michael@0: <?xml version="1.0"?>
michael@0: 
michael@0: <!-- This Source Code Form is subject to the terms of the Mozilla Public
michael@0:    - License, v. 2.0. If a copy of the MPL was not distributed with this
michael@0:    - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
michael@0: 
michael@0: <!DOCTYPE bindings [
michael@0: <!ENTITY % tabBrowserDTD SYSTEM "chrome://browser/locale/tabbrowser.dtd" >
michael@0: %tabBrowserDTD;
michael@0: ]>
michael@0: 
michael@0: # MAKE_E10S_WORK surrounds code needed to have the front-end try to be smart
michael@0: # about using non-remote browsers for loading certain URIs when remote tabs
michael@0: # (browser.tabs.remote) are enabled.
michael@0: #define MAKE_E10S_WORK 1
michael@0: 
michael@0: <bindings id="tabBrowserBindings"
michael@0:           xmlns="http://www.mozilla.org/xbl"
michael@0:           xmlns:xul="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
michael@0:           xmlns:xbl="http://www.mozilla.org/xbl">
michael@0: 
michael@0:   <binding id="tabbrowser">
michael@0:     <resources>
michael@0:       <stylesheet src="chrome://browser/content/tabbrowser.css"/>
michael@0:     </resources>
michael@0: 
michael@0:     <content>
michael@0:       <xul:stringbundle anonid="tbstringbundle" src="chrome://browser/locale/tabbrowser.properties"/>
michael@0:       <xul:tabbox anonid="tabbox" class="tabbrowser-tabbox"
michael@0:                   flex="1" eventnode="document" xbl:inherits="handleCtrlPageUpDown"
michael@0:                   onselect="if (event.target.localName == 'tabpanels') this.parentNode.updateCurrentBrowser();">
michael@0:         <xul:tabpanels flex="1" class="plain" selectedIndex="0" anonid="panelcontainer">
michael@0:           <xul:notificationbox flex="1">
michael@0:             <xul:hbox flex="1" class="browserSidebarContainer">
michael@0:               <xul:vbox flex="1" class="browserContainer">
michael@0:                 <xul:stack flex="1" class="browserStack" anonid="browserStack">
michael@0:                   <xul:browser anonid="initialBrowser" type="content-primary" message="true"
michael@0:                                xbl:inherits="tooltip=contenttooltip,contextmenu=contentcontextmenu,autocompletepopup,selectpopup"/>
michael@0:                 </xul:stack>
michael@0:               </xul:vbox>
michael@0:             </xul:hbox>
michael@0:           </xul:notificationbox>
michael@0:         </xul:tabpanels>
michael@0:       </xul:tabbox>
michael@0:       <children/>
michael@0:     </content>
michael@0:     <implementation implements="nsIDOMEventListener, nsIMessageListener">
michael@0: 
michael@0:       <property name="tabContextMenu" readonly="true"
michael@0:                 onget="return this.tabContainer.contextMenu;"/>
michael@0: 
michael@0:       <field name="tabContainer" readonly="true">
michael@0:         document.getElementById(this.getAttribute("tabcontainer"));
michael@0:       </field>
michael@0:       <field name="tabs" readonly="true">
michael@0:         this.tabContainer.childNodes;
michael@0:       </field>
michael@0: 
michael@0:       <property name="visibleTabs" readonly="true">
michael@0:         <getter><![CDATA[
michael@0:           if (!this._visibleTabs)
michael@0:             this._visibleTabs = Array.filter(this.tabs,
michael@0:                                              function (tab) !tab.hidden && !tab.closing);
michael@0:           return this._visibleTabs;
michael@0:         ]]></getter>
michael@0:       </property>
michael@0: 
michael@0:       <field name="closingTabsEnum" readonly="true">({ ALL: 0, OTHER: 1, TO_END: 2 });</field>
michael@0: 
michael@0:       <field name="_visibleTabs">null</field>
michael@0: 
michael@0:       <field name="mURIFixup" readonly="true">
michael@0:         Components.classes["@mozilla.org/docshell/urifixup;1"]
michael@0:                   .getService(Components.interfaces.nsIURIFixup);
michael@0:       </field>
michael@0:       <field name="mFaviconService" readonly="true">
michael@0:         Components.classes["@mozilla.org/browser/favicon-service;1"]
michael@0:                   .getService(Components.interfaces.nsIFaviconService);
michael@0:       </field>
michael@0:       <field name="_placesAutocomplete" readonly="true">
michael@0:          Components.classes["@mozilla.org/autocomplete/search;1?name=history"]
michael@0:                    .getService(Components.interfaces.mozIPlacesAutoComplete);
michael@0:       </field>
michael@0:       <field name="_unifiedComplete" readonly="true">
michael@0:          Components.classes["@mozilla.org/autocomplete/search;1?name=unifiedcomplete"]
michael@0:                    .getService(Components.interfaces.mozIPlacesAutoComplete);
michael@0:       </field>
michael@0:       <field name="mTabBox" readonly="true">
michael@0:         document.getAnonymousElementByAttribute(this, "anonid", "tabbox");
michael@0:       </field>
michael@0:       <field name="mPanelContainer" readonly="true">
michael@0:         document.getAnonymousElementByAttribute(this, "anonid", "panelcontainer");
michael@0:       </field>
michael@0:       <field name="mStringBundle">
michael@0:         document.getAnonymousElementByAttribute(this, "anonid", "tbstringbundle");
michael@0:       </field>
michael@0:       <field name="mCurrentTab">
michael@0:         null
michael@0:       </field>
michael@0:       <field name="_lastRelatedTab">
michael@0:         null
michael@0:       </field>
michael@0:       <field name="mCurrentBrowser">
michael@0:         null
michael@0:       </field>
michael@0:       <field name="mProgressListeners">
michael@0:         []
michael@0:       </field>
michael@0:       <field name="mTabsProgressListeners">
michael@0:         []
michael@0:       </field>
michael@0:       <field name="mTabListeners">
michael@0:         []
michael@0:       </field>
michael@0:       <field name="mTabFilters">
michael@0:         []
michael@0:       </field>
michael@0:       <field name="mIsBusy">
michael@0:         false
michael@0:       </field>
michael@0:       <field name="arrowKeysShouldWrap" readonly="true">
michael@0: #ifdef XP_MACOSX
michael@0:         true
michael@0: #else
michael@0:         false
michael@0: #endif
michael@0:       </field>
michael@0: 
michael@0:       <field name="_autoScrollPopup">
michael@0:         null
michael@0:       </field>
michael@0: 
michael@0:       <field name="_previewMode">
michael@0:         false
michael@0:       </field>
michael@0: 
michael@0:       <field name="_lastFindValue">
michael@0:         ""
michael@0:       </field>
michael@0: 
michael@0:       <property name="_numPinnedTabs" readonly="true">
michael@0:         <getter><![CDATA[
michael@0:           for (var i = 0; i < this.tabs.length; i++) {
michael@0:             if (!this.tabs[i].pinned)
michael@0:               break;
michael@0:           }
michael@0:           return i;
michael@0:         ]]></getter>
michael@0:       </property>
michael@0: 
michael@0:       <method name="isFindBarInitialized">
michael@0:         <parameter name="aTab"/>
michael@0:         <body><![CDATA[
michael@0:           return (aTab || this.selectedTab)._findBar != undefined;
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="getFindBar">
michael@0:         <parameter name="aTab"/>
michael@0:         <body><![CDATA[
michael@0:           if (!aTab)
michael@0:             aTab = this.selectedTab;
michael@0: 
michael@0:           if (aTab._findBar)
michael@0:             return aTab._findBar;
michael@0: 
michael@0:           let findBar = document.createElementNS(this.namespaceURI, "findbar");
michael@0:           let browser = this.getBrowserForTab(aTab);
michael@0:           let browserContainer = this.getBrowserContainer(browser);
michael@0:           browserContainer.appendChild(findBar);
michael@0: 
michael@0:           // Force a style flush to ensure that our binding is attached.
michael@0:           findBar.clientTop;
michael@0: 
michael@0:           findBar.browser = browser;
michael@0:           findBar._findField.value = this._lastFindValue;
michael@0: 
michael@0:           aTab._findBar = findBar;
michael@0: 
michael@0:           let event = document.createEvent("Events");
michael@0:           event.initEvent("TabFindInitialized", true, false);
michael@0:           aTab.dispatchEvent(event);
michael@0: 
michael@0:           return findBar;
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="getStatusPanel">
michael@0:         <body><![CDATA[
michael@0:           if (!this._statusPanel) {
michael@0:             this._statusPanel = document.createElementNS(this.namespaceURI, "statuspanel");
michael@0:             this._statusPanel.setAttribute("inactive", "true");
michael@0:             this._statusPanel.setAttribute("layer", "true");
michael@0:             this._appendStatusPanel();
michael@0:           }
michael@0:           return this._statusPanel;
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_appendStatusPanel">
michael@0:         <body><![CDATA[
michael@0:           if (this._statusPanel) {
michael@0:             let browser = this.selectedBrowser;
michael@0:             let browserContainer = this.getBrowserContainer(browser);
michael@0:             browserContainer.insertBefore(this._statusPanel, browser.parentNode.nextSibling);
michael@0:           }
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="updateWindowResizers">
michael@0:         <body><![CDATA[
michael@0:           if (!window.gShowPageResizers)
michael@0:             return;
michael@0: 
michael@0:           var show = window.windowState == window.STATE_NORMAL;
michael@0:           for (let i = 0; i < this.browsers.length; i++) {
michael@0:             this.browsers[i].showWindowResizer = show;
michael@0:           }
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_setCloseKeyState">
michael@0:         <parameter name="aEnabled"/>
michael@0:         <body><![CDATA[
michael@0:           let keyClose = document.getElementById("key_close");
michael@0:           let closeKeyEnabled = keyClose.getAttribute("disabled") != "true";
michael@0:           if (closeKeyEnabled == aEnabled)
michael@0:             return;
michael@0: 
michael@0:           if (aEnabled)
michael@0:             keyClose.removeAttribute("disabled");
michael@0:           else
michael@0:             keyClose.setAttribute("disabled", "true");
michael@0: 
michael@0:           // We also want to remove the keyboard shortcut from the file menu
michael@0:           // when the shortcut is disabled, and bring it back when it's
michael@0:           // renabled.
michael@0:           //
michael@0:           // Fixing bug 630826 could make that happen automatically.
michael@0:           // Fixing bug 630830 could avoid the ugly hack below.
michael@0: 
michael@0:           let closeMenuItem = document.getElementById("menu_close");
michael@0:           let parentPopup = closeMenuItem.parentNode;
michael@0:           let nextItem = closeMenuItem.nextSibling;
michael@0:           let clonedItem = closeMenuItem.cloneNode(true);
michael@0: 
michael@0:           parentPopup.removeChild(closeMenuItem);
michael@0: 
michael@0:           if (aEnabled)
michael@0:             clonedItem.setAttribute("key", "key_close");
michael@0:           else
michael@0:             clonedItem.removeAttribute("key");
michael@0: 
michael@0:           parentPopup.insertBefore(clonedItem, nextItem);
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="pinTab">
michael@0:         <parameter name="aTab"/>
michael@0:         <body><![CDATA[
michael@0:           if (aTab.pinned)
michael@0:             return;
michael@0: 
michael@0:           if (aTab.hidden)
michael@0:             this.showTab(aTab);
michael@0: 
michael@0:           this.moveTabTo(aTab, this._numPinnedTabs);
michael@0:           aTab.setAttribute("pinned", "true");
michael@0:           this.tabContainer._unlockTabSizing();
michael@0:           this.tabContainer._positionPinnedTabs();
michael@0:           this.tabContainer.adjustTabstrip();
michael@0: 
michael@0:           // Bug 961867 - [e10s] Implement the logic for app tabs
michael@0:           if (!gMultiProcessBrowser)
michael@0:             this.getBrowserForTab(aTab).docShell.isAppTab = true;
michael@0: 
michael@0:           if (aTab.selected)
michael@0:             this._setCloseKeyState(false);
michael@0: 
michael@0:           let event = document.createEvent("Events");
michael@0:           event.initEvent("TabPinned", true, false);
michael@0:           aTab.dispatchEvent(event);
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="unpinTab">
michael@0:         <parameter name="aTab"/>
michael@0:         <body><![CDATA[
michael@0:           if (!aTab.pinned)
michael@0:             return;
michael@0: 
michael@0:           this.moveTabTo(aTab, this._numPinnedTabs - 1);
michael@0:           aTab.removeAttribute("pinned");
michael@0:           aTab.style.MozMarginStart = "";
michael@0:           this.tabContainer._unlockTabSizing();
michael@0:           this.tabContainer._positionPinnedTabs();
michael@0:           this.tabContainer.adjustTabstrip();
michael@0: 
michael@0:           // Bug 961867 - [e10s] Implement the logic for app tabs
michael@0:           if (!gMultiProcessBrowser)
michael@0:             this.getBrowserForTab(aTab).docShell.isAppTab = false;
michael@0: 
michael@0:           if (aTab.selected)
michael@0:             this._setCloseKeyState(true);
michael@0: 
michael@0:           let event = document.createEvent("Events");
michael@0:           event.initEvent("TabUnpinned", true, false);
michael@0:           aTab.dispatchEvent(event);
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="previewTab">
michael@0:         <parameter name="aTab"/>
michael@0:         <parameter name="aCallback"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             let currentTab = this.selectedTab;
michael@0:             try {
michael@0:               // Suppress focus, ownership and selected tab changes
michael@0:               this._previewMode = true;
michael@0:               this.selectedTab = aTab;
michael@0:               aCallback();
michael@0:             } finally {
michael@0:               this.selectedTab = currentTab;
michael@0:               this._previewMode = false;
michael@0:             }
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="getBrowserAtIndex">
michael@0:         <parameter name="aIndex"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             return this.browsers[aIndex];
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="getBrowserIndexForDocument">
michael@0:         <parameter name="aDocument"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             var tab = this._getTabForContentWindow(aDocument.defaultView);
michael@0:             return tab ? tab._tPos : -1;
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="getBrowserForDocument">
michael@0:         <parameter name="aDocument"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             var tab = this._getTabForContentWindow(aDocument.defaultView);
michael@0:             return tab ? tab.linkedBrowser : null;
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_getTabForContentWindow">
michael@0:         <parameter name="aWindow"/>
michael@0:         <body>
michael@0:         <![CDATA[
michael@0:           for (let i = 0; i < this.browsers.length; i++) {
michael@0:             if (this.browsers[i].contentWindow == aWindow)
michael@0:               return this.tabs[i];
michael@0:           }
michael@0:           return null;
michael@0:         ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_getTabForBrowser">
michael@0:         <parameter name="aBrowser"/>
michael@0:         <body>
michael@0:         <![CDATA[
michael@0:           for (let i = 0; i < this.tabs.length; i++) {
michael@0:             if (this.tabs[i].linkedBrowser == aBrowser)
michael@0:               return this.tabs[i];
michael@0:           }
michael@0:           return null;
michael@0:         ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="getNotificationBox">
michael@0:         <parameter name="aBrowser"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             return this.getSidebarContainer(aBrowser).parentNode;
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="getSidebarContainer">
michael@0:         <parameter name="aBrowser"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             return this.getBrowserContainer(aBrowser).parentNode;
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="getBrowserContainer">
michael@0:         <parameter name="aBrowser"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             return (aBrowser || this.mCurrentBrowser).parentNode.parentNode;
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="getTabModalPromptBox">
michael@0:         <parameter name="aBrowser"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
michael@0:             let browser = (aBrowser || this.mCurrentBrowser);
michael@0:             let stack = browser.parentNode;
michael@0:             let self = this;
michael@0: 
michael@0:             let promptBox = {
michael@0:               appendPrompt : function(args, onCloseCallback) {
michael@0:                 let newPrompt = document.createElementNS(XUL_NS, "tabmodalprompt");
michael@0:                 stack.appendChild(newPrompt);
michael@0:                 browser.setAttribute("tabmodalPromptShowing", true);
michael@0: 
michael@0:                 newPrompt.clientTop; // style flush to assure binding is attached
michael@0: 
michael@0:                 let tab = self._getTabForBrowser(browser);
michael@0:                 newPrompt.init(args, tab, onCloseCallback);
michael@0:                 return newPrompt;
michael@0:               },
michael@0: 
michael@0:               removePrompt : function(aPrompt) {
michael@0:                 stack.removeChild(aPrompt);
michael@0: 
michael@0:                 let prompts = this.listPrompts();
michael@0:                 if (prompts.length) {
michael@0:                   let prompt = prompts[prompts.length - 1];
michael@0:                   prompt.Dialog.setDefaultFocus();
michael@0:                 } else {
michael@0:                   browser.removeAttribute("tabmodalPromptShowing");
michael@0:                   browser.focus();
michael@0:                 }
michael@0:               },
michael@0: 
michael@0:               listPrompts : function(aPrompt) {
michael@0:                 let els = stack.getElementsByTagNameNS(XUL_NS, "tabmodalprompt");
michael@0:                 // NodeList --> real JS array
michael@0:                 let prompts = Array.slice(els);
michael@0:                 return prompts;
michael@0:               },
michael@0:             };
michael@0: 
michael@0:             return promptBox;
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_callProgressListeners">
michael@0:         <parameter name="aBrowser"/>
michael@0:         <parameter name="aMethod"/>
michael@0:         <parameter name="aArguments"/>
michael@0:         <parameter name="aCallGlobalListeners"/>
michael@0:         <parameter name="aCallTabsListeners"/>
michael@0:         <body><![CDATA[
michael@0:           var rv = true;
michael@0: 
michael@0:           if (!aBrowser)
michael@0:             aBrowser = this.mCurrentBrowser;
michael@0: 
michael@0:           if (aCallGlobalListeners != false &&
michael@0:               aBrowser == this.mCurrentBrowser) {
michael@0:             this.mProgressListeners.forEach(function (p) {
michael@0:               if (aMethod in p) {
michael@0:                 try {
michael@0:                   if (!p[aMethod].apply(p, aArguments))
michael@0:                     rv = false;
michael@0:                 } catch (e) {
michael@0:                   // don't inhibit other listeners
michael@0:                   Components.utils.reportError(e);
michael@0:                 }
michael@0:               }
michael@0:             });
michael@0:           }
michael@0: 
michael@0:           if (aCallTabsListeners != false) {
michael@0:             aArguments.unshift(aBrowser);
michael@0: 
michael@0:             this.mTabsProgressListeners.forEach(function (p) {
michael@0:               if (aMethod in p) {
michael@0:                 try {
michael@0:                   if (!p[aMethod].apply(p, aArguments))
michael@0:                     rv = false;
michael@0:                 } catch (e) {
michael@0:                   // don't inhibit other listeners
michael@0:                   Components.utils.reportError(e);
michael@0:                 }
michael@0:               }
michael@0:             });
michael@0:           }
michael@0: 
michael@0:           return rv;
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <!-- A web progress listener object definition for a given tab. -->
michael@0:       <method name="mTabProgressListener">
michael@0:         <parameter name="aTab"/>
michael@0:         <parameter name="aBrowser"/>
michael@0:         <parameter name="aStartsBlank"/>
michael@0:         <body>
michael@0:         <![CDATA[
michael@0:           return ({
michael@0:             mTabBrowser: this,
michael@0:             mTab: aTab,
michael@0:             mBrowser: aBrowser,
michael@0:             mBlank: aStartsBlank,
michael@0: 
michael@0:             // cache flags for correct status UI update after tab switching
michael@0:             mStateFlags: 0,
michael@0:             mStatus: 0,
michael@0:             mMessage: "",
michael@0:             mTotalProgress: 0,
michael@0: 
michael@0:             // count of open requests (should always be 0 or 1)
michael@0:             mRequestCount: 0,
michael@0: 
michael@0:             destroy: function () {
michael@0:               delete this.mTab;
michael@0:               delete this.mBrowser;
michael@0:               delete this.mTabBrowser;
michael@0:             },
michael@0: 
michael@0:             _callProgressListeners: function () {
michael@0:               Array.unshift(arguments, this.mBrowser);
michael@0:               return this.mTabBrowser._callProgressListeners.apply(this.mTabBrowser, arguments);
michael@0:             },
michael@0: 
michael@0:             _shouldShowProgress: function (aRequest) {
michael@0:               if (this.mBlank)
michael@0:                 return false;
michael@0: 
michael@0:               if (gMultiProcessBrowser)
michael@0:                 return true;
michael@0: 
michael@0:               // Don't show progress indicators in tabs for about: URIs
michael@0:               // pointing to local resources.
michael@0:               try {
michael@0:                 let channel = aRequest.QueryInterface(Ci.nsIChannel);
michael@0:                 if (channel.originalURI.schemeIs("about") &&
michael@0:                     (channel.URI.schemeIs("jar") || channel.URI.schemeIs("file")))
michael@0:                   return false;
michael@0:               } catch (e) {}
michael@0: 
michael@0:               return true;
michael@0:             },
michael@0: 
michael@0:             onProgressChange: function (aWebProgress, aRequest,
michael@0:                                         aCurSelfProgress, aMaxSelfProgress,
michael@0:                                         aCurTotalProgress, aMaxTotalProgress) {
michael@0:               this.mTotalProgress = aMaxTotalProgress ? aCurTotalProgress / aMaxTotalProgress : 0;
michael@0: 
michael@0:               if (!this._shouldShowProgress(aRequest))
michael@0:                 return;
michael@0: 
michael@0:               if (this.mTotalProgress)
michael@0:                 this.mTab.setAttribute("progress", "true");
michael@0: 
michael@0:               this._callProgressListeners("onProgressChange",
michael@0:                                           [aWebProgress, aRequest,
michael@0:                                            aCurSelfProgress, aMaxSelfProgress,
michael@0:                                            aCurTotalProgress, aMaxTotalProgress]);
michael@0:             },
michael@0: 
michael@0:             onProgressChange64: function (aWebProgress, aRequest,
michael@0:                                           aCurSelfProgress, aMaxSelfProgress,
michael@0:                                           aCurTotalProgress, aMaxTotalProgress) {
michael@0:               return this.onProgressChange(aWebProgress, aRequest,
michael@0:                 aCurSelfProgress, aMaxSelfProgress, aCurTotalProgress,
michael@0:                 aMaxTotalProgress);
michael@0:             },
michael@0: 
michael@0:             onStateChange: function (aWebProgress, aRequest, aStateFlags, aStatus) {
michael@0:               if (!aRequest)
michael@0:                 return;
michael@0: 
michael@0:               var oldBlank = this.mBlank;
michael@0: 
michael@0:               const nsIWebProgressListener = Components.interfaces.nsIWebProgressListener;
michael@0:               const nsIChannel = Components.interfaces.nsIChannel;
michael@0: 
michael@0:               if (aStateFlags & nsIWebProgressListener.STATE_START) {
michael@0:                 this.mRequestCount++;
michael@0:               }
michael@0:               else if (aStateFlags & nsIWebProgressListener.STATE_STOP) {
michael@0:                 const NS_ERROR_UNKNOWN_HOST = 2152398878;
michael@0:                 if (--this.mRequestCount > 0 && aStatus == NS_ERROR_UNKNOWN_HOST) {
michael@0:                   // to prevent bug 235825: wait for the request handled
michael@0:                   // by the automatic keyword resolver
michael@0:                   return;
michael@0:                 }
michael@0:                 // since we (try to) only handle STATE_STOP of the last request,
michael@0:                 // the count of open requests should now be 0
michael@0:                 this.mRequestCount = 0;
michael@0:               }
michael@0: 
michael@0:               if (aStateFlags & nsIWebProgressListener.STATE_START &&
michael@0:                   aStateFlags & nsIWebProgressListener.STATE_IS_NETWORK) {
michael@0:                 // It's okay to clear what the user typed when we start
michael@0:                 // loading a document. If the user types, this counter gets
michael@0:                 // set to zero, if the document load ends without an
michael@0:                 // onLocationChange, this counter gets decremented
michael@0:                 // (so we keep it while switching tabs after failed loads)
michael@0:                 // We need to add 2 because loadURIWithFlags may have
michael@0:                 // cancelled a pending load which would have cleared
michael@0:                 // its anchor scroll detection temporary increment.
michael@0:                 if (aWebProgress.isTopLevel)
michael@0:                   this.mBrowser.userTypedClear += 2;
michael@0: 
michael@0:                 if (this._shouldShowProgress(aRequest)) {
michael@0:                   if (!(aStateFlags & nsIWebProgressListener.STATE_RESTORING)) {
michael@0:                     this.mTab.setAttribute("busy", "true");
michael@0:                     if (!(aWebProgress.loadType & Ci.nsIDocShell.LOAD_CMD_RELOAD))
michael@0:                       this.mTabBrowser.setTabTitleLoading(this.mTab);
michael@0:                   }
michael@0: 
michael@0:                   if (this.mTab.selected)
michael@0:                     this.mTabBrowser.mIsBusy = true;
michael@0:                 }
michael@0:               }
michael@0:               else if (aStateFlags & nsIWebProgressListener.STATE_STOP &&
michael@0:                        aStateFlags & nsIWebProgressListener.STATE_IS_NETWORK) {
michael@0: 
michael@0:                 if (this.mTab.hasAttribute("busy")) {
michael@0:                   this.mTab.removeAttribute("busy");
michael@0:                   this.mTabBrowser._tabAttrModified(this.mTab);
michael@0:                   if (!this.mTab.selected)
michael@0:                     this.mTab.setAttribute("unread", "true");
michael@0:                 }
michael@0:                 this.mTab.removeAttribute("progress");
michael@0: 
michael@0:                 if (aWebProgress.isTopLevel) {
michael@0:                   if (!Components.isSuccessCode(aStatus) &&
michael@0:                       !isTabEmpty(this.mTab)) {
michael@0:                     // Restore the current document's location in case the
michael@0:                     // request was stopped (possibly from a content script)
michael@0:                     // before the location changed.
michael@0: 
michael@0:                     this.mBrowser.userTypedValue = null;
michael@0: 
michael@0:                     if (this.mTab.selected && gURLBar)
michael@0:                       URLBarSetURI();
michael@0:                   } else {
michael@0:                     // The document is done loading, we no longer want the
michael@0:                     // value cleared.
michael@0: 
michael@0:                     if (this.mBrowser.userTypedClear > 1)
michael@0:                       this.mBrowser.userTypedClear -= 2;
michael@0:                     else if (this.mBrowser.userTypedClear > 0)
michael@0:                       this.mBrowser.userTypedClear--;
michael@0:                   }
michael@0: 
michael@0:                   if (!this.mBrowser.mIconURL)
michael@0:                     this.mTabBrowser.useDefaultIcon(this.mTab);
michael@0:                 }
michael@0: 
michael@0:                 if (this.mBlank)
michael@0:                   this.mBlank = false;
michael@0: 
michael@0:                 var location = aRequest.QueryInterface(nsIChannel).URI;
michael@0: 
michael@0:                 // For keyword URIs clear the user typed value since they will be changed into real URIs
michael@0:                 if (location.scheme == "keyword")
michael@0:                   this.mBrowser.userTypedValue = null;
michael@0: 
michael@0:                 if (this.mTab.label == this.mTabBrowser.mStringBundle.getString("tabs.connecting"))
michael@0:                   this.mTabBrowser.setTabTitle(this.mTab);
michael@0: 
michael@0:                 if (this.mTab.selected)
michael@0:                   this.mTabBrowser.mIsBusy = false;
michael@0:               }
michael@0: 
michael@0:               if (oldBlank) {
michael@0:                 this._callProgressListeners("onUpdateCurrentBrowser",
michael@0:                                             [aStateFlags, aStatus, "", 0],
michael@0:                                             true, false);
michael@0:               } else {
michael@0:                 this._callProgressListeners("onStateChange",
michael@0:                                             [aWebProgress, aRequest, aStateFlags, aStatus],
michael@0:                                             true, false);
michael@0:               }
michael@0: 
michael@0:               this._callProgressListeners("onStateChange",
michael@0:                                           [aWebProgress, aRequest, aStateFlags, aStatus],
michael@0:                                           false);
michael@0: 
michael@0:               if (aStateFlags & (nsIWebProgressListener.STATE_START |
michael@0:                                  nsIWebProgressListener.STATE_STOP)) {
michael@0:                 // reset cached temporary values at beginning and end
michael@0:                 this.mMessage = "";
michael@0:                 this.mTotalProgress = 0;
michael@0:               }
michael@0:               this.mStateFlags = aStateFlags;
michael@0:               this.mStatus = aStatus;
michael@0:             },
michael@0: 
michael@0:             onLocationChange: function (aWebProgress, aRequest, aLocation,
michael@0:                                         aFlags) {
michael@0:               // OnLocationChange is called for both the top-level content
michael@0:               // and the subframes.
michael@0:               let topLevel = aWebProgress.isTopLevel;
michael@0: 
michael@0:               if (topLevel) {
michael@0:                 // If userTypedClear > 0, the document loaded correctly and we should be
michael@0:                 // clearing the user typed value. We also need to clear the typed value
michael@0:                 // if the document failed to load, to make sure the urlbar reflects the
michael@0:                 // failed URI (particularly for SSL errors). However, don't clear the value
michael@0:                 // if the error page's URI is about:blank, because that causes complete
michael@0:                 // loss of urlbar contents for invalid URI errors (see bug 867957).
michael@0:                 if (this.mBrowser.userTypedClear > 0 ||
michael@0:                     ((aFlags & Ci.nsIWebProgressListener.LOCATION_CHANGE_ERROR_PAGE) &&
michael@0:                      aLocation.spec != "about:blank"))
michael@0:                   this.mBrowser.userTypedValue = null;
michael@0: 
michael@0:                 // Clear out the missing plugins list since it's related to the
michael@0:                 // previous location.
michael@0:                 this.mBrowser.missingPlugins = null;
michael@0: 
michael@0:                 if (this.mTabBrowser.isFindBarInitialized(this.mTab)) {
michael@0:                   let findBar = this.mTabBrowser.getFindBar(this.mTab);
michael@0: 
michael@0:                   // Close the Find toolbar if we're in old-style TAF mode
michael@0:                   if (findBar.findMode != findBar.FIND_NORMAL)
michael@0:                     findBar.close();
michael@0: 
michael@0:                   // fix bug 253793 - turn off highlight when page changes
michael@0:                   findBar.getElement("highlight").checked = false;
michael@0:                 }
michael@0: 
michael@0:                 // Don't clear the favicon if this onLocationChange was
michael@0:                 // triggered by a pushState or a replaceState.  See bug 550565.
michael@0:                 if (aWebProgress.isLoadingDocument &&
michael@0:                     !(aWebProgress.loadType & Ci.nsIDocShell.LOAD_CMD_PUSHSTATE)) {
michael@0:                   this.mBrowser.mIconURL = null;
michael@0:                 }
michael@0: 
michael@0:                 let autocomplete = this.mTabBrowser._placesAutocomplete;
michael@0:                 let unifiedComplete = this.mTabBrowser._unifiedComplete;
michael@0:                 if (this.mBrowser.registeredOpenURI) {
michael@0:                   autocomplete.unregisterOpenPage(this.mBrowser.registeredOpenURI);
michael@0:                   unifiedComplete.unregisterOpenPage(this.mBrowser.registeredOpenURI);
michael@0:                   delete this.mBrowser.registeredOpenURI;
michael@0:                 }
michael@0:                 // Tabs in private windows aren't registered as "Open" so
michael@0:                 // that they don't appear as switch-to-tab candidates.
michael@0:                 if (!isBlankPageURL(aLocation.spec) &&
michael@0:                     (!PrivateBrowsingUtils.isWindowPrivate(window) ||
michael@0:                     PrivateBrowsingUtils.permanentPrivateBrowsing)) {
michael@0:                   autocomplete.registerOpenPage(aLocation);
michael@0:                   unifiedComplete.registerOpenPage(aLocation);
michael@0:                   this.mBrowser.registeredOpenURI = aLocation;
michael@0:                 }
michael@0:               }
michael@0: 
michael@0:               if (!this.mBlank) {
michael@0:                 this._callProgressListeners("onLocationChange",
michael@0:                                             [aWebProgress, aRequest, aLocation,
michael@0:                                              aFlags]);
michael@0:               }
michael@0: 
michael@0:               if (topLevel) {
michael@0:                 this.mBrowser.lastURI = aLocation;
michael@0:                 this.mBrowser.lastLocationChange = Date.now();
michael@0:               }
michael@0:             },
michael@0: 
michael@0:             onStatusChange: function (aWebProgress, aRequest, aStatus, aMessage) {
michael@0:               if (this.mBlank)
michael@0:                 return;
michael@0: 
michael@0:               this._callProgressListeners("onStatusChange",
michael@0:                                           [aWebProgress, aRequest, aStatus, aMessage]);
michael@0: 
michael@0:               this.mMessage = aMessage;
michael@0:             },
michael@0: 
michael@0:             onSecurityChange: function (aWebProgress, aRequest, aState) {
michael@0:               this._callProgressListeners("onSecurityChange",
michael@0:                                           [aWebProgress, aRequest, aState]);
michael@0:             },
michael@0: 
michael@0:             onRefreshAttempted: function (aWebProgress, aURI, aDelay, aSameURI) {
michael@0:               return this._callProgressListeners("onRefreshAttempted",
michael@0:                                                  [aWebProgress, aURI, aDelay, aSameURI]);
michael@0:             },
michael@0: 
michael@0:             QueryInterface: function (aIID) {
michael@0:               if (aIID.equals(Components.interfaces.nsIWebProgressListener) ||
michael@0:                   aIID.equals(Components.interfaces.nsIWebProgressListener2) ||
michael@0:                   aIID.equals(Components.interfaces.nsISupportsWeakReference) ||
michael@0:                   aIID.equals(Components.interfaces.nsISupports))
michael@0:                 return this;
michael@0:               throw Components.results.NS_NOINTERFACE;
michael@0:             }
michael@0:           });
michael@0:         ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="setIcon">
michael@0:         <parameter name="aTab"/>
michael@0:         <parameter name="aURI"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             var browser = this.getBrowserForTab(aTab);
michael@0:             browser.mIconURL = aURI instanceof Ci.nsIURI ? aURI.spec : aURI;
michael@0: 
michael@0:             if (aURI && this.mFaviconService) {
michael@0:               if (!(aURI instanceof Ci.nsIURI))
michael@0:                 aURI = makeURI(aURI);
michael@0:               this.mFaviconService.setAndFetchFaviconForPage(browser.currentURI,
michael@0:                                                              aURI, false,
michael@0:                                                              PrivateBrowsingUtils.isWindowPrivate(window) ?
michael@0:                                                                this.mFaviconService.FAVICON_LOAD_PRIVATE :
michael@0:                                                                this.mFaviconService.FAVICON_LOAD_NON_PRIVATE);
michael@0:             }
michael@0: 
michael@0:             let sizedIconUrl = browser.mIconURL || "";
michael@0:             if (sizedIconUrl) {
michael@0:               let size = Math.round(16 * window.devicePixelRatio);
michael@0:               sizedIconUrl += (sizedIconUrl.contains("#") ? "&" : "#") +
michael@0:                               "-moz-resolution=" + size + "," + size;
michael@0:             }
michael@0:             if (sizedIconUrl != aTab.getAttribute("image")) {
michael@0:               if (sizedIconUrl)
michael@0:                 aTab.setAttribute("image", sizedIconUrl);
michael@0:               else
michael@0:                 aTab.removeAttribute("image");
michael@0:               this._tabAttrModified(aTab);
michael@0:             }
michael@0: 
michael@0:             this._callProgressListeners(browser, "onLinkIconAvailable", [browser.mIconURL]);
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="getIcon">
michael@0:         <parameter name="aTab"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             let browser = aTab ? this.getBrowserForTab(aTab) : this.selectedBrowser;
michael@0:             return browser.mIconURL;
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="shouldLoadFavIcon">
michael@0:         <parameter name="aURI"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             return (aURI &&
michael@0:                     Services.prefs.getBoolPref("browser.chrome.site_icons") &&
michael@0:                     Services.prefs.getBoolPref("browser.chrome.favicons") &&
michael@0:                     ("schemeIs" in aURI) && (aURI.schemeIs("http") || aURI.schemeIs("https")));
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="useDefaultIcon">
michael@0:         <parameter name="aTab"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             var browser = this.getBrowserForTab(aTab);
michael@0:             var documentURI = browser.documentURI;
michael@0:             var icon = null;
michael@0: 
michael@0:             if (browser.imageDocument) {
michael@0:               if (Services.prefs.getBoolPref("browser.chrome.site_icons")) {
michael@0:                 let sz = Services.prefs.getIntPref("browser.chrome.image_icons.max_size");
michael@0:                 if (browser.imageDocument.width <= sz &&
michael@0:                     browser.imageDocument.height <= sz) {
michael@0:                   icon = browser.currentURI;
michael@0:                 }
michael@0:               }
michael@0:             }
michael@0:             // Use documentURIObject in the check for shouldLoadFavIcon so that we
michael@0:             // do the right thing with about:-style error pages.  Bug 453442
michael@0:             else if (this.shouldLoadFavIcon(documentURI)) {
michael@0:               let url = documentURI.prePath + "/favicon.ico";
michael@0:               if (!this.isFailedIcon(url))
michael@0:                 icon = url;
michael@0:             }
michael@0:             this.setIcon(aTab, icon);
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="isFailedIcon">
michael@0:         <parameter name="aURI"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             if (this.mFaviconService) {
michael@0:               if (!(aURI instanceof Ci.nsIURI))
michael@0:                 aURI = makeURI(aURI);
michael@0:               return this.mFaviconService.isFailedFavicon(aURI);
michael@0:             }
michael@0:             return null;
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="getWindowTitleForBrowser">
michael@0:         <parameter name="aBrowser"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             var newTitle = "";
michael@0:             var docElement = this.ownerDocument.documentElement;
michael@0:             var sep = docElement.getAttribute("titlemenuseparator");
michael@0: 
michael@0:             // Strip out any null bytes in the content title, since the
michael@0:             // underlying widget implementations of nsWindow::SetTitle pass
michael@0:             // null-terminated strings to system APIs.
michael@0:             var docTitle = aBrowser.contentTitle.replace("\0", "", "g");
michael@0: 
michael@0:             if (!docTitle)
michael@0:               docTitle = docElement.getAttribute("titledefault");
michael@0: 
michael@0:             var modifier = docElement.getAttribute("titlemodifier");
michael@0:             if (docTitle) {
michael@0:               newTitle += docElement.getAttribute("titlepreface");
michael@0:               newTitle += docTitle;
michael@0:               if (modifier)
michael@0:                 newTitle += sep;
michael@0:             }
michael@0:             newTitle += modifier;
michael@0: 
michael@0:             // If location bar is hidden and the URL type supports a host,
michael@0:             // add the scheme and host to the title to prevent spoofing.
michael@0:             // XXX https://bugzilla.mozilla.org/show_bug.cgi?id=22183#c239
michael@0:             try {
michael@0:               if (docElement.getAttribute("chromehidden").contains("location")) {
michael@0:                 var uri = this.mURIFixup.createExposableURI(
michael@0:                             aBrowser.currentURI);
michael@0:                 if (uri.scheme == "about")
michael@0:                   newTitle = uri.spec + sep + newTitle;
michael@0:                 else
michael@0:                   newTitle = uri.prePath + sep + newTitle;
michael@0:               }
michael@0:             } catch (e) {}
michael@0: 
michael@0:             return newTitle;
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="updateTitlebar">
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             if ("TabView" in window && TabView.isVisible()) {
michael@0:               // ToDo: this will be removed when we gain ability to draw to the menu bar.
michael@0:               // Bug 586175
michael@0:               this.ownerDocument.title = TabView.windowTitle;
michael@0:             }
michael@0:             else {
michael@0:               this.ownerDocument.title = this.getWindowTitleForBrowser(this.mCurrentBrowser);
michael@0:             }
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="updateCurrentBrowser">
michael@0:         <parameter name="aForceUpdate"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             var newBrowser = this.getBrowserAtIndex(this.tabContainer.selectedIndex);
michael@0:             if (this.mCurrentBrowser == newBrowser && !aForceUpdate)
michael@0:               return;
michael@0: 
michael@0:             if (!aForceUpdate) {
michael@0:               TelemetryStopwatch.start("FX_TAB_SWITCH_UPDATE_MS");
michael@0:               window.QueryInterface(Ci.nsIInterfaceRequestor).getInterface(Ci.nsIDOMWindowUtils)
michael@0:                                                              .beginTabSwitch();
michael@0:             }
michael@0: 
michael@0:             var oldTab = this.mCurrentTab;
michael@0: 
michael@0:             // Preview mode should not reset the owner
michael@0:             if (!this._previewMode && !oldTab.selected)
michael@0:               oldTab.owner = null;
michael@0: 
michael@0:             if (this._lastRelatedTab) {
michael@0:               if (!this._lastRelatedTab.selected)
michael@0:                 this._lastRelatedTab.owner = null;
michael@0:               this._lastRelatedTab = null;
michael@0:             }
michael@0: 
michael@0:             var oldBrowser = this.mCurrentBrowser;
michael@0:             oldBrowser.setAttribute("type", "content-targetable");
michael@0:             oldBrowser.docShellIsActive = false;
michael@0: 
michael@0:             var updateBlockedPopups = false;
michael@0:             if ((oldBrowser.blockedPopups && !newBrowser.blockedPopups) ||
michael@0:                 (!oldBrowser.blockedPopups && newBrowser.blockedPopups))
michael@0:               updateBlockedPopups = true;
michael@0: 
michael@0:             newBrowser.setAttribute("type", "content-primary");
michael@0:             newBrowser.docShellIsActive =
michael@0:               (window.windowState != window.STATE_MINIMIZED);
michael@0:             this.mCurrentBrowser = newBrowser;
michael@0:             this.mCurrentTab = this.tabContainer.selectedItem;
michael@0:             this.showTab(this.mCurrentTab);
michael@0: 
michael@0:             var forwardButtonContainer = document.getElementById("urlbar-wrapper");
michael@0:             if (forwardButtonContainer) {
michael@0:               forwardButtonContainer.setAttribute("switchingtabs", "true");
michael@0:               window.addEventListener("MozAfterPaint", function removeSwitchingtabsAttr() {
michael@0:                 window.removeEventListener("MozAfterPaint", removeSwitchingtabsAttr);
michael@0:                 forwardButtonContainer.removeAttribute("switchingtabs");
michael@0:               });
michael@0:             }
michael@0: 
michael@0:             this._appendStatusPanel();
michael@0: 
michael@0:             if (updateBlockedPopups)
michael@0:               this.mCurrentBrowser.updateBlockedPopups(false);
michael@0: 
michael@0:             // Update the URL bar.
michael@0:             var loc = this.mCurrentBrowser.currentURI;
michael@0: 
michael@0:             // Bug 666809 - SecurityUI support for e10s
michael@0:             var webProgress = this.mCurrentBrowser.webProgress;
michael@0:             var securityUI = this.mCurrentBrowser.securityUI;
michael@0: 
michael@0:             this._callProgressListeners(null, "onLocationChange",
michael@0:                                         [webProgress, null, loc, 0], true,
michael@0:                                         false);
michael@0: 
michael@0:             if (securityUI) {
michael@0:               this._callProgressListeners(null, "onSecurityChange",
michael@0:                                           [webProgress, null, securityUI.state], true, false);
michael@0:             }
michael@0: 
michael@0:             var listener = this.mTabListeners[this.tabContainer.selectedIndex] || null;
michael@0:             if (listener && listener.mStateFlags) {
michael@0:               this._callProgressListeners(null, "onUpdateCurrentBrowser",
michael@0:                                           [listener.mStateFlags, listener.mStatus,
michael@0:                                            listener.mMessage, listener.mTotalProgress],
michael@0:                                           true, false);
michael@0:             }
michael@0: 
michael@0:             if (!this._previewMode) {
michael@0:               this.mCurrentTab.removeAttribute("unread");
michael@0:               oldTab.lastAccessed = Date.now();
michael@0: 
michael@0:               let oldFindBar = oldTab._findBar;
michael@0:               if (oldFindBar &&
michael@0:                   oldFindBar.findMode == oldFindBar.FIND_NORMAL &&
michael@0:                   !oldFindBar.hidden)
michael@0:                 this._lastFindValue = oldFindBar._findField.value;
michael@0: 
michael@0:               this.updateTitlebar();
michael@0: 
michael@0:               this.mCurrentTab.removeAttribute("titlechanged");
michael@0:             }
michael@0: 
michael@0:             // If the new tab is busy, and our current state is not busy, then
michael@0:             // we need to fire a start to all progress listeners.
michael@0:             const nsIWebProgressListener = Components.interfaces.nsIWebProgressListener;
michael@0:             if (this.mCurrentTab.hasAttribute("busy") && !this.mIsBusy) {
michael@0:               this.mIsBusy = true;
michael@0:               this._callProgressListeners(null, "onStateChange",
michael@0:                                           [webProgress, null,
michael@0:                                            nsIWebProgressListener.STATE_START |
michael@0:                                            nsIWebProgressListener.STATE_IS_NETWORK, 0],
michael@0:                                           true, false);
michael@0:             }
michael@0: 
michael@0:             // If the new tab is not busy, and our current state is busy, then
michael@0:             // we need to fire a stop to all progress listeners.
michael@0:             if (!this.mCurrentTab.hasAttribute("busy") && this.mIsBusy) {
michael@0:               this.mIsBusy = false;
michael@0:               this._callProgressListeners(null, "onStateChange",
michael@0:                                           [webProgress, null,
michael@0:                                            nsIWebProgressListener.STATE_STOP |
michael@0:                                            nsIWebProgressListener.STATE_IS_NETWORK, 0],
michael@0:                                           true, false);
michael@0:             }
michael@0: 
michael@0:             this._setCloseKeyState(!this.mCurrentTab.pinned);
michael@0: 
michael@0:             // TabSelect events are suppressed during preview mode to avoid confusing extensions and other bits of code
michael@0:             // that might rely upon the other changes suppressed.
michael@0:             // Focus is suppressed in the event that the main browser window is minimized - focusing a tab would restore the window
michael@0:             if (!this._previewMode) {
michael@0:               // We've selected the new tab, so go ahead and notify listeners.
michael@0:               let event = new CustomEvent("TabSelect", {
michael@0:                 bubbles: true,
michael@0:                 cancelable: false,
michael@0:                 detail: {
michael@0:                   previousTab: oldTab
michael@0:                 }
michael@0:               });
michael@0:               this.mCurrentTab.dispatchEvent(event);
michael@0: 
michael@0:               this._tabAttrModified(oldTab);
michael@0:               this._tabAttrModified(this.mCurrentTab);
michael@0: 
michael@0:               if (oldBrowser != newBrowser &&
michael@0:                   oldBrowser.docShell &&
michael@0:                   oldBrowser.docShell.contentViewer.inPermitUnload) {
michael@0:                 // Since the user is switching away from a tab that has
michael@0:                 // a beforeunload prompt active, we remove the prompt.
michael@0:                 // This prevents confusing user flows like the following:
michael@0:                 //   1. User attempts to close Firefox
michael@0:                 //   2. User switches tabs (ingoring a beforeunload prompt)
michael@0:                 //   3. User returns to tab, presses "Leave page"
michael@0:                 let promptBox = this.getTabModalPromptBox(oldBrowser);
michael@0:                 let prompts = promptBox.listPrompts();
michael@0:                 // NB: This code assumes that the beforeunload prompt
michael@0:                 //     is the top-most prompt on the tab.
michael@0:                 promptBox.removePrompt(prompts[prompts.length - 1]);
michael@0:               }
michael@0: 
michael@0:               // Adjust focus
michael@0:               oldBrowser._urlbarFocused = (gURLBar && gURLBar.focused);
michael@0:               if (this.isFindBarInitialized(oldTab)) {
michael@0:                 let findBar = this.getFindBar(oldTab);
michael@0:                 oldTab._findBarFocused = (!findBar.hidden &&
michael@0:                   findBar._findField.getAttribute("focused") == "true");
michael@0:               }
michael@0:               do {
michael@0:                 // When focus is in the tab bar, retain it there.
michael@0:                 if (document.activeElement == oldTab) {
michael@0:                   // We need to explicitly focus the new tab, because
michael@0:                   // tabbox.xml does this only in some cases.
michael@0:                   this.mCurrentTab.focus();
michael@0:                   break;
michael@0:                 }
michael@0: 
michael@0:                 // If there's a tabmodal prompt showing, focus it.
michael@0:                 if (newBrowser.hasAttribute("tabmodalPromptShowing")) {
michael@0:                   let XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
michael@0:                   let prompts = newBrowser.parentNode.getElementsByTagNameNS(XUL_NS, "tabmodalprompt");
michael@0:                   let prompt = prompts[prompts.length - 1];
michael@0:                   prompt.Dialog.setDefaultFocus();
michael@0:                   break;
michael@0:                 }
michael@0: 
michael@0:                 // Focus the location bar if it was previously focused for that tab.
michael@0:                 // In full screen mode, only bother making the location bar visible
michael@0:                 // if the tab is a blank one.
michael@0:                 if (newBrowser._urlbarFocused && gURLBar) {
michael@0: 
michael@0:                   // Explicitly close the popup if the URL bar retains focus
michael@0:                   gURLBar.closePopup();
michael@0: 
michael@0:                   if (!window.fullScreen) {
michael@0:                     gURLBar.focus();
michael@0:                     break;
michael@0:                   } else if (isTabEmpty(this.mCurrentTab)) {
michael@0:                     focusAndSelectUrlBar();
michael@0:                     break;
michael@0:                   }
michael@0:                 }
michael@0: 
michael@0:                 // Focus the find bar if it was previously focused for that tab.
michael@0:                 if (gFindBarInitialized && !gFindBar.hidden &&
michael@0:                     this.selectedTab._findBarFocused) {
michael@0:                   gFindBar._findField.focus();
michael@0:                   break;
michael@0:                 }
michael@0: 
michael@0:                 // Otherwise, focus the content area.
michael@0:                 let fm = Cc["@mozilla.org/focus-manager;1"].getService(Ci.nsIFocusManager);
michael@0:                 let focusFlags = fm.FLAG_NOSCROLL;
michael@0: 
michael@0:                 if (!gMultiProcessBrowser) {
michael@0:                   let newFocusedElement = fm.getFocusedElementForWindow(window.content, true, {});
michael@0: 
michael@0:                   // for anchors, use FLAG_SHOWRING so that it is clear what link was
michael@0:                   // last clicked when switching back to that tab
michael@0:                   if (newFocusedElement &&
michael@0:                       (newFocusedElement instanceof HTMLAnchorElement ||
michael@0:                        newFocusedElement.getAttributeNS("http://www.w3.org/1999/xlink", "type") == "simple"))
michael@0:                     focusFlags |= fm.FLAG_SHOWRING;
michael@0:                 }
michael@0:                 fm.setFocus(newBrowser, focusFlags);
michael@0:               } while (false);
michael@0:             }
michael@0: 
michael@0:             this.tabContainer._setPositionalAttributes();
michael@0: 
michael@0:             if (!aForceUpdate)
michael@0:               TelemetryStopwatch.finish("FX_TAB_SWITCH_UPDATE_MS");
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_tabAttrModified">
michael@0:         <parameter name="aTab"/>
michael@0:         <body><![CDATA[
michael@0:           if (aTab.closing)
michael@0:             return;
michael@0: 
michael@0:           // This event should be dispatched when any of these attributes change:
michael@0:           // label, crop, busy, image, selected
michael@0:           var event = document.createEvent("Events");
michael@0:           event.initEvent("TabAttrModified", true, false);
michael@0:           aTab.dispatchEvent(event);
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="setTabTitleLoading">
michael@0:         <parameter name="aTab"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             aTab.label = this.mStringBundle.getString("tabs.connecting");
michael@0:             aTab.crop = "end";
michael@0:             this._tabAttrModified(aTab);
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="setTabTitle">
michael@0:         <parameter name="aTab"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             var browser = this.getBrowserForTab(aTab);
michael@0:             var crop = "end";
michael@0:             var title = browser.contentTitle;
michael@0: 
michael@0:             if (!title) {
michael@0:               if (browser.currentURI.spec) {
michael@0:                 try {
michael@0:                   title = this.mURIFixup.createExposableURI(browser.currentURI).spec;
michael@0:                 } catch(ex) {
michael@0:                   title = browser.currentURI.spec;
michael@0:                 }
michael@0:               }
michael@0: 
michael@0:               if (title && !isBlankPageURL(title)) {
michael@0:                 // At this point, we now have a URI.
michael@0:                 // Let's try to unescape it using a character set
michael@0:                 // in case the URI is not ASCII.
michael@0:                 try {
michael@0:                   var characterSet = browser.characterSet;
michael@0:                   const textToSubURI = Components.classes["@mozilla.org/intl/texttosuburi;1"]
michael@0:                                                  .getService(Components.interfaces.nsITextToSubURI);
michael@0:                   title = textToSubURI.unEscapeNonAsciiURI(characterSet, title);
michael@0:                 } catch(ex) { /* Do nothing. */ }
michael@0: 
michael@0:                 crop = "center";
michael@0: 
michael@0:               } else // Still no title?  Fall back to our untitled string.
michael@0:                 title = this.mStringBundle.getString("tabs.emptyTabTitle");
michael@0:             }
michael@0: 
michael@0:             if (aTab.label == title &&
michael@0:                 aTab.crop == crop)
michael@0:               return false;
michael@0: 
michael@0:             aTab.label = title;
michael@0:             aTab.crop = crop;
michael@0:             this._tabAttrModified(aTab);
michael@0: 
michael@0:             if (aTab.selected)
michael@0:               this.updateTitlebar();
michael@0: 
michael@0:             return true;
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="loadOneTab">
michael@0:         <parameter name="aURI"/>
michael@0:         <parameter name="aReferrerURI"/>
michael@0:         <parameter name="aCharset"/>
michael@0:         <parameter name="aPostData"/>
michael@0:         <parameter name="aLoadInBackground"/>
michael@0:         <parameter name="aAllowThirdPartyFixup"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             var aFromExternal;
michael@0:             var aRelatedToCurrent;
michael@0:             var aDisableMCB;
michael@0:             var aSkipAnimation;
michael@0:             if (arguments.length == 2 &&
michael@0:                 typeof arguments[1] == "object" &&
michael@0:                 !(arguments[1] instanceof Ci.nsIURI)) {
michael@0:               let params = arguments[1];
michael@0:               aReferrerURI          = params.referrerURI;
michael@0:               aCharset              = params.charset;
michael@0:               aPostData             = params.postData;
michael@0:               aLoadInBackground     = params.inBackground;
michael@0:               aAllowThirdPartyFixup = params.allowThirdPartyFixup;
michael@0:               aFromExternal         = params.fromExternal;
michael@0:               aRelatedToCurrent     = params.relatedToCurrent;
michael@0:               aDisableMCB           = params.disableMCB;
michael@0:               aSkipAnimation        = params.skipAnimation;
michael@0:             }
michael@0: 
michael@0:             var bgLoad = (aLoadInBackground != null) ? aLoadInBackground :
michael@0:                          Services.prefs.getBoolPref("browser.tabs.loadInBackground");
michael@0:             var owner = bgLoad ? null : this.selectedTab;
michael@0:             var tab = this.addTab(aURI, {
michael@0:                                   referrerURI: aReferrerURI,
michael@0:                                   charset: aCharset,
michael@0:                                   postData: aPostData,
michael@0:                                   ownerTab: owner,
michael@0:                                   allowThirdPartyFixup: aAllowThirdPartyFixup,
michael@0:                                   fromExternal: aFromExternal,
michael@0:                                   relatedToCurrent: aRelatedToCurrent,
michael@0:                                   skipAnimation: aSkipAnimation,
michael@0:                                   disableMCB: aDisableMCB});
michael@0:             if (!bgLoad)
michael@0:               this.selectedTab = tab;
michael@0: 
michael@0:             return tab;
michael@0:          ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="loadTabs">
michael@0:         <parameter name="aURIs"/>
michael@0:         <parameter name="aLoadInBackground"/>
michael@0:         <parameter name="aReplace"/>
michael@0:         <body><![CDATA[
michael@0:           if (!aURIs.length)
michael@0:             return;
michael@0: 
michael@0:           // The tab selected after this new tab is closed (i.e. the new tab's
michael@0:           // "owner") is the next adjacent tab (i.e. not the previously viewed tab)
michael@0:           // when several urls are opened here (i.e. closing the first should select
michael@0:           // the next of many URLs opened) or if the pref to have UI links opened in
michael@0:           // the background is set (i.e. the link is not being opened modally)
michael@0:           //
michael@0:           // i.e.
michael@0:           //    Number of URLs    Load UI Links in BG       Focus Last Viewed?
michael@0:           //    == 1              false                     YES
michael@0:           //    == 1              true                      NO
michael@0:           //    > 1               false/true                NO
michael@0:           var multiple = aURIs.length > 1;
michael@0:           var owner = multiple || aLoadInBackground ? null : this.selectedTab;
michael@0:           var firstTabAdded = null;
michael@0: 
michael@0:           if (aReplace) {
michael@0:             try {
michael@0:               this.loadURI(aURIs[0], null, null);
michael@0:             } catch (e) {
michael@0:               // Ignore failure in case a URI is wrong, so we can continue
michael@0:               // opening the next ones.
michael@0:             }
michael@0:           }
michael@0:           else
michael@0:             firstTabAdded = this.addTab(aURIs[0], {ownerTab: owner, skipAnimation: multiple});
michael@0: 
michael@0:           var tabNum = this.tabContainer.selectedIndex;
michael@0:           for (let i = 1; i < aURIs.length; ++i) {
michael@0:             let tab = this.addTab(aURIs[i], {skipAnimation: true});
michael@0:             if (aReplace)
michael@0:               this.moveTabTo(tab, ++tabNum);
michael@0:           }
michael@0: 
michael@0:           if (!aLoadInBackground) {
michael@0:             if (firstTabAdded) {
michael@0:               // .selectedTab setter focuses the content area
michael@0:               this.selectedTab = firstTabAdded;
michael@0:             }
michael@0:             else
michael@0:               this.selectedBrowser.focus();
michael@0:           }
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0: #ifdef MAKE_E10S_WORK
michael@0:       <method name="updateBrowserRemoteness">
michael@0:         <parameter name="aBrowser"/>
michael@0:         <parameter name="aURL"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             let shouldBeRemote = this._shouldBrowserBeRemote(aURL);
michael@0: 
michael@0:             let isRemote = aBrowser.getAttribute("remote") == "true";
michael@0:             if (isRemote == shouldBeRemote)
michael@0:               return false;
michael@0: 
michael@0:             let wasActive = document.activeElement == aBrowser;
michael@0: 
michael@0:             // Unhook our progress listener.
michael@0:             let tab = this._getTabForBrowser(aBrowser);
michael@0:             let index = tab._tPos;
michael@0:             let filter = this.mTabFilters[index];
michael@0:             aBrowser.webProgress.removeProgressListener(filter);
michael@0: 
michael@0:             // Change the "remote" attribute.
michael@0:             let parent = aBrowser.parentNode;
michael@0:             parent.removeChild(aBrowser);
michael@0:             aBrowser.setAttribute("remote", shouldBeRemote ? "true" : "false");
michael@0:             parent.appendChild(aBrowser);
michael@0: 
michael@0:             // Restore the progress listener.
michael@0:             aBrowser.webProgress.addProgressListener(filter, Ci.nsIWebProgress.NOTIFY_ALL);
michael@0: 
michael@0:             if (shouldBeRemote)
michael@0:               tab.setAttribute("remote", "true");
michael@0:             else
michael@0:               tab.removeAttribute("remote");
michael@0: 
michael@0:             if (wasActive)
michael@0:               aBrowser.focus();
michael@0: 
michael@0:             return true;
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <!--
michael@0:         Returns true if we want to load the content for this URL in a
michael@0:         remote process. Eventually this should just check whether aURL
michael@0:         is unprivileged. Right now, though, we would like to load
michael@0:         some unprivileged URLs (like about:neterror) in the main
michael@0:         process since they interact with chrome code through
michael@0:         BrowserOnClick.
michael@0:       -->
michael@0:       <method name="_shouldBrowserBeRemote">
michael@0:         <parameter name="aURL"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             if (!gMultiProcessBrowser)
michael@0:               return false;
michael@0: 
michael@0:             // loadURI in browser.xml treats null as about:blank
michael@0:             if (!aURL)
michael@0:               aURL = "about:blank";
michael@0: 
michael@0:             if (aURL.startsWith("about:") &&
michael@0:                 aURL.toLowerCase() != "about:home" &&
michael@0:                 aURL.toLowerCase() != "about:blank") {
michael@0:               return false;
michael@0:             }
michael@0: 
michael@0:             if (aURL.startsWith("chrome:"))
michael@0:               return false;
michael@0: 
michael@0:             return true;
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: #endif
michael@0: 
michael@0:       <method name="addTab">
michael@0:         <parameter name="aURI"/>
michael@0:         <parameter name="aReferrerURI"/>
michael@0:         <parameter name="aCharset"/>
michael@0:         <parameter name="aPostData"/>
michael@0:         <parameter name="aOwner"/>
michael@0:         <parameter name="aAllowThirdPartyFixup"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             const NS_XUL = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
michael@0:             var aFromExternal;
michael@0:             var aRelatedToCurrent;
michael@0:             var aSkipAnimation;
michael@0:             var aDisableMCB;
michael@0:             if (arguments.length == 2 &&
michael@0:                 typeof arguments[1] == "object" &&
michael@0:                 !(arguments[1] instanceof Ci.nsIURI)) {
michael@0:               let params = arguments[1];
michael@0:               aReferrerURI          = params.referrerURI;
michael@0:               aCharset              = params.charset;
michael@0:               aPostData             = params.postData;
michael@0:               aOwner                = params.ownerTab;
michael@0:               aAllowThirdPartyFixup = params.allowThirdPartyFixup;
michael@0:               aFromExternal         = params.fromExternal;
michael@0:               aRelatedToCurrent     = params.relatedToCurrent;
michael@0:               aSkipAnimation        = params.skipAnimation;
michael@0:               aDisableMCB           = params.disableMCB;
michael@0:             }
michael@0: 
michael@0:             // if we're adding tabs, we're past interrupt mode, ditch the owner
michael@0:             if (this.mCurrentTab.owner)
michael@0:               this.mCurrentTab.owner = null;
michael@0: 
michael@0:             var t = document.createElementNS(NS_XUL, "tab");
michael@0: 
michael@0:             var uriIsAboutBlank = !aURI || aURI == "about:blank";
michael@0: 
michael@0:             t.setAttribute("crop", "end");
michael@0:             t.setAttribute("onerror", "this.removeAttribute('image');");
michael@0:             t.className = "tabbrowser-tab";
michael@0: 
michael@0: #ifdef MAKE_E10S_WORK
michael@0:             let remote = this._shouldBrowserBeRemote(aURI);
michael@0: #else
michael@0:             let remote = gMultiProcessBrowser;
michael@0: #endif
michael@0:             if (remote)
michael@0:               t.setAttribute("remote", "true");
michael@0: 
michael@0:             this.tabContainer._unlockTabSizing();
michael@0: 
michael@0:             // When overflowing, new tabs are scrolled into view smoothly, which
michael@0:             // doesn't go well together with the width transition. So we skip the
michael@0:             // transition in that case.
michael@0:             let animate = !aSkipAnimation &&
michael@0:                           this.tabContainer.getAttribute("overflow") != "true" &&
michael@0:                           Services.prefs.getBoolPref("browser.tabs.animate");
michael@0:             if (!animate) {
michael@0:               t.setAttribute("fadein", "true");
michael@0:               setTimeout(function (tabContainer) {
michael@0:                 tabContainer._handleNewTab(t);
michael@0:               }, 0, this.tabContainer);
michael@0:             }
michael@0: 
michael@0:             // invalidate caches
michael@0:             this._browsers = null;
michael@0:             this._visibleTabs = null;
michael@0: 
michael@0:             this.tabContainer.appendChild(t);
michael@0: 
michael@0:             // If this new tab is owned by another, assert that relationship
michael@0:             if (aOwner)
michael@0:               t.owner = aOwner;
michael@0: 
michael@0:             var b = document.createElementNS(
michael@0:               "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul",
michael@0:                                              "browser");
michael@0:             b.setAttribute("type", "content-targetable");
michael@0:             b.setAttribute("message", "true");
michael@0:             b.setAttribute("contextmenu", this.getAttribute("contentcontextmenu"));
michael@0:             b.setAttribute("tooltip", this.getAttribute("contenttooltip"));
michael@0: 
michael@0:             if (remote)
michael@0:               b.setAttribute("remote", "true");
michael@0: 
michael@0:             if (window.gShowPageResizers && window.windowState == window.STATE_NORMAL) {
michael@0:               b.setAttribute("showresizer", "true");
michael@0:             }
michael@0: 
michael@0:             if (this.hasAttribute("autocompletepopup"))
michael@0:               b.setAttribute("autocompletepopup", this.getAttribute("autocompletepopup"));
michael@0: 
michael@0:             if (this.hasAttribute("selectpopup"))
michael@0:               b.setAttribute("selectpopup", this.getAttribute("selectpopup"));
michael@0: 
michael@0:             b.setAttribute("autoscrollpopup", this._autoScrollPopup.id);
michael@0: 
michael@0:             // Create the browserStack container
michael@0:             var stack = document.createElementNS(NS_XUL, "stack");
michael@0:             stack.className = "browserStack";
michael@0:             stack.appendChild(b);
michael@0:             stack.setAttribute("flex", "1");
michael@0: 
michael@0:             // Create the browserContainer
michael@0:             var browserContainer = document.createElementNS(NS_XUL, "vbox");
michael@0:             browserContainer.className = "browserContainer";
michael@0:             browserContainer.appendChild(stack);
michael@0:             browserContainer.setAttribute("flex", "1");
michael@0: 
michael@0:             // Create the sidebar container
michael@0:             var browserSidebarContainer = document.createElementNS(NS_XUL,
michael@0:                                                                    "hbox");
michael@0:             browserSidebarContainer.className = "browserSidebarContainer";
michael@0:             browserSidebarContainer.appendChild(browserContainer);
michael@0:             browserSidebarContainer.setAttribute("flex", "1");
michael@0: 
michael@0:             // Add the Message and the Browser to the box
michael@0:             var notificationbox = document.createElementNS(NS_XUL,
michael@0:                                                            "notificationbox");
michael@0:             notificationbox.setAttribute("flex", "1");
michael@0:             notificationbox.appendChild(browserSidebarContainer);
michael@0: 
michael@0:             var position = this.tabs.length - 1;
michael@0:             var uniqueId = this._generateUniquePanelID();
michael@0:             notificationbox.id = uniqueId;
michael@0:             t.linkedPanel = uniqueId;
michael@0:             t.linkedBrowser = b;
michael@0:             t._tPos = position;
michael@0:             this.tabContainer._setPositionalAttributes();
michael@0: 
michael@0:             // Prevent the superfluous initial load of a blank document
michael@0:             // if we're going to load something other than about:blank.
michael@0:             if (!uriIsAboutBlank) {
michael@0:               b.setAttribute("nodefaultsrc", "true");
michael@0:             }
michael@0: 
michael@0:             // NB: this appendChild call causes us to run constructors for the
michael@0:             // browser element, which fires off a bunch of notifications. Some
michael@0:             // of those notifications can cause code to run that inspects our
michael@0:             // state, so it is important that the tab element is fully
michael@0:             // initialized by this point.
michael@0:             this.mPanelContainer.appendChild(notificationbox);
michael@0: 
michael@0:             // We've waited until the tab is in the DOM to set the label. This
michael@0:             // allows the TabLabelModified event to be properly dispatched.
michael@0:             if (!aURI || isBlankPageURL(aURI)) {
michael@0:               t.label = this.mStringBundle.getString("tabs.emptyTabTitle");
michael@0:             } else {
michael@0:               t.label = aURI;
michael@0:             }
michael@0: 
michael@0:             this.tabContainer.updateVisibility();
michael@0: 
michael@0:             // wire up a progress listener for the new browser object.
michael@0:             var tabListener = this.mTabProgressListener(t, b, uriIsAboutBlank);
michael@0:             const filter = Components.classes["@mozilla.org/appshell/component/browser-status-filter;1"]
michael@0:                                      .createInstance(Components.interfaces.nsIWebProgress);
michael@0:             filter.addProgressListener(tabListener, Components.interfaces.nsIWebProgress.NOTIFY_ALL);
michael@0:             b.webProgress.addProgressListener(filter, Components.interfaces.nsIWebProgress.NOTIFY_ALL);
michael@0:             this.mTabListeners[position] = tabListener;
michael@0:             this.mTabFilters[position] = filter;
michael@0: 
michael@0:             b.droppedLinkHandler = handleDroppedLink;
michael@0: 
michael@0:             // If we just created a new tab that loads the default
michael@0:             // newtab url, swap in a preloaded page if possible.
michael@0:             // Do nothing if we're a private window.
michael@0:             let docShellsSwapped = false;
michael@0:             if (aURI == BROWSER_NEW_TAB_URL &&
michael@0:                 !PrivateBrowsingUtils.isWindowPrivate(window) &&
michael@0:                 !gMultiProcessBrowser) {
michael@0:               docShellsSwapped = gBrowserNewTabPreloader.newTab(t);
michael@0:             } else if (aURI == "about:customizing") {
michael@0:               docShellsSwapped = gCustomizationTabPreloader.newTab(t);
michael@0:             }
michael@0: 
michael@0:             // Dispatch a new tab notification.  We do this once we're
michael@0:             // entirely done, so that things are in a consistent state
michael@0:             // even if the event listener opens or closes tabs.
michael@0:             var evt = document.createEvent("Events");
michael@0:             evt.initEvent("TabOpen", true, false);
michael@0:             t.dispatchEvent(evt);
michael@0: 
michael@0:             // If we didn't swap docShells with a preloaded browser
michael@0:             // then let's just continue loading the page normally.
michael@0:             if (!docShellsSwapped && !uriIsAboutBlank) {
michael@0:               // pretend the user typed this so it'll be available till
michael@0:               // the document successfully loads
michael@0:               if (aURI && gInitialPages.indexOf(aURI) == -1)
michael@0:                 b.userTypedValue = aURI;
michael@0: 
michael@0:               let flags = Ci.nsIWebNavigation.LOAD_FLAGS_NONE;
michael@0:               if (aAllowThirdPartyFixup) {
michael@0:                 flags |= Ci.nsIWebNavigation.LOAD_FLAGS_ALLOW_THIRD_PARTY_FIXUP;
michael@0:                 flags |= Ci.nsIWebNavigation.LOAD_FLAGS_FIXUP_SCHEME_TYPOS;
michael@0:               }
michael@0:               if (aFromExternal)
michael@0:                 flags |= Ci.nsIWebNavigation.LOAD_FLAGS_FROM_EXTERNAL;
michael@0:               if (aDisableMCB)
michael@0:                 flags |= Ci.nsIWebNavigation.LOAD_FLAGS_ALLOW_MIXED_CONTENT;
michael@0:               try {
michael@0:                 b.loadURIWithFlags(aURI, flags, aReferrerURI, aCharset, aPostData);
michael@0:               } catch (ex) {
michael@0:                 Cu.reportError(ex);
michael@0:               }
michael@0:             }
michael@0: 
michael@0:             // We start our browsers out as inactive, and then maintain
michael@0:             // activeness in the tab switcher.
michael@0:             b.docShellIsActive = false;
michael@0: 
michael@0:             // Check if we're opening a tab related to the current tab and
michael@0:             // move it to after the current tab.
michael@0:             // aReferrerURI is null or undefined if the tab is opened from
michael@0:             // an external application or bookmark, i.e. somewhere other
michael@0:             // than the current tab.
michael@0:             if ((aRelatedToCurrent == null ? aReferrerURI : aRelatedToCurrent) &&
michael@0:                 Services.prefs.getBoolPref("browser.tabs.insertRelatedAfterCurrent")) {
michael@0:               let newTabPos = (this._lastRelatedTab ||
michael@0:                                this.selectedTab)._tPos + 1;
michael@0:               if (this._lastRelatedTab)
michael@0:                 this._lastRelatedTab.owner = null;
michael@0:               else
michael@0:                 t.owner = this.selectedTab;
michael@0:               this.moveTabTo(t, newTabPos);
michael@0:               this._lastRelatedTab = t;
michael@0:             }
michael@0: 
michael@0:             if (animate) {
michael@0:               mozRequestAnimationFrame(function () {
michael@0:                 this.tabContainer._handleTabTelemetryStart(t, aURI);
michael@0: 
michael@0:                 // kick the animation off
michael@0:                 t.setAttribute("fadein", "true");
michael@0:               }.bind(this));
michael@0:             }
michael@0: 
michael@0:             return t;
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="warnAboutClosingTabs">
michael@0:       <parameter name="aCloseTabs"/>
michael@0:       <parameter name="aTab"/>
michael@0:       <body>
michael@0:         <![CDATA[
michael@0:           var tabsToClose;
michael@0:           switch (aCloseTabs) {
michael@0:             case this.closingTabsEnum.ALL:
michael@0:               tabsToClose = this.tabs.length - this._removingTabs.length -
michael@0:                             gBrowser._numPinnedTabs;
michael@0:               break;
michael@0:             case this.closingTabsEnum.OTHER:
michael@0:               tabsToClose = this.visibleTabs.length - 1 - gBrowser._numPinnedTabs;
michael@0:               break;
michael@0:             case this.closingTabsEnum.TO_END:
michael@0:               if (!aTab)
michael@0:                 throw new Error("Required argument missing: aTab");
michael@0: 
michael@0:               tabsToClose = this.getTabsToTheEndFrom(aTab).length;
michael@0:               break;
michael@0:             default:
michael@0:               throw new Error("Invalid argument: " + aCloseTabs);
michael@0:           }
michael@0: 
michael@0:           if (tabsToClose <= 1)
michael@0:             return true;
michael@0: 
michael@0:           const pref = aCloseTabs == this.closingTabsEnum.ALL ?
michael@0:                        "browser.tabs.warnOnClose" : "browser.tabs.warnOnCloseOtherTabs";
michael@0:           var shouldPrompt = Services.prefs.getBoolPref(pref);
michael@0:           if (!shouldPrompt)
michael@0:             return true;
michael@0: 
michael@0:           var ps = Services.prompt;
michael@0: 
michael@0:           // default to true: if it were false, we wouldn't get this far
michael@0:           var warnOnClose = { value: true };
michael@0:           var bundle = this.mStringBundle;
michael@0: 
michael@0:           // focus the window before prompting.
michael@0:           // this will raise any minimized window, which will
michael@0:           // make it obvious which window the prompt is for and will
michael@0:           // solve the problem of windows "obscuring" the prompt.
michael@0:           // see bug #350299 for more details
michael@0:           window.focus();
michael@0:           var warningMessage =
michael@0:             PluralForm.get(tabsToClose, bundle.getString("tabs.closeWarningMultiple"))
michael@0:                       .replace("#1", tabsToClose);
michael@0:           var buttonPressed =
michael@0:             ps.confirmEx(window,
michael@0:                          bundle.getString("tabs.closeWarningTitle"),
michael@0:                          warningMessage,
michael@0:                          (ps.BUTTON_TITLE_IS_STRING * ps.BUTTON_POS_0)
michael@0:                          + (ps.BUTTON_TITLE_CANCEL * ps.BUTTON_POS_1),
michael@0:                          bundle.getString("tabs.closeButtonMultiple"),
michael@0:                          null, null,
michael@0:                          aCloseTabs == this.closingTabsEnum.ALL ?
michael@0:                            bundle.getString("tabs.closeWarningPromptMe") : null,
michael@0:                          warnOnClose);
michael@0:           var reallyClose = (buttonPressed == 0);
michael@0: 
michael@0:           // don't set the pref unless they press OK and it's false
michael@0:           if (aCloseTabs == this.closingTabsEnum.ALL && reallyClose && !warnOnClose.value)
michael@0:             Services.prefs.setBoolPref(pref, false);
michael@0: 
michael@0:           return reallyClose;
michael@0:         ]]>
michael@0:       </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="getTabsToTheEndFrom">
michael@0:         <parameter name="aTab"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             var tabsToEnd = [];
michael@0:             let tabs = this.visibleTabs;
michael@0:             for (let i = tabs.length - 1; tabs[i] != aTab && i >= 0; --i) {
michael@0:               tabsToEnd.push(tabs[i]);
michael@0:             }
michael@0:             return tabsToEnd.reverse();
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="removeTabsToTheEndFrom">
michael@0:         <parameter name="aTab"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             if (this.warnAboutClosingTabs(this.closingTabsEnum.TO_END, aTab)) {
michael@0:               let tabs = this.getTabsToTheEndFrom(aTab);
michael@0:               for (let i = tabs.length - 1; i >= 0; --i) {
michael@0:                 this.removeTab(tabs[i], {animate: true});
michael@0:               }
michael@0:             }
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="removeAllTabsBut">
michael@0:         <parameter name="aTab"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             if (aTab.pinned)
michael@0:               return;
michael@0: 
michael@0:             if (this.warnAboutClosingTabs(this.closingTabsEnum.OTHER)) {
michael@0:               let tabs = this.visibleTabs;
michael@0:               this.selectedTab = aTab;
michael@0: 
michael@0:               for (let i = tabs.length - 1; i >= 0; --i) {
michael@0:                 if (tabs[i] != aTab && !tabs[i].pinned)
michael@0:                   this.removeTab(tabs[i], {animate: true});
michael@0:               }
michael@0:             }
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="removeCurrentTab">
michael@0:         <parameter name="aParams"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             this.removeTab(this.mCurrentTab, aParams);
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <field name="_removingTabs">
michael@0:         []
michael@0:       </field>
michael@0: 
michael@0:       <method name="removeTab">
michael@0:         <parameter name="aTab"/>
michael@0:         <parameter name="aParams"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             if (aParams) {
michael@0:               var animate = aParams.animate;
michael@0:               var byMouse = aParams.byMouse;
michael@0:             }
michael@0: 
michael@0:             // Handle requests for synchronously removing an already
michael@0:             // asynchronously closing tab.
michael@0:             if (!animate &&
michael@0:                 aTab.closing) {
michael@0:               this._endRemoveTab(aTab);
michael@0:               return;
michael@0:             }
michael@0: 
michael@0:             var isLastTab = (this.tabs.length - this._removingTabs.length == 1);
michael@0: 
michael@0:             if (!this._beginRemoveTab(aTab, false, null, true))
michael@0:               return;
michael@0: 
michael@0:             if (!aTab.pinned && !aTab.hidden && aTab._fullyOpen && byMouse)
michael@0:               this.tabContainer._lockTabSizing(aTab);
michael@0:             else
michael@0:               this.tabContainer._unlockTabSizing();
michael@0: 
michael@0:             if (!animate /* the caller didn't opt in */ ||
michael@0:                 isLastTab ||
michael@0:                 aTab.pinned ||
michael@0:                 aTab.hidden ||
michael@0:                 this._removingTabs.length > 3 /* don't want lots of concurrent animations */ ||
michael@0:                 aTab.getAttribute("fadein") != "true" /* fade-in transition hasn't been triggered yet */ ||
michael@0:                 window.getComputedStyle(aTab).maxWidth == "0.1px" /* fade-in transition hasn't moved yet */ ||
michael@0:                 !Services.prefs.getBoolPref("browser.tabs.animate")) {
michael@0:               this._endRemoveTab(aTab);
michael@0:               return;
michael@0:             }
michael@0: 
michael@0:             this.tabContainer._handleTabTelemetryStart(aTab);
michael@0: 
michael@0:             this._blurTab(aTab);
michael@0:             aTab.style.maxWidth = ""; // ensure that fade-out transition happens
michael@0:             aTab.removeAttribute("fadein");
michael@0: 
michael@0:             setTimeout(function (tab, tabbrowser) {
michael@0:               if (tab.parentNode &&
michael@0:                   window.getComputedStyle(tab).maxWidth == "0.1px") {
michael@0:                 NS_ASSERT(false, "Giving up waiting for the tab closing animation to finish (bug 608589)");
michael@0:                 tabbrowser._endRemoveTab(tab);
michael@0:               }
michael@0:             }, 3000, aTab, this);
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <!-- Tab close requests are ignored if the window is closing anyway,
michael@0:            e.g. when holding Ctrl+W. -->
michael@0:       <field name="_windowIsClosing">
michael@0:         false
michael@0:       </field>
michael@0: 
michael@0:       <method name="_beginRemoveTab">
michael@0:         <parameter name="aTab"/>
michael@0:         <parameter name="aTabWillBeMoved"/>
michael@0:         <parameter name="aCloseWindowWithLastTab"/>
michael@0:         <parameter name="aCloseWindowFastpath"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             if (aTab.closing ||
michael@0:                 this._windowIsClosing)
michael@0:               return false;
michael@0: 
michael@0:             var browser = this.getBrowserForTab(aTab);
michael@0: 
michael@0:             if (!aTabWillBeMoved) {
michael@0:               let ds = browser.docShell;
michael@0:               if (ds &&
michael@0:                   ds.contentViewer &&
michael@0:                   !ds.contentViewer.permitUnload()) {
michael@0:                 return false;
michael@0:               }
michael@0:             }
michael@0: 
michael@0:             var closeWindow = false;
michael@0:             var newTab = false;
michael@0:             if (this.tabs.length - this._removingTabs.length == 1) {
michael@0:               closeWindow = aCloseWindowWithLastTab != null ? aCloseWindowWithLastTab :
michael@0:                             !window.toolbar.visible ||
michael@0:                               Services.prefs.getBoolPref("browser.tabs.closeWindowWithLastTab");
michael@0: 
michael@0:               // Closing the tab and replacing it with a blank one is notably slower
michael@0:               // than closing the window right away. If the caller opts in, take
michael@0:               // the fast path.
michael@0:               if (closeWindow &&
michael@0:                   aCloseWindowFastpath &&
michael@0:                   this._removingTabs.length == 0) {
michael@0:                 // This call actually closes the window, unless the user
michael@0:                 // cancels the operation.  We are finished here in both cases.
michael@0:                 this._windowIsClosing = window.closeWindow(true, window.warnAboutClosingWindow);
michael@0:                 return null;
michael@0:               }
michael@0: 
michael@0:               newTab = true;
michael@0:             }
michael@0: 
michael@0:             aTab.closing = true;
michael@0:             this._removingTabs.push(aTab);
michael@0:             this._visibleTabs = null; // invalidate cache
michael@0: 
michael@0:             // Invalidate hovered tab state tracking for this closing tab.
michael@0:             if (this.tabContainer._hoveredTab == aTab)
michael@0:               aTab._mouseleave();
michael@0: 
michael@0:             if (newTab)
michael@0:               this.addTab(BROWSER_NEW_TAB_URL, {skipAnimation: true});
michael@0:             else
michael@0:               this.tabContainer.updateVisibility();
michael@0: 
michael@0:             // We're committed to closing the tab now.
michael@0:             // Dispatch a notification.
michael@0:             // We dispatch it before any teardown so that event listeners can
michael@0:             // inspect the tab that's about to close.
michael@0:             var evt = document.createEvent("UIEvent");
michael@0:             evt.initUIEvent("TabClose", true, false, window, aTabWillBeMoved ? 1 : 0);
michael@0:             aTab.dispatchEvent(evt);
michael@0: 
michael@0:             if (!aTabWillBeMoved && !gMultiProcessBrowser) {
michael@0:               // Prevent this tab from showing further dialogs, since we're closing it
michael@0:               var windowUtils = browser.contentWindow.QueryInterface(Ci.nsIInterfaceRequestor).
michael@0:                                 getInterface(Ci.nsIDOMWindowUtils);
michael@0:               windowUtils.disableDialogs();
michael@0:             }
michael@0: 
michael@0:             // Remove the tab's filter and progress listener.
michael@0:             const filter = this.mTabFilters[aTab._tPos];
michael@0: 
michael@0:             browser.webProgress.removeProgressListener(filter);
michael@0: 
michael@0:             filter.removeProgressListener(this.mTabListeners[aTab._tPos]);
michael@0:             this.mTabListeners[aTab._tPos].destroy();
michael@0: 
michael@0:             if (browser.registeredOpenURI && !aTabWillBeMoved) {
michael@0:               this._placesAutocomplete.unregisterOpenPage(browser.registeredOpenURI);
michael@0:               this._unifiedComplete.unregisterOpenPage(browser.registeredOpenURI);
michael@0:               delete browser.registeredOpenURI;
michael@0:             }
michael@0: 
michael@0:             // We are no longer the primary content area.
michael@0:             browser.setAttribute("type", "content-targetable");
michael@0: 
michael@0:             // Remove this tab as the owner of any other tabs, since it's going away.
michael@0:             Array.forEach(this.tabs, function (tab) {
michael@0:               if ("owner" in tab && tab.owner == aTab)
michael@0:                 // |tab| is a child of the tab we're removing, make it an orphan
michael@0:                 tab.owner = null;
michael@0:             });
michael@0: 
michael@0:             aTab._endRemoveArgs = [closeWindow, newTab];
michael@0:             return true;
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_endRemoveTab">
michael@0:         <parameter name="aTab"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             if (!aTab || !aTab._endRemoveArgs)
michael@0:               return;
michael@0: 
michael@0:             var [aCloseWindow, aNewTab] = aTab._endRemoveArgs;
michael@0:             aTab._endRemoveArgs = null;
michael@0: 
michael@0:             if (this._windowIsClosing) {
michael@0:               aCloseWindow = false;
michael@0:               aNewTab = false;
michael@0:             }
michael@0: 
michael@0:             this._lastRelatedTab = null;
michael@0: 
michael@0:             // update the UI early for responsiveness
michael@0:             aTab.collapsed = true;
michael@0:             this.tabContainer._fillTrailingGap();
michael@0:             this._blurTab(aTab);
michael@0: 
michael@0:             this._removingTabs.splice(this._removingTabs.indexOf(aTab), 1);
michael@0: 
michael@0:             if (aCloseWindow) {
michael@0:               this._windowIsClosing = true;
michael@0:               while (this._removingTabs.length)
michael@0:                 this._endRemoveTab(this._removingTabs[0]);
michael@0:             } else if (!this._windowIsClosing) {
michael@0:               if (aNewTab)
michael@0:                 focusAndSelectUrlBar();
michael@0: 
michael@0:               // workaround for bug 345399
michael@0:               this.tabContainer.mTabstrip._updateScrollButtonsDisabledState();
michael@0:             }
michael@0: 
michael@0:             // We're going to remove the tab and the browser now.
michael@0:             // Clean up mTabFilters and mTabListeners now rather than in
michael@0:             // _beginRemoveTab, so that their size is always in sync with the
michael@0:             // number of tabs and browsers (the xbl destructor depends on this).
michael@0:             this.mTabFilters.splice(aTab._tPos, 1);
michael@0:             this.mTabListeners.splice(aTab._tPos, 1);
michael@0: 
michael@0:             var browser = this.getBrowserForTab(aTab);
michael@0: 
michael@0:             // Because of the way XBL works (fields just set JS
michael@0:             // properties on the element) and the code we have in place
michael@0:             // to preserve the JS objects for any elements that have
michael@0:             // JS properties set on them, the browser element won't be
michael@0:             // destroyed until the document goes away.  So we force a
michael@0:             // cleanup ourselves.
michael@0:             // This has to happen before we remove the child so that the
michael@0:             // XBL implementation of nsIObserver still works.
michael@0:             browser.destroy();
michael@0: 
michael@0:             var wasPinned = aTab.pinned;
michael@0: 
michael@0:             // Invalidate browsers cache, as the tab is removed from the
michael@0:             // tab container.
michael@0:             this._browsers = null;
michael@0: 
michael@0:             // Remove the tab ...
michael@0:             this.tabContainer.removeChild(aTab);
michael@0: 
michael@0:             // ... and fix up the _tPos properties immediately.
michael@0:             for (let i = aTab._tPos; i < this.tabs.length; i++)
michael@0:               this.tabs[i]._tPos = i;
michael@0: 
michael@0:             if (!this._windowIsClosing) {
michael@0:               if (wasPinned)
michael@0:                 this.tabContainer._positionPinnedTabs();
michael@0: 
michael@0:               // update tab close buttons state
michael@0:               this.tabContainer.adjustTabstrip();
michael@0: 
michael@0:               setTimeout(function(tabs) {
michael@0:                 tabs._lastTabClosedByMouse = false;
michael@0:               }, 0, this.tabContainer);
michael@0:             }
michael@0: 
michael@0:             // update tab positional properties and attributes
michael@0:             this.selectedTab._selected = true;
michael@0:             this.tabContainer._setPositionalAttributes();
michael@0: 
michael@0:             // Removing the panel requires fixing up selectedPanel immediately
michael@0:             // (see below), which would be hindered by the potentially expensive
michael@0:             // browser removal. So we remove the browser and the panel in two
michael@0:             // steps.
michael@0: 
michael@0:             var panel = this.getNotificationBox(browser);
michael@0: 
michael@0:             // This will unload the document. An unload handler could remove
michael@0:             // dependant tabs, so it's important that the tabbrowser is now in
michael@0:             // a consistent state (tab removed, tab positions updated, etc.).
michael@0:             browser.parentNode.removeChild(browser);
michael@0: 
michael@0:             // Release the browser in case something is erroneously holding a
michael@0:             // reference to the tab after its removal.
michael@0:             aTab.linkedBrowser = null;
michael@0: 
michael@0:             // As the browser is removed, the removal of a dependent document can
michael@0:             // cause the whole window to close. So at this point, it's possible
michael@0:             // that the binding is destructed.
michael@0:             if (this.mTabBox) {
michael@0:               let selectedPanel = this.mTabBox.selectedPanel;
michael@0: 
michael@0:               this.mPanelContainer.removeChild(panel);
michael@0: 
michael@0:               // Under the hood, a selectedIndex attribute controls which panel
michael@0:               // is displayed. Removing a panel A which precedes the selected
michael@0:               // panel B makes selectedIndex point to the panel next to B. We
michael@0:               // need to explicitly preserve B as the selected panel.
michael@0:               this.mTabBox.selectedPanel = selectedPanel;
michael@0:             }
michael@0: 
michael@0:             if (aCloseWindow)
michael@0:               this._windowIsClosing = closeWindow(true, window.warnAboutClosingWindow);
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_blurTab">
michael@0:         <parameter name="aTab"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             if (!aTab.selected)
michael@0:               return;
michael@0: 
michael@0:             if (aTab.owner &&
michael@0:                 !aTab.owner.hidden &&
michael@0:                 !aTab.owner.closing &&
michael@0:                 Services.prefs.getBoolPref("browser.tabs.selectOwnerOnClose")) {
michael@0:               this.selectedTab = aTab.owner;
michael@0:               return;
michael@0:             }
michael@0: 
michael@0:             // Switch to a visible tab unless there aren't any others remaining
michael@0:             let remainingTabs = this.visibleTabs;
michael@0:             let numTabs = remainingTabs.length;
michael@0:             if (numTabs == 0 || numTabs == 1 && remainingTabs[0] == aTab) {
michael@0:               remainingTabs = Array.filter(this.tabs, function(tab) {
michael@0:                 return !tab.closing;
michael@0:               }, this);
michael@0:             }
michael@0: 
michael@0:             // Try to find a remaining tab that comes after the given tab
michael@0:             var tab = aTab;
michael@0:             do {
michael@0:               tab = tab.nextSibling;
michael@0:             } while (tab && remainingTabs.indexOf(tab) == -1);
michael@0: 
michael@0:             if (!tab) {
michael@0:               tab = aTab;
michael@0: 
michael@0:               do {
michael@0:                 tab = tab.previousSibling;
michael@0:               } while (tab && remainingTabs.indexOf(tab) == -1);
michael@0:             }
michael@0: 
michael@0:             this.selectedTab = tab;
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="swapNewTabWithBrowser">
michael@0:         <parameter name="aNewTab"/>
michael@0:         <parameter name="aBrowser"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             // The browser must be standalone.
michael@0:             if (aBrowser.getTabBrowser())
michael@0:               throw Cr.NS_ERROR_INVALID_ARG;
michael@0: 
michael@0:             // The tab is definitely not loading.
michael@0:             aNewTab.removeAttribute("busy");
michael@0:             if (aNewTab.selected) {
michael@0:               this.mIsBusy = false;
michael@0:             }
michael@0: 
michael@0:             this._swapBrowserDocShells(aNewTab, aBrowser);
michael@0: 
michael@0:             // Update the new tab's title.
michael@0:             this.setTabTitle(aNewTab);
michael@0: 
michael@0:             if (aNewTab.selected) {
michael@0:               this.updateCurrentBrowser(true);
michael@0:             }
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="swapBrowsersAndCloseOther">
michael@0:         <parameter name="aOurTab"/>
michael@0:         <parameter name="aOtherTab"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             // Do not allow transfering a private tab to a non-private window
michael@0:             // and vice versa.
michael@0:             if (PrivateBrowsingUtils.isWindowPrivate(window) !=
michael@0:                 PrivateBrowsingUtils.isWindowPrivate(aOtherTab.ownerDocument.defaultView))
michael@0:               return;
michael@0: 
michael@0:             // That's gBrowser for the other window, not the tab's browser!
michael@0:             var remoteBrowser = aOtherTab.ownerDocument.defaultView.gBrowser;
michael@0:             var isPending = aOtherTab.hasAttribute("pending");
michael@0: 
michael@0:             // First, start teardown of the other browser.  Make sure to not
michael@0:             // fire the beforeunload event in the process.  Close the other
michael@0:             // window if this was its last tab.
michael@0:             if (!remoteBrowser._beginRemoveTab(aOtherTab, true, true))
michael@0:               return;
michael@0: 
michael@0:             let ourBrowser = this.getBrowserForTab(aOurTab);
michael@0:             let otherBrowser = aOtherTab.linkedBrowser;
michael@0: 
michael@0:             // If the other tab is pending (i.e. has not been restored, yet)
michael@0:             // then do not switch docShells but retrieve the other tab's state
michael@0:             // and apply it to our tab.
michael@0:             if (isPending) {
michael@0:               SessionStore.setTabState(aOurTab, SessionStore.getTabState(aOtherTab));
michael@0: 
michael@0:               // Make sure to unregister any open URIs.
michael@0:               this._swapRegisteredOpenURIs(ourBrowser, otherBrowser);
michael@0:             } else {
michael@0:               // Workarounds for bug 458697
michael@0:               // Icon might have been set on DOMLinkAdded, don't override that.
michael@0:               if (!ourBrowser.mIconURL && otherBrowser.mIconURL)
michael@0:                 this.setIcon(aOurTab, otherBrowser.mIconURL);
michael@0:               var isBusy = aOtherTab.hasAttribute("busy");
michael@0:               if (isBusy) {
michael@0:                 aOurTab.setAttribute("busy", "true");
michael@0:                 this._tabAttrModified(aOurTab);
michael@0:                 if (aOurTab.selected)
michael@0:                   this.mIsBusy = true;
michael@0:               }
michael@0: 
michael@0:               this._swapBrowserDocShells(aOurTab, otherBrowser);
michael@0:             }
michael@0: 
michael@0:             // Handle findbar data (if any)
michael@0:             let otherFindBar = aOtherTab._findBar;
michael@0:             if (otherFindBar &&
michael@0:                 otherFindBar.findMode == otherFindBar.FIND_NORMAL) {
michael@0:               let ourFindBar = this.getFindBar(aOurTab);
michael@0:               ourFindBar._findField.value = otherFindBar._findField.value;
michael@0:               if (!otherFindBar.hidden)
michael@0:                 ourFindBar.onFindCommand();
michael@0:             }
michael@0: 
michael@0:             // Finish tearing down the tab that's going away.
michael@0:             remoteBrowser._endRemoveTab(aOtherTab);
michael@0: 
michael@0:             if (isBusy)
michael@0:               this.setTabTitleLoading(aOurTab);
michael@0:             else
michael@0:               this.setTabTitle(aOurTab);
michael@0: 
michael@0:             // If the tab was already selected (this happpens in the scenario
michael@0:             // of replaceTabWithWindow), notify onLocationChange, etc.
michael@0:             if (aOurTab.selected)
michael@0:               this.updateCurrentBrowser(true);
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_swapBrowserDocShells">
michael@0:         <parameter name="aOurTab"/>
michael@0:         <parameter name="aOtherBrowser"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             // Unhook our progress listener
michael@0:             let index = aOurTab._tPos;
michael@0:             const filter = this.mTabFilters[index];
michael@0:             let tabListener = this.mTabListeners[index];
michael@0:             let ourBrowser = this.getBrowserForTab(aOurTab);
michael@0:             ourBrowser.webProgress.removeProgressListener(filter);
michael@0:             filter.removeProgressListener(tabListener);
michael@0: 
michael@0:             // Make sure to unregister any open URIs.
michael@0:             this._swapRegisteredOpenURIs(ourBrowser, aOtherBrowser);
michael@0: 
michael@0:             // Give others a chance to swap state.
michael@0:             let event = new CustomEvent("SwapDocShells", {"detail": aOtherBrowser});
michael@0:             ourBrowser.dispatchEvent(event);
michael@0: 
michael@0:             // Swap the docshells
michael@0:             ourBrowser.swapDocShells(aOtherBrowser);
michael@0: 
michael@0:             // Restore the progress listener
michael@0:             this.mTabListeners[index] = tabListener =
michael@0:               this.mTabProgressListener(aOurTab, ourBrowser, false);
michael@0: 
michael@0:             const notifyAll = Ci.nsIWebProgress.NOTIFY_ALL;
michael@0:             filter.addProgressListener(tabListener, notifyAll);
michael@0:             ourBrowser.webProgress.addProgressListener(filter, notifyAll);
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_swapRegisteredOpenURIs">
michael@0:         <parameter name="aOurBrowser"/>
michael@0:         <parameter name="aOtherBrowser"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             // If the current URI is registered as open remove it from the list.
michael@0:             if (aOurBrowser.registeredOpenURI) {
michael@0:               this._placesAutocomplete.unregisterOpenPage(aOurBrowser.registeredOpenURI);
michael@0:               this._unifiedComplete.unregisterOpenPage(aOurBrowser.registeredOpenURI);
michael@0:               delete aOurBrowser.registeredOpenURI;
michael@0:             }
michael@0: 
michael@0:             // If the other/new URI is registered as open then copy it over.
michael@0:             if (aOtherBrowser.registeredOpenURI) {
michael@0:               aOurBrowser.registeredOpenURI = aOtherBrowser.registeredOpenURI;
michael@0:               delete aOtherBrowser.registeredOpenURI;
michael@0:             }
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="reloadAllTabs">
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             let tabs = this.visibleTabs;
michael@0:             let l = tabs.length;
michael@0:             for (var i = 0; i < l; i++) {
michael@0:               try {
michael@0:                 this.getBrowserForTab(tabs[i]).reload();
michael@0:               } catch (e) {
michael@0:                 // ignore failure to reload so others will be reloaded
michael@0:               }
michael@0:             }
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="reloadTab">
michael@0:         <parameter name="aTab"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             this.getBrowserForTab(aTab).reload();
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="addProgressListener">
michael@0:         <parameter name="aListener"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             if (arguments.length != 1) {
michael@0:               Components.utils.reportError("gBrowser.addProgressListener was " +
michael@0:                                            "called with a second argument, " +
michael@0:                                            "which is not supported. See bug " +
michael@0:                                            "608628. Call stack: " + new Error().stack);
michael@0:             }
michael@0: 
michael@0:             this.mProgressListeners.push(aListener);
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="removeProgressListener">
michael@0:         <parameter name="aListener"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             this.mProgressListeners =
michael@0:               this.mProgressListeners.filter(function (l) l != aListener);
michael@0:          ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="addTabsProgressListener">
michael@0:         <parameter name="aListener"/>
michael@0:         <body>
michael@0:           this.mTabsProgressListeners.push(aListener);
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="removeTabsProgressListener">
michael@0:         <parameter name="aListener"/>
michael@0:         <body>
michael@0:         <![CDATA[
michael@0:           this.mTabsProgressListeners =
michael@0:             this.mTabsProgressListeners.filter(function (l) l != aListener);
michael@0:         ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="getBrowserForTab">
michael@0:         <parameter name="aTab"/>
michael@0:         <body>
michael@0:         <![CDATA[
michael@0:           return aTab.linkedBrowser;
michael@0:         ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="showOnlyTheseTabs">
michael@0:         <parameter name="aTabs"/>
michael@0:         <body>
michael@0:         <![CDATA[
michael@0:           Array.forEach(this.tabs, function(tab) {
michael@0:             if (aTabs.indexOf(tab) == -1)
michael@0:               this.hideTab(tab);
michael@0:             else
michael@0:               this.showTab(tab);
michael@0:           }, this);
michael@0: 
michael@0:           this.tabContainer._handleTabSelect(false);
michael@0:         ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="showTab">
michael@0:         <parameter name="aTab"/>
michael@0:         <body>
michael@0:         <![CDATA[
michael@0:           if (aTab.hidden) {
michael@0:             aTab.removeAttribute("hidden");
michael@0:             this._visibleTabs = null; // invalidate cache
michael@0: 
michael@0:             this.tabContainer.adjustTabstrip();
michael@0: 
michael@0:             this.tabContainer._setPositionalAttributes();
michael@0: 
michael@0:             let event = document.createEvent("Events");
michael@0:             event.initEvent("TabShow", true, false);
michael@0:             aTab.dispatchEvent(event);
michael@0:           }
michael@0:         ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="hideTab">
michael@0:         <parameter name="aTab"/>
michael@0:         <body>
michael@0:         <![CDATA[
michael@0:           if (!aTab.hidden && !aTab.pinned && !aTab.selected &&
michael@0:               !aTab.closing) {
michael@0:             aTab.setAttribute("hidden", "true");
michael@0:             this._visibleTabs = null; // invalidate cache
michael@0: 
michael@0:             this.tabContainer.adjustTabstrip();
michael@0: 
michael@0:             this.tabContainer._setPositionalAttributes();
michael@0: 
michael@0:             let event = document.createEvent("Events");
michael@0:             event.initEvent("TabHide", true, false);
michael@0:             aTab.dispatchEvent(event);
michael@0:           }
michael@0:         ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="selectTabAtIndex">
michael@0:         <parameter name="aIndex"/>
michael@0:         <parameter name="aEvent"/>
michael@0:         <body>
michael@0:         <![CDATA[
michael@0:           let tabs = this.visibleTabs;
michael@0: 
michael@0:           // count backwards for aIndex < 0
michael@0:           if (aIndex < 0)
michael@0:             aIndex += tabs.length;
michael@0: 
michael@0:           if (aIndex >= 0 && aIndex < tabs.length)
michael@0:             this.selectedTab = tabs[aIndex];
michael@0: 
michael@0:           if (aEvent) {
michael@0:             aEvent.preventDefault();
michael@0:             aEvent.stopPropagation();
michael@0:           }
michael@0:         ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <property name="selectedTab">
michael@0:         <getter>
michael@0:           return this.mCurrentTab;
michael@0:         </getter>
michael@0:         <setter>
michael@0:           <![CDATA[
michael@0:           // Update the tab
michael@0:           this.mTabBox.selectedTab = val;
michael@0:           return val;
michael@0:           ]]>
michael@0:         </setter>
michael@0:       </property>
michael@0: 
michael@0:       <property name="selectedBrowser"
michael@0:                 onget="return this.mCurrentBrowser;"
michael@0:                 readonly="true"/>
michael@0: 
michael@0:       <property name="browsers" readonly="true">
michael@0:        <getter>
michael@0:           <![CDATA[
michael@0:             return this._browsers ||
michael@0:                    (this._browsers = Array.map(this.tabs, function (tab) tab.linkedBrowser));
michael@0:           ]]>
michael@0:         </getter>
michael@0:       </property>
michael@0:       <field name="_browsers">null</field>
michael@0: 
michael@0:       <!-- Moves a tab to a new browser window, unless it's already the only tab
michael@0:            in the current window, in which case this will do nothing. -->
michael@0:       <method name="replaceTabWithWindow">
michael@0:         <parameter name="aTab"/>
michael@0:         <parameter name="aOptions"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             if (this.tabs.length == 1)
michael@0:               return null;
michael@0: 
michael@0:             let event = new CustomEvent("TabBecomingWindow", {
michael@0:               bubbles: true,
michael@0:               cancelable: true
michael@0:             });
michael@0:             aTab.dispatchEvent(event);
michael@0:             if (event.defaultPrevented) {
michael@0:               return null;
michael@0:             }
michael@0: 
michael@0:             var options = "chrome,dialog=no,all";
michael@0:             for (var name in aOptions)
michael@0:               options += "," + name + "=" + aOptions[name];
michael@0: 
michael@0:             // tell a new window to take the "dropped" tab
michael@0:             return window.openDialog(getBrowserURL(), "_blank", options, aTab);
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="moveTabTo">
michael@0:         <parameter name="aTab"/>
michael@0:         <parameter name="aIndex"/>
michael@0:         <body>
michael@0:         <![CDATA[
michael@0:           var oldPosition = aTab._tPos;
michael@0:           if (oldPosition == aIndex)
michael@0:             return;
michael@0: 
michael@0:           // Don't allow mixing pinned and unpinned tabs.
michael@0:           if (aTab.pinned)
michael@0:             aIndex = Math.min(aIndex, this._numPinnedTabs - 1);
michael@0:           else
michael@0:             aIndex = Math.max(aIndex, this._numPinnedTabs);
michael@0:           if (oldPosition == aIndex)
michael@0:             return;
michael@0: 
michael@0:           this._lastRelatedTab = null;
michael@0: 
michael@0:           this.mTabFilters.splice(aIndex, 0, this.mTabFilters.splice(aTab._tPos, 1)[0]);
michael@0:           this.mTabListeners.splice(aIndex, 0, this.mTabListeners.splice(aTab._tPos, 1)[0]);
michael@0: 
michael@0:           let wasFocused = (document.activeElement == this.mCurrentTab);
michael@0: 
michael@0:           aIndex = aIndex < aTab._tPos ? aIndex: aIndex+1;
michael@0:           this.mCurrentTab._selected = false;
michael@0: 
michael@0:           // invalidate caches
michael@0:           this._browsers = null;
michael@0:           this._visibleTabs = null;
michael@0: 
michael@0:           // use .item() instead of [] because dragging to the end of the strip goes out of
michael@0:           // bounds: .item() returns null (so it acts like appendChild), but [] throws
michael@0:           this.tabContainer.insertBefore(aTab, this.tabs.item(aIndex));
michael@0: 
michael@0:           for (let i = 0; i < this.tabs.length; i++) {
michael@0:             this.tabs[i]._tPos = i;
michael@0:             this.tabs[i]._selected = false;
michael@0:           }
michael@0:           this.mCurrentTab._selected = true;
michael@0: 
michael@0:           if (wasFocused)
michael@0:             this.mCurrentTab.focus();
michael@0: 
michael@0:           this.tabContainer._handleTabSelect(false);
michael@0: 
michael@0:           if (aTab.pinned)
michael@0:             this.tabContainer._positionPinnedTabs();
michael@0: 
michael@0:           this.tabContainer._setPositionalAttributes();
michael@0: 
michael@0:           var evt = document.createEvent("UIEvents");
michael@0:           evt.initUIEvent("TabMove", true, false, window, oldPosition);
michael@0:           aTab.dispatchEvent(evt);
michael@0:         ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="moveTabForward">
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             let nextTab = this.mCurrentTab.nextSibling;
michael@0:             while (nextTab && nextTab.hidden)
michael@0:               nextTab = nextTab.nextSibling;
michael@0: 
michael@0:             if (nextTab)
michael@0:               this.moveTabTo(this.mCurrentTab, nextTab._tPos);
michael@0:             else if (this.arrowKeysShouldWrap)
michael@0:               this.moveTabToStart();
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="moveTabBackward">
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             let previousTab = this.mCurrentTab.previousSibling;
michael@0:             while (previousTab && previousTab.hidden)
michael@0:               previousTab = previousTab.previousSibling;
michael@0: 
michael@0:             if (previousTab)
michael@0:               this.moveTabTo(this.mCurrentTab, previousTab._tPos);
michael@0:             else if (this.arrowKeysShouldWrap)
michael@0:               this.moveTabToEnd();
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="moveTabToStart">
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             var tabPos = this.mCurrentTab._tPos;
michael@0:             if (tabPos > 0)
michael@0:               this.moveTabTo(this.mCurrentTab, 0);
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="moveTabToEnd">
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             var tabPos = this.mCurrentTab._tPos;
michael@0:             if (tabPos < this.browsers.length - 1)
michael@0:               this.moveTabTo(this.mCurrentTab, this.browsers.length - 1);
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="moveTabOver">
michael@0:         <parameter name="aEvent"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             var direction = window.getComputedStyle(this.parentNode, null).direction;
michael@0:             if ((direction == "ltr" && aEvent.keyCode == KeyEvent.DOM_VK_RIGHT) ||
michael@0:                 (direction == "rtl" && aEvent.keyCode == KeyEvent.DOM_VK_LEFT))
michael@0:               this.moveTabForward();
michael@0:             else
michael@0:               this.moveTabBackward();
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="duplicateTab">
michael@0:         <parameter name="aTab"/><!-- can be from a different window as well -->
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             return SessionStore.duplicateTab(window, aTab);
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <!-- BEGIN FORWARDED BROWSER PROPERTIES.  IF YOU ADD A PROPERTY TO THE BROWSER ELEMENT
michael@0:            MAKE SURE TO ADD IT HERE AS WELL. -->
michael@0:       <property name="canGoBack"
michael@0:                 onget="return this.mCurrentBrowser.canGoBack;"
michael@0:                 readonly="true"/>
michael@0: 
michael@0:       <property name="canGoForward"
michael@0:                 onget="return this.mCurrentBrowser.canGoForward;"
michael@0:                 readonly="true"/>
michael@0: 
michael@0:       <method name="goBack">
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             return this.mCurrentBrowser.goBack();
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="goForward">
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             return this.mCurrentBrowser.goForward();
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="reload">
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             return this.mCurrentBrowser.reload();
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="reloadWithFlags">
michael@0:         <parameter name="aFlags"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             return this.mCurrentBrowser.reloadWithFlags(aFlags);
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="stop">
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             return this.mCurrentBrowser.stop();
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <!-- throws exception for unknown schemes -->
michael@0:       <method name="loadURI">
michael@0:         <parameter name="aURI"/>
michael@0:         <parameter name="aReferrerURI"/>
michael@0:         <parameter name="aCharset"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0: #ifdef MAKE_E10S_WORK
michael@0:             this.updateBrowserRemoteness(this.mCurrentBrowser, aURI);
michael@0:             try {
michael@0: #endif
michael@0:             return this.mCurrentBrowser.loadURI(aURI, aReferrerURI, aCharset);
michael@0: #ifdef MAKE_E10S_WORK
michael@0:             } catch (e) {
michael@0:               let url = this.mCurrentBrowser.currentURI.spec;
michael@0:               this.updateBrowserRemoteness(this.mCurrentBrowser, url);
michael@0:               throw e;
michael@0:             }
michael@0: #endif
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <!-- throws exception for unknown schemes -->
michael@0:       <method name="loadURIWithFlags">
michael@0:         <parameter name="aURI"/>
michael@0:         <parameter name="aFlags"/>
michael@0:         <parameter name="aReferrerURI"/>
michael@0:         <parameter name="aCharset"/>
michael@0:         <parameter name="aPostData"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0: #ifdef MAKE_E10S_WORK
michael@0:             this.updateBrowserRemoteness(this.mCurrentBrowser, aURI);
michael@0:             try {
michael@0: #endif
michael@0:             return this.mCurrentBrowser.loadURIWithFlags(aURI, aFlags, aReferrerURI, aCharset, aPostData);
michael@0: #ifdef MAKE_E10S_WORK
michael@0:             } catch (e) {
michael@0:               let url = this.mCurrentBrowser.currentURI.spec;
michael@0:               this.updateBrowserRemoteness(this.mCurrentBrowser, url);
michael@0:               throw e;
michael@0:             }
michael@0: #endif
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="goHome">
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             return this.mCurrentBrowser.goHome();
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <property name="homePage">
michael@0:         <getter>
michael@0:           <![CDATA[
michael@0:             return this.mCurrentBrowser.homePage;
michael@0:           ]]>
michael@0:         </getter>
michael@0:         <setter>
michael@0:           <![CDATA[
michael@0:             this.mCurrentBrowser.homePage = val;
michael@0:             return val;
michael@0:           ]]>
michael@0:         </setter>
michael@0:       </property>
michael@0: 
michael@0:       <method name="gotoIndex">
michael@0:         <parameter name="aIndex"/>
michael@0:         <body>
michael@0:           <![CDATA[
michael@0:             return this.mCurrentBrowser.gotoIndex(aIndex);
michael@0:           ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="attachFormFill">
michael@0:         <body><![CDATA[
michael@0:           for (var i = 0; i < this.mPanelContainer.childNodes.length; ++i) {
michael@0:             var cb = this.getBrowserAtIndex(i);
michael@0:             cb.attachFormFill();
michael@0:           }
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="detachFormFill">
michael@0:         <body><![CDATA[
michael@0:           for (var i = 0; i < this.mPanelContainer.childNodes.length; ++i) {
michael@0:             var cb = this.getBrowserAtIndex(i);
michael@0:             cb.detachFormFill();
michael@0:           }
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <property name="currentURI"
michael@0:                 onget="return this.mCurrentBrowser.currentURI;"
michael@0:                 readonly="true"/>
michael@0: 
michael@0:       <property name="finder"
michael@0:                 onget="return this.mCurrentBrowser.finder"
michael@0:                 readonly="true"/>
michael@0: 
michael@0:       <property name="docShell"
michael@0:                 onget="return this.mCurrentBrowser.docShell"
michael@0:                 readonly="true"/>
michael@0: 
michael@0:       <property name="webNavigation"
michael@0:                 onget="return this.mCurrentBrowser.webNavigation"
michael@0:                 readonly="true"/>
michael@0: 
michael@0:       <property name="webBrowserFind"
michael@0:                 readonly="true"
michael@0:                 onget="return this.mCurrentBrowser.webBrowserFind"/>
michael@0: 
michael@0:       <property name="webProgress"
michael@0:                 readonly="true"
michael@0:                 onget="return this.mCurrentBrowser.webProgress"/>
michael@0: 
michael@0:       <property name="contentWindow"
michael@0:                 readonly="true"
michael@0:                 onget="return this.mCurrentBrowser.contentWindow"/>
michael@0: 
michael@0:       <property name="sessionHistory"
michael@0:                 onget="return this.mCurrentBrowser.sessionHistory;"
michael@0:                 readonly="true"/>
michael@0: 
michael@0:       <property name="markupDocumentViewer"
michael@0:                 onget="return this.mCurrentBrowser.markupDocumentViewer;"
michael@0:                 readonly="true"/>
michael@0: 
michael@0:       <property name="contentViewerEdit"
michael@0:                 onget="return this.mCurrentBrowser.contentViewerEdit;"
michael@0:                 readonly="true"/>
michael@0: 
michael@0:       <property name="contentViewerFile"
michael@0:                 onget="return this.mCurrentBrowser.contentViewerFile;"
michael@0:                 readonly="true"/>
michael@0: 
michael@0:       <property name="contentDocument"
michael@0:                 onget="return this.mCurrentBrowser.contentDocument;"
michael@0:                 readonly="true"/>
michael@0: 
michael@0:       <property name="contentTitle"
michael@0:                 onget="return this.mCurrentBrowser.contentTitle;"
michael@0:                 readonly="true"/>
michael@0: 
michael@0:       <property name="contentPrincipal"
michael@0:                 onget="return this.mCurrentBrowser.contentPrincipal;"
michael@0:                 readonly="true"/>
michael@0: 
michael@0:       <property name="securityUI"
michael@0:                 onget="return this.mCurrentBrowser.securityUI;"
michael@0:                 readonly="true"/>
michael@0: 
michael@0:       <property name="fullZoom"
michael@0:                 onget="return this.mCurrentBrowser.fullZoom;"
michael@0:                 onset="this.mCurrentBrowser.fullZoom = val;"/>
michael@0: 
michael@0:       <property name="textZoom"
michael@0:                 onget="return this.mCurrentBrowser.textZoom;"
michael@0:                 onset="this.mCurrentBrowser.textZoom = val;"/>
michael@0: 
michael@0:       <property name="isSyntheticDocument"
michael@0:                 onget="return this.mCurrentBrowser.isSyntheticDocument;"
michael@0:                 readonly="true"/>
michael@0: 
michael@0:       <method name="_handleKeyEvent">
michael@0:         <parameter name="aEvent"/>
michael@0:         <body><![CDATA[
michael@0:           if (!aEvent.isTrusted) {
michael@0:             // Don't let untrusted events mess with tabs.
michael@0:             return;
michael@0:           }
michael@0: 
michael@0:           if (aEvent.altKey)
michael@0:             return;
michael@0: 
michael@0:           if (aEvent.ctrlKey && aEvent.shiftKey && !aEvent.metaKey) {
michael@0:             switch (aEvent.keyCode) {
michael@0:               case aEvent.DOM_VK_PAGE_UP:
michael@0:                 this.moveTabBackward();
michael@0:                 aEvent.stopPropagation();
michael@0:                 aEvent.preventDefault();
michael@0:                 return;
michael@0:               case aEvent.DOM_VK_PAGE_DOWN:
michael@0:                 this.moveTabForward();
michael@0:                 aEvent.stopPropagation();
michael@0:                 aEvent.preventDefault();
michael@0:                 return;
michael@0:             }
michael@0:           }
michael@0: 
michael@0:           // We need to take care of FAYT-watching as long as the findbar
michael@0:           // isn't initialized.  The checks on aEvent are copied from
michael@0:           // _shouldFastFind (see findbar.xml).
michael@0:           if (!gFindBarInitialized &&
michael@0:               !(aEvent.ctrlKey || aEvent.metaKey) &&
michael@0:               !aEvent.defaultPrevented) {
michael@0:             let charCode = aEvent.charCode;
michael@0:             if (charCode) {
michael@0:               let char = String.fromCharCode(charCode);
michael@0:               if (char == "'" || char == "/" ||
michael@0:                   Services.prefs.getBoolPref("accessibility.typeaheadfind")) {
michael@0:                 gFindBar._onBrowserKeypress(aEvent);
michael@0:                 return;
michael@0:               }
michael@0:             }
michael@0:           }
michael@0: 
michael@0: #ifdef XP_MACOSX
michael@0:           if (!aEvent.metaKey)
michael@0:             return;
michael@0: 
michael@0:           var offset = 1;
michael@0:           switch (aEvent.charCode) {
michael@0:             case '}'.charCodeAt(0):
michael@0:               offset = -1;
michael@0:             case '{'.charCodeAt(0):
michael@0:               if (window.getComputedStyle(this, null).direction == "ltr")
michael@0:                 offset *= -1;
michael@0:               this.tabContainer.advanceSelectedTab(offset, true);
michael@0:               aEvent.stopPropagation();
michael@0:               aEvent.preventDefault();
michael@0:           }
michael@0: #else
michael@0:           if (aEvent.ctrlKey && !aEvent.shiftKey && !aEvent.metaKey &&
michael@0:               aEvent.keyCode == KeyEvent.DOM_VK_F4 &&
michael@0:               !this.mCurrentTab.pinned) {
michael@0:             this.removeCurrentTab({animate: true});
michael@0:             aEvent.stopPropagation();
michael@0:             aEvent.preventDefault();
michael@0:           }
michael@0: #endif
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <property name="userTypedClear"
michael@0:                 onget="return this.mCurrentBrowser.userTypedClear;"
michael@0:                 onset="return this.mCurrentBrowser.userTypedClear = val;"/>
michael@0: 
michael@0:       <property name="userTypedValue"
michael@0:                 onget="return this.mCurrentBrowser.userTypedValue;"
michael@0:                 onset="return this.mCurrentBrowser.userTypedValue = val;"/>
michael@0: 
michael@0:       <method name="createTooltip">
michael@0:         <parameter name="event"/>
michael@0:         <body><![CDATA[
michael@0:           event.stopPropagation();
michael@0:           var tab = document.tooltipNode;
michael@0:           if (tab.localName != "tab") {
michael@0:             event.preventDefault();
michael@0:             return;
michael@0:           }
michael@0:           event.target.setAttribute("label", tab.mOverCloseButton ?
michael@0:                                              tab.getAttribute("closetabtext") :
michael@0:                                              tab.getAttribute("label"));
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="handleEvent">
michael@0:         <parameter name="aEvent"/>
michael@0:         <body><![CDATA[
michael@0:           switch (aEvent.type) {
michael@0:             case "keypress":
michael@0:               this._handleKeyEvent(aEvent);
michael@0:               break;
michael@0:             case "sizemodechange":
michael@0:               if (aEvent.target == window) {
michael@0:                 this.mCurrentBrowser.docShellIsActive =
michael@0:                   (window.windowState != window.STATE_MINIMIZED);
michael@0:               }
michael@0:               break;
michael@0:           }
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="receiveMessage">
michael@0:         <parameter name="aMessage"/>
michael@0:         <body><![CDATA[
michael@0:           let json = aMessage.json;
michael@0:           let browser = aMessage.target;
michael@0: 
michael@0:           switch (aMessage.name) {
michael@0:             case "DOMTitleChanged": {
michael@0:               let tab = this._getTabForBrowser(browser);
michael@0:               if (!tab || tab.hasAttribute("pending"))
michael@0:                 return;
michael@0:               let titleChanged = this.setTabTitle(tab);
michael@0:               if (titleChanged && !tab.selected && !tab.hasAttribute("busy"))
michael@0:                 tab.setAttribute("titlechanged", "true");
michael@0:               break;
michael@0:             }
michael@0:             case "DOMWindowClose": {
michael@0:               if (this.tabs.length == 1) {
michael@0:                 window.close();
michael@0:                 return;
michael@0:               }
michael@0: 
michael@0:               let tab = this._getTabForBrowser(browser);
michael@0:               if (tab) {
michael@0:                 this.removeTab(tab);
michael@0:               }
michael@0:               break;
michael@0:             }
michael@0:             case "contextmenu": {
michael@0:               gContextMenuContentData = { event: aMessage.objects.event,
michael@0:                                           browser: browser };
michael@0:               let popup = browser.ownerDocument.getElementById("contentAreaContextMenu");
michael@0:               let event = gContextMenuContentData.event;
michael@0:               let pos = browser.mapScreenCoordinatesFromContent(event.screenX, event.screenY);
michael@0:               popup.openPopupAtScreen(pos.x, pos.y, true);
michael@0:               break;
michael@0:             }
michael@0:             case "DOMWebNotificationClicked": {
michael@0:               let tab = this._getTabForBrowser(browser);
michael@0:               if (!tab)
michael@0:                 return;
michael@0:               this.selectedTab = tab;
michael@0:               window.focus();
michael@0:               break;
michael@0:             }
michael@0:           }
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <constructor>
michael@0:         <![CDATA[
michael@0:           let browserStack = document.getAnonymousElementByAttribute(this, "anonid", "browserStack");
michael@0:           this.mCurrentBrowser = document.getAnonymousElementByAttribute(this, "anonid", "initialBrowser");
michael@0: 
michael@0:           this.mCurrentTab = this.tabContainer.firstChild;
michael@0:           document.addEventListener("keypress", this, false);
michael@0:           window.addEventListener("sizemodechange", this, false);
michael@0: 
michael@0:           var uniqueId = this._generateUniquePanelID();
michael@0:           this.mPanelContainer.childNodes[0].id = uniqueId;
michael@0:           this.mCurrentTab.linkedPanel = uniqueId;
michael@0:           this.mCurrentTab._tPos = 0;
michael@0:           this.mCurrentTab._fullyOpen = true;
michael@0:           this.mCurrentTab.linkedBrowser = this.mCurrentBrowser;
michael@0: 
michael@0:           // set up the shared autoscroll popup
michael@0:           this._autoScrollPopup = this.mCurrentBrowser._createAutoScrollPopup();
michael@0:           this._autoScrollPopup.id = "autoscroller";
michael@0:           this.appendChild(this._autoScrollPopup);
michael@0:           this.mCurrentBrowser.setAttribute("autoscrollpopup", this._autoScrollPopup.id);
michael@0:           this.mCurrentBrowser.droppedLinkHandler = handleDroppedLink;
michael@0:           this.updateWindowResizers();
michael@0: 
michael@0:           // Hook up the event listeners to the first browser
michael@0:           var tabListener = this.mTabProgressListener(this.mCurrentTab, this.mCurrentBrowser, true);
michael@0:           const nsIWebProgress = Components.interfaces.nsIWebProgress;
michael@0:           const filter = Components.classes["@mozilla.org/appshell/component/browser-status-filter;1"]
michael@0:                                    .createInstance(nsIWebProgress);
michael@0:           filter.addProgressListener(tabListener, nsIWebProgress.NOTIFY_ALL);
michael@0:           this.mTabListeners[0] = tabListener;
michael@0:           this.mTabFilters[0] = filter;
michael@0:           this.webProgress.addProgressListener(filter, nsIWebProgress.NOTIFY_ALL);
michael@0: 
michael@0:           this.style.backgroundColor =
michael@0:             Services.prefs.getBoolPref("browser.display.use_system_colors") ?
michael@0:               "-moz-default-background-color" :
michael@0:               Services.prefs.getCharPref("browser.display.background_color");
michael@0: 
michael@0:           let remote = window.QueryInterface(Ci.nsIInterfaceRequestor)
michael@0:             .getInterface(Ci.nsIWebNavigation)
michael@0:             .QueryInterface(Ci.nsILoadContext)
michael@0:             .useRemoteTabs;
michael@0:           if (remote) {
michael@0:             messageManager.addMessageListener("DOMTitleChanged", this);
michael@0:             messageManager.addMessageListener("DOMWindowClose", this);
michael@0:             messageManager.addMessageListener("contextmenu", this);
michael@0:           }
michael@0:           messageManager.addMessageListener("DOMWebNotificationClicked", this);
michael@0:         ]]>
michael@0:       </constructor>
michael@0: 
michael@0:       <method name="_generateUniquePanelID">
michael@0:         <body><![CDATA[
michael@0:           if (!this._uniquePanelIDCounter) {
michael@0:             this._uniquePanelIDCounter = 0;
michael@0:           }
michael@0: 
michael@0:           let outerID = window.QueryInterface(Ci.nsIInterfaceRequestor)
michael@0:                               .getInterface(Ci.nsIDOMWindowUtils)
michael@0:                               .outerWindowID;
michael@0: 
michael@0:           // We want panel IDs to be globally unique, that's why we include the
michael@0:           // window ID. We switched to a monotonic counter as Date.now() lead
michael@0:           // to random failures because of colliding IDs.
michael@0:           return "panel-" + outerID + "-" + (++this._uniquePanelIDCounter);
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <destructor>
michael@0:         <![CDATA[
michael@0:           for (var i = 0; i < this.mTabListeners.length; ++i) {
michael@0:             let browser = this.getBrowserAtIndex(i);
michael@0:             if (browser.registeredOpenURI) {
michael@0:               this._placesAutocomplete.unregisterOpenPage(browser.registeredOpenURI);
michael@0:               this._unifiedComplete.unregisterOpenPage(browser.registeredOpenURI);
michael@0:               delete browser.registeredOpenURI;
michael@0:             }
michael@0:             browser.webProgress.removeProgressListener(this.mTabFilters[i]);
michael@0:             this.mTabFilters[i].removeProgressListener(this.mTabListeners[i]);
michael@0:             this.mTabFilters[i] = null;
michael@0:             this.mTabListeners[i].destroy();
michael@0:             this.mTabListeners[i] = null;
michael@0:           }
michael@0:           document.removeEventListener("keypress", this, false);
michael@0:           window.removeEventListener("sizemodechange", this, false);
michael@0: 
michael@0:           if (gMultiProcessBrowser) {
michael@0:             messageManager.removeMessageListener("DOMTitleChanged", this);
michael@0:             messageManager.removeMessageListener("contextmenu", this);
michael@0:           }
michael@0:         ]]>
michael@0:       </destructor>
michael@0: 
michael@0:       <!-- Deprecated stuff, implemented for backwards compatibility. -->
michael@0:       <method name="enterTabbedMode">
michael@0:         <body>
michael@0:           Application.console.log("enterTabbedMode is an obsolete method and " +
michael@0:                                   "will be removed in a future release.");
michael@0:         </body>
michael@0:       </method>
michael@0:       <field name="mTabbedMode" readonly="true">true</field>
michael@0:       <method name="setStripVisibilityTo">
michael@0:         <parameter name="aShow"/>
michael@0:         <body>
michael@0:           this.tabContainer.visible = aShow;
michael@0:         </body>
michael@0:       </method>
michael@0:       <method name="getStripVisibility">
michael@0:         <body>
michael@0:           return this.tabContainer.visible;
michael@0:         </body>
michael@0:       </method>
michael@0:       <property name="mContextTab" readonly="true"
michael@0:                 onget="return TabContextMenu.contextTab;"/>
michael@0:       <property name="mPrefs" readonly="true"
michael@0:                 onget="return Services.prefs;"/>
michael@0:       <property name="mTabContainer" readonly="true"
michael@0:                 onget="return this.tabContainer;"/>
michael@0:       <property name="mTabs" readonly="true"
michael@0:                 onget="return this.tabs;"/>
michael@0:       <!--
michael@0:         - Compatibility hack: several extensions depend on this property to
michael@0:         - access the tab context menu or tab container, so keep that working for
michael@0:         - now. Ideally we can remove this once extensions are using
michael@0:         - tabbrowser.tabContextMenu and tabbrowser.tabContainer directly.
michael@0:         -->
michael@0:       <property name="mStrip" readonly="true">
michael@0:         <getter>
michael@0:         <![CDATA[
michael@0:           return ({
michael@0:             self: this,
michael@0:             childNodes: [null, this.tabContextMenu, this.tabContainer],
michael@0:             firstChild: { nextSibling: this.tabContextMenu },
michael@0:             getElementsByAttribute: function (attr, attrValue) {
michael@0:               if (attr == "anonid" && attrValue == "tabContextMenu")
michael@0:                 return [this.self.tabContextMenu];
michael@0:               return [];
michael@0:             },
michael@0:             // Also support adding event listeners (forward to the tab container)
michael@0:             addEventListener: function (a,b,c) { this.self.tabContainer.addEventListener(a,b,c); },
michael@0:             removeEventListener: function (a,b,c) { this.self.tabContainer.removeEventListener(a,b,c); }
michael@0:           });
michael@0:         ]]>
michael@0:         </getter>
michael@0:       </property>
michael@0:     </implementation>
michael@0: 
michael@0:     <handlers>
michael@0:       <handler event="DOMWindowClose" phase="capturing">
michael@0:         <![CDATA[
michael@0:           if (!event.isTrusted)
michael@0:             return;
michael@0: 
michael@0:           if (this.tabs.length == 1)
michael@0:             return;
michael@0: 
michael@0:           var tab = this._getTabForContentWindow(event.target);
michael@0:           if (tab) {
michael@0:             this.removeTab(tab);
michael@0:             event.preventDefault();
michael@0:           }
michael@0:         ]]>
michael@0:       </handler>
michael@0:       <handler event="DOMWillOpenModalDialog" phase="capturing">
michael@0:         <![CDATA[
michael@0:           if (!event.isTrusted)
michael@0:             return;
michael@0: 
michael@0:           // We're about to open a modal dialog, make sure the opening
michael@0:           // tab is brought to the front.
michael@0:           // If this is a same-process modal dialog, then we're given its DOM
michael@0:           // window as the event's target. For remote dialogs, we're given the
michael@0:           // browser, but that's in the originalTarget.
michael@0:           // XXX Why originalTarget for the browser?
michael@0:           this.selectedTab = (event.target instanceof Window) ?
michael@0:                                this._getTabForContentWindow(event.target.top) :
michael@0:                                this._getTabForBrowser(event.originalTarget);
michael@0:         ]]>
michael@0:       </handler>
michael@0:       <handler event="DOMTitleChanged">
michael@0:         <![CDATA[
michael@0:           if (!event.isTrusted)
michael@0:             return;
michael@0: 
michael@0:           var contentWin = event.target.defaultView;
michael@0:           if (contentWin != contentWin.top)
michael@0:             return;
michael@0: 
michael@0:           var tab = this._getTabForContentWindow(contentWin);
michael@0:           if (tab.hasAttribute("pending"))
michael@0:             return;
michael@0: 
michael@0:           var titleChanged = this.setTabTitle(tab);
michael@0:           if (titleChanged && !tab.selected && !tab.hasAttribute("busy"))
michael@0:             tab.setAttribute("titlechanged", "true");
michael@0:         ]]>
michael@0:       </handler>
michael@0:       <handler event="oop-browser-crashed">
michael@0:         <![CDATA[
michael@0:           if (!event.isTrusted)
michael@0:             return;
michael@0: 
michael@0:           let browser = event.originalTarget;
michael@0:           let title = browser.contentTitle;
michael@0:           let uri = browser.currentURI;
michael@0:           let icon = browser.mIconURL;
michael@0: 
michael@0:           this.updateBrowserRemoteness(browser, "about:tabcrashed");
michael@0: 
michael@0:           browser.setAttribute("crashedPageTitle", title);
michael@0:           browser.docShell.displayLoadError(Cr.NS_ERROR_CONTENT_CRASHED, uri, null);
michael@0:           browser.removeAttribute("crashedPageTitle");
michael@0:           let tab = this._getTabForBrowser(browser);
michael@0:           this.setIcon(tab, icon);
michael@0:         ]]>
michael@0:       </handler>
michael@0:     </handlers>
michael@0:   </binding>
michael@0: 
michael@0:   <binding id="tabbrowser-tabbox"
michael@0:            extends="chrome://global/content/bindings/tabbox.xml#tabbox">
michael@0:     <implementation>
michael@0:       <property name="tabs" readonly="true"
michael@0:                 onget="return document.getBindingParent(this).tabContainer;"/>
michael@0:     </implementation>
michael@0:   </binding>
michael@0: 
michael@0:   <binding id="tabbrowser-arrowscrollbox" extends="chrome://global/content/bindings/scrollbox.xml#arrowscrollbox-clicktoscroll">
michael@0:     <implementation>
michael@0:       <!-- Override scrollbox.xml method, since our scrollbox's children are
michael@0:            inherited from the binding parent -->
michael@0:       <method name="_getScrollableElements">
michael@0:         <body><![CDATA[
michael@0:           return Array.filter(document.getBindingParent(this).childNodes,
michael@0:                               this._canScrollToElement, this);
michael@0:         ]]></body>
michael@0:       </method>
michael@0:       <method name="_canScrollToElement">
michael@0:         <parameter name="tab"/>
michael@0:         <body><![CDATA[
michael@0:           return !tab.pinned && !tab.hidden;
michael@0:         ]]></body>
michael@0:       </method>
michael@0:       <field name="_tabMarginLeft">null</field>
michael@0:       <field name="_tabMarginRight">null</field>
michael@0:       <method name="_calcTabMargins">
michael@0:         <parameter name="aTab"/>
michael@0:         <body><![CDATA[
michael@0:           if (this._tabMarginLeft === null || this._tabMarginRight === null) {
michael@0:             let tabMiddle = document.getAnonymousElementByAttribute(aTab, "class", "tab-background-middle");
michael@0:             let tabMiddleStyle = window.getComputedStyle(tabMiddle, null);
michael@0:             this._tabMarginLeft = parseFloat(tabMiddleStyle.marginLeft);
michael@0:             this._tabMarginRight = parseFloat(tabMiddleStyle.marginRight);
michael@0:           }
michael@0:         ]]></body>
michael@0:       </method>
michael@0:       <method name="_adjustElementStartAndEnd">
michael@0:         <parameter name="aTab"/>
michael@0:         <parameter name="tabStart"/>
michael@0:         <parameter name="tabEnd"/>
michael@0:         <body><![CDATA[
michael@0:           this._calcTabMargins(aTab);
michael@0:           if (this._tabMarginLeft < 0) {
michael@0:             tabStart = tabStart + this._tabMarginLeft;
michael@0:           }
michael@0:           if (this._tabMarginRight < 0) {
michael@0:             tabEnd = tabEnd - this._tabMarginRight;
michael@0:           }
michael@0:           return [tabStart, tabEnd];
michael@0:         ]]></body>
michael@0:       </method>
michael@0:     </implementation>
michael@0: 
michael@0:     <handlers>
michael@0:       <handler event="underflow" phase="capturing"><![CDATA[
michael@0:         if (event.detail == 0)
michael@0:           return; // Ignore vertical events
michael@0: 
michael@0:         var tabs = document.getBindingParent(this);
michael@0:         tabs.removeAttribute("overflow");
michael@0: 
michael@0:         if (tabs._lastTabClosedByMouse)
michael@0:           tabs._expandSpacerBy(this._scrollButtonDown.clientWidth);
michael@0: 
michael@0:         tabs.tabbrowser._removingTabs.forEach(tabs.tabbrowser.removeTab,
michael@0:                                               tabs.tabbrowser);
michael@0: 
michael@0:         tabs._positionPinnedTabs();
michael@0:       ]]></handler>
michael@0:       <handler event="overflow"><![CDATA[
michael@0:         if (event.detail == 0)
michael@0:           return; // Ignore vertical events
michael@0:         var tabs = document.getBindingParent(this);
michael@0:         var numberOfTabs = tabs.tabbrowser.visibleTabs.length;
michael@0:         if (numberOfTabs == 1)
michael@0:           return;
michael@0: 
michael@0:         tabs.setAttribute("overflow", "true");
michael@0:         tabs._positionPinnedTabs();
michael@0:         tabs._handleTabSelect(false);
michael@0:       ]]></handler>
michael@0:     </handlers>
michael@0:   </binding>
michael@0: 
michael@0:   <binding id="tabbrowser-tabs"
michael@0:            extends="chrome://global/content/bindings/tabbox.xml#tabs">
michael@0:     <resources>
michael@0:       <stylesheet src="chrome://browser/content/tabbrowser.css"/>
michael@0:     </resources>
michael@0: 
michael@0:     <content>
michael@0:       <xul:hbox align="end">
michael@0:         <xul:image class="tab-drop-indicator" anonid="tab-drop-indicator" collapsed="true"/>
michael@0:       </xul:hbox>
michael@0:       <xul:arrowscrollbox anonid="arrowscrollbox" orient="horizontal" flex="1"
michael@0:                           style="min-width: 1px;"
michael@0: #ifndef XP_MACOSX
michael@0:                           clicktoscroll="true"
michael@0: #endif
michael@0:                           class="tabbrowser-arrowscrollbox">
michael@0: # This is a hack to circumvent bug 472020, otherwise the tabs show up on the
michael@0: # right of the newtab button.
michael@0:         <children includes="tab"/>
michael@0: # This is to ensure anything extensions put here will go before the newtab
michael@0: # button, necessary due to the previous hack.
michael@0:         <children/>
michael@0:         <xul:toolbarbutton class="tabs-newtab-button"
michael@0:                            command="cmd_newNavigatorTab"
michael@0:                            onclick="checkForMiddleClick(this, event);"
michael@0:                            onmouseover="document.getBindingParent(this)._enterNewTab();"
michael@0:                            onmouseout="document.getBindingParent(this)._leaveNewTab();"
michael@0:                            tooltiptext="&newTabButton.tooltip;"/>
michael@0:         <xul:spacer class="closing-tabs-spacer" anonid="closing-tabs-spacer"
michael@0:                     style="width: 0;"/>
michael@0:       </xul:arrowscrollbox>
michael@0:     </content>
michael@0: 
michael@0:     <implementation implements="nsIDOMEventListener">
michael@0:       <constructor>
michael@0:         <![CDATA[
michael@0:           this.mTabClipWidth = Services.prefs.getIntPref("browser.tabs.tabClipWidth");
michael@0: 
michael@0:           var tab = this.firstChild;
michael@0:           tab.label = this.tabbrowser.mStringBundle.getString("tabs.emptyTabTitle");
michael@0:           tab.setAttribute("crop", "end");
michael@0:           tab.setAttribute("onerror", "this.removeAttribute('image');");
michael@0: 
michael@0:           window.addEventListener("resize", this, false);
michael@0:           window.addEventListener("load", this, false);
michael@0: 
michael@0:           try {
michael@0:             this._tabAnimationLoggingEnabled = Services.prefs.getBoolPref("browser.tabs.animationLogging.enabled");
michael@0:           } catch (ex) {
michael@0:             this._tabAnimationLoggingEnabled = false;
michael@0:           }
michael@0:           this._browserNewtabpageEnabled = Services.prefs.getBoolPref("browser.newtabpage.enabled");
michael@0:         ]]>
michael@0:       </constructor>
michael@0: 
michael@0:       <field name="tabbrowser" readonly="true">
michael@0:         document.getElementById(this.getAttribute("tabbrowser"));
michael@0:       </field>
michael@0: 
michael@0:       <field name="tabbox" readonly="true">
michael@0:         this.tabbrowser.mTabBox;
michael@0:       </field>
michael@0: 
michael@0:       <field name="contextMenu" readonly="true">
michael@0:         document.getElementById("tabContextMenu");
michael@0:       </field>
michael@0: 
michael@0:       <field name="mTabstripWidth">0</field>
michael@0: 
michael@0:       <field name="mTabstrip">
michael@0:         document.getAnonymousElementByAttribute(this, "anonid", "arrowscrollbox");
michael@0:       </field>
michael@0: 
michael@0:       <field name="_firstTab">null</field>
michael@0:       <field name="_lastTab">null</field>
michael@0:       <field name="_afterSelectedTab">null</field>
michael@0:       <field name="_beforeHoveredTab">null</field>
michael@0:       <field name="_afterHoveredTab">null</field>
michael@0:       <field name="_hoveredTab">null</field>
michael@0: 
michael@0:       <property name="_isCustomizing" readonly="true">
michael@0:         <getter>
michael@0:           let root = document.documentElement;
michael@0:           return root.getAttribute("customizing") == "true" ||
michael@0:                  root.getAttribute("customize-exiting") == "true";
michael@0:         </getter>
michael@0:       </property>
michael@0: 
michael@0:       <method name="_setPositionalAttributes">
michael@0:         <body><![CDATA[
michael@0:           let visibleTabs = this.tabbrowser.visibleTabs;
michael@0: 
michael@0:           if (!visibleTabs.length)
michael@0:             return;
michael@0: 
michael@0:           let selectedIndex = visibleTabs.indexOf(this.selectedItem);
michael@0: 
michael@0:           let lastVisible = visibleTabs.length - 1;
michael@0: 
michael@0:           if (this._afterSelectedTab)
michael@0:             this._afterSelectedTab.removeAttribute("afterselected-visible");
michael@0:           if (this.selectedItem.closing || selectedIndex == lastVisible) {
michael@0:             this._afterSelectedTab = null;
michael@0:           } else {
michael@0:             this._afterSelectedTab = visibleTabs[selectedIndex + 1];
michael@0:             this._afterSelectedTab.setAttribute("afterselected-visible",
michael@0:                                                 "true");
michael@0:           }
michael@0: 
michael@0:           if (this._firstTab)
michael@0:             this._firstTab.removeAttribute("first-visible-tab");
michael@0:           this._firstTab = visibleTabs[0];
michael@0:           this._firstTab.setAttribute("first-visible-tab", "true");
michael@0:           if (this._lastTab)
michael@0:             this._lastTab.removeAttribute("last-visible-tab");
michael@0:           this._lastTab = visibleTabs[lastVisible];
michael@0:           this._lastTab.setAttribute("last-visible-tab", "true");
michael@0: 
michael@0:           let hoveredTab = this._hoveredTab;
michael@0:           if (hoveredTab) {
michael@0:             hoveredTab._mouseleave();
michael@0:             hoveredTab._mouseenter();
michael@0:           }
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <field name="_blockDblClick">false</field>
michael@0: 
michael@0:       <field name="_tabDropIndicator">
michael@0:         document.getAnonymousElementByAttribute(this, "anonid", "tab-drop-indicator");
michael@0:       </field>
michael@0: 
michael@0:       <field name="_dragOverDelay">350</field>
michael@0:       <field name="_dragTime">0</field>
michael@0: 
michael@0:       <field name="_container" readonly="true"><![CDATA[
michael@0:         this.parentNode && this.parentNode.localName == "toolbar" ? this.parentNode : this;
michael@0:       ]]></field>
michael@0: 
michael@0:       <field name="_propagatedVisibilityOnce">false</field>
michael@0: 
michael@0:       <property name="visible"
michael@0:                 onget="return !this._container.collapsed;">
michael@0:         <setter><![CDATA[
michael@0:           if (val == this.visible &&
michael@0:               this._propagatedVisibilityOnce)
michael@0:             return val;
michael@0: 
michael@0:           this._container.collapsed = !val;
michael@0: 
michael@0:           this._propagateVisibility();
michael@0:           this._propagatedVisibilityOnce = true;
michael@0: 
michael@0:           return val;
michael@0:         ]]></setter>
michael@0:       </property>
michael@0: 
michael@0:       <method name="_enterNewTab">
michael@0:         <body><![CDATA[
michael@0:           let visibleTabs = this.tabbrowser.visibleTabs;
michael@0:           let candidate = visibleTabs[visibleTabs.length - 1];
michael@0:           if (!candidate.selected) {
michael@0:             this._beforeHoveredTab = candidate;
michael@0:             candidate.setAttribute("beforehovered", "true");
michael@0:           }
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_leaveNewTab">
michael@0:         <body><![CDATA[
michael@0:           if (this._beforeHoveredTab) {
michael@0:             this._beforeHoveredTab.removeAttribute("beforehovered");
michael@0:             this._beforeHoveredTab = null;
michael@0:           }
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_propagateVisibility">
michael@0:         <body><![CDATA[
michael@0:           let visible = this.visible;
michael@0: 
michael@0:           document.getElementById("menu_closeWindow").hidden = !visible;
michael@0:           document.getElementById("menu_close").setAttribute("label",
michael@0:             this.tabbrowser.mStringBundle.getString(visible ? "tabs.closeTab" : "tabs.close"));
michael@0: 
michael@0:           TabsInTitlebar.allowedBy("tabs-visible", visible);
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="updateVisibility">
michael@0:         <body><![CDATA[
michael@0:           if (this.childNodes.length - this.tabbrowser._removingTabs.length == 1)
michael@0:             this.visible = window.toolbar.visible;
michael@0:           else
michael@0:             this.visible = true;
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="adjustTabstrip">
michael@0:         <body><![CDATA[
michael@0:           let numTabs = this.childNodes.length -
michael@0:                         this.tabbrowser._removingTabs.length;
michael@0:           if (numTabs > 2) {
michael@0:             // This is an optimization to avoid layout flushes by calling
michael@0:             // getBoundingClientRect() when we just opened a second tab. In
michael@0:             // this case it's highly unlikely that the tab width is smaller
michael@0:             // than mTabClipWidth and the tab close button obscures too much
michael@0:             // of the tab's label. In the edge case of the window being too
michael@0:             // narrow (or if tabClipWidth has been set to a way higher value),
michael@0:             // we'll correct the 'closebuttons' attribute after the tabopen
michael@0:             // animation has finished.
michael@0: 
michael@0:             let tab = this.tabbrowser.visibleTabs[this.tabbrowser._numPinnedTabs];
michael@0:             if (tab && tab.getBoundingClientRect().width <= this.mTabClipWidth) {
michael@0:               this.setAttribute("closebuttons", "activetab");
michael@0:               return;
michael@0:             }
michael@0:           }
michael@0:           this.removeAttribute("closebuttons");
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_handleTabSelect">
michael@0:         <parameter name="aSmoothScroll"/>
michael@0:         <body><![CDATA[
michael@0:           if (this.getAttribute("overflow") == "true")
michael@0:             this.mTabstrip.ensureElementIsVisible(this.selectedItem, aSmoothScroll);
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_fillTrailingGap">
michael@0:         <body><![CDATA[
michael@0:           try {
michael@0:             // if we're at the right side (and not the logical end,
michael@0:             // which is why this works for both LTR and RTL)
michael@0:             // of the tabstrip, we need to ensure that we stay
michael@0:             // completely scrolled to the right side
michael@0:             var tabStrip = this.mTabstrip;
michael@0:             if (tabStrip.scrollPosition + tabStrip.scrollClientSize >
michael@0:                 tabStrip.scrollSize)
michael@0:               tabStrip.scrollByPixels(-1);
michael@0:           } catch (e) {}
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <field name="_closingTabsSpacer">
michael@0:         document.getAnonymousElementByAttribute(this, "anonid", "closing-tabs-spacer");
michael@0:       </field>
michael@0: 
michael@0:       <field name="_tabDefaultMaxWidth">NaN</field>
michael@0:       <field name="_lastTabClosedByMouse">false</field>
michael@0:       <field name="_hasTabTempMaxWidth">false</field>
michael@0: 
michael@0:       <!-- Try to keep the active tab's close button under the mouse cursor -->
michael@0:       <method name="_lockTabSizing">
michael@0:         <parameter name="aTab"/>
michael@0:         <body><![CDATA[
michael@0:           var tabs = this.tabbrowser.visibleTabs;
michael@0:           if (!tabs.length)
michael@0:             return;
michael@0: 
michael@0:           var isEndTab = (aTab._tPos > tabs[tabs.length-1]._tPos);
michael@0:           var tabWidth = aTab.getBoundingClientRect().width;
michael@0: 
michael@0:           if (!this._tabDefaultMaxWidth)
michael@0:             this._tabDefaultMaxWidth =
michael@0:               parseFloat(window.getComputedStyle(aTab).maxWidth);
michael@0:           this._lastTabClosedByMouse = true;
michael@0: 
michael@0:           if (this.getAttribute("overflow") == "true") {
michael@0:             // Don't need to do anything if we're in overflow mode and aren't scrolled
michael@0:             // all the way to the right, or if we're closing the last tab.
michael@0:             if (isEndTab || !this.mTabstrip._scrollButtonDown.disabled)
michael@0:               return;
michael@0: 
michael@0:             // If the tab has an owner that will become the active tab, the owner will
michael@0:             // be to the left of it, so we actually want the left tab to slide over.
michael@0:             // This can't be done as easily in non-overflow mode, so we don't bother.
michael@0:             if (aTab.owner)
michael@0:               return;
michael@0: 
michael@0:             this._expandSpacerBy(tabWidth);
michael@0:           } else { // non-overflow mode
michael@0:             // Locking is neither in effect nor needed, so let tabs expand normally.
michael@0:             if (isEndTab && !this._hasTabTempMaxWidth)
michael@0:               return;
michael@0: 
michael@0:             let numPinned = this.tabbrowser._numPinnedTabs;
michael@0:             // Force tabs to stay the same width, unless we're closing the last tab,
michael@0:             // which case we need to let them expand just enough so that the overall
michael@0:             // tabbar width is the same.
michael@0:             if (isEndTab) {
michael@0:               let numNormalTabs = tabs.length - numPinned;
michael@0:               tabWidth = tabWidth * (numNormalTabs + 1) / numNormalTabs;
michael@0:               if (tabWidth > this._tabDefaultMaxWidth)
michael@0:                 tabWidth = this._tabDefaultMaxWidth;
michael@0:             }
michael@0:             tabWidth += "px";
michael@0:             for (let i = numPinned; i < tabs.length; i++) {
michael@0:               let tab = tabs[i];
michael@0:               tab.style.setProperty("max-width", tabWidth, "important");
michael@0:               if (!isEndTab) { // keep tabs the same width
michael@0:                 tab.style.transition = "none";
michael@0:                 tab.clientTop; // flush styles to skip animation; see bug 649247
michael@0:                 tab.style.transition = "";
michael@0:               }
michael@0:             }
michael@0:             this._hasTabTempMaxWidth = true;
michael@0:             this.tabbrowser.addEventListener("mousemove", this, false);
michael@0:             window.addEventListener("mouseout", this, false);
michael@0:           }
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_expandSpacerBy">
michael@0:         <parameter name="pixels"/>
michael@0:         <body><![CDATA[
michael@0:           let spacer = this._closingTabsSpacer;
michael@0:           spacer.style.width = parseFloat(spacer.style.width) + pixels + "px";
michael@0:           this.setAttribute("using-closing-tabs-spacer", "true");
michael@0:           this.tabbrowser.addEventListener("mousemove", this, false);
michael@0:           window.addEventListener("mouseout", this, false);
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_unlockTabSizing">
michael@0:         <body><![CDATA[
michael@0:           this.tabbrowser.removeEventListener("mousemove", this, false);
michael@0:           window.removeEventListener("mouseout", this, false);
michael@0: 
michael@0:           if (this._hasTabTempMaxWidth) {
michael@0:             this._hasTabTempMaxWidth = false;
michael@0:             let tabs = this.tabbrowser.visibleTabs;
michael@0:             for (let i = 0; i < tabs.length; i++)
michael@0:               tabs[i].style.maxWidth = "";
michael@0:           }
michael@0: 
michael@0:           if (this.hasAttribute("using-closing-tabs-spacer")) {
michael@0:             this.removeAttribute("using-closing-tabs-spacer");
michael@0:             this._closingTabsSpacer.style.width = 0;
michael@0:           }
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <field name="_lastNumPinned">0</field>
michael@0:       <method name="_positionPinnedTabs">
michael@0:         <body><![CDATA[
michael@0:           var numPinned = this.tabbrowser._numPinnedTabs;
michael@0:           var doPosition = this.getAttribute("overflow") == "true" &&
michael@0:                            numPinned > 0;
michael@0: 
michael@0:           if (doPosition) {
michael@0:             this.setAttribute("positionpinnedtabs", "true");
michael@0: 
michael@0:             let scrollButtonWidth = this.mTabstrip._scrollButtonDown.getBoundingClientRect().width;
michael@0:             let paddingStart = this.mTabstrip.scrollboxPaddingStart;
michael@0:             let width = 0;
michael@0: 
michael@0:             for (let i = numPinned - 1; i >= 0; i--) {
michael@0:               let tab = this.childNodes[i];
michael@0:               width += tab.getBoundingClientRect().width;
michael@0:               tab.style.MozMarginStart = - (width + scrollButtonWidth + paddingStart) + "px";
michael@0:             }
michael@0: 
michael@0:             this.style.MozPaddingStart = width + paddingStart + "px";
michael@0: 
michael@0:           } else {
michael@0:             this.removeAttribute("positionpinnedtabs");
michael@0: 
michael@0:             for (let i = 0; i < numPinned; i++) {
michael@0:               let tab = this.childNodes[i];
michael@0:               tab.style.MozMarginStart = "";
michael@0:             }
michael@0: 
michael@0:             this.style.MozPaddingStart = "";
michael@0:           }
michael@0: 
michael@0:           if (this._lastNumPinned != numPinned) {
michael@0:             this._lastNumPinned = numPinned;
michael@0:             this._handleTabSelect(false);
michael@0:           }
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_animateTabMove">
michael@0:         <parameter name="event"/>
michael@0:         <body><![CDATA[
michael@0:           let draggedTab = event.dataTransfer.mozGetDataAt(TAB_DROP_TYPE, 0);
michael@0: 
michael@0:           if (this.getAttribute("movingtab") != "true") {
michael@0:             this.setAttribute("movingtab", "true");
michael@0:             this.selectedItem = draggedTab;
michael@0:           }
michael@0: 
michael@0:           if (!("animLastScreenX" in draggedTab._dragData))
michael@0:             draggedTab._dragData.animLastScreenX = draggedTab._dragData.screenX;
michael@0: 
michael@0:           let screenX = event.screenX;
michael@0:           if (screenX == draggedTab._dragData.animLastScreenX)
michael@0:             return;
michael@0: 
michael@0:           let draggingRight = screenX > draggedTab._dragData.animLastScreenX;
michael@0:           draggedTab._dragData.animLastScreenX = screenX;
michael@0: 
michael@0:           let rtl = (window.getComputedStyle(this).direction == "rtl");
michael@0:           let pinned = draggedTab.pinned;
michael@0:           let numPinned = this.tabbrowser._numPinnedTabs;
michael@0:           let tabs = this.tabbrowser.visibleTabs
michael@0:                                     .slice(pinned ? 0 : numPinned,
michael@0:                                            pinned ? numPinned : undefined);
michael@0:           if (rtl)
michael@0:             tabs.reverse();
michael@0:           let tabWidth = draggedTab.getBoundingClientRect().width;
michael@0: 
michael@0:           // Move the dragged tab based on the mouse position.
michael@0: 
michael@0:           let leftTab = tabs[0];
michael@0:           let rightTab = tabs[tabs.length - 1];
michael@0:           let tabScreenX = draggedTab.boxObject.screenX;
michael@0:           let translateX = screenX - draggedTab._dragData.screenX;
michael@0:           if (!pinned)
michael@0:             translateX += this.mTabstrip.scrollPosition - draggedTab._dragData.scrollX;
michael@0:           let leftBound = leftTab.boxObject.screenX - tabScreenX;
michael@0:           let rightBound = (rightTab.boxObject.screenX + rightTab.boxObject.width) -
michael@0:                            (tabScreenX + tabWidth);
michael@0:           translateX = Math.max(translateX, leftBound);
michael@0:           translateX = Math.min(translateX, rightBound);
michael@0:           draggedTab.style.transform = "translateX(" + translateX + "px)";
michael@0: 
michael@0:           // Determine what tab we're dragging over.
michael@0:           // * Point of reference is the center of the dragged tab. If that
michael@0:           //   point touches a background tab, the dragged tab would take that
michael@0:           //   tab's position when dropped.
michael@0:           // * We're doing a binary search in order to reduce the amount of
michael@0:           //   tabs we need to check.
michael@0: 
michael@0:           let tabCenter = tabScreenX + translateX + tabWidth / 2;
michael@0:           let newIndex = -1;
michael@0:           let oldIndex = "animDropIndex" in draggedTab._dragData ?
michael@0:                          draggedTab._dragData.animDropIndex : draggedTab._tPos;
michael@0:           let low = 0;
michael@0:           let high = tabs.length - 1;
michael@0:           while (low <= high) {
michael@0:             let mid = Math.floor((low + high) / 2);
michael@0:             if (tabs[mid] == draggedTab &&
michael@0:                 ++mid > high)
michael@0:               break;
michael@0:             let boxObject = tabs[mid].boxObject;
michael@0:             let screenX = boxObject.screenX + getTabShift(tabs[mid], oldIndex);
michael@0:             if (screenX > tabCenter) {
michael@0:               high = mid - 1;
michael@0:             } else if (screenX + boxObject.width < tabCenter) {
michael@0:               low = mid + 1;
michael@0:             } else {
michael@0:               newIndex = tabs[mid]._tPos;
michael@0:               break;
michael@0:             }
michael@0:           }
michael@0:           if (newIndex >= oldIndex)
michael@0:             newIndex++;
michael@0:           if (newIndex < 0 || newIndex == oldIndex)
michael@0:             return;
michael@0:           draggedTab._dragData.animDropIndex = newIndex;
michael@0: 
michael@0:           // Shift background tabs to leave a gap where the dragged tab
michael@0:           // would currently be dropped.
michael@0: 
michael@0:           for (let tab of tabs) {
michael@0:             if (tab != draggedTab) {
michael@0:               let shift = getTabShift(tab, newIndex);
michael@0:               tab.style.transform = shift ? "translateX(" + shift + "px)" : "";
michael@0:             }
michael@0:           }
michael@0: 
michael@0:           function getTabShift(tab, dropIndex) {
michael@0:             if (tab._tPos < draggedTab._tPos && tab._tPos >= dropIndex)
michael@0:               return rtl ? -tabWidth : tabWidth;
michael@0:             if (tab._tPos > draggedTab._tPos && tab._tPos < dropIndex)
michael@0:               return rtl ? tabWidth : -tabWidth;
michael@0:             return 0;
michael@0:           }
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_finishAnimateTabMove">
michael@0:         <body><![CDATA[
michael@0:           if (this.getAttribute("movingtab") != "true")
michael@0:             return;
michael@0: 
michael@0:           for (let tab of this.tabbrowser.visibleTabs)
michael@0:             tab.style.transform = "";
michael@0: 
michael@0:           this.removeAttribute("movingtab");
michael@0: 
michael@0:           this._handleTabSelect();
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="handleEvent">
michael@0:         <parameter name="aEvent"/>
michael@0:         <body><![CDATA[
michael@0:           switch (aEvent.type) {
michael@0:             case "load":
michael@0:               this.updateVisibility();
michael@0:               break;
michael@0:             case "resize":
michael@0:               if (aEvent.target != window)
michael@0:                 break;
michael@0: 
michael@0:               TabsInTitlebar.updateAppearance();
michael@0: 
michael@0:               if (this.tabbrowser.visibleTabs.length > 1) {
michael@0:                 var width = this.mTabstrip.boxObject.width;
michael@0:                 if (width != this.mTabstripWidth) {
michael@0:                   this.adjustTabstrip();
michael@0:                   this._fillTrailingGap();
michael@0:                   this._handleTabSelect();
michael@0:                   this.mTabstripWidth = width;
michael@0:                 }
michael@0:               }
michael@0: 
michael@0:               this.tabbrowser.updateWindowResizers();
michael@0:               break;
michael@0:             case "mouseout":
michael@0:               // If the "related target" (the node to which the pointer went) is not
michael@0:               // a child of the current document, the mouse just left the window.
michael@0:               let relatedTarget = aEvent.relatedTarget;
michael@0:               if (relatedTarget && relatedTarget.ownerDocument == document)
michael@0:                 break;
michael@0:             case "mousemove":
michael@0:               if (document.getElementById("tabContextMenu").state != "open")
michael@0:                 this._unlockTabSizing();
michael@0:               break;
michael@0:           }
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <field name="_animateElement">
michael@0:         this.mTabstrip._scrollButtonDown;
michael@0:       </field>
michael@0: 
michael@0:       <method name="_notifyBackgroundTab">
michael@0:         <parameter name="aTab"/>
michael@0:         <body><![CDATA[
michael@0:           if (aTab.pinned)
michael@0:             return;
michael@0: 
michael@0:           var scrollRect = this.mTabstrip.scrollClientRect;
michael@0:           var tab = aTab.getBoundingClientRect();
michael@0:           this.mTabstrip._calcTabMargins(aTab);
michael@0: 
michael@0:           // DOMRect left/right properties are immutable.
michael@0:           tab = {left: tab.left, right: tab.right};
michael@0: 
michael@0:           // Is the new tab already completely visible?
michael@0:           if (scrollRect.left <= tab.left && tab.right <= scrollRect.right)
michael@0:             return;
michael@0: 
michael@0:           if (this.mTabstrip.smoothScroll) {
michael@0:             let selected = !this.selectedItem.pinned &&
michael@0:                            this.selectedItem.getBoundingClientRect();
michael@0:             if (selected) {
michael@0:               selected = {left: selected.left, right: selected.right};
michael@0:               // Need to take in to account the width of the left/right margins on tabs.
michael@0:               selected.left = selected.left + this.mTabstrip._tabMarginLeft;
michael@0:               selected.right = selected.right - this.mTabstrip._tabMarginRight;
michael@0:             }
michael@0: 
michael@0:             tab.left += this.mTabstrip._tabMarginLeft;
michael@0:             tab.right -= this.mTabstrip._tabMarginRight;
michael@0: 
michael@0:             // Can we make both the new tab and the selected tab completely visible?
michael@0:             if (!selected ||
michael@0:                 Math.max(tab.right - selected.left, selected.right - tab.left) <=
michael@0:                   scrollRect.width) {
michael@0:               this.mTabstrip.ensureElementIsVisible(aTab);
michael@0:               return;
michael@0:             }
michael@0: 
michael@0:             this.mTabstrip._smoothScrollByPixels(this.mTabstrip._isRTLScrollbox ?
michael@0:                                                  selected.right - scrollRect.right :
michael@0:                                                  selected.left - scrollRect.left);
michael@0:           }
michael@0: 
michael@0:           if (!this._animateElement.hasAttribute("notifybgtab")) {
michael@0:             this._animateElement.setAttribute("notifybgtab", "true");
michael@0:             setTimeout(function (ele) {
michael@0:               ele.removeAttribute("notifybgtab");
michael@0:             }, 150, this._animateElement);
michael@0:           }
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_getDragTargetTab">
michael@0:         <parameter name="event"/>
michael@0:         <body><![CDATA[
michael@0:           let tab = event.target.localName == "tab" ? event.target : null;
michael@0:           if (tab &&
michael@0:               (event.type == "drop" || event.type == "dragover") &&
michael@0:               event.dataTransfer.dropEffect == "link") {
michael@0:             let boxObject = tab.boxObject;
michael@0:             if (event.screenX < boxObject.screenX + boxObject.width * .25 ||
michael@0:                 event.screenX > boxObject.screenX + boxObject.width * .75)
michael@0:               return null;
michael@0:           }
michael@0:           return tab;
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_getDropIndex">
michael@0:         <parameter name="event"/>
michael@0:         <body><![CDATA[
michael@0:           var tabs = this.childNodes;
michael@0:           var tab = this._getDragTargetTab(event);
michael@0:           if (window.getComputedStyle(this, null).direction == "ltr") {
michael@0:             for (let i = tab ? tab._tPos : 0; i < tabs.length; i++)
michael@0:               if (event.screenX < tabs[i].boxObject.screenX + tabs[i].boxObject.width / 2)
michael@0:                 return i;
michael@0:           } else {
michael@0:             for (let i = tab ? tab._tPos : 0; i < tabs.length; i++)
michael@0:               if (event.screenX > tabs[i].boxObject.screenX + tabs[i].boxObject.width / 2)
michael@0:                 return i;
michael@0:           }
michael@0:           return tabs.length;
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_setEffectAllowedForDataTransfer">
michael@0:         <parameter name="event"/>
michael@0:         <body><![CDATA[
michael@0:           var dt = event.dataTransfer;
michael@0:           // Disallow dropping multiple items
michael@0:           if (dt.mozItemCount > 1)
michael@0:             return dt.effectAllowed = "none";
michael@0: 
michael@0:           var types = dt.mozTypesAt(0);
michael@0:           var sourceNode = null;
michael@0:           // tabs are always added as the first type
michael@0:           if (types[0] == TAB_DROP_TYPE) {
michael@0:             var sourceNode = dt.mozGetDataAt(TAB_DROP_TYPE, 0);
michael@0:             if (sourceNode instanceof XULElement &&
michael@0:                 sourceNode.localName == "tab" &&
michael@0:                 sourceNode.ownerDocument.defaultView instanceof ChromeWindow &&
michael@0:                 sourceNode.ownerDocument.documentElement.getAttribute("windowtype") == "navigator:browser" &&
michael@0:                 sourceNode.ownerDocument.defaultView.gBrowser.tabContainer == sourceNode.parentNode) {
michael@0:               // Do not allow transfering a private tab to a non-private window
michael@0:               // and vice versa.
michael@0:               if (PrivateBrowsingUtils.isWindowPrivate(window) !=
michael@0:                   PrivateBrowsingUtils.isWindowPrivate(sourceNode.ownerDocument.defaultView))
michael@0:                 return dt.effectAllowed = "none";
michael@0: 
michael@0:               if (window.gMultiProcessBrowser !=
michael@0:                   sourceNode.ownerDocument.defaultView.gMultiProcessBrowser)
michael@0:                 return dt.effectAllowed = "none";
michael@0: 
michael@0: #ifdef XP_MACOSX
michael@0:               return dt.effectAllowed = event.altKey ? "copy" : "move";
michael@0: #else
michael@0:               return dt.effectAllowed = event.ctrlKey ? "copy" : "move";
michael@0: #endif
michael@0:             }
michael@0:           }
michael@0: 
michael@0:           if (browserDragAndDrop.canDropLink(event)) {
michael@0:             // Here we need to do this manually
michael@0:             return dt.effectAllowed = dt.dropEffect = "link";
michael@0:           }
michael@0:           return dt.effectAllowed = "none";
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_handleNewTab">
michael@0:         <parameter name="tab"/>
michael@0:         <body><![CDATA[
michael@0:           if (tab.parentNode != this)
michael@0:             return;
michael@0:           tab._fullyOpen = true;
michael@0: 
michael@0:           this.adjustTabstrip();
michael@0: 
michael@0:           if (tab.getAttribute("selected") == "true") {
michael@0:             this._fillTrailingGap();
michael@0:             this._handleTabSelect();
michael@0:           } else {
michael@0:             this._notifyBackgroundTab(tab);
michael@0:           }
michael@0: 
michael@0:           // XXXmano: this is a temporary workaround for bug 345399
michael@0:           // We need to manually update the scroll buttons disabled state
michael@0:           // if a tab was inserted to the overflow area or removed from it
michael@0:           // without any scrolling and when the tabbar has already
michael@0:           // overflowed.
michael@0:           this.mTabstrip._updateScrollButtonsDisabledState();
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_canAdvanceToTab">
michael@0:         <parameter name="aTab"/>
michael@0:         <body>
michael@0:         <![CDATA[
michael@0:           return !aTab.closing;
michael@0:         ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_handleTabTelemetryStart">
michael@0:         <parameter name="aTab"/>
michael@0:         <parameter name="aURI"/>
michael@0:         <body>
michael@0:         <![CDATA[
michael@0:           // Animation-smoothness telemetry/logging
michael@0:           if (Services.telemetry.canRecord || this._tabAnimationLoggingEnabled) {
michael@0:             if (aURI == "about:newtab" && (aTab._tPos == 1 || aTab._tPos == 2)) {
michael@0:               // Indicate newtab page animation where other tabs are unaffected
michael@0:               // (for which case, the 2nd or 3rd tabs are good representatives, even if not absolute)
michael@0:               aTab._recordingTabOpenPlain = true;
michael@0:             }
michael@0:             aTab._recordingHandle = window.QueryInterface(Ci.nsIInterfaceRequestor)
michael@0:                                           .getInterface(Ci.nsIDOMWindowUtils)
michael@0:                                           .startFrameTimeRecording();
michael@0:           }
michael@0: 
michael@0:           // Overall animation duration
michael@0:           aTab._animStartTime = Date.now();
michael@0:         ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_handleTabTelemetryEnd">
michael@0:         <parameter name="aTab"/>
michael@0:         <body>
michael@0:         <![CDATA[
michael@0:           if (!aTab._animStartTime) {
michael@0:             return;
michael@0:           }
michael@0: 
michael@0:           Services.telemetry.getHistogramById(aTab.closing ?
michael@0:                                               "FX_TAB_ANIM_CLOSE_MS" :
michael@0:                                               "FX_TAB_ANIM_OPEN_MS")
michael@0:                             .add(Date.now() - aTab._animStartTime);
michael@0:           aTab._animStartTime = 0;
michael@0: 
michael@0:           // Handle tab animation smoothness telemetry/logging of frame intervals and paint times
michael@0:           if (!("_recordingHandle" in aTab)) {
michael@0:             return;
michael@0:           }
michael@0: 
michael@0:           let intervals = window.QueryInterface(Ci.nsIInterfaceRequestor)
michael@0:                                 .getInterface(Ci.nsIDOMWindowUtils)
michael@0:                                 .stopFrameTimeRecording(aTab._recordingHandle);
michael@0:           delete aTab._recordingHandle;
michael@0:           let frameCount = intervals.length;
michael@0: 
michael@0:           if (this._tabAnimationLoggingEnabled) {
michael@0:             let msg = "Tab " + (aTab.closing ? "close" : "open") + " (Frame-interval):\n";
michael@0:             for (let i = 0; i < frameCount; i++) {
michael@0:               msg += Math.round(intervals[i]) + "\n";
michael@0:             }
michael@0:             Services.console.logStringMessage(msg);
michael@0:           }
michael@0: 
michael@0:           // For telemetry, the first frame interval is not useful since it may represent an interval
michael@0:           // to a relatively old frame (prior to recording start). So we'll ignore it for the average.
michael@0:           if (frameCount > 1) {
michael@0:             let averageInterval = 0;
michael@0:             for (let i = 1; i < frameCount; i++) {
michael@0:               averageInterval += intervals[i];
michael@0:             };
michael@0:             averageInterval = averageInterval / (frameCount - 1);
michael@0: 
michael@0:             Services.telemetry.getHistogramById("FX_TAB_ANIM_ANY_FRAME_INTERVAL_MS").add(averageInterval);
michael@0: 
michael@0:             if (aTab._recordingTabOpenPlain) {
michael@0:               delete aTab._recordingTabOpenPlain;
michael@0:               // While we do have a telemetry probe NEWTAB_PAGE_ENABLED to monitor newtab preview, it'll be
michael@0:               // easier to overview the data without slicing by it. Hence the additional histograms with _PREVIEW.
michael@0:               let preview = this._browserNewtabpageEnabled ? "_PREVIEW" : "";
michael@0:               Services.telemetry.getHistogramById("FX_TAB_ANIM_OPEN" + preview + "_FRAME_INTERVAL_MS").add(averageInterval);
michael@0:             }
michael@0:           }
michael@0:         ]]>
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <!-- Deprecated stuff, implemented for backwards compatibility. -->
michael@0:       <property name="mTabstripClosebutton" readonly="true"
michael@0:                 onget="return document.getElementById('tabs-closebutton');"/>
michael@0:       <property name="mAllTabsPopup" readonly="true"
michael@0:                 onget="return document.getElementById('alltabs-popup');"/>
michael@0:     </implementation>
michael@0: 
michael@0:     <handlers>
michael@0:       <handler event="TabSelect" action="this._handleTabSelect();"/>
michael@0: 
michael@0:       <handler event="transitionend"><![CDATA[
michael@0:         if (event.propertyName != "max-width")
michael@0:           return;
michael@0: 
michael@0:         var tab = event.target;
michael@0: 
michael@0:         this._handleTabTelemetryEnd(tab);
michael@0: 
michael@0:         if (tab.getAttribute("fadein") == "true") {
michael@0:           if (tab._fullyOpen)
michael@0:             this.adjustTabstrip();
michael@0:           else
michael@0:             this._handleNewTab(tab);
michael@0:         } else if (tab.closing) {
michael@0:           this.tabbrowser._endRemoveTab(tab);
michael@0:         }
michael@0:       ]]></handler>
michael@0: 
michael@0:       <handler event="dblclick"><![CDATA[
michael@0: #ifndef XP_MACOSX
michael@0:         // When the tabbar has an unified appearance with the titlebar
michael@0:         // and menubar, a double-click in it should have the same behavior
michael@0:         // as double-clicking the titlebar
michael@0:         if (TabsInTitlebar.enabled || this.parentNode._dragBindingAlive)
michael@0:           return;
michael@0: #endif
michael@0: 
michael@0:         if (event.button != 0 ||
michael@0:             event.originalTarget.localName != "box")
michael@0:           return;
michael@0: 
michael@0:         // See hack note in the tabbrowser-close-tab-button binding
michael@0:         if (!this._blockDblClick)
michael@0:           BrowserOpenTab();
michael@0: 
michael@0:         event.preventDefault();
michael@0:       ]]></handler>
michael@0: 
michael@0:       <handler event="click" button="0" phase="capturing"><![CDATA[
michael@0:         /* Catches extra clicks meant for the in-tab close button.
michael@0:          * Placed here to avoid leaking (a temporary handler added from the
michael@0:          * in-tab close button binding would close over the tab and leak it
michael@0:          * until the handler itself was removed). (bug 897751)
michael@0:          *
michael@0:          * The only sequence in which a second click event (i.e. dblclik)
michael@0:          * can be dispatched on an in-tab close button is when it is shown
michael@0:          * after the first click (i.e. the first click event was dispatched
michael@0:          * on the tab). This happens when we show the close button only on
michael@0:          * the active tab. (bug 352021)
michael@0:          * The only sequence in which a third click event can be dispatched
michael@0:          * on an in-tab close button is when the tab was opened with a
michael@0:          * double click on the tabbar. (bug 378344)
michael@0:          * In both cases, it is most likely that the close button area has
michael@0:          * been accidentally clicked, therefore we do not close the tab.
michael@0:          *
michael@0:          * We don't want to ignore processing of more than one click event,
michael@0:          * though, since the user might actually be repeatedly clicking to
michael@0:          * close many tabs at once.
michael@0:          */
michael@0:         let target = event.originalTarget;
michael@0:         if (target.classList.contains('tab-close-button')) {
michael@0:           // We preemptively set this to allow the closing-multiple-tabs-
michael@0:           // in-a-row case.
michael@0:           if (this._blockDblClick) {
michael@0:             target._ignoredCloseButtonClicks = true;
michael@0:           } else if (event.detail > 1 && !target._ignoredCloseButtonClicks) {
michael@0:             target._ignoredCloseButtonClicks = true;
michael@0:             event.stopPropagation();
michael@0:             return;
michael@0:           } else {
michael@0:             // Reset the "ignored click" flag
michael@0:             target._ignoredCloseButtonClicks = false;
michael@0:           }
michael@0:         }
michael@0: 
michael@0:         /* Protects from close-tab-button errant doubleclick:
michael@0:          * Since we're removing the event target, if the user
michael@0:          * double-clicks the button, the dblclick event will be dispatched
michael@0:          * with the tabbar as its event target (and explicit/originalTarget),
michael@0:          * which treats that as a mouse gesture for opening a new tab.
michael@0:          * In this context, we're manually blocking the dblclick event
michael@0:          * (see tabbrowser-close-tab-button dblclick handler).
michael@0:          */
michael@0:         if (this._blockDblClick) {
michael@0:           if (!("_clickedTabBarOnce" in this)) {
michael@0:             this._clickedTabBarOnce = true;
michael@0:             return;
michael@0:           }
michael@0:           delete this._clickedTabBarOnce;
michael@0:           this._blockDblClick = false;
michael@0:         }
michael@0:       ]]></handler>
michael@0: 
michael@0:       <handler event="click"><![CDATA[
michael@0:         if (event.button != 1)
michael@0:           return;
michael@0: 
michael@0:         if (event.target.localName == "tab") {
michael@0:           this.tabbrowser.removeTab(event.target, {animate: true, byMouse: true});
michael@0:         } else if (event.originalTarget.localName == "box") {
michael@0:           BrowserOpenTab();
michael@0:         } else {
michael@0:           return;
michael@0:         }
michael@0: 
michael@0:         event.stopPropagation();
michael@0:       ]]></handler>
michael@0: 
michael@0:       <handler event="keypress"><![CDATA[
michael@0:         if (event.altKey || event.shiftKey ||
michael@0: #ifdef XP_MACOSX
michael@0:             !event.metaKey)
michael@0: #else
michael@0:             !event.ctrlKey || event.metaKey)
michael@0: #endif
michael@0:           return;
michael@0: 
michael@0:         switch (event.keyCode) {
michael@0:           case KeyEvent.DOM_VK_UP:
michael@0:             this.tabbrowser.moveTabBackward();
michael@0:             break;
michael@0:           case KeyEvent.DOM_VK_DOWN:
michael@0:             this.tabbrowser.moveTabForward();
michael@0:             break;
michael@0:           case KeyEvent.DOM_VK_RIGHT:
michael@0:           case KeyEvent.DOM_VK_LEFT:
michael@0:             this.tabbrowser.moveTabOver(event);
michael@0:             break;
michael@0:           case KeyEvent.DOM_VK_HOME:
michael@0:             this.tabbrowser.moveTabToStart();
michael@0:             break;
michael@0:           case KeyEvent.DOM_VK_END:
michael@0:             this.tabbrowser.moveTabToEnd();
michael@0:             break;
michael@0:           default:
michael@0:             // Stop the keypress event for the above keyboard
michael@0:             // shortcuts only.
michael@0:             return;
michael@0:         }
michael@0:         event.stopPropagation();
michael@0:         event.preventDefault();
michael@0:       ]]></handler>
michael@0: 
michael@0:       <handler event="dragstart"><![CDATA[
michael@0:         var tab = this._getDragTargetTab(event);
michael@0:         if (!tab || this._isCustomizing)
michael@0:           return;
michael@0: 
michael@0:         let dt = event.dataTransfer;
michael@0:         dt.mozSetDataAt(TAB_DROP_TYPE, tab, 0);
michael@0:         let browser = tab.linkedBrowser;
michael@0: 
michael@0:         // We must not set text/x-moz-url or text/plain data here,
michael@0:         // otherwise trying to deatch the tab by dropping it on the desktop
michael@0:         // may result in an "internet shortcut"
michael@0:         dt.mozSetDataAt("text/x-moz-text-internal", browser.currentURI.spec, 0);
michael@0: 
michael@0:         // Set the cursor to an arrow during tab drags.
michael@0:         dt.mozCursor = "default";
michael@0: 
michael@0:         // Create a canvas to which we capture the current tab.
michael@0:         // Until canvas is HiDPI-aware (bug 780362), we need to scale the desired
michael@0:         // canvas size (in CSS pixels) to the window's backing resolution in order
michael@0:         // to get a full-resolution drag image for use on HiDPI displays.
michael@0:         let windowUtils = window.getInterface(Ci.nsIDOMWindowUtils);
michael@0:         let scale = windowUtils.screenPixelsPerCSSPixel / windowUtils.fullZoom;
michael@0:         let canvas = document.createElementNS("http://www.w3.org/1999/xhtml", "canvas");
michael@0:         canvas.mozOpaque = true;
michael@0:         canvas.width = 160 * scale;
michael@0:         canvas.height = 90 * scale;
michael@0:         PageThumbs.captureToCanvas(browser.contentWindow, canvas);
michael@0:         dt.setDragImage(canvas, -16 * scale, -16 * scale);
michael@0: 
michael@0:         // _dragData.offsetX/Y give the coordinates that the mouse should be
michael@0:         // positioned relative to the corner of the new window created upon
michael@0:         // dragend such that the mouse appears to have the same position
michael@0:         // relative to the corner of the dragged tab.
michael@0:         function clientX(ele) ele.getBoundingClientRect().left;
michael@0:         let tabOffsetX = clientX(tab) - clientX(this);
michael@0:         tab._dragData = {
michael@0:           offsetX: event.screenX - window.screenX - tabOffsetX,
michael@0:           offsetY: event.screenY - window.screenY,
michael@0:           scrollX: this.mTabstrip.scrollPosition,
michael@0:           screenX: event.screenX
michael@0:         };
michael@0: 
michael@0:         event.stopPropagation();
michael@0:       ]]></handler>
michael@0: 
michael@0:       <handler event="dragover"><![CDATA[
michael@0:         var effects = this._setEffectAllowedForDataTransfer(event);
michael@0: 
michael@0:         var ind = this._tabDropIndicator;
michael@0:         if (effects == "" || effects == "none") {
michael@0:           ind.collapsed = true;
michael@0:           return;
michael@0:         }
michael@0:         event.preventDefault();
michael@0:         event.stopPropagation();
michael@0: 
michael@0:         var tabStrip = this.mTabstrip;
michael@0:         var ltr = (window.getComputedStyle(this, null).direction == "ltr");
michael@0: 
michael@0:         // autoscroll the tab strip if we drag over the scroll
michael@0:         // buttons, even if we aren't dragging a tab, but then
michael@0:         // return to avoid drawing the drop indicator
michael@0:         var pixelsToScroll = 0;
michael@0:         if (this.getAttribute("overflow") == "true") {
michael@0:           var targetAnonid = event.originalTarget.getAttribute("anonid");
michael@0:           switch (targetAnonid) {
michael@0:             case "scrollbutton-up":
michael@0:               pixelsToScroll = tabStrip.scrollIncrement * -1;
michael@0:               break;
michael@0:             case "scrollbutton-down":
michael@0:               pixelsToScroll = tabStrip.scrollIncrement;
michael@0:               break;
michael@0:           }
michael@0:           if (pixelsToScroll)
michael@0:             tabStrip.scrollByPixels((ltr ? 1 : -1) * pixelsToScroll);
michael@0:         }
michael@0: 
michael@0:         if (effects == "move" &&
michael@0:             this == event.dataTransfer.mozGetDataAt(TAB_DROP_TYPE, 0).parentNode) {
michael@0:           ind.collapsed = true;
michael@0:           this._animateTabMove(event);
michael@0:           return;
michael@0:         }
michael@0: 
michael@0:         this._finishAnimateTabMove();
michael@0: 
michael@0:         if (effects == "link") {
michael@0:           let tab = this._getDragTargetTab(event);
michael@0:           if (tab) {
michael@0:             if (!this._dragTime)
michael@0:               this._dragTime = Date.now();
michael@0:             if (Date.now() >= this._dragTime + this._dragOverDelay)
michael@0:               this.selectedItem = tab;
michael@0:             ind.collapsed = true;
michael@0:             return;
michael@0:           }
michael@0:         }
michael@0: 
michael@0:         var rect = tabStrip.getBoundingClientRect();
michael@0:         var newMargin;
michael@0:         if (pixelsToScroll) {
michael@0:           // if we are scrolling, put the drop indicator at the edge
michael@0:           // so that it doesn't jump while scrolling
michael@0:           let scrollRect = tabStrip.scrollClientRect;
michael@0:           let minMargin = scrollRect.left - rect.left;
michael@0:           let maxMargin = Math.min(minMargin + scrollRect.width,
michael@0:                                    scrollRect.right);
michael@0:           if (!ltr)
michael@0:             [minMargin, maxMargin] = [this.clientWidth - maxMargin,
michael@0:                                       this.clientWidth - minMargin];
michael@0:           newMargin = (pixelsToScroll > 0) ? maxMargin : minMargin;
michael@0:         }
michael@0:         else {
michael@0:           let newIndex = this._getDropIndex(event);
michael@0:           if (newIndex == this.childNodes.length) {
michael@0:             let tabRect = this.childNodes[newIndex-1].getBoundingClientRect();
michael@0:             if (ltr)
michael@0:               newMargin = tabRect.right - rect.left;
michael@0:             else
michael@0:               newMargin = rect.right - tabRect.left;
michael@0:           }
michael@0:           else {
michael@0:             let tabRect = this.childNodes[newIndex].getBoundingClientRect();
michael@0:             if (ltr)
michael@0:               newMargin = tabRect.left - rect.left;
michael@0:             else
michael@0:               newMargin = rect.right - tabRect.right;
michael@0:           }
michael@0:         }
michael@0: 
michael@0:         ind.collapsed = false;
michael@0: 
michael@0:         newMargin += ind.clientWidth / 2;
michael@0:         if (!ltr)
michael@0:           newMargin *= -1;
michael@0: 
michael@0:         ind.style.transform = "translate(" + Math.round(newMargin) + "px)";
michael@0:         ind.style.MozMarginStart = (-ind.clientWidth) + "px";
michael@0:       ]]></handler>
michael@0: 
michael@0:       <handler event="drop"><![CDATA[
michael@0:         var dt = event.dataTransfer;
michael@0:         var dropEffect = dt.dropEffect;
michael@0:         var draggedTab;
michael@0:         if (dropEffect != "link") { // copy or move
michael@0:           draggedTab = dt.mozGetDataAt(TAB_DROP_TYPE, 0);
michael@0:           // not our drop then
michael@0:           if (!draggedTab)
michael@0:             return;
michael@0:         }
michael@0: 
michael@0:         this._tabDropIndicator.collapsed = true;
michael@0:         event.stopPropagation();
michael@0:         if (draggedTab && dropEffect == "copy") {
michael@0:           // copy the dropped tab (wherever it's from)
michael@0:           let newIndex = this._getDropIndex(event);
michael@0:           let newTab = this.tabbrowser.duplicateTab(draggedTab);
michael@0:           this.tabbrowser.moveTabTo(newTab, newIndex);
michael@0:           if (draggedTab.parentNode != this || event.shiftKey)
michael@0:             this.selectedItem = newTab;
michael@0:         } else if (draggedTab && draggedTab.parentNode == this) {
michael@0:           this._finishAnimateTabMove();
michael@0: 
michael@0:           // actually move the dragged tab
michael@0:           if ("animDropIndex" in draggedTab._dragData) {
michael@0:             let newIndex = draggedTab._dragData.animDropIndex;
michael@0:             if (newIndex > draggedTab._tPos)
michael@0:               newIndex--;
michael@0:             this.tabbrowser.moveTabTo(draggedTab, newIndex);
michael@0:           }
michael@0:         } else if (draggedTab) {
michael@0:           // swap the dropped tab with a new one we create and then close
michael@0:           // it in the other window (making it seem to have moved between
michael@0:           // windows)
michael@0:           let newIndex = this._getDropIndex(event);
michael@0:           let newTab = this.tabbrowser.addTab("about:blank");
michael@0:           let newBrowser = this.tabbrowser.getBrowserForTab(newTab);
michael@0:           // Stop the about:blank load
michael@0:           newBrowser.stop();
michael@0:           // make sure it has a docshell
michael@0:           newBrowser.docShell;
michael@0: 
michael@0:           let numPinned = this.tabbrowser._numPinnedTabs;
michael@0:           if (newIndex < numPinned || draggedTab.pinned && newIndex == numPinned)
michael@0:             this.tabbrowser.pinTab(newTab);
michael@0:           this.tabbrowser.moveTabTo(newTab, newIndex);
michael@0: 
michael@0:           // We need to select the tab before calling swapBrowsersAndCloseOther
michael@0:           // so that window.content in chrome windows points to the right tab
michael@0:           // when pagehide/show events are fired.
michael@0:           this.tabbrowser.selectedTab = newTab;
michael@0: 
michael@0:           draggedTab.parentNode._finishAnimateTabMove();
michael@0:           this.tabbrowser.swapBrowsersAndCloseOther(newTab, draggedTab);
michael@0: 
michael@0:           // Call updateCurrentBrowser to make sure the URL bar is up to date
michael@0:           // for our new tab after we've done swapBrowsersAndCloseOther.
michael@0:           this.tabbrowser.updateCurrentBrowser(true);
michael@0:         } else {
michael@0:           // Pass true to disallow dropping javascript: or data: urls
michael@0:           let url;
michael@0:           try {
michael@0:             url = browserDragAndDrop.drop(event, { }, true);
michael@0:           } catch (ex) {}
michael@0: 
michael@0:           if (!url)
michael@0:             return;
michael@0: 
michael@0:           let bgLoad = Services.prefs.getBoolPref("browser.tabs.loadInBackground");
michael@0: 
michael@0:           if (event.shiftKey)
michael@0:             bgLoad = !bgLoad;
michael@0: 
michael@0:           let tab = this._getDragTargetTab(event);
michael@0:           if (!tab || dropEffect == "copy") {
michael@0:             // We're adding a new tab.
michael@0:             let newIndex = this._getDropIndex(event);
michael@0:             let newTab = this.tabbrowser.loadOneTab(url, {inBackground: bgLoad, allowThirdPartyFixup: true});
michael@0:             this.tabbrowser.moveTabTo(newTab, newIndex);
michael@0:           } else {
michael@0:             // Load in an existing tab.
michael@0:             try {
michael@0:               let webNav = Ci.nsIWebNavigation;
michael@0:               let flags = webNav.LOAD_FLAGS_ALLOW_THIRD_PARTY_FIXUP |
michael@0:                           webNav.LOAD_FLAGS_FIXUP_SCHEME_TYPOS;
michael@0:               this.tabbrowser.getBrowserForTab(tab).loadURIWithFlags(url, flags);
michael@0:               if (!bgLoad)
michael@0:                 this.selectedItem = tab;
michael@0:             } catch(ex) {
michael@0:               // Just ignore invalid urls
michael@0:             }
michael@0:           }
michael@0:         }
michael@0: 
michael@0:         if (draggedTab) {
michael@0:           delete draggedTab._dragData;
michael@0:         }
michael@0:       ]]></handler>
michael@0: 
michael@0:       <handler event="dragend"><![CDATA[
michael@0:         // Note: while this case is correctly handled here, this event
michael@0:         // isn't dispatched when the tab is moved within the tabstrip,
michael@0:         // see bug 460801.
michael@0: 
michael@0:         this._finishAnimateTabMove();
michael@0: 
michael@0:         var dt = event.dataTransfer;
michael@0:         var draggedTab = dt.mozGetDataAt(TAB_DROP_TYPE, 0);
michael@0:         if (dt.mozUserCancelled || dt.dropEffect != "none" || this._isCustomizing) {
michael@0:           delete draggedTab._dragData;
michael@0:           return;
michael@0:         }
michael@0: 
michael@0:         // Disable detach within the browser toolbox
michael@0:         var eX = event.screenX;
michael@0:         var eY = event.screenY;
michael@0:         var wX = window.screenX;
michael@0:         // check if the drop point is horizontally within the window
michael@0:         if (eX > wX && eX < (wX + window.outerWidth)) {
michael@0:           let bo = this.mTabstrip.boxObject;
michael@0:           // also avoid detaching if the the tab was dropped too close to
michael@0:           // the tabbar (half a tab)
michael@0:           let endScreenY = bo.screenY + 1.5 * bo.height;
michael@0:           if (eY < endScreenY && eY > window.screenY)
michael@0:             return;
michael@0:         }
michael@0: 
michael@0:         // screen.availLeft et. al. only check the screen that this window is on,
michael@0:         // but we want to look at the screen the tab is being dropped onto.
michael@0:         var sX = {}, sY = {}, sWidth = {}, sHeight = {};
michael@0:         Cc["@mozilla.org/gfx/screenmanager;1"]
michael@0:           .getService(Ci.nsIScreenManager)
michael@0:           .screenForRect(eX, eY, 1, 1)
michael@0:           .GetAvailRect(sX, sY, sWidth, sHeight);
michael@0:         // ensure new window entirely within screen
michael@0:         var winWidth = Math.min(window.outerWidth, sWidth.value);
michael@0:         var winHeight = Math.min(window.outerHeight, sHeight.value);
michael@0:         var left = Math.min(Math.max(eX - draggedTab._dragData.offsetX, sX.value),
michael@0:                             sX.value + sWidth.value - winWidth);
michael@0:         var top = Math.min(Math.max(eY - draggedTab._dragData.offsetY, sY.value),
michael@0:                            sY.value + sHeight.value - winHeight);
michael@0: 
michael@0:         delete draggedTab._dragData;
michael@0: 
michael@0:         if (this.tabbrowser.tabs.length == 1) {
michael@0:           // resize _before_ move to ensure the window fits the new screen.  if
michael@0:           // the window is too large for its screen, the window manager may do
michael@0:           // automatic repositioning.
michael@0:           window.resizeTo(winWidth, winHeight);
michael@0:           window.moveTo(left, top);
michael@0:           window.focus();
michael@0:         } else {
michael@0:           this.tabbrowser.replaceTabWithWindow(draggedTab, { screenX: left,
michael@0:                                                              screenY: top,
michael@0: #ifndef XP_WIN
michael@0:                                                              outerWidth: winWidth,
michael@0:                                                              outerHeight: winHeight
michael@0: #endif
michael@0:                                                              });
michael@0:         }
michael@0:         event.stopPropagation();
michael@0:       ]]></handler>
michael@0: 
michael@0:       <handler event="dragexit"><![CDATA[
michael@0:         this._dragTime = 0;
michael@0: 
michael@0:         // This does not work at all (see bug 458613)
michael@0:         var target = event.relatedTarget;
michael@0:         while (target && target != this)
michael@0:           target = target.parentNode;
michael@0:         if (target)
michael@0:           return;
michael@0: 
michael@0:         this._tabDropIndicator.collapsed = true;
michael@0:         event.stopPropagation();
michael@0:       ]]></handler>
michael@0:     </handlers>
michael@0:   </binding>
michael@0: 
michael@0:   <!-- close-tab-button binding
michael@0:        This binding relies on the structure of the tabbrowser binding.
michael@0:        Therefore it should only be used as a child of the tab or the tabs
michael@0:        element (in both cases, when they are anonymous nodes of <tabbrowser>).
michael@0:   -->
michael@0:   <binding id="tabbrowser-close-tab-button"
michael@0:            extends="chrome://global/content/bindings/toolbarbutton.xml#toolbarbutton-image">
michael@0:     <handlers>
michael@0:       <handler event="click" button="0"><![CDATA[
michael@0:         var bindingParent = document.getBindingParent(this);
michael@0:         var tabContainer = bindingParent.parentNode;
michael@0:         tabContainer.tabbrowser.removeTab(bindingParent, {animate: true, byMouse: true});
michael@0:         // This enables double-click protection for the tab container
michael@0:         // (see tabbrowser-tabs 'click' handler).
michael@0:         tabContainer._blockDblClick = true;
michael@0:       ]]></handler>
michael@0: 
michael@0:       <handler event="dblclick" button="0" phase="capturing">
michael@0:         // for the one-close-button case
michael@0:         event.stopPropagation();
michael@0:       </handler>
michael@0: 
michael@0:       <handler event="dragstart">
michael@0:         event.stopPropagation();
michael@0:       </handler>
michael@0:     </handlers>
michael@0:   </binding>
michael@0: 
michael@0:   <binding id="tabbrowser-tab" display="xul:hbox"
michael@0:            extends="chrome://global/content/bindings/tabbox.xml#tab">
michael@0:     <resources>
michael@0:       <stylesheet src="chrome://browser/content/tabbrowser.css"/>
michael@0:     </resources>
michael@0: 
michael@0:     <content context="tabContextMenu" closetabtext="&closeTab.label;">
michael@0:       <xul:stack class="tab-stack" flex="1">
michael@0:         <xul:hbox xbl:inherits="pinned,selected,titlechanged,fadein"
michael@0:                   class="tab-background">
michael@0:           <xul:hbox xbl:inherits="pinned,selected,titlechanged"
michael@0:                     class="tab-background-start"/>
michael@0:           <xul:hbox xbl:inherits="pinned,selected,titlechanged"
michael@0:                     class="tab-background-middle"/>
michael@0:           <xul:hbox xbl:inherits="pinned,selected,titlechanged"
michael@0:                     class="tab-background-end"/>
michael@0:         </xul:hbox>
michael@0:         <xul:hbox xbl:inherits="pinned,selected,titlechanged"
michael@0:                   class="tab-content" align="center">
michael@0:           <xul:image xbl:inherits="fadein,pinned,busy,progress,selected"
michael@0:                      class="tab-throbber"
michael@0:                      role="presentation"
michael@0:                      layer="true" />
michael@0:           <xul:image xbl:inherits="src=image,fadein,pinned,selected"
michael@0:                      anonid="tab-icon-image"
michael@0:                      class="tab-icon-image"
michael@0:                      validate="never"
michael@0:                      role="presentation"/>
michael@0:           <xul:label flex="1"
michael@0:                      anonid="tab-label"
michael@0:                      xbl:inherits="value=visibleLabel,crop,accesskey,fadein,pinned,selected"
michael@0:                      class="tab-text tab-label"
michael@0:                      role="presentation"/>
michael@0:           <xul:toolbarbutton anonid="close-button"
michael@0:                              xbl:inherits="fadein,pinned,selected"
michael@0:                              class="tab-close-button close-icon"/>
michael@0:         </xul:hbox>
michael@0:       </xul:stack>
michael@0:     </content>
michael@0: 
michael@0:     <implementation>
michael@0:       <property name="label">
michael@0:         <getter>
michael@0:           return this.getAttribute("label");
michael@0:         </getter>
michael@0:         <setter>
michael@0:           this.setAttribute("label", val);
michael@0:           let event = new CustomEvent("TabLabelModified", {
michael@0:             bubbles: true,
michael@0:             cancelable: true
michael@0:           });
michael@0:           this.dispatchEvent(event);
michael@0: 
michael@0:           // Let listeners prevent synchronizing the actual label to the
michael@0:           // visible label (allowing them to override the visible label).
michael@0:           if (!event.defaultPrevented)
michael@0:             this.visibleLabel = val;
michael@0:         </setter>
michael@0:       </property>
michael@0:       <property name="visibleLabel">
michael@0:         <getter>
michael@0:           return this.getAttribute("visibleLabel");
michael@0:         </getter>
michael@0:         <setter>
michael@0:           this.setAttribute("visibleLabel", val);
michael@0:         </setter>
michael@0:       </property>
michael@0:       <property name="pinned" readonly="true">
michael@0:         <getter>
michael@0:           return this.getAttribute("pinned") == "true";
michael@0:         </getter>
michael@0:       </property>
michael@0:       <property name="hidden" readonly="true">
michael@0:         <getter>
michael@0:           return this.getAttribute("hidden") == "true";
michael@0:         </getter>
michael@0:       </property>
michael@0: 
michael@0:       <property name="lastAccessed">
michael@0:         <getter>
michael@0:           return this.selected ? Date.now() : this._lastAccessed;
michael@0:         </getter>
michael@0:         <setter>
michael@0:           this._lastAccessed = val;
michael@0:         </setter>
michael@0:       </property>
michael@0:       <field name="_lastAccessed">0</field>
michael@0: 
michael@0:       <field name="mOverCloseButton">false</field>
michael@0:       <field name="mCorrespondingMenuitem">null</field>
michael@0:       <field name="closing">false</field>
michael@0: 
michael@0:       <method name="_mouseenter">
michael@0:         <body><![CDATA[
michael@0:           if (this.hidden || this.closing)
michael@0:             return;
michael@0: 
michael@0:           let tabContainer = this.parentNode;
michael@0:           let visibleTabs = tabContainer.tabbrowser.visibleTabs;
michael@0:           let tabIndex = visibleTabs.indexOf(this);
michael@0:           if (tabIndex == 0) {
michael@0:             tabContainer._beforeHoveredTab = null;
michael@0:           } else {
michael@0:             let candidate = visibleTabs[tabIndex - 1];
michael@0:             if (!candidate.selected) {
michael@0:               tabContainer._beforeHoveredTab = candidate;
michael@0:               candidate.setAttribute("beforehovered", "true");
michael@0:             }
michael@0:           }
michael@0: 
michael@0:           if (tabIndex == visibleTabs.length - 1) {
michael@0:             tabContainer._afterHoveredTab = null;
michael@0:           } else {
michael@0:             let candidate = visibleTabs[tabIndex + 1];
michael@0:             if (!candidate.selected) {
michael@0:               tabContainer._afterHoveredTab = candidate;
michael@0:               candidate.setAttribute("afterhovered", "true");
michael@0:             }
michael@0:           }
michael@0: 
michael@0:           tabContainer._hoveredTab = this;
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_mouseleave">
michael@0:         <body><![CDATA[
michael@0:           let tabContainer = this.parentNode;
michael@0:           if (tabContainer._beforeHoveredTab) {
michael@0:             tabContainer._beforeHoveredTab.removeAttribute("beforehovered");
michael@0:             tabContainer._beforeHoveredTab = null;
michael@0:           }
michael@0:           if (tabContainer._afterHoveredTab) {
michael@0:             tabContainer._afterHoveredTab.removeAttribute("afterhovered");
michael@0:             tabContainer._afterHoveredTab = null;
michael@0:           }
michael@0: 
michael@0:           tabContainer._hoveredTab = null;
michael@0:         ]]></body>
michael@0:       </method>
michael@0:     </implementation>
michael@0: 
michael@0:     <handlers>
michael@0:       <handler event="mouseover"><![CDATA[
michael@0:         let anonid = event.originalTarget.getAttribute("anonid");
michael@0:         if (anonid == "close-button")
michael@0:           this.mOverCloseButton = true;
michael@0: 
michael@0:         this._mouseenter();
michael@0:       ]]></handler>
michael@0:       <handler event="mouseout"><![CDATA[
michael@0:         let anonid = event.originalTarget.getAttribute("anonid");
michael@0:         if (anonid == "close-button")
michael@0:           this.mOverCloseButton = false;
michael@0: 
michael@0:         this._mouseleave();
michael@0:       ]]></handler>
michael@0:       <handler event="dragstart" phase="capturing">
michael@0:         this.style.MozUserFocus = '';
michael@0:       </handler>
michael@0:       <handler event="mousedown" phase="capturing">
michael@0:       <![CDATA[
michael@0:         if (this.selected) {
michael@0:           this.style.MozUserFocus = 'ignore';
michael@0:           this.clientTop; // just using this to flush style updates
michael@0:         } else if (this.mOverCloseButton) {
michael@0:           // Prevent tabbox.xml from selecting the tab.
michael@0:           event.stopPropagation();
michael@0:         }
michael@0:       ]]>
michael@0:       </handler>
michael@0:       <handler event="mouseup">
michael@0:         this.style.MozUserFocus = '';
michael@0:       </handler>
michael@0:     </handlers>
michael@0:   </binding>
michael@0: 
michael@0:   <binding id="tabbrowser-alltabs-popup"
michael@0:            extends="chrome://global/content/bindings/popup.xml#popup">
michael@0:     <implementation implements="nsIDOMEventListener">
michael@0:       <method name="_tabOnAttrModified">
michael@0:         <parameter name="aEvent"/>
michael@0:         <body><![CDATA[
michael@0:           var tab = aEvent.target;
michael@0:           if (tab.mCorrespondingMenuitem)
michael@0:             this._setMenuitemAttributes(tab.mCorrespondingMenuitem, tab);
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_tabOnTabClose">
michael@0:         <parameter name="aEvent"/>
michael@0:         <body><![CDATA[
michael@0:           var tab = aEvent.target;
michael@0:           if (tab.mCorrespondingMenuitem)
michael@0:             this.removeChild(tab.mCorrespondingMenuitem);
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="handleEvent">
michael@0:         <parameter name="aEvent"/>
michael@0:         <body><![CDATA[
michael@0:           switch (aEvent.type) {
michael@0:             case "TabAttrModified":
michael@0:               this._tabOnAttrModified(aEvent);
michael@0:               break;
michael@0:             case "TabClose":
michael@0:               this._tabOnTabClose(aEvent);
michael@0:               break;
michael@0:             case "scroll":
michael@0:               this._updateTabsVisibilityStatus();
michael@0:               break;
michael@0:           }
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_updateTabsVisibilityStatus">
michael@0:         <body><![CDATA[
michael@0:           var tabContainer = gBrowser.tabContainer;
michael@0:           // We don't want menu item decoration unless there is overflow.
michael@0:           if (tabContainer.getAttribute("overflow") != "true")
michael@0:             return;
michael@0: 
michael@0:           var tabstripBO = tabContainer.mTabstrip.scrollBoxObject;
michael@0:           for (var i = 0; i < this.childNodes.length; i++) {
michael@0:             let curTab = this.childNodes[i].tab;
michael@0:             if (!curTab) // "Tab Groups" menuitem and its menuseparator
michael@0:               continue;
michael@0:             let curTabBO = curTab.boxObject;
michael@0:             if (curTabBO.screenX >= tabstripBO.screenX &&
michael@0:                 curTabBO.screenX + curTabBO.width <= tabstripBO.screenX + tabstripBO.width)
michael@0:               this.childNodes[i].setAttribute("tabIsVisible", "true");
michael@0:             else
michael@0:               this.childNodes[i].removeAttribute("tabIsVisible");
michael@0:           }
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_createTabMenuItem">
michael@0:         <parameter name="aTab"/>
michael@0:         <body><![CDATA[
michael@0:           var menuItem = document.createElementNS(
michael@0:             "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul",
michael@0:             "menuitem");
michael@0: 
michael@0:           menuItem.setAttribute("class", "menuitem-iconic alltabs-item menuitem-with-favicon");
michael@0: 
michael@0:           this._setMenuitemAttributes(menuItem, aTab);
michael@0: 
michael@0:           aTab.mCorrespondingMenuitem = menuItem;
michael@0:           menuItem.tab = aTab;
michael@0: 
michael@0:           this.appendChild(menuItem);
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_setMenuitemAttributes">
michael@0:         <parameter name="aMenuitem"/>
michael@0:         <parameter name="aTab"/>
michael@0:         <body><![CDATA[
michael@0:           aMenuitem.setAttribute("label", aTab.label);
michael@0:           aMenuitem.setAttribute("crop", aTab.getAttribute("crop"));
michael@0: 
michael@0:           if (aTab.hasAttribute("busy")) {
michael@0:             aMenuitem.setAttribute("busy", aTab.getAttribute("busy"));
michael@0:             aMenuitem.removeAttribute("image");
michael@0:           } else {
michael@0:             aMenuitem.setAttribute("image", aTab.getAttribute("image"));
michael@0:             aMenuitem.removeAttribute("busy");
michael@0:           }
michael@0: 
michael@0:           if (aTab.hasAttribute("pending"))
michael@0:             aMenuitem.setAttribute("pending", aTab.getAttribute("pending"));
michael@0:           else
michael@0:             aMenuitem.removeAttribute("pending");
michael@0: 
michael@0:           if (aTab.selected)
michael@0:             aMenuitem.setAttribute("selected", "true");
michael@0:           else
michael@0:             aMenuitem.removeAttribute("selected");
michael@0:         ]]></body>
michael@0:       </method>
michael@0:     </implementation>
michael@0: 
michael@0:     <handlers>
michael@0:       <handler event="popupshowing">
michael@0:       <![CDATA[
michael@0:         var tabcontainer = gBrowser.tabContainer;
michael@0: 
michael@0:         // Listen for changes in the tab bar.
michael@0:         tabcontainer.addEventListener("TabAttrModified", this, false);
michael@0:         tabcontainer.addEventListener("TabClose", this, false);
michael@0:         tabcontainer.mTabstrip.addEventListener("scroll", this, false);
michael@0: 
michael@0:         let tabs = gBrowser.visibleTabs;
michael@0:         for (var i = 0; i < tabs.length; i++) {
michael@0:           if (!tabs[i].pinned)
michael@0:             this._createTabMenuItem(tabs[i]);
michael@0:         }
michael@0:         this._updateTabsVisibilityStatus();
michael@0:       ]]></handler>
michael@0: 
michael@0:       <handler event="popuphidden">
michael@0:       <![CDATA[
michael@0:         // clear out the menu popup and remove the listeners
michael@0:         for (let i = this.childNodes.length - 1; i > 0; i--) {
michael@0:           let menuItem = this.childNodes[i];
michael@0:           if (menuItem.tab) {
michael@0:             menuItem.tab.mCorrespondingMenuitem = null;
michael@0:             this.removeChild(menuItem);
michael@0:           }
michael@0:         }
michael@0:         var tabcontainer = gBrowser.tabContainer;
michael@0:         tabcontainer.mTabstrip.removeEventListener("scroll", this, false);
michael@0:         tabcontainer.removeEventListener("TabAttrModified", this, false);
michael@0:         tabcontainer.removeEventListener("TabClose", this, false);
michael@0:       ]]></handler>
michael@0: 
michael@0:       <handler event="DOMMenuItemActive">
michael@0:       <![CDATA[
michael@0:         var tab = event.target.tab;
michael@0:         if (tab) {
michael@0:           let overLink = tab.linkedBrowser.currentURI.spec;
michael@0:           if (overLink == "about:blank")
michael@0:             overLink = "";
michael@0:           XULBrowserWindow.setOverLink(overLink, null);
michael@0:         }
michael@0:       ]]></handler>
michael@0: 
michael@0:       <handler event="DOMMenuItemInactive">
michael@0:       <![CDATA[
michael@0:         XULBrowserWindow.setOverLink("", null);
michael@0:       ]]></handler>
michael@0: 
michael@0:       <handler event="command"><![CDATA[
michael@0:         if (event.target.tab)
michael@0:           gBrowser.selectedTab = event.target.tab;
michael@0:       ]]></handler>
michael@0: 
michael@0:     </handlers>
michael@0:   </binding>
michael@0: 
michael@0:   <binding id="statuspanel" display="xul:hbox">
michael@0:     <content>
michael@0:       <xul:hbox class="statuspanel-inner">
michael@0:         <xul:label class="statuspanel-label"
michael@0:                    role="status"
michael@0:                    aria-live="off"
michael@0:                    xbl:inherits="value=label,crop,mirror"
michael@0:                    flex="1"
michael@0:                    crop="end"/>
michael@0:       </xul:hbox>
michael@0:     </content>
michael@0: 
michael@0:     <implementation implements="nsIDOMEventListener">
michael@0:       <constructor><![CDATA[
michael@0:         window.addEventListener("resize", this, false);
michael@0:       ]]></constructor>
michael@0: 
michael@0:       <destructor><![CDATA[
michael@0:         window.removeEventListener("resize", this, false);
michael@0:         MousePosTracker.removeListener(this);
michael@0:       ]]></destructor>
michael@0: 
michael@0:       <property name="label">
michael@0:         <setter><![CDATA[
michael@0:           if (!this.label) {
michael@0:             this.removeAttribute("mirror");
michael@0:             this.removeAttribute("sizelimit");
michael@0:           }
michael@0: 
michael@0:           this.style.minWidth = this.getAttribute("type") == "status" &&
michael@0:                                 this.getAttribute("previoustype") == "status"
michael@0:                                   ? getComputedStyle(this).width : "";
michael@0: 
michael@0:           if (val) {
michael@0:             this.setAttribute("label", val);
michael@0:             this.removeAttribute("inactive");
michael@0:             this._calcMouseTargetRect();
michael@0:             MousePosTracker.addListener(this);
michael@0:           } else {
michael@0:             this.setAttribute("inactive", "true");
michael@0:             MousePosTracker.removeListener(this);
michael@0:           }
michael@0: 
michael@0:           return val;
michael@0:         ]]></setter>
michael@0:         <getter>
michael@0:           return this.hasAttribute("inactive") ? "" : this.getAttribute("label");
michael@0:         </getter>
michael@0:       </property>
michael@0: 
michael@0:       <method name="getMouseTargetRect">
michael@0:         <body><![CDATA[
michael@0:           return this._mouseTargetRect;
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="onMouseEnter">
michael@0:         <body>
michael@0:           this._mirror();
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="onMouseLeave">
michael@0:         <body>
michael@0:           this._mirror();
michael@0:         </body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="handleEvent">
michael@0:         <parameter name="event"/>
michael@0:         <body><![CDATA[
michael@0:           if (!this.label)
michael@0:             return;
michael@0: 
michael@0:           switch (event.type) {
michael@0:             case "resize":
michael@0:               this._calcMouseTargetRect();
michael@0:               break;
michael@0:           }
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_calcMouseTargetRect">
michael@0:         <body><![CDATA[
michael@0:           let container = this.parentNode;
michael@0:           let alignRight = (getComputedStyle(container).direction == "rtl");
michael@0:           let panelRect = this.getBoundingClientRect();
michael@0:           let containerRect = container.getBoundingClientRect();
michael@0: 
michael@0:           this._mouseTargetRect = {
michael@0:             top:    panelRect.top,
michael@0:             bottom: panelRect.bottom,
michael@0:             left:   alignRight ? containerRect.right - panelRect.width : containerRect.left,
michael@0:             right:  alignRight ? containerRect.right : containerRect.left + panelRect.width
michael@0:           };
michael@0:         ]]></body>
michael@0:       </method>
michael@0: 
michael@0:       <method name="_mirror">
michael@0:         <body>
michael@0:           if (this.hasAttribute("mirror"))
michael@0:             this.removeAttribute("mirror");
michael@0:           else
michael@0:             this.setAttribute("mirror", "true");
michael@0: 
michael@0:           if (!this.hasAttribute("sizelimit")) {
michael@0:             this.setAttribute("sizelimit", "true");
michael@0:             this._calcMouseTargetRect();
michael@0:           }
michael@0:         </body>
michael@0:       </method>
michael@0:     </implementation>
michael@0:   </binding>
michael@0: 
michael@0: </bindings>