home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2005 October / Gamestar_77_2005-10_dvd.iso / Programy / nsb-install-8-0.exe / chrome / browser.jar / content / browser / contentAreaUtils.js < prev    next >
Encoding:
JavaScript  |  2005-07-29  |  32.6 KB  |  1,006 lines
  1. /**
  2.  * Determine whether or not a given focused DOMWindow is in the content
  3.  * area.
  4.  **/
  5.  
  6. function openNewTabWith(href, linkNode, event, securityCheck, postData)
  7. {
  8.   if (securityCheck)
  9.     urlSecurityCheck(href, document); 
  10.  
  11.   var prefSvc = Components.classes["@mozilla.org/preferences-service;1"]
  12.                           .getService(Components.interfaces.nsIPrefService);
  13.   prefSvc = prefSvc.getBranch(null);
  14.  
  15.   // should we open it in a new tab?
  16.   var loadInBackground = true;
  17.   try {
  18.     loadInBackground = prefSvc.getBoolPref("browser.tabs.loadInBackground");
  19.   }
  20.   catch(ex) {
  21.   }
  22.  
  23.   if (event && event.shiftKey)
  24.     loadInBackground = !loadInBackground;
  25.  
  26.   // As in openNewWindowWith(), we want to pass the charset of the
  27.   // current document over to a new tab. 
  28.   var wintype = document.firstChild.getAttribute('windowtype');
  29.   var originCharset;
  30.   if (wintype == "navigator:browser") {
  31.     originCharset = window._content.document.characterSet;
  32.   }
  33.  
  34.   // open link in new tab
  35.   var browser = top.document.getElementById("content");  
  36.   var theTab = browser.addTabAt(href, undefined, getReferrer(document), originCharset, postData);  // MERC (DP): changed to addTabAt
  37.   if (!loadInBackground)
  38.     browser.selectedTab = theTab;
  39.   
  40.   if (linkNode)
  41.     markLinkVisited(href, linkNode);
  42. }
  43.  
  44. // Stevo
  45. function askUserAboutJar(href)
  46. {
  47.     var xpinstallObj = {};
  48.     var args = new Object( );
  49.     args.handled = 2;
  50.     args.jarUrl = href;
  51.     
  52.   var uri = Components.classes["@mozilla.org/network/standard-url;1"]
  53.                       .createInstance(Components.interfaces.nsIURI);
  54.   uri.spec = href;
  55.   var url = uri.QueryInterface(Components.interfaces.nsIURL);
  56.   if (url.fileExtension == "xpi") {
  57.     xpinstallObj[url.fileName] = uri.spec;
  58.       InstallTrigger.install(xpinstallObj);
  59.       args.handled = 0;
  60.   }
  61.   else if (url.fileExtension == "jar") {
  62.          window.openDialog("chrome://browser/content/askUserAboutJar.xul",
  63.             "Descision", "modal,centerscreen,chrome,resizable=no",args);
  64. //    InstallTrigger.installChrome(InstallTrigger.SKIN, href, url.fileName);
  65. //        args.handled = 0;
  66.   }
  67.  
  68.     return args.handled;
  69. }
  70.  
  71. //JA
  72. function openPopupInTab(href,bUserInitiated)
  73. {
  74.   // As in openNewWindowWith(), we want to pass the charset of the
  75.   // current document over to a new tab. 
  76.   var wintype = document.firstChild.getAttribute('windowtype');
  77.   var originCharset;
  78.   if (wintype == "navigator:browser") 
  79.   {
  80.     //sliu, it crash when close tab cause a unload event, 
  81.     //    , the event is open a new window and pref set to open popup in tab
  82.     //originCharset = window._content.document.characterSet;
  83.     originCharset = gCurrentDocCharset;    
  84.   }
  85.  
  86.   // open link in new tab
  87.   var browser = top.document.getElementById("content");
  88.   
  89.   // MERC (DP): if popup is user initiated, then position tab according to pref browser.tabs.newTabLocation
  90.   // Otherwise, if not user initiated position tab at far right
  91.   var theTab;
  92.   if(bUserInitiated) {
  93.     theTab = browser.addTabAt(href, undefined, getReferrer(document), originCharset, null);
  94.   } else {
  95.     // theTab = browser.addTab(href, getReferrer(document), originCharset, null);
  96.  
  97.     // MERC - JCH: Add the non-user-initiated-popup to far right tab 
  98.     theTab = browser.getNonUserInitPopupTab(href, getReferrer(document), originCharset);
  99.   }
  100.   
  101.   var b = browser.getBrowserForTab(theTab);
  102.     
  103.   if(b)
  104.   {
  105.       // whether or not to set focus to the new popup tab
  106.       var bgLoad = browser.mPrefs.getBoolPref("browser.tabs.loadInBackground");
  107.       if(bUserInitiated && !bgLoad)
  108.           browser.selectedTab = theTab;
  109.       return b.contentWindow;
  110.   }
  111.   else
  112.      return null;//error
  113.  
  114. }
  115.  
  116. function openNewWindowWith(href, linkNode, securityCheck, postData) 
  117. {
  118.   if (securityCheck)
  119.     urlSecurityCheck(href, document);
  120.  
  121.   // if and only if the current window is a browser window and it has a document with a character
  122.   // set, then extract the current charset menu setting from the current document and use it to
  123.   // initialize the new browser window...
  124.   var charsetArg = null;
  125.   var wintype = document.firstChild.getAttribute('windowtype');
  126.   if (wintype == "navigator:browser")
  127.     charsetArg = "charset=" + window._content.document.characterSet;
  128.  
  129.   var referrer = getReferrer(document);
  130.   window.openDialog(getBrowserURL(), "_blank", "chrome,all,dialog=no", href, charsetArg, referrer, postData);
  131.   
  132.   if (linkNode)
  133.     markLinkVisited(href, linkNode);
  134. }
  135.  
  136. function markLinkVisited(href, linkNode)
  137. {
  138.   var globalHistory = Components.classes["@mozilla.org/browser/global-history;2"]
  139.                                 .getService(Components.interfaces.nsIGlobalHistory2);
  140.  
  141.   var uri = makeURL(href);
  142.   if (!globalHistory.isVisited(uri)) {
  143.     globalHistory.addURI(uri, false, true);
  144.     var oldHref = linkNode.getAttribute("href");
  145.     if (typeof oldHref == "string") {
  146.       // Use setAttribute instead of direct assignment.
  147.       // (bug 217195, bug 187195)
  148.       linkNode.setAttribute("href", "");
  149.       linkNode.setAttribute("href", oldHref);
  150.     }
  151.     else {
  152.       // Converting to string implicitly would be a 
  153.       // minor security hole (similar to bug 202994).
  154.     }
  155.   }
  156. }
  157.  
  158. function urlSecurityCheck(url, doc) 
  159. {
  160.   // URL Loading Security Check
  161.   var focusedWindow = doc.commandDispatcher.focusedWindow;
  162.   var sourceURL = getContentFrameURI(focusedWindow);
  163.   var sourceURI = Components.classes["@mozilla.org/network/standard-url;1"]
  164.                             .createInstance(Components.interfaces.nsIURI);
  165.   sourceURI.spec = sourceURL;
  166.   var destURI = Components.classes["@mozilla.org/network/standard-url;1"]
  167.                           .createInstance(Components.interfaces.nsIURI);
  168.   destURI.spec = url;
  169.   const nsIScriptSecurityManager = Components.interfaces.nsIScriptSecurityManager;
  170.   var secMan = Components.classes["@mozilla.org/scriptsecuritymanager;1"]
  171.                          .getService(nsIScriptSecurityManager);
  172.   try {
  173.     secMan.checkLoadURI(sourceURI, destURI, nsIScriptSecurityManager.STANDARD);
  174.   } catch (e) {
  175.     throw "Load of " + url + " denied.";
  176.   }
  177. }
  178.  
  179. function webPanelSecurityCheck(aSourceURL, aDestURL) {
  180.   var sourceURI = makeURL(aSourceURL);
  181.   var destURI = makeURL(aDestURL);
  182.  
  183.   const nsIScriptSecurityManager = Components.interfaces.nsIScriptSecurityManager;
  184.   var secMan = Components.classes["@mozilla.org/scriptsecuritymanager;1"]
  185.                          .getService(nsIScriptSecurityManager);
  186.   try {
  187.     secMan.checkLoadURI(sourceURI, destURI, nsIScriptSecurityManager.STANDARD);
  188.   } catch (e) {
  189.     return false;
  190.   }
  191.   return true;
  192. }
  193.  
  194. function isContentFrame(aFocusedWindow)
  195. {
  196.   if (!aFocusedWindow)
  197.     return false;
  198.  
  199.   var focusedTop = Components.lookupMethod(aFocusedWindow, 'top')
  200.                              .call(aFocusedWindow);
  201.  
  202.   return (focusedTop == window.content);
  203. }
  204.  
  205. function getContentFrameURI(aFocusedWindow)
  206. {
  207.   var contentFrame = isContentFrame(aFocusedWindow) ? aFocusedWindow : window.content;
  208.   if (contentFrame)
  209.     return Components.lookupMethod(contentFrame, 'location').call(contentFrame).href;
  210.   else
  211.     return null;
  212. }
  213.  
  214. function getReferrer(doc)
  215. {
  216.   var focusedWindow = doc.commandDispatcher.focusedWindow;
  217.   var sourceURL = getContentFrameURI(focusedWindow);
  218.  
  219.   if (sourceURL) {
  220.     try {
  221.       return makeURL(sourceURL);
  222.     }
  223.     catch (e) { }
  224.   }
  225.   return null;
  226. }
  227.  
  228. const kSaveAsType_Complete = 0;   // Save document with attached objects
  229. const kSaveAsType_URL = 1;        // Save document or URL by itself
  230. const kSaveAsType_Text = 2;       // Save document, converting to plain text. 
  231.  
  232. // Clientelle: (Make sure you don't break any of these)
  233. //  - File    ->  Save Page/Frame As...
  234. //  - Context ->  Save Page/Frame As...
  235. //  - Context ->  Save Link As...
  236. //  - Context ->  Save Image As...
  237. //  - Alt-Click links in web pages
  238. //  - Alt-Click links in the UI
  239. //
  240. // Try saving each of these types:
  241. // - A complete webpage using File->Save Page As, and Context->Save Page As
  242. // - A webpage as HTML only using the above methods
  243. // - A webpage as Text only using the above methods
  244. // - An image with an extension (e.g. .jpg) in its file name, using
  245. //   Context->Save Image As...
  246. // - An image without an extension (e.g. a banner ad on cnn.com) using
  247. //   the above method. 
  248. // - A linked document using Save Link As...
  249. // - A linked document using Alt-click Save Link As...
  250. //
  251. function saveURL(aURL, aFileName, aFilePickerTitleKey, aShouldBypassCache, aSkipPrompt, aReferrer)
  252. {
  253.   saveInternal(aURL, null, aFileName, aFilePickerTitleKey, aShouldBypassCache, aSkipPrompt, aReferrer);
  254. }
  255.  
  256. function saveDocument(aDocument, aSkipPrompt)
  257. {
  258.   // In both cases here, we want to use cached data because the 
  259.   // document is currently visible. 
  260.   //Mercurial start
  261.    var hpDoc;
  262.    try 
  263.    {
  264.        hpDoc=gBrowser.contentDocument.QueryInterface(Components.interfaces.nsIHTMLPluginDocument);
  265.    }
  266.    catch(ex){}
  267.      
  268.    try
  269.    {
  270.       if(hpDoc)
  271.       {
  272.          hpDoc.doOLECmd(3);    
  273.       }
  274.       else
  275.       {          
  276.          if (aDocument) 
  277.             saveInternal(aDocument.location.href, aDocument, false, aSkipPrompt);
  278.          else
  279.             saveInternal(_content.location.href, null, false, aSkipPrompt);
  280.       }
  281.    }
  282.    catch(e)
  283.    {}
  284. }
  285.  
  286. function saveInternal(aURL, aDocument, 
  287.                       aFileName, aFilePickerTitleKey,
  288.                       aShouldBypassCache, aSkipPrompt,
  289.                       aReferrer)
  290. {
  291.   if (aSkipPrompt == undefined)
  292.     aSkipPrompt = false;
  293.  
  294.   var data = {
  295.     url: aURL,
  296.     fileName: aFileName,
  297.     filePickerTitle: aFilePickerTitleKey,
  298.     document: aDocument,
  299.     bypassCache: aShouldBypassCache,
  300.     window: window,
  301.     referrer: aReferrer
  302.   };
  303.   var sniffer = new nsHeaderSniffer(aURL, foundHeaderInfo, data, aSkipPrompt);
  304. }
  305.  
  306. function foundHeaderInfo(aSniffer, aData, aSkipPrompt)
  307. {
  308.   var contentType = aSniffer.contentType;
  309.   var contentEncodingType = aSniffer.contentEncodingType;
  310.  
  311.   var shouldDecode = false;
  312.   // Are we allowed to decode?
  313.   try {
  314.     const helperAppService =
  315.       Components.classes["@mozilla.org/uriloader/external-helper-app-service;1"].
  316.         getService(Components.interfaces.nsIExternalHelperAppService);
  317.     var url = aSniffer.uri.QueryInterface(Components.interfaces.nsIURL);
  318.     var urlExt = url.fileExtension;
  319.     if (helperAppService.applyDecodingForExtension(urlExt,
  320.                                                    contentEncodingType)) {
  321.       shouldDecode = true;
  322.     }
  323.   }
  324.   catch (e) {
  325.   }
  326.  
  327.   var isDocument = aData.document != null && isDocumentType(contentType);
  328.   if (!isDocument && !shouldDecode && contentEncodingType) {
  329.     // The data is encoded, we are not going to decode it, and this is not a
  330.     // document save so we won't be doing a "save as, complete" (which would
  331.     // break if we reset the type here).  So just set our content type to
  332.     // correspond to the outermost encoding so we get extensions and the like
  333.     // right.
  334.     contentType = contentEncodingType;
  335.   }
  336.   
  337.   var file = null;
  338.   var saveAsType = kSaveAsType_URL;
  339.   try {
  340.     file = aData.fileName.QueryInterface(Components.interfaces.nsILocalFile);
  341.   }
  342.   catch (e) {
  343.     var saveAsTypeResult = { rv: 0 };
  344.     file = getTargetFile(aData, aSniffer, contentType, isDocument, aSkipPrompt, saveAsTypeResult);
  345.     if (!file)
  346.       return;
  347.     saveAsType = saveAsTypeResult.rv;
  348.   }
  349.  
  350.   // If we're saving a document, and are saving either in complete mode or 
  351.   // as converted text, pass the document to the web browser persist component.
  352.   // If we're just saving the HTML (second option in the list), send only the URI.
  353.   var source = (isDocument && saveAsType != kSaveAsType_URL) ? aData.document : aSniffer.uri;
  354.   var persistArgs = {
  355.     source      : source,
  356.     contentType : (isDocument && saveAsType == kSaveAsType_Text) ? "text/plain" : contentType,
  357.     target      : makeFileURL(file),
  358.     postData    : aData.document ? getPostData() : null,
  359.     bypassCache : aData.bypassCache
  360.   };
  361.   
  362.   var persist = makeWebBrowserPersist();
  363.  
  364.   // Calculate persist flags.
  365.   const nsIWBP = Components.interfaces.nsIWebBrowserPersist;
  366.   const flags = nsIWBP.PERSIST_FLAGS_NO_CONVERSION | nsIWBP.PERSIST_FLAGS_REPLACE_EXISTING_FILES;
  367.   if (aData.bypassCache)
  368.     persist.persistFlags = flags | nsIWBP.PERSIST_FLAGS_BYPASS_CACHE;
  369.   else 
  370.     persist.persistFlags = flags | nsIWBP.PERSIST_FLAGS_FROM_CACHE;
  371.  
  372.   if (shouldDecode)
  373.     persist.persistFlags &= ~nsIWBP.PERSIST_FLAGS_NO_CONVERSION;
  374.     
  375.   // Create download and initiate it (below)
  376.   var dl = Components.classes["@mozilla.org/download;1"].createInstance(Components.interfaces.nsIDownload);
  377.  
  378.   if (isDocument && saveAsType != kSaveAsType_URL) {
  379.     // Saving a Document, not a URI:
  380.     var filesFolder = null;
  381.     if (persistArgs.contentType != "text/plain") {
  382.       // Create the local directory into which to save associated files. 
  383.       filesFolder = file.clone();
  384.       
  385.       var nameWithoutExtension = filesFolder.leafName;
  386.       nameWithoutExtension = nameWithoutExtension.substring(0, nameWithoutExtension.lastIndexOf("."));
  387.       var filesFolderLeafName = getStringBundle().formatStringFromName("filesFolder",
  388.                                                                        [nameWithoutExtension],
  389.                                                                        1);
  390.  
  391.       filesFolder.leafName = filesFolderLeafName;
  392.     }
  393.       
  394.     var encodingFlags = 0;
  395.     if (persistArgs.contentType == "text/plain") {
  396.       encodingFlags |= nsIWBP.ENCODE_FLAGS_FORMATTED;
  397.       encodingFlags |= nsIWBP.ENCODE_FLAGS_ABSOLUTE_LINKS;
  398.       encodingFlags |= nsIWBP.ENCODE_FLAGS_NOFRAMES_CONTENT;        
  399.     }
  400.     else {
  401.       encodingFlags |= nsIWBP.ENCODE_FLAGS_ENCODE_BASIC_ENTITIES;
  402.     }
  403.     
  404.     const kWrapColumn = 80;
  405.     dl.init(aSniffer.uri, persistArgs.target, null, null, null, persist);
  406.     persist.saveDocument(persistArgs.source, persistArgs.target, filesFolder, 
  407.                          persistArgs.contentType, encodingFlags, kWrapColumn);
  408.   } else {
  409.     dl.init(source, persistArgs.target, null, null, null, persist);
  410.     var referrer = aData.referrer || getReferrer(document)
  411.     persist.saveURI(source, null, referrer, persistArgs.postData, null, persistArgs.target);
  412.   }
  413. }
  414.  
  415. function getTargetFile(aData, aSniffer, aContentType, aIsDocument, aSkipPrompt, aSaveAsTypeResult)
  416. {
  417.   aSaveAsTypeResult.rv = kSaveAsType_Complete;
  418.   
  419.   // Determine what the 'default' string to display in the File Picker dialog 
  420.   // should be. 
  421.   var defaultFileName = getDefaultFileName(aData.fileName, 
  422.                                            aSniffer.suggestedFileName, 
  423.                                            aSniffer.uri,
  424.                                            aData.document);
  425.  
  426.   var defaultExtension = getDefaultExtension(defaultFileName, aSniffer.uri, aContentType);
  427.   var defaultString = getNormalizedLeafName(defaultFileName, defaultExtension);
  428.  
  429.   const prefSvcContractID = "@mozilla.org/preferences-service;1";
  430.   const prefSvcIID = Components.interfaces.nsIPrefService;                              
  431.   var prefs = Components.classes[prefSvcContractID].getService(prefSvcIID).getBranch("browser.download.");
  432.  
  433.   const nsILocalFile = Components.interfaces.nsILocalFile;
  434.  
  435.   // ben 07/31/2003:
  436.   // |browser.download.defaultFolder| holds the default download folder for 
  437.   // all files when the user has elected to have all files automatically
  438.   // download to a folder. The values of |defaultFolder| can be either their
  439.   // desktop, their downloads folder (My Documents\My Downloads) or some other
  440.   // location of their choosing (which is mapped to |browser.download.dir|
  441.   // This pref is _unset_ when the user has elected to be asked about where
  442.   // to place every download - this will force the prompt to ask the user
  443.   // where to put saved files. 
  444.   var dir = null;
  445.   try {
  446.     dir = prefs.getComplexValue("defaultFolder", nsILocalFile);
  447.   }
  448.   catch (e) { }
  449.   
  450.   var file;
  451.   if (!aSkipPrompt || !dir) {
  452.     // If we're asking the user where to save the file, root the Save As...
  453.     // dialog on they place they last picked. 
  454.     try {
  455.       dir = prefs.getComplexValue("lastDir", nsILocalFile);
  456.     }
  457.     catch (e) {
  458.       // No default download location. Default to desktop. 
  459.       var fileLocator = Components.classes["@mozilla.org/file/directory_service;1"].getService(Components.interfaces.nsIProperties);
  460.  
  461.       function getDesktopKey()
  462.       {      
  463.         return "DeskP";
  464.         return "Home";
  465.       }
  466.       
  467.       dir = fileLocator.get(getDesktopKey(), Components.interfaces.nsILocalFile);
  468.     }
  469.  
  470.  
  471.     var fp = makeFilePicker();
  472.     var titleKey = aData.filePickerTitle || "SaveLinkTitle";
  473.     var bundle = getStringBundle();
  474.     fp.init(window, bundle.GetStringFromName(titleKey), 
  475.             Components.interfaces.nsIFilePicker.modeSave);
  476.     
  477.     appendFiltersForContentType(fp, aContentType, defaultExtension,
  478.                                 aIsDocument ? MODE_COMPLETE : MODE_FILEONLY);  
  479.   
  480.     if (dir)
  481.       fp.displayDirectory = dir;
  482.     
  483.     if (aIsDocument) {
  484.       try {
  485.         fp.filterIndex = prefs.getIntPref("save_converter_index");
  486.       }
  487.       catch (e) {
  488.       }
  489.     }
  490.   
  491.     fp.defaultExtension = defaultExtension;
  492.     fp.defaultString = defaultString;
  493.   
  494.     if (fp.show() == Components.interfaces.nsIFilePicker.returnCancel || !fp.file)
  495.       return null;
  496.   
  497.     var useDownloadDir = false;
  498.     try {
  499.       useDownloadDir = prefs.getBoolPref("useDownloadDir");
  500.     }
  501.     catch(ex) {
  502.     }
  503.     
  504.     var directory = fp.file.parent.QueryInterface(nsILocalFile);
  505.     prefs.setComplexValue("lastDir", nsILocalFile, directory);
  506.  
  507.     fp.file.leafName = validateFileName(fp.file.leafName);
  508.     aSaveAsTypeResult.rv = fp.filterIndex;
  509.     file = fp.file;
  510.  
  511.     if (aIsDocument) 
  512.       prefs.setIntPref("save_converter_index", aSaveAsTypeResult.rv);
  513.   }
  514.   else {
  515.     // ben 07/31/2003: 
  516.     // We don't nullcheck dir here because dir should never be null if we get here
  517.     // unless something is badly wrong, and if it is, I want to know about it in
  518.     // bugs. 
  519.     dir.append(defaultString);
  520.     file = dir;
  521.     
  522.     // Since we're automatically downloading, we don't get the file picker's 
  523.     // logic to check for existing files, so we need to do that here.
  524.     //
  525.     // Note - this code is identical to that in 
  526.     //   browser/components/downloads/content/nsHelperAppDlg.js. 
  527.     // If you are updating this code, update that code too! We can't share code
  528.     // here since that code is called in a js component. 
  529.     while (file.exists()) {
  530.       var parts = /.+-(\d+)(\..*)?$/.exec(file.leafName);
  531.       if (parts) {
  532.         file.leafName = file.leafName.replace(/((\d+)\.)|((\d+)$)/,
  533.                                               function (str, dot, dotNum, noDot, noDotNum, pos, s) {
  534.                                                 return (parseInt(str) + 1) + (dot ? "." : "");
  535.                                               });
  536.       }
  537.       else {
  538.         file.leafName = file.leafName.replace(/\.|$/, "-1$&");
  539.       }
  540.     }
  541.     
  542.   }
  543.  
  544.   return file;    
  545. }
  546.  
  547. function nsHeaderSniffer(aURL, aCallback, aData, aSkipPrompt)
  548. {
  549.   this.mCallback = aCallback;
  550.   this.mData = aData;
  551.   this.mSkipPrompt = aSkipPrompt;
  552.   
  553.   this.uri = makeURL(aURL);
  554.   
  555.   this.linkChecker = Components.classes["@mozilla.org/network/urichecker;1"]
  556.     .createInstance(Components.interfaces.nsIURIChecker);
  557.   this.linkChecker.init(this.uri);
  558.  
  559.   var flags;
  560.   if (aData.bypassCache) {
  561.     flags = Components.interfaces.nsIRequest.LOAD_BYPASS_CACHE;
  562.   } else {
  563.     flags = Components.interfaces.nsIRequest.LOAD_FROM_CACHE;
  564.   }
  565.   this.linkChecker.loadFlags = flags;
  566.  
  567.   this.linkChecker.asyncCheck(this, null);
  568. }
  569.  
  570. nsHeaderSniffer.prototype = {
  571.  
  572.   // ---------- nsISupports methods ----------
  573.   QueryInterface: function (iid) {
  574.     if (!iid.equals(Components.interfaces.nsIRequestObserver) &&
  575.         !iid.equals(Components.interfaces.nsISupports) &&
  576.         !iid.equals(Components.interfaces.nsIInterfaceRequestor)) {
  577.       throw Components.results.NS_ERROR_NO_INTERFACE;
  578.     }
  579.     return this;
  580.   },
  581.  
  582.   // ---------- nsIInterfaceRequestor methods ----------
  583.   getInterface : function(iid) {
  584.     if (iid.equals(Components.interfaces.nsIAuthPrompt)) {
  585.       // use the window watcher service to get a nsIAuthPrompt impl
  586.       var ww = Components.classes["@mozilla.org/embedcomp/window-watcher;1"]
  587.                          .getService(Components.interfaces.nsIWindowWatcher);
  588.       return ww.getNewAuthPrompter(window);
  589.     }
  590.     Components.returnCode = Components.results.NS_ERROR_NO_INTERFACE;
  591.     return null;
  592.   },
  593.  
  594.   // ---------- nsIRequestObserver methods ----------
  595.   onStartRequest: function (aRequest, aContext) { },
  596.   
  597.   onStopRequest: function (aRequest, aContext, aStatus) {
  598.     try {
  599.       if (aStatus == 0) { // NS_BINDING_SUCCEEDED, so there's something there
  600.         var linkChecker = aRequest.QueryInterface(Components.interfaces.nsIURIChecker);
  601.         var channel = linkChecker.baseChannel;
  602.         this.contentType = channel.contentType;
  603.         try {
  604.           var httpChannel = channel.QueryInterface(Components.interfaces.nsIHttpChannel);
  605.           var encodedChannel = channel.QueryInterface(Components.interfaces.nsIEncodedChannel);
  606.           this.contentEncodingType = null;
  607.           // There may be content-encodings on the channel.  Multiple content
  608.           // encodings are allowed, eg "Content-Encoding: gzip, uuencode".  This
  609.           // header would mean that the content was first gzipped and then
  610.           // uuencoded.  The encoding enumerator returns MIME types
  611.           // corresponding to each encoding starting from the end, so the first
  612.           // thing it returns corresponds to the outermost encoding.
  613.           var encodingEnumerator = encodedChannel.contentEncodings;
  614.           if (encodingEnumerator && encodingEnumerator.hasMore()) {
  615.             try {
  616.               this.contentEncodingType = encodingEnumerator.getNext();
  617.             } catch (e) {
  618.             }
  619.           }
  620.           this.mContentDisposition = httpChannel.getResponseHeader("content-disposition");
  621.         }
  622.         catch (e) {
  623.         }
  624.         if (!this.contentType || this.contentType == "application/x-unknown-content-type") {
  625.           // We didn't get a type from the server.  Fall back on other type detection mechanisms
  626.           throw "Unknown Type";
  627.         }
  628.       }
  629.       else {
  630.         dump("Error saving link aStatus = 0x" + aStatus.toString(16) + "\n");
  631.         var bundle = getStringBundle();
  632.         var errorTitle = bundle.GetStringFromName("saveLinkErrorTitle");
  633.         var errorMsg = bundle.GetStringFromName("saveLinkErrorMsg");
  634.         const promptService = Components.classes["@mozilla.org/embedcomp/prompt-service;1"].getService(Components.interfaces.nsIPromptService);
  635.         promptService.alert(this.mData.window, errorTitle, errorMsg);
  636.         return;
  637.       }
  638.     }
  639.     catch (e) {
  640.       if (this.mData.document) {
  641.         this.contentType = this.mData.document.contentType;
  642.       } else {
  643.         var type = getMIMETypeForURI(this.uri);
  644.         if (type)
  645.           this.contentType = type;
  646.       }
  647.     }
  648.     this.mCallback(this, this.mData, this.mSkipPrompt);
  649.   },
  650.  
  651.   // ------------------------------------------------
  652.  
  653.   get promptService()
  654.   {
  655.     var promptSvc;
  656.     try {
  657.       promptSvc = Components.classes["@mozilla.org/embedcomp/prompt-service;1"].getService();
  658.       promptSvc = promptSvc.QueryInterface(Components.interfaces.nsIPromptService);
  659.     }
  660.     catch (e) {}
  661.     return promptSvc;
  662.   },
  663.  
  664.   get suggestedFileName()
  665.   {
  666.     var fileName = "";
  667.  
  668.     if (this.mContentDisposition) {
  669.       const mhpContractID = "@mozilla.org/network/mime-hdrparam;1"
  670.       const mhpIID = Components.interfaces.nsIMIMEHeaderParam;
  671.       const mhp = Components.classes[mhpContractID].getService(mhpIID);
  672.       var dummy = { value: null }; // To make JS engine happy.
  673.       var charset = getCharsetforSave(null);
  674.  
  675.       try {
  676.         fileName = mhp.getParameter(this.mContentDisposition, "filename", charset, true, dummy);
  677.       } 
  678.       catch (e) {
  679.         try {
  680.           fileName = mhp.getParameter(this.mContentDisposition, "name", charset, true, dummy);
  681.         }
  682.         catch (e) {
  683.         }
  684.       }
  685.     }
  686.     fileName = fileName.replace(/^"|"$/g, "");
  687.     return fileName;
  688.   }
  689. };
  690.  
  691. const MODE_COMPLETE = 0;
  692. const MODE_FILEONLY = 1;
  693.  
  694. function appendFiltersForContentType(aFilePicker, aContentType, aFileExtension, aSaveMode)
  695. {
  696.   var bundle = getStringBundle();
  697.     
  698.   switch (aContentType) {
  699.   case "text/html":
  700.     if (aSaveMode == MODE_COMPLETE)
  701.       aFilePicker.appendFilter(bundle.GetStringFromName("WebPageCompleteFilter"), "*.htm; *.html");
  702.     aFilePicker.appendFilter(bundle.GetStringFromName("WebPageHTMLOnlyFilter"), "*.htm; *.html");
  703.     if (aSaveMode == MODE_COMPLETE)
  704.       aFilePicker.appendFilters(Components.interfaces.nsIFilePicker.filterText);
  705.     break;
  706.   default:
  707.     var mimeInfo = getMIMEInfoForType(aContentType, aFileExtension);
  708.     if (mimeInfo) {
  709.  
  710.       var extEnumerator = mimeInfo.getFileExtensions();
  711.  
  712.       var extString = "";
  713.       var defaultDesc = "";
  714.       var plural = false;
  715.       while (extEnumerator.hasMore()) {
  716.         if (defaultDesc) {
  717.           defaultDesc += ", ";
  718.           plural = true;
  719.         }
  720.         var extension = extEnumerator.getNext();
  721.         if (extString)
  722.           extString += "; ";    // If adding more than one extension,
  723.                                 // separate by semi-colon
  724.         extString += "*." + extension;
  725.         defaultDesc += extension.toUpperCase();
  726.       }
  727.  
  728.       if (extString) {
  729.         var desc = mimeInfo.Description;
  730.         if (!desc) { 
  731.           var key = plural ? "unknownDescriptionFilesPluralFilter" : 
  732.                              "unknownDescriptionFilesFilter";
  733.           desc = getStringBundle().formatStringFromName(key, [defaultDesc], 1);
  734.         }
  735.         aFilePicker.appendFilter(desc, extString);
  736.       } else {
  737.         aFilePicker.appendFilters(Components.interfaces.nsIFilePicker.filterAll);
  738.       }        
  739.     }
  740.     else
  741.       aFilePicker.appendFilters(Components.interfaces.nsIFilePicker.filterAll);
  742.     break;
  743.   }
  744. } 
  745.  
  746. function getPostData()
  747. {
  748.   try {
  749.     var sessionHistory = getWebNavigation().sessionHistory;
  750.     entry = sessionHistory.getEntryAtIndex(sessionHistory.index, false);
  751.     entry = entry.QueryInterface(Components.interfaces.nsISHEntry);
  752.     return entry.postData;
  753.   }
  754.   catch (e) {
  755.   }
  756.   return null;
  757. }
  758.  
  759. //XXXPch: that that be removed.
  760. function getStringBundle()
  761. {
  762.   const bundleURL = "chrome://browser/locale/contentAreaCommands.properties";
  763.   
  764.   const sbsContractID = "@mozilla.org/intl/stringbundle;1";
  765.   const sbsIID = Components.interfaces.nsIStringBundleService;
  766.   const sbs = Components.classes[sbsContractID].getService(sbsIID);
  767.   
  768.   const lsContractID = "@mozilla.org/intl/nslocaleservice;1";
  769.   const lsIID = Components.interfaces.nsILocaleService;
  770.   const ls = Components.classes[lsContractID].getService(lsIID);
  771.   var appLocale = ls.getApplicationLocale();
  772.   return sbs.createBundle(bundleURL, appLocale);    
  773. }
  774.  
  775. function makeWebBrowserPersist()
  776. {
  777.   const persistContractID = "@mozilla.org/embedding/browser/nsWebBrowserPersist;1";
  778.   const persistIID = Components.interfaces.nsIWebBrowserPersist;
  779.   return Components.classes[persistContractID].createInstance(persistIID);
  780. }
  781.  
  782. function makeURL(aURL)
  783. {
  784.   var ioService = Components.classes["@mozilla.org/network/io-service;1"]
  785.                             .getService(Components.interfaces.nsIIOService);
  786.   return ioService.newURI(aURL, null, null);
  787. }
  788.  
  789. function makeFileURL(aFile)
  790. {
  791.   var ioService = Components.classes["@mozilla.org/network/io-service;1"]
  792.                 .getService(Components.interfaces.nsIIOService);
  793.   return ioService.newFileURI(aFile);
  794. }
  795.  
  796. function makeFilePicker()
  797. {
  798.   const fpContractID = "@mozilla.org/filepicker;1";
  799.   const fpIID = Components.interfaces.nsIFilePicker;
  800.   return Components.classes[fpContractID].createInstance(fpIID);
  801. }
  802.  
  803. function getMIMEService()
  804. {
  805.   const mimeSvcContractID = "@mozilla.org/mime;1";
  806.   const mimeSvcIID = Components.interfaces.nsIMIMEService;
  807.   const mimeSvc = Components.classes[mimeSvcContractID].getService(mimeSvcIID);
  808.   return mimeSvc;
  809. }
  810.  
  811. function getMIMETypeForURI(aURI)
  812. {
  813.   try {  
  814.     return getMIMEService().getTypeFromURI(aURI);
  815.   }
  816.   catch (e) {
  817.   }
  818.   return null;
  819. }
  820.  
  821. function getMIMEInfoForType(aMIMEType, aExtension)
  822. {
  823.   try {  
  824.     return getMIMEService().getFromTypeAndExtension(aMIMEType, aExtension);
  825.   }
  826.   catch (e) {
  827.   }
  828.   return null;
  829. }
  830.  
  831. function getDefaultFileName(aDefaultFileName, aNameFromHeaders, aDocumentURI, aDocument)
  832. {
  833.   if (aNameFromHeaders)
  834.     // 1) Use the name suggested by the HTTP headers
  835.     return validateFileName(aNameFromHeaders);
  836.  
  837.   try {
  838.     var url = aDocumentURI.QueryInterface(Components.interfaces.nsIURL);
  839.     if (url.fileName != "") {
  840.       // 2) Use the actual file name, if present
  841.       return validateFileName(decodeURIComponent(url.fileName));
  842.     }
  843.   } catch (e) {
  844.     try {
  845.       // the file name might be non ASCII
  846.       // try unescape again with a characterSet
  847.       var textToSubURI = Components.classes["@mozilla.org/intl/texttosuburi;1"]
  848.                                    .getService(Components.interfaces.nsITextToSubURI);
  849.       var charset = getCharsetforSave(aDocument);
  850.       return validateFileName(textToSubURI.unEscapeURIForUI(charset, url.fileName));
  851.     } catch (e) {
  852.       // This is something like a wyciwyg:, data:, and so forth
  853.       // URI... no usable filename here.
  854.     }
  855.   }
  856.   
  857.   if (aDocument) {
  858.     var docTitle = validateFileName(aDocument.title).replace(/^\s+|\s+$/g, "");
  859.  
  860.     if (docTitle != "") {
  861.       // 3) Use the document title
  862.       return docTitle;
  863.     }
  864.   }
  865.   
  866.   if (aDefaultFileName)
  867.     // 4) Use the caller-provided name, if any
  868.     return validateFileName(aDefaultFileName);
  869.  
  870.   // 5) If this is a directory, use the last directory name
  871.   var re = /\/([^\/]+)\/$/;
  872.   var path = aDocumentURI.path.match(re);
  873.   if (path && path.length > 1) {
  874.       return validateFileName(path[1]);
  875.   }
  876.   
  877.   try {
  878.     if (aDocumentURI.host)
  879.       // 6) Use the host.
  880.       return aDocumentURI.host;
  881.   } catch (e) {
  882.     // Some files have no information at all, like Javascript generated pages
  883.   }
  884.   try {
  885.     // 7) Use the default file name
  886.     return getStringBundle().GetStringFromName("DefaultSaveFileName");
  887.   } catch (e) {
  888.     //in case localized string cannot be found
  889.   }
  890.   // 8) If all else fails, use "index"
  891.   return "index";
  892. }
  893.  
  894. function validateFileName(aFileName)
  895. {
  896.   var re = /[\/]+/g;
  897.   if (navigator.appVersion.indexOf("Windows") != -1) {
  898.     re = /[\\\/\|]+/g;
  899.     aFileName = aFileName.replace(/[\"]+/g, "'");
  900.     aFileName = aFileName.replace(/[\*\:\?]+/g, " ");
  901.     aFileName = aFileName.replace(/[\<]+/g, "(");
  902.     aFileName = aFileName.replace(/[\>]+/g, ")");
  903.   }
  904.   else if (navigator.appVersion.indexOf("Macintosh") != -1)
  905.     re = /[\:\/]+/g;
  906.   
  907.   return aFileName.replace(re, "_");
  908. }
  909.  
  910. function getNormalizedLeafName(aFile, aDefaultExtension)
  911. {
  912.   if (!aDefaultExtension)
  913.     return aFile;
  914.   
  915.   // Fix up the file name we're saving to to include the default extension
  916.   const stdURLContractID = "@mozilla.org/network/standard-url;1";
  917.   const stdURLIID = Components.interfaces.nsIURL;
  918.   var url = Components.classes[stdURLContractID].createInstance(stdURLIID);
  919.   url.filePath = aFile;
  920.   
  921.   if (url.fileExtension != aDefaultExtension) {
  922.     return aFile + "." + aDefaultExtension;
  923.   }
  924.  
  925.   return aFile;
  926. }
  927.  
  928. function getDefaultExtension(aFilename, aURI, aContentType)
  929. {
  930.   if (aContentType == "text/plain" || aContentType == "application/octet-stream" || aURI.scheme == "ftp")
  931.     return "";   // temporary fix for bug 120327
  932.  
  933.   // First try the extension from the filename
  934.   const stdURLContractID = "@mozilla.org/network/standard-url;1";
  935.   const stdURLIID = Components.interfaces.nsIURL;
  936.   var url = Components.classes[stdURLContractID].createInstance(stdURLIID);
  937.   url.filePath = aFilename;
  938.  
  939.   var ext = url.fileExtension;
  940.  
  941.   // This mirrors some code in nsExternalHelperAppService::DoContent
  942.   // Use the filename first and then the URI if that fails
  943.   
  944.   var mimeInfo = getMIMEInfoForType(aContentType, ext);
  945.  
  946.   if (ext && mimeInfo && mimeInfo.ExtensionExists(ext)) {
  947.     return ext;
  948.   }
  949.   
  950.   // Well, that failed.  Now try the extension from the URI
  951.   var urlext;
  952.   try {
  953.     url = aURI.QueryInterface(Components.interfaces.nsIURL);
  954.     urlext = url.fileExtension;
  955.   } catch (e) {
  956.   }
  957.  
  958.   if (urlext && mimeInfo && mimeInfo.ExtensionExists(urlext)) {
  959.     return urlext;
  960.   }
  961.   else {
  962.     try {
  963.       return mimeInfo.primaryExtension;
  964.     }
  965.     catch (e) {
  966.       // Fall back on the extensions in the filename and URI for lack
  967.       // of anything better.
  968.       return ext || urlext;
  969.     }
  970.   }
  971. }
  972.  
  973. function isDocumentType(aContentType)
  974. {
  975.   switch (aContentType) {
  976.   case "text/html":
  977.     return true;
  978.   case "text/xml":
  979.   case "application/xhtml+xml":
  980.   case "application/xml":
  981.     return false; // XXX Disables Save As Complete until it works for XML
  982.   }
  983.   return false;
  984. }
  985.  
  986. function getCharsetforSave(aDocument)
  987. {
  988.   if (aDocument)
  989.     return aDocument.characterSet;
  990.  
  991.   if (document.commandDispatcher.focusedWindow)
  992.     return document.commandDispatcher.focusedWindow.document.characterSet;
  993.  
  994.   return  window._content.document.characterSet;
  995.   return false;
  996. }
  997.  
  998. function SwitchTextEntryDirection(aElement) {
  999.   if (window.getComputedStyle(aElement, "").direction == "ltr")
  1000.     aElement.style.direction = "rtl";
  1001.   else
  1002.     aElement.style.direction = "ltr";
  1003. }
  1004.  
  1005.  
  1006.