#!/usr/bin/env python # # delugegtk.py # # Copyright (C) Zach Tibbitts 2006 # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2, or (at your option) # any later version. # # This program 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 this program. If not, write to: # The Free Software Foundation, Inc., # 51 Franklin Street, Fifth Floor # Boston, MA 02110-1301, USA. import sys, os, os.path, gettext, urllib import deluge, dcommon, dgtk, delugeplugins import pygtk pygtk.require('2.0') import gtk, gtk.glade, gobject import xdg, xdg.BaseDirectory import dbus, dbus.service if getattr(dbus, 'version', (0,0,0)) >= (0,41,0): import dbus.glib _ = gettext.gettext class DelugeGTK(dbus.service.Object): ## external_add_torrent should only be called from outside the class @dbus.service.method('org.deluge_torrent.DelugeInterface') def external_add_torrent(self, torrent_file): print "Ding!" print "Got torrent externally:", os.path.basename(torrent_file) print "\tNow, what to do with it?" if self.is_running: print "\t\tthe client seems to already be running, i'll try and add the torrent" uid = self.manager.add_torrent(torrent_file, ".", True) self.store.append(self.get_list_from_unique_id(uid)) else: print "\t\tthe client hasn't started yet, I'll queue the torrent" self.torrent_file_queue.append(torrent_file) def __init__(self, bus_name=dbus.service.BusName('org.deluge_torrent.Deluge', bus=dbus.SessionBus()), object_path='/org/deluge_torrent/DelugeObject'): dbus.service.Object.__init__(self, bus_name, object_path) self.is_running = False self.torrent_file_queue = [] #Load up a config file: self.conf_file = dcommon.CONFIG_DIR + '/deluge.conf' if os.path.isdir(self.conf_file): print 'Weird, the file I was trying to write to, %s, is an existing directory'%(self.conf_file) sys.exit(0) if not os.path.isfile(self.conf_file): f = open(self.conf_file, mode='w') f.flush() f.close() self.pref = dcommon.DelugePreferences() self.load_default_settings() self.pref.load_from_file(self.conf_file) #Start the Deluge Manager: self.manager = deluge.Manager("DE", "0490", "Deluge 0.4.90", dcommon.CONFIG_DIR) #Set up the interface: self.wtree = gtk.glade.XML(dcommon.get_glade_file("delugegtk.glade")) self.window = self.wtree.get_widget("main_window") self.window.hide() self.toolbar = self.wtree.get_widget("tb_middle") if(self.window): self.window.connect("destroy", self.quit) self.window.set_title('%s %s'%(dcommon.PROGRAM_NAME, dcommon.PROGRAM_VERSION)) self.window.set_icon_from_file(dcommon.get_pixmap("deluge32.png")) self.plugins = delugeplugins.PluginManager(self.manager, self) self.plugins.add_plugin_dir(dcommon.PLUGIN_DIR) if os.path.isdir(dcommon.CONFIG_DIR + '/plugins'): self.plugins.add_plugin_dir(dcommon.CONFIG_DIR + '/plugins') self.plugins.scan_for_plugins() ## Construct the Interface self.build_tray_icon() self.build_about_dialog() self.build_pref_dialog() self.build_torrent_table() self.build_summary_tab() self.build_file_tab() self.build_peer_tab() self.connect_signals() self.apply_prefs() def connect_signals(self): self.wtree.signal_autoconnect({ ## File Menu "add_torrent": self.add_torrent_clicked, "add_torrent_url": self.add_torrent_url_clicked, "remove_torrent" : self.remove_torrent_clicked, "menu_quit": self.quit, ## Edit Menu "pref_clicked": self.show_pref_dialog, "plugins_clicked": self.show_plugin_dialog, ## View Menu "infopane_toggle": self.infopane_toggle, "size_toggle": self.size_toggle, "status_toggle": self.status_toggle, "seeders_toggle": self.seeders_toggle, "peers_toggle": self.peers_toggle, "dl_toggle": self.dl_toggle, "ul_toggle": self.ul_toggle, "eta_toggle": self.eta_toggle, "share_toggle": self.share_toggle, ## Help Menu "show_about_dialog": self.show_about_dialog, ## Toolbar "update_tracker": self.update_tracker, "clear_finished": self.clear_finished, "queue_up": self.q_torrent_up, "queue_down": self.q_torrent_down, ## Other events "torrentrow_click": self.torrentview_clicked, }) def build_tray_icon(self): self.tray = gtk.StatusIcon() self.tray.set_from_file(dcommon.get_pixmap("deluge32.png")) self.tray.set_tooltip("Deluge BitTorrent Client") tray_glade = gtk.glade.XML(dcommon.get_glade_file("dgtkpopups.glade")) self.tray_menu = tray_glade.get_widget("tray_menu") dic = { "show_hide_window": self.force_show_hide, "add_torrent": self.add_torrent_clicked, "clear_finished": self.clear_finished, "preferences": self.show_pref_dialog, "plugins": self.show_plugin_dialog, "quit": self.quit, } tray_glade.signal_autoconnect(dic) self.tray.connect("popup-menu", self.tray_popup, None) self.tray.connect("activate", self.tray_clicked, None) def tray_popup(self, status_icon, button, activate_time, arg0=None): self.tray_menu.popup(None, None, gtk.status_icon_position_menu, button, activate_time, self.tray) def tray_clicked(self, status_icon=None, arg=None): if self.window.get_property("visible"): if self.window.is_active(): self.window.hide() else: self.window.present() else: self.window.show() def force_show_hide(self, arg=None): if self.window.get_property("visible"): self.window.hide() else: self.window.show() def build_about_dialog(self): gtk.about_dialog_set_url_hook(dcommon.open_url_in_browser) self.abt = gtk.AboutDialog() self.abt.set_name(dcommon.PROGRAM_NAME) self.abt.set_version(dcommon.PROGRAM_VERSION) self.abt.set_authors(["Zach Tibbits", "A. Zakai"]) self.abt.set_artists(["Andrew Wedderburn"]) self.abt.set_website("http://deluge-torrent.org") self.abt.set_icon_from_file(dcommon.get_pixmap("deluge32.png")) self.abt.set_logo(gtk.gdk.pixbuf_new_from_file( dcommon.get_pixmap("deluge32.png"))) def build_pref_dialog(self): self.prf_glade = gtk.glade.XML(dcommon.get_glade_file("dgtkpref.glade")) self.prf = self.prf_glade.get_widget("pref_dialog") self.prf.set_icon_from_file(dcommon.get_pixmap("deluge32.png")) self.prf_glade.signal_autoconnect({"tray_toggle": self.tray_toggle,}) self.plugin_dlg = self.prf_glade.get_widget("plugin_dialog") self.plugin_dlg.set_icon_from_file(dcommon.get_pixmap("deluge32.png")) self.plugin_view = self.prf_glade.get_widget("plugin_view") self.plugin_store = gtk.ListStore(str, bool) self.plugin_view.set_model(self.plugin_store) self.plugin_view.get_selection().set_select_function(self.plugin_clicked, full=True ) name_col = dgtk.add_text_column(self.plugin_view, "Name", 0) name_col.set_expand(True) dgtk.add_toggle_column(self.plugin_view, "Enabled", 1, toggled_signal=self.plugin_toggled) self.prf_glade.signal_autoconnect({'plugin_pref': self.plugin_pref}) def plugin_clicked(self, selection, model, path, is_selected): if is_selected: return True name = model.get_value(model.get_iter(path), 0) plugin = self.plugins.get_plugin(name) version = plugin['version'] config = plugin['config'] description = plugin['description'] self.prf_glade.get_widget("plugin_conf").set_sensitive(config) self.prf_glade.get_widget("plugin_text").get_buffer( ).set_text("%s\nVersion: %s\n\n%s"% (name, version, description)) return True def plugin_toggled(self, renderer, path): plugin_iter = self.plugin_store.get_iter_from_string(path) plugin_name = self.plugin_store.get_value(plugin_iter, 0) plugin_value = not self.plugin_store.get_value(plugin_iter, 1) self.plugin_store.set_value(plugin_iter, 1, plugin_value) if plugin_value: self.plugins.enable_plugin(plugin_name) else: self.plugins.disable_plugin(plugin_name) def plugin_pref(self, widget=None): (model, plugin_iter) = self.plugin_view.get_selection().get_selected() plugin_name = self.plugin_store.get_value(plugin_iter, 0) self.plugins.configure_plugin(plugin_name) def build_torrent_table(self): ## Create the torrent listview self.view = self.wtree.get_widget("torrent_view") # UID, Q#, Name, Size, Progress, Message, Seeders, Peers, DL, UL, ETA, Share self.store = gtk.ListStore(int, int, str, str, float, str, str, str, str, str, str, str) self.view.set_model(self.store) self.view.set_rules_hint(True) self.view.set_reorderable(True) ## Initializes the columns for the torrent_view #Just found out there are built-in pygtk methods with similar functionality #to these, perhaps I should look into using those. self.queue_column = dgtk.add_text_column(self.view, "#", 1) self.name_column = dgtk.add_text_column(self.view, "Name", 2) self.size_column = dgtk.add_text_column(self.view, "Size", 3) self.status_column = dgtk.add_progress_column(self.view, "Status", 4, 5) self.seed_column = dgtk.add_text_column(self.view, "Seeders", 6) self.peer_column = dgtk.add_text_column(self.view, "Peers", 7) self.dl_column = dgtk.add_text_column(self.view, "Download", 8) self.ul_column = dgtk.add_text_column(self.view, "Upload", 9) self.eta_column = dgtk.add_text_column(self.view, "Time Remaining", 10) self.share_column = dgtk.add_text_column(self.view, "Ratio", 11) self.status_column.set_expand(True) def build_summary_tab(self): #Torrent Summary tab # Look into glade's widget prefix function self.text_summary_title = self.wtree.get_widget("summary_title") self.text_summary_total_size = self.wtree.get_widget("summary_total_size") self.text_summary_pieces = self.wtree.get_widget("summary_pieces") self.text_summary_total_downloaded = self.wtree.get_widget("summary_total_downloaded") self.text_summary_total_uploaded = self.wtree.get_widget("summary_total_uploaded") self.text_summary_download_rate = self.wtree.get_widget("summary_download_rate") self.text_summary_upload_rate = self.wtree.get_widget("summary_upload_rate") self.text_summary_seeders = self.wtree.get_widget("summary_seeders") self.text_summary_peers = self.wtree.get_widget("summary_peers") self.text_summary_percentage_done = self.wtree.get_widget("summary_percentage_done") self.text_summary_share_ratio = self.wtree.get_widget("summary_share_ratio") self.text_summary_downloaded_this_session = self.wtree.get_widget("summary_downloaded_this_session") self.text_summary_uplodaded_this_session = self.wtree.get_widget("summary_uploaded_this_session") self.text_summary_tracker = self.wtree.get_widget("summary_tracker") self.text_summary_tracker_response = self.wtree.get_widget("summary_tracker_response") self.text_summary_tracker_status = self.wtree.get_widget("summary_tracker_status") self.text_summary_next_announce = self.wtree.get_widget("summary_next_announce") self.text_summary_compact_allocation = self.wtree.get_widget("summary_compact_allocation") self.text_summary_eta = self.wtree.get_widget("summary_eta") def build_peer_tab(self): self.peer_view = self.wtree.get_widget("peer_view") self.peer_store = gtk.ListStore(str, str, str, str, str) self.peer_view.set_model(self.peer_store) self.peer_ip_column = dgtk.add_text_column(self.peer_view, "IP Address", 0) self.peer_client_column = dgtk.add_text_column(self.peer_view, "Client", 1) ## Note: (maybe) change this column to use a progress column before 0.5 is released self.peer_complete_column = dgtk.add_text_column(self.peer_view, "Percent Complete", 2) self.peer_download_column = dgtk.add_text_column(self.peer_view, "Download Rate", 3) self.peer_upload_column = dgtk.add_text_column(self.peer_view, "Upload Rate", 4) def build_file_tab(self): self.file_view = self.wtree.get_widget("file_view") self.file_store = gtk.ListStore(str, bool) self.file_view.set_model(self.file_store) self.filename_column = dgtk.add_text_column(self.file_view, "Filename", 0) self.filetoggle_column = dgtk.add_toggle_column(self.file_view, "DL?", 0) self.filename_column.set_expand(True) def load_default_settings(self): self.pref.set("enable_system_tray", True) self.pref.set("close_to_tray", False) self.pref.set("use_default_dir", False) self.pref.set("default_download_path", os.path.expandvars('$HOME')) self.pref.set("auto_end_seeding", False) self.pref.set("end_seed_ratio", 1.0) self.pref.set("use_compact_storage", False) self.pref.set("tcp_port_range_lower", 6881) self.pref.set("tcp_port_range_upper", 6889) self.pref.set("max_upload_rate", 0) self.pref.set("max_number_uploads", 0) self.pref.set("max_download_rate", 0) self.pref.set("max_number_downloads", 0) def show_about_dialog(self, arg=None): self.abt.show_all() self.abt.run() self.abt.hide_all() def show_pref_dialog(self, arg=None): #Try to get current settings from pref, if an error occurs, the default settings will be used: try: # Page 1 self.prf_glade.get_widget("chk_use_tray").set_active(self.pref.get("enable_system_tray", bool)) self.prf_glade.get_widget("chk_min_on_close").set_active(self.pref.get("close_to_tray", bool)) if(self.pref.get("use_default_dir", bool)): self.prf_glade.get_widget("radio_save_all_to").set_active(True) else: self.prf_glade.get_widget("radio_ask_save").set_active(True) self.prf_glade.get_widget("download_path_button").set_filename(self.pref.get("default_download_path", str)) self.prf_glade.get_widget("chk_autoseed").set_active(self.pref.get("auto_end_seeding", bool)) self.prf_glade.get_widget("ratio_spinner").set_value(self.pref.get("end_seed_ratio", float)) self.prf_glade.get_widget("chk_compact").set_active(self.pref.get("use_compact_storage", bool)) # Page 2 self.prf_glade.get_widget("spin_port_min").set_value(self.pref.get("tcp_port_range_lower", int)) self.prf_glade.get_widget("spin_port_max").set_value(self.pref.get("tcp_port_range_upper", int)) self.prf_glade.get_widget("spin_max_upload").set_value(self.pref.get("max_upload_rate", int)) self.prf_glade.get_widget("spin_num_upload").set_value(self.pref.get("max_number_uploads", int)) self.prf_glade.get_widget("spin_max_download").set_value(self.pref.get("max_download_rate", int)) self.prf_glade.get_widget("spin_num_download").set_value(self.pref.get("max_number_downloads", int)) except KeyError: pass self.prf.show_all() result = self.prf.run() self.prf.hide_all() print result if result == 1: self.pref.set("enable_system_tray", self.prf_glade.get_widget("chk_use_tray").get_active()) self.pref.set("close_to_tray", self.prf_glade.get_widget("chk_min_on_close").get_active()) self.pref.set("use_default_dir", self.prf_glade.get_widget("radio_save_all_to").get_active()) self.pref.set("default_download_path", self.prf_glade.get_widget("download_path_button").get_filename()) self.pref.set("auto_end_seeding", self.prf_glade.get_widget("chk_autoseed").get_active()) self.pref.set("end_seed_ratio", self.prf_glade.get_widget("ratio_spinner").get_value()) self.pref.set("use_compact_storage", self.prf_glade.get_widget("chk_compact").get_active()) self.pref.set("tcp_port_range_lower", self.prf_glade.get_widget("spin_port_min").get_value()) self.pref.set("tcp_port_range_upper", self.prf_glade.get_widget("spin_port_max").get_value()) self.pref.set("max_upload_rate", self.prf_glade.get_widget("spin_max_upload").get_value()) self.pref.set("max_number_uploads", self.prf_glade.get_widget("spin_num_upload").get_value()) self.pref.set("max_download_rate", self.prf_glade.get_widget("spin_max_download").get_value()) self.pref.set("max_number_downloads", self.prf_glade.get_widget("spin_num_download").get_value()) self.pref.save_to_file(self.conf_file) self.apply_prefs() def show_plugin_dialog(self, arg=None): self.plugin_store.clear() for plugin in self.plugins.get_available_plugins(): if plugin in self.plugins.get_enabled_plugins(): self.plugin_store.append( (plugin, True) ) else: self.plugin_store.append( (plugin, False) ) self.plugin_dlg.show() self.plugin_dlg.run() self.plugin_dlg.hide() def tray_toggle(self, obj): if obj.get_active(): self.prf_glade.get_widget("chk_min_on_close").set_sensitive(True) else: self.prf_glade.get_widget("chk_min_on_close").set_sensitive(False) def apply_prefs(self): pass # UID, Q#, Name, Size, Progress, Message, Seeders, Peers, DL, UL, ETA, Share def get_list_from_unique_id(self, unique_id): state = self.manager.get_torrent_state(unique_id) queue = int(state['queue_pos']) + 1 name = state['name'] size = dcommon.fsize(state['total_size']) progress = float(state['progress'] * 100) message = '%s %d%%'%(deluge.STATE_MESSAGES[state['state']], int(state['progress'] * 100)) seeds = dcommon.fseed(state) peers = dcommon.fpeer(state) dlrate = dcommon.frate(state['download_rate']) ulrate = dcommon.frate(state['upload_rate']) eta = dcommon.estimate_eta(state) share = self.calc_share_ratio(unique_id, state) return [unique_id, queue, name, size, progress, message, seeds, peers, dlrate, ulrate, eta, share] ## Start the timer that updates the interface def start(self, hidden=False): if not hidden: self.window.show() # go through torrent files to add #dummy preferences values: use_default_download_location = True default_download_location = "." for torrent_file in self.torrent_file_queue: print "adding torrent", torrent_file try: self.manager.add_torrent(torrent_file, ".", True) except deluge.DelugeError: print "duplicate torrent found, ignoring", torrent_file ## add torrents in manager to interface for uid in self.manager.get_unique_IDs(): self.store.append(self.get_list_from_unique_id(uid)) gobject.timeout_add(1000, self.update) try: self.is_running = True gtk.main() except KeyboardInterrupt: self.manager.quit() ## Call via a timer to update the interface def update(self): # Make sure that the interface still exists try: tab = self.wtree.get_widget("torrent_info").get_current_page() except AttributeError: return False self.plugins.update_active_plugins() # If no torrent is selected, select the first torrent: (temp, selection) = self.view.get_selection().get_selected() if selection is None: self.view.get_selection().select_path("0") #Torrent List itr = self.store.get_iter_first() if itr is None: return True while itr is not None: uid = self.store.get_value(itr, 0) try: state = self.manager.get_torrent_state(uid) tlist = self.get_list_from_unique_id(uid) for i in range(12): self.store.set_value(itr, i, tlist[i]) itr = self.store.iter_next(itr) except deluge.InvalidUniqueIDError: self.store.remove(itr) if not self.store.iter_is_valid(itr): itr = None self.saved_peer_info = None if tab == 0: #Details Pane try: state = self.manager.get_torrent_state(self.get_selected_torrent()) except deluge.InvalidUniqueIDError: return True self.wtree.get_widget("progressbar").set_text('%s %s'%(str(state["name"]), dcommon.fpcnt(state["progress"]))) self.text_summary_total_size.set_text(dcommon.fsize(state["total_size"])) self.text_summary_pieces.set_text(str(state["pieces"])) self.text_summary_total_downloaded.set_text(dcommon.fsize(state["total_download"])) self.text_summary_total_uploaded.set_text(dcommon.fsize(state["total_upload"])) self.text_summary_download_rate.set_text(dcommon.frate(state["download_rate"])) self.text_summary_upload_rate.set_text(dcommon.frate(state["upload_rate"])) self.text_summary_seeders.set_text(dcommon.fseed(state)) self.text_summary_peers.set_text(dcommon.fpeer(state)) self.wtree.get_widget("progressbar").set_fraction(float(state['progress'])) self.text_summary_share_ratio.set_text(self.calc_share_ratio(self.get_selected_torrent(), state)) #self.text_summary_downloaded_this_session.set_text(str(state[""])) #self.text_summary_uplodaded_this_session.set_text(str(state[""])) self.text_summary_tracker.set_text(str(state["tracker"])) #self.text_summary_tracker_response.set_text(str(state[""])) self.text_summary_tracker_status.set_text(str(state["tracker_ok"])) self.text_summary_next_announce.set_text(str(state["next_announce"])) #self.text_summary_compact_allocation.set_text(str(state[""])) self.text_summary_eta.set_text(dcommon.estimate_eta(state)) elif tab == 1: #Peers List unique_id = self.get_selected_torrent() if self.saved_peer_info is None: self.saved_peer_info = self.manager.get_torrent_peer_info(unique_id) new_peer_info = self.saved_peer_info new_ips = {} for index in range(len(new_peer_info)): if not new_peer_info[index]['client'] == "": assert(new_peer_info[index]['ip'] not in new_ips.keys()) new_ips[new_peer_info[index]['ip']] = index def biographer(model, path, iter, dictionary): assert(model.get_value(iter, 0) not in dictionary.keys()) dictionary[model.get_value(iter, 0)] = model.get_string_from_iter(iter) class remover_data: def __init__(self, new_ips): self.new_ips = new_ips self.removed = False def remover(model, path, iter, data): if model.get_value(iter, 0) not in data.new_ips: model.remove(iter) data.removed = True return True else: return False while True: data = remover_data(new_ips.keys()) self.peer_store.foreach(remover, data) if not data.removed: break curr_ips = {} self.peer_store.foreach(biographer, curr_ips) assert(self.peer_store.iter_n_children(None) == len(curr_ips.keys())) for peer in new_peer_info: if peer['ip'] in curr_ips.keys(): self.peer_store.set(self.peer_store.get_iter_from_string(curr_ips[peer['ip']]), 1, unicode(peer['client'], 'Latin-1'), 2, peer['peer_has'], 3, peer['download_speed'], 4, peer['upload_speed']) for peer in new_peer_info: if peer['ip'] not in curr_ips.keys() and peer['client'] is not "": self.peer_store.append([peer["ip"], unicode(peer["client"], 'Latin-1'), peer["peer_has"], peer["download_speed"], peer["upload_speed"]]) elif tab == 2: #File List pass else: pass return True def calc_share_ratio(self, unique_id, torrent_state): r = self.manager.calc_ratio(unique_id, torrent_state) return '%.2f'%(r) def get_selected_torrent(self): try: return self.store.get_value(self.view.get_selection().get_selected()[1], 0) except TypeError: return None def interactive_add_torrent(self, torrent): if self.pref.get('use_default_dir', bool): path = self.pref.get('default_download_path') else: path = dgtk.show_directory_chooser_dialog(self.window) if path is None: return unique_id = self.manager.add_torrent(torrent, path, True) self.store.append(self.get_list_from_unique_id(unique_id)) def add_torrent_clicked(self, obj=None): torrent = dgtk.show_file_open_dialog() if torrent is not None: self.interactive_add_torrent(torrent) def add_torrent_url_clicked(self, obj=None): dlg = gtk.Dialog(title="Add torrent from URL", parent=self.window, buttons=(gtk.STOCK_CANCEL, 0, gtk.STOCK_OK, 1)) dlg.set_icon_from_file(dcommon.get_pixmap("deluge32.png")) label = gtk.Label("Enter the URL of the .torrent to download") entry = gtk.Entry() dlg.vbox.pack_start(label) dlg.vbox.pack_start(entry) dlg.show_all() result = dlg.run() url = entry.get_text() dlg.destroy() if result == 1: opener = urllib.URLopener() filename, headers = opener.retrieve(url) if filename.endswith(".torrent") or headers["content-type"]=="application/x=bittorrent": self.interactive_add_torrent(filename) def remove_torrent_clicked(self, obj=None): torrent = self.get_selected_torrent() if torrent is not None: glade = gtk.glade.XML(dcommon.get_glade_file("dgtkpopups.glade")) asker = glade.get_widget("remove_torrent_dlg") warning = glade.get_widget("warning") warning.set_text(" ") data_also = glade.get_widget("data_also") data_also.connect("toggled", self.remove_toggle_warning, warning) response = asker.run() asker.destroy() if response == 1: self.manager.remove_torrent(torrent, data_also.get_active()) def remove_toggle_warning(self, args, warning): if not args.get_active(): warning.set_text(" ") else: warning.set_markup("" + "Warning - all downloaded files for this torrent will be deleted!" + "") return False def update_tracker(self, obj=None): torrent = self.get_selected_torrent() if torrent is not None: self.manager.update_tracker(torrent) def clear_finished(self, obj=None): self.manager.clear_completed() def q_torrent_up(self, obj=None): torrent = self.get_selected_torrent() if torrent is not None: self.manager.queue_up(torrent) def q_torrent_down(self, obj=None): torrent = self.get_selected_torrent() if torrent is not None: self.manager.queue_up(torrent) def torrentview_clicked(self, widget, event): pass def infopane_toggle(self, widget): if widget.get_active(): self.wtree.get_widget("torrent_info").show() else: self.wtree.get_widget("torrent_info").hide() def size_toggle(self, obj): self.size_column.set_visible(obj.get_active()) def status_toggle(self, obj): self.status_column.set_visible(obj.get_active()) def seeders_toggle(self, obj): self.seed_column.set_visible(obj.get_active()) def peers_toggle(self, obj): self.peer_column.set_visible(obj.get_active()) def dl_toggle(self, obj): self.dl_column.set_visible(obj.get_active()) def ul_toggle(self, obj): self.ul_column.set_visible(obj.get_active()) def eta_toggle(self, obj): self.eta_column.set_visible(obj.get_active()) def share_toggle(self, obj): self.share_column.set_visible(obj.get_active()) def quit(self, obj=None): self.manager.quit() gtk.main_quit() ## For testing purposes, create a copy of the interface if __name__ == "__main__": interface = DelugeGTK() interface.start()