home *** CD-ROM | disk | FTP | other *** search
/ PC World 2003 May / PCWorld_2003-05_cd.bin / Komunik / phoenix / chrome / browser.jar / content / browser / bookmarks / addBookmark.js next >
Text File  |  2002-10-13  |  13KB  |  340 lines
  1. /* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
  2. /* ***** BEGIN LICENSE BLOCK *****
  3.  * Version: NPL 1.1/GPL 2.0/LGPL 2.1
  4.  *
  5.  * The contents of this file are subject to the Netscape Public License
  6.  * Version 1.1 (the "License"); you may not use this file except in
  7.  * compliance with the License. You may obtain a copy of the License at
  8.  * http://www.mozilla.org/NPL/
  9.  *
  10.  * Software distributed under the License is distributed on an "AS IS" basis,
  11.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12.  * for the specific language governing rights and limitations under the
  13.  * License.
  14.  *
  15.  * The Original Code is mozilla.org code.
  16.  *
  17.  * The Initial Developer of the Original Code is 
  18.  * Netscape Communications Corporation.
  19.  * Portions created by the Initial Developer are Copyright (C) 1998
  20.  * the Initial Developer. All Rights Reserved.
  21.  *
  22.  * Contributor(s):
  23.  *   Ben Goodger <ben@netscape.com> (Original Author)
  24.  *
  25.  * Alternatively, the contents of this file may be used under the terms of
  26.  * either the GNU General Public License Version 2 or later (the "GPL"), or 
  27.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28.  * in which case the provisions of the GPL or the LGPL are applicable instead
  29.  * of those above. If you wish to allow use of your version of this file only
  30.  * under the terms of either the GPL or the LGPL, and not to allow others to
  31.  * use your version of this file under the terms of the NPL, indicate your
  32.  * decision by deleting the provisions above and replace them with the notice
  33.  * and other provisions required by the GPL or the LGPL. If you do not delete
  34.  * the provisions above, a recipient may use your version of this file under
  35.  * the terms of any one of the NPL, the GPL or the LGPL.
  36.  *
  37.  * ***** END LICENSE BLOCK ***** */
  38.  
  39. /**
  40.  * Add Bookmark Dialog. 
  41.  * ====================
  42.  * 
  43.  * This is a generic bookmark dialog that allows for bookmark addition
  44.  * and folder selection. It can be opened with various parameters that 
  45.  * result in appearance/purpose differences and initial state. 
  46.  * 
  47.  * Use: Open with 'openDialog', with the flags 
  48.  *        'centerscreen,chrome,dialog=no,resizable=yes'
  49.  * 
  50.  * Parameters: 
  51.  *   Apart from the standard openDialog parameters, this dialog can 
  52.  *   be passed additional information, which gets mapped to the 
  53.  *   window.arguments array:
  54.  * 
  55.  *   window.arguments[0]: Bookmark Name. The value to be prefilled
  56.  *                        into the "Name: " field (if visible).
  57.  *   window.arguments[1]: Bookmark URL: The location of the bookmark.
  58.  *                        The value to be filled in the "Location: "
  59.  *                        field (if visible).
  60.  *   window.arguments[2]: Bookmark Folder. The RDF Resource URI of the
  61.  *                        folder that this bookmark should be created in.
  62.  *   window.arguments[3]: Bookmark Charset. The charset that should be
  63.  *                        used when adding a bookmark to the specified
  64.  *                        URL. (Usually the charset of the current 
  65.  *                        document when launching this window). 
  66.  *   window.arguments[4]: The mode of operation. See notes for details.
  67.  *   window.arguments[5]: If the mode is "addGroup", this is an array
  68.  *                        of objects with name, URL and charset
  69.  *                        properties, one for each group member.
  70.  *
  71.  * Mode of Operation Notes:
  72.  * ------------------------
  73.  * This dialog can be opened in four different ways by using a parameter
  74.  * passed through the call to openDialog. The 'mode' of operation
  75.  * of the window is expressed in window.arguments[4]. The valid modes are:
  76.  *
  77.  * 1) <default> (no fifth open parameter).
  78.  *      Opens this dialog with the bookmark Name, URL and folder selection
  79.  *      components visible. 
  80.  * 2) "newBookmark" (fifth open parameter = String("newBookmark"))
  81.  *      Opens the dialog as in (1) above except the folder selection tree
  82.  *      is hidden. This type of mode is useful when the creation folder 
  83.  *      is pre-determined.
  84.  * 3) "selectFolder" (fifth open parameter = String("selectFolder"))
  85.  *      Opens the dialog as in (1) above except the Name/Location section
  86.  *      is hidden, and the dialog takes on the utility of a Folder chooser.
  87.  *      Used when the user must select a Folder for some purpose. 
  88.  * 4) "addGroup" (fifth open parameter = String("addGroup"))
  89.  *      Opens the dialog like <default>, with a checkbox to select between
  90.  *      filing a single bookmark or a group. For the single bookmark the
  91.  *      values are taken from the name, URL and charset arguments.
  92.  *      For the group, the values are taken from the sixth argument.
  93.  *      This parameter can also be String("addGroup,group") where "group"
  94.  *      specifies that the dialog starts in filing as a group.
  95.  */
  96.  
  97. var gFld_Name   = null;
  98. var gFld_URL    = null; 
  99. var gFolderTree = null;
  100. var gCB_AddGroup = null;
  101.  
  102. var gBookmarkCharset = null;
  103.  
  104. var gSelectItemObserver = null;
  105.  
  106. var gCreateInFolder = "NC:NewBookmarkFolder";
  107.  
  108. function Startup()
  109. {
  110.   initServices();
  111.   initBMService();
  112.   gFld_Name = document.getElementById("name");
  113.   gFld_URL = document.getElementById("url");
  114.   gCB_AddGroup = document.getElementById("addgroup");
  115.   var bookmarkView = document.getElementById("bookmarks-view");
  116.  
  117.   var shouldSetOKButton = true;
  118.   var dialogElement = document.documentElement;
  119.   if ("arguments" in window) {
  120.     var ind;
  121.     var folderItem = null;
  122.     var arg;
  123.     if (window.arguments.length < 5)
  124.       arg = null;
  125.     else
  126.       arg = window.arguments[4];
  127.     switch (arg) {
  128.     case "selectFolder":
  129.       // If we're being opened as a folder selection window
  130.       document.getElementById("bookmarknamegrid").setAttribute("hidden", "true");
  131.       document.getElementById("createinseparator").setAttribute("hidden", "true");
  132.       document.getElementById("nameseparator").setAttribute("hidden", "true");
  133.       sizeToContent();
  134.       dialogElement.setAttribute("title", dialogElement.getAttribute("title-selectFolder"));
  135.       shouldSetOKButton = false;
  136.       if (window.arguments[2])
  137.         folderItem = RDF.GetResource(window.arguments[2]);
  138.       if (folderItem) {
  139.         ind = bookmarkView.treeBuilder.getIndexOfResource(folderItem);
  140.         bookmarkView.treeBoxObject.selection.select(ind);
  141.       }
  142.       break;
  143.     case "newBookmark":
  144.       setupFields();
  145.       if (window.arguments[2])
  146.         gCreateInFolder = window.arguments[2];
  147.       document.getElementById("folderbox").setAttribute("hidden", "true");
  148.       sizeToFit();
  149.       break;
  150.     case "addGroup":
  151.       document.getElementById("showaddgroup").setAttribute("hidden", "false");
  152.       setupFields();
  153.       sizeToFit();
  154.       break;
  155.     case "addGroup,group":
  156.       document.getElementById("showaddgroup").setAttribute("hidden", "false");
  157.       gCB_AddGroup.setAttribute("checked", "true");
  158.       setupFields();
  159.       toggleGroup();
  160.       sizeToFit();
  161.       break;
  162.     default:
  163.       // Regular Add Bookmark
  164.       setupFields();
  165.       if (window.arguments[2]) {
  166.         gCreateInFolder = window.arguments[2];
  167.         folderItem = bookmarkView.rdf.GetResource(gCreateInFolder);
  168.         if (folderItem) {
  169.           ind = bookmarkView.treeBuilder.getIndexOfResource(folderItem);
  170.           bookmarkView.treeBoxObject.selection.select(ind);
  171.         }
  172.       }
  173.     }
  174.   }
  175.   
  176.   if (shouldSetOKButton)
  177.     onFieldInput();
  178.   if (document.getElementById("bookmarknamegrid").hasAttribute("hidden")) {
  179.     bookmarkView.tree.focus();
  180.     if (bookmarkView.currentIndex == -1)
  181.       bookmarkView.treeBoxObject.selection.select(0);
  182.   }
  183.   else {
  184.     gFld_Name.select();
  185.     gFld_Name.focus();
  186.   }
  187. } 
  188.  
  189. function sizeToFit()
  190. {
  191.   var dialogElement = document.documentElement;
  192.   dialogElement.removeAttribute("persist");
  193.   dialogElement.removeAttribute("height");
  194.   dialogElement.removeAttribute("width");
  195.   dialogElement.setAttribute("style", dialogElement.getAttribute("style"));
  196.   sizeToContent();
  197. }
  198.  
  199. function setupFields()
  200. {
  201.   // New bookmark in predetermined folder. 
  202.   gFld_Name.value = window.arguments[0] || "";
  203.   gFld_URL.value = window.arguments[1] || "";
  204.   onFieldInput();
  205.   gFld_Name.select();
  206.   gFld_Name.focus();
  207.   gBookmarkCharset = window.arguments[3] || null;
  208. }
  209.  
  210. function onFieldInput()
  211. {
  212.   const ok = document.documentElement.getButton("accept");
  213.   ok.disabled = gFld_URL.value == "" && !addingGroup() ||
  214.                 gFld_Name.value == "";
  215. }    
  216.  
  217. function onOK()
  218. {
  219.   if (!document.getElementById("folderbox").hasAttribute("hidden")) {
  220.     var bookmarkView = document.getElementById("bookmarks-view");
  221.     var currentIndex = bookmarkView.currentIndex;
  222.     if (currentIndex != -1)
  223.       gCreateInFolder = bookmarkView.treeBuilder.getResourceAtIndex(currentIndex).Value;
  224.   }
  225.   // In Select Folder Mode, do nothing but tell our caller what
  226.   // folder was selected. 
  227.   if (window.arguments.length > 4 && window.arguments[4] == "selectFolder")
  228.     window.arguments[5].selectedFolder = gCreateInFolder;
  229.   else {
  230.     // Otherwise add a bookmark to the selected folder. 
  231.     var rFolder = RDF.GetResource(gCreateInFolder);
  232.     try {
  233.       RDFC.Init(BMDS, rFolder);
  234.     }
  235.     catch (e) {
  236.       // No "NC:NewBookmarkFolder" exists, just append to the root.
  237.       rFolder = RDF.GetResource("NC:BookmarksRoot");
  238.       RDFC.Init(BMDS, rFolder);
  239.     }
  240.  
  241.     // if no URL was provided and we're not filing as a group, do nothing
  242.     if (!gFld_URL.value && !addingGroup())
  243.       return;
  244.  
  245.     var url, rSource;
  246.     if (addingGroup()) {
  247.       rSource = BMDS.createFolder(gFld_Name.value);
  248.       const groups  = window.arguments[5];
  249.       for (var i = 0; i < groups.length; ++i) {
  250.         url = getNormalizedURL(groups[i].url);
  251.         BMDS.createBookmarkInContainer(groups[i].name, url,
  252.                                        groups[i].charset, rSource, -1);
  253.       }
  254.     } else {
  255.       url = getNormalizedURL(gFld_URL.value);
  256.       rSource = BMDS.createBookmark(gFld_Name.value, url, gBookmarkCharset);
  257.       if (window.arguments.length > 4 && window.arguments[4] == "newBookmark") {
  258.         window.arguments[5].newBookmark = rSource;
  259.       }
  260.     }
  261.     var selection, target;
  262.     selection = BookmarksUtils.getSelectionFromResource(rSource);
  263.     target    = BookmarksUtils.getSelectionFromResource(rFolder);
  264.     target    = BookmarksUtils.getTargetFromSelection(target);
  265.     BookmarksUtils.insertSelection("newbookmark", selection, target);
  266.   }
  267. }
  268.  
  269. function getNormalizedURL(url)
  270. {
  271.   // Check to see if the item is a local directory path, and if so, convert
  272.   // to a file URL so that aggregation with rdf:files works
  273.   try {
  274.     const kLF = Components.classes["@mozilla.org/file/local;1"]
  275.                           .createInstance(Components.interfaces.nsILocalFile);
  276.     kLF.initWithPath(url);
  277.     if (kLF.exists()) {
  278.       var ioService = Components.classes["@mozilla.org/network/io-service;1"]
  279.                                 .getService(Components.interfaces.nsIIOService);
  280.       var fileHandler = ioService.getProtocolHandler("file")
  281.                                  .QueryInterface(Components.interfaces.nsIFileProtocolHandler);
  282.  
  283.       url = fileHandler.getURLSpecFromFile(kLF);
  284.     }
  285.   }
  286.   catch (e) {
  287.   }
  288.  
  289.   return url;
  290. }
  291.  
  292. function createNewFolder ()
  293. {
  294.   var bookmarksView = document.getElementById("bookmarks-view");
  295.   var selection = bookmarksView.getTreeSelection();
  296.   var target    = BookmarksUtils.getTargetFromSelection(selection)
  297.   BookmarksCommand.createNewFolder(target);
  298. }
  299.  
  300. function useDefaultFolder ()
  301. {
  302.   var bookmarkView = document.getElementById("bookmarks-view");
  303.   var folder = BookmarksUtils.getNewBookmarkFolder();
  304.   var ind = bookmarkView.treeBuilder.getIndexOfResource(folder);
  305.   if (ind != -1) {
  306.     bookmarkView.tree.focus();
  307.     bookmarkView.treeBoxObject.selection.select(ind);
  308.   } else {
  309.     bookmarkView.treeBoxObject.selection.clearSelection();
  310.   }
  311.   gCreateInFolder = folder.Value;
  312. }
  313.  
  314. var gOldNameValue = "";
  315. var gOldURLValue = "";
  316.  
  317. function toggleGroup()
  318. {
  319.   // swap between single bookmark and group name
  320.   var temp = gOldNameValue;
  321.   gOldNameValue = gFld_Name.value;
  322.   gFld_Name.value = temp;
  323.  
  324.   // swap between single bookmark and group url
  325.   temp = gOldURLValue;
  326.   gOldURLValue = gFld_URL.value;
  327.   gFld_URL.value = temp;
  328.   gFld_URL.disabled = gCB_AddGroup.getAttribute("checked") == "true";
  329.  
  330.   gFld_Name.select();
  331.   gFld_Name.focus();
  332.   onFieldInput();
  333. }
  334.  
  335. function addingGroup()
  336. {
  337.   const showAddGroup = document.getElementById("showaddgroup");
  338.   return showAddGroup.getAttribute("hidden") != "true" && gCB_AddGroup.getAttribute("checked") == "true";
  339. }
  340.