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