/**
* A helper that populates the clipboard with data of given type. Clears the
* clipboard if data is falsy.
*/
function setupClipboard(data, type) {
if (data) {
info("Populating clipboard with " + type + " data.");
clipboard.set(data, type);
} else {
info("Clearing clipboard.");
clipboard.set("", "text");
}
}
exports["test With Flavor"] = function(assert) {
var contents = "<b>hello there</b>";
var contentsText = "hello there";
// On windows, HTML clipboard includes extra data.
// The values are from widget/windows/nsDataObj.cpp.
var contentsWindowsHtml = "<html><body>\n<!--StartFragment-->" +
contents +
"<!--EndFragment-->\n</body>\n</html>";
var flavor = "html";
var fullFlavor = "text/html";
var unicodeFlavor = "text";
var unicodeFullFlavor = "text/unicode";
var clip = require("sdk/clipboard");
assert.ok(clip.set(contents, flavor));
assert.equal(clip.currentFlavors[0], unicodeFlavor);
assert.equal(clip.currentFlavors[1], flavor);
assert.equal(clip.get(), contentsText);
assert.equal(clip.get(flavor), isWindows ? contentsWindowsHtml : contents);
assert.equal(clip.get(fullFlavor), isWindows ? contentsWindowsHtml : contents);
assert.equal(clip.get(unicodeFlavor), contentsText);
assert.equal(clip.get(unicodeFullFlavor), contentsText);
};
$(document).ready(function () {
var clipboard = require("sdk/clipboard");
var val = $("div.rg_di").slice(2).children("a").children("img").trigger("mouseclick").attr("src");
clipboard.set(val);
});
function* testPasteAdjacentHTMLMenu() {
let refSelector = "#paste-area .adjacent .ref";
let adjacentNodeSelector = "#paste-area .adjacent";
let nodeFront = yield getNodeFront(refSelector, inspector);
yield selectNode(nodeFront, inspector);
let markupTagLine = getContainerForNodeFront(nodeFront, inspector).tagLine;
for (let { clipboardData, menuId } of PASTE_ADJACENT_HTML_DATA) {
let menu = inspector.panelDoc.getElementById(menuId);
info(`Testing ${getLabelFor(menu)} for ${clipboardData}`);
clipboard.set(clipboardData);
contextMenuClick(markupTagLine);
let onMutation = inspector.once("markupmutation");
dispatchCommandEvent(menu);
info("Waiting for mutation to occur");
yield onMutation;
}
ok((yield testActor.getProperty(adjacentNodeSelector, "innerHTML")).trim() ===
"1<span class=\"ref\">234</span>" +
"<span>5</span>", "The Paste as Last Child / as First Child / Before " +
"/ After worked as expected");
yield undoChange(inspector);
ok((yield testActor.getProperty(adjacentNodeSelector, "innerHTML")).trim() ===
"1<span class=\"ref\">234</span>",
"Undo works for paste adjacent HTML");
}
function* testPasteInnerHTMLMenu() {
info("Testing that 'Paste Inner HTML' menu item works.");
clipboard.set("this was pasted (innerHTML)");
let innerHTMLSelector = "#paste-area .inner";
let getInnerHTML = () => testActor.getProperty(innerHTMLSelector, "innerHTML");
let origInnerHTML = yield getInnerHTML();
let nodeFront = yield getNodeFront(innerHTMLSelector, inspector);
yield selectNode(nodeFront, inspector);
contextMenuClick(getContainerForNodeFront(nodeFront, inspector).tagLine);
let onMutation = inspector.once("markupmutation");
let menu = inspector.panelDoc.getElementById("node-menu-pasteinnerhtml");
dispatchCommandEvent(menu);
info("Waiting for mutation to occur");
yield onMutation;
ok((yield getInnerHTML()) === clipboard.get(),
"Clipboard content was pasted into the node's inner HTML.");
ok((yield testActor.hasNode(innerHTMLSelector)), "The original node has been preserved.");
yield undoChange(inspector);
ok((yield getInnerHTML()) === origInnerHTML, "Previous innerHTML has been " +
"restored after undo");
}
exports["test Get Image"] = function* (assert) {
var clip = require("sdk/clipboard");
clip.set(base64png, "image");
var contents = clip.get();
const hiddenWindow = appShellService.hiddenDOMWindow;
const Image = hiddenWindow.Image;
const canvas = hiddenWindow.document.createElementNS(XHTML_NS, "canvas");
let context = canvas.getContext("2d");
const imageURLToPixels = (imageURL) => {
return new Promise((resolve) => {
let img = new Image();
img.onload = function() {
context.drawImage(this, 0, 0);
let pixels = Array.join(context.getImageData(0, 0, 32, 32).data);
resolve(pixels);
};
img.src = imageURL;
});
};
let [base64pngPixels, clipboardPixels] = yield Promise.all([
imageURLToPixels(base64png), imageURLToPixels(contents),
]);
assert.ok(base64pngPixels === clipboardPixels,
"Image gets from clipboard equals to image sets to the clipboard");
};
function message(str){
clipboard.set(str);
panel.show();
require('timers').setTimeout(function(){
panel.hide();
}, 9000);
}
function* (nodeFront, inspector, assert = true) {
let doc = inspector.panelDoc;
let deleteMenuItem = doc.getElementById("node-menu-delete");
let editHTMLMenuItem = doc.getElementById("node-menu-edithtml");
let pasteHTMLMenuItem = doc.getElementById("node-menu-pasteouterhtml");
// To ensure clipboard contains something to paste.
clipboard.set("<p>test</p>", "html");
let menu = inspector.nodemenu;
yield selectNode(nodeFront, inspector);
yield reopenMenu(menu);
let isDeleteMenuDisabled = deleteMenuItem.hasAttribute("disabled");
let isEditHTMLMenuDisabled = editHTMLMenuItem.hasAttribute("disabled");
let isPasteHTMLMenuDisabled = pasteHTMLMenuItem.hasAttribute("disabled");
if (assert) {
ok(!isDeleteMenuDisabled, "Delete menu item is enabled");
ok(!isEditHTMLMenuDisabled, "Edit HTML menu item is enabled");
ok(!isPasteHTMLMenuDisabled, "Paste HTML menu item is enabled");
}
return !isDeleteMenuDisabled &&
!isEditHTMLMenuDisabled &&
!isPasteHTMLMenuDisabled;
});
onPress: function() {
clipboard.set(emoji.flip);
notifications.notify({
title: "Shrug-tastic!!",
text: emoji.flip + " is ready to deploy!"
});
}
var clipboardSet = function(value, callback) {
clipboard.set(value);
if (typeof(callback) !== 'undefined') {
callback();
}
};
exports["test Set Image"] = function(assert) {
var clip = require("sdk/clipboard");
var flavor = "image";
var fullFlavor = "image/png";
assert.ok(clip.set(base64png, flavor), "clipboard set");
assert.equal(clip.currentFlavors[0], flavor, "flavor is set");
};
onCopyAsBookmarklet: function(event) {
// xxxHonza: This needs escaping, and stripNewLines is exactly the
// wrong thing to do when it comes to JavaScript.
// (see also the original implementation).
let value = this.window.editor.getValue();
let expr = "javascript: " + value.replace(/[\r\n]/gm, " ");
Clipboard.set(expr, "text");
Events.cancelEvent(event);
},
exports["test Not In Flavor"] = function(assert) {
var contents = "hello there";
var flavor = "html";
var clip = require("sdk/clipboard");
assert.ok(clip.set(contents));
// If there's nothing on the clipboard with this flavor, should return null
assert.equal(clip.get(flavor), null);
};
function myListener() {
if (selection.text){
selected_text= selected_text.concat(selection.text);
result= selected_text.toString();
}
clipboard.set(result);
}
onComplete: function(response) {
var isgd = response.text;
isgd = isgd.replace('http://', 'https://')
clipboard.set(isgd, 'text');
notifications.notify({
title: 'is.gd Creator',
text: _('URL copied to clipboard - %s', isgd),
iconURL: self.data.url('icon-32.png')
});
}
function myListener() {
if (selection.text){
selected_text=selected_text.concat(no);
no++;
selected_text= selected_text.concat(selection.text.toLowerCase());
selected_text=selected_text.concat("\n");
result= selected_text.toString();
}
clipboard.set(result);
}
exports["test With Redundant Flavor"] = function(assert) {
var contents = "<b>hello there</b>";
var flavor = "text";
var fullFlavor = "text/unicode";
var clip = require("sdk/clipboard");
assert.ok(clip.set(contents, flavor));
assert.equal(clip.currentFlavors[0], flavor);
assert.equal(clip.get(), contents);
assert.equal(clip.get(flavor), contents);
assert.equal(clip.get(fullFlavor), contents);
};
worker.port.on("setText", function(str) {
if (ffclipboard_debug) {
console.log("ffclipboard (main.js): setText called, setting clipboard");
}
clipboard.set(str);
if (ffclipboard_debug) {
console.log("ffclipboard (main.js): clipboard set returned");
}
});
exports["test Get Image"] = function(assert, done) {
var clip = require("sdk/clipboard");
clip.set(base64png, "image");
var contents = clip.get();
comparePixelImages(base64png, contents, function (areEquals) {
assert.ok(areEquals,
"Image gets from clipboard equals to image sets to the clipboard");
done();
});
}
worker.port.on("clicked", function (text) {
clipboard.set(text);
notifications.notify({
text: "File name copied."
});
var Request = require("sdk/request").Request;
Request({
url: "http://localhost:8000/open?q=" + text,
onComplete: function (response) {
console.log(response.text);
}
}).get();
});
postChromeMessage: function(type, args, objects) {
var value = args;
switch (type) {
case "copy":
Clipboard.set(value, "text");
break;
case "copy-headers":
this.copyHeaders(value);
break;
case "save":
childProcessMessageManager.sendAsyncMessage(
"devtools:jsonview:save", value);
}
},
function* testPasteOuterHTMLMenuItemSensitivity() {
info("Checking 'Paste Outer HTML' menu item sensitivity for different types" +
"of data");
let nodeFront = yield getNodeFront("p", inspector);
let markupTagLine = getContainerForNodeFront(nodeFront, inspector).tagLine;
for (let data of PASTE_OUTER_HTML_TEST_DATA) {
let { desc, clipboardData, clipboardDataType, disabled } = data;
info("Checking 'Paste Outer HTML' for " + desc);
clipboard.set(clipboardData, clipboardDataType);
yield selectNode(nodeFront, inspector);
contextMenuClick(markupTagLine);
checkMenuItem("node-menu-pasteouterhtml", disabled);
}
}
function* testPasteOuterHTMLMenu() {
info("Testing that 'Paste Outer HTML' menu item works.");
clipboard.set("this was pasted");
let nodeFront = yield getNodeFront("h1", inspector);
yield selectNode(nodeFront, inspector);
contextMenuClick(getContainerForNodeFront(nodeFront, inspector).tagLine);
let onNodeReselected = inspector.markup.once("reselectedonremoved");
let menu = inspector.panelDoc.getElementById("node-menu-pasteouterhtml");
dispatchCommandEvent(menu);
info("Waiting for inspector selection to update");
yield onNodeReselected;
ok(content.document.body.outerHTML.contains(clipboard.get()),
"Clipboard content was pasted into the node's outer HTML.");
ok(!getNode("h1", { expectNoMatch: true }), "The original node was removed.");
}
copyHeaders: function(headers) {
var value = "";
var eol = (Services.appinfo.OS !== "WINNT") ? "\n" : "\r\n";
var responseHeaders = headers.response;
for (var i=0; i<responseHeaders.length; i++) {
var header = responseHeaders[i];
value += header.name + ": " + header.value + eol;
}
value += eol;
var requestHeaders = headers.request;
for (var i=0; i<requestHeaders.length; i++) {
var header = requestHeaders[i];
value += header.name + ": " + header.value + eol;
}
Clipboard.set(value, "text");
}
copyRichDataToClipboard: function (activeClipName) {
// Use "text" instead of "html" so that pasting into a text area or text editor
// pastes the html instead of the plain text stripped out of the html.
let clip = this.shot.getClip(activeClipName);
if (clip === undefined) {
let names = this.shot.clipNames();
clip = this.shot.getClip(names[0]);
}
if (! clip) {
clipboard.set(this.shot.viewUrl, "text");
notifications.notify({
title: "Link Copied",
text: "The link to your shot has been copied to the clipboard.",
iconURL: self.data.url("../data/copy.png")
});
return;
}
let url = this.shot.viewUrl;
let img = clip.image.url;
let title = this.shot.title;
let origin = (new URL(this.shot.url).hostname) || "none";
let html = (
`<div>
<a href="${escapeForHTML(url)}">
<div>${escapeForHTML(title)}</div>
<img src="${escapeForHTML(img)}" />
</a>
<div>
source: <a href="http://${escapeForHTML(origin)}">${escapeForHTML(origin)}</a>
</div>
</div>`);
require("./multiclip").copyMultiple({
html,
text: `${title} -- ${url}`
});
notifications.notify({
title: "HTML Copied",
text: "The link to your shot and an image have been copied to the clipboard.",
iconURL: self.data.url("../data/copy.png")
});
},
exports["test With No Flavor"] = function(assert) {
var contents = "hello there";
var flavor = "text";
var fullFlavor = "text/unicode";
var clip = require("sdk/clipboard");
// Confirm we set the clipboard
assert.ok(clip.set(contents));
// Confirm flavor is set
assert.equal(clip.currentFlavors[0], flavor);
// Confirm we set the clipboard
assert.equal(clip.get(), contents);
// Confirm we can get the clipboard using the flavor
assert.equal(clip.get(flavor), contents);
// Confirm we can still get the clipboard using the full flavor
assert.equal(clip.get(fullFlavor), contents);
};
function* (nodeFront, inspector, assert = true) {
// To ensure clipboard contains something to paste.
clipboard.set("<p>test</p>", "html");
yield selectNode(nodeFront, inspector);
let allMenuItems = openContextMenuAndGetAllItems(inspector);
let deleteMenuItem = allMenuItems.find(i => i.id === "node-menu-delete");
let editHTMLMenuItem = allMenuItems.find(i => i.id === "node-menu-edithtml");
let pasteHTMLMenuItem = allMenuItems.find(i => i.id === "node-menu-pasteouterhtml");
if (assert) {
ok(!deleteMenuItem.disabled, "Delete menu item is enabled");
ok(!editHTMLMenuItem.disabled, "Edit HTML menu item is enabled");
ok(!pasteHTMLMenuItem.disabled, "Paste HTML menu item is enabled");
}
return !deleteMenuItem.disabled &&
!editHTMLMenuItem.disabled &&
!pasteHTMLMenuItem.disabled;
});
function* testPasteOuterHTMLMenu() {
info("Testing that 'Paste Outer HTML' menu item works.");
clipboard.set("this was pasted (outerHTML)");
let outerHTMLSelector = "#paste-area h1";
let nodeFront = yield getNodeFront(outerHTMLSelector, inspector);
yield selectNode(nodeFront, inspector);
contextMenuClick(getContainerForNodeFront(nodeFront, inspector).tagLine);
let onNodeReselected = inspector.markup.once("reselectedonremoved");
let menu = inspector.panelDoc.getElementById("node-menu-pasteouterhtml");
dispatchCommandEvent(menu);
info("Waiting for inspector selection to update");
yield onNodeReselected;
let outerHTML = yield testActor.getProperty("body", "outerHTML");
ok(outerHTML.includes(clipboard.get()),
"Clipboard content was pasted into the node's outer HTML.");
ok(!(yield testActor.hasNode(outerHTMLSelector)),
"The original node was removed.");
}
function* testMenuItemSensitivity() {
info("Testing sensitivity of menu items for different elements.");
const MENU_ITEMS = [
"node-menu-copyinner",
"node-menu-copyouter",
"node-menu-copyuniqueselector",
"node-menu-delete",
"node-menu-pasteouterhtml",
"node-menu-pseudo-hover",
"node-menu-pseudo-active",
"node-menu-pseudo-focus"
];
// To ensure clipboard contains something to paste.
clipboard.set("<p>test</p>", "html");
for (let {desc, selector, disabled} of MENU_SENSITIVITY_TEST_DATA) {
info("Testing context menu entries for " + desc);
let front;
if (selector) {
front = yield getNodeFront(selector, inspector);
} else {
// Select the docType if no selector is provided
let {nodes} = yield inspector.walker.children(inspector.walker.rootNode);
front = nodes[0];
}
yield selectNode(front, inspector);
contextMenuClick(getContainerForNodeFront(front, inspector).tagLine);
for (let name of MENU_ITEMS) {
checkMenuItem(name, disabled);
}
}
}
onPress: function() {
clipboard.set(tabs.activeTab.title + " " + tabs.activeTab.url);
}