home *** CD-ROM | disk | FTP | other *** search
/ PC World 2003 October / PCWorld_2003-10_cd.bin / Komunik / Thunderbird / thunderbird-0.2-win32.exe / thunderbird / components / nsHelperAppDlg.js < prev    next >
Encoding:
JavaScript  |  2003-09-01  |  31.9 KB  |  834 lines
  1. /*
  2. # -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  3. # Version: MPL 1.1/GPL 2.0/LGPL 2.1
  4. # 
  5. # The contents of this file are subject to the Mozilla Public License Version
  6. # 1.1 (the "License"); you may not use this file except in compliance with
  7. # the License. You may obtain a copy of the License at
  8. # http://www.mozilla.org/MPL/
  9. # 
  10. # Software distributed under the License is distributed on an "AS IS" basis,
  11. # WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12. # for the specific language governing rights and limitations under the
  13. # License.
  14. # 
  15. # The Original Code is Mozilla.org Code.
  16. # 
  17. # The Initial Developer of the Original Code is
  18. # Doron Rosenberg.
  19. # Portions created by the Initial Developer are Copyright (C) 2001
  20. # the Initial Developer. All Rights Reserved.
  21. # 
  22. # Contributor(s):
  23. #   Bill Law <law@netscape.com>
  24. #   Scott MacGregor <mscott@netscape.com>
  25. #   Ben Goodger <ben@bengoodger.com> (2.0)
  26. # 
  27. # Alternatively, the contents of this file may be used under the terms of
  28. # either the GNU General Public License Version 2 or later (the "GPL"), or
  29. # the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  30. # in which case the provisions of the GPL or the LGPL are applicable instead
  31. # of those above. If you wish to allow use of your version of this file only
  32. # under the terms of either the GPL or the LGPL, and not to allow others to
  33. # use your version of this file under the terms of the MPL, indicate your
  34. # decision by deleting the provisions above and replace them with the notice
  35. # and other provisions required by the GPL or the LGPL. If you do not delete
  36. # the provisions above, a recipient may use your version of this file under
  37. # the terms of any one of the MPL, the GPL or the LGPL.
  38. # 
  39. # ***** END LICENSE BLOCK *****
  40. */
  41.  
  42. /* This file implements the nsIHelperAppLauncherDialog interface.
  43.  *
  44.  * The implementation consists of a JavaScript "class" named nsUnknownContentTypeDialog,
  45.  * comprised of:
  46.  *   - a JS constructor function
  47.  *   - a prototype providing all the interface methods and implementation stuff
  48.  *
  49.  * In addition, this file implements an nsIModule object that registers the
  50.  * nsUnknownContentTypeDialog component.
  51.  */
  52.  
  53.  
  54. /* ctor
  55.  */
  56. function nsUnknownContentTypeDialog() {
  57.     // Initialize data properties.
  58.     this.mLauncher = null;
  59.     this.mContext  = null;
  60.     this.mSourcePath = null;
  61.     this.chosenApp = null;
  62.     this.givenDefaultApp = false;
  63.     this.updateSelf = true;
  64.     this.mTitle    = "";
  65. }
  66.  
  67. nsUnknownContentTypeDialog.prototype = {
  68.     nsIMIMEInfo  : Components.interfaces.nsIMIMEInfo,
  69.  
  70.     // This "class" supports nsIHelperAppLauncherDialog, and nsISupports.
  71.     QueryInterface: function (iid) {
  72.         if (!iid.equals(Components.interfaces.nsIHelperAppLauncherDialog) &&
  73.             !iid.equals(Components.interfaces.nsISupports)) {
  74.             throw Components.results.NS_ERROR_NO_INTERFACE;
  75.         }
  76.         return this;
  77.     },
  78.  
  79.     // ---------- nsIHelperAppLauncherDialog methods ----------
  80.  
  81.     // show: Open XUL dialog using window watcher.  Since the dialog is not
  82.     //       modal, it needs to be a top level window and the way to open
  83.     //       one of those is via that route).
  84.     show: function(aLauncher, aContext)  {  
  85.       this.mLauncher = aLauncher;
  86.       this.mContext  = aContext;
  87.       // Display the dialog using the Window Watcher interface.
  88.       var ww = Components.classes["@mozilla.org/embedcomp/window-watcher;1"]
  89.                 .getService(Components.interfaces.nsIWindowWatcher);
  90.       this.mDialog = ww.openWindow(null, // no parent
  91.                                    "chrome://mozapps/content/downloads/unknownContentType.xul",
  92.                                    null,
  93.                                    "chrome,titlebar,dialog=yes",
  94.                                    null);
  95.       // Hook this object to the dialog.
  96.       this.mDialog.dialog = this;
  97.       
  98.       // Hook up utility functions. 
  99.       // XXXben these lines can disappear if we can get XULPP to run on stuff not 
  100.       //        thus referenced in jar.mns. 
  101.       this.getSpecialFolderKey = this.mDialog.getSpecialFolderKey;
  102.       
  103.       this.mIsMac = (this.mDialog.navigator.platform.indexOf("Mac") != -1);
  104.       this.mIsWin = (this.mDialog.navigator.platform.indexOf("Win") != -1);
  105.       
  106.       // Watch for error notifications.
  107.       this.progressListener.helperAppDlg = this;
  108.       this.mLauncher.setWebProgressListener(this.progressListener);
  109.     },
  110.  
  111.     // promptForSaveToFile:  Display file picker dialog and return selected file.
  112.     //                       This is called by the External Helper App Service
  113.     //                       after the ucth dialog calls |saveToDisk| with a null
  114.     //                       target filename (no target, therefore user must pick).
  115.     //
  116.     //                       Alternatively, if the user has selected to have all
  117.     //                       files download to a specific location, return that
  118.     //                       location and don't ask via the dialog. 
  119.     //
  120.     // Note - this function is called without a dialog, so it cannot access any part
  121.     // of the dialog XUL as other functions on this object do. 
  122.     promptForSaveToFile: function(aLauncher, aContext, aDefaultFile, aSuggestedFileExtension) {
  123.       var result = "";
  124.       
  125.       this.mLauncher = aLauncher;
  126.  
  127.       // If the user is always downloading to the same location, the default download
  128.       // folder is stored in preferences. If a value is found stored, use that 
  129.       // automatically and don't ask via a dialog. 
  130.       const kDownloadFolderPref = "browser.download.defaultFolder";
  131.       var prefs = Components.classes["@mozilla.org/preferences-service;1"].getService(Components.interfaces.nsIPrefBranch);
  132.       try {
  133.         result = prefs.getComplexValue(kDownloadFolderPref, Components.interfaces.nsILocalFile);
  134.         result.append(aDefaultFile);
  135.         
  136.         // Since we're automatically downloading, we don't get the file picker's 
  137.         // logic to check for existing files, so we need to do that here.
  138.         //
  139.         // Note - this code is identical to that in 
  140.         //   browser/base/content/contentAreaUtils.js. 
  141.         // If you are updating this code, update that code too! We can't share code
  142.         // here since this is called in a js component. 
  143.         while (result.exists()) {
  144.           var parts = /.+-(\d+)(\..*)?$/.exec(result.leafName);
  145.           if (parts) {
  146.             result.leafName = result.leafName.replace(/((\d+)\.)/, 
  147.                                                       function (str, p1, part, s) { 
  148.                                                         return (parseInt(part) + 1) + "."; 
  149.                                                       });
  150.           }
  151.           else {
  152.             result.leafName = result.leafName.replace(/\./, "-1$&");
  153.           }
  154.         }
  155.       }
  156.       catch (e) { }
  157.       
  158.       if (!result) {
  159.         // Use file picker to show dialog.
  160.         var nsIFilePicker = Components.interfaces.nsIFilePicker;
  161.         var picker = Components.classes["@mozilla.org/filepicker;1"].createInstance(nsIFilePicker);
  162.  
  163.         var bundle = Components.classes["@mozilla.org/intl/stringbundle;1"].getService(Components.interfaces.nsIStringBundleService);
  164.         bundle = bundle.createBundle("chrome://mozapps/locale/downloads/unknownContentType.properties");
  165.  
  166.         var windowTitle = bundle.GetStringFromName("saveDialogTitle");
  167.         var parent = aContext.QueryInterface(Components.interfaces.nsIInterfaceRequestor).getInterface(Components.interfaces.nsIDOMWindowInternal);
  168.         picker.init(parent, windowTitle, nsIFilePicker.modeSave);
  169.         picker.defaultString = aDefaultFile;
  170.  
  171.         if (aSuggestedFileExtension) {
  172.           // aSuggestedFileExtension includes the period, so strip it
  173.           picker.defaultExtension = aSuggestedFileExtension.substring(1);
  174.         } 
  175.         else {
  176.           try {
  177.             picker.defaultExtension = this.mLauncher.MIMEInfo.primaryExtension;
  178.           } 
  179.           catch (ex) { }
  180.         }
  181.  
  182.         var wildCardExtension = "*";
  183.         if (aSuggestedFileExtension) {
  184.           wildCardExtension += aSuggestedFileExtension;
  185.           picker.appendFilter(this.mLauncher.MIMEInfo.Description, wildCardExtension);
  186.         }
  187.  
  188.         picker.appendFilters( nsIFilePicker.filterAll );
  189.  
  190.         // Pull in the user's preferences and get the default download directory.
  191.         var prefs = Components.classes["@mozilla.org/preferences-service;1"].getService(Components.interfaces.nsIPrefBranch);
  192.         try {
  193.           var startDir = prefs.getComplexValue("browser.download.dir", Components.interfaces.nsILocalFile);
  194.           if (startDir.exists()) {
  195.             picker.displayDirectory = startDir;
  196.           }
  197.         } 
  198.         catch(exception) { }
  199.  
  200.         var dlgResult = picker.show();
  201.  
  202.         if (dlgResult == nsIFilePicker.returnCancel) {
  203.           // null result means user cancelled.
  204.           return null;
  205.         }
  206.  
  207.  
  208.         // Be sure to save the directory the user chose as the new browser.download.dir
  209.         result = picker.file;
  210.  
  211.         if (result) {
  212.           var newDir = result.parent;
  213.           prefs.setComplexValue("browser.download.dir", Components.interfaces.nsILocalFile, newDir);
  214.         }
  215.         
  216.       }
  217.       return result;
  218.     },
  219.     
  220.     // ---------- implementation methods ----------
  221.  
  222.     // Web progress listener so we can detect errors while mLauncher is
  223.     // streaming the data to a temporary file.
  224.     progressListener: {
  225.         // Implementation properties.
  226.         helperAppDlg: null,
  227.  
  228.         // nsIWebProgressListener methods.
  229.         // Look for error notifications and display alert to user.
  230.         onStatusChange: function( aWebProgress, aRequest, aStatus, aMessage ) {
  231.             if ( aStatus != Components.results.NS_OK ) {
  232.                 // Get prompt service.
  233.                 var prompter = Components.classes[ "@mozilla.org/embedcomp/prompt-service;1" ]
  234.                                    .getService( Components.interfaces.nsIPromptService );
  235.                 // Display error alert (using text supplied by back-end).
  236.                 prompter.alert( this.dialog, this.helperAppDlg.mTitle, aMessage );
  237.  
  238.                 // Close the dialog.
  239.                 this.helperAppDlg.onCancel();
  240.                 if ( this.helperAppDlg.mDialog ) {
  241.                     this.helperAppDlg.mDialog.close();
  242.                 }
  243.             }
  244.         },
  245.  
  246.         // Ignore onProgressChange, onStateChange, onLocationChange, and onSecurityChange notifications.
  247.         onProgressChange: function( aWebProgress,
  248.                                     aRequest,
  249.                                     aCurSelfProgress,
  250.                                     aMaxSelfProgress,
  251.                                     aCurTotalProgress,
  252.                                     aMaxTotalProgress ) {
  253.         },
  254.  
  255.         onStateChange: function( aWebProgress, aRequest, aStateFlags, aStatus ) {
  256.         },
  257.  
  258.         onLocationChange: function( aWebProgress, aRequest, aLocation ) {
  259.         },
  260.  
  261.         onSecurityChange: function( aWebProgress, aRequest, state ) {
  262.         }
  263.     },
  264.  
  265.     // initDialog:  Fill various dialog fields with initial content.
  266.     initDialog : function() {
  267.          // Put file name in window title.
  268.          var win   = this.dialogElement( "unknownContentType" );
  269.          var suggestedFileName = this.mLauncher.suggestedFileName;
  270.  
  271.          // Some URIs do not implement nsIURL, so we can't just QI.
  272.          var url   = this.mLauncher.source;
  273.          var fname = "";
  274.          this.mSourcePath = url.prePath;
  275.          try {
  276.              url = url.QueryInterface( Components.interfaces.nsIURL );
  277.              // A url, use file name from it.
  278.              fname = url.fileName;
  279.              this.mSourcePath += url.directory;
  280.          } catch (ex) {
  281.              // A generic uri, use path.
  282.              fname = url.path;
  283.              this.mSourcePath += url.path;
  284.          }
  285.  
  286.          if (suggestedFileName)
  287.            fname = suggestedFileName;
  288.            
  289.  
  290.          this.mTitle = this.dialogElement("strings").getFormattedString("title", [fname]);
  291.          win.setAttribute( "title", this.mTitle );
  292.  
  293.          // Put content type, filename and location into intro.
  294.          this.initIntro(url, fname);
  295.  
  296.          var iconString = "moz-icon://" + fname + "?size=16&contentType=" + this.mLauncher.MIMEInfo.MIMEType;
  297.          this.dialogElement("contentTypeImage").setAttribute("src", iconString);
  298.  
  299.          this.initAppAndSaveToDiskValues();
  300.  
  301.          // Initialize "always ask me" box. This should always be disabled
  302.          // and set to true for the ambiguous type application/octet-stream.
  303.          // We don't also check for application/x-msdownload here since we
  304.          // want users to be able to autodownload .exe files. 
  305.          var rememberChoice = this.dialogElement("rememberChoice");
  306.          if (this.mLauncher.MIMEInfo.MIMEType == "application/octet-stream") {
  307.             rememberChoice.checked = false;
  308.             rememberChoice.disabled = true;
  309.          }
  310.          else {
  311.             rememberChoice.checked = !this.mLauncher.MIMEInfo.alwaysAskBeforeHandling;
  312.          }
  313.          this.toggleRememberChoice(rememberChoice);
  314.          
  315.  
  316.          // XXXben - menulist won't init properly, hack. 
  317.          var openHandler = this.dialogElement("openHandler");
  318.          openHandler.parentNode.removeChild(openHandler);
  319.          var openParent = this.dialogElement("open").parentNode;
  320.          openParent.appendChild(openHandler);
  321.          
  322.          this.mDialog.setTimeout("dialog.postShowCallback()", 0);
  323.     },
  324.     
  325.     postShowCallback: function () {
  326.       // Position the window if it has never been positioned before (i.e. 
  327.       // before XUL persistence has picked up anything to fill the screenX/
  328.       // screenY attributes with. Assume if one is unset, the other will be too).
  329.       if (this.mDialog.document.documentElement.getAttribute("screenX") == "") {
  330.         if (this.mDialog.opener) {
  331.           this.mDialog.moveToAlertPosition();
  332.         } 
  333.         else {
  334.           this.mDialog.centerWindowOnScreen();
  335.         }
  336.       }
  337.       
  338.       this.mDialog.sizeToContent();
  339.  
  340.       // Set initial focus
  341.       this.dialogElement("mode").focus();
  342.     },
  343.  
  344.     // initIntro:
  345.     initIntro: function(url, filename) {
  346.         this.dialogElement( "location" ).value = filename;
  347.  
  348.         // if mSourcePath is a local file, then let's use the pretty path name instead of an ugly
  349.         // url...
  350.         var pathString = this.mSourcePath;
  351.         try 
  352.         {
  353.           var fileURL = url.QueryInterface(Components.interfaces.nsIFileURL);
  354.           if (fileURL)
  355.           {
  356.             var fileObject = fileURL.file;
  357.             if (fileObject)
  358.             {
  359.               var parentObject = fileObject.parent;
  360.               if (parentObject)
  361.               {
  362.                 pathString = parentObject.path;
  363.               }
  364.             }
  365.           }
  366.         } catch(ex) {}
  367.  
  368.         // Set the location text, which is separate from the intro text so it can be cropped
  369.         var location = this.dialogElement( "source" );
  370.         location.value = pathString;
  371.         
  372.         // Show the type of file. 
  373.         var type = this.dialogElement("type");
  374.         var mimeInfo = this.mLauncher.MIMEInfo;
  375.         
  376.         // 1. Try to use the pretty description of the type, if one is available.
  377.         var typeString = mimeInfo.Description;
  378.         
  379.         if (typeString == "") {
  380.           // 2. If there is none, use the extension to identify the file, e.g. "ZIP file"
  381.           var primaryExtension = "";
  382.           try {
  383.             primaryExtension = mimeInfo.primaryExtension;
  384.           }
  385.           catch (ex) {
  386.           }
  387.           if (primaryExtension != "")
  388.             typeString = primaryExtension.toUpperCase() + " file";
  389.           // 3. If we can't even do that, just give up and show the MIME type. 
  390.           else
  391.             typeString = mimeInfo.MIMEType;
  392.         }
  393.         
  394.         type.value = typeString;
  395.     },
  396.  
  397.     // Returns true if opening the default application makes sense.
  398.     openWithDefaultOK: function() {
  399.         var result;
  400.  
  401.         // The checking is different on Windows...
  402.         if ( this.mIsWin ) {
  403.             // Windows presents some special cases.
  404.             // We need to prevent use of "system default" when the file is
  405.             // executable (so the user doesn't launch nasty programs downloaded
  406.             // from the web), and, enable use of "system default" if it isn't
  407.             // executable (because we will prompt the user for the default app
  408.             // in that case).
  409.             
  410.             // Need to get temporary file and check for executable-ness.
  411.             var ignore1 = new Object;
  412.             var ignore2 = new Object;
  413.             var tmpFile = this.mLauncher.getDownloadInfo( ignore1, ignore2 );
  414.             
  415.             //  Default is Ok if the file isn't executable (and vice-versa).
  416.             result = !tmpFile.isExecutable();
  417.         } else {
  418.             // On other platforms, default is Ok if there is a default app.
  419.             // Note that nsIMIMEInfo providers need to ensure that this holds true
  420.             // on each platform.
  421.             result = this.mLauncher.MIMEInfo.defaultApplicationHandler;
  422.         }
  423.         return result;
  424.     },
  425.     
  426.     // Set "default" application description field.
  427.     initDefaultApp: function() {
  428.       // Use description, if we can get one.
  429.       var desc = this.mLauncher.MIMEInfo.defaultDescription;
  430.       if (desc) {
  431.         var defaultApp = this.dialogElement("strings").getFormattedString("defaultApp", [desc]);
  432.         this.dialogElement("defaultHandler").label = defaultApp;
  433.       }
  434.     },
  435.  
  436.     // getPath:
  437.     getPath: function (aFile) {
  438.       if (this.mIsMac)
  439.         return aFile.leafName || aFile.path;
  440.       return aFile.path;
  441.     },
  442.  
  443.     // initAppAndSaveToDiskValues:
  444.     initAppAndSaveToDiskValues: function() {
  445.       var modeGroup = this.dialogElement("mode");
  446.  
  447.       // We don't let users open .exe files or random binary data directly 
  448.       // from the browser at the moment because of security concerns. 
  449.       var mimeType = this.mLauncher.MIMEInfo.MIMEType;
  450.       if (mimeType == "application/octet-stream" ||
  451.           mimeType == "application/x-msdownload") {
  452.         this.dialogElement("open").disabled = true;
  453.         var openHandler = this.dialogElement("openHandler");
  454.         openHandler.disabled = true;
  455.         openHandler.label = "";
  456.         modeGroup.selectedItem = this.dialogElement("save");
  457.         return;
  458.       }
  459.     
  460.       // Fill in helper app info, if there is any.
  461.       this.chosenApp = this.mLauncher.MIMEInfo.preferredApplicationHandler;
  462.       // Initialize "default application" field.
  463.       this.initDefaultApp();
  464.  
  465.       var otherHandler = this.dialogElement("otherHandler");
  466.               
  467.       // Fill application name textbox.
  468.       if (this.chosenApp && this.chosenApp.path) {
  469.         otherHandler.setAttribute("path", this.getPath(this.chosenApp));
  470.         otherHandler.label = this.chosenApp.leafName;
  471.         otherHandler.hidden = false;
  472.       }
  473.  
  474.       var useDefault = this.dialogElement("useSystemDefault");
  475.       var openHandler = this.dialogElement("openHandler");
  476.       openHandler.selectedIndex = 0;
  477.  
  478.       if (this.mLauncher.MIMEInfo.preferredAction == this.nsIMIMEInfo.useSystemDefault) {
  479.         // Open (using system default).
  480.         modeGroup.selectedItem = this.dialogElement("open");
  481.       } else if (this.mLauncher.MIMEInfo.preferredAction == this.nsIMIMEInfo.useHelperApp) {
  482.         // Open with given helper app.
  483.         modeGroup.selectedItem = this.dialogElement("open");
  484.         openHandler.selectedIndex = 1;
  485.       } else {
  486.         // Save to disk.
  487.         modeGroup.selectedItem = this.dialogElement("save");
  488.       }
  489.       
  490.       // If we don't have a "default app" then disable that choice.
  491.       if (!this.openWithDefaultOK()) {
  492.         var useDefault = this.dialogElement("defaultHandler");
  493.         var isSelected = useDefault.selected;
  494.         
  495.         // Disable that choice.
  496.         useDefault.hidden = true;
  497.         // If that's the default, then switch to "save to disk."
  498.         if (isSelected) {
  499.           openHandler.selectedIndex = 1;
  500.           modeGroup.selectedItem = this.dialogElement("save");
  501.         }
  502.       }
  503.       
  504.       // otherHandler is always disabled on Mac
  505.       if (this.mIsMac) 
  506.         otherHandler.hidden = true;
  507.  
  508.       otherHandler.nextSibling.hidden = otherHandler.nextSibling.nextSibling.hidden = this.isMac;
  509.       this.updateOKButton();
  510.     },
  511.  
  512.     // Returns the user-selected application
  513.     helperAppChoice: function() {
  514.       return this.chosenApp;
  515.     },
  516.     
  517.     get saveToDisk() {
  518.       return this.dialogElement("save").selected;
  519.     },
  520.     
  521.     get useOtherHandler() {
  522.       return this.dialogElement("open").selected && this.dialogElement("openHandler").selectedIndex == 1;
  523.     },
  524.     
  525.     get useSystemDefault() {
  526.       return this.dialogElement("open").selected && this.dialogElement("openHandler").selectedIndex == 0;
  527.     },
  528.     
  529.     toggleRememberChoice: function (aCheckbox) {
  530.         this.dialogElement("settingsChange").hidden = !aCheckbox.checked;
  531.         this.mDialog.sizeToContent();
  532.     },
  533.     
  534.     openHandlerCommand: function () {
  535.       if (this.dialogElement("openHandler").selectedItem.id == "choose")
  536.         this.chooseApp();
  537.     },
  538.  
  539.     updateOKButton: function() {
  540.       var ok = false;
  541.       if (this.dialogElement("save").selected) {
  542.         // This is always OK.
  543.         ok = true;
  544.       } 
  545.       else if (this.dialogElement("open").selected) {
  546.         switch (this.dialogElement("openHandler").selectedIndex) {
  547.         case 0:
  548.           // No app need be specified in this case.
  549.           ok = true;
  550.           break;
  551.         case 1:
  552.           // only enable the OK button if we have a default app to use or if 
  553.           // the user chose an app....
  554.           ok = this.chosenApp || /\S/.test(this.dialogElement("otherHandler").getAttribute("path")); 
  555.         break;
  556.         }
  557.       }
  558.  
  559.       // Enable Ok button if ok to press.
  560.       this.mDialog.document.documentElement.getButton("accept").disabled = !ok;
  561.     },
  562.     
  563.     // Returns true iff the user-specified helper app has been modified.
  564.     appChanged: function() {
  565.       return this.helperAppChoice() != this.mLauncher.MIMEInfo.preferredApplicationHandler;
  566.     },
  567.  
  568.     updateMIMEInfo: function() {
  569.       var needUpdate = false;
  570.       // If current selection differs from what's in the mime info object,
  571.       // then we need to update.
  572.       if (this.saveToDisk) {
  573.         needUpdate = this.mLauncher.MIMEInfo.preferredAction != this.nsIMIMEInfo.saveToDisk;
  574.         if (needUpdate)
  575.           this.mLauncher.MIMEInfo.preferredAction = this.nsIMIMEInfo.saveToDisk;
  576.       } 
  577.       else if (this.useSystemDefault) {
  578.         needUpdate = this.mLauncher.MIMEInfo.preferredAction != this.nsIMIMEInfo.useSystemDefault;
  579.         if (needUpdate)
  580.           this.mLauncher.MIMEInfo.preferredAction = this.nsIMIMEInfo.useSystemDefault;
  581.       } 
  582.       else {
  583.         // For "open with", we need to check both preferred action and whether the user chose
  584.         // a new app.
  585.         needUpdate = this.mLauncher.MIMEInfo.preferredAction != this.nsIMIMEInfo.useHelperApp || this.appChanged();
  586.         if (needUpdate) {
  587.           this.mLauncher.MIMEInfo.preferredAction = this.nsIMIMEInfo.useHelperApp;
  588.           // App may have changed - Update application and description
  589.           var app = this.helperAppChoice();
  590.           this.mLauncher.MIMEInfo.preferredApplicationHandler = app;
  591.           this.mLauncher.MIMEInfo.applicationDescription = "";
  592.         }
  593.       }
  594.       // We will also need to update if the "always ask" flag has changed.
  595.       needUpdate = needUpdate || this.mLauncher.MIMEInfo.alwaysAskBeforeHandling != (!this.dialogElement("rememberChoice").checked);
  596.  
  597.       // One last special case: If the input "always ask" flag was false, then we always
  598.       // update.  In that case we are displaying the helper app dialog for the first
  599.       // time for this mime type and we need to store the user's action in the mimeTypes.rdf
  600.       // data source (whether that action has changed or not; if it didn't change, then we need
  601.       // to store the "always ask" flag so the helper app dialog will or won't display
  602.       // next time, per the user's selection).
  603.       needUpdate = needUpdate || !this.mLauncher.MIMEInfo.alwaysAskBeforeHandling;
  604.  
  605.       // Make sure mime info has updated setting for the "always ask" flag.
  606.       this.mLauncher.MIMEInfo.alwaysAskBeforeHandling = !this.dialogElement("rememberChoice").checked;
  607.  
  608.       return needUpdate;        
  609.     },
  610.     
  611.     // See if the user changed things, and if so, update the
  612.     // mimeTypes.rdf entry for this mime type.
  613.     updateHelperAppPref: function() {
  614.       var ha = new this.mDialog.HelperApps();
  615.       ha.updateTypeInfo(this.mLauncher.MIMEInfo);
  616.     },
  617.     
  618.     // onOK:
  619.     onOK: function() {
  620.       // Verify typed app path, if necessary.
  621.       if (this.useOtherHandler) {
  622.         var helperApp = this.helperAppChoice();
  623.         if (!helperApp || !helperApp.exists()) {
  624.           // Show alert and try again.        
  625.           var bundle = this.dialogElement("strings");                    
  626.           var msg = bundle.getFormattedString("badApp", [this.dialogElement("otherHandler").path]);
  627.           var svc = Components.classes["@mozilla.org/embedcomp/prompt-service;1"].getService(Components.interfaces.nsIPromptService);
  628.           svc.alert(this.mDialog, bundle.getString("badApp.title"), msg);
  629.  
  630.           // Disable the OK button.
  631.           this.mDialog.document.documentElement.getButton("accept").disabled = true;
  632.           this.dialogElement("mode").focus();          
  633.  
  634.           // Clear chosen application.
  635.           this.chosenApp = null;
  636.  
  637.           // Leave dialog up.
  638.           return false;
  639.         }
  640.       }
  641.         
  642.       // Remove our web progress listener (a progress dialog will be
  643.       // taking over).
  644.       this.mLauncher.setWebProgressListener(null);
  645.       
  646.       // saveToDisk and launchWithApplication can return errors in 
  647.       // certain circumstances (e.g. The user clicks cancel in the
  648.       // "Save to Disk" dialog. In those cases, we don't want to
  649.       // update the helper application preferences in the RDF file.
  650.       try {
  651.         var needUpdate = this.updateMIMEInfo();
  652.         
  653.         if (this.dialogElement("save").selected) {
  654.           // If we're using a default download location, create a path
  655.           // for the file to be saved to to pass to |saveToDisk| - otherwise
  656.           // we must ask the user to pick a save name.
  657.  
  658.           var prefs = Components.classes["@mozilla.org/preferences-service;1"].getService(Components.interfaces.nsIPrefBranch);
  659.           var targetFile = null;
  660.           try {
  661.             targetFile = prefs.getComplexValue("browser.download.defaultFolder", 
  662.                                                Components.interfaces.nsILocalFile);
  663.             targetFile.append(this.dialogElement("location").value);
  664.           }
  665.           catch(e) {}
  666.           
  667.           this.mLauncher.saveToDisk(targetFile, false);
  668.         }
  669.         else
  670.           this.mLauncher.launchWithApplication(null, false);
  671.  
  672.         // Update user pref for this mime type (if necessary). We do not
  673.         // store anything in the mime type preferences for the ambiguous
  674.         // type application/octet-stream. We do NOT do this for 
  675.         // application/x-msdownload since we want users to be able to 
  676.         // autodownload these to disk. 
  677.         if (needUpdate && this.mLauncher.MIMEInfo.MIMEType != "application/octet-stream")
  678.           this.updateHelperAppPref();
  679.       } catch(e) { }
  680.  
  681.       // Unhook dialog from this object.
  682.       this.mDialog.dialog = null;
  683.  
  684.       // Close up dialog by returning true.
  685.       return true;
  686.     },
  687.  
  688.     // onCancel:
  689.     onCancel: function() {
  690.       // Remove our web progress listener.
  691.       this.mLauncher.setWebProgressListener(null);
  692.  
  693.       // Cancel app launcher.
  694.       try {
  695.         this.mLauncher.Cancel();
  696.       } catch(exception) {
  697.       }
  698.  
  699.       // Unhook dialog from this object.
  700.       this.mDialog.dialog = null;
  701.  
  702.       // Close up dialog by returning true.
  703.       return true;
  704.     },
  705.  
  706.     // dialogElement:  Convenience. 
  707.     dialogElement: function(id) {
  708.       return this.mDialog.document.getElementById(id);
  709.     },
  710.  
  711.     // chooseApp:  Open file picker and prompt user for application.
  712.     chooseApp: function() {
  713.       var nsIFilePicker = Components.interfaces.nsIFilePicker;
  714.       var fp = Components.classes["@mozilla.org/filepicker;1"].createInstance(nsIFilePicker);
  715.       fp.init(this.mDialog,
  716.               this.dialogElement("strings").getString("chooseAppFilePickerTitle"),
  717.               nsIFilePicker.modeOpen);
  718.  
  719.       fp.appendFilters(nsIFilePicker.filterApps);
  720.  
  721.       if (fp.show() == nsIFilePicker.returnOK && fp.file) {
  722.         // Remember the file they chose to run.
  723.         this.chosenApp = fp.file;
  724.         // Update dialog.
  725.         var otherHandler = this.dialogElement("otherHandler");
  726.         otherHandler.removeAttribute("hidden");
  727.         otherHandler.setAttribute("path", this.getPath(this.chosenApp));
  728.         otherHandler.label = this.chosenApp.leafName;
  729.         this.dialogElement("openHandler").selectedIndex = 1;
  730.         
  731.         this.dialogElement("mode").selectedItem = this.dialogElement("open");
  732.       }
  733.     },
  734.  
  735.     // Turn this on to get debugging messages.
  736.     debug: false,
  737.  
  738.     // Dump text (if debug is on).
  739.     dump: function( text ) {
  740.         if ( this.debug ) {
  741.             dump( text ); 
  742.         }
  743.     },
  744.  
  745.     // dumpInfo:
  746.     doDebug: function() {
  747.         const nsIProgressDialog = Components.interfaces.nsIProgressDialog;
  748.         // Open new progress dialog.
  749.         var progress = Components.classes[ "@mozilla.org/progressdialog;1" ]
  750.                          .createInstance( nsIProgressDialog );
  751.         // Show it.
  752.         progress.open( this.mDialog );
  753.     },
  754.  
  755.     // dumpObj:
  756.     dumpObj: function( spec ) {
  757.          var val = "<undefined>";
  758.          try {
  759.              val = eval( "this."+spec ).toString();
  760.          } catch( exception ) {
  761.          }
  762.          this.dump( spec + "=" + val + "\n" );
  763.     },
  764.  
  765.     // dumpObjectProperties
  766.     dumpObjectProperties: function( desc, obj ) {
  767.          for( prop in obj ) {
  768.              this.dump( desc + "." + prop + "=" );
  769.              var val = "<undefined>";
  770.              try {
  771.                  val = obj[ prop ];
  772.              } catch ( exception ) {
  773.              }
  774.              this.dump( val + "\n" );
  775.          }
  776.     }
  777. }
  778.  
  779. // This Component's module implementation.  All the code below is used to get this
  780. // component registered and accessible via XPCOM.
  781. var module = {
  782.     firstTime: true,
  783.  
  784.     // registerSelf: Register this component.
  785.     registerSelf: function (compMgr, fileSpec, location, type) {
  786.         if (this.firstTime) {
  787.             this.firstTime = false;
  788.             throw Components.results.NS_ERROR_FACTORY_REGISTER_AGAIN;
  789.         }
  790.         compMgr = compMgr.QueryInterface(Components.interfaces.nsIComponentRegistrar);
  791.  
  792.         compMgr.registerFactoryLocation( this.cid,
  793.                                          "Unknown Content Type Dialog",
  794.                                          this.contractId,
  795.                                          fileSpec,
  796.                                          location,
  797.                                          type );
  798.     },
  799.  
  800.     // getClassObject: Return this component's factory object.
  801.     getClassObject: function (compMgr, cid, iid) {
  802.         if (!cid.equals(this.cid)) {
  803.             throw Components.results.NS_ERROR_NO_INTERFACE;
  804.         }
  805.  
  806.         if (!iid.equals(Components.interfaces.nsIFactory)) {
  807.             throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
  808.         }
  809.  
  810.         return this.factory;
  811.     },
  812.  
  813.     /* CID for this class */
  814.     cid: Components.ID("{F68578EB-6EC2-4169-AE19-8C6243F0ABE1}"),
  815.  
  816.     /* Contract ID for this class */
  817.     contractId: "@mozilla.org/helperapplauncherdialog;1",
  818.  
  819.     /* factory object */
  820.     factory: {
  821.         // createInstance: Return a new nsProgressDialog object.
  822.         createInstance: function (outer, iid) {
  823.             if (outer != null)
  824.                 throw Components.results.NS_ERROR_NO_AGGREGATION;
  825.  
  826.             return (new nsUnknownContentTypeDialog()).QueryInterface(iid);
  827.         }
  828.     },
  829.  
  830.     // canUnload: n/a (returns true)
  831.     canUnload: function(compMgr) {
  832.         return true;
  833.     }
  834. };
  835.  
  836. // NSGetModule: Return the nsIModule object.
  837. function NSGetModule(compMgr, fileSpec) {
  838.     return module;
  839. }
  840.