mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
474 lines
16 KiB
JavaScript
474 lines
16 KiB
JavaScript
/* 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/. */
|
|
|
|
let Ci = Components.interfaces, Cc = Components.classes, Cu = Components.utils;
|
|
|
|
Cu.import("resource://gre/modules/Services.jsm");
|
|
Cu.import("resource://gre/modules/DownloadUtils.jsm");
|
|
Cu.import("resource://gre/modules/XPCOMUtils.jsm");
|
|
|
|
let gStrings = Services.strings.createBundle("chrome://browser/locale/aboutDownloads.properties");
|
|
|
|
let downloadTemplate =
|
|
"<li downloadID='{id}' role='button' state='{state}'>" +
|
|
"<img class='icon' src='{icon}'/>" +
|
|
"<div class='details'>" +
|
|
"<div class='row'>" +
|
|
// This is a hack so that we can crop this label in its center
|
|
"<xul:label class='title' crop='center' value='{target}'/>" +
|
|
"<div class='date'>{date}</div>" +
|
|
"</div>" +
|
|
"<div class='size'>{size}</div>" +
|
|
"<div class='domain'>{domain}</div>" +
|
|
"<div class='displayState'>{displayState}</div>" +
|
|
"</div>" +
|
|
"</li>";
|
|
|
|
XPCOMUtils.defineLazyGetter(window, "gChromeWin", function ()
|
|
window.QueryInterface(Ci.nsIInterfaceRequestor)
|
|
.getInterface(Ci.nsIWebNavigation)
|
|
.QueryInterface(Ci.nsIDocShellTreeItem)
|
|
.rootTreeItem
|
|
.QueryInterface(Ci.nsIInterfaceRequestor)
|
|
.getInterface(Ci.nsIDOMWindow)
|
|
.QueryInterface(Ci.nsIDOMChromeWindow));
|
|
|
|
let Downloads = {
|
|
init: function () {
|
|
this._list = document.getElementById("downloads-list");
|
|
this._list.addEventListener("click", function (event) {
|
|
let target = event.target;
|
|
while (target && target.nodeName != "li") {
|
|
target = target.parentNode;
|
|
}
|
|
|
|
Downloads.openDownload(target);
|
|
}, false);
|
|
|
|
Services.obs.addObserver(this, "dl-start", false);
|
|
Services.obs.addObserver(this, "dl-failed", false);
|
|
Services.obs.addObserver(this, "dl-scanning", false);
|
|
Services.obs.addObserver(this, "dl-done", false);
|
|
Services.obs.addObserver(this, "dl-blocked", false);
|
|
Services.obs.addObserver(this, "dl-dirty", false);
|
|
Services.obs.addObserver(this, "dl-cancel", false);
|
|
|
|
this.getDownloads();
|
|
|
|
let contextmenus = gChromeWin.NativeWindow.contextmenus;
|
|
|
|
// Open shown only for downloads that completed successfully
|
|
Downloads.openMenuItem = contextmenus.add(gStrings.GetStringFromName("downloadAction.open"),
|
|
contextmenus.SelectorContext("li[state='" + this._dlmgr.DOWNLOAD_FINISHED + "']"),
|
|
function (aTarget) {
|
|
Downloads.openDownload(aTarget);
|
|
}
|
|
);
|
|
|
|
// Retry shown when its failed, canceled, blocked(covered in failed, see _getState())
|
|
Downloads.retryMenuItem = contextmenus.add(gStrings.GetStringFromName("downloadAction.retry"),
|
|
contextmenus.SelectorContext("li[state='" + this._dlmgr.DOWNLOAD_FAILED + "']," +
|
|
"li[state='" + this._dlmgr.DOWNLOAD_CANCELED + "']"),
|
|
function (aTarget) {
|
|
Downloads.retryDownload(aTarget);
|
|
}
|
|
);
|
|
|
|
// Remove shown when its canceled, finished, failed(failed includes blocked and dirty, see _getState())
|
|
Downloads.removeMenuItem = contextmenus.add(gStrings.GetStringFromName("downloadAction.remove"),
|
|
contextmenus.SelectorContext("li[state='" + this._dlmgr.DOWNLOAD_CANCELED + "']," +
|
|
"li[state='" + this._dlmgr.DOWNLOAD_FINISHED + "']," +
|
|
"li[state='" + this._dlmgr.DOWNLOAD_FAILED + "']"),
|
|
function (aTarget) {
|
|
Downloads.removeDownload(aTarget);
|
|
}
|
|
);
|
|
|
|
// Pause shown when item is currently downloading
|
|
Downloads.pauseMenuItem = contextmenus.add(gStrings.GetStringFromName("downloadAction.pause"),
|
|
contextmenus.SelectorContext("li[state='" + this._dlmgr.DOWNLOAD_DOWNLOADING + "']"),
|
|
function (aTarget) {
|
|
Downloads.pauseDownload(aTarget);
|
|
}
|
|
);
|
|
|
|
// Resume shown for paused items only
|
|
Downloads.resumeMenuItem = contextmenus.add(gStrings.GetStringFromName("downloadAction.resume"),
|
|
contextmenus.SelectorContext("li[state='" + this._dlmgr.DOWNLOAD_PAUSED + "']"),
|
|
function (aTarget) {
|
|
Downloads.resumeDownload(aTarget);
|
|
}
|
|
);
|
|
|
|
// Cancel shown when its downloading, notstarted, queued or paused
|
|
Downloads.cancelMenuItem = contextmenus.add(gStrings.GetStringFromName("downloadAction.cancel"),
|
|
contextmenus.SelectorContext("li[state='" + this._dlmgr.DOWNLOAD_DOWNLOADING + "']," +
|
|
"li[state='" + this._dlmgr.DOWNLOAD_NOTSTARTED + "']," +
|
|
"li[state='" + this._dlmgr.DOWNLOAD_QUEUED + "']," +
|
|
"li[state='" + this._dlmgr.DOWNLOAD_PAUSED + "']"),
|
|
function (aTarget) {
|
|
Downloads.cancelDownload(aTarget);
|
|
}
|
|
);
|
|
},
|
|
|
|
uninit: function () {
|
|
let contextmenus = gChromeWin.NativeWindow.contextmenus;
|
|
contextmenus.remove(this.openMenuItem);
|
|
contextmenus.remove(this.removeMenuItem);
|
|
contextmenus.remove(this.pauseMenuItem);
|
|
contextmenus.remove(this.resumeMenuItem);
|
|
contextmenus.remove(this.retryMenuItem);
|
|
contextmenus.remove(this.cancelMenuItem);
|
|
|
|
Services.obs.removeObserver(this, "dl-start");
|
|
Services.obs.removeObserver(this, "dl-failed");
|
|
Services.obs.removeObserver(this, "dl-scanning");
|
|
Services.obs.removeObserver(this, "dl-done");
|
|
Services.obs.removeObserver(this, "dl-blocked");
|
|
Services.obs.removeObserver(this, "dl-dirty");
|
|
Services.obs.removeObserver(this, "dl-cancel");
|
|
},
|
|
|
|
observe: function (aSubject, aTopic, aData) {
|
|
let download = aSubject.QueryInterface(Ci.nsIDownload);
|
|
switch (aTopic) {
|
|
case "dl-blocked":
|
|
case "dl-dirty":
|
|
case "dl-cancel":
|
|
case "dl-done":
|
|
case "dl-failed":
|
|
// For all "completed" states, move them after active downloads
|
|
this._moveDownloadAfterActive(this._getElementForDownload(download.id));
|
|
|
|
// Fall-through the rest
|
|
case "dl-start":
|
|
case "dl-scanning":
|
|
let item = this._getElementForDownload(download.id);
|
|
if (item)
|
|
this._updateDownloadRow(item);
|
|
else
|
|
this._insertDownloadRow(download);
|
|
break;
|
|
}
|
|
},
|
|
|
|
_moveDownloadAfterActive: function (aItem) {
|
|
// Move downloads that just reached a "completed" state below any active
|
|
try {
|
|
// Iterate down until we find a non-active download
|
|
let next = aItem.nextSibling;
|
|
while (next && this._inProgress(next.getAttribute("state")))
|
|
next = next.nextSibling;
|
|
// Move the item
|
|
this._list.insertBefore(aItem, next);
|
|
} catch (ex) {
|
|
console.log("ERROR: _moveDownloadAfterActive() : " + ex);
|
|
}
|
|
},
|
|
|
|
_inProgress: function (aState) {
|
|
return [
|
|
this._dlmgr.DOWNLOAD_NOTSTARTED,
|
|
this._dlmgr.DOWNLOAD_QUEUED,
|
|
this._dlmgr.DOWNLOAD_DOWNLOADING,
|
|
this._dlmgr.DOWNLOAD_PAUSED,
|
|
this._dlmgr.DOWNLOAD_SCANNING,
|
|
].indexOf(parseInt(aState)) != -1;
|
|
},
|
|
|
|
_insertDownloadRow: function (aDownload) {
|
|
let updatedState = this._getState(aDownload.state);
|
|
let item = this._createItem(downloadTemplate, {
|
|
id: aDownload.id,
|
|
target: aDownload.displayName,
|
|
icon: "moz-icon://" + aDownload.displayName + "?size=64",
|
|
date: DownloadUtils.getReadableDates(new Date())[0],
|
|
domain: DownloadUtils.getURIHost(aDownload.source.spec)[0],
|
|
size: this._getDownloadSize(aDownload.size),
|
|
displayState: this._getStateString(updatedState),
|
|
state: updatedState
|
|
});
|
|
this._list.insertAdjacentHTML("afterbegin", item);
|
|
},
|
|
|
|
_getDownloadSize: function (aSize) {
|
|
let displaySize = DownloadUtils.convertByteUnits(aSize);
|
|
if (displaySize[0] > 0) // [0] is size, [1] is units
|
|
return displaySize.join("");
|
|
else
|
|
return gStrings.GetStringFromName("downloadState.unknownSize");
|
|
},
|
|
|
|
// Not all states are displayed as-is on mobile, some are translated to a generic state
|
|
_getState: function (aState) {
|
|
let str;
|
|
switch (aState) {
|
|
// Downloading and Scanning states show up as "Downloading"
|
|
case this._dlmgr.DOWNLOAD_DOWNLOADING:
|
|
case this._dlmgr.DOWNLOAD_SCANNING:
|
|
str = this._dlmgr.DOWNLOAD_DOWNLOADING;
|
|
break;
|
|
|
|
// Failed, Dirty and Blocked states show up as "Failed"
|
|
case this._dlmgr.DOWNLOAD_FAILED:
|
|
case this._dlmgr.DOWNLOAD_DIRTY:
|
|
case this._dlmgr.DOWNLOAD_BLOCKED_POLICY:
|
|
case this._dlmgr.DOWNLOAD_BLOCKED_PARENTAL:
|
|
str = this._dlmgr.DOWNLOAD_FAILED;
|
|
break;
|
|
|
|
/* QUEUED and NOTSTARTED are not translated as they
|
|
dont fall under a common state but we still need
|
|
to display a common "status" on the UI */
|
|
|
|
default:
|
|
str = aState;
|
|
}
|
|
return str;
|
|
},
|
|
|
|
// Note: This doesn't cover all states as some of the states are translated in _getState()
|
|
_getStateString: function (aState) {
|
|
let str;
|
|
switch (aState) {
|
|
case this._dlmgr.DOWNLOAD_DOWNLOADING:
|
|
str = "downloadState.downloading";
|
|
break;
|
|
case this._dlmgr.DOWNLOAD_CANCELED:
|
|
str = "downloadState.canceled";
|
|
break;
|
|
case this._dlmgr.DOWNLOAD_FAILED:
|
|
str = "downloadState.failed";
|
|
break;
|
|
case this._dlmgr.DOWNLOAD_PAUSED:
|
|
str = "downloadState.paused";
|
|
break;
|
|
|
|
// Queued and Notstarted show up as "Starting..."
|
|
case this._dlmgr.DOWNLOAD_QUEUED:
|
|
case this._dlmgr.DOWNLOAD_NOTSTARTED:
|
|
str = "downloadState.starting";
|
|
break;
|
|
|
|
default:
|
|
return "";
|
|
}
|
|
return gStrings.GetStringFromName(str);
|
|
},
|
|
|
|
_updateItem: function (aItem, aValues) {
|
|
for (let i in aValues) {
|
|
aItem.querySelector("." + i).textContent = aValues[i];
|
|
}
|
|
},
|
|
|
|
_initStatement: function dv__initStatement() {
|
|
if (this._stmt)
|
|
this._stmt.finalize();
|
|
|
|
this._stmt = this._dlmgr.DBConnection.createStatement(
|
|
"SELECT id, name, source, state, startTime, endTime, referrer, " +
|
|
"currBytes, maxBytes, state IN (?1, ?2, ?3, ?4, ?5) isActive " +
|
|
"FROM moz_downloads " +
|
|
"ORDER BY isActive DESC, endTime DESC, startTime DESC");
|
|
},
|
|
|
|
_createItem: function _createItem(aTemplate, aValues) {
|
|
function htmlEscape(s) {
|
|
s = s.replace(/&/g, "&");
|
|
s = s.replace(/>/g, ">");
|
|
s = s.replace(/</g, "<");
|
|
s = s.replace(/"/g, """);
|
|
s = s.replace(/'/g, "'");
|
|
return s;
|
|
}
|
|
|
|
let t = aTemplate;
|
|
for (let key in aValues) {
|
|
if (aValues.hasOwnProperty(key)) {
|
|
let regEx = new RegExp("{" + key + "}", "g");
|
|
let value = htmlEscape(aValues[key].toString());
|
|
t = t.replace(regEx, value);
|
|
}
|
|
}
|
|
return t;
|
|
},
|
|
|
|
_stepDownloads: function dv__stepDownloads(aNumItems) {
|
|
try {
|
|
if (!this._stmt.executeStep()) {
|
|
this._stmt.finalize();
|
|
this._stmt = null;
|
|
return;
|
|
}
|
|
|
|
let updatedState = this._getState(this._stmt.row.state);
|
|
// Try to get the attribute values from the statement
|
|
let attrs = {
|
|
id: this._stmt.row.id,
|
|
target: this._stmt.row.name,
|
|
icon: "moz-icon://" + this._stmt.row.name + "?size=64",
|
|
date: DownloadUtils.getReadableDates(new Date(this._stmt.row.endTime / 1000))[0],
|
|
domain: DownloadUtils.getURIHost(this._stmt.row.source)[0],
|
|
size: this._getDownloadSize(this._stmt.row.maxBytes),
|
|
displayState: this._getStateString(updatedState),
|
|
state: updatedState
|
|
};
|
|
|
|
let item = this._createItem(downloadTemplate, attrs);
|
|
this._list.insertAdjacentHTML("beforeend", item);
|
|
} catch (e) {
|
|
// Something went wrong when stepping or getting values, so clear and quit
|
|
console.log("Error: " + e);
|
|
this._stmt.reset();
|
|
return;
|
|
}
|
|
|
|
// Add another item to the list if we should; otherwise, let the UI update
|
|
// and continue later
|
|
if (aNumItems > 1) {
|
|
this._stepDownloads(aNumItems - 1);
|
|
} else {
|
|
// Use a shorter delay for earlier downloads to display them faster
|
|
let delay = Math.min(this._list.itemCount * 10, 300);
|
|
let self = this;
|
|
this._timeoutID = setTimeout(function () { self._stepDownloads(5); }, delay);
|
|
}
|
|
},
|
|
|
|
getDownloads: function () {
|
|
this._dlmgr = Cc["@mozilla.org/download-manager;1"].getService(Ci.nsIDownloadManager);
|
|
|
|
this._initStatement();
|
|
|
|
clearTimeout(this._timeoutID);
|
|
|
|
this._stmt.reset();
|
|
this._stmt.bindInt32Parameter(0, Ci.nsIDownloadManager.DOWNLOAD_NOTSTARTED);
|
|
this._stmt.bindInt32Parameter(1, Ci.nsIDownloadManager.DOWNLOAD_DOWNLOADING);
|
|
this._stmt.bindInt32Parameter(2, Ci.nsIDownloadManager.DOWNLOAD_PAUSED);
|
|
this._stmt.bindInt32Parameter(3, Ci.nsIDownloadManager.DOWNLOAD_QUEUED);
|
|
this._stmt.bindInt32Parameter(4, Ci.nsIDownloadManager.DOWNLOAD_SCANNING);
|
|
|
|
// Take a quick break before we actually start building the list
|
|
let self = this;
|
|
this._timeoutID = setTimeout(function () {
|
|
self._stepDownloads(1);
|
|
}, 0);
|
|
},
|
|
|
|
_getElementForDownload: function (aKey) {
|
|
return this._list.querySelector("li[downloadID='" + aKey + "']");
|
|
},
|
|
|
|
_getDownloadForElement: function (aElement) {
|
|
let id = parseInt(aElement.getAttribute("downloadID"));
|
|
return this._dlmgr.getDownload(id);
|
|
},
|
|
|
|
_removeItem: function dv__removeItem(aItem) {
|
|
// Make sure we have an item to remove
|
|
if (!aItem)
|
|
return;
|
|
|
|
let index = this._list.selectedIndex;
|
|
this._list.removeChild(aItem);
|
|
this._list.selectedIndex = Math.min(index, this._list.itemCount - 1);
|
|
},
|
|
|
|
openDownload: function (aItem) {
|
|
let f = null;
|
|
try {
|
|
let download = this._getDownloadForElement(aItem);
|
|
f = download.targetFile;
|
|
} catch(ex) { }
|
|
|
|
try {
|
|
if (f) f.launch();
|
|
} catch (ex) { }
|
|
},
|
|
|
|
removeDownload: function (aItem) {
|
|
let f = null;
|
|
try {
|
|
let download = this._getDownloadForElement(aItem);
|
|
f = download.targetFile;
|
|
} catch(ex) {
|
|
// even if there is no file, pretend that there is so that we can remove
|
|
// it from the list
|
|
f = { leafName: "" };
|
|
}
|
|
|
|
this._dlmgr.removeDownload(aItem.getAttribute("downloadID"));
|
|
|
|
this._list.removeChild(aItem);
|
|
|
|
try {
|
|
if (f) f.remove(false);
|
|
} catch(ex) { }
|
|
},
|
|
|
|
pauseDownload: function (aItem) {
|
|
try {
|
|
let download = this._getDownloadForElement(aItem);
|
|
this._dlmgr.pauseDownload(aItem.getAttribute("downloadID"));
|
|
this._updateDownloadRow(aItem);
|
|
} catch (ex) {
|
|
console.log("Error: pauseDownload() " + ex);
|
|
}
|
|
|
|
},
|
|
|
|
resumeDownload: function (aItem) {
|
|
try {
|
|
let download = this._getDownloadForElement(aItem);
|
|
this._dlmgr.resumeDownload(aItem.getAttribute("downloadID"));
|
|
this._updateDownloadRow(aItem);
|
|
} catch (ex) {
|
|
console.log("Error: resumeDownload() " + ex);
|
|
}
|
|
},
|
|
|
|
retryDownload: function (aItem) {
|
|
try {
|
|
let download = this._getDownloadForElement(aItem);
|
|
this._removeItem(aItem);
|
|
this._dlmgr.retryDownload(aItem.getAttribute("downloadID"));
|
|
} catch (ex) {
|
|
console.log("Error: retryDownload() " + ex);
|
|
}
|
|
},
|
|
|
|
cancelDownload: function (aItem) {
|
|
try {
|
|
this._dlmgr.cancelDownload(aItem.getAttribute("downloadID"));
|
|
let download = this._getDownloadForElement(aItem);
|
|
let f = download.targetFile;
|
|
|
|
if (f.exists())
|
|
f.remove(false);
|
|
|
|
this._updateDownloadRow(aItem);
|
|
} catch (ex) {
|
|
console.log("Error: cancelDownload() " + ex);
|
|
}
|
|
},
|
|
|
|
_updateDownloadRow: function (aItem){
|
|
try {
|
|
let download = this._getDownloadForElement(aItem);
|
|
let updatedState = this._getState(download.state);
|
|
aItem.setAttribute("state", updatedState);
|
|
this._updateItem(aItem, {
|
|
size: this._getDownloadSize(download.size),
|
|
displayState: this._getStateString(updatedState),
|
|
date: DownloadUtils.getReadableDates(new Date())[0]
|
|
});
|
|
} catch (ex){
|
|
console.log("ERROR: _updateDownloadRow(): " + ex);
|
|
}
|
|
}
|
|
}
|