forked from mirrors/gecko-dev
1efc237714
This actor was only used by the legacy listener. Its main method was listStores which exposed all the storage type actors. Now they are exposed via storage Resource watchers. This requires to tweak the decision making to show the storage panel as the actor no longer exists... Unfortunately we can't check for resource traits on the watcher actor as the browser toolbox on older runtime won't expose it. Note that this.front wasn't used for a little while in ui.js. I had to keep a few things in the frontend in order to still be able to connect to old servers. But I put lots of comments to do proper cleanup later. Differential Revision: https://phabricator.services.mozilla.com/D166770
653 lines
18 KiB
JavaScript
653 lines
18 KiB
JavaScript
/* 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/. */
|
|
|
|
"use strict";
|
|
|
|
const osString = Services.appinfo.OS;
|
|
|
|
// Panels
|
|
loader.lazyGetter(
|
|
this,
|
|
"OptionsPanel",
|
|
() =>
|
|
require("resource://devtools/client/framework/toolbox-options.js")
|
|
.OptionsPanel
|
|
);
|
|
loader.lazyGetter(
|
|
this,
|
|
"InspectorPanel",
|
|
() => require("resource://devtools/client/inspector/panel.js").InspectorPanel
|
|
);
|
|
loader.lazyGetter(
|
|
this,
|
|
"WebConsolePanel",
|
|
() =>
|
|
require("resource://devtools/client/webconsole/panel.js").WebConsolePanel
|
|
);
|
|
loader.lazyGetter(
|
|
this,
|
|
"DebuggerPanel",
|
|
() => require("resource://devtools/client/debugger/panel.js").DebuggerPanel
|
|
);
|
|
loader.lazyGetter(
|
|
this,
|
|
"StyleEditorPanel",
|
|
() =>
|
|
require("resource://devtools/client/styleeditor/panel.js").StyleEditorPanel
|
|
);
|
|
loader.lazyGetter(
|
|
this,
|
|
"MemoryPanel",
|
|
() => require("resource://devtools/client/memory/panel.js").MemoryPanel
|
|
);
|
|
loader.lazyGetter(
|
|
this,
|
|
"NewPerformancePanel",
|
|
() =>
|
|
require("resource://devtools/client/performance-new/panel.js")
|
|
.PerformancePanel
|
|
);
|
|
loader.lazyGetter(
|
|
this,
|
|
"NetMonitorPanel",
|
|
() =>
|
|
require("resource://devtools/client/netmonitor/panel.js").NetMonitorPanel
|
|
);
|
|
loader.lazyGetter(
|
|
this,
|
|
"StoragePanel",
|
|
() => require("resource://devtools/client/storage/panel.js").StoragePanel
|
|
);
|
|
loader.lazyGetter(
|
|
this,
|
|
"DomPanel",
|
|
() => require("resource://devtools/client/dom/panel.js").DomPanel
|
|
);
|
|
loader.lazyGetter(
|
|
this,
|
|
"AccessibilityPanel",
|
|
() =>
|
|
require("resource://devtools/client/accessibility/panel.js")
|
|
.AccessibilityPanel
|
|
);
|
|
loader.lazyGetter(
|
|
this,
|
|
"ApplicationPanel",
|
|
() =>
|
|
require("resource://devtools/client/application/panel.js").ApplicationPanel
|
|
);
|
|
|
|
// Other dependencies
|
|
loader.lazyRequireGetter(
|
|
this,
|
|
"ResponsiveUIManager",
|
|
"resource://devtools/client/responsive/manager.js"
|
|
);
|
|
|
|
const lazy = {};
|
|
ChromeUtils.defineESModuleGetters(lazy, {
|
|
AppConstants: "resource://gre/modules/AppConstants.sys.mjs",
|
|
});
|
|
loader.lazyRequireGetter(
|
|
this,
|
|
"DevToolsExperimentalPrefs",
|
|
"resource://devtools/client/devtools-experimental-prefs.js"
|
|
);
|
|
loader.lazyRequireGetter(
|
|
this,
|
|
"captureAndSaveScreenshot",
|
|
"resource://devtools/client/shared/screenshot.js",
|
|
true
|
|
);
|
|
|
|
const { LocalizationHelper } = require("resource://devtools/shared/l10n.js");
|
|
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,
|
|
url: "chrome://devtools/content/framework/toolbox-options.html",
|
|
icon: "chrome://devtools/skin/images/settings.svg",
|
|
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,
|
|
icon: "chrome://devtools/skin/images/tool-inspector.svg",
|
|
url: "chrome://devtools/content/inspector/index.xhtml",
|
|
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) {
|
|
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,
|
|
url: "chrome://devtools/content/webconsole/index.html",
|
|
icon: "chrome://devtools/skin/images/tool-webconsole.svg",
|
|
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,
|
|
icon: "chrome://devtools/skin/images/tool-debugger.svg",
|
|
url: "chrome://devtools/content/debugger/index.html",
|
|
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"),
|
|
icon: "chrome://devtools/skin/images/tool-styleeditor.svg",
|
|
url: "chrome://devtools/content/styleeditor/index.xhtml",
|
|
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,
|
|
icon: "chrome://devtools/skin/images/tool-profiler.svg",
|
|
url: "chrome://devtools/content/performance-new/index.xhtml",
|
|
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,
|
|
icon: "chrome://devtools/skin/images/tool-memory.svg",
|
|
url: "chrome://devtools/content/memory/index.xhtml",
|
|
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",
|
|
icon: "chrome://devtools/skin/images/tool-network.svg",
|
|
url: "chrome://devtools/content/netmonitor/index.html",
|
|
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",
|
|
icon: "chrome://devtools/skin/images/tool-storage.svg",
|
|
url: "chrome://devtools/content/storage/index.xhtml",
|
|
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",
|
|
icon: "chrome://devtools/skin/images/tool-dom.svg",
|
|
url: "chrome://devtools/content/dom/index.html",
|
|
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",
|
|
icon: "chrome://devtools/skin/images/tool-accessibility.svg",
|
|
url: "chrome://devtools/content/accessibility/index.html",
|
|
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",
|
|
icon: "chrome://devtools/skin/images/tool-application.svg",
|
|
url: "chrome://devtools/content/application/index.html",
|
|
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,
|
|
stylesheets: ["chrome://devtools/skin/dark-theme.css"],
|
|
classList: ["theme-dark"],
|
|
};
|
|
|
|
Tools.lightTheme = {
|
|
id: "light",
|
|
label: l10n("options.lightTheme.label2"),
|
|
ordinal: 2,
|
|
stylesheets: ["chrome://devtools/skin/light-theme.css"],
|
|
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);
|
|
},
|
|
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", "rulers"),
|
|
createHighlightButton("MeasuringToolHighlighter", "measure"),
|
|
];
|
|
|
|
function createHighlightButton(highlighterName, 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");
|
|
const highlighter = await inspectorFront.getOrCreateHighlighterByType(
|
|
highlighterName
|
|
);
|
|
if (highlighter.isShown()) {
|
|
return highlighter.hide();
|
|
}
|
|
|
|
return 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;
|
|
}
|
|
const highlighter = inspectorFront.getKnownHighlighter(highlighterName);
|
|
return highlighter && highlighter.isShown();
|
|
},
|
|
};
|
|
}
|
|
|
|
/**
|
|
* 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];
|
|
}
|