From 6bf0a5cb5034a7e684dcc3500e841785237ce2dd Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 19:32:43 +0200 Subject: Adding upstream version 1:115.7.0. Signed-off-by: Daniel Baumann --- .../extensions/parent/ext-sidebarAction.js | 532 +++++++++++++++++++++ 1 file changed, 532 insertions(+) create mode 100644 browser/components/extensions/parent/ext-sidebarAction.js (limited to 'browser/components/extensions/parent/ext-sidebarAction.js') diff --git a/browser/components/extensions/parent/ext-sidebarAction.js b/browser/components/extensions/parent/ext-sidebarAction.js new file mode 100644 index 0000000000..a07f9a9f0e --- /dev/null +++ b/browser/components/extensions/parent/ext-sidebarAction.js @@ -0,0 +1,532 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +/* 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"; + +var { ExtensionParent } = ChromeUtils.importESModule( + "resource://gre/modules/ExtensionParent.sys.mjs" +); + +var { ExtensionError } = ExtensionUtils; + +var { IconDetails } = ExtensionParent; + +// WeakMap[Extension -> SidebarAction] +let sidebarActionMap = new WeakMap(); + +const sidebarURL = "chrome://browser/content/webext-panels.xhtml"; + +/** + * Responsible for the sidebar_action section of the manifest as well + * as the associated sidebar browser. + */ +this.sidebarAction = class extends ExtensionAPI { + static for(extension) { + return sidebarActionMap.get(extension); + } + + onManifestEntry(entryName) { + let { extension } = this; + + extension.once("ready", this.onReady.bind(this)); + + let options = extension.manifest.sidebar_action; + + // Add the extension to the sidebar menu. The sidebar widget will copy + // from that when it is viewed, so we shouldn't need to update that. + let widgetId = makeWidgetId(extension.id); + this.id = `${widgetId}-sidebar-action`; + this.menuId = `menu_${this.id}`; + this.buttonId = `button_${this.id}`; + + this.browserStyle = options.browser_style; + + this.defaults = { + enabled: true, + title: options.default_title || extension.name, + icon: IconDetails.normalize({ path: options.default_icon }, extension), + panel: options.default_panel || "", + }; + this.globals = Object.create(this.defaults); + + this.tabContext = new TabContext(target => { + let window = target.ownerGlobal; + if (target === window) { + return this.globals; + } + return this.tabContext.get(window); + }); + + // We need to ensure our elements are available before session restore. + this.windowOpenListener = window => { + this.createMenuItem(window, this.globals); + }; + windowTracker.addOpenListener(this.windowOpenListener); + + this.updateHeader = event => { + let window = event.target.ownerGlobal; + let details = this.tabContext.get(window.gBrowser.selectedTab); + let header = window.document.getElementById("sidebar-switcher-target"); + if (window.SidebarUI.currentID === this.id) { + this.setMenuIcon(header, details); + } + }; + + this.windowCloseListener = window => { + let header = window.document.getElementById("sidebar-switcher-target"); + if (header) { + header.removeEventListener("SidebarShown", this.updateHeader); + } + }; + windowTracker.addCloseListener(this.windowCloseListener); + + sidebarActionMap.set(extension, this); + } + + onReady() { + this.build(); + } + + onShutdown(isAppShutdown) { + sidebarActionMap.delete(this.this); + + this.tabContext.shutdown(); + + // Don't remove everything on app shutdown so session restore can handle + // restoring open sidebars. + if (isAppShutdown) { + return; + } + + for (let window of windowTracker.browserWindows()) { + let { document, SidebarUI } = window; + if (SidebarUI.currentID === this.id) { + SidebarUI.hide(); + } + let menu = document.getElementById(this.menuId); + if (menu) { + menu.remove(); + } + let button = document.getElementById(this.buttonId); + if (button) { + button.remove(); + } + let header = document.getElementById("sidebar-switcher-target"); + header.removeEventListener("SidebarShown", this.updateHeader); + SidebarUI.sidebars.delete(this.id); + } + windowTracker.removeOpenListener(this.windowOpenListener); + windowTracker.removeCloseListener(this.windowCloseListener); + } + + static onUninstall(id) { + const sidebarId = `${makeWidgetId(id)}-sidebar-action`; + for (let window of windowTracker.browserWindows()) { + let { SidebarUI } = window; + if (SidebarUI.lastOpenedId === sidebarId) { + SidebarUI.lastOpenedId = null; + } + } + } + + build() { + // eslint-disable-next-line mozilla/balanced-listeners + this.tabContext.on("tab-select", (evt, tab) => { + this.updateWindow(tab.ownerGlobal); + }); + + let install = this.extension.startupReason === "ADDON_INSTALL"; + for (let window of windowTracker.browserWindows()) { + this.updateWindow(window); + let { SidebarUI } = window; + if ( + (install && this.extension.manifest.sidebar_action.open_at_install) || + SidebarUI.lastOpenedId == this.id + ) { + SidebarUI.show(this.id); + } + } + } + + createMenuItem(window, details) { + if (!this.extension.canAccessWindow(window)) { + return; + } + let { document, SidebarUI } = window; + let keyId = `ext-key-id-${this.id}`; + + SidebarUI.sidebars.set(this.id, { + title: details.title, + url: sidebarURL, + menuId: this.menuId, + buttonId: this.buttonId, + // The following properties are specific to extensions + extensionId: this.extension.id, + panel: details.panel, + browserStyle: this.browserStyle, + }); + + let header = document.getElementById("sidebar-switcher-target"); + header.addEventListener("SidebarShown", this.updateHeader); + + // Insert a menuitem for View->Show Sidebars. + let menuitem = document.createXULElement("menuitem"); + menuitem.setAttribute("id", this.menuId); + menuitem.setAttribute("type", "checkbox"); + menuitem.setAttribute("label", details.title); + menuitem.setAttribute("oncommand", `SidebarUI.toggle("${this.id}");`); + menuitem.setAttribute("class", "menuitem-iconic webextension-menuitem"); + menuitem.setAttribute("key", keyId); + this.setMenuIcon(menuitem, details); + + // Insert a toolbarbutton for the sidebar dropdown selector. + let toolbarbutton = document.createXULElement("toolbarbutton"); + toolbarbutton.setAttribute("id", this.buttonId); + toolbarbutton.setAttribute("label", details.title); + toolbarbutton.setAttribute("oncommand", `SidebarUI.show("${this.id}");`); + toolbarbutton.setAttribute( + "class", + "subviewbutton subviewbutton-iconic webextension-menuitem" + ); + toolbarbutton.setAttribute("key", keyId); + this.setMenuIcon(toolbarbutton, details); + + document.getElementById("viewSidebarMenu").appendChild(menuitem); + let separator = document.getElementById("sidebar-extensions-separator"); + separator.parentNode.insertBefore(toolbarbutton, separator); + SidebarUI.updateShortcut({ button: toolbarbutton }); + + return menuitem; + } + + setMenuIcon(menuitem, details) { + let getIcon = size => + IconDetails.escapeUrl( + IconDetails.getPreferredIcon(details.icon, this.extension, size).icon + ); + + menuitem.setAttribute( + "style", + ` + --webextension-menuitem-image: url("${getIcon(16)}"); + --webextension-menuitem-image-2x: url("${getIcon(32)}"); + ` + ); + } + + /** + * Update the menu items with the tab context data in `tabData`. + * + * @param {ChromeWindow} window + * Browser chrome window. + * @param {object} tabData + * Tab specific sidebar configuration. + */ + updateButton(window, tabData) { + let { document, SidebarUI } = window; + let title = tabData.title || this.extension.name; + let menu = document.getElementById(this.menuId); + if (!menu) { + menu = this.createMenuItem(window, tabData); + } + + let urlChanged = tabData.panel !== SidebarUI.sidebars.get(this.id).panel; + if (urlChanged) { + SidebarUI.sidebars.get(this.id).panel = tabData.panel; + } + + menu.setAttribute("label", title); + this.setMenuIcon(menu, tabData); + + let button = document.getElementById(this.buttonId); + button.setAttribute("label", title); + this.setMenuIcon(button, tabData); + + // Update the sidebar if this extension is the current sidebar. + if (SidebarUI.currentID === this.id) { + SidebarUI.title = title; + let header = document.getElementById("sidebar-switcher-target"); + this.setMenuIcon(header, tabData); + if (SidebarUI.isOpen && urlChanged) { + SidebarUI.show(this.id); + } + } + } + + /** + * Update the menu items for a given window. + * + * @param {ChromeWindow} window + * Browser chrome window. + */ + updateWindow(window) { + if (!this.extension.canAccessWindow(window)) { + return; + } + let nativeTab = window.gBrowser.selectedTab; + this.updateButton(window, this.tabContext.get(nativeTab)); + } + + /** + * Update the menu items when the extension changes the icon, + * title, url, etc. If it only changes a parameter for a single tab, `target` + * will be that tab. If it only changes a parameter for a single window, + * `target` will be that window. Otherwise `target` will be null. + * + * @param {XULElement|ChromeWindow|null} target + * Browser tab or browser chrome window, may be null. + */ + updateOnChange(target) { + if (target) { + let window = target.ownerGlobal; + if (target === window || target.selected) { + this.updateWindow(window); + } + } else { + for (let window of windowTracker.browserWindows()) { + this.updateWindow(window); + } + } + } + + /** + * Gets the target object corresponding to the `details` parameter of the various + * get* and set* API methods. + * + * @param {object} details + * An object with optional `tabId` or `windowId` properties. + * @param {number} [details.tabId] + * The target tab. + * @param {number} [details.windowId] + * The target window. + * @throws if both `tabId` and `windowId` are specified, or if they are invalid. + * @returns {XULElement|ChromeWindow|null} + * If a `tabId` was specified, the corresponding XULElement tab. + * If a `windowId` was specified, the corresponding ChromeWindow. + * Otherwise, `null`. + */ + getTargetFromDetails({ tabId, windowId }) { + if (tabId != null && windowId != null) { + throw new ExtensionError( + "Only one of tabId and windowId can be specified." + ); + } + let target = null; + if (tabId != null) { + target = tabTracker.getTab(tabId); + if (!this.extension.canAccessWindow(target.ownerGlobal)) { + throw new ExtensionError(`Invalid tab ID: ${tabId}`); + } + } else if (windowId != null) { + target = windowTracker.getWindow(windowId); + if (!this.extension.canAccessWindow(target)) { + throw new ExtensionError(`Invalid window ID: ${windowId}`); + } + } + return target; + } + + /** + * Gets the data associated with a tab, window, or the global one. + * + * @param {XULElement|ChromeWindow|null} target + * A XULElement tab, a ChromeWindow, or null for the global data. + * @returns {object} + * The icon, title, panel, etc. associated with the target. + */ + getContextData(target) { + if (target) { + return this.tabContext.get(target); + } + return this.globals; + } + + /** + * Set a global, window specific or tab specific property. + * + * @param {XULElement|ChromeWindow|null} target + * A XULElement tab, a ChromeWindow, or null for the global data. + * @param {string} prop + * String property to set ["icon", "title", or "panel"]. + * @param {string} value + * Value for property. + */ + setProperty(target, prop, value) { + let values = this.getContextData(target); + if (value === null) { + delete values[prop]; + } else { + values[prop] = value; + } + + this.updateOnChange(target); + } + + /** + * Retrieve the value of a global, window specific or tab specific property. + * + * @param {XULElement|ChromeWindow|null} target + * A XULElement tab, a ChromeWindow, or null for the global data. + * @param {string} prop + * String property to retrieve ["icon", "title", or "panel"] + * @returns {string} value + * Value of prop. + */ + getProperty(target, prop) { + return this.getContextData(target)[prop]; + } + + setPropertyFromDetails(details, prop, value) { + return this.setProperty(this.getTargetFromDetails(details), prop, value); + } + + getPropertyFromDetails(details, prop) { + return this.getProperty(this.getTargetFromDetails(details), prop); + } + + /** + * Triggers this sidebar action for the given window, with the same effects as + * if it were toggled via menu or toolbarbutton by a user. + * + * @param {ChromeWindow} window + */ + triggerAction(window) { + let { SidebarUI } = window; + if (SidebarUI && this.extension.canAccessWindow(window)) { + SidebarUI.toggle(this.id); + } + } + + /** + * Opens this sidebar action for the given window. + * + * @param {ChromeWindow} window + */ + open(window) { + let { SidebarUI } = window; + if (SidebarUI && this.extension.canAccessWindow(window)) { + SidebarUI.show(this.id); + } + } + + /** + * Closes this sidebar action for the given window if this sidebar action is open. + * + * @param {ChromeWindow} window + */ + close(window) { + if (this.isOpen(window)) { + window.SidebarUI.hide(); + } + } + + /** + * Toogles this sidebar action for the given window + * + * @param {ChromeWindow} window + */ + toggle(window) { + let { SidebarUI } = window; + if (!SidebarUI || !this.extension.canAccessWindow(window)) { + return; + } + + if (!this.isOpen(window)) { + SidebarUI.show(this.id); + } else { + SidebarUI.hide(); + } + } + + /** + * Checks whether this sidebar action is open in the given window. + * + * @param {ChromeWindow} window + * @returns {boolean} + */ + isOpen(window) { + let { SidebarUI } = window; + return SidebarUI.isOpen && this.id == SidebarUI.currentID; + } + + getAPI(context) { + let { extension } = context; + const sidebarAction = this; + + return { + sidebarAction: { + async setTitle(details) { + sidebarAction.setPropertyFromDetails(details, "title", details.title); + }, + + getTitle(details) { + return sidebarAction.getPropertyFromDetails(details, "title"); + }, + + async setIcon(details) { + let icon = IconDetails.normalize(details, extension, context); + if (!Object.keys(icon).length) { + icon = null; + } + sidebarAction.setPropertyFromDetails(details, "icon", icon); + }, + + async setPanel(details) { + let url; + // Clear the url when given null or empty string. + if (!details.panel) { + url = null; + } else { + url = context.uri.resolve(details.panel); + if (!context.checkLoadURL(url)) { + return Promise.reject({ + message: `Access denied for URL ${url}`, + }); + } + } + + sidebarAction.setPropertyFromDetails(details, "panel", url); + }, + + getPanel(details) { + return sidebarAction.getPropertyFromDetails(details, "panel"); + }, + + open() { + let window = windowTracker.topWindow; + if (context.canAccessWindow(window)) { + sidebarAction.open(window); + } + }, + + close() { + let window = windowTracker.topWindow; + if (context.canAccessWindow(window)) { + sidebarAction.close(window); + } + }, + + toggle() { + let window = windowTracker.topWindow; + if (context.canAccessWindow(window)) { + sidebarAction.toggle(window); + } + }, + + isOpen(details) { + let { windowId } = details; + if (windowId == null) { + windowId = Window.WINDOW_ID_CURRENT; + } + let window = windowTracker.getWindow(windowId, context); + return sidebarAction.isOpen(window); + }, + }, + }; + } +}; + +global.sidebarActionFor = this.sidebarAction.for; -- cgit v1.2.3