Attachment #800975 for bug #902100

Attachment #800975: Patch v2.2 for bug #902100

View | Details | Raw Unified | Return to bug 902100
Collapse All | Expand All





let gResetting = false;

/**
 * gBuildAreas maps area IDs to actual area nodes within browser windows.
 */
let gBuildAreas = new Map();

/**
 * gBuildWindows is a set of windows that have registered build areas.
 * to a Set of known toolboxes in that window.
 */
let gBuildWindows = new Set();

let gNewElementCount = 0;
let gGroupWrapperCache = new Map();
let gSingleWrapperCache = new WeakMap();
let gListeners = new Set();

let gModuleName = "[CustomizableUI]";
#include logging.js

let CustomizeHelper = {
  getToolboxForWindow: function(aWindow) {
    return aWindow.gNavToolbox;
  },
};

let CustomizableUIInternal = {
  initialize: function() {
    LOG("Initializing");

    this.addListener(this);
    this._defineBuiltInWidgets();
    this.loadSavedState();



      this.insertWidgetBefore(node, currentNode, container, aArea);
      this._addParentFlex(node);
      if (gResetting)
        this.notifyListeners("onWidgetReset", id);
    }

    if (currentNode) {
      let palette = CustomizeHelper.getToolboxForWindow(window).palette;
      let limit = currentNode.previousSibling;
      let node = container.lastChild;
      while (node && node != limit) {
        let previousSibling = node.previousSibling;
        // Nodes opt-in to removability. If they're removable, and we haven't
        // seen them in the placements array, then we toss them into the palette
        // if one exists. If no palette exists, we just remove the node. If the
        // node is not removable, we leave it where it is. However, we can only

    for (let btn of aPanel.querySelectorAll("toolbarbutton")) {
      btn.setAttribute("tabindex", "0");
      this.ensureButtonContextMenu(btn, true);
      if (!btn.hasAttribute("type")) {
        btn.setAttribute("type", "wrap");
      }
    }

    aPanel.toolbox = document.getElementById("navigator-toolbox");
    aPanel.customizationTarget = aPanel;

    this.addPanelCloseListeners(aPanel);

    let placements = gPlacements.get(CustomizableUI.AREA_PANEL);
    this.buildArea(CustomizableUI.AREA_PANEL, placements, aPanel);
    this.registerBuildArea(CustomizableUI.AREA_PANEL, aPanel);
  },

      if (gPalette.has(aWidgetId) || this.isSpecialWidget(aWidgetId)) {
        container.removeChild(widgetNode);
      } else {
        this.removeLocationAttributes(widgetNode);
        widgetNode.removeAttribute("tabindex");
        if (widgetNode.getAttribute("type") == "wrap") {
          widgetNode.removeAttribute("type");
        }
        let palette = CustomizeHelper.getToolboxForWindow(window).palette;
        palette.appendChild(widgetNode);
      }
      if (area.get("type") == CustomizableUI.TYPE_TOOLBAR) {
        areaNode.setAttribute("currentset", areaNode.currentSet);
      }

      let windowCache = gSingleWrapperCache.get(window);
      if (windowCache) {
        windowCache.delete(aWidgetId);

  },

  registerBuildArea: function(aArea, aNode) {
    // We ensure that the window is registered to have its customization data
    // cleaned up when unloading.
    let window = aNode.ownerDocument.defaultView;
    this.registerBuildWindow(window);

    // Also register this build area's toolbox.
    if (aNode.toolbox) {
      gBuildWindows.get(window).add(aNode.toolbox);
    }

    if (!gBuildAreas.has(aArea)) {
      gBuildAreas.set(aArea, new Set());
    }

    gBuildAreas.get(aArea).add(aNode);
  },

  registerBuildWindow: function(aWindow) {
    gBuildWindows.add(aWindow);
      gBuildWindows.set(aWindow, new Set());
    }

    aWindow.addEventListener("unload", this);
    aWindow.addEventListener("command", this, true);
  },

  unregisterBuildWindow: function(aWindow) {
    aWindow.removeEventListener("unload", this);
    aWindow.removeEventListener("command", this, true);

    let node = document.getElementById(aId);
    if (node) {
      let parent = node.parentNode;
      while (parent && !(parent.customizationTarget ||
                         parent.localName == "toolbarpaletteitem")) {
        parent = parent.parentNode;
      }

      if ((parent && parent.customizationTarget == node.parentNode) ||
           gBuildWindows.get(aWindow).has(parent.toolbox)) ||
          (parent && parent.localName == "toolbarpaletteitem")) {
        // Normalize the removable attribute. For backwards compat, if
        // the widget is not defined in a toolbox palette then absence
        // of the "removable" attribute means it is not removable.
        if (!node.hasAttribute("removable")) {
          // If we first see this in customization mode, it may be in the
          // customization palette instead of the toolbox palette.
          node.setAttribute("removable", !parent.customizationTarget);
        }

        return node;
      }
    }

    let palette = CustomizeHelper.getToolboxForWindow(aWindow).palette;
    // Attempt to locate a node with a matching ID within
    // the palette.
    let node = palette.querySelector(idToSelector(aId));
    if (node) {
      // Normalize the removable attribute. For backwards compat, this
      // is optional if the widget is defined in the toolbox palette,
      // and defaults to *true*, unlike if it was defined elsewhere.
      if (!node.hasAttribute("removable")) {
        node.setAttribute("removable", true);
          if (!node.hasAttribute("removable")) {
            node.setAttribute("removable", true);
          }
          return node;
        }
      }
      return node;
    }
    return null;
  },

  buildWidget: function(aDocument, aWidget) {
    if (typeof aWidget == "string") {
      aWidget = gPalette.get(aWidget);
    }

      if (gBuildWindows.size == 0) {
        // We don't have any build windows to look at, so just assume for now
        // that its removable.
        return true;
      }

      if (!widgetNode) {
        // Pick any of the build windows to look at.
        let window = [...gBuildWindows][0];
        [, widgetNode] = this.getWidgetNode(widgetId, window);
      }
      // If we don't have a node, we assume it's removable. This can happen because
      // getWidgetProvider returns PROVIDER_XUL by default, but this will also happen
      // for API-provided widgets which have been destroyed.
      if (!widgetNode) {
        return true;
      }

    if (wrapperMap.has(aWidgetId)) {
      return wrapperMap.get(aWidgetId);
    }

    let instance = aWindow.document.getElementById(aWidgetId);
    if (!instance) {
      // Toolbar palettes aren't part of the document, so elements in there
      // won't be found via document.getElementById().
      let palette = CustomizeHelper.getToolboxForWindow(aWindow).palette;
      instance = palette.querySelector(idToSelector(aWidgetId));
    }

    let wrapper = new XULWidgetSingleWrapper(aWidgetId, instance);
    wrapperMap.set(aWidgetId, wrapper);
    return wrapper;
  };

  this.__defineGetter__("areaType", function() {


  init: function() {
    this._target = this._toolbar.customizationTarget;
    let doc = this._toolbar.ownerDocument;
    this._list = doc.getElementById(this._toolbar.getAttribute("overflowtarget"));

    let window = doc.defaultView;
    window.addEventListener("resize", this);
    let toolbox = CustomizeHelper.getToolboxForWindow(window);
    toolbox.addEventListener("customizationstarting", this);
    toolbox.addEventListener("aftercustomization", this);

    let chevronId = this._toolbar.getAttribute("overflowbutton");
    this._chevron = doc.getElementById(chevronId);
    this._chevron.addEventListener("command", this);

    this._panel = doc.getElementById("widget-overflow");
    this._panel.addEventListener("popuphiding", this);
    CustomizableUIInternal.addPanelCloseListeners(this._panel);

      Services.obs.removeObserver(this, "browser-delayed-startup-finished");
      return;
    }

    this._disable();

    let window = this._toolbar.ownerDocument.defaultView;
    window.removeEventListener("resize", this);
    let toolbox = CustomizeHelper.getToolboxForWindow(window);
    toolbox.removeEventListener("customizationstarting", this);
    toolbox.removeEventListener("aftercustomization", this);
    this._chevron.removeEventListener("command", this);
    this._panel.removeEventListener("popuphiding", this);
    CustomizableUIInternal.removePanelCloseListeners(this._panel);
  },

  handleEvent: function(aEvent) {
    switch(aEvent.type) {
      case "overflow":

Return to bug 902100