Update project

_locales/de/messages.json

@@ -0,0 +1,8 @@
+{
+    "errorTitle": {
+        "message": "Einfügen aus Zwischenablage"
+    },
+    "errorMessage": {
+        "message": "Fehler beim Einfügen aus der Zwischenablage"
+    }
+}

_locales/en/messages.json

@@ -0,0 +1,8 @@
+{
+    "errorTitle": {
+        "message": "Attach from Clipboard"
+    },
+    "errorMessage": {
+        "message": "Failed to create attachment from the clipboard"
+    }
+}

api/WindowListener/implementation.js

@@ -0,0 +1,628 @@
+/*
+ * This file is provided by the addon-developer-support repository at
+ * https://github.com/thundernest/addon-developer-support
+ *
+ * Version: 1.20
+ * - fix long delay before customize window opens
+ * - fix non working removal of palette items
+ *
+ * Version: 1.19
+ * - add support for ToolbarPalette
+ *
+ * Version: 1.18
+ * - execute shutdown script also during global app shutdown (fixed)
+ *
+ * Version: 1.17
+ * - execute shutdown script also during global app shutdown
+ *
+ * Version: 1.16
+ * - support for persist
+ *
+ * Version: 1.15
+ * - make (undocumented) startup() async
+ *
+ * Version: 1.14
+ * - support resource urls
+ *
+ * Version: 1.12
+ * - no longer allow to enforce custom "namespace"
+ * - no longer call it namespace but uniqueRandomID / scopeName
+ * - expose special objects as the global WL object
+ * - autoremove injected elements after onUnload has ben executed
+ *
+ * Version: 1.9
+ * - automatically remove all entries added by injectElements
+ *
+ * Version: 1.8
+ * - add injectElements
+ *
+ * Version: 1.7
+ * - add injectCSS
+ * - add optional enforced namespace
+ *
+ * Version: 1.6
+ * - added mutation observer to be able to inject into browser elements
+ * - use larger icons as fallback
+ *
+ * Author: John Bieling (john@thunderbird.net)
+ *
+ * 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/.
+ */
+
+
+// Import some things we need.
+var { ExtensionCommon } = ChromeUtils.import("resource://gre/modules/ExtensionCommon.jsm");
+var { ExtensionSupport } = ChromeUtils.import("resource:///modules/ExtensionSupport.jsm");
+var { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+
+var WindowListener = class extends ExtensionCommon.ExtensionAPI {
+  getAPI(context) {
+    // track if this is the background/main context
+    this.isBackgroundContext = (context.viewType == "background");
+
+    this.uniqueRandomID = "AddOnNS" + context.extension.instanceId;
+    this.menu_addonsManager_id ="addonsManager";
+    this.menu_addonsManager_prefs_id = "addonsManager_prefs_revived";
+    this.menu_addonPrefs_id = "addonPrefs_revived";
+
+    this.registeredWindows = {};
+    this.pathToStartupScript = null;
+    this.pathToShutdownScript = null;
+    this.pathToOptionsPage = null;
+    this.chromeHandle = null;
+    this.chromeData = null;
+    this.resourceData = null;    
+    this.openWindows = [];
+
+    const aomStartup = Cc["@mozilla.org/addons/addon-manager-startup;1"].getService(Ci.amIAddonManagerStartup);
+    const resProto = Cc["@mozilla.org/network/protocol;1?name=resource"].getService(Ci.nsISubstitutingProtocolHandler);
+
+    let self = this;
+
+    return {
+      WindowListener: {
+
+        registerOptionsPage(optionsUrl) {
+          self.pathToOptionsPage = optionsUrl.startsWith("chrome://")
+            ? optionsUrl
+            : context.extension.rootURI.resolve(optionsUrl);
+        },
+
+        registerDefaultPrefs(defaultUrl) {
+          let url = context.extension.rootURI.resolve(defaultUrl);
+          let prefsObj = {};
+          prefsObj.Services = ChromeUtils.import("resource://gre/modules/Services.jsm").Services;
+          prefsObj.pref = function(aName, aDefault) {
+            let defaults = Services.prefs.getDefaultBranch("");
+            switch (typeof aDefault) {
+              case "string":
+                  return defaults.setCharPref(aName, aDefault);
+
+              case "number":
+                  return defaults.setIntPref(aName, aDefault);
+
+              case "boolean":
+                  return defaults.setBoolPref(aName, aDefault);
+
+              default:
+                throw new Error("Preference <" + aName + "> has an unsupported type <" + typeof aDefault + ">. Allowed are string, number and boolean.");
+            }
+          }
+          Services.scriptloader.loadSubScript(url, prefsObj, "UTF-8");
+        },
+
+        registerChromeUrl(data) {
+          if (!self.isBackgroundContext)
+            throw new Error("The WindowListener API may only be called from the background page.");
+
+          let chromeData = [];
+          let resourceData = [];
+          for (let entry of data) {
+            if (entry[0] == "resource") resourceData.push(entry);
+            else chromeData.push(entry)
+          }
+
+          if (chromeData.length > 0) {
+            const manifestURI = Services.io.newURI(
+              "manifest.json",
+              null,
+              context.extension.rootURI
+            );
+            self.chromeHandle = aomStartup.registerChrome(manifestURI, chromeData);
+          }
+
+          for (let res of resourceData) {
+            // [ "resource", "shortname" , "path" ]
+            let uri = Services.io.newURI(
+              res[2],
+              null,
+              context.extension.rootURI
+            );
+            resProto.setSubstitutionWithFlags(
+              res[1],
+              uri,
+              resProto.ALLOW_CONTENT_ACCESS
+            );
+          }
+
+          self.chromeData = chromeData;
+          self.resourceData = resourceData;
+        },
+
+        registerWindow(windowHref, jsFile) {
+          if (!self.isBackgroundContext)
+            throw new Error("The WindowListener API may only be called from the background page.");
+
+          if (!self.registeredWindows.hasOwnProperty(windowHref)) {
+            // path to JS file can either be chrome:// URL or a relative URL
+            let path = jsFile.startsWith("chrome://")
+              ? jsFile
+              : context.extension.rootURI.resolve(jsFile)
+            self.registeredWindows[windowHref] = path;
+          } else {
+            console.error("Window <" +windowHref + "> has already been registered");
+          }
+        },
+
+        registerStartupScript(aPath) {
+          if (!self.isBackgroundContext)
+            throw new Error("The WindowListener API may only be called from the background page.");
+
+          self.pathToStartupScript = aPath.startsWith("chrome://")
+            ? aPath
+            : context.extension.rootURI.resolve(aPath);
+        },
+
+        registerShutdownScript(aPath) {
+          if (!self.isBackgroundContext)
+            throw new Error("The WindowListener API may only be called from the background page.");
+
+          self.pathToShutdownScript = aPath.startsWith("chrome://")
+            ? aPath
+            : context.extension.rootURI.resolve(aPath);
+        },
+
+        async startListening() {
+          // async sleep function using Promise
+          async function sleep(delay) {
+            let timer =  Components.classes["@mozilla.org/timer;1"].createInstance(Components.interfaces.nsITimer);
+            return new Promise(function(resolve, reject) {
+              let event = {
+                notify: function(timer) {
+                  resolve();
+                }
+              }
+              timer.initWithCallback(event, delay, Components.interfaces.nsITimer.TYPE_ONE_SHOT);
+            });
+          };
+
+          if (!self.isBackgroundContext)
+            throw new Error("The WindowListener API may only be called from the background page.");
+
+          // load the registered startup script, if one has been registered
+          // (mail3:pane may not have been fully loaded yet)
+          if (self.pathToStartupScript) {
+            let startupJS = {};
+            startupJS.WL = {}
+            startupJS.WL.extension = self.extension;
+            startupJS.WL.messenger = Array.from(self.extension.views).find(
+              view => view.viewType === "background").xulBrowser.contentWindow
+              .wrappedJSObject.browser;
+            try {
+              if (self.pathToStartupScript) {
+                Services.scriptloader.loadSubScript(self.pathToStartupScript, startupJS, "UTF-8");
+                // delay startup until startup has been finished
+                console.log("Waiting for async startup() in <" + self.pathToStartupScript + "> to finish.");
+                if (startupJS.startup) {
+                  await startupJS.startup();
+                  console.log("startup() in <" + self.pathToStartupScript + "> finished");
+                } else {
+                  console.log("No startup() in <" + self.pathToStartupScript + "> found.");
+                }
+              }
+            } catch (e) {
+              Components.utils.reportError(e)
+            }
+          }
+                  
+          let urls = Object.keys(self.registeredWindows);
+          if (urls.length > 0) {
+            // Before registering the window listener, check which windows are already open
+            self.openWindows = [];
+            for (let window of Services.wm.getEnumerator(null)) {
+              self.openWindows.push(window);
+            }
+
+            // Register window listener for all pre-registered windows
+            ExtensionSupport.registerWindowListener("injectListener_" + self.uniqueRandomID, {
+              // React on all windows and manually reduce to the registered
+              // windows, so we can do special actions when the main
+              // messenger window is opened.
+              //chromeURLs: Object.keys(self.registeredWindows),
+              async onLoadWindow(window) {
+                // Create add-on scope
+                window[self.uniqueRandomID] = {};
+
+                // Special action #1: If this is the main messenger window
+                if (window.location.href == "chrome://messenger/content/messenger.xul" ||
+                  window.location.href == "chrome://messenger/content/messenger.xhtml") {
+
+                  if (self.pathToOptionsPage) {
+                    try {
+                      // add the add-on options menu if needed
+                      if (!window.document.getElementById(self.menu_addonsManager_prefs_id)) {
+                        let addonprefs = window.MozXULElement.parseXULToFragment(`
+                          <menu id="${self.menu_addonsManager_prefs_id}" label="&addonPrefs.label;">
+                            <menupopup id="${self.menu_addonPrefs_id}">
+                            </menupopup>
+                          </menu>
+                        `, ["chrome://messenger/locale/messenger.dtd"]);
+
+                      let element_addonsManager = window.document.getElementById(self.menu_addonsManager_id);
+                      element_addonsManager.parentNode.insertBefore(addonprefs, element_addonsManager.nextSibling);
+                      }
+
+                      // add the options entry
+                      let element_addonPrefs = window.document.getElementById(self.menu_addonPrefs_id);
+                      let id = self.menu_addonPrefs_id + "_" + self.uniqueRandomID;
+
+                      // Get the best size of the icon (16px or bigger)
+                      let iconSizes = Object.keys(self.extension.manifest.icons);
+                      iconSizes.sort((a,b)=>a-b);
+                      let bestSize = iconSizes.filter(e => parseInt(e) >= 16).shift();
+                      let icon = bestSize ? self.extension.manifest.icons[bestSize] : "";
+
+                      let name = self.extension.manifest.name;
+                      let entry = window.MozXULElement.parseXULToFragment(
+                        `<menuitem class="menuitem-iconic" id="${id}" image="${icon}" label="${name}" />`);
+                      element_addonPrefs.appendChild(entry);
+                      window.document.getElementById(id).addEventListener("command", function() {window.openDialog(self.pathToOptionsPage, "AddonOptions")});
+                    } catch (e) {
+                      Components.utils.reportError(e)
+                    }
+                  }
+                }
+
+                // Special action #2: If this page contains browser elements
+                let browserElements = window.document.getElementsByTagName("browser");
+                if (browserElements.length > 0) {
+                  //register a MutationObserver
+                  window[self.uniqueRandomID]._mObserver = new window.MutationObserver(function(mutations) {
+                      mutations.forEach(async function(mutation) {
+                          if (mutation.attributeName == "src" && self.registeredWindows.hasOwnProperty(mutation.target.getAttribute("src"))) {
+                            // When the MutationObserver callsback, the window is still showing "about:black" and it is going
+                            // to unload and then load the new page. Any eventListener attached to the window will be removed
+                            // so we cannot listen for the load event. We have to poll manually to learn when loading has finished.
+                            // On my system it takes 70ms.
+                            let loaded = false;
+                            for (let i=0; i < 100 && !loaded; i++) {
+                              await sleep(100);
+                              let targetWindow = mutation.target.contentWindow.wrappedJSObject;
+                              if (targetWindow && targetWindow.location.href == mutation.target.getAttribute("src") && targetWindow.document.readyState == "complete") {
+                                loaded = true;
+                                break;
+                              }
+                            }
+                            if (loaded) {
+                              let targetWindow = mutation.target.contentWindow.wrappedJSObject;
+                              // Create add-on scope
+                              targetWindow[self.uniqueRandomID] = {};
+                              // Inject with isAddonActivation = false
+                              self._loadIntoWindow(targetWindow, false);
+                            }
+                          }
+                      });
+                  });
+
+                  for (let element of browserElements) {
+                      if (self.registeredWindows.hasOwnProperty(element.getAttribute("src"))) {
+                        let targetWindow = element.contentWindow.wrappedJSObject;
+                        // Create add-on scope
+                        targetWindow[self.uniqueRandomID] = {};
+                        // Inject with isAddonActivation = true
+                        self._loadIntoWindow(targetWindow, true);
+                      } else {
+                        // Window/Browser is not yet fully loaded, postpone injection via MutationObserver
+                        window[self.uniqueRandomID]._mObserver.observe(element, { attributes: true, childList: false, characterData: false });
+                      }
+                  }
+                }
+
+                // Load JS into window
+                self._loadIntoWindow(window, self.openWindows.includes(window));
+              },
+
+              onUnloadWindow(window) {
+                // Remove JS from window, window is being closed, addon is not shut down
+                self._unloadFromWindow(window, false);
+              }
+            });
+          } else {
+            console.error("Failed to start listening, no windows registered");
+          }
+        },
+
+      }
+    };
+  }
+
+  _loadIntoWindow(window, isAddonActivation) {
+      if (window.hasOwnProperty(this.uniqueRandomID) && this.registeredWindows.hasOwnProperty(window.location.href)) {
+        try {
+          let uniqueRandomID = this.uniqueRandomID;
+
+          // Add reference to window to add-on scope
+          window[this.uniqueRandomID].window = window;
+          window[this.uniqueRandomID].document = window.document;
+
+          // Keep track of toolbarpalettes we are injecting into
+          window[this.uniqueRandomID]._toolbarpalettes = {};
+          
+          //Create WLDATA object
+          window[this.uniqueRandomID].WL = {};
+          window[this.uniqueRandomID].WL.scopeName = this.uniqueRandomID;
+
+          // Add helper function to inject CSS to WLDATA object
+          window[this.uniqueRandomID].WL.injectCSS = function (cssFile) {
+            let element;
+            let v = parseInt(Services.appinfo.version.split(".").shift());
+            
+            // using createElementNS in TB78 delays the insert process and hides any security violation errors
+            if (v > 68) {
+              element = window.document.createElement("link");
+            } else {
+              let ns = window.document.documentElement.lookupNamespaceURI("html");
+              element = window.document.createElementNS(ns, "link");
+            }
+            
+            element.setAttribute("wlapi_autoinjected", uniqueRandomID);
+            element.setAttribute("rel", "stylesheet");
+            element.setAttribute("href", cssFile);
+            return window.document.documentElement.appendChild(element);
+          }
+
+          // Add helper function to inject XUL to WLDATA object
+          window[this.uniqueRandomID].WL.injectElements = function (xulString, dtdFiles = [], debug = false) {
+            let toolbarsToResolve = [];
+
+            function checkElements(stringOfIDs) {
+              let arrayOfIDs = stringOfIDs.split(",").map(e => e.trim());
+              for (let id of arrayOfIDs) {
+                let element = window.document.getElementById(id);
+                if (element) {
+                  return element;
+                }
+              }
+              return null;
+            }
+
+
+            function injectChildren(elements, container) {
+              if (debug) console.log(elements);
+
+              for (let i = 0; i < elements.length; i++) {
+                // take care of persists
+                const uri = window.document.documentURI;
+                for (const persistentNode of elements[i].querySelectorAll("[persist]")) {
+                  for (const persistentAttribute of persistentNode.getAttribute("persist").trim().split(" ")) {
+                    if (Services.xulStore.hasValue(uri, persistentNode.id, persistentAttribute)) {
+                      persistentNode.setAttribute(
+                        persistentAttribute,
+                        Services.xulStore.getValue(uri, persistentNode.id, persistentAttribute)
+                      );
+                    }
+                  }
+                }
+                
+                if (elements[i].hasAttribute("insertafter") && checkElements(elements[i].getAttribute("insertafter"))) {
+                  let insertAfterElement = checkElements(elements[i].getAttribute("insertafter"));
+
+                  if (debug) console.log(elements[i].tagName + "#" + elements[i].id + ": insertafter " + insertAfterElement.id);
+                  if (elements[i].id && window.document.getElementById(elements[i].id)) {
+                    console.error("The id <" + elements[i].id + "> of the injected element already exists in the document!");
+                  }
+                  elements[i].setAttribute("wlapi_autoinjected", uniqueRandomID);
+                  insertAfterElement.parentNode.insertBefore(elements[i], insertAfterElement.nextSibling);
+
+                } else if (elements[i].hasAttribute("insertbefore") && checkElements(elements[i].getAttribute("insertbefore"))) {
+                  let insertBeforeElement = checkElements(elements[i].getAttribute("insertbefore"));
+
+                  if (debug) console.log(elements[i].tagName + "#" + elements[i].id + ": insertbefore " + insertBeforeElement.id);
+                  if (elements[i].id && window.document.getElementById(elements[i].id)) {
+                    console.error("The id <" + elements[i].id + "> of the injected element already exists in the document!");
+                  }
+                  elements[i].setAttribute("wlapi_autoinjected", uniqueRandomID);
+                  insertBeforeElement.parentNode.insertBefore(elements[i], insertBeforeElement);
+
+                } else if (elements[i].id && window.document.getElementById(elements[i].id)) {
+                  // existing container match, dive into recursivly
+                  if (debug) console.log(elements[i].tagName + "#" + elements[i].id + " is an existing container, injecting into " + elements[i].id);
+                  injectChildren(Array.from(elements[i].children), window.document.getElementById(elements[i].id));
+
+                } else if (elements[i].localName === "toolbarpalette") {
+                  // These vanish from the document but still exist via the palette property
+                  if (debug) console.log(elements[i].id + " is a toolbarpalette");
+                  let boxes = [...window.document.getElementsByTagName("toolbox")];
+                  let box = boxes.find(box => box.palette && box.palette.id === elements[i].id);
+                  let palette = box ? box.palette : null;
+            
+                  if (!palette) {
+                    if (debug) console.log(`The palette for ${elements[i].id} could not be found, deferring to later`);
+                    continue;
+                  }
+            
+                  if (debug) console.log(`The toolbox for ${elements[i].id} is ${box.id}`);
+            
+                  toolbarsToResolve.push(...box.querySelectorAll("toolbar"));
+                  toolbarsToResolve.push(...window.document.querySelectorAll(`toolbar[toolboxid="${box.id}"]`));
+                  for (let child of elements[i].children) {
+                    child.setAttribute("wlapi_autoinjected", uniqueRandomID);
+                  }
+                  window[uniqueRandomID]._toolbarpalettes[palette.id] = palette;
+                  injectChildren(Array.from(elements[i].children), palette);
+                } else {
+                  // append element to the current container
+                  if (debug) console.log(elements[i].tagName + "#" + elements[i].id + ": append to " + container.id);
+                  elements[i].setAttribute("wlapi_autoinjected", uniqueRandomID);
+                  container.appendChild(elements[i]);
+                }
+              }
+            }
+
+            if (debug) console.log ("Injecting into root document:");
+            injectChildren(Array.from(window.MozXULElement.parseXULToFragment(xulString, dtdFiles).children), window.document.documentElement);
+
+            for (let bar of toolbarsToResolve) {
+              let currentset = Services.xulStore.getValue(
+                window.location,
+                bar.id,
+                "currentset"
+              );
+              if (currentset) {
+                bar.currentSet = currentset;
+              } else if (bar.getAttribute("defaultset")) {
+                bar.currentSet = bar.getAttribute("defaultset");
+              }
+            }
+          }
+
+          // Add extension object to WLDATA object
+          window[this.uniqueRandomID].WL.extension = this.extension;
+          // Add messenger object to WLDATA object
+          window[this.uniqueRandomID].WL.messenger = Array.from(this.extension.views).find(
+            view => view.viewType === "background").xulBrowser.contentWindow
+            .wrappedJSObject.browser;
+          // Load script into add-on scope
+          Services.scriptloader.loadSubScript(this.registeredWindows[window.location.href], window[this.uniqueRandomID], "UTF-8");
+          window[this.uniqueRandomID].onLoad(isAddonActivation);
+        } catch (e) {
+          Components.utils.reportError(e)
+        }
+      }
+  }
+
+  _unloadFromWindow(window, isAddonDeactivation) {
+    // unload any contained browser elements
+      if (window.hasOwnProperty(this.uniqueRandomID) && window[this.uniqueRandomID].hasOwnProperty("_mObserver")) {
+        window[this.uniqueRandomID]._mObserver.disconnect();
+        let browserElements = window.document.getElementsByTagName("browser");
+        for (let element of browserElements) {
+          this._unloadFromWindow(element.contentWindow.wrappedJSObject, isAddonDeactivation);
+        }
+      }
+
+      if (window.hasOwnProperty(this.uniqueRandomID) && this.registeredWindows.hasOwnProperty(window.location.href)) {
+        //  Remove this window from the list of open windows
+        this.openWindows = this.openWindows.filter(e => (e != window));
+
+        if (window[this.uniqueRandomID].onUnload) {
+          try {
+            // Call onUnload()
+            window[this.uniqueRandomID].onUnload(isAddonDeactivation);
+          } catch (e) {
+            Components.utils.reportError(e)
+          }
+        }
+
+        // Remove all auto injected objects
+        let elements = Array.from(window.document.querySelectorAll('[wlapi_autoinjected="' + this.uniqueRandomID + '"]'));
+        for (let element of elements) {
+          element.remove();
+        }
+        
+        // Remove all autoinjected toolbarpalette items
+        for (const palette of Object.values(window[this.uniqueRandomID]._toolbarpalettes)) {
+          let elements = Array.from(palette.querySelectorAll('[wlapi_autoinjected="' + this.uniqueRandomID + '"]'));
+          for (let element of elements) {
+            element.remove();
+          }
+        }
+        
+      }
+
+      // Remove add-on scope, if it exists
+      if (window.hasOwnProperty(this.uniqueRandomID)) {
+        delete window[this.uniqueRandomID];
+      }
+  }
+
+
+  onShutdown(isAppShutdown) {
+    // Unload from all still open windows
+    let urls = Object.keys(this.registeredWindows);
+    if (urls.length > 0) {
+      for (let window of Services.wm.getEnumerator(null)) {
+
+        //remove our entry in the add-on options menu
+        if (
+          this.pathToOptionsPage &&
+          (window.location.href == "chrome://messenger/content/messenger.xul" ||
+          window.location.href == "chrome://messenger/content/messenger.xhtml")) {
+          let id = this.menu_addonPrefs_id + "_" + this.uniqueRandomID;
+          window.document.getElementById(id).remove();
+
+          //do we have to remove the entire add-on options menu?
+          let element_addonPrefs = window.document.getElementById(this.menu_addonPrefs_id);
+          if (element_addonPrefs.children.length == 0) {
+            window.document.getElementById(this.menu_addonsManager_prefs_id).remove();
+          }
+        }
+
+        // if it is app shutdown, it is not just an add-on deactivation
+        this._unloadFromWindow(window, !isAppShutdown);
+      }
+      // Stop listening for new windows.
+      ExtensionSupport.unregisterWindowListener("injectListener_" + this.uniqueRandomID);
+    }
+
+    // Load registered shutdown script
+    let shutdownJS = {};
+    shutdownJS.extension = this.extension;
+    try {
+      if (this.pathToShutdownScript) Services.scriptloader.loadSubScript(this.pathToShutdownScript, shutdownJS, "UTF-8");
+    } catch (e) {
+      Components.utils.reportError(e)
+    }
+
+    // Extract all registered chrome content urls
+    let chromeUrls = [];
+    if (this.chromeData) {
+        for (let chromeEntry of this.chromeData) {
+        if (chromeEntry[0].toLowerCase().trim() == "content") {
+          chromeUrls.push("chrome://" + chromeEntry[1] + "/");
+        }
+      }
+    }
+
+    // Unload JSMs of this add-on
+    const rootURI = this.extension.rootURI.spec;
+    for (let module of Cu.loadedModules) {
+      if (module.startsWith(rootURI) || (module.startsWith("chrome://") && chromeUrls.find(s => module.startsWith(s)))) {
+        console.log("Unloading: " + module);
+        Cu.unload(module);
+      }
+    }
+
+    // Flush all caches
+    Services.obs.notifyObservers(null, "startupcache-invalidate");
+    this.registeredWindows = {};
+
+    if (this.resourceData) {
+      const resProto = Cc["@mozilla.org/network/protocol;1?name=resource"].getService(Ci.nsISubstitutingProtocolHandler);
+      for (let res of this.resourceData) {
+        // [ "resource", "shortname" , "path" ]
+        resProto.setSubstitution(
+          res[1],
+          null,
+        );
+      }
+    }
+
+    if (this.chromeHandle) {
+      this.chromeHandle.destruct();
+      this.chromeHandle = null;
+    }
+  }
+};

api/WindowListener/schema.json

@@ -0,0 +1,91 @@
+[
+  {
+    "namespace": "WindowListener",
+    "functions": [
+      {
+        "name": "registerDefaultPrefs",
+        "type": "function",
+        "parameters": [
+          {
+            "name": "aPath",
+            "type": "string",
+            "description": "Relative path to the default file."
+          }
+        ]
+      },
+      {
+        "name": "registerOptionsPage",
+        "type": "function",
+        "parameters": [
+          {
+            "name": "aPath",
+            "type": "string",
+            "description": "Path to the options page, which should be made accessible in the (legacy) Add-On Options menu."
+          }
+        ]
+      },
+      {
+        "name": "registerChromeUrl",
+        "type": "function",
+        "description": "Register folders which should be available as chrome:// urls (as defined in the legacy chrome.manifest)",
+        "parameters": [
+          {
+            "name": "data",
+            "type": "array",
+            "items": {
+              "type": "array",
+              "items" : {
+                "type": "string"
+              }
+            },
+            "description": "Array of manifest url definitions (content, locale, resource)"
+          }
+        ]
+      },
+      {
+        "name": "startListening",
+        "type": "function",
+        "async": true,
+        "parameters": []
+      },
+      {
+        "name": "registerWindow",
+        "type": "function",
+        "parameters": [
+          {
+            "name": "windowHref",
+            "type": "string",
+            "description": "Url of the window, which should be listen for."
+          },
+          {
+            "name": "jsFile",
+            "type": "string",
+            "description": "Path to the JavaScript file, which should be loaded into the window."
+          }
+        ]
+      },
+      {
+        "name": "registerStartupScript",
+        "type": "function",
+        "parameters": [
+          {
+            "name": "aPath",
+            "type": "string",
+            "description": "Path to a JavaScript file, which should be executed on add-on startup. The script will be executed after the main application window has been sucessfully loaded."
+          }
+        ]
+      },
+      {
+        "name": "registerShutdownScript",
+        "type": "function",
+        "parameters": [
+          {
+            "name": "aPath",
+            "type": "string",
+            "description": "Path to a JavaScript file, which should be executed on add-on shutdown."
+          }
+        ]
+      }
+    ]
+  }
+]

background.js

@@ -0,0 +1,10 @@
+messenger.WindowListener.registerChromeUrl([ 
+    ["content", "clipboard",           "chrome/content/"],
+    ["locale",  "clipboard", "en-US",  "chrome/locale/en-US/"],
+    ["locale",  "clipboard", "de-DE",     "chrome/locale/de-DE/"]
+]);
+messenger.WindowListener.registerWindow(
+    "chrome://messenger/content/messengercompose/messengercompose.xhtml", 
+    "chrome://clipboard/content/messengercompose.js");
+messenger.WindowListener.registerShutdownScript("chrome://clipboard/content/shutdown.js");
+messenger.WindowListener.startListening();

chrome/content/messengercompose.js

@@ -0,0 +1,45 @@
+// Import any needed modules.
+var { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+
+function onLoad(activatedWhileWindowOpen) {
+
+    let xul = `<commandset id="composeCommands">
+    <commandset id="attachFromClipboardCmds" commandupdater="true" events="clipboard" oncommandupdate="clipboardAttachment.updateCommand()">
+      <command id="attachFromClipboardCmd" oncommand="clipboardAttachment.attachFromClipboard()" />
+    </commandset>
+  </commandset>
+  <keyset id="tasksKeys">
+    <keyset id="attachFromClipboardKeys">
+      <key id="attachFromClipboardKey" modifiers="shift alt" key="v" command="attachFromClipboardCmd" />
+    </keyset>
+  </keyset>
+  <menupopup id="button-attachPopup">
+    <menuitem id="button-attachPopup_attachClipboard" insertafter="button-attachPopup_attachPageItem"
+      label="&attachFromClipboard.label;" accesskey="&attachFromClipboard.accesskey;"
+      command="attachFromClipboardCmd" />
+  </menupopup>
+  <menupopup id="menu_EditPopup">
+    <menuitem id="menu_Attach_Clipboard" insertafter="menu_pasteNoFormatting" label="&attachFromClipboard.label;" accesskey="&attachFromClipboard.accesskey;"
+      command="attachFromClipboardCmd" key="attachFromClipboardKey" position="4" />
+  </menupopup>
+  <menupopup id="msgComposeAttachmentListContext">
+    <menuitem id="msgComposeAttachmentListContext_attachClipboard" insertafter="attachmentListContext_attachPageItem"
+      label="&attachFromClipboardContextMenu.label;" accesskey="&attachFromClipboard.accesskey;"
+      command="attachFromClipboardCmd" />
+  </menupopup>`;
+
+    WL.injectElements(xul, ["chrome://clipboard/locale/clipboard.dtd"]);
+
+    Services.scriptloader.loadSubScript("chrome://clipboard/content/overlay.js", this, "UTF-8");
+}
+
+function onUnload(deactivatedWhileWindowOpen) {
+    // Cleaning up the window UI is only needed when the
+    // add-on is being deactivated/removed while the window
+    // is still open. It can be skipped otherwise.
+    if (!deactivatedWhileWindowOpen) {
+        return
+    }
+    
+    window.clipboardAttachment.unload();
+}

chrome/content/overlay.js

@@ -1,4 +1,4 @@
-var clipboardAttachment = (function () {
+window.clipboardAttachment = (function () {
     var { classes: Cc, interfaces: Ci, utils: Cu } = Components;
 
     Cu.import('resource://gre/modules/Services.jsm');
@@ -56,7 +56,7 @@ var clipboardAttachment = (function () {
             trans.addDataFlavor(flavors[i]);
         }
 
-        Services.clipboard.getData(trans, Services.clipboard.kGlobalClipboard);
+        window.Services.clipboard.getData(trans, window.Services.clipboard.kGlobalClipboard);
 
         var flavor = {};
         var data = {};
@@ -75,7 +75,7 @@ var clipboardAttachment = (function () {
             trans.init(null);
             trans.addDataFlavor("text/unicode");
 
-            Services.clipboard.getData(trans, Services.clipboard.kGlobalClipboard);
+            window.Services.clipboard.getData(trans, window.Services.clipboard.kGlobalClipboard);
 
             trans.getAnyTransferData(flavor, data, len);
 
@@ -86,35 +86,34 @@ var clipboardAttachment = (function () {
     }
 
     function createFile(name) {
-        var file = FileUtils.getFile("TmpD", [name]);
-        file.createUnique(Ci.nsIFile.NORMAL_FILE_TYPE, FileUtils.PERMS_FILE);
+        var file = window.FileUtils.getFile("TmpD", [name]);
+        file.createUnique(Ci.nsIFile.NORMAL_FILE_TYPE, window.FileUtils.PERMS_FILE);
         return file;
     }
 
     function writeString(data, name, callback) {
         var file = createFile(name);
-        var ostream = FileUtils.openSafeFileOutputStream(file);
+        var ostream = window.FileUtils.openSafeFileOutputStream(file);
         var converter = Cc["@mozilla.org/intl/scriptableunicodeconverter"].createInstance(Ci.nsIScriptableUnicodeConverter);
         converter.charset = "UTF-8";
         var istream = converter.convertToInputStream(data);
 
-        NetUtil.asyncCopy(istream, ostream, function () {
+        window.NetUtil.asyncCopy(istream, ostream, function () {
             callback(file);
         });
     }
 
     function showException(ex) {
-        var stringBundle = document.getElementById("stringBundle");
         var promptService = Cc["@mozilla.org/embedcomp/prompt-service;1"].getService(Ci.nsIPromptService);
-        var title = stringBundle.getString("errorTitle");
-        var msg = stringBundle.getString("errorMessage") + ": " + ex;
+        var title = WL.messenger.i18n.getMessage("errorTitle");
+        var msg = WL.messenger.i18n.getMessage("errorMessage") + ": " + ex;
         promptService.alert(window, title, msg);
     }
 
     function addFileAttachment(file) {
         try {
-            var attachment = FileToAttachment(file);
-            AddAttachments([attachment]);
+            var attachment = window.FileToAttachment(file);
+            window.AddAttachments([attachment]);
             createdFiles.push(file);
         } catch (ex) {
             showException(ex);
@@ -125,9 +124,9 @@ var clipboardAttachment = (function () {
 
     var my = {
         canAttach: function () {
-            var clipboard = Services.clipboard;
+            var clipboard = window.Services.clipboard;
             var flavors = getOrderedFlavors();
-            var hasFlavors = clipboard.hasDataMatchingFlavors(flavors, flavors.length, clipboard.kGlobalClipboard);
+            var hasFlavors = clipboard.hasDataMatchingFlavors(flavors, clipboard.kGlobalClipboard);
             return hasFlavors;
         },
         attachFromClipboard: function () {
@@ -138,8 +137,8 @@ var clipboardAttachment = (function () {
                     if (data.flavor.indexOf("image/") === 0) {
                         var extension = data.flavor === "image/png" ? "png" : (data.flavor === "image/gif" ? "gif" : "jpg");
                         var file = createFile("image." + extension);
-                        var output = FileUtils.openSafeFileOutputStream(file);
-                        NetUtil.asyncCopy(data.data, output, function () {
+                        var output = window.FileUtils.openSafeFileOutputStream(file);
+                        window.NetUtil.asyncCopy(data.data, output, function () {
                             addFileAttachment(file);
                         });
                     } else if (data.flavor === "text/html") {
@@ -154,7 +153,7 @@ var clipboardAttachment = (function () {
                         attachment.url = lines[0];
                         if (lines.length > 1) attachment.name = lines[1];
                         if (lines.length > 2) attachment.size = lines[2];
-                        AddAttachments([attachment]);
+                        window.AddAttachments([attachment]);
                     } else if (data.flavor === "text/uri-list") {
                         var text = data.data.QueryInterface(Ci.nsISupportsString).data;
                         var lines = text.split('\n');
@@ -163,12 +162,12 @@ var clipboardAttachment = (function () {
                             var attachment = Cc["@mozilla.org/messengercompose/attachment;1"].createInstance(Ci.nsIMsgAttachment);
                             var fileUri = lines[i];
                             if (!fileUri.startsWith("file:///")) {
-                                fileUri = OS.Path.toFileURI(fileUri);
+                                fileUri = window.OS.Path.toFileURI(fileUri);
                             }
                             attachment.url = fileUri;
                             attachments.push(attachment);
                         }
-                        AddAttachments(attachments);
+                        window.AddAttachments(attachments);
                     } else if (data.flavor === "text/unicode" || data.flavor === "text/plain") {
                         var text = data.data.QueryInterface(Ci.nsISupportsString).data;
                         writeString(data.data, "document.txt", function (file) {
@@ -176,8 +175,8 @@ var clipboardAttachment = (function () {
                         });
                     } else if (data.flavor === "application/x-moz-file") {
                         var file = data.data.QueryInterface(Ci.nsIFile);
-                        var attachment = FileToAttachment(file);
-                        AddAttachments([attachment]);
+                        var attachment = window.FileToAttachment(file);
+                        window.AddAttachments([attachment]);
                     }
                 }
             } catch (ex) {
@@ -186,26 +185,22 @@ var clipboardAttachment = (function () {
         },
         updateCommand: function () {
             var canAttach = my.canAttach();
-            goSetCommandEnabled("attachFromClipboardCmd", canAttach);
+            window.goSetCommandEnabled("attachFromClipboardCmd", canAttach);
+        },
+        unload: function () {
+            for (i = 0; i < createdFiles.length; i++) {
+                createdFiles[i].remove(false);
+            }
+            createdFiles = [];
         }
     };
 
-    function unload() {
-        for (i = 0; i < createdFiles.length; i++) {
-            createdFiles[i].remove(false);
-        }
-        createdFiles = [];
-    }
-
-    window.addEventListener("load", function () {
-        var menuEditPopup = document.getElementById("menu_EditPopup");
-        menuEditPopup.addEventListener("popupshowing", my.updateCommand);
+    var menuEditPopup = document.getElementById("menu_EditPopup");
+    menuEditPopup.addEventListener("popupshowing", my.updateCommand);
 
-        var msgComposeWindow = document.getElementById("msgcomposeWindow");
-        msgComposeWindow.addEventListener("compose-window-close", unload);
-        msgComposeWindow.addEventListener("compose-window-unload", unload);
-    });
-    window.addEventListener("unload", unload);
+    var msgComposeWindow = document.getElementById("msgcomposeWindow");
+    msgComposeWindow.addEventListener("compose-window-close", my.unload);
+    msgComposeWindow.addEventListener("compose-window-unload", my.unload);
 
     return my;
 }());

chrome/locale/de-DE/clipboard.dtd

@@ -1,3 +1,3 @@
-<!ENTITY attachFromClipboard.label "Aus Zwischenablage">
+<!ENTITY attachFromClipboard.label "Aus Zwischenablage anfügen">
 <!ENTITY attachFromClipboard.accesskey "Z">
 <!ENTITY attachFromClipboardContextMenu.label "Aus Zwischenablage anfügen">

chrome/locale/en-US/clipboard.dtd

@@ -1,3 +1,3 @@
-<!ENTITY attachFromClipboard.label "From clipboard">
+<!ENTITY attachFromClipboard.label "Attach from clipboard">
 <!ENTITY attachFromClipboard.accesskey "c">
 <!ENTITY attachFromClipboardContextMenu.label "Attach from clipboard">

manifest.json

@@ -1,20 +1,36 @@
 {
   "manifest_version": 2,
+  "name": "Attach from Clipboard",
+  "description": "Create message attachments directly from the system clipboard.",
+  "version": "1.78.1",
+  "author": "Michael Ganss",
+  "homepage_url": "https://www.updatestar.com/dl/clipboard/clipboard.html",
   "applications": {
     "gecko": {
-      "id": "clipboard@scaniatm.net",
-      "strict_min_version": "68.0"
+      "id": "clipboard@ganss.org",
+      "strict_min_version": "78.0"
     }
   },
-  "name": "Attach from Clipboard",
-  "description": "Create message attachments directly from the system clipboard.",
-  "version": "1.3.68",
-  "homepage_url": "https://scaniatm.net",
   "icons": {
+    "32": "chrome/skin/icon.svg",
     "48": "chrome/skin/icon.svg",
     "96": "chrome/skin/icon.svg"
   },
-  "legacy": {
-    "type": "xul"
-  }
-}
+  "experiment_apis": {
+    "WindowListener": {
+      "schema": "api/WindowListener/schema.json",
+      "parent": {
+        "scopes": ["addon_parent"],
+        "paths": [["WindowListener"]],
+        "script": "api/WindowListener/implementation.js"
+      }
+    }
+  },
+  "background": {
+    "scripts": [
+      "background.js"
+    ]
+  },
+  "default_locale": "en",
+  "permissions": ["clipboardRead"]
+}