def __init__(self, parent):
QtGui.QDialog.__init__(
self, parent,
QtCore.Qt.WindowTitleHint | QtCore.Qt.WindowSystemMenuHint)
self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
self.setupUi(self)
self.ui_config = ConfigManager("qtui.conf")
self.default_options = {}
self._selected_item = None
self.download_location_browse.setVisible(client.is_localhost())
self.EMPTY_FILE_MODEL = TorrentFileModel([], self)
self.tree_files.setModel(self.EMPTY_FILE_MODEL)
header = self.tree_files.header()
header.setStretchLastSection(False)
header.setMinimumSectionSize(header.fontMetrics().width("M") * 10)
header.setResizeMode(0, QtGui.QHeaderView.Stretch)
header.setResizeMode(
1, QtGui.QHeaderView.Fixed) # NB: ResizeToContents is slow
HeightFixItemDelegate.install(self.tree_files)
self._update_default_options()
def __init__(self):
component.Component.__init__(self, "ToolBar")
log.debug("ToolBar Init..")
self.window = component.get("MainWindow")
self.toolbar = self.window.main_glade.get_object("toolbar")
self.config = ConfigManager("gtkui.conf")
### Connect Signals ###
self.window.insert_signals({
"on_toolbutton_add_clicked": self.on_toolbutton_add_clicked,
"on_toolbutton_remove_clicked": self.on_toolbutton_remove_clicked,
"on_toolbutton_pause_clicked": self.on_toolbutton_pause_clicked,
"on_toolbutton_resume_clicked": self.on_toolbutton_resume_clicked,
"on_toolbutton_preferences_clicked": \
self.on_toolbutton_preferences_clicked,
"on_toolbutton_connectionmanager_clicked": \
self.on_toolbutton_connectionmanager_clicked,
"on_toolbutton_queue_up_clicked": self.on_toolbutton_queue_up_clicked,
"on_toolbutton_queue_down_clicked": self.on_toolbutton_queue_down_clicked
})
self.change_sensitivity = [
"toolbutton_add", "toolbutton_remove", "toolbutton_pause",
"toolbutton_resume", "toolbutton_queue_up", "toolbutton_queue_down"
]
# Hide if necessary
self.visible(self.config["show_toolbar"])
def __init__(self):
component.Component.__init__(self, 'SystemTray', interval=4)
self.mainwindow = component.get('MainWindow')
self.config = ConfigManager('gtkui.conf')
# List of widgets that need to be hidden when not connected to a host
self.hide_widget_list = [
'menuitem_add_torrent',
'menuitem_pause_session',
'menuitem_resume_session',
'menuitem_download_limit',
'menuitem_upload_limit',
'menuitem_quitdaemon',
'separatormenuitem1',
'separatormenuitem2',
'separatormenuitem3',
'separatormenuitem4',
]
self.config.register_set_function('enable_system_tray',
self.on_enable_system_tray_set)
# bit of a hack to prevent function from doing something on startup
self.__enabled_set_once = False
self.config.register_set_function('enable_appindicator',
self.on_enable_appindicator_set)
self.max_download_speed = -1.0
self.download_rate = 0.0
self.max_upload_speed = -1.0
self.upload_rate = 0.0
self.config_value_changed_dict = {
'max_download_speed': self._on_max_download_speed,
'max_upload_speed': self._on_max_upload_speed,
}
def __init__(self):
component.Component.__init__(self, "SystemTray", interval=4)
self.window = component.get("MainWindow")
self.config = ConfigManager("gtkui.conf")
# List of widgets that need to be hidden when not connected to a host
self.hide_widget_list = [
"menuitem_add_torrent", "menuitem_pause_all",
"menuitem_resume_all", "menuitem_download_limit",
"menuitem_upload_limit", "menuitem_quitdaemon",
"separatormenuitem1", "separatormenuitem2", "separatormenuitem3",
"separatormenuitem4"
]
self.config.register_set_function("enable_system_tray",
self.on_enable_system_tray_set)
# bit of a hack to prevent function from doing something on startup
self.__enabled_set_once = False
self.config.register_set_function("enable_appindicator",
self.on_enable_appindicator_set)
self.max_download_speed = -1.0
self.download_rate = 0.0
self.max_upload_speed = -1.0
self.upload_rate = 0.0
self.config_value_changed_dict = {
"max_download_speed": self._on_max_download_speed,
"max_upload_speed": self._on_max_upload_speed
}
def __init__(self):
component.Component.__init__(self,
"QueuedTorrents",
depend=["StatusBar", "AddTorrentDialog"])
self.queue = []
self.status_item = None
self.config = ConfigManager("gtkui.conf")
self.glade = gtk.glade.XML(
pkg_resources.resource_filename("deluge.ui.gtkui",
"glade/queuedtorrents.glade"))
self.glade.get_widget("chk_autoadd").set_active(
self.config["autoadd_queued"])
self.dialog = self.glade.get_widget("queued_torrents_dialog")
self.dialog.set_icon(common.get_logo(32))
self.glade.signal_autoconnect({
"on_button_remove_clicked":
self.on_button_remove_clicked,
"on_button_clear_clicked":
self.on_button_clear_clicked,
"on_button_close_clicked":
self.on_button_close_clicked,
"on_button_add_clicked":
self.on_button_add_clicked,
"on_chk_autoadd_toggled":
self.on_chk_autoadd_toggled
})
self.treeview = self.glade.get_widget("treeview")
self.treeview.append_column(
gtk.TreeViewColumn(_("Torrent"), gtk.CellRendererText(), text=0))
self.liststore = gtk.ListStore(str, str)
self.treeview.set_model(self.liststore)
def __init__(self):
component.Component.__init__(
self, 'QueuedTorrents', depend=['StatusBar', 'AddTorrentDialog']
)
self.queue = []
self.status_item = None
self.config = ConfigManager('gtk3ui.conf')
self.builder = Builder()
self.builder.add_from_file(
deluge.common.resource_filename(
__package__, os.path.join('glade', 'queuedtorrents.ui')
)
)
self.builder.get_object('chk_autoadd').set_active(self.config['autoadd_queued'])
self.dialog = self.builder.get_object('queued_torrents_dialog')
self.dialog.set_icon(get_logo(32))
self.builder.connect_signals(self)
self.treeview = self.builder.get_object('treeview')
self.treeview.append_column(
TreeViewColumn(_('Torrent'), CellRendererText(), text=0)
)
self.liststore = ListStore(str, str)
self.treeview.set_model(self.liststore)
self.treeview.set_tooltip_column(1)
def enable(self):
self.config = ConfigManager("execute.conf", DEFAULT_CONFIG)
event_manager = component.get("EventManager")
self.torrent_manager = component.get("TorrentManager")
self.registered_events = {}
self.preremoved_cache = {}
# Go through the commands list and register event handlers
for command in self.config["commands"]:
event = command[EXECUTE_EVENT]
if event in self.registered_events:
continue
def create_event_handler(event):
def event_handler(torrent_id):
self.execute_commands(torrent_id, event)
return event_handler
event_handler = create_event_handler(event)
event_manager.register_event_handler(EVENT_MAP[event],
event_handler)
if event == "removed":
event_manager.register_event_handler("PreTorrentRemovedEvent",
self.on_preremoved)
self.registered_events[event] = event_handler
log.debug("Execute core plugin enabled!")
def enable(self):
self.config = ConfigManager('execute.conf', DEFAULT_CONFIG)
event_manager = component.get('EventManager')
self.registered_events = {}
self.preremoved_cache = {}
# Go through the commands list and register event handlers
for command in self.config['commands']:
event = command[EXECUTE_EVENT]
if event in self.registered_events:
continue
def create_event_handler(event):
def event_handler(torrent_id, *arg):
self.execute_commands(torrent_id, event, *arg)
return event_handler
event_handler = create_event_handler(event)
event_manager.register_event_handler(EVENT_MAP[event],
event_handler)
if event == 'removed':
event_manager.register_event_handler('PreTorrentRemovedEvent',
self.on_preremoved)
self.registered_events[event] = event_handler
log.debug('Execute core plugin enabled!')
def __init__(self):
gtk.DrawingArea.__init__(self)
# Get progress bar styles, in order to keep font consistency
pb = gtk.ProgressBar()
pb_style = pb.get_style()
self.__text_font = pb_style.font_desc
self.__text_font.set_weight(pango.WEIGHT_BOLD)
# Done with the ProgressBar styles, don't keep refs of it
del pb, pb_style
self.set_size_request(-1, 25)
self.gtkui_config = ConfigManager("gtkui.conf")
self.__width = self.__old_width = 0
self.__height = self.__old_height = 0
self.__pieces = self.__old_pieces = ()
self.__num_pieces = self.__old_num_pieces = None
self.__text = self.__old_text = ""
self.__fraction = self.__old_fraction = 0.0
self.__state = self.__old_state = None
self.__progress_overlay = self.__text_overlay = self.__pieces_overlay = None
self.__cr = None
self.connect('size-allocate', self.do_size_allocate_event)
self.set_colormap(self.get_screen().get_rgba_colormap())
self.show()
def __init__(self):
super(PiecesBar, self).__init__()
# Get progress bar styles, in order to keep font consistency
pb = ProgressBar()
pb_style = pb.get_style()
self.text_font = pb_style.font_desc
self.text_font.set_weight(WEIGHT_BOLD)
# Done with the ProgressBar styles, don't keep refs of it
del pb, pb_style
self.set_size_request(-1, 25)
self.gtkui_config = ConfigManager('gtkui.conf')
self.width = self.prev_width = 0
self.height = self.prev_height = 0
self.pieces = self.prev_pieces = ()
self.num_pieces = None
self.text = self.prev_text = ''
self.fraction = self.prev_fraction = 0
self.progress_overlay = self.text_overlay = self.pieces_overlay = None
self.cr = None
self.connect('size-allocate', self.do_size_allocate_event)
self.set_colormap(colormap_get_system())
self.show()
def __init__(self):
component.Component.__init__(self, "ToolBar")
log.debug("ToolBar Init..")
self.window = component.get("MainWindow")
self.toolbar = self.window.main_glade.get_widget("toolbar")
self.config = ConfigManager("gtkui.conf")
### Connect Signals ###
self.window.main_glade.signal_autoconnect({
"on_toolbutton_add_clicked": self.on_toolbutton_add_clicked,
"on_toolbutton_remove_clicked": self.on_toolbutton_remove_clicked,
"on_toolbutton_pause_clicked": self.on_toolbutton_pause_clicked,
"on_toolbutton_resume_clicked": self.on_toolbutton_resume_clicked,
"on_toolbutton_preferences_clicked": \
self.on_toolbutton_preferences_clicked,
"on_toolbutton_connectionmanager_clicked": \
self.on_toolbutton_connectionmanager_clicked,
"on_toolbutton_queue_up_clicked": self.on_toolbutton_queue_up_clicked,
"on_toolbutton_queue_down_clicked": self.on_toolbutton_queue_down_clicked
})
self.change_sensitivity = [
"toolbutton_add", "toolbutton_remove", "toolbutton_pause",
"toolbutton_resume", "toolbutton_queue_up",
"toolbutton_queue_down", "toolbutton_filter", "find_menuitem"
]
self.config.register_set_function("classic_mode",
self._on_classic_mode, True)
# Hide if necessary
self.visible(self.config["show_toolbar"])
def on_menuitem_move_activate(self, data=None):
log.debug("on_menuitem_move_activate")
if client.is_localhost():
from deluge.configmanager import ConfigManager
config = ConfigManager("gtkui.conf")
chooser = gtk.FileChooserDialog(_("Choose a directory to move files to"\
) , component.get("MainWindow").window, \
gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER, buttons=(gtk.STOCK_CANCEL, \
gtk.RESPONSE_CANCEL, gtk.STOCK_OK, gtk.RESPONSE_OK))
chooser.set_local_only(True)
if not deluge.common.windows_check():
chooser.set_icon(common.get_deluge_icon())
chooser.set_property("skip-taskbar-hint", True)
chooser.set_current_folder(config["choose_directory_dialog_path"])
if chooser.run() == gtk.RESPONSE_OK:
result = chooser.get_filename()
config["choose_directory_dialog_path"] = result
client.core.move_storage(
component.get("TorrentView").get_selected_torrents(),
result)
chooser.destroy()
else:
component.get("SessionProxy").get_torrent_status(
component.get("TorrentView").get_selected_torrent(),
["save_path"]).addCallback(self.show_move_storage_dialog)
def __init__(self):
super(PiecesBar, self).__init__()
# Get progress bar styles, in order to keep font consistency
pb = ProgressBar()
pb_style = pb.get_style_context()
# Get a copy of Pango.FontDescription since original needs freed.
self.text_font = pb_style.get_property('font',
StateFlags.NORMAL).copy()
self.text_font.set_weight(Weight.BOLD)
# Done with the ProgressBar styles, don't keep refs of it
del pb, pb_style
self.set_size_request(-1, 25)
self.gtkui_config = ConfigManager('gtk3ui.conf')
self.width = self.prev_width = 0
self.height = self.prev_height = 0
self.pieces = self.prev_pieces = ()
self.num_pieces = None
self.text = self.prev_text = ''
self.fraction = self.prev_fraction = 0
self.progress_overlay = self.text_overlay = self.pieces_overlay = None
self.cr = None
self.connect('size-allocate', self.do_size_allocate_event)
self.show()
def show(self, available_version):
self.config = ConfigManager("gtkui.conf")
builder = component.get("MainWindow").get_builder()
self.dialog = builder.get_object("new_release_dialog")
# Set the version labels
if deluge.common.windows_check() or deluge.common.osx_check():
builder.get_object("image_new_release").set_from_file(
deluge.common.get_pixmap("deluge16.png"))
else:
builder.get_object("image_new_release").set_from_icon_name(
"deluge", 4)
builder.get_object("label_available_version").set_text(
available_version)
builder.get_object("label_client_version").set_text(
deluge.common.get_version())
self.chk_not_show_dialog = builder.get_object(
"chk_do_not_show_new_release")
builder.get_object("button_goto_downloads").connect(
"clicked", self._on_button_goto_downloads)
builder.get_object("button_close_new_release").connect(
"clicked", self._on_button_close_new_release)
if client.connected():
def on_info(version):
builder.get_object("label_server_version").set_text(version)
builder.get_object("label_server_version").show()
builder.get_object("label_server_version_text").show()
if not client.is_classicmode():
builder.get_object("label_client_version_text").set_label(
_("<i>Client Version</i>"))
client.daemon.info().addCallback(on_info)
self.dialog.show()
def update_config(self):
self.config = ConfigManager("console.conf",DEFAULT_PREFS)
self.__cols_to_show = [pref for pref in column_pref_names if self.config["show_%s"%pref]]
self.__columns = [prefs_to_names[col] for col in self.__cols_to_show]
self.__status_fields = column.get_required_fields(self.__columns)
for rf in ["state","name","queue"]: # we always need these, even if we're not displaying them
if not rf in self.__status_fields: self.__status_fields.append(rf)
self.__update_columns()
def __init__(self, stdscr, encoding=None):
self.popup = None
self.statuses = {}
self.messages = deque()
self.config = ConfigManager("hostlist.conf.1.2", DEFAULT_CONFIG)
BaseMode.__init__(self, stdscr, encoding)
self.__update_statuses()
self.__update_popup()
def menubar_osx(gtkui, osxapp):
main_builder = gtkui.mainwindow.get_builder()
menubar = main_builder.get_object('menubar')
group = accel_groups_from_object(gtkui.mainwindow.window)[0]
config = ConfigManager('gtk3ui.conf')
# NOTE: accel maps doesn't work with glade file format
# because of libglade not setting MenuItem accel groups
# That's why we remove / set accelerators by hand... (dirty)
# Clean solution: migrate glades files to gtkbuilder format
file_menu = main_builder.get_object('menu_file').get_submenu()
file_items = file_menu.get_children()
accel_meta(file_items[0], group, 'o')
accel_meta(file_items[1], group, 'n')
quit_all_item = file_items[3]
accel_swap(
quit_all_item,
group,
'q',
ModifierType.SHIFT_MASK | ModifierType.CONTROL_MASK,
'q',
ModifierType.SHIFT_MASK | ModifierType.META_MASK,
)
for item in range(2, len(file_items)): # remove quits
file_menu.remove(file_items[item])
menu_widget = main_builder.get_object('menu_edit')
edit_menu = menu_widget.get_submenu()
edit_items = edit_menu.get_children()
pref_item = edit_items[0]
accel_swap(pref_item, group, 'p', ModifierType.CONTROL_MASK, ',',
ModifierType.META_MASK)
edit_menu.remove(pref_item)
conn_item = edit_items[1]
accel_meta(conn_item, group, 'm')
edit_menu.remove(conn_item)
menubar.remove(menu_widget)
help_menu = main_builder.get_object('menu_help').get_submenu()
help_items = help_menu.get_children()
about_item = help_items[4]
help_menu.remove(about_item)
help_menu.remove(help_items[3]) # separator
menubar.hide()
osxapp.set_menu_bar(menubar)
# populate app menu
osxapp.insert_app_menu_item(about_item, 0)
osxapp.insert_app_menu_item(SeparatorMenuItem(), 1)
osxapp.insert_app_menu_item(pref_item, 2)
if not config['standalone']:
osxapp.insert_app_menu_item(conn_item, 3)
if quit_all_item.get_visible():
osxapp.insert_app_menu_item(SeparatorMenuItem(), 4)
osxapp.insert_app_menu_item(quit_all_item, 5)
def process_args(args):
"""Process arguments sent to already running Deluge"""
# Make sure args is a list
args = list(args)
log.debug("Processing args from other process: %s", args)
if not client.connected():
# We're not connected so add these to the queue
log.debug("Not connected to host.. Adding to queue.")
component.get("QueuedTorrents").add_to_queue(args)
return
config = ConfigManager("gtkui.conf")
for arg in args:
if not arg.strip():
continue
log.debug("arg: %s", arg)
if deluge.common.is_url(arg):
log.debug("Attempting to add url (%s) from external source...",
arg)
if config["interactive_add"]:
component.get("AddTorrentDialog").add_from_url(arg)
component.get("AddTorrentDialog").show(
config["focus_add_dialog"])
else:
client.core.add_torrent_url(arg, None)
elif deluge.common.is_magnet(arg):
log.debug("Attempting to add magnet (%s) from external source...",
arg)
if config["interactive_add"]:
component.get("AddTorrentDialog").add_from_magnets([arg])
component.get("AddTorrentDialog").show(
config["focus_add_dialog"])
else:
client.core.add_torrent_magnet(arg, {})
else:
log.debug("Attempting to add file (%s) from external source...",
arg)
if urlparse(arg).scheme == "file":
arg = url2pathname(urlparse(arg).path)
path = os.path.abspath(deluge.common.decode_string(arg))
if not os.path.exists(path):
log.error("No such file: %s", path)
continue
if config["interactive_add"]:
component.get("AddTorrentDialog").add_from_files([path])
component.get("AddTorrentDialog").show(
config["focus_add_dialog"])
else:
with open(path, "rb") as _file:
filedump = base64.encodestring(_file.read())
client.core.add_torrent_file(
os.path.split(path)[-1], filedump, None)
def __init__(self):
component.Component.__init__(self, "Web.PluginManager")
self.config = ConfigManager("web.conf")
PluginManagerBase.__init__(self, "web.conf", "deluge.plugin.web")
client.register_event_handler("PluginEnabledEvent",
self._on_plugin_enabled_event)
client.register_event_handler("PluginDisabledEvent",
self._on_plugin_disabled_event)
def process_args(args):
"""Process arguments sent to already running Deluge"""
# Make sure args is a list
args = list(args)
log.debug('Processing args from other process: %s', args)
if not client.connected():
# We're not connected so add these to the queue
log.debug('Not connected to host.. Adding to queue.')
component.get('QueuedTorrents').add_to_queue(args)
return
config = ConfigManager('gtkui.conf')
for arg in args:
if not arg.strip():
continue
log.debug('arg: %s', arg)
if is_url(arg):
log.debug('Attempting to add url (%s) from external source...',
arg)
if config['interactive_add']:
component.get('AddTorrentDialog').add_from_url(arg)
component.get('AddTorrentDialog').show(
config['focus_add_dialog'])
else:
client.core.add_torrent_url(arg, None)
elif is_magnet(arg):
log.debug('Attempting to add magnet (%s) from external source...',
arg)
if config['interactive_add']:
component.get('AddTorrentDialog').add_from_magnets([arg])
component.get('AddTorrentDialog').show(
config['focus_add_dialog'])
else:
client.core.add_torrent_magnet(arg, {})
else:
log.debug('Attempting to add file (%s) from external source...',
arg)
if urlparse(arg).scheme == 'file':
arg = url2pathname(urlparse(arg).path)
path = os.path.abspath(decode_bytes(arg))
if not os.path.exists(path):
log.error('No such file: %s', path)
continue
if config['interactive_add']:
component.get('AddTorrentDialog').add_from_files([path])
component.get('AddTorrentDialog').show(
config['focus_add_dialog'])
else:
with open(path, 'rb') as _file:
filedump = b64encode(_file.read())
client.core.add_torrent_file(
os.path.split(path)[-1], filedump, None)
def __init__(self):
component.Component.__init__(self, 'Web.PluginManager')
self.config = ConfigManager('web.conf')
PluginManagerBase.__init__(self, 'web.conf', 'deluge.plugin.web')
client.register_event_handler('PluginEnabledEvent',
self._on_plugin_enabled_event)
client.register_event_handler('PluginDisabledEvent',
self._on_plugin_disabled_event)
def __init__(self):
super(WebApi, self).__init__("Web", depend=["SessionProxy"])
self.host_list = ConfigManager("hostlist.conf.1.2", DEFAULT_HOSTS)
self.core_config = CoreConfig()
self.event_queue = EventQueue()
try:
self.sessionproxy = component.get("SessionProxy")
except KeyError:
self.sessionproxy = SessionProxy()
def __init__(self):
self.config = ConfigManager("core.conf")
self.state05_location = os.path.join(get_config_dir(),
"persistent.state")
self.state10_location = os.path.join(get_config_dir(), "state",
"torrents.state")
if os.path.exists(self.state05_location) and not os.path.exists(
self.state10_location):
# If the 0.5 state file exists and the 1.0 doesn't, then let's upgrade it
self.upgrade05()
def __init__(self, torrent_id, parent=None):
self.torrent_id = torrent_id
self.builder = Gtk.Builder()
self.gtkui_config = ConfigManager('gtk3ui.conf')
# Main dialog
self.builder.add_from_file(
resource_filename(__package__, os.path.join('glade', 'edit_trackers.ui'))
)
# add tracker dialog
self.builder.add_from_file(
resource_filename(
__package__, os.path.join('glade', 'edit_trackers.add.ui')
)
)
# edit tracker dialog
self.builder.add_from_file(
resource_filename(
__package__, os.path.join('glade', 'edit_trackers.edit.ui')
)
)
self.dialog = self.builder.get_object('edit_trackers_dialog')
self.treeview = self.builder.get_object('tracker_treeview')
self.add_tracker_dialog = self.builder.get_object('add_tracker_dialog')
self.add_tracker_dialog.set_transient_for(self.dialog)
self.edit_tracker_entry = self.builder.get_object('edit_tracker_entry')
self.edit_tracker_entry.set_transient_for(self.dialog)
self.dialog.set_icon(get_deluge_icon())
self.load_edit_trackers_dialog_state()
if parent is not None:
self.dialog.set_transient_for(parent)
# Connect the signals
self.builder.connect_signals(self)
# Create a liststore for tier, url
self.liststore = Gtk.ListStore(int, str)
# Create the columns
self.treeview.append_column(
Gtk.TreeViewColumn(_('Tier'), Gtk.CellRendererText(), text=0)
)
self.treeview.append_column(
Gtk.TreeViewColumn(_('Tracker'), Gtk.CellRendererText(), text=1)
)
self.treeview.set_model(self.liststore)
self.liststore.set_sort_column_id(0, Gtk.SortType.ASCENDING)
self.dialog.connect('delete-event', self._on_delete_event)
self.dialog.connect('response', self._on_response)
self.treeview.connect('button_press_event', self.on_button_press_event)
def set_up(self):
if libs_available is False:
raise unittest.SkipTest('GTKUI dependencies not available')
common.set_tmp_config_dir()
# MainWindow loads this config file, so lets make sure it contains the defaults
ConfigManager('gtkui.conf', defaults=DEFAULT_PREFS)
self.mainwindow = MainWindow()
self.torrentview = TorrentView()
self.torrentdetails = TorrentDetails()
self.menubar = MenuBar()
def set_up(self):
if libs_available is False:
raise unittest.SkipTest('GTKUI dependencies not available')
common.set_tmp_config_dir()
ConfigManager('gtkui.conf', defaults=DEFAULT_PREFS)
self.mainwindow = MainWindow()
self.filestab = FilesTab()
self.t_id = '1'
self.filestab.torrent_id = self.t_id
self.index = 1
def __init__(self):
component.Component.__init__(self, 'SideBar')
main_builder = component.get('MainWindow').get_builder()
self.notebook = main_builder.get_object('sidebar_notebook')
self.config = ConfigManager('gtk3ui.conf')
# Tabs holds references to the Tab widgets by their name
self.tabs = {}
# Hide if necessary
self.visible(self.config['show_sidebar'])
def menubar_osx(gtkui, osxapp):
window = gtkui.mainwindow
glade = window.main_glade
menubar = glade.get_widget("menubar")
group = gtk.accel_groups_from_object(window.window)[0]
config = ConfigManager("gtkui.conf")
# NOTE: accel maps doesn't work with glade file format
# because of libglade not setting MenuItem accel groups
# That's why we remove / set accelerators by hand... (dirty)
# Clean solution: migrate glades files to gtkbuilder format
file_menu = glade.get_widget("menu_file").get_submenu()
file_items = file_menu.get_children()
accel_meta(file_items[0], group, 'o')
accel_meta(file_items[1], group, 'n')
quit_all_item = file_items[3]
accel_swap(quit_all_item, group, 'q',
gtk.gdk.SHIFT_MASK | gtk.gdk.CONTROL_MASK, 'q',
gtk.gdk.SHIFT_MASK | gtk.gdk.META_MASK)
for item in range(2, len(file_items)): # remove quits
file_menu.remove(file_items[item])
menu_widget = glade.get_widget("menu_edit")
edit_menu = menu_widget.get_submenu()
edit_items = edit_menu.get_children()
pref_item = edit_items[0]
accel_swap(pref_item, group, 'p', gtk.gdk.CONTROL_MASK, ',',
gtk.gdk.META_MASK)
edit_menu.remove(pref_item)
conn_item = edit_items[1]
accel_meta(conn_item, group, 'm')
edit_menu.remove(conn_item)
menubar.remove(menu_widget)
help_menu = glade.get_widget("menu_help").get_submenu()
help_items = help_menu.get_children()
about_item = help_items[4]
help_menu.remove(about_item)
help_menu.remove(help_items[3]) # separator
menubar.hide()
osxapp.set_menu_bar(menubar)
# populate app menu
osxapp.insert_app_menu_item(about_item, 0)
osxapp.insert_app_menu_item(gtk.SeparatorMenuItem(), 1)
osxapp.insert_app_menu_item(pref_item, 2)
if not config["classic_mode"]:
osxapp.insert_app_menu_item(conn_item, 3)
if quit_all_item.get_visible():
osxapp.insert_app_menu_item(gtk.SeparatorMenuItem(), 4)
osxapp.insert_app_menu_item(quit_all_item, 5)
def __init__(self):
if wnck:
self.screen = wnck.screen_get_default()
component.Component.__init__(self, 'MainWindow', interval=2)
self.config = ConfigManager('gtkui.conf')
self.main_builder = gtk.Builder()
# Patch this GtkBuilder to avoid connecting signals from elsewhere
#
# Think about splitting up mainwindow gtkbuilder file into the necessary parts
# to avoid GtkBuilder monkey patch. Those parts would then need adding to mainwindow 'by hand'.
self.gtk_builder_signals_holder = _GtkBuilderSignalsHolder()
self.main_builder.prev_connect_signals = copy.deepcopy(self.main_builder.connect_signals)
def patched_connect_signals(*a, **k):
raise RuntimeError('In order to connect signals to this GtkBuilder instance please use '
'"component.get(\'MainWindow\').connect_signals()"')
self.main_builder.connect_signals = patched_connect_signals
# Get Gtk Builder files Main Window, New release dialog, and Tabs.
for filename in ('main_window.ui', 'main_window.new_release.ui', 'main_window.tabs.ui',
'main_window.tabs.menu_file.ui', 'main_window.tabs.menu_peer.ui'):
self.main_builder.add_from_file(
resource_filename('deluge.ui.gtkui', os.path.join('glade', filename)))
self.window = self.main_builder.get_object('main_window')
self.window.set_icon(deluge.ui.gtkui.common.get_deluge_icon())
self.vpaned = self.main_builder.get_object('vpaned')
self.initial_vpaned_position = self.config['window_pane_position']
# Keep a list of components to pause and resume when changing window state.
self.child_components = ['TorrentView', 'StatusBar', 'TorrentDetails']
# Load the window state
self.load_window_state()
# Keep track of window minimization state so we don't update UI when it is minimized.
self.is_minimized = False
self.restart = False
self.window.drag_dest_set(gtk.DEST_DEFAULT_ALL, [('text/uri-list', 0, 80)], ACTION_COPY)
# Connect events
self.window.connect('window-state-event', self.on_window_state_event)
self.window.connect('configure-event', self.on_window_configure_event)
self.window.connect('delete-event', self.on_window_delete_event)
self.window.connect('drag-data-received', self.on_drag_data_received_event)
self.vpaned.connect('notify::position', self.on_vpaned_position_event)
self.window.connect('expose-event', self.on_expose_event)
self.config.register_set_function('show_rate_in_title', self._on_set_show_rate_in_title, apply_now=False)
client.register_event_handler('NewVersionAvailableEvent', self.on_newversionavailable_event)
def __init__(self):
component.Component.__init__(self, 'PluginManager')
self.config = ConfigManager('gtkui.conf')
deluge.pluginmanagerbase.PluginManagerBase.__init__(
self, 'gtkui.conf', 'deluge.plugin.gtkui')
self.hooks = {'on_apply_prefs': [], 'on_show_prefs': []}
client.register_event_handler('PluginEnabledEvent',
self._on_plugin_enabled_event)
client.register_event_handler('PluginDisabledEvent',
self._on_plugin_disabled_event)
