home *** CD-ROM | disk | FTP | other *** search
/ PC World 2005 December / PCWorld_2005-12_cd.bin / komunikace / netscape / nsb-install-8-0.exe / chrome / toolkit.jar / content / global / customizeToolbar.js < prev    next >
Text File  |  2005-09-26  |  58KB  |  1,838 lines
  1.  
  2. const kRowMax = 2;
  3. const kWindowWidth = 805;
  4. const kWindowHeight = 415;
  5. const kAnimateIncrement = 50;
  6. const kAnimateSteps = kWindowHeight / kAnimateIncrement - 1;
  7. const kVSizeSlop = 5;
  8.  
  9. var gToolboxDocument = null;
  10. var gToolbox = null;
  11. var gCurrentDragOverItem = null;
  12. var gToolboxChanged = false;
  13. var gToolboxIconSize = false;
  14.  
  15. var gSelectedToolbar = null;
  16. var toolTree = null;
  17. var gRepopulating = false;
  18.  
  19. function onLoad()
  20. {
  21.     gToolbox = window.arguments[0];
  22.     gToolboxDocument = gToolbox.ownerDocument;
  23.  
  24.     gToolbox.addEventListener("draggesture", onToolbarDragGesture, false);
  25.     gToolbox.addEventListener("dragover", onToolbarDragOver, false);
  26.     gToolbox.addEventListener("dragexit", onToolbarDragExit, false);
  27.     gToolbox.addEventListener("dragdrop", onToolbarDragDrop, false);
  28.  
  29.     var multibars = gToolbox.getElementsByTagName('multibar');
  30.     var multibar;
  31.     for (var i =0; i < multibars.length; i++)
  32.     {
  33.         multibar = multibars.item(i);
  34.         multibar.searchParent.addEventListener("draggesture", onToolbarDragGesture, false);
  35.         multibar.searchParent.addEventListener("dragover", onToolbarDragOver, false);
  36.         multibar.searchParent.addEventListener("dragexit", onToolbarDragExit, false);
  37.         multibar.searchParent.addEventListener("dragdrop", onToolbarDragDrop, false);
  38.     }
  39.  
  40.     repositionDialog();
  41.  
  42.     initDialog();
  43.     gToolboxDocument.defaultView.reshuffleToolbars(true);
  44. }
  45.  
  46. function onUnload(aEvent)
  47. {
  48.     removeToolboxListeners();
  49.     unwrapToolbarItems();
  50.     persistCurrentSets();
  51.  
  52.     notifyParentComplete();
  53.  
  54.     window.close();
  55. }
  56.  
  57. function onAccept(aEvent)
  58. {
  59.     document.getElementById("main-box").collapsed = true;
  60.     // gToolboxDocument.moveMenubar();
  61.     window.close();
  62. }
  63.  
  64. /*
  65. var renameOnly = false;
  66. function renameBySetButton(newName) {
  67.     renameOnly = true;
  68.     renameToolbar(newName);
  69. }
  70. */
  71.  
  72. function renameToolbar(newName) {
  73.     // dump("\n\nNew toolbar name is : " + newName + "\n");
  74.     if (!newName || (newName == '')) {
  75.         var promptService =
  76.             Components.classes["@mozilla.org/embedcomp/prompt-service;1"]
  77.                       .getService(Components.interfaces.nsIPromptService);
  78.         var stringBundle = document.getElementById("stringBundle");
  79.         var title = stringBundle.getString("toolbarMustHaveNameTitle");
  80.         var message = stringBundle.getString("toolbarMustHaveNameMessage");
  81.         promptService.alert(window, title, message);
  82.         return;
  83.     }
  84.     if (gSelectedToolbar.localName == 'multibartray') {
  85.         gSelectedToolbar.parentNode
  86.                         .renameTray(gSelectedToolbar.parentNode
  87.                                                     .getIndexOfTray(gSelectedToolbar),
  88.                                     newName);
  89.         // Reset the "Set" button flag
  90.     //    if(renameOnly) renameOnly = false;
  91.     } else {
  92.     //    if(renameOnly) {     // Don't change the id, as I only want to change the name
  93.         //    renameOnly = false;
  94.             //gSelectedToolbar.setAttribute("toolbarname", newName);
  95.     //    }
  96.         //else
  97.             gSelectedToolbar.parentNode.renameToolbar(gSelectedToolbar, newName);
  98.     }
  99.     gToolboxChanged = true;
  100.     populateTree();
  101.     updateToolbarSelected();
  102. }
  103.  
  104. function populateTree() {
  105.     gRepopulating = true;
  106.  
  107.     var treeItems = document.getElementById("toolbarItemParent")
  108.                             .getElementsByTagNameNS('http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul', 'treeitem');
  109.     var thisChild = treeItems.item(0);
  110.     while (thisChild) {
  111.         dump("\n\nGonna remove " + thisChild.getAttribute("toolbarId") + "\n\n");
  112.         thisChild.parentNode.removeChild(thisChild);
  113.         thisChild = treeItems.item(0);
  114.     }
  115.  
  116.     var toolbarset = gToolboxDocument.getElementById("customToolbars");
  117.     var toolbarorder = toolbarset.getAttribute("toolbarorder");
  118.     dump("\nmultibar: The toolbar order is : " + toolbarorder + "\n");
  119.     var orderSplit = toolbarorder.split(",");
  120.     for (var i=0; i < orderSplit.length; i++) {
  121.         var node = gToolboxDocument.getElementById(orderSplit[i]);
  122.         if (node && node.localName == 'toolbar') {
  123.             addToolbarMenuItem(node);
  124.         } else if (node && node.localName == 'multibar') {
  125.             // JMC : Add parent tree node for multibar
  126.             var multibarTreeItem = addToolbarMenuItem(node);
  127.             multibarTreeItem.setAttribute('container', 'true');
  128.             multibarTreeItem.setAttribute('open', 'true');
  129.  
  130.             var subtreeParent = document.createElement("treechildren");
  131.             multibarTreeItem.appendChild(subtreeParent);
  132.             var innerSplit = node.currentSet.split(";");
  133.             for (var j=0; j < innerSplit.length; j++) {
  134.                 var trayCSet = innerSplit[j];
  135.                 var trayName = trayCSet.split(":").shift();
  136.                 var thisTray = node.getTrayByName(trayName);
  137.                 addToolbarMenuItem(thisTray, subtreeParent);
  138.             }
  139.         }
  140.     }
  141.     gRepopulating = false;
  142.     // gSelectedToolbar = getToolbarAt(1);
  143. }
  144.  
  145. function initDialog()
  146. {
  147.     document.getElementById("main-box").collapsed = false;
  148.  
  149. //    var prefService = Components.classes["@mozilla.org/preferences-service;1"]
  150. //    .getService(Components.interfaces.nsIPrefBranch);
  151.     // document.getElementById("menuInTitlebar").setAttribute("checked",(prefService.getBoolPref('browser.menu_in_titlebar')) ? "true" : "false");
  152.  
  153.     // Build an array of toolbars
  154.     // Add menuitems to the menulist of toolbars
  155.     // Select the first one
  156.     // Pull the mode and icon size from it
  157.     toolTree = document.getElementById("toolbartree");
  158.     populateTree();
  159.  
  160.     toolTree.view.selection.select(0);
  161.  
  162.     // Build up the palette of other items.
  163.     buildPalette();
  164.  
  165.     // Wrap all the items on the toolbar in toolbarpaletteitems.
  166.     wrapToolbarItems();
  167.  
  168.     updateToolbarSelected();
  169. }
  170.  
  171. function repositionDialog()
  172. {
  173.     // Position the dialog touching the bottom of the toolbox and centered with
  174.     // it. We must resize the window smaller first so that it is positioned
  175.     // properly.
  176.  
  177.     gToolboxDocument.defaultView.reshuffleToolbars();
  178.  
  179.     var screenX = gToolbox.boxObject.screenX + ((gToolbox.boxObject.width - kWindowWidth) / 2);
  180.     var screenY = gToolbox.boxObject.screenY + gToolbox.boxObject.height;
  181.  
  182.     var newHeight = kWindowHeight;
  183.     if (newHeight >= screen.availHeight - screenY - kVSizeSlop) {
  184.         newHeight = screen.availHeight - screenY - kVSizeSlop;
  185.     }
  186.  
  187.     window.resizeTo(kWindowWidth, newHeight);
  188.     window.moveTo(screenX, screenY);
  189. }
  190.  
  191. function removeToolboxListeners()
  192. {
  193.     gToolbox.removeEventListener("draggesture", onToolbarDragGesture, false);
  194.     gToolbox.removeEventListener("dragover", onToolbarDragOver, false);
  195.     gToolbox.removeEventListener("dragexit", onToolbarDragExit, false);
  196.     gToolbox.removeEventListener("dragdrop", onToolbarDragDrop, false);
  197.  
  198.     var multibars = gToolbox.getElementsByTagName('multibar');
  199.     var multibar;
  200.     for (var i =0; i < multibars.length; i++)
  201.     {
  202.         multibar = multibars.item(i);
  203.         multibar.searchParent.removeEventListener("draggesture", onToolbarDragGesture, false);
  204.         multibar.searchParent.removeEventListener("dragover", onToolbarDragOver, false);
  205.         multibar.searchParent.removeEventListener("dragexit", onToolbarDragExit, false);
  206.         multibar.searchParent.removeEventListener("dragdrop", onToolbarDragDrop, false);
  207.     }
  208. }
  209.  
  210. /**
  211. * Invoke a callback on the toolbox to notify it that the dialog is done
  212. * and going away.
  213. */
  214. function notifyParentComplete()
  215. {
  216.     if ("customizeDone" in gToolbox)
  217.         gToolbox.customizeDone(gToolboxChanged);
  218. }
  219.  
  220. // JMC: Extended to return toolbar with matching ordinal
  221. function getToolbarByOrdinal(ordinal)
  222. {
  223.     for (var i = 0; i < gToolbox.childNodes.length; i++) {
  224.         var toolbar = gToolbox.childNodes[i];
  225.         if (toolbar && toolbar.localName == "toolbar"
  226.             && toolbar.getAttribute("ordinal") == ordinal)
  227.         {
  228.             return toolbar;
  229.         }
  230.     }
  231. }
  232.  
  233. function getToolbarAt(i)
  234. {
  235.     return gToolbox.childNodes[i];
  236. }
  237.  
  238. /**
  239. * Persist the current set of buttons in all customizable toolbars to
  240. * localstore.
  241. */
  242. function persistCurrentSets()
  243. {
  244.     dump("CUSTOMIZE: Persisting current sets\n");
  245. //    var prefService = Components.classes["@mozilla.org/preferences-service;1"]
  246. //    .getService(Components.interfaces.nsIPrefBranch);
  247.     // prefService.setBoolPref('browser.menu_in_titlebar', document.getElementById("menuInTitlebar").checked);
  248.     // gToolboxDocument.moveMenubar();
  249.  
  250.     if (!gToolboxChanged)
  251.     {
  252.         dump ("I don't think the sets have changed, exiting... \t");
  253.         return;
  254.     }
  255.  
  256.     var customToolbarCount = 0;
  257.     var customMultibarCount = 0;
  258.     for (var i = 0; i < gToolbox.childNodes.length; ++i) {
  259.         // Look for customizable toolbars that need to be persisted.
  260.         var toolbar = getToolbarAt(i);
  261.         if (isCustomizableToolbar(toolbar)) {
  262.             // Calculate currentset and store it in the attribute.
  263.             var currentSet = toolbar.currentSet;
  264.             toolbar.setAttribute("currentset", currentSet);
  265.             dump ("Persist Current Sets - about to reset currentset on toolbar " + toolbar.id + " to " + currentSet + "\t\t\t");
  266.             toolbar.currentSet = currentSet; // JMC - this will force a total redraw, expensive!
  267.  
  268.             var customIndex = toolbar.hasAttribute("customindex");
  269.             if (customIndex) {
  270.                 /*
  271.                 if (!toolbar.firstChild) {
  272.                 // Remove custom toolbars whose contents have been removed.
  273.                 gToolbox.removeToolbar(toolbar);
  274.                 --i;
  275.                 } else {
  276.                 */
  277.                 // Persist custom toolbar info on the <toolbarset/>
  278.                 if (toolbar.localName == 'toolbar') {
  279.                     gToolbox.toolbarset.setAttribute("toolbar"+(++customToolbarCount),
  280.                     toolbar.toolbarName + ":" + currentSet);
  281.                     gToolboxDocument.persist(gToolbox.toolbarset.id, "toolbar"+customToolbarCount);                    
  282.                     
  283.                     gToolbox.toolbarset.setAttribute("toolbariconsize"+(customToolbarCount),
  284.                     toolbar.getAttribute('iconsize'));
  285.                     gToolboxDocument.persist(gToolbox.toolbarset.id, "toolbariconsize"+customToolbarCount);
  286.                     
  287.                     gToolbox.toolbarset.setAttribute("toolbarmode"+(customToolbarCount),
  288.                     toolbar.getAttribute('mode'));
  289.                     gToolboxDocument.persist(gToolbox.toolbarset.id, "toolbarmode"+customToolbarCount);
  290.                     
  291.                 } else if (toolbar.localName == 'multibar') {
  292.                     var setString = toolbar.getAttribute('toolbarname') + ":" ;
  293.                     for (var j = 0; j < toolbar.mTrays.length; j++)
  294.                     {
  295.                         setString += toolbar.mTrays[j].getAttribute('toolbarname') + ":" + toolbar.mTrays[j].currentSet;
  296.                         if (j != (toolbar.mTrays.length-1))
  297.                         setString += ";";
  298.                     }
  299.                     gToolbox.toolbarset.setAttribute("multibar"+(++customMultibarCount), setString);
  300.                     gToolboxDocument.persist(gToolbox.toolbarset.id, "multibar"+customMultibarCount);
  301.  
  302.                     gToolbox.toolbarset.setAttribute("multibarselected"+(customMultibarCount),
  303.                                                      toolbar.currentTrayIndex);
  304.                     gToolboxDocument.persist(gToolbox.toolbarset.id,
  305.                                              "multibarselected"+customMultibarCount);
  306.                     
  307.                     gToolbox.toolbarset.setAttribute("multibariconsize"+(customMultibarCount),
  308.                                                      toolbar.getAttribute('iconsize'));
  309.                     gToolboxDocument.persist(gToolbox.toolbarset.id,
  310.                                              "multibariconsize"+customMultibarCount);
  311.                     
  312.                     gToolbox.toolbarset.setAttribute("multibarmode"+(customMultibarCount),
  313.                                                      toolbar.getAttribute('mode'));
  314.                     gToolboxDocument.persist(gToolbox.toolbarset.id,
  315.                                              "multibarmode"+customMultibarCount);
  316.                 }
  317.                 // }
  318.             }
  319.  
  320.             if (!customIndex) {
  321.                 // Persist the currentset attribute directly on hardcoded toolbars.
  322.                 dump ("This toolbar is not custom, persisting directly on it... \t");
  323.                 gToolboxDocument.persist(toolbar.id, "currentset");
  324.                 toolbar.setAttribute("currentIndex",  toolbar.currentTrayIndex);
  325.             }
  326.         }
  327.     }
  328.  
  329.     // Remove toolbarX attributes for removed toolbars.
  330.     while (gToolbox.toolbarset.hasAttribute("toolbar"+(++customToolbarCount))) {
  331.         gToolbox.toolbarset.removeAttribute("toolbar"+customToolbarCount);
  332.         gToolboxDocument.persist(gToolbox.toolbarset.id, "toolbar"+customToolbarCount);
  333.     }
  334.  
  335.     while (gToolbox.toolbarset.hasAttribute("multibar"+(++customMultibarCount))) {
  336.         gToolbox.toolbarset.removeAttribute("multibar"+customMultibarCount);
  337.         gToolboxDocument.persist(gToolbox.toolbarset.id, "multibar"+customMultibarCount);
  338.         gToolbox.toolbarset.removeAttribute("multibarselected"+customMultibarCount);
  339.         gToolboxDocument.persist(gToolbox.toolbarset.id, "multibarselected"+customMultibarCount);
  340.     }
  341. }
  342.  
  343. /**
  344. * Wraps all items in all customizable toolbars in a toolbox.
  345. */
  346. function wrapToolbarItems()
  347. {
  348.     for (var i = 0; i < gToolbox.childNodes.length; i++) {
  349.  
  350.         var toolbar = getToolbarAt(i);
  351.         if (toolbar.localName == 'multibar') {
  352.             for (var j = 0; j < toolbar.mTrays.length; j++) {
  353.                 var multibartray = toolbar.mTrays[j];
  354.                 for (var k = 0; k < multibartray.childNodes.length; k++) {
  355.                     var item = multibartray.childNodes[k];
  356.                     if (isToolbarItem(item)) {
  357.                         var nextSibling = item.nextSibling;
  358.                         var wrapper = wrapToolbarItem(item);
  359.                         if (nextSibling) {
  360.                             dump ("Inserting wrapper for " + item.id + " just before " + nextSibling.id + "\t");
  361.                             multibartray.insertBefore(wrapper, nextSibling);
  362.                         } else {
  363.                             multibartray.appendChild(wrapper);                            
  364.                         }
  365.                     }
  366.                 }
  367.             }
  368.             // Special case for search bar on multibar
  369.             if (toolbar.searchBar) {
  370.                 dump ("CUSTOMIZE: Wrapping the searchBar for moving.. \n");
  371.                 var wrapper = wrapToolbarItem(toolbar.searchParent.firstChild);
  372.                 toolbar.searchParent.appendChild(wrapper);
  373.             }
  374.         } else {
  375.             if (isCustomizableToolbar(toolbar)) {
  376.                 for (var k = 0; k < toolbar.childNodes.length; ++k) {
  377.                     var item = toolbar.childNodes[k];
  378.                     if (isToolbarItem(item)) {
  379.                         var nextSibling = item.nextSibling;
  380.                         var wrapper = wrapToolbarItem(item);
  381.                         if (nextSibling)
  382.                             toolbar.insertBefore(wrapper, nextSibling);
  383.                         else
  384.                             toolbar.appendChild(wrapper);
  385.                     }
  386.                 }
  387.             }
  388.         }
  389.     }
  390. }
  391.  
  392. /**
  393. * Unwraps all items in all customizable toolbars in a toolbox.
  394. */
  395. function unwrapToolbarItems()
  396. {
  397.  
  398.     // JMC: Must unwrap multibar toolbaritems here, too
  399.  
  400.     var paletteItems = gToolbox.getElementsByTagName("toolbarpaletteitem");
  401.     var paletteItem;
  402.     while ((paletteItem = paletteItems.item(0)) != null) {
  403.         var toolbarItem = paletteItem.firstChild;
  404.  
  405.         if (paletteItem.hasAttribute("itemdisabled"))
  406.             toolbarItem.disabled = true;
  407.  
  408.         if (paletteItem.hasAttribute("itemcommand"))
  409.             toolbarItem.setAttribute("command", paletteItem.getAttribute("itemcommand"));
  410.  
  411.         if (paletteItem.hasAttribute("itemstate"))
  412.             toolbarItem.setAttribute("state", paletteItem.getAttribute("itemstate"));
  413.  
  414.         // We need the removeChild here because replaceChild and XBL no workee
  415.         // together.  See bug 193298.
  416.         paletteItem.removeChild(toolbarItem);
  417.         paletteItem.parentNode.replaceChild(toolbarItem, paletteItem);
  418.     }
  419.  
  420.     var multibars = gToolbox.getElementsByTagName("multibar");
  421.     var multibar;
  422.     for (var i =0; i < multibars.length; i++) {
  423.         multibar = multibars.item(i);
  424.         if (multibar.searchBar) {
  425.             dump ( "Unwrapping searchbar... \n");
  426.             var toolbarItem = multibar.searchBar.firstChild;
  427.             multibar.searchBar.removeChild(toolbarItem);
  428.             multibar.searchParent.replaceChild(toolbarItem, multibar.searchBar);
  429.         }
  430.  
  431.     }
  432.  
  433. }
  434.  
  435. /**
  436. * Creates a wrapper that can be used to contain a toolbaritem and prevent
  437. * it from receiving UI events.
  438. */
  439. function createWrapper(aId)
  440. {
  441.     var wrapper =
  442.         document.createElementNS("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul",
  443.                                  "toolbarpaletteitem");
  444.  
  445.     wrapper.id = "wrapper-"+aId;
  446.     return wrapper;
  447. }
  448.  
  449. /**
  450. * Wraps an item that has been cloned from a template and adds
  451. * it to the end of a row in the palette.
  452. */
  453. function wrapPaletteItem(aPaletteItem, aCurrentRow, aSpacer)
  454. {
  455.     var wrapper = createWrapper(aPaletteItem.id);
  456.  
  457.     wrapper.setAttribute("flex", 1);
  458.     wrapper.setAttribute("align", "center");
  459.     wrapper.setAttribute("pack", "center");
  460.     wrapper.setAttribute("minheight", "0");
  461.     wrapper.setAttribute("minwidth", "0");
  462.  
  463.     wrapper.appendChild(aPaletteItem);
  464.  
  465.     // XXX We need to call this AFTER the palette item has been appended
  466.     // to the wrapper or else we crash dropping certain buttons on the
  467.     // palette due to removal of the command and disabled attributes - JRH
  468.     cleanUpItemForPalette(aPaletteItem, wrapper);
  469.  
  470.     if (aSpacer)
  471.         aCurrentRow.insertBefore(wrapper, aSpacer);
  472.     else
  473.         aCurrentRow.appendChild(wrapper);
  474. }
  475.  
  476. /**
  477. * Wraps an item that is currently on a toolbar and replaces the item
  478. * with the wrapper. This is not used when dropping items from the palette,
  479. * only when first starting the dialog and wrapping everything on the toolbars.
  480. */
  481. function wrapToolbarItem(aToolbarItem)
  482. {
  483.     var wrapper = createWrapper(aToolbarItem.id);
  484.  
  485.     cleanupItemForToolbar(aToolbarItem, wrapper);
  486.     wrapper.flex = aToolbarItem.flex;
  487.  
  488.     if (aToolbarItem.parentNode)
  489.     aToolbarItem.parentNode.removeChild(aToolbarItem);
  490.  
  491.     wrapper.appendChild(aToolbarItem);
  492.  
  493.     return wrapper;
  494. }
  495.  
  496. /**
  497. * Get the list of ids for the current set of items on each toolbar.
  498. */
  499. function getCurrentItemIds()
  500. {
  501.     var currentItems = {}; // Never put on palette
  502.     currentItems['search-container'] = 1;
  503.     var toolbar = gToolbox.firstChild;
  504.     while (toolbar) {
  505.  
  506.         if (isCustomizableToolbar(toolbar)) {
  507.             var child = toolbar.firstChild;
  508.             while (child) {
  509.                 if (isToolbarItem(child))
  510.                     currentItems[child.id] = 1;
  511.                 child = child.nextSibling;
  512.             }
  513.         }
  514.  
  515.         // JMC
  516.         if (toolbar.localName == 'multibar') {
  517.             toolbar = toolbar.firstChild;
  518.         } else if (toolbar.localName == 'multibartray' && (!toolbar.nextSibling)) {
  519.             toolbar = toolbar.parentNode.nextSibling;
  520.         } else {
  521.             toolbar = toolbar.nextSibling;
  522.         }
  523.     }
  524.     return currentItems;
  525. }
  526.  
  527.  
  528. var rowLimits = new Array(4);
  529. /**
  530. * Builds the palette of draggable items that are not yet in a toolbar.
  531. */
  532. function buildPalette()
  533. {
  534.     // Empty the palette first.
  535.     var paletteBoxes = new Array(4);
  536.     paletteBoxes[0] = document.getElementById("palette-box-grid");
  537.     paletteBoxes[1] = document.getElementById("personal-palette-box-grid");
  538.     paletteBoxes[2] = document.getElementById("functional-palette-box-grid");
  539.     paletteBoxes[3] = document.getElementById("headline-palette-box-grid");
  540.  
  541.     var currentRows = new Array(4);
  542.     
  543.     // Different grid layout for each tab
  544.     rowLimits[0] = 4;
  545.     rowLimits[1] = 2;
  546.     rowLimits[2] = 4;
  547.     rowLimits[3] = 2;    
  548.     
  549.     var i =0;
  550.     for (i = 0; i < 4; i++) {
  551.         while (paletteBoxes[i].lastChild)
  552.             paletteBoxes[i].removeChild(paletteBoxes[i].lastChild);
  553.  
  554.         currentRows[i] = document.createElementNS("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul",
  555.         "row");
  556.         currentRows[i].setAttribute("class", "paletteRow");
  557.     }
  558.  
  559.     // Add the toolbar separator item.
  560.     var templateNode = document.createElementNS("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul",
  561.     "toolbarseparator");
  562.     templateNode.id = "separator";
  563.     wrapPaletteItem(templateNode, currentRows[0], null);
  564.  
  565.     // Add the toolbar spring item.
  566.     templateNode = document.createElementNS("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul",
  567.     "toolbarspring");
  568.     templateNode.id = "spring";
  569.     templateNode.flex = 1;
  570.     wrapPaletteItem(templateNode, currentRows[0], null);
  571.  
  572.     // Add the toolbar spacer item.
  573.     templateNode = document.createElementNS("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul",
  574.     "toolbarspacer");
  575.     templateNode.id = "spacer";
  576.     templateNode.flex = 1;
  577.     wrapPaletteItem(templateNode, currentRows[0], null);
  578.  
  579.     var rowSlots = new Array(4);
  580.     rowSlots[0] = 3;
  581.     for (i =1 ;i < 4; i++) {
  582.         rowSlots[i] = 0;
  583.     }
  584.     // var rowSlot = 3;
  585.  
  586.     var currentItems = getCurrentItemIds();
  587.     templateNode = gToolbox.palette.firstChild;
  588.     while (templateNode) {
  589.         // Check if the item is already in a toolbar before adding it to the palette.
  590.  
  591.         // JMC - If it's duplicatable, add it anyways
  592.         var bCanDuplicate = templateNode.getAttribute("allowDuplicate");
  593.         if (!(templateNode.id in currentItems) || bCanDuplicate) {
  594.             var paletteItem = templateNode.cloneNode(true);
  595.  
  596.             var paletteIndex = 0;
  597.             // JMC - pick a tab for this item
  598.             switch (paletteItem.getAttribute("toolgroup")) {
  599.             case "functional":
  600.                 paletteIndex = 2;
  601.                 break;
  602.             case "personal":
  603.                 paletteIndex = 1;
  604.                 break;
  605.             case "headline":
  606.                 paletteIndex = 3;
  607.                 break;
  608.             case "navigation":
  609.             default:
  610.                 paletteIndex = 0;
  611.             }
  612.  
  613.             if (rowSlots[paletteIndex] == rowLimits[paletteIndex]) {
  614.                 // Append the old row.
  615.                 paletteBoxes[paletteIndex].appendChild(currentRows[paletteIndex]);
  616.  
  617.                 // Make a new row.
  618.                 currentRows[paletteIndex] = document.createElementNS("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul",
  619.                 "row");
  620.                 currentRows[paletteIndex].setAttribute("class", "paletteRow");
  621.                 rowSlots[paletteIndex] = 0;
  622.             }
  623.  
  624.             ++rowSlots[paletteIndex];
  625.             wrapPaletteItem(paletteItem, currentRows[paletteIndex], null);
  626.         }
  627.  
  628.         templateNode = templateNode.nextSibling;
  629.     }
  630.  
  631.     for (i = 0; i < 4; i++) {
  632.         if (currentRows[i]) {
  633.         //    fillRowWithFlex(currentRows[i]);
  634.             paletteBoxes[i].appendChild(currentRows[i]);
  635.         }
  636.     }
  637. }
  638.  
  639. /**
  640. * Creates a new palette item for a cloned template node and
  641. * adds it to the last slot in the palette.
  642. */
  643. function appendPaletteItem(aItem)
  644. {
  645.     // JMC Changes to place item back on the right palette
  646.     var paletteIndex = 0;
  647.     switch (aItem.getAttribute("toolgroup")) {
  648.         case "functional":
  649.         paletteIndex = 2;
  650.         break;
  651.         case "personal":
  652.         paletteIndex = 1;
  653.         break;
  654.         case "headline":
  655.         paletteIndex = 3;
  656.         break;
  657.         case "navigation":
  658.         default:
  659.         paletteIndex = 0;
  660.     }
  661.  
  662.     var paletteBoxes = new Array(4);
  663.     paletteBoxes[0] = document.getElementById("palette-box-grid");
  664.     paletteBoxes[1] = document.getElementById("personal-palette-box-grid");
  665.     paletteBoxes[2] = document.getElementById("functional-palette-box-grid");
  666.     paletteBoxes[3] = document.getElementById("headline-palette-box-grid");
  667.  
  668.     var paletteBox = paletteBoxes[paletteIndex];
  669.  
  670.     var lastRow = paletteBox.lastChild;
  671.     if (!lastRow || lastRow.childNodes.length == rowLimits[paletteIndex])
  672.     {
  673.         lastRow = document.createElementNS("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul",
  674.                 "row");
  675.         lastRow.setAttribute("class", "paletteRow");
  676.         paletteBox.appendChild(lastRow);
  677.     }
  678.  
  679.     wrapPaletteItem(aItem, lastRow, null);
  680.     // fillRowWithFlex(lastRow);
  681.  
  682. }
  683.  
  684. function fillRowWithFlex(aRow)
  685. {
  686.     var remainingFlex = kRowMax - aRow.childNodes.length;
  687.     if (remainingFlex > 0) {
  688.         var spacer = document.createElementNS("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul",
  689.         "spacer");
  690.         spacer.setAttribute("flex", remainingFlex);
  691.         aRow.appendChild(spacer);
  692.     }
  693. }
  694.  
  695. /**
  696. * Makes sure that an item that has been cloned from a template
  697. * is stripped of all properties that may adversely affect it's
  698. * appearance in the palette.
  699. */
  700. function cleanUpItemForPalette(aItem, aWrapper)
  701. {
  702.     aWrapper.setAttribute("place", "palette");
  703.     setWrapperType(aItem, aWrapper);
  704.  
  705.     if (aItem.hasAttribute("title"))
  706.         aWrapper.setAttribute("title", aItem.getAttribute("title"));
  707.     else if (isSpecialItem(aItem)) {
  708.         var stringBundle = document.getElementById("stringBundle");
  709.         var title = stringBundle.getString(aItem.id + "Title");
  710.         aWrapper.setAttribute("title", title);
  711.     }
  712.  
  713.     // Remove attributes that screw up our appearance.
  714.     aItem.removeAttribute("command");
  715.     aItem.removeAttribute("observes");
  716.     aItem.removeAttribute("disabled");
  717.     aItem.removeAttribute("type");
  718.  
  719.     if (aItem.localName == "toolbaritem" && aItem.firstChild) {
  720.         aItem.firstChild.removeAttribute("observes");
  721.  
  722.         // So the throbber doesn't throb in the dialog,
  723.         // cute as that may be...
  724.         aItem.firstChild.removeAttribute("busy");
  725.     }
  726. }
  727.  
  728. /**
  729. * Makes sure that an item that has been cloned from a template
  730. * is stripped of all properties that may adversely affect it's
  731. * appearance in the toolbar.  Store critical properties on the
  732. * wrapper so they can be put back on the item when we're done.
  733. */
  734. function cleanupItemForToolbar(aItem, aWrapper)
  735. {
  736.     setWrapperType(aItem, aWrapper);
  737.     aWrapper.setAttribute("place", "toolbar");
  738.  
  739.     if (aItem.hasAttribute("command")) {
  740.         aWrapper.setAttribute("itemcommand", aItem.getAttribute("command"));
  741.         aItem.removeAttribute("command");
  742.     }
  743.     
  744.     if (aItem.hasAttribute("state")) {
  745.         aWrapper.setAttribute("itemstate", aItem.getAttribute("state"));
  746.         aItem.removeAttribute("state");
  747.     }
  748.  
  749.     if (aItem.disabled) {
  750.         aWrapper.setAttribute("itemdisabled", "true");
  751.         aItem.disabled = false;
  752.     }
  753. }
  754.  
  755. function setWrapperType(aItem, aWrapper)
  756. {
  757.     if (aItem.localName == "toolbarseparator") {
  758.         aWrapper.setAttribute("type", "separator");
  759.     } else if (aItem.localName == "toolbarspring") {
  760.         aWrapper.setAttribute("type", "spring");
  761.     } else if (aItem.localName == "toolbarspacer") {
  762.         aWrapper.setAttribute("type", "spacer");
  763.     } else if (aItem.localName == "toolbaritem" && aItem.firstChild) {
  764.         aWrapper.setAttribute("type", aItem.firstChild.localName);
  765.     }
  766. }
  767.  
  768. function setDragActive(aItem, aValue)
  769. {
  770.     var node = aItem;
  771.     var value = "left";
  772.     if (aItem.localName == "toolbar" ||
  773.         aItem.localName == "multibartray" ||
  774.         aItem.localName == "multibar")
  775.     {
  776.         //JMC: Try this?
  777.         node = aItem.lastChild;
  778.         value = "right";
  779.     }
  780.     
  781.     if (!node)
  782.         return;
  783.  
  784.     if (aValue) {
  785.         if (!node.hasAttribute("dragover"))
  786.             node.setAttribute("dragover", value);
  787.     } else {
  788.         node.removeAttribute("dragover");
  789.     }
  790. }
  791.  
  792. function getPersonalBar() {
  793.     for (var i = 0; i < gToolbox.childNodes.length; ++i) {
  794.         var toolbar = getToolbarAt(i);
  795.         if (isCustomizableToolbar(toolbar) && toolbar.id == "PersonalToolbar") {
  796.             return toolbar;
  797.         }
  798.     }
  799. }
  800.  
  801. function addNewTray()
  802. {
  803.     dump ("\nCUSTOMIZE: AddnewTray() \n\n");
  804.     /*
  805.     var promptService = Components.classes["@mozilla.org/embedcomp/prompt-service;1"]
  806.         .getService(Components.interfaces.nsIPromptService);
  807.  
  808.     var stringBundle = document.getElementById("stringBundle");
  809.     var message = stringBundle.getString("enterToolbarName");
  810.     var title = stringBundle.getString("enterToolbarTitle");
  811.  
  812.     var name = {};
  813.     while (true) {
  814.         if (!promptService.prompt(window, title, message, name, null, {}))
  815.         return;
  816.  
  817.         var dupeFound = false;
  818.         // Check for an existing tray with the same display name
  819.         for (i = 0; i < gSelectedToolbar.childNodes.length; ++i) {
  820.             var toolbar = gSelectedToolbar.childNodes[i];
  821.             var toolbarName = toolbar.getAttribute("toolbarname");
  822.             if (toolbarName == name.value && toolbar.getAttribute("type") != "menubar") {
  823.                 dupeFound = true;
  824.                 break;
  825.             }
  826.         }
  827.         if (!dupeFound)
  828.             break;
  829.  
  830.         message = stringBundle.getFormattedString("enterToolbarDup", [name.value]);
  831.     }
  832.  
  833.     var toolbar;
  834.     var treeItem;
  835.  
  836.     if (gSelectedToolbar.localName == 'multibartray') {
  837.         toolbar = gSelectedToolbar.parentNode.addNewTray(name.value);
  838.     } else { // JMC: multibar
  839.         toolbar = gSelectedToolbar.addNewTray(name.value);
  840.     }
  841.     // toolbar.setAttribute("currentSet", "spring");
  842.     toolbar.parentNode.parentNode.reorderToolbars();
  843.     */
  844.     var multibar;
  845.     if (gSelectedToolbar.localName == 'multibartray') {
  846.         multibar = gSelectedToolbar.parentNode;
  847.     } else { // JMC: multibar
  848.         multibar = gSelectedToolbar;
  849.     }
  850.     var oldCount = multibar.mTrays.length;
  851.     window.openDialog("chrome://global/content/addRenameTrayDialog.xul", "addRenameTrayDialog",
  852.                     "centerscreen,modal=yes", 'add', multibar);
  853.     if (oldCount <  multibar.mTrays.length) {
  854.         gSelectedToolbar = multibar.currentTray;
  855.         populateTree();
  856.         toolTree.view.selection.select(toolTree.contentView.getIndexOfItem(getTreeItem(gSelectedToolbar)));
  857.         updateToolbarSelected();
  858.         repositionDialog();
  859.         gToolboxChanged = true;
  860.     }
  861.  
  862. }
  863.  
  864. function addNewToolbar(bMultibar)
  865. {
  866.     var promptService = Components.classes["@mozilla.org/embedcomp/prompt-service;1"]
  867.                                   .getService(Components.interfaces.nsIPromptService);
  868.  
  869.     var stringBundle = document.getElementById("stringBundle");
  870.     if (bMultibar) {
  871.         var message = stringBundle.getString("enterMultibarName");
  872.         var title = stringBundle.getString("enterMultibarTitle");    
  873.     } else {
  874.         var message = stringBundle.getString("enterToolbarName");
  875.         var title = stringBundle.getString("enterToolbarTitle");
  876.     }
  877.  
  878.     var name = {};
  879.     while (true) {
  880.         if (!promptService.prompt(window, title, message, name, null, {}))
  881.             return;
  882.  
  883.         var dupeFound = false;
  884.         for (i = 0; i < gToolbox.childNodes.length; ++i) {
  885.             var toolbar = gToolbox.childNodes[i];
  886.             var toolbarName = toolbar.getAttribute("toolbarname");
  887.             if (toolbarName == name.value && toolbar.getAttribute("type") != "menubar") {
  888.                 dupeFound = true;
  889.                 break;
  890.             }
  891.         }
  892.  
  893.         if (!dupeFound)
  894.         break;
  895.  
  896.         message = stringBundle.getFormattedString("enterToolbarDup", [name.value]);
  897.     }
  898.  
  899.     var toolbar;
  900.     if (bMultibar) {
  901.         toolbar = gToolbox.appendCustomMultibar(name.value, "first:__empty");
  902.         toolbar.parentNode.reorderToolbars();
  903.         toolbar.searchParent.addEventListener("draggesture", onToolbarDragGesture, false);
  904.         toolbar.searchParent.addEventListener("dragover", onToolbarDragOver, false);
  905.         toolbar.searchParent.addEventListener("dragexit", onToolbarDragExit, false);
  906.         toolbar.searchParent.addEventListener("dragdrop", onToolbarDragDrop, false);
  907.     } else {
  908.         toolbar = gToolbox.appendCustomToolbar(name.value, "__empty");
  909.         toolbar.parentNode.reorderToolbars();
  910.     }
  911.  
  912.     gSelectedToolbar = toolbar;
  913.     copyPersonalModes(gSelectedToolbar);
  914.  
  915.     populateTree();
  916.     toolTree.view.selection.select(toolTree.contentView.getIndexOfItem(getTreeItem(gSelectedToolbar)));
  917.     updateToolbarSelected();
  918.     repositionDialog();
  919.     gToolboxChanged = true;
  920. }
  921.  
  922. function copyPersonalModes(modeTarget)
  923. {
  924.     var personalbar = getPersonalBar();
  925.     if (modeTarget.localName == 'multibartray') {
  926.         modeTarget = modeTarget.parentNode;
  927.     }
  928.     modeTarget.setAttribute("mode", personalbar.getAttribute("mode"));
  929.     modeTarget.setAttribute("iconsize", personalbar.getAttribute("iconsize"));
  930.     modeTarget.setAttribute("smallicons", personalbar.getAttribute("smallicons"));
  931. }
  932.  
  933. function getTreeItem(aToolbar) {
  934.     var treeItems = toolTree.getElementsByTagName('treeitem');
  935.     for (var i = 0; i < treeItems.length; i++) {
  936.         var treeItem = treeItems.item(i);
  937.         if (treeItem.getAttribute("toolbarId") == aToolbar.id) {
  938.             return treeItem;
  939.         }
  940.     }
  941.     return treeItems.item(0); // JMC: Kind of ugly
  942. }
  943.  
  944. function addNewMulti() {
  945.     addNewToolbar(true);
  946. }
  947.  
  948. function removeToolbar(bReentrant, bForce) {
  949.     dump ("Removing current toolbar, id : " + gSelectedToolbar.id + "\n\n");
  950.  
  951.     // Sanity checks - can't remove personal or navigation toolbars
  952.     if (gSelectedToolbar.id == "nav-bar" ||
  953.         gSelectedToolbar.id == "PersonalToolbar")
  954.     {
  955.         return;
  956.     }
  957.  
  958.     var bCanDelete = true;
  959.     var toolbarChild = gSelectedToolbar.firstChild;
  960.     while (toolbarChild) {        
  961.         dump ("Scanning toolbar children, this ones called : " + toolbarChild.id + "\n");
  962.         var itemId = toolbarChild.id.substring(8,toolbarChild.id.length);
  963.         if (itemId == "search-container") { // Not allowed to delete searchbox
  964.             if (!bForce) {
  965.                 bCanDelete = false;
  966.             }
  967.             break;
  968.         }
  969.         toolbarChild = toolbarChild.nextSibling;
  970.     }
  971.  
  972.     if (!bCanDelete || (gSelectedToolbar.localName == 'multibartray' && 
  973.     !gSelectedToolbar.parentNode.checkDelete(gSelectedToolbar.parentNode.getIndexOfTray(gSelectedToolbar)))) return; // Optionally show a dialog explaining why can't remove.
  974.  
  975.     // If it's a multibar, recurse through all the trays
  976.     if (gSelectedToolbar.localName == 'multibar') {
  977.         dump ("This is a multibar, gonna recurse for children...\n");
  978.         var oldSelected = gSelectedToolbar;
  979.         toolbarChild = gSelectedToolbar.firstChild;
  980.         while (toolbarChild) {
  981.             if (toolbarChild.localName == 'multibartray') {
  982.                 gSelectedToolbar = toolbarChild;
  983.                 removeToolbar(true);
  984.                 gSelectedToolbar = oldSelected;
  985.             }
  986.             toolbarChild = gSelectedToolbar.firstChild;;
  987.         }
  988.             // Now sanity check again to make sure there's no trays left
  989.         if (gSelectedToolbar.childNodes.length > 0)
  990.             return;
  991.     }
  992.  
  993.     toolbarChild = gSelectedToolbar.firstChild;
  994.     while (toolbarChild) {
  995.         dump ("Removing existing toolbar items : " + toolbarChild.id + "\n");
  996.         var itemId = toolbarChild.id.substring(8,toolbarChild.id.length);
  997.         dump ("Item id is : " + itemId + "\n");
  998.         // var wrapper = gToolboxDocument.getElementById("wrapper-"+itemId);
  999.         var wrapper = toolbarChild;
  1000.         toolbarChild = toolbarChild.nextSibling;        
  1001.         if (wrapper) {
  1002.             if (itemId == "search-container") continue; // Don't ever put this back on the palette
  1003.             // Don't allow static kids (e.g., the menubar) to move.
  1004.             if (wrapper.parentNode.firstPermanentChild && wrapper.parentNode.firstPermanentChild.id == wrapper.firstChild.id)
  1005.                 continue;
  1006.             if (wrapper.parentNode.lastPermanentChild && wrapper.parentNode.lastPermanentChild.id == wrapper.firstChild.id)
  1007.                 continue;
  1008.  
  1009.             // The item was dragged out of the toolbar.
  1010.             wrapper.parentNode.removeChild(wrapper);
  1011.  
  1012.             var wrapperType = wrapper.getAttribute("type");
  1013.             if (wrapperType != "separator" && wrapperType != "spacer" && wrapperType != "spring") {
  1014.                 // Find the template node in the toolbox palette
  1015.                 var templateNode = gToolbox.palette.firstChild;
  1016.                 while (templateNode) {
  1017.                     if (templateNode.id == itemId)
  1018.                         break;
  1019.                     templateNode = templateNode.nextSibling;
  1020.                 }
  1021.                 if (!templateNode)
  1022.                     continue;
  1023.  
  1024.                 // Clone the template and add it to our palette.
  1025.                 var paletteItem = templateNode.cloneNode(true);
  1026.                 appendPaletteItem(paletteItem);
  1027.             }
  1028.         }
  1029.     }
  1030.  
  1031.     gToolboxChanged = true;
  1032.  
  1033.  
  1034.     var customCount = gSelectedToolbar.getAttribute('customindex');
  1035.     dump ("CUSTOMIZE: deleteing toolbar with customindex of " + customCount + "\n");
  1036.     if (gSelectedToolbar.localName == 'multibartray') {
  1037.         gSelectedToolbar.parentNode.deleteTrayByObj(gSelectedToolbar, true); // Force delete
  1038.     } else {
  1039.         if (gSelectedToolbar.localName == 'multibar') {
  1040.             gToolbox.toolbarset.removeAttribute("multibar"+customCount);
  1041.             gToolboxDocument.persist(gToolbox.toolbarset.id, "multibar"+customCount);
  1042.             gToolbox.toolbarset.removeAttribute("multibarselected"+customCount);
  1043.             gToolboxDocument.persist(gToolbox.toolbarset.id, "multibarselected"+customCount);
  1044.             gToolbox.toolbarset.removeAttribute("multibarshowtitle"+customCount);
  1045.             gToolboxDocument.persist(gToolbox.toolbarset.id, "multibarshowtitle"+customCount);
  1046.         } else {
  1047.             gToolbox.toolbarset.removeAttribute("toolbar"+customCount);
  1048.             gToolboxDocument.persist(gToolbox.toolbarset.id, "toolbar"+customCount);
  1049.         }
  1050.         gToolbox.removeToolbar(gSelectedToolbar);
  1051.     }
  1052.  
  1053.     var treeParent = document.getElementById("toolbarItemParent");
  1054.     var toolChild = treeParent.firstChild;
  1055.     while (toolChild) {
  1056.         if (toolChild.getAttribute('toolbarId') == gSelectedToolbar.id) {
  1057.             treeParent.removeChild(toolChild);
  1058.             break;
  1059.         }
  1060.         toolChild = toolChild.nextSibling;
  1061.     }
  1062.     if (!bReentrant) {
  1063.         populateTree();
  1064.         repositionDialog();
  1065.         toolTree.view.selection.select(1);
  1066.         updateToolbarSelected();
  1067.     }
  1068. }
  1069.  
  1070. function addToolbarMenuItem(aToolbar, attachPoint)
  1071. {
  1072.     var toolbarName = aToolbar.getAttribute("toolbarname");
  1073.     // Make a new menu item
  1074.     var newTreeItem = document.createElement("treeitem");
  1075.     var newTreeRow = document.createElement("treerow");
  1076.     var newTreeCell = document.createElement("treecell");
  1077.  
  1078.     newTreeCell.setAttribute("label", toolbarName);
  1079.     newTreeItem.setAttribute("toolbarId", aToolbar.id);
  1080.  
  1081.     // Append the new item
  1082.     newTreeRow.appendChild(newTreeCell);
  1083.     newTreeItem.appendChild(newTreeRow);
  1084.  
  1085.     if (attachPoint) {
  1086.         attachPoint.appendChild(newTreeItem);
  1087.     } else {
  1088.         document.getElementById("toolbarItemParent").appendChild(newTreeItem);
  1089.     }
  1090.     return newTreeItem;
  1091. }
  1092.  
  1093. /**
  1094. * Restore the default set of buttons to fixed toolbars,
  1095. * remove all custom toolbars, and rebuild the palette.
  1096. */
  1097. function restoreDefaultSet()
  1098. {
  1099.     // Save disabled/command states, because we're
  1100.     // going to recreate the wrappers and lose this
  1101.     var savedAttributes = saveItemAttributes(["itemdisabled", "itemcommand"]);
  1102.  
  1103.     // Restore the defaultset for fixed toolbars.
  1104.     var toolbar = gToolbox.firstChild;
  1105.     while (toolbar) {
  1106.         if (isCustomizableToolbar(toolbar)) {
  1107.             if (!toolbar.hasAttribute("customindex")) {
  1108.                 var defaultSet = toolbar.getAttribute("defaultset");
  1109.                 if (defaultSet) {
  1110.  
  1111.                     toolbar.currentSet = defaultSet;
  1112.                     if (toolbar.localName == 'multibar') {
  1113.                         if (toolbar.searchBar)
  1114.                             toolbar.searchParent.removeChild(toolbar.searchBar);
  1115.                         gToolbox.toolbarset.removeAttribute('showsearch');
  1116.                         gToolboxDocument.persist(gToolbox.toolbarset.id, 'showsearch');
  1117.                         toolbar.showTray(0);
  1118.                         // gToolboxDocument.defaultView.resizeSearchBar();
  1119.                     } else {
  1120.                         toolbar.setAttribute('currentset', defaultSet);
  1121.                         gToolboxDocument.persist(toolbar.id, 'currentset');
  1122.                     }
  1123.                     
  1124.                     setAttribute(toolbar, "mode", toolbar.getAttribute('default_mode'));
  1125.                     gToolboxDocument.persist(toolbar.id, "mode");
  1126.                     setAttribute(toolbar, "iconsize", toolbar.getAttribute('default_iconsize'));
  1127.                     gToolboxDocument.persist(toolbar.id, "iconsize");
  1128.                     setAttribute(toolbar, "iconsize", toolbar.getAttribute('default_iconsize'));
  1129.                     gToolboxDocument.persist(toolbar.id, "iconsize");
  1130.                     setAttribute(toolbar, "toolbarname", toolbar.getAttribute('default_toolbarname'));
  1131.                     gToolboxDocument.persist(toolbar.id, "toolbarname");                    
  1132.                     toolbar.removeAttribute("collapsed");
  1133.                     gToolboxDocument.persist(toolbar.id, "collapsed");
  1134.                     
  1135.                     
  1136.                 }
  1137.             }
  1138.         }
  1139.         toolbar = toolbar.nextSibling;
  1140.     }
  1141.  
  1142. /*
  1143.     // Restore the default icon size (large) and mode (icons only).
  1144.     updateIconSize(false);
  1145.     document.getElementById("smallicons").checked = false;
  1146.     updateToolbarMode("icons");
  1147.     document.getElementById("modelist").value = "icons";
  1148.     */
  1149.  
  1150.     // JMC : Todo - reset default mode and icon sizes on all toolbars
  1151.  
  1152.     // Remove all of the customized toolbars.
  1153.     var child = gToolbox.lastChild;
  1154.     while (child) {
  1155.         if (child.hasAttribute("customindex")) {
  1156.             var thisChild = child;
  1157.             child = child.previousSibling;
  1158.             gSelectedToolbar = thisChild;
  1159.             removeToolbar(false, true); // force removal of search container
  1160.         } else {
  1161.             child = child.previousSibling;
  1162.         }
  1163.     }
  1164.  
  1165.     // Reset toolbarorder to default
  1166.     gToolbox.toolbarset.setAttribute("toolbarorder",
  1167.         gToolbox.toolbarset.getAttribute("defaulttoolbarorder"));
  1168.  
  1169.     // And reorder toolbars
  1170.     gToolbox.reorderToolbars();
  1171.  
  1172.  
  1173.     // Now rebuild the palette.
  1174.     buildPalette();
  1175.  
  1176.     // Now re-wrap the items on the toolbar.
  1177.     wrapToolbarItems();
  1178.  
  1179.     // Restore the disabled and command states
  1180.     restoreItemAttributes(["itemdisabled", "itemcommand"], savedAttributes);
  1181.  
  1182.     populateTree();
  1183.     repositionDialog();
  1184.     gToolboxChanged = true;
  1185.  
  1186.     toolTree.view.selection.select(1);
  1187.     updateToolbarSelected();
  1188. }
  1189.  
  1190. function saveItemAttributes(aAttributeList)
  1191. {
  1192.     var items = [];
  1193.     var paletteItems = gToolbox.getElementsByTagName("toolbarpaletteitem");
  1194.     for (var i = 0; i < paletteItems.length; i++) {
  1195.         var paletteItem = paletteItems.item(i);
  1196.         for (var j = 0; j < aAttributeList.length; j++) {
  1197.             var attr = aAttributeList[j];
  1198.             if (paletteItem.hasAttribute(attr)) {
  1199.                 items.push([paletteItem.id, attr, paletteItem.getAttribute(attr)]);
  1200.             }
  1201.         }
  1202.     }
  1203.     return items;
  1204. }
  1205.  
  1206. function restoreItemAttributes(aAttributeList, aSavedAttrList)
  1207. {
  1208.     var paletteItems = gToolbox.getElementsByTagName("toolbarpaletteitem");
  1209.  
  1210.     for (var i = 0; i < paletteItems.length; i++) {
  1211.         var paletteItem = paletteItems.item(i);
  1212.  
  1213.         // if the item is supposed to have this, it'll get
  1214.         // restored from the saved list
  1215.         for (var j = 0; j < aAttributeList.length; j++)
  1216.         paletteItem.removeAttribute(aAttributeList[j]);
  1217.  
  1218.         for (var j = 0; j < aSavedAttrList.length; j++) {
  1219.             var savedAttr = aSavedAttrList[j];
  1220.             if (paletteItem.id == savedAttr[0]) {
  1221.                 paletteItem.setAttribute(savedAttr[1], savedAttr[2]);
  1222.             }
  1223.         }
  1224.     }
  1225. }
  1226.  
  1227. function updateToolbarSelected()
  1228. {
  1229.     var toolbarIndex = toolTree.currentIndex;
  1230.     if ((toolbarIndex > -1) && (!gRepopulating)) {
  1231.         var selectedTreeItem = toolTree.contentView.getItemAtIndex(toolbarIndex);
  1232.         dump("The selected tree Item is " + selectedTreeItem.getAttribute('toolbarId') + "\n");
  1233.         gSelectedToolbar = gToolboxDocument.getElementById(selectedTreeItem.getAttribute('toolbarId'));
  1234.         document.getElementById("toolbarname").value = gSelectedToolbar.getAttribute('toolbarname');
  1235.         
  1236.         document.getElementById("settingsBoxCaption").label = gSelectedToolbar.getAttribute('toolbarname') + " Settings";
  1237.  
  1238.     //    var smallIconsCheckbox = document.getElementById("smallicons");
  1239.                              var iconSize = "small";
  1240.         // if it's multibartray, can't change mode values
  1241.         // But show them for the parent multibar anyway
  1242.  
  1243.         if (gSelectedToolbar.localName == 'multibartray') {
  1244.             var mode = gSelectedToolbar.parentNode.getAttribute("mode");
  1245.             gToolboxIconSize = gSelectedToolbar.parentNode.getAttribute("iconsize");
  1246.             if (gToolboxIconSize != "small")
  1247.             {
  1248.                 iconSize = "large";
  1249.             }
  1250.             
  1251.     //        smallIconsCheckbox.checked = gToolboxIconSize == "small";
  1252.     //        smallIconsCheckbox.disabled = true;
  1253.     
  1254.             document.getElementById("modelist").disabled = true;
  1255.     //        document.getElementById("smallicons").disabled = true;
  1256.             
  1257.     //        document.getElementById("newMultiButton").label = "New Tray";
  1258.     //        document.getElementById("newMultiButton").setAttribute('oncommand','addNewTray()');
  1259.     
  1260.                                  document.getElementById('newTrayButton').disabled = false;
  1261.             gSelectedToolbar.parentNode.showTrayByObj(gSelectedToolbar);
  1262.             if (gSelectedToolbar.parentNode.childNodes.length < 2) {
  1263.                 document.getElementById("removeButton").disabled = true;
  1264.             } else {
  1265.                 document.getElementById("removeButton").disabled = false;
  1266.             }
  1267.  
  1268.         } else {
  1269.  
  1270.             var mode = gSelectedToolbar.getAttribute("mode");
  1271.             gToolboxIconSize = gSelectedToolbar.getAttribute("iconsize");
  1272.             document.getElementById("modelist").disabled = false;
  1273.  
  1274.         /*    smallIconsCheckbox.disabled = false;
  1275.             if (mode == "text") {
  1276.                 smallIconsCheckbox.disabled = true;
  1277.             } else {
  1278.                 smallIconsCheckbox.checked = gToolboxIconSize == "small";
  1279.             }
  1280.             */
  1281.             if (gToolboxIconSize != "small")
  1282.             {
  1283.                 iconSize = "large";
  1284.             }
  1285.  
  1286.             if (gSelectedToolbar.localName == 'multibar')
  1287.             {
  1288.                 // Change new button to make new tray                
  1289.                 document.getElementById('newTrayButton').disabled = false;
  1290.                 
  1291.                 if (gSelectedToolbar.id == 'PersonalToolbar') {
  1292.                     document.getElementById("removeButton").disabled = true;
  1293.                 } else {
  1294.                     document.getElementById("removeButton").disabled = false;
  1295.                 }
  1296.  
  1297.             } else {
  1298.  
  1299.                 
  1300.                 document.getElementById('newTrayButton').disabled = true;
  1301.                 
  1302.                 if (gSelectedToolbar.id == 'nav-bar') {
  1303.                     document.getElementById("removeButton").disabled = true;
  1304.                 } else {
  1305.                     document.getElementById("removeButton").disabled = false;
  1306.                 }
  1307.  
  1308.             }
  1309.  
  1310.         }
  1311.                             
  1312.                             document.getElementById("modelist").value = mode + "-" + iconSize;
  1313.  
  1314.     } else if (!gRepopulating) {
  1315.         toolTree.view.selection.select(0);
  1316.     } else { // disable everything?
  1317.  
  1318.     }
  1319. }
  1320.  
  1321.  
  1322. function updateIconSize(aUseSmallIcons)
  1323. {
  1324.     // gToolboxIconSize = aUseSmallIcons ? "small" : "large";
  1325.     dump("useSmallIcons is " + aUseSmallIcons + "\n\n");
  1326.     gToolboxIconSize = aUseSmallIcons;
  1327.     if (isCustomizableToolbar(gSelectedToolbar)) {
  1328.         if (gSelectedToolbar.localName == 'multibartray') {
  1329.             setAttribute(gSelectedToolbar.parentNode, "iconsize", gToolboxIconSize);
  1330.             gToolboxDocument.persist(gSelectedToolbar.parentNode.id, "iconsize");
  1331.         } else {
  1332.             setAttribute(gSelectedToolbar, "iconsize", gToolboxIconSize);
  1333.             gToolboxDocument.persist(gSelectedToolbar.id, "iconsize");
  1334.  
  1335.         }
  1336.     }
  1337.     gToolboxChanged = true;
  1338.     repositionDialog();
  1339. }
  1340.  
  1341. function updateToolbarMode(aModeValue)
  1342. {
  1343.     if (isCustomizableToolbar(gSelectedToolbar)) {
  1344.         if (gSelectedToolbar.localName == 'multibartray') {
  1345.             setAttribute(gSelectedToolbar.parentNode, "mode", aModeValue);
  1346.             gToolboxDocument.persist(gSelectedToolbar.parentNode.id, "mode");
  1347.         } else {
  1348.             setAttribute(gSelectedToolbar, "mode", aModeValue);
  1349.              gToolboxDocument.persist(gSelectedToolbar.id, "mode");
  1350.         }
  1351.     }
  1352.  
  1353.     gToolboxChanged = true;
  1354.     updateToolbarSelected();
  1355.     repositionDialog();
  1356. }
  1357.  
  1358.  
  1359. function setAttribute(aElt, aAttr, aVal)
  1360. {
  1361.     if (aVal)
  1362.         aElt.setAttribute(aAttr, aVal);
  1363.     else
  1364.         aElt.removeAttribute(aAttr);
  1365. }
  1366.  
  1367. function isCustomizableToolbar(aElt)
  1368. {
  1369.     return aElt &&
  1370.            (aElt.localName == "toolbar" ||
  1371.             aElt.localName == "multibar" ||
  1372.             aElt.localName == "multibartray") &&
  1373.            aElt.getAttribute("customizable") == "true";
  1374. }
  1375.  
  1376. function isSpecialItem(aElt)
  1377. {
  1378.     return aElt.localName == "toolbarseparator" ||
  1379.            aElt.localName == "toolbarspring" ||
  1380.            aElt.localName == "toolbarspacer";
  1381. }
  1382.  
  1383. function isToolbarItem(aElt)
  1384. {
  1385.     return aElt.localName == "toolbarbutton" ||
  1386.            aElt.localName == "toolbaritem" ||
  1387.            aElt.localName == "toolbarseparator" ||
  1388.            aElt.localName == "toolbarspring" ||
  1389.            aElt.localName == "toolbarspacer";
  1390. }
  1391.  
  1392. ///////////////////////////////////////////////////////////////////////////
  1393. //// Drag and Drop observers
  1394.  
  1395. function onToolbarDragGesture(aEvent)
  1396. {
  1397.     nsDragAndDrop.startDrag(aEvent, dragStartObserver);
  1398. }
  1399.  
  1400. function onToolbarDragOver(aEvent)
  1401. {
  1402.     nsDragAndDrop.dragOver(aEvent, toolbarDNDObserver);
  1403. }
  1404.  
  1405. function onToolbarDragDrop(aEvent)
  1406. {
  1407.     nsDragAndDrop.drop(aEvent, toolbarDNDObserver);
  1408. }
  1409.  
  1410. function onToolbarDragExit(aEvent)
  1411. {
  1412.     if (gCurrentDragOverItem)
  1413.         setDragActive(gCurrentDragOverItem, false);
  1414. }
  1415.  
  1416. var dragStartObserver =
  1417. {
  1418.     onDragStart : function (aEvent, aXferData, aDragAction) {
  1419.         dump("CUSTOMIZE: In drag Start\n");
  1420.         var documentId = gToolboxDocument.documentElement.id;
  1421.  
  1422.         var item = aEvent.target;
  1423.         while (item && item.localName != "toolbarpaletteitem"){
  1424.             dump("Looking at item : " + item.id + "\n");
  1425.             item = item.parentNode;
  1426.         }
  1427.  
  1428.         item.setAttribute("dragactive", "true");
  1429.         dump("CUSTOMIZE: item is : " + item + "\n");
  1430.         aXferData.data = new TransferDataSet();
  1431.         var data = new TransferData();
  1432.         data.addDataForFlavour("text/toolbarwrapper-id/"+documentId, item.firstChild.id);
  1433.         aXferData.data.push(data);
  1434.         aDragAction.action = Components.interfaces.nsIDragService.DRAGDROP_ACTION_MOVE;
  1435.     }
  1436. }
  1437.  
  1438. var toolbarDNDObserver =
  1439. {
  1440.     onDragOver: function (aEvent, aFlavour, aDragSession)
  1441.     {
  1442.         var toolbar = aEvent.target;
  1443.         var dropTarget = aEvent.target;
  1444.         while (toolbar && (toolbar.localName != "toolbar" && toolbar.localName != "multibartray")) {
  1445.             dropTarget = toolbar;
  1446.             toolbar = toolbar.parentNode;
  1447.         }
  1448.  
  1449.         var previousDragItem = gCurrentDragOverItem;
  1450.  
  1451.         // Make sure we are dragging over a customizable toolbar.
  1452.         if (!isCustomizableToolbar(toolbar)) {
  1453.             gCurrentDragOverItem = null;
  1454.             return;
  1455.         }
  1456.  
  1457.         if (dropTarget.localName == "toolbar"
  1458.         || dropTarget.localName == "multibartray") {
  1459.             gCurrentDragOverItem = dropTarget;
  1460.         } else {
  1461.             var dropTargetWidth = dropTarget.boxObject.width;
  1462.             var dropTargetX = dropTarget.boxObject.x;
  1463.  
  1464.             gCurrentDragOverItem = null;
  1465.             if (aEvent.clientX > (dropTargetX + (dropTargetWidth / 2))) {
  1466.                 gCurrentDragOverItem = dropTarget.nextSibling;
  1467.                 if (!gCurrentDragOverItem)
  1468.                     gCurrentDragOverItem = toolbar;
  1469.             } else
  1470.                 gCurrentDragOverItem = dropTarget;
  1471.             }
  1472.  
  1473.             if (previousDragItem && gCurrentDragOverItem != previousDragItem) {
  1474.                 setDragActive(previousDragItem, false);
  1475.             }
  1476.  
  1477.             setDragActive(gCurrentDragOverItem, true);
  1478.  
  1479.             aDragSession.canDrop = true;
  1480.         },
  1481.  
  1482.         onDrop: function (aEvent, aXferData, aDragSession)
  1483.         {
  1484.             if (!gCurrentDragOverItem)
  1485.                 return;
  1486.  
  1487.             setDragActive(gCurrentDragOverItem, false);
  1488.  
  1489.             var draggedItemId = aXferData.data;
  1490.             if (gCurrentDragOverItem.id == draggedItemId)
  1491.                 return;
  1492.  
  1493.             var toolbar = aEvent.target;
  1494.             while (toolbar && toolbar.localName != "toolbar" &&
  1495.                    toolbar.localName != "multibartray")
  1496.                 toolbar = toolbar.parentNode;
  1497.  
  1498.             var draggedPaletteWrapper = document.getElementById("wrapper-"+draggedItemId);
  1499.             if (!draggedPaletteWrapper) {
  1500.                 // The wrapper has been dragged from the toolbar.
  1501.  
  1502.                 // Get the wrapper from the toolbar document and make sure that
  1503.                 // it isn't being dropped on itself.
  1504.                 var wrapper = gToolboxDocument.getElementById("wrapper-"+draggedItemId);
  1505.                 if (wrapper == gCurrentDragOverItem)
  1506.                     return;
  1507.  
  1508.                 // Don't allow static kids (e.g., the menubar) to move.
  1509.                 if (wrapper.parentNode.firstPermanentChild && wrapper.parentNode.firstPermanentChild.id == wrapper.firstChild.id)
  1510.                     return;
  1511.                 if (wrapper.parentNode.lastPermanentChild && wrapper.parentNode.lastPermanentChild.id == wrapper.firstChild.id)
  1512.                     return;
  1513.  
  1514.                 // Remove the item from it's place in the toolbar.
  1515.                 var oldToolbar = wrapper.parentNode;
  1516.                 wrapper.parentNode.removeChild(wrapper);
  1517.  
  1518.                 // Determine which toolbar we are dropping on.
  1519.                 var dropToolbar = null;
  1520.                 dump ("CUSTOMIZE: currentDragOverItem is : " + gCurrentDragOverItem.id + "\n");
  1521.                 if (gCurrentDragOverItem.localName == 'multibar')
  1522.                 {
  1523.                     dropToolbar = gCurrentDragOverItem.firstChild;
  1524.                     // JMC - BORK! This will always drop to the first tray, not quite right I think
  1525.                 } else {
  1526.                     dropToolbar = gCurrentDragOverItem;
  1527.                 }
  1528.  
  1529.                 while (dropToolbar && dropToolbar.localName != "toolbar" &&
  1530.                     dropToolbar.localName != "multibartray")
  1531.                 {
  1532.                     dropToolbar = dropToolbar.parentNode;
  1533.                 }
  1534.                 if (!dropToolbar)
  1535.                     return;
  1536.  
  1537.                 dump ("dropping === Compare dropToolbar (" + dropToolbar.id + ") with toolbar (" + toolbar.id + ")\t\t");
  1538.  
  1539.                 // JMC: Searchbar container dropped onto multibar =
  1540.                 dump ("Dropping onto a : " + dropToolbar.localName + " called " + dropToolbar.getAttribute('toolbarname')  + "\n");
  1541.  
  1542.                 if (draggedItemId == 'search-container' &&
  1543.                     dropToolbar.localName != "toolbar")
  1544.                 {
  1545.                     if (dropToolbar.localName == 'multibartray')
  1546.                         dropToolbar = dropToolbar.parentNode;
  1547.                     dropToolbar.searchParent.appendChild(wrapper);
  1548.                     gToolboxChanged = true;
  1549.  
  1550.                     // dropToolbar.setAttribute("showsearch", "true");
  1551.                     // var customIndex = dropToolbar.getAttribute("customindex");
  1552.                     gToolbox.toolbarset.setAttribute("showsearch", dropToolbar.id);
  1553.                     gToolboxDocument.persist(gToolbox.toolbarset.id, "showsearch");
  1554.  
  1555.                     return true;
  1556.  
  1557.                     // TODO: Allow dragging search bar back to nav or other toolbars.
  1558.                 } else if (draggedItemId == 'search-container') { // dropped on a toolbar
  1559.                     gToolbox.toolbarset.removeAttribute("showsearch");
  1560.                     gToolboxDocument.persist(gToolbox.toolbarset.id, "showsearch");
  1561.                 }
  1562.  
  1563.  
  1564.                 // Insert the item into the toolbar.
  1565.                 if (gCurrentDragOverItem != dropToolbar) {
  1566.                     dump ("Finally! Inserting the wrapper " + wrapper.id + " before " + gCurrentDragOverItem.id + "\t\t\t");
  1567.                     
  1568.                     dropToolbar.insertBefore(wrapper, gCurrentDragOverItem);
  1569.                     gToolboxDocument.defaultView.XULBrowserWindow.init();
  1570.                  } else { 
  1571.                     dropToolbar.appendChild(wrapper);
  1572.                 }
  1573.             } else {
  1574.                 // The item has been dragged from the palette
  1575.  
  1576.                 // Create a new wrapper for the item. We don't know the id yet.
  1577.                 var wrapper = createWrapper("");
  1578.  
  1579.                 // Ask the toolbar to clone the item's template, place it inside the wrapper, and insert it in the toolbar.
  1580.                 dump("\n\n ++++++++ Inserting new item to toolbar from palette, item is " + draggedPaletteWrapper.id + ", inserting before " + gCurrentDragOverItem.id);
  1581.                 var newItem = toolbar.insertItem(draggedItemId, gCurrentDragOverItem == toolbar ? null : gCurrentDragOverItem, wrapper);
  1582.  
  1583.                 // Prepare the item and wrapper to look good on the toolbar.
  1584.                 cleanupItemForToolbar(newItem, wrapper);
  1585.                 wrapper.id = "wrapper-"+newItem.id;
  1586.                 wrapper.flex = newItem.flex;
  1587.  
  1588.                 // Remove the wrapper from the palette.
  1589.                 // JMC, *IF* it's non-duplicateable
  1590.                 var bCanDuplicate = newItem.getAttribute('allowDuplicate');
  1591.                 var currentRow = draggedPaletteWrapper.parentNode;
  1592.                 if (draggedItemId != "separator" &&
  1593.                     draggedItemId != "spring" &&
  1594.                     draggedItemId != "spacer" &&
  1595.                     !bCanDuplicate)
  1596.                 {
  1597.                     currentRow.removeChild(draggedPaletteWrapper);
  1598.  
  1599.                     while (currentRow) {
  1600.                         // Pull the first child of the next row up
  1601.                         // into this row.
  1602.                         var nextRow = currentRow.nextSibling;
  1603.  
  1604.                         if (!nextRow) {
  1605.                             var last = currentRow.lastChild;
  1606.                             var first = currentRow.firstChild;
  1607.                             if (!first) {
  1608.                                 // Kill the row.
  1609.                                 currentRow.parentNode.removeChild(currentRow);
  1610.                                 // currentRow = null;
  1611.                                 break;
  1612.                             }
  1613. /*
  1614.                             if (last.localName == "spacer") {
  1615.                                 var flex = last.getAttribute("flex");
  1616.                                 last.setAttribute("flex", ++flex);
  1617.                                 // Reflow doesn't happen for some reason.  Trigger it with a hide/show. ICK! -dwh
  1618.                                 last.hidden = true;
  1619.                                 last.hidden = false;
  1620.                                 break;
  1621.                             } else {
  1622.                                 // Make a spacer and give it a flex of 1.
  1623.                                 var spacer = document.createElementNS("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul",
  1624.                                 "spacer");
  1625.                                 spacer.setAttribute("flex", "1");
  1626.                                 currentRow.appendChild(spacer);
  1627.                             }
  1628.                             */
  1629.                         } else if (!nextRow.firstChild) {                            
  1630.                             currentRow.parentNode.removeChild(nextRow);
  1631.                             break;
  1632.                         }
  1633.                         if (nextRow) {
  1634.                             currentRow.appendChild(nextRow.firstChild);
  1635.                         }
  1636.                         currentRow = currentRow.nextSibling;
  1637.                     }
  1638.                 }
  1639.             }
  1640.  
  1641.             gCurrentDragOverItem = null;
  1642.  
  1643.             repositionDialog();
  1644.             gToolboxChanged = true;
  1645.         },
  1646.  
  1647.         _flavourSet: null,
  1648.  
  1649.         getSupportedFlavours: function ()
  1650.         {
  1651.             if (!this._flavourSet) {
  1652.                 this._flavourSet = new FlavourSet();
  1653.                 var documentId = gToolboxDocument.documentElement.id;
  1654.                 this._flavourSet.appendFlavour("text/toolbarwrapper-id/"+documentId);
  1655.             }
  1656.             return this._flavourSet;
  1657.         }
  1658.     }
  1659.  
  1660.     var paletteDNDObserver =
  1661.     {
  1662.         onDragOver: function (aEvent, aFlavour, aDragSession)
  1663.         {
  1664.             aDragSession.canDrop = true;
  1665.         },
  1666.  
  1667.         onDrop: function(aEvent, aXferData, aDragSession)
  1668.         {                             
  1669.             var itemId = aXferData.data;
  1670.             dump("\n TOOLBAR: Dropping a : " + itemId + "\n");
  1671.             var wrapper = gToolboxDocument.getElementById("wrapper-"+itemId);
  1672.             if (wrapper) {
  1673.                 // Don't allow static kids (e.g., the menubar) to move.
  1674.                 if (wrapper.parentNode.firstPermanentChild && wrapper.parentNode.firstPermanentChild.id == wrapper.firstChild.id)
  1675.                     return;
  1676.                 if (wrapper.parentNode.lastPermanentChild && wrapper.parentNode.lastPermanentChild.id == wrapper.firstChild.id)
  1677.                     return;
  1678.  
  1679.                 // Never remove searchbox
  1680.                 if (itemId == 'search-container')
  1681.                     return;
  1682.  
  1683.                 // The item was dragged out of the toolbar.
  1684.                 wrapper.parentNode.removeChild(wrapper);
  1685.  
  1686.                 var wrapperType = wrapper.getAttribute("type");
  1687.                 if (wrapperType != "separator" && wrapperType != "spacer" && wrapperType != "spring") {
  1688.                     // Find the template node in the toolbox palette
  1689.                     var templateNode = gToolbox.palette.firstChild;
  1690.                     while (templateNode) {
  1691.                         if (templateNode.id == itemId)
  1692.                             break;
  1693.                         templateNode = templateNode.nextSibling;
  1694.                     }
  1695.  
  1696.                     if (templateNode)
  1697.                     {
  1698.                         // Clone the template and add it to our palette.
  1699.                         var paletteItem = templateNode.cloneNode(true);
  1700.                         appendPaletteItem(paletteItem);
  1701.                         
  1702.                         var panelIndex = 0;
  1703.                         switch (templateNode.getAttribute("toolgroup")) {
  1704.                         case "functional":
  1705.                             panelIndex = 3;
  1706.                             break;
  1707.                         case "headline":
  1708.                             panelIndex = 1;
  1709.                             break;
  1710.                         case "personal":
  1711.                             panelIndex = 0;
  1712.                             break;
  1713.                         case "navigation":
  1714.                         default:
  1715.                             panelIndex = 2;
  1716.                             break;
  1717.                         }
  1718.                     } else {
  1719.                         // MERC (DP): SPUI items being dropped
  1720.                         
  1721.                         // we only want the wrapper ID
  1722.                         tmpArry = wrapper.id.split('|');
  1723.                         var wrapperID = tmpArry[0];
  1724.                         if(tmpArry.length > 1 && !isNaN(tmpArry[tmpArry.length-1]) && parseInt(tmpArry[tmpArry.length-1]) > 100000) {
  1725.                             var prefService = Components.classes["@mozilla.org/preferences-service;1"].getService(Components.interfaces.nsIPrefService);                                
  1726.                             prefService.getBranch("spui.").deleteBranch(tmpArry[tmpArry.length-1] + ".");
  1727.                         }
  1728.                         
  1729.                         var panelID = document.getElementById(wrapperID).parentNode.parentNode.parentNode.parentNode.id;
  1730.                         var panelIndex = 0;
  1731.                         switch(panelID) {
  1732.                         case 'headlinetab':
  1733.                             panelIndex = 1;
  1734.                             break;
  1735.                         case 'navigationaltab':
  1736.                             panelIndex = 2;
  1737.                             break;
  1738.                         case 'functionaltab':
  1739.                             panelIndex = 3;
  1740.                             break;
  1741.                         case 'personaltab':
  1742.                         default:
  1743.                             panelIndex = 0;
  1744.                             break;
  1745.                         }
  1746.                     }
  1747.                     // MERC (DP): focus the tab panel that the toolbar item belongs to
  1748.                     document.getElementById("palette-tab-box").selectedIndex = panelIndex;
  1749.                 } else {
  1750.                     // MERC (DP): if we are in this segment it means we have dragged one of the
  1751.                     // following items off the toolbar: separator, spacer, spring
  1752.                     
  1753.                     // focus the navigational panel
  1754.                     document.getElementById("palette-tab-box").selectedIndex = 2;
  1755.                 }
  1756.             }
  1757.  
  1758.             repositionDialog();
  1759.             gToolboxChanged = true;
  1760.         },
  1761.  
  1762.         _flavourSet: null,
  1763.  
  1764.         getSupportedFlavours: function ()
  1765.         {
  1766.             if (!this._flavourSet) {
  1767.                 this._flavourSet = new FlavourSet();
  1768.                 var documentId = gToolboxDocument.documentElement.id;
  1769.                 this._flavourSet.appendFlavour("text/toolbarwrapper-id/"+documentId);
  1770.             }
  1771.             return this._flavourSet;
  1772.         }
  1773.     }
  1774.  
  1775.     // Operates on currently selected Toolbar
  1776.  
  1777.     function moveToolbarUp() {
  1778.         gToolbox.moveToolbarUp(gSelectedToolbar);
  1779.         gToolboxChanged = true;
  1780.         populateTree();
  1781.  
  1782.         toolTree.view.selection.select(toolTree.contentView.getIndexOfItem(getTreeItem(gSelectedToolbar)));
  1783.         // toolTree.view.selection.select(1);
  1784.         // updateToolbarSelected();
  1785.     }
  1786.  
  1787.     function moveToolbarDown() {
  1788.         gToolbox.moveToolbarDown(gSelectedToolbar);
  1789.         gToolboxChanged = true;
  1790.         populateTree();
  1791.  
  1792.         toolTree.view.selection.select(toolTree.contentView.getIndexOfItem(getTreeItem(gSelectedToolbar)));
  1793.         // toolTree.view.selection.select(1);
  1794.         // updateToolbarSelected();
  1795.     }
  1796.  
  1797.     var treeDragObserver = {
  1798.         onDragStart: function (evt, transferData, action){
  1799.             var txt=evt.target.getAttribute("toolbarId");
  1800.             transferData.data=new TransferData();
  1801.             transferData.data.addDataForFlavour("text/unicode",txt);
  1802.         },
  1803.  
  1804.         getSupportedFlavours : function () {
  1805.             var flavours = new FlavourSet();
  1806.             flavours.appendFlavour("text/unicode");
  1807.             return flavours;
  1808.         },
  1809.         onDrop : function (evt, transferData, session) {
  1810.             event.target.setAttribute("value",transferData.data);
  1811.         },
  1812.         onDragOver: function (evt, transferData, session) {}
  1813.  
  1814.  
  1815.     }
  1816.  
  1817. // MERC (DP): confirm dialog for reset all button
  1818. function confirmRestoreDefaultSet()
  1819. {
  1820.   var prefService = Components.classes["@mozilla.org/preferences-service;1"]
  1821.                               .getService(Components.interfaces.nsIPrefBranch);
  1822.   if (!prefService.getBoolPref("custoolbar.restoredefault.suppressdialog")) {
  1823.     var promptService = Components.classes["@mozilla.org/embedcomp/prompt-service;1"]
  1824.                                   .getService(Components.interfaces.nsIPromptService);
  1825.  
  1826.     var checkResult = {};
  1827.     var result = promptService.confirmCheck(window,
  1828.                                          "Confirm Reset All",
  1829.                                          "Are you sure you wish to restore default toolbar settings?",
  1830.                                          "Don't show this message again",
  1831.                                          checkResult);
  1832.  
  1833.     if(checkResult.value) prefService.setBoolPref("custoolbar.restoredefault.suppressdialog", true);
  1834.  
  1835.     return result;
  1836.   }
  1837.   return true;
  1838. }