1964 lines
52 KiB
JavaScript
1964 lines
52 KiB
JavaScript
/**
|
|
* Copyright © Charles Kerr, Dave Perrett, Malcolm Jarvis and Bruno Bierbaumer
|
|
*
|
|
* This file is licensed under the GPLv2.
|
|
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
|
|
*/
|
|
|
|
function Transmission() {
|
|
this.initialize();
|
|
}
|
|
|
|
Transmission.prototype = {
|
|
/****
|
|
*****
|
|
***** STARTUP
|
|
*****
|
|
****/
|
|
|
|
initialize: function () {
|
|
let e;
|
|
|
|
// Initialize the helper classes
|
|
this.remote = new TransmissionRemote(this);
|
|
this.inspector = new Inspector(this);
|
|
this.prefsDialog = new PrefsDialog(this.remote);
|
|
$(this.prefsDialog).bind('closed', $.proxy(this.onPrefsDialogClosed, this));
|
|
|
|
this.isMenuEnabled = !isMobileDevice;
|
|
|
|
// Initialize the implementation fields
|
|
this.filterText = '';
|
|
this._torrents = {};
|
|
this._rows = [];
|
|
this.dirtyTorrents = {};
|
|
this.uriCache = {};
|
|
|
|
// Initialize the clutch preferences
|
|
Prefs.getClutchPrefs(this);
|
|
|
|
// Set up user events
|
|
$('#toolbar-pause').click($.proxy(this.stopSelectedClicked, this));
|
|
$('#toolbar-start').click($.proxy(this.startSelectedClicked, this));
|
|
$('#toolbar-pause-all').click($.proxy(this.stopAllClicked, this));
|
|
$('#toolbar-start-all').click($.proxy(this.startAllClicked, this));
|
|
$('#toolbar-remove').click($.proxy(this.removeClicked, this));
|
|
$('#toolbar-open').click($.proxy(this.openTorrentClicked, this));
|
|
|
|
$('#prefs-button').click($.proxy(this.togglePrefsDialogClicked, this));
|
|
|
|
$('#upload_confirm_button').click($.proxy(this.confirmUploadClicked, this));
|
|
$('#upload_cancel_button').click($.proxy(this.hideUploadDialog, this));
|
|
|
|
$('#rename_confirm_button').click($.proxy(this.confirmRenameClicked, this));
|
|
$('#rename_cancel_button').click($.proxy(this.hideRenameDialog, this));
|
|
|
|
$('#move_confirm_button').click($.proxy(this.confirmMoveClicked, this));
|
|
$('#move_cancel_button').click($.proxy(this.hideMoveDialog, this));
|
|
|
|
$('#turtle-button').click($.proxy(this.toggleTurtleClicked, this));
|
|
$('#compact-button').click($.proxy(this.toggleCompactClicked, this));
|
|
|
|
// tell jQuery to copy the dataTransfer property from events over if it exists
|
|
jQuery.event.props.push('dataTransfer');
|
|
|
|
$('#torrent_upload_form').submit(function () {
|
|
$('#upload_confirm_button').click();
|
|
return false;
|
|
});
|
|
|
|
$('#toolbar-inspector').click($.proxy(this.toggleInspector, this));
|
|
|
|
e = $('#filter-mode');
|
|
e.val(this[Prefs._FilterMode]);
|
|
e.change($.proxy(this.onFilterModeClicked, this));
|
|
$('#filter-tracker').change($.proxy(this.onFilterTrackerClicked, this));
|
|
|
|
if (!isMobileDevice) {
|
|
$(document).bind('keydown', $.proxy(this.keyDown, this));
|
|
$(document).bind('keyup', $.proxy(this.keyUp, this));
|
|
$('#torrent_container').click($.proxy(this.deselectAll, this));
|
|
$('#torrent_container').bind('dragover', $.proxy(this.dragenter, this));
|
|
$('#torrent_container').bind('dragenter', $.proxy(this.dragenter, this));
|
|
$('#torrent_container').bind('drop', $.proxy(this.drop, this));
|
|
$('#inspector_link').click($.proxy(this.toggleInspector, this));
|
|
|
|
this.setupSearchBox();
|
|
this.createContextMenu();
|
|
}
|
|
|
|
if (this.isMenuEnabled) {
|
|
this.createSettingsMenu();
|
|
}
|
|
|
|
e = {};
|
|
e.torrent_list = $('#torrent_list')[0];
|
|
e.toolbar_buttons = $('#toolbar ul li');
|
|
e.toolbar_pause_button = $('#toolbar-pause')[0];
|
|
e.toolbar_start_button = $('#toolbar-start')[0];
|
|
e.toolbar_remove_button = $('#toolbar-remove')[0];
|
|
this.elements = e;
|
|
|
|
// Apply the prefs settings to the gui
|
|
this.initializeSettings();
|
|
|
|
// Get preferences & torrents from the daemon
|
|
const async = false;
|
|
this.loadDaemonPrefs(async);
|
|
this.loadDaemonStats(async);
|
|
this.initializeTorrents();
|
|
this.refreshTorrents();
|
|
this.togglePeriodicSessionRefresh(true);
|
|
|
|
this.updateButtonsSoon();
|
|
},
|
|
|
|
loadDaemonPrefs: function (async, callback) {
|
|
this.remote.loadDaemonPrefs(
|
|
function (data) {
|
|
const o = data['arguments'];
|
|
Prefs.getClutchPrefs(o);
|
|
this.updateGuiFromSession(o);
|
|
this.sessionProperties = o;
|
|
|
|
if (callback) {
|
|
callback();
|
|
}
|
|
},
|
|
this,
|
|
async
|
|
);
|
|
},
|
|
|
|
loadImages: function () {
|
|
for (var i = 0, row; (row = arguments[i]); ++i) {
|
|
jQuery('<img>').attr('src', row);
|
|
}
|
|
},
|
|
|
|
/*
|
|
* Load the clutch prefs and init the GUI according to those prefs
|
|
*/
|
|
initializeSettings: function () {
|
|
Prefs.getClutchPrefs(this);
|
|
|
|
if (this.isMenuEnabled) {
|
|
$('#sort_by_' + this[Prefs._SortMethod]).selectMenuItem();
|
|
|
|
if (this[Prefs._SortDirection] === Prefs._SortDescending) {
|
|
$('#reverse_sort_order').selectMenuItem();
|
|
}
|
|
}
|
|
|
|
this.initCompactMode();
|
|
},
|
|
|
|
/*
|
|
* Set up the search box
|
|
*/
|
|
setupSearchBox: function () {
|
|
const tr = this;
|
|
const search_box = $('#torrent_search');
|
|
search_box.bind('keyup click', function () {
|
|
tr.setFilterText(this.value);
|
|
});
|
|
if (!$.browser.safari) {
|
|
search_box.addClass('blur');
|
|
search_box[0].value = 'Filter';
|
|
search_box
|
|
.bind('blur', function () {
|
|
if (this.value === '') {
|
|
$(this).addClass('blur');
|
|
this.value = 'Filter';
|
|
tr.setFilterText(null);
|
|
}
|
|
})
|
|
.bind('focus', function () {
|
|
if ($(this).is('.blur')) {
|
|
this.value = '';
|
|
$(this).removeClass('blur');
|
|
}
|
|
});
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Create the torrent right-click menu
|
|
*/
|
|
createContextMenu: function () {
|
|
const tr = this;
|
|
const bindings = {
|
|
pause_selected: function () {
|
|
tr.stopSelectedTorrents();
|
|
},
|
|
resume_selected: function () {
|
|
tr.startSelectedTorrents(false);
|
|
},
|
|
resume_now_selected: function () {
|
|
tr.startSelectedTorrents(true);
|
|
},
|
|
move: function () {
|
|
tr.moveSelectedTorrents(false);
|
|
},
|
|
remove: function () {
|
|
tr.removeSelectedTorrents();
|
|
},
|
|
remove_data: function () {
|
|
tr.removeSelectedTorrentsAndData();
|
|
},
|
|
verify: function () {
|
|
tr.verifySelectedTorrents();
|
|
},
|
|
rename: function () {
|
|
tr.renameSelectedTorrents();
|
|
},
|
|
reannounce: function () {
|
|
tr.reannounceSelectedTorrents();
|
|
},
|
|
move_top: function () {
|
|
tr.moveTop();
|
|
},
|
|
move_up: function () {
|
|
tr.moveUp();
|
|
},
|
|
move_down: function () {
|
|
tr.moveDown();
|
|
},
|
|
move_bottom: function () {
|
|
tr.moveBottom();
|
|
},
|
|
select_all: function () {
|
|
tr.selectAll();
|
|
},
|
|
deselect_all: function () {
|
|
tr.deselectAll();
|
|
},
|
|
};
|
|
|
|
// Set up the context menu
|
|
$('ul#torrent_list').contextmenu({
|
|
delegate: '.torrent',
|
|
menu: '#torrent_context_menu',
|
|
preventSelect: true,
|
|
taphold: true,
|
|
show: {
|
|
effect: 'none',
|
|
},
|
|
hide: {
|
|
effect: 'none',
|
|
},
|
|
select: function (event, ui) {
|
|
bindings[ui.cmd]();
|
|
},
|
|
beforeOpen: $.proxy(function (event, ui) {
|
|
const element = $(event.currentTarget);
|
|
const i = $('#torrent_list > li').index(element);
|
|
if (i !== -1 && !this._rows[i].isSelected()) {
|
|
this.setSelectedRow(this._rows[i]);
|
|
}
|
|
|
|
this.calculateTorrentStates(function (s) {
|
|
const tl = $(event.target);
|
|
tl.contextmenu('enableEntry', 'pause_selected', s.activeSel > 0);
|
|
tl.contextmenu('enableEntry', 'resume_selected', s.pausedSel > 0);
|
|
tl.contextmenu('enableEntry', 'resume_now_selected', s.pausedSel > 0 || s.queuedSel > 0);
|
|
tl.contextmenu('enableEntry', 'rename', s.sel == 1);
|
|
});
|
|
}, this),
|
|
});
|
|
},
|
|
|
|
createSettingsMenu: function () {
|
|
$('#footer_super_menu').transMenu({
|
|
open: function () {
|
|
$('#settings_menu').addClass('selected');
|
|
},
|
|
close: function () {
|
|
$('#settings_menu').removeClass('selected');
|
|
},
|
|
select: $.proxy(this.onMenuClicked, this),
|
|
});
|
|
$('#settings_menu').click(function (event) {
|
|
$('#footer_super_menu').transMenu('open');
|
|
});
|
|
},
|
|
|
|
/****
|
|
*****
|
|
****/
|
|
|
|
updateFreeSpaceInAddDialog: function () {
|
|
const formdir = $('input#add-dialog-folder-input').val();
|
|
this.remote.getFreeSpace(formdir, this.onFreeSpaceResponse, this);
|
|
},
|
|
|
|
onFreeSpaceResponse: function (dir, bytes) {
|
|
let e, str, formdir;
|
|
|
|
formdir = $('input#add-dialog-folder-input').val();
|
|
if (formdir == dir) {
|
|
e = $('label#add-dialog-folder-label');
|
|
if (bytes > 0) {
|
|
str = ' <i>(' + Transmission.fmt.size(bytes) + ' Free)</i>';
|
|
} else {
|
|
str = '';
|
|
}
|
|
e.html('Destination folder' + str + ':');
|
|
}
|
|
},
|
|
|
|
/****
|
|
*****
|
|
***** UTILITIES
|
|
*****
|
|
****/
|
|
|
|
getAllTorrents: function () {
|
|
const torrents = [];
|
|
for (const key in this._torrents) {
|
|
torrents.push(this._torrents[key]);
|
|
}
|
|
return torrents;
|
|
},
|
|
|
|
getTorrentIds: function (torrents) {
|
|
return $.map(torrents.slice(0), function (t) {
|
|
return t.getId();
|
|
});
|
|
},
|
|
|
|
scrollToRow: function (row) {
|
|
if (isMobileDevice) {
|
|
// FIXME: why? return
|
|
const list = $('#torrent_container');
|
|
const scrollTop = list.scrollTop();
|
|
const innerHeight = list.innerHeight();
|
|
const offsetTop = row.getElement().offsetTop;
|
|
const offsetHeight = $(row.getElement()).outerHeight();
|
|
|
|
if (offsetTop < scrollTop) {
|
|
list.scrollTop(offsetTop);
|
|
} else if (innerHeight + scrollTop < offsetTop + offsetHeight) {
|
|
list.scrollTop(offsetTop + offsetHeight - innerHeight);
|
|
}
|
|
}
|
|
},
|
|
|
|
seedRatioLimit: function () {
|
|
const p = this.sessionProperties;
|
|
if (p && p.seedRatioLimited) {
|
|
return p.seedRatioLimit;
|
|
}
|
|
return -1;
|
|
},
|
|
|
|
setPref: function (key, val) {
|
|
this[key] = val;
|
|
Prefs.setValue(key, val);
|
|
},
|
|
|
|
/****
|
|
*****
|
|
***** SELECTION
|
|
*****
|
|
****/
|
|
|
|
getSelectedRows: function () {
|
|
return $.grep(this._rows, function (r) {
|
|
return r.isSelected();
|
|
});
|
|
},
|
|
|
|
getSelectedTorrents: function () {
|
|
return $.map(this.getSelectedRows(), function (r) {
|
|
return r.getTorrent();
|
|
});
|
|
},
|
|
|
|
getSelectedTorrentIds: function () {
|
|
return this.getTorrentIds(this.getSelectedTorrents());
|
|
},
|
|
|
|
setSelectedRow: function (row) {
|
|
$(this.elements.torrent_list).children('.selected').removeClass('selected');
|
|
this.selectRow(row);
|
|
},
|
|
|
|
selectRow: function (row) {
|
|
$(row.getElement()).addClass('selected');
|
|
this.callSelectionChangedSoon();
|
|
},
|
|
|
|
deselectRow: function (row) {
|
|
$(row.getElement()).removeClass('selected');
|
|
this.callSelectionChangedSoon();
|
|
},
|
|
|
|
selectAll: function () {
|
|
$(this.elements.torrent_list).children().addClass('selected');
|
|
this.callSelectionChangedSoon();
|
|
},
|
|
deselectAll: function () {
|
|
$(this.elements.torrent_list).children('.selected').removeClass('selected');
|
|
this.callSelectionChangedSoon();
|
|
delete this._last_torrent_clicked;
|
|
},
|
|
|
|
indexOfLastTorrent: function () {
|
|
for (var i = 0, r; (r = this._rows[i]); ++i) {
|
|
if (r.getTorrentId() === this._last_torrent_clicked) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
},
|
|
|
|
// Select a range from this row to the last clicked torrent
|
|
selectRange: function (row) {
|
|
const last = this.indexOfLastTorrent();
|
|
|
|
if (last === -1) {
|
|
this.selectRow(row);
|
|
} else {
|
|
// select the range between the prevous & current
|
|
const next = this._rows.indexOf(row);
|
|
const min = Math.min(last, next);
|
|
const max = Math.max(last, next);
|
|
for (let i = min; i <= max; ++i) {
|
|
this.selectRow(this._rows[i]);
|
|
}
|
|
}
|
|
|
|
this.callSelectionChangedSoon();
|
|
},
|
|
|
|
selectionChanged: function () {
|
|
this.updateButtonStates();
|
|
|
|
this.inspector.setTorrents(this.inspectorIsVisible() ? this.getSelectedTorrents() : []);
|
|
|
|
clearTimeout(this.selectionChangedTimer);
|
|
delete this.selectionChangedTimer;
|
|
},
|
|
|
|
callSelectionChangedSoon: function () {
|
|
if (!this.selectionChangedTimer) {
|
|
const callback = $.proxy(this.selectionChanged, this),
|
|
msec = 200;
|
|
this.selectionChangedTimer = setTimeout(callback, msec);
|
|
}
|
|
},
|
|
|
|
/*--------------------------------------------
|
|
*
|
|
* E V E N T F U N C T I O N S
|
|
*
|
|
*--------------------------------------------*/
|
|
|
|
/*
|
|
* Process key event
|
|
*/
|
|
keyDown: function (ev) {
|
|
let handled = false;
|
|
const rows = this._rows;
|
|
const isInputFocused = $(ev.target).is('input');
|
|
const isDialogVisible =
|
|
$('.dialog_heading:visible').length > 0 || $('.ui-dialog:visible').length > 0;
|
|
|
|
// hotkeys
|
|
const up_key = ev.keyCode === 38; // up key pressed
|
|
const dn_key = ev.keyCode === 40; // down key pressed
|
|
const a_key = ev.keyCode === 65; // a key pressed
|
|
const c_key = ev.keyCode === 67; // c key pressed
|
|
const d_key = ev.keyCode === 68; // d key pressed
|
|
const i_key = ev.keyCode === 73; // i key pressed
|
|
const l_key = ev.keyCode === 76; // l key pressed
|
|
const m_key = ev.keyCode === 77; // m key pressed
|
|
const o_key = ev.keyCode === 79; // o key pressed
|
|
const p_key = ev.keyCode === 80; // p key pressed
|
|
const r_key = ev.keyCode === 82; // r key pressed
|
|
const t_key = ev.keyCode === 84; // t key pressed
|
|
const u_key = ev.keyCode === 85; // u key pressed
|
|
const shift_key = ev.keyCode === 16; // shift key pressed
|
|
const slash_key = ev.keyCode === 191; // slash (/) key pressed
|
|
const backspace_key = ev.keyCode === 8; // backspace key pressed
|
|
const del_key = ev.keyCode === 46; // delete key pressed
|
|
const enter_key = ev.keyCode === 13; // enter key pressed
|
|
const esc_key = ev.keyCode === 27; // esc key pressed
|
|
const comma_key = ev.keyCode === 188; // comma key pressed
|
|
|
|
if (enter_key) {
|
|
// handle other dialogs
|
|
if (dialog && dialog.isVisible()) {
|
|
dialog.executeCallback();
|
|
handled = true;
|
|
}
|
|
|
|
// handle upload dialog
|
|
if ($('#upload_container').is(':visible')) {
|
|
this.confirmUploadClicked();
|
|
handled = true;
|
|
}
|
|
|
|
// handle move dialog
|
|
if ($('#move_container').is(':visible')) {
|
|
this.confirmMoveClicked();
|
|
handled = true;
|
|
}
|
|
|
|
// handle rename dialog
|
|
if ($('#rename_container').is(':visible')) {
|
|
this.confirmRenameClicked();
|
|
handled = true;
|
|
}
|
|
}
|
|
|
|
if (esc_key) {
|
|
// handle other dialogs
|
|
if (dialog && dialog.isVisible()) {
|
|
dialog.hideDialog();
|
|
handled = true;
|
|
}
|
|
|
|
// handle upload dialog
|
|
if ($('#upload_container').is(':visible')) {
|
|
this.hideUploadDialog();
|
|
handled = true;
|
|
}
|
|
|
|
// handle move dialog
|
|
if ($('#move_container').is(':visible')) {
|
|
this.hideMoveDialog();
|
|
handled = true;
|
|
}
|
|
|
|
// handle rename dialog
|
|
if ($('#rename_container').is(':visible')) {
|
|
this.hideRenameDialog();
|
|
handled = true;
|
|
}
|
|
}
|
|
|
|
// Some hotkeys can only be used if the following conditions are met:
|
|
// 1. when no input fields are focused
|
|
// 2. when no other dialogs are visible
|
|
// 3. when the meta or ctrl key isn't pressed (i.e. opening dev tools shouldn't trigger the info panel)
|
|
if (!isInputFocused && !isDialogVisible && !ev.metaKey && !ev.ctrlKey) {
|
|
if (comma_key) {
|
|
this.togglePrefsDialogClicked();
|
|
handled = true;
|
|
}
|
|
|
|
if (slash_key) {
|
|
this.showHotkeysDialog();
|
|
handled = true;
|
|
}
|
|
|
|
if (a_key) {
|
|
if (ev.shiftKey) {
|
|
this.deselectAll();
|
|
} else {
|
|
this.selectAll();
|
|
}
|
|
handled = true;
|
|
}
|
|
|
|
if (c_key) {
|
|
this.toggleCompactClicked();
|
|
handled = true;
|
|
}
|
|
|
|
if ((backspace_key || del_key || d_key) && rows.length) {
|
|
this.removeSelectedTorrents();
|
|
handled = true;
|
|
}
|
|
|
|
if (i_key) {
|
|
this.toggleInspector();
|
|
handled = true;
|
|
}
|
|
|
|
if (m_key || l_key) {
|
|
this.moveSelectedTorrents();
|
|
handled = true;
|
|
}
|
|
|
|
if (o_key || u_key) {
|
|
this.openTorrentClicked(ev);
|
|
handled = true;
|
|
}
|
|
|
|
if (p_key) {
|
|
this.stopSelectedTorrents();
|
|
handled = true;
|
|
}
|
|
|
|
if (r_key) {
|
|
this.startSelectedTorrents();
|
|
handled = true;
|
|
}
|
|
|
|
if (t_key) {
|
|
this.toggleTurtleClicked();
|
|
handled = true;
|
|
}
|
|
|
|
if ((up_key || dn_key) && rows.length) {
|
|
var last = this.indexOfLastTorrent(),
|
|
i = last,
|
|
anchor = this._shift_index,
|
|
min = 0,
|
|
max = rows.length - 1;
|
|
|
|
if (dn_key && i + 1 <= max) {
|
|
++i;
|
|
} else if (up_key && i - 1 >= min) {
|
|
--i;
|
|
}
|
|
|
|
const r = rows[i];
|
|
|
|
if (anchor >= 0) {
|
|
// user is extending the selection
|
|
// with the shift + arrow keys...
|
|
if ((anchor <= last && last < i) || (anchor >= last && last > i)) {
|
|
this.selectRow(r);
|
|
} else if ((anchor >= last && i > last) || (anchor <= last && last > i)) {
|
|
this.deselectRow(rows[last]);
|
|
}
|
|
} else {
|
|
if (ev.shiftKey) {
|
|
this.selectRange(r);
|
|
} else {
|
|
this.setSelectedRow(r);
|
|
}
|
|
}
|
|
this._last_torrent_clicked = r.getTorrentId();
|
|
this.scrollToRow(r);
|
|
handled = true;
|
|
} else if (shift_key) {
|
|
this._shift_index = this.indexOfLastTorrent();
|
|
}
|
|
}
|
|
|
|
return !handled;
|
|
},
|
|
|
|
keyUp: function (ev) {
|
|
if (ev.keyCode === 16) {
|
|
// shift key pressed
|
|
delete this._shift_index;
|
|
}
|
|
},
|
|
|
|
isButtonEnabled: function (ev) {
|
|
const p = (ev.target || ev.srcElement).parentNode;
|
|
return p.className !== 'disabled' && p.parentNode.className !== 'disabled';
|
|
},
|
|
|
|
stopSelectedClicked: function (ev) {
|
|
if (this.isButtonEnabled(ev)) {
|
|
this.stopSelectedTorrents();
|
|
this.hideMobileAddressbar();
|
|
}
|
|
},
|
|
|
|
startSelectedClicked: function (ev) {
|
|
if (this.isButtonEnabled(ev)) {
|
|
this.startSelectedTorrents(false);
|
|
this.hideMobileAddressbar();
|
|
}
|
|
},
|
|
|
|
stopAllClicked: function (ev) {
|
|
if (this.isButtonEnabled(ev)) {
|
|
this.stopAllTorrents();
|
|
this.hideMobileAddressbar();
|
|
}
|
|
},
|
|
|
|
startAllClicked: function (ev) {
|
|
if (this.isButtonEnabled(ev)) {
|
|
this.startAllTorrents(false);
|
|
this.hideMobileAddressbar();
|
|
}
|
|
},
|
|
|
|
openTorrentClicked: function (ev) {
|
|
if (this.isButtonEnabled(ev)) {
|
|
$('body').addClass('open_showing');
|
|
this.uploadTorrentFile();
|
|
this.updateButtonStates();
|
|
}
|
|
},
|
|
|
|
dragenter: function (ev) {
|
|
if (ev.dataTransfer && ev.dataTransfer.types) {
|
|
const types = ['text/uri-list', 'text/plain'];
|
|
for (let i = 0; i < types.length; ++i) {
|
|
// it would be better to look at the links here;
|
|
// sadly, with Firefox, trying would throw.
|
|
if (ev.dataTransfer.types.contains(types[i])) {
|
|
ev.stopPropagation();
|
|
ev.preventDefault();
|
|
ev.dropEffect = 'copy';
|
|
return false;
|
|
}
|
|
}
|
|
} else if (ev.dataTransfer) {
|
|
ev.dataTransfer.dropEffect = 'none';
|
|
}
|
|
return true;
|
|
},
|
|
|
|
drop: function (ev) {
|
|
let i, uri;
|
|
let uris = null;
|
|
const types = ['text/uri-list', 'text/plain'];
|
|
const paused = this.shouldAddedTorrentsStart();
|
|
|
|
if (!ev.dataTransfer || !ev.dataTransfer.types) {
|
|
return true;
|
|
}
|
|
|
|
for (i = 0; !uris && i < types.length; ++i) {
|
|
if (ev.dataTransfer.types.contains(types[i])) {
|
|
uris = ev.dataTransfer.getData(types[i]).split('\n');
|
|
}
|
|
}
|
|
|
|
for (i = 0; (uri = uris[i]); ++i) {
|
|
if (/^#/.test(uri)) {
|
|
// lines which start with "#" are comments
|
|
continue;
|
|
}
|
|
if (/^[a-z-]+:/i.test(uri)) {
|
|
// close enough to a url
|
|
this.remote.addTorrentByUrl(uri, paused);
|
|
}
|
|
}
|
|
|
|
ev.preventDefault();
|
|
return false;
|
|
},
|
|
|
|
hideUploadDialog: function () {
|
|
$('body.open_showing').removeClass('open_showing');
|
|
$('#upload_container').hide();
|
|
this.updateButtonStates();
|
|
},
|
|
|
|
confirmUploadClicked: function () {
|
|
this.uploadTorrentFile(true);
|
|
this.hideUploadDialog();
|
|
},
|
|
|
|
hideMoveDialog: function () {
|
|
$('#move_container').hide();
|
|
this.updateButtonStates();
|
|
},
|
|
|
|
confirmMoveClicked: function () {
|
|
this.moveSelectedTorrents(true);
|
|
this.hideUploadDialog();
|
|
},
|
|
|
|
hideRenameDialog: function () {
|
|
$('body.open_showing').removeClass('open_showing');
|
|
$('#rename_container').hide();
|
|
},
|
|
|
|
confirmRenameClicked: function () {
|
|
const torrents = this.getSelectedTorrents();
|
|
this.renameTorrent(torrents[0], $('input#torrent_rename_name').attr('value'));
|
|
this.hideRenameDialog();
|
|
},
|
|
|
|
removeClicked: function (ev) {
|
|
if (this.isButtonEnabled(ev)) {
|
|
this.removeSelectedTorrents();
|
|
this.hideMobileAddressbar();
|
|
}
|
|
},
|
|
|
|
// turn the periodic ajax session refresh on & off
|
|
togglePeriodicSessionRefresh: function (enabled) {
|
|
const that = this,
|
|
msec = 8000;
|
|
|
|
function callback() {
|
|
that.loadDaemonPrefs(undefined, rescheduleTimeout);
|
|
}
|
|
|
|
function rescheduleTimeout() {
|
|
that.sessionTimeout = setTimeout(callback, msec);
|
|
}
|
|
|
|
clearTimeout(this.sessionTimeout);
|
|
delete this.sessionTimeout;
|
|
|
|
if (enabled) {
|
|
rescheduleTimeout();
|
|
}
|
|
},
|
|
|
|
toggleTurtleClicked: function () {
|
|
const o = {};
|
|
o[RPC._TurtleState] = !$('#turtle-button').hasClass('selected');
|
|
this.remote.savePrefs(o);
|
|
},
|
|
|
|
/*--------------------------------------------
|
|
*
|
|
* I N T E R F A C E F U N C T I O N S
|
|
*
|
|
*--------------------------------------------*/
|
|
|
|
onPrefsDialogClosed: function () {
|
|
$('#prefs-button').removeClass('selected');
|
|
},
|
|
|
|
togglePrefsDialogClicked: function (ev) {
|
|
const e = $('#prefs-button');
|
|
|
|
if (e.hasClass('selected')) {
|
|
this.prefsDialog.close();
|
|
} else {
|
|
e.addClass('selected');
|
|
this.prefsDialog.show();
|
|
}
|
|
},
|
|
|
|
setFilterText: function (search) {
|
|
this.filterText = search ? search.trim() : null;
|
|
this.refilter(true);
|
|
},
|
|
|
|
setSortMethod: function (sort_method) {
|
|
this.setPref(Prefs._SortMethod, sort_method);
|
|
this.refilter(true);
|
|
},
|
|
|
|
setSortDirection: function (direction) {
|
|
this.setPref(Prefs._SortDirection, direction);
|
|
this.refilter(true);
|
|
},
|
|
|
|
onMenuClicked: function (event, ui) {
|
|
let o, dir;
|
|
const id = ui.id;
|
|
const remote = this.remote;
|
|
const element = ui.target;
|
|
|
|
if (ui.group == 'sort-mode') {
|
|
element.selectMenuItem();
|
|
this.setSortMethod(id.replace(/sort_by_/, ''));
|
|
} else if (element.hasClass('upload-speed')) {
|
|
o = {};
|
|
o[RPC._UpSpeedLimit] = parseInt(element.text());
|
|
o[RPC._UpSpeedLimited] = true;
|
|
remote.savePrefs(o);
|
|
} else if (element.hasClass('download-speed')) {
|
|
o = {};
|
|
o[RPC._DownSpeedLimit] = parseInt(element.text());
|
|
o[RPC._DownSpeedLimited] = true;
|
|
remote.savePrefs(o);
|
|
} else {
|
|
switch (id) {
|
|
case 'statistics':
|
|
this.showStatsDialog();
|
|
break;
|
|
|
|
case 'hotkeys':
|
|
this.showHotkeysDialog();
|
|
break;
|
|
|
|
case 'about-button':
|
|
o = 'Transmission ' + this.serverVersion;
|
|
$('#about-dialog #about-title').html(o);
|
|
$('#about-dialog').dialog({
|
|
title: 'About',
|
|
show: 'fade',
|
|
hide: 'fade',
|
|
});
|
|
break;
|
|
|
|
case 'homepage':
|
|
window.open('https://transmissionbt.com/');
|
|
break;
|
|
|
|
case 'tipjar':
|
|
window.open('https://transmissionbt.com/donate/');
|
|
break;
|
|
|
|
case 'unlimited_download_rate':
|
|
o = {};
|
|
o[RPC._DownSpeedLimited] = false;
|
|
remote.savePrefs(o);
|
|
break;
|
|
|
|
case 'limited_download_rate':
|
|
o = {};
|
|
o[RPC._DownSpeedLimited] = true;
|
|
remote.savePrefs(o);
|
|
break;
|
|
|
|
case 'unlimited_upload_rate':
|
|
o = {};
|
|
o[RPC._UpSpeedLimited] = false;
|
|
remote.savePrefs(o);
|
|
break;
|
|
|
|
case 'limited_upload_rate':
|
|
o = {};
|
|
o[RPC._UpSpeedLimited] = true;
|
|
remote.savePrefs(o);
|
|
break;
|
|
|
|
case 'reverse_sort_order':
|
|
if (element.menuItemIsSelected()) {
|
|
dir = Prefs._SortAscending;
|
|
element.deselectMenuItem();
|
|
} else {
|
|
dir = Prefs._SortDescending;
|
|
element.selectMenuItem();
|
|
}
|
|
this.setSortDirection(dir);
|
|
break;
|
|
|
|
case 'toggle_notifications':
|
|
Notifications && Notifications.toggle();
|
|
break;
|
|
|
|
default:
|
|
console.log('unhandled: ' + id);
|
|
break;
|
|
}
|
|
}
|
|
},
|
|
|
|
onTorrentChanged: function (ev, tor) {
|
|
// update our dirty fields
|
|
this.dirtyTorrents[tor.getId()] = true;
|
|
|
|
// enqueue ui refreshes
|
|
this.refilterSoon();
|
|
this.updateButtonsSoon();
|
|
},
|
|
|
|
updateFromTorrentGet: function (updates, removed_ids) {
|
|
let i, o, t, id, needed, callback, fields;
|
|
const needinfo = [];
|
|
|
|
for (i = 0; (o = updates[i]); ++i) {
|
|
id = o.id;
|
|
if ((t = this._torrents[id])) {
|
|
needed = t.needsMetaData();
|
|
t.refresh(o);
|
|
if (needed && !t.needsMetaData()) {
|
|
needinfo.push(id);
|
|
}
|
|
} else {
|
|
t = this._torrents[id] = new Torrent(o);
|
|
this.dirtyTorrents[id] = true;
|
|
callback = $.proxy(this.onTorrentChanged, this);
|
|
$(t).bind('dataChanged', callback);
|
|
// do we need more info for this torrent?
|
|
if (!('name' in t.fields) || !('status' in t.fields)) {
|
|
needinfo.push(id);
|
|
}
|
|
|
|
t.notifyOnFieldChange(
|
|
'status',
|
|
$.proxy(function (newValue, oldValue) {
|
|
if (
|
|
oldValue === Torrent._StatusDownload &&
|
|
(newValue == Torrent._StatusSeed || newValue == Torrent._StatusSeedWait)
|
|
) {
|
|
$(this).trigger('downloadComplete', [t]);
|
|
} else if (
|
|
oldValue === Torrent._StatusSeed &&
|
|
newValue === Torrent._StatusStopped &&
|
|
t.isFinished()
|
|
) {
|
|
$(this).trigger('seedingComplete', [t]);
|
|
} else {
|
|
$(this).trigger('statusChange', [t]);
|
|
}
|
|
}, this)
|
|
);
|
|
}
|
|
}
|
|
|
|
if (needinfo.length) {
|
|
// whee, new torrents! get their initial information.
|
|
fields = ['id'].concat(Torrent.Fields.Metadata, Torrent.Fields.Stats);
|
|
this.updateTorrents(needinfo, fields);
|
|
this.refilterSoon();
|
|
}
|
|
|
|
if (removed_ids) {
|
|
this.deleteTorrents(removed_ids);
|
|
this.refilterSoon();
|
|
}
|
|
},
|
|
|
|
updateTorrents: function (ids, fields, callback) {
|
|
const that = this;
|
|
|
|
function f(updates, removedIds) {
|
|
if (callback) {
|
|
callback();
|
|
}
|
|
|
|
that.updateFromTorrentGet(updates, removedIds);
|
|
}
|
|
|
|
this.remote.updateTorrents(ids, fields, f);
|
|
},
|
|
|
|
refreshTorrents: function () {
|
|
const callback = $.proxy(this.refreshTorrents, this);
|
|
const msec = this[Prefs._RefreshRate] * 1000;
|
|
const fields = ['id'].concat(Torrent.Fields.Stats);
|
|
|
|
// send a request right now
|
|
this.updateTorrents('recently-active', fields);
|
|
|
|
// schedule the next request
|
|
clearTimeout(this.refreshTorrentsTimeout);
|
|
this.refreshTorrentsTimeout = setTimeout(callback, msec);
|
|
},
|
|
|
|
initializeTorrents: function () {
|
|
const fields = ['id'].concat(Torrent.Fields.Metadata, Torrent.Fields.Stats);
|
|
this.updateTorrents(null, fields);
|
|
},
|
|
|
|
onRowClicked: function (ev) {
|
|
const meta_key = ev.metaKey || ev.ctrlKey,
|
|
row = ev.currentTarget.row;
|
|
|
|
// handle the per-row "torrent_resume" button
|
|
if (ev.target.className === 'torrent_resume') {
|
|
this.startTorrent(row.getTorrent());
|
|
return;
|
|
}
|
|
|
|
// handle the per-row "torrent_pause" button
|
|
if (ev.target.className === 'torrent_pause') {
|
|
this.stopTorrent(row.getTorrent());
|
|
return;
|
|
}
|
|
|
|
// Prevents click carrying to parent element
|
|
// which deselects all on click
|
|
ev.stopPropagation();
|
|
|
|
if (isMobileDevice) {
|
|
if (row.isSelected()) {
|
|
this.setInspectorVisible(true);
|
|
}
|
|
this.setSelectedRow(row);
|
|
} else if (ev.shiftKey) {
|
|
this.selectRange(row);
|
|
// Need to deselect any selected text
|
|
window.focus();
|
|
|
|
// Apple-Click, not selected
|
|
} else if (!row.isSelected() && meta_key) {
|
|
this.selectRow(row);
|
|
|
|
// Regular Click, not selected
|
|
} else if (!row.isSelected()) {
|
|
this.setSelectedRow(row);
|
|
|
|
// Apple-Click, selected
|
|
} else if (row.isSelected() && meta_key) {
|
|
this.deselectRow(row);
|
|
|
|
// Regular Click, selected
|
|
} else if (row.isSelected()) {
|
|
this.setSelectedRow(row);
|
|
}
|
|
|
|
this._last_torrent_clicked = row.getTorrentId();
|
|
},
|
|
|
|
deleteTorrents: function (ids) {
|
|
let i, id;
|
|
|
|
if (ids && ids.length) {
|
|
for (i = 0; (id = ids[i]); ++i) {
|
|
this.dirtyTorrents[id] = true;
|
|
delete this._torrents[id];
|
|
}
|
|
this.refilter();
|
|
}
|
|
},
|
|
|
|
shouldAddedTorrentsStart: function () {
|
|
return this.prefsDialog.shouldAddedTorrentsStart();
|
|
},
|
|
|
|
/*
|
|
* Select a torrent file to upload
|
|
*/
|
|
uploadTorrentFile: function (confirmed) {
|
|
const fileInput = $('input#torrent_upload_file');
|
|
const folderInput = $('input#add-dialog-folder-input');
|
|
const startInput = $('input#torrent_auto_start');
|
|
const urlInput = $('input#torrent_upload_url');
|
|
|
|
if (!confirmed) {
|
|
// update the upload dialog's fields
|
|
fileInput.attr('value', '');
|
|
urlInput.attr('value', '');
|
|
startInput.attr('checked', this.shouldAddedTorrentsStart());
|
|
folderInput.attr('value', $('#download-dir').val());
|
|
folderInput.change($.proxy(this.updateFreeSpaceInAddDialog, this));
|
|
this.updateFreeSpaceInAddDialog();
|
|
|
|
// show the dialog
|
|
$('#upload_container').show();
|
|
urlInput.focus();
|
|
} else {
|
|
const paused = !startInput.is(':checked');
|
|
const destination = folderInput.val();
|
|
const remote = this.remote;
|
|
|
|
jQuery.each(fileInput[0].files, function (i, file) {
|
|
const reader = new FileReader();
|
|
reader.onload = function (e) {
|
|
const contents = e.target.result;
|
|
const key = 'base64,';
|
|
const index = contents.indexOf(key);
|
|
if (index > -1) {
|
|
const metainfo = contents.substring(index + key.length);
|
|
const o = {
|
|
method: 'torrent-add',
|
|
arguments: {
|
|
paused: paused,
|
|
'download-dir': destination,
|
|
metainfo: metainfo,
|
|
},
|
|
};
|
|
remote.sendRequest(o, function (response) {
|
|
if (response.result != 'success') {
|
|
alert('Error adding "' + file.name + '": ' + response.result);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
reader.readAsDataURL(file);
|
|
});
|
|
|
|
let url = $('#torrent_upload_url').val();
|
|
if (url != '') {
|
|
if (url.match(/^[0-9a-f]{40}$/i)) {
|
|
url = 'magnet:?xt=urn:btih:' + url;
|
|
}
|
|
const o = {
|
|
method: 'torrent-add',
|
|
arguments: {
|
|
paused: paused,
|
|
'download-dir': destination,
|
|
filename: url,
|
|
},
|
|
};
|
|
remote.sendRequest(o, function (response) {
|
|
if (response.result != 'success') {
|
|
alert('Error adding "' + url + '": ' + response.result);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
},
|
|
|
|
promptSetLocation: function (confirmed, torrents) {
|
|
if (!confirmed) {
|
|
let path;
|
|
if (torrents.length === 1) {
|
|
path = torrents[0].getDownloadDir();
|
|
} else {
|
|
path = $('#download-dir').val();
|
|
}
|
|
$('input#torrent_path').attr('value', path);
|
|
$('#move_container').show();
|
|
$('#torrent_path').focus();
|
|
} else {
|
|
const ids = this.getTorrentIds(torrents);
|
|
this.remote.moveTorrents(ids, $('input#torrent_path').val(), this.refreshTorrents, this);
|
|
$('#move_container').hide();
|
|
}
|
|
},
|
|
|
|
moveSelectedTorrents: function (confirmed) {
|
|
const torrents = this.getSelectedTorrents();
|
|
if (torrents.length) {
|
|
this.promptSetLocation(confirmed, torrents);
|
|
}
|
|
},
|
|
|
|
removeSelectedTorrents: function () {
|
|
const torrents = this.getSelectedTorrents();
|
|
if (torrents.length) {
|
|
this.promptToRemoveTorrents(torrents);
|
|
}
|
|
},
|
|
|
|
removeSelectedTorrentsAndData: function () {
|
|
const torrents = this.getSelectedTorrents();
|
|
if (torrents.length) {
|
|
this.promptToRemoveTorrentsAndData(torrents);
|
|
}
|
|
},
|
|
|
|
promptToRemoveTorrents: function (torrents) {
|
|
if (torrents.length === 1) {
|
|
const torrent = torrents[0];
|
|
const header = 'Remove ' + torrent.getName() + '?';
|
|
const message =
|
|
'Once removed, continuing the transfer will require the torrent file. Are you sure you want to remove it?';
|
|
dialog.confirm(header, message, 'Remove', function () {
|
|
transmission.removeTorrents(torrents);
|
|
});
|
|
} else {
|
|
const header = 'Remove ' + torrents.length + ' transfers?';
|
|
const message =
|
|
'Once removed, continuing the transfers will require the torrent files. Are you sure you want to remove them?';
|
|
dialog.confirm(header, message, 'Remove', function () {
|
|
transmission.removeTorrents(torrents);
|
|
});
|
|
}
|
|
},
|
|
|
|
promptToRemoveTorrentsAndData: function (torrents) {
|
|
if (torrents.length === 1) {
|
|
const torrent = torrents[0];
|
|
const header = 'Remove ' + torrent.getName() + ' and delete data?';
|
|
const message =
|
|
'All data downloaded for this torrent will be deleted. Are you sure you want to remove it?';
|
|
|
|
dialog.confirm(header, message, 'Remove', function () {
|
|
transmission.removeTorrentsAndData(torrents);
|
|
});
|
|
} else {
|
|
const header = 'Remove ' + torrents.length + ' transfers and delete data?';
|
|
const message =
|
|
'All data downloaded for these torrents will be deleted. Are you sure you want to remove them?';
|
|
|
|
dialog.confirm(header, message, 'Remove', function () {
|
|
transmission.removeTorrentsAndData(torrents);
|
|
});
|
|
}
|
|
},
|
|
|
|
removeTorrents: function (torrents) {
|
|
const ids = this.getTorrentIds(torrents);
|
|
this.remote.removeTorrents(ids, this.refreshTorrents, this);
|
|
},
|
|
|
|
removeTorrentsAndData: function (torrents) {
|
|
this.remote.removeTorrentsAndData(torrents);
|
|
},
|
|
|
|
promptToRenameTorrent: function (torrent) {
|
|
$('body').addClass('open_showing');
|
|
$('input#torrent_rename_name').attr('value', torrent.getName());
|
|
$('#rename_container').show();
|
|
$('#torrent_rename_name').focus();
|
|
},
|
|
|
|
renameSelectedTorrents: function () {
|
|
const torrents = this.getSelectedTorrents();
|
|
if (torrents.length != 1) {
|
|
dialog.alert('Renaming', 'You can rename only one torrent at a time.', 'Ok');
|
|
} else {
|
|
this.promptToRenameTorrent(torrents[0]);
|
|
}
|
|
},
|
|
|
|
onTorrentRenamed: function (response) {
|
|
let torrent;
|
|
if (
|
|
response.result === 'success' &&
|
|
response.arguments &&
|
|
(torrent = this._torrents[response.arguments.id])
|
|
) {
|
|
torrent.refresh(response.arguments);
|
|
}
|
|
},
|
|
|
|
renameTorrent: function (torrent, newname) {
|
|
const oldpath = torrent.getName();
|
|
this.remote.renameTorrent([torrent.getId()], oldpath, newname, this.onTorrentRenamed, this);
|
|
},
|
|
|
|
verifySelectedTorrents: function () {
|
|
this.verifyTorrents(this.getSelectedTorrents());
|
|
},
|
|
|
|
reannounceSelectedTorrents: function () {
|
|
this.reannounceTorrents(this.getSelectedTorrents());
|
|
},
|
|
|
|
startAllTorrents: function (force) {
|
|
this.startTorrents(this.getAllTorrents(), force);
|
|
},
|
|
startSelectedTorrents: function (force) {
|
|
this.startTorrents(this.getSelectedTorrents(), force);
|
|
},
|
|
startTorrent: function (torrent) {
|
|
this.startTorrents([torrent], false);
|
|
},
|
|
|
|
startTorrents: function (torrents, force) {
|
|
this.remote.startTorrents(this.getTorrentIds(torrents), force, this.refreshTorrents, this);
|
|
},
|
|
verifyTorrent: function (torrent) {
|
|
this.verifyTorrents([torrent]);
|
|
},
|
|
verifyTorrents: function (torrents) {
|
|
this.remote.verifyTorrents(this.getTorrentIds(torrents), this.refreshTorrents, this);
|
|
},
|
|
|
|
reannounceTorrent: function (torrent) {
|
|
this.reannounceTorrents([torrent]);
|
|
},
|
|
reannounceTorrents: function (torrents) {
|
|
this.remote.reannounceTorrents(this.getTorrentIds(torrents), this.refreshTorrents, this);
|
|
},
|
|
|
|
stopAllTorrents: function () {
|
|
this.stopTorrents(this.getAllTorrents());
|
|
},
|
|
stopSelectedTorrents: function () {
|
|
this.stopTorrents(this.getSelectedTorrents());
|
|
},
|
|
stopTorrent: function (torrent) {
|
|
this.stopTorrents([torrent]);
|
|
},
|
|
stopTorrents: function (torrents) {
|
|
this.remote.stopTorrents(this.getTorrentIds(torrents), this.refreshTorrents, this);
|
|
},
|
|
changeFileCommand: function (torrentId, rowIndices, command) {
|
|
this.remote.changeFileCommand(torrentId, rowIndices, command);
|
|
},
|
|
|
|
hideMobileAddressbar: function (delaySecs) {
|
|
if (isMobileDevice && !scroll_timeout) {
|
|
const callback = $.proxy(this.doToolbarHide, this);
|
|
const msec = delaySecs * 1000 || 150;
|
|
scroll_timeout = setTimeout(callback, msec);
|
|
}
|
|
},
|
|
doToolbarHide: function () {
|
|
window.scrollTo(0, 1);
|
|
scroll_timeout = null;
|
|
},
|
|
|
|
// Queue
|
|
moveTop: function () {
|
|
this.remote.moveTorrentsToTop(this.getSelectedTorrentIds(), this.refreshTorrents, this);
|
|
},
|
|
moveUp: function () {
|
|
this.remote.moveTorrentsUp(this.getSelectedTorrentIds(), this.refreshTorrents, this);
|
|
},
|
|
moveDown: function () {
|
|
this.remote.moveTorrentsDown(this.getSelectedTorrentIds(), this.refreshTorrents, this);
|
|
},
|
|
moveBottom: function () {
|
|
this.remote.moveTorrentsToBottom(this.getSelectedTorrentIds(), this.refreshTorrents, this);
|
|
},
|
|
|
|
/***
|
|
****
|
|
***/
|
|
|
|
updateGuiFromSession: function (o) {
|
|
let limit, limited, e, b, text;
|
|
const fmt = Transmission.fmt;
|
|
const menu = $('#footer_super_menu');
|
|
|
|
this.serverVersion = o.version;
|
|
|
|
this.prefsDialog.set(o);
|
|
|
|
if (RPC._TurtleState in o) {
|
|
b = o[RPC._TurtleState];
|
|
e = $('#turtle-button');
|
|
text = [
|
|
'Click to ',
|
|
b ? 'disable' : 'enable',
|
|
' Temporary Speed Limits (',
|
|
fmt.speed(o[RPC._TurtleUpSpeedLimit]),
|
|
' up,',
|
|
fmt.speed(o[RPC._TurtleDownSpeedLimit]),
|
|
' down)',
|
|
].join('');
|
|
e.toggleClass('selected', b);
|
|
e.attr('title', text);
|
|
}
|
|
|
|
if (this.isMenuEnabled && RPC._DownSpeedLimited in o && RPC._DownSpeedLimit in o) {
|
|
limit = o[RPC._DownSpeedLimit];
|
|
limited = o[RPC._DownSpeedLimited];
|
|
|
|
e = menu.find('#limited_download_rate');
|
|
e.html('Limit (' + fmt.speed(limit) + ')');
|
|
|
|
if (!limited) {
|
|
e = menu.find('#unlimited_download_rate');
|
|
}
|
|
e.selectMenuItem();
|
|
}
|
|
|
|
if (this.isMenuEnabled && RPC._UpSpeedLimited in o && RPC._UpSpeedLimit in o) {
|
|
limit = o[RPC._UpSpeedLimit];
|
|
limited = o[RPC._UpSpeedLimited];
|
|
|
|
e = menu.find('#limited_upload_rate');
|
|
e.html('Limit (' + fmt.speed(limit) + ')');
|
|
|
|
if (!limited) {
|
|
e = menu.find('#unlimited_upload_rate');
|
|
}
|
|
e.selectMenuItem();
|
|
}
|
|
},
|
|
|
|
updateStatusbar: function () {
|
|
let i, row;
|
|
let u = 0;
|
|
let d = 0;
|
|
const fmt = Transmission.fmt;
|
|
const torrents = this.getAllTorrents();
|
|
|
|
// up/down speed
|
|
for (i = 0; (row = torrents[i]); ++i) {
|
|
u += row.getUploadSpeed();
|
|
d += row.getDownloadSpeed();
|
|
}
|
|
|
|
$('#speed-up-container').toggleClass('active', u > 0);
|
|
$('#speed-up-label').text(fmt.speedBps(u));
|
|
|
|
$('#speed-dn-container').toggleClass('active', d > 0);
|
|
$('#speed-dn-label').text(fmt.speedBps(d));
|
|
|
|
// visible torrents
|
|
$('#filter-count').text(fmt.countString('Transfer', 'Transfers', this._rows.length));
|
|
},
|
|
|
|
setEnabled: function (key, flag) {
|
|
$(key).toggleClass('disabled', !flag);
|
|
},
|
|
|
|
updateFilterSelect: function () {
|
|
let i, names, name, str, o;
|
|
const trackers = this.getTrackers();
|
|
|
|
// build a sorted list of names
|
|
names = [];
|
|
for (name in trackers) {
|
|
names.push(name);
|
|
}
|
|
names.sort();
|
|
|
|
// build the new html
|
|
if (!this.filterTracker) {
|
|
str = '<option value="all" selected="selected">All</option>';
|
|
} else {
|
|
str = '<option value="all">All</option>';
|
|
}
|
|
for (i = 0; (name = names[i]); ++i) {
|
|
o = trackers[name];
|
|
str += '<option value="' + o.domain + '"';
|
|
if (trackers[name].domain === this.filterTracker) {
|
|
str += ' selected="selected"';
|
|
}
|
|
str += '>' + name + '</option>';
|
|
}
|
|
|
|
if (!this.filterTrackersStr || this.filterTrackersStr !== str) {
|
|
this.filterTrackersStr = str;
|
|
$('#filter-tracker').html(str);
|
|
}
|
|
},
|
|
|
|
updateButtonsSoon: function () {
|
|
if (!this.buttonRefreshTimer) {
|
|
const callback = $.proxy(this.updateButtonStates, this);
|
|
const msec = 100;
|
|
|
|
this.buttonRefreshTimer = setTimeout(callback, msec);
|
|
}
|
|
},
|
|
|
|
calculateTorrentStates: function (callback) {
|
|
const stats = {
|
|
total: 0,
|
|
active: 0,
|
|
paused: 0,
|
|
sel: 0,
|
|
activeSel: 0,
|
|
pausedSel: 0,
|
|
queuedSel: 0,
|
|
};
|
|
|
|
clearTimeout(this.buttonRefreshTimer);
|
|
delete this.buttonRefreshTimer;
|
|
|
|
for (var i = 0, row; (row = this._rows[i]); ++i) {
|
|
const isStopped = row.getTorrent().isStopped();
|
|
const isSelected = row.isSelected();
|
|
const isQueued = row.getTorrent().isQueued();
|
|
++stats.total;
|
|
if (!isStopped) {
|
|
++stats.active;
|
|
}
|
|
if (isStopped) {
|
|
++stats.paused;
|
|
}
|
|
if (isSelected) {
|
|
++stats.sel;
|
|
}
|
|
if (isSelected && !isStopped) {
|
|
++stats.activeSel;
|
|
}
|
|
if (isSelected && isStopped) {
|
|
++stats.pausedSel;
|
|
}
|
|
if (isSelected && isQueued) {
|
|
++stats.queuedSel;
|
|
}
|
|
}
|
|
|
|
callback(stats);
|
|
},
|
|
|
|
updateButtonStates: function () {
|
|
const tr = this;
|
|
const e = this.elements;
|
|
|
|
this.calculateTorrentStates(function (s) {
|
|
tr.setEnabled(e.toolbar_pause_button, s.activeSel > 0);
|
|
tr.setEnabled(e.toolbar_start_button, s.pausedSel > 0);
|
|
tr.setEnabled(e.toolbar_remove_button, s.sel > 0);
|
|
});
|
|
},
|
|
|
|
/****
|
|
*****
|
|
***** INSPECTOR
|
|
*****
|
|
****/
|
|
|
|
inspectorIsVisible: function () {
|
|
return $('#torrent_inspector').is(':visible');
|
|
},
|
|
toggleInspector: function () {
|
|
this.setInspectorVisible(!this.inspectorIsVisible());
|
|
},
|
|
setInspectorVisible: function (visible) {
|
|
if (visible) {
|
|
this.inspector.setTorrents(this.getSelectedTorrents());
|
|
}
|
|
|
|
// update the ui widgetry
|
|
$('#torrent_inspector').toggle(visible);
|
|
$('#toolbar-inspector').toggleClass('selected', visible);
|
|
this.hideMobileAddressbar();
|
|
if (isMobileDevice) {
|
|
$('body').toggleClass('inspector_showing', visible);
|
|
} else {
|
|
const w = visible ? $('#torrent_inspector').outerWidth() + 1 + 'px' : '0px';
|
|
$('#torrent_container')[0].style.right = w;
|
|
}
|
|
},
|
|
|
|
/****
|
|
*****
|
|
***** FILTER
|
|
*****
|
|
****/
|
|
|
|
refilterSoon: function () {
|
|
if (!this.refilterTimer) {
|
|
const tr = this,
|
|
callback = function () {
|
|
tr.refilter(false);
|
|
},
|
|
msec = 100;
|
|
this.refilterTimer = setTimeout(callback, msec);
|
|
}
|
|
},
|
|
|
|
sortRows: function (rows) {
|
|
let i,
|
|
tor,
|
|
row,
|
|
id2row = {},
|
|
torrents = [];
|
|
|
|
for (i = 0; (row = rows[i]); ++i) {
|
|
tor = row.getTorrent();
|
|
torrents.push(tor);
|
|
id2row[tor.getId()] = row;
|
|
}
|
|
|
|
Torrent.sortTorrents(torrents, this[Prefs._SortMethod], this[Prefs._SortDirection]);
|
|
|
|
for (i = 0; (tor = torrents[i]); ++i) {
|
|
rows[i] = id2row[tor.getId()];
|
|
}
|
|
},
|
|
|
|
refilter: function (rebuildEverything) {
|
|
let i, e, id, t, row, tmp, rows, clean_rows, dirty_rows, frag;
|
|
const sort_mode = this[Prefs._SortMethod];
|
|
const sort_direction = this[Prefs._SortDirection];
|
|
const filter_mode = this[Prefs._FilterMode];
|
|
const filter_text = this.filterText;
|
|
const filter_tracker = this.filterTracker;
|
|
const renderer = this.torrentRenderer;
|
|
const list = this.elements.torrent_list;
|
|
|
|
const old_sel_count = $(list).children('.selected').length;
|
|
|
|
this.updateFilterSelect();
|
|
|
|
clearTimeout(this.refilterTimer);
|
|
delete this.refilterTimer;
|
|
|
|
if (rebuildEverything) {
|
|
$(list).empty();
|
|
this._rows = [];
|
|
for (id in this._torrents) {
|
|
this.dirtyTorrents[id] = true;
|
|
}
|
|
}
|
|
|
|
// rows that overlap with dirtyTorrents need to be refiltered.
|
|
// those that don't are 'clean' and don't need refiltering.
|
|
clean_rows = [];
|
|
dirty_rows = [];
|
|
for (i = 0; (row = this._rows[i]); ++i) {
|
|
if (row.getTorrentId() in this.dirtyTorrents) {
|
|
dirty_rows.push(row);
|
|
} else {
|
|
clean_rows.push(row);
|
|
}
|
|
}
|
|
|
|
// remove the dirty rows from the dom
|
|
e = [];
|
|
for (i = 0; (row = dirty_rows[i]); ++i) {
|
|
e.push(row.getElement());
|
|
}
|
|
$(e).detach();
|
|
|
|
// drop any dirty rows that don't pass the filter test
|
|
tmp = [];
|
|
for (i = 0; (row = dirty_rows[i]); ++i) {
|
|
id = row.getTorrentId();
|
|
t = this._torrents[id];
|
|
if (t && t.test(filter_mode, filter_text, filter_tracker)) {
|
|
tmp.push(row);
|
|
}
|
|
delete this.dirtyTorrents[id];
|
|
}
|
|
dirty_rows = tmp;
|
|
|
|
// make new rows for dirty torrents that pass the filter test
|
|
// but don't already have a row
|
|
for (id in this.dirtyTorrents) {
|
|
t = this._torrents[id];
|
|
if (t && t.test(filter_mode, filter_text, filter_tracker)) {
|
|
row = new TorrentRow(renderer, this, t);
|
|
e = row.getElement();
|
|
e.row = row;
|
|
dirty_rows.push(row);
|
|
$(e).click($.proxy(this.onRowClicked, this));
|
|
$(e).dblclick($.proxy(this.toggleInspector, this));
|
|
}
|
|
}
|
|
|
|
// sort the dirty rows
|
|
this.sortRows(dirty_rows);
|
|
|
|
// now we have two sorted arrays of rows
|
|
// and can do a simple two-way sorted merge.
|
|
rows = [];
|
|
let ci = 0,
|
|
cmax = clean_rows.length;
|
|
let di = 0,
|
|
dmax = dirty_rows.length;
|
|
frag = document.createDocumentFragment();
|
|
while (ci != cmax || di != dmax) {
|
|
var push_clean;
|
|
|
|
if (ci == cmax) {
|
|
push_clean = false;
|
|
} else if (di == dmax) {
|
|
push_clean = true;
|
|
} else {
|
|
const c = Torrent.compareTorrents(
|
|
clean_rows[ci].getTorrent(),
|
|
dirty_rows[di].getTorrent(),
|
|
sort_mode,
|
|
sort_direction
|
|
);
|
|
push_clean = c < 0;
|
|
}
|
|
|
|
if (push_clean) {
|
|
rows.push(clean_rows[ci++]);
|
|
} else {
|
|
row = dirty_rows[di++];
|
|
e = row.getElement();
|
|
|
|
if (ci !== cmax) {
|
|
list.insertBefore(e, clean_rows[ci].getElement());
|
|
} else {
|
|
frag.appendChild(e);
|
|
}
|
|
|
|
rows.push(row);
|
|
}
|
|
}
|
|
list.appendChild(frag);
|
|
|
|
// update our implementation fields
|
|
this._rows = rows;
|
|
this.dirtyTorrents = {};
|
|
|
|
// jquery's even/odd starts with 1 not 0, so invert its logic
|
|
e = rows.map((row) => row.getElement());
|
|
$(e).filter(':odd').addClass('even');
|
|
$(e).filter(':even').removeClass('even');
|
|
|
|
// sync gui
|
|
this.updateStatusbar();
|
|
if (old_sel_count !== $(list).children('.selected').length) {
|
|
this.selectionChanged();
|
|
}
|
|
},
|
|
|
|
setFilterMode: function (mode) {
|
|
// set the state
|
|
this.setPref(Prefs._FilterMode, mode);
|
|
|
|
// refilter
|
|
this.refilter(true);
|
|
},
|
|
|
|
onFilterModeClicked: function (ev) {
|
|
this.setFilterMode($('#filter-mode').val());
|
|
},
|
|
|
|
onFilterTrackerClicked: function (ev) {
|
|
const tracker = $('#filter-tracker').val();
|
|
this.setFilterTracker(tracker === 'all' ? null : tracker);
|
|
},
|
|
|
|
setFilterTracker: function (domain) {
|
|
// update which tracker is selected in the popup
|
|
const key = domain ? this.getReadableDomain(domain) : 'all';
|
|
const id = '#show-tracker-' + key;
|
|
|
|
$(id).addClass('selected').siblings().removeClass('selected');
|
|
|
|
this.filterTracker = domain;
|
|
this.refilter(true);
|
|
},
|
|
|
|
// example: "tracker.ubuntu.com" returns "ubuntu.com"
|
|
getDomainName: function (host) {
|
|
const dot = host.indexOf('.');
|
|
if (dot !== host.lastIndexOf('.')) {
|
|
host = host.slice(dot + 1);
|
|
}
|
|
|
|
return host;
|
|
},
|
|
|
|
// example: "ubuntu.com" returns "Ubuntu"
|
|
getReadableDomain: function (name) {
|
|
if (name.length) {
|
|
name = name.charAt(0).toUpperCase() + name.slice(1);
|
|
}
|
|
const dot = name.indexOf('.');
|
|
if (dot !== -1) {
|
|
name = name.slice(0, dot);
|
|
}
|
|
return name;
|
|
},
|
|
|
|
getTrackers: function () {
|
|
const ret = {};
|
|
|
|
const torrents = this.getAllTorrents();
|
|
for (let i = 0, torrent; (torrent = torrents[i]); ++i) {
|
|
const names = [];
|
|
const trackers = torrent.getTrackers();
|
|
|
|
for (let j = 0, tracker; (tracker = trackers[j]); ++j) {
|
|
var uri,
|
|
announce = tracker.announce;
|
|
|
|
if (announce in this.uriCache) {
|
|
uri = this.uriCache[announce];
|
|
} else {
|
|
uri = this.uriCache[announce] = new URL(announce);
|
|
uri.domain = this.getDomainName(uri.host);
|
|
uri.name = this.getReadableDomain(uri.domain);
|
|
}
|
|
|
|
if (!(uri.name in ret)) {
|
|
ret[uri.name] = {
|
|
uri: uri,
|
|
domain: uri.domain,
|
|
count: 0,
|
|
};
|
|
}
|
|
|
|
if (names.indexOf(uri.name) === -1) {
|
|
names.push(uri.name);
|
|
}
|
|
}
|
|
|
|
for (const name of names) {
|
|
ret[name].count++;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
},
|
|
|
|
/***
|
|
****
|
|
**** Compact Mode
|
|
****
|
|
***/
|
|
|
|
toggleCompactClicked: function () {
|
|
this.setCompactMode(!this[Prefs._CompactDisplayState]);
|
|
},
|
|
setCompactMode: function (is_compact) {
|
|
const key = Prefs._CompactDisplayState;
|
|
const was_compact = this[key];
|
|
|
|
if (was_compact !== is_compact) {
|
|
this.setPref(key, is_compact);
|
|
this.onCompactModeChanged();
|
|
}
|
|
},
|
|
initCompactMode: function () {
|
|
this.onCompactModeChanged();
|
|
},
|
|
onCompactModeChanged: function () {
|
|
const compact = this[Prefs._CompactDisplayState];
|
|
|
|
// update the ui: footer button
|
|
$('#compact-button').toggleClass('selected', compact);
|
|
|
|
// update the ui: torrent list
|
|
this.torrentRenderer = compact ? new TorrentRendererCompact() : new TorrentRendererFull();
|
|
this.refilter(true);
|
|
},
|
|
|
|
/***
|
|
****
|
|
**** Statistics
|
|
****
|
|
***/
|
|
|
|
// turn the periodic ajax stats refresh on & off
|
|
togglePeriodicStatsRefresh: function (enabled) {
|
|
const that = this,
|
|
msec = 5000;
|
|
|
|
function callback() {
|
|
that.loadDaemonStats(undefined, rescheduleTimeout);
|
|
}
|
|
|
|
function rescheduleTimeout() {
|
|
that.statsTimeout = setTimeout(callback, msec);
|
|
}
|
|
|
|
clearTimeout(this.statsTimeout);
|
|
delete this.statsTimeout;
|
|
|
|
if (enabled) {
|
|
rescheduleTimeout();
|
|
}
|
|
},
|
|
|
|
loadDaemonStats: function (async, callback) {
|
|
this.remote.loadDaemonStats(
|
|
function (data) {
|
|
this.updateStats(data['arguments']);
|
|
|
|
if (callback) {
|
|
callback();
|
|
}
|
|
},
|
|
this,
|
|
async
|
|
);
|
|
},
|
|
|
|
// Process new session stats from the server
|
|
updateStats: function (stats) {
|
|
let s, ratio;
|
|
const fmt = Transmission.fmt;
|
|
|
|
s = stats['current-stats'];
|
|
ratio = Math.ratio(s.uploadedBytes, s.downloadedBytes);
|
|
$('#stats-session-uploaded').html(fmt.size(s.uploadedBytes));
|
|
$('#stats-session-downloaded').html(fmt.size(s.downloadedBytes));
|
|
$('#stats-session-ratio').html(fmt.ratioString(ratio));
|
|
$('#stats-session-duration').html(fmt.timeInterval(s.secondsActive));
|
|
|
|
s = stats['cumulative-stats'];
|
|
ratio = Math.ratio(s.uploadedBytes, s.downloadedBytes);
|
|
$('#stats-total-count').html(s.sessionCount + ' times');
|
|
$('#stats-total-uploaded').html(fmt.size(s.uploadedBytes));
|
|
$('#stats-total-downloaded').html(fmt.size(s.downloadedBytes));
|
|
$('#stats-total-ratio').html(fmt.ratioString(ratio));
|
|
$('#stats-total-duration').html(fmt.timeInterval(s.secondsActive));
|
|
},
|
|
|
|
showStatsDialog: function () {
|
|
this.loadDaemonStats();
|
|
this.hideMobileAddressbar();
|
|
this.togglePeriodicStatsRefresh(true);
|
|
$('#stats-dialog').dialog({
|
|
close: $.proxy(this.onStatsDialogClosed, this),
|
|
show: 'fade',
|
|
hide: 'fade',
|
|
title: 'Statistics',
|
|
});
|
|
},
|
|
|
|
onStatsDialogClosed: function () {
|
|
this.hideMobileAddressbar();
|
|
this.togglePeriodicStatsRefresh(false);
|
|
},
|
|
|
|
/***
|
|
****
|
|
**** Hotkeys
|
|
****
|
|
***/
|
|
showHotkeysDialog: function () {
|
|
$('#hotkeys-dialog').dialog({
|
|
title: 'Hotkeys',
|
|
show: 'fade',
|
|
hide: 'fade',
|
|
});
|
|
},
|
|
};
|