mail/base/content/tabmail.xml
author Thomas Schmid <schmid-thomas@gmx.net>
Wed, 16 Feb 2011 14:13:00 -0800
changeset 7250 491fbcf7a1b443860503f245f68941d8f7a1306b
parent 7067 c51913c44f242036112df133b7d455172b2da9f0
child 7251 33614283e6756b057b026a322b34dfbaa12db5e2
permissions -rw-r--r--
Bug 468808 - "Tabs can't be reordered". r=asuth

<?xml version="1.0"?>
<!-- ***** BEGIN LICENSE BLOCK *****
  - Version: MPL 1.1/GPL 2.0/LGPL 2.1
  -
  - The contents of this file are subject to the Mozilla Public License Version
  - 1.1 (the "License"); you may not use this file except in compliance with
  - the License. You may obtain a copy of the License at
  - http://www.mozilla.org/MPL/
  -
  - Software distributed under the License is distributed on an "AS IS" basis,
  - WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  - for the specific language governing rights and limitations under the
  - License.
  -
  - The Original Code is tab email
  -
  - The Initial Developer of the Original Code is
  -   David Bienvenu <bienvenu@nventure.com>.
  - Portions created by the Initial Developer are Copyright (C) 2007
  - the Initial Developer. All Rights Reserved.
  -
  - Contributor(s):
  -  Scott MacGregor <mscott@mozilla.org>
  -  Andrew Sutherland <asutherland@asutherland.org>
  -  Magnus Melin <mkmelin+mozilla@iki.fi>
  -  Thomas Schmid <schmid-thomas@gmx.net>
  -
  - Alternatively, the contents of this file may be used under the terms of
  - either the GNU General Public License Version 2 or later (the "GPL"), or
  - the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  - in which case the provisions of the GPL or the LGPL are applicable instead
  - of those above. If you wish to allow use of your version of this file only
  - under the terms of either the GPL or the LGPL, and not to allow others to
  - use your version of this file under the terms of the MPL, indicate your
  - decision by deleting the provisions above and replace them with the notice
  - and other provisions required by the GPL or the LGPL. If you do not delete
  - the provisions above, a recipient may use your version of this file under
  - the terms of any one of the MPL, the GPL or the LGPL.
  -
  - ***** END LICENSE BLOCK ***** -->

<!DOCTYPE bindings [
<!ENTITY % messengerDTD SYSTEM "chrome://messenger/locale/messenger.dtd" >
%messengerDTD;
<!ENTITY % tabMailDTD SYSTEM "chrome://messenger/locale/tabmail.dtd" >
 %tabMailDTD;
]>

<bindings id="tabmailBindings"
   xmlns="http://www.mozilla.org/xbl"
   xmlns:xul="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
   xmlns:xbl="http://www.mozilla.org/xbl">

  <!-- Thunderbird's tab UI mechanism.
    -
    - We expect to be instantiated with the following children:
    - * One "tabpanels" child element whose id must be placed in the
    -   "panelcontainer" attribute on the element we are being bound to. We do
    -   this because it is important to allow overlays to contribute panels.
    -   When we attempted to have the immediate children of the bound element
    -   be propagated through use of the "children" tag, we found that children
    -   contributed by overlays did not propagate.
    - * Any children you want added to the right side of the tab bar.  This is
    -   primarily intended to allow for "open a BLANK tab" buttons, namely
    -   calendar and tasks.  For reasons similar to the tabpanels case, we
    -   expect the instantiating element to provide a child hbox for overlays
    -   to contribute buttons to.
    -
    - From a javascript perspective, there are three types of code that we
    -  expect to interact with:
    - 1) Code that wants to open new tabs.
    - 2) Code that wants to contribute one or more varieties of tabs.
    - 3) Code that wants to monitor to know when the active tab changes.
    -
    - Consumer code should use the following methods:
    - * openTab(aTabModeName, aArgs)
    -     Open a tab of the given "mode", passing the provided arguments as an 
    -     object. The tab type author should tell you the modes they implement 
    -     and the required/optional arguments.
    -     One of the arguments you can pass is "background": if this is true,
    -     the tab will be loaded in the background.
    - * closeTab(aOptionalTabIndexInfoOrTabNode,aNoUndo): 
    -     If no argument is provided, the current tab is closed. The first 
    -     argument specifies a specific tab to be closed. It can be a tab index,
    -     a tab info object, or a tab's DOM element. In case the second 
    -     argument is true, the closed tab can't be restored by calling
    -     undoCloseTab(). 
    -     Please note, some tabs cannot be closed. Trying to close such tab, 
    -     willd fail silently.
    - * undoCloseTab(): 
    -     Restores the most recent tab closed by the user. 
    - * switchToTab(aTabIndexInfoOrTabNode): 
    -     Switch to the tab by providing a tab index, tab info object, or tab 
    -     node (tabmail-tab bound element.) You can also just poke at 
    -     tabmail.tabContainer and its selectedIndex and selectedItem
    -     properties.
    - * setTabIcon(aTabNodeorInfo, aIcon): Sets the tab icon to the specified
    -     url or removes the icon if no url is specified. Note that this may
    -     overrride css provided images.
    - * replaceTabWithWindow(aTab):
    -     Detaches a tab from this tabbar to new window. The argument "aTab" is 
    -     required and can be a tab index, a tab info object or a tabs's 
    -     DOM element. Calling this method works only for tabs implementing
    -     session restore.
    - * moveTabTo(aTab,aIndex):
    -     moves the given tab to the given Index. The first argument can be
    -     a tab index, a tab info object or a tab's DOM element. The second
    -     argument specifies the tabs new absolute position within the tabbar.
    - 
    - Less-friendly consumer methods:
    - * persistTab(tab):
    -     serializes a tab into an object, by passing  a tab info object as 
    -     argument. It is used for session restore and moving tabs between 
    -     windows. Returns null in case persist failes.
    - * removeCurrentTab():
    -     Close the current tab.
    - * removeTabByNode(aTabElement):
    -     Close the tab whose tabmail-tab bound element is passed in.
    - Changing the currently displayed tab is accomplished by changing
    -  tabmail.tabContainer's selectedIndex or selectedItem property.
    -
    - Code that lives in a tab should use the following methods:
    - * setTabTitle([aOptionalTabInfo]): Tells us that the title of the current
    -   tab (if no argument is provided) or provided tab needs to be updated.
    -   This will result in a call to the tab mode's logic to update the title.
    -   In the event this is not for the current tab, the caller is responsible
    -   for ensuring that the underlying tab mode is capable of providing a tab
    -   title when it is in the background.  (The is currently not the case for
    -   "folder" and "mail" modes because of their implementation.)
    - * setTabBusy(aTabNode, aBusyState): Tells us that the tab in question
    -   is now busy or not busy.  "Busy" means that it is occupied and
    -   will not be able to respond to you until it is no longer busy.
    -   This impacts the cursor display, as well as potentially
    -   providing tab display hints.
    - * setTabThinking(aTabNode, aThinkingState): Tells us that the
    -   tab in question is now thinking or not thinking.  "Thinking" means
    -   that the tab is involved in some ongoing process but you can still
    -   interact with the tab while it is thinking.  A search would be an
    -   example of thinking.  This impacts spinny-thing feedback as well as
    -   potential providing tab display hints.  aThinkingState may be a
    -   boolean or a localized string explaining what you are thinking about.
    -
    - Tab contributing code should define a tab type object and register it
    -  with us by calling registerTabType.  Each tab type can provide multiple
    -  tab modes.  The rationale behind this organization is that Thunderbird
    -  historically/currently uses a single 3-pane view to display both
    -  three-pane folder browsing and single message browsing across multiple
    -  tabs.  Each tab type has the ability to use a single tab panel for all
    -  of its display needs.  So Thunderbird's "mail" tab type covers both the
    -  "folder" (3-pane folder-based browsing)  and "message" (just a single
    -  message) tab modes.  Likewise, calendar/lightning currently displays both
    -  its calendar and tasks in the same panel.  A tab type can also create a
    -  new tabpanel for each tab as it is created.  In that case, the tab type 
    -  should probably only have a single mode unless there are a number of
    -  similar modes that can gain from code sharing.
    - The tab type definition should include the following attributes:
    - * name: The name of the tab-type, mainly to aid in debugging.
    - * panelId or perTabPanel: If using a single tab panel, the id of the
    -     panel must be provided in panelId.  If using one tab panel per tab,
    -     perTabPanel should be the XUL element name that should be created for
    -     each tab.  If a reason arises, in the future we might support
    -     this being a helper function to create and return the element.
    - * modes: An object whose attributes are mode names (which are
    -     automatically propagated to a 'name' attribute for debugging) and
    -     values are objects with the following attributes...
    - * any of the openTab/closeTab/saveTabState/showTab/onTitleChanged
    -     functions as described on the mode definitions.  These will only be
    -     called if the mode does not provide the functions.  Note that because
    -     the 'this' variable passed to the functions will always reference the
    -     tab type definition (rather than the mode definition), the mode
    -     functions can defer to the tab type functions by calling 
    -     this.functionName().  (This should prove convenient.)
    - Mode definition attributes:
    - * type: The "type" attribute to set on the displayed tab for CSS purposes.
    -     Generally, this would be the same as the mode name, but you can do as
    -     you please.
    - * isDefault: This should only be present and should be true for the tab
    -     mode that is the tab displayed automatically on startup.
    - * maxTabs: The maximum number of this mode that can be opened at a time.
    -     If this limit is reached, any additional calls to openTab for this
    -     mode will simply result in the first existing tab of this mode being
    -     displayed.
    - * shouldSwitchTo(aArgs): Optional function. Called when openTab is called
    -     on the top-level tabmail binding. It is used to decide if the openTab
    -     function should switch to an existing tab or actually open a new tab.
    -     If the openTab function should switch to an existing tab, return the
    -     index of that tab; otherwise return -1.
    -     aArgs is a set of named parameters (the ones that are later passed to
    -     openTab).
    - * openTab(aTab, aArgs): Called when a tab of the given mode is in the
    -     process of being opened.  aTab will have its "mode" attribute
    -     set to the mode definition of the tab mode being opened.  You should
    -     set the "title" attribute on it, and may set any other attributes
    -     you wish for your own use in subsequent functions.  Note that 'this'
    -     points to the tab type definition, not the mode definition as you
    -     might expect.  This allows you to place common logic code on the
    -     tab type for use by multiple modes and to defer to it.  Any arguments
    -     provided to the caller of tabmail.openTab will be passed to your
    -     function as well, including background.
    - * closeTab(aTab): Called when aTab is being closed.  The tab need not be
    -     currently displayed.  You are responsible for properly cleaning up
    -     any state you preserved in aTab.
    - * saveTabState(aTab): Called when aTab is being switched away from so that
    -     you can preserve its state on aTab.  This is primarily for single
    -     tab panel implementations; you may not have much state to save if your
    -     tab has its own tab panel.
    - * showTab(aTab): Called when aTab is being displayed and you should
    -     restore its state (if required).
    - * persistTab(aTab): Called when we want to persist the tab because we are
    -     saving the session state.  You should return an object suitable for
    -     JSON serialization.  The object will be provided to your restoreTab
    -     method when we attempt to restore the session.  If your code is
    -     unable or unwilling to persist the tab (some of the time), you should
    -     return null in that case.  If your code never wants to persist the tab
    -     you should not implement this method.  You must implement restoreTab
    -     if you implement this method.
    - * restoreTab(aTabmail, aPersistedState): Called when we are restoring a
    -     tab session and a tab with your mode was previously persisted via a
    -     call to your persistTab implementation.  You are provided with a
    -     reference to this tabmail instance and the (deserialized) state object
    -     you returned from your persistTab implementation.  It is your
    -     function's job to determine if you can restore the tab, and if so,
    -     you should invoke aTabmail.openTab to actually cause your tab to be
    -     opened.  This may seem odd, but it should help keep your code simple
    -     while letting you do whatever you want.  Since openTab is synchronous
    -     and returns the tabInfo structure built for the tab, you can perform
    -     any additional work you need after the call to openTab.
    - * onTitleChanged(aTab): Called when someone calls tabmail.setTabTitle() to
    -     hint that the tab's title needs to be updated.  This function should
    -     update aTab.title if it can.
    - Mode definition functions to do with menu/toolbar commands:
    - * supportsCommand(aCommand, aTab): Called when a menu or toolbar needs to
    -     be updated. Return true if you support that command in
    -     isCommandEnabled and doCommand, return false otherwise.
    - * isCommandEnabled(aCommand, aTab): Called when a menu or toolbar needs
    -     to be updated. Return true if the command can be executed at the
    -     current time, false otherwise.
    - * doCommand(aCommand, aTab): Called when a menu or toolbar command is to
    -     be executed. Perform the action appropriate to the command.
    - * onEvent(aEvent, aTab): This can be used to handle different events on
    -     the window.
    - * getBrowser(aTab): This function should return the browser element for
    -     your tab if there is one (return null or don't define this function
    -     otherwise). It is used for some toolkit functions that require a
    -     global "getBrowser" function, e.g. ZoomManager.
    -
    - Tab monitoring code is expected to be used for widgets on the screen
    -  outside of the tab box that need to update themselves as the active tab
    -  changes.
    - Tab monitoring code (un)registers itself via (un)registerTabMonitor.
    -  The following attributes should be provided on the monitor object:
    - * monitorName: A string value naming the tab monitor/extension.  This is
    -     the canonical name for the tab monitor for all persistence purposes.
    -     If the tab monitor wants to store data in the tab info object and its
    -     name is FOO it should store it in 'tabInfo._ext.FOO'.  This is the
    -     only place the tab monitor should store information on the tab info
    -     object.  The FOO attribute will not be automatically created; it is
    -     up to the code.  The _ext attribute will be there, reliably, however.
    -     The name is also used when persisting state, but the tab monitor
    -     does not need to do anything in that case; the name is automatically
    -     used in the course of wrapping the object.
    -  The following functions should be provided on the monitor object:
    - * onTabTitleChanged(aTab): Called when the tab's title changes.
    - * onTabSwitched(aTab, aOldTab): Called when a new tab is made active.  If
    -     this is the first tab ever, aOldTab will be null, otherwise aOldTab
    -     will be the previously active tab.
    - * onTabOpened(aTab, aIsFirstTab, aWasCurrentTab): Called when a new tab is
    -     opened.  This method is invoked after the tab mode's openTab method
    -     is invoked.  This method is invoked before the tab monitor
    -     onTabSwitched method in the case where it will be invoked.  (It is
    -     not invoked if the tab is opened in the background.)
    - * onTabClosing(aTab): Called when a tab is being closed.  This method is
    -     is invoked before the call to the tab mode's closeTab function.
    - * onTabPersist(aTab): Return a JSON-representable object to persist for
    -     the tab.  Return null if you do not have anything to persist.
    - * onTabRestored(aTab, aState, aIsFirstTab): Called when a tab is being
    -     restored and there is data previously persisted by the tab monitor.
    -     This method is called instead of invoking onTabOpened.  This is done
    -     because the restoreTab method (potentially) uses the tabmail openTab
    -     API to effect restoration.  (Note: the first opened tab is special;
    -     it will produce an onTabOpened notification potentially followed by
    -     an onTabRestored notification.)
    - Tab monitor code is also allowed to hook into the command processing
    -  logic.  We support the standard supportsCommand/isCommandEnabled/
    -  doCommand functions but with a twist to indicate when other tab monitors
    -  and the actual tab itself should get a chance to process: supportsCommand
    -  and isCommandEnabled should return null when they are not handling the
    -  case.  doCommand should return true if it handled the case, null
    -  otherwise.
    -->
  <binding id="tabmail">
    <resources>
      <stylesheet src="chrome://messenger/content/tabmail.css"/>
      <stylesheet src="chrome://messenger/skin/tabmail.css"/>
    </resources>
    <content>
      <xul:tabbox anonid="tabbox" flex="1" eventnode="document" xbl:inherits="handleCtrlPageUpDown"
                  onselect="if (!('updateCurrentTab' in this.parentNode) || event.target.localName != 'tabs')
                            return; this.parentNode.updateCurrentTab();">
        <xul:hbox align="start">
          <xul:image class="tab-drop-indicator" anonid="tab-drop-indicator" collapsed="true"/>
        </xul:hbox>        
        
        <xul:hbox class="tabmail-strip" collapsed="false" tooltip="_child" context="_child"
                  anonid="strip">
          <xul:tooltip onpopupshowing="return CreateToolbarTooltip(document, event);"/>
          <xul:menupopup anonid="tabContextMenu"
                onpopupshowing="
                  var tabmail = document.getElementById('tabmail');
                  return tabmail.onTabContextMenuShowing(document.popupNode);">
            
            <xul:menuitem label="&moveToNewWindow.label;" 
                          accesskey="&moveToNewWindow.accesskey;"
                          anonid="openTabInWindow"
                          oncommand="document.getElementById('tabmail').replaceTabWithWindow(document.popupNode);"/>
                                     
            <xul:menuseparator />
            
            <xul:menuitem label="&closeOtherTabsCmd2.label;" 
                          accesskey="&closeOtherTabsCmd2.accesskey;"
                          anonid="closeOtherTabs"
                          oncommand="document.getElementById('tabmail').closeOtherTabs(document.popupNode);"/>
                                                 
            <xul:menuseparator />
            
            <xul:menuitem label="&undoCloseTabCmd.label;"
                          accesskey="&undoCloseTabCmd.accesskey;"
                          anonid="undoCloseTab"
                          oncommand="document.getElementById('tabmail').undoCloseTab();"/>
                                                                         
            <xul:menuitem label="&closeTabCmd2.label;" 
                          accesskey="&closeTabCmd2.accesskey;"
                          anonid="closeTab"
                          oncommand="document.getElementById('tabmail').closeTab(document.popupNode);"/>
                                                                          
          </xul:menupopup>
          <xul:tabs class="tabmail-tabs" flex="1"
                    anonid="tabcontainer"
                    setfocus="false"
                    onclick="this.parentNode.parentNode.parentNode.onTabClick(event);">
            <xul:tab selected="true" validate="never" type="folder"
                     maxwidth="250" width="0" minwidth="100" flex="100"
                     class="tabmail-tab" crop="end"/>
            <children/>
          </xul:tabs>
        </xul:hbox>
        <!-- Remember, user of this binding, you need to provide tabpanels!  -->
        <children includes="tabpanels"/>
      </xul:tabbox>
    </content>

    <implementation implements="nsIController">
      <constructor>
        window.controllers.insertControllerAt(0, this);
        this._restoringTabState = null;
        this._tabUndo = [];
      </constructor>
      <destructor>
        window.controllers.removeController(this);
      </destructor>
      <field name="currentTabInfo">
        null
      </field>
      <!-- Temporary field that only has a non-null value during a call to
           openTab, and whose value is the currentTabInfo of the tab that was
           open when we received the call to openTab. -->
      <field name="_mostRecentTabInfo">
        null
      </field>
      <field name="tabTypes" readonly="true">
        new Object()
      </field>
      <field name="tabModes" readonly="true">
        new Object()
      </field>
      <field name="defaultTabMode">
        null
      </field>
      <field name="tabInfo" readonly="true">
        new Array()
      </field>
      <field name="tabStrip" readonly="true">
        document.getAnonymousElementByAttribute(this, "anonid", "strip");
      </field>
      <field name="tabContainer" readonly="true">
        document.getAnonymousElementByAttribute(this, "anonid", "tabcontainer");
      </field>
      <field name="panelContainer" readonly="true">
        document.getElementById(this.getAttribute("panelcontainer"));
      </field>
      <field name="tabMonitors" readonly="true">
        new Array()
      </field>
      <method name="registerTabType">
        <parameter name="aTabType"/>
        <body><![CDATA[
          if (aTabType.name in this.tabTypes)
            return;
        
          this.tabTypes[aTabType.name] = aTabType;
          for (let [modeName, modeDetails] in Iterator(aTabType.modes)) {
            modeDetails.name = modeName;
            modeDetails.tabType = aTabType;
            modeDetails.tabs = [];
            this.tabModes[modeName] = modeDetails;
            if (modeDetails.isDefault)
              this.defaultTabMode = modeDetails;
          }
          
          aTabType.panel = document.getElementById(aTabType.panelId);
        ]]></body>
      </method>
      <method name="registerTabMonitor">
        <parameter name="aTabMonitor"/>
        <body><![CDATA[
          if (this.tabMonitors.indexOf(aTabMonitor) == -1)
            this.tabMonitors.push(aTabMonitor);
        ]]></body>
      </method>
      <method name="unregisterTabMonitor">
        <parameter name="aTabMonitor"/>
        <body><![CDATA[
          if (this.tabMonitors.indexOf(aTabMonitor) >= 0)
            this.tabMonitors.splice(this.tabMonitors.indexOf(aTabMonitor), 1);
        ]]></body>
      </method>
      <!-- Given an index, tab node or tab info object, return a tuple of
           [iTab, tab info dictionary, tab DOM node].  If
           aTabIndexNodeOrInfo is not specified and aDefaultToCurrent is
           true, the current tab will be returned.  Otherwise, an
           exception will be thrown.
        -->
      <method name="_getTabContextForTabbyThing">
        <parameter name="aTabIndexNodeOrInfo"/>
        <parameter name="aDefaultToCurrent"/>
        <body><![CDATA[
          let iTab, tab, tabNode;
          if (aTabIndexNodeOrInfo == null) {
            if (!aDefaultToCurrent)
              throw Error("You need to specify a tab!");
            iTab = this.tabContainer.selectedIndex;
            return [iTab, this.tabInfo[iTab],
                    this.tabContainer.childNodes[iTab]];
          }

          if (typeof(aTabIndexNodeOrInfo) == "number") {
            iTab = aTabIndexNodeOrInfo;
            tabNode = this.tabContainer.childNodes[iTab];
            tab = this.tabInfo[iTab];
          }
          else if (aTabIndexNodeOrInfo.tagName == "tab") {
            tabNode = aTabIndexNodeOrInfo;
            iTab = this.tabContainer.getIndexOfItem(tabNode);
            tab = this.tabInfo[iTab];
          }
          else {
            tab = aTabIndexNodeOrInfo;
            iTab = this.tabInfo.indexOf(tab);
            tabNode = (iTab >= 0) ? this.tabContainer.childNodes[iTab] : null;
          }

          return [iTab, tab, tabNode];
        ]]></body>
      </method>
      <method name="openFirstTab">
        <body><![CDATA[
          // From the moment of creation, our XBL binding already has a visible
          //  tab.  We need to create a tab information structure for this tab.
          //  In the process we also generate a synthetic tab title changed
          //  event to ensure we have an accurate title.  We assume the tab
          //  contents will set themselves up correctly.
          if (this.tabInfo.length == 0) {
            let firstTab = {mode: this.defaultTabMode, busy: false,
                            canClose: false,
                            _ext: {}};
            firstTab.mode.tabs.push(firstTab);

            this.tabInfo[0] = this.currentTabInfo = firstTab;

            let tabOpenFirstFunc = firstTab.mode.openFirstTab ||
                                   firstTab.mode.tabType.openFirstTab;
            tabOpenFirstFunc.call(firstTab.mode.tabType, firstTab);
            this.setTabTitle(null);

            for each (let [i, tabMonitor] in Iterator(this.tabMonitors)) {
              if ("onTabOpened" in tabMonitor)
                tabMonitor.onTabOpened(firstTab, true);
              tabMonitor.onTabSwitched(firstTab, null);
            }
          }
        ]]></body>
      </method>
      <method name="openTab">
        <parameter name="aTabModeName"/>
        <parameter name="aArgs"/>
        <body>
            <![CDATA[
        try {
          if (!(aTabModeName in this.tabModes))
            throw new Error("No such tab mode: " + aTabModeName);
          let tabMode = this.tabModes[aTabModeName];
          // if we are already at our limit for this mode, show an existing one
          if (tabMode.tabs.length == tabMode.maxTabs) {
            let desiredTab = tabMode.tabs[0];
            this.tabContainer.selectedIndex = this.tabInfo.indexOf(desiredTab);
            return;
          }

          // Do this so that we don't generate strict warnings
          let background = ("background" in aArgs) && aArgs.background;

          // If the mode wants us to, we should switch to an existing tab
          // rather than open a new one. We shouldn't switch to the tab if
          // we're opening it in the background, though.
          let shouldSwitchToFunc = tabMode.shouldSwitchTo ||
                                   tabMode.tabType.shouldSwitchTo;

          if (shouldSwitchToFunc) {
            let tabIndex = shouldSwitchToFunc.apply(tabMode.tabType, [aArgs]);
            if (tabIndex >= 0) {
              if (!background)
                this.selectTabByIndex(null, tabIndex);
              return;
            }
          }

          if (!background)
            // we need to save the state before it gets corrupted
            this.saveCurrentTabState();

          let tab = {mode: tabMode, busy: false, canClose: true, _ext: {}};
          tabMode.tabs.push(tab);

          var t = document.createElementNS(
            "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul",
            "tab");
          tab.tabNode = t;
          t.setAttribute("crop", "end");
          t.maxWidth = this.tabContainer.mTabMaxWidth;
          t.minWidth = this.tabContainer.mTabMinWidth;
          t.width = 0;
          t.setAttribute("flex", "100");
          t.setAttribute("validate", "never");
          t.className = "tabmail-tab";
          this.tabContainer.appendChild(t);
          if (this.tabContainer.collapsed) {
            this.tabContainer.collapsed = false;
            this.tabContainer.adjustTabstrip();
          }

          let oldTab = this._mostRecentTabInfo = this.currentTabInfo;

          // the order of the following statements is important
          this.tabInfo[this.tabContainer.childNodes.length - 1] = tab;
          if (!background) {
            this.currentTabInfo = tab;
            // this has a side effect of calling updateCurrentTab, but our
            //  setting currentTabInfo above will cause it to take no action.
            this.tabContainer.selectedIndex =
              this.tabContainer.childNodes.length - 1;
          }

          // make sure we are on the right panel
          if (tab.mode.tabType.perTabPanel) {
            // should we create the element for them, or will they do it?
            if (typeof(tab.mode.tabType.perTabPanel) == "string") {
              tab.panel = document.createElementNS(
                "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul",
                tab.mode.tabType.perTabPanel);
            }
            else {
              tab.panel = tab.mode.tabType.perTabPanel(tab);
            }
            this.panelContainer.appendChild(tab.panel);
            if (!background)
              this.panelContainer.selectedPanel = tab.panel;
          }
          else if (!background)
            this.panelContainer.selectedPanel = tab.mode.tabType.panel;

          let tabOpenFunc = tab.mode.openTab || tab.mode.tabType.openTab;
          tabOpenFunc.apply(tab.mode.tabType, [tab, aArgs]);

          let restoreState = this._restoringTabState;
          for each (let [i, tabMonitor] in Iterator(this.tabMonitors)) {
            if (("onTabRestored" in tabMonitor) && restoreState &&
                (tabMonitor.monitorName in restoreState.ext))
              tabMonitor.onTabRestored(tab,
                                       restoreState.ext[tabMonitor.monitorName],
                                       false);
            else if ("onTabOpened" in tabMonitor)
              tabMonitor.onTabOpened(tab, false, oldTab);
            if (!background)
              tabMonitor.onTabSwitched(tab, oldTab);
          }
          
          // clear _mostRecentTabInfo; we only needed it during the call to
          //  openTab.
          this._mostRecentTabInfo = null;
          
          t.setAttribute("label", tab.title);

          if (!background)
            this.setDocumentTitle(tab);

          // for styling purposes, apply the type to the tab...
          t.setAttribute('type', tab.mode.type);

          if (!background)
            // Update the toolbar status - we don't need to do menus as they
            // do themselves when we open them.
            UpdateMailToolbar("tabmail");

          return tab;
          } catch (e) { logException(e);}
        ]]></body>
      </method>
      <method name="selectTabByMode">
        <parameter name="aTabModeName"/>
        <body><![CDATA[
          let tabMode = this.tabModes[aTabModeName];
          if (tabMode.tabs.length) {
            let desiredTab = tabMode.tabs[0];
            this.tabContainer.selectedIndex = this.tabInfo.indexOf(desiredTab);
          }
        ]]></body>
      </method>
      <method name="selectTabByIndex">
        <parameter name="aEvent"/>
        <parameter name="aIndex"/>
        <body><![CDATA[
          // count backwards for aIndex < 0
          if (aIndex < 0)
            aIndex += this.tabInfo.length;

          if (aIndex >= 0 &&
              aIndex < this.tabInfo.length &&
              aIndex != this.tabContainer.selectedIndex) {
            this.tabContainer.selectedIndex = aIndex;
          }

          if (aEvent) {
            aEvent.preventDefault();
            aEvent.stopPropagation();
          }
        ]]></body>
      </method>
      <method name="getTabInfoForCurrentOrFirstModeInstance">
        <parameter name="aTabMode"/>
        <body><![CDATA[
        /**
         * If the current/most recent tab is of mode aTabModeName, return its
         *  tab info, otherwise return the tab info for the first tab of the
         *  given mode.
         * You would want to use this method when you would like to mimic the
         *  settings of an existing instance of your mode.  In such a case,
         *  it is reasonable to assume that if the 'current' tab was of the
         *  same mode that its settings should be used.  Otherwise, we must
         *  fall back to another tab.  We currently choose the first tab of
         *  the instance, because for the "folder" tab, it is the canonical tab.
         *  In other cases, having an MRU order and choosing the MRU tab might
         *  be more appropriate.
         *
         * @return the tab info object for the tab meeting the above criteria,
         *     or null if no such tab exists.
         */
          // If we're in the middle of opening a new tab
          // (this._mostRecentTabInfo is non-null), we shouldn't consider the
          // current tab
          let tabToConsider = this._mostRecentTabInfo || this.currentTabInfo;
          if (tabToConsider && tabToConsider.mode == aTabMode)
            return tabToConsider;
          else if (aTabMode.tabs.length)
            return aTabMode.tabs[0];
          else
            return null;
        ]]></body>
      </method>
      <method name="undoCloseTab">
        <body><![CDATA[
          let history = this._tabUndo.pop();
          
          if (!history.tab)
            return;

          if (!this.restoreTab(JSON.parse(history.tab)))
            return;
          
          let idx = Math.min(history.idx,this.tabInfo.length);          
          let tab = this.tabContainer.childNodes[this.tabInfo.length - 1];
          this.moveTabTo(tab, idx);
          
          this.switchToTab(tab);
          
        ]]></body>
      </method>
      <method name="closeTab">
        <parameter name="aOptTabIndexNodeOrInfo"/>
        <parameter name="aNoUndo" />
        <body><![CDATA[
        
            let [iTab, tab, tabNode] =
              this._getTabContextForTabbyThing(aOptTabIndexNodeOrInfo, true);

            if (!tab.canClose)
              return;

            for each (let [i, tabMonitor] in Iterator(this.tabMonitors)) {
              if ("onTabClosing" in tabMonitor)
                tabMonitor.onTabClosing(tab);
            }

            if (!aNoUndo) {
              // Allow user to undo accidentially closed tabs
              let session = this.persistTab(tab);

              if (session) {
                this._tabUndo.push(
                    { tab: JSON.stringify(session), idx: iTab } );

                if (this._tabUndo.length > 10)
                  this._tabUndo.shift();    
              }
            }
            
            let closeFunc = tab.mode.closeTab || tab.mode.tabType.closeTab;
            closeFunc.call(tab.mode.tabType, tab);
             
            this.tabInfo.splice(iTab, 1);
            tab.mode.tabs.splice(tab.mode.tabs.indexOf(tab), 1);
            this.tabContainer.removeChild(tabNode);
            if (this.tabContainer.selectedIndex == -1)
              this.tabContainer.selectedIndex =
                (iTab == this.tabContainer.childNodes.length) ? iTab - 1 : iTab;
            if (this.currentTabInfo == tab)
              this.updateCurrentTab();

            if (tab.panel) {
              this.panelContainer.removeChild(tab.panel);
              delete tab.panel;

              // Ensure current tab is still selecte and displayed in the
              // panelContainer.
              this.panelContainer.selectedPanel =
                this.currentTabInfo.panel || this.currentTabInfo.mode.tabType.panel;
            }
            if (this.tabContainer.childNodes.length == 1 &&
                this.tabContainer.mAutoHide)
              this.tabContainer.collapsed = true;
          ]]>
        </body>
      </method>
      <method name="removeTabByNode">
        <parameter name="aTabNode"/>
        <body>
          <![CDATA[
            this.closeTab(aTabNode);
          ]]>
        </body>
      </method>
      <method name="closeOtherTabs">
        <parameter name="aTabNode"/>
        <body>
          <![CDATA[
            /**
             * Given a tabNode (or tabby thing), close all of the other tabs
             *  that are closeable.
             */
            let [iTab, thisTab, tabNode] = this._getTabContextForTabbyThing(
                                           aTabNode, false);

            // closeTab mutates the tabInfo array, so start from the end.
            for (let i = this.tabInfo.length - 1; i >= 0; i--) {
              let tab = this.tabInfo[i];
              if ((tab != thisTab) && tab.canClose)
                this.closeTab(tab);
            }
          ]]>
        </body>
      </method>
      <method name="replaceTabWithWindow">
        <parameter name="aTab"/>
        <body>
          <![CDATA[
            if (this.tabInfo.length <= 1)
              return null;

            let tab = this._getTabContextForTabbyThing(aTab, false)[1];
                                                         
            if (!tab.canClose)
              return null;
            
            // We use Json and session restore transfer the tab to the new window.
            tab = this.persistTab(tab);
            if (!tab)
              return null;
        
            // Converting to JSON and back again creates clean javascript 
            // object with absolutely no references to our current window.
            let tab = JSON.parse(JSON.stringify(tab));            
            
            this.closeTab(aTab,true);
                      
            return window.openDialog("chrome://messenger/content/", "_blank",
               "chrome,dialog=no,all", null,  
               { action : "restore", tabs: [tab] } ).focus();
          ]]>
        </body>
      </method>      
      <method name="moveTabTo">
        <parameter name="aTab"/>
        <parameter name="aIndex"/>
        <body><![CDATA[
          
          if ((!aTab) || (aTab.tagName != "tab"))
            return -1;

          let oldIdx = this.tabContainer.getIndexOfItem(aTab);
          if (oldIdx < 0)
            return -1;
          
          if (oldIdx == aIndex)
            return -1;
            
          // Cache the old tabInfo
          let tab = this.tabInfo[oldIdx];          
          
          if (!tab)
            return -1;
                     
          // remove the entries form tabInfo, tabMode and tabStrip
          this.tabInfo.splice(oldIdx, 1);
          tab.mode.tabs.splice(tab.mode.tabs.indexOf(tab), 1);
          this.tabContainer.removeChild(aTab);
          

          // as we removed items, we might need to update indices
          if (oldIdx < aIndex)
            aIndex --;
                       
          // Read it into tabInfo and tabStrip.
          this.tabInfo.splice(aIndex, 0, tab);
          this.tabContainer.insertBefore(aTab, this.tabContainer.childNodes[aIndex]);
          
          // Now it's getting a bit ugly, as tabModes stores redundant
          // information we need to get it in sync with tabInfo.
          //              
          // As tabModes.tabs is a subset of tabInfo, every tab can be mapped 
          // to a tabInfo index. So we check for each tab in tabModes if it is 
          // directly in front of our moved tab. We do this by looking up the 
          // index in tabInfo and compare it with the moved tab's index. If we
          // found our tab, we insert the moved tab directly behind into tabModes
          
          // In case find no tab we simply append it 
          let modeIdx = tab.mode.tabs.length+1;
          
          for (let i = 0; i < tab.mode.tabs.length; i++) {
                    
            if (this.tabInfo.indexOf(tab.mode.tabs[i]) < aIndex)
              continue;
              
            modeIdx = i;
            break;
          }
                            
          tab.mode.tabs.splice(modeIdx, 0, tab);          
          
          return aIndex;
         ]]>
         </body>
       </method>
       <method name="persistTab">
         <parameter name="tab"/>        
         <body><![CDATA[              
           /* Returns null in case persist fails */
           
           let persistFunc = tab.mode.persistTab || tab.mode.tabType.persistTab;
        
           // if we can't restore the tab we can't move it
           if (!persistFunc)
             return null; 
                 
           //  If there is a non-null tab-state, then persisting succeeded and
           //  we should store it.  We store the tab's persisted state in its
           //  own distinct object rather than mixing things up in a dictionary
           //  to avoid bugs and because we may eventually let extensions store
           //  per-tab information in the persisted state.
           
           let tabState;
           // Wrap this in an exception handler so that if the persistence
           // logic fails, things like tab closure still run to completion.
           try {
             tabState = persistFunc.call(tab.mode.tabType, tab);
           }
           catch(ex) {
             // Report this so that our unit testing framework sees this
             // error and (extension) developers likewise can see when their
             // extensions are ill-behaved.
             Components.utils.reportError(ex);
           }

           if (!tabState)
             return null;
             
           let ext = {};

           for each (let [i, tabMonitor] in Iterator(this.tabMonitors)) {
             if ("onTabPersist" in tabMonitor) {
               let monState = tabMonitor.onTabPersist(tab);
               if (monState !== null)
                 ext[tabMonitor.monitorName] = monState;
             }
           }
           
           return {mode: tab.mode.name, state: tabState, ext: ext}           
        ]]></body>
      </method>
      
      <method name="persistTabs">
        <body><![CDATA[
          /**
           * Persist the state of all tab modes implementing persistTab methods
           *  to a JSON-serializable object representation and return it.  Call
           *  restoreTabs with the result to restore the tab state.
           * Calling this method should have no side effects; tabs will not be
           *  closed, displays will not change, etc.  This means the method is
           *  safe to use in an auto-save style so that if we crash we can
           *  restore the (approximate) state at the time of the crash.
           *
           * @return {Object} The persisted tab states.
           */
          let state = {
            // Explicitly specify a revision so we don't wish we had later.
            rev: 0,
            // If our currently selected tab gets persisted, we will update this
            selectedIndex: null,
          };
          
          let tabs = state.tabs = [];

          for each (let [iTab, tab] in Iterator(this.tabInfo)) {
          
            let persistTab = this.persistTab(tab);
            
            if (!persistTab)
              continue;
            
            tabs.push(persistTab);
            
            // Mark this persisted tab as selected
            if (iTab == this.tabContainer.selectedIndex)
              state.selectedIndex = tabs.length - 1;
          }

          return state;
        ]]></body>
      </method>      
      <method name="restoreTab">
        <parameter name="aState"/>
        <body><![CDATA[
                    
          // if we no longer know about the mode, we can't restore the tab        
          let mode = this.tabModes[aState.mode];        
          if (!mode)
            return false;
          
          let restoreFunc = mode.restoreTab || mode.tabType.restoreTab;
        
          if (!restoreFunc)
            return false;
            
          // normalize the state to have an ext attribute if it does not.
          if (!("ext" in aState))
            aState.ext = {};
            
          this._restoringTabState = aState;  
          restoreFunc.call(mode.tabType, this, aState.state);
          this._restoringTabState = null;
          
          return true;
          
        ]]></body>
      </method>          
      <method name="restoreTabs">
        <parameter name="aPersistedState"/>
        <parameter name="aDontRestoreFirstTab"/>
        <body><![CDATA[
          /**
           * Attempts to restore tabs persisted from a prior call to
           *  |persistTabs|.  This is currently a synchronous operation, but in
           *  the future this may kick off an asynchronous mechanism to restore
           *  the tabs one-by-one.
           */
          let tabs = aPersistedState.tabs;
          let indexToSelect = null;
          for each (let [iTab, tabState] in Iterator(tabs)) {
          
            if (tabState.state.firstTab && aDontRestoreFirstTab)
              tabState.state.dontRestoreFirstTab = aDontRestoreFirstTab;
          
            if (!this.restoreTab(tabState))
              continue;

            // If this persisted tab was the selected one, then mark the newest
            //  tab as the guy to select.
            if (iTab == aPersistedState.selectedIndex)
              indexToSelect = this.tabInfo.length - 1;
          }
          
          if (indexToSelect != null && !aDontRestoreFirstTab)
            this.tabContainer.selectedIndex = indexToSelect;
          else
            this.tabContainer.selectedIndex = 0;
        ]]></body>
      </method>

      <!-- Called when the window is being unloaded, this calls the close
           function for every tab. -->
      <method name="_teardown">
        <body>
          <![CDATA[
            for (var i = 0; i < this.tabInfo.length; i++) {
              let tab = this.tabInfo[i];
              
              let tabCloseFunc = tab.mode.closeTab || tab.mode.tabType.closeTab;
              tabCloseFunc.call(tab.mode.tabType, tab);
            }
          ]]>
        </body>
      </method>

      <property name="selectedTab" readonly="true">
        <getter><![CDATA[
          if (!this.currentTabInfo)
            this.currentTabInfo = this.tabInfo[0];

          return this.currentTabInfo;
        ]]></getter>
      </property>

      <!-- getBrowserForSelectedTab is required as some toolkit functions
           require a getBrowser() function. -->
      <method name="getBrowserForSelectedTab">
        <body><![CDATA[
          if (!this.currentTabInfo)
            this.currentTabInfo = this.tabInfo[0];

          let tab = this.currentTabInfo;

          let browserFunc = tab.mode.getBrowser || tab.mode.tabType.getBrowser;
          if (browserFunc)
            return browserFunc.call(tab.mode.tabType, tab);

          return null;
        ]]></body>
      </method>
      <!-- getBrowserForDocument is used to find the browser for a specific
           document that's been loaded -->
      <method name="getBrowserForDocument">
        <parameter name="aDocument"/>
        <body><![CDATA[
          for (let i = 0; i < this.tabInfo.length; ++i) {
            let browserFunc = this.tabInfo[i].mode.getBrowser ||
                              this.tabInfo[i].mode.tabType.getBrowser;
            if (browserFunc) {
              var possBrowser = browserFunc.call(this.tabInfo[i].mode.tabType,
                                                 this.tabInfo[i]);
              if (possBrowser &&
                  possBrowser.contentWindow == aDocument)
                return this.tabInfo[i];
            }
          }
          return null;
        ]]></body>
      </method>
      <method name="removeCurrentTab">
        <body><![CDATA[
          this.removeTabByNode(
            this.tabContainer.childNodes[this.tabContainer.selectedIndex]);
        ]]></body>
      </method>
      <method name="switchToTab">
        <parameter name="aTabIndexNodeOrInfo"/>
        <body>
          <![CDATA[
            let [iTab, tab, tabNode] =
              this._getTabContextForTabbyThing(aTabIndexNodeOrInfo, false);

            this.tabContainer.selectedIndex = iTab;
          ]]>
        </body>
      </method>
      <!--  UpdateCurrentTab - called in response to changing the current tab -->
      <method name="updateCurrentTab">
        <body>
          <![CDATA[
            if (this.currentTabInfo != this.tabInfo[this.tabContainer.selectedIndex])
            {
              if (this.currentTabInfo)
                this.saveCurrentTabState();
              
              let oldTab = this.currentTabInfo;
              let tab = this.currentTabInfo =
                this.tabInfo[this.tabContainer.selectedIndex];

              this.panelContainer.selectedPanel = tab.panel ||
                                                  tab.mode.tabType.panel;

              let showTabFunc = tab.mode.showTab || tab.mode.tabType.showTab;
              showTabFunc.call(tab.mode.tabType, tab);

              for each (let [i, tabMonitor] in Iterator(this.tabMonitors))
                tabMonitor.onTabSwitched(tab, oldTab);

              // always update the cursor status when we switch tabs
              SetBusyCursor(window, tab.busy);
              // active tabs should not have the wasBusy attribute
              this.tabContainer.selectedItem.removeAttribute("wasBusy");

              // update the thinking status when we switch tabs
              this._setActiveThinkingState(tab.thinking);
              // active tabs should not have the wasThinking attribute
              this.tabContainer.selectedItem.removeAttribute("wasThinking");

              this.setDocumentTitle(tab);

              // Update the toolbar status - we don't need to do menus as they
              // do themselves when we open them.
              UpdateMailToolbar("tabmail");
            }
          ]]>
        </body>
      </method>
      <method name="saveCurrentTabState">
        <body>
          <![CDATA[
            if (!this.currentTabInfo)
              this.currentTabInfo = this.tabInfo[0];
            let tab = this.currentTabInfo;
            
            // save the old tab state before we change the current tab
            let saveTabFunc = tab.mode.saveTabState ||
                              tab.mode.tabType.saveTabState;
            saveTabFunc.call(tab.mode.tabType, tab);
          ]]>
        </body>
      </method>
      <method name="onTabClick">
        <parameter name="event"/>
        <body>
          <![CDATA[
            // a middle mouse button click on a tab is a short cut for closing a tab
            if (event.button != 1 || event.target.localName != 'tab')
              return;
            this.removeTabByNode(event.target);
            event.stopPropagation();
          ]]>
        </body>
      </method>
      <method name="setTabTitle">
        <parameter name="aTabNodeOrInfo"/>
        <body>
          <![CDATA[
            let [iTab, tab, tabNode] =
              this._getTabContextForTabbyThing(aTabNodeOrInfo, true);

            if (tab)
            {
              let tabNode =
                this.tabContainer.childNodes[iTab];

              let titleChangeFunc = tab.mode.onTitleChanged ||
                                    tab.mode.tabType.onTitleChanged;
              if (titleChangeFunc)
                titleChangeFunc.call(tab.mode.tabType, tab, tabNode);

              for each (let [, tabMonitor] in Iterator(this.tabMonitors))
                tabMonitor.onTabTitleChanged(tab);

              tabNode.setAttribute("label", tab.title);

              // Update the window title if we're the displayed tab.
              if (iTab == this.tabContainer.selectedIndex)
                this.setDocumentTitle(tab);
            }
          ]]>
        </body>
      </method>
      <!--
        - Sets the tab icon to the specified url, or removes the icon if no
        - url is specified. Note that this may override css provided images.
        -->
      <method name="setTabIcon">
        <parameter name="aTabNodeOrInfo"/>
        <parameter name="aIcon"/>
        <body>
          <![CDATA[
            let [iTab, tab, tabNode] =
              this._getTabContextForTabbyThing(aTabNodeOrInfo, true);

            if (tab) {
              let tabNode = this.tabContainer.childNodes[iTab];

              if (aIcon)
                tabNode.setAttribute("image", aIcon);
              else
                tabNode.removeAttribute("image");
            }
          ]]>
        </body>
      </method>
      <!--
        - Updates the global state to reflect the active tab's thinking
        -   state (which the caller provides).
        -->
      <method name="_setActiveThinkingState">
        <parameter name="aThinkingState"/>
        <body><![CDATA[
          if (aThinkingState) {
            statusFeedback.showProgress(0);
            if (typeof(aThinkingState) == "string")
              statusFeedback.showStatusString(aThinkingState);
            gStatusBar.setAttribute("mode","undetermined");
          }
          else {
            statusFeedback.showProgress(0);
            gStatusBar.setAttribute("mode", "normal");
          }
        ]]></body>
      </method>
      <method name="setTabThinking">
        <parameter name="aTabNodeOrInfo"/>
        <parameter name="aThinking"/>
        <body>
          <![CDATA[
            let [iTab, tab, tabNode] = this._getTabContextForTabbyThing(
                                         aTabNodeOrInfo, false);
            let isSelected = (iTab == this.tabContainer.selectedIndex);

            // if we are the current tab, update the cursor
            if (isSelected)
              this._setActiveThinkingState(aThinking);

            // if we are busy, hint our tab
            if (aThinking) {
              tabNode.setAttribute("thinking", "true");
            }
            else {
              // if we were thinking and are not selected, set the
              //  "wasThinking" attribute.
              if (tab.thinking && !isSelected)
                tabNode.setAttribute("wasThinking", "true");
              tabNode.removeAttribute("thinking");
            }

            // update the tab info to store the busy state.
            tab.thinking = aThinking;
          ]]>
        </body>
      </method>
      <method name="setTabBusy">
        <parameter name="aTabNodeOrInfo"/>
        <parameter name="aBusy"/>
        <body>
          <![CDATA[
            let [iTab, tab, tabNode] = this._getTabContextForTabbyThing(
                                         aTabNodeOrInfo, false);
            let isSelected = (iTab == this.tabContainer.selectedIndex);

            // if we are the current tab, update the cursor
            if (isSelected)
              SetBusyCursor(window, aBusy);

            // if we are busy, hint our tab
            if (aBusy) {
              tabNode.setAttribute("busy", "true");
            }
            else {
              // if we were busy and are not selected, set the
              //  "wasBusy" attribute.
              if (tab.busy && !isSelected)
                tabNode.setAttribute("wasBusy", "true");
              tabNode.removeAttribute("busy");
            }

            // update the tab info to store the busy state.
            tab.busy = aBusy;
          ]]>
        </body>
      </method>
      <method name="onTabContextMenuShowing">
        <parameter name="aTabNode"/>
        <body>
          <![CDATA[
            // this happens when the user did not actually-click on a tab but
            // instead on the strip behind it.
            if (aTabNode.localName != "tab")
              return false;

            let tab = this._getTabContextForTabbyThing(aTabNode, true) [1];
             
            // by default "close other tabs" is disabled...
            document
              .getAnonymousElementByAttribute(this, "anonid", "closeOtherTabs")
              .setAttribute("disabled","true")
                          
            // ... except if we find at least one other tab that can be closed.
            for (let i = 0; i < this.tabInfo.length; i++) {
            
              if (this.tabInfo[i].canClose && this.tabInfo[i] != tab) {
              
                document
                  .getAnonymousElementByAttribute(this,"anonid", "closeOtherTabs")
                  .setAttribute("disabled","false")
                  
                break;
              }
            }
            
            document
              .getAnonymousElementByAttribute(this, "anonid", "closeTab")
              .setAttribute("disabled", tab.canClose ? "false" : "true");       
            
            // enable "Open in new Window" iff tab is closable and...
            // ... it can persist its state. Other wise it would get destroyed...
            // ... while moving it to a new window.
            document
              .getAnonymousElementByAttribute(this, "anonid", "openTabInWindow")
              .setAttribute("disabled", 
                  (tab.canClose && this.persistTab(tab)) ? "false" : "true")

            // If the tab history is empty, disable "Undo Close Tab"
            document
              .getAnonymousElementByAttribute(this, "anonid", "undoCloseTab")
              .setAttribute("disabled",
                  (this._tabUndo.length) ? "false" : "true");
                          
            return true;
          ]]>
        </body>
      </method>
      <method name="supportsCommand">
        <parameter name="aCommand"/>
        <body>
          <![CDATA[
            let tab = this.currentTabInfo;

            // This can happen if we're starting up and haven't got a tab
            // loaded yet.
            if (!tab)
              return false;

            for each (let [, tabMonitor] in Iterator(this.tabMonitors)) {
              if ("supportsCommand" in tabMonitor) {
                let result = tabMonitor.supportsCommand(aCommand, tab);
                if (result !== null)
                  return result;
              }
            }

            let supportsCommandFunc = tab.mode.supportsCommand ||
                                      tab.mode.tabType.supportsCommand;
            if (supportsCommandFunc)
              return supportsCommandFunc.call(tab.mode.tabType, aCommand, tab);

            return false;
          ]]>
        </body>
      </method>
      <method name="isCommandEnabled">
        <parameter name="aCommand"/>
        <body>
          <![CDATA[
            let tab = this.currentTabInfo;

            // This can happen if we're starting up and haven't got a tab
            // loaded yet.
            if (!tab)
              return false;

            for each (let [, tabMonitor] in Iterator(this.tabMonitors)) {
              if ("isCommandEnabled" in tabMonitor) {
                let result = tabMonitor.isCommandEnabled(aCommand, tab);
                if (result !== null)
                  return result;
              }
            }

            let isCommandEnabledFunc = tab.mode.isCommandEnabled ||
                                       tab.mode.tabType.isCommandEnabled;
            if (isCommandEnabledFunc)
              return isCommandEnabledFunc.call(tab.mode.tabType, aCommand, tab);

            return false;
          ]]>
        </body>
      </method>
      <method name="doCommand">
        <parameter name="aCommand"/>
        <body>
          <![CDATA[
            let tab = this.currentTabInfo;

            // This can happen if we're starting up and haven't got a tab
            // loaded yet.
            if (!tab)
              return;

            for each (let [, tabMonitor] in Iterator(this.tabMonitors)) {
              if ("doCommand" in tabMonitor) {
                let result = tabMonitor.doCommand(aCommand, tab);
                if (result === true)
                  return;
              }
            }

            let doCommandFunc = tab.mode.doCommand ||
                                tab.mode.tabType.doCommand;
            if (doCommandFunc)
              doCommandFunc.call(tab.mode.tabType, aCommand, tab);
          ]]>
        </body>
      </method>
      <method name="onEvent">
        <parameter name="aEvent"/>
        <body>
           <![CDATA[
             let tab = this.currentTabInfo;

             // This can happen if we're starting up and haven't got a tab
             // loaded yet.
             if (!tab)
               return;

             let onEventFunc = tab.mode.onEvent ||
                               tab.mode.tabType.onEvent;
             if (onEventFunc)
               return onEventFunc.call(tab.mode.tabType, aEvent, tab);

             return false;
           ]]>
        </body>
      </method>
      <!-- Set the document title based on the tab title -->
      <method name="setDocumentTitle">
        <parameter name="aTab"/>
        <body>
          <![CDATA[
            let docTitle = aTab.title;

            // If the tab hasn't got a title, or we're on Mac, don't display
            // the separator.
            if (docTitle && !Application.platformIsMac)
              docTitle += document.documentElement
                                  .getAttribute("titlemenuseparator");

            // If we haven't got a title at this stage add the modifier, or if
            // we are on a non-mac platform, add the modifier.
            if (!docTitle || !Application.platformIsMac)
              docTitle += document.documentElement
                                  .getAttribute("titlemodifier");

            document.title = docTitle;
          ]]>
        </body>
      </method>
    </implementation>
  </binding>

  <binding id="tabmail-tab" display="xul:box"
           extends="chrome://global/content/bindings/tabbox.xml#tab">
    <content closetabtext="&closeTab.label;">
      <xul:hbox class="tab-image-left" xbl:inherits="selected"/>
      <xul:hbox class="tab-image-middle box-inherit" align="center"
                xbl:inherits="dir,pack,orient,selected" flex="1">
        <xul:image class="tab-throbber" xbl:inherits="busy,thinking"/>
        <xul:image class="tab-icon-image" xbl:inherits="validate,src=image"/>
        <xul:label class="tab-text"
                  xbl:inherits="value=label,accesskey,crop,disabled"
                  crop="right" flex="1"/>
      </xul:hbox>
      <xul:toolbarbutton anonid="close-button" class="tab-close-button" tabindex="-1"/>
      <xul:hbox class="tab-image-right" xbl:inherits="selected"/>
    </content>

    <implementation>
      <field name="mOverCloseButton">false</field>
      <field name="mCorrespondingMenuitem">null</field>
    </implementation>

    <handlers>
      <handler event="mouseover">
        var anonid = event.originalTarget.getAttribute("anonid");
        if (anonid == "close-button")
          this.mOverCloseButton = true;
      </handler>
      <handler event="mouseout">
        var anonid = event.originalTarget.getAttribute("anonid");
        if (anonid == "close-button")
          this.mOverCloseButton = false;
      </handler>
      <handler event="mousedown" button="0" phase="capturing">
      <![CDATA[
        if (this.mOverCloseButton)
          event.stopPropagation();
      ]]>
      </handler>
    </handlers>
  </binding>

  <binding id="tabmail-arrowscrollbox" extends="chrome://global/content/bindings/scrollbox.xml#arrowscrollbox-clicktoscroll">
    <content>
      <xul:toolbarbutton class="scrollbutton-up" collapsed="true"
                         xbl:inherits="orient"
                         anonid="scrollbutton-up"
                         onmousedown="_startScroll(-1);"
                         onmouseup="_stopScroll();"
                         onmouseout="_stopScroll();"/>
      <xul:scrollbox xbl:inherits="orient,align,pack,dir" flex="1" anonid="scrollbox">
        <children/>
      </xul:scrollbox>
      <xul:stack align="center" pack="end" class="scrollbutton-down-stack">
        <xul:hbox flex="1" class="scrollbutton-down-box" 
                           collapsed="true" anonid="down-box"/>
        <xul:hbox flex="1" class="scrollbutton-down-box-animate" 
                           collapsed="true" anonid="down-box-animate"/>
        <xul:toolbarbutton class="scrollbutton-down" collapsed="true"
                           xbl:inherits="orient"
                           anonid="scrollbutton-down"
                           onmousedown="_startScroll(1);"
                           onmouseup="_stopScroll();"
                           onmouseout="_stopScroll();"/>
      </xul:stack>
    </content>
    <implementation>
      <field name="_scrollButtonDownBox">
        document.getAnonymousElementByAttribute(this, "anonid", "down-box");
      </field>
      <field name="_scrollButtonDownBoxAnimate">
        document.getAnonymousElementByAttribute(this, "anonid", "down-box-animate");
      </field>
    </implementation>
    <handlers>
      <handler event="underflow"><![CDATA[
        // filter underflow events which were dispatched on nested scrollboxes
        if (event.target != this)
          return;

        // Ignore vertical events.
        if (event.detail == 0) {
          return;
        }

        this._scrollButtonDownBox.collapsed = true;
        this._scrollButtonDownBoxAnimate.collapsed = true;
      ]]></handler>

      <handler event="overflow"><![CDATA[
        // filter underflow events which were dispatched on nested scrollboxes
        if (event.target != this)
          return;

        // Ignore vertical events.
        if (event.detail == 0) {
          return;
        }

        this._scrollButtonDownBox.collapsed = false;
        this._scrollButtonDownBoxAnimate.collapsed = false;
      ]]></handler>

      <handler event="UpdatedScrollButtonsDisabledState"><![CDATA[
        // filter underflow events which were dispatched on nested scrollboxes
        if (event.target != this)
          return;

        // fix for bug #352353
        // unlike the scrollup button on the tab strip (which is a 
        // simple toolbarbutton) the scrolldown button is 
        // a more complicated stack of boxes and a toolbarbutton
        // so that we can animate when a tab is opened offscreen.
        // in order to style the box with the actual background image
        // we need to manually set the disable state to match the
        // disable state of the toolbarbutton.
        this._scrollButtonDownBox
            .setAttribute("disabled", this._scrollButtonDown.disabled);
      ]]></handler>

    </handlers>
  </binding>

  <binding id="tabmail-tabs"
           extends="chrome://global/content/bindings/tabbox.xml#tabs">
    <content>
      <xul:stack flex="1" class="tabs-stack">
        <xul:vbox>
          <xul:spacer flex="1"/>
          <xul:hbox class="tabs-bottom" align="center"/>
        </xul:vbox>
        <xul:vbox>
          <xul:hbox>
            <xul:stack>
              <xul:spacer class="tabs-left"/>
            </xul:stack>
            <xul:arrowscrollbox class="tabmail-arrowscrollbox"
                                anonid="arrowscrollbox"
                                orient="horizontal"
                                flex="1"
                                style="min-width: 1px;">
              <children includes="tab"/>
            </xul:arrowscrollbox>
            <children/>
            <xul:stack align="center" pack="end">
              <xul:hbox class="tabs-alltabs-box" anonid="alltabs-box" flex="1"/>
              <xul:hbox class="tabs-alltabs-box-animate"
                        anonid="alltabs-box-animate"
                        flex="1"/>
              <xul:toolbarbutton class="tabs-alltabs-button"
                                 anonid="alltabs-button"
                                 type="menu"
                                 tooltipstring="&listAllTabs.label;">
                <xul:menupopup class="tabs-alltabs-popup"
                               anonid="alltabs-popup" position="after_end"/>
              </xul:toolbarbutton>
            </xul:stack>
            <xul:hbox class="tabs-closebutton-box"
                      anonid="tabstrip-closebutton"
                      align="center" pack="end">
              <xul:toolbarbutton class="close-button tabs-closebutton"/>
            </xul:hbox>
          </xul:hbox>
          <xul:spacer class="tabs-bottom-spacer"/>
        </xul:vbox>
      </xul:stack>
    </content>

    <implementation implements="nsITimerCallback, nsIDOMEventListener">
      <constructor>
        <![CDATA[
          var pb2 =
              Components.classes['@mozilla.org/preferences-service;1'].
              getService(Components.interfaces.nsIPrefBranch2);

          try {
            this.mTabMinWidth = pb2.getIntPref("mail.tabs.tabMinWidth");
          } catch (e) {
          }
          try {
            this.mTabMaxWidth = pb2.getIntPref("mail.tabs.tabMaxWidth");
          } catch (e) {
          }
          try {
            this.mTabClipWidth = pb2.getIntPref("mail.tabs.tabClipWidth");
          } catch (e) {
          }
          try {
            this.mCloseButtons = pb2.getIntPref("mail.tabs.closeButtons");
          } catch (e) {
          }
          try {
            this.mAutoHide = pb2.getBoolPref("mail.tabs.autoHide");
          } catch (e) {
          }

          if (this.mAutoHide)
            this.collapsed = true;

          this.firstChild.minWidth = this.mTabMinWidth;
          this.firstChild.maxWidth = this.mTabMaxWidth;
          this.adjustTabstrip();

          pb2.addObserver("mail.tabs.", this._prefObserver, false);

          window.addEventListener("resize", this, false);

          // Listen to overflow/underflow events on the tabstrip,
          // we cannot put these as xbl handlers on the entire binding because
          // they would also get called for the all-tabs popup scrollbox.
          // Also, we can't rely on event.target becuase these are all
          // anonymous nodes.
          this.mTabstrip.addEventListener("overflow", this, false);
          this.mTabstrip.addEventListener("underflow", this, false);
        ]]>
      </constructor>

      <destructor>
        <![CDATA[
          var pb2 =
              Components.classes['@mozilla.org/preferences-service;1'].
              getService(Components.interfaces.nsIPrefBranch2);
          pb2.removeObserver("mail.tabs.", this._prefObserver);

          // Release timer to avoid reference cycles.
          if (this._animateTimer) {
            this._animateTimer.cancel();
            this._animateTimer = null;
          }

          this.mTabstrip.removeEventListener("overflow", this, false);
          this.mTabstrip.removeEventListener("underflow", this, false);
        ]]>
      </destructor>

      <field name="mTabstripWidth">0</field>

      <field name="mTabstrip">
        document.getAnonymousElementByAttribute(this, "anonid", "arrowscrollbox");
      </field>

      <field name="mTabstripClosebutton">
        document.getAnonymousElementByAttribute(this, "anonid", "tabstrip-closebutton");
      </field>

      <field name="_prefObserver">({
        tabbox: this,
  
        observe: function(subject, topic, data)
        {
          if (topic == "nsPref:changed") {
            subject.QueryInterface(Components.interfaces.nsIPrefBranch);
            switch (data) {
            case "mail.tabs.closeButtons":
              this.tabbox.mCloseButtons = subject.getIntPref("mail.tabs.closeButtons");
              this.tabbox.adjustTabstrip();
              break;
            case "mail.tabs.autoHide":
              this.tabbox.mAutoHide = subject.getBoolPref("mail.tabs.autoHide");
              break;
            }
          }
        },
  
        QueryInterface: function(aIID)
        {
          if (aIID.equals(Components.interfaces.nsIObserver) ||
              aIID.equals(Components.interfaces.nsISupports))
            return this;
          throw Components.results.NS_NOINTERFACE;
        }
        });
      </field>
      
      <field name="_tabDropIndicator">
        document.getAnonymousElementByAttribute(
            this.parentNode.parentNode.parentNode, 
            "anonid", "tab-drop-indicator");
      </field>
      
      <field name="_dragOverDelay">350</field>
      <field name="_dragTime">0</field>
      
      <field name="mTabMinWidth">100</field>
      <field name="mTabMaxWidth">250</field>
      <field name="mTabClipWidth">140</field>
      <field name="mCloseButtons">1</field>

      <field name="_mAutoHide">false</field>
      <property name="mAutoHide" onget="return this._mAutoHide;">
        <setter><![CDATA[
          if (val != this._mAutoHide) {
            if (this.childNodes.length == 1)
              this.collapsed = val;
            this._mAutoHide = val;
          }
          return val;
        ]]></setter>
      </property>

      <method name="adjustTabstrip">
        <body><![CDATA[
          // modes for tabstrip
          // 0 - activetab  = close button on active tab only
          // 1 - alltabs    = close buttons on all tabs
          // 2 - noclose    = no close buttons at all
          // 3 - closeatend = close button at the end of the tabstrip
          switch (this.mCloseButtons) {
          case 0:
            this.setAttribute("closebuttons", "activetab");
            break;
          case 1:
            var width = this.firstChild.boxObject.width;
            // 0 width is an invalid value and indicates
            // an item without display, so ignore.
            if (width > this.mTabClipWidth || width == 0)
              this.setAttribute("closebuttons", "alltabs");
            else
              this.setAttribute("closebuttons", "activetab");
            break;
          case 2:
          case 3:
            this.setAttribute("closebuttons", "noclose");
            break;
          }
          this.mTabstripClosebutton.collapsed = this.mCloseButtons != 3;
        ]]></body>
      </method>
        
      <field name="_mPrefs">null</field>
      <property name="mPrefs" readonly="true">
        <getter>
        <![CDATA[
          if (!this._mPrefs) {
            this._mPrefs =
              Components.classes['@mozilla.org/preferences-service;1'].
              getService(Components.interfaces.nsIPrefBranch2);
          }
          return this._mPrefs;
        ]]>
        </getter>
      </property>
        
      <method name="_handleTabSelect">
        <body><![CDATA[
          this.mTabstrip.ensureElementIsVisible(this.selectedItem);
        ]]></body>
      </method>

      <method name="handleEvent">
        <parameter name="aEvent"/>
        <body><![CDATA[
          switch (aEvent.type) {
            case "overflow":
              this.setAttribute("overflow", "true");
              this.mTabstrip.scrollBoxObject
                            .ensureElementIsVisible(this.selectedItem);
              break;
            case "underflow":
              this.removeAttribute("overflow");
              break;
            case "resize":
              var width = this.mTabstrip.boxObject.width;
              if (width != this.mTabstripWidth) {
                this.adjustTabstrip();
                // XXX without this line the tab bar won't budge
                this.mTabstrip.scrollByPixels(1);
                this._handleTabSelect();
                this.mTabstripWidth = width;
              }
              break;
          }
        ]]></body>
      </method>

      <field name="mAllTabsPopup">
        document.getAnonymousElementByAttribute(this, 
                                                "anonid", "alltabs-popup");
      </field>

      <field name="mAllTabsBoxAnimate">
        document.getAnonymousElementByAttribute(this, 
                                                "anonid",
                                                "alltabs-box-animate");
      </field>

      <field name="mDownBoxAnimate">
        this.mTabstrip._scrollButtonDownBoxAnimate;
      </field>

      <field name="mAllTabsButton">
        document.getAnonymousElementByAttribute(this, 
                                                "anonid", "alltabs-button");
      </field>

      <field name="_animateTimer">null</field>
      <field name="_animateStep">-1</field>
      <field name="_animateDelay">25</field>
      <field name="_animatePercents">
       [1.00, 0.85, 0.80, 0.75, 0.71, 0.68, 0.65, 0.62, 0.59, 0.57,
        0.54, 0.52, 0.50, 0.47, 0.45, 0.44, 0.42, 0.40, 0.38, 0.37,
        0.35, 0.34, 0.32, 0.31, 0.30, 0.29, 0.28, 0.27, 0.26, 0.25,
        0.24, 0.23, 0.23, 0.22, 0.22, 0.21, 0.21, 0.21, 0.20, 0.20,
        0.20, 0.20, 0.20, 0.20, 0.20, 0.20, 0.19, 0.19, 0.19, 0.18,
        0.18, 0.17, 0.17, 0.16, 0.15, 0.14, 0.13, 0.11, 0.09, 0.06]
      </field>

      <method name="_stopAnimation">
        <body><![CDATA[
          if (this._animateStep != -1) {
            if (this._animateTimer)
              this._animateTimer.cancel();

            this._animateStep = -1;
            this.mAllTabsBoxAnimate.style.opacity = 0.0;
            this.mDownBoxAnimate.style.opacity = 0.0;
          }
        ]]></body>
      </method>
      
      <method name="_notifyBackgroundTab">
        <parameter name="aTab"/>
        <body><![CDATA[
          var tsbo = this.mTabstrip.scrollBoxObject;
          var tsboStart = tsbo.screenX;
          var tsboEnd = tsboStart + tsbo.width;

          var ctbo = aTab.boxObject;
          var ctboStart = ctbo.screenX;
          var ctboEnd = ctboStart + ctbo.width;

          // only start the flash timer if the new tab (which was loaded in
          // the background) is not completely visible
          if (tsboStart > ctboStart || ctboEnd > tsboEnd) {
            this._animateStep = 0;

            if (!this._animateTimer) 
              this._animateTimer =
                Components.classes["@mozilla.org/timer;1"]
                          .createInstance(Components.interfaces.nsITimer);
            else
               this._animateTimer.cancel();

            this._animateTimer.initWithCallback(this,
                         this._animateDelay,
                         Components.interfaces.nsITimer.TYPE_REPEATING_SLACK);
          }
        ]]></body>
      </method>
      
      <method name="notify">
        <parameter name="aTimer"/>
        <body><![CDATA[
          if (!document)
            aTimer.cancel();

          var percent = this._animatePercents[this._animateStep];
          this.mAllTabsBoxAnimate.style.opacity = percent;
          this.mDownBoxAnimate.style.opacity = percent;

          if (this._animateStep < (this._animatePercents.length - 1))
            this._animateStep++;
          else
            this._stopAnimation();
        ]]></body>
      </method>
      
      <method name="_getDragTargetTab">
        <parameter name="event"/>
        <body><![CDATA[     
                                   
          if (event.target.localName != "tab")
            return null;
                      
          let tab = event.target;
          
          if ((event.type != "drop") && (event.type != "dragover")) 
            return tab;
            
          let boxObject = tab.boxObject;
          
          if (event.screenX < boxObject.screenX + boxObject.width * .25)
            return null
          
          if (event.screenX > boxObject.screenX + boxObject.width * .75)
            return null;
           
          return tab; 
        ]]></body>
      </method>
    
      
      <method name="_getDropIndex">
        <parameter name="event"/>
        <body><![CDATA[        
          let tabs = this.childNodes;                   
            
          if (window.getComputedStyle(this, null).direction == "ltr") {                      
            for (let i = 0; i < tabs.length; i++)              
              if (event.screenX < (tabs[i].boxObject.screenX + (tabs[i].boxObject.width / 2)))
                return i;
          }
          else  {
            for (let i = 0; i < tabs.length; i++)
              if (event.screenX > (tabs[i].boxObject.screenX + (tabs[i].boxObject.width / 2)))
                return i;         
          }          
         
           return tabs.length;           
        ]]></body>
      </method>        
    </implementation>
    <handlers>
      <handler event="TabSelect" action="this._handleTabSelect();"/>
      <handler event="mouseover"><![CDATA[
        if (event.originalTarget == this.mAllTabsButton) {
          this.mAllTabsButton
              .setAttribute("tooltiptext",
                            this.mAllTabsButton.getAttribute("tooltipstring"));
        }
        else
          this.mAllTabsButton.removeAttribute("tooltiptext");
      ]]></handler>
      <handler event="dragstart"><![CDATA[          
        let draggedTab = this._getDragTargetTab(event);
        
        if (!draggedTab)
          return;  

        let tabmail = document.getElementById("tabmail");
        let tab = tabmail.selectedTab;
        
        if (!tab || !tab.canClose)
          return;
                                          
        let dt = event.dataTransfer;
        
        // If we drag within the same window, we use the tab directly
        dt.mozSetDataAt("application/x-moz-tabmail-tab", draggedTab, 0);
        
        // otherwise we use session restore & JSON to migrate the tab.        
        let uri = tabmail.persistTab(tab);
        
        // In case the tab implements session restore, we use JSON to convert
        // it into a string
        // 
        // If a tab does not support session restore it retuns null. We can't 
        // moved such tabs to a new window. However moving them within the same
        // window works perfectly fine
        
        if (uri)
          uri = JSON.stringify(uri);
        
        dt.mozSetDataAt("application/x-moz-tabmail-json", uri, 0);

        dt.mozCursor = "default";
            
        // Create Drag Image
        let panel = document.getElementById("tabpanelcontainer");
        
        let thumbnail = document.createElementNS("http://www.w3.org/1999/xhtml", "canvas"); 
        thumbnail.width = Math.ceil(screen.availWidth / 5.75);
        thumbnail.height = Math.round(width * 0.5625);
        
        let snippetWidth = panel.boxObject.width * .6;
        let scale = thumbnail.width / snippetWidth;

        let ctx = thumbnail.getContext("2d");
    
        ctx.scale(scale, scale);
          
        ctx.drawWindow(window,
                panel.boxObject.screenX - window.mozInnerScreenX,
                panel.boxObject.screenY - window.mozInnerScreenY, 
                snippetWidth,
                snippetWidth * 0.5625,
                "rgb(255,255,255)"); 

        var dt = event.dataTransfer;
        dt.setDragImage(thumbnail, 0, 0);        
                
        event.stopPropagation();        
      ]]></handler>
      <handler event="dragover"><![CDATA[
        let dt = event.dataTransfer;
        
        if (dt.mozItemCount == 0)
          return;
                
        // Bug 516247:
        // incase the user is dragging something else than a tab, and
        // keeps hovering over a tab, we assume he wants to switch to this tab. 
        
        if ((dt.mozTypesAt(0)[0] != "application/x-moz-tabmail-tab")
            && (dt.mozTypesAt(0)[1] != "application/x-moz-tabmail-json"))  {
          
          let tab = this._getDragTargetTab(event); 
         
          if (!tab)
            return;
          
          event.preventDefault();
          event.stopPropagation();          
          
          if (!this._dragTime) {
            this._dragTime = Date.now();
            return;
          }
          
          if (Date.now() <= this._dragTime + this._dragOverDelay)
            return;
          
          let tabmail = document.getElementById("tabmail");
          
          if (tabmail.tabContainer.selectedItem == tab)
            return;
             
          tabmail.tabContainer.selectedItem = tab;         
          
          return;
        }
                            
        // as some tabs do not support session restore they can't be 
        // moved to a different or new window. We should not show 
        // a dropmarker in such a case
        if (!dt.mozGetDataAt("application/x-moz-tabmail-json", 0)) {
        
          let draggedTab = dt.mozGetDataAt("application/x-moz-tabmail-tab", 0);
           
          if (!draggedTab)
            return;

          let tabmail = document.getElementById("tabmail");
          
          if (tabmail.tabContainer.getIndexOfItem(draggedTab) == -1)
            return;
        }

        dt.effectAllowed = "copyMove";

        event.preventDefault();
        event.stopPropagation();
                
        let ltr = (window.getComputedStyle(this, null).direction == "ltr");        
        let ind = this._tabDropIndicator;
        
        // Let's scroll
        if (this.hasAttribute("overflow")) {
                 
          let target = event.originalTarget.getAttribute("anonid");
                    
          let pixelsToScroll = 0;
          
          if (target == "scrollbutton-up")
            pixelsToScroll = this.mTabstrip.scrollIncrement;
            
          if (target == "scrollbutton-down")
            pixelsToScroll = this.mTabstrip.scrollIncrement * -1;
            
          if (ltr)
            pixelsToScroll = pixelsToScroll * -1;
          
          if (pixelsToScroll) {
            // Hide Indicator while Scrolling
            ind.collapsed = true;
            this.mTabstrip.scrollByPixels(pixelsToScroll);            
            return;
          }
        }
                                 
        let newIndex = this._getDropIndex(event);
        
        // fix the DropIndex in case it points to tab that can't be closed        
        let tabInfo = document.getElementById("tabmail").tabInfo;
                
        while ((newIndex < tabInfo.length) && !(tabInfo[newIndex].canClose))
          newIndex++;  
                
                  
        var scrollRect = this.mTabstrip.scrollClientRect;
        var rect = this.getBoundingClientRect();
        var minMargin = scrollRect.left - rect.left;
        var maxMargin = Math.min(minMargin + scrollRect.width,scrollRect.right);
         
        if (!ltr)
          [minMargin, maxMargin] = [this.clientWidth - maxMargin, this.clientWidth - minMargin];
           
        var newMargin;
         
        if (newIndex == this.childNodes.length) {
                 
          let tabRect = this.childNodes[newIndex-1].getBoundingClientRect();
                   
          if (ltr)
            newMargin = tabRect.right - rect.left;
          else
            newMargin = rect.right - tabRect.left;
        }
        else  {
        
          let tabRect = this.childNodes[newIndex].getBoundingClientRect();

          if (ltr)
            newMargin = tabRect.left - rect.left;
          else
            newMargin = rect.right - tabRect.right;
        }
                         
        ind.collapsed = false;
 
        newMargin += ind.clientWidth / 2;
        if (!ltr)
          newMargin *= -1;
 
        ind.style.MozTransform = "translate(" + Math.round(newMargin) + "px)";
        ind.style.MozMarginStart = (-ind.clientWidth) + "px";
        ind.style.marginTop = (-ind.clientHeight) + "px";
      ]]></handler>
      <handler event="drop"><![CDATA[
        let dt = event.dataTransfer;
    
        if (dt.mozItemCount != 1)
          return;
        
        let draggedTab = dt.mozGetDataAt("application/x-moz-tabmail-tab",0);
        
        if (!draggedTab)
          return;
        
        event.stopPropagation();        
        this._tabDropIndicator.collapsed = true;
      
        let tabmail = document.getElementById("tabmail");
        
        // Is the tab one of our children?
        if (tabmail.tabContainer.getIndexOfItem(draggedTab) == -1) {
        
          // It's a tab from an other window, so we have to trigger session
          // restore to get our tab

          let tabmail2 = draggedTab.ownerDocument.getElementById("tabmail");        
          if (!tabmail2)
            return;
          
          let draggedJson = dt.mozGetDataAt("application/x-moz-tabmail-json", 0);                        
          if (!draggedJson)
            return;
        
          draggedJson = JSON.parse(draggedJson);
          
          // Some tab exist only once, so we have to gamble a bit. We close 
          // the tab and try to reopen it. If something fails the tab is gone.
 
          tabmail2.closeTab(draggedTab,true);
          
          if (! tabmail.restoreTab(draggedJson))
            return;
                           
          draggedTab = tabmail.tabContainer.childNodes[tabmail.tabContainer.childNodes.length-1];
        }

        let idx = this._getDropIndex(event);
        
        // fix the DropIndex in case it points to tab that can't be closed        
        let tabInfo = tabmail.tabInfo;                
        while ((idx < tabInfo.length) && !(tabInfo[idx].canClose))
          idx++;  
                            
        tabmail.moveTabTo(draggedTab, idx);
                  
        tabmail.switchToTab(draggedTab);
        tabmail.updateCurrentTab();          
      ]]></handler>
      
      <handler event="dragend"><![CDATA[
            
        // Note: while this case is correctly handled here, this event
        // isn't dispatched when the tab is moved within the tabstrip,
        // see bug 460801.

        // the user pressed ESC to cancel the drag, or the drag succeded
        var dt = event.dataTransfer;
        if ((dt.mozUserCancelled) || (dt.dropEffect != "none"))
          return;
          
        // Disable detach within the browser toolbox
        var eX = event.screenX;
        var wX = window.screenX;
        
        // check if the drop point is horizontally within the window
        if (eX > wX && eX < (wX + window.outerWidth)) {
        
          let bo = this.mTabstrip.boxObject;
          // also avoid detaching if the the tab was dropped too close to
          // the tabbar (half a tab)
          let endScreenY = bo.screenY + 1.5 * bo.height;
          let eY = event.screenY;
          
          if (eY < endScreenY && eY > window.screenY)        
            return;
        }

        // user wants to deatach tab from window...        
        if (dt.mozItemCount != 1)
          return;
        
        let draggedTab = dt.mozGetDataAt("application/x-moz-tabmail-tab",0);
        
        if (!draggedTab)
          return;
        
        document.getElementById("tabmail").replaceTabWithWindow(draggedTab);                    
                            
      ]]></handler>
      
      <handler event="dragexit"><![CDATA[
        this._dragTime = 0;
        
        this._tabDropIndicator.collapsed = true;                
        event.stopPropagation();
        
      ]]></handler>      
    </handlers>
  </binding>
  
  <!-- alltabs-popup binding
       This binding relies on the structure of the tabbrowser binding.
       Therefore it should only be used as a child of the tabs element.
       This binding is exposed as a pseudo-public-API so themes can customize
       the tabbar appearance without having to be scriptable
       (see globalBindings.xml in Pinstripe for example).
  -->
  <binding id="tabmail-alltabs-popup"
           extends="chrome://global/content/bindings/popup.xml#popup">
    <implementation implements="nsIDOMEventListener">
      <field name="_xulWindow">
        null
      </field>

      <constructor><![CDATA[
        // We cannot cache the XULBrowserWindow object itself since it might
        // be set after this binding is constructed.
        try {
          this._xulWindow = 
            window.QueryInterface(Components.interfaces.nsIInterfaceRequestor)
                  .getInterface(Components.interfaces.nsIWebNavigation)
                  .QueryInterface(Components.interfaces.nsIDocShellTreeItem)
                  .treeOwner
                  .QueryInterface(Components.interfaces.nsIInterfaceRequestor)
                  .getInterface(Components.interfaces.nsIXULWindow);
        }
        catch(ex) { }
      ]]></constructor>

      <method name="_menuItemOnCommand">
        <parameter name="aEvent"/>
        <body><![CDATA[
          var tabcontainer = document.getBindingParent(this);
          tabcontainer.selectedItem = aEvent.target.tab;
        ]]></body>
      </method>

      <method name="_tabOnAttrModified">
        <parameter name="aEvent"/>
        <body><![CDATA[
          var menuItem = aEvent.target.mCorrespondingMenuitem;
          if (menuItem) {
            var attrName = aEvent.attrName;
            switch (attrName) {
              case "label":
              case "crop":
              case "busy":
              case "image":
              case "selected":
                if (aEvent.attrChange == aEvent.REMOVAL)
                  menuItem.removeAttribute(attrName);
                else
                  menuItem.setAttribute(attrName, aEvent.newValue);
            }
          }
        ]]></body>
      </method>

      <method name="_tabOnTabClose">
        <parameter name="aEvent"/>
        <body><![CDATA[
          var menuItem = aEvent.target.mCorrespondingMenuitem;
          if (menuItem)
            this.removeChild(menuItem);
        ]]></body>
      </method>

      <method name="handleEvent">
        <parameter name="aEvent"/>
        <body><![CDATA[
          if (!aEvent.isTrusted)
            return;

          switch (aEvent.type) {
            case "command":
              this._menuItemOnCommand(aEvent);
              break;
            case "DOMAttrModified":
              this._tabOnAttrModified(aEvent);
              break;
            case "TabClose":
              this._tabOnTabClose(aEvent);
              break;
            case "TabOpen":
              this._createTabMenuItem(aEvent.originalTarget);
              break;
            case "scroll":
              this._updateTabsVisibilityStatus();
              break;
          }
        ]]></body>
      </method>

      <method name="_updateTabsVisibilityStatus">
        <body><![CDATA[
          var tabContainer = document.getBindingParent(this);
          // We don't want menu item decoration unless there is overflow.
          if (tabContainer.getAttribute("overflow") != "true")
            return;

          var tabstripBO = tabContainer.mTabstrip.scrollBoxObject;
          for (var i = 0; i < this.childNodes.length; i++) {
            var curTabBO = this.childNodes[i].tab.boxObject;
            if (curTabBO.screenX >= tabstripBO.screenX &&
                curTabBO.screenX + curTabBO.width <= tabstripBO.screenX + tabstripBO.width)
              this.childNodes[i].setAttribute("tabIsVisible", "true"); 
            else
              this.childNodes[i].removeAttribute("tabIsVisible");
          }
        ]]></body>
      </method>

      <method name="_createTabMenuItem">
        <parameter name="aTab"/>
        <body><![CDATA[
          var menuItem = document.createElementNS(
            "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul", 
            "menuitem");

          menuItem.setAttribute("class", "menuitem-iconic alltabs-item");

          menuItem.setAttribute("label", aTab.label);
          menuItem.setAttribute("crop", aTab.getAttribute("crop"));
          menuItem.setAttribute("image", aTab.getAttribute("image"));

          if (aTab.hasAttribute("busy"))
            menuItem.setAttribute("busy", aTab.getAttribute("busy"));
          if (aTab.selected)
            menuItem.setAttribute("selected", "true");

          // Keep some attributes of the menuitem in sync with its
          // corresponding tab (e.g. the tab label)
          aTab.mCorrespondingMenuitem = menuItem;
          aTab.addEventListener("DOMAttrModified", this, false);
          aTab.addEventListener("TabClose", this, false);
          menuItem.tab = aTab;
          menuItem.addEventListener("command", this, false);

          this.appendChild(menuItem);
          return menuItem;
        ]]></body>
      </method>
    </implementation>

    <handlers>
      <handler event="popupshowing">
      <![CDATA[
        // set up the menu popup
        var tabcontainer = document.getBindingParent(this);
        var tabs = tabcontainer.childNodes;

        // Listen for changes in the tab bar.
        var tabbrowser = document.getBindingParent(tabcontainer);
        tabbrowser.addEventListener("TabOpen", this, false);
        tabcontainer.mTabstrip.addEventListener("scroll", this, false);

        // if an animation is in progress and the user
        // clicks on the "all tabs" button, stop the animation
        tabcontainer._stopAnimation();

        for (var i = 0; i < tabs.length; i++) {
          this._createTabMenuItem(tabs[i]);
        }
        this._updateTabsVisibilityStatus();
      ]]></handler>

      <handler event="popuphiding">
      <![CDATA[
        // clear out the menu popup and remove the listeners
        while (this.hasChildNodes()) {
          var menuItem = this.lastChild;
          menuItem.removeEventListener("command", this, false);
          menuItem.tab.removeEventListener("DOMAttrModified", this, false);
          menuItem.tab.removeEventListener("TabClose", this, false);
          menuItem.tab.mCorrespondingMenuitem = null;
          this.removeChild(menuItem);
        }
        var tabcontainer = document.getBindingParent(this);
        tabcontainer.mTabstrip.removeEventListener("scroll", this, false);
        document.getBindingParent(tabcontainer).removeEventListener("TabOpen", this, false);
      ]]></handler>
    </handlers>
  </binding>
  <!-- close-tab-button binding
       This binding relies on the structure of the tabbrowser binding.
       Therefore it should only be used as a child of the tab or the tabs
       element (in both cases, when they are anonymous nodes of <tabbrowser>).
       This binding is exposed as a pseudo-public-API so themes can customize
       the tabbar appearance without having to be scriptable
       (see globalBindings.xml in Pinstripe for example).
  -->
  <binding id="tabmail-close-tab-button"
           extends="chrome://global/content/bindings/toolbarbutton.xml#toolbarbutton-image">
    <handlers>
      <handler event="click" button="0"><![CDATA[
        var bindingParent = document.getBindingParent(this);
        if (bindingParent) {
          var tabbedBrowser = document.getBindingParent(bindingParent);
          if (bindingParent.localName == "tab") {
            /* The only sequence in which a second click event (i.e. dblclik)
             * can be dispatched on an in-tab close button is when it is shown
             * after the first click (i.e. the first click event was dispatched
             * on the tab). This happens when we show the close button only on
             * the active tab. (bug 352021)
             * The only sequence in which a third click event can be dispatched
             * on an in-tab close button is when the tab was opened with a
             * double click on the tabbar. (bug 378344)
             * In both cases, it is most likely that the close button area has
             * been accidentally clicked, therefore we do not close the tab.
             */
            if (event.detail > 1)
              return;

            tabbedBrowser.removeTabByNode(bindingParent);
            tabbedBrowser._blockDblClick = true;

            /* XXXmano hack (see bug 343628):
             * Since we're removing the event target, if the user
             * double-clicks this button, the dblclick event will be dispatched
             * with the tabbar as its event target (and explicit/originalTarget),
             * which treats that as a mouse gesture for opening a new tab.
             * In this context, we're manually blocking the dblclick event
             * (see onTabBarDblClick).
             */
            var clickedOnce = false;
            function enableDblClick(event) {
              if (event.detail == 1 && !clickedOnce) {
                clickedOnce = true;
                return;
              }
              setTimeout(function() {
                tabbedBrowser._blockDblClick = false;
              }, 0);
              tabbedBrowser.removeEventListener("click", enableDblClick, false);
            }
            tabbedBrowser.addEventListener("click", enableDblClick, false);
          }
          else // "tabs"
            tabbedBrowser.removeCurrentTab();
        }
      ]]></handler>
      <handler event="dblclick" button="0" phase="capturing">
        // for the one-close-button case
        event.stopPropagation();
      </handler>
    </handlers>
  </binding>

</bindings>