LOCAL_INCLUDES += -I$(topsrcdir)/toolkit/xre

#include "nsKDEUtils.h"

  // make sure we load these special files after all the others

  static const char* specialFiles[] = {

#if defined(XP_UNIX)

    ""

#endif

  };

  if (nsKDEUtils::kdeSession()) {

    for(int i = 0;

        i < NS_ARRAY_LENGTH(specialFiles);

        ++i ) {

      if (*specialFiles[ i ] == '\0') {

        specialFiles[ i ] = "kde.js";

        break;

      }

    }

  }

    , "" // placeholder for KDE  (empty is otherwise harmless)

  if(nsKDEUtils::kdeSession()) { // TODO what if some setup actually requires the helper?

    for(int i = 0;

        i < NS_ARRAY_LENGTH(specialFiles);

        ++i ) {

      if( *specialFiles[ i ] == '\0' ) {

        specialFiles[ i ] = "kde.js";

        break;

      }

    }

  }

	'desktop': StringFlag,

	'desktop',

LOCAL_INCLUDES += -I$(topsrcdir)/toolkit/xre

#if defined(XP_UNIX) && !defined(XP_MACOSX)

#include "nsKDEUtils.h"

#endif

        if( nsKDEUtils::kdeSupport()) {

          nsTArray<nsCString> command;

          command.AppendElement( NS_LITERAL_CSTRING( "DOWNLOADFINISHED" ));

          nsAutoString displayName;

          GetDisplayName( displayName );

          command.AppendElement( nsAutoCString( ToNewUTF8String( displayName )));

          nsKDEUtils::command( command );

        } else {

        // begin non-KDE block

      }

*+ content/global/bindings/dialog-kde.xml      (widgets/dialog-kde.xml)

% override chrome://global/content/bindings/dialog.xml chrome://global/content/bindings/dialog-kde.xml desktop=kde

*+ content/global/bindings/preferences-kde.xml (widgets/preferences-kde.xml)

% override chrome://global/content/bindings/preferences.xml chrome://global/content/bindings/preferences-kde.xml desktop=kde

<?xml version="1.0"?>

<!-- This Source Code Form is subject to the terms of the Mozilla Public

   - License, v. 2.0. If a copy of the MPL was not distributed with this

   - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->

<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

                >

        <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:spacer anonid="spacer" flex="1"/>

        <xul:button dlgtype="cancel" class="dialog-button"/>

        <xul:button dlgtype="accept" class="dialog-button" xbl:inherits="disabled=buttondisabledaccept"/>

#elif XP_UNIX

                pack="end">

	<xul:button dlgtype="help" class="dialog-button" hidden="true"/>

	<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"/>

	<xul:button dlgtype="extra1" class="dialog-button" hidden="true"/>

	<xul:button dlgtype="cancel" class="dialog-button"/>

	<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"/>

        <xul:button dlgtype="extra1" class="dialog-button" hidden="true"/>

        <xul:button dlgtype="cancel" class="dialog-button"/>

        <xul:button dlgtype="help" class="dialog-button" hidden="true"/>

        <xul:button dlgtype="disclosure" class="dialog-button" hidden="true"/>

#endif

      </xul:hbox>

    </content>

    <implementation>

      <field name="_mStrBundle">null</field>

      <field name="_closeHandler">(function(event) {

        if (!document.documentElement.cancelDialog())

          event.preventDefault();

      })</field>

      <property name="buttons"

                onget="return this.getAttribute('buttons');"

                onset="this._configureButtons(val); return val;"/>

      <property name="defaultButton">

        <getter>

        <![CDATA[

          if (this.hasAttribute("defaultButton"))

            return this.getAttribute("defaultButton");

          else // default to the accept button

            return "accept";

        ]]>

        </getter>

        <setter>

        <![CDATA[

          this._setDefaultButton(val);

          return val;

        ]]>

        </setter>

      </property>

      <method name="acceptDialog">

        <body>

        <![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];

        ]]>

        </body>

      </method>

      <method name="moveToAlertPosition">

        <body>

        <![CDATA[

          // hack. we need this so the window has something like its final size

          if (window.outerWidth == 1) {

            dump("Trying to position a sizeless window; caller should have called sizeToContent() or sizeTo(). See bug 75649.\n");

            sizeToContent();

          }

          var xOffset = (opener.outerWidth - window.outerWidth) / 2;

          var yOffset = opener.outerHeight / 5;

          var newX = opener.screenX + xOffset;

          var newY = opener.screenY + yOffset;

          // ensure the window is fully onscreen (if smaller than the screen)

          if (newX < screen.availLeft)

            newX = screen.availLeft + 20;

          if ((newX + window.outerWidth) > (screen.availLeft + screen.availWidth))

            newX = (screen.availLeft + screen.availWidth) - window.outerWidth - 20;

          if (newY < screen.availTop)

            newY = screen.availTop + 20;

          if ((newY + window.outerHeight) > (screen.availTop + screen.availHeight))

            newY = (screen.availTop + screen.availHeight) - window.outerHeight - 60;

          window.moveTo( newX, newY );

        ]]>

        </body>

      </method>

      <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>

      </method>

      <constructor>

      <![CDATA[

        this._configureButtons(this.buttons);

        // listen for when window is closed via native close buttons

        window.addEventListener("close", this._closeHandler, false);

        // for things that we need to initialize after onload fires

        window.addEventListener("load", this.postLoadInit, false);

        window.moveToAlertPosition = this.moveToAlertPosition;

        window.centerWindowOnScreen = this.centerWindowOnScreen;

      ]]>

      </constructor>

      <method name="postLoadInit">

        <parameter name="aEvent"/>

        <body>

        <![CDATA[

          function focusInit() {

            const dialog = document.documentElement;

            const defaultButton = dialog.getButton(dialog.defaultButton);

            // give focus to the first focusable element in the dialog

            if (!document.commandDispatcher.focusedElement) {

              document.commandDispatcher.advanceFocusIntoSubtree(dialog);

              var focusedElt = document.commandDispatcher.focusedElement;

              if (focusedElt) {

                var initialFocusedElt = focusedElt;

                while (focusedElt.localName == "tab" ||

                       focusedElt.getAttribute("noinitialfocus") == "true") {

                  document.commandDispatcher.advanceFocusIntoSubtree(focusedElt);

                  focusedElt = document.commandDispatcher.focusedElement;

                  if (focusedElt == initialFocusedElt)

                    break;

                }

                if (initialFocusedElt.localName == "tab") {

                  if (focusedElt.hasAttribute("dlgtype")) {

                    // We don't want to focus on anonymous OK, Cancel, etc. buttons,

                    // so return focus to the tab itself

                    initialFocusedElt.focus();

                  }

                }

#ifndef XP_MACOSX

                else if (focusedElt.hasAttribute("dlgtype") && focusedElt != defaultButton) {

                  defaultButton.focus();

                }

#endif

              }

            }

            try {

              if (defaultButton)

                window.notifyDefaultButtonLoaded(defaultButton);

            } catch (e) { }

          }

          // Give focus after onload completes, see bug 103197.

          setTimeout(focusInit, 0);

        ]]>

        </body>

      </method>                

      <property name="mStrBundle">

        <getter>

        <![CDATA[

          if (!this._mStrBundle) {

            // need to create string bundle manually instead of using <xul:stringbundle/>

            // see bug 63370 for details

            this._mStrBundle = Components.classes["@mozilla.org/intl/stringbundle;1"]

                                         .getService(Components.interfaces.nsIStringBundleService)

                                         .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

          var buttons = {};

          this._buttons = buttons;

          buttons.accept = document.getAnonymousElementByAttribute(this, "dlgtype", "accept");

          buttons.cancel = document.getAnonymousElementByAttribute(this, "dlgtype", "cancel");

          buttons.extra1 = document.getAnonymousElementByAttribute(this, "dlgtype", "extra1");

          buttons.extra2 = document.getAnonymousElementByAttribute(this, "dlgtype", "extra2");

          buttons.help = document.getAnonymousElementByAttribute(this, "dlgtype", "help");

          buttons.disclosure = document.getAnonymousElementByAttribute(this, "dlgtype", "disclosure");

          // look for any overriding explicit button elements

          var exBtns = this.getElementsByAttribute("dlgtype", "*");

          var dlgtype;

          var i;

          for (i = 0; i < exBtns.length; ++i) {

            dlgtype = exBtns[i].getAttribute("dlgtype");

            buttons[dlgtype].hidden = true; // hide the anonymous button

            buttons[dlgtype] = exBtns[i];

          }

          // add the label and oncommand handler to each button

          for (dlgtype in buttons) {

            var button = buttons[dlgtype];

            button.addEventListener("command", this._handleButtonCommand, true);

            // don't override custom labels with pre-defined labels on explicit buttons

            if (!button.hasAttribute("label")) {

              // dialog attributes override the default labels in dialog.properties

              if (this.hasAttribute("buttonlabel"+dlgtype)) {

                button.setAttribute("label", this.getAttribute("buttonlabel"+dlgtype));

                if (this.hasAttribute("buttonaccesskey"+dlgtype))

                  button.setAttribute("accesskey", this.getAttribute("buttonaccesskey"+dlgtype));

              } else if (dlgtype != "extra1" && dlgtype != "extra2") {

                button.setAttribute("label", this.mStrBundle.GetStringFromName("button-"+dlgtype));

                var accessKey = this.mStrBundle.GetStringFromName("accesskey-"+dlgtype);

                if (accessKey)

                  button.setAttribute("accesskey", accessKey);

              }

            }

            // allow specifying alternate icons in the dialog header

            if (!button.hasAttribute("icon")) {

              // if there's an icon specified, use that

              if (this.hasAttribute("buttonicon"+dlgtype))

                button.setAttribute("icon", this.getAttribute("buttonicon"+dlgtype));

              // otherwise set defaults

              else

                switch (dlgtype) {

                  case "accept":

                    button.setAttribute("icon","accept");

                    break;

                  case "cancel":

                    button.setAttribute("icon","cancel");

                    break;

                  case "disclosure":

                    button.setAttribute("icon","properties");

                    break;

                  case "help":

                    button.setAttribute("icon","help");

                    break;

                  default:

                    break;

                }

            }

          }

          // 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(",");

            // mark shown dlgtypes as true

            var shown = { accept: false, cancel: false, help: false,

                          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];

#ifdef XP_WIN

#           show the spacer on Windows only when the extra2 button is present

            var spacer = document.getAnonymousElementByAttribute(this, "anonid", "spacer");

            spacer.removeAttribute("hidden");

            spacer.setAttribute("flex", shown["extra2"]?"1":"0");

#endif

          }

        ]]>

        </body>

      </method>

      <method name="_setDefaultButton">

        <parameter name="aNewDefault"/>

        <body>

        <![CDATA[

          // remove the default attribute from the previous default button, if any

          var oldDefaultButton = this.getButton(this.defaultButton);

          if (oldDefaultButton)

            oldDefaultButton.removeAttribute("default");

          var newDefaultButton = this.getButton(aNewDefault);

          if (newDefaultButton) {

            this.setAttribute("defaultButton", aNewDefault);

            newDefaultButton.setAttribute("default", "true");

          }

          else {

            this.setAttribute("defaultButton", "none");

            if (aNewDefault != "none")

              dump("invalid new default button: " +  aNewDefault + ", assuming: none\n");

          }

        ]]>

        </body>

      </method>

      <method name="_handleButtonCommand">

        <parameter name="aEvent"/>

        <body>

        <![CDATA[

          return document.documentElement._doButtonCommand(

                                        aEvent.target.getAttribute("dlgtype"));

        ]]>

        </body>

      </method>

      <method name="_doButtonCommand">

        <parameter name="aDlgType"/>

        <body>

        <![CDATA[

          var button = this.getButton(aDlgType);

          if (!button.disabled) {

            var noCancel = this._fireButtonEvent(aDlgType);

            if (noCancel) {

              if (aDlgType == "accept" || aDlgType == "cancel")

                window.close();

            }

            return noCancel;

          }

          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>

      <method name="_hitEnter">

        <parameter name="evt"/>

        <body>

        <![CDATA[

          if (evt.defaultPrevented)

            return;

          var btn = this.getButton(this.defaultButton);

          if (btn)

            this._doButtonCommand(this.defaultButton);

        ]]>

        </body>

      </method>

    </implementation>

    <handlers>

      <handler event="keypress" keycode="VK_ENTER"

               group="system" action="this._hitEnter(event);"/>

      <handler event="keypress" keycode="VK_RETURN"

               group="system" action="this._hitEnter(event);"/>

      <handler event="keypress" keycode="VK_ESCAPE" group="system">

        if (!event.defaultPrevented)

          this.cancelDialog();

      </handler>

#ifdef XP_MACOSX

      <handler event="keypress" key="." modifiers="meta" phase="capturing" action="this.cancelDialog();"/>

#else

      <handler event="focus" phase="capturing">

        var btn = this.getButton(this.defaultButton);

        if (btn)

          btn.setAttribute("default", event.originalTarget == btn || !(event.originalTarget instanceof Components.interfaces.nsIDOMXULButtonElement));

      </handler>

#endif

    </handlers>

  </binding>

  <binding id="dialogheader">

    <resources>

      <stylesheet src="chrome://global/skin/dialog.css"/>

    </resources>

    <content>

      <xul:label class="dialogheader-title" xbl:inherits="value=title,crop" crop="right" flex="1"/>

      <xul:label class="dialogheader-description" xbl:inherits="value=description"/>

    </content>

  </binding>

</bindings>

<?xml version="1.0"?>

<!DOCTYPE bindings [

  <!ENTITY % preferencesDTD SYSTEM "chrome://global/locale/preferences.dtd">

  %preferencesDTD;

  <!ENTITY % globalKeysDTD SYSTEM "chrome://global/locale/globalKeys.dtd">

  %globalKeysDTD;

]>

<bindings id="preferencesBindings"

          xmlns="http://www.mozilla.org/xbl"

          xmlns:xbl="http://www.mozilla.org/xbl"

          xmlns:xul="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">

#

# = Preferences Window Framework

#

#   The syntax for use looks something like:

#

#   <prefwindow>

#     <prefpane id="prefPaneA">

#       <preferences>

#         <preference id="preference1" name="app.preference1" type="bool" onchange="foo();"/>

#         <preference id="preference2" name="app.preference2" type="bool" useDefault="true"/>

#       </preferences>

#       <checkbox label="Preference" preference="preference1"/>

#     </prefpane>

#   </prefwindow>

#

  <binding id="preferences">

    <implementation implements="nsIObserver">

      <method name="observe">

        <parameter name="aSubject"/>

        <parameter name="aTopic"/>

        <parameter name="aData"/>

        <body>

        <![CDATA[

          for (var i = 0; i < this.childNodes.length; ++i) {

            var preference = this.childNodes[i];

            if (preference.name == aData) {

              preference.value = preference.valueFromPreferences;

            }

          }

        ]]>

        </body>

      </method>

      <method name="fireChangedEvent">

        <parameter name="aPreference"/>

        <body>

        <![CDATA[

          // Value changed, synthesize an event

          try {

            var event = document.createEvent("Events");

            event.initEvent("change", true, true);

            aPreference.dispatchEvent(event);

          }

          catch (e) {

            Components.utils.reportError(e);

          }

        ]]>

        </body>

      </method>

      <field name="service">

        Components.classes["@mozilla.org/preferences-service;1"]

                  .getService(Components.interfaces.nsIPrefService);

      </field>

      <field name="rootBranch">

        Components.classes["@mozilla.org/preferences-service;1"]

                  .getService(Components.interfaces.nsIPrefBranch);

      </field>

      <field name="defaultBranch">

        this.service.getDefaultBranch("");

      </field>

      <field name="rootBranchInternal">

        Components.classes["@mozilla.org/preferences-service;1"]

                  .getService(Components.interfaces.nsIPrefBranchInternal);

      </field>

      <property name="type" readonly="true">

        <getter>

          <![CDATA[

            return document.documentElement.type || "";

          ]]>

        </getter>

      </property>

      <property name="instantApply" readonly="true">

        <getter>

          <![CDATA[

            var doc = document.documentElement;

            return this.type == "child" ? doc.instantApply

                                        : doc.instantApply || this.rootBranch.getBoolPref("browser.preferences.instantApply");

          ]]>

        </getter>

      </property>

    </implementation>

  </binding>

  <binding id="preference">

    <implementation>

      <constructor>

      <![CDATA[

        // if the element has been inserted without the name attribute set,

        // we have nothing to do here

        if (!this.name)

          return;

        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. 

        if (this.preferences.type == "child" && 

            !this.instantApply && window.opener) {

          var pdoc = window.opener.document;

          // Try to find a preference element for the same preference.

          var preference = null;

          var parentPreferences = pdoc.getElementsByTagName("preferences");

          for (var k = 0; (k < parentPreferences.length && !preference); ++k) {

            var parentPrefs = parentPreferences[k]

                                    .getElementsByAttribute("name", this.name);

            for (var l = 0; (l < parentPrefs.length && !preference); ++l) {

              if (parentPrefs[l].localName == "preference")

                preference = parentPrefs[l];

            }

          }

          this._setValue(preference ? preference.value 

                                    : this.valueFromPreferences, false);

        }

        else

          this._setValue(this.valueFromPreferences, false);

      ]]>

      </constructor>

      <destructor>

        this.preferences.rootBranchInternal

            .removeObserver(this.name, this.preferences);

      </destructor>

      <property name="instantApply">

        <getter>

          return this.getAttribute("instantApply") == "true" || this.preferences.instantApply;

        </getter>

      </property>

      <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;"/>

      <property name="inverted" onget="return this.getAttribute('inverted') == 'true';"

                                onset="this.setAttribute('inverted', val); return val;"/>

      <property name="readonly" onget="return this.getAttribute('readonly') == 'true';"

                                onset="this.setAttribute('readonly', val); return val;"/>

      <field name="_value">null</field>

      <method name="_setValue">

        <parameter name="aValue"/>

        <parameter name="aUpdate"/>

        <body>

        <![CDATA[

          if (aUpdate && this.value !== aValue) {

            this._value = aValue;

            if (this.instantApply)

              this.valueFromPreferences = aValue;

            this.preferences.fireChangedEvent(this);

          }

          else if (!aUpdate) {

            this._value = aValue;

            this.updateElements();

          }

          return aValue;

        ]]>

        </body>

      </method>

      <property name="value" onget="return this._value" onset="return this._setValue(val, true);"/>

      <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>

      <property name="hasUserValue">

        <getter>

        <![CDATA[

          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.

            switch (this.type) {

            case "int":

              return this._branch.getIntPref(this.name);

            case "bool":

              var val = this._branch.getBoolPref(this.name);

              return this.inverted ? !val : val;

            case "wstring":

              return this._branch

                         .getComplexValue(this.name, Components.interfaces.nsIPrefLocalizedString)

                         .data;

            case "string":

            case "unichar":

              return this._branch

                         .getComplexValue(this.name, Components.interfaces.nsISupportsString)

                         .data;

            case "fontname":

              var family = this._branch

                               .getComplexValue(this.name, Components.interfaces.nsISupportsString)

                               .data;

              var fontEnumerator = Components.classes["@mozilla.org/gfx/fontenumerator;1"]

                                             .createInstance(Components.interfaces.nsIFontEnumerator);

              return fontEnumerator.getStandardFamilyName(family);

            case "file":

              var f = this._branch

                          .getComplexValue(this.name, Components.interfaces.nsILocalFile);

              return f;

            default:

              this._reportUnknownType();

            }

          }

          catch (e) { }

          return null;

        ]]>

        </getter>

        <setter>

        <![CDATA[

          // Exit early if nothing to do.

          if (this.readonly || this.valueFromPreferences == val)

            return val;

          // The special value undefined means 'reset preference to default'.

          if (val === undefined) {

            this.preferences.rootBranch.clearUserPref(this.name);

            return val;

          }

          // Force a resync of preferences with value.

          switch (this.type) {

          case "int":

            this.preferences.rootBranch.setIntPref(this.name, val);

            break;

          case "bool":

            this.preferences.rootBranch.setBoolPref(this.name, this.inverted ? !val : val);

            break;

          case "wstring":

            var pls = Components.classes["@mozilla.org/pref-localizedstring;1"]

                                .createInstance(Components.interfaces.nsIPrefLocalizedString);

            pls.data = val;

            this.preferences.rootBranch

                .setComplexValue(this.name, Components.interfaces.nsIPrefLocalizedString, pls);

            break;

          case "string":

          case "unichar":

          case "fontname":

            var iss = Components.classes["@mozilla.org/supports-string;1"]

                                .createInstance(Components.interfaces.nsISupportsString);

            iss.data = val;

            this.preferences.rootBranch

                .setComplexValue(this.name, Components.interfaces.nsISupportsString, iss);

            break;

          case "file":

            var lf;

            if (typeof(val) == "string") {

              lf = Components.classes["@mozilla.org/file/local;1"]

                             .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._reportUnknownType();

          }

          if (!this.batching)

            this.preferences.service.savePrefFile(null);

          return val;

        ]]>

        </setter>

      </property>

      <method name="setElementValue">

        <parameter name="aElement"/>

        <body>

        <![CDATA[

          if (this.locked)

            aElement.disabled = true;

          if (!this.isElementEditable(aElement))

            return;

          var rv = undefined;

          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);

          // 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" ||

              aElement.localName == "listitem")

            setValue(aElement, "checked", val);

          else if (aElement.localName == "colorpicker")

            setValue(aElement, "color", val);

          else if (aElement.localName == "textbox") {

            // XXXmano Bug 303998: Avoid a caret placement issue if either the

            // preference observer or its setter calls updateElements as a result

            // of the input event handler.

            if (aElement.value !== val)

              setValue(aElement, "value", val);

          }

          else

            setValue(aElement, "value", val);

        ]]>

        </body>

      </method>

      <method name="getElementValue">

        <parameter name="aElement"/>

        <body>

        <![CDATA[

          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) {

            if (attribute in element)

              return element[attribute];

            return element.getAttribute(attribute);

          }

          if (aElement.localName == "checkbox" ||

              aElement.localName == "listitem")

            var value = getValue(aElement, "checked");

          else if (aElement.localName == "colorpicker")

            value = getValue(aElement, "color");

          else

            value = getValue(aElement, "value");

          switch (this.type) {

          case "int":

            return parseInt(value, 10) || 0;

          case "bool":

            return typeof(value) == "boolean" ? value : value == "true";

          }

          return value;

        ]]>

        </body>

      </method>

      <method name="isElementEditable">

        <parameter name="aElement"/>

        <body>

        <![CDATA[

          switch (aElement.localName) {

          case "checkbox":

          case "colorpicker":

          case "radiogroup":

          case "textbox":

          case "listitem":

          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>

  </binding>

  <binding id="prefwindow"

           extends="chrome://global/content/bindings/dialog.xml#dialog">

    <resources>

      <stylesheet src="chrome://global/skin/preferences.css"/>

    </resources>

    <content dlgbuttons="accept,cancel" persist="lastSelected screenX screenY"

             closebuttonlabel="&preferencesCloseButton.label;"

             closebuttonaccesskey="&preferencesCloseButton.accesskey;"

             role="dialog"

#ifdef XP_WIN

             title="&preferencesDefaultTitleWin.title;">

#else

             title="&preferencesDefaultTitleMac.title;">

#endif

      <xul:windowdragbox orient="vertical">

        <xul:radiogroup anonid="selector" orient="horizontal" class="paneSelector chromeclass-toolbar"

                        role="listbox"/> <!-- Expose to accessibility APIs as a listbox -->

      </xul:windowdragbox>

      <xul:hbox flex="1" class="paneDeckContainer">

        <xul:deck anonid="paneDeck" flex="1">

          <children includes="prefpane"/>

        </xul:deck>

      </xul:hbox>

      <xul:hbox anonid="dlg-buttons" class="prefWindow-dlgbuttons"

#ifdef XP_UNIX_GNOME

                >

        <xul:button dlgtype="disclosure" class="dialog-button" hidden="true"/>

        <xul:button dlgtype="help" class="dialog-button" hidden="true" icon="help"/>

        <xul:button dlgtype="extra2" class="dialog-button" hidden="true"/>

        <xul:button dlgtype="extra1" class="dialog-button" hidden="true"/>

        <xul:spacer anonid="spacer" flex="1"/>

        <xul:button dlgtype="cancel" class="dialog-button" icon="cancel"/>

        <xul:button dlgtype="accept" class="dialog-button" icon="accept"/>

#elif XP_UNIX

                pack="end">

	<xul:button dlgtype="help" class="dialog-button" hidden="true" icon="help"/>

	<xul:button dlgtype="extra2" class="dialog-button" hidden="true"/>

	<xul:spacer anonid="spacer" flex="1"/>

	<xul:button dlgtype="accept" class="dialog-button" icon="accept"/>

	<xul:button dlgtype="extra1" class="dialog-button" hidden="true"/>

	<xul:button dlgtype="cancel" class="dialog-button" icon="cancel"/>

	<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"/>

        <xul:button dlgtype="accept" class="dialog-button" icon="accept"/>

        <xul:button dlgtype="extra1" class="dialog-button" hidden="true"/>

        <xul:button dlgtype="cancel" class="dialog-button" icon="cancel"/>

        <xul:button dlgtype="help" class="dialog-button" hidden="true" icon="help"/>

        <xul:button dlgtype="disclosure" class="dialog-button" hidden="true"/>

#endif

      </xul:hbox>

      <xul:hbox>

        <children/>

      </xul:hbox>

    </content>

    <implementation implements="nsITimerCallback">

      <constructor>

      <![CDATA[

        if (this.type != "child") {

          var psvc = Components.classes["@mozilla.org/preferences-service;1"]

                               .getService(Components.interfaces.nsIPrefBranch);

          this.instantApply = psvc.getBoolPref("browser.preferences.instantApply");

          if (this.instantApply) {

            var docElt = document.documentElement;

            var acceptButton = docElt.getButton("accept");

            acceptButton.hidden = true;

            var cancelButton  = docElt.getButton("cancel");

#ifdef XP_MACOSX

            // no buttons on Mac except Help

            cancelButton.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");

            cancelButton.label = docElt.getAttribute("closebuttonlabel");

            cancelButton.accesskey = docElt.getAttribute("closebuttonaccesskey");

#endif

          }

        }

        this.setAttribute("animated", this._shouldAnimate ? "true" : "false");

        var panes = this.preferencePanes;

        var lastPane = null;

        if (this.lastSelected) {

          lastPane = document.getElementById(this.lastSelected);

          if (!lastPane) {

            this.lastSelected = "";

          }

        }

        var paneToLoad;

        if ("arguments" in window && window.arguments[0] && document.getElementById(window.arguments[0]) && document.getElementById(window.arguments[0]).nodeName == "prefpane") {

          paneToLoad = document.getElementById(window.arguments[0]);

          this.lastSelected = paneToLoad.id;

        }

        else if (lastPane)

          paneToLoad = lastPane;

        else

          paneToLoad = panes[0];

        for (var i = 0; i < panes.length; ++i) {

          this._makePaneButton(panes[i]);

          if (panes[i].loaded) {

            // Inline pane content, fire load event to force initialization.

            this._fireEvent("paneload", panes[i]);

          }

        }

        this.showPane(paneToLoad);

        if (panes.length == 1)

          this._selector.setAttribute("collapsed", "true");

      ]]>

      </constructor>

      <destructor>

      <![CDATA[

        // Release timers to avoid reference cycles.

        if (this._animateTimer) {

          this._animateTimer.cancel();

          this._animateTimer = null;

        }

        if (this._fadeTimer) {

          this._fadeTimer.cancel();

          this._fadeTimer = null;

        }

      ]]>

      </destructor>

      <field name="instantApply">false</field>

      <property name="preferencePanes"

                onget="return this.getElementsByTagName('prefpane');"/>

      <property name="type" onget="return this.getAttribute('type');"/>

      <property name="_paneDeck"

                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");

          radio.setAttribute("pane", aPaneElement.id);

          radio.setAttribute("label", aPaneElement.label);

          // Expose preference group choice to accessibility APIs as an unchecked list item

          // The parent group is exposed to accessibility APIs as a list

          if (aPaneElement.image)

            radio.setAttribute("src", aPaneElement.image);

          radio.style.listStyleImage = aPaneElement.style.listStyleImage;

          this._selector.appendChild(radio);

          return radio;

        ]]>

        </body>

      </method>

      <method name="showPane">

        <parameter name="aPaneElement"/>

        <body>

        <![CDATA[

          if (!aPaneElement)

            return;

          this._selector.selectedItem = document.getAnonymousElementByAttribute(this, "pane", aPaneElement.id);

          if (!aPaneElement.loaded) {

            function OverlayLoadObserver(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[

#ifdef XP_MACOSX

          var paneTitle = aPaneElement.label;

          if (paneTitle != "")

            document.title = paneTitle;

#endif

          var helpButton = document.documentElement.getButton("help");

          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

                // will size the windows contents so style information is

                // available to calculate correct sizing.

                if (!this._initialized && prefpanes.length > 1) {

                  if (this._shouldAnimate)

                    this.style.minHeight = 0;

                  window.sizeToContent();

                }

                var oldPane = this.lastSelected ? document.getElementById(this.lastSelected) : this.preferencePanes[0];

                oldPane.selected = !(aPaneElement.selected = true);

                this.lastSelected = aPaneElement.id;

                this.currentPane = aPaneElement;

                this._initialized = true;

                // Only animate if we've switched between prefpanes

                if (this._shouldAnimate && oldPane.id != aPaneElement.id) {

                  aPaneElement.style.opacity = 0.0;

                  this.animate(oldPane, aPaneElement);

                }

                else if (!this._shouldAnimate && prefpanes.length > 1) {

                  var targetHeight = parseInt(window.getComputedStyle(this._paneDeckContainer, "").height);

                  var verticalPadding = parseInt(window.getComputedStyle(aPaneElement, "").paddingTop);

                  verticalPadding += parseInt(window.getComputedStyle(aPaneElement, "").paddingBottom);

                  if (aPaneElement.contentHeight > targetHeight - verticalPadding) {

                    // To workaround the bottom border of a groupbox from being

                    // cutoff an hbox with a class of bottomBox may enclose it.

                    // This needs to include its padding to resize properly.

                    // See bug 394433

                    var bottomPadding = 0;

                    var bottomBox = aPaneElement.getElementsByAttribute("class", "bottomBox")[0];

                    if (bottomBox)

                      bottomPadding = parseInt(window.getComputedStyle(bottomBox, "").paddingBottom);

                    window.innerHeight += bottomPadding + verticalPadding + aPaneElement.contentHeight - targetHeight;

                  }

                  // XXX rstrong - extend the contents of the prefpane to

                  // prevent elements from being cutoff (see bug 349098).

                  if (aPaneElement.contentHeight + verticalPadding < targetHeight)

                    aPaneElement._content.style.height = targetHeight - verticalPadding + "px";

                }

              }

              break;

            }

          }

        ]]>

        </body>

      </method>

      <property name="_shouldAnimate">

        <getter>

        <![CDATA[

          var psvc = Components.classes["@mozilla.org/preferences-service;1"]

                               .getService(Components.interfaces.nsIPrefBranch);

#ifdef XP_MACOSX

          var animate = true;

#else

          var animate = false;

#endif

          try {

            animate = psvc.getBoolPref("browser.preferences.animateFadeIn");

          }

          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;

            }

            else {

              aTimer.cancel();

              this._setUpFadeTimer();

            }

          } else if (aTimer == this._fadeTimer) {

            var elt = document.getElementById(this.lastSelected);

            var newOpacity = parseFloat(window.getComputedStyle(elt, "").opacity) + this._fadeIncrement;

            if (newOpacity < 1.0)

              elt.style.opacity = newOpacity;

            else {

              aTimer.cancel();

              elt.style.opacity = 1.0;

            }

          }

        ]]>

        </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>

      <field name="_fadeIncrement">0.40</field>

      <field name="_animateRemainder">0</field>

      <field name="_currentHeight">0</field>

      <field name="_multiplier">0</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"/>

        <body>

        <![CDATA[

          var wm = Components.classes["@mozilla.org/appshell/window-mediator;1"]

                             .getService(Components.interfaces.nsIWindowMediator);

          var win = aWindowType ? wm.getMostRecentWindow(aWindowType) : null;

          if (win) {

            if ("initWithParams" in win)

              win.initWithParams(aParams);

            win.focus();

          }

          else {

            var features = "resizable,dialog=no,centerscreen" + (aFeatures != "" ? ("," + aFeatures) : "");

            var parentWindow = (this.instantApply || !window.opener || window.opener.closed) ? window : window.opener;

            win = parentWindow.openDialog(aURL, "_blank", features, aParams);

          }

          return win;

        ]]>

        </body>

      </method>

    </implementation>

    <handlers>

      <handler event="dialogaccept">

      <![CDATA[

        if (!this._fireEvent("beforeaccept", this)) 

          return;

        if (this.type == "child" && window.opener) {

          var psvc = Components.classes["@mozilla.org/preferences-service;1"]

                               .getService(Components.interfaces.nsIPrefBranch);

          var instantApply = psvc.getBoolPref("browser.preferences.instantApply");