add various extensions
authorDon Armstrong <don@donarmstrong.com>
Sun, 11 Feb 2007 10:26:03 +0000 (10:26 +0000)
committerDon Armstrong <don@donarmstrong.com>
Sun, 11 Feb 2007 10:26:03 +0000 (10:26 +0000)
23 files changed:
.mozilla/firefox/default/extensions/externaleditor@nullref.se/chrome/externaleditor.jar [new file with mode: 0644]
.mozilla/firefox/default/extensions/externaleditor@nullref.se/install.rdf [new file with mode: 0644]
.mozilla/firefox/default/extensions/keyconfig@dorando/chrome.manifest [new file with mode: 0644]
.mozilla/firefox/default/extensions/keyconfig@dorando/chrome/keyconfig.jar [new file with mode: 0644]
.mozilla/firefox/default/extensions/keyconfig@dorando/components/keyconfig-service.js [new file with mode: 0644]
.mozilla/firefox/default/extensions/keyconfig@dorando/defaults/preferences/keyconfig.js [new file with mode: 0644]
.mozilla/firefox/default/extensions/keyconfig@dorando/install.js [new file with mode: 0644]
.mozilla/firefox/default/extensions/keyconfig@dorando/install.rdf [new file with mode: 0644]
.mozilla/firefox/default/extensions/vertical-tabbar@dark-demon.nm.ru/chrome.manifest [new file with mode: 0644]
.mozilla/firefox/default/extensions/vertical-tabbar@dark-demon.nm.ru/chrome/vertical-tabbar/content/browser.css [new file with mode: 0644]
.mozilla/firefox/default/extensions/vertical-tabbar@dark-demon.nm.ru/chrome/vertical-tabbar/content/browser.xbl [new file with mode: 0644]
.mozilla/firefox/default/extensions/vertical-tabbar@dark-demon.nm.ru/chrome/vertical-tabbar/content/icon.png [new file with mode: 0644]
.mozilla/firefox/default/extensions/vertical-tabbar@dark-demon.nm.ru/chrome/vertical-tabbar/skin/classic/tabbrowser.css [new file with mode: 0644]
.mozilla/firefox/default/extensions/vertical-tabbar@dark-demon.nm.ru/chrome/vertical-tabbar/skin/lolifox-theme/tabbrowser.css [new file with mode: 0644]
.mozilla/firefox/default/extensions/vertical-tabbar@dark-demon.nm.ru/install.rdf [new file with mode: 0644]
.mozilla/firefox/default/extensions/{4476fef4-3557-40b5-afcd-d6903cf7cc9d}/chrome.manifest [new file with mode: 0644]
.mozilla/firefox/default/extensions/{4476fef4-3557-40b5-afcd-d6903cf7cc9d}/chrome/chrome.jar [new file with mode: 0644]
.mozilla/firefox/default/extensions/{4476fef4-3557-40b5-afcd-d6903cf7cc9d}/defaults/preferences/prefs.js [new file with mode: 0644]
.mozilla/firefox/default/extensions/{4476fef4-3557-40b5-afcd-d6903cf7cc9d}/install.rdf [new file with mode: 0644]
.mozilla/firefox/default/extensions/{a44ef047-cd8d-406e-a354-b7101bd24735}/chrome.manifest [new file with mode: 0644]
.mozilla/firefox/default/extensions/{a44ef047-cd8d-406e-a354-b7101bd24735}/chrome/chrome.jar [new file with mode: 0644]
.mozilla/firefox/default/extensions/{a44ef047-cd8d-406e-a354-b7101bd24735}/defaults/preferences/prefs.js [new file with mode: 0644]
.mozilla/firefox/default/extensions/{a44ef047-cd8d-406e-a354-b7101bd24735}/install.rdf [new file with mode: 0644]

diff --git a/.mozilla/firefox/default/extensions/externaleditor@nullref.se/chrome/externaleditor.jar b/.mozilla/firefox/default/extensions/externaleditor@nullref.se/chrome/externaleditor.jar
new file mode 100644 (file)
index 0000000..fe8ccbb
Binary files /dev/null and b/.mozilla/firefox/default/extensions/externaleditor@nullref.se/chrome/externaleditor.jar differ
diff --git a/.mozilla/firefox/default/extensions/externaleditor@nullref.se/install.rdf b/.mozilla/firefox/default/extensions/externaleditor@nullref.se/install.rdf
new file mode 100644 (file)
index 0000000..7321449
--- /dev/null
@@ -0,0 +1,60 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+
+<!-- ***** BEGIN LICENSE BLOCK *****
+   - Version: MPL 1.1
+   -
+   - The contents of this file are subject to the Mozilla Public License Version
+   - 1.1 (the "License"); you may not use this file except in compliance with
+   - the License. You may obtain a copy of the License at
+   - http://www.mozilla.org/MPL/
+   -
+   - Software distributed under the License is distributed on an "AS IS" basis,
+   - WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+   - for the specific language governing rights and limitations under the
+   - License.
+   -
+   - The Original Code is the External Editor extension.
+   -
+   - The Initial Developer of the Original Code is Philip Nilsson.
+   - Portions created by the Initial Developer are Copyright (C) 2005, 2006
+   - the Initial Developer. All Rights Reserved.
+   -
+   - Contributor(s):
+   -
+   - ***** END LICENSE BLOCK ***** -->
+
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+         xmlns:em="http://www.mozilla.org/2004/em-rdf#">
+       <rdf:Description rdf:about="urn:mozilla:install-manifest">
+               <em:id>externaleditor@nullref.se</em:id>
+               <em:name>Editus Externus</em:name>
+               <em:version>0.9.3</em:version>
+               <em:description>Edit textboxes using an external editor.</em:description>
+               <em:type>2</em:type>
+               <em:creator>Philip Nilsson</em:creator>
+               <em:contributor>Kimitake Abe, some encoding hackery</em:contributor>
+               <em:contributor>Stas Fomin, features and more encoding hackery</em:contributor>
+               <em:contributor>MatrixIsAllOver, it locale</em:contributor>
+               <em:contributor>Goofy, fr locale</em:contributor>
+               <em:contributor>chuzo, es-ES locale</em:contributor>
+               <em:contributor>Timur Timirkhanov, ru locale</em:contributor>
+               <em:contributor>victory, ja locale</em:contributor>
+               <em:contributor>SlovakSoft, sk locale</em:contributor>
+               <em:homepageURL>http://nullref.se/projects/externaleditor</em:homepageURL>
+               <em:optionsURL>chrome://externaleditor/content/options.xul</em:optionsURL>
+               <em:iconURL>chrome://externaleditor/skin/null.png</em:iconURL>
+
+               <em:targetApplication>
+                       <rdf:Description> <!-- Firefox. -->
+                               <em:id>{ec8030f7-c20a-464f-9b0e-13a3a9e97384}</em:id>
+                               <em:minVersion>1.0+</em:minVersion>
+                               <em:maxVersion>1.6a1</em:maxVersion>
+                       </rdf:Description>
+                       <rdf:Description> <!-- Thunderbird. -->
+                               <em:id>{3550f703-e582-4d05-9a08-453d09bdfdc6}</em:id>
+                               <em:minVersion>1.0+</em:minVersion>
+                               <em:maxVersion>1.4+</em:maxVersion>
+                       </rdf:Description>
+               </em:targetApplication>
+       </rdf:Description>
+</rdf:RDF>
diff --git a/.mozilla/firefox/default/extensions/keyconfig@dorando/chrome.manifest b/.mozilla/firefox/default/extensions/keyconfig@dorando/chrome.manifest
new file mode 100644 (file)
index 0000000..e2c55ea
--- /dev/null
@@ -0,0 +1,31 @@
+
+overlay        chrome://browser/content/browser.xul    chrome://keyconfig/content/overlay.xul
+overlay        chrome://global/content/globalOverlay.xul       chrome://keyconfig/content/overlay.xul
+overlay        chrome://messenger/content/messengercompose/messengercompose.xul        chrome://keyconfig/content/overlay.xul
+overlay        chrome://xmleditor/content/xmleditor.xul        chrome://keyconfig/content/overlay.xul
+overlay        chrome://chat/content/roster.xul        chrome://keyconfig/content/overlay.xul
+overlay        chrome://chatzilla/content/chatzilla.xul        chrome://keyconfig/content/overlay.xul
+content        keyconfig       jar:chrome/keyconfig.jar!/content/
+
+skin   keyconfig       classic/1.0     jar:chrome/keyconfig.jar!/skin/
+style  chrome://keyconfig/content/keyconfig.xul        chrome://keyconfig/skin/keyconfig.css
+
+locale keyconfig       en-US   jar:chrome/keyconfig.jar!/locale/en-US/
+
+locale keyconfig       cs-CZ   jar:chrome/keyconfig.jar!/locale/cs-CZ/
+
+locale keyconfig       de-DE   jar:chrome/keyconfig.jar!/locale/de-DE/
+
+locale keyconfig       es-AR   jar:chrome/keyconfig.jar!/locale/es-AR/
+
+locale keyconfig       fr-FR   jar:chrome/keyconfig.jar!/locale/fr-FR/
+
+locale keyconfig       it-IT   jar:chrome/keyconfig.jar!/locale/it-IT/
+
+locale keyconfig       ja-JP   jar:chrome/keyconfig.jar!/locale/ja-JP/
+
+locale keyconfig       ru-RU   jar:chrome/keyconfig.jar!/locale/ru-RU/
+
+locale keyconfig       sk-SK   jar:chrome/keyconfig.jar!/locale/sk-SK/
+
+locale keyconfig       zh-TW   jar:chrome/keyconfig.jar!/locale/zh-TW/
diff --git a/.mozilla/firefox/default/extensions/keyconfig@dorando/chrome/keyconfig.jar b/.mozilla/firefox/default/extensions/keyconfig@dorando/chrome/keyconfig.jar
new file mode 100644 (file)
index 0000000..46e6596
Binary files /dev/null and b/.mozilla/firefox/default/extensions/keyconfig@dorando/chrome/keyconfig.jar differ
diff --git a/.mozilla/firefox/default/extensions/keyconfig@dorando/components/keyconfig-service.js b/.mozilla/firefox/default/extensions/keyconfig@dorando/components/keyconfig-service.js
new file mode 100644 (file)
index 0000000..a76d105
--- /dev/null
@@ -0,0 +1,110 @@
+function NSGetModule(compMgr, fileSpec) { return keyconfigModule; }\r
+\r
+var keyconfigModule = {\r
+  CID: Components.ID("{e9f7950e-d78d-4aaa-900a-c43588052eba}"),\r
+  contractID : "@dorando.at/keyconfig;1",\r
+  className  : "keyconfigService",\r
+\r
+  registerSelf: function (aComponentManager, aFileSpec, aLocation, aType) \r
+  {\r
+    aComponentManager = aComponentManager.QueryInterface(Components.interfaces.nsIComponentRegistrar);\r
+\r
+    aComponentManager.registerFactoryLocation(this.CID, this.className, this.contractID, aFileSpec, aLocation, aType);\r
+\r
+    var CategoryManager = Components.classes["@mozilla.org/categorymanager;1"]\r
+                                    .getService(Components.interfaces.nsICategoryManager);\r
+    CategoryManager.addCategoryEntry("app-startup", this.className, "service," + this.contractID, true, true, null);\r
+  },\r
+  \r
+  getClassObject: function (aComponentManager, aCID, aIID) \r
+  {\r
+    if (!aIID.equals(Components.interfaces.nsIFactory)) throw Components.results.NS_ERROR_NOT_IMPLEMENTED;\r
+\r
+    if (aCID.equals(this.CID)) return this.factory;\r
+    \r
+    throw Components.results.NS_ERROR_NO_INTERFACE;\r
+  },\r
+\r
+  factory: {\r
+    createInstance: function (aOuter, aIID)\r
+    {\r
+      if (aOuter != null) throw Components.results.NS_ERROR_NO_AGGREGATION;\r
+\r
+      return new keyconfigService();\r
+    }\r
+  },\r
+  \r
+  canUnload: function () { return true; }\r
+};\r
+\r
+function keyconfigService() { }\r
+\r
+keyconfigService.prototype = {\r
+  os: Components.classes["@mozilla.org/observer-service;1"].getService(Components.interfaces.nsIObserverService),\r
+  ps: Components.classes['@mozilla.org/preferences-service;1']\r
+                .getService(Components.interfaces.nsIPrefService).getBranch(""),\r
+  bug174320fixed: Components.interfaces.nsIDOMNSFeatureFactory ? true : false,\r
+  haspageshow: Components.interfaces.nsIDOMPageTransitionEvent ? true : false,\r
+\r
+  observe: function (aSubject, aTopic, aData) {\r
+    if(aTopic == "app-startup") this.os.addObserver(this,"domwindowopened",false);\r
+    else if(aTopic == "domwindowopened") {\r
+      aSubject.keyconfig = {service: this};\r
+      aSubject.addEventListener("load",this.load,this.bug174320fixed);\r
+    }\r
+  },\r
+\r
+  load: function(event) {\r
+    this.removeEventListener(event.type,this.keyconfig.service.load,true);\r
+\r
+    if(event.eventPhase == 2 && this.keyconfig.service.bug174320fixed)\r
+     if(this.keyconfig.service.haspageshow)\r
+      this.addEventListener("pageshow",this.keyconfig.service.init,false);\r
+     else\r
+      this.keyconfig.service.init.call(this);\r
+    else\r
+      this.addEventListener("load",this.keyconfig.service.init,false);\r
+  },\r
+\r
+  init: function() {\r
+    this.removeEventListener("pageshow",this.keyconfig.service.init,false);\r
+\r
+    this.keyconfig.removedKeys = this.document.createElement("keyset");\r
+    this.keyconfig.profile = "keyconfig." + this.keyconfig.service.ps.getCharPref("keyconfig.profile") + ".";\r
+\r
+    var i, l;\r
+\r
+    var keyset = this.document.getElementsByTagName("keyset")[0] ||\r
+                 this.document.documentElement.appendChild(this.document.createElement("keyset"));\r
+\r
+    var nodes = this.document.getElementsByTagName("key");\r
+    for(i = 0, l = nodes.length; i < l; i++) if(!nodes[i].id)\r
+      nodes[i].id = "xxx_key"+ i +"_"+nodes[i].getAttribute("command")+nodes[i].getAttribute("oncommand");\r
+\r
+    var keys = this.keyconfig.service.ps.getChildList(this.keyconfig.profile, {});\r
+\r
+    for(i = 0, l = keys.length; i < l; i++) {\r
+      var key, node;\r
+      try {\r
+       key = this.keyconfig.service.ps.getComplexValue(keys[i], Components.interfaces.nsISupportsString).data.split("][");\r
+      } catch(e) { continue; }\r
+      if(key[3] && (!key[4] || key[4] == this.document.location)) {\r
+        node = keyset.appendChild(this.document.createElement("key"));\r
+        node.id = keys[i].substr(this.keyconfig.profile.length);\r
+        node.setAttribute("oncommand",key[3]);\r
+      } else {\r
+        node = this.document.getElementById(keys[i].substr(this.keyconfig.profile.length));\r
+        if(!node) continue;\r
+      }\r
+\r
+      node.removeAttribute("modifiers"); node.removeAttribute("key"); node.removeAttribute("keycode");\r
+      node.removeAttribute("charcode");\r
+      if(key[0] == "!") {this.keyconfig.removedKeys.appendChild(node); continue;}\r
+\r
+      if(key[0]) node.setAttribute("modifiers",key[0]);\r
+      if(key[1]) node.setAttribute("key",key[1]);\r
+      if(key[2]) node.setAttribute("keycode",key[2]);\r
+    }\r
+  }\r
+\r
+}\r
diff --git a/.mozilla/firefox/default/extensions/keyconfig@dorando/defaults/preferences/keyconfig.js b/.mozilla/firefox/default/extensions/keyconfig@dorando/defaults/preferences/keyconfig.js
new file mode 100644 (file)
index 0000000..aab9fea
--- /dev/null
@@ -0,0 +1,5 @@
+pref("keyconfig.devmode", false);\r
+pref("keyconfig.nicenames.reverse_order", false);\r
+pref("keyconfig.profile", "main");\r
+pref("keyconfig.warnOnClose", true);\r
+pref("keyconfig.warnOnDuplicate", true);
\ No newline at end of file
diff --git a/.mozilla/firefox/default/extensions/keyconfig@dorando/install.js b/.mozilla/firefox/default/extensions/keyconfig@dorando/install.js
new file mode 100644 (file)
index 0000000..1d0fa69
--- /dev/null
@@ -0,0 +1,32 @@
+initInstall("keyconfig", "/dorando/keyconfig/", ""); \r
+\r
+var chromeDir = getFolder("Profile", "chrome");\r
+\r
+addFile("keyconfig","chrome/keyconfig.jar",chromeDir,"");\r
+addFile("keyconfig-service","components/keyconfig-service.js",getFolder("Program","components"),"");\r
+addFile("keyconfig-pref","defaults/preferences/keyconfig.js",getFolder("Program","defaults/pref"),"");\r
+\r
+registerChrome(PACKAGE | PROFILE_CHROME, getFolder(chromeDir,"keyconfig.jar"), "content/");\r
+registerChrome(SKIN | PROFILE_CHROME, getFolder(chromeDir,"keyconfig.jar"), "skin/");\r
+\r
+function l(a)\r
+{\r
+  registerChrome(LOCALE | PROFILE_CHROME, getFolder(chromeDir,"keyconfig.jar"), "locale/"+a);\r
+}\r
+\r
+l("en-US/");\r
+\r
+l("cs-CZ/");\r
+l("de-DE/");\r
+l("es-AR/");\r
+l("fr-FR/");\r
+l("it-IT/");\r
+l("ja-JP/");\r
+l("ru-RU/");\r
+l("sk-SK/");\r
+l("zh-TW/");\r
+\r
+if (0 == getLastError())\r
+  performInstall();\r
+else\r
+  cancelInstall();
\ No newline at end of file
diff --git a/.mozilla/firefox/default/extensions/keyconfig@dorando/install.rdf b/.mozilla/firefox/default/extensions/keyconfig@dorando/install.rdf
new file mode 100644 (file)
index 0000000..7fd7024
--- /dev/null
@@ -0,0 +1,114 @@
+<?xml version="1.0"?>\r
+<rdf:RDF\r
+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"\r
+ xmlns="http://www.mozilla.org/2004/em-rdf#">\r
+\r
+  <rdf:Description rdf:about="urn:mozilla:install-manifest">\r
+    <id>keyconfig@dorando</id>\r
+    <name>keyconfig</name>\r
+    <version>20060828</version>\r
+    <creator>Dorando</creator>\r
+    <contributor>Hadar Hagai</contributor>\r
+    <contributor>MatrixIsAllOver of eXtenZilla.it (it-IT)</contributor>\r
+    <contributor>Mori (fr-FR)</contributor>\r
+    <contributor>SHIMODA Hiroshi (ja-JP)</contributor>\r
+    <contributor>SlovakSoft (sk-SK)</contributor>\r
+    <contributor>Tomáš Kopečný (cs-CZ)</contributor>\r
+    <contributor>ReinekeFux - erweiterungen.de (de-DE)</contributor>\r
+    <contributor>stoneflash (ru-RU)</contributor>\r
+    <contributor>ZuGro (es-AR)</contributor>\r
+    <contributor>rexx26 (zh-TW)</contributor>\r
+    <homepageURL>http://mozilla.dorando.at/</homepageURL>\r
+    <description>Rebind your keys.</description>\r
+    <updateURL>http://mozilla.dorando.at/update.rdf</updateURL>\r
+    \r
+    <targetApplication><rdf:Description>\r
+      <id>{ec8030f7-c20a-464f-9b0e-13a3a9e97384}</id>\r
+      <minVersion>1.5.0.6</minVersion>\r
+      <maxVersion>1.5.0.6</maxVersion>\r
+    </rdf:Description></targetApplication>\r
+    \r
+    <targetApplication><rdf:Description>\r
+      <id>{3550f703-e582-4d05-9a08-453d09bdfdc6}</id>\r
+      <minVersion>1.5.0.5</minVersion>\r
+      <maxVersion>1.5.0.5</maxVersion>\r
+    </rdf:Description></targetApplication>\r
+\r
+    <targetApplication><rdf:Description>\r
+      <id>{718e30fb-e89b-41dd-9da7-e25a45638b28}</id>\r
+      <minVersion>0.3a1+</minVersion>\r
+      <maxVersion>0.3a1+</maxVersion>\r
+    </rdf:Description></targetApplication>\r
+\r
+    <targetApplication><rdf:Description>\r
+      <id>{136c295a-4a5a-41cf-bf24-5cee526720d5}</id>\r
+      <minVersion>1.0</minVersion>\r
+      <maxVersion>1.0</maxVersion>\r
+    </rdf:Description></targetApplication>\r
+\r
+    <targetApplication><rdf:Description>\r
+      <id>{3a699c0b-c85e-4a8d-baf1-948bdcfb75bd}</id>\r
+      <minVersion>0.3.1</minVersion>\r
+      <maxVersion>0.3.1</maxVersion>\r
+    </rdf:Description></targetApplication>\r
+\r
+    <targetApplication><rdf:Description>\r
+      <id>{a463f10c-3994-11da-9945-000d60ca027b}</id>\r
+      <minVersion>0.7.4.1</minVersion>\r
+      <maxVersion>0.7.4.1</maxVersion>\r
+    </rdf:Description></targetApplication>\r
+\r
+    <targetApplication><rdf:Description>\r
+      <id>{59c81df5-4b7a-477b-912d-4e0fdf64e5f2}</id>\r
+      <minVersion>0.9.75</minVersion>\r
+      <maxVersion>0.9.75</maxVersion>\r
+    </rdf:Description></targetApplication>\r
+\r
+    <targetApplication><rdf:Description>\r
+      <id>{4669bfc0-2957-11da-8cd6-0800200c9a66}</id>\r
+      <minVersion>0</minVersion>\r
+      <maxVersion>0</maxVersion>\r
+    </rdf:Description></targetApplication>\r
+\r
+    <targetApplication><rdf:Description>\r
+      <id>{3db10fab-e461-4c80-8b97-957ad5f8ea47}</id>\r
+      <minVersion>8.1</minVersion>\r
+      <maxVersion>8.1</maxVersion>\r
+    </rdf:Description></targetApplication>\r
+\r
+    <targetApplication><rdf:Description>\r
+      <id>{758DAD28-FDE9-4ab8-A301-3FFFAB3A697A}</id>\r
+      <minVersion>0</minVersion>\r
+      <maxVersion>0</maxVersion>\r
+    </rdf:Description></targetApplication>\r
+\r
+    <targetApplication><rdf:Description>\r
+      <id>songbird@songbirdnest.com</id>\r
+      <minVersion>0</minVersion>\r
+      <maxVersion>0</maxVersion>\r
+    </rdf:Description></targetApplication>\r
+\r
+    <targetApplication><rdf:Description>\r
+      <id>{92650c4d-4b8e-4d2a-b7eb-24ecf4f6b63a}</id>\r
+      <minVersion>0</minVersion>\r
+      <maxVersion>0</maxVersion>\r
+    </rdf:Description></targetApplication>\r
+\r
+    <file><rdf:Description rdf:about="urn:mozilla:extension:file:keyconfig.jar">\r
+      <package>content/</package>\r
+      <locale>locale/en-US/</locale>\r
+\r
+      <locale>locale/cs-CZ/</locale>\r
+      <locale>locale/de-DE/</locale>\r
+      <locale>locale/es-AR/</locale>\r
+      <locale>locale/fr-FR/</locale>\r
+      <locale>locale/it-IT/</locale>\r
+      <locale>locale/ja-JP/</locale>\r
+      <locale>locale/ru-RU/</locale>\r
+      <locale>locale/sk-SK/</locale>\r
+      <locale>locale/zh-TW/</locale>\r
+      <skin>skin/</skin>\r
+    </rdf:Description></file>\r
+  </rdf:Description>\r
+\r
+</rdf:RDF>
\ No newline at end of file
diff --git a/.mozilla/firefox/default/extensions/vertical-tabbar@dark-demon.nm.ru/chrome.manifest b/.mozilla/firefox/default/extensions/vertical-tabbar@dark-demon.nm.ru/chrome.manifest
new file mode 100644 (file)
index 0000000..1cf83bb
--- /dev/null
@@ -0,0 +1,8 @@
+content vertical-tabbar chrome/vertical-tabbar/content/\r
+\r
+skin   vertical-tabbar classic/1.0     chrome/vertical-tabbar/skin/classic/\r
+skin   vertical-tabbar lolifox-(default)       chrome/vertical-tabbar/skin/lolifox-theme/\r
+skin   vertical-tabbar lolifox-theme   chrome/vertical-tabbar/skin/lolifox-theme/\r
+\r
+style  chrome://browser/content/browser.xul chrome://vertical-tabbar/content/browser.css\r
+style  chrome://browser/content/browser.xul chrome://vertical-tabbar/skin/tabbrowser.css
\ No newline at end of file
diff --git a/.mozilla/firefox/default/extensions/vertical-tabbar@dark-demon.nm.ru/chrome/vertical-tabbar/content/browser.css b/.mozilla/firefox/default/extensions/vertical-tabbar@dark-demon.nm.ru/chrome/vertical-tabbar/content/browser.css
new file mode 100644 (file)
index 0000000..c732ff1
--- /dev/null
@@ -0,0 +1,88 @@
+@namespace url("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul");\r
+\r
+#appcontent tabbrowser\r
+{\r
+       -moz-binding: url('browser.xbl#tabbrowser') !important;\r
+}\r
+\r
+.tab-text\r
+{\r
+       -moz-margin-start: 0;\r
+       text-indent: 18px;\r
+       width:100%\r
+}\r
+\r
+.tab-icon\r
+{\r
+  list-style-image: url("chrome://global/skin/icons/folder-item.png");\r
+  -moz-image-region: rect(0px, 16px, 16px, 0px);\r
+  opacity: .8;\r
+}\r
+\r
+#appcontent .tabbrowser-tabs {\r
+       -moz-binding: url("browser.xbl#tabbrowser-tabs") !important;\r
+       padding: 2px 2px 2px 0 !important;\r
+       background: none;\r
+       -moz-padding-start: 0px;\r
+       border-left: 1px solid steelblue !important;\r
+       border: none !important;\r
+       width: 100%;\r
+       max-width: 10000px;\r
+       min-width: 0px;\r
+       overflow-y: auto !important;\r
+       overflow-x: hidden !important;\r
+}\r
+\r
+#appcontent .tabbrowser-tab {\r
+       -moz-appearance: none !important;\r
+       -moz-binding: url("browser.xbl#tabbrowser-tab") !important;\r
+       padding: 2px !important;\r
+       background: none;\r
+       border: none !important;\r
+       outline: 1px solid steelblue !important;\r
+       margin: 2px 2px 3px 1px !important;\r
+       -moz-box-pack: start !important;\r
+       -moz-box-align: start !important;\r
+       min-height: 20px;\r
+       font-size: 12px !important;\r
+       overflow: hidden;\r
+}\r
+#appcontent .tabbrowser-tab[selected=true]\r
+{\r
+       font-weight: bold;\r
+}\r
+#appcontent .tabbrowser-tab[selected=true] .tab-icon\r
+{\r
+       opacity: 1;\r
+}\r
+#appcontent .tabbrowser-tab[busy] .tab-icon {\r
+       list-style-image: url("chrome://global/skin/throbber/Throbber-small.gif");\r
+}\r
+#appcontent .tabbrowser-tab .tab-icon \r
+{\r
+       height: 16px;\r
+       width: 16px;\r
+}\r
+#appcontent .tabbrowser-strip\r
+{\r
+       width: 100%;\r
+       -moz-box-orient: vertical !important;\r
+}\r
+\r
+#appcontent tabbox\r
+{\r
+       -moz-box-orient: horizontal;\r
+       -moz-box-direction: reverse;\r
+}\r
+\r
+#appcontent tabpanels {\r
+  -moz-appearance: none;\r
+}\r
+\r
+#appcontent .tabbrowser-splitter\r
+{\r
+       border:none; \r
+       width:4px; \r
+       min-width:0; \r
+       border-left: 1px solid steelblue\r
+}
\ No newline at end of file
diff --git a/.mozilla/firefox/default/extensions/vertical-tabbar@dark-demon.nm.ru/chrome/vertical-tabbar/content/browser.xbl b/.mozilla/firefox/default/extensions/vertical-tabbar@dark-demon.nm.ru/chrome/vertical-tabbar/content/browser.xbl
new file mode 100644 (file)
index 0000000..ca14bf9
--- /dev/null
@@ -0,0 +1,2358 @@
+<?xml version="1.0"?>
+
+<!DOCTYPE bindings [
+<!ENTITY % tabBrowserDTD SYSTEM "chrome://global/locale/tabbrowser.dtd" >
+%tabBrowserDTD;
+<!ENTITY % globalDTD SYSTEM "chrome://global/locale/global.dtd">
+%globalDTD;
+]>
+
+<bindings id="vertical-tabbar-bindings"
+          xmlns="http://www.mozilla.org/xbl"
+          xmlns:xul="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+          xmlns:xbl="http://www.mozilla.org/xbl">
+
+
+
+  <binding id="tabbrowser">
+    <content>
+      <xul:stringbundle anonid="tbstringbundle" src="chrome://global/locale/tabbrowser.properties"/>
+      <xul:tabbox anonid="tabbox" flex="1" eventnode="document" xbl:inherits="handleCtrlPageUpDown"
+                  onselect="if (!('updateCurrentBrowser' in this.parentNode) || event.target.localName != 'tabpanels') return; this.parentNode.updateCurrentBrowser();">
+        <xul:vbox class="tabbrowser-strip" collapsed="true" tooltip="_child" context="_child"
+                  anonid="strip" width="102" orient="vertical"
+                  ondraggesture="nsDragAndDrop.startDrag(event, this.parentNode.parentNode); event.stopPropagation();"
+                  ondragover="nsDragAndDrop.dragOver(event, this.parentNode.parentNode); event.stopPropagation();"
+                  ondragdrop="nsDragAndDrop.drop(event, this.parentNode.parentNode); event.stopPropagation();"
+                  ondragexit="nsDragAndDrop.dragExit(event, this.parentNode.parentNode); event.stopPropagation();">
+          <xul:tooltip onpopupshowing="return this.parentNode.parentNode.parentNode.createTooltip(event);"/>
+          <xul:menupopup anonid="tabContextMenu" onpopupshowing="this.parentNode.parentNode.parentNode.updatePopupMenu(this);">
+            <xul:menuitem label="&newTab.label;" accesskey="&newTab.accesskey;"
+                          xbl:inherits="oncommand=onnewtab"/>
+            <xul:menuseparator/>
+            <xul:menuitem label="&reloadTab.label;" accesskey="&reloadTab.accesskey;"
+                          oncommand="var tabbrowser = this.parentNode.parentNode.parentNode.parentNode;
+                                     tabbrowser.reloadTab(tabbrowser.mContextTab);"/>
+            <xul:menuitem label="&reloadAllTabs.label;" accesskey="&reloadAllTabs.accesskey;"
+                          tbattr="tabbrowser-multiple"
+                          oncommand="var tabbrowser = this.parentNode.parentNode.parentNode.parentNode;
+                                     tabbrowser.reloadAllTabs(tabbrowser.mContextTab);"/>
+            <xul:menuitem label="&closeOtherTabs.label;" accesskey="&closeOtherTabs.accesskey;"
+                          tbattr="tabbrowser-multiple"
+                          oncommand="var tabbrowser = this.parentNode.parentNode.parentNode.parentNode;
+                                     tabbrowser.removeAllTabsBut(tabbrowser.mContextTab);"/>
+            <xul:menuseparator/>
+            <xul:menuitem label="&closeTab.label;" accesskey="&closeTab.accesskey;"
+                          tbattr="tabbrowser-multiple"
+                          oncommand="var tabbrowser = this.parentNode.parentNode.parentNode.parentNode;
+                                     tabbrowser.removeTab(tabbrowser.mContextTab);"/>
+          </xul:menupopup>
+
+          <xul:tabs class="tabbrowser-tabs" flex="1"
+                    anonid="tabcontainer"
+                    setfocus="false"
+                    onclick="this.parentNode.parentNode.parentNode.onTabClick(event);"
+                    xbl:inherits="onnewtab"
+                    ondblclick="this.parentNode.parentNode.parentNode.onTabBarDblClick(event);"
+                    onclosetab="var node = this.parentNode;
+                                while (node.localName != 'tabbrowser')
+                                  node = node.parentNode;
+                                node.removeCurrentTab();">
+            <xul:tab selected="true" validate="never"
+                     onerror="this.parentNode.parentNode.parentNode.parentNode.addToMissedIconCache(this.getAttribute('image'));
+                              this.removeAttribute('image');"
+                      flex="100"
+                     class="tabbrowser-tab" label="&untitledTab;" crop="end"/>
+          </xul:tabs>
+        </xul:vbox>
+        <xul:splitter class="tabbrowser-splitter" collapse="before" resizeafter="closest" resizebefore="closest" ondblclick="this.previousSibling.width=102">
+               <xul:grippy />
+        </xul:splitter>
+        <xul:tabpanels flex="1" class="plain" selectedIndex="0" anonid="panelcontainer">
+          <xul:notificationbox flex="1">
+            <xul:browser flex="1" type="content-primary" message="true" disablehistory="true"
+                         xbl:inherits="tooltip=contenttooltip,contextmenu=contentcontextmenu,autocompletepopup"/>
+          </xul:notificationbox>
+        </xul:tabpanels>
+      </xul:tabbox>
+      <children/>
+    </content>
+    <implementation>
+      <field name="mTabstrip">
+        document.getAnonymousElementByAttribute(this, "anonid", "arrowscrollbox");
+      </field>
+      <field name="mPrefs" readonly="true">
+        Components.classes['@mozilla.org/preferences-service;1']
+                  .getService(Components.interfaces.nsIPrefService)
+                  .getBranch(null);
+      </field>
+      <field name="mURIFixup" readonly="true">
+        Components.classes["@mozilla.org/docshell/urifixup;1"]
+                  .getService(Components.interfaces.nsIURIFixup);
+      </field>
+      <field name="mTabBox" readonly="true">
+        document.getAnonymousElementByAttribute(this, "anonid", "tabbox");
+      </field>
+      <field name="mTabDropIndicatorBar">
+        this.mTabBox.childNodes[0]
+      </field>
+      <field name="mStrip" readonly="true">
+        document.getAnonymousElementByAttribute(this, "anonid", "strip");
+      </field>
+      <field name="mTabContainer" readonly="true">
+        document.getAnonymousElementByAttribute(this, "anonid", "tabcontainer");
+      </field>
+      <field name="mPanelContainer" readonly="true">
+        document.getAnonymousElementByAttribute(this, "anonid", "panelcontainer");
+      </field>
+      <field name="mTabs" readonly="true">
+        this.mTabContainer.childNodes
+      </field>
+      <field name="mStringBundle">
+        document.getAnonymousElementByAttribute(this, "anonid", "tbstringbundle");
+      </field>
+      <field name="mCurrentTab">
+        null
+      </field>
+      <field name="mCurrentBrowser">
+        null
+      </field>
+      <field name="mProgressListeners">
+        []
+      </field>
+      <field name="mTabListeners">
+        new Array()
+      </field>
+      <field name="mTabFilters">
+        new Array()
+      </field>
+      <field name="mTabbedMode">
+        false
+      </field>
+      <field name="mIsBusy">
+        false
+      </field>
+      <field name="mMissedIconCache">
+        null
+      </field>
+      <field name="mContextTab">
+        null
+      </field>
+      <field name="mModalDialogShowing">
+        false
+      </field>
+      <field name="arrowKeysShouldWrap" readonly="true">
+        false
+      </field>
+      <field name="mAddProgressListenerWasCalled">
+        false
+      </field>
+      <field name="_browsers">
+        null
+      </field>
+
+      <field name="_blockDblClick">
+        false
+      </field>
+
+      <method name="getBrowserAtIndex">
+        <parameter name="aIndex"/>
+        <body>
+          <![CDATA[
+            return this.mTabContainer.childNodes[aIndex].linkedBrowser;
+          ]]>
+        </body>
+      </method>
+
+      <method name="getBrowserIndexForDocument">
+        <parameter name="aDocument"/>
+        <body>
+          <![CDATA[
+            for (var i = 0; i < this.mPanelContainer.childNodes.length; i++) {
+              if (this.getBrowserAtIndex(i).contentDocument == aDocument) {
+                return i;
+              }
+            }
+            return -1;
+          ]]>
+        </body>
+      </method>
+
+      <method name="getBrowserForDocument">
+        <parameter name="aDocument"/>
+        <body>
+          <![CDATA[
+            var index = this.getBrowserIndexForDocument(aDocument);
+            if (index < 0)
+              return null;
+            return this.getBrowserAtIndex(index);
+          ]]>
+        </body>
+      </method>
+
+      <method name="getNotificationBox">
+        <parameter name="aBrowser"/>
+        <body>
+          <![CDATA[
+            if (aBrowser)
+              return aBrowser.parentNode;
+            else if (this.mCurrentBrowser)
+              return this.mCurrentBrowser.parentNode;
+            return null;
+          ]]>
+        </body>
+      </method>
+
+      <!-- A web progress listener object definition for a given tab. -->
+      <method name="mTabProgressListener">
+        <parameter name="aTab"/>
+        <parameter name="aBrowser"/>
+        <parameter name="aStartsBlank"/>
+        <body>
+        <![CDATA[
+          return ({
+            mTabBrowser: this,
+            mTab: aTab,
+            mBrowser: aBrowser,
+            mBlank: aStartsBlank,
+            mLastURI: null,
+
+            // cache flags for correct status bar update after tab switching
+            mStateFlags: 0,
+            mStatus: 0,
+            mMessage: "",
+            mTotalProgress: 0,
+
+            // count of open requests (should always be 0 or 1)
+            mRequestCount: 0,
+
+            onProgressChange : function (aWebProgress, aRequest,
+                                         aCurSelfProgress, aMaxSelfProgress,
+                                         aCurTotalProgress, aMaxTotalProgress)
+            {
+              if (!this.mBlank && this.mTabBrowser.mCurrentTab == this.mTab) {
+                for (var i = 0; i < this.mTabBrowser.mProgressListeners.length; i++) {
+                  var p = this.mTabBrowser.mProgressListeners[i];
+                  if (p)
+                    p.onProgressChange(aWebProgress, aRequest,
+                                       aCurSelfProgress, aMaxSelfProgress,
+                                       aCurTotalProgress, aMaxTotalProgress);
+                }
+              }
+
+              this.mTotalProgress = aMaxTotalProgress ? aCurTotalProgress / aMaxTotalProgress : 0;
+            },
+
+            onStateChange : function(aWebProgress, aRequest, aStateFlags, aStatus)
+            {
+              if (!aRequest)
+                return;
+
+              var oldBlank = this.mBlank;
+
+              const nsIWebProgressListener = Components.interfaces.nsIWebProgressListener;
+              const nsIChannel = Components.interfaces.nsIChannel;
+
+              if (aStateFlags & nsIWebProgressListener.STATE_START) {
+                this.mRequestCount++;
+              }
+              else if (aStateFlags & nsIWebProgressListener.STATE_STOP) {
+                const NS_ERROR_UNKNOWN_HOST = 2152398878;
+                if (--this.mRequestCount > 0 && aStatus == NS_ERROR_UNKNOWN_HOST) {
+                  // to prevent bug 235825: wait for the request handled
+                  // by the automatic keyword resolver
+                  return;
+                }
+                // since we (try to) only handle STATE_STOP of the last request,
+                // the count of open requests should now be 0
+                this.mRequestCount = 0;
+              }
+
+              if (aStateFlags & nsIWebProgressListener.STATE_START &&
+                  aStateFlags & nsIWebProgressListener.STATE_IS_NETWORK) {
+                // It's okay to clear what the user typed when we start
+                // loading a document. If the user types, this counter gets
+                // set to zero, if the document load ends without an
+                // onLocationChange, this counter gets decremented
+                // (so we keep it while switching tabs after failed loads)
+                if (aWebProgress.DOMWindow == this.mBrowser.contentWindow)
+                  this.mBrowser.userTypedClear++;
+
+                if (!this.mBlank) {
+                  this.mTab.setAttribute("busy", "true");
+                  this.mTabBrowser.updateIcon(this.mTab);
+                  this.mTabBrowser.setTabTitleLoading(this.mTab);
+
+                  if (this.mTabBrowser.mCurrentTab == this.mTab)
+                    this.mTabBrowser.mIsBusy = true;
+                }
+              }
+              else if (aStateFlags & nsIWebProgressListener.STATE_STOP &&
+                       aStateFlags & nsIWebProgressListener.STATE_IS_NETWORK) {
+                if (aWebProgress.DOMWindow == this.mBrowser.contentWindow) {
+                  // The document is done loading, we no longer want the
+                  // value cleared.
+                  if (this.mBrowser.userTypedClear > 0)
+                    this.mBrowser.userTypedClear--;
+
+                  if (!this.mBrowser.mIconURL)
+                    this.mTabBrowser.useDefaultIcon(this.mTab);
+                }
+
+                if (this.mBlank)
+                  this.mBlank = false;
+
+                this.mTab.removeAttribute("busy");
+                this.mTabBrowser.updateIcon(this.mTab);
+
+                var location = aRequest.QueryInterface(nsIChannel).URI;
+
+                // For keyword URIs clear the user typed value since they will be changed into real URIs
+                if (location.scheme == "keyword")
+                  this.mBrowser.userTypedValue = null;
+
+                if (this.mTab.label == this.mTabBrowser.mStringBundle.getString("tabs.loading"))
+                  this.mTabBrowser.setTabTitle(this.mTab);
+
+                if (this.mTabBrowser.mCurrentTab == this.mTab)
+                  this.mTabBrowser.mIsBusy = false;
+              }
+
+              if (this.mTabBrowser.mCurrentTab == this.mTab) {
+                for (var i = 0; i < this.mTabBrowser.mProgressListeners.length; i++) {
+                  var p = this.mTabBrowser.mProgressListeners[i];
+                  if (p && !oldBlank)
+                    p.onStateChange(aWebProgress, aRequest, aStateFlags, aStatus);
+                  // make sure that the visible status of new blank tabs is correctly set
+                  else if (p && "onUpdateCurrentBrowser" in p)
+                    p.onUpdateCurrentBrowser(aStateFlags, aStatus, "", 0);
+                }
+              }
+
+              if (aStateFlags & (nsIWebProgressListener.STATE_START |
+                                 nsIWebProgressListener.STATE_STOP)) {
+                // reset cached temporary values at beginning and end
+                this.mMessage = "";
+                this.mTotalProgress = 0;
+              }
+              this.mStateFlags = aStateFlags;
+              this.mStatus = aStatus;
+            },
+
+            onLocationChange : function(aWebProgress, aRequest, aLocation)
+            {
+              // The document loaded correctly, clear the value if we should
+              if (this.mBrowser.userTypedClear > 0 && aRequest)
+                this.mBrowser.userTypedValue = null;
+
+              if (aWebProgress.DOMWindow == this.mBrowser.contentWindow &&
+                  aWebProgress.isLoadingDocument)
+                this.mTabBrowser.setIcon(this.mTab, null);
+
+              // changing location, clear out the missing plugins list
+              this.mTab.missingPlugins = null;
+
+              if (!this.mBlank && this.mTabBrowser.mCurrentTab == this.mTab) {
+                for (var i = 0; i < this.mTabBrowser.mProgressListeners.length; i++) {
+                  var p = this.mTabBrowser.mProgressListeners[i];
+                  if (p)
+                    p.onLocationChange(aWebProgress, aRequest, aLocation);
+                }
+              }
+            },
+
+            onStatusChange : function(aWebProgress, aRequest, aStatus, aMessage)
+            {
+              if (this.mBlank)
+                return;
+
+              if (this.mTabBrowser.mCurrentTab == this.mTab) {
+                for (var i = 0; i < this.mTabBrowser.mProgressListeners.length; i++) {
+                  var p = this.mTabBrowser.mProgressListeners[i];
+                  if (p)
+                    p.onStatusChange(aWebProgress, aRequest, aStatus, aMessage);
+                }
+              }
+
+              this.mMessage = aMessage;
+            },
+
+            onSecurityChange : function(aWebProgress, aRequest, aState)
+            {
+              if (this.mTabBrowser.mCurrentTab == this.mTab) {
+                for (var i = 0; i < this.mTabBrowser.mProgressListeners.length; i++) {
+                  var p = this.mTabBrowser.mProgressListeners[i];
+                  if (p)
+                    p.onSecurityChange(aWebProgress, aRequest, aState);
+                }
+              }
+            },
+
+            QueryInterface : function(aIID)
+            {
+              if (aIID.equals(Components.interfaces.nsIWebProgressListener) ||
+                  aIID.equals(Components.interfaces.nsISupportsWeakReference) ||
+                  aIID.equals(Components.interfaces.nsISupports))
+                return this;
+              throw Components.results.NS_NOINTERFACE;
+            }
+          });
+        ]]>
+        </body>
+      </method>
+
+      <method name="setIcon">
+        <parameter name="aTab"/>
+        <parameter name="aURI"/>
+        <body>
+          <![CDATA[
+            var browser = this.getBrowserForTab(aTab);
+            browser.mIconURL = aURI;
+
+            this.updateIcon(aTab);
+
+            for (var i = 0; i < this.mProgressListeners.length; i++) {
+              var p = this.mProgressListeners[i];
+              if ('onLinkIconAvailable' in p)
+                p.onLinkIconAvailable(browser);
+            }
+          ]]>
+        </body>
+      </method>
+
+      <method name="updateIcon">
+        <parameter name="aTab"/>
+        <body>
+          <![CDATA[
+            var browser = this.getBrowserForTab(aTab);
+            if (!aTab.hasAttribute("busy") && browser.mIconURL)
+              aTab.setAttribute("image", browser.mIconURL);
+            else
+              aTab.removeAttribute("image");
+          ]]>
+        </body>
+      </method>
+
+      <method name="shouldLoadFavIcon">
+        <parameter name="aURI"/>
+        <body>
+          <![CDATA[
+            return (aURI && this.mPrefs.getBoolPref("browser.chrome.site_icons") &&
+                    this.mPrefs.getBoolPref("browser.chrome.favicons") &&
+                    ("schemeIs" in aURI) && (aURI.schemeIs("http") || aURI.schemeIs("https")));
+          ]]>
+        </body>
+      </method>
+
+      <method name="useDefaultIcon">
+        <parameter name="aTab"/>
+        <body>
+          <![CDATA[
+            var browser = this.getBrowserForTab(aTab);
+            if (browser.contentDocument instanceof ImageDocument) {
+              if (this.mPrefs.getBoolPref("browser.chrome.site_icons")) {
+                try {
+                  var sz = this.mPrefs.getIntPref("browser.chrome.image_icons.max_size");
+                  if (!sz)
+                    return;
+
+                  var req = browser.contentDocument.imageRequest;
+                  if (!req || !req.image ||
+                      req.image.width > sz ||
+                      req.image.height > sz)
+                    return;
+
+                  this.setIcon(aTab, browser.currentURI.spec);
+                } catch (e) { }
+              }
+            }
+            else if (this.shouldLoadFavIcon(browser.currentURI)) {
+              var url = browser.currentURI.prePath + "/favicon.ico";
+              if (!this.isIconKnownMissing(url))
+                this.setIcon(aTab, url);
+            }
+          ]]>
+        </body>
+      </method>
+
+      <method name="addToMissedIconCache">
+        <parameter name="aURI"/>
+        <body>
+          <![CDATA[
+            var entry = this.openCacheEntry(aURI, Components.interfaces.nsICache.ACCESS_READ_WRITE);
+            if (!entry)
+              return;
+
+            if (entry.accessGranted == Components.interfaces.nsICache.ACCESS_WRITE)
+              // It's a new entry.  Just write a bit of metadata in to the entry.
+              entry.setMetaDataElement("Icon", "Missed");
+            entry.markValid();
+            entry.close();
+          ]]>
+        </body>
+      </method>
+
+      <method name="openCacheEntry">
+        <parameter name="key"/>
+        <parameter name="access"/>
+        <body>
+          <![CDATA[
+            try {
+              if (!this.mMissedIconCache) {
+                var cacheService = Components.classes['@mozilla.org/network/cache-service;1'].getService(Components.interfaces.nsICacheService);
+                this.mMissedIconCache = cacheService.createSession("MissedIconCache", Components.interfaces.nsICache.STORE_ANYWHERE, true);
+                if (!this.mMissedIconCache)
+                  return null;
+              }
+              return this.mMissedIconCache.openCacheEntry(key, access, true);
+            }
+            catch (e) {
+              return null;
+            }
+          ]]>
+        </body>
+      </method>
+
+      <method name="isIconKnownMissing">
+        <parameter name="key"/>
+        <body>
+          <![CDATA[
+            var e = this.openCacheEntry(key, Components.interfaces.nsICache.ACCESS_READ);
+            if (e) {
+                e.close();
+                return true;
+            }
+            return false;
+          ]]>
+        </body>
+      </method>
+
+      <method name="updateTitlebar">
+        <body>
+          <![CDATA[
+            var newTitle = "";
+            var docTitle;
+            var docElement = this.ownerDocument.documentElement;
+            var sep = docElement.getAttribute("titlemenuseparator");
+
+            if (this.docShell.contentViewer)
+              docTitle = this.contentTitle;
+
+            if (!docTitle)
+              docTitle = docElement.getAttribute("titledefault");
+
+            var modifier = docElement.getAttribute("titlemodifier");
+            if (docTitle) {
+              newTitle += docElement.getAttribute("titlepreface");
+              newTitle += docTitle;
+              if (modifier)
+                newTitle += sep;
+            }
+            newTitle += modifier;
+
+            // If location bar is hidden and the URL type supports a host,
+            // add the scheme and host to the title to prevent spoofing.
+            // XXX https://bugzilla.mozilla.org/show_bug.cgi?id=22183#c239
+            // (only for schemes that support a host)
+            try {
+              if (docElement.getAttribute("chromehidden").indexOf("location") != -1) {
+                var uri = this.mURIFixup.createExposableURI(
+                            this.mCurrentBrowser.currentURI);
+                if (uri.host)
+                  newTitle = uri.prePath + sep + newTitle;
+              }
+            } catch (e) {}
+
+            this.ownerDocument.title = newTitle;
+          ]]>
+        </body>
+      </method>
+
+      <method name="updatePopupMenu">
+        <parameter name="aPopupMenu"/>
+        <body>
+          <![CDATA[
+            this.mContextTab = document.popupNode;
+            var disabled = this.mPanelContainer.childNodes.length == 1;
+            var menuItems = aPopupMenu.getElementsByAttribute("tbattr", "tabbrowser-multiple");
+            for (var i = 0; i < menuItems.length; i++)
+              menuItems[i].disabled = disabled;
+          ]]>
+        </body>
+      </method>
+
+      <method name="updateCurrentBrowser">
+        <body>
+          <![CDATA[
+            var newBrowser = this.getBrowserAtIndex(this.mTabContainer.selectedIndex);
+            if (this.mCurrentBrowser == newBrowser)
+              return;
+
+            if (this.mCurrentBrowser) {
+              // Only save the focused element if it is in our content window
+              // or in an ancestor window.
+              var focusedWindow = document.commandDispatcher.focusedWindow;
+              var saveFocus = false;
+
+              if (focusedWindow && focusedWindow.top == window.content) {
+                saveFocus = true;
+              } else {
+                var contentWindow = window;
+
+                while (contentWindow) {
+                  if (contentWindow == focusedWindow) {
+                    saveFocus = true;
+                    break;
+                  }
+
+                  if (contentWindow.parent == contentWindow) {
+                    break;
+                  }
+
+                  contentWindow = contentWindow.parent;
+                }
+              }
+
+              if (saveFocus) {
+                // Preserve the currently-focused element or DOM window for
+                // this tab.
+
+                this.mCurrentBrowser.focusedWindow = focusedWindow;
+                this.mCurrentBrowser.focusedElement = document.commandDispatcher.focusedElement;
+              }
+
+              if (this.mCurrentBrowser.focusedElement instanceof NSHTMLElement || 
+                  this.mCurrentBrowser.focusedElement instanceof XULElement) {
+                // Clear focus outline before we draw on top of it
+                this.mCurrentBrowser.focusedElement.blur();
+              }
+              else {
+                // non-HTML/XUL elements have no blur method, see bug 323805
+                this.mCurrentBrowser.focusedElement = null;
+              }
+              this.mCurrentBrowser.setAttribute("type", "content-targetable");
+            }
+
+            var updatePageReport = false;
+            if ((this.mCurrentBrowser.pageReport && !newBrowser.pageReport) ||
+                (!this.mCurrentBrowser.pageReport && newBrowser.pageReport))
+              updatePageReport = true;
+
+            newBrowser.setAttribute("type", "content-primary");
+            this.mCurrentBrowser = newBrowser;
+            this.mCurrentTab = this.selectedTab;
+
+            if (updatePageReport)
+              this.mCurrentBrowser.updatePageReport();
+
+            // Update the URL bar.
+            var loc = this.mCurrentBrowser.currentURI;
+            if (!loc)
+              loc = ({ spec: "" });
+
+            var webProgress = this.mCurrentBrowser.webProgress;
+            var securityUI = this.mCurrentBrowser.securityUI;
+
+            var i, p;
+            for (i = 0; i < this.mProgressListeners.length; i++) {
+              p = this.mProgressListeners[i];
+              if (p) {
+                p.onLocationChange(webProgress, null, loc);
+                if (securityUI)
+                  p.onSecurityChange(webProgress, null, securityUI.state);
+
+                // make sure that all status indicators are properly updated
+                if ("onUpdateCurrentBrowser" in p) {
+                  var listener = this.mTabListeners[this.mTabContainer.selectedIndex] || null;
+                  if (listener && listener.mStateFlags)
+                    p.onUpdateCurrentBrowser(listener.mStateFlags, listener.mStatus,
+                                             listener.mMessage, listener.mTotalProgress);
+                }
+              }
+            }
+
+            this._fastFind.setDocShell(this.mCurrentBrowser.docShell);
+
+            // Update the window title.
+            this.updateTitlebar();
+
+            // If the new tab is busy, and our current state is not busy, then
+            // we need to fire a start to all progress listeners.
+            const nsIWebProgressListener = Components.interfaces.nsIWebProgressListener;
+            if (this.mCurrentTab.hasAttribute("busy") && !this.mIsBusy) {
+              this.mIsBusy = true;
+              webProgress = this.mCurrentBrowser.webProgress;
+              for (i = 0; i < this.mProgressListeners.length; i++) {
+                p = this.mProgressListeners[i];
+                if (p)
+                  p.onStateChange(webProgress, null, nsIWebProgressListener.STATE_START | nsIWebProgressListener.STATE_IS_NETWORK, 0);
+              }
+            }
+
+            // If the new tab is not busy, and our current state is busy, then
+            // we need to fire a stop to all progress listeners.
+            if (!this.mCurrentTab.hasAttribute("busy") && this.mIsBusy) {
+              this.mIsBusy = false;
+              webProgress = this.mCurrentBrowser.webProgress;
+              for (i = 0; i < this.mProgressListeners.length; i++) {
+                p = this.mProgressListeners[i];
+                if (p)
+                  p.onStateChange(webProgress, null, nsIWebProgressListener.STATE_STOP | nsIWebProgressListener.STATE_IS_NETWORK, 0);
+              }
+            }
+
+            // We've selected the new tab, so go ahead and notify listeners.
+            var event = document.createEvent("Events");
+            event.initEvent("TabSelect", true, false);
+            this.mCurrentTab.dispatchEvent(event);
+
+            if (document.commandDispatcher.focusedElement &&
+                document.commandDispatcher.focusedElement.parentNode ==
+                this.mCurrentTab.parentNode) {
+              // The focus is on a tab in the same tab panel
+              return;  // If focus was on a tab, switching tabs focuses the new tab
+            }
+
+            var whatToFocus = window.content;
+
+            // Focus the previously focused element or window
+            if (newBrowser.focusedElement) {
+              if (newBrowser.focusedElement.parentNode !=
+                  this.mCurrentTab.parentNode) {
+                // Focus the remembered element unless it's in the current tab panel
+                whatToFocus = newBrowser.focusedElement;
+              }
+            }
+            else if (newBrowser.focusedWindow) {
+              whatToFocus = newBrowser.focusedWindow;
+            }
+
+            function setFocus(element) {
+              document.commandDispatcher.suppressFocusScroll = true;
+
+              if (element instanceof Window ||
+                  element instanceof NSHTMLElement || 
+                  element instanceof XULElement) {
+                try {
+                  element.focus();
+                }
+                catch(ex) {
+                  dump("XXXfocus() failed, see bug #348183: ex = " + ex + "\n");
+                }
+              }
+              document.commandDispatcher.suppressFocusScroll = false;
+            }
+
+            // Use setTimeout to avoid focus outline ghosting.
+            setTimeout(setFocus, 0, whatToFocus);
+          ]]>
+        </body>
+      </method>
+
+      <method name="onTabClick">
+        <parameter name="event"/>
+        <body>
+          <![CDATA[
+            if (event.button != 1 || event.target.localName != 'tab')
+              return;
+
+            this.removeTab(event.target);
+            event.stopPropagation();
+          ]]>
+        </body>
+      </method>
+
+      <method name="onLinkAdded">
+        <parameter name="event"/>
+        <body>
+          <![CDATA[
+            if (!this.mPrefs.getBoolPref("browser.chrome.site_icons"))
+              return;
+
+            if (!event.originalTarget.rel.match((/(?:^|\s)icon(?:\s|$)/i)))
+              return;
+
+            // We have an icon.
+            var href = event.originalTarget.href;
+            if (!href)
+              return;
+
+            const nsIContentPolicy = Components.interfaces.nsIContentPolicy;
+            try {
+              var contentPolicy =
+                Components.classes['@mozilla.org/layout/content-policy;1']
+                          .getService(nsIContentPolicy);
+            } catch(e) {
+              return; // Refuse to load if we can't do a security check.
+            }
+
+            // Verify that the load of this icon is legal.
+            // We check first with the security manager
+            const secMan =
+              Components.classes["@mozilla.org/scriptsecuritymanager;1"]
+                        .getService(Components.interfaces.nsIScriptSecurityManager);
+
+            // Get the IOService so we can make URIs
+            const ioService =
+              Components.classes["@mozilla.org/network/io-service;1"]
+                        .getService(Components.interfaces.nsIIOService);
+
+            const targetDoc = event.target.ownerDocument;
+            // Make a URI out of our href.
+            var uri = ioService.newURI(href, targetDoc.characterSet, null);
+
+            var origURI = ioService.newURI(targetDoc.documentURI, targetDoc.characterSet, null);
+
+            const nsIScriptSecMan =
+              Components.interfaces.nsIScriptSecurityManager;
+
+            try {
+              // error pages can load their favicon
+              // to be on the safe side, only allow chrome:// favicons
+              const aboutNeterr = "about:neterror?";
+              if (origURI.spec.substr(0, aboutNeterr.length) != aboutNeterr ||
+                  !uri.schemeIs("chrome"))
+                secMan.checkLoadURI(origURI, uri,
+                                    nsIScriptSecMan.DISALLOW_SCRIPT);
+            } catch(e) {
+              return;
+            }
+
+            // Security says okay, now ask content policy
+            if (contentPolicy.shouldLoad(nsIContentPolicy.TYPE_IMAGE,
+                                         uri, origURI, event.target,
+                                         event.target.type,
+                                         null) != nsIContentPolicy.ACCEPT)
+              return;
+
+            var browserIndex = this.getBrowserIndexForDocument(targetDoc);
+            // no browser? no favicon.
+            if (browserIndex == -1)
+              return;
+
+            var tab = this.mTabContainer.childNodes[browserIndex];
+            this.setIcon(tab, href);
+          ]]>
+        </body>
+      </method>
+
+      <method name="onTitleChanged">
+        <parameter name="evt"/>
+        <body>
+          <![CDATA[
+            if (evt.target != this.contentDocument)
+              return;
+
+            var i = 0;
+            for ( ; i < this.parentNode.parentNode.childNodes.length; i++) {
+              if (this.parentNode.parentNode.childNodes[i].firstChild == this)
+                break;
+            }
+
+            var tabBrowser = this.parentNode.parentNode.parentNode.parentNode;
+
+            var tab = document.getAnonymousElementByAttribute(tabBrowser, "linkedpanel", this.parentNode.id);
+            tabBrowser.setTabTitle(tab);
+
+            if (tab == tabBrowser.mCurrentTab)
+              tabBrowser.updateTitlebar();
+          ]]>
+        </body>
+      </method>
+
+      <method name="setTabTitleLoading">
+        <parameter name="aTab"/>
+        <body>
+          <![CDATA[
+            aTab.label = this.mStringBundle.getString("tabs.loading");
+            aTab.setAttribute("crop", "end");
+          ]]>
+        </body>
+      </method>
+
+      <method name="setTabTitle">
+        <parameter name="aTab"/>
+        <body>
+          <![CDATA[
+            var browser = this.getBrowserForTab(aTab);
+            var title = browser.contentDocument.title;
+
+            if (!title) {
+              if (browser.currentURI.spec) {
+                try {
+                  title = this.mURIFixup.createExposableURI(browser.currentURI).spec;
+                } catch(ex) {
+                  title = browser.currentURI.spec;
+                }
+              }
+
+              if (title && title != "about:blank") {
+                // At this point, we now have a URI.
+                // Let's try to unescape it using a character set
+                // in case the URI is not ASCII.
+                try {
+                  var characterSet = browser.contentDocument.characterSet;
+                  const textToSubURI = Components.classes["@mozilla.org/intl/texttosuburi;1"]
+                                                 .getService(Components.interfaces.nsITextToSubURI);
+                  title = textToSubURI.unEscapeNonAsciiURI(characterSet, title);
+                } catch(ex) { /* Do nothing. */ }
+
+
+              } else // Still no title?  Fall back to our untitled string.
+                title = '\\{0_0}/';
+            }
+
+            aTab.label = title;
+          ]]>
+        </body>
+      </method>
+
+      <method name="setStripVisibilityTo">
+        <parameter name="aShow"/>
+        <body>
+        <![CDATA[
+          this.mStrip.collapsed = !aShow;
+          if (aShow) {
+            // XXXdwh temporary unclean dependency on specific menu items in navigator.xul
+            document.getElementById("menu_closeWindow").hidden = false;
+            document.getElementById("menu_close").setAttribute("label", this.mStringBundle.getString("tabs.closeTab"));
+            if (!this.mTabbedMode)
+              this.enterTabbedMode();
+          }
+          else {
+            // XXXdwh temporary unclean dependency on specific menu items in navigator.xul
+            document.getElementById("menu_closeWindow").hidden = true;
+            document.getElementById("menu_close").setAttribute("label", this.mStringBundle.getString("tabs.close"));
+          }
+        ]]>
+        </body>
+      </method>
+
+      <method name="getStripVisibility">
+        <body>
+          return !this.mStrip.collapsed;
+        </body>
+      </method>
+
+      <method name="enterTabbedMode">
+        <body>
+          <![CDATA[
+            this.mTabbedMode = true; // Welcome to multi-tabbed mode.
+
+            // Get the first tab all hooked up with a title listener and popup blocking listener.
+            this.mCurrentBrowser.addEventListener("DOMTitleChanged", this.onTitleChanged, true);
+
+            var throbberElement = document.getElementById("navigator-throbber");
+            if (throbberElement && throbberElement.hasAttribute("busy")) {
+              this.mCurrentTab.setAttribute("busy", "true");
+              this.mIsBusy = true;
+              this.setTabTitleLoading(this.mCurrentTab);
+              this.updateIcon(this.mCurrentTab);
+            } else {
+              this.setTabTitle(this.mCurrentTab);
+              this.setIcon(this.mCurrentTab, this.mCurrentBrowser.mIconURL);
+            }
+
+            var filter;
+            if (this.mTabFilters.length > 0) {
+              // Use the filter hooked up in our addProgressListener
+              filter = this.mTabFilters[0];
+            } else {
+              // create a filter and hook it up to our first browser
+              filter = Components.classes["@mozilla.org/appshell/component/browser-status-filter;1"]
+                                 .createInstance(Components.interfaces.nsIWebProgress);
+              this.mTabFilters[0] = filter;
+              this.mCurrentBrowser.webProgress.addProgressListener(filter, Components.interfaces.nsIWebProgress.NOTIFY_ALL);
+            }
+
+            // Remove all our progress listeners from the active browser's filter.
+            for (var i = 0; i < this.mProgressListeners.length; i++) {
+              var p = this.mProgressListeners[i];
+              if (p)
+                filter.removeProgressListener(p);
+            }
+
+            // Wire up a progress listener to our filter.
+            const listener = this.mTabProgressListener(this.mCurrentTab,
+                                                       this.mCurrentBrowser,
+                                                       false);
+            filter.addProgressListener(listener, Components.interfaces.nsIWebProgress.NOTIFY_ALL);
+            this.mTabListeners[0] = listener;
+          ]]>
+        </body>
+      </method>
+
+      <method name="loadOneTab">
+        <parameter name="aURI"/>
+        <parameter name="aReferrerURI"/>
+        <parameter name="aCharset"/>
+        <parameter name="aPostData"/>
+        <parameter name="aLoadInBackground"/>
+        <parameter name="aAllowThirdPartyFixup"/>
+        <body>
+          <![CDATA[
+            var bgLoad = (aLoadInBackground != null) ? aLoadInBackground :
+                         this.mPrefs.getBoolPref("browser.tabs.loadInBackground");
+            var owner = bgLoad ? null : this.selectedTab;
+            var tab = this.addTab(aURI, aReferrerURI, aCharset, aPostData, owner,
+                                  aAllowThirdPartyFixup);
+            // Set newly selected tab after quick timeout, otherwise hideous focus problems
+            // can occur when "browser.tabs.loadInBackground" is false and presshell is not ready
+            if (!bgLoad) {
+              function selectNewForegroundTab(browser, tab) {
+                browser.selectedTab = tab;
+              }
+              setTimeout(selectNewForegroundTab, 0, getBrowser(), tab);
+            }
+            if (!bgLoad)
+              this.selectedTab = tab;
+            
+            return tab;
+         ]]>
+        </body>
+      </method>
+
+      <method name="loadTabs">
+        <parameter name="aURIs"/>
+        <parameter name="aLoadInBackground"/>
+        <parameter name="aReplace"/>
+        <body><![CDATA[
+          // The tab selected after this new tab is closed (i.e. the new tab's
+          // "owner") is the next adjacent tab (i.e. not the previously viewed tab)
+          // when several urls are opened here (i.e. closing the first should select
+          // the next of many URLs opened) or if the pref to have UI links opened in
+          // the background is set (i.e. the link is not being opened modally)
+          //
+          // i.e.
+          //    Number of URLs    Load UI Links in BG       Focus Last Viewed?
+          //    == 1              false                     YES
+          //    == 1              true                      NO
+          //    > 1               false/true                NO
+          var owner = (aURIs.length > 1) || aLoadInBackground ? null : gBrowser.selectedTab;
+          var firstTabAdded = null;
+          if (aReplace)
+            this.loadURI(aURIs[0], null, null);
+          else
+            firstTabAdded = gBrowser.addTab(aURIs[0], null, null, null, owner, false);
+
+          var tabNum = this.mTabContainer.selectedIndex;
+          for (var i = 1; i < aURIs.length; ++i) {
+            var tab = gBrowser.addTab(aURIs[i]);
+            if (aReplace)
+              this.moveTabTo(tab, ++tabNum);
+          }
+
+          if (!aLoadInBackground) {
+            if (firstTabAdded) {
+              // .selectedTab setter focuses the content area
+              this.selectedTab = firstTabAdded;
+            }
+            else
+              window.content.focus();
+          }
+        ]]></body>
+      </method>
+
+      <method name="addTab">
+        <parameter name="aURI"/>
+        <parameter name="aReferrerURI"/>
+        <parameter name="aCharset"/>
+        <parameter name="aPostData"/>
+        <parameter name="aOwner"/>
+        <parameter name="aAllowThirdPartyFixup"/>
+        <body>
+          <![CDATA[
+            this._browsers = null; // invalidate cache
+
+            if (!this.mTabbedMode)
+              this.enterTabbedMode();
+
+            // if we're adding tabs, we're past interrupt mode, ditch the owner
+            if (this.mCurrentTab.owner)
+              this.mCurrentTab.owner = null;
+
+            var t = document.createElementNS(
+              "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul",
+                                             "tab");
+
+            var blank = (aURI == "about:blank");
+
+            if (blank)
+              t.setAttribute("label", this.mStringBundle.getString("tabs.untitled"));
+            else
+              t.setAttribute("label", aURI);
+
+            t.setAttribute("crop", "end");
+            t.minWidth = this.mTabContainer.mTabMinWidth;
+            t.setAttribute("flex", "100");
+            t.setAttribute("validate", "never");
+            t.setAttribute("onerror", "this.parentNode.parentNode.parentNode.parentNode.addToMissedIconCache(this.getAttribute('image')); this.removeAttribute('image');");
+            t.className = "tabbrowser-tab";
+
+            this.mTabContainer.appendChild(t);
+
+            if (document.defaultView
+                        .getComputedStyle(this.mTabContainer, "")
+                        .direction == "rtl") {
+              /* In RTL UI, the tab is visually added to the left side of the
+               * tabstrip. This means the tabstip has to be scrolled back in
+               * order to make sure the same set of tabs is visible before and
+               * after the new tab is added */
+
+            }
+
+            // invalidate cache, because mTabContainer is about to change
+            this._browsers = null; 
+
+            // If this new tab is owned by another, assert that relationship
+            if (aOwner !== undefined && aOwner !== null) {
+              t.owner = aOwner;
+
+              var self = this;
+              function attrChanged(event) {
+                if (event.attrName == "selectedIndex" &&
+                    event.prevValue != event.newValue)
+                  self.resetOwner(parseInt(event.prevValue));
+              }
+              if (!this.mTabChangedListenerAdded) {
+                this.mTabBox.addEventListener("DOMAttrModified", attrChanged, false);
+                this.mTabChangedListenerAdded = true;
+              }
+            }
+
+            var b = document.createElementNS(
+              "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul",
+                                             "browser");
+            b.setAttribute("type", "content-targetable");
+            b.setAttribute("message", "true");
+            b.setAttribute("contextmenu", this.getAttribute("contentcontextmenu"));
+            b.setAttribute("tooltip", this.getAttribute("contenttooltip"));
+            if (this.hasAttribute("autocompletepopup"))
+              b.setAttribute("autocompletepopup", this.getAttribute("autocompletepopup"));
+
+            // Add the Message and the Browser to the box
+            var notificationbox = document.createElementNS(
+                                    "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul",
+                                    "notificationbox");
+            notificationbox.setAttribute("flex", "1");
+            notificationbox.appendChild(b);
+            b.setAttribute("flex", "1");
+            this.mPanelContainer.appendChild(notificationbox);
+
+            b.addEventListener("DOMTitleChanged", this.onTitleChanged, true);
+
+            if (this.mStrip.collapsed)
+              this.setStripVisibilityTo(true);
+
+            this.mPrefs.setBoolPref("browser.tabs.forceHide", false);
+
+            // wire up a progress listener for the new browser object.
+            var position = this.mTabContainer.childNodes.length-1;
+            var tabListener = this.mTabProgressListener(t, b, blank);
+            const filter = Components.classes["@mozilla.org/appshell/component/browser-status-filter;1"]
+                                     .createInstance(Components.interfaces.nsIWebProgress);
+            filter.addProgressListener(tabListener, Components.interfaces.nsIWebProgress.NOTIFY_ALL);
+            b.webProgress.addProgressListener(filter, Components.interfaces.nsIWebProgress.NOTIFY_ALL);
+            this.mTabListeners[position] = tabListener;
+            this.mTabFilters[position] = filter;
+
+            b._fastFind = this.fastFind;
+
+            var uniqueId = "panel" + Date.now() + position;
+            this.mPanelContainer.lastChild.id = uniqueId;
+            t.linkedPanel = uniqueId;
+            t.linkedBrowser = b;
+            t._tPos = position;
+            if (t.previousSibling.selected)
+              t.setAttribute("afterselected", true);
+
+            if (!blank) {
+              // pretend the user typed this so it'll be available till
+              // the document successfully loads
+              b.userTypedValue = aURI;
+
+              if (aPostData === undefined)
+                aPostData = null;
+              const nsIWebNavigation = Components.interfaces.nsIWebNavigation;
+              var flags = nsIWebNavigation.LOAD_FLAGS_NONE;
+              if (aAllowThirdPartyFixup) {
+                flags = nsIWebNavigation.LOAD_FLAGS_ALLOW_THIRD_PARTY_FIXUP;
+              }
+              b.loadURIWithFlags(aURI, flags, aReferrerURI, aCharset, aPostData);
+            }
+
+
+            // Dispatch a new tab notification.  We do this once we're
+            // entirely done, so that things are in a consistent state
+            // even if the event listener opens or closes tabs.
+            var evt = document.createEvent("Events");
+            evt.initEvent("TabOpen", true, false);
+            t.dispatchEvent(evt);
+
+            return t;
+          ]]>
+        </body>
+      </method>
+
+      <method name="warnAboutClosingTabs">
+      <parameter name="aAll"/>
+      <body>
+        <![CDATA[
+          var numTabs = this.mTabContainer.childNodes.length;
+          var reallyClose = true;
+          if (numTabs <= 1)
+            return reallyClose;
+
+          const pref = "browser.tabs.warnOnClose";
+          var shouldPrompt = this.mPrefs.getBoolPref(pref);
+
+          if (shouldPrompt) {
+            var promptService = Components.classes["@mozilla.org/embedcomp/prompt-service;1"]
+                                          .getService(Components.interfaces.nsIPromptService);
+
+            //default to true: if it were false, we wouldn't get this far
+            var warnOnClose = { value:true };
+            var bundle = this.mStringBundle;
+            var tabsToClose = numTabs;  //number of tabs to be removed
+            if (!aAll)
+              --tabsToClose;
+
+            var messageKey = (tabsToClose == 1) ? "tabs.closeWarningOneTab" : "tabs.closeWarningMultipleTabs";
+            var closeKey = (tabsToClose == 1) ? "tabs.closeButtonOne" : "tabs.closeButtonMultiple";
+            // focus the window before prompting.
+            // this will raise any minimized window, which will 
+            // make it obvious which window the prompt is for and will
+            // solve the problem of windows "obscuring" the prompt.
+            // see bug #350299 for more details
+            window.focus();
+            var buttonPressed = promptService.confirmEx(window,
+                                                        bundle.getString("tabs.closeWarningTitle"),
+                                                        bundle.getFormattedString(messageKey, [tabsToClose]),
+                                                        (promptService.BUTTON_TITLE_IS_STRING * promptService.BUTTON_POS_0)
+                                                        + (promptService.BUTTON_TITLE_CANCEL * promptService.BUTTON_POS_1),
+                                                        bundle.getString(closeKey),
+                                                        null, null,
+                                                        bundle.getString("tabs.closeWarningPromptMe"),
+                                                        warnOnClose);
+            reallyClose = (buttonPressed == 0);
+            // don't set the pref unless they press OK and it's false
+            if (reallyClose && !warnOnClose.value)
+              this.mPrefs.setBoolPref(pref, false);
+          }
+          return reallyClose;
+        ]]>
+      </body>
+      </method>
+
+      <method name="removeAllTabsBut">
+        <parameter name="aTab"/>
+        <body>
+          <![CDATA[
+            if (this.warnAboutClosingTabs(false)) {
+              if (aTab.localName != "tab")
+                aTab = this.mCurrentTab;
+              else
+                this.mTabContainer.selectedItem = aTab;
+
+              var childNodes = this.mTabContainer.childNodes;
+
+              for (var i = childNodes.length - 1; i >= 0; --i) {
+                if (childNodes[i] != aTab)
+                  this.removeTab(childNodes[i]);
+              }
+            }
+          ]]>
+        </body>
+      </method>
+
+      <method name="removeCurrentTab">
+        <body>
+          <![CDATA[
+            return this.removeTab(this.mCurrentTab);
+          ]]>
+        </body>
+      </method>
+
+      <method name="resetOwner">
+        <parameter name="oldIndex"/>
+        <body>
+          <![CDATA[
+            // Reset the owner property, since we're leaving the modally opened
+            // tab for another.
+            if (oldIndex < this.mTabContainer.childNodes.length) {
+              var tab = this.mTabContainer.childNodes[oldIndex];
+              tab.owner = null;
+            }
+          ]]>
+        </body>
+      </method>
+
+      <method name="removeTab">
+        <parameter name="aTab"/>
+        <body>
+          <![CDATA[
+            this._browsers = null; // invalidate cache
+            if (aTab.localName != "tab")
+              aTab = this.mCurrentTab;
+
+            var l = this.mTabContainer.childNodes.length;
+            if (l == 1 && this.mPrefs.getBoolPref("browser.tabs.autoHide")) {
+              // hide the tab bar
+              this.mPrefs.setBoolPref("browser.tabs.forceHide", true);
+              this.setStripVisibilityTo(false);
+              return;
+            }
+
+            var ds = this.getBrowserForTab(aTab).docShell;
+            if (ds.contentViewer && !ds.contentViewer.permitUnload())
+              return;
+
+            // see notes in addTab
+            var _delayedUpdate = function(aTabContainer) {
+            }
+            setTimeout(_delayedUpdate, 0, this.mTabContainer);
+
+            if (l == 1) {
+              // add a new blank tab to replace the one we're about to close
+              // (this ensures that the remaining tab is as good as new)
+              this.addTab("about:blank");
+              l++;
+            };
+            // We're committed to closing the tab now.  
+            // Dispatch a notification.
+            // We dispatch it before any teardown so that event listeners can
+            // inspect the tab that's about to close.
+            var evt = document.createEvent("Events");
+            evt.initEvent("TabClose", true, false);
+            aTab.dispatchEvent(evt);
+
+            var index = -1;
+            if (this.mCurrentTab == aTab)
+              index = this.mTabContainer.selectedIndex;
+            else {
+              // Find and locate the tab in our list.
+              for (var i = 0; i < l; i++)
+                if (this.mTabContainer.childNodes[i] == aTab)
+                  index = i;
+            }
+
+            // Remove the tab's filter and progress listener.
+            const filter = this.mTabFilters[index];
+            var oldBrowser = this.getBrowserAtIndex(index);
+            oldBrowser.webProgress.removeProgressListener(filter);
+            filter.removeProgressListener(this.mTabListeners[index]);
+            this.mTabFilters.splice(index, 1);
+            this.mTabListeners.splice(index, 1);
+
+            // Remove our title change and blocking listeners
+            oldBrowser.removeEventListener("DOMTitleChanged", this.onTitleChanged, true);
+
+            // We are no longer the primary content area.
+            oldBrowser.setAttribute("type", "content-targetable");
+
+            // Get the index of the tab we're removing before unselecting it
+            var currentIndex = this.mTabContainer.selectedIndex;
+
+            var oldTab = aTab;
+
+            // clean up the before/afterselected attributes before removing the tab
+            oldTab.selected = false;
+
+            // Remove this tab as the owner of any other tabs, since it's going away.
+            for (i = 0; i < this.mTabContainer.childNodes.length; ++i) {
+              var tab = this.mTabContainer.childNodes[i];
+              if ("owner" in tab && tab.owner == oldTab)
+                // |tab| is a child of the tab we're removing, make it an orphan
+                tab.owner = null;
+            }
+
+            // Because of the way XBL works (fields just set JS
+            // properties on the element) and the code we have in place
+            // to preserve the JS objects for any elements that have
+            // JS properties set on them, the browser element won't be
+            // destroyed until the document goes away.  So we force a
+            // cleanup ourselves.
+            // This has to happen before we remove the child so that the
+            // XBL implementation of nsIObserver still works.  But
+            // clearing focusedWindow happens below because it gets
+            // reset by updateCurrentBrowser.
+            oldBrowser.destroy();
+
+            // Remove the tab
+            this.mTabContainer.removeChild(oldTab);
+            // invalidate cache, because mTabContainer is about to change
+            this._browsers = null; 
+            this.mPanelContainer.removeChild(oldBrowser.parentNode);
+
+            // Find the tab to select
+            var newIndex = -1;
+            if (currentIndex > index)
+              newIndex = currentIndex-1;
+            else if (currentIndex < index)
+              newIndex = currentIndex;
+            else {
+              if ("owner" in oldTab && oldTab.owner &&
+                  this.mPrefs.getBoolPref("browser.tabs.selectOwnerOnClose")) {
+                for (i = 0; i < this.mTabContainer.childNodes.length; ++i) {
+                  tab = this.mTabContainer.childNodes[i];
+                  if (tab == oldTab.owner) {
+                    newIndex = i;
+                    break;
+                  }
+                }
+              }
+              if (newIndex == -1)
+                newIndex = (index == l - 1) ? index - 1 : index;
+            }
+
+            // Select the new tab
+            this.selectedTab = this.mTabContainer.childNodes[newIndex];
+
+            for (i = oldTab._tPos; i < this.mTabContainer.childNodes.length; i++) {
+              this.mTabContainer.childNodes[i]._tPos = i;
+            }
+            this.mTabBox.selectedPanel = this.getBrowserForTab(this.mCurrentTab).parentNode;
+            this.mCurrentTab.selected = true;
+
+            this.updateCurrentBrowser();
+
+            // see comment above destroy above
+            oldBrowser.focusedWindow = null;
+            oldBrowser.focusedElement = null;
+          ]]>
+        </body>
+      </method>
+
+      <method name="reloadAllTabs">
+        <body>
+          <![CDATA[
+            var l = this.mPanelContainer.childNodes.length;
+            for (var i = 0; i < l; i++) {
+              try {
+                this.getBrowserAtIndex(i).reload();
+              } catch (e) {
+                // ignore failure to reload so others will be reloaded
+              }
+            }
+          ]]>
+        </body>
+      </method>
+
+      <method name="reloadTab">
+        <parameter name="aTab"/>
+        <body>
+          <![CDATA[
+            if (aTab.localName != "tab")
+              aTab = this.mCurrentTab;
+
+            this.getBrowserForTab(aTab).reload();
+          ]]>
+        </body>
+      </method>
+
+      <method name="onTabBarDblClick">
+        <parameter name="aEvent"/>
+        <body>
+          <![CDATA[
+            // See hack note in the tabbrowser-close-button binding
+            if (!this._blockDblClick && aEvent.button == 0 &&
+                aEvent.originalTarget.localName == "box") {
+              // xxx this needs to check that we're in the empty area of the tabstrip
+              var e = document.createEvent("Events");
+              e.initEvent("NewTab", true, true);
+              this.dispatchEvent(e);
+            }
+          ]]>
+        </body>
+      </method>
+
+      <method name="addProgressListener">
+        <parameter name="aListener"/>
+        <parameter name="aMask"/>
+        <body>
+          <![CDATA[
+            if (!this.mAddProgressListenerWasCalled) {
+              this.mAddProgressListenerWasCalled = true;
+              var autoHide = this.mPrefs.getBoolPref("browser.tabs.autoHide");
+              var forceHide = this.mPrefs.getBoolPref("browser.tabs.forceHide");
+              var tabStripHide = !window.toolbar.visible;
+              if (!autoHide && !forceHide && !tabStripHide)
+                this.setStripVisibilityTo(true);
+            }
+
+            if (!this.mTabbedMode && this.mProgressListeners.length == 1) {
+              // If we are adding a 2nd progress listener, we need to enter tabbed mode
+              // because the browser status filter can only handle one progress listener.
+              // In tabbed mode, mTabProgressListener is used which will iterate over all listeners.
+              this.enterTabbedMode();
+            }
+
+            this.mProgressListeners.push(aListener);
+
+            if (!this.mTabbedMode) {
+              // If someone does this:
+              // addProgressListener, removeProgressListener, addProgressListener
+              // don't create a new filter; reuse the existing filter.
+              if (this.mTabFilters.length == 0) {
+                // hook a filter up to our first browser
+                const filter = Components.classes["@mozilla.org/appshell/component/browser-status-filter;1"]
+                                         .createInstance(Components.interfaces.nsIWebProgress);
+                this.mTabFilters[0] = filter;
+                this.mCurrentBrowser.webProgress.addProgressListener(filter, Components.interfaces.nsIWebProgress.NOTIFY_ALL);
+              }
+
+              // Directly hook the listener up to the filter for better performance
+              this.mTabFilters[0].addProgressListener(aListener, aMask);
+            }
+          ]]>
+        </body>
+      </method>
+
+      <method name="removeProgressListener">
+        <parameter name="aListener"/>
+        <body>
+          <![CDATA[
+            for (var i = 0; i < this.mProgressListeners.length; i++) {
+              if (this.mProgressListeners[i] == aListener) {
+                this.mProgressListeners.splice(i, 1);
+                break;
+              }
+            }
+
+            if (!this.mTabbedMode)
+              // Don't forget to remove it from the filter we hooked it up to
+              this.mTabFilters[0].removeProgressListener(aListener);
+         ]]>
+        </body>
+      </method>
+
+      <method name="getBrowserForTab">
+        <parameter name="aTab"/>
+        <body>
+        <![CDATA[
+          return aTab.linkedBrowser;
+        ]]>
+        </body>
+      </method>
+
+      <property name="tabContainer">
+        <getter>
+          return this.mTabContainer;
+        </getter>
+      </property>
+
+      <property name="selectedTab">
+        <getter>
+          return this.mTabBox.selectedTab;
+        </getter>
+        <setter>
+          <![CDATA[
+          // Update the tab
+          this.mTabBox.selectedTab = val;
+          return val;
+          ]]>
+        </setter>
+      </property>
+
+      <property name="selectedBrowser"
+                onget="return this.mCurrentBrowser;"
+                readonly="true"/>
+
+      <property name="browsers" readonly="true">
+       <getter>
+          <![CDATA[
+            if (!this._browsers) {
+              var browsers = [];
+              var i;
+              browsers.item = function(i) {return this[i];}
+              for (i = 0; i < this.mTabContainer.childNodes.length; i++)
+                browsers.push(this.mTabContainer.childNodes[i].linkedBrowser);
+              this._browsers = browsers;
+            }
+            return this._browsers;
+          ]]>
+        </getter>
+      </property>
+
+      <!-- Drag and drop observer API -->
+      <method name="onDragStart">
+        <parameter name="aEvent"/>
+        <parameter name="aXferData"/>
+        <parameter name="aDragAction"/>
+        <body>
+        <![CDATA[
+          if (aEvent.target.localName == "tab" &&
+              aEvent.originalTarget.localName != "toolbarbutton") {
+            aXferData.data = new TransferData();
+
+            var URI = this.getBrowserForTab(aEvent.target).currentURI;
+            if (URI) {
+              aXferData.data.addDataForFlavour("text/x-moz-url", URI.spec + "\n" + aEvent.target.label);
+              aXferData.data.addDataForFlavour("text/unicode", URI.spec);
+              aXferData.data.addDataForFlavour("text/html", '<a href="' + URI.spec + '">' + aEvent.target.label + '</a>');
+            } else {
+              aXferData.data.addDataForFlavour("text/unicode", "about:blank");
+            }
+          }
+        ]]>
+        </body>
+      </method>
+
+      <method name="canDrop">
+        <parameter name="aEvent"/>
+        <parameter name="aDragSession"/>
+        <body>
+          <![CDATA[
+            /*if (aDragSession.sourceNode &&
+                aDragSession.sourceNode.parentNode == this.mTabContainer &&
+                (aEvent.screenX >= aDragSession.sourceNode.boxObject.screenX &&
+                 aEvent.screenX <= (aDragSession.sourceNode.boxObject.screenX +
+                                    aDragSession.sourceNode.boxObject.width)))
+                return false;*/
+            return true;
+          ]]>
+        </body>
+      </method>
+
+      <method name="onDragOver">
+        <parameter name="aEvent"/>
+        <parameter name="aFlavour"/>
+        <parameter name="aDragSession"/>
+        <body>
+          <![CDATA[
+
+          ]]>
+        </body>
+      </method>
+
+      <method name="onDrop">
+        <parameter name="aEvent"/>
+        <parameter name="aXferData"/>
+        <parameter name="aDragSession"/>
+        <body>
+          <![CDATA[
+            if (aDragSession.sourceNode && aDragSession.sourceNode.parentNode == this.mTabContainer) {
+              var newIndex = this.getNewIndex(aEvent);
+              var oldIndex = aDragSession.sourceNode._tPos;
+
+              /*if (newIndex > oldIndex)
+                newIndex--;*/
+              if (newIndex != oldIndex)
+                this.moveTabTo(this.mTabs[oldIndex], newIndex);
+                var tn=this.mTabs[newIndex].label;
+                this.mTabs[newIndex].label= '';
+                this.mTabs[newIndex].label= tn;
+            } else {
+              var url = transferUtils.retrieveURLFromData(aXferData.data, aXferData.flavour.contentType);
+
+              // valid urls don't contain spaces ' '; if we have a space it isn't a valid url.
+              // Also disallow dropping javascript: or data: urls--bail out
+              if (!url || !url.length || url.indexOf(" ", 0) != -1 ||
+                  /^\s*(javascript|data):/.test(url))
+                return;
+
+              this.dragDropSecurityCheck(aEvent, aDragSession, url);
+
+              var bgLoad = true;
+              try {
+                bgLoad = this.mPrefs.getBoolPref("browser.tabs.loadInBackground");
+              }
+              catch (e) { }
+
+              if (aEvent.shiftKey)
+                bgLoad = !bgLoad;
+
+              if (document.getBindingParent(aEvent.originalTarget).localName != "tab") {
+                // We're adding a new tab.
+                this.loadOneTab(getShortcutOrURI(url), null, null, null, bgLoad, false);
+              }
+              else {
+                // Load in an existing tab.
+                var tab = aEvent.target;
+                try {
+                  this.getBrowserForTab(tab).loadURI(getShortcutOrURI(url));
+                  if (this.mCurrentTab != tab && !bgLoad)
+                    this.selectedTab = tab;
+                } catch(ex) {
+                  // Just ignore invalid urls
+                }
+              }
+            }
+          ]]>
+        </body>
+      </method>
+
+      <method name="onDragExit">
+        <parameter name="aEvent"/>
+        <parameter name="aDragSession"/>
+        <body>
+          <![CDATA[
+            if (aDragSession.sourceNode &&
+                aDragSession.sourceNode.parentNode == this.mTabContainer &&
+                aDragSession.canDrop) {
+              var target = aEvent.relatedTarget;
+              while (target && target != this.mStrip)
+                target = target.parentNode;
+              if (target)
+                return;
+            }
+            this.mTabDropIndicatorBar.setAttribute('dragging','false');
+          ]]>
+        </body>
+      </method>
+
+      <method name="getSupportedFlavours">
+        <body>
+        <![CDATA[
+          var flavourSet = new FlavourSet();
+          flavourSet.appendFlavour("text/x-moz-url");
+          flavourSet.appendFlavour("text/unicode");
+          flavourSet.appendFlavour("application/x-moz-file", "nsIFile");
+          return flavourSet;
+        ]]>
+        </body>
+      </method>
+
+      <method name="moveTabTo">
+        <parameter name="aTab"/>
+        <parameter name="aIndex"/>
+        <body>
+        <![CDATA[
+          this._browsers = null; // invalidate cache
+          this.mTabFilters.splice(aIndex, 0, this.mTabFilters.splice(aTab._tPos, 1)[0]);
+          this.mTabListeners.splice(aIndex, 0, this.mTabListeners.splice(aTab._tPos, 1)[0]);
+
+          var oldPosition = aTab._tPos;
+
+          aIndex = aIndex <= aTab._tPos ? aIndex: aIndex+1;
+
+          this.mCurrentTab.selected = false;
+          this.mTabContainer.insertBefore(aTab, this.mTabContainer.childNodes[aIndex]);
+          // invalidate cache, because mTabContainer is about to change
+          this._browsers = null;
+
+          var i;
+          for (i = 0; i < this.mTabContainer.childNodes.length; i++) {
+            this.mTabContainer.childNodes[i]._tPos = i;
+            this.mTabContainer.childNodes[i].selected = false;
+          }
+          this.mCurrentTab.selected = true;
+
+          var evt = document.createEvent("UIEvents");
+          evt.initUIEvent("TabMove", true, false, window, oldPosition);
+          aTab.dispatchEvent(evt);
+
+          return aTab;
+        ]]>
+        </body>
+      </method>
+
+      <method name="getNewIndex">
+        <parameter name="aEvent"/>
+        <body>
+          <![CDATA[
+            var i;
+              for (i = aEvent.target.localName == "tab" ? aEvent.target._tPos : 0; i < this.mTabs.length; i++)
+                if (aEvent.screenY < this.mTabs[i].boxObject.screenY + this.mTabs[i].boxObject.height) 
+                  return i;
+/*            var i;
+            if (window.getComputedStyle(this.parentNode, null).direction == "ltr") {
+              for (i = aEvent.target.localName == "tab" ? aEvent.target._tPos : 0; i < this.mTabs.length; i++)
+                if (aEvent.screenX < this.mTabs[i].boxObject.screenX + this.mTabs[i].boxObject.width / 2) 
+                  return i;
+            } else {
+               for (i = aEvent.target.localName == "tab" ? aEvent.target._tPos : 0; i < this.mTabs.length; i++)
+                if (aEvent.screenX > this.mTabs[i].boxObject.screenX + this.mTabs[i].boxObject.width / 2)
+                  return i;
+            }*/
+
+            return this.mTabs.length;
+          ]]>
+        </body>
+      </method>
+
+
+      <method name="moveTabForward">
+        <body>
+          <![CDATA[
+            var tabPos = this.mCurrentTab._tPos;
+            if (tabPos < this.browsers.length - 1) {
+              this.moveTabTo(this.mCurrentTab, tabPos + 1);
+              this.mCurrentTab.focus();
+            }
+            else if (this.arrowKeysShouldWrap)
+              this.moveTabToStart();
+          ]]>
+        </body>
+      </method>
+
+      <method name="moveTabBackward">
+        <body>
+          <![CDATA[
+            var tabPos = this.mCurrentTab._tPos;
+            if (tabPos > 0) {
+              this.moveTabTo(this.mCurrentTab, tabPos - 1);
+              this.mCurrentTab.focus();
+            }
+            else if (this.arrowKeysShouldWrap)
+              this.moveTabToEnd();
+          ]]>
+        </body>
+      </method>
+
+      <method name="moveTabToStart">
+        <body>
+          <![CDATA[
+            var tabPos = this.mCurrentTab._tPos;
+            if (tabPos > 0) {
+              this.moveTabTo(this.mCurrentTab, 0);
+              this.mCurrentTab.focus();
+            }
+          ]]>
+        </body>
+      </method>
+
+      <method name="moveTabToEnd">
+        <body>
+          <![CDATA[
+            var tabPos = this.mCurrentTab._tPos;
+            if (tabPos < this.browsers.length - 1) {
+              this.moveTabTo(this.mCurrentTab,
+                                        this.browsers.length - 1);
+              this.mCurrentTab.focus();
+            }
+          ]]>
+        </body>
+      </method>
+
+      <method name="moveTabOver">
+        <parameter name="aEvent"/>
+        <body>
+          <![CDATA[
+            var direction = window.getComputedStyle(this.parentNode, null).direction;
+            if ((direction == "ltr" && aEvent.keyCode == KeyEvent.DOM_VK_RIGHT) ||
+                (direction == "rtl" && aEvent.keyCode == KeyEvent.DOM_VK_LEFT))
+              this.moveTabForward();
+            else
+              this.moveTabBackward();
+          ]]>
+        </body>
+      </method>
+
+      <!-- BEGIN FORWARDED BROWSER PROPERTIES.  IF YOU ADD A PROPERTY TO THE BROWSER ELEMENT
+           MAKE SURE TO ADD IT HERE AS WELL. -->
+      <property name="canGoBack"
+                onget="return this.mCurrentBrowser.canGoBack;"
+                readonly="true"/>
+
+      <property name="canGoForward"
+                onget="return this.mCurrentBrowser.canGoForward;"
+                readonly="true"/>
+
+      <method name="goBack">
+        <body>
+          <![CDATA[
+            return this.mCurrentBrowser.goBack();
+          ]]>
+        </body>
+      </method>
+
+      <method name="goForward">
+        <body>
+          <![CDATA[
+            return this.mCurrentBrowser.goForward();
+          ]]>
+        </body>
+      </method>
+
+      <method name="reload">
+        <body>
+          <![CDATA[
+            return this.mCurrentBrowser.reload();
+          ]]>
+        </body>
+      </method>
+
+      <method name="reloadWithFlags">
+        <parameter name="aFlags"/>
+        <body>
+          <![CDATA[
+            return this.mCurrentBrowser.reloadWithFlags(aFlags);
+          ]]>
+        </body>
+      </method>
+
+      <method name="stop">
+        <body>
+          <![CDATA[
+            return this.mCurrentBrowser.stop();
+          ]]>
+        </body>
+      </method>
+
+      <!-- throws exception for unknown schemes -->
+      <method name="loadURI">
+        <parameter name="aURI"/>
+        <parameter name="aReferrerURI"/>
+        <parameter name="aCharset"/>
+        <body>
+          <![CDATA[
+            return this.mCurrentBrowser.loadURI(aURI, aReferrerURI, aCharset);
+          ]]>
+        </body>
+      </method>
+
+      <!-- throws exception for unknown schemes -->
+      <method name="loadURIWithFlags">
+        <parameter name="aURI"/>
+        <parameter name="aFlags"/>
+        <parameter name="aReferrerURI"/>
+        <parameter name="aCharset"/>
+        <body>
+          <![CDATA[
+            return this.mCurrentBrowser.loadURIWithFlags(aURI, aFlags, aReferrerURI, aCharset);
+          ]]>
+        </body>
+      </method>
+
+      <method name="goHome">
+        <body>
+          <![CDATA[
+            return this.mCurrentBrowser.goHome();
+          ]]>
+        </body>
+      </method>
+
+      <property name="homePage">
+        <getter>
+          <![CDATA[
+            return this.mCurrentBrowser.homePage;
+          ]]>
+        </getter>
+        <setter>
+          <![CDATA[
+            this.mCurrentBrowser.homePage = val;
+            return val;
+          ]]>
+        </setter>
+      </property>
+
+      <method name="gotoIndex">
+        <parameter name="aIndex"/>
+        <body>
+          <![CDATA[
+            return this.mCurrentBrowser.gotoIndex(aIndex);
+          ]]>
+        </body>
+      </method>
+
+      <method name="attachFormFill">
+        <body><![CDATA[
+          for (var i = 0; i < this.mPanelContainer.childNodes.length; ++i) {
+            var cb = this.getBrowserAtIndex(i);
+            cb.attachFormFill();
+          }
+        ]]></body>
+      </method>
+
+      <method name="detachFormFill">
+        <body><![CDATA[
+          for (var i = 0; i < this.mPanelContainer.childNodes.length; ++i) {
+            var cb = this.getBrowserAtIndex(i);
+            cb.detachFormFill();
+          }
+        ]]></body>
+      </method>
+
+      <property name="pageReport"
+                onget="return this.mCurrentBrowser.pageReport;"
+                readonly="true"/>
+
+      <property name="currentURI"
+                onget="return this.mCurrentBrowser.currentURI;"
+                readonly="true"/>
+
+      <field name="_fastFind">null</field>
+      <property name="fastFind"
+                readonly="true">
+        <getter>
+        <![CDATA[
+          if (!this._fastFind) {
+            this._fastFind = Components.classes["@mozilla.org/typeaheadfind;1"]
+                                       .createInstance(Components.interfaces.nsITypeAheadFind_MOZILLA_1_8_BRANCH);
+            this._fastFind.init(this.docShell);
+          }
+          return this._fastFind;
+        ]]>
+        </getter>
+      </property>
+
+      <property name="findString"
+                onget="return this.mCurrentBrowser.findString;"
+                readonly="true"/>
+
+      <property name="docShell"
+                onget="return this.mCurrentBrowser.docShell"
+                readonly="true"/>
+
+      <property name="webNavigation"
+                onget="return this.mCurrentBrowser.webNavigation"
+                readonly="true"/>
+
+      <property name="webBrowserFind"
+                readonly="true"
+                onget="return this.mCurrentBrowser.webBrowserFind"/>
+
+      <property name="webProgress"
+                readonly="true"
+                onget="return this.mCurrentBrowser.webProgress"/>
+
+      <property name="contentWindow"
+                readonly="true"
+                onget="return this.mCurrentBrowser.contentWindow"/>
+
+      <property name="sessionHistory"
+                onget="return this.mCurrentBrowser.sessionHistory;"
+                readonly="true"/>
+
+      <property name="markupDocumentViewer"
+                onget="return this.mCurrentBrowser.markupDocumentViewer;"
+                readonly="true"/>
+
+      <property name="contentViewerEdit"
+                onget="return this.mCurrentBrowser.contentViewerEdit;"
+                readonly="true"/>
+
+      <property name="contentViewerFile"
+                onget="return this.mCurrentBrowser.contentViewerFile;"
+                readonly="true"/>
+
+      <property name="documentCharsetInfo"
+                onget="return this.mCurrentBrowser.documentCharsetInfo;"
+                readonly="true"/>
+
+      <property name="contentDocument"
+                onget="return this.mCurrentBrowser.contentDocument;"
+                readonly="true"/>
+
+      <property name="contentTitle"
+                onget="return this.mCurrentBrowser.contentTitle;"
+                readonly="true"/>
+
+      <property name="securityUI"
+                onget="return this.mCurrentBrowser.securityUI;"
+                readonly="true"/>
+
+      <method name="find">
+        <body>
+          <![CDATA[
+            return this.mCurrentBrowser.find();
+          ]]>
+        </body>
+      </method>
+
+      <method name="findAgain">
+        <body>
+          <![CDATA[
+            return this.mCurrentBrowser.findAgain();
+          ]]>
+        </body>
+      </method>
+
+      <method name="findPrevious">
+        <body>
+          <![CDATA[
+            return this.mCurrentBrowser.findPrevious();
+          ]]>
+        </body>
+      </method>
+
+      <method name="dragDropSecurityCheck">
+        <parameter name="aEvent"/>
+        <parameter name="aDragSession"/>
+        <parameter name="aUri"/>
+        <body>
+          <![CDATA[
+            // Do a security check for drag n' drop. Make sure the
+            // source document can load the dragged link.
+            var sourceDoc = aDragSession.sourceDocument;
+
+            if (sourceDoc) {
+              // 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 aUri
+              // really is a URI.
+
+              var uriStr = aUri.replace(/^\s*|\s*$/g, '');
+              var uri = null;
+
+              try {
+                uri = Components.classes["@mozilla.org/network/io-service;1"]
+                  .getService(Components.interfaces.nsIIOService)
+                  .newURI(uriStr, null, null);
+              } catch (e) {
+              }
+
+              if (uri) {
+                // aUri is a URI, do the security check.
+                var sourceURI = sourceDoc.documentURI;
+
+                const nsIScriptSecurityManager =
+                  Components.interfaces.nsIScriptSecurityManager;
+                var secMan =
+                  Components.classes["@mozilla.org/scriptsecuritymanager;1"]
+                  .getService(nsIScriptSecurityManager);
+
+                try {
+                  secMan.checkLoadURIStr(sourceURI, uriStr,
+                                         nsIScriptSecurityManager.STANDARD);
+                } catch (e) {
+                  // Stop event propagation right here.
+                  aEvent.stopPropagation();
+
+                  throw "Drop of " + aUri + " denied.";
+                }
+              }
+            }
+          ]]>
+        </body>
+      </method>
+
+      <field name="_keyEventHandler" readonly="true">
+      <![CDATA[({
+        tabbrowser: this,
+        handleEvent: function handleEvent(aEvent) {
+          if (!aEvent.isTrusted) {
+            // Don't let untrusted events mess with tabs.
+            return;
+          }
+
+          if (('shiftKey' in aEvent && aEvent.shiftKey) ||
+              ('altKey' in aEvent && aEvent.altKey))
+            return;
+          if (('ctrlKey' in aEvent && aEvent.ctrlKey) &&
+              !('metaKey' in aEvent && aEvent.metaKey)) {
+            if (aEvent.keyCode == KeyEvent.DOM_VK_F4 &&
+                this.tabbrowser.mTabBox.handleCtrlPageUpDown) {
+              this.tabbrowser.removeCurrentTab();
+
+              aEvent.stopPropagation();
+              aEvent.preventDefault();
+              return;
+            }
+            if (aEvent.target.localName == "tabbrowser") {
+              switch (aEvent.keyCode) {
+                case KeyEvent.DOM_VK_UP:
+                  this.tabbrowser.moveTabBackward();
+                  break;
+                case KeyEvent.DOM_VK_DOWN:
+                  this.tabbrowser.moveTabForward();
+                  break;
+                case KeyEvent.DOM_VK_RIGHT:
+                case KeyEvent.DOM_VK_LEFT:
+                  this.tabbrowser.moveTabOver(aEvent);
+                  break;
+                case KeyEvent.DOM_VK_HOME:
+                  this.tabbrowser.moveTabToStart();
+                  break;
+                case KeyEvent.DOM_VK_END:
+                  this.tabbrowser.moveTabToEnd();
+                  break;
+                default:
+                  // Stop the keypress event for the above keyboard
+                  // shortcuts only.
+                  return;
+              }
+              aEvent.stopPropagation();
+              aEvent.preventDefault();
+            }
+          }
+        }
+      })]]>
+      </field>
+
+      <property name="canFindAgain"
+                onget="return this.mCurrentBrowser.canFindAgain;"
+                readonly="true"/>
+
+      <property name="userTypedClear"
+                onget="return this.mCurrentBrowser.userTypedClear;"
+                onset="return this.mCurrentBrowser.userTypedClear = val;"/>
+
+      <property name="userTypedValue"
+                onget="return this.mCurrentBrowser.userTypedValue;"
+                onset="return this.mCurrentBrowser.userTypedValue = val;"/>
+
+      <property name="forceSyncURLBarUpdate"
+                onget="return this.mModalDialogShowing;"/>
+
+      <method name="createTooltip">
+        <parameter name="event"/>
+        <body>
+          <![CDATA[
+            event.stopPropagation();
+            var tn = document.tooltipNode;
+            if (tn.localName != "tab")
+              return false; // Not a tab, so cancel the tooltip
+            if ("mOverCloseButton" in tn && tn.mOverCloseButton) {
+              event.target.setAttribute("label", tn.getAttribute("closetabtext"));
+              return true;
+            }
+            if (tn.hasAttribute("label")) {
+              event.target.setAttribute("label", tn.getAttribute("label"));
+              return true;
+            }
+            return false;
+          ]]>
+        </body>
+      </method>
+
+      <constructor>
+        <![CDATA[
+               try{this.mStrip.width= this.mPrefs.getIntPref("browser.tabs.width");}catch(ex){};
+
+          this.mCurrentBrowser = this.mPanelContainer.childNodes[0].firstChild;
+          this.mCurrentTab = this.mTabContainer.firstChild;
+          document.addEventListener("keypress", this._keyEventHandler, false);
+
+          var uniqueId = "panel" + Date.now();
+          this.mPanelContainer.childNodes[0].id = uniqueId;
+          this.mTabContainer.childNodes[0].linkedPanel = uniqueId;
+          this.mTabContainer.childNodes[0]._tPos = 0;
+          this.mTabContainer.childNodes[0].linkedBrowser = this.mPanelContainer.childNodes[0].firstChild;
+        ]]>
+      </constructor>
+
+      <destructor>
+        <![CDATA[
+          for (var i = 0; i < this.mTabListeners.length; ++i) {
+            this.getBrowserAtIndex(i).webProgress.removeProgressListener(this.mTabFilters[i]);
+            this.mTabFilters[i].removeProgressListener(this.mTabListeners[i]);
+            this.mTabFilters[i] = null;
+            this.mTabListeners[i] = null;
+            this.getBrowserAtIndex(i).removeEventListener("DOMTitleChanged", this.onTitleChanged, true);
+          }
+          document.removeEventListener("keypress", this._keyEventHandler, false);
+        ]]>
+      </destructor>
+    </implementation>
+
+    <handlers>
+      <handler event="DOMLinkAdded" phase="capturing" action="this.onLinkAdded(event);"/>
+
+      <handler event="DOMWindowClose" phase="capturing">
+        <![CDATA[
+          if (!event.isTrusted)
+            return;
+
+          const browsers = this.mPanelContainer.childNodes;
+          if (browsers.length == 1) {
+            // There's only one browser left. If a window is being
+            // closed and the window is *not* the window in the
+            // browser that's still around, prevent the event's default
+            // action to prevent closing a window that's being closed
+            // already.
+            if (this.getBrowserAtIndex(0).contentWindow != event.target)
+              event.preventDefault();
+
+            return;
+          }
+
+          var i = 0;
+          for (; i < browsers.length; ++i) {
+            if (this.getBrowserAtIndex(i).contentWindow == event.target) {
+              this.removeTab(this.mTabContainer.childNodes[i]);
+              event.preventDefault();
+
+              break;
+            }
+          }
+        ]]>
+      </handler>
+      <handler event="DOMWillOpenModalDialog" phase="capturing">
+        <![CDATA[
+          if (!event.isTrusted)
+            return;
+
+          // We're about to open a modal dialog, make sure the opening
+          // tab is brought to the front.
+
+          var targetTop = event.target.top;
+
+          for (var i = 0; i < browsers.length; ++i) {
+            if (this.getBrowserAtIndex(i).contentWindow == targetTop) {
+              this.mModalDialogShowing = true;
+              this.selectedTab = this.mTabContainer.childNodes[i];
+
+              break;
+            }
+          }
+        ]]>
+      </handler>
+      <handler event="DOMModalDialogClosed" phase="capturing">
+        <![CDATA[
+          if (!event.isTrusted)
+            return;
+
+          this.mModalDialogShowing = false;
+        ]]>
+      </handler>
+      <handler event="resize">
+        <![CDATA[
+               this.mPrefs.setIntPref("browser.tabs.width", this.mStrip.width);
+      ]]>
+      </handler>
+    </handlers>
+  </binding>
+
+  <binding id="tabbrowser-tabs"
+           extends="chrome://global/content/bindings/tabbox.xml#tabs" >
+    <content>
+       <xul:vbox style="overflow-y: auto; overflow-x: hidden;" anonid="arrowscrollbox" flex="1">
+               <children includes="tab"/>
+        </xul:vbox>
+    </content>
+    <handlers>
+       <!--<handler event="dblclick">
+               BrowserOpenTab();
+       </handler>
+       <handler event="click" button="1">
+               if (event.target==this) undoCloseTab();
+       </handler>-->
+    </handlers>
+  </binding>
+
+  <binding id="tabbrowser-tab" display="xul:box" extends="chrome://global/content/bindings/tabbox.xml#tab">
+       <content chromedir="&locale.dir;">
+               <xul:hbox class="tab-mid box-inherit" xbl:inherits="align,dir,pack,orient,selected" flex="1">
+                       <xul:stack flex="1">
+                               <xul:hbox><xul:vbox><xul:image class="tab-icon" xbl:inherits="validate,src=image" /></xul:vbox></xul:hbox>
+                               <xul:description class="tab-text" anonid="tabtext" xbl:inherits="accesskey,crop,disabled" flex="1" >\(0_0)/</xul:description>
+                       </xul:stack>
+                       <!--<xul:label class="tab-text" xbl:inherits="value=label,accesskey,crop,disabled" flex="1"/>-->
+               </xul:hbox>
+       </content>
+
+    <implementation>
+      <field name="mCorrespondingMenuitem">null</field>
+      <constructor>
+       
+      </constructor>
+      <method name="textinit">
+        <body>
+               document.getAnonymousElementByAttribute(this,'anonid','tabtext').textContent= this.label;
+        </body>
+      </method>
+    </implementation>
+
+    <handlers>
+       <handler event="DOMAttrModified"><![CDATA[              if (event.attrName=='label') this.textinit();           ]]></handler>
+    </handlers>
+
+  </binding>
+
+</bindings>
diff --git a/.mozilla/firefox/default/extensions/vertical-tabbar@dark-demon.nm.ru/chrome/vertical-tabbar/content/icon.png b/.mozilla/firefox/default/extensions/vertical-tabbar@dark-demon.nm.ru/chrome/vertical-tabbar/content/icon.png
new file mode 100644 (file)
index 0000000..d21d23d
Binary files /dev/null and b/.mozilla/firefox/default/extensions/vertical-tabbar@dark-demon.nm.ru/chrome/vertical-tabbar/content/icon.png differ
diff --git a/.mozilla/firefox/default/extensions/vertical-tabbar@dark-demon.nm.ru/chrome/vertical-tabbar/skin/classic/tabbrowser.css b/.mozilla/firefox/default/extensions/vertical-tabbar@dark-demon.nm.ru/chrome/vertical-tabbar/skin/classic/tabbrowser.css
new file mode 100644 (file)
index 0000000..17dbd0d
--- /dev/null
@@ -0,0 +1,13 @@
+@namespace url("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul");\r
+\r
+.tabbrowser-tab:not([selected="true"])\r
+{\r
+       opacity: .85;\r
+}\r
+\r
+.tabbrowser-tab[busy]{\r
+       opacity: .7 !important;\r
+}\r
+.tabbrowser-tab:not([selected]){\r
+       opacity: 1 !important;\r
+}\r
diff --git a/.mozilla/firefox/default/extensions/vertical-tabbar@dark-demon.nm.ru/chrome/vertical-tabbar/skin/lolifox-theme/tabbrowser.css b/.mozilla/firefox/default/extensions/vertical-tabbar@dark-demon.nm.ru/chrome/vertical-tabbar/skin/lolifox-theme/tabbrowser.css
new file mode 100644 (file)
index 0000000..149af0d
--- /dev/null
@@ -0,0 +1,28 @@
+@namespace url("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul");\r
+\r
+#appcontent .tabbrowser-tabs\r
+{\r
+       background: #f6f6f6;\r
+}\r
+\r
+#appcontent .tabbrowser-tab\r
+{\r
+       /*background: #eee;*/\r
+}\r
+\r
+#appcontent .tabbrowser-tab[selected="true"]\r
+{\r
+       background: #eee;\r
+}\r
+\r
+#appcontent .tabbrowser-splitter\r
+{\r
+       background: #f6f6f6;\r
+}\r
+\r
+#appcontent .tabbrowser-tab[busy]{\r
+       background: #fff6f0;\r
+}\r
+#appcontent .tabbrowser-tab:not([selected]){\r
+       background: #ffffff;\r
+}\r
diff --git a/.mozilla/firefox/default/extensions/vertical-tabbar@dark-demon.nm.ru/install.rdf b/.mozilla/firefox/default/extensions/vertical-tabbar@dark-demon.nm.ru/install.rdf
new file mode 100644 (file)
index 0000000..c86f1c2
--- /dev/null
@@ -0,0 +1,32 @@
+<?xml version="1.0"?>
+
+<RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+     xmlns:em="http://www.mozilla.org/2004/em-rdf#">
+
+  <Description about="urn:mozilla:install-manifest">
+    <em:id>vertical-tabbar@dark-demon.nm.ru</em:id>
+    <em:version>1.1.1</em:version>
+
+    <em:targetApplication>
+      <Description>
+        <em:id>{ec8030f7-c20a-464f-9b0e-13a3a9e97384}</em:id>
+        <em:minVersion>2.0</em:minVersion>
+        <em:maxVersion>2.0.0.*</em:maxVersion>
+      </Description>
+    </em:targetApplication>
+    
+    <em:name>Vertical Tabbar</em:name>
+    <em:description>make tabbar in FF2.0 is vertical</em:description>
+    
+<!--    <em:appManaged>true</em:appManaged>
+
+    <em:locked>true</em:locked>-->
+
+    <em:creator>Dark-Demon</em:creator>
+    <em:contributor>Mozilla Contributors</em:contributor>
+    <em:homepageURL>http://dark-demon.nm.ru/</em:homepageURL>
+       <em:iconURL>chrome://vertical-tabbar/content/icon.png</em:iconURL>
+
+  </Description>      
+
+</RDF>
diff --git a/.mozilla/firefox/default/extensions/{4476fef4-3557-40b5-afcd-d6903cf7cc9d}/chrome.manifest b/.mozilla/firefox/default/extensions/{4476fef4-3557-40b5-afcd-d6903cf7cc9d}/chrome.manifest
new file mode 100644 (file)
index 0000000..2df0aca
--- /dev/null
@@ -0,0 +1,8 @@
+content hah jar:chrome/chrome.jar!/content/
+overlay chrome://browser/content/browser.xul chrome://hah/content/overlay.xul
+skin hah classic/1.0 jar:chrome/chrome.jar!/skin/
+locale hah en-US jar:chrome/chrome.jar!/locale/en-US/
+locale hah fi-FI jar:chrome/chrome.jar!/locale/fi-FI/
+locale hah hu-HU jar:chrome/chrome.jar!/locale/hu-HU/
+locale hah it-IT jar:chrome/chrome.jar!/locale/it-IT/
+locale hah fr-FR jar:chrome/chrome.jar!/locale/fr-FR/
diff --git a/.mozilla/firefox/default/extensions/{4476fef4-3557-40b5-afcd-d6903cf7cc9d}/chrome/chrome.jar b/.mozilla/firefox/default/extensions/{4476fef4-3557-40b5-afcd-d6903cf7cc9d}/chrome/chrome.jar
new file mode 100644 (file)
index 0000000..fc2639d
Binary files /dev/null and b/.mozilla/firefox/default/extensions/{4476fef4-3557-40b5-afcd-d6903cf7cc9d}/chrome/chrome.jar differ
diff --git a/.mozilla/firefox/default/extensions/{4476fef4-3557-40b5-afcd-d6903cf7cc9d}/defaults/preferences/prefs.js b/.mozilla/firefox/default/extensions/{4476fef4-3557-40b5-afcd-d6903cf7cc9d}/defaults/preferences/prefs.js
new file mode 100644 (file)
index 0000000..baea932
--- /dev/null
@@ -0,0 +1,19 @@
+# Hit-a-Hint default preferences
+
+/* Do not edit this file.
+ *
+ * If you make changes to this file while the application is running,
+ * the changes will be overwritten when the application exits.
+ *
+ * To make a manual change to preferences, you can visit the URL about:config
+ * For more information, see http://www.mozilla.org/unix/customizing.html#prefs
+ */
+
+pref("extensions.hah.enabled", true);
+pref("extensions.hah.hideTabs", false);
+pref("extensions.hah.hints.forceNumeric", false);
+pref("extensions.hah.hints.style", "z-index:500;font:normal normal normal x-small helvetica;color:ButtonText;background-color:ButtonFace;border-color:ButtonShadow;border-width:1px;-moz-border-radius:0.3em;border-style:solid;padding:0px 3px 0px 3px;position:absolute;");
+pref("extensions.hah.hints.styleFocus", "z-index:500;font:normal normal normal x-small helvetica;color:ButtonText;background-color:ButtonShadow;border-color:ButtonShadow;border-width:1px;-moz-border-radius:0.3em;border-style:solid;padding:0px 3px 0px 3px;position:absolute;");
+pref("extensions.hah.hints.tags", "//*[@onclick or @onmouseover or @onmousedown or @onmouseup or @oncommand or @class='lk' or @class='s'] | //input[@type!='hidden'] | //a | //area | //iframe | //textarea | //button | //select");
+pref("extensions.hah.keys.magicDelay", 150);
+pref("extensions.hah.keys.numbers", "0123456789");
diff --git a/.mozilla/firefox/default/extensions/{4476fef4-3557-40b5-afcd-d6903cf7cc9d}/install.rdf b/.mozilla/firefox/default/extensions/{4476fef4-3557-40b5-afcd-d6903cf7cc9d}/install.rdf
new file mode 100644 (file)
index 0000000..bf251af
--- /dev/null
@@ -0,0 +1,31 @@
+<?xml version="1.0"?>
+<RDF:RDF xmlns:em="http://www.mozilla.org/2004/em-rdf#"
+         xmlns:NC="http://home.netscape.com/NC-rdf#"
+         xmlns:RDF="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+  <RDF:Description RDF:about="rdf:#$9XuHR2"
+                   em:id="{ec8030f7-c20a-464f-9b0e-13a3a9e97384}"
+                   em:minVersion="1.5"
+                   em:maxVersion="2.0.0.*" />
+  <RDF:Description RDF:about="urn:mozilla:extension:file:hah.jar"
+                   em:package="content/hah/"
+                   em:skin="skin/classic/hah/">
+    <em:locale>locale/en-US/hah/</em:locale>
+    <em:locale>locale/fi-FI/hah/</em:locale>
+    <em:locale>locale/it-IT/hah/</em:locale>
+    <em:locale>locale/fr-FR/hah/</em:locale>
+    <em:locale>locale/hu-HU/hah/</em:locale>
+  </RDF:Description>
+  <RDF:Description RDF:about="urn:mozilla:install-manifest"
+                   em:id="{4476fef4-3557-40b5-afcd-d6903cf7cc9d}"
+                   em:version="0.9.1"
+                   em:name="Hit-a-Hint"
+                   em:description="Click links by hitting hints!"
+                   em:creator="Pekka Sillanpaa"
+                   em:homepageURL="http://hah.mozdev.org"
+                   em:iconURL="chrome://hah/skin/icon.png"
+                   em:optionsURL="chrome://hah/content/preferences.xul"
+                   em:type="2">
+    <em:targetApplication RDF:resource="rdf:#$9XuHR2"/>
+    <em:file RDF:resource="urn:mozilla:extension:file:hah.jar"/>
+  </RDF:Description>
+</RDF:RDF>
diff --git a/.mozilla/firefox/default/extensions/{a44ef047-cd8d-406e-a354-b7101bd24735}/chrome.manifest b/.mozilla/firefox/default/extensions/{a44ef047-cd8d-406e-a354-b7101bd24735}/chrome.manifest
new file mode 100644 (file)
index 0000000..a7d461e
--- /dev/null
@@ -0,0 +1,4 @@
+content surfkeys jar:chrome/chrome.jar!/content/
+overlay chrome://browser/content/browser.xul chrome://surfkeys/content/overlay.xul
+skin surfkeys classic/1.0 jar:chrome/chrome.jar!/skin/
+locale surfkeys en-US jar:chrome/chrome.jar!/locale/en-US/
diff --git a/.mozilla/firefox/default/extensions/{a44ef047-cd8d-406e-a354-b7101bd24735}/chrome/chrome.jar b/.mozilla/firefox/default/extensions/{a44ef047-cd8d-406e-a354-b7101bd24735}/chrome/chrome.jar
new file mode 100644 (file)
index 0000000..c8b98d4
Binary files /dev/null and b/.mozilla/firefox/default/extensions/{a44ef047-cd8d-406e-a354-b7101bd24735}/chrome/chrome.jar differ
diff --git a/.mozilla/firefox/default/extensions/{a44ef047-cd8d-406e-a354-b7101bd24735}/defaults/preferences/prefs.js b/.mozilla/firefox/default/extensions/{a44ef047-cd8d-406e-a354-b7101bd24735}/defaults/preferences/prefs.js
new file mode 100644 (file)
index 0000000..1de7faf
--- /dev/null
@@ -0,0 +1,13 @@
+# Hit-a-Hint default preferences
+
+/* Do not edit this file.
+ *
+ * If you make changes to this file while the application is running,
+ * the changes will be overwritten when the application exits.
+ *
+ * To make a manual change to preferences, you can visit the URL about:config
+ * For more information, see http://www.mozilla.org/unix/customizing.html#prefs
+ */
+
+pref("extensions.surfkeys.enabled", true);
+pref("extensions.surfkeys.resultpattern", "google.com:Next:Previous;google.fi:Seuraava:Edellinen;www.helsinginsanomat.fi/viivijawagner:SEURAAVA:EDELLINEN");
diff --git a/.mozilla/firefox/default/extensions/{a44ef047-cd8d-406e-a354-b7101bd24735}/install.rdf b/.mozilla/firefox/default/extensions/{a44ef047-cd8d-406e-a354-b7101bd24735}/install.rdf
new file mode 100644 (file)
index 0000000..f8eac50
--- /dev/null
@@ -0,0 +1,36 @@
+<?xml version="1.0"?>\r
+\r
+<RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:em="http://www.mozilla.org/2004/em-rdf#">\r
+\r
+<Description about="urn:mozilla:install-manifest">\r
+\r
+    <em:id>{a44ef047-cd8d-406e-a354-b7101bd24735}</em:id>\r
+    <em:version>0.4.1</em:version>\r
+    <!-- Front End MetaData -->\r
+    <em:name>SurfKeys</em:name>\r
+    <em:description>Comfortable surfing with keyboard.</em:description>\r
+    <em:creator>Pekka Sillanpaa</em:creator>\r
+    <em:homepageURL>http://surfkeys.mozdev.org</em:homepageURL>\r
+       <em:iconURL>chrome://surfkeys/skin/icon.png</em:iconURL>  \r
+           <em:optionsURL>chrome://surfkeys/content/preferences.xul</em:optionsURL>\r
+    <em:targetApplication>\r
+        <Description>\r
+            <em:id>{ec8030f7-c20a-464f-9b0e-13a3a9e97384}</em:id>\r
+            <em:minVersion>1.5</em:minVersion>\r
+            <em:maxVersion>2.2</em:maxVersion>\r
+        </Description>\r
+    </em:targetApplication>\r
\r
+    <em:file>\r
+        <Description about="urn:mozilla:extension:file:surfkeys.jar">\r
+            <em:package>content/surfkeys/</em:package>\r
+            <em:skin>skin/classic/surfkeys/</em:skin>\r
+            <em:locale>locale/en-US/surfkeys/</em:locale>\r
+        </Description>\r
+    </em:file>\r
+\r
+    <em:type>2</em:type>\r
+\r
+</Description>\r
+\r
+</RDF>\r