Source code
Revision control
Copy as Markdown
Other Tools
/* 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
"use strict";
const osString = Services.appinfo.OS;
// Panels
loader.lazyGetter(
this,
"OptionsPanel",
() =>
.OptionsPanel
);
loader.lazyGetter(
this,
"InspectorPanel",
);
loader.lazyGetter(
this,
"WebConsolePanel",
() =>
);
loader.lazyGetter(
this,
"DebuggerPanel",
);
loader.lazyGetter(
this,
"StyleEditorPanel",
() =>
);
loader.lazyGetter(
this,
"MemoryPanel",
);
loader.lazyGetter(
this,
"NewPerformancePanel",
() =>
.PerformancePanel
);
loader.lazyGetter(
this,
"NetMonitorPanel",
() =>
);
loader.lazyGetter(
this,
"StoragePanel",
);
loader.lazyGetter(
this,
"DomPanel",
);
loader.lazyGetter(
this,
"AccessibilityPanel",
() =>
.AccessibilityPanel
);
loader.lazyGetter(
this,
"ApplicationPanel",
() =>
);
// Other dependencies
loader.lazyRequireGetter(
this,
"ResponsiveUIManager",
);
const lazy = {};
ChromeUtils.defineESModuleGetters(lazy, {
});
loader.lazyRequireGetter(
this,
"DevToolsExperimentalPrefs",
);
loader.lazyRequireGetter(
this,
"captureAndSaveScreenshot",
true
);
const L10N = new LocalizationHelper(
"devtools/client/locales/startup.properties"
);
const CommandKeys = new Localization(
["devtools/startup/key-shortcuts.ftl"],
true
);
var Tools = {};
exports.Tools = Tools;
// Definitions
Tools.options = {
id: "options",
ordinal: 0,
bgTheme: "theme-body",
label: l10n("options.label"),
iconOnly: true,
panelLabel: l10n("options.panelLabel"),
tooltip: l10n("optionsButton.tooltip"),
inMenu: false,
isToolSupported() {
return true;
},
build(iframeWindow, toolbox, commands) {
return new OptionsPanel(iframeWindow, toolbox, commands);
},
};
Tools.inspector = {
id: "inspector",
accesskey: l10n("inspector.accesskey"),
ordinal: 1,
label: l10n("inspector.label"),
panelLabel: l10n("inspector.panelLabel"),
get tooltip() {
const key = commandkey("devtools-commandkey-inspector");
if (osString == "Darwin") {
const cmdShiftC = "Cmd+Shift+" + key;
const cmdOptC = "Cmd+Opt+" + key;
return l10n("inspector.mac.tooltip", cmdShiftC, cmdOptC);
}
const ctrlShiftC = "Ctrl+Shift+" + key;
return l10n("inspector.tooltip2", ctrlShiftC);
},
inMenu: false,
preventClosingOnKey: true,
// preventRaisingOnKey is used to keep the focus on the content window for shortcuts
// that trigger the element picker.
preventRaisingOnKey: true,
onkey(panel, toolbox) {
if (
Services.prefs.getBoolPref("devtools.command-button-pick.enabled", false)
) {
toolbox.nodePicker.togglePicker();
}
},
isToolSupported(toolbox) {
return toolbox.target.hasActor("inspector");
},
build(iframeWindow, toolbox, commands) {
return new InspectorPanel(iframeWindow, toolbox, commands);
},
};
Tools.webConsole = {
id: "webconsole",
accesskey: l10n("webConsoleCmd.accesskey"),
ordinal: 2,
label: l10n("ToolboxTabWebconsole.label"),
menuLabel: l10n("MenuWebconsole.label"),
panelLabel: l10n("ToolboxWebConsole.panelLabel"),
get tooltip() {
return l10n(
"ToolboxWebconsole.tooltip2",
(osString == "Darwin" ? "Cmd+Opt+" : "Ctrl+Shift+") +
commandkey("devtools-commandkey-webconsole")
);
},
inMenu: false,
preventClosingOnKey: true,
onkey(panel, toolbox) {
if (toolbox.splitConsole) {
return toolbox.focusConsoleInput();
}
panel.focusInput();
return undefined;
},
isToolSupported() {
return true;
},
build(iframeWindow, toolbox, commands) {
return new WebConsolePanel(iframeWindow, toolbox, commands);
},
};
Tools.jsdebugger = {
id: "jsdebugger",
accesskey: l10n("debuggerMenu.accesskey"),
ordinal: 3,
label: l10n("ToolboxDebugger.label"),
panelLabel: l10n("ToolboxDebugger.panelLabel"),
get tooltip() {
return l10n(
"ToolboxDebugger.tooltip4",
(osString == "Darwin" ? "Cmd+Opt+" : "Ctrl+Shift+") +
commandkey("devtools-commandkey-jsdebugger")
);
},
inMenu: false,
isToolSupported() {
return true;
},
build(iframeWindow, toolbox, commands) {
return new DebuggerPanel(iframeWindow, toolbox, commands);
},
};
Tools.styleEditor = {
id: "styleeditor",
ordinal: 5,
visibilityswitch: "devtools.styleeditor.enabled",
accesskey: l10n("open.accesskey"),
label: l10n("ToolboxStyleEditor.label"),
panelLabel: l10n("ToolboxStyleEditor.panelLabel"),
get tooltip() {
return l10n(
"ToolboxStyleEditor.tooltip3",
"Shift+" + functionkey(commandkey("devtools-commandkey-styleeditor"))
);
},
inMenu: false,
isToolSupported(toolbox) {
return toolbox.target.hasActor("styleSheets");
},
build(iframeWindow, toolbox, commands) {
return new StyleEditorPanel(iframeWindow, toolbox, commands);
},
};
Tools.performance = {
id: "performance",
ordinal: 6,
visibilityswitch: "devtools.performance.enabled",
label: l10n("performance.label"),
panelLabel: l10n("performance.panelLabel"),
get tooltip() {
return l10n(
"performance.tooltip",
"Shift+" + functionkey(commandkey("devtools-commandkey-performance"))
);
},
accesskey: l10n("performance.accesskey"),
inMenu: false,
isToolSupported(toolbox) {
// Only use the new performance panel on local tab toolboxes, as they are guaranteed
// to have a performance actor.
// Remote tab toolboxes (eg about:devtools-toolbox from about:debugging) should not
// use the performance panel; about:debugging provides a "Profile performance" button
// which can be used instead, without having the overhead of starting a remote toolbox.
// Also accept the Browser Toolbox, so that we can profile its process via a second browser toolbox.
return (
toolbox.commands.descriptorFront.isLocalTab || toolbox.isBrowserToolbox
);
},
build(frame, toolbox, commands) {
return new NewPerformancePanel(frame, toolbox, commands);
},
};
Tools.memory = {
id: "memory",
ordinal: 7,
visibilityswitch: "devtools.memory.enabled",
label: l10n("memory.label"),
panelLabel: l10n("memory.panelLabel"),
tooltip: l10n("memory.tooltip"),
isToolSupported(toolbox) {
const { descriptorFront } = toolbox.commands;
return (
!descriptorFront.isWebExtensionDescriptor &&
!descriptorFront.isWorkerDescriptor
);
},
build(frame, toolbox, commands) {
return new MemoryPanel(frame, toolbox, commands);
},
};
Tools.netMonitor = {
id: "netmonitor",
accesskey: l10n("netmonitor.accesskey"),
ordinal: 4,
visibilityswitch: "devtools.netmonitor.enabled",
label: l10n("netmonitor.label"),
panelLabel: l10n("netmonitor.panelLabel"),
get tooltip() {
return l10n(
"netmonitor.tooltip2",
(osString == "Darwin" ? "Cmd+Opt+" : "Ctrl+Shift+") +
commandkey("devtools-commandkey-netmonitor")
);
},
inMenu: false,
isToolSupported(toolbox) {
return (
toolbox.target.getTrait("networkMonitor") &&
!toolbox.target.isWorkerTarget
);
},
build(iframeWindow, toolbox, commands) {
return new NetMonitorPanel(iframeWindow, toolbox, commands);
},
};
Tools.storage = {
id: "storage",
ordinal: 8,
accesskey: l10n("storage.accesskey"),
visibilityswitch: "devtools.storage.enabled",
label: l10n("storage.label"),
menuLabel: l10n("storage.menuLabel"),
panelLabel: l10n("storage.panelLabel"),
get tooltip() {
return l10n(
"storage.tooltip3",
"Shift+" + functionkey(commandkey("devtools-commandkey-storage"))
);
},
inMenu: false,
isToolSupported(toolbox) {
const { descriptorFront } = toolbox.commands;
// Storage is available on all contexts debugging a BrowsingContext.
// As of today, this is all but worker toolboxes.
return (
descriptorFront.isTabDescriptor ||
descriptorFront.isParentProcessDescriptor ||
descriptorFront.isWebExtensionDescriptor
);
},
build(iframeWindow, toolbox, commands) {
return new StoragePanel(iframeWindow, toolbox, commands);
},
};
Tools.dom = {
id: "dom",
accesskey: l10n("dom.accesskey"),
ordinal: 11,
visibilityswitch: "devtools.dom.enabled",
label: l10n("dom.label"),
panelLabel: l10n("dom.panelLabel"),
get tooltip() {
return l10n(
"dom.tooltip",
(osString == "Darwin" ? "Cmd+Opt+" : "Ctrl+Shift+") +
commandkey("devtools-commandkey-dom")
);
},
inMenu: false,
isToolSupported() {
return true;
},
build(iframeWindow, toolbox, commands) {
return new DomPanel(iframeWindow, toolbox, commands);
},
};
Tools.accessibility = {
id: "accessibility",
accesskey: l10n("accessibility.accesskey"),
ordinal: 9,
modifiers: osString == "Darwin" ? "accel,alt" : "accel,shift",
visibilityswitch: "devtools.accessibility.enabled",
label: l10n("accessibility.label"),
panelLabel: l10n("accessibility.panelLabel"),
get tooltip() {
return l10n(
"accessibility.tooltip3",
"Shift+" +
functionkey(commandkey("devtools-commandkey-accessibility-f12"))
);
},
inMenu: false,
isToolSupported(toolbox) {
return toolbox.target.hasActor("accessibility");
},
build(iframeWindow, toolbox, commands) {
return new AccessibilityPanel(iframeWindow, toolbox, commands);
},
};
Tools.application = {
id: "application",
ordinal: 10,
visibilityswitch: "devtools.application.enabled",
label: l10n("application.label"),
panelLabel: l10n("application.panelLabel"),
tooltip: l10n("application.tooltip"),
inMenu: false,
isToolSupported(toolbox) {
return toolbox.target.hasActor("manifest");
},
build(iframeWindow, toolbox, commands) {
return new ApplicationPanel(iframeWindow, toolbox, commands);
},
};
var defaultTools = [
Tools.options,
Tools.webConsole,
Tools.inspector,
Tools.jsdebugger,
Tools.styleEditor,
Tools.performance,
Tools.netMonitor,
Tools.storage,
Tools.memory,
Tools.dom,
Tools.accessibility,
Tools.application,
];
exports.defaultTools = defaultTools;
Tools.darkTheme = {
id: "dark",
label: l10n("options.darkTheme.label2"),
ordinal: 1,
classList: ["theme-dark"],
};
Tools.lightTheme = {
id: "light",
label: l10n("options.lightTheme.label2"),
ordinal: 2,
classList: ["theme-light"],
};
exports.defaultThemes = [Tools.darkTheme, Tools.lightTheme];
// List buttons that can be toggled to prevent adding prefs for
// addons that have manually inserted toolbarbuttons into DOM.
// (By default, supported target is only local tab)
exports.ToolboxButtons = [
{
id: "command-button-experimental-prefs",
description: "DevTools Experimental preferences",
isToolSupported: () => !lazy.AppConstants.MOZILLA_OFFICIAL,
onClick: (event, toolbox) => DevToolsExperimentalPrefs.showTooltip(toolbox),
isChecked: () => DevToolsExperimentalPrefs.isAnyPreferenceEnabled(),
},
{
id: "command-button-responsive",
description: l10n(
"toolbox.buttons.responsive",
osString == "Darwin" ? "Cmd+Opt+M" : "Ctrl+Shift+M"
),
isToolSupported: toolbox => toolbox.commands.descriptorFront.isLocalTab,
onClick(event, toolbox) {
const { localTab } = toolbox.commands.descriptorFront;
const browserWindow = localTab.ownerDocument.defaultView;
ResponsiveUIManager.toggle(browserWindow, localTab, {
trigger: "toolbox",
});
},
isChecked(toolbox) {
const { localTab } = toolbox.commands.descriptorFront;
if (!localTab) {
return false;
}
return ResponsiveUIManager.isActiveForTab(localTab);
},
isToggle: true,
setup(toolbox, onChange) {
ResponsiveUIManager.on("on", onChange);
ResponsiveUIManager.on("off", onChange);
},
teardown(toolbox, onChange) {
ResponsiveUIManager.off("on", onChange);
ResponsiveUIManager.off("off", onChange);
},
},
{
id: "command-button-screenshot",
description: l10n("toolbox.buttons.screenshot"),
isToolSupported: toolbox => {
return (
// @backward-compat { version 87 } We need to check for the screenshot actor as well
// when connecting to older server that does not have the screenshotContentActor
toolbox.target.hasActor("screenshotContent") ||
toolbox.target.hasActor("screenshot")
);
},
async onClick(event, toolbox) {
// Special case for screenshot button to check for clipboard preference
const clipboardEnabled = Services.prefs.getBoolPref(
"devtools.screenshot.clipboard.enabled"
);
// When screenshot to clipboard is enabled disabling saving to file
const args = {
fullpage: true,
file: !clipboardEnabled,
clipboard: clipboardEnabled,
};
const messages = await captureAndSaveScreenshot(
toolbox.target,
toolbox.win,
args
);
const notificationBox = toolbox.getNotificationBox();
const priorityMap = {
error: notificationBox.PRIORITY_CRITICAL_HIGH,
warn: notificationBox.PRIORITY_WARNING_HIGH,
};
for (const { text, level } of messages) {
// captureAndSaveScreenshot returns "saved" messages, that indicate where the
// screenshot was saved. In regular toolbox, we don't want to display them as
// the download UI can be used to open them.
// But in the browser toolbox, we can't see the download UI, so we'll display the
// saved message so the user knows there the file was saved.
if (
!toolbox.isBrowserToolbox &&
level !== "warn" &&
level !== "error"
) {
continue;
}
notificationBox.appendNotification(
text,
null,
null,
priorityMap[level] || notificationBox.PRIORITY_INFO_MEDIUM
);
}
},
},
createHighlightButton(
["RulersHighlighter", "ViewportSizeHighlighter"],
"rulers"
),
createHighlightButton(["MeasuringToolHighlighter"], "measure"),
];
function createHighlightButton(highlighters, id) {
return {
id: `command-button-${id}`,
description: l10n(`toolbox.buttons.${id}`),
isToolSupported: toolbox =>
toolbox.commands.descriptorFront.isTabDescriptor,
async onClick(event, toolbox) {
const inspectorFront = await toolbox.target.getFront("inspector");
await Promise.all(
highlighters.map(async name => {
const highlighter = await inspectorFront.getOrCreateHighlighterByType(
name
);
if (highlighter.isShown()) {
await highlighter.hide();
} else {
await highlighter.show();
}
})
);
},
isChecked(toolbox) {
// if the inspector doesn't exist, then the highlighter has not yet been connected
// to the front end.
const inspectorFront = toolbox.target.getCachedFront("inspector");
if (!inspectorFront) {
// initialize the inspector front asyncronously. There is a potential for buggy
// behavior here, but we need to change how the buttons get data (have them
// consume data from reducers rather than writing our own version) in order to
// fix this properly.
return false;
}
return highlighters.every(name =>
inspectorFront.getKnownHighlighter(name)?.isShown()
);
},
isToggle: true,
};
}
/**
* Lookup l10n string from a string bundle.
*
* @param {string} name
* The key to lookup.
* @param {...string} args
* Optional format argument.
* @returns A localized version of the given key.
*/
function l10n(name, ...args) {
try {
return args ? L10N.getFormatStr(name, ...args) : L10N.getStr(name);
} catch (ex) {
console.log("Error reading '" + name + "'");
throw new Error("l10n error with " + name);
}
}
function commandkey(name) {
try {
return CommandKeys.formatValueSync(name);
} catch (ex) {
console.log("Error reading '" + name + "'");
throw new Error("l10n error with " + name);
}
}
function functionkey(shortkey) {
return shortkey.split("_")[1];
}