2484 lines
71 KiB
JavaScript
2484 lines
71 KiB
JavaScript
/* vim:set ts=2 sw=2 sts=2 et:
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
/*
|
|
* Original version history can be found here:
|
|
* https://github.com/mozilla/workspace
|
|
*
|
|
* Copied and relicensed from the Public Domain.
|
|
* See bug 653934 for details.
|
|
* https://bugzilla.mozilla.org/show_bug.cgi?id=653934
|
|
*/
|
|
|
|
"use strict";
|
|
|
|
var Cu = Components.utils;
|
|
var Cc = Components.classes;
|
|
var Ci = Components.interfaces;
|
|
|
|
const SCRATCHPAD_CONTEXT_CONTENT = 1;
|
|
const SCRATCHPAD_CONTEXT_BROWSER = 2;
|
|
const BUTTON_POSITION_SAVE = 0;
|
|
const BUTTON_POSITION_CANCEL = 1;
|
|
const BUTTON_POSITION_DONT_SAVE = 2;
|
|
const BUTTON_POSITION_REVERT = 0;
|
|
const EVAL_FUNCTION_TIMEOUT = 1000; // milliseconds
|
|
|
|
const MAXIMUM_FONT_SIZE = 96;
|
|
const MINIMUM_FONT_SIZE = 6;
|
|
const NORMAL_FONT_SIZE = 12;
|
|
|
|
const SCRATCHPAD_L10N = "chrome://devtools/locale/scratchpad.properties";
|
|
const DEVTOOLS_CHROME_ENABLED = "devtools.chrome.enabled";
|
|
const PREF_RECENT_FILES_MAX = "devtools.scratchpad.recentFilesMax";
|
|
const SHOW_LINE_NUMBERS = "devtools.scratchpad.lineNumbers";
|
|
const WRAP_TEXT = "devtools.scratchpad.wrapText";
|
|
const SHOW_TRAILING_SPACE = "devtools.scratchpad.showTrailingSpace";
|
|
const EDITOR_FONT_SIZE = "devtools.scratchpad.editorFontSize";
|
|
const ENABLE_AUTOCOMPLETION = "devtools.scratchpad.enableAutocompletion";
|
|
const TAB_SIZE = "devtools.editor.tabsize";
|
|
const FALLBACK_CHARSET_LIST = "intl.fallbackCharsetList.ISO-8859-1";
|
|
|
|
const VARIABLES_VIEW_URL = "chrome://devtools/content/shared/widgets/VariablesView.xul";
|
|
|
|
const {require, loader} = Cu.import("resource://devtools/shared/Loader.jsm", {});
|
|
|
|
const Editor = require("devtools/client/sourceeditor/editor");
|
|
const TargetFactory = require("devtools/client/framework/target").TargetFactory;
|
|
const EventEmitter = require("devtools/shared/event-emitter");
|
|
const {DevToolsWorker} = require("devtools/shared/worker/worker");
|
|
const DevToolsUtils = require("devtools/shared/DevToolsUtils");
|
|
const flags = require("devtools/shared/flags");
|
|
const promise = require("promise");
|
|
const Services = require("Services");
|
|
const {gDevTools} = require("devtools/client/framework/devtools");
|
|
const {Heritage} = require("devtools/client/shared/widgets/view-helpers");
|
|
|
|
const {XPCOMUtils} = require("resource://gre/modules/XPCOMUtils.jsm");
|
|
const {NetUtil} = require("resource://gre/modules/NetUtil.jsm");
|
|
const {ScratchpadManager} = require("resource://devtools/client/scratchpad/scratchpad-manager.jsm");
|
|
const {addDebuggerToGlobal} = require("resource://gre/modules/jsdebugger.jsm");
|
|
const {OS} = require("resource://gre/modules/osfile.jsm");
|
|
const {Reflect} = require("resource://gre/modules/reflect.jsm");
|
|
|
|
XPCOMUtils.defineConstant(this, "SCRATCHPAD_CONTEXT_CONTENT", SCRATCHPAD_CONTEXT_CONTENT);
|
|
XPCOMUtils.defineConstant(this, "SCRATCHPAD_CONTEXT_BROWSER", SCRATCHPAD_CONTEXT_BROWSER);
|
|
XPCOMUtils.defineConstant(this, "BUTTON_POSITION_SAVE", BUTTON_POSITION_SAVE);
|
|
XPCOMUtils.defineConstant(this, "BUTTON_POSITION_CANCEL", BUTTON_POSITION_CANCEL);
|
|
XPCOMUtils.defineConstant(this, "BUTTON_POSITION_DONT_SAVE", BUTTON_POSITION_DONT_SAVE);
|
|
XPCOMUtils.defineConstant(this, "BUTTON_POSITION_REVERT", BUTTON_POSITION_REVERT);
|
|
|
|
XPCOMUtils.defineLazyModuleGetter(this, "VariablesView",
|
|
"resource://devtools/client/shared/widgets/VariablesView.jsm");
|
|
|
|
XPCOMUtils.defineLazyModuleGetter(this, "VariablesViewController",
|
|
"resource://devtools/client/shared/widgets/VariablesViewController.jsm");
|
|
|
|
loader.lazyRequireGetter(this, "DebuggerServer", "devtools/server/main", true);
|
|
|
|
loader.lazyRequireGetter(this, "DebuggerClient", "devtools/shared/client/main", true);
|
|
loader.lazyRequireGetter(this, "EnvironmentClient", "devtools/shared/client/main", true);
|
|
loader.lazyRequireGetter(this, "ObjectClient", "devtools/shared/client/main", true);
|
|
loader.lazyRequireGetter(this, "HUDService", "devtools/client/webconsole/hudservice", true);
|
|
|
|
XPCOMUtils.defineLazyGetter(this, "REMOTE_TIMEOUT", () =>
|
|
Services.prefs.getIntPref("devtools.debugger.remote-timeout"));
|
|
|
|
XPCOMUtils.defineLazyModuleGetter(this, "ShortcutUtils",
|
|
"resource://gre/modules/ShortcutUtils.jsm");
|
|
|
|
XPCOMUtils.defineLazyModuleGetter(this, "Reflect",
|
|
"resource://gre/modules/reflect.jsm");
|
|
|
|
var WebConsoleUtils = require("devtools/client/webconsole/utils").Utils;
|
|
|
|
/**
|
|
* The scratchpad object handles the Scratchpad window functionality.
|
|
*/
|
|
var Scratchpad = {
|
|
_instanceId: null,
|
|
_initialWindowTitle: document.title,
|
|
_dirty: false,
|
|
|
|
/**
|
|
* Check if provided string is a mode-line and, if it is, return an
|
|
* object with its values.
|
|
*
|
|
* @param string aLine
|
|
* @return string
|
|
*/
|
|
_scanModeLine: function SP__scanModeLine(aLine = "")
|
|
{
|
|
aLine = aLine.trim();
|
|
|
|
let obj = {};
|
|
let ch1 = aLine.charAt(0);
|
|
let ch2 = aLine.charAt(1);
|
|
|
|
if (ch1 !== "/" || (ch2 !== "*" && ch2 !== "/")) {
|
|
return obj;
|
|
}
|
|
|
|
aLine = aLine
|
|
.replace(/^\/\//, "")
|
|
.replace(/^\/\*/, "")
|
|
.replace(/\*\/$/, "");
|
|
|
|
aLine.split(",").forEach(pair => {
|
|
let [key, val] = pair.split(":");
|
|
|
|
if (key && val) {
|
|
obj[key.trim()] = val.trim();
|
|
}
|
|
});
|
|
|
|
return obj;
|
|
},
|
|
|
|
/**
|
|
* Add the event listeners for popupshowing events.
|
|
*/
|
|
_setupPopupShowingListeners: function SP_setupPopupShowing() {
|
|
let elementIDs = ["sp-menu_editpopup", "scratchpad-text-popup"];
|
|
|
|
for (let elementID of elementIDs) {
|
|
let elem = document.getElementById(elementID);
|
|
if (elem) {
|
|
elem.addEventListener("popupshowing", function () {
|
|
goUpdateGlobalEditMenuItems();
|
|
let commands = ["cmd_undo", "cmd_redo", "cmd_delete", "cmd_findAgain"];
|
|
commands.forEach(goUpdateCommand);
|
|
});
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Add the event event listeners for command events.
|
|
*/
|
|
_setupCommandListeners: function SP_setupCommands() {
|
|
let commands = {
|
|
"cmd_find": () => {
|
|
goDoCommand("cmd_find");
|
|
},
|
|
"cmd_findAgain": () => {
|
|
goDoCommand("cmd_findAgain");
|
|
},
|
|
"cmd_gotoLine": () => {
|
|
goDoCommand("cmd_gotoLine");
|
|
},
|
|
"sp-cmd-newWindow": () => {
|
|
Scratchpad.openScratchpad();
|
|
},
|
|
"sp-cmd-openFile": () => {
|
|
Scratchpad.openFile();
|
|
},
|
|
"sp-cmd-clearRecentFiles": () => {
|
|
Scratchpad.clearRecentFiles();
|
|
},
|
|
"sp-cmd-save": () => {
|
|
Scratchpad.saveFile();
|
|
},
|
|
"sp-cmd-saveas": () => {
|
|
Scratchpad.saveFileAs();
|
|
},
|
|
"sp-cmd-revert": () => {
|
|
Scratchpad.promptRevert();
|
|
},
|
|
"sp-cmd-close": () => {
|
|
Scratchpad.close();
|
|
},
|
|
"sp-cmd-run": () => {
|
|
Scratchpad.run();
|
|
},
|
|
"sp-cmd-inspect": () => {
|
|
Scratchpad.inspect();
|
|
},
|
|
"sp-cmd-display": () => {
|
|
Scratchpad.display();
|
|
},
|
|
"sp-cmd-pprint": () => {
|
|
Scratchpad.prettyPrint();
|
|
},
|
|
"sp-cmd-contentContext": () => {
|
|
Scratchpad.setContentContext();
|
|
},
|
|
"sp-cmd-browserContext": () => {
|
|
Scratchpad.setBrowserContext();
|
|
},
|
|
"sp-cmd-reloadAndRun": () => {
|
|
Scratchpad.reloadAndRun();
|
|
},
|
|
"sp-cmd-evalFunction": () => {
|
|
Scratchpad.evalTopLevelFunction();
|
|
},
|
|
"sp-cmd-errorConsole": () => {
|
|
Scratchpad.openErrorConsole();
|
|
},
|
|
"sp-cmd-webConsole": () => {
|
|
Scratchpad.openWebConsole();
|
|
},
|
|
"sp-cmd-documentationLink": () => {
|
|
Scratchpad.openDocumentationPage();
|
|
},
|
|
"sp-cmd-hideSidebar": () => {
|
|
Scratchpad.sidebar.hide();
|
|
},
|
|
"sp-cmd-line-numbers": () => {
|
|
Scratchpad.toggleEditorOption("lineNumbers", SHOW_LINE_NUMBERS);
|
|
},
|
|
"sp-cmd-wrap-text": () => {
|
|
Scratchpad.toggleEditorOption("lineWrapping", WRAP_TEXT);
|
|
},
|
|
"sp-cmd-highlight-trailing-space": () => {
|
|
Scratchpad.toggleEditorOption("showTrailingSpace", SHOW_TRAILING_SPACE);
|
|
},
|
|
"sp-cmd-larger-font": () => {
|
|
Scratchpad.increaseFontSize();
|
|
},
|
|
"sp-cmd-smaller-font": () => {
|
|
Scratchpad.decreaseFontSize();
|
|
},
|
|
"sp-cmd-normal-font": () => {
|
|
Scratchpad.normalFontSize();
|
|
},
|
|
};
|
|
|
|
for (let command in commands) {
|
|
let elem = document.getElementById(command);
|
|
if (elem) {
|
|
elem.addEventListener("command", commands[command]);
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Check or uncheck view menu items according to stored preferences.
|
|
*/
|
|
_updateViewMenuItems: function SP_updateViewMenuItems() {
|
|
this._updateViewMenuItem(SHOW_LINE_NUMBERS, "sp-menu-line-numbers");
|
|
this._updateViewMenuItem(WRAP_TEXT, "sp-menu-word-wrap");
|
|
this._updateViewMenuItem(SHOW_TRAILING_SPACE, "sp-menu-highlight-trailing-space");
|
|
this._updateViewFontMenuItem(MINIMUM_FONT_SIZE, "sp-cmd-smaller-font");
|
|
this._updateViewFontMenuItem(MAXIMUM_FONT_SIZE, "sp-cmd-larger-font");
|
|
},
|
|
|
|
/**
|
|
* Check or uncheck view menu item according to stored preferences.
|
|
*/
|
|
_updateViewMenuItem: function SP_updateViewMenuItem(preferenceName, menuId) {
|
|
let checked = Services.prefs.getBoolPref(preferenceName);
|
|
if (checked) {
|
|
document.getElementById(menuId).setAttribute("checked", true);
|
|
} else {
|
|
document.getElementById(menuId).removeAttribute("checked");
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Disable view menu item if the stored font size is equals to the given one.
|
|
*/
|
|
_updateViewFontMenuItem: function SP_updateViewFontMenuItem(fontSize, commandId) {
|
|
let prefFontSize = Services.prefs.getIntPref(EDITOR_FONT_SIZE);
|
|
if (prefFontSize === fontSize) {
|
|
document.getElementById(commandId).setAttribute("disabled", true);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* The script execution context. This tells Scratchpad in which context the
|
|
* script shall execute.
|
|
*
|
|
* Possible values:
|
|
* - SCRATCHPAD_CONTEXT_CONTENT to execute code in the context of the current
|
|
* tab content window object.
|
|
* - SCRATCHPAD_CONTEXT_BROWSER to execute code in the context of the
|
|
* currently active chrome window object.
|
|
*/
|
|
executionContext: SCRATCHPAD_CONTEXT_CONTENT,
|
|
|
|
/**
|
|
* Tells if this Scratchpad is initialized and ready for use.
|
|
* @boolean
|
|
* @see addObserver
|
|
*/
|
|
initialized: false,
|
|
|
|
/**
|
|
* Returns the 'dirty' state of this Scratchpad.
|
|
*/
|
|
get dirty()
|
|
{
|
|
let clean = this.editor && this.editor.isClean();
|
|
return this._dirty || !clean;
|
|
},
|
|
|
|
/**
|
|
* Sets the 'dirty' state of this Scratchpad.
|
|
*/
|
|
set dirty(aValue)
|
|
{
|
|
this._dirty = aValue;
|
|
if (!aValue && this.editor)
|
|
this.editor.setClean();
|
|
this._updateTitle();
|
|
},
|
|
|
|
/**
|
|
* Retrieve the xul:notificationbox DOM element. It notifies the user when
|
|
* the current code execution context is SCRATCHPAD_CONTEXT_BROWSER.
|
|
*/
|
|
get notificationBox()
|
|
{
|
|
return document.getElementById("scratchpad-notificationbox");
|
|
},
|
|
|
|
/**
|
|
* Hide the menu bar.
|
|
*/
|
|
hideMenu: function SP_hideMenu()
|
|
{
|
|
document.getElementById("sp-menubar").style.display = "none";
|
|
},
|
|
|
|
/**
|
|
* Show the menu bar.
|
|
*/
|
|
showMenu: function SP_showMenu()
|
|
{
|
|
document.getElementById("sp-menubar").style.display = "";
|
|
},
|
|
|
|
/**
|
|
* Get the editor content, in the given range. If no range is given you get
|
|
* the entire editor content.
|
|
*
|
|
* @param number [aStart=0]
|
|
* Optional, start from the given offset.
|
|
* @param number [aEnd=content char count]
|
|
* Optional, end offset for the text you want. If this parameter is not
|
|
* given, then the text returned goes until the end of the editor
|
|
* content.
|
|
* @return string
|
|
* The text in the given range.
|
|
*/
|
|
getText: function SP_getText(aStart, aEnd)
|
|
{
|
|
var value = this.editor.getText();
|
|
return value.slice(aStart || 0, aEnd || value.length);
|
|
},
|
|
|
|
/**
|
|
* Set the filename in the scratchpad UI and object
|
|
*
|
|
* @param string aFilename
|
|
* The new filename
|
|
*/
|
|
setFilename: function SP_setFilename(aFilename)
|
|
{
|
|
this.filename = aFilename;
|
|
this._updateTitle();
|
|
},
|
|
|
|
/**
|
|
* Update the Scratchpad window title based on the current state.
|
|
* @private
|
|
*/
|
|
_updateTitle: function SP__updateTitle()
|
|
{
|
|
let title = this.filename || this._initialWindowTitle;
|
|
|
|
if (this.dirty)
|
|
title = "*" + title;
|
|
|
|
document.title = title;
|
|
},
|
|
|
|
/**
|
|
* Get the current state of the scratchpad. Called by the
|
|
* Scratchpad Manager for session storing.
|
|
*
|
|
* @return object
|
|
* An object with 3 properties: filename, text, and
|
|
* executionContext.
|
|
*/
|
|
getState: function SP_getState()
|
|
{
|
|
return {
|
|
filename: this.filename,
|
|
text: this.getText(),
|
|
executionContext: this.executionContext,
|
|
saved: !this.dirty
|
|
};
|
|
},
|
|
|
|
/**
|
|
* Set the filename and execution context using the given state. Called
|
|
* when scratchpad is being restored from a previous session.
|
|
*
|
|
* @param object aState
|
|
* An object with filename and executionContext properties.
|
|
*/
|
|
setState: function SP_setState(aState)
|
|
{
|
|
if (aState.filename)
|
|
this.setFilename(aState.filename);
|
|
|
|
this.dirty = !aState.saved;
|
|
|
|
if (aState.executionContext == SCRATCHPAD_CONTEXT_BROWSER)
|
|
this.setBrowserContext();
|
|
else
|
|
this.setContentContext();
|
|
},
|
|
|
|
/**
|
|
* Get the most recent main chrome browser window
|
|
*/
|
|
get browserWindow()
|
|
{
|
|
return Services.wm.getMostRecentWindow(gDevTools.chromeWindowType);
|
|
},
|
|
|
|
/**
|
|
* Get the gBrowser object of the most recent browser window.
|
|
*/
|
|
get gBrowser()
|
|
{
|
|
let recentWin = this.browserWindow;
|
|
return recentWin ? recentWin.gBrowser : null;
|
|
},
|
|
|
|
/**
|
|
* Unique name for the current Scratchpad instance. Used to distinguish
|
|
* Scratchpad windows between each other. See bug 661762.
|
|
*/
|
|
get uniqueName()
|
|
{
|
|
return "Scratchpad/" + this._instanceId;
|
|
},
|
|
|
|
|
|
/**
|
|
* Sidebar that contains the VariablesView for object inspection.
|
|
*/
|
|
get sidebar()
|
|
{
|
|
if (!this._sidebar) {
|
|
this._sidebar = new ScratchpadSidebar(this);
|
|
}
|
|
return this._sidebar;
|
|
},
|
|
|
|
/**
|
|
* Replaces context of an editor with provided value (a string).
|
|
* Note: this method is simply a shortcut to editor.setText.
|
|
*/
|
|
setText: function SP_setText(value)
|
|
{
|
|
return this.editor.setText(value);
|
|
},
|
|
|
|
/**
|
|
* Evaluate a string in the currently desired context, that is either the
|
|
* chrome window or the tab content window object.
|
|
*
|
|
* @param string aString
|
|
* The script you want to evaluate.
|
|
* @return Promise
|
|
* The promise for the script evaluation result.
|
|
*/
|
|
evaluate: function SP_evaluate(aString)
|
|
{
|
|
let connection;
|
|
if (this.target) {
|
|
connection = ScratchpadTarget.consoleFor(this.target);
|
|
}
|
|
else if (this.executionContext == SCRATCHPAD_CONTEXT_CONTENT) {
|
|
connection = ScratchpadTab.consoleFor(this.gBrowser.selectedTab);
|
|
}
|
|
else {
|
|
connection = ScratchpadWindow.consoleFor(this.browserWindow);
|
|
}
|
|
|
|
let evalOptions = { url: this.uniqueName };
|
|
|
|
return connection.then(({ debuggerClient, webConsoleClient }) => {
|
|
let deferred = promise.defer();
|
|
|
|
webConsoleClient.evaluateJSAsync(aString, aResponse => {
|
|
this.debuggerClient = debuggerClient;
|
|
this.webConsoleClient = webConsoleClient;
|
|
if (aResponse.error) {
|
|
deferred.reject(aResponse);
|
|
}
|
|
else if (aResponse.exception !== null) {
|
|
deferred.resolve([aString, aResponse]);
|
|
}
|
|
else {
|
|
deferred.resolve([aString, undefined, aResponse.result]);
|
|
}
|
|
}, evalOptions);
|
|
|
|
return deferred.promise;
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Execute the selected text (if any) or the entire editor content in the
|
|
* current context.
|
|
*
|
|
* @return Promise
|
|
* The promise for the script evaluation result.
|
|
*/
|
|
execute: function SP_execute()
|
|
{
|
|
WebConsoleUtils.usageCount++;
|
|
let selection = this.editor.getSelection() || this.getText();
|
|
return this.evaluate(selection);
|
|
},
|
|
|
|
/**
|
|
* Execute the selected text (if any) or the entire editor content in the
|
|
* current context.
|
|
*
|
|
* @return Promise
|
|
* The promise for the script evaluation result.
|
|
*/
|
|
run: function SP_run()
|
|
{
|
|
let deferred = promise.defer();
|
|
let reject = aReason => deferred.reject(aReason);
|
|
|
|
this.execute().then(([aString, aError, aResult]) => {
|
|
let resolve = () => deferred.resolve([aString, aError, aResult]);
|
|
|
|
if (aError) {
|
|
this.writeAsErrorComment(aError).then(resolve, reject);
|
|
}
|
|
else {
|
|
this.editor.dropSelection();
|
|
resolve();
|
|
}
|
|
}, reject);
|
|
|
|
return deferred.promise;
|
|
},
|
|
|
|
/**
|
|
* Execute the selected text (if any) or the entire editor content in the
|
|
* current context. The resulting object is inspected up in the sidebar.
|
|
*
|
|
* @return Promise
|
|
* The promise for the script evaluation result.
|
|
*/
|
|
inspect: function SP_inspect()
|
|
{
|
|
let deferred = promise.defer();
|
|
let reject = aReason => deferred.reject(aReason);
|
|
|
|
this.execute().then(([aString, aError, aResult]) => {
|
|
let resolve = () => deferred.resolve([aString, aError, aResult]);
|
|
|
|
if (aError) {
|
|
this.writeAsErrorComment(aError).then(resolve, reject);
|
|
}
|
|
else {
|
|
this.editor.dropSelection();
|
|
this.sidebar.open(aString, aResult).then(resolve, reject);
|
|
}
|
|
}, reject);
|
|
|
|
return deferred.promise;
|
|
},
|
|
|
|
/**
|
|
* Reload the current page and execute the entire editor content when
|
|
* the page finishes loading. Note that this operation should be available
|
|
* only in the content context.
|
|
*
|
|
* @return Promise
|
|
* The promise for the script evaluation result.
|
|
*/
|
|
reloadAndRun: function SP_reloadAndRun()
|
|
{
|
|
let deferred = promise.defer();
|
|
|
|
if (this.executionContext !== SCRATCHPAD_CONTEXT_CONTENT) {
|
|
console.error(this.strings.
|
|
GetStringFromName("scratchpadContext.invalid"));
|
|
return;
|
|
}
|
|
|
|
let target = TargetFactory.forTab(this.gBrowser.selectedTab);
|
|
target.once("navigate", () => {
|
|
this.run().then(results => deferred.resolve(results));
|
|
});
|
|
target.makeRemote().then(() => target.activeTab.reload());
|
|
|
|
return deferred.promise;
|
|
},
|
|
|
|
/**
|
|
* Execute the selected text (if any) or the entire editor content in the
|
|
* current context. The evaluation result is inserted into the editor after
|
|
* the selected text, or at the end of the editor content if there is no
|
|
* selected text.
|
|
*
|
|
* @return Promise
|
|
* The promise for the script evaluation result.
|
|
*/
|
|
display: function SP_display()
|
|
{
|
|
let deferred = promise.defer();
|
|
let reject = aReason => deferred.reject(aReason);
|
|
|
|
this.execute().then(([aString, aError, aResult]) => {
|
|
let resolve = () => deferred.resolve([aString, aError, aResult]);
|
|
|
|
if (aError) {
|
|
this.writeAsErrorComment(aError).then(resolve, reject);
|
|
}
|
|
else if (VariablesView.isPrimitive({ value: aResult })) {
|
|
this._writePrimitiveAsComment(aResult).then(resolve, reject);
|
|
}
|
|
else {
|
|
let objectClient = new ObjectClient(this.debuggerClient, aResult);
|
|
objectClient.getDisplayString(aResponse => {
|
|
if (aResponse.error) {
|
|
reportError("display", aResponse);
|
|
reject(aResponse);
|
|
}
|
|
else {
|
|
this.writeAsComment(aResponse.displayString);
|
|
resolve();
|
|
}
|
|
});
|
|
}
|
|
}, reject);
|
|
|
|
return deferred.promise;
|
|
},
|
|
|
|
_prettyPrintWorker: null,
|
|
|
|
/**
|
|
* Get or create the worker that handles pretty printing.
|
|
*/
|
|
get prettyPrintWorker() {
|
|
if (!this._prettyPrintWorker) {
|
|
this._prettyPrintWorker = new DevToolsWorker(
|
|
"resource://devtools/server/actors/pretty-print-worker.js",
|
|
{ name: "pretty-print",
|
|
verbose: flags.wantLogging }
|
|
);
|
|
}
|
|
return this._prettyPrintWorker;
|
|
},
|
|
|
|
/**
|
|
* Pretty print the source text inside the scratchpad.
|
|
*
|
|
* @return Promise
|
|
* A promise resolved with the pretty printed code, or rejected with
|
|
* an error.
|
|
*/
|
|
prettyPrint: function SP_prettyPrint() {
|
|
const uglyText = this.getText();
|
|
const tabsize = Services.prefs.getIntPref(TAB_SIZE);
|
|
|
|
return this.prettyPrintWorker.performTask("pretty-print", {
|
|
url: "(scratchpad)",
|
|
indent: tabsize,
|
|
source: uglyText
|
|
}).then(data => {
|
|
this.editor.setText(data.code);
|
|
}).then(null, error => {
|
|
this.writeAsErrorComment({ exception: error });
|
|
throw error;
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Parse the text and return an AST. If we can't parse it, write an error
|
|
* comment and return false.
|
|
*/
|
|
_parseText: function SP__parseText(aText) {
|
|
try {
|
|
return Reflect.parse(aText);
|
|
} catch (e) {
|
|
this.writeAsErrorComment({ exception: DevToolsUtils.safeErrorString(e) });
|
|
return false;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Determine if the given AST node location contains the given cursor
|
|
* position.
|
|
*
|
|
* @returns Boolean
|
|
*/
|
|
_containsCursor: function (aLoc, aCursorPos) {
|
|
// Our line numbers are 1-based, while CodeMirror's are 0-based.
|
|
const lineNumber = aCursorPos.line + 1;
|
|
const columnNumber = aCursorPos.ch;
|
|
|
|
if (aLoc.start.line <= lineNumber && aLoc.end.line >= lineNumber) {
|
|
if (aLoc.start.line === aLoc.end.line) {
|
|
return aLoc.start.column <= columnNumber
|
|
&& aLoc.end.column >= columnNumber;
|
|
}
|
|
|
|
if (aLoc.start.line == lineNumber) {
|
|
return columnNumber >= aLoc.start.column;
|
|
}
|
|
|
|
if (aLoc.end.line == lineNumber) {
|
|
return columnNumber <= aLoc.end.column;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
},
|
|
|
|
/**
|
|
* Find the top level function AST node that the cursor is within.
|
|
*
|
|
* @returns Object|null
|
|
*/
|
|
_findTopLevelFunction: function SP__findTopLevelFunction(aAst, aCursorPos) {
|
|
for (let statement of aAst.body) {
|
|
switch (statement.type) {
|
|
case "FunctionDeclaration":
|
|
if (this._containsCursor(statement.loc, aCursorPos)) {
|
|
return statement;
|
|
}
|
|
break;
|
|
|
|
case "VariableDeclaration":
|
|
for (let decl of statement.declarations) {
|
|
if (!decl.init) {
|
|
continue;
|
|
}
|
|
if ((decl.init.type == "FunctionExpression"
|
|
|| decl.init.type == "ArrowFunctionExpression")
|
|
&& this._containsCursor(decl.loc, aCursorPos)) {
|
|
return decl;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
},
|
|
|
|
/**
|
|
* Get the source text associated with the given function statement.
|
|
*
|
|
* @param Object aFunction
|
|
* @param String aFullText
|
|
* @returns String
|
|
*/
|
|
_getFunctionText: function SP__getFunctionText(aFunction, aFullText) {
|
|
let functionText = "";
|
|
// Initially set to 0, but incremented first thing in the loop below because
|
|
// line numbers are 1 based, not 0 based.
|
|
let lineNumber = 0;
|
|
const { start, end } = aFunction.loc;
|
|
const singleLine = start.line === end.line;
|
|
|
|
for (let line of aFullText.split(/\n/g)) {
|
|
lineNumber++;
|
|
|
|
if (singleLine && start.line === lineNumber) {
|
|
functionText = line.slice(start.column, end.column);
|
|
break;
|
|
}
|
|
|
|
if (start.line === lineNumber) {
|
|
functionText += line.slice(start.column) + "\n";
|
|
continue;
|
|
}
|
|
|
|
if (end.line === lineNumber) {
|
|
functionText += line.slice(0, end.column);
|
|
break;
|
|
}
|
|
|
|
if (start.line < lineNumber && end.line > lineNumber) {
|
|
functionText += line + "\n";
|
|
}
|
|
}
|
|
|
|
return functionText;
|
|
},
|
|
|
|
/**
|
|
* Evaluate the top level function that the cursor is resting in.
|
|
*
|
|
* @returns Promise [text, error, result]
|
|
*/
|
|
evalTopLevelFunction: function SP_evalTopLevelFunction() {
|
|
const text = this.getText();
|
|
const ast = this._parseText(text);
|
|
if (!ast) {
|
|
return promise.resolve([text, undefined, undefined]);
|
|
}
|
|
|
|
const cursorPos = this.editor.getCursor();
|
|
const funcStatement = this._findTopLevelFunction(ast, cursorPos);
|
|
if (!funcStatement) {
|
|
return promise.resolve([text, undefined, undefined]);
|
|
}
|
|
|
|
let functionText = this._getFunctionText(funcStatement, text);
|
|
|
|
// TODO: This is a work around for bug 940086. It should be removed when
|
|
// that is fixed.
|
|
if (funcStatement.type == "FunctionDeclaration"
|
|
&& !functionText.startsWith("function ")) {
|
|
functionText = "function " + functionText;
|
|
funcStatement.loc.start.column -= 9;
|
|
}
|
|
|
|
// The decrement by one is because our line numbers are 1-based, while
|
|
// CodeMirror's are 0-based.
|
|
const from = {
|
|
line: funcStatement.loc.start.line - 1,
|
|
ch: funcStatement.loc.start.column
|
|
};
|
|
const to = {
|
|
line: funcStatement.loc.end.line - 1,
|
|
ch: funcStatement.loc.end.column
|
|
};
|
|
|
|
const marker = this.editor.markText(from, to, "eval-text");
|
|
setTimeout(() => marker.clear(), EVAL_FUNCTION_TIMEOUT);
|
|
|
|
return this.evaluate(functionText);
|
|
},
|
|
|
|
/**
|
|
* Writes out a primitive value as a comment. This handles values which are
|
|
* to be printed directly (number, string) as well as grips to values
|
|
* (null, undefined, longString).
|
|
*
|
|
* @param any aValue
|
|
* The value to print.
|
|
* @return Promise
|
|
* The promise that resolves after the value has been printed.
|
|
*/
|
|
_writePrimitiveAsComment: function SP__writePrimitiveAsComment(aValue)
|
|
{
|
|
let deferred = promise.defer();
|
|
|
|
if (aValue.type == "longString") {
|
|
let client = this.webConsoleClient;
|
|
client.longString(aValue).substring(0, aValue.length, aResponse => {
|
|
if (aResponse.error) {
|
|
reportError("display", aResponse);
|
|
deferred.reject(aResponse);
|
|
}
|
|
else {
|
|
deferred.resolve(aResponse.substring);
|
|
}
|
|
});
|
|
}
|
|
else {
|
|
deferred.resolve(aValue.type || aValue);
|
|
}
|
|
|
|
return deferred.promise.then(aComment => {
|
|
this.writeAsComment(aComment);
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Write out a value at the next line from the current insertion point.
|
|
* The comment block will always be preceded by a newline character.
|
|
* @param object aValue
|
|
* The Object to write out as a string
|
|
*/
|
|
writeAsComment: function SP_writeAsComment(aValue)
|
|
{
|
|
let value = "\n/*\n" + aValue + "\n*/";
|
|
|
|
if (this.editor.somethingSelected()) {
|
|
let from = this.editor.getCursor("end");
|
|
this.editor.replaceSelection(this.editor.getSelection() + value);
|
|
let to = this.editor.getPosition(this.editor.getOffset(from) + value.length);
|
|
this.editor.setSelection(from, to);
|
|
return;
|
|
}
|
|
|
|
let text = this.editor.getText();
|
|
this.editor.setText(text + value);
|
|
|
|
let [ from, to ] = this.editor.getPosition(text.length, (text + value).length);
|
|
this.editor.setSelection(from, to);
|
|
},
|
|
|
|
/**
|
|
* Write out an error at the current insertion point as a block comment
|
|
* @param object aValue
|
|
* The error object to write out the message and stack trace. It must
|
|
* contain an |exception| property with the actual error thrown, but it
|
|
* will often be the entire response of an evaluateJS request.
|
|
* @return Promise
|
|
* The promise that indicates when writing the comment completes.
|
|
*/
|
|
writeAsErrorComment: function SP_writeAsErrorComment(aError)
|
|
{
|
|
let deferred = promise.defer();
|
|
|
|
if (VariablesView.isPrimitive({ value: aError.exception })) {
|
|
let error = aError.exception;
|
|
let type = error.type;
|
|
if (type == "undefined" ||
|
|
type == "null" ||
|
|
type == "Infinity" ||
|
|
type == "-Infinity" ||
|
|
type == "NaN" ||
|
|
type == "-0") {
|
|
deferred.resolve(type);
|
|
}
|
|
else if (type == "longString") {
|
|
deferred.resolve(error.initial + "\u2026");
|
|
}
|
|
else {
|
|
deferred.resolve(error);
|
|
}
|
|
} else if ("preview" in aError.exception) {
|
|
let error = aError.exception;
|
|
let stack = this._constructErrorStack(error.preview);
|
|
if (typeof aError.exceptionMessage == "string") {
|
|
deferred.resolve(aError.exceptionMessage + stack);
|
|
} else {
|
|
deferred.resolve(stack);
|
|
}
|
|
} else {
|
|
// If there is no preview information, we need to ask the server for more.
|
|
let objectClient = new ObjectClient(this.debuggerClient, aError.exception);
|
|
objectClient.getPrototypeAndProperties(aResponse => {
|
|
if (aResponse.error) {
|
|
deferred.reject(aResponse);
|
|
return;
|
|
}
|
|
|
|
let { ownProperties, safeGetterValues } = aResponse;
|
|
let error = Object.create(null);
|
|
|
|
// Combine all the property descriptor/getter values into one object.
|
|
for (let key of Object.keys(safeGetterValues)) {
|
|
error[key] = safeGetterValues[key].getterValue;
|
|
}
|
|
|
|
for (let key of Object.keys(ownProperties)) {
|
|
error[key] = ownProperties[key].value;
|
|
}
|
|
|
|
let stack = this._constructErrorStack(error);
|
|
|
|
if (typeof error.message == "string") {
|
|
deferred.resolve(error.message + stack);
|
|
}
|
|
else {
|
|
objectClient.getDisplayString(aResponse => {
|
|
if (aResponse.error) {
|
|
deferred.reject(aResponse);
|
|
}
|
|
else if (typeof aResponse.displayString == "string") {
|
|
deferred.resolve(aResponse.displayString + stack);
|
|
}
|
|
else {
|
|
deferred.resolve(stack);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
return deferred.promise.then(aMessage => {
|
|
console.error(aMessage);
|
|
this.writeAsComment("Exception: " + aMessage);
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Assembles the best possible stack from the properties of the provided
|
|
* error.
|
|
*/
|
|
_constructErrorStack(error) {
|
|
let stack;
|
|
if (typeof error.stack == "string" && error.stack) {
|
|
stack = error.stack;
|
|
} else if (typeof error.fileName == "string") {
|
|
stack = "@" + error.fileName;
|
|
if (typeof error.lineNumber == "number") {
|
|
stack += ":" + error.lineNumber;
|
|
}
|
|
} else if (typeof error.filename == "string") {
|
|
stack = "@" + error.filename;
|
|
if (typeof error.lineNumber == "number") {
|
|
stack += ":" + error.lineNumber;
|
|
if (typeof error.columnNumber == "number") {
|
|
stack += ":" + error.columnNumber;
|
|
}
|
|
}
|
|
} else if (typeof error.lineNumber == "number") {
|
|
stack = "@" + error.lineNumber;
|
|
if (typeof error.columnNumber == "number") {
|
|
stack += ":" + error.columnNumber;
|
|
}
|
|
}
|
|
|
|
return stack ? "\n" + stack.replace(/\n$/, "") : "";
|
|
},
|
|
|
|
// Menu Operations
|
|
|
|
/**
|
|
* Open a new Scratchpad window.
|
|
*
|
|
* @return nsIWindow
|
|
*/
|
|
openScratchpad: function SP_openScratchpad()
|
|
{
|
|
return ScratchpadManager.openScratchpad();
|
|
},
|
|
|
|
/**
|
|
* Export the textbox content to a file.
|
|
*
|
|
* @param nsILocalFile aFile
|
|
* The file where you want to save the textbox content.
|
|
* @param boolean aNoConfirmation
|
|
* If the file already exists, ask for confirmation?
|
|
* @param boolean aSilentError
|
|
* True if you do not want to display an error when file save fails,
|
|
* false otherwise.
|
|
* @param function aCallback
|
|
* Optional function you want to call when file save completes. It will
|
|
* get the following arguments:
|
|
* 1) the nsresult status code for the export operation.
|
|
*/
|
|
exportToFile: function SP_exportToFile(aFile, aNoConfirmation, aSilentError,
|
|
aCallback)
|
|
{
|
|
if (!aNoConfirmation && aFile.exists() &&
|
|
!window.confirm(this.strings.
|
|
GetStringFromName("export.fileOverwriteConfirmation"))) {
|
|
return;
|
|
}
|
|
|
|
let encoder = new TextEncoder();
|
|
let buffer = encoder.encode(this.getText());
|
|
let writePromise = OS.File.writeAtomic(aFile.path, buffer, {tmpPath: aFile.path + ".tmp"});
|
|
writePromise.then(value => {
|
|
if (aCallback) {
|
|
aCallback.call(this, Components.results.NS_OK);
|
|
}
|
|
}, reason => {
|
|
if (!aSilentError) {
|
|
window.alert(this.strings.GetStringFromName("saveFile.failed"));
|
|
}
|
|
if (aCallback) {
|
|
aCallback.call(this, Components.results.NS_ERROR_UNEXPECTED);
|
|
}
|
|
});
|
|
|
|
},
|
|
|
|
/**
|
|
* Get a list of applicable charsets.
|
|
* The best charset, defaulting to "UTF-8"
|
|
*
|
|
* @param string aBestCharset
|
|
* @return array of strings
|
|
*/
|
|
_getApplicableCharsets: function SP__getApplicableCharsets(aBestCharset = "UTF-8") {
|
|
let charsets = Services.prefs.getCharPref(
|
|
FALLBACK_CHARSET_LIST).split(",").filter(function (value) {
|
|
return value.length;
|
|
});
|
|
charsets.unshift(aBestCharset);
|
|
return charsets;
|
|
},
|
|
|
|
/**
|
|
* Get content converted to unicode, using a list of input charset to try.
|
|
*
|
|
* @param string aContent
|
|
* @param array of string aCharsetArray
|
|
* @return string
|
|
*/
|
|
_getUnicodeContent: function SP__getUnicodeContent(aContent, aCharsetArray) {
|
|
let content = null,
|
|
converter = Cc["@mozilla.org/intl/scriptableunicodeconverter"].createInstance(Ci.nsIScriptableUnicodeConverter),
|
|
success = aCharsetArray.some(charset => {
|
|
try {
|
|
converter.charset = charset;
|
|
content = converter.ConvertToUnicode(aContent);
|
|
return true;
|
|
} catch (e) {
|
|
this.notificationBox.appendNotification(
|
|
this.strings.formatStringFromName("importFromFile.convert.failed",
|
|
[ charset ], 1),
|
|
"file-import-convert-failed",
|
|
null,
|
|
this.notificationBox.PRIORITY_WARNING_HIGH,
|
|
null);
|
|
}
|
|
});
|
|
return content;
|
|
},
|
|
|
|
/**
|
|
* Read the content of a file and put it into the textbox.
|
|
*
|
|
* @param nsILocalFile aFile
|
|
* The file you want to save the textbox content into.
|
|
* @param boolean aSilentError
|
|
* True if you do not want to display an error when file load fails,
|
|
* false otherwise.
|
|
* @param function aCallback
|
|
* Optional function you want to call when file load completes. It will
|
|
* get the following arguments:
|
|
* 1) the nsresult status code for the import operation.
|
|
* 2) the data that was read from the file, if any.
|
|
*/
|
|
importFromFile: function SP_importFromFile(aFile, aSilentError, aCallback)
|
|
{
|
|
// Prevent file type detection.
|
|
let channel = NetUtil.newChannel({
|
|
uri: NetUtil.newURI(aFile),
|
|
loadingNode: window.document,
|
|
securityFlags: Ci.nsILoadInfo.SEC_ALLOW_CROSS_ORIGIN_DATA_INHERITS,
|
|
contentPolicyType: Ci.nsIContentPolicy.TYPE_OTHER});
|
|
channel.contentType = "application/javascript";
|
|
|
|
this.notificationBox.removeAllNotifications(false);
|
|
|
|
NetUtil.asyncFetch(channel, (aInputStream, aStatus) => {
|
|
let content = null;
|
|
|
|
if (Components.isSuccessCode(aStatus)) {
|
|
let charsets = this._getApplicableCharsets();
|
|
content = NetUtil.readInputStreamToString(aInputStream,
|
|
aInputStream.available());
|
|
content = this._getUnicodeContent(content, charsets);
|
|
if (!content) {
|
|
let message = this.strings.formatStringFromName(
|
|
"importFromFile.convert.failed",
|
|
[ charsets.join(", ") ],
|
|
1);
|
|
this.notificationBox.appendNotification(
|
|
message,
|
|
"file-import-convert-failed",
|
|
null,
|
|
this.notificationBox.PRIORITY_CRITICAL_MEDIUM,
|
|
null);
|
|
if (aCallback) {
|
|
aCallback.call(this, aStatus, content);
|
|
}
|
|
return;
|
|
}
|
|
// Check to see if the first line is a mode-line comment.
|
|
let line = content.split("\n")[0];
|
|
let modeline = this._scanModeLine(line);
|
|
let chrome = Services.prefs.getBoolPref(DEVTOOLS_CHROME_ENABLED);
|
|
|
|
if (chrome && modeline["-sp-context"] === "browser") {
|
|
this.setBrowserContext();
|
|
}
|
|
|
|
this.editor.setText(content);
|
|
this.editor.clearHistory();
|
|
this.dirty = false;
|
|
document.getElementById("sp-cmd-revert").setAttribute("disabled", true);
|
|
}
|
|
else if (!aSilentError) {
|
|
window.alert(this.strings.GetStringFromName("openFile.failed"));
|
|
}
|
|
this.setFilename(aFile.path);
|
|
this.setRecentFile(aFile);
|
|
if (aCallback) {
|
|
aCallback.call(this, aStatus, content);
|
|
}
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Open a file to edit in the Scratchpad.
|
|
*
|
|
* @param integer aIndex
|
|
* Optional integer: clicked menuitem in the 'Open Recent'-menu.
|
|
*/
|
|
openFile: function SP_openFile(aIndex)
|
|
{
|
|
let promptCallback = aFile => {
|
|
this.promptSave((aCloseFile, aSaved, aStatus) => {
|
|
let shouldOpen = aCloseFile;
|
|
if (aSaved && !Components.isSuccessCode(aStatus)) {
|
|
shouldOpen = false;
|
|
}
|
|
|
|
if (shouldOpen) {
|
|
let file;
|
|
if (aFile) {
|
|
file = aFile;
|
|
} else {
|
|
file = Components.classes["@mozilla.org/file/local;1"].
|
|
createInstance(Components.interfaces.nsILocalFile);
|
|
let filePath = this.getRecentFiles()[aIndex];
|
|
file.initWithPath(filePath);
|
|
}
|
|
|
|
if (!file.exists()) {
|
|
this.notificationBox.appendNotification(
|
|
this.strings.GetStringFromName("fileNoLongerExists.notification"),
|
|
"file-no-longer-exists",
|
|
null,
|
|
this.notificationBox.PRIORITY_WARNING_HIGH,
|
|
null);
|
|
|
|
this.clearFiles(aIndex, 1);
|
|
return;
|
|
}
|
|
|
|
this.importFromFile(file, false);
|
|
}
|
|
});
|
|
};
|
|
|
|
if (aIndex > -1) {
|
|
promptCallback();
|
|
} else {
|
|
let fp = Cc["@mozilla.org/filepicker;1"].createInstance(Ci.nsIFilePicker);
|
|
fp.init(window, this.strings.GetStringFromName("openFile.title"),
|
|
Ci.nsIFilePicker.modeOpen);
|
|
fp.defaultString = "";
|
|
fp.appendFilter("JavaScript Files", "*.js; *.jsm; *.json");
|
|
fp.appendFilter("All Files", "*.*");
|
|
fp.open(aResult => {
|
|
if (aResult != Ci.nsIFilePicker.returnCancel) {
|
|
promptCallback(fp.file);
|
|
}
|
|
});
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Get recent files.
|
|
*
|
|
* @return Array
|
|
* File paths.
|
|
*/
|
|
getRecentFiles: function SP_getRecentFiles()
|
|
{
|
|
let branch = Services.prefs.getBranch("devtools.scratchpad.");
|
|
let filePaths = [];
|
|
|
|
// WARNING: Do not use getCharPref here, it doesn't play nicely with
|
|
// Unicode strings.
|
|
|
|
if (branch.prefHasUserValue("recentFilePaths")) {
|
|
let data = branch.getComplexValue("recentFilePaths",
|
|
Ci.nsISupportsString).data;
|
|
filePaths = JSON.parse(data);
|
|
}
|
|
|
|
return filePaths;
|
|
},
|
|
|
|
/**
|
|
* Save a recent file in a JSON parsable string.
|
|
*
|
|
* @param nsILocalFile aFile
|
|
* The nsILocalFile we want to save as a recent file.
|
|
*/
|
|
setRecentFile: function SP_setRecentFile(aFile)
|
|
{
|
|
let maxRecent = Services.prefs.getIntPref(PREF_RECENT_FILES_MAX);
|
|
if (maxRecent < 1) {
|
|
return;
|
|
}
|
|
|
|
let filePaths = this.getRecentFiles();
|
|
let filesCount = filePaths.length;
|
|
let pathIndex = filePaths.indexOf(aFile.path);
|
|
|
|
// We are already storing this file in the list of recent files.
|
|
if (pathIndex > -1) {
|
|
// If it's already the most recent file, we don't have to do anything.
|
|
if (pathIndex === (filesCount - 1)) {
|
|
// Updating the menu to clear the disabled state from the wrong menuitem
|
|
// in rare cases when two or more Scratchpad windows are open and the
|
|
// same file has been opened in two or more windows.
|
|
this.populateRecentFilesMenu();
|
|
return;
|
|
}
|
|
|
|
// It is not the most recent file. Remove it from the list, we add it as
|
|
// the most recent farther down.
|
|
filePaths.splice(pathIndex, 1);
|
|
}
|
|
// If we are not storing the file and the 'recent files'-list is full,
|
|
// remove the oldest file from the list.
|
|
else if (filesCount === maxRecent) {
|
|
filePaths.shift();
|
|
}
|
|
|
|
filePaths.push(aFile.path);
|
|
|
|
// WARNING: Do not use setCharPref here, it doesn't play nicely with
|
|
// Unicode strings.
|
|
|
|
let str = Cc["@mozilla.org/supports-string;1"]
|
|
.createInstance(Ci.nsISupportsString);
|
|
str.data = JSON.stringify(filePaths);
|
|
|
|
let branch = Services.prefs.getBranch("devtools.scratchpad.");
|
|
branch.setComplexValue("recentFilePaths",
|
|
Ci.nsISupportsString, str);
|
|
},
|
|
|
|
/**
|
|
* Populates the 'Open Recent'-menu.
|
|
*/
|
|
populateRecentFilesMenu: function SP_populateRecentFilesMenu()
|
|
{
|
|
let maxRecent = Services.prefs.getIntPref(PREF_RECENT_FILES_MAX);
|
|
let recentFilesMenu = document.getElementById("sp-open_recent-menu");
|
|
|
|
if (maxRecent < 1) {
|
|
recentFilesMenu.setAttribute("hidden", true);
|
|
return;
|
|
}
|
|
|
|
let recentFilesPopup = recentFilesMenu.firstChild;
|
|
let filePaths = this.getRecentFiles();
|
|
let filename = this.getState().filename;
|
|
|
|
recentFilesMenu.setAttribute("disabled", true);
|
|
while (recentFilesPopup.hasChildNodes()) {
|
|
recentFilesPopup.removeChild(recentFilesPopup.firstChild);
|
|
}
|
|
|
|
if (filePaths.length > 0) {
|
|
recentFilesMenu.removeAttribute("disabled");
|
|
|
|
// Print out menuitems with the most recent file first.
|
|
for (let i = filePaths.length - 1; i >= 0; --i) {
|
|
let menuitem = document.createElement("menuitem");
|
|
menuitem.setAttribute("type", "radio");
|
|
menuitem.setAttribute("label", filePaths[i]);
|
|
|
|
if (filePaths[i] === filename) {
|
|
menuitem.setAttribute("checked", true);
|
|
menuitem.setAttribute("disabled", true);
|
|
}
|
|
|
|
menuitem.addEventListener("command", Scratchpad.openFile.bind(Scratchpad, i));
|
|
recentFilesPopup.appendChild(menuitem);
|
|
}
|
|
|
|
recentFilesPopup.appendChild(document.createElement("menuseparator"));
|
|
let clearItems = document.createElement("menuitem");
|
|
clearItems.setAttribute("id", "sp-menu-clear_recent");
|
|
clearItems.setAttribute("label",
|
|
this.strings.
|
|
GetStringFromName("clearRecentMenuItems.label"));
|
|
clearItems.setAttribute("command", "sp-cmd-clearRecentFiles");
|
|
recentFilesPopup.appendChild(clearItems);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Clear a range of files from the list.
|
|
*
|
|
* @param integer aIndex
|
|
* Index of file in menu to remove.
|
|
* @param integer aLength
|
|
* Number of files from the index 'aIndex' to remove.
|
|
*/
|
|
clearFiles: function SP_clearFile(aIndex, aLength)
|
|
{
|
|
let filePaths = this.getRecentFiles();
|
|
filePaths.splice(aIndex, aLength);
|
|
|
|
// WARNING: Do not use setCharPref here, it doesn't play nicely with
|
|
// Unicode strings.
|
|
|
|
let str = Cc["@mozilla.org/supports-string;1"]
|
|
.createInstance(Ci.nsISupportsString);
|
|
str.data = JSON.stringify(filePaths);
|
|
|
|
let branch = Services.prefs.getBranch("devtools.scratchpad.");
|
|
branch.setComplexValue("recentFilePaths",
|
|
Ci.nsISupportsString, str);
|
|
},
|
|
|
|
/**
|
|
* Clear all recent files.
|
|
*/
|
|
clearRecentFiles: function SP_clearRecentFiles()
|
|
{
|
|
Services.prefs.clearUserPref("devtools.scratchpad.recentFilePaths");
|
|
},
|
|
|
|
/**
|
|
* Handle changes to the 'PREF_RECENT_FILES_MAX'-preference.
|
|
*/
|
|
handleRecentFileMaxChange: function SP_handleRecentFileMaxChange()
|
|
{
|
|
let maxRecent = Services.prefs.getIntPref(PREF_RECENT_FILES_MAX);
|
|
let menu = document.getElementById("sp-open_recent-menu");
|
|
|
|
// Hide the menu if the 'PREF_RECENT_FILES_MAX'-pref is set to zero or less.
|
|
if (maxRecent < 1) {
|
|
menu.setAttribute("hidden", true);
|
|
} else {
|
|
if (menu.hasAttribute("hidden")) {
|
|
if (!menu.firstChild.hasChildNodes()) {
|
|
this.populateRecentFilesMenu();
|
|
}
|
|
|
|
menu.removeAttribute("hidden");
|
|
}
|
|
|
|
let filePaths = this.getRecentFiles();
|
|
if (maxRecent < filePaths.length) {
|
|
let diff = filePaths.length - maxRecent;
|
|
this.clearFiles(0, diff);
|
|
}
|
|
}
|
|
},
|
|
/**
|
|
* Save the textbox content to the currently open file.
|
|
*
|
|
* @param function aCallback
|
|
* Optional function you want to call when file is saved
|
|
*/
|
|
saveFile: function SP_saveFile(aCallback)
|
|
{
|
|
if (!this.filename) {
|
|
return this.saveFileAs(aCallback);
|
|
}
|
|
|
|
let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsILocalFile);
|
|
file.initWithPath(this.filename);
|
|
|
|
this.exportToFile(file, true, false, aStatus => {
|
|
if (Components.isSuccessCode(aStatus)) {
|
|
this.dirty = false;
|
|
document.getElementById("sp-cmd-revert").setAttribute("disabled", true);
|
|
this.setRecentFile(file);
|
|
}
|
|
if (aCallback) {
|
|
aCallback(aStatus);
|
|
}
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Save the textbox content to a new file.
|
|
*
|
|
* @param function aCallback
|
|
* Optional function you want to call when file is saved
|
|
*/
|
|
saveFileAs: function SP_saveFileAs(aCallback)
|
|
{
|
|
let fp = Cc["@mozilla.org/filepicker;1"].createInstance(Ci.nsIFilePicker);
|
|
let fpCallback = aResult => {
|
|
if (aResult != Ci.nsIFilePicker.returnCancel) {
|
|
this.setFilename(fp.file.path);
|
|
this.exportToFile(fp.file, true, false, aStatus => {
|
|
if (Components.isSuccessCode(aStatus)) {
|
|
this.dirty = false;
|
|
this.setRecentFile(fp.file);
|
|
}
|
|
if (aCallback) {
|
|
aCallback(aStatus);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
fp.init(window, this.strings.GetStringFromName("saveFileAs"),
|
|
Ci.nsIFilePicker.modeSave);
|
|
fp.defaultString = "scratchpad.js";
|
|
fp.appendFilter("JavaScript Files", "*.js; *.jsm; *.json");
|
|
fp.appendFilter("All Files", "*.*");
|
|
fp.open(fpCallback);
|
|
},
|
|
|
|
/**
|
|
* Restore content from saved version of current file.
|
|
*
|
|
* @param function aCallback
|
|
* Optional function you want to call when file is saved
|
|
*/
|
|
revertFile: function SP_revertFile(aCallback)
|
|
{
|
|
let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsILocalFile);
|
|
file.initWithPath(this.filename);
|
|
|
|
if (!file.exists()) {
|
|
return;
|
|
}
|
|
|
|
this.importFromFile(file, false, (aStatus, aContent) => {
|
|
if (aCallback) {
|
|
aCallback(aStatus);
|
|
}
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Prompt to revert scratchpad if it has unsaved changes.
|
|
*
|
|
* @param function aCallback
|
|
* Optional function you want to call when file is saved. The callback
|
|
* receives three arguments:
|
|
* - aRevert (boolean) - tells if the file has been reverted.
|
|
* - status (number) - the file revert status result (if the file was
|
|
* saved).
|
|
*/
|
|
promptRevert: function SP_promptRervert(aCallback)
|
|
{
|
|
if (this.filename) {
|
|
let ps = Services.prompt;
|
|
let flags = ps.BUTTON_POS_0 * ps.BUTTON_TITLE_REVERT +
|
|
ps.BUTTON_POS_1 * ps.BUTTON_TITLE_CANCEL;
|
|
|
|
let button = ps.confirmEx(window,
|
|
this.strings.GetStringFromName("confirmRevert.title"),
|
|
this.strings.GetStringFromName("confirmRevert"),
|
|
flags, null, null, null, null, {});
|
|
if (button == BUTTON_POSITION_CANCEL) {
|
|
if (aCallback) {
|
|
aCallback(false);
|
|
}
|
|
|
|
return;
|
|
}
|
|
if (button == BUTTON_POSITION_REVERT) {
|
|
this.revertFile(aStatus => {
|
|
if (aCallback) {
|
|
aCallback(true, aStatus);
|
|
}
|
|
});
|
|
|
|
return;
|
|
}
|
|
}
|
|
if (aCallback) {
|
|
aCallback(false);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Open the Error Console.
|
|
*/
|
|
openErrorConsole: function SP_openErrorConsole()
|
|
{
|
|
HUDService.toggleBrowserConsole();
|
|
},
|
|
|
|
/**
|
|
* Open the Web Console.
|
|
*/
|
|
openWebConsole: function SP_openWebConsole()
|
|
{
|
|
let target = TargetFactory.forTab(this.gBrowser.selectedTab);
|
|
gDevTools.showToolbox(target, "webconsole");
|
|
this.browserWindow.focus();
|
|
},
|
|
|
|
/**
|
|
* Set the current execution context to be the active tab content window.
|
|
*/
|
|
setContentContext: function SP_setContentContext()
|
|
{
|
|
if (this.executionContext == SCRATCHPAD_CONTEXT_CONTENT) {
|
|
return;
|
|
}
|
|
|
|
let content = document.getElementById("sp-menu-content");
|
|
document.getElementById("sp-menu-browser").removeAttribute("checked");
|
|
document.getElementById("sp-cmd-reloadAndRun").removeAttribute("disabled");
|
|
content.setAttribute("checked", true);
|
|
this.executionContext = SCRATCHPAD_CONTEXT_CONTENT;
|
|
this.notificationBox.removeAllNotifications(false);
|
|
},
|
|
|
|
/**
|
|
* Set the current execution context to be the most recent chrome window.
|
|
*/
|
|
setBrowserContext: function SP_setBrowserContext()
|
|
{
|
|
if (this.executionContext == SCRATCHPAD_CONTEXT_BROWSER) {
|
|
return;
|
|
}
|
|
|
|
let browser = document.getElementById("sp-menu-browser");
|
|
let reloadAndRun = document.getElementById("sp-cmd-reloadAndRun");
|
|
|
|
document.getElementById("sp-menu-content").removeAttribute("checked");
|
|
reloadAndRun.setAttribute("disabled", true);
|
|
browser.setAttribute("checked", true);
|
|
|
|
this.executionContext = SCRATCHPAD_CONTEXT_BROWSER;
|
|
this.notificationBox.appendNotification(
|
|
this.strings.GetStringFromName("browserContext.notification"),
|
|
SCRATCHPAD_CONTEXT_BROWSER,
|
|
null,
|
|
this.notificationBox.PRIORITY_WARNING_HIGH,
|
|
null);
|
|
},
|
|
|
|
/**
|
|
* Gets the ID of the inner window of the given DOM window object.
|
|
*
|
|
* @param nsIDOMWindow aWindow
|
|
* @return integer
|
|
* the inner window ID
|
|
*/
|
|
getInnerWindowId: function SP_getInnerWindowId(aWindow)
|
|
{
|
|
return aWindow.QueryInterface(Ci.nsIInterfaceRequestor).
|
|
getInterface(Ci.nsIDOMWindowUtils).currentInnerWindowID;
|
|
},
|
|
|
|
updateStatusBar: function SP_updateStatusBar(aEventType)
|
|
{
|
|
var statusBarField = document.getElementById("statusbar-line-col");
|
|
let { line, ch } = this.editor.getCursor();
|
|
statusBarField.textContent = this.strings.formatStringFromName(
|
|
"scratchpad.statusBarLineCol", [ line + 1, ch + 1], 2);
|
|
},
|
|
|
|
/**
|
|
* The Scratchpad window load event handler. This method
|
|
* initializes the Scratchpad window and source editor.
|
|
*
|
|
* @param nsIDOMEvent aEvent
|
|
*/
|
|
onLoad: function SP_onLoad(aEvent)
|
|
{
|
|
if (aEvent.target != document) {
|
|
return;
|
|
}
|
|
|
|
let chrome = Services.prefs.getBoolPref(DEVTOOLS_CHROME_ENABLED);
|
|
if (chrome) {
|
|
let environmentMenu = document.getElementById("sp-environment-menu");
|
|
let errorConsoleCommand = document.getElementById("sp-cmd-errorConsole");
|
|
let chromeContextCommand = document.getElementById("sp-cmd-browserContext");
|
|
environmentMenu.removeAttribute("hidden");
|
|
chromeContextCommand.removeAttribute("disabled");
|
|
errorConsoleCommand.removeAttribute("disabled");
|
|
}
|
|
|
|
let initialText = this.strings.formatStringFromName(
|
|
"scratchpadIntro1",
|
|
[ShortcutUtils.prettifyShortcut(document.getElementById("sp-key-run"), true),
|
|
ShortcutUtils.prettifyShortcut(document.getElementById("sp-key-inspect"), true),
|
|
ShortcutUtils.prettifyShortcut(document.getElementById("sp-key-display"), true)],
|
|
3);
|
|
|
|
let args = window.arguments;
|
|
let state = null;
|
|
|
|
if (args && args[0] instanceof Ci.nsIDialogParamBlock) {
|
|
args = args[0];
|
|
this._instanceId = args.GetString(0);
|
|
|
|
state = args.GetString(1) || null;
|
|
if (state) {
|
|
state = JSON.parse(state);
|
|
this.setState(state);
|
|
if ("text" in state) {
|
|
initialText = state.text;
|
|
}
|
|
}
|
|
} else {
|
|
this._instanceId = ScratchpadManager.createUid();
|
|
}
|
|
|
|
let config = {
|
|
mode: Editor.modes.js,
|
|
value: initialText,
|
|
lineNumbers: Services.prefs.getBoolPref(SHOW_LINE_NUMBERS),
|
|
contextMenu: "scratchpad-text-popup",
|
|
showTrailingSpace: Services.prefs.getBoolPref(SHOW_TRAILING_SPACE),
|
|
autocomplete: Services.prefs.getBoolPref(ENABLE_AUTOCOMPLETION),
|
|
lineWrapping: Services.prefs.getBoolPref(WRAP_TEXT),
|
|
};
|
|
|
|
this.editor = new Editor(config);
|
|
let editorElement = document.querySelector("#scratchpad-editor");
|
|
this.editor.appendTo(editorElement).then(() => {
|
|
var lines = initialText.split("\n");
|
|
|
|
this.editor.setFontSize(Services.prefs.getIntPref(EDITOR_FONT_SIZE));
|
|
|
|
this.editor.on("change", this._onChanged);
|
|
// Keep a reference to the bound version for use in onUnload.
|
|
this.updateStatusBar = Scratchpad.updateStatusBar.bind(this);
|
|
this.editor.on("cursorActivity", this.updateStatusBar);
|
|
let okstring = this.strings.GetStringFromName("selfxss.okstring");
|
|
let msg = this.strings.formatStringFromName("selfxss.msg", [okstring], 1);
|
|
this._onPaste = WebConsoleUtils.pasteHandlerGen(this.editor.container.contentDocument.body,
|
|
document.querySelector("#scratchpad-notificationbox"),
|
|
msg, okstring);
|
|
editorElement.addEventListener("paste", this._onPaste, true);
|
|
editorElement.addEventListener("drop", this._onPaste);
|
|
this.editor.on("saveRequested", () => this.saveFile());
|
|
this.editor.focus();
|
|
this.editor.setCursor({ line: lines.length, ch: lines.pop().length });
|
|
|
|
// Add the commands controller for the source-editor.
|
|
this.editor.insertCommandsController();
|
|
|
|
if (state)
|
|
this.dirty = !state.saved;
|
|
|
|
this.initialized = true;
|
|
this._triggerObservers("Ready");
|
|
this.populateRecentFilesMenu();
|
|
PreferenceObserver.init();
|
|
CloseObserver.init();
|
|
}).then(null, (err) => console.error(err));
|
|
this._setupCommandListeners();
|
|
this._updateViewMenuItems();
|
|
this._setupPopupShowingListeners();
|
|
},
|
|
|
|
/**
|
|
* The Source Editor "change" event handler. This function updates the
|
|
* Scratchpad window title to show an asterisk when there are unsaved changes.
|
|
*
|
|
* @private
|
|
*/
|
|
_onChanged: function SP__onChanged()
|
|
{
|
|
Scratchpad._updateTitle();
|
|
|
|
if (Scratchpad.filename) {
|
|
if (Scratchpad.dirty)
|
|
document.getElementById("sp-cmd-revert").removeAttribute("disabled");
|
|
else
|
|
document.getElementById("sp-cmd-revert").setAttribute("disabled", true);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Undo the last action of the user.
|
|
*/
|
|
undo: function SP_undo()
|
|
{
|
|
this.editor.undo();
|
|
},
|
|
|
|
/**
|
|
* Redo the previously undone action.
|
|
*/
|
|
redo: function SP_redo()
|
|
{
|
|
this.editor.redo();
|
|
},
|
|
|
|
/**
|
|
* The Scratchpad window unload event handler. This method unloads/destroys
|
|
* the source editor.
|
|
*
|
|
* @param nsIDOMEvent aEvent
|
|
*/
|
|
onUnload: function SP_onUnload(aEvent)
|
|
{
|
|
if (aEvent.target != document) {
|
|
return;
|
|
}
|
|
|
|
// This event is created only after user uses 'reload and run' feature.
|
|
if (this._reloadAndRunEvent && this.gBrowser) {
|
|
this.gBrowser.selectedBrowser.removeEventListener("load",
|
|
this._reloadAndRunEvent, true);
|
|
}
|
|
|
|
PreferenceObserver.uninit();
|
|
CloseObserver.uninit();
|
|
if (this._onPaste) {
|
|
let editorElement = document.querySelector("#scratchpad-editor");
|
|
editorElement.removeEventListener("paste", this._onPaste, true);
|
|
editorElement.removeEventListener("drop", this._onPaste);
|
|
this._onPaste = null;
|
|
}
|
|
this.editor.off("change", this._onChanged);
|
|
this.editor.off("cursorActivity", this.updateStatusBar);
|
|
this.editor.destroy();
|
|
this.editor = null;
|
|
|
|
if (this._sidebar) {
|
|
this._sidebar.destroy();
|
|
this._sidebar = null;
|
|
}
|
|
|
|
if (this._prettyPrintWorker) {
|
|
this._prettyPrintWorker.destroy();
|
|
this._prettyPrintWorker = null;
|
|
}
|
|
|
|
scratchpadTargets = null;
|
|
this.webConsoleClient = null;
|
|
this.debuggerClient = null;
|
|
this.initialized = false;
|
|
},
|
|
|
|
/**
|
|
* Prompt to save scratchpad if it has unsaved changes.
|
|
*
|
|
* @param function aCallback
|
|
* Optional function you want to call when file is saved. The callback
|
|
* receives three arguments:
|
|
* - toClose (boolean) - tells if the window should be closed.
|
|
* - saved (boolen) - tells if the file has been saved.
|
|
* - status (number) - the file save status result (if the file was
|
|
* saved).
|
|
* @return boolean
|
|
* Whether the window should be closed
|
|
*/
|
|
promptSave: function SP_promptSave(aCallback)
|
|
{
|
|
if (this.dirty) {
|
|
let ps = Services.prompt;
|
|
let flags = ps.BUTTON_POS_0 * ps.BUTTON_TITLE_SAVE +
|
|
ps.BUTTON_POS_1 * ps.BUTTON_TITLE_CANCEL +
|
|
ps.BUTTON_POS_2 * ps.BUTTON_TITLE_DONT_SAVE;
|
|
|
|
let button = ps.confirmEx(window,
|
|
this.strings.GetStringFromName("confirmClose.title"),
|
|
this.strings.GetStringFromName("confirmClose"),
|
|
flags, null, null, null, null, {});
|
|
|
|
if (button == BUTTON_POSITION_CANCEL) {
|
|
if (aCallback) {
|
|
aCallback(false, false);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
if (button == BUTTON_POSITION_SAVE) {
|
|
this.saveFile(aStatus => {
|
|
if (aCallback) {
|
|
aCallback(true, true, aStatus);
|
|
}
|
|
});
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (aCallback) {
|
|
aCallback(true, false);
|
|
}
|
|
return true;
|
|
},
|
|
|
|
/**
|
|
* Handler for window close event. Prompts to save scratchpad if
|
|
* there are unsaved changes.
|
|
*
|
|
* @param nsIDOMEvent aEvent
|
|
* @param function aCallback
|
|
* Optional function you want to call when file is saved/closed.
|
|
* Used mainly for tests.
|
|
*/
|
|
onClose: function SP_onClose(aEvent, aCallback)
|
|
{
|
|
aEvent.preventDefault();
|
|
this.close(aCallback);
|
|
},
|
|
|
|
/**
|
|
* Close the scratchpad window. Prompts before closing if the scratchpad
|
|
* has unsaved changes.
|
|
*
|
|
* @param function aCallback
|
|
* Optional function you want to call when file is saved
|
|
*/
|
|
close: function SP_close(aCallback)
|
|
{
|
|
let shouldClose;
|
|
|
|
this.promptSave((aShouldClose, aSaved, aStatus) => {
|
|
shouldClose = aShouldClose;
|
|
if (aSaved && !Components.isSuccessCode(aStatus)) {
|
|
shouldClose = false;
|
|
}
|
|
|
|
if (shouldClose) {
|
|
window.close();
|
|
}
|
|
|
|
if (aCallback) {
|
|
aCallback(shouldClose);
|
|
}
|
|
});
|
|
|
|
return shouldClose;
|
|
},
|
|
|
|
/**
|
|
* Toggle a editor's boolean option.
|
|
*/
|
|
toggleEditorOption: function SP_toggleEditorOption(optionName, optionPreference)
|
|
{
|
|
let newOptionValue = !this.editor.getOption(optionName);
|
|
this.editor.setOption(optionName, newOptionValue);
|
|
Services.prefs.setBoolPref(optionPreference, newOptionValue);
|
|
},
|
|
|
|
/**
|
|
* Increase the editor's font size by 1 px.
|
|
*/
|
|
increaseFontSize: function SP_increaseFontSize()
|
|
{
|
|
let size = this.editor.getFontSize();
|
|
|
|
if (size < MAXIMUM_FONT_SIZE) {
|
|
let newFontSize = size + 1;
|
|
this.editor.setFontSize(newFontSize);
|
|
Services.prefs.setIntPref(EDITOR_FONT_SIZE, newFontSize);
|
|
|
|
if (newFontSize === MAXIMUM_FONT_SIZE) {
|
|
document.getElementById("sp-cmd-larger-font").setAttribute("disabled", true);
|
|
}
|
|
|
|
document.getElementById("sp-cmd-smaller-font").removeAttribute("disabled");
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Decrease the editor's font size by 1 px.
|
|
*/
|
|
decreaseFontSize: function SP_decreaseFontSize()
|
|
{
|
|
let size = this.editor.getFontSize();
|
|
|
|
if (size > MINIMUM_FONT_SIZE) {
|
|
let newFontSize = size - 1;
|
|
this.editor.setFontSize(newFontSize);
|
|
Services.prefs.setIntPref(EDITOR_FONT_SIZE, newFontSize);
|
|
|
|
if (newFontSize === MINIMUM_FONT_SIZE) {
|
|
document.getElementById("sp-cmd-smaller-font").setAttribute("disabled", true);
|
|
}
|
|
}
|
|
|
|
document.getElementById("sp-cmd-larger-font").removeAttribute("disabled");
|
|
},
|
|
|
|
/**
|
|
* Restore the editor's original font size.
|
|
*/
|
|
normalFontSize: function SP_normalFontSize()
|
|
{
|
|
this.editor.setFontSize(NORMAL_FONT_SIZE);
|
|
Services.prefs.setIntPref(EDITOR_FONT_SIZE, NORMAL_FONT_SIZE);
|
|
|
|
document.getElementById("sp-cmd-larger-font").removeAttribute("disabled");
|
|
document.getElementById("sp-cmd-smaller-font").removeAttribute("disabled");
|
|
},
|
|
|
|
_observers: [],
|
|
|
|
/**
|
|
* Add an observer for Scratchpad events.
|
|
*
|
|
* The observer implements IScratchpadObserver := {
|
|
* onReady: Called when the Scratchpad and its Editor are ready.
|
|
* Arguments: (Scratchpad aScratchpad)
|
|
* }
|
|
*
|
|
* All observer handlers are optional.
|
|
*
|
|
* @param IScratchpadObserver aObserver
|
|
* @see removeObserver
|
|
*/
|
|
addObserver: function SP_addObserver(aObserver)
|
|
{
|
|
this._observers.push(aObserver);
|
|
},
|
|
|
|
/**
|
|
* Remove an observer for Scratchpad events.
|
|
*
|
|
* @param IScratchpadObserver aObserver
|
|
* @see addObserver
|
|
*/
|
|
removeObserver: function SP_removeObserver(aObserver)
|
|
{
|
|
let index = this._observers.indexOf(aObserver);
|
|
if (index != -1) {
|
|
this._observers.splice(index, 1);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Trigger named handlers in Scratchpad observers.
|
|
*
|
|
* @param string aName
|
|
* Name of the handler to trigger.
|
|
* @param Array aArgs
|
|
* Optional array of arguments to pass to the observer(s).
|
|
* @see addObserver
|
|
*/
|
|
_triggerObservers: function SP_triggerObservers(aName, aArgs)
|
|
{
|
|
// insert this Scratchpad instance as the first argument
|
|
if (!aArgs) {
|
|
aArgs = [this];
|
|
} else {
|
|
aArgs.unshift(this);
|
|
}
|
|
|
|
// trigger all observers that implement this named handler
|
|
for (let i = 0; i < this._observers.length; ++i) {
|
|
let observer = this._observers[i];
|
|
let handler = observer["on" + aName];
|
|
if (handler) {
|
|
handler.apply(observer, aArgs);
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Opens the MDN documentation page for Scratchpad.
|
|
*/
|
|
openDocumentationPage: function SP_openDocumentationPage()
|
|
{
|
|
let url = this.strings.GetStringFromName("help.openDocumentationPage");
|
|
this.browserWindow.openUILinkIn(url,"tab");
|
|
this.browserWindow.focus();
|
|
},
|
|
};
|
|
|
|
|
|
/**
|
|
* Represents the DebuggerClient connection to a specific tab as used by the
|
|
* Scratchpad.
|
|
*
|
|
* @param object aTab
|
|
* The tab to connect to.
|
|
*/
|
|
function ScratchpadTab(aTab)
|
|
{
|
|
this._tab = aTab;
|
|
}
|
|
|
|
var scratchpadTargets = new WeakMap();
|
|
|
|
/**
|
|
* Returns the object containing the DebuggerClient and WebConsoleClient for a
|
|
* given tab or window.
|
|
*
|
|
* @param object aSubject
|
|
* The tab or window to obtain the connection for.
|
|
* @return Promise
|
|
* The promise for the connection information.
|
|
*/
|
|
ScratchpadTab.consoleFor = function consoleFor(aSubject)
|
|
{
|
|
if (!scratchpadTargets.has(aSubject)) {
|
|
scratchpadTargets.set(aSubject, new this(aSubject));
|
|
}
|
|
return scratchpadTargets.get(aSubject).connect(aSubject);
|
|
};
|
|
|
|
|
|
ScratchpadTab.prototype = {
|
|
/**
|
|
* The promise for the connection.
|
|
*/
|
|
_connector: null,
|
|
|
|
/**
|
|
* Initialize a debugger client and connect it to the debugger server.
|
|
*
|
|
* @param object aSubject
|
|
* The tab or window to obtain the connection for.
|
|
* @return Promise
|
|
* The promise for the result of connecting to this tab or window.
|
|
*/
|
|
connect: function ST_connect(aSubject)
|
|
{
|
|
if (this._connector) {
|
|
return this._connector;
|
|
}
|
|
|
|
let deferred = promise.defer();
|
|
this._connector = deferred.promise;
|
|
|
|
let connectTimer = setTimeout(() => {
|
|
deferred.reject({
|
|
error: "timeout",
|
|
message: Scratchpad.strings.GetStringFromName("connectionTimeout"),
|
|
});
|
|
}, REMOTE_TIMEOUT);
|
|
|
|
deferred.promise.then(() => clearTimeout(connectTimer));
|
|
|
|
this._attach(aSubject).then(aTarget => {
|
|
let consoleActor = aTarget.form.consoleActor;
|
|
let client = aTarget.client;
|
|
client.attachConsole(consoleActor, [], (aResponse, aWebConsoleClient) => {
|
|
if (aResponse.error) {
|
|
reportError("attachConsole", aResponse);
|
|
deferred.reject(aResponse);
|
|
}
|
|
else {
|
|
deferred.resolve({
|
|
webConsoleClient: aWebConsoleClient,
|
|
debuggerClient: client
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
return deferred.promise;
|
|
},
|
|
|
|
/**
|
|
* Attach to this tab.
|
|
*
|
|
* @param object aSubject
|
|
* The tab or window to obtain the connection for.
|
|
* @return Promise
|
|
* The promise for the TabTarget for this tab.
|
|
*/
|
|
_attach: function ST__attach(aSubject)
|
|
{
|
|
let target = TargetFactory.forTab(this._tab);
|
|
target.once("close", () => {
|
|
if (scratchpadTargets) {
|
|
scratchpadTargets.delete(aSubject);
|
|
}
|
|
});
|
|
return target.makeRemote().then(() => target);
|
|
},
|
|
};
|
|
|
|
|
|
/**
|
|
* Represents the DebuggerClient connection to a specific window as used by the
|
|
* Scratchpad.
|
|
*/
|
|
function ScratchpadWindow() {}
|
|
|
|
ScratchpadWindow.consoleFor = ScratchpadTab.consoleFor;
|
|
|
|
ScratchpadWindow.prototype = Heritage.extend(ScratchpadTab.prototype, {
|
|
/**
|
|
* Attach to this window.
|
|
*
|
|
* @return Promise
|
|
* The promise for the target for this window.
|
|
*/
|
|
_attach: function SW__attach()
|
|
{
|
|
if (!DebuggerServer.initialized) {
|
|
DebuggerServer.init();
|
|
DebuggerServer.addBrowserActors();
|
|
}
|
|
DebuggerServer.allowChromeProcess = true;
|
|
|
|
let client = new DebuggerClient(DebuggerServer.connectPipe());
|
|
return client.connect()
|
|
.then(() => client.getProcess())
|
|
.then(aResponse => {
|
|
return { form: aResponse.form, client: client };
|
|
});
|
|
}
|
|
});
|
|
|
|
|
|
function ScratchpadTarget(aTarget)
|
|
{
|
|
this._target = aTarget;
|
|
}
|
|
|
|
ScratchpadTarget.consoleFor = ScratchpadTab.consoleFor;
|
|
|
|
ScratchpadTarget.prototype = Heritage.extend(ScratchpadTab.prototype, {
|
|
_attach: function ST__attach()
|
|
{
|
|
if (this._target.isRemote) {
|
|
return promise.resolve(this._target);
|
|
}
|
|
return this._target.makeRemote().then(() => this._target);
|
|
}
|
|
});
|
|
|
|
|
|
/**
|
|
* Encapsulates management of the sidebar containing the VariablesView for
|
|
* object inspection.
|
|
*/
|
|
function ScratchpadSidebar(aScratchpad)
|
|
{
|
|
// Make sure to decorate this object. ToolSidebar requires the parent
|
|
// panel to support event (emit) API.
|
|
EventEmitter.decorate(this);
|
|
|
|
let ToolSidebar = require("devtools/client/framework/sidebar").ToolSidebar;
|
|
let tabbox = document.querySelector("#scratchpad-sidebar");
|
|
this._sidebar = new ToolSidebar(tabbox, this, "scratchpad");
|
|
this._scratchpad = aScratchpad;
|
|
}
|
|
|
|
ScratchpadSidebar.prototype = {
|
|
/*
|
|
* The ToolSidebar for this sidebar.
|
|
*/
|
|
_sidebar: null,
|
|
|
|
/*
|
|
* The VariablesView for this sidebar.
|
|
*/
|
|
variablesView: null,
|
|
|
|
/*
|
|
* Whether the sidebar is currently shown.
|
|
*/
|
|
visible: false,
|
|
|
|
/**
|
|
* Open the sidebar, if not open already, and populate it with the properties
|
|
* of the given object.
|
|
*
|
|
* @param string aString
|
|
* The string that was evaluated.
|
|
* @param object aObject
|
|
* The object to inspect, which is the aEvalString evaluation result.
|
|
* @return Promise
|
|
* A promise that will resolve once the sidebar is open.
|
|
*/
|
|
open: function SS_open(aEvalString, aObject)
|
|
{
|
|
this.show();
|
|
|
|
let deferred = promise.defer();
|
|
|
|
let onTabReady = () => {
|
|
if (this.variablesView) {
|
|
this.variablesView.controller.releaseActors();
|
|
}
|
|
else {
|
|
let window = this._sidebar.getWindowForTab("variablesview");
|
|
let container = window.document.querySelector("#variables");
|
|
|
|
this.variablesView = new VariablesView(container, {
|
|
searchEnabled: true,
|
|
searchPlaceholder: this._scratchpad.strings
|
|
.GetStringFromName("propertiesFilterPlaceholder")
|
|
});
|
|
|
|
VariablesViewController.attach(this.variablesView, {
|
|
getEnvironmentClient: aGrip => {
|
|
return new EnvironmentClient(this._scratchpad.debuggerClient, aGrip);
|
|
},
|
|
getObjectClient: aGrip => {
|
|
return new ObjectClient(this._scratchpad.debuggerClient, aGrip);
|
|
},
|
|
getLongStringClient: aActor => {
|
|
return this._scratchpad.webConsoleClient.longString(aActor);
|
|
},
|
|
releaseActor: aActor => {
|
|
this._scratchpad.debuggerClient.release(aActor);
|
|
}
|
|
});
|
|
}
|
|
this._update(aObject).then(() => deferred.resolve());
|
|
};
|
|
|
|
if (this._sidebar.getCurrentTabID() == "variablesview") {
|
|
onTabReady();
|
|
}
|
|
else {
|
|
this._sidebar.once("variablesview-ready", onTabReady);
|
|
this._sidebar.addTab("variablesview", VARIABLES_VIEW_URL, {selected: true});
|
|
}
|
|
|
|
return deferred.promise;
|
|
},
|
|
|
|
/**
|
|
* Show the sidebar.
|
|
*/
|
|
show: function SS_show()
|
|
{
|
|
if (!this.visible) {
|
|
this.visible = true;
|
|
this._sidebar.show();
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Hide the sidebar.
|
|
*/
|
|
hide: function SS_hide()
|
|
{
|
|
if (this.visible) {
|
|
this.visible = false;
|
|
this._sidebar.hide();
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Destroy the sidebar.
|
|
*
|
|
* @return Promise
|
|
* The promise that resolves when the sidebar is destroyed.
|
|
*/
|
|
destroy: function SS_destroy()
|
|
{
|
|
if (this.variablesView) {
|
|
this.variablesView.controller.releaseActors();
|
|
this.variablesView = null;
|
|
}
|
|
return this._sidebar.destroy();
|
|
},
|
|
|
|
/**
|
|
* Update the object currently inspected by the sidebar.
|
|
*
|
|
* @param any aValue
|
|
* The JS value to inspect in the sidebar.
|
|
* @return Promise
|
|
* A promise that resolves when the update completes.
|
|
*/
|
|
_update: function SS__update(aValue)
|
|
{
|
|
let options, onlyEnumVisible;
|
|
if (VariablesView.isPrimitive({ value: aValue })) {
|
|
options = { rawObject: { value: aValue } };
|
|
onlyEnumVisible = true;
|
|
} else {
|
|
options = { objectActor: aValue };
|
|
onlyEnumVisible = false;
|
|
}
|
|
let view = this.variablesView;
|
|
view.onlyEnumVisible = onlyEnumVisible;
|
|
view.empty();
|
|
return view.controller.setSingleVariable(options).expanded;
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Report an error coming over the remote debugger protocol.
|
|
*
|
|
* @param string aAction
|
|
* The name of the action or method that failed.
|
|
* @param object aResponse
|
|
* The response packet that contains the error.
|
|
*/
|
|
function reportError(aAction, aResponse)
|
|
{
|
|
console.error(aAction + " failed: " + aResponse.error + " " +
|
|
aResponse.message);
|
|
}
|
|
|
|
|
|
/**
|
|
* The PreferenceObserver listens for preference changes while Scratchpad is
|
|
* running.
|
|
*/
|
|
var PreferenceObserver = {
|
|
_initialized: false,
|
|
|
|
init: function PO_init()
|
|
{
|
|
if (this._initialized) {
|
|
return;
|
|
}
|
|
|
|
this.branch = Services.prefs.getBranch("devtools.scratchpad.");
|
|
this.branch.addObserver("", this, false);
|
|
this._initialized = true;
|
|
},
|
|
|
|
observe: function PO_observe(aMessage, aTopic, aData)
|
|
{
|
|
if (aTopic != "nsPref:changed") {
|
|
return;
|
|
}
|
|
|
|
if (aData == "recentFilesMax") {
|
|
Scratchpad.handleRecentFileMaxChange();
|
|
}
|
|
else if (aData == "recentFilePaths") {
|
|
Scratchpad.populateRecentFilesMenu();
|
|
}
|
|
},
|
|
|
|
uninit: function PO_uninit() {
|
|
if (!this.branch) {
|
|
return;
|
|
}
|
|
|
|
this.branch.removeObserver("", this);
|
|
this.branch = null;
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* The CloseObserver listens for the last browser window closing and attempts to
|
|
* close the Scratchpad.
|
|
*/
|
|
var CloseObserver = {
|
|
init: function CO_init()
|
|
{
|
|
Services.obs.addObserver(this, "browser-lastwindow-close-requested", false);
|
|
},
|
|
|
|
observe: function CO_observe(aSubject)
|
|
{
|
|
if (Scratchpad.close()) {
|
|
this.uninit();
|
|
}
|
|
else {
|
|
aSubject.QueryInterface(Ci.nsISupportsPRBool);
|
|
aSubject.data = true;
|
|
}
|
|
},
|
|
|
|
uninit: function CO_uninit()
|
|
{
|
|
// Will throw exception if removeObserver is called twice.
|
|
if (this._uninited) {
|
|
return;
|
|
}
|
|
|
|
this._uninited = true;
|
|
Services.obs.removeObserver(this, "browser-lastwindow-close-requested",
|
|
false);
|
|
},
|
|
};
|
|
|
|
XPCOMUtils.defineLazyGetter(Scratchpad, "strings", function () {
|
|
return Services.strings.createBundle(SCRATCHPAD_L10N);
|
|
});
|
|
|
|
addEventListener("load", Scratchpad.onLoad.bind(Scratchpad), false);
|
|
addEventListener("unload", Scratchpad.onUnload.bind(Scratchpad), false);
|
|
addEventListener("close", Scratchpad.onClose.bind(Scratchpad), false);
|