home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2005 October / Gamestar_77_2005-10_dvd.iso / Programy / nsb-install-8-0.exe / chrome / browser.jar / content / browser / bookmarks / addBookmark.js next >
Encoding:
Text File  |  2005-07-29  |  12.7 KB  |  339 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.  *   window.arguments[6]: If the bookmark should become a web panel.
  71.  *
  72.  * Mode of Operation Notes:
  73.  * ------------------------
  74.  * This dialog can be opened in four different ways by using a parameter
  75.  * passed through the call to openDialog. The 'mode' of operation
  76.  * of the window is expressed in window.arguments[4]. The valid modes are:
  77.  *
  78.  * 1) <default> (no fifth open parameter).
  79.  *      Opens this dialog with the bookmark Name, URL and folder selection
  80.  *      components visible. 
  81.  * 2) "newBookmark" (fifth open parameter = String("newBookmark"))
  82.  *      Opens the dialog as in (1) above except the folder selection tree
  83.  *      is hidden. This type of mode is useful when the creation folder 
  84.  *      is pre-determined.
  85.  * 3) "selectFolder" (fifth open parameter = String("selectFolder"))
  86.  *      Opens the dialog as in (1) above except the Name/Location section
  87.  *      is hidden, and the dialog takes on the utility of a Folder chooser.
  88.  *      Used when the user must select a Folder for some purpose. 
  89.  * 4) "addGroup" (fifth open parameter = String("addGroup"))
  90.  *      Opens the dialog like <default>, with a checkbox to select between
  91.  *      filing a single bookmark or a group. For the single bookmark the
  92.  *      values are taken from the name, URL and charset arguments.
  93.  *      For the group, the values are taken from the sixth argument.
  94.  *      This parameter can also be String("addGroup,group") where "group"
  95.  *      specifies that the dialog starts in filing as a group.
  96.  */
  97.  
  98. var gFld_Name   = null;
  99. var gFld_URL    = null; 
  100. var gFolderTree = null;
  101. var gCB_AddGroup = null;
  102.  
  103. var gBookmarkCharset = null;
  104.  
  105. var gSelectItemObserver = null;
  106.  
  107. var gCreateInFolder = "NC:NewBookmarkFolder";
  108.  
  109. function Startup()
  110. {
  111.   initServices();
  112.   initBMService();
  113.   gFld_Name = document.getElementById("name");
  114.   gFld_URL = document.getElementById("url");
  115.   gCB_AddGroup = document.getElementById("addgroup");
  116.   var bookmarkView = document.getElementById("bookmarks-view");
  117.  
  118.   var shouldSetOKButton = true;
  119.   var dialogElement = document.documentElement;
  120.   if ("arguments" in window) {
  121.     var ind;
  122.     var folderItem = null;
  123.     var arg;
  124.     if (window.arguments.length < 5)
  125.       arg = null;
  126.     else
  127.       arg = window.arguments[4];
  128.     switch (arg) {
  129.     case "selectFolder":
  130.       // If we're being opened as a folder selection window
  131.       document.getElementById("bookmarknamegrid").setAttribute("hidden", "true");
  132.       document.getElementById("createinseparator").setAttribute("hidden", "true");
  133.       document.getElementById("nameseparator").setAttribute("hidden", "true");
  134.       sizeToContent();
  135.       dialogElement.setAttribute("title", dialogElement.getAttribute("title-selectFolder"));
  136.       shouldSetOKButton = false;
  137.       if (window.arguments[2])
  138.         folderItem = RDF.GetResource(window.arguments[2]);
  139.       if (folderItem) {
  140.         ind = bookmarkView.treeBuilder.getIndexOfResource(folderItem);
  141.         bookmarkView.treeBoxObject.selection.select(ind);
  142.       }
  143.       break;
  144.     case "newBookmark":
  145.       setupFields();
  146.       if (window.arguments[2])
  147.         gCreateInFolder = window.arguments[2];
  148.       document.getElementById("folderbox").setAttribute("hidden", "true");
  149.       sizeToFit();
  150.       break;
  151.     case "addGroup":
  152.       document.getElementById("showaddgroup").setAttribute("hidden", "false");
  153.       setupFields();
  154.       sizeToFit();
  155.       break;
  156.     case "addGroup,group":
  157.       document.getElementById("showaddgroup").setAttribute("hidden", "false");
  158.       gCB_AddGroup.setAttribute("checked", "true");
  159.       setupFields();
  160.       toggleGroup();
  161.       sizeToFit();
  162.       break;
  163.     default:
  164.       // Regular Add Bookmark
  165.       setupFields();
  166.       if (window.arguments[2]) {
  167.         gCreateInFolder = window.arguments[2];
  168.         folderItem = bookmarkView.rdf.GetResource(gCreateInFolder);
  169.         if (folderItem) {
  170.           ind = bookmarkView.treeBuilder.getIndexOfResource(folderItem);
  171.           bookmarkView.treeBoxObject.selection.select(ind);
  172.         }
  173.       }
  174.     }
  175.   }
  176.   
  177.   if (shouldSetOKButton)
  178.     onFieldInput();
  179.   if (document.getElementById("bookmarknamegrid").hasAttribute("hidden")) {
  180.     bookmarkView.tree.focus();
  181.     if (bookmarkView.currentIndex == -1)
  182.       bookmarkView.treeBoxObject.selection.select(0);
  183.   }
  184.   else {
  185.     gFld_Name.select();
  186.     gFld_Name.focus();
  187.   }
  188. } 
  189.  
  190. function sizeToFit()
  191. {
  192.   var dialogElement = document.documentElement;
  193.   dialogElement.removeAttribute("persist");
  194.   dialogElement.removeAttribute("height");
  195.   dialogElement.removeAttribute("width");
  196.   dialogElement.setAttribute("style", dialogElement.getAttribute("style"));
  197.   sizeToContent();
  198. }
  199.  
  200. function setupFields()
  201. {
  202.   // New bookmark in predetermined folder. 
  203.   gFld_Name.value = window.arguments[0] || "";
  204.   gFld_URL.value = window.arguments[1] || "";
  205.   onFieldInput();
  206.   gFld_Name.select();
  207.   gFld_Name.focus();
  208.   gBookmarkCharset = window.arguments[3] || null;
  209. }
  210.  
  211. function onFieldInput()
  212. {
  213.   const ok = document.documentElement.getButton("accept");
  214.   ok.disabled = gFld_URL.value == "" && !addingGroup() ||
  215.                 gFld_Name.value == "";
  216. }    
  217.  
  218. function onOK()
  219. {
  220.   if (!document.getElementById("folderbox").hasAttribute("hidden")) {
  221.     var bookmarkView = document.getElementById("bookmarks-view");
  222.     var currentIndex = bookmarkView.currentIndex;
  223.     if (currentIndex != -1)
  224.       gCreateInFolder = bookmarkView.treeBuilder.getResourceAtIndex(currentIndex).Value;
  225.   }
  226.   // In Select Folder Mode, do nothing but tell our caller what
  227.   // folder was selected. 
  228.   if (window.arguments.length > 4 && window.arguments[4] == "selectFolder")
  229.     window.arguments[5].target = BookmarksUtils.getTargetFromFolder(bookmarkView.treeBuilder.getResourceAtIndex(currentIndex));
  230.   else {
  231.     // Otherwise add a bookmark to the selected folder. 
  232.     var rFolder = RDF.GetResource(gCreateInFolder);
  233.     try {
  234.       RDFC.Init(BMDS, rFolder);
  235.     }
  236.     catch (e) {
  237.       // No "NC:NewBookmarkFolder" exists, just append to the root.
  238.       rFolder = RDF.GetResource("NC:BookmarksRoot");
  239.       RDFC.Init(BMDS, rFolder);
  240.     }
  241.  
  242.     // if no URL was provided and we're not filing as a group, do nothing
  243.     if (!gFld_URL.value && !addingGroup())
  244.       return;
  245.  
  246.     var url, rSource;
  247.     if (addingGroup()) {
  248.       rSource = BMDS.createFolder(gFld_Name.value);
  249.       const groups  = window.arguments[5];
  250.       for (var i = 0; i < groups.length; ++i) {
  251.         url = getNormalizedURL(groups[i].url);
  252.         BMDS.createBookmarkInContainer(groups[i].name, url, null, null,
  253.                                        groups[i].charset, null, rSource, -1);
  254.       }
  255.     } else {
  256.       url = getNormalizedURL(gFld_URL.value);
  257.       rSource = BMDS.createBookmark(gFld_Name.value, url, null, null, gBookmarkCharset, false, "");
  258.       if (window.arguments.length > 4 && window.arguments[4] == "newBookmark") {
  259.         window.arguments[5].newBookmark = rSource;
  260.       }
  261.     }
  262.     var selection = BookmarksUtils.getSelectionFromResource(rSource);
  263.     var target    = BookmarksUtils.getTargetFromFolder(rFolder);
  264.     BookmarksUtils.insertAndCheckSelection("newbookmark", selection, target);
  265.   }
  266. }
  267.  
  268. function getNormalizedURL(url)
  269. {
  270.   // Check to see if the item is a local directory path, and if so, convert
  271.   // to a file URL so that aggregation with rdf:files works
  272.   try {
  273.     const kLF = Components.classes["@mozilla.org/file/local;1"]
  274.                           .createInstance(Components.interfaces.nsILocalFile);
  275.     kLF.initWithPath(url);
  276.     if (kLF.exists()) {
  277.       var ioService = Components.classes["@mozilla.org/network/io-service;1"]
  278.                                 .getService(Components.interfaces.nsIIOService);
  279.       var fileHandler = ioService.getProtocolHandler("file")
  280.                                  .QueryInterface(Components.interfaces.nsIFileProtocolHandler);
  281.  
  282.       url = fileHandler.getURLSpecFromFile(kLF);
  283.     }
  284.   }
  285.   catch (e) {
  286.   }
  287.  
  288.   return url;
  289. }
  290.  
  291. function createNewFolder ()
  292. {
  293.   var bookmarksView = document.getElementById("bookmarks-view");
  294.   var resource = bookmarksView.treeBuilder.getResourceAtIndex(bookmarksView.currentIndex);
  295.   var target = BookmarksUtils.getTargetFromFolder(resource);
  296.   BookmarksCommand.createNewFolder(target);
  297. }
  298.  
  299. function useDefaultFolder ()
  300. {
  301.   var bookmarkView = document.getElementById("bookmarks-view");
  302.   var folder = BookmarksUtils.getNewBookmarkFolder();
  303.   var ind = bookmarkView.treeBuilder.getIndexOfResource(folder);
  304.   if (ind != -1) {
  305.     bookmarkView.tree.focus();
  306.     bookmarkView.treeBoxObject.selection.select(ind);
  307.   } else {
  308.     bookmarkView.treeBoxObject.selection.clearSelection();
  309.   }
  310.   gCreateInFolder = folder.Value;
  311. }
  312.  
  313. var gOldNameValue = "";
  314. var gOldURLValue = "";
  315.  
  316. function toggleGroup()
  317. {
  318.   // swap between single bookmark and group name
  319.   var temp = gOldNameValue;
  320.   gOldNameValue = gFld_Name.value;
  321.   gFld_Name.value = temp;
  322.  
  323.   // swap between single bookmark and group url
  324.   temp = gOldURLValue;
  325.   gOldURLValue = gFld_URL.value;
  326.   gFld_URL.value = temp;
  327.   gFld_URL.disabled = gCB_AddGroup.getAttribute("checked") == "true";
  328.  
  329.   gFld_Name.select();
  330.   gFld_Name.focus();
  331.   onFieldInput();
  332. }
  333.  
  334. function addingGroup()
  335. {
  336.   const showAddGroup = document.getElementById("showaddgroup");
  337.   return showAddGroup.getAttribute("hidden") != "true" && gCB_AddGroup.getAttribute("checked") == "true";
  338. }
  339.