/* # -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- # ***** BEGIN LICENSE BLOCK ***** # Version: MPL 1.1/GPL 2.0/LGPL 2.1 # # The contents of this file are subject to the Mozilla Public License Version # 1.1 (the "License"); you may not use this file except in compliance with # the License. You may obtain a copy of the License at # http://www.mozilla.org/MPL/ # # Software distributed under the License is distributed on an "AS IS" basis, # WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License # for the specific language governing rights and limitations under the # License. # # The Original Code is the Download Actions Manager. # # The Initial Developer of the Original Code is # Ben Goodger. # Portions created by the Initial Developer are Copyright (C) 2000 # the Initial Developer. All Rights Reserved. # # Contributor(s): # Ben Goodger # Jeff Walden # Asaf Romano # Myk Melez # Florian Queze # Will Guaraldi # Magnus Melin # # Alternatively, the contents of this file may be used under the terms of # either the GNU General Public License Version 2 or later (the "GPL"), or # the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), # in which case the provisions of the GPL or the LGPL are applicable instead # of those above. If you wish to allow use of your version of this file only # under the terms of either the GPL or the LGPL, and not to allow others to # use your version of this file under the terms of the MPL, indicate your # decision by deleting the provisions above and replace them with the notice # and other provisions required by the GPL or the LGPL. If you do not delete # the provisions above, a recipient may use your version of this file under # the terms of any one of the MPL, the GPL or the LGPL. # # ***** END LICENSE BLOCK ***** */ //****************************************************************************// // Constants & Enumeration Values const PREF_DISABLED_PLUGIN_TYPES = "plugin.disable_full_page_plugin_for_types"; // Preferences that affect which entries to show in the list. const PREF_SHOW_PLUGINS_IN_LIST = "browser.download.show_plugins_in_list"; const PREF_HIDE_PLUGINS_WITHOUT_EXTENSIONS = "browser.download.hide_plugins_without_extensions"; // The nsHandlerInfoAction enumeration values in nsIHandlerInfo identify // the actions the application can take with content of various types. // But since nsIHandlerInfo doesn't support plugins, there's no value // identifying the "use plugin" action, so we use this constant instead. const kActionUsePlugin = 5; /* #ifdef MOZ_WIDGET_GTK2 */ const ICON_URL_APP = "moz-icon://dummy.exe?size=16"; /* #else */ const ICON_URL_APP = "chrome://messenger/skin/preferences/application.png"; /* #endif */ // For CSS. Can be one of "ask", "save", "plugin" or "feed". If absent, the icon URL // was set by us to a custom handler icon and CSS should not try to override it. const APP_ICON_ATTR_NAME = "appHandlerIcon"; //****************************************************************************// // Utilities function getDisplayNameForFile(aFile) { /* #ifdef XP_WIN */ if (aFile instanceof Components.interfaces.nsILocalFileWin) { try { return aFile.getVersionInfoField("FileDescription"); } catch(ex) { // fall through to the file name } } /* #endif #ifdef XP_MACOSX */ if (aFile instanceof Components.interfaces.nsILocalFileMac) { try { return aFile.bundleDisplayName; } catch(ex) { // fall through to the file name } } /* #endif */ return aFile.leafName; } function getLocalHandlerApp(aFile) { var localHandlerApp = Components.classes["@mozilla.org/uriloader/local-handler-app;1"] .createInstance(Components.interfaces.nsILocalHandlerApp); localHandlerApp.name = getDisplayNameForFile(aFile); localHandlerApp.executable = aFile; return localHandlerApp; } /** * An enumeration of items in a JS array. * * FIXME: use ArrayConverter once it lands (bug 380839). * * @constructor */ function ArrayEnumerator(aItems) { this._index = 0; this._contents = aItems; } ArrayEnumerator.prototype = { _index: 0, hasMoreElements: function() { return this._index < this._contents.length; }, getNext: function() { return this._contents[this._index++]; } }; //****************************************************************************// // HandlerInfoWrapper /** * This object wraps nsIHandlerInfo with some additional functionality * the Applications prefpane needs to display and allow modification of * the list of handled types. * * We create an instance of this wrapper for each entry we might display * in the prefpane, and we compose the instances from various sources, * including navigator.plugins and the handler service. * * We don't implement all the original nsIHandlerInfo functionality, * just the stuff that the prefpane needs. * * In theory, all of the custom functionality in this wrapper should get * pushed down into nsIHandlerInfo eventually. */ function HandlerInfoWrapper(aType, aHandlerInfo) { this._type = aType; this.wrappedHandlerInfo = aHandlerInfo; } HandlerInfoWrapper.prototype = { // The wrapped nsIHandlerInfo object. In general, this object is private, // but there are a couple cases where callers access it directly for things // we haven't (yet?) implemented, so we make it a public property. wrappedHandlerInfo: null, //**************************************************************************// // Convenience Utils _handlerSvc: Components.classes["@mozilla.org/uriloader/handler-service;1"] .getService(Components.interfaces.nsIHandlerService), _prefSvc: Components.classes["@mozilla.org/preferences-service;1"] .getService(Components.interfaces.nsIPrefBranch2), _categoryMgr: Components.classes["@mozilla.org/categorymanager;1"] .getService(Components.interfaces.nsICategoryManager), //**************************************************************************// // nsIHandlerInfo // The MIME type or protocol scheme. _type: null, get type() { return this._type; }, get description() { if (this.wrappedHandlerInfo.description) return this.wrappedHandlerInfo.description; if (this.primaryExtension) { var extension = this.primaryExtension.toUpperCase(); return document.getElementById("bundlePreferences") .getFormattedString("fileEnding", [extension]); } return this.type; }, get preferredApplicationHandler() { return this.wrappedHandlerInfo.preferredApplicationHandler; }, set preferredApplicationHandler(aNewValue) { this.wrappedHandlerInfo.preferredApplicationHandler = aNewValue; // Make sure the preferred handler is in the set of possible handlers. if (aNewValue) this.addPossibleApplicationHandler(aNewValue) }, get possibleApplicationHandlers() { return this.wrappedHandlerInfo.possibleApplicationHandlers; }, addPossibleApplicationHandler: function(aNewHandler) { try { if (this.possibleApplicationHandlers.indexOf(0, aNewHandler) != -1) return; } catch (e) { } this.possibleApplicationHandlers.appendElement(aNewHandler, false); }, removePossibleApplicationHandler: function(aHandler) { var defaultApp = this.preferredApplicationHandler; if (defaultApp && aHandler.equals(defaultApp)) { // If the app we remove was the default app, we must make sure // it won't be used anymore this.alwaysAskBeforeHandling = true; this.preferredApplicationHandler = null; } try { var handlerIdx = this.possibleApplicationHandlers.indexOf(0, aHandler); this.possibleApplicationHandlers.removeElementAt(handlerIdx); } catch (e) { } }, get hasDefaultHandler() { return this.wrappedHandlerInfo.hasDefaultHandler; }, get defaultDescription() { return this.wrappedHandlerInfo.defaultDescription; }, // What to do with content of this type. get preferredAction() { // If we have an enabled plugin, then the action is to use that plugin. if (this.plugin && !this.isDisabledPluginType) return kActionUsePlugin; // If the action is to use a helper app, but we don't have a preferred // handler app, then switch to using the system default, if any; otherwise // fall back to saving to disk, which is the default action in nsMIMEInfo. // Note: "save to disk" is an invalid value for protocol info objects, // but the alwaysAskBeforeHandling getter will detect that situation // and always return true in that case to override this invalid value. if (this.wrappedHandlerInfo.preferredAction == Components.interfaces.nsIHandlerInfo.useHelperApp && !gApplicationsPane.isValidHandlerApp(this.preferredApplicationHandler)) { if (this.wrappedHandlerInfo.hasDefaultHandler) return Components.interfaces.nsIHandlerInfo.useSystemDefault; else return Components.interfaces.nsIHandlerInfo.saveToDisk; } return this.wrappedHandlerInfo.preferredAction; }, set preferredAction(aNewValue) { // We don't modify the preferred action if the new action is to use a plugin // because handler info objects don't understand our custom "use plugin" // value. Also, leaving it untouched means that we can automatically revert // to the old setting if the user ever removes the plugin. if (aNewValue != kActionUsePlugin) this.wrappedHandlerInfo.preferredAction = aNewValue; }, get alwaysAskBeforeHandling() { // If this type is handled only by a plugin, we can't trust the value // in the handler info object, since it'll be a default based on the absence // of any user configuration, and the default in that case is to always ask, // even though we never ask for content handled by a plugin, so special case // plugin-handled types by returning false here. if (this.plugin && this.handledOnlyByPlugin) return false; // If this is a protocol type and the preferred action is "save to disk", // which is invalid for such types, then return true here to override that // action. This could happen when the preferred action is to use a helper // app, but the preferredApplicationHandler is invalid, and there isn't // a default handler, so the preferredAction getter returns save to disk // instead. if (!(this.wrappedHandlerInfo instanceof Components.interfaces.nsIMIMEInfo) && this.preferredAction == Components.interfaces.nsIHandlerInfo.saveToDisk) return true; return this.wrappedHandlerInfo.alwaysAskBeforeHandling; }, set alwaysAskBeforeHandling(aNewValue) { this.wrappedHandlerInfo.alwaysAskBeforeHandling = aNewValue; }, //**************************************************************************// // nsIMIMEInfo // The primary file extension associated with this type, if any. // // XXX Plugin objects contain an array of MimeType objects with "suffixes" // properties; if this object has an associated plugin, shouldn't we check // those properties for an extension? get primaryExtension() { try { if (this.wrappedHandlerInfo instanceof Components.interfaces.nsIMIMEInfo && this.wrappedHandlerInfo.primaryExtension) return this.wrappedHandlerInfo.primaryExtension; } catch(ex) {} return null; }, //**************************************************************************// // Plugin Handling // A plugin that can handle this type, if any. // // Note: just because we have one doesn't mean it *will* handle the type. // That depends on whether or not the type is in the list of types for which // plugin handling is disabled. plugin: null, // Whether or not this type is only handled by a plugin or is also handled // by some user-configured action as specified in the handler info object. // // Note: we can't just check if there's a handler info object for this type, // because OS and user configuration is mixed up in the handler info object, // so we always need to retrieve it for the OS info and can't tell whether // it represents only OS-default information or user-configured information. // // FIXME: once handler info records are broken up into OS-provided records // and user-configured records, stop using this boolean flag and simply // check for the presence of a user-configured record to determine whether // or not this type is only handled by a plugin. Filed as bug 395142. handledOnlyByPlugin: undefined, get isDisabledPluginType() { return this._getDisabledPluginTypes().indexOf(this.type) != -1; }, _getDisabledPluginTypes: function() { var types = ""; if (this._prefSvc.prefHasUserValue(PREF_DISABLED_PLUGIN_TYPES)) types = this._prefSvc.getCharPref(PREF_DISABLED_PLUGIN_TYPES); // Only split if the string isn't empty so we don't end up with an array // containing a single empty string. return types ? types.split(",") : []; }, disablePluginType: function() { var disabledPluginTypes = this._getDisabledPluginTypes(); if (disabledPluginTypes.indexOf(this.type) == -1) disabledPluginTypes.push(this.type); this._prefSvc.setCharPref(PREF_DISABLED_PLUGIN_TYPES, disabledPluginTypes.join(",")); // Update the category manager so existing browser windows update. this._categoryMgr.deleteCategoryEntry("Gecko-Content-Viewers", this.type, false); }, enablePluginType: function() { var disabledPluginTypes = this._getDisabledPluginTypes(); var type = this.type; disabledPluginTypes = disabledPluginTypes.filter(function(v) v != type); this._prefSvc.setCharPref(PREF_DISABLED_PLUGIN_TYPES, disabledPluginTypes.join(",")); // Update the category manager so existing browser windows update. this._categoryMgr. addCategoryEntry("Gecko-Content-Viewers", this.type, "@mozilla.org/content/plugin/document-loader-factory;1", false, true); }, //**************************************************************************// // Storage store: function() { this._handlerSvc.store(this.wrappedHandlerInfo); }, remove: function() { this._handlerSvc.remove(this.wrappedHandlerInfo); }, //**************************************************************************// // Icons get smallIcon() { return this._getIcon(16); }, get largeIcon() { return this._getIcon(32); }, _getIcon: function(aSize) { if (this.primaryExtension) return "moz-icon://goat." + this.primaryExtension + "?size=" + aSize; if (this.wrappedHandlerInfo instanceof Components.interfaces.nsIMIMEInfo) return "moz-icon://goat?size=" + aSize + "&contentType=" + this.type; // FIXME: consider returning some generic icon when we can't get a URL for // one (for example in the case of protocol schemes). Filed as bug 395141. return null; } }; //****************************************************************************// // Prefpane Controller var gApplicationsPane = { // The set of types the app knows how to handle. A hash of HandlerInfoWrapper // objects, indexed by type. _handledTypes: {}, // The list of types we can show, sorted by the sort column/direction. // An array of HandlerInfoWrapper objects. We build this list when we first // load the data and then rebuild it when users change a pref that affects // what types we can show or change the sort column/direction. // Note: this isn't necessarily the list of types we *will* show; if the user // provides a filter string, we'll only show the subset of types in this list // that match that string. _visibleTypes: [], // A count of the number of times each visible type description appears. // We use these counts to determine whether or not to annotate descriptions // with their types to distinguish duplicate descriptions from each other. // A hash of integer counts, indexed by string description. _visibleTypeDescriptionCount: [], //**************************************************************************// // Convenience & Performance Shortcuts // These get defined by init(). _brandShortName : null, _prefsBundle : null, _list : null, _filter : null, _prefSvc : Components.classes["@mozilla.org/preferences-service;1"] .getService(Components.interfaces.nsIPrefBranch2), _mimeSvc : Components.classes["@mozilla.org/mime;1"] .getService(Components.interfaces.nsIMIMEService), _helperAppSvc : Components.classes["@mozilla.org/uriloader/external-helper-app-service;1"] .getService(Components.interfaces.nsIExternalHelperAppService), _handlerSvc : Components.classes["@mozilla.org/uriloader/handler-service;1"] .getService(Components.interfaces.nsIHandlerService), _ioSvc : Components.classes["@mozilla.org/network/io-service;1"] .getService(Components.interfaces.nsIIOService), //**************************************************************************// // Initialization & Destruction init: function() { // Initialize shortcuts to some commonly accessed elements & values. this._brandShortName = document.getElementById("bundleBrand").getString("brandShortName"); this._prefsBundle = document.getElementById("bundlePreferences"); this._list = document.getElementById("handlersView"); this._filter = document.getElementById("filter"); // Observe preferences that influence what we display so we can rebuild // the view when they change. this._prefSvc.addObserver(PREF_SHOW_PLUGINS_IN_LIST, this, false); this._prefSvc.addObserver(PREF_HIDE_PLUGINS_WITHOUT_EXTENSIONS, this, false); // Listen for window unload so we can remove our preference observers. window.addEventListener("unload", this, false); // Figure out how we should be sorting the list. We persist sort settings // across sessions, so we can't assume the default sort column/direction. // XXX should we be using the XUL sort service instead? this._sortColumn = document.getElementById("typeColumn") if (document.getElementById("actionColumn").hasAttribute("sortDirection")) { this._sortColumn = document.getElementById("actionColumn"); // The typeColumn element always has a sortDirection attribute, // either because it was persisted or because the default value // from the xul file was used. If we are sorting on the other // column, we should remove it. document.getElementById("typeColumn").removeAttribute("sortDirection"); } // By doing this in a timeout, we let the preferences dialog resize itself // to an appropriate size before we add a bunch of items to the list. // Otherwise, if there are many items, and the Applications prefpane // is the one that gets displayed when the user first opens the dialog, // the dialog might stretch too much in an attempt to fit them all in. // XXX Shouldn't we perhaps just set a max-height on the richlistbox? var _delayedPaneLoad = function(self) { self._loadData(); self._rebuildVisibleTypes(); self._sortVisibleTypes(); self.rebuildView(); // Notify observers that the UI is now ready Components.classes["@mozilla.org/observer-service;1"] .getService(Components.interfaces.nsIObserverService) .notifyObservers(window, "app-handler-pane-loaded", null); } setTimeout(_delayedPaneLoad, 0, this); }, destroy: function() { window.removeEventListener("unload", this, false); this._prefSvc.removeObserver(PREF_SHOW_PLUGINS_IN_LIST, this); this._prefSvc.removeObserver(PREF_HIDE_PLUGINS_WITHOUT_EXTENSIONS, this); }, //**************************************************************************// // nsISupports QueryInterface: function(aIID) { if (aIID.equals(Components.interfaces.nsIObserver) || aIID.equals(Components.interfaces.nsIDOMEventListener || aIID.equals(Components.interfaces.nsISupports))) return this; throw Components.results.NS_ERROR_NO_INTERFACE; }, //**************************************************************************// // nsIObserver observe: function (aSubject, aTopic, aData) { // Rebuild the list when there are changes to preferences that influence // whether or not to show certain entries in the list. if (aTopic == "nsPref:changed" && !this._storingAction) { // These two prefs alter the list of visible types, so we have to rebuild // that list when they change. if (aData == PREF_SHOW_PLUGINS_IN_LIST || aData == PREF_HIDE_PLUGINS_WITHOUT_EXTENSIONS) { this._rebuildVisibleTypes(); this._sortVisibleTypes(); } // All the prefs we observe can affect what we display, so we rebuild // the view when any of them changes. this.rebuildView(); } }, //**************************************************************************// // nsIDOMEventListener handleEvent: function(aEvent) { if (aEvent.type == "unload") this.destroy(); }, //**************************************************************************// // Composed Model Construction _loadData: function() { this._loadPluginHandlers(); this._loadApplicationHandlers(); }, /** * Load the set of handlers defined by plugins. * * Note: if there's more than one plugin for a given MIME type, we assume * the last one is the one that the application will use. That may not be * correct, but it's how we've been doing it for years. * * Perhaps we should instead query navigator.mimeTypes for the set of types * supported by the application and then get the plugin from each MIME type's * enabledPlugin property. But if there's a plugin for a type, we need * to know about it even if it isn't enabled, since we're going to give * the user an option to enable it. * * I'll also note that my reading of nsPluginTag::RegisterWithCategoryManager * suggests that enabledPlugin is only determined during registration * and does not get updated when plugin.disable_full_page_plugin_for_types * changes (unless modification of that preference spawns reregistration). * So even if we could use enabledPlugin to get the plugin that would be used, * we'd still need to check the pref ourselves to find out if it's enabled. */ _loadPluginHandlers: function() { for (let i = 0; i < navigator.plugins.length; ++i) { let plugin = navigator.plugins[i]; for (let j = 0; j < plugin.length; ++j) { let type = plugin[j].type; let handlerInfoWrapper; if (type in this._handledTypes) handlerInfoWrapper = this._handledTypes[type]; else { let wrappedHandlerInfo = this._mimeSvc.getFromTypeAndExtension(type, null); handlerInfoWrapper = new HandlerInfoWrapper(type, wrappedHandlerInfo); handlerInfoWrapper.handledOnlyByPlugin = true; this._handledTypes[type] = handlerInfoWrapper; } handlerInfoWrapper.plugin = plugin; } } }, /** * Load the set of handlers defined by the application datastore. */ _loadApplicationHandlers: function() { var wrappedHandlerInfos = this._handlerSvc.enumerate(); while (wrappedHandlerInfos.hasMoreElements()) { let wrappedHandlerInfo = wrappedHandlerInfos.getNext().QueryInterface(Components.interfaces.nsIHandlerInfo); let type = wrappedHandlerInfo.type; let handlerInfoWrapper; if (type in this._handledTypes) { handlerInfoWrapper = this._handledTypes[type]; } else { handlerInfoWrapper = new HandlerInfoWrapper(type, wrappedHandlerInfo); this._handledTypes[type] = handlerInfoWrapper; } handlerInfoWrapper.handledOnlyByPlugin = false; } }, //**************************************************************************// // View Construction _rebuildVisibleTypes: function() { // Reset the list of visible types and the visible type description counts. this._visibleTypes = []; this._visibleTypeDescriptionCount = []; // Get the preferences that help determine what types to show. var showPlugins = this._prefSvc.getBoolPref(PREF_SHOW_PLUGINS_IN_LIST); var hidePluginsWithoutExtensions = this._prefSvc.getBoolPref(PREF_HIDE_PLUGINS_WITHOUT_EXTENSIONS); for (let type in this._handledTypes) { let handlerInfo = this._handledTypes[type]; // Hide plugins without associated extensions if so prefed so we don't // show a whole bunch of obscure types handled by plugins on Mac. // Note: though protocol types don't have extensions, we still show them; // the pref is only meant to be applied to MIME types, since plugins are // only associated with MIME types. // FIXME: should we also check the "suffixes" property of the plugin? // Filed as bug 395135. if (hidePluginsWithoutExtensions && handlerInfo.handledOnlyByPlugin && handlerInfo.wrappedHandlerInfo instanceof Components.interfaces.nsIMIMEInfo && !handlerInfo.primaryExtension) continue; // Hide types handled only by plugins if so prefed. if (handlerInfo.handledOnlyByPlugin && !showPlugins) continue; // We couldn't find any reason to exclude the type, so include it. this._visibleTypes.push(handlerInfo); if (handlerInfo.description in this._visibleTypeDescriptionCount) this._visibleTypeDescriptionCount[handlerInfo.description]++; else this._visibleTypeDescriptionCount[handlerInfo.description] = 1; } }, rebuildView: function() { // Clear the list of entries. while (this._list.childNodes.length > 1) this._list.removeChild(this._list.lastChild); var visibleTypes = this._visibleTypes; // If the user is filtering the list, then only show matching types. if (this._filter.value) visibleTypes = visibleTypes.filter(this._matchesFilter, this); for each (let visibleType in visibleTypes) { let item = document.createElement("richlistitem"); item.setAttribute("type", visibleType.type); item.setAttribute("typeDescription", this._describeType(visibleType)); item.setAttribute("shortTypeDescription", visibleType.description); item.setAttribute("shortTypeDetails", this._typeDetails(visibleType)); if (visibleType.smallIcon) item.setAttribute("typeIcon", visibleType.smallIcon); item.setAttribute("actionDescription", this._describePreferredAction(visibleType)); if (!this._setIconClassForPreferredAction(visibleType, item)) { item.setAttribute("actionIcon", this._getIconURLForPreferredAction(visibleType)); } this._list.appendChild(item); } this._selectLastSelectedType(); }, _matchesFilter: function(aType) { var filterValue = this._filter.value.toLowerCase(); return this._describeType(aType).toLowerCase().indexOf(filterValue) != -1 || this._describePreferredAction(aType).toLowerCase().indexOf(filterValue) != -1; }, /** * Describe, in a human-readable fashion, the type represented by the given * handler info object. Normally this is just the description provided by * the info object, but if more than one object presents the same description, * then we annotate the duplicate descriptions with the type itself to help * users distinguish between those types. * * @param aHandlerInfo {nsIHandlerInfo} the type being described * @return {string} a description of the type */ _describeType: function(aHandlerInfo) { let details = this._typeDetails(aHandlerInfo); if (details) return this._prefsBundle.getFormattedString("typeDescriptionWithDetails", [aHandlerInfo.description, details]); return aHandlerInfo.description; }, /** * Get the details for the type represented by the given handler info * object. * * @param aHandlerInfo {nsIHandlerInfo} the type to get the extensions for. * @return {string} the extensions for the type */ _typeDetails: function(aHandlerInfo) { let exts = []; if (aHandlerInfo.wrappedHandlerInfo instanceof Components.interfaces.nsIMIMEInfo) { let extIter = aHandlerInfo.wrappedHandlerInfo.getFileExtensions(); while(extIter.hasMore()) { let ext = "."+extIter.getNext(); if (exts.indexOf(ext) == -1) exts.push(ext); } } exts.sort(); exts = exts.join(", "); if (this._visibleTypeDescriptionCount[aHandlerInfo.description] > 0) { if (exts) return this._prefsBundle.getFormattedString("typeDetailsWithTypeAndExt", [aHandlerInfo.type, exts]); return this._prefsBundle.getFormattedString("typeDetailsWithTypeOrExt", [ aHandlerInfo.type]); } if (exts) return this._prefsBundle.getFormattedString("typeDescriptionWithExt", [exts]); return exts; }, /** * Describe, in a human-readable fashion, the preferred action to take on * the type represented by the given handler info object. * * XXX Should this be part of the HandlerInfoWrapper interface? It would * violate the separation of model and view, but it might make more sense * nonetheless (f.e. it would make sortTypes easier). * * @param aHandlerInfo {nsIHandlerInfo} the type whose preferred action * is being described * @return {string} a description of the action */ _describePreferredAction: function(aHandlerInfo) { // alwaysAskBeforeHandling overrides the preferred action, so if that flag // is set, then describe that behavior instead. For most types, this is // the "alwaysAsk" string, but for the feed type we show something special. if (aHandlerInfo.alwaysAskBeforeHandling) return this._prefsBundle.getString("alwaysAsk"); switch (aHandlerInfo.preferredAction) { case Components.interfaces.nsIHandlerInfo.saveToDisk: return this._prefsBundle.getString("saveFile"); case Components.interfaces.nsIHandlerInfo.useHelperApp: var preferredApp = aHandlerInfo.preferredApplicationHandler; var name; if (preferredApp instanceof Components.interfaces.nsILocalHandlerApp) name = getDisplayNameForFile(preferredApp.executable); else name = preferredApp.name; return this._prefsBundle.getFormattedString("useApp", [name]); case Components.interfaces.nsIHandlerInfo.handleInternally: // For other types, handleInternally looks like either useHelperApp // or useSystemDefault depending on whether or not there's a preferred // handler app. if (this.isValidHandlerApp(aHandlerInfo.preferredApplicationHandler)) return aHandlerInfo.preferredApplicationHandler.name; return aHandlerInfo.defaultDescription; // XXX Why don't we say the app will handle the type internally? // Is it because the app can't actually do that? But if that's true, // then why would a preferredAction ever get set to this value // in the first place? case Components.interfaces.nsIHandlerInfo.useSystemDefault: return this._prefsBundle.getFormattedString("useDefault", [aHandlerInfo.defaultDescription]); case kActionUsePlugin: return this._prefsBundle.getFormattedString("usePluginIn", [aHandlerInfo.plugin.name, this._brandShortName]); } }, _selectLastSelectedType: function() { // If the list is disabled by the pref.downloads.disable_button.edit_actions // preference being locked, then don't select the type, as that would cause // it to appear selected, with a different background and an actions menu // that makes it seem like you can choose an action for the type. if (this._list.disabled) return; var lastSelectedType = this._list.getAttribute("lastSelectedType"); if (!lastSelectedType) return; var item = this._list.getElementsByAttribute("type", lastSelectedType)[0]; if (!item) return; this._list.selectedItem = item; }, /** * Whether or not the given handler app is valid. * @param aHandlerApp {nsIHandlerApp} the handler app in question * @return {boolean} whether or not it's valid */ isValidHandlerApp: function(aHandlerApp) { if (!aHandlerApp) return false; if (aHandlerApp instanceof Components.interfaces.nsILocalHandlerApp) return this._isValidHandlerExecutable(aHandlerApp.executable); if (aHandlerApp instanceof Components.interfaces.nsIWebHandlerApp) return aHandlerApp.uriTemplate; if (aHandlerApp instanceof Components.interfaces.nsIWebContentHandlerInfo) return aHandlerApp.uri; return false; }, _isValidHandlerExecutable: function(aExecutable) { return aExecutable && aExecutable.exists() && aExecutable.isExecutable() && // XXXben - we need to compare this with the running instance executable // just don't know how to do that via script... // XXXmano TBD: can probably add this to nsIShellService #ifdef XP_WIN #expand aExecutable.leafName != "__MOZ_APP_NAME__.exe"; #else #ifdef XP_MACOSX #expand aExecutable.leafName != "__MOZ_MACBUNDLE_NAME__"; #else #expand aExecutable.leafName != "__MOZ_APP_NAME__-bin"; #endif #endif }, /** * Rebuild the actions menu for the selected entry. Gets called by * the richlistitem constructor when an entry in the list gets selected. */ rebuildActionsMenu: function() { var typeItem = this._list.selectedItem; var handlerInfo = this._handledTypes[typeItem.type]; var menu = document.getAnonymousElementByAttribute(typeItem, "class", "actionsMenu"); var menuPopup = menu.menupopup; // Clear out existing items. while (menuPopup.hasChildNodes()) menuPopup.removeChild(menuPopup.lastChild); var askMenuItem = document.createElement("menuitem"); askMenuItem.setAttribute("alwaysAsk", "true"); { let label = this._prefsBundle.getString("alwaysAsk"); askMenuItem.setAttribute("label", label); askMenuItem.setAttribute("tooltiptext", label); askMenuItem.setAttribute(APP_ICON_ATTR_NAME, "ask"); menuPopup.appendChild(askMenuItem); } // Create a menu item for saving to disk. // Note: this option isn't available to protocol types, since we don't know // what it means to save a URL having a certain scheme to disk. if ((handlerInfo.wrappedHandlerInfo instanceof Components.interfaces.nsIMIMEInfo)) { var saveMenuItem = document.createElement("menuitem"); saveMenuItem.setAttribute("action", Components.interfaces.nsIHandlerInfo.saveToDisk); let label = this._prefsBundle.getString("saveFile"); saveMenuItem.setAttribute("label", label); saveMenuItem.setAttribute("tooltiptext", label); saveMenuItem.setAttribute(APP_ICON_ATTR_NAME, "save"); menuPopup.appendChild(saveMenuItem); } // Add a separator to distinguish these items from the helper app items // that follow them. let menuItem = document.createElement("menuseparator"); menuPopup.appendChild(menuItem); // Create a menu item for the OS default application, if any. if (handlerInfo.hasDefaultHandler) { var defaultMenuItem = document.createElement("menuitem"); defaultMenuItem.setAttribute("action", Components.interfaces.nsIHandlerInfo.useSystemDefault); let label = this._prefsBundle.getFormattedString("useDefault", [handlerInfo.defaultDescription]); defaultMenuItem.setAttribute("label", label); defaultMenuItem.setAttribute("tooltiptext", handlerInfo.defaultDescription); defaultMenuItem.setAttribute("image", this._getIconURLForSystemDefault(handlerInfo)); menuPopup.appendChild(defaultMenuItem); } // Create menu items for possible handlers. let preferredApp = handlerInfo.preferredApplicationHandler; let possibleApps = handlerInfo.possibleApplicationHandlers.enumerate(); var possibleAppMenuItems = []; while (possibleApps.hasMoreElements()) { let possibleApp = possibleApps.getNext(); if (!this.isValidHandlerApp(possibleApp)) continue; let menuItem = document.createElement("menuitem"); menuItem.setAttribute("action", Components.interfaces.nsIHandlerInfo.useHelperApp); let label; if (possibleApp instanceof Components.interfaces.nsILocalHandlerApp) label = getDisplayNameForFile(possibleApp.executable); else label = possibleApp.name; label = this._prefsBundle.getFormattedString("useApp", [label]); menuItem.setAttribute("label", label); menuItem.setAttribute("tooltiptext", label); menuItem.setAttribute("image", this._getIconURLForHandlerApp(possibleApp)); // Attach the handler app object to the menu item so we can use it // to make changes to the datastore when the user selects the item. menuItem.handlerApp = possibleApp; menuPopup.appendChild(menuItem); possibleAppMenuItems.push(menuItem); } // Create a menu item for the plugin. if (handlerInfo.plugin) { var pluginMenuItem = document.createElement("menuitem"); pluginMenuItem.setAttribute("action", kActionUsePlugin); let label = this._prefsBundle.getFormattedString("usePluginIn", [handlerInfo.plugin.name, this._brandShortName]); pluginMenuItem.setAttribute("label", label); pluginMenuItem.setAttribute("tooltiptext", label); pluginMenuItem.setAttribute(APP_ICON_ATTR_NAME, "plugin"); menuPopup.appendChild(pluginMenuItem); } // Create a menu item for selecting a local application. #ifdef XP_WIN // On Windows, selecting an application to open another application // would be meaningless so we special case executables. var executableType = Components.classes["@mozilla.org/mime;1"] .getService(Components.interfaces.nsIMIMEService) .getTypeFromExtension("exe"); if (handlerInfo.type != executableType) #endif { let menuItem = document.createElement("menuitem"); menuItem.setAttribute("oncommand", "gApplicationsPane.chooseApp(event)"); let label = this._prefsBundle.getString("useOtherApp"); menuItem.setAttribute("label", label); menuItem.setAttribute("tooltiptext", label); menuPopup.appendChild(menuItem); } // Create a menu item for managing applications. if (possibleAppMenuItems.length) { let menuItem = document.createElement("menuseparator"); menuPopup.appendChild(menuItem); menuItem = document.createElement("menuitem"); menuItem.setAttribute("oncommand", "gApplicationsPane.manageApp(event)"); menuItem.setAttribute("label", this._prefsBundle.getString("manageApp")); menuPopup.appendChild(menuItem); } let menuItem = document.createElement("menuseparator"); menuPopup.appendChild(menuItem); menuItem = document.createElement("menuitem"); menuItem.setAttribute("oncommand", "gApplicationsPane.confirmDelete(event)"); menuItem.setAttribute("label", this._prefsBundle.getString("delete")); menuPopup.appendChild(menuItem); // Select the item corresponding to the preferred action. If the always // ask flag is set, it overrides the preferred action. Otherwise we pick // the item identified by the preferred action (when the preferred action // is to use a helper app, we have to pick the specific helper app item). if (handlerInfo.alwaysAskBeforeHandling) menu.selectedItem = askMenuItem; else switch (handlerInfo.preferredAction) { case Components.interfaces.nsIHandlerInfo.handleInternally: menu.selectedItem = internalMenuItem; break; case Components.interfaces.nsIHandlerInfo.useSystemDefault: menu.selectedItem = defaultMenuItem; break; case Components.interfaces.nsIHandlerInfo.useHelperApp: if (preferredApp) menu.selectedItem = possibleAppMenuItems.filter(function(v) v.handlerApp.equals(preferredApp))[0]; break; case kActionUsePlugin: menu.selectedItem = pluginMenuItem; break; case Components.interfaces.nsIHandlerInfo.saveToDisk: menu.selectedItem = saveMenuItem; break; } // menu.selectedItem may be null if the preferredAction is // useSystemDefault, but handlerInfo.hasDefaultHandler returns false. // For now, we'll just use the askMenuItem to avoid ugly exceptions. menu.previousSelectedItem = menu.selectedItem || askMenuItem; }, //**************************************************************************// // Sorting & Filtering _sortColumn: null, /** * Sort the list when the user clicks on a column header. */ sort: function (event) { var column = event.target; // If the user clicked on a new sort column, remove the direction indicator // from the old column. if (this._sortColumn && this._sortColumn != column) this._sortColumn.removeAttribute("sortDirection"); this._sortColumn = column; // Set (or switch) the sort direction indicator. if (column.getAttribute("sortDirection") == "ascending") column.setAttribute("sortDirection", "descending"); else column.setAttribute("sortDirection", "ascending"); this._sortVisibleTypes(); this.rebuildView(); }, /** * Sort the list of visible types by the current sort column/direction. */ _sortVisibleTypes: function() { if (!this._sortColumn) return; var t = this; function sortByType(a, b) { return t._describeType(a).toLowerCase() .localeCompare(t._describeType(b).toLowerCase()); } function sortByAction(a, b) { return t._describePreferredAction(a).toLowerCase() .localeCompare(t._describePreferredAction(b).toLowerCase()); } switch (this._sortColumn.getAttribute("value")) { case "type": this._visibleTypes.sort(sortByType); break; case "action": this._visibleTypes.sort(sortByAction); break; } if (this._sortColumn.getAttribute("sortDirection") == "descending") this._visibleTypes.reverse(); }, focusFilterBox: function() { this._filter.focus(); this._filter.select(); }, //**************************************************************************// // Changes onSelectAction: function(aActionItem) { this._storingAction = true; let typeItem = this._list.selectedItem; let menu = document.getAnonymousElementByAttribute(typeItem, "class", "actionsMenu"); menu.previousSelectedItem = aActionItem; try { this._storeAction(aActionItem); } finally { this._storingAction = false; } }, _storeAction: function(aActionItem) { var typeItem = this._list.selectedItem; var handlerInfo = this._handledTypes[typeItem.type]; if (aActionItem.hasAttribute("alwaysAsk")) { handlerInfo.alwaysAskBeforeHandling = true; } else if (aActionItem.hasAttribute("action")) { let action = parseInt(aActionItem.getAttribute("action")); // Set the plugin state if we're enabling or disabling a plugin. if (action == kActionUsePlugin) handlerInfo.enablePluginType(); else if (handlerInfo.plugin && !handlerInfo.isDisabledPluginType) handlerInfo.disablePluginType(); // Set the preferred application handler. // We leave the existing preferred app in the list when we set // the preferred action to something other than useHelperApp so that // legacy datastores that don't have the preferred app in the list // of possible apps still include the preferred app in the list of apps // the user can choose to handle the type. if (action == Components.interfaces.nsIHandlerInfo.useHelperApp) handlerInfo.preferredApplicationHandler = aActionItem.handlerApp; // Set the "always ask" flag. handlerInfo.alwaysAskBeforeHandling = false; // Set the preferred action. handlerInfo.preferredAction = action; } handlerInfo.store(); // Make sure the handler info object is flagged to indicate that there is // now some user configuration for the type. handlerInfo.handledOnlyByPlugin = false; // Update the action label and image to reflect the new preferred action. typeItem.setAttribute("actionDescription", this._describePreferredAction(handlerInfo)); if (!this._setIconClassForPreferredAction(handlerInfo, typeItem)) { typeItem.setAttribute("actionIcon", this._getIconURLForPreferredAction(handlerInfo)); } }, manageApp: function(aEvent) { // Don't let the normal "on select action" handler get this event, // as we handle it specially ourselves. aEvent.stopPropagation(); var typeItem = this._list.selectedItem; var handlerInfo = this._handledTypes[typeItem.type]; document.documentElement.openSubDialog( "chrome://messenger/content/preferences/applicationManager.xul", "", handlerInfo); // Rebuild the actions menu so that we revert to the previous selection, // or "Always ask" if the previous default application has been removed this.rebuildActionsMenu(); // update the richlistitem too. Will be visible when selecting another row typeItem.setAttribute("actionDescription", this._describePreferredAction(handlerInfo)); if (!this._setIconClassForPreferredAction(handlerInfo, typeItem)) { typeItem.setAttribute("actionIcon", this._getIconURLForPreferredAction(handlerInfo)); } }, chooseApp: function(aEvent) { // Don't let the normal "on select action" handler get this event, // as we handle it specially ourselves. aEvent.stopPropagation(); var handlerApp; #ifdef XP_WIN var params = {}; var handlerInfo = this._handledTypes[this._list.selectedItem.type]; params.mimeInfo = handlerInfo.wrappedHandlerInfo; params.title = this._prefsBundle.getString("fpTitleChooseApp"); params.description = handlerInfo.description; params.filename = null; params.handlerApp = null; window.openDialog("chrome://global/content/appPicker.xul", null, "chrome,modal,centerscreen,titlebar,dialog=yes", params); if (params.handlerApp && params.handlerApp.executable && params.handlerApp.executable.isFile()) { handlerApp = params.handlerApp; // Add the app to the type's list of possible handlers. handlerInfo.addPossibleApplicationHandler(handlerApp); } #else var fp = Components.classes["@mozilla.org/filepicker;1"].createInstance(Components.interfaces.nsIFilePicker); var winTitle = this._prefsBundle.getString("fpTitleChooseApp"); fp.init(window, winTitle, Components.interfaces.nsIFilePicker.modeOpen); fp.appendFilters(Components.interfaces.nsIFilePicker.filterApps); // Prompt the user to pick an app. If they pick one, and it's a valid // selection, then add it to the list of possible handlers. if (fp.show() == Components.interfaces.nsIFilePicker.returnOK && fp.file && this._isValidHandlerExecutable(fp.file)) { handlerApp = Components.classes["@mozilla.org/uriloader/local-handler-app;1"] .createInstance(Components.interfaces.nsILocalHandlerApp); handlerApp.name = getDisplayNameForFile(fp.file); handlerApp.executable = fp.file; // Add the app to the type's list of possible handlers. let handlerInfo = this._handledTypes[this._list.selectedItem.type]; handlerInfo.addPossibleApplicationHandler(handlerApp); } #endif // Rebuild the actions menu whether the user picked an app or canceled. // If they picked an app, we want to add the app to the menu and select it. // If they canceled, we want to go back to their previous selection. this.rebuildActionsMenu(); // If the user picked a new app from the menu, select it. if (handlerApp) { let typeItem = this._list.selectedItem; let actionsMenu = document.getAnonymousElementByAttribute(typeItem, "class", "actionsMenu"); let menuItems = actionsMenu.menupopup.childNodes; for (let i = 0; i < menuItems.length; i++) { let menuItem = menuItems[i]; if (menuItem.handlerApp && menuItem.handlerApp.equals(handlerApp)) { actionsMenu.selectedIndex = i; this.onSelectAction(menuItem); break; } } } }, // Mark which item in the list was last selected so we can reselect it // when we rebuild the list or when the user returns to the prefpane. onSelectionChanged: function() { if (this._list.selectedItem) this._list.setAttribute("lastSelectedType", this._list.selectedItem.getAttribute("type")); }, confirmDelete: function(aEvent) { aEvent.stopPropagation(); let promptSvc = Components.classes["@mozilla.org/embedcomp/prompt-service;1"] .getService(Components.interfaces.nsIPromptService); if (promptSvc.confirm(null, this._prefsBundle.getString("confirmDeleteTitle"), this._prefsBundle.getString("confirmDeleteText"))) this.onDelete(aEvent); else { // They hit cancel, so return them to the previously selected item. let typeItem = this._list.selectedItem; let menu = document.getAnonymousElementByAttribute(this._list.selectedItem, "class", "actionsMenu"); menu.selectedItem = menu.previousSelectedItem; } }, onDelete: function(aEvent) { // We want to delete if either the request came from the confirmDelete // method (which is the only thing that populates the aEvent parameter), // or we've hit the delete/backspace key while the list has focus. if ((aEvent || document.commandDispatcher.focusedElement == this._list) && this._list.selectedIndex != -1) { let typeItem = this._list.getItemAtIndex(this._list.selectedIndex); let handlerInfo = this._handledTypes[typeItem.type]; this._list.removeItemAt(this._list.selectedIndex); let index = this._visibleTypes.indexOf(handlerInfo); if (index != -1) this._visibleTypes.splice(index, 1); handlerInfo.remove(); delete this._handledTypes[typeItem.type]; } }, _setIconClassForPreferredAction: function(aHandlerInfo, aElement) { // If this returns true, the attribute that CSS sniffs for was set to something // so you shouldn't manually set an icon URI. // This removes the existing actionIcon attribute if any, even if returning false. aElement.removeAttribute("actionIcon"); if (aHandlerInfo.alwaysAskBeforeHandling) { aElement.setAttribute(APP_ICON_ATTR_NAME, "ask"); return true; } switch (aHandlerInfo.preferredAction) { case Components.interfaces.nsIHandlerInfo.saveToDisk: aElement.setAttribute(APP_ICON_ATTR_NAME, "save"); return true; case Components.interfaces.nsIHandlerInfo.handleInternally: break; case kActionUsePlugin: aElement.setAttribute(APP_ICON_ATTR_NAME, "plugin"); return true; } aElement.removeAttribute(APP_ICON_ATTR_NAME); return false; }, _getIconURLForPreferredAction: function(aHandlerInfo) { switch (aHandlerInfo.preferredAction) { case Components.interfaces.nsIHandlerInfo.useSystemDefault: return this._getIconURLForSystemDefault(aHandlerInfo); case Components.interfaces.nsIHandlerInfo.useHelperApp: let (preferredApp = aHandlerInfo.preferredApplicationHandler) { if (this.isValidHandlerApp(preferredApp)) return this._getIconURLForHandlerApp(preferredApp); } break; // This should never happen, but if preferredAction is set to some weird // value, then fall back to the generic application icon. default: return ICON_URL_APP; } }, _getIconURLForHandlerApp: function(aHandlerApp) { if (aHandlerApp instanceof Components.interfaces.nsILocalHandlerApp) return this._getIconURLForFile(aHandlerApp.executable); if (aHandlerApp instanceof Components.interfaces.nsIWebHandlerApp) return this._getIconURLForWebApp(aHandlerApp.uriTemplate); if (aHandlerApp instanceof Components.interfaces.nsIWebContentHandlerInfo) return this._getIconURLForWebApp(aHandlerApp.uri) // We know nothing about other kinds of handler apps. return ""; }, _getIconURLForFile: function(aFile) { var fph = this._ioSvc.getProtocolHandler("file") .QueryInterface(Components.interfaces.nsIFileProtocolHandler); var urlSpec = fph.getURLSpecFromFile(aFile); return "moz-icon://" + urlSpec + "?size=16"; }, _getIconURLForWebApp: function(aWebAppURITemplate) { var uri = this._ioSvc.newURI(aWebAppURITemplate, null, null); // Unfortunately we can't use the favicon service to get the favicon, // because the service looks in the annotations table for a record with // the exact URL we give it, and users won't have such records for URLs // they don't visit, and users won't visit the web app's URL template, // they'll only visit URLs derived from that template (i.e. with %s // in the template replaced by the URL of the content being handled). if (/^https?/.test(uri.scheme)) return uri.prePath + "/favicon.ico"; return /^https?/.test(uri.scheme) ? uri.resolve("/favicon.ico") : ""; }, _getIconURLForSystemDefault: function(aHandlerInfo) { // Handler info objects for MIME types on some OSes implement a property bag // interface from which we can get an icon for the default app, so if we're // dealing with a MIME type on one of those OSes, then try to get the icon. if ("wrappedHandlerInfo" in aHandlerInfo) { let wrappedHandlerInfo = aHandlerInfo.wrappedHandlerInfo; if (wrappedHandlerInfo instanceof Components.interfaces.nsIMIMEInfo && wrappedHandlerInfo instanceof Components.interfaces.nsIPropertyBag) { try { let url = wrappedHandlerInfo.getProperty("defaultApplicationIconURL"); if (url) return url + "?size=16"; } catch(ex) { } } } // If this isn't a MIME type object on an OS that supports retrieving // the icon, or if we couldn't retrieve the icon for some other reason, // then use a generic icon. return ICON_URL_APP; } };