mozilla: comparison mozilla-kde.patch

equal deleted inserted replaced

-:e969636be188
+:2f9f2e040647
 # HG changeset patch
-# Parent  61cdc9af8ceaf75083e751e0d6497feddc26f7ba
+# Parent  f2726ebfae7cdded8e7ca6030829b0a3fae4e438
 Description: Add KDE integration to Firefox (toolkit parts)
 Author: Wolfgang Rosenauer <wolfgang@rosenauer.org>
 Author: Lubos Lunak <lunak@suse.com>
 Bug: https://bugzilla.mozilla.org/show_bug.cgi?id=140751
 https://bugzilla.novell.com/show_bug.cgi?id=170055
 #include "prefapi.h"
 #include "prefread.h"
 #include "prefapi_private_data.h"
-@@ -1135,16 +1136,34 @@ pref_LoadPrefsInDir(nsIFile* aDir, char
+@@ -1138,16 +1139,34 @@ pref_LoadPrefsInDir(nsIFile* aDir, char
 static nsresult pref_LoadPrefsInDirList(const char *listId)
 {
 nsresult rv;
 nsCOMPtr<nsIProperties> dirSvc(do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID, &rv));
 getter_AddRefs(list));
 if (!list)
 return NS_OK;
 bool hasMore;
-@@ -1160,17 +1179,17 @@ static nsresult pref_LoadPrefsInDirList(
+@@ -1163,17 +1182,17 @@ static nsresult pref_LoadPrefsInDirList(
 nsAutoCString leaf;
 path->GetNativeLeafName(leaf);
 // Do we care if a file provided by this process fails to load?
 static nsresult pref_ReadPrefFromJar(nsZipArchive* jarReader, const char *name)
 {
 nsZipItemPtr<char> manifest(jarReader, name, true);
 NS_ENSURE_TRUE(manifest.Buffer(), NS_ERROR_NOT_AVAILABLE);
-@@ -1264,24 +1283,36 @@ static nsresult pref_InitInitialObjects(
+@@ -1267,24 +1286,36 @@ static nsresult pref_InitInitialObjects(
 /* these pref file names should not be used: we process them after all other application pref files for backwards compatibility */
 static const char* specialFiles[] = {
 #if defined(XP_MACOSX)
 "macprefs.js"
 #elif defined(XP_WIN)
 +
 +<bindings id="dialogBindings"
 +          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="dialog" extends="chrome://global/content/bindings/general.xml#root-element">
 +    <resources>
 +      <stylesheet src="chrome://global/skin/dialog.css"/>
 +    </resources>
 +    <content>
 +      <xul:vbox class="box-inherit dialog-content-box" flex="1">
 +        <children/>
 +      </xul:vbox>
 +
 +      <xul:hbox class="dialog-button-box" anonid="buttons"
 +                xbl:inherits="pack=buttonpack,align=buttonalign,dir=buttondir,orient=buttonorient"
-+#ifdef XP_UNIX_GNOME
++#ifdef XP_UNIX
 +                >
 +        <xul:button dlgtype="disclosure" class="dialog-button" hidden="true"/>
 +        <xul:button dlgtype="help" class="dialog-button" hidden="true"/>
 +        <xul:button dlgtype="extra2" class="dialog-button" hidden="true"/>
 +        <xul:button dlgtype="extra1" class="dialog-button" hidden="true"/>
 +        <xul:button dlgtype="cancel" class="dialog-button"/>
 +        <xul:button dlgtype="accept" class="dialog-button" xbl:inherits="disabled=buttondisabledaccept"/>
 +#elif XP_UNIX
 +                >
 +        <xul:button dlgtype="help" class="dialog-button" hidden="true"/>
-+	<xul:button dlgtype="extra2" class="dialog-button" hidden="true"/>
++        <xul:button dlgtype="extra2" class="dialog-button" hidden="true"/>
-+	<xul:spacer anonid="spacer" flex="1"/>
++        <xul:spacer anonid="spacer" flex="1"/>
-+	<xul:button dlgtype="accept" class="dialog-button" xbl:inherits="disabled=buttondisabledaccept"/>
++        <xul:button dlgtype="accept" class="dialog-button" xbl:inherits="disabled=buttondisabledaccept"/>
-+	<xul:button dlgtype="extra1" class="dialog-button" hidden="true"/>
++        <xul:button dlgtype="extra1" class="dialog-button" hidden="true"/>
-+	<xul:button dlgtype="cancel" class="dialog-button"/>
++        <xul:button dlgtype="cancel" class="dialog-button"/>
-+	<xul:button dlgtype="disclosure" class="dialog-button" hidden="true"/>
++        <xul:button dlgtype="disclosure" class="dialog-button" hidden="true"/>
 +#else
 +                pack="end">
 +        <xul:button dlgtype="extra2" class="dialog-button" hidden="true"/>
 +        <xul:spacer anonid="spacer" flex="1" hidden="true"/>
 +        <xul:button dlgtype="accept" class="dialog-button" xbl:inherits="disabled=buttondisabledaccept"/>
 +        <![CDATA[
 +          return this._doButtonCommand("accept");
 +        ]]>
 +        </body>
 +      </method>
 +
 +      <method name="cancelDialog">
 +        <body>
 +        <![CDATA[
 +          return this._doButtonCommand("cancel");
 +        ]]>
 +        </body>
 +      </method>
 +
 +      <method name="getButton">
 +        <parameter name="aDlgType"/>
 +        <body>
 +        <![CDATA[
 +          return this._buttons[aDlgType];
 +      <method name="centerWindowOnScreen">
 +        <body>
 +        <![CDATA[
 +          var xOffset = screen.availWidth/2 - window.outerWidth/2;
 +          var yOffset = screen.availHeight/2 - window.outerHeight/2; //(opener.outerHeight *2)/10;
 +
 +          xOffset = xOffset > 0 ? xOffset : 0;
 +          yOffset = yOffset > 0 ? yOffset : 0;
 +          window.moveTo(xOffset, yOffset);
 +        ]]>
 +        </body>
 +
 +          // Give focus after onload completes, see bug 103197.
 +          setTimeout(focusInit, 0);
 +        ]]>
 +        </body>
 +      </method>
 +
 +      <property name="mStrBundle">
 +        <getter>
 +        <![CDATA[
 +          if (!this._mStrBundle) {
 +                                         .createBundle("chrome://global/locale/dialog.properties");
 +          }
 +          return this._mStrBundle;
 +        ]]></getter>
 +      </property>
 +
 +      <method name="_configureButtons">
 +        <parameter name="aButtons"/>
 +        <body>
 +        <![CDATA[
 +          // by default, get all the anonymous button elements
 +            }
 +          }
 +
 +          // ensure that hitting enter triggers the default button command
 +          this.defaultButton = this.defaultButton;
 +
 +          // if there is a special button configuration, use it
 +          if (aButtons) {
 +            // expect a comma delimited list of dlgtype values
 +            var list = aButtons.split(",");
 +
 +                          disclosure: false, extra1: false, extra2: false };
 +            for (i = 0; i < list.length; ++i)
 +              shown[list[i].replace(/ /g, "")] = true;
 +
 +            // hide/show the buttons we want
 +            for (dlgtype in buttons)
 +              buttons[dlgtype].hidden = !shown[dlgtype];
 +
 +            let { AppConstants } =
 +                Components.utils.import("resource://gre/modules/AppConstants.jsm", {});
 +            // show the spacer on Windows only when the extra2 button is present
 +          return document.documentElement._doButtonCommand(
 +                                        aEvent.target.getAttribute("dlgtype"));
 +        ]]>
 +        </body>
 +      </method>
 +
 +      <method name="_doButtonCommand">
 +        <parameter name="aDlgType"/>
 +        <body>
 +        <![CDATA[
 +          var button = this.getButton(aDlgType);
 +          }
 +          return true;
 +        ]]>
 +        </body>
 +      </method>
 +
 +      <method name="_fireButtonEvent">
 +        <parameter name="aDlgType"/>
 +        <body>
 +        <![CDATA[
 +          var event = document.createEvent("Events");
 +          event.initEvent("dialog"+aDlgType, true, true);
 +
 +          // handle dom event handlers
 +          var noCancel = this.dispatchEvent(event);
 +
 +          // handle any xml attribute event handlers
 +          var handler = this.getAttribute("ondialog"+aDlgType);
 +          if (handler != "") {
 +            var fn = new Function("event", handler);
 +            var returned = fn(event);
 +            if (returned == false)
 +              noCancel = false;
 +          }
 +
 +          return noCancel;
 +        ]]>
 +        </body>
 +      </method>
 +
 +        ]]>
 +        </body>
 +      </method>
 +
 +    </implementation>
 +
 +    <handlers>
 +      <handler event="keypress" keycode="VK_RETURN"
 +               group="system" action="this._hitEnter(event);"/>
 +      <handler event="keypress" keycode="VK_ESCAPE" group="system">
 +        if (!event.defaultPrevented)
 +</bindings>
 diff --git a/toolkit/content/widgets/preferences-kde.xml b/toolkit/content/widgets/preferences-kde.xml
 new file mode 100644
 --- /dev/null
 +++ b/toolkit/content/widgets/preferences-kde.xml
-@@ -0,0 +1,1406 @@
+@@ -0,0 +1,1408 @@
 +<?xml version="1.0"?>
 +
 +<!DOCTYPE bindings [
 +  <!ENTITY % preferencesDTD SYSTEM "chrome://global/locale/preferences.dtd">
 +  %preferencesDTD;
 +            }
 +          }
 +        ]]>
 +        </body>
 +      </method>
 +
 +      <method name="fireChangedEvent">
 +        <parameter name="aPreference"/>
 +        <body>
 +        <![CDATA[
 +          // Value changed, synthesize an event
 +            Components.utils.reportError(e);
 +          }
 +        ]]>
 +        </body>
 +      </method>
 +
 +      <field name="service">
 +        Components.classes["@mozilla.org/preferences-service;1"]
 +                  .getService(Components.interfaces.nsIPrefService);
 +      </field>
 +      <field name="rootBranch">
 +
 +        this.preferences.rootBranchInternal
 +            .addObserver(this.name, this.preferences, false);
 +        // In non-instant apply mode, we must try and use the last saved state
 +        // from any previous opens of a child dialog instead of the value from
 +        // preferences, to pick up any edits a user may have made.
 +
 +        var secMan = Components.classes["@mozilla.org/scriptsecuritymanager;1"]
 +                    .getService(Components.interfaces.nsIScriptSecurityManager);
 +        if (this.preferences.type == "child" &&
 +            !this.instantApply && window.opener &&
 +            secMan.isSystemPrincipal(window.opener.document.nodePrincipal)) {
 +          var pdoc = window.opener.document;
 +
 +          // Try to find a preference element for the same preference.
 +      <property name="preferences" onget="return this.parentNode"/>
 +      <property name="name" onget="return this.getAttribute('name');">
 +        <setter>
 +          if (val == this.name)
 +            return val;
 +
 +          this.preferences.rootBranchInternal
 +              .removeObserver(this.name, this.preferences);
 +          this.setAttribute('name', val);
 +          this.preferences.rootBranchInternal
 +              .addObserver(val, this.preferences, false);
 +
 +          return val;
 +        </setter>
 +      </property>
 +      <property name="type" onget="return this.getAttribute('type');"
 +                            onset="this.setAttribute('type', val); return val;"/>
 +          return aValue;
 +        ]]>
 +        </body>
 +      </method>
 +      <property name="value" onget="return this._value" onset="return this._setValue(val);"/>
 +
 +      <property name="locked">
 +        <getter>
 +          return this.preferences.rootBranch.prefIsLocked(this.name);
 +        </getter>
 +      </property>
 +
 +      <property name="disabled">
 +        <getter>
 +          return this.getAttribute("disabled") == "true";
 +        </getter>
 +        <setter>
 +        <![CDATA[
 +          if (val)
 +            this.setAttribute("disabled", "true");
 +          else
 +            this.removeAttribute("disabled");
 +
 +          if (!this.id)
 +            return val;
 +
 +          var elements = document.getElementsByAttribute("preference", this.id);
 +          for (var i = 0; i < elements.length; ++i) {
 +            elements[i].disabled = val;
 +
 +            var labels = document.getElementsByAttribute("control", elements[i].id);
 +            for (var j = 0; j < labels.length; ++j)
 +              labels[j].disabled = val;
 +          }
 +
 +          return val;
 +        ]]>
 +        </setter>
 +      </property>
 +
 +      <property name="tabIndex">
 +        <getter>
 +          return parseInt(this.getAttribute("tabindex"));
 +        </getter>
 +        <setter>
 +        <![CDATA[
 +          if (val)
 +            this.setAttribute("tabindex", val);
 +          else
 +            this.removeAttribute("tabindex");
 +
 +          if (!this.id)
 +            return val;
 +
 +          var elements = document.getElementsByAttribute("preference", this.id);
 +          for (var i = 0; i < elements.length; ++i) {
 +            elements[i].tabIndex = val;
 +
 +            var labels = document.getElementsByAttribute("control", elements[i].id);
 +            for (var j = 0; j < labels.length; ++j)
 +              labels[j].tabIndex = val;
 +          }
 +
 +          return val;
 +        ]]>
 +        </setter>
 +      </property>
 +
 +          return this.preferences.rootBranch.prefHasUserValue(this.name) &&
 +                 this.value !== undefined;
 +        ]]>
 +        </getter>
 +      </property>
 +
 +      <method name="reset">
 +        <body>
 +          // defer reset until preference update
 +          this.value = undefined;
 +        </body>
 +      </method>
 +
 +      <field name="_useDefault">false</field>
 +      <property name="defaultValue">
 +        <getter>
 +        <![CDATA[
 +          this._useDefault = true;
 +          var val = this.valueFromPreferences;
 +          this._useDefault = false;
 +          return val;
 +        ]]>
 +        </getter>
 +      </property>
 +
 +      <property name="_branch">
 +        <getter>
 +          return this._useDefault ? this.preferences.defaultBranch : this.preferences.rootBranch;
 +        </getter>
 +      </property>
 +
 +      <field name="batching">false</field>
 +
 +      <method name="_reportUnknownType">
 +        <body>
 +        <![CDATA[
 +          var consoleService = Components.classes["@mozilla.org/consoleservice;1"]
 +                                         .getService(Components.interfaces.nsIConsoleService);
 +          var msg = "<preference> with id='" + this.id + "' and name='" +
 +                    this.name + "' has unknown type '" + this.type + "'.";
 +          consoleService.logStringMessage(msg);
 +        ]]>
 +        </body>
 +      </method>
 +
 +      <property name="valueFromPreferences">
 +        <getter>
 +        <![CDATA[
 +          try {
 +            // Force a resync of value with preferences.
 +                             .createInstance(Components.interfaces.nsILocalFile);
 +              lf.persistentDescriptor = val;
 +              if (!lf.exists())
 +                lf.initWithPath(val);
 +            }
 +            else
 +              lf = val.QueryInterface(Components.interfaces.nsILocalFile);
 +            this.preferences.rootBranch
 +                .setComplexValue(this.name, Components.interfaces.nsILocalFile, lf);
 +            break;
 +          default:
 +            this.preferences.service.savePrefFile(null);
 +          return val;
 +        ]]>
 +        </setter>
 +      </property>
 +
 +      <method name="setElementValue">
 +        <parameter name="aElement"/>
 +        <body>
 +        <![CDATA[
 +          if (this.locked)
 +          if (aElement.hasAttribute("onsyncfrompreference")) {
 +            // Value changed, synthesize an event
 +            try {
 +              var event = document.createEvent("Events");
 +              event.initEvent("syncfrompreference", true, true);
 +              var f = new Function ("event",
 +                                    aElement.getAttribute("onsyncfrompreference"));
 +              rv = f.call(aElement, event);
 +            }
 +            catch (e) {
 +              Components.utils.reportError(e);
 +            }
 +          }
-+          var val = rv !== undefined ? rv : (this.instantApply ? this.valueFromPreferences : this.value);
++          var val = rv;
++          if (val === undefined)
++            val = this.instantApply ? this.valueFromPreferences : this.value;
 +          // if the preference is marked for reset, show default value in UI
 +          if (val === undefined)
 +            val = this.defaultValue;
 +
 +          /**
 +           * Initialize a UI element property with a value. Handles the case
 +           * where an element has not yet had a XBL binding attached for it and
 +           * the property setter does not yet exist by setting the same attribute
 +           * on the XUL element using DOM apis and assuming the element's
 +           * constructor or property getters appropriately handle this state.
 +           */
 +          function setValue(element, attribute, value) {
 +            if (attribute in element)
 +              element[attribute] = value;
 +            else
 +              element.setAttribute(attribute, value);
 +          }
 +          if (aElement.localName == "checkbox" ||
 +          if (aElement.hasAttribute("onsynctopreference")) {
 +            // Value changed, synthesize an event
 +            try {
 +              var event = document.createEvent("Events");
 +              event.initEvent("synctopreference", true, true);
 +              var f = new Function ("event",
 +                                    aElement.getAttribute("onsynctopreference"));
 +              var rv = f.call(aElement, event);
 +              if (rv !== undefined)
 +                return rv;
 +            }
 +            catch (e) {
 +              Components.utils.reportError(e);
 +            }
 +          }
 +
 +          /**
 +           * Read the value of an attribute from an element, assuming the
 +           * attribute is a property on the element's node API. If the property
 +           * is not present in the API, then assume its value is contained in
 +           * an attribute, as is the case before a binding has been attached.
 +           */
 +          function getValue(element, attribute) {
 +          }
 +          return value;
 +        ]]>
 +        </body>
 +      </method>
 +
 +      <method name="isElementEditable">
 +        <parameter name="aElement"/>
 +        <body>
 +        <![CDATA[
 +          switch (aElement.localName) {
 +          case "listbox":
 +          case "menulist":
 +            return true;
 +          }
 +          return aElement.getAttribute("preference-editable") == "true";
 +        ]]>
 +        </body>
 +      </method>
 +
 +      <method name="updateElements">
 +        <body>
 +        <![CDATA[
 +          if (!this.id)
 +            return;
 +
 +          // This "change" event handler tracks changes made to preferences by
 +          // sources other than the user in this window.
 +          var elements = document.getElementsByAttribute("preference", this.id);
 +          for (var i = 0; i < elements.length; ++i)
 +            this.setElementValue(elements[i]);
 +        ]]>
 +        </body>
 +      </method>
 +    </implementation>
 +
 +    <handlers>
 +      <handler event="change">
 +        this.updateElements();
 +      </handler>
 +    </handlers>
 +                Components.utils.import("resource://gre/modules/AppConstants.jsm", {});
 +            if (AppConstants.platform == "macosx") {
 +              // no buttons on Mac except Help
 +              cancelButton.hidden = true;
 +              // Move Help button to the end
 +              document.getAnonymousElementByAttribute(this, "anonid", "spacer").hidden = true;
 +              // Also, don't fire onDialogAccept on enter
 +              acceptButton.disabled = true;
 +            } else {
 +              // morph the Cancel button into the Close button
 +              cancelButton.setAttribute ("icon", "close");
 +                onget="return document.getAnonymousElementByAttribute(this, 'anonid', 'paneDeck');"/>
 +      <property name="_paneDeckContainer"
 +                onget="return document.getAnonymousElementByAttribute(this, 'class', 'paneDeckContainer');"/>
 +      <property name="_selector"
 +                onget="return document.getAnonymousElementByAttribute(this, 'anonid', 'selector');"/>
 +      <property name="lastSelected"
 +                onget="return this.getAttribute('lastSelected');">
 +        <setter>
 +          this.setAttribute("lastSelected", val);
 +          document.persist(this.id, "lastSelected");
 +          return val;
 +        </setter>
 +      </property>
 +      <property name="currentPane"
 +                onset="return this._currentPane = val;">
 +        <getter>
 +          if (!this._currentPane)
 +            this._currentPane = this.preferencePanes[0];
 +
 +          return this._currentPane;
 +        </getter>
 +      </property>
 +      <field name="_currentPane">null</field>
 +
 +
 +      <method name="_makePaneButton">
 +        <parameter name="aPaneElement"/>
 +        <body>
 +        <![CDATA[
 +          var radio = document.createElement("radio");
 +          if (!aPaneElement.loaded) {
 +            let OverlayLoadObserver = function(aPane)
 +            {
 +              this._pane = aPane;
 +            }
 +            OverlayLoadObserver.prototype = {
 +              _outer: this,
 +              observe: function (aSubject, aTopic, aData)
 +              {
 +                this._pane.loaded = true;
 +                this._outer._fireEvent("paneload", this._pane);
 +                this._outer._selectPane(this._pane);
 +              }
 +            };
 +
 +            var obs = new OverlayLoadObserver(aPaneElement);
 +            document.loadOverlay(aPaneElement.src, obs);
 +          }
 +          else
 +            this._selectPane(aPaneElement);
 +        ]]>
 +        </body>
 +      </method>
 +
 +      <method name="_fireEvent">
 +        <parameter name="aEventName"/>
 +        <parameter name="aTarget"/>
 +        <body>
 +        <![CDATA[
 +          // Panel loaded, synthesize a load event.
 +          try {
 +            var event = document.createEvent("Events");
 +            event.initEvent(aEventName, true, true);
 +            var cancel = !aTarget.dispatchEvent(event);
 +            if (aTarget.hasAttribute("on" + aEventName)) {
 +              var fn = new Function ("event", aTarget.getAttribute("on" + aEventName));
 +              var rv = fn.call(aTarget, event);
 +              if (rv == false)
 +                cancel = true;
 +            }
 +            return !cancel;
 +          }
 +          catch (e) {
 +            Components.utils.reportError(e);
 +          }
 +          return false;
 +        ]]>
 +        </body>
 +      </method>
 +
 +      <field name="_initialized">false</field>
 +      <method name="_selectPane">
 +        <parameter name="aPaneElement"/>
 +        <body>
 +        <![CDATA[
 +          if (aPaneElement.helpTopic)
 +            helpButton.hidden = false;
 +          else
 +            helpButton.hidden = true;
 +
 +          // Find this pane's index in the deck and set the deck's
 +          // selectedIndex to that value to switch to it.
 +          var prefpanes = this.preferencePanes;
 +          for (var i = 0; i < prefpanes.length; ++i) {
 +            if (prefpanes[i] == aPaneElement) {
 +              this._paneDeck.selectedIndex = i;
 +
 +              if (this.type != "child") {
 +                if (aPaneElement.hasAttribute("flex") && this._shouldAnimate &&
 +                    prefpanes.length > 1)
 +                  aPaneElement.removeAttribute("flex");
 +                // Calling sizeToContent after the first prefpane is loaded
 +            }
 +          }
 +        ]]>
 +        </body>
 +      </method>
 +
 +      <property name="_shouldAnimate">
 +        <getter>
 +        <![CDATA[
 +          let { AppConstants } =
 +              Components.utils.import("resource://gre/modules/AppConstants.jsm", {});
 +          catch (e) { }
 +          return animate;
 +        ]]>
 +        </getter>
 +      </property>
 +
 +      <method name="animate">
 +        <parameter name="aOldPane"/>
 +        <parameter name="aNewPane"/>
 +        <body>
 +        <![CDATA[
 +          // if we are already resizing, use currentHeight
 +          var oldHeight = this._currentHeight ? this._currentHeight : aOldPane.contentHeight;
 +
 +          this._multiplier = aNewPane.contentHeight > oldHeight ? 1 : -1;
 +          var sizeDelta = Math.abs(oldHeight - aNewPane.contentHeight);
 +          this._animateRemainder = sizeDelta % this._animateIncrement;
 +
 +          this._setUpAnimationTimer(oldHeight);
 +        ]]>
 +        </body>
 +      </method>
 +
 +      <property name="_sizeIncrement">
 +        <getter>
 +        <![CDATA[
 +          var lastSelectedPane = document.getElementById(this.lastSelected);
 +          var increment = this._animateIncrement * this._multiplier;
 +          var newHeight = this._currentHeight + increment;
 +          if ((this._multiplier > 0 && this._currentHeight >= lastSelectedPane.contentHeight) ||
 +              (this._multiplier < 0 && this._currentHeight <= lastSelectedPane.contentHeight))
 +            return 0;
 +
 +          if ((this._multiplier > 0 && newHeight > lastSelectedPane.contentHeight) ||
 +              (this._multiplier < 0 && newHeight < lastSelectedPane.contentHeight))
 +            increment = this._animateRemainder * this._multiplier;
 +          return increment;
 +        ]]>
 +        </getter>
 +      </property>
 +
 +      <method name="notify">
 +        <parameter name="aTimer"/>
 +        <body>
 +        <![CDATA[
 +          if (!document)
 +            aTimer.cancel();
 +
 +          if (aTimer == this._animateTimer) {
 +            var increment = this._sizeIncrement;
 +            if (increment != 0) {
 +              window.innerHeight += increment;
 +              this._currentHeight += increment;
 +            }
 +          }
 +        ]]>
 +        </body>
 +      </method>
 +
 +      <method name="_setUpAnimationTimer">
 +        <parameter name="aStartHeight"/>
 +        <body>
 +        <![CDATA[
 +          if (!this._animateTimer)
 +            this._animateTimer = Components.classes["@mozilla.org/timer;1"]
 +                                           .createInstance(Components.interfaces.nsITimer);
 +          else
 +            this._animateTimer.cancel();
 +          this._currentHeight = aStartHeight;
 +
 +          this._animateTimer.initWithCallback(this, this._animateDelay,
 +                                              Components.interfaces.nsITimer.TYPE_REPEATING_SLACK);
 +        ]]>
 +        </body>
 +      </method>
 +
 +      <method name="_setUpFadeTimer">
 +        <body>
 +        <![CDATA[
 +          if (!this._fadeTimer)
 +            this._fadeTimer = Components.classes["@mozilla.org/timer;1"]
 +                                        .createInstance(Components.interfaces.nsITimer);
 +          else
 +            this._fadeTimer.cancel();
 +
 +          this._fadeTimer.initWithCallback(this, this._fadeDelay,
 +                                           Components.interfaces.nsITimer.TYPE_REPEATING_SLACK);
 +        ]]>
 +        </body>
 +      </method>
 +
 +      <field name="_animateTimer">null</field>
 +      <field name="_fadeTimer">null</field>
 +      <field name="_animateDelay">15</field>
 +      <field name="_animateIncrement">40</field>
 +      <field name="_fadeDelay">5</field>
 +      <method name="addPane">
 +        <parameter name="aPaneElement"/>
 +        <body>
 +        <![CDATA[
 +          this.appendChild(aPaneElement);
 +
 +          // Set up pane button
 +          this._makePaneButton(aPaneElement);
 +        ]]>
 +        </body>
 +      </method>
 +
 +      <method name="openSubDialog">
 +        <parameter name="aURL"/>
 +        <parameter name="aFeatures"/>
 +        <parameter name="aParams"/>
 +        <body>
 +          return openDialog(aURL, "", "modal,centerscreen,resizable=no" + (aFeatures != "" ? ("," + aFeatures) : ""), aParams);
 +        </body>
 +      </method>
 +
 +      <method name="openWindow">
 +        <parameter name="aWindowType"/>
 +        <parameter name="aURL"/>
 +        <parameter name="aFeatures"/>
 +        <parameter name="aParams"/>
 +
 +        var secMan = Components.classes["@mozilla.org/scriptsecuritymanager;1"]
 +                    .getService(Components.interfaces.nsIScriptSecurityManager);
 +        if (this.type == "child" && window.opener &&
 +            secMan.isSystemPrincipal(window.opener.document.nodePrincipal)) {
-+          var psvc = Components.classes["@mozilla.org/preferences-service;1"]
++          let psvc = Components.classes["@mozilla.org/preferences-service;1"]
 +                               .getService(Components.interfaces.nsIPrefBranch);
 +          var pdocEl = window.opener.document.documentElement;
 +          if (pdocEl.instantApply) {
-+            var panes = this.preferencePanes;
++            let panes = this.preferencePanes;
-+            for (var i = 0; i < panes.length; ++i)
++            for (let i = 0; i < panes.length; ++i)
 +              panes[i].writePreferences(true);
 +          }
 +          else {
 +            // Clone all the preferences elements from the child document and
 +            // insert them into the pane collection of the parent.
 +            var pdoc = window.opener.document;
 +            if (pdoc.documentElement.localName == "prefwindow") {
 +              var currentPane = pdoc.documentElement.currentPane;
 +              var id = window.location.href + "#childprefs";
 +              var childPrefs = pdoc.getElementById(id);
 +              if (!childPrefs) {
-+                var childPrefs = pdoc.createElement("preferences");
++                childPrefs = pdoc.createElement("preferences");
 +                currentPane.appendChild(childPrefs);
 +                childPrefs.id = id;
 +              }
-+              var panes = this.preferencePanes;
++              let panes = this.preferencePanes;
-+              for (var i = 0; i < panes.length; ++i) {
++              for (let i = 0; i < panes.length; ++i) {
 +                var preferences = panes[i].preferences;
 +                for (var j = 0; j < preferences.length; ++j) {
 +                  // Try to find a preference element for the same preference.
 +                  var preference = null;
 +                  var parentPreferences = pdoc.getElementsByTagName("preferences");
 +              }
 +            }
 +          }
 +        }
 +        else {
-+          var panes = this.preferencePanes;
++          let panes = this.preferencePanes;
 +          for (var i = 0; i < panes.length; ++i)
 +            panes[i].writePreferences(false);
 +
-+          var psvc = Components.classes["@mozilla.org/preferences-service;1"]
++          let psvc = Components.classes["@mozilla.org/preferences-service;1"]
 +                               .getService(Components.interfaces.nsIPrefService);
 +          psvc.savePrefFile(null);
 +        }
 +
 +        return true;
 +        event.preventDefault();
 +      ]]>
 +      </handler>
 +    </handlers>
 +  </binding>
 +
 +  <binding id="prefpane">
 +    <resources>
 +      <stylesheet src="chrome://global/skin/preferences.css"/>
 +    </resources>
 +    <content>
 +            psvc.savePrefFile(null);
 +          }
 +        ]]>
 +        </body>
 +      </method>
 +
 +      <property name="src"
 +                onget="return this.getAttribute('src');"
 +                onset="this.setAttribute('src', val); return val;"/>
 +      <property name="selected"
 +                onget="return this.getAttribute('selected') == 'true';"
 +                onset="this.setAttribute('selected', val); return val;"/>
 +      <property name="image"
 +                onget="return this.getAttribute('image');"
 +                onset="this.setAttribute('image', val); return val;"/>
 +      <property name="label"
 +                onget="return this.getAttribute('label');"
 +                onset="this.setAttribute('label', val); return val;"/>
 +
 +      <property name="preferenceElements"
 +                onget="return this.getElementsByAttribute('preference', '*');"/>
 +      <property name="preferences"
 +                onget="return this.getElementsByTagName('preference');"/>
 +
 +        ]]>
 +        </getter>
 +      </property>
 +
 +      <field name="_loaded">false</field>
 +      <property name="loaded"
 +                onget="return !this.src ? true : this._loaded;"
 +                onset="this._loaded = val; return val;"/>
 +
 +      <method name="preferenceForElement">
 +        <parameter name="aElement"/>
 +        <body>
 +          return document.getElementById(aElement.getAttribute("preference"));
 +        </body>
 +      </method>
 +
 +      <method name="getPreferenceElement">
 +        <parameter name="aStartElement"/>
 +        <body>
 +        <![CDATA[
 +          var temp = aStartElement;
 +          while (temp && temp.nodeType == Node.ELEMENT_NODE &&
 +                 !temp.hasAttribute("preference"))
 +            temp = temp.parentNode;
 +          return temp.nodeType == Node.ELEMENT_NODE ? temp : aStartElement;
 +        ]]>
 +        </body>
 +      </method>
 +
 +      <field name="DeferredTask" readonly="true">
 +        let targetObj = {};
 +        Components.utils.import("resource://gre/modules/DeferredTask.jsm", targetObj);
 +        targetObj.DeferredTask;
 +      </field>
 +            }
 +          }
 +        ]]>
 +        </body>
 +      </method>
 +
 +      <property name="contentHeight">
 +        <getter>
 +          var targetHeight = parseInt(window.getComputedStyle(this._content, "").height);
 +          targetHeight += parseInt(window.getComputedStyle(this._content, "").marginTop);
 +          targetHeight += parseInt(window.getComputedStyle(this._content, "").marginBottom);
 +        document.getAnonymousElementByAttribute(this, "class", "content-box");
 +      </field>
 +    </implementation>
 +    <handlers>
 +      <handler event="command">
 +        // This "command" event handler tracks changes made to preferences by
 +        // the user in this window.
 +        if (event.sourceEvent)
 +          event = event.sourceEvent;
 +        this.userChangedValue(event.target);
 +      </handler>
 +      <handler event="select">
 +        // This "select" event handler tracks changes made to colorpicker
 +        // preferences by the user in this window.
 +        if (event.target.localName == "colorpicker")
 +          this.userChangedValue(event.target);
 +      </handler>
 +      <handler event="change">
 +        // This "change" event handler tracks changes made to preferences by
 +        // the user in this window.
 +        this.userChangedValue(event.target);
 +      </handler>
 +      <handler event="input">
 +        // This "input" event handler tracks changes made to preferences by
 +        // the user in this window.
 +        this.userChangedValue(event.target);
 +      </handler>
 +      <handler event="paneload">
 +      <![CDATA[
 +          }
 +          catch (e) {
 +            dump("*** No preference found for " + elements[i].getAttribute("preference") + "\n");
 +          }
 +        }
 +      ]]>
 +      </handler>
 +    </handlers>
 +  </binding>
 +
 +  <binding id="panebutton" role="xul:listitem"
 +           extends="chrome://global/content/bindings/radio.xml#radio">
 +    <resources>
 +      <stylesheet src="chrome://global/skin/preferences.css"/>
 +    </resources>

changeset 916	2f9f2e040647
parent 909	c6717354928b
child 918	0f93e8da34b6