home *** CD-ROM | disk | FTP | other *** search
/ PC World 2008 February / PCWorld_2008-02_cd.bin / temacd / songbird / Songbird_0.4_windows-i686.exe / components / sbBookmarksService.js < prev    next >
Text File  |  2007-12-21  |  22KB  |  685 lines
  1. /** vim: ts=2 sw=2 expandtab
  2. //
  3. // BEGIN SONGBIRD GPL
  4. //
  5. // This file is part of the Songbird web player.
  6. //
  7. // Copyright(c) 2005-2008 POTI, Inc.
  8. // http://songbirdnest.com
  9. //
  10. // This file may be licensed under the terms of of the
  11. // GNU General Public License Version 2 (the "GPL").
  12. //
  13. // Software distributed under the License is distributed
  14. // on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either
  15. // express or implied. See the GPL for the specific language
  16. // governing rights and limitations.
  17. //
  18. // You should have received a copy of the GPL along with this
  19. // program. If not, go to http://www.gnu.org/licenses/gpl.html
  20. // or write to the Free Software Foundation, Inc.,
  21. // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  22. //
  23. // END SONGBIRD GPL
  24. //
  25.  */
  26.  
  27. /**
  28.  * \file sbBookmarks.js
  29.  * \brief the service pane service manages the tree behind the service pane.
  30.  * It provides an interface for creating bookmark nodes in the service pane tree.
  31.  *
  32.  * TODO:
  33.  *  - move downloading to nsIChannel and friends for better chrome-proofing
  34.  *  - send version and locale info when requesting new bookmarks
  35.  *  - handle errors more elegantly in bookmarks downloading
  36.  *  - handle the adding of bookmarks before the defaults are downloaded
  37.  *  - allow the server bookmarks list to remove stale entries [bug 2352]
  38.  * PERHAPS:
  39.  *  - move default bookmarks downloading to after first-run so we can have
  40.  *  per-locale bookmarks?
  41.  *  - download and cache images
  42.  *  - add a confirmation dialog for for bookmark deletion
  43.  *  
  44.  */
  45.  
  46. const Cc = Components.classes;
  47. const Ci = Components.interfaces;
  48. const Cr = Components.results;
  49. const Cu = Components.utils;
  50.  
  51. const CONTRACTID = "@songbirdnest.com/servicepane/bookmarks;1"
  52. const ROOTNODE = "SB:Bookmarks"
  53. const BOOKMARK_DRAG_TYPE = 'text/x-sb-bookmark';
  54. const MOZ_URL_DRAG_TYPE = 'text/x-moz-url';
  55. const BSP = 'http://songbirdnest.com/rdf/bookmarks#';
  56. const SP='http://songbirdnest.com/rdf/servicepane#';
  57.  
  58. function SB_NewDataRemote(a,b) {
  59.   return (new Components.Constructor("@songbirdnest.com/Songbird/DataRemote;1",
  60.                     "sbIDataRemote", "init"))(a,b);
  61. }
  62.  
  63. function sbBookmarks() {
  64.   this._servicePane = null;
  65.   this._stringBundle = null;
  66.   
  67.   // use the default stringbundle to translate tree nodes
  68.   this.stringbundle = null;
  69.  
  70.   this._importAttempts = 5;
  71.   this._importTimer = null;
  72. }
  73. sbBookmarks.prototype.QueryInterface = 
  74. function sbBookmarks_QueryInterface(iid) {
  75.   if (!iid.equals(Ci.nsISupports) &&
  76.     !iid.equals(Ci.sbIBookmarks) &&
  77.     !iid.equals(Ci.sbIServicePaneModule)) {
  78.     throw Cr.NS_ERROR_NO_INTERFACE;
  79.   }
  80.   return this;
  81. }
  82. sbBookmarks.prototype.servicePaneInit = 
  83. function sbBookmarks_servicePaneInit(sps) {
  84.   this._servicePane = sps;
  85.   
  86.   // if we don't have a bookmarks node, lets create one
  87.   this._bookmarkNode = this._servicePane.getNode(ROOTNODE);
  88.   if (!this._bookmarkNode) {
  89.     // create bookmarks folder
  90.     this._bookmarkNode = this.addFolderAt('SB:Bookmarks',
  91.         '&servicesource.bookmarks', null, sps.root, null);
  92.   }
  93.  
  94.   // set the weight of the bookmarks node
  95.   this._bookmarkNode.setAttributeNS(SP, 'Weight', 4);
  96.     
  97.   // if the bookmark node doesn't have the Imported attribute set, lets do an import
  98.   if (this._bookmarkNode.getAttributeNS(BSP, 'Imported') != 'true') {
  99.     // run the importer
  100.     this.importBookmarks();
  101.   }
  102.  
  103.   var sbSvc = Cc["@mozilla.org/intl/stringbundle;1"].getService(Ci.nsIStringBundleService);
  104.   this._stringBundle = sbSvc.createBundle("chrome://songbird/locale/songbird.properties");
  105. }
  106.  
  107. sbBookmarks.prototype.scheduleImportBookmarks =
  108. function sbBookmarks_scheduleImportBookmarks() {
  109.   this._importTimer = Cc['@mozilla.org/timer;1'].createInstance(Ci.nsITimer);
  110.   this._importTimer.init(this, 5000, Ci.nsITimer.TYPE_ONE_SHOT);
  111. }
  112.  
  113. sbBookmarks.prototype.observe = 
  114. function sbBookmarks_observe(subject, topic, data) {
  115.   if (topic == 'timer-callback' && subject == this._importTimer) {
  116.     // the bookmarks import timer
  117.     this._importTimer = null;
  118.     if (!this._servicePane) {
  119.       // hmm, we're shutting down, no need to import now
  120.       return;
  121.     }
  122.     this.importBookmarks();
  123.   }
  124. }
  125.  
  126. sbBookmarks.prototype.importBookmarks =
  127. function sbBookmarks_importBookmarks() {
  128.   var prefsService =
  129.       Cc["@mozilla.org/preferences-service;1"].
  130.       getService(Ci.nsIPrefBranch);
  131.   var bookmarksURL = prefsService.getCharPref("songbird.url.bookmarks");
  132.   
  133.   // fetch the default set of bookmarks through a series of tubes
  134.   // FIXME: don't use XHR - use nsIChannel and friends
  135.   // FIXME: send parameters and/or headers to indicate product version or something
  136.   var xhr = Cc["@mozilla.org/xmlextras/xmlhttprequest;1"]
  137.       .createInstance(Ci.nsIDOMEventTarget);
  138.   var sps = this._servicePane;
  139.   var service = this;
  140.   function importError() {
  141.     service._importAttempts--;
  142.     if (service._importAttempts < 0) {
  143.       // we tried, but it's time to give up till the next time the player starts
  144.       // but first, let's create some default bookmarks to get us through
  145.       var default_bookmarks = [
  146.         {name:'Add-ons', url:'http://addons.songbirdnest.com/'},
  147.         {name:'Directory', url:'http://birdhouse.songbirdnest.com/directory'}];
  148.       for (var i=0; i<default_bookmarks.length; i++) {
  149.         var bm = default_bookmarks[i];
  150.         var bnode = sps.getNode(bm.url);
  151.         if (!bnode) {
  152.           service.addBookmarkAt(bm.url, bm.name, 
  153.             'chrome://songbird-branding/skin/logo_16.png', 
  154.             service._bookmarkNode, null);
  155.         }
  156.       }
  157.       
  158.       return;
  159.     }
  160.     service.scheduleImportBookmarks();
  161.   }
  162.   xhr.addEventListener('load', function(evt) {
  163.     var root = null;
  164.     try {
  165.       // a non-XML page will cause an exception here.
  166.       root = xhr.responseXML.documentElement;
  167.     } catch (e) {
  168.       // catch it and try again
  169.       importError();
  170.       return;
  171.     }
  172.     var folders = root.getElementsByTagName('folder');
  173.     for (var f=0; folders && f<folders.length; f++) {
  174.       var folder = folders[f];
  175.       if (!folder.hasAttribute('id') ||
  176.           !folder.hasAttribute('name')) {
  177.         // the folder is missing required attributes, we must ignore it
  178.         continue;
  179.       }
  180.  
  181.       var fnode = sps.getNode(folder.getAttribute('id'));
  182.       
  183.       if (!fnode) {
  184.         // if the folder doesn't exist, create it
  185.         fnode = service.addFolderAt(folder.getAttribute('id'),
  186.             folder.getAttribute('name'), folder.getAttribute('image'),
  187.             sps.root, null);
  188.       }
  189.       
  190.       fnode.isOpen = (folder.getAttribute('open') == 'true');
  191.       
  192.       if (fnode && fnode.getAttributeNS(BSP, 'Imported')) {
  193.         // don't reimport a folder that's already been imported
  194.         continue;
  195.       }
  196.       
  197.       if (fnode.id == ROOTNODE) {
  198.         // we just created the default bookmarks root
  199.         // we'll need that later if we want to let the user create
  200.         // their own bookmarks
  201.         service._bookmarkNode = fnode;
  202.       }
  203.       
  204.       // now, let's create what goes in
  205.       var bookmarks = folder.getElementsByTagName('bookmark');
  206.       for (var b=0; bookmarks && b<bookmarks.length; b++) {
  207.         var bookmark = bookmarks[b];
  208.         if (!bookmark.hasAttribute('url') ||
  209.             !bookmark.hasAttribute('name')) {
  210.           // missing required attributes
  211.           continue;
  212.         }
  213.         // If the bookmark already exists, then it's somewhere else
  214.         // in the tree and we should leave it there untouched.
  215.         // Except that it should be marked as imported now...
  216.         var bnode = sps.getNode(bookmark.getAttribute('url'));
  217.         if (!bnode) {
  218.           // create the bookmark
  219.           bnode = service.addBookmarkAt(bookmark.getAttribute('url'),
  220.               bookmark.getAttribute('name'), bookmark.getAttribute('image'),
  221.               fnode, null);
  222.         }
  223.         // remember we imported it.
  224.         bnode.setAttributeNS(BSP, 'Imported', 'true');
  225.       }
  226.       
  227.       fnode.setAttributeNS(BSP, 'Imported', 'true');
  228.     }
  229.     
  230.     // try to import json bookmarks from 0.2.5
  231.     try {
  232.       service.migrateLegacyBookmarks();
  233.     } catch (e) {
  234.     }
  235.  
  236.   }, false);
  237.   xhr.addEventListener('error', function(evt) {
  238.     importError();
  239.   }, false);
  240.   xhr.QueryInterface(Ci.nsIXMLHttpRequest);
  241.   xhr.open('GET', bookmarksURL, true);
  242.   xhr.send(null);
  243. }
  244.  
  245. sbBookmarks.prototype.shutdown = 
  246. function sbBookmarks_shutdown() {
  247.   this._bookmarkNode = null;
  248.   this._servicePane = null;
  249.   this._stringBundle = null;
  250.   this._importAttempts = -1; // do not make any more attempts to import
  251.   if (this._importTimer) {
  252.     this._importTimer.cancel();
  253.     this._importTimer = null;
  254.   }
  255. }
  256.  
  257. sbBookmarks.prototype.getString =
  258. function sbBookmarks_getString(aStringId, aDefault) {
  259.   try {
  260.     return this._stringBundle.GetStringFromName(aStringId);
  261.   } catch (e) {
  262.     return aDefault;
  263.   }
  264. }
  265. sbBookmarks.prototype.migrateLegacyBookmarks =
  266. function sbBookmarks_migrateLegacyBookmarks() {
  267.   try {
  268.     var prefsService =
  269.         Cc["@mozilla.org/preferences-service;1"].
  270.         getService(Ci.nsIPrefBranch);
  271.     var LEGACY_BOOKMARKS_PREF = 'songbird.bookmarks.serializedTree';
  272.     if (prefsService.prefHasUserValue(LEGACY_BOOKMARKS_PREF)) {
  273.       var json = '(' + prefsService.getCharPref(LEGACY_BOOKMARKS_PREF) + ')';
  274.       var bms = eval(json);
  275.       for (var i in bms.children) {
  276.         var folder = bms.children[i];
  277.         if (folder.label == '&servicesource.bookmarks') {
  278.           for (var j in folder.children) {
  279.             var bm = folder.children[j];
  280.             if (bm.properties != 'bookmark') {
  281.               continue;
  282.             }
  283.             var node = this._servicePane.getNode(bm.url);
  284.             if (node) {
  285.               // this bookmark already existed.
  286.               // we want to set the title to the old
  287.               node.name = bm.label;
  288.             } else {
  289.               // the bookmark does not exist. We need to create it
  290.               var icon = null;
  291.               // only import the icon if its from the web
  292.               if (bm.icon.match(/^http/)) {
  293.                 icon = bm.icon;
  294.               }
  295.               this.addBookmark(bm.url, bm.label, icon);
  296.             }
  297.           }
  298.           break;
  299.         }
  300.       }
  301.       // let's clear that pref
  302.       prefsService.clearUserPref(LEGACY_BOOKMARKS_PREF);
  303.     }
  304.   } catch (e) {
  305.   }
  306. }
  307.  
  308. sbBookmarks.prototype.addBookmark =
  309. function sbBookmarks_addBookmark(aURL, aTitle, aIconURL) {
  310.   dump('sbBookmarks.addBookmark('+aURL.toSource()+','+aTitle.toSource()+','+aIconURL.toSource()+')\n');
  311.   if (!this._bookmarkNode) {
  312.     // if we try to add a bookmark the defaults are loaded, lets create the default folder anyway
  313.     this._bookmarkNode = this._servicePane.addNode(ROOTNODE,
  314.         this._servicePane.root, true);
  315.   }
  316.   return this.addBookmarkAt(aURL, aTitle, aIconURL, this._bookmarkNode, null);
  317. }
  318.  
  319. sbBookmarks.prototype.addBookmarkAt =
  320. function sbBookmarks_addBookmarkAt(aURL, aTitle, aIconURL, aParent, aBefore) {
  321.   var bnode = this._servicePane.addNode(aURL, aParent, false);
  322.   if (!bnode) {
  323.     return bnode;
  324.   }
  325.   
  326.   bnode.url = aURL;
  327.   bnode.name = aTitle;
  328.   if (aBefore) {
  329.     aBefore.parentNode.insertBefore(bnode, aBefore);
  330.   }
  331.   bnode.properties = "bookmark " + aTitle;
  332.   bnode.hidden = false;
  333.   bnode.contractid = CONTRACTID;
  334.   bnode.dndDragTypes = BOOKMARK_DRAG_TYPE;
  335.   bnode.dndAcceptNear = BOOKMARK_DRAG_TYPE;
  336.   bnode.editable = true;
  337.   
  338.   if (aIconURL && aIconURL.match(/^https?:/)) {
  339.     // check that the supplied image url works, otherwise use the default
  340.     var checker = Cc["@mozilla.org/network/urichecker;1"]
  341.       .createInstance(Ci.nsIURIChecker);
  342.     var uri = Cc["@mozilla.org/network/standard-url;1"]
  343.       .createInstance(Ci.nsIURI);
  344.     uri.spec = aIconURL;
  345.     checker.init(uri);
  346.     checker.asyncCheck(new ImageUriCheckerObserver(bnode, aIconURL), null);
  347.   }
  348.  
  349.   return bnode;
  350. }
  351.  
  352. function ImageUriCheckerObserver(bnode, icon) {
  353.   this._bnode = bnode;
  354.   this._icon = icon;
  355. }
  356.  
  357. ImageUriCheckerObserver.prototype.onStartRequest =
  358. function ImageUriCheckerObserver_onStartRequest(aRequest, aContext)
  359. {
  360. }
  361. ImageUriCheckerObserver.prototype.onStopRequest =
  362. function ImageUriCheckerObserver_onStopRequest(aRequest, aContext, aStatusCode)
  363. {
  364.   if (aStatusCode == 0) {
  365.  
  366.     if(aRequest &&
  367.        aRequest.baseChannel &&
  368.        aRequest.baseChannel instanceof Ci.nsIHttpChannel) {
  369.  
  370.       var channel = aRequest.baseChannel.QueryInterface(Ci.nsIHttpChannel);
  371.  
  372.       if (channel) {
  373.         try {
  374.           var contentType = channel.getResponseHeader("content-type");
  375.             
  376.           if (contentType.substr(0,6) != "image/") {
  377.             Cu.reportError("Favicon URL is not an image - content-type = " + 
  378.                            contentType + 
  379.                            "faviconURL = " +
  380.                            this._icon);
  381.             return;
  382.           }
  383.         }
  384.         catch(e) {
  385.           if (Components.lastResult != Cr.NS_ERROR_NOT_AVAILABLE) {
  386.             Cu.reportError(e);
  387.           }
  388.         }
  389.       }
  390.     }
  391.  
  392.     // If the requested image exists, set it as the icon.
  393.     this._bnode.image = this._icon;
  394.  
  395.   }
  396.   
  397.   // Otherwise, we don't set the image property and we get the default from the skin.
  398.   return;
  399. }
  400.  
  401. sbBookmarks.prototype.addFolder =
  402. function sbBookmarks_addFolder(aTitle) {
  403.   return this.addFolderAt(null, aTitle, null, this._servicePane.root, null);
  404. }
  405.  
  406. sbBookmarks.prototype.addFolderAt =
  407. function sbBookmarks_addFolderAt(aId, aTitle, aIconURL, aParent, aBefore) {
  408.   var  fnode = this._servicePane.addNode(aId, aParent, true);  
  409.   fnode.name = aTitle;
  410.   if (aIconURL != null) {
  411.     fnode.image = aIconURL;
  412.   }
  413.   if (aBefore) {
  414.     aBefore.parentNode.insertBefore(fnode, aBefore);
  415.   }
  416.   fnode.properties = "folder " + aTitle;
  417.   fnode.hidden = false;
  418.   fnode.contractid = CONTRACTID;
  419.   fnode.dndAcceptIn = BOOKMARK_DRAG_TYPE;
  420.   fnode.editable = false; // folder names are not editable
  421.   
  422.   return fnode;
  423. }
  424.  
  425. sbBookmarks.prototype.bookmarkExists =
  426. function sbBookmarks_bookmarkExists(aURL) {
  427.   var node = this._servicePane.getNode(aURL);
  428.   return (node != null);
  429. }
  430. sbBookmarks.prototype.fillContextMenu =
  431. function sbBookmarks_fillContextMenu(aNode, aContextMenu, aParentWindow) {
  432.   dump ('called fillContextMenu with node: '+aNode+'\n');
  433.  
  434.   if (!aNode.editable) {
  435.     // not editable - don't add any items
  436.     return;
  437.   }
  438.   
  439.   if (aNode.contractid != CONTRACTID) {
  440.     dump('or not...('+aNode.contractid+')\n');
  441.     return;
  442.   }
  443.     
  444.   var document = aContextMenu.ownerDocument;
  445.     
  446.   var item = document.createElement('menuitem');
  447.   item.setAttribute('label',
  448.             this.getString('bookmarks.menu.rename', 'Rename'));
  449.   var service = this; // so we can get to it from the callback
  450.   item.addEventListener('command',
  451.   function bookmark_edit_oncommand (event) {
  452.     var servicepane = aParentWindow.document.getElementById('servicepane');
  453.     servicepane.startEditingNode(aNode);
  454.   }, false);
  455.   aContextMenu.appendChild(item);
  456.  
  457.   item = document.createElement('menuitem');
  458.   item.setAttribute('label',
  459.             this.getString('bookmarks.menu.edit', 'Edit'));
  460.   var service = this; // so we can get to it from the callback
  461.   item.addEventListener('command',
  462.   function bookmark_edit_oncommand (event) {
  463.     dump ('edit properties of: '+aNode.name+'\n');
  464.     aParentWindow.QueryInterface(Ci.nsIDOMWindowInternal);
  465.     /* begin code stolen from windowUtils.js:SBOpenModalDialog */
  466.     /* FIXME: what's that BackscanPause stuff? */
  467.     var chromeFeatures = "chrome,centerscreen,modal=yes,resizable=no";
  468.     var accessibility = SB_NewDataRemote('accessibility.enabled', null).boolValue;
  469.     chromeFeatures += (',titlebar='+accessibility?'yes':'no');
  470.     aParentWindow.openDialog('chrome://songbird/content/xul/editBookmark.xul',
  471.                  'edit_bookmark', chromeFeatures, aNode);
  472.   }, false);
  473.   aContextMenu.appendChild(item);
  474.   
  475.   item = document.createElement('menuitem');
  476.   item.setAttribute('label',
  477.             this.getString('bookmarks.menu.remove', 'Remove'));
  478.   item.addEventListener('command',
  479.   function bookmark_delete_oncommand (event) {
  480.     dump ('delete: '+aNode.name+'\n');
  481.     // FIXME: confirmation dialog, eh??
  482.     service._servicePane.removeNode(aNode);
  483.   }, false);
  484.   aContextMenu.appendChild(item);
  485. }
  486.  
  487. sbBookmarks.prototype.fillNewItemMenu =
  488. function sbBookmarks_fillNewItemMenu(aNode, aContextMenu, aParentWindow) {
  489.   // XXX lone: disabled; see bug 4387
  490.   /*
  491.   var stringBundle = this._stringBundle;
  492.   function add(id, label, accesskey, oncommand) {
  493.     var menuitem = aContextMenu.ownerDocument.createElement('menuitem');
  494.     menuitem.setAttribute('id', id);
  495.     menuitem.setAttribute('class', 'menuitem-iconic');
  496.     menuitem.setAttribute('label', stringBundle.GetStringFromName(label));
  497.     menuitem.setAttribute('accesskey', stringBundle.GetStringFromName(accesskey));
  498.     menuitem.setAttribute('oncommand', oncommand);
  499.     aContextMenu.appendChild(menuitem);
  500.   }
  501.  
  502.   add('file.folder', 'menu.file.folder', 'menu.file.folder.accesskey', 'doMenu("file.folder")');
  503.   */
  504. }
  505.  
  506. sbBookmarks.prototype.onSelectionChanged=
  507. function sbBookmarks_onSelectionChanged(aNode, aContainer, aParentWindow) {
  508. }
  509.  
  510. sbBookmarks.prototype.canDrop =
  511. function sbBookmarks_canDrop(aNode, aDragSession, aOrientation) {
  512.   if (aNode.isContainer) {
  513.     if (aOrientation != 0) {
  514.       // for folders you can only drop on the folder, not before or after
  515.       return false;
  516.     }
  517.   }
  518.   if (aDragSession.isDataFlavorSupported(MOZ_URL_DRAG_TYPE)) {
  519.     return true;
  520.  
  521.   }
  522.   return false;
  523. }
  524. sbBookmarks.prototype._getDragData =
  525. function sbBookmarks__getDragData(aDragSession, aDataType) {
  526.   // create an nsITransferable
  527.   var transferable = Cc["@mozilla.org/widget/transferable;1"].
  528.       createInstance(Ci.nsITransferable);
  529.   // specify what kind of data we want it to contain
  530.   transferable.addDataFlavor(aDataType);
  531.   // ask the drag session to fill the transferable with that data
  532.   aDragSession.getData(transferable, 0);
  533.   // get the data from the transferable
  534.   var data = {};
  535.   var dataLength = {};
  536.   transferable.getTransferData(aDataType, data, dataLength);
  537.   // it's always a string. always.
  538.   data = data.value.QueryInterface(Ci.nsISupportsString);
  539.   return data.toString();
  540. }
  541. sbBookmarks.prototype.onDrop =
  542. function sbBookmarks_onDrop(aNode, aDragSession, aOrientation) {
  543.   if (aDragSession.isDataFlavorSupported(MOZ_URL_DRAG_TYPE)) {
  544.     var data = this._getDragData(aDragSession, MOZ_URL_DRAG_TYPE).split('\n');
  545.     var url = data[0];
  546.     var text = data[1];
  547.     var parent, before=null;
  548.     if (aNode.isContainer) {
  549.       parent = aNode;
  550.     } else {
  551.       parent = aNode.parentNode;
  552.       before = aNode;
  553.       if (aOrientation == 1) {
  554.         // after
  555.         before = aNode.nextSibling;
  556.       }
  557.     }
  558.     this.addBookmarkAt(url, text, null, parent, before);
  559.   }
  560. }
  561. sbBookmarks.prototype._addDragData =
  562. function sbBookmarks__addDragData (aTransferable, aData, aDataType) {
  563.   aTransferable.addDataFlavor(aDataType);
  564.   var text = Cc["@mozilla.org/supports-string;1"].
  565.      createInstance(Ci.nsISupportsString);
  566.   text.data = aData;
  567.   // double the length - it's unicode - this is stupid
  568.   aTransferable.setTransferData(aDataType, text, text.data.length*2);
  569. }
  570. sbBookmarks.prototype.onDragGesture =
  571. function sbBookmarks_onDragGesture(aNode, aTransferable) {
  572.   if (aNode.isContainer) {
  573.     // you can't drag folders - that should be handled at the
  574.     // service pane service layer
  575.     return false;
  576.   }
  577.   
  578.   // attach a text/x-moz-url
  579.   // this is for dragging to other places
  580.   /*
  581.   this._addDragData(aTransferable, aNode.url+'\n'+aNode.name, MOZ_URL_DRAG_TYPE);
  582.   */
  583.   
  584.   // and say yet - lets do this drag
  585.   return true;
  586. }
  587.  
  588. /**
  589.  * Called when the user has attempted to rename a bookmark node
  590.  */
  591. sbBookmarks.prototype.onRename =
  592. function sbBookmarks_onRename(aNode, aNewName) {
  593.   if (aNode && aNewName) {
  594.     aNode.name = aNewName;
  595.   }
  596. }
  597.  
  598.  
  599.  
  600. /**
  601.  * /brief XPCOM initialization code
  602.  */
  603. function makeGetModule(CONSTRUCTOR, CID, CLASSNAME, CONTRACTID, CATEGORIES) {
  604.   return function (comMgr, fileSpec) {
  605.     return {
  606.       registerSelf : function (compMgr, fileSpec, location, type) {
  607.         compMgr.QueryInterface(Ci.nsIComponentRegistrar);
  608.         compMgr.registerFactoryLocation(CID,
  609.                         CLASSNAME,
  610.                         CONTRACTID,
  611.                         fileSpec,
  612.                         location,
  613.                         type);
  614.         if (CATEGORIES && CATEGORIES.length) {
  615.           var catman =  Cc["@mozilla.org/categorymanager;1"]
  616.               .getService(Ci.nsICategoryManager);
  617.           for (var i=0; i<CATEGORIES.length; i++) {
  618.             var e = CATEGORIES[i];
  619.             catman.addCategoryEntry(e.category, e.entry, e.value, 
  620.               true, true);
  621.           }
  622.         }
  623.       },
  624.  
  625.       getClassObject : function (compMgr, cid, iid) {
  626.         if (!cid.equals(CID)) {
  627.           throw Cr.NS_ERROR_NO_INTERFACE;
  628.         }
  629.  
  630.         if (!iid.equals(Ci.nsIFactory)) {
  631.           throw Cr.NS_ERROR_NOT_IMPLEMENTED;
  632.         }
  633.  
  634.         return this._factory;
  635.       },
  636.  
  637.       _factory : {
  638.         createInstance : function (outer, iid) {
  639.           if (outer != null) {
  640.             throw Cr.NS_ERROR_NO_AGGREGATION;
  641.           }
  642.           return (new CONSTRUCTOR()).QueryInterface(iid);
  643.         }
  644.       },
  645.  
  646.       unregisterSelf : function (compMgr, location, type) {
  647.         compMgr.QueryInterface(Ci.nsIComponentRegistrar);
  648.         compMgr.unregisterFactoryLocation(CID, location);
  649.         if (CATEGORIES && CATEGORIES.length) {
  650.           var catman =  Cc["@mozilla.org/categorymanager;1"]
  651.               .getService(Ci.nsICategoryManager);
  652.           for (var i=0; i<CATEGORIES.length; i++) {
  653.             var e = CATEGORIES[i];
  654.             catman.deleteCategoryEntry(e.category, e.entry, true);
  655.           }
  656.         }
  657.       },
  658.  
  659.       canUnload : function (compMgr) {
  660.         return true;
  661.       },
  662.  
  663.       QueryInterface : function (iid) {
  664.         if ( !iid.equals(Ci.nsIModule) ||
  665.              !iid.equals(Ci.nsISupports) )
  666.           throw Cr.NS_ERROR_NO_INTERFACE;
  667.         return this;
  668.       }
  669.  
  670.     };
  671.   }
  672. }
  673.  
  674. var NSGetModule = makeGetModule (
  675.   sbBookmarks,
  676.   Components.ID("{21e3e540-1191-46b5-a041-d0ab95d4c067}"),
  677.   "Songbird Bookmarks Service",
  678.   CONTRACTID,
  679.   [{
  680.     category: 'service-pane',
  681.     entry: 'bookmarks',
  682.     value: '@songbirdnest.com/servicepane/bookmarks;1'
  683.   }]);
  684.  
  685.