730 lines
28 KiB
Python
730 lines
28 KiB
Python
#
|
|
# addtorrentdialog.py
|
|
#
|
|
# Copyright (C) 2007 Andrew Resch <andrewresch@gmail.com>
|
|
#
|
|
# Deluge is free software.
|
|
#
|
|
# You may redistribute it and/or modify it under the terms of the
|
|
# GNU General Public License, as published by the Free Software
|
|
# Foundation; either version 3 of the License, or (at your option)
|
|
# any later version.
|
|
#
|
|
# deluge is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
# See the GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with deluge. If not, write to:
|
|
# The Free Software Foundation, Inc.,
|
|
# 51 Franklin Street, Fifth Floor
|
|
# Boston, MA 02110-1301, USA.
|
|
#
|
|
# In addition, as a special exception, the copyright holders give
|
|
# permission to link the code of portions of this program with the OpenSSL
|
|
# library.
|
|
# You must obey the GNU General Public License in all respects for all of
|
|
# the code used other than OpenSSL. If you modify file(s) with this
|
|
# exception, you may extend this exception to your version of the file(s),
|
|
# but you are not obligated to do so. If you do not wish to do so, delete
|
|
# this exception statement from your version. If you delete this exception
|
|
# statement from all source files in the program, then also delete it here.
|
|
#
|
|
|
|
#
|
|
|
|
|
|
import pygtk
|
|
pygtk.require('2.0')
|
|
import gtk, gtk.glade
|
|
import gettext
|
|
import gobject
|
|
|
|
import pkg_resources
|
|
|
|
from deluge.ui.client import aclient as client
|
|
import deluge.component as component
|
|
import deluge.ui.gtkui.listview as listview
|
|
from deluge.configmanager import ConfigManager
|
|
from deluge.log import LOG as log
|
|
import deluge.common
|
|
import deluge.ui.common
|
|
|
|
class AddTorrentDialog(component.Component):
|
|
def __init__(self):
|
|
component.Component.__init__(self, "AddTorrentDialog")
|
|
self.glade = gtk.glade.XML(
|
|
pkg_resources.resource_filename(
|
|
"deluge.ui.gtkui", "glade/add_torrent_dialog.glade"))
|
|
|
|
self.dialog = self.glade.get_widget("dialog_add_torrent")
|
|
|
|
self.dialog.connect("delete-event", self._on_delete_event)
|
|
|
|
self.glade.signal_autoconnect({
|
|
"on_button_file_clicked": self._on_button_file_clicked,
|
|
"on_button_url_clicked": self._on_button_url_clicked,
|
|
"on_button_hash_clicked": self._on_button_hash_clicked,
|
|
"on_button_remove_clicked": self._on_button_remove_clicked,
|
|
"on_button_trackers_clicked": self._on_button_trackers_clicked,
|
|
"on_button_cancel_clicked": self._on_button_cancel_clicked,
|
|
"on_button_add_clicked": self._on_button_add_clicked,
|
|
"on_button_apply_clicked": self._on_button_apply_clicked,
|
|
"on_button_revert_clicked": self._on_button_revert_clicked
|
|
})
|
|
|
|
self.torrent_liststore = gtk.ListStore(str, str, str)
|
|
#download?, path, filesize, sequence number, inconsistent?
|
|
self.files_treestore = gtk.TreeStore(bool, str, gobject.TYPE_UINT64,
|
|
gobject.TYPE_INT64, bool, str)
|
|
self.files_treestore.set_sort_column_id(1, gtk.SORT_ASCENDING)
|
|
|
|
# Holds the files info
|
|
self.files = {}
|
|
self.infos = {}
|
|
self.core_config = {}
|
|
self.options = {}
|
|
self.previous_selected_torrent = None
|
|
|
|
|
|
self.listview_torrents = self.glade.get_widget("listview_torrents")
|
|
self.listview_files = self.glade.get_widget("listview_files")
|
|
|
|
render = gtk.CellRendererText()
|
|
column = gtk.TreeViewColumn(_("Torrent"), render, text=1)
|
|
self.listview_torrents.append_column(column)
|
|
|
|
render = gtk.CellRendererToggle()
|
|
render.connect("toggled", self._on_file_toggled)
|
|
column = gtk.TreeViewColumn(None, render, active=0, inconsistent=4)
|
|
self.listview_files.append_column(column)
|
|
|
|
column = gtk.TreeViewColumn(_("Filename"))
|
|
render = gtk.CellRendererPixbuf()
|
|
column.pack_start(render, False)
|
|
column.add_attribute(render, "stock-id", 5)
|
|
render = gtk.CellRendererText()
|
|
column.pack_start(render, True)
|
|
column.add_attribute(render, "text", 1)
|
|
column.set_expand(True)
|
|
self.listview_files.append_column(column)
|
|
|
|
render = gtk.CellRendererText()
|
|
column = gtk.TreeViewColumn(_("Size"))
|
|
column.pack_start(render)
|
|
column.set_cell_data_func(render, listview.cell_data_size, 2)
|
|
self.listview_files.append_column(column)
|
|
|
|
self.listview_torrents.set_model(self.torrent_liststore)
|
|
self.listview_files.set_model(self.files_treestore)
|
|
|
|
self.listview_files.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
|
|
self.listview_torrents.get_selection().connect("changed",
|
|
self._on_torrent_changed)
|
|
|
|
# Get default config values from the core
|
|
self.core_keys = [
|
|
"compact_allocation",
|
|
"max_connections_per_torrent",
|
|
"max_upload_slots_per_torrent",
|
|
"max_upload_speed_per_torrent",
|
|
"max_download_speed_per_torrent",
|
|
"prioritize_first_last_pieces",
|
|
"download_location",
|
|
"add_paused"
|
|
]
|
|
self.core_config = {}
|
|
|
|
self.glade.get_widget("notebook1").connect("switch-page", self._on_switch_page)
|
|
|
|
def start(self):
|
|
self.update_core_config()
|
|
|
|
def show(self, focus=False):
|
|
self.update_core_config()
|
|
|
|
if client.is_localhost():
|
|
self.glade.get_widget("button_location").show()
|
|
self.glade.get_widget("entry_download_path").hide()
|
|
else:
|
|
self.glade.get_widget("button_location").hide()
|
|
self.glade.get_widget("entry_download_path").show()
|
|
|
|
self.dialog.set_transient_for(component.get("MainWindow").window)
|
|
self.dialog.present()
|
|
if focus:
|
|
self.dialog.window.focus()
|
|
|
|
return None
|
|
|
|
def hide(self):
|
|
self.dialog.hide()
|
|
self.files = {}
|
|
self.infos = {}
|
|
self.options = {}
|
|
self.previous_selected_torrent = None
|
|
self.torrent_liststore.clear()
|
|
self.files_treestore.clear()
|
|
self.dialog.set_transient_for(component.get("MainWindow").window)
|
|
return None
|
|
|
|
def update_core_config(self):
|
|
self.core_config = {}
|
|
|
|
def _on_config_values(config):
|
|
self.core_config = config
|
|
|
|
# Send requests to the core for these config values
|
|
client.get_config_values(_on_config_values, self.core_keys)
|
|
# Force a call to the core because we need this data now
|
|
client.force_call()
|
|
self.set_default_options()
|
|
|
|
def add_from_files(self, filenames):
|
|
import os.path
|
|
new_row = None
|
|
|
|
for filename in filenames:
|
|
# Convert the path to unicode
|
|
filename = unicode(filename)
|
|
|
|
# Get the torrent data from the torrent file
|
|
try:
|
|
info = deluge.ui.common.TorrentInfo(filename)
|
|
except Exception, e:
|
|
log.debug("Unable to open torrent file: %s", e)
|
|
continue
|
|
|
|
if info.info_hash in self.files:
|
|
log.debug("Trying to add a duplicate torrent!")
|
|
continue
|
|
|
|
name = "%s (%s)" % (info.name, os.path.split(filename)[-1])
|
|
new_row = self.torrent_liststore.append(
|
|
[info.info_hash, info.name, filename])
|
|
self.files[info.info_hash] = info.files
|
|
self.infos[info.info_hash] = info.metadata
|
|
self.listview_torrents.get_selection().select_iter(new_row)
|
|
self.set_default_options()
|
|
self.save_torrent_options(new_row)
|
|
|
|
(model, row) = self.listview_torrents.get_selection().get_selected()
|
|
if not row and new_row:
|
|
self.listview_torrents.get_selection().select_iter(new_row)
|
|
|
|
def add_from_magnets(self, uris):
|
|
import base64
|
|
new_row = None
|
|
|
|
for uri in uris:
|
|
info_hash = base64.b32decode(uri.split("&")[0][20:]).encode("hex")
|
|
if info_hash in self.infos:
|
|
log.debug("Torrent already in list!")
|
|
continue
|
|
name = None
|
|
for i in uri.split("&"):
|
|
if i[:3] == "dn=":
|
|
name = "%s (%s)" % (i.split("=")[1], uri)
|
|
if not name:
|
|
name = uri
|
|
new_row = self.torrent_liststore.append(
|
|
[info_hash, name, uri])
|
|
self.files[info_hash] = []
|
|
self.infos[info_hash] = None
|
|
self.listview_torrents.get_selection().select_iter(new_row)
|
|
self.set_default_options()
|
|
self.save_torrent_options(new_row)
|
|
|
|
(model, row) = self.listview_torrents.get_selection().get_selected()
|
|
if not row and new_row:
|
|
self.listview_torrents.get_selection().select_iter(new_row)
|
|
|
|
def _on_torrent_changed(self, treeselection):
|
|
(model, row) = treeselection.get_selected()
|
|
if row is None or not model.iter_is_valid(row):
|
|
self.files_treestore.clear()
|
|
self.previous_selected_torrent = None
|
|
return
|
|
|
|
if model[row][0] not in self.files:
|
|
self.files_treestore.clear()
|
|
self.previous_selected_torrent = None
|
|
return
|
|
|
|
# Save the previous torrents options
|
|
self.save_torrent_options()
|
|
# Update files list
|
|
files_list = self.files[model.get_value(row, 0)]
|
|
|
|
self.prepare_file_store(files_list)
|
|
|
|
if self.core_config == {}:
|
|
self.update_core_config()
|
|
|
|
# Update the options frame
|
|
self.update_torrent_options(model.get_value(row, 0))
|
|
|
|
self.previous_selected_torrent = row
|
|
|
|
def _on_switch_page(self, widget, page, page_num):
|
|
# Save the torrent options when switching notebook pages
|
|
self.save_torrent_options()
|
|
|
|
def prepare_file_store(self, files):
|
|
self.listview_files.set_model(None)
|
|
self.files_treestore.clear()
|
|
split_files = { }
|
|
i = 0
|
|
for file in files:
|
|
self.prepare_file(file, file["path"], i, file["download"], split_files)
|
|
i += 1
|
|
self.add_files(None, split_files)
|
|
self.listview_files.set_model(self.files_treestore)
|
|
self.listview_files.expand_row("0", False)
|
|
|
|
def prepare_file(self, file, file_name, file_num, download, files_storage):
|
|
first_slash_index = file_name.find("/")
|
|
if first_slash_index == -1:
|
|
files_storage[file_name] = (file_num, file, download)
|
|
else:
|
|
file_name_chunk = file_name[:first_slash_index+1]
|
|
if file_name_chunk not in files_storage:
|
|
files_storage[file_name_chunk] = { }
|
|
self.prepare_file(file, file_name[first_slash_index+1:],
|
|
file_num, download, files_storage[file_name_chunk])
|
|
|
|
def add_files(self, parent_iter, split_files):
|
|
ret = 0
|
|
for key,value in split_files.iteritems():
|
|
if key.endswith("/"):
|
|
chunk_iter = self.files_treestore.append(parent_iter,
|
|
[True, key, 0, -1, False, gtk.STOCK_DIRECTORY])
|
|
chunk_size = self.add_files(chunk_iter, value)
|
|
self.files_treestore.set(chunk_iter, 2, chunk_size)
|
|
ret += chunk_size
|
|
else:
|
|
self.files_treestore.append(parent_iter, [value[2], key,
|
|
value[1]["size"], value[0], False, gtk.STOCK_FILE])
|
|
|
|
if parent_iter and self.files_treestore.iter_has_child(parent_iter):
|
|
# Iterate through the children and see what we should label the
|
|
# folder, download true, download false or inconsistent.
|
|
itr = self.files_treestore.iter_children(parent_iter)
|
|
download = []
|
|
download_value = False
|
|
inconsistent = False
|
|
while itr:
|
|
download.append(self.files_treestore.get_value(itr, 0))
|
|
itr = self.files_treestore.iter_next(itr)
|
|
|
|
if sum(download) == len(download):
|
|
download_value = True
|
|
elif sum(download) == 0:
|
|
download_value = False
|
|
else:
|
|
inconsistent = True
|
|
|
|
self.files_treestore.set_value(parent_iter, 0, download_value)
|
|
self.files_treestore.set_value(parent_iter, 4, inconsistent)
|
|
|
|
ret += value[1]["size"]
|
|
return ret
|
|
|
|
def update_torrent_options(self, torrent_id):
|
|
if torrent_id not in self.options:
|
|
self.set_default_options()
|
|
return
|
|
|
|
options = self.options[torrent_id]
|
|
|
|
if client.is_localhost():
|
|
self.glade.get_widget("button_location").set_current_folder(
|
|
options["download_location"])
|
|
else:
|
|
self.glade.get_widget("entry_download_path").set_text(
|
|
options["download_location"])
|
|
|
|
self.glade.get_widget("radio_full").set_active(
|
|
not options["compact_allocation"])
|
|
self.glade.get_widget("radio_compact").set_active(
|
|
options["compact_allocation"])
|
|
self.glade.get_widget("spin_maxdown").set_value(
|
|
options["max_download_speed"])
|
|
self.glade.get_widget("spin_maxup").set_value(
|
|
options["max_upload_speed"])
|
|
self.glade.get_widget("spin_maxconnections").set_value(
|
|
options["max_connections"])
|
|
self.glade.get_widget("spin_maxupslots").set_value(
|
|
options["max_upload_slots"])
|
|
self.glade.get_widget("chk_paused").set_active(
|
|
options["add_paused"])
|
|
self.glade.get_widget("chk_prioritize").set_active(
|
|
options["prioritize_first_last_pieces"])
|
|
|
|
def save_torrent_options(self, row=None):
|
|
# Keeps the torrent options dictionary up-to-date with what the user has
|
|
# selected.
|
|
if row is None:
|
|
if self.previous_selected_torrent and self.torrent_liststore.iter_is_valid(self.previous_selected_torrent):
|
|
row = self.previous_selected_torrent
|
|
else:
|
|
return
|
|
|
|
torrent_id = self.torrent_liststore.get_value(row, 0)
|
|
|
|
options = {}
|
|
if client.is_localhost():
|
|
options["download_location"] = \
|
|
self.glade.get_widget("button_location").get_current_folder()
|
|
else:
|
|
options["download_location"] = \
|
|
self.glade.get_widget("entry_download_path").get_text()
|
|
options["compact_allocation"] = \
|
|
self.glade.get_widget("radio_compact").get_active()
|
|
|
|
if options["compact_allocation"]:
|
|
# We need to make sure all the files are set to download
|
|
def set_download_true(model, path, itr):
|
|
model[path][0] = True
|
|
self.files_treestore.foreach(set_download_true)
|
|
self.update_treeview_toggles(self.files_treestore.get_iter_first())
|
|
|
|
options["max_download_speed"] = \
|
|
self.glade.get_widget("spin_maxdown").get_value()
|
|
options["max_upload_speed"] = \
|
|
self.glade.get_widget("spin_maxup").get_value()
|
|
options["max_connections"] = \
|
|
self.glade.get_widget("spin_maxconnections").get_value_as_int()
|
|
options["max_upload_slots"] = \
|
|
self.glade.get_widget("spin_maxupslots").get_value_as_int()
|
|
options["add_paused"] = \
|
|
self.glade.get_widget("chk_paused").get_active()
|
|
options["prioritize_first_last_pieces"] = \
|
|
self.glade.get_widget("chk_prioritize").get_active()
|
|
|
|
self.options[torrent_id] = options
|
|
|
|
# Save the file priorities
|
|
files_priorities = self.build_priorities(
|
|
self.files_treestore.get_iter_first(), {})
|
|
|
|
if len(files_priorities) > 0:
|
|
for i, file_dict in enumerate(self.files[torrent_id]):
|
|
file_dict["download"] = files_priorities[i]
|
|
|
|
def build_priorities(self, iter, priorities):
|
|
while iter is not None:
|
|
if self.files_treestore.iter_has_child(iter):
|
|
self.build_priorities(self.files_treestore.iter_children(iter),
|
|
priorities)
|
|
elif not self.files_treestore.get_value(iter, 1).endswith("/"):
|
|
priorities[self.files_treestore.get_value(iter, 3)] = self.files_treestore.get_value(iter, 0)
|
|
iter = self.files_treestore.iter_next(iter)
|
|
return priorities
|
|
|
|
def set_default_options(self):
|
|
if client.is_localhost():
|
|
self.glade.get_widget("button_location").set_current_folder(
|
|
self.core_config["download_location"])
|
|
else:
|
|
self.glade.get_widget("entry_download_path").set_text(
|
|
self.core_config["download_location"])
|
|
|
|
self.glade.get_widget("radio_compact").set_active(
|
|
self.core_config["compact_allocation"])
|
|
self.glade.get_widget("radio_full").set_active(
|
|
not self.core_config["compact_allocation"])
|
|
self.glade.get_widget("spin_maxdown").set_value(
|
|
self.core_config["max_download_speed_per_torrent"])
|
|
self.glade.get_widget("spin_maxup").set_value(
|
|
self.core_config["max_upload_speed_per_torrent"])
|
|
self.glade.get_widget("spin_maxconnections").set_value(
|
|
self.core_config["max_connections_per_torrent"])
|
|
self.glade.get_widget("spin_maxupslots").set_value(
|
|
self.core_config["max_upload_slots_per_torrent"])
|
|
self.glade.get_widget("chk_paused").set_active(
|
|
self.core_config["add_paused"])
|
|
self.glade.get_widget("chk_prioritize").set_active(
|
|
self.core_config["prioritize_first_last_pieces"])
|
|
|
|
def get_file_priorities(self, torrent_id):
|
|
# A list of priorities
|
|
files_list = []
|
|
|
|
for file_dict in self.files[torrent_id]:
|
|
if not file_dict["download"]:
|
|
files_list.append(0)
|
|
else:
|
|
files_list.append(1)
|
|
|
|
return files_list
|
|
|
|
def _on_file_toggled(self, render, path):
|
|
# Check to see if we can change file priorities
|
|
(model, row) = self.listview_torrents.get_selection().get_selected()
|
|
if self.options[model[row][0]]["compact_allocation"]:
|
|
return
|
|
(model, paths) = self.listview_files.get_selection().get_selected_rows()
|
|
if len(paths) > 1:
|
|
for path in paths:
|
|
row = model.get_iter(path)
|
|
self.toggle_iter(row)
|
|
else:
|
|
row = model.get_iter(path)
|
|
self.toggle_iter(row)
|
|
self.update_treeview_toggles(self.files_treestore.get_iter_first())
|
|
|
|
def toggle_iter(self, iter, toggle_to=None):
|
|
if toggle_to is None:
|
|
toggle_to = not self.files_treestore.get_value(iter, 0)
|
|
self.files_treestore.set_value(iter, 0, toggle_to)
|
|
if self.files_treestore.iter_has_child(iter):
|
|
child = self.files_treestore.iter_children(iter)
|
|
while child is not None:
|
|
self.toggle_iter(child, toggle_to)
|
|
child = self.files_treestore.iter_next(child)
|
|
|
|
def update_treeview_toggles(self, iter):
|
|
TOGGLE_INCONSISTENT = -1
|
|
this_level_toggle = None
|
|
while iter is not None:
|
|
if self.files_treestore.iter_has_child(iter):
|
|
toggle = self.update_treeview_toggles(
|
|
self.files_treestore.iter_children(iter))
|
|
if toggle == TOGGLE_INCONSISTENT:
|
|
self.files_treestore.set_value(iter, 4, True)
|
|
else:
|
|
self.files_treestore.set_value(iter, 0, toggle)
|
|
#set inconsistent to false
|
|
self.files_treestore.set_value(iter, 4, False)
|
|
else:
|
|
toggle = self.files_treestore.get_value(iter, 0)
|
|
if this_level_toggle is None:
|
|
this_level_toggle = toggle
|
|
elif this_level_toggle != toggle:
|
|
this_level_toggle = TOGGLE_INCONSISTENT
|
|
iter = self.files_treestore.iter_next(iter)
|
|
return this_level_toggle
|
|
|
|
def _on_button_file_clicked(self, widget):
|
|
log.debug("_on_button_file_clicked")
|
|
# Setup the filechooserdialog
|
|
chooser = gtk.FileChooserDialog(_("Choose a .torrent file"),
|
|
None,
|
|
gtk.FILE_CHOOSER_ACTION_OPEN,
|
|
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN,
|
|
gtk.RESPONSE_OK))
|
|
|
|
chooser.set_transient_for(self.dialog)
|
|
chooser.set_select_multiple(True)
|
|
chooser.set_property("skip-taskbar-hint", True)
|
|
|
|
# Add .torrent and * file filters
|
|
file_filter = gtk.FileFilter()
|
|
file_filter.set_name(_("Torrent files"))
|
|
file_filter.add_pattern("*." + "torrent")
|
|
chooser.add_filter(file_filter)
|
|
file_filter = gtk.FileFilter()
|
|
file_filter.set_name(_("All files"))
|
|
file_filter.add_pattern("*")
|
|
chooser.add_filter(file_filter)
|
|
|
|
# Load the 'default_load_path' from the config
|
|
self.config = ConfigManager("gtkui.conf")
|
|
if self.config["default_load_path"] is not None:
|
|
chooser.set_current_folder(self.config["default_load_path"])
|
|
|
|
# Run the dialog
|
|
response = chooser.run()
|
|
|
|
if response == gtk.RESPONSE_OK:
|
|
result = chooser.get_filenames()
|
|
self.config["default_load_path"] = chooser.get_current_folder()
|
|
else:
|
|
chooser.destroy()
|
|
return
|
|
|
|
chooser.destroy()
|
|
self.add_from_files(result)
|
|
|
|
def _on_button_url_clicked(self, widget):
|
|
log.debug("_on_button_url_clicked")
|
|
dialog = self.glade.get_widget("url_dialog")
|
|
entry = self.glade.get_widget("entry_url")
|
|
|
|
dialog.set_default_response(gtk.RESPONSE_OK)
|
|
dialog.set_transient_for(self.dialog)
|
|
entry.grab_focus()
|
|
|
|
if deluge.common.windows_check():
|
|
import win32clipboard as clip
|
|
import win32con
|
|
clip.OpenClipboard()
|
|
text = clip.GetClipboardData(win32con.CF_UNICODETEXT)
|
|
clip.CloseClipboard()
|
|
else:
|
|
clip = gtk.clipboard_get(selection='PRIMARY')
|
|
text = clip.wait_for_text()
|
|
if text:
|
|
text = text.strip()
|
|
if deluge.common.is_url(text) or deluge.common.is_magnet(text):
|
|
entry.set_text(text)
|
|
|
|
dialog.show_all()
|
|
response = dialog.run()
|
|
|
|
if response == gtk.RESPONSE_OK:
|
|
url = entry.get_text().decode("utf_8")
|
|
else:
|
|
url = None
|
|
|
|
# This is where we need to fetch the .torrent file from the URL and
|
|
# add it to the list.
|
|
log.debug("url: %s", url)
|
|
if url != None:
|
|
if deluge.common.is_url(url):
|
|
self.add_from_url(url)
|
|
elif deluge.common.is_magnet(url):
|
|
self.add_from_magnets([url])
|
|
|
|
entry.set_text("")
|
|
dialog.hide()
|
|
|
|
def add_from_url(self, url):
|
|
gobject.idle_add(self._download_from_url, url)
|
|
|
|
def _download_from_url(self, url):
|
|
import urllib
|
|
import tempfile
|
|
import os.path
|
|
tmp_file = os.path.join(tempfile.gettempdir(), url.split("/")[-1])
|
|
filename, headers = urllib.urlretrieve(url, tmp_file)
|
|
log.debug("filename: %s", filename)
|
|
self.add_from_files([filename])
|
|
|
|
def _on_button_hash_clicked(self, widget):
|
|
log.debug("_on_button_hash_clicked")
|
|
dialog = self.glade.get_widget("dialog_infohash")
|
|
entry = self.glade.get_widget("entry_hash")
|
|
textview = self.glade.get_widget("text_trackers")
|
|
|
|
dialog.set_default_response(gtk.RESPONSE_OK)
|
|
dialog.set_transient_for(self.dialog)
|
|
entry.grab_focus()
|
|
dialog.show_all()
|
|
response = dialog.run()
|
|
if response == gtk.RESPONSE_OK and len(entry.get_text()) == 40:
|
|
trackers = []
|
|
b = textview.get_buffer()
|
|
lines = b.get_text(b.get_start_iter(), b.get_end_iter()).strip().split("\n")
|
|
log.debug("lines: %s", lines)
|
|
for l in lines:
|
|
if deluge.common.is_url(l):
|
|
trackers.append(l)
|
|
# Convert the information to a magnet uri, this is just easier to
|
|
# handle this way.
|
|
log.debug("trackers: %s", trackers)
|
|
magnet = deluge.common.create_magnet_uri(
|
|
infohash=entry.get_text().decode("utf_8"),
|
|
trackers=trackers)
|
|
log.debug("magnet uri: %s", magnet)
|
|
self.add_from_magnets([magnet])
|
|
|
|
entry.set_text("")
|
|
textview.get_buffer().set_text("")
|
|
dialog.hide()
|
|
|
|
def _on_button_remove_clicked(self, widget):
|
|
log.debug("_on_button_remove_clicked")
|
|
(model, row) = self.listview_torrents.get_selection().get_selected()
|
|
if row is None:
|
|
return
|
|
|
|
torrent_id = model.get_value(row, 0)
|
|
|
|
model.remove(row)
|
|
del self.files[torrent_id]
|
|
del self.infos[torrent_id]
|
|
|
|
def _on_button_trackers_clicked(self, widget):
|
|
log.debug("_on_button_trackers_clicked")
|
|
|
|
def _on_button_cancel_clicked(self, widget):
|
|
log.debug("_on_button_cancel_clicked")
|
|
self.hide()
|
|
|
|
def _on_button_add_clicked(self, widget):
|
|
log.debug("_on_button_add_clicked")
|
|
# Save the options for selected torrent prior to adding
|
|
(model, row) = self.listview_torrents.get_selection().get_selected()
|
|
if row is not None:
|
|
self.save_torrent_options(row)
|
|
|
|
torrent_filenames = []
|
|
torrent_magnets = []
|
|
torrent_magnet_options = []
|
|
torrent_options = []
|
|
|
|
row = self.torrent_liststore.get_iter_first()
|
|
while row != None:
|
|
torrent_id = self.torrent_liststore.get_value(row, 0)
|
|
filename = self.torrent_liststore.get_value(row, 2)
|
|
try:
|
|
options = self.options[torrent_id]
|
|
except:
|
|
options = None
|
|
|
|
file_priorities = self.get_file_priorities(torrent_id)
|
|
if options != None:
|
|
options["file_priorities"] = file_priorities
|
|
|
|
if deluge.common.is_magnet(filename):
|
|
torrent_magnets.append(filename)
|
|
del options["file_priorities"]
|
|
torrent_magnet_options.append(options)
|
|
else:
|
|
torrent_filenames.append(filename)
|
|
torrent_options.append(options)
|
|
|
|
row = self.torrent_liststore.iter_next(row)
|
|
|
|
if torrent_filenames:
|
|
client.add_torrent_file(torrent_filenames, torrent_options)
|
|
if torrent_magnets:
|
|
client.add_torrent_magnets(torrent_magnets, torrent_magnet_options)
|
|
|
|
client.force_call(False)
|
|
self.hide()
|
|
|
|
def _on_button_apply_clicked(self, widget):
|
|
log.debug("_on_button_apply_clicked")
|
|
(model, row) = self.listview_torrents.get_selection().get_selected()
|
|
if row is None:
|
|
return
|
|
|
|
self.save_torrent_options(row)
|
|
|
|
# The options we want all the torrents to have
|
|
options = self.options[model.get_value(row, 0)]
|
|
|
|
# Set all the torrent options
|
|
row = model.get_iter_first()
|
|
while row != None:
|
|
torrent_id = model.get_value(row, 0)
|
|
self.options[torrent_id] = options
|
|
row = model.iter_next(row)
|
|
|
|
def _on_button_revert_clicked(self, widget):
|
|
log.debug("_on_button_revert_clicked")
|
|
(model, row) = self.listview_torrents.get_selection().get_selected()
|
|
if row is None:
|
|
return
|
|
|
|
del self.options[model.get_value(row, 0)]
|
|
self.set_default_options()
|
|
|
|
def _on_delete_event(self, widget, event):
|
|
self.hide()
|
|
return True
|