Restore toolkit/obsolete files and reinstate them to toolkit/content

9 files changed, 1065 insertions, 0 deletions

diff --git a/toolkit/content/dialogOverlay.js b/toolkit/content/dialogOverlay.js
new file mode 100644
index 000000000..4b03f268f
--- /dev/null
+++ b/toolkit/content/dialogOverlay.js
@@ -0,0 +1,107 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+var doOKFunction = 0;
+var doCancelFunction = 0;
+var doButton2Function = 0;
+var doButton3Function = 0;
+
+// call this from dialog onload() to allow ok and cancel to call your code
+// functions should return true if they want the dialog to close
+function doSetOKCancel(okFunc, cancelFunc, button2Func, button3Func )
+{
+	//dump("top.window.navigator.platform: " + top.window.navigator.platform + "\n");
+
+	doOKFunction = okFunc;
+	doCancelFunction = cancelFunc;
+	doButton2Function = button2Func;
+	doButton3Function = button3Func;
+}
+
+function doOKButton()
+{
+	var close = true;
+
+	if ( doOKFunction )
+		close = doOKFunction();
+
+	if (close && top)
+		top.window.close();
+}
+
+function doCancelButton()
+{
+	var close = true;
+
+	if ( doCancelFunction )
+		close = doCancelFunction();
+
+	if (close && top)
+		top.window.close();
+}
+
+function doButton2()
+{
+	var close = true;
+
+	if ( doButton2Function )
+		close = doButton2Function();
+
+	if (close && top)
+		top.window.close();
+}
+
+function doButton3()
+{
+	var close = true;
+
+	if ( doButton3Function )
+		close = doButton3Function();
+
+	if (close && top)
+		top.window.close();
+}
+
+function moveToAlertPosition()
+{
+    // hack. we need this so the window has something like its final size
+    if (window.outerWidth == 1) {
+        dump("Trying to position a sizeless window; caller should have called sizeToContent() or sizeTo(). See bug 75649.\n");
+        sizeToContent();
+    }
+
+    if (opener) {
+        var xOffset = (opener.outerWidth - window.outerWidth) / 2;
+        var yOffset = opener.outerHeight / 5;
+
+        var newX = opener.screenX + xOffset;
+        var newY = opener.screenY + yOffset;
+    } else {
+        newX = (screen.availWidth - window.outerWidth) / 2;
+        newY = (screen.availHeight - window.outerHeight) / 2;
+    }
+
+	// ensure the window is fully onscreen (if smaller than the screen)
+	if (newX < screen.availLeft)
+		newX = screen.availLeft + 20;
+	if ((newX + window.outerWidth) > (screen.availLeft + screen.availWidth))
+		newX = (screen.availLeft + screen.availWidth) - window.outerWidth - 20;
+
+	if (newY < screen.availTop)
+		newY = screen.availTop + 20;
+	if ((newY + window.outerHeight) > (screen.availTop + screen.availHeight))
+		newY = (screen.availTop + screen.availHeight) - window.outerHeight - 60;
+
+	window.moveTo( newX, newY );
+}
+
+function centerWindowOnScreen()
+{
+	var xOffset = screen.availWidth/2 - window.outerWidth/2;
+	var yOffset = screen.availHeight/2 - window.outerHeight/2; //(opener.outerHeight *2)/10;
+
+	xOffset = ( xOffset > 0 ) ? xOffset : 0;
+  yOffset = ( yOffset > 0 ) ? yOffset : 0;
+	window.moveTo( xOffset, yOffset);
+}
diff --git a/toolkit/content/dialogOverlay.xul b/toolkit/content/dialogOverlay.xul
new file mode 100644
index 000000000..09e00613e
--- /dev/null
+++ b/toolkit/content/dialogOverlay.xul
@@ -0,0 +1,101 @@
+<?xml version="1.0"?>
+# -*- Mode: HTML -*-
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+# WARNING!!! This file is obsoleted by the dialog.xml widget
+#
+
+<!DOCTYPE overlay SYSTEM "chrome://global/locale/dialogOverlay.dtd">
+
+<overlay id="dialogOverlay"
+         xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
+
+  <script type="application/javascript" src="chrome://global/content/dialogOverlay.js"/>
+
+#ifdef XP_MACOSX
+#
+  <hbox id="okCancelButtons">
+    <spacer flex="1"/>
+    <button class="exit-dialog" id="Button3" label="" collapsed="true" oncommand="doButton3();"/>
+    <button class="exit-dialog" id="Button2" label="" collapsed="true" oncommand="doButton2();"/>
+    <button class="exit-dialog" id="cancel" label="&cancelButton.label;" oncommand="doCancelButton();"/>
+    <button class="right exit-dialog" id="ok" default="true" label="&okButton.label;" oncommand="doOKButton();"/>
+  </hbox>
+
+  <hbox id="okCancelHelpButtons">
+    <button class="exit-dialog" id="help" label="&helpButton.label;" oncommand="doHelpButton();"/>
+    <spacer flex="1"/>
+    <button class="exit-dialog" id="Button3" label="" collapsed="true" oncommand="doButton3();"/>
+    <button class="exit-dialog" id="Button2" label="" collapsed="true" oncommand="doButton2();"/>
+    <button class="exit-dialog" id="cancel" label="&cancelButton.label;" oncommand="doCancelButton();"/>
+    <button class="right exit-dialog" id="ok" default="true" label="&okButton.label;" oncommand="doOKButton();"/>
+  </hbox>
+
+  <hbox id="okCancelButtonsRight">
+    <spacer flex="1"/>
+    <button class="exit-dialog" id="Button3" label="" collapsed="true" oncommand="doButton3();"/>
+    <button class="exit-dialog" id="Button2" label="" collapsed="true" oncommand="doButton2();"/>
+    <button class="exit-dialog" id="cancel" label="&cancelButton.label;" oncommand="doCancelButton();"/>
+    <button class="right exit-dialog" id="ok" default="true" label="&okButton.label;" oncommand="doOKButton();"/>
+  </hbox>
+
+  <hbox id="okCancelHelpButtonsRight">
+    <button class="exit-dialog" id="help" label="&helpButton.label;" oncommand="doHelpButton();"/>
+    <spacer flex="1"/>
+    <button class="exit-dialog" id="Button3" label="" collapsed="true" oncommand="doButton3();"/>
+    <button class="exit-dialog" id="Button2" label="" collapsed="true" oncommand="doButton2();"/>
+    <button class="exit-dialog" id="cancel" label="&cancelButton.label;" oncommand="doCancelButton();"/>
+    <button class="right exit-dialog" id="ok" default="true" label="&okButton.label;" oncommand="doOKButton();"/>
+  </hbox>
+#
+#else
+#
+  <hbox id="okCancelButtons">
+    <spacer flex="1"/>
+    <button class="right exit-dialog" id="ok" label="&okButton.label;" default="true" oncommand="doOKButton();"/> 
+    <button class="exit-dialog" id="Button2" label="&cancelButton.label;" collapsed="true" oncommand="doButton2();"/> 
+    <button class="exit-dialog" id="Button3" label="&cancelButton.label;" collapsed="true" oncommand="doButton3();"/> 
+    <button class="exit-dialog" id="cancel" label="&cancelButton.label;" oncommand="doCancelButton();"/>
+    <spacer flex="1"/>
+  </hbox>
+
+  <hbox id="okCancelHelpButtons">
+    <spacer flex="1"/>
+    <button class="right exit-dialog" id="ok" label="&okButton.label;" default="true" oncommand="doOKButton();"/>
+    <button class="exit-dialog" id="Button2" label="&cancelButton.label;" collapsed="true" oncommand="doButton2();"/>
+    <button class="exit-dialog" id="Button3" label="&cancelButton.label;" collapsed="true" oncommand="doButton3();"/>
+    <button class="exit-dialog" id="cancel" label="&cancelButton.label;" oncommand="doCancelButton();"/>
+    <button class="exit-dialog" id="help" label="&helpButton.label;" oncommand="doHelpButton();"/>
+    <spacer flex="1"/>
+  </hbox>
+
+  <hbox id="okCancelButtonsRight">
+    <spacer flex="1"/>
+    <button class="right exit-dialog" id="ok" label="&okButton.label;" default="true" oncommand="doOKButton();"/> 
+    <button class="exit-dialog" id="Button2" label="&cancelButton.label;" collapsed="true" oncommand="doButton2();"/> 
+    <button class="exit-dialog" id="Button3" label="&cancelButton.label;" collapsed="true" oncommand="doButton3();"/> 
+    <button class="exit-dialog" id="cancel" label="&cancelButton.label;" oncommand="doCancelButton();"/>
+  </hbox>
+
+  <hbox id="okCancelHelpButtonsRight">
+    <spacer flex="1"/>
+    <button class="right exit-dialog" id="ok" label="&okButton.label;" default="true" oncommand="doOKButton();"/>
+    <button class="exit-dialog" id="Button2" label="&cancelButton.label;" collapsed="true" oncommand="doButton2();"/>
+    <button class="exit-dialog" id="Button3" label="&cancelButton.label;" collapsed="true" oncommand="doButton3();"/>
+    <button class="exit-dialog" id="cancel" label="&cancelButton.label;" oncommand="doCancelButton();"/>
+    <button class="exit-dialog" id="help" label="&helpButton.label;" oncommand="doHelpButton();"/>
+  </hbox>
+#endif
+
+  <keyset id="dialogKeys">
+    <key keycode="VK_RETURN" oncommand="if (!document.getElementById('ok').disabled) doOKButton();"/>
+    <key keycode="VK_ESCAPE" oncommand="doCancelButton();"/>
+#ifdef XP_MACOSX
+    <key key="." modifiers="meta" oncommand="doCancelButton();"/>
+#
+#endif
+  </keyset>
+
+</overlay>
diff --git a/toolkit/content/globalOverlay.xul b/toolkit/content/globalOverlay.xul
new file mode 100644
index 000000000..90268a8e4
--- /dev/null
+++ b/toolkit/content/globalOverlay.xul
@@ -0,0 +1,38 @@
+<?xml version="1.0"?> 
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this
+   - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
+
+
+<overlay id="globalOverlay"
+		 xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
+
+  <script type="application/javascript" src="chrome://global/content/globalOverlay.js"/>
+  <script type="application/javascript"><![CDATA[
+
+    function FillInTooltip ( tipElement )
+    {
+      var retVal = false;
+      var textNode = document.getElementById("TOOLTIP-tooltipText");
+      if (textNode) {
+        while (textNode.hasChildNodes())
+          textNode.removeChild(textNode.firstChild);
+        var tipText = tipElement.getAttribute("tooltiptext");
+        if (tipText) {
+          var node = document.createTextNode(tipText);
+          textNode.appendChild(node);
+          retVal = true;
+        }
+      }
+      return retVal;
+    }
+
+  ]]></script>
+
+  <popupset id="aTooltipSet">
+    <tooltip id="aTooltip" class="tooltip" onpopupshowing="return FillInTooltip(document.tooltipNode);">
+      <label id="TOOLTIP-tooltipText" class="tooltip-label" flex="1"/>
+    </tooltip>
+  </popupset>
+
+</overlay>		
diff --git a/toolkit/content/inlineSpellCheckUI.js b/toolkit/content/inlineSpellCheckUI.js
new file mode 100644
index 000000000..177ce90cd
--- /dev/null
+++ b/toolkit/content/inlineSpellCheckUI.js
@@ -0,0 +1,7 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+Components.utils.import("resource://gre/modules/InlineSpellChecker.jsm");
+
+var InlineSpellCheckerUI = new InlineSpellChecker();
diff --git a/toolkit/content/jar.mn b/toolkit/content/jar.mn
index 590356b64..b4eec241c 100644
--- a/toolkit/content/jar.mn
+++ b/toolkit/content/jar.mn
@@ -65,6 +65,14 @@ toolkit.jar:
    content/global/timepicker.xhtml
    content/global/treeUtils.js
    content/global/viewZoomOverlay.js
+   content/global/globalOverlay.xul
+*  content/global/dialogOverlay.xul
+   content/global/dialogOverlay.js
+   content/global/inlineSpellCheckUI.js
+   content/global/nsClipboard.js
+   content/global/nsDragAndDrop.js
+   content/global/nsUserSettings.js
+   content/global/strres.js
    content/global/bindings/autocomplete.xml    (widgets/autocomplete.xml)
    content/global/bindings/browser.xml         (widgets/browser.xml)
    content/global/bindings/button.xml          (widgets/button.xml)
diff --git a/toolkit/content/nsClipboard.js b/toolkit/content/nsClipboard.js
new file mode 100644
index 000000000..d9f7c4589
--- /dev/null
+++ b/toolkit/content/nsClipboard.js
@@ -0,0 +1,64 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * nsClipboard - wrapper around nsIClipboard and nsITransferable
+ *               that simplifies access to the clipboard.
+ **/
+var nsClipboard = {
+  _CB: null,
+  get mClipboard()
+    {
+      if (!this._CB)
+        {
+          const kCBContractID = "@mozilla.org/widget/clipboard;1";
+          const kCBIID = Components.interfaces.nsIClipboard;
+          this._CB = Components.classes[kCBContractID].getService(kCBIID);
+        }
+      return this._CB;
+    },
+
+  currentClipboard: null,
+  /**
+   * Array/Object read (Object aFlavourList, long aClipboard, Bool aAnyFlag) ;
+   *
+   * returns the data in the clipboard
+   *
+   * @param FlavourSet aFlavourSet
+   *        formatted list of desired flavours
+   * @param long aClipboard
+   *        the clipboard to read data from (kSelectionClipboard/kGlobalClipboard)
+   * @param Bool aAnyFlag
+   *        should be false.
+   **/
+  read: function (aFlavourList, aClipboard, aAnyFlag)
+    {
+      this.currentClipboard = aClipboard;
+      var data = nsTransferable.get(aFlavourList, this.getClipboardTransferable, aAnyFlag);
+      return data.first.first;  // only support one item
+    },
+
+  /**
+   * nsISupportsArray getClipboardTransferable (Object aFlavourList) ;
+   *
+   * returns a nsISupportsArray of the item on the clipboard
+   *
+   * @param Object aFlavourList
+   *        formatted list of desired flavours.
+   **/
+  getClipboardTransferable: function (aFlavourList)
+    {
+      const supportsContractID = "@mozilla.org/supports-array;1";
+      const supportsIID = Components.interfaces.nsISupportsArray;
+      var supportsArray = Components.classes[supportsContractID].createInstance(supportsIID);
+      var trans = nsTransferable.createTransferable();
+      for (var flavour in aFlavourList)
+        trans.addDataFlavor(flavour);
+      nsClipboard.mClipboard.getData(trans, nsClipboard.currentClipboard)
+      supportsArray.AppendElement(trans);
+      return supportsArray;
+    }
+};
+
diff --git a/toolkit/content/nsDragAndDrop.js b/toolkit/content/nsDragAndDrop.js
new file mode 100644
index 000000000..40e96f9d1
--- /dev/null
+++ b/toolkit/content/nsDragAndDrop.js
@@ -0,0 +1,604 @@
+// -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+////////////////////////////////////////////////////////////////////////
+//
+// USE OF THIS API FOR DRAG AND DROP IS DEPRECATED!
+// Do not use this file for new code.
+//
+// For documentation about what to use instead, see:
+//   http://developer.mozilla.org/En/DragDrop/Drag_and_Drop
+//
+////////////////////////////////////////////////////////////////////////
+
+
+/** 
+ *  nsTransferable - a wrapper for nsITransferable that simplifies
+ *                   javascript clipboard and drag&drop. for use in
+ *                   these situations you should use the nsClipboard
+ *                   and nsDragAndDrop wrappers for more convenience
+ **/ 
+ 
+var nsTransferable = {
+  /**
+   * nsITransferable set (TransferData aTransferData) ;
+   *
+   * Creates a transferable with data for a list of supported types ("flavours")
+   * 
+   * @param TransferData aTransferData
+   *        a javascript object in the format described above 
+   **/ 
+  set: function (aTransferDataSet)
+    {
+      var trans = this.createTransferable();
+      for (var i = 0; i < aTransferDataSet.dataList.length; ++i) 
+        {
+          var currData = aTransferDataSet.dataList[i];
+          var currFlavour = currData.flavour.contentType;
+          trans.addDataFlavor(currFlavour);
+          var supports = null; // nsISupports data
+          var length = 0;
+          if (currData.flavour.dataIIDKey == "nsISupportsString")
+            {
+              supports = Components.classes["@mozilla.org/supports-string;1"]
+                                   .createInstance(Components.interfaces.nsISupportsString);
+
+              supports.data = currData.supports;
+              length = supports.data.length;
+            }
+          else 
+            {
+              // non-string data.
+              supports = currData.supports;
+              length = 0; // kFlavorHasDataProvider
+            }
+          trans.setTransferData(currFlavour, supports, length * 2);
+        }
+      return trans;
+    },
+  
+  /**
+   * TransferData/TransferDataSet get (FlavourSet aFlavourSet, 
+   *                                   Function aRetrievalFunc, Boolean aAnyFlag) ;
+   *
+   * Retrieves data from the transferable provided in aRetrievalFunc, formatted
+   * for more convenient access.
+   *
+   * @param FlavourSet aFlavourSet
+   *        a FlavourSet object that contains a list of supported flavours.
+   * @param Function aRetrievalFunc
+   *        a reference to a function that returns a nsISupportsArray of nsITransferables
+   *        for each item from the specified source (clipboard/drag&drop etc)
+   * @param Boolean aAnyFlag
+   *        a flag specifying whether or not a specific flavour is requested. If false,
+   *        data of the type of the first flavour in the flavourlist parameter is returned,
+   *        otherwise the best flavour supported will be returned.
+   **/
+  get: function (aFlavourSet, aRetrievalFunc, aAnyFlag)
+    {
+      if (!aRetrievalFunc) 
+        throw "No data retrieval handler provided!";
+      
+      var supportsArray = aRetrievalFunc(aFlavourSet);
+      var dataArray = [];
+      var count = supportsArray.Count();
+      
+      // Iterate over the number of items returned from aRetrievalFunc. For
+      // clipboard operations, this is 1, for drag and drop (where multiple
+      // items may have been dragged) this could be >1.
+      for (var i = 0; i < count; i++)
+        {
+          var trans = supportsArray.GetElementAt(i);
+          if (!trans) continue;
+          trans = trans.QueryInterface(Components.interfaces.nsITransferable);
+            
+          var data = { };
+          var length = { };
+          
+          var currData = null;
+          if (aAnyFlag)
+            { 
+              var flavour = { };
+              trans.getAnyTransferData(flavour, data, length);
+              if (data && flavour)
+                {
+                  var selectedFlavour = aFlavourSet.flavourTable[flavour.value];
+                  if (selectedFlavour) 
+                    dataArray[i] = FlavourToXfer(data.value, length.value, selectedFlavour);
+                }
+            }
+          else
+            {
+              var firstFlavour = aFlavourSet.flavours[0];
+              trans.getTransferData(firstFlavour, data, length);
+              if (data && firstFlavour)
+                dataArray[i] = FlavourToXfer(data.value, length.value, firstFlavour);
+            }
+        }
+      return new TransferDataSet(dataArray);
+    },
+
+  /** 
+   * nsITransferable createTransferable (void) ;
+   *
+   * Creates and returns a transferable object.
+   **/    
+  createTransferable: function ()
+    {
+      const kXferableContractID = "@mozilla.org/widget/transferable;1";
+      const kXferableIID = Components.interfaces.nsITransferable;
+      var trans = Components.classes[kXferableContractID].createInstance(kXferableIID);
+      trans.init(null);
+      return trans;
+    }
+};  
+
+/** 
+ * A FlavourSet is a simple type that represents a collection of Flavour objects.
+ * FlavourSet is constructed from an array of Flavours, and stores this list as
+ * an array and a hashtable. The rationale for the dual storage is as follows:
+ * 
+ * Array: Ordering is important when adding data flavours to a transferable. 
+ *        Flavours added first are deemed to be 'preferred' by the client. 
+ * Hash:  Convenient lookup of flavour data using the content type (MIME type)
+ *        of data as a key. 
+ */
+function FlavourSet(aFlavourList)
+{
+  this.flavours = aFlavourList || [];
+  this.flavourTable = { };
+
+  this._XferID = "FlavourSet";
+  
+  for (var i = 0; i < this.flavours.length; ++i)
+    this.flavourTable[this.flavours[i].contentType] = this.flavours[i];
+}
+
+FlavourSet.prototype = {
+  appendFlavour: function (aFlavour, aFlavourIIDKey)
+  {
+    var flavour = new Flavour (aFlavour, aFlavourIIDKey);
+    this.flavours.push(flavour);
+    this.flavourTable[flavour.contentType] = flavour;
+  }
+};
+
+/** 
+ * A Flavour is a simple type that represents a data type that can be handled. 
+ * It takes a content type (MIME type) which is used when storing data on the
+ * system clipboard/drag and drop, and an IIDKey (string interface name
+ * which is used to QI data to an appropriate form. The default interface is
+ * assumed to be wide-string.
+ */ 
+function Flavour(aContentType, aDataIIDKey)
+{
+  this.contentType = aContentType;
+  this.dataIIDKey = aDataIIDKey || "nsISupportsString";
+
+  this._XferID = "Flavour";
+}
+
+function TransferDataBase() {}
+TransferDataBase.prototype = {
+  push: function (aItems)
+  {
+    this.dataList.push(aItems);
+  },
+
+  get first ()
+  {
+    return "dataList" in this && this.dataList.length ? this.dataList[0] : null;
+  }
+};
+
+/** 
+ * TransferDataSet is a list (array) of TransferData objects, which represents
+ * data dragged from one or more elements. 
+ */
+function TransferDataSet(aTransferDataList)
+{
+  this.dataList = aTransferDataList || [];
+
+  this._XferID = "TransferDataSet";
+}
+TransferDataSet.prototype = TransferDataBase.prototype;
+
+/** 
+ * TransferData is a list (array) of FlavourData for all the applicable content
+ * types associated with a drag from a single item. 
+ */
+function TransferData(aFlavourDataList)
+{
+  this.dataList = aFlavourDataList || [];
+
+  this._XferID = "TransferData";
+}
+TransferData.prototype = {
+  __proto__: TransferDataBase.prototype,
+  
+  addDataForFlavour: function (aFlavourString, aData, aLength, aDataIIDKey)
+  {
+    this.dataList.push(new FlavourData(aData, aLength, 
+                       new Flavour(aFlavourString, aDataIIDKey)));
+  }
+};
+
+/** 
+ * FlavourData is a type that represents data retrieved from the system 
+ * clipboard or drag and drop. It is constructed internally by the Transferable
+ * using the raw (nsISupports) data from the clipboard, the length of the data,
+ * and an object of type Flavour representing the type. Clients implementing
+ * IDragDropObserver receive an object of this type in their implementation of
+ * onDrop. They access the 'data' property to retrieve data, which is either data 
+ * QI'ed to a usable form, or unicode string. 
+ */
+function FlavourData(aData, aLength, aFlavour) 
+{
+  this.supports = aData;
+  this.contentLength = aLength;
+  this.flavour = aFlavour || null;
+  
+  this._XferID = "FlavourData";
+}
+
+FlavourData.prototype = {
+  get data ()
+  {
+    if (this.flavour &&
+        this.flavour.dataIIDKey != "nsISupportsString")
+      return this.supports.QueryInterface(Components.interfaces[this.flavour.dataIIDKey]); 
+
+    var supports = this.supports;
+    if (supports instanceof Components.interfaces.nsISupportsString)
+      return supports.data.substring(0, this.contentLength/2);
+     
+    return supports;
+  }
+}
+
+/** 
+ * Create a TransferData object with a single FlavourData entry. Used when 
+ * unwrapping data of a specific flavour from the drag service. 
+ */
+function FlavourToXfer(aData, aLength, aFlavour) 
+{
+  return new TransferData([new FlavourData(aData, aLength, aFlavour)]);
+}
+
+var transferUtils = {
+
+  retrieveURLFromData: function (aData, flavour)
+  {
+    switch (flavour) {
+      case "text/unicode":
+      case "text/plain":
+      case "text/x-moz-text-internal":
+        return aData.replace(/^\s+|\s+$/g, "");
+      case "text/x-moz-url":
+        return ((aData instanceof Components.interfaces.nsISupportsString) ? aData.toString() : aData).split("\n")[0];
+      case "application/x-moz-file":
+        var ioService = Components.classes["@mozilla.org/network/io-service;1"]
+                                  .getService(Components.interfaces.nsIIOService);
+        var fileHandler = ioService.getProtocolHandler("file")
+                                   .QueryInterface(Components.interfaces.nsIFileProtocolHandler);
+        return fileHandler.getURLSpecFromFile(aData);
+    }
+    return null;                                                   
+  }
+
+}
+
+/**
+ * nsDragAndDrop - a convenience wrapper for nsTransferable, nsITransferable
+ *                 and nsIDragService/nsIDragSession. 
+ *
+ * Use: map the handler functions to the 'ondraggesture', 'ondragover' and
+ *   'ondragdrop' event handlers on your XML element, e.g.                   
+ *   <xmlelement ondraggesture="nsDragAndDrop.startDrag(event, observer);"   
+ *               ondragover="nsDragAndDrop.dragOver(event, observer);"      
+ *               ondragdrop="nsDragAndDrop.drop(event, observer);"/>         
+ *                                                                           
+ *   You need to create an observer js object with the following member      
+ *   functions:                                                              
+ *     Object onDragStart (event)        // called when drag initiated,      
+ *                                       // returns flavour list with data   
+ *                                       // to stuff into transferable      
+ *     void onDragOver (Object flavour)  // called when element is dragged   
+ *                                       // over, so that it can perform     
+ *                                       // any drag-over feedback for provided
+ *                                       // flavour                          
+ *     void onDrop (Object data)         // formatted data object dropped.   
+ *     Object getSupportedFlavours ()    // returns a flavour list so that   
+ *                                       // nsTransferable can determine
+ *                                       // whether or not to accept drop. 
+ **/   
+
+var nsDragAndDrop = {
+  
+  _mDS: null,
+  get mDragService()
+    {
+      if (!this._mDS) 
+        {
+          const kDSContractID = "@mozilla.org/widget/dragservice;1";
+          const kDSIID = Components.interfaces.nsIDragService;
+          this._mDS = Components.classes[kDSContractID].getService(kDSIID);
+        }
+      return this._mDS;
+    },
+
+  /**
+   * void startDrag (DOMEvent aEvent, Object aDragDropObserver) ;
+   *
+   * called when a drag on an element is started.
+   *
+   * @param DOMEvent aEvent
+   *        the DOM event fired by the drag init
+   * @param Object aDragDropObserver
+   *        javascript object of format described above that specifies
+   *        the way in which the element responds to drag events.
+   **/  
+  startDrag: function (aEvent, aDragDropObserver)
+    {
+      if (!("onDragStart" in aDragDropObserver))
+        return;
+
+      const kDSIID = Components.interfaces.nsIDragService;
+      var dragAction = { action: kDSIID.DRAGDROP_ACTION_COPY + kDSIID.DRAGDROP_ACTION_MOVE + kDSIID.DRAGDROP_ACTION_LINK };
+
+      var transferData = { data: null };
+      try 
+        {
+          aDragDropObserver.onDragStart(aEvent, transferData, dragAction);
+        }
+      catch (e) 
+        {
+          return;  // not a draggable item, bail!
+        }
+
+      if (!transferData.data) return;
+      transferData = transferData.data;
+
+      var dt = aEvent.dataTransfer;
+      var count = 0;
+      do {
+        var tds = transferData._XferID == "TransferData" 
+                                         ? transferData 
+                                         : transferData.dataList[count]
+        for (var i = 0; i < tds.dataList.length; ++i) 
+        {
+          var currData = tds.dataList[i];
+          var currFlavour = currData.flavour.contentType;
+          var value = currData.supports;
+          if (value instanceof Components.interfaces.nsISupportsString)
+            value = value.toString();
+          dt.mozSetDataAt(currFlavour, value, count);
+        }
+
+        count++;
+      }
+      while (transferData._XferID == "TransferDataSet" && 
+             count < transferData.dataList.length);
+
+      dt.effectAllowed = "all";
+      // a drag targeted at a tree should instead use the treechildren so that
+      // the current selection is used as the drag feedback
+      dt.addElement(aEvent.originalTarget.localName == "treechildren" ?
+                    aEvent.originalTarget : aEvent.target);
+      aEvent.stopPropagation();
+    },
+
+  /** 
+   * void dragOver (DOMEvent aEvent, Object aDragDropObserver) ;
+   *
+   * called when a drag passes over this element
+   *
+   * @param DOMEvent aEvent
+   *        the DOM event fired by passing over the element
+   * @param Object aDragDropObserver
+   *        javascript object of format described above that specifies
+   *        the way in which the element responds to drag events.
+   **/
+  dragOver: function (aEvent, aDragDropObserver)
+    { 
+      if (!("onDragOver" in aDragDropObserver)) 
+        return;
+      if (!this.checkCanDrop(aEvent, aDragDropObserver))
+        return;
+      var flavourSet = aDragDropObserver.getSupportedFlavours();
+      for (var flavour in flavourSet.flavourTable)
+        {
+          if (this.mDragSession.isDataFlavorSupported(flavour))
+            {
+              aDragDropObserver.onDragOver(aEvent, 
+                                           flavourSet.flavourTable[flavour], 
+                                           this.mDragSession);
+              aEvent.stopPropagation();
+              aEvent.preventDefault();
+              break;
+            }
+        }
+    },
+
+  mDragSession: null,
+
+  /** 
+   * void drop (DOMEvent aEvent, Object aDragDropObserver) ;
+   *
+   * called when the user drops on the element
+   *
+   * @param DOMEvent aEvent
+   *        the DOM event fired by the drop
+   * @param Object aDragDropObserver
+   *        javascript object of format described above that specifies
+   *        the way in which the element responds to drag events.
+   **/
+  drop: function (aEvent, aDragDropObserver)
+    {
+      if (!("onDrop" in aDragDropObserver))
+        return;
+      if (!this.checkCanDrop(aEvent, aDragDropObserver))
+        return;  
+
+      var flavourSet = aDragDropObserver.getSupportedFlavours();
+
+      var dt = aEvent.dataTransfer;
+      var dataArray = [];
+      var count = dt.mozItemCount;
+      for (var i = 0; i < count; ++i) {
+        var types = dt.mozTypesAt(i);
+        for (var j = 0; j < flavourSet.flavours.length; j++) {
+          var type = flavourSet.flavours[j].contentType;
+          // dataTransfer uses text/plain but older code used text/unicode, so
+          // switch this for compatibility
+          var modtype = (type == "text/unicode") ? "text/plain" : type;
+          if (Array.indexOf(types, modtype) >= 0) {
+            var data = dt.mozGetDataAt(modtype, i);
+            if (data) {
+              // Non-strings need some non-zero value used for their data length.
+              const kNonStringDataLength = 4;
+
+              var length = (typeof data == "string") ? data.length : kNonStringDataLength;
+              dataArray[i] = FlavourToXfer(data, length, flavourSet.flavourTable[type]);
+              break;
+            }
+          }
+        }
+      }
+
+      var transferData = new TransferDataSet(dataArray)
+
+      // hand over to the client to respond to dropped data
+      var multiple = "canHandleMultipleItems" in aDragDropObserver && aDragDropObserver.canHandleMultipleItems;
+      var dropData = multiple ? transferData : transferData.first.first;
+      aDragDropObserver.onDrop(aEvent, dropData, this.mDragSession);
+      aEvent.stopPropagation();
+    },
+
+  /** 
+   * void dragExit (DOMEvent aEvent, Object aDragDropObserver) ;
+   *
+   * called when a drag leaves this element
+   *
+   * @param DOMEvent aEvent
+   *        the DOM event fired by leaving the element
+   * @param Object aDragDropObserver
+   *        javascript object of format described above that specifies
+   *        the way in which the element responds to drag events.
+   **/
+  dragExit: function (aEvent, aDragDropObserver)
+    {
+      if (!this.checkCanDrop(aEvent, aDragDropObserver))
+        return;
+      if ("onDragExit" in aDragDropObserver)
+        aDragDropObserver.onDragExit(aEvent, this.mDragSession);
+    },  
+    
+  /** 
+   * void dragEnter (DOMEvent aEvent, Object aDragDropObserver) ;
+   *
+   * called when a drag enters in this element
+   *
+   * @param DOMEvent aEvent
+   *        the DOM event fired by entering in the element
+   * @param Object aDragDropObserver
+   *        javascript object of format described above that specifies
+   *        the way in which the element responds to drag events.
+   **/
+  dragEnter: function (aEvent, aDragDropObserver)
+    {
+      if (!this.checkCanDrop(aEvent, aDragDropObserver))
+        return;
+      if ("onDragEnter" in aDragDropObserver)
+        aDragDropObserver.onDragEnter(aEvent, this.mDragSession);
+    },  
+
+  /** 
+   * Boolean checkCanDrop (DOMEvent aEvent, Object aDragDropObserver) ;
+   *
+   * Sets the canDrop attribute for the drag session.
+   * returns false if there is no current drag session.
+   *
+   * @param DOMEvent aEvent
+   *        the DOM event fired by the drop
+   * @param Object aDragDropObserver
+   *        javascript object of format described above that specifies
+   *        the way in which the element responds to drag events.
+   **/
+  checkCanDrop: function (aEvent, aDragDropObserver)
+    {
+      if (!this.mDragSession) 
+        this.mDragSession = this.mDragService.getCurrentSession();
+      if (!this.mDragSession) 
+        return false;
+      this.mDragSession.canDrop = this.mDragSession.sourceNode != aEvent.target;
+      if ("canDrop" in aDragDropObserver)
+        this.mDragSession.canDrop &= aDragDropObserver.canDrop(aEvent, this.mDragSession);
+      return true;
+    },
+
+  /**
+   * Do a security check for drag n' drop. Make sure the source document
+   * can load the dragged link.
+   *
+   * @param DOMEvent aEvent
+   *        the DOM event fired by leaving the element
+   * @param Object aDragDropObserver
+   *        javascript object of format described above that specifies
+   *        the way in which the element responds to drag events.
+   * @param String aDraggedText
+   *        the text being dragged
+   **/
+  dragDropSecurityCheck: function (aEvent, aDragSession, aDraggedText)
+    {
+      // Strip leading and trailing whitespace, then try to create a
+      // URI from the dropped string. If that succeeds, we're
+      // dropping a URI and we need to do a security check to make
+      // sure the source document can load the dropped URI. We don't
+      // so much care about creating the real URI here
+      // (i.e. encoding differences etc don't matter), we just want
+      // to know if aDraggedText really is a URI.
+
+      aDraggedText = aDraggedText.replace(/^\s*|\s*$/g, '');
+
+      var uri;
+      var ioService = Components.classes["@mozilla.org/network/io-service;1"]
+                                .getService(Components.interfaces.nsIIOService);
+      try {
+        uri = ioService.newURI(aDraggedText, null, null);
+      } catch (e) {
+      }
+
+      if (!uri)
+        return;
+
+      // aDraggedText is a URI, do the security check.
+      const nsIScriptSecurityManager = Components.interfaces
+                                                 .nsIScriptSecurityManager;
+      var secMan = Components.classes["@mozilla.org/scriptsecuritymanager;1"]
+                             .getService(nsIScriptSecurityManager);
+
+      if (!aDragSession)
+        aDragSession = this.mDragService.getCurrentSession();
+
+      var sourceDoc = aDragSession.sourceDocument;
+      // Use "file:///" as the default sourceURI so that drops of file:// URIs
+      // are always allowed.
+      var principal = sourceDoc ? sourceDoc.nodePrincipal
+                                : secMan.getSimpleCodebasePrincipal(ioService.newURI("file:///", null, null));
+
+      try {
+        secMan.checkLoadURIStrWithPrincipal(principal, aDraggedText,
+                                            nsIScriptSecurityManager.STANDARD);
+      } catch (e) {
+        // Stop event propagation right here.
+        aEvent.stopPropagation();
+
+        throw "Drop of " + aDraggedText + " denied.";
+      }
+    }
+};
+
diff --git a/toolkit/content/nsUserSettings.js b/toolkit/content/nsUserSettings.js
new file mode 100644
index 000000000..e0c378caf
--- /dev/null
+++ b/toolkit/content/nsUserSettings.js
@@ -0,0 +1,108 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+
+/**
+ * nsPreferences - a wrapper around nsIPrefService. Provides built in
+ *                 exception handling to make preferences access simpler.
+ **/
+var nsPreferences = {
+  get mPrefService()
+    {
+      return Components.classes["@mozilla.org/preferences-service;1"]
+                       .getService(Components.interfaces.nsIPrefBranch);
+    },
+
+  setBoolPref: function (aPrefName, aPrefValue)
+    {
+      try
+        {
+          this.mPrefService.setBoolPref(aPrefName, aPrefValue);
+        }
+      catch (e)
+        {
+        }
+    },
+
+  getBoolPref: function (aPrefName, aDefVal)
+    {
+      try
+        {
+          return this.mPrefService.getBoolPref(aPrefName);
+        }
+      catch (e)
+        {
+          return aDefVal != undefined ? aDefVal : null;
+        }
+      return null;        // quiet warnings
+    },
+
+  setUnicharPref: function (aPrefName, aPrefValue)
+    {
+      try
+        {
+          var str = Components.classes["@mozilla.org/supports-string;1"]
+                              .createInstance(Components.interfaces.nsISupportsString);
+          str.data = aPrefValue;
+          this.mPrefService.setComplexValue(aPrefName,
+                                            Components.interfaces.nsISupportsString, str);
+        }
+      catch (e)
+        {
+        }
+    },
+
+  copyUnicharPref: function (aPrefName, aDefVal)
+    {
+      try
+        {
+          return this.mPrefService.getComplexValue(aPrefName,
+                                                   Components.interfaces.nsISupportsString).data;
+        }
+      catch (e)
+        {
+          return aDefVal != undefined ? aDefVal : null;
+        }
+      return null;        // quiet warnings
+    },
+
+  setIntPref: function (aPrefName, aPrefValue)
+    {
+      try
+        {
+          this.mPrefService.setIntPref(aPrefName, aPrefValue);
+        }
+      catch (e)
+        {
+        }
+    },
+
+  getIntPref: function (aPrefName, aDefVal)
+    {
+      try
+        {
+          return this.mPrefService.getIntPref(aPrefName);
+        }
+      catch (e)
+        {
+          return aDefVal != undefined ? aDefVal : null;
+        }
+      return null;        // quiet warnings
+    },
+
+  getLocalizedUnicharPref: function (aPrefName, aDefVal)
+    {
+      try
+        {
+          return this.mPrefService.getComplexValue(aPrefName,
+                                                   Components.interfaces.nsIPrefLocalizedString).data;
+        }
+      catch (e)
+        {
+          return aDefVal != undefined ? aDefVal : null;
+        }
+      return null;        // quiet warnings
+    }
+};
+
diff --git a/toolkit/content/strres.js b/toolkit/content/strres.js
new file mode 100644
index 000000000..928c8f75f
--- /dev/null
+++ b/toolkit/content/strres.js
@@ -0,0 +1,28 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+var strBundleService = null;
+
+function srGetStrBundle(path)
+{
+  var strBundle = null;
+
+  if (!strBundleService) {
+      try {
+          strBundleService =
+              Components.classes["@mozilla.org/intl/stringbundle;1"].getService();
+          strBundleService =
+              strBundleService.QueryInterface(Components.interfaces.nsIStringBundleService);
+      } catch (ex) {
+          dump("\n--** strBundleService failed: " + ex + "\n");
+          return null;
+      }
+  }
+
+  strBundle = strBundleService.createBundle(path);
+  if (!strBundle) {
+	dump("\n--** strBundle createInstance failed **--\n");
+  }
+  return strBundle;
+}