File: tree.xml

package info (click to toggle)
iceweasel 2.0.0.19-0etch1
links: PTS
area: main
in suites: etch
size: 298,784 kB
ctags: 317,912
sloc: cpp: 1,796,902; ansic: 987,677; xml: 109,036; makefile: 47,777; asm: 35,201; perl: 26,983; sh: 20,879; cs: 6,232; java: 5,513; python: 3,249; pascal: 459; lex: 306; php: 244; csh: 132; objc: 97; yacc: 79; ada: 49; awk: 14; sql: 4; sed: 4
file content (1022 lines) | stat: -rw-r--r-- 37,805 bytes
parent folder | download | duplicates (4)
<?xml version="1.0"?>

<!DOCTYPE bindings SYSTEM "chrome://global/locale/tree.dtd">

<bindings id="treeBindings"
   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">
  
  <binding id="tree-base" extends="chrome://global/content/bindings/general.xml#basecontrol">
    <resources>
      <stylesheet src="chrome://global/skin/tree.css"/>
    </resources>
    <implementation>
      <method name="_isAccelPressed">
        <parameter name="aEvent"/>
        <body><![CDATA[
# Workaround until bug 302174 is fixed
#ifdef XP_MACOSX
          return aEvent.metaKey;
#else
          return aEvent.ctrlKey;
#endif
        ]]></body>       
      </method>
    </implementation>
  </binding>

  <binding id="tree" extends="chrome://global/content/bindings/tree.xml#tree-base">
    <content>
      <children includes="treecols"/>
      <xul:treerows class="tree-rows" flex="1">
        <children/>
      </xul:treerows>
    </content>
    
    <implementation implements="nsIDOMXULTreeElement, nsIDOMXULMultiSelectControlElement, nsIAccessibleProvider">

      <!-- ///////////////// nsIDOMXULTreeElement ///////////////// -->

      <property name="columns"
                onget="return this.treeBoxObject.columns;"/>

      <property name="view"
                onget="return this.treeBoxObject.view;"
                onset="return this.treeBoxObject.view = val;"/>

      <property name="body"
                onget="return this.treeBoxObject.treeBody;"/>

      <property name="editable"
                onget="return this.hasAttribute('editable');"
                onset="if (val) this.setAttribute('editable', 'true');
                       else this.removeAttribute('editable'); return val;"/>

      <!-- ///////////////// nsIDOMXULSelectControlElement ///////////////// -->

      <!-- ///////////////// nsIDOMXULMultiSelectControlElement ///////////////// -->

      <property name="selType"
                onget="return this.getAttribute('seltype')"
                onset="this.setAttribute('seltype', val); return val;"/>

      <property name="currentIndex"
                onget="return this.view.selection.currentIndex;"
                onset="return this.view.selection.currentIndex = val;"/>

      <!-- ///////////////// nsIAccessibleProvider ///////////////// -->

      <property name="accessible">
        <getter>
          <![CDATA[
            var accService = Components.classes["@mozilla.org/accessibilityService;1"].getService(Components.interfaces.nsIAccessibilityService);
            return accService.createXULTreeAccessible(this);
          ]]>
        </getter>
      </property>

      <property name="treeBoxObject"
                onget="return this.boxObject.QueryInterface(Components.interfaces.nsITreeBoxObject);"
                readonly="true"/>
# contentView is obsolete (see bug 202391)
      <property name="contentView"
                onget="return this.view; /*.QueryInterface(Components.interfaces.nsITreeContentView)*/"
                readonly="true"/>
# builderView is obsolete (see bug 202393)
      <property name="builderView"
                onget="return this.view; /*.QueryInterface(Components.interfaces.nsIXULTreeBuilder)*/"
                readonly="true"/>
      <field name="pageUpOrDownMovesSelection">
#ifdef XP_MACOSX
        false
#else
        true
#endif
      </field>
      <property name="enableColumnDrag"
                onget="return this.hasAttribute('enableColumnDrag');"
                onset="if (val) this.setAttribute('enableColumnDrag', 'true');
                       else this.removeAttribute('enableColumnDrag'); return val;"/>

      <property name="firstOrdinalColumn">
        <getter><![CDATA[
          var cols = this.firstChild;
          while (cols && cols.localName != "treecols")
            cols = cols.nextSibling;

          if (cols)
            return cols.boxObject.firstChild;
          else
            return null;
        ]]></getter>
      </property>

      <property name="disableKeyNavigation"
                onget="return this.hasAttribute('disableKeyNavigation');"
                onset="if (val) this.setAttribute('disableKeyNavigation', 'true');
                       else this.removeAttribute('disableKeyNavigation'); return val;"/>
      
      <property name="_selectDelay" 
                onset="this.setAttribute('_selectDelay', val);"
                onget="return this.getAttribute('_selectDelay') || 50;"/>
      <field name="_columnsDirty">true</field>
      <field name="_lastKeyTime">0</field>
      <field name="_incrementalString">""</field>

      <method name="_ensureColumnOrder">
        <body><![CDATA[
          if (this._columnsDirty) {
            // update the ordinal position of each column to assure that it is
            // an odd number and 2 positions above it's next sibling
            var col = this.firstOrdinalColumn;
            var cols = [];
            while (col) {
              if (col.localName == "treecol" && col.parentNode.parentNode == this)
                cols[cols.length] = col;
              col = col.boxObject.nextSibling;
            }
            var i;
            for (i = 0; i < cols.length; ++i)
              cols[i].setAttribute("ordinal", (i*2)+1);

            // update the ordinal positions of splitters to even numbers, so that 
            // they are in between columns
            var splitters = this.getElementsByTagName("splitter");
            for (i = 0; i < splitters.length; ++i)
              splitters[i].setAttribute("ordinal", (i+1)*2);
            
            this._columnsDirty = false;
          }
        ]]></body>
      </method>

      <method name="_reorderColumn">
        <parameter name="aColMove"/>
        <parameter name="aColBefore"/>
        <parameter name="aBefore"/>
        <body><![CDATA[
          this._ensureColumnOrder();
          
          var cols = [];
          var col;
          if (aColBefore.ordinal < aColMove.ordinal) {
            col = aColBefore;
            while (col) {
              if (col.localName == "treecol")
                cols.push(col);
              col = col.boxObject.nextSibling;
              if (col == aColMove)  
                break;
            }

            aColMove.ordinal = aColBefore.ordinal;
            var i;
            for (i = 0; i < cols.length; ++i)
              cols[i].ordinal += 2;
          } else {
            col = aColMove.boxObject.nextSibling;
            while (col) {
              if (col.localName == "treecol")
                cols.push(col);
              col = col.boxObject.nextSibling;
              if (col == aColBefore && aBefore)
                break;
            }

            aColMove.ordinal = aBefore ? aColBefore.ordinal-2 : aColBefore.ordinal;

            for (i = 0; i < cols.length; ++i)
              cols[i].ordinal -= 2;
          }
        ]]></body>
      </method>
      
      <method name="_getColumnAtX">
        <parameter name="aX"/>
        <parameter name="aThresh"/>
        <parameter name="aPos"/>
        <body><![CDATA[
          if (aPos) aPos.value = "before";

          var col = this.firstOrdinalColumn;
          var lastCol = null;
          var currentX = this.boxObject.x;
          while (col) {
            if (col.localName == "treecol" && col.parentNode.parentNode == this) {
              var cw = col.boxObject.width;
              if (cw > 0) {
                currentX += cw;
                if (currentX - (cw*aThresh) > aX)
                  return col;
              }
              lastCol = col;
            }
            col = col.boxObject.nextSibling;
          }

          if (aPos) aPos.value = "after";
          return lastCol;
        ]]></body>
      </method>

      <method name="changeOpenState">
        <parameter name="row"/>
        <!-- Optional parameter openState == true or false to set. 
             No openState param == toggle -->
        <parameter name="openState"/>
        <body><![CDATA[
          if (row < 0 || !this.view.isContainer(row)) {
            return false;
          }
          if (this.view.isContainerOpen(row) != openState) {
            this.view.toggleOpenState(row);
            if (row == this.currentIndex) {
              // Only fire event when current row is expanded or collapsed
              // because that's all the assistive technology really cares about.
              var event = document.createEvent('Events');
              event.initEvent('OpenStateChange', true, true);
              this.dispatchEvent(event);
            }
            return true;
          }
          return false;
        ]]></body>
      </method>

      <method name="keyNavigate">
        <parameter name="event"/>
        <body><![CDATA[
          var key = String.fromCharCode(event.charCode).toLowerCase();
          if (event.timeStamp - this._lastKeyTime > 1000)
            this._incrementalString = key;
          else
            this._incrementalString += key;
          this._lastKeyTime = event.timeStamp;

          var length = this._incrementalString.length;
          var incrementalString = this._incrementalString;
          var charIndex = 1;
          while (charIndex < length && incrementalString[charIndex] == incrementalString[charIndex - 1])
            charIndex++;
          // If all letters in incremental string are same, just try to match the first one
          if (charIndex == length) {
            length = 1;
            incrementalString = incrementalString.substring(0, length);
          }

          var keyCol = this.columns.getKeyColumn();
          var rowCount = this.view.rowCount;
          var start = 1;

          var c = this.currentIndex;
          if (length > 1) {
            start = 0;
            if (c < 0)
              c = 0;
          }

          for (var i = 0; i < rowCount; i++) {
            var l = (i + start + c) % rowCount;
            var cellText = this.view.getCellText(l, keyCol);
            cellText = cellText.substring(0, length).toLowerCase();
            if (cellText == incrementalString)
              return l;
          }
          return -1;
        ]]></body>
      </method>
    </implementation>
    
    <handlers>
      <handler event="DOMMouseScroll" phase="capturing">
        <![CDATA[
          var rows = event.detail;
          if (rows == NSUIEvent.SCROLL_PAGE_UP)
            this.treeBoxObject.scrollByPages(-1);
          else if (rows == NSUIEvent.SCROLL_PAGE_DOWN)
            this.treeBoxObject.scrollByPages(1);
          else
            this.treeBoxObject.scrollByLines(rows);
        ]]>
      </handler>
      <handler event="focus">
        <![CDATA[
          this.treeBoxObject.focused = true;
          if (this.currentIndex == -1 && this.view.rowCount > 0) {
            this.currentIndex = this.treeBoxObject.getFirstVisibleRow();
          }
        ]]>
      </handler>
      <handler event="blur" action="this.treeBoxObject.focused = false;"/>
      <handler event="keypress" keycode="vk_enter" action="this.changeOpenState(this.currentIndex);"/>
      <handler event="keypress" keycode="vk_return" action="this.changeOpenState(this.currentIndex);"/>
      <handler event="keypress" keycode="vk_left">
        <![CDATA[
         if (!this.changeOpenState(this.currentIndex, false)) {
            var parentIndex = this.view.getParentIndex(this.currentIndex);
           if (parentIndex >= 0) {
             this.view.selection.select(parentIndex);
             this.treeBoxObject.ensureRowIsVisible(parentIndex);
           }
         }
        ]]>
      </handler>
      <handler event="keypress" keycode="vk_right">
        <![CDATA[
          var row = this.currentIndex;
          if (row >= 0 && !this.changeOpenState(row, true)) {
            var view = this.view;
            if (row + 1 < view.rowCount &&
                view.getParentIndex(row + 1) == row) {
              // If already opened, select the first child.
              // The getParentIndex test above ensures that the children
              // are already populated and ready.
              this.view.selection.timedSelect(row + 1, this._selectDelay);
              this.treeBoxObject.ensureRowIsVisible(row + 1);
            }
          }
        ]]>
      </handler>
      <handler event="keypress" keycode="vk_up" modifiers="accel any">
        <![CDATA[
         if (this._isAccelPressed(event) && this.view.selection.single) {
           this.treeBoxObject.scrollByLines(-1);
           return;
         }

         var c = this.currentIndex;
         if (c == -1 || c == 0)
           return;
         if (!this._isAccelPressed(event))
           this.view.selection.timedSelect(c - 1, this._selectDelay);
         else // Ctrl+Up moves the anchor without selecting
           this.currentIndex = c - 1;
         this.treeBoxObject.ensureRowIsVisible(c-1);
        ]]>
      </handler>
      <handler event="keypress" keycode="vk_down" modifiers="accel any">
        <![CDATA[
         if (this._isAccelPressed(event) && this.view.selection.single) {
           this.treeBoxObject.scrollByLines(1);
           return;
         }
         var c = this.currentIndex;
          try {
            if (c+1 == this.view.rowCount)
              return;
         } catch (e) {}
         if (!this._isAccelPressed(event))
           this.view.selection.timedSelect(c+1, this._selectDelay);
         else // Ctrl+Down moves the anchor without selecting
           this.currentIndex = c + 1;
         this.treeBoxObject.ensureRowIsVisible(c+1);
        ]]>
      </handler>
      <handler event="keypress" keycode="vk_up" modifiers="accel any, shift">
        <![CDATA[
         if (this.view.selection.single)
           return;
         var c = this.currentIndex;
         if (c == -1 || c == 0)
           return;
         // Extend the selection from the existing pivot, if any
         this.view.selection.rangedSelect(-1, c - 1,
                                          this._isAccelPressed(event));
         this.treeBoxObject.ensureRowIsVisible(c - 1);
        ]]>
      </handler>
      <handler event="keypress" keycode="vk_down" modifiers="accel any, shift">
        <![CDATA[
         if (this.view.selection.single)
           return;
         var c = this.currentIndex;
          try {
            if (c+1 == this.view.rowCount)
              return;
         } catch (e) {}
         // Extend the selection from the existing pivot, if any
         this.view.selection.rangedSelect(-1, c + 1,
                                          this._isAccelPressed(event));
         this.treeBoxObject.ensureRowIsVisible(c + 1);
        ]]>
      </handler>
      <handler event="keypress" keycode="vk_page_up" modifiers="accel any">
        <![CDATA[
         if (this.pageUpOrDownMovesSelection == this._isAccelPressed(event)) {
           this.treeBoxObject.scrollByPages(-1);
           return;
         }
         var c = this.currentIndex;
         if (c == 0)
           return;
         var f = this.treeBoxObject.getFirstVisibleRow();
         var i = 0;
         if (f > 0) {
           var p = this.treeBoxObject.getPageLength();
           if (f - p >= 0)
             i = c - p;
           else
             i = c - f;
           this.treeBoxObject.scrollByPages(-1);
         }
         this.view.selection.timedSelect(i, this._selectDelay);
        ]]>
      </handler>
      <handler event="keypress" keycode="vk_page_down" modifiers="accel any">
        <![CDATA[
         if (this.pageUpOrDownMovesSelection == this._isAccelPressed(event)) {
           this.treeBoxObject.scrollByPages(1);
           return;
         }
         var c = this.currentIndex;
          var l = this.view.rowCount - 1;
         if (c == l)
           return;
         var f = this.treeBoxObject.getFirstVisibleRow();
         var p = this.treeBoxObject.getPageLength();
         var i = l;
         var lastTopRowIndex = l - p;
         if (f <= lastTopRowIndex) {
           if (f + p <= lastTopRowIndex)
             i = c + p;
           else
             i = lastTopRowIndex + c - f + 1;
           this.treeBoxObject.scrollByPages(1);
         }
         this.view.selection.timedSelect(i, this._selectDelay);
        ]]>
      </handler>
      <handler event="keypress" keycode="vk_page_up" modifiers="accel any, shift">
        <![CDATA[
         if (this.view.selection.single)
           return;
         var c = this.currentIndex;
         if (c == 0)
           return;
         var f = this.treeBoxObject.getFirstVisibleRow();
         var i = 0;
         if (f > 0) {
           var p = this.treeBoxObject.getPageLength();
           if (f - p >= 0)
             i = c - p;
           else
             i = c - f;
           this.treeBoxObject.scrollByPages(-1);
         }
         // Extend the selection from the existing pivot, if any
         this.view.selection.rangedSelect(-1, i, this._isAccelPressed(event));
        ]]>
      </handler>
      <handler event="keypress" keycode="vk_page_down" modifiers="accel any, shift">
        <![CDATA[
         if (this.view.selection.single)
           return;
         var c = this.currentIndex;
          var l = this.view.rowCount - 1;
         if (c == l)
           return;
         var f = this.treeBoxObject.getFirstVisibleRow();
         var p = this.treeBoxObject.getPageLength();
         var i = l;
         var lastTopRowIndex = l - p;
         if (f <= lastTopRowIndex) {
           if (f + p <= lastTopRowIndex)
             i = c + p;
           else
             i = lastTopRowIndex + c - f + 1;
           this.treeBoxObject.scrollByPages(1);
         }
         // Extend the selection from the existing pivot, if any
         this.view.selection.rangedSelect(-1, i, this._isAccelPressed(event));
        ]]>
      </handler>
      <handler event="keypress" keycode="vk_home" modifiers="accel any">
        <![CDATA[
          if (this.view.rowCount == 0)
           return;
         // Normal behaviour is to select the first row
         if (!this._isAccelPressed(event))
           this.view.selection.timedSelect(0, this._selectDelay);
         // In a multiselect tree Ctrl+Home moves the anchor
         else if (!this.view.selection.single)
           this.currentIndex = 0;
         this.treeBoxObject.ensureRowIsVisible(0);
        ]]>
      </handler>
      <handler event="keypress" keycode="vk_end" modifiers="accel any">
        <![CDATA[
         var l = this.view.rowCount - 1;
         if (l < 0)
           return;
         // Normal behaviour is to select the last row
         if (!this._isAccelPressed(event))
           this.view.selection.timedSelect(l, this._selectDelay);
         // In a multiselect tree Ctrl+End moves the anchor
         else if (!this.view.selection.single)
           this.currentIndex = l;
         this.treeBoxObject.ensureRowIsVisible(l);
        ]]>
      </handler>
      <handler event="keypress" keycode="vk_home" modifiers="accel any, shift">
        <![CDATA[
         if (this.view.selection.single)
           return;
         // Extend the selection from the existing pivot, if any
         this.view.selection.rangedSelect(-1, 0, this._isAccelPressed(event));
         this.treeBoxObject.ensureRowIsVisible(0);
        ]]>
      </handler>
      <handler event="keypress" keycode="vk_end" modifiers="accel any, shift">
        <![CDATA[
         if (this.view.selection.single)
           return;
         var l = this.view.rowCount - 1;
         // Extend the selection from the existing pivot, if any
         this.view.selection.rangedSelect(-1, l, this._isAccelPressed(event));
         this.treeBoxObject.ensureRowIsVisible(l);
        ]]>
      </handler>
      <handler event="keypress">
        <![CDATA[
         if (event.charCode == ' '.charCodeAt(0)) {
           var c = this.currentIndex;
           if (!this.view.selection.isSelected(c) ||
               (!this.view.selection.single && this._isAccelPressed(event))) {
             this.view.selection.toggleSelect(c);
           }
         }
         else if (!this.disableKeyNavigation && event.charCode > 0 &&
                  !event.altKey && !this._isAccelPressed(event) &&
                  !event.metaKey) {
           var l = this.keyNavigate(event);
           if (l >= 0) {
             this.view.selection.timedSelect(l, this._selectDelay);
             this.treeBoxObject.ensureRowIsVisible(l);
           }
          }
         ]]>
      </handler>
    </handlers>    
  </binding>

  <binding id="treecols" extends="chrome://global/content/bindings/tree.xml#tree-base">
    <content>
      <children includes="treecol|splitter"/>
      <xul:treecolpicker class="treecol-image" fixed="true" ordinal="2147483647" xbl:inherits="tooltiptext=pickertooltiptext"/>
    </content>
    <implementation implements="nsIAccessibleProvider">
      <property name="accessible">
        <getter>
          <![CDATA[
            var accService = Components.classes["@mozilla.org/accessibilityService;1"].getService(Components.interfaces.nsIAccessibilityService);
            return accService.createXULTreeColumnsAccessible(this);
          ]]>
        </getter>
      </property>
    </implementation>
  </binding>

  <binding id="treerows" extends="chrome://global/content/bindings/tree.xml#tree-base">
    <content>
      <xul:hbox flex="1" class="tree-bodybox">
        <children/>
      </xul:hbox>
      <xul:scrollbar height="0" minwidth="0" minheight="0" orient="vertical" class="tree-scrollbar" collapsed="true"/>
    </content>
    <handlers>
      <handler event="underflow">
        <![CDATA[
          document.getAnonymousNodes(this)[1].collapsed = true;
          event.stopPropagation();
        ]]>
      </handler>
      <handler event="overflow">
        <![CDATA[
          document.getAnonymousNodes(this)[1].collapsed = false;
          event.stopPropagation();
        ]]>
      </handler>
    </handlers>
  </binding>

  <binding id="treebody" extends="chrome://global/content/bindings/tree.xml#tree-base">
    <implementation>
      <constructor>
        if ("_ensureColumnOrder" in this.parentNode)
          this.parentNode._ensureColumnOrder();
      </constructor>

      <field name="_lastSelectedRow">
        -1
      </field>
    </implementation>
    <handlers>
      <!-- If there is no modifier key, we select on mousedown, not
           click, so that drags work correctly. -->
      <handler event="mousedown" clickcount="1">
      <![CDATA[
         if (((!this._isAccelPressed(event) ||
             !this.parentNode.pageUpOrDownMovesSelection) &&
             !event.shiftKey && !event.metaKey) ||
             this.parentNode.view.selection.single) {
           var row = {};
           var col = {};
           var obj = {};
           var b = this.parentNode.treeBoxObject;
           b.getCellAt(event.clientX, event.clientY, row, col, obj);

           // save off the last selected row
           this._lastSelectedRow = row.value;

           if (row.value == -1)
             return;

           if (col.value && obj.value != "twisty") {
             if (col.value.cycler)
               b.view.cycleCell(row.value, col.value);
             else if (col.value.type == Components.interfaces.nsITreeColumn.TYPE_CHECKBOX) {
               if (this.parentNode.editable && col.value.editable &&
                   b.view.isEditable(row.value, col.value)) {
                 var value = b.view.getCellValue(row.value, col.value);
                 value = value == "true" ? "false" : "true";
                 b.view.setCellValue(row.value, col.value, value);
               }
             }
             else
               if (!b.view.selection.isSelected(row.value)) {
                 b.view.selection.select(row.value);
                 b.ensureRowIsVisible(row.value);
               }
           }
         }
      ]]>
      </handler>

      <!-- On a click (up+down on the same item), deselect everything
           except this item. -->
      <handler event="click" button="0" clickcount="1">
      <![CDATA[
        var row = {};
        var col = {};
        var obj = {};
        var b = this.parentNode.treeBoxObject;
        b.getCellAt(event.clientX, event.clientY, row, col, obj);

        if (row.value == -1)
          return;

        if (obj.value == "twisty") {
          if (b.view.selection.currentIndex >= 0 &&
              b.view.isContainerOpen(row.value)) {
            var parentIndex = b.view.getParentIndex(b.view.selection.currentIndex);
            while (parentIndex >= 0 && parentIndex != row.value)
              parentIndex = b.view.getParentIndex(parentIndex);
            if (parentIndex == row.value)
              b.view.selection.select(parentIndex);
          }
          this.parentNode.changeOpenState(row.value);
          return;
        }

        if (! b.view.selection.single) {
          var augment = this._isAccelPressed(event);
          if (event.shiftKey) {
            b.view.selection.rangedSelect(-1, row.value, augment);
            b.ensureRowIsVisible(row.value);
            return;
          }
          if (augment) {
            b.view.selection.toggleSelect(row.value);
            b.ensureRowIsVisible(row.value);
            b.view.selection.currentIndex = row.value;
            return;
          }
        }

        /* We want to deselect all the selected items except what was
          clicked, UNLESS it was a right-click.  We have to do this
          in click rather than mousedown so that you can drag a
          selected group of items */

        if (!col.value) return;

        // if the last row has changed in between the time we 
        // mousedown and the time we click, don't fire the select handler.
        // see bug #92366
        if (!col.value.cycler && this._lastSelectedRow == row.value &&
            col.value.type != Components.interfaces.nsITreeColumn.TYPE_CHECKBOX) {
          b.view.selection.select(row.value);  
          b.ensureRowIsVisible(row.value);
        }
      ]]>
      </handler>

      <!-- double-click -->
      <handler event="click" clickcount="2">
      <![CDATA[
        var b = this.parentNode.treeBoxObject;
        var row = b.view.selection.currentIndex;
        if (row == -1 || !b.view.isContainer(row))
          return;

         var col = {};
         var obj = {};
         b.getCellAt(event.clientX, event.clientY, {}, col, obj);

         // Cyclers and twisties respond to single clicks, not double clicks
         if (!col.value.cycler && obj.value != "twisty")
           this.parentNode.changeOpenState(row);
      ]]>
      </handler>
      
    </handlers>
  </binding>

  <binding id="treecol-base" extends="chrome://global/content/bindings/tree.xml#tree-base">
    <implementation>
      <constructor>
        this.parentNode.parentNode._columnsDirty = true;
      </constructor>

      <property name="ordinal">
        <getter><![CDATA[
          var val = this.getAttribute("ordinal");
          return val == "" ? 1 : (val == "0" ? 0 : parseInt(val));
        ]]></getter>
        <setter><![CDATA[
          this.setAttribute("ordinal", val);
        ]]></setter>
      </property>
      
      <property name="_previousVisibleColumn">
        <getter><![CDATA[
          var sib = this.boxObject.previousSibling;
          while (sib) {
            if (sib.localName == "treecol" && sib.boxObject.width > 0 && sib.parentNode == this.parentNode)
              return sib;
            sib = sib.boxObject.previousSibling;
          }
          return null;
        ]]></getter>
      </property>

      <method name="onDragMouseMove">
        <parameter name="aEvent"/>
        <body><![CDATA[
          var col = document.treecolDragging;
          if (!col) return;

          // determine if we have moved the mouse far enough
          // to initiate a drag
          if (col.mDragGesturing) {
            if (Math.abs(aEvent.clientX - col.mStartDragX) < 5 &&
                Math.abs(aEvent.clientY - col.mStartDragY) < 5) {
              return;
            } else {
              col.mDragGesturing = false;
              col.setAttribute("dragging", "true");
              window.addEventListener("click", col.onDragMouseClick, true);
            }
          }
                    
          var pos = {};
          var targetCol = col.parentNode.parentNode._getColumnAtX(aEvent.clientX, 0.5, pos);
          
          // bail if we haven't mousemoved to a different column
          if (col.mTargetCol == targetCol && col.mTargetDir == pos.value)
            return;

          var tree = col.parentNode.parentNode;
          var sib;
          var column;
          if (col.mTargetCol) {
            // remove previous insertbefore/after attributes
            col.mTargetCol.removeAttribute("insertbefore");
            col.mTargetCol.removeAttribute("insertafter");
            column = tree.columns.getColumnFor(col.mTargetCol);
            tree.treeBoxObject.invalidateColumn(column);
            sib = col.mTargetCol._previousVisibleColumn;
            if (sib) {
              sib.removeAttribute("insertafter");
              column = tree.columns.getColumnFor(sib);
              tree.treeBoxObject.invalidateColumn(column);
            }
            col.mTargetCol = null;
            col.mTargetDir = null;
          }
          
          if (targetCol) {
            // set insertbefore/after attributes
            if (pos.value == "after") {
              targetCol.setAttribute("insertafter", "true");
            } else {
              targetCol.setAttribute("insertbefore", "true");
              sib = targetCol._previousVisibleColumn;
              if (sib) {
                sib.setAttribute("insertafter", "true");
                column = tree.columns.getColumnFor(sib);
                tree.treeBoxObject.invalidateColumn(column);
              }
            }
            column = tree.columns.getColumnFor(targetCol);
            tree.treeBoxObject.invalidateColumn(column);
            col.mTargetCol = targetCol;
            col.mTargetDir = pos.value;
          }
        ]]></body>        
      </method>

      <method name="onDragMouseUp">
        <parameter name="aEvent"/>
        <body><![CDATA[
          var col = document.treecolDragging;
          if (!col) return;
          
          if (!col.mDragGesturing) {
            if (col.mTargetCol) {
              // remove insertbefore/after attributes
              var before = col.mTargetCol.hasAttribute("insertbefore");
              col.mTargetCol.removeAttribute(before ? "insertbefore" : "insertafter");
              if (before) {
                var sib = col.mTargetCol._previousVisibleColumn;
                if (sib)
                  sib.removeAttribute("insertafter");
              }
                          
              // move the column
              if (col != col.mTargetCol)
                col.parentNode.parentNode._reorderColumn(col, col.mTargetCol, before);
            
              // repaint to remove lines
              col.parentNode.parentNode.treeBoxObject.invalidate();
  
              col.mTargetCol = null;
            }
          } else
            col.mDragGesturing = false;
                    
          document.treecolDragging = null;
          col.removeAttribute("dragging");
          
          window.removeEventListener("mousemove", col.onDragMouseMove, true);
          window.removeEventListener("mouseup", col.onDragMouseUp, true);
          // we have to wait for the click event to fire before removing
          // cancelling handler
          var clickHandler = function(handler) { 
            window.removeEventListener("click", handler, true);
          };
          window.setTimeout(clickHandler, 0, col.onDragMouseClick);
        ]]></body>        
      </method>

      <method name="onDragMouseClick">
        <parameter name="aEvent"/>
        <body><![CDATA[
          // prevent click event from firing after column drag and drop
          aEvent.stopPropagation();
          aEvent.preventDefault();
        ]]></body>        
      </method>
    </implementation>
    
    <handlers>
      <handler event="mousedown" button="0"><![CDATA[
        if (this.parentNode.parentNode.enableColumnDrag) {
          var xulns = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
          var cols = this.parentNode.getElementsByTagNameNS(xulns, "treecol");
          
          // only start column drag operation if there are at least 2 visible columns
          var visible = 0;
          for (var i = 0; i < cols.length; ++i)
            if (cols[i].boxObject.width > 0) ++visible;
            
          if (visible > 1) {
            window.addEventListener("mousemove", this.onDragMouseMove, true);
            window.addEventListener("mouseup", this.onDragMouseUp, true);
            document.treecolDragging = this;
            this.mDragGesturing = true;
            this.mStartDragX = event.clientX;
            this.mStartDragY = event.clientY;
          }
        }
      ]]></handler>
      <handler event="click" button="0" phase="target">
        <![CDATA[
          var tree = this.parentNode.parentNode;
          var column = tree.columns.getColumnFor(this);
          tree.view.cycleHeader(column);
        ]]>
      </handler>
    </handlers>
  </binding>

  <binding id="treecol" extends="chrome://global/content/bindings/tree.xml#treecol-base">
    <content>
      <xul:label class="treecol-text" xbl:inherits="crop,value=label" flex="1" crop="right"/>
      <xul:image class="treecol-sortdirection" xbl:inherits="sortDirection,hidden=hideheader"/>
    </content>
    <implementation implements="nsIAccessibleProvider">
      <property name="accessible">
        <getter>
          <![CDATA[
            var accService = Components.classes["@mozilla.org/accessibilityService;1"].getService(Components.interfaces.nsIAccessibilityService);
            return accService.createXULTreeColumnitemAccessible(this);
          ]]>
        </getter>
      </property>
    </implementation>
  </binding>

  <binding id="treecol-image" extends="chrome://global/content/bindings/tree.xml#treecol-base">
    <content>
      <xul:image class="treecol-icon" xbl:inherits="src"/>
    </content>
  </binding>

  <binding id="columnpicker" display="xul:button"
           extends="chrome://global/content/bindings/tree.xml#tree-base">
    <content>
      <xul:image class="tree-columnpicker-icon"/>
      <xul:menupopup anonid="popup">
        <xul:menuseparator anonid="menuseparator"/>
        <xul:menuitem anonid="menuitem" label="&restoreNaturalOrder.label;"/>
      </xul:menupopup>
    </content>
    
    <implementation>
      <method name="buildPopup">
        <parameter name="aPopup"/>
        <body>
          <![CDATA[
            // We no longer cache the picker content, remove the old content.
            while (aPopup.childNodes.length > 2)
              aPopup.removeChild(aPopup.firstChild);

            var refChild = aPopup.firstChild;

            var tree = this.parentNode.parentNode;
            for (var currCol = tree.columns.getFirstColumn(); currCol;
                 currCol = currCol.getNext()) {
              // Construct an entry for each column in the row, unless
              // it is not being shown.
              var currElement = currCol.element;
              if (!currElement.hasAttribute("ignoreincolumnpicker")) {
                var popupChild = document.createElement("menuitem");
                popupChild.setAttribute("type", "checkbox");
                var columnName = currElement.getAttribute("display") ||
                                 currElement.getAttribute("label");
                popupChild.setAttribute("label", columnName);
                popupChild.setAttribute("colindex", currCol.index);
                if (currElement.getAttribute("hidden") != "true")
                  popupChild.setAttribute("checked", "true");
                if (currCol.primary)
                  popupChild.setAttribute("disabled", "true");
                aPopup.insertBefore(popupChild, refChild);
              }
            }

            var hidden = !tree.enableColumnDrag;
            const anonids = ["menuseparator", "menuitem"];
            for (var i = 0; i < anonids.length; i++) {
              var element = document.getAnonymousElementByAttribute(this, "anonid", anonids[i]);
              element.hidden = hidden;
            }
          ]]>
        </body>
      </method>
    </implementation>

    <handlers>
      <handler event="command">
        <![CDATA[
          if (event.originalTarget == this) {
            var popup = document.getAnonymousElementByAttribute(this, "anonid", "popup");
            this.buildPopup(popup);
            popup.showPopup(this, -1, -1, "popup", "bottomright", "topright");
          }
          else {
            var tree = this.parentNode.parentNode;
            var menuitem = document.getAnonymousElementByAttribute(this, "anonid", "menuitem");
            if (event.originalTarget == menuitem) {
              tree.columns.restoreNaturalOrder();
              tree._ensureColumnOrder();
            }
            else {
              var colindex = event.originalTarget.getAttribute("colindex");
              var column = tree.columns[colindex];
              if (column) {
                var element = column.element;
                if (element.getAttribute("hidden") == "true")
                  element.setAttribute("hidden", "false");
                else
                  element.setAttribute("hidden", "true");
              }
            }
          }
        ]]>
      </handler>
    </handlers>
  </binding>
</bindings>