1732 lines
54 KiB
JavaScript
1732 lines
54 KiB
JavaScript
/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
|
* You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
/**
|
|
* Handles the Downloads panel user interface for each browser window.
|
|
*
|
|
* This file includes the following constructors and global objects:
|
|
*
|
|
* DownloadsPanel
|
|
* Main entry point for the downloads panel interface.
|
|
*
|
|
* DownloadsOverlayLoader
|
|
* Allows loading the downloads panel and the status indicator interfaces on
|
|
* demand, to improve startup performance.
|
|
*
|
|
* DownloadsView
|
|
* Builds and updates the downloads list widget, responding to changes in the
|
|
* download state and real-time data. In addition, handles part of the user
|
|
* interaction events raised by the downloads list widget.
|
|
*
|
|
* DownloadsViewItem
|
|
* Builds and updates a single item in the downloads list widget, responding to
|
|
* changes in the download state and real-time data, and handles the user
|
|
* interaction events related to a single item in the downloads list widgets.
|
|
*
|
|
* DownloadsViewController
|
|
* Handles part of the user interaction events raised by the downloads list
|
|
* widget, in particular the "commands" that apply to multiple items, and
|
|
* dispatches the commands that apply to individual items.
|
|
*/
|
|
|
|
/**
|
|
* A few words on focus and focusrings
|
|
*
|
|
* We do quite a few hacks in the Downloads Panel for focusrings. In fact, we
|
|
* basically suppress most if not all XUL-level focusrings, and style/draw
|
|
* them ourselves (using :focus instead of -moz-focusring). There are a few
|
|
* reasons for this:
|
|
*
|
|
* 1) Richlists on OSX don't have focusrings; instead, they are shown as
|
|
* selected. This makes for some ambiguity when we have a focused/selected
|
|
* item in the list, and the mouse is hovering a completed download (which
|
|
* highlights).
|
|
* 2) Windows doesn't show focusrings until after the first time that tab is
|
|
* pressed (and by then you're focusing the second item in the panel).
|
|
* 3) Richlistbox sets -moz-focusring even when we select it with a mouse.
|
|
*
|
|
* In general, the desired behaviour is to focus the first item after pressing
|
|
* tab/down, and show that focus with a ring. Then, if the mouse moves over
|
|
* the panel, to hide that focus ring; essentially resetting us to the state
|
|
* before pressing the key.
|
|
*
|
|
* We end up capturing the tab/down key events, and preventing their default
|
|
* behaviour. We then set a "keyfocus" attribute on the panel, which allows
|
|
* us to draw a ring around the currently focused element. If the panel is
|
|
* closed or the mouse moves over the panel, we remove the attribute.
|
|
*/
|
|
|
|
"use strict";
|
|
|
|
var { classes: Cc, interfaces: Ci, utils: Cu, results: Cr } = Components;
|
|
|
|
Cu.import("resource://gre/modules/XPCOMUtils.jsm");
|
|
|
|
XPCOMUtils.defineLazyModuleGetter(this, "DownloadsCommon",
|
|
"resource:///modules/DownloadsCommon.jsm");
|
|
XPCOMUtils.defineLazyModuleGetter(this, "DownloadsViewUI",
|
|
"resource:///modules/DownloadsViewUI.jsm");
|
|
XPCOMUtils.defineLazyModuleGetter(this, "FileUtils",
|
|
"resource://gre/modules/FileUtils.jsm");
|
|
XPCOMUtils.defineLazyModuleGetter(this, "NetUtil",
|
|
"resource://gre/modules/NetUtil.jsm");
|
|
XPCOMUtils.defineLazyModuleGetter(this, "PlacesUtils",
|
|
"resource://gre/modules/PlacesUtils.jsm");
|
|
XPCOMUtils.defineLazyModuleGetter(this, "Services",
|
|
"resource://gre/modules/Services.jsm");
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
//// DownloadsPanel
|
|
|
|
/**
|
|
* Main entry point for the downloads panel interface.
|
|
*/
|
|
const DownloadsPanel = {
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//// Initialization and termination
|
|
|
|
/**
|
|
* Internal state of the downloads panel, based on one of the kState
|
|
* constants. This is not the same state as the XUL panel element.
|
|
*/
|
|
_state: 0,
|
|
|
|
/** The panel is not linked to downloads data yet. */
|
|
get kStateUninitialized() {
|
|
return 0;
|
|
},
|
|
/** This object is linked to data, but the panel is invisible. */
|
|
get kStateHidden() {
|
|
return 1;
|
|
},
|
|
/** The panel will be shown as soon as possible. */
|
|
get kStateWaitingData() {
|
|
return 2;
|
|
},
|
|
/** The panel is almost shown - we're just waiting to get a handle on the
|
|
anchor. */
|
|
get kStateWaitingAnchor() {
|
|
return 3;
|
|
},
|
|
/** The panel is open. */
|
|
get kStateShown() {
|
|
return 4;
|
|
},
|
|
|
|
/**
|
|
* Location of the panel overlay.
|
|
*/
|
|
get kDownloadsOverlay() {
|
|
return "chrome://browser/content/downloads/downloadsOverlay.xul";
|
|
},
|
|
|
|
/**
|
|
* Starts loading the download data in background, without opening the panel.
|
|
* Use showPanel instead to load the data and open the panel at the same time.
|
|
*
|
|
* @param aCallback
|
|
* Called when initialization is complete.
|
|
*/
|
|
initialize(aCallback) {
|
|
DownloadsCommon.log("Attempting to initialize DownloadsPanel for a window.");
|
|
if (this._state != this.kStateUninitialized) {
|
|
DownloadsCommon.log("DownloadsPanel is already initialized.");
|
|
DownloadsOverlayLoader.ensureOverlayLoaded(this.kDownloadsOverlay,
|
|
aCallback);
|
|
return;
|
|
}
|
|
this._state = this.kStateHidden;
|
|
|
|
window.addEventListener("unload", this.onWindowUnload, false);
|
|
|
|
// Load and resume active downloads if required. If there are downloads to
|
|
// be shown in the panel, they will be loaded asynchronously.
|
|
DownloadsCommon.initializeAllDataLinks();
|
|
|
|
// Now that data loading has eventually started, load the required XUL
|
|
// elements and initialize our views.
|
|
DownloadsCommon.log("Ensuring DownloadsPanel overlay loaded.");
|
|
DownloadsOverlayLoader.ensureOverlayLoaded(this.kDownloadsOverlay, () => {
|
|
DownloadsViewController.initialize();
|
|
DownloadsCommon.log("Attaching DownloadsView...");
|
|
DownloadsCommon.getData(window).addView(DownloadsView);
|
|
DownloadsCommon.getSummary(window, DownloadsView.kItemCountLimit)
|
|
.addView(DownloadsSummary);
|
|
DownloadsCommon.log("DownloadsView attached - the panel for this window",
|
|
"should now see download items come in.");
|
|
DownloadsPanel._attachEventListeners();
|
|
DownloadsCommon.log("DownloadsPanel initialized.");
|
|
aCallback();
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Closes the downloads panel and frees the internal resources related to the
|
|
* downloads. The downloads panel can be reopened later, even after this
|
|
* function has been called.
|
|
*/
|
|
terminate() {
|
|
DownloadsCommon.log("Attempting to terminate DownloadsPanel for a window.");
|
|
if (this._state == this.kStateUninitialized) {
|
|
DownloadsCommon.log("DownloadsPanel was never initialized. Nothing to do.");
|
|
return;
|
|
}
|
|
|
|
window.removeEventListener("unload", this.onWindowUnload, false);
|
|
|
|
// Ensure that the panel is closed before shutting down.
|
|
this.hidePanel();
|
|
|
|
DownloadsViewController.terminate();
|
|
DownloadsCommon.getData(window).removeView(DownloadsView);
|
|
DownloadsCommon.getSummary(window, DownloadsView.kItemCountLimit)
|
|
.removeView(DownloadsSummary);
|
|
this._unattachEventListeners();
|
|
|
|
this._state = this.kStateUninitialized;
|
|
|
|
DownloadsSummary.active = false;
|
|
DownloadsCommon.log("DownloadsPanel terminated.");
|
|
},
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//// Panel interface
|
|
|
|
/**
|
|
* Main panel element in the browser window, or null if the panel overlay
|
|
* hasn't been loaded yet.
|
|
*/
|
|
get panel() {
|
|
// If the downloads panel overlay hasn't loaded yet, just return null
|
|
// without resetting this.panel.
|
|
let downloadsPanel = document.getElementById("downloadsPanel");
|
|
if (!downloadsPanel)
|
|
return null;
|
|
|
|
delete this.panel;
|
|
return this.panel = downloadsPanel;
|
|
},
|
|
|
|
/**
|
|
* Starts opening the downloads panel interface, anchored to the downloads
|
|
* button of the browser window. The list of downloads to display is
|
|
* initialized the first time this method is called, and the panel is shown
|
|
* only when data is ready.
|
|
*/
|
|
showPanel() {
|
|
DownloadsCommon.log("Opening the downloads panel.");
|
|
|
|
if (this.isPanelShowing) {
|
|
DownloadsCommon.log("Panel is already showing - focusing instead.");
|
|
this._focusPanel();
|
|
return;
|
|
}
|
|
|
|
this.initialize(() => {
|
|
let downloadsFooterButtons =
|
|
document.getElementById("downloadsFooterButtons");
|
|
if (DownloadsCommon.showPanelDropmarker) {
|
|
downloadsFooterButtons.classList.remove("downloadsHideDropmarker");
|
|
} else {
|
|
downloadsFooterButtons.classList.add("downloadsHideDropmarker");
|
|
}
|
|
|
|
// Delay displaying the panel because this function will sometimes be
|
|
// called while another window is closing (like the window for selecting
|
|
// whether to save or open the file), and that would cause the panel to
|
|
// close immediately.
|
|
setTimeout(() => this._openPopupIfDataReady(), 0);
|
|
});
|
|
|
|
DownloadsCommon.log("Waiting for the downloads panel to appear.");
|
|
this._state = this.kStateWaitingData;
|
|
},
|
|
|
|
/**
|
|
* Hides the downloads panel, if visible, but keeps the internal state so that
|
|
* the panel can be reopened quickly if required.
|
|
*/
|
|
hidePanel() {
|
|
DownloadsCommon.log("Closing the downloads panel.");
|
|
|
|
if (!this.isPanelShowing) {
|
|
DownloadsCommon.log("Downloads panel is not showing - nothing to do.");
|
|
return;
|
|
}
|
|
|
|
this.panel.hidePopup();
|
|
|
|
// Ensure that we allow the panel to be reopened. Note that, if the popup
|
|
// was open, then the onPopupHidden event handler has already updated the
|
|
// current state, otherwise we must update the state ourselves.
|
|
this._state = this.kStateHidden;
|
|
DownloadsCommon.log("Downloads panel is now closed.");
|
|
},
|
|
|
|
/**
|
|
* Indicates whether the panel is shown or will be shown.
|
|
*/
|
|
get isPanelShowing() {
|
|
return this._state == this.kStateWaitingData ||
|
|
this._state == this.kStateWaitingAnchor ||
|
|
this._state == this.kStateShown;
|
|
},
|
|
|
|
/**
|
|
* Returns whether the user has started keyboard navigation.
|
|
*/
|
|
get keyFocusing() {
|
|
return this.panel.hasAttribute("keyfocus");
|
|
},
|
|
|
|
/**
|
|
* Set to true if the user has started keyboard navigation, and we should be
|
|
* showing focusrings in the panel. Also adds a mousemove event handler to
|
|
* the panel which disables keyFocusing.
|
|
*/
|
|
set keyFocusing(aValue) {
|
|
if (aValue) {
|
|
this.panel.setAttribute("keyfocus", "true");
|
|
this.panel.addEventListener("mousemove", this);
|
|
} else {
|
|
this.panel.removeAttribute("keyfocus");
|
|
this.panel.removeEventListener("mousemove", this);
|
|
}
|
|
return aValue;
|
|
},
|
|
|
|
/**
|
|
* Handles the mousemove event for the panel, which disables focusring
|
|
* visualization.
|
|
*/
|
|
handleEvent(aEvent) {
|
|
switch (aEvent.type) {
|
|
case "mousemove":
|
|
this.keyFocusing = false;
|
|
break;
|
|
case "keydown":
|
|
return this._onKeyDown(aEvent);
|
|
case "keypress":
|
|
return this._onKeyPress(aEvent);
|
|
case "popupshown":
|
|
if (this.setHeightToFitOnShow) {
|
|
this.setHeightToFitOnShow = false;
|
|
this.setHeightToFit();
|
|
}
|
|
break;
|
|
}
|
|
},
|
|
|
|
setHeightToFit() {
|
|
if (this._state == this.kStateShown) {
|
|
DownloadsBlockedSubview.view.setHeightToFit();
|
|
} else {
|
|
this.setHeightToFitOnShow = true;
|
|
}
|
|
},
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//// Callback functions from DownloadsView
|
|
|
|
/**
|
|
* Called after data loading finished.
|
|
*/
|
|
onViewLoadCompleted() {
|
|
this._openPopupIfDataReady();
|
|
},
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//// User interface event functions
|
|
|
|
onWindowUnload() {
|
|
// This function is registered as an event listener, we can't use "this".
|
|
DownloadsPanel.terminate();
|
|
},
|
|
|
|
onPopupShown(aEvent) {
|
|
// Ignore events raised by nested popups.
|
|
if (aEvent.target != aEvent.currentTarget) {
|
|
return;
|
|
}
|
|
|
|
DownloadsCommon.log("Downloads panel has shown.");
|
|
this._state = this.kStateShown;
|
|
|
|
// Since at most one popup is open at any given time, we can set globally.
|
|
DownloadsCommon.getIndicatorData(window).attentionSuppressed = true;
|
|
|
|
// Ensure that the first item is selected when the panel is focused.
|
|
if (DownloadsView.richListBox.itemCount > 0 &&
|
|
DownloadsView.richListBox.selectedIndex == -1) {
|
|
DownloadsView.richListBox.selectedIndex = 0;
|
|
}
|
|
|
|
this._focusPanel();
|
|
},
|
|
|
|
onPopupHidden(aEvent) {
|
|
// Ignore events raised by nested popups.
|
|
if (aEvent.target != aEvent.currentTarget) {
|
|
return;
|
|
}
|
|
|
|
DownloadsCommon.log("Downloads panel has hidden.");
|
|
|
|
// Removes the keyfocus attribute so that we stop handling keyboard
|
|
// navigation.
|
|
this.keyFocusing = false;
|
|
|
|
// Since at most one popup is open at any given time, we can set globally.
|
|
DownloadsCommon.getIndicatorData(window).attentionSuppressed = false;
|
|
|
|
// Allow the anchor to be hidden.
|
|
DownloadsButton.releaseAnchor();
|
|
|
|
// Allow the panel to be reopened.
|
|
this._state = this.kStateHidden;
|
|
},
|
|
|
|
onFooterPopupShowing(aEvent) {
|
|
let itemClearList = document.getElementById("downloadsDropdownItemClearList");
|
|
if (DownloadsCommon.getData(window).canRemoveFinished) {
|
|
itemClearList.removeAttribute("hidden");
|
|
} else {
|
|
itemClearList.setAttribute("hidden", "true");
|
|
}
|
|
DownloadsViewController.updateCommands();
|
|
|
|
document.getElementById("downloadsFooter")
|
|
.setAttribute("showingdropdown", true);
|
|
},
|
|
|
|
onFooterPopupHidden(aEvent) {
|
|
document.getElementById("downloadsFooter")
|
|
.removeAttribute("showingdropdown");
|
|
},
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//// Related operations
|
|
|
|
/**
|
|
* Shows or focuses the user interface dedicated to downloads history.
|
|
*/
|
|
showDownloadsHistory() {
|
|
DownloadsCommon.log("Showing download history.");
|
|
// Hide the panel before showing another window, otherwise focus will return
|
|
// to the browser window when the panel closes automatically.
|
|
this.hidePanel();
|
|
|
|
BrowserDownloadsUI();
|
|
},
|
|
|
|
openDownloadsFolder() {
|
|
Downloads.getPreferredDownloadsDirectory().then(downloadsPath => {
|
|
DownloadsCommon.showDirectory(new FileUtils.File(downloadsPath));
|
|
}).catch(Cu.reportError);
|
|
this.hidePanel();
|
|
},
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//// Internal functions
|
|
|
|
/**
|
|
* Attach event listeners to a panel element. These listeners should be
|
|
* removed in _unattachEventListeners. This is called automatically after the
|
|
* panel has successfully loaded.
|
|
*/
|
|
_attachEventListeners() {
|
|
// Handle keydown to support accel-V.
|
|
this.panel.addEventListener("keydown", this, false);
|
|
// Handle keypress to be able to preventDefault() events before they reach
|
|
// the richlistbox, for keyboard navigation.
|
|
this.panel.addEventListener("keypress", this, false);
|
|
// Handle height adjustment on show.
|
|
this.panel.addEventListener("popupshown", this, false);
|
|
},
|
|
|
|
/**
|
|
* Unattach event listeners that were added in _attachEventListeners. This
|
|
* is called automatically on panel termination.
|
|
*/
|
|
_unattachEventListeners() {
|
|
this.panel.removeEventListener("keydown", this, false);
|
|
this.panel.removeEventListener("keypress", this, false);
|
|
this.panel.removeEventListener("popupshown", this, false);
|
|
},
|
|
|
|
_onKeyPress(aEvent) {
|
|
// Handle unmodified keys only.
|
|
if (aEvent.altKey || aEvent.ctrlKey || aEvent.shiftKey || aEvent.metaKey) {
|
|
return;
|
|
}
|
|
|
|
let richListBox = DownloadsView.richListBox;
|
|
|
|
// If the user has pressed the tab, up, or down cursor key, start keyboard
|
|
// navigation, thus enabling focusrings in the panel. Keyboard navigation
|
|
// is automatically disabled if the user moves the mouse on the panel, or
|
|
// if the panel is closed.
|
|
if ((aEvent.keyCode == Ci.nsIDOMKeyEvent.DOM_VK_TAB ||
|
|
aEvent.keyCode == Ci.nsIDOMKeyEvent.DOM_VK_UP ||
|
|
aEvent.keyCode == Ci.nsIDOMKeyEvent.DOM_VK_DOWN) &&
|
|
!this.keyFocusing) {
|
|
this.keyFocusing = true;
|
|
// Ensure there's a selection, we will show the focus ring around it and
|
|
// prevent the richlistbox from changing the selection.
|
|
if (DownloadsView.richListBox.selectedIndex == -1) {
|
|
DownloadsView.richListBox.selectedIndex = 0;
|
|
}
|
|
aEvent.preventDefault();
|
|
return;
|
|
}
|
|
|
|
if (aEvent.keyCode == Ci.nsIDOMKeyEvent.DOM_VK_DOWN) {
|
|
// If the last element in the list is selected, or the footer is already
|
|
// focused, focus the footer.
|
|
if (richListBox.selectedItem === richListBox.lastChild ||
|
|
document.activeElement.parentNode.id === "downloadsFooter") {
|
|
DownloadsFooter.focus();
|
|
aEvent.preventDefault();
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Pass keypress events to the richlistbox view when it's focused.
|
|
if (document.activeElement === richListBox) {
|
|
DownloadsView.onDownloadKeyPress(aEvent);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Keydown listener that listens for the keys to start key focusing, as well
|
|
* as the the accel-V "paste" event, which initiates a file download if the
|
|
* pasted item can be resolved to a URI.
|
|
*/
|
|
_onKeyDown(aEvent) {
|
|
// If the footer is focused and the downloads list has at least 1 element
|
|
// in it, focus the last element in the list when going up.
|
|
if (aEvent.keyCode == Ci.nsIDOMKeyEvent.DOM_VK_UP &&
|
|
document.activeElement.parentNode.id === "downloadsFooter" &&
|
|
DownloadsView.richListBox.firstChild) {
|
|
DownloadsView.richListBox.focus();
|
|
DownloadsView.richListBox.selectedItem = DownloadsView.richListBox.lastChild;
|
|
aEvent.preventDefault();
|
|
return;
|
|
}
|
|
|
|
let pasting = aEvent.keyCode == Ci.nsIDOMKeyEvent.DOM_VK_V &&
|
|
aEvent.getModifierState("Accel");
|
|
|
|
if (!pasting) {
|
|
return;
|
|
}
|
|
|
|
DownloadsCommon.log("Received a paste event.");
|
|
|
|
let trans = Cc["@mozilla.org/widget/transferable;1"]
|
|
.createInstance(Ci.nsITransferable);
|
|
trans.init(null);
|
|
let flavors = ["text/x-moz-url", "text/unicode"];
|
|
flavors.forEach(trans.addDataFlavor);
|
|
Services.clipboard.getData(trans, Services.clipboard.kGlobalClipboard);
|
|
// Getting the data or creating the nsIURI might fail
|
|
try {
|
|
let data = {};
|
|
trans.getAnyTransferData({}, data, {});
|
|
let [url, name] = data.value
|
|
.QueryInterface(Ci.nsISupportsString)
|
|
.data
|
|
.split("\n");
|
|
if (!url) {
|
|
return;
|
|
}
|
|
|
|
let uri = NetUtil.newURI(url);
|
|
DownloadsCommon.log("Pasted URL seems valid. Starting download.");
|
|
DownloadURL(uri.spec, name, document);
|
|
} catch (ex) {}
|
|
},
|
|
|
|
/**
|
|
* Move focus to the main element in the downloads panel, unless another
|
|
* element in the panel is already focused.
|
|
*/
|
|
_focusPanel() {
|
|
// We may be invoked while the panel is still waiting to be shown.
|
|
if (this._state != this.kStateShown) {
|
|
return;
|
|
}
|
|
|
|
let element = document.commandDispatcher.focusedElement;
|
|
while (element && element != this.panel) {
|
|
element = element.parentNode;
|
|
}
|
|
if (!element) {
|
|
if (DownloadsView.richListBox.itemCount > 0) {
|
|
DownloadsView.richListBox.focus();
|
|
} else {
|
|
DownloadsFooter.focus();
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Opens the downloads panel when data is ready to be displayed.
|
|
*/
|
|
_openPopupIfDataReady() {
|
|
// We don't want to open the popup if we already displayed it, or if we are
|
|
// still loading data.
|
|
if (this._state != this.kStateWaitingData || DownloadsView.loading) {
|
|
return;
|
|
}
|
|
|
|
this._state = this.kStateWaitingAnchor;
|
|
|
|
// Ensure the anchor is visible. If that is not possible, show the panel
|
|
// anchored to the top area of the window, near the default anchor position.
|
|
DownloadsButton.getAnchor(anchor => {
|
|
// If somehow we've switched states already (by getting a panel hiding
|
|
// event before an overlay is loaded, for example), bail out.
|
|
if (this._state != this.kStateWaitingAnchor) {
|
|
return;
|
|
}
|
|
|
|
// At this point, if the window is minimized, opening the panel could fail
|
|
// without any notification, and there would be no way to either open or
|
|
// close the panel any more. To prevent this, check if the window is
|
|
// minimized and in that case force the panel to the closed state.
|
|
if (window.windowState == Ci.nsIDOMChromeWindow.STATE_MINIMIZED) {
|
|
DownloadsButton.releaseAnchor();
|
|
this._state = this.kStateHidden;
|
|
return;
|
|
}
|
|
|
|
if (!anchor) {
|
|
DownloadsCommon.error("Downloads button cannot be found.");
|
|
return;
|
|
}
|
|
|
|
// When the panel is opened, we check if the target files of visible items
|
|
// still exist, and update the allowed items interactions accordingly. We
|
|
// do these checks on a background thread, and don't prevent the panel to
|
|
// be displayed while these checks are being performed.
|
|
for (let viewItem of DownloadsView._visibleViewItems.values()) {
|
|
viewItem.download.refresh().catch(Cu.reportError);
|
|
}
|
|
|
|
DownloadsCommon.log("Opening downloads panel popup.");
|
|
this.panel.openPopup(anchor, "bottomcenter topright", 0, 0, false, null);
|
|
});
|
|
},
|
|
};
|
|
|
|
XPCOMUtils.defineConstant(this, "DownloadsPanel", DownloadsPanel);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
//// DownloadsOverlayLoader
|
|
|
|
/**
|
|
* Allows loading the downloads panel and the status indicator interfaces on
|
|
* demand, to improve startup performance.
|
|
*/
|
|
const DownloadsOverlayLoader = {
|
|
/**
|
|
* We cannot load two overlays at the same time, thus we use a queue of
|
|
* pending load requests.
|
|
*/
|
|
_loadRequests: [],
|
|
|
|
/**
|
|
* True while we are waiting for an overlay to be loaded.
|
|
*/
|
|
_overlayLoading: false,
|
|
|
|
/**
|
|
* This object has a key for each overlay URI that is already loaded.
|
|
*/
|
|
_loadedOverlays: {},
|
|
|
|
/**
|
|
* Loads the specified overlay and invokes the given callback when finished.
|
|
*
|
|
* @param aOverlay
|
|
* String containing the URI of the overlay to load in the current
|
|
* window. If this overlay has already been loaded using this
|
|
* function, then the overlay is not loaded again.
|
|
* @param aCallback
|
|
* Invoked when loading is completed. If the overlay is already
|
|
* loaded, the function is called immediately.
|
|
*/
|
|
ensureOverlayLoaded(aOverlay, aCallback) {
|
|
// The overlay is already loaded, invoke the callback immediately.
|
|
if (aOverlay in this._loadedOverlays) {
|
|
aCallback();
|
|
return;
|
|
}
|
|
|
|
// The callback will be invoked when loading is finished.
|
|
this._loadRequests.push({ overlay: aOverlay, callback: aCallback });
|
|
if (this._overlayLoading) {
|
|
return;
|
|
}
|
|
|
|
this._overlayLoading = true;
|
|
DownloadsCommon.log("Loading overlay ", aOverlay);
|
|
document.loadOverlay(aOverlay, () => {
|
|
this._overlayLoading = false;
|
|
this._loadedOverlays[aOverlay] = true;
|
|
|
|
this.processPendingRequests();
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Re-processes all the currently pending requests, invoking the callbacks
|
|
* and/or loading more overlays as needed. In most cases, there will be a
|
|
* single request for one overlay, that will be processed immediately.
|
|
*/
|
|
processPendingRequests() {
|
|
// Re-process all the currently pending requests, yet allow more requests
|
|
// to be appended at the end of the array if we're not ready for them.
|
|
let currentLength = this._loadRequests.length;
|
|
for (let i = 0; i < currentLength; i++) {
|
|
let request = this._loadRequests.shift();
|
|
|
|
// We must call ensureOverlayLoaded again for each request, to check if
|
|
// the associated callback can be invoked now, or if we must still wait
|
|
// for the associated overlay to load.
|
|
this.ensureOverlayLoaded(request.overlay, request.callback);
|
|
}
|
|
},
|
|
};
|
|
|
|
XPCOMUtils.defineConstant(this, "DownloadsOverlayLoader", DownloadsOverlayLoader);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
//// DownloadsView
|
|
|
|
/**
|
|
* Builds and updates the downloads list widget, responding to changes in the
|
|
* download state and real-time data. In addition, handles part of the user
|
|
* interaction events raised by the downloads list widget.
|
|
*/
|
|
const DownloadsView = {
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//// Functions handling download items in the list
|
|
|
|
/**
|
|
* Maximum number of items shown by the list at any given time.
|
|
*/
|
|
kItemCountLimit: 5,
|
|
|
|
/**
|
|
* Indicates whether there is an open contextMenu for a download item.
|
|
*/
|
|
contextMenuOpen: false,
|
|
|
|
/**
|
|
* Indicates whether there is a DownloadsBlockedSubview open.
|
|
*/
|
|
subViewOpen: false,
|
|
|
|
/**
|
|
* Indicates whether we are still loading downloads data asynchronously.
|
|
*/
|
|
loading: false,
|
|
|
|
/**
|
|
* Ordered array of all Download objects. We need to keep this array because
|
|
* only a limited number of items are shown at once, and if an item that is
|
|
* currently visible is removed from the list, we might need to take another
|
|
* item from the array and make it appear at the bottom.
|
|
*/
|
|
_downloads: [],
|
|
|
|
/**
|
|
* Associates the visible Download objects with their corresponding
|
|
* DownloadsViewItem object. There is a limited number of view items in the
|
|
* panel at any given time.
|
|
*/
|
|
_visibleViewItems: new Map(),
|
|
|
|
/**
|
|
* Called when the number of items in the list changes.
|
|
*/
|
|
_itemCountChanged() {
|
|
DownloadsCommon.log("The downloads item count has changed - we are tracking",
|
|
this._downloads.length, "downloads in total.");
|
|
let count = this._downloads.length;
|
|
let hiddenCount = count - this.kItemCountLimit;
|
|
|
|
if (count > 0) {
|
|
DownloadsCommon.log("Setting the panel's hasdownloads attribute to true.");
|
|
DownloadsPanel.panel.setAttribute("hasdownloads", "true");
|
|
} else {
|
|
DownloadsCommon.log("Removing the panel's hasdownloads attribute.");
|
|
DownloadsPanel.panel.removeAttribute("hasdownloads");
|
|
}
|
|
|
|
// If we've got some hidden downloads, we should activate the
|
|
// DownloadsSummary. The DownloadsSummary will determine whether or not
|
|
// it's appropriate to actually display the summary.
|
|
DownloadsSummary.active = hiddenCount > 0;
|
|
},
|
|
|
|
/**
|
|
* Element corresponding to the list of downloads.
|
|
*/
|
|
get richListBox() {
|
|
delete this.richListBox;
|
|
return this.richListBox = document.getElementById("downloadsListBox");
|
|
},
|
|
|
|
/**
|
|
* Element corresponding to the button for showing more downloads.
|
|
*/
|
|
get downloadsHistory() {
|
|
delete this.downloadsHistory;
|
|
return this.downloadsHistory = document.getElementById("downloadsHistory");
|
|
},
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//// Callback functions from DownloadsData
|
|
|
|
/**
|
|
* Called before multiple downloads are about to be loaded.
|
|
*/
|
|
onDataLoadStarting() {
|
|
DownloadsCommon.log("onDataLoadStarting called for DownloadsView.");
|
|
this.loading = true;
|
|
},
|
|
|
|
/**
|
|
* Called after data loading finished.
|
|
*/
|
|
onDataLoadCompleted() {
|
|
DownloadsCommon.log("onDataLoadCompleted called for DownloadsView.");
|
|
|
|
this.loading = false;
|
|
|
|
// We suppressed item count change notifications during the batch load, at
|
|
// this point we should just call the function once.
|
|
this._itemCountChanged();
|
|
|
|
// Notify the panel that all the initially available downloads have been
|
|
// loaded. This ensures that the interface is visible, if still required.
|
|
DownloadsPanel.onViewLoadCompleted();
|
|
},
|
|
|
|
/**
|
|
* Called when a new download data item is available, either during the
|
|
* asynchronous data load or when a new download is started.
|
|
*
|
|
* @param aDownload
|
|
* Download object that was just added.
|
|
* @param aNewest
|
|
* When true, indicates that this item is the most recent and should be
|
|
* added in the topmost position. This happens when a new download is
|
|
* started. When false, indicates that the item is the least recent
|
|
* and should be appended. The latter generally happens during the
|
|
* asynchronous data load.
|
|
*/
|
|
onDownloadAdded(download, aNewest) {
|
|
DownloadsCommon.log("A new download data item was added - aNewest =",
|
|
aNewest);
|
|
|
|
if (aNewest) {
|
|
this._downloads.unshift(download);
|
|
} else {
|
|
this._downloads.push(download);
|
|
}
|
|
|
|
let itemsNowOverflow = this._downloads.length > this.kItemCountLimit;
|
|
if (aNewest || !itemsNowOverflow) {
|
|
// The newly added item is visible in the panel and we must add the
|
|
// corresponding element. This is either because it is the first item, or
|
|
// because it was added at the bottom but the list still doesn't overflow.
|
|
this._addViewItem(download, aNewest);
|
|
}
|
|
if (aNewest && itemsNowOverflow) {
|
|
// If the list overflows, remove the last item from the panel to make room
|
|
// for the new one that we just added at the top.
|
|
this._removeViewItem(this._downloads[this.kItemCountLimit]);
|
|
}
|
|
|
|
// For better performance during batch loads, don't update the count for
|
|
// every item, because the interface won't be visible until load finishes.
|
|
if (!this.loading) {
|
|
this._itemCountChanged();
|
|
}
|
|
},
|
|
|
|
onDownloadStateChanged(download) {
|
|
let viewItem = this._visibleViewItems.get(download);
|
|
if (viewItem) {
|
|
viewItem.onStateChanged();
|
|
}
|
|
},
|
|
|
|
onDownloadChanged(download) {
|
|
let viewItem = this._visibleViewItems.get(download);
|
|
if (viewItem) {
|
|
viewItem.onChanged();
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Called when a data item is removed. Ensures that the widget associated
|
|
* with the view item is removed from the user interface.
|
|
*
|
|
* @param download
|
|
* Download object that is being removed.
|
|
*/
|
|
onDownloadRemoved(download) {
|
|
DownloadsCommon.log("A download data item was removed.");
|
|
|
|
let itemIndex = this._downloads.indexOf(download);
|
|
this._downloads.splice(itemIndex, 1);
|
|
|
|
if (itemIndex < this.kItemCountLimit) {
|
|
// The item to remove is visible in the panel.
|
|
this._removeViewItem(download);
|
|
if (this._downloads.length >= this.kItemCountLimit) {
|
|
// Reinsert the next item into the panel.
|
|
this._addViewItem(this._downloads[this.kItemCountLimit - 1], false);
|
|
}
|
|
}
|
|
|
|
this._itemCountChanged();
|
|
|
|
// Adjust the panel height if we removed items.
|
|
DownloadsPanel.setHeightToFit();
|
|
},
|
|
|
|
/**
|
|
* Associates each richlistitem for a download with its corresponding
|
|
* DownloadsViewItem object.
|
|
*/
|
|
_itemsForElements: new Map(),
|
|
|
|
itemForElement(element) {
|
|
return this._itemsForElements.get(element);
|
|
},
|
|
|
|
/**
|
|
* Creates a new view item associated with the specified data item, and adds
|
|
* it to the top or the bottom of the list.
|
|
*/
|
|
_addViewItem(download, aNewest)
|
|
{
|
|
DownloadsCommon.log("Adding a new DownloadsViewItem to the downloads list.",
|
|
"aNewest =", aNewest);
|
|
|
|
let element = document.createElement("richlistitem");
|
|
let viewItem = new DownloadsViewItem(download, element);
|
|
this._visibleViewItems.set(download, viewItem);
|
|
this._itemsForElements.set(element, viewItem);
|
|
if (aNewest) {
|
|
this.richListBox.insertBefore(element, this.richListBox.firstChild);
|
|
} else {
|
|
this.richListBox.appendChild(element);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Removes the view item associated with the specified data item.
|
|
*/
|
|
_removeViewItem(download) {
|
|
DownloadsCommon.log("Removing a DownloadsViewItem from the downloads list.");
|
|
let element = this._visibleViewItems.get(download).element;
|
|
let previousSelectedIndex = this.richListBox.selectedIndex;
|
|
this.richListBox.removeChild(element);
|
|
if (previousSelectedIndex != -1) {
|
|
this.richListBox.selectedIndex = Math.min(previousSelectedIndex,
|
|
this.richListBox.itemCount - 1);
|
|
}
|
|
this._visibleViewItems.delete(download);
|
|
this._itemsForElements.delete(element);
|
|
},
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//// User interface event functions
|
|
|
|
/**
|
|
* Helper function to do commands on a specific download item.
|
|
*
|
|
* @param aEvent
|
|
* Event object for the event being handled. If the event target is
|
|
* not a richlistitem that represents a download, this function will
|
|
* walk up the parent nodes until it finds a DOM node that is.
|
|
* @param aCommand
|
|
* The command to be performed.
|
|
*/
|
|
onDownloadCommand(aEvent, aCommand) {
|
|
let target = aEvent.target;
|
|
while (target.nodeName != "richlistitem") {
|
|
target = target.parentNode;
|
|
}
|
|
DownloadsView.itemForElement(target).doCommand(aCommand);
|
|
},
|
|
|
|
onDownloadClick(aEvent) {
|
|
// Handle primary clicks only, and exclude the action button.
|
|
if (aEvent.button == 0 &&
|
|
!aEvent.originalTarget.hasAttribute("oncommand")) {
|
|
let target = aEvent.target;
|
|
while (target.nodeName != "richlistitem") {
|
|
target = target.parentNode;
|
|
}
|
|
let download = DownloadsView.itemForElement(target).download;
|
|
if (download.hasBlockedData) {
|
|
goDoCommand("downloadsCmd_showBlockedInfo");
|
|
} else {
|
|
goDoCommand("downloadsCmd_open");
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Handles keypress events on a download item.
|
|
*/
|
|
onDownloadKeyPress(aEvent) {
|
|
// Pressing the key on buttons should not invoke the action because the
|
|
// event has already been handled by the button itself.
|
|
if (aEvent.originalTarget.hasAttribute("command") ||
|
|
aEvent.originalTarget.hasAttribute("oncommand")) {
|
|
return;
|
|
}
|
|
|
|
if (aEvent.charCode == " ".charCodeAt(0)) {
|
|
goDoCommand("downloadsCmd_pauseResume");
|
|
return;
|
|
}
|
|
|
|
if (aEvent.keyCode == KeyEvent.DOM_VK_RETURN) {
|
|
goDoCommand("downloadsCmd_doDefault");
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Event handlers to keep track of context menu state (open/closed) for
|
|
* download items.
|
|
*/
|
|
onContextPopupShown(aEvent) {
|
|
// Ignore events raised by nested popups.
|
|
if (aEvent.target != aEvent.currentTarget) {
|
|
return;
|
|
}
|
|
|
|
DownloadsCommon.log("Context menu has shown.");
|
|
this.contextMenuOpen = true;
|
|
},
|
|
|
|
onContextPopupHidden(aEvent) {
|
|
// Ignore events raised by nested popups.
|
|
if (aEvent.target != aEvent.currentTarget) {
|
|
return;
|
|
}
|
|
|
|
DownloadsCommon.log("Context menu has hidden.");
|
|
this.contextMenuOpen = false;
|
|
},
|
|
|
|
/**
|
|
* Mouse listeners to handle selection on hover.
|
|
*/
|
|
onDownloadMouseOver(aEvent) {
|
|
if (!(this.contextMenuOpen || this.subViewOpen) &&
|
|
aEvent.target.parentNode == this.richListBox) {
|
|
this.richListBox.selectedItem = aEvent.target;
|
|
}
|
|
},
|
|
|
|
onDownloadMouseOut(aEvent) {
|
|
if (!(this.contextMenuOpen || this.subViewOpen) &&
|
|
aEvent.target.parentNode == this.richListBox) {
|
|
// If the destination element is outside of the richlistitem, clear the
|
|
// selection.
|
|
let element = aEvent.relatedTarget;
|
|
while (element && element != aEvent.target) {
|
|
element = element.parentNode;
|
|
}
|
|
if (!element) {
|
|
this.richListBox.selectedIndex = -1;
|
|
}
|
|
}
|
|
},
|
|
|
|
onDownloadContextMenu(aEvent) {
|
|
let element = this.richListBox.selectedItem;
|
|
if (!element) {
|
|
return;
|
|
}
|
|
|
|
DownloadsViewController.updateCommands();
|
|
|
|
// Set the state attribute so that only the appropriate items are displayed.
|
|
let contextMenu = document.getElementById("downloadsContextMenu");
|
|
contextMenu.setAttribute("state", element.getAttribute("state"));
|
|
contextMenu.classList.toggle("temporary-block",
|
|
element.classList.contains("temporary-block"));
|
|
},
|
|
|
|
onDownloadDragStart(aEvent) {
|
|
let element = this.richListBox.selectedItem;
|
|
if (!element) {
|
|
return;
|
|
}
|
|
|
|
// We must check for existence synchronously because this is a DOM event.
|
|
let file = new FileUtils.File(DownloadsView.itemForElement(element)
|
|
.download.target.path);
|
|
if (!file.exists()) {
|
|
return;
|
|
}
|
|
|
|
let dataTransfer = aEvent.dataTransfer;
|
|
dataTransfer.mozSetDataAt("application/x-moz-file", file, 0);
|
|
dataTransfer.effectAllowed = "copyMove";
|
|
let spec = NetUtil.newURI(file).spec;
|
|
dataTransfer.setData("text/uri-list", spec);
|
|
dataTransfer.setData("text/plain", spec);
|
|
dataTransfer.addElement(element);
|
|
|
|
aEvent.stopPropagation();
|
|
},
|
|
}
|
|
|
|
XPCOMUtils.defineConstant(this, "DownloadsView", DownloadsView);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
//// DownloadsViewItem
|
|
|
|
/**
|
|
* Builds and updates a single item in the downloads list widget, responding to
|
|
* changes in the download state and real-time data, and handles the user
|
|
* interaction events related to a single item in the downloads list widgets.
|
|
*
|
|
* @param download
|
|
* Download object to be associated with the view item.
|
|
* @param aElement
|
|
* XUL element corresponding to the single download item in the view.
|
|
*/
|
|
function DownloadsViewItem(download, aElement) {
|
|
this.download = download;
|
|
this.element = aElement;
|
|
this.element._shell = this;
|
|
|
|
this.element.setAttribute("type", "download");
|
|
this.element.classList.add("download-state");
|
|
|
|
this._updateState();
|
|
}
|
|
|
|
DownloadsViewItem.prototype = {
|
|
__proto__: DownloadsViewUI.DownloadElementShell.prototype,
|
|
|
|
/**
|
|
* The XUL element corresponding to the associated richlistbox item.
|
|
*/
|
|
_element: null,
|
|
|
|
onStateChanged() {
|
|
this._updateState();
|
|
},
|
|
|
|
onChanged() {
|
|
this._updateProgress();
|
|
},
|
|
|
|
isCommandEnabled(aCommand) {
|
|
switch (aCommand) {
|
|
case "downloadsCmd_open": {
|
|
if (!this.download.succeeded) {
|
|
return false;
|
|
}
|
|
|
|
let file = new FileUtils.File(this.download.target.path);
|
|
return file.exists();
|
|
}
|
|
case "downloadsCmd_show": {
|
|
let file = new FileUtils.File(this.download.target.path);
|
|
if (file.exists()) {
|
|
return true;
|
|
}
|
|
|
|
if (!this.download.target.partFilePath) {
|
|
return false;
|
|
}
|
|
|
|
let partFile = new FileUtils.File(this.download.target.partFilePath);
|
|
return partFile.exists();
|
|
}
|
|
case "cmd_delete":
|
|
case "downloadsCmd_cancel":
|
|
case "downloadsCmd_copyLocation":
|
|
case "downloadsCmd_doDefault":
|
|
return true;
|
|
case "downloadsCmd_showBlockedInfo":
|
|
return this.download.hasBlockedData;
|
|
}
|
|
return DownloadsViewUI.DownloadElementShell.prototype
|
|
.isCommandEnabled.call(this, aCommand);
|
|
},
|
|
|
|
doCommand(aCommand) {
|
|
if (this.isCommandEnabled(aCommand)) {
|
|
this[aCommand]();
|
|
}
|
|
},
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//// Item commands
|
|
|
|
cmd_delete() {
|
|
DownloadsCommon.removeAndFinalizeDownload(this.download);
|
|
PlacesUtils.bhistory.removePage(
|
|
NetUtil.newURI(this.download.source.url));
|
|
},
|
|
|
|
downloadsCmd_unblock() {
|
|
DownloadsPanel.hidePanel();
|
|
this.confirmUnblock(window, "unblock");
|
|
},
|
|
|
|
downloadsCmd_chooseUnblock() {
|
|
DownloadsPanel.hidePanel();
|
|
this.confirmUnblock(window, "chooseUnblock");
|
|
},
|
|
|
|
downloadsCmd_unblockAndOpen() {
|
|
DownloadsPanel.hidePanel();
|
|
this.unblockAndOpenDownload().catch(Cu.reportError);
|
|
},
|
|
|
|
downloadsCmd_open() {
|
|
this.download.launch().catch(Cu.reportError);
|
|
|
|
// We explicitly close the panel here to give the user the feedback that
|
|
// their click has been received, and we're handling the action.
|
|
// Otherwise, we'd have to wait for the file-type handler to execute
|
|
// before the panel would close. This also helps to prevent the user from
|
|
// accidentally opening a file several times.
|
|
DownloadsPanel.hidePanel();
|
|
},
|
|
|
|
downloadsCmd_show() {
|
|
let file = new FileUtils.File(this.download.target.path);
|
|
DownloadsCommon.showDownloadedFile(file);
|
|
|
|
// We explicitly close the panel here to give the user the feedback that
|
|
// their click has been received, and we're handling the action.
|
|
// Otherwise, we'd have to wait for the operating system file manager
|
|
// window to open before the panel closed. This also helps to prevent the
|
|
// user from opening the containing folder several times.
|
|
DownloadsPanel.hidePanel();
|
|
},
|
|
|
|
downloadsCmd_showBlockedInfo() {
|
|
DownloadsBlockedSubview.toggle(this.element,
|
|
...this.rawBlockedTitleAndDetails);
|
|
},
|
|
|
|
downloadsCmd_openReferrer() {
|
|
openURL(this.download.source.referrer);
|
|
},
|
|
|
|
downloadsCmd_copyLocation() {
|
|
let clipboard = Cc["@mozilla.org/widget/clipboardhelper;1"]
|
|
.getService(Ci.nsIClipboardHelper);
|
|
clipboard.copyString(this.download.source.url);
|
|
},
|
|
|
|
downloadsCmd_doDefault() {
|
|
let defaultCommand = this.currentDefaultCommandName;
|
|
if (defaultCommand && this.isCommandEnabled(defaultCommand)) {
|
|
this.doCommand(defaultCommand);
|
|
}
|
|
},
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
//// DownloadsViewController
|
|
|
|
/**
|
|
* Handles part of the user interaction events raised by the downloads list
|
|
* widget, in particular the "commands" that apply to multiple items, and
|
|
* dispatches the commands that apply to individual items.
|
|
*/
|
|
const DownloadsViewController = {
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//// Initialization and termination
|
|
|
|
initialize() {
|
|
window.controllers.insertControllerAt(0, this);
|
|
},
|
|
|
|
terminate() {
|
|
window.controllers.removeController(this);
|
|
},
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//// nsIController
|
|
|
|
supportsCommand(aCommand) {
|
|
if (aCommand === "downloadsCmd_clearList") {
|
|
return true;
|
|
}
|
|
// Firstly, determine if this is a command that we can handle.
|
|
if (!DownloadsViewUI.isCommandName(aCommand)) {
|
|
return false;
|
|
}
|
|
if (!(aCommand in this) &&
|
|
!(aCommand in DownloadsViewItem.prototype)) {
|
|
return false;
|
|
}
|
|
// The currently supported commands depend on whether the blocked subview is
|
|
// showing. If it is, then take the following path.
|
|
if (DownloadsBlockedSubview.view.showingSubView) {
|
|
let blockedSubviewCmds = [
|
|
"downloadsCmd_unblockAndOpen",
|
|
"cmd_delete",
|
|
];
|
|
return blockedSubviewCmds.indexOf(aCommand) >= 0;
|
|
}
|
|
// If the blocked subview is not showing, then determine if focus is on a
|
|
// control in the downloads list.
|
|
let element = document.commandDispatcher.focusedElement;
|
|
while (element && element != DownloadsView.richListBox) {
|
|
element = element.parentNode;
|
|
}
|
|
// We should handle the command only if the downloads list is among the
|
|
// ancestors of the focused element.
|
|
return !!element;
|
|
},
|
|
|
|
isCommandEnabled(aCommand) {
|
|
// Handle commands that are not selection-specific.
|
|
if (aCommand == "downloadsCmd_clearList") {
|
|
return DownloadsCommon.getData(window).canRemoveFinished;
|
|
}
|
|
|
|
// Other commands are selection-specific.
|
|
let element = DownloadsView.richListBox.selectedItem;
|
|
return element && DownloadsView.itemForElement(element)
|
|
.isCommandEnabled(aCommand);
|
|
},
|
|
|
|
doCommand(aCommand) {
|
|
// If this command is not selection-specific, execute it.
|
|
if (aCommand in this) {
|
|
this[aCommand]();
|
|
return;
|
|
}
|
|
|
|
// Other commands are selection-specific.
|
|
let element = DownloadsView.richListBox.selectedItem;
|
|
if (element) {
|
|
// The doCommand function also checks if the command is enabled.
|
|
DownloadsView.itemForElement(element).doCommand(aCommand);
|
|
}
|
|
},
|
|
|
|
onEvent() {},
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//// Other functions
|
|
|
|
updateCommands() {
|
|
function updateCommandsForObject(object) {
|
|
for (let name in object) {
|
|
if (DownloadsViewUI.isCommandName(name)) {
|
|
goUpdateCommand(name);
|
|
}
|
|
}
|
|
}
|
|
updateCommandsForObject(this);
|
|
updateCommandsForObject(DownloadsViewItem.prototype);
|
|
},
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//// Selection-independent commands
|
|
|
|
downloadsCmd_clearList() {
|
|
DownloadsCommon.getData(window).removeFinished();
|
|
},
|
|
};
|
|
|
|
XPCOMUtils.defineConstant(this, "DownloadsViewController", DownloadsViewController);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
//// DownloadsSummary
|
|
|
|
/**
|
|
* Manages the summary at the bottom of the downloads panel list if the number
|
|
* of items in the list exceeds the panels limit.
|
|
*/
|
|
const DownloadsSummary = {
|
|
|
|
/**
|
|
* Sets the active state of the summary. When active, the summary subscribes
|
|
* to the DownloadsCommon DownloadsSummaryData singleton.
|
|
*
|
|
* @param aActive
|
|
* Set to true to activate the summary.
|
|
*/
|
|
set active(aActive) {
|
|
if (aActive == this._active || !this._summaryNode) {
|
|
return this._active;
|
|
}
|
|
if (aActive) {
|
|
DownloadsCommon.getSummary(window, DownloadsView.kItemCountLimit)
|
|
.refreshView(this);
|
|
} else {
|
|
DownloadsFooter.showingSummary = false;
|
|
}
|
|
|
|
return this._active = aActive;
|
|
},
|
|
|
|
/**
|
|
* Returns the active state of the downloads summary.
|
|
*/
|
|
get active() {
|
|
return this._active;
|
|
},
|
|
|
|
_active: false,
|
|
|
|
/**
|
|
* Sets whether or not we show the progress bar.
|
|
*
|
|
* @param aShowingProgress
|
|
* True if we should show the progress bar.
|
|
*/
|
|
set showingProgress(aShowingProgress) {
|
|
if (aShowingProgress) {
|
|
this._summaryNode.setAttribute("inprogress", "true");
|
|
} else {
|
|
this._summaryNode.removeAttribute("inprogress");
|
|
}
|
|
// If progress isn't being shown, then we simply do not show the summary.
|
|
return DownloadsFooter.showingSummary = aShowingProgress;
|
|
},
|
|
|
|
/**
|
|
* Sets the amount of progress that is visible in the progress bar.
|
|
*
|
|
* @param aValue
|
|
* A value between 0 and 100 to represent the progress of the
|
|
* summarized downloads.
|
|
*/
|
|
set percentComplete(aValue) {
|
|
if (this._progressNode) {
|
|
this._progressNode.setAttribute("value", aValue);
|
|
}
|
|
return aValue;
|
|
},
|
|
|
|
/**
|
|
* Sets the description for the download summary.
|
|
*
|
|
* @param aValue
|
|
* A string representing the description of the summarized
|
|
* downloads.
|
|
*/
|
|
set description(aValue) {
|
|
if (this._descriptionNode) {
|
|
this._descriptionNode.setAttribute("value", aValue);
|
|
this._descriptionNode.setAttribute("tooltiptext", aValue);
|
|
}
|
|
return aValue;
|
|
},
|
|
|
|
/**
|
|
* Sets the details for the download summary, such as the time remaining,
|
|
* the amount of bytes transferred, etc.
|
|
*
|
|
* @param aValue
|
|
* A string representing the details of the summarized
|
|
* downloads.
|
|
*/
|
|
set details(aValue) {
|
|
if (this._detailsNode) {
|
|
this._detailsNode.setAttribute("value", aValue);
|
|
this._detailsNode.setAttribute("tooltiptext", aValue);
|
|
}
|
|
return aValue;
|
|
},
|
|
|
|
/**
|
|
* Focuses the root element of the summary.
|
|
*/
|
|
focus() {
|
|
if (this._summaryNode) {
|
|
this._summaryNode.focus();
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Respond to keydown events on the Downloads Summary node.
|
|
*
|
|
* @param aEvent
|
|
* The keydown event being handled.
|
|
*/
|
|
onKeyDown(aEvent) {
|
|
if (aEvent.charCode == " ".charCodeAt(0) ||
|
|
aEvent.keyCode == KeyEvent.DOM_VK_RETURN) {
|
|
DownloadsPanel.showDownloadsHistory();
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Respond to click events on the Downloads Summary node.
|
|
*
|
|
* @param aEvent
|
|
* The click event being handled.
|
|
*/
|
|
onClick(aEvent) {
|
|
DownloadsPanel.showDownloadsHistory();
|
|
},
|
|
|
|
/**
|
|
* Element corresponding to the root of the downloads summary.
|
|
*/
|
|
get _summaryNode() {
|
|
let node = document.getElementById("downloadsSummary");
|
|
if (!node) {
|
|
return null;
|
|
}
|
|
delete this._summaryNode;
|
|
return this._summaryNode = node;
|
|
},
|
|
|
|
/**
|
|
* Element corresponding to the progress bar in the downloads summary.
|
|
*/
|
|
get _progressNode() {
|
|
let node = document.getElementById("downloadsSummaryProgress");
|
|
if (!node) {
|
|
return null;
|
|
}
|
|
delete this._progressNode;
|
|
return this._progressNode = node;
|
|
},
|
|
|
|
/**
|
|
* Element corresponding to the main description of the downloads
|
|
* summary.
|
|
*/
|
|
get _descriptionNode() {
|
|
let node = document.getElementById("downloadsSummaryDescription");
|
|
if (!node) {
|
|
return null;
|
|
}
|
|
delete this._descriptionNode;
|
|
return this._descriptionNode = node;
|
|
},
|
|
|
|
/**
|
|
* Element corresponding to the secondary description of the downloads
|
|
* summary.
|
|
*/
|
|
get _detailsNode() {
|
|
let node = document.getElementById("downloadsSummaryDetails");
|
|
if (!node) {
|
|
return null;
|
|
}
|
|
delete this._detailsNode;
|
|
return this._detailsNode = node;
|
|
}
|
|
};
|
|
|
|
XPCOMUtils.defineConstant(this, "DownloadsSummary", DownloadsSummary);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
//// DownloadsFooter
|
|
|
|
/**
|
|
* Manages events sent to to the footer vbox, which contains both the
|
|
* DownloadsSummary as well as the "Show All Downloads" button.
|
|
*/
|
|
const DownloadsFooter = {
|
|
|
|
/**
|
|
* Focuses the appropriate element within the footer. If the summary
|
|
* is visible, focus it. If not, focus the "Show All Downloads"
|
|
* button.
|
|
*/
|
|
focus() {
|
|
if (this._showingSummary) {
|
|
DownloadsSummary.focus();
|
|
} else {
|
|
DownloadsView.downloadsHistory.focus();
|
|
}
|
|
},
|
|
|
|
_showingSummary: false,
|
|
|
|
/**
|
|
* Sets whether or not the Downloads Summary should be displayed in the
|
|
* footer. If not, the "Show All Downloads" button is shown instead.
|
|
*/
|
|
set showingSummary(aValue) {
|
|
if (this._footerNode) {
|
|
if (aValue) {
|
|
this._footerNode.setAttribute("showingsummary", "true");
|
|
} else {
|
|
this._footerNode.removeAttribute("showingsummary");
|
|
}
|
|
if (!aValue && this._showingSummary) {
|
|
// Make sure the panel's height shrinks when the summary is hidden.
|
|
DownloadsPanel.setHeightToFit();
|
|
}
|
|
this._showingSummary = aValue;
|
|
}
|
|
return aValue;
|
|
},
|
|
|
|
/**
|
|
* Element corresponding to the footer of the downloads panel.
|
|
*/
|
|
get _footerNode() {
|
|
let node = document.getElementById("downloadsFooter");
|
|
if (!node) {
|
|
return null;
|
|
}
|
|
delete this._footerNode;
|
|
return this._footerNode = node;
|
|
}
|
|
};
|
|
|
|
XPCOMUtils.defineConstant(this, "DownloadsFooter", DownloadsFooter);
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
//// DownloadsBlockedSubview
|
|
|
|
/**
|
|
* Manages the blocked subview that slides in when you click a blocked download.
|
|
*/
|
|
const DownloadsBlockedSubview = {
|
|
|
|
get subview() {
|
|
let subview = document.getElementById("downloadsPanel-blockedSubview");
|
|
delete this.subview;
|
|
return this.subview = subview;
|
|
},
|
|
|
|
/**
|
|
* Elements in the subview.
|
|
*/
|
|
get elements() {
|
|
let idSuffixes = [
|
|
"title",
|
|
"details1",
|
|
"details2",
|
|
"openButton",
|
|
"deleteButton",
|
|
];
|
|
let elements = idSuffixes.reduce((memo, s) => {
|
|
memo[s] = document.getElementById("downloadsPanel-blockedSubview-" + s);
|
|
return memo;
|
|
}, {});
|
|
delete this.elements;
|
|
return this.elements = elements;
|
|
},
|
|
|
|
/**
|
|
* The multiview that contains both the main view and the subview.
|
|
*/
|
|
get view() {
|
|
let view = document.getElementById("downloadsPanel-multiView");
|
|
delete this.view;
|
|
return this.view = view;
|
|
},
|
|
|
|
/**
|
|
* The blocked-download richlistitem element that was clicked to show the
|
|
* subview. If the subview is not showing, this is undefined.
|
|
*/
|
|
element: undefined,
|
|
|
|
/**
|
|
* Slides in the blocked subview.
|
|
*
|
|
* @param element
|
|
* The blocked-download richlistitem element that was clicked.
|
|
* @param title
|
|
* The title to show in the subview.
|
|
* @param details
|
|
* An array of strings with information about the block.
|
|
*/
|
|
toggle(element, title, details) {
|
|
if (this.view.showingSubView) {
|
|
this.hide();
|
|
return;
|
|
}
|
|
|
|
this.element = element;
|
|
element.setAttribute("showingsubview", "true");
|
|
DownloadsView.subViewOpen = true;
|
|
DownloadsViewController.updateCommands();
|
|
|
|
let e = this.elements;
|
|
let s = DownloadsCommon.strings;
|
|
e.title.textContent = title;
|
|
e.details1.textContent = details[0];
|
|
e.details2.textContent = details[1];
|
|
e.openButton.label = s.unblockButtonOpen;
|
|
e.deleteButton.label = s.unblockButtonConfirmBlock;
|
|
|
|
let verdict = element.getAttribute("verdict");
|
|
this.subview.setAttribute("verdict", verdict);
|
|
this.subview.addEventListener("ViewHiding", this);
|
|
|
|
this.view.showSubView(this.subview.id);
|
|
|
|
// Without this, the mainView is more narrow than the panel once all
|
|
// downloads are removed from the panel.
|
|
document.getElementById("downloadsPanel-mainView").style.minWidth =
|
|
window.getComputedStyle(this.view).width;
|
|
},
|
|
|
|
handleEvent(event) {
|
|
switch (event.type) {
|
|
case "ViewHiding":
|
|
this.subview.removeEventListener(event.type, this);
|
|
this.element.removeAttribute("showingsubview");
|
|
DownloadsView.subViewOpen = false;
|
|
delete this.element;
|
|
break;
|
|
default:
|
|
DownloadsCommon.log("Unhandled DownloadsBlockedSubview event: " +
|
|
event.type);
|
|
break;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Slides out the blocked subview and shows the main view.
|
|
*/
|
|
hide() {
|
|
this.view.showMainView();
|
|
// The point of this is to focus the proper element in the panel now that
|
|
// the main view is showing again. showPanel handles that.
|
|
DownloadsPanel.showPanel();
|
|
},
|
|
|
|
/**
|
|
* Deletes the download and hides the entire panel.
|
|
*/
|
|
confirmBlock() {
|
|
goDoCommand("cmd_delete");
|
|
DownloadsPanel.hidePanel();
|
|
},
|
|
};
|
|
|
|
XPCOMUtils.defineConstant(this, "DownloadsBlockedSubview",
|
|
DownloadsBlockedSubview);
|