The Tor Browser: browser/metro/base/content/appbar.js@6474c204b198 (annotated)

browser/metro/base/content/appbar.js@6474c204b198 (annotated)

browser/metro/base/content/appbar.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* 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 Appbar = {
   get starButton()    { return document.getElementById('star-button'); },
   get pinButton()     { return document.getElementById('pin-button'); },
   get menuButton()    { return document.getElementById('menu-button'); },
   // track selected/active richgrid/tilegroup - the context for contextual action buttons
   activeTileset: null,
   init: function Appbar_init() {
     // fired from appbar bindings
     Elements.contextappbar.addEventListener('MozAppbarShowing', this, false);
     Elements.contextappbar.addEventListener('MozAppbarDismissing', this, false);
     // fired when a context sensitive item (bookmarks) changes state
     window.addEventListener('MozContextActionsChange', this, false);
     // browser events we need to update button state on
     Elements.browsers.addEventListener('URLChanged', this, true);
     Elements.tabList.addEventListener('TabSelect', this, true);
     // tilegroup selection events for all modules get bubbled up
     window.addEventListener("selectionchange", this, false);
     Services.obs.addObserver(this, "metro_on_async_tile_created", false);
     // gather appbar telemetry data
     try {
       UITelemetry.addSimpleMeasureFunction("metro-appbar",
                                            this.getAppbarMeasures.bind(this));
     } catch (ex) {
       // swallow exception that occurs if metro-appbar measure is already set up
     }
   },
   observe: function(aSubject, aTopic, aData) {
     switch (aTopic) {
       case "metro_on_async_tile_created":
         this._updatePinButton();
         break;
     }
   },
   handleEvent: function Appbar_handleEvent(aEvent) {
     switch (aEvent.type) {
       case 'URLChanged':
       case 'TabSelect':
         this.update();
         this.flushActiveTileset(aEvent.lastTab);
         break;
       case 'MozAppbarShowing':
         this.update();
         break;
       case 'MozAppbarDismissing':
         if (this.activeTileset && ('isBound' in this.activeTileset)) {
           this.activeTileset.clearSelection();
         }
         this._clearContextualActions();
         this.activeTileset = null;
         break;
       case 'MozContextActionsChange':
         let actions = aEvent.actions;
         let setName = aEvent.target.contextSetName;
         // could transition in old, new buttons?
         this.showContextualActions(actions, setName);
         break;
       case "selectionchange":
         let nodeName = aEvent.target.nodeName;
         if ('richgrid' === nodeName) {
           this._onTileSelectionChanged(aEvent);
         }
         break;
     }
   },
   flushActiveTileset: function flushActiveTileset(aTab) {
     try {
       let tab = aTab || Browser.selectedTab;
       // Switching away from or loading a site into a startui tab that has actions
       // pending, we consider this confirmation that the user wants to flush changes.
       if (this.activeTileset && tab && tab.browser && tab.browser.currentURI.spec == kStartURI) {
         ContextUI.dismiss();
       }
     } catch (ex) {}
   },
   shutdown: function shutdown() {
     this.flushActiveTileset();
   },
   /*
    * Called from various places when the visible content
    * has changed such that button states may need to be
    * updated.
    */
   update: function update() {
     this._updatePinButton();
     this._updateStarButton();
   },
   onPinButton: function() {
     if (this.pinButton.checked) {
       Browser.pinSite();
     } else {
       Browser.unpinSite();
     }
   },
   onStarButton: function(aValue) {
     if (aValue === undefined) {
       aValue = this.starButton.checked;
     }
     if (aValue) {
       Browser.starSite(function () {
         Appbar._updateStarButton();
       });
     } else {
       Browser.unstarSite(function () {
         Appbar._updateStarButton();
       });
     }
   },
   onMenuButton: function(aEvent) {
       let typesArray = [];
       if (BrowserUI.isPrivateBrowsingEnabled) {
         typesArray.push("private-browsing");
       }
       if (!BrowserUI.isStartTabVisible) {
         typesArray.push("find-in-page");
         if (ContextCommands.getPageSource())
           typesArray.push("view-page-source");
       }
       if (ContextCommands.getStoreLink())
         typesArray.push("ms-meta-data");
       if (ConsolePanelView.enabled)
         typesArray.push("open-error-console");
       if (!Services.metro.immersive)
         typesArray.push("open-jsshell");
       typesArray.push("view-on-desktop");
       var x = this.menuButton.getBoundingClientRect().left;
       var y = Elements.toolbar.getBoundingClientRect().top;
       ContextMenuUI.showContextMenu({
         json: {
           types: typesArray,
           string: '',
           xPos: x,
           yPos: y,
           leftAligned: true,
           bottomAligned: true
       }
       });
   },
   onViewOnDesktop: function() {
     let appStartup = Components.classes["@mozilla.org/toolkit/app-startup;1"].
       getService(Components.interfaces.nsIAppStartup);
     Services.prefs.setBoolPref('browser.sessionstore.resume_session_once', true);
     this._incrementCountableEvent("switch-to-desktop-button");
     appStartup.quit(Components.interfaces.nsIAppStartup.eAttemptQuit |
                     Components.interfaces.nsIAppStartup.eRestart);
   },
   onAutocompleteCloseButton: function () {
     Elements.autocomplete.closePopup();
   },
   dispatchContextualAction: function(aActionName){
     let activeTileset = this.activeTileset;
     if (activeTileset && ('isBound' in this.activeTileset)) {
       // fire event on the richgrid, others can listen
       // but we keep coupling loose so grid doesn't need to know about appbar
       let event = document.createEvent("Events");
       event.action = aActionName;
       event.initEvent("context-action", true, true); // is cancelable
       activeTileset.dispatchEvent(event);
       if (!event.defaultPrevented) {
         activeTileset.clearSelection();
         Elements.contextappbar.dismiss();
       }
     }
   },
   showContextualActions: function(aVerbs, aSetName) {
     // When the appbar is not visible, we want the icons to refresh right away
     let immediate = !Elements.contextappbar.isShowing;
     if (aVerbs.length) {
       Elements.contextappbar.show();
     }
     // Look up all of the buttons for the verbs that should be visible.
     let idsToVisibleVerbs = new Map();
     for (let verb of aVerbs) {
       let id = verb + "-selected-button";
       if (!document.getElementById(id)) {
         throw new Error("Appbar.showContextualActions: no button for " + verb);
       }
       idsToVisibleVerbs.set(id, verb);
     }
     // Sort buttons into 2 buckets - needing showing and needing hiding.
     let toHide = [], toShow = [];
     let buttons = Elements.contextappbar.getElementsByTagName("toolbarbutton");
     for (let button of buttons) {
       let verb = idsToVisibleVerbs.get(button.id);
       if (verb != undefined) {
         // Button should be visible, and may or may not be showing.
         this._updateContextualActionLabel(button, verb, aSetName);
         if (button.hidden) {
           toShow.push(button);
         }
       } else if (!button.hidden) {
         // Button is visible, but shouldn't be.
         toHide.push(button);
       }
     }
     if (immediate) {
       toShow.forEach(function(element) {
         element.removeAttribute("fade");
         element.hidden = false;
       });
       toHide.forEach(function(element) {
         element.setAttribute("fade", true);
         element.hidden = true;
       });
       return;
     }
     return Task.spawn(function() {
       if (toHide.length) {
         yield Util.transitionElementVisibility(toHide, false);
       }
       if (toShow.length) {
         yield Util.transitionElementVisibility(toShow, true);
       }
     });
   },
   _clearContextualActions: function() {
     this.showContextualActions([]);
   },
   _updateContextualActionLabel: function(aButton, aVerb, aSetName) {
     // True if the action's label string contains the set name and
     // thus has to be selected based on the list passed in.
     let usesSetName = aButton.hasAttribute("label-uses-set-name");
     let name = "contextAppbar2." + aVerb + (usesSetName ? "." + aSetName : "");
     aButton.label = Strings.browser.GetStringFromName(name);
   },
   _onTileSelectionChanged: function _onTileSelectionChanged(aEvent){
     let activeTileset = aEvent.target;
     // deselect tiles in other tile groups,
     // ensure previousyl-activeTileset is bound before calling methods on it
     if (this.activeTileset &&
           ('isBound' in this.activeTileset) &&
           this.activeTileset !== activeTileset) {
       this.activeTileset.clearSelection();
     }
     // keep track of which view is the target/scope for the contextual actions
     this.activeTileset = activeTileset;
     // ask the view for the list verbs/action-names it thinks are
     // appropriate for the tiles selected
     let contextActions = activeTileset.contextActions;
     let verbs = [v for (v of contextActions)];
     // fire event with these verbs as payload
     let event = document.createEvent("Events");
     event.actions = verbs;
     event.initEvent("MozContextActionsChange", true, false);
     activeTileset.dispatchEvent(event);
     if (verbs.length) {
       Elements.contextappbar.show(); // should be no-op if we're already showing
     } else {
       Elements.contextappbar.dismiss();
     }
   },
   // track certain appbar events and interactions for the UITelemetry probe
   _countableEvents: {},
   _incrementCountableEvent: function(aName) {
     if (!(aName in this._countableEvents)) {
       this._countableEvents[aName] = 0;
     }
     this._countableEvents[aName]++;
   },
   getAppbarMeasures: function() {
     return {
       countableEvents: this._countableEvents
     };
   },
   _updatePinButton: function() {
     this.pinButton.checked = Browser.isSitePinned();
   },
   _updateStarButton: function() {
     Browser.isSiteStarredAsync(function (isStarred) {
       this.starButton.checked = isStarred;
     }.bind(this));
   },
 };