def __init__(self): log.debug("CoreConfig init..") component.Component.__init__(self, "CoreConfig") self.config = {} def on_configvaluechanged_event(key, value): self.config[key] = value client.register_event_handler("ConfigValueChangedEvent", on_configvaluechanged_event)
def __init__(self, config_key, values, parent=None, suffix="", custom_label=None, custom_max=None): QtGui.QActionGroup.__init__(self, parent) self.config_key = config_key self.custom_label = custom_label self.custom_max = custom_max self.value = None for value in values: self.addAction( QtGui.QAction(unicode(value) + suffix, self, checkable=True, triggered=self._value_triggered)).setData(value) self.addAction( QtGui.QAction(_("Unlimited"), self, checkable=True, triggered=self._value_triggered)).setData(-1) self.addAction(QtGui.QAction(self)).setSeparator(True) self.custom_action = self.addAction( QtGui.QAction(_("Other..."), self, triggered=self._custom_triggered)) client.register_event_handler("ConfigValueChangedEvent", self._client_configvaluechanged)
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 __on_connect_success(self, result): ''' : add event handlers ''' LOG.info('Connection was successful') client.register_event_handler('TorrentFinishedEvent', self.__on_download_completed) return result
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 load(self): log.debug("Adding Execute Preferences page") self.glade = gtk.glade.XML(self.get_resource("execute_prefs.glade")) self.glade.signal_autoconnect({ "on_add_button_clicked": self.on_add_button_clicked }) events = self.glade.get_widget("event_combobox") store = gtk.ListStore(str, str) for event in EVENTS: event_label = EVENT_MAP[event] store.append((event_label, event)) events.set_model(store) events.set_active(0) self.plugin.add_preferences_page(_("Execute"), self.glade.get_widget("execute_box")) self.plugin.register_hook("on_show_prefs", self.load_commands) self.plugin.register_hook("on_apply_prefs", self.on_apply_prefs) self.load_commands() client.register_event_handler("ExecuteCommandAddedEvent", self.on_command_added_event) client.register_event_handler("ExecuteCommandRemovedEvent", self.on_command_removed_event)
def enable(self): self.create_prefs_page() component.get("PluginManager").register_hook("on_apply_prefs", self.on_apply_prefs) component.get("PluginManager").register_hook("on_show_prefs", self.on_show_prefs) self.statusbar = component.get("StatusBar") self.status_item = self.statusbar.add_item( image=get_resource("green.png"), text="", callback=self.on_status_item_clicked, tooltip="MyScheduler") self.menu = gtk.CheckMenuItem(_("Force Start")) self.menu.connect("activate", self.on_menu_activated, None) self.menu.show() torrentmenu = component.get("MenuBar").torrentmenu torrentmenu.connect("show", self.on_menu_show, None) torrentmenu.append(self.menu) def on_state_deferred(state): self.state = state self.on_scheduler_event(state) client.scheduler.get_state().addCallback(on_state_deferred) client.register_event_handler("SchedulerEvent", self.on_scheduler_event)
def __init__(self): component.Component.__init__(self, "PluginManager") PluginManagerBase.__init__(self, "qtui.conf", "deluge.plugin.qtui") client.register_event_handler("PluginEnabledEvent", self.enable_plugin) client.register_event_handler("PluginDisabledEvent", self.disable_plugin)
def enable(self): log.debug('Enabling %s FreeSpace', self.__class__.__name__) self.glade = gtk.glade.XML(get_resource("config.glade")) self.prefs = self.glade.get_widget('prefs_box') parent = self.prefs.get_parent() if parent: parent.remove(self.prefs) self.downloads_vbox = component.get("Preferences").builder.get_object('downloads_vbox') self.downloads_vbox.pack_start(self.prefs, False, True, 0) component.get("PluginManager").register_hook("on_apply_prefs", self.on_apply_prefs) component.get("PluginManager").register_hook("on_show_prefs", self.on_show_prefs) try: notifications = component.get("GtkPlugin.Notifications") notifications.register_custom_popup_notification( "LowDiskSpaceEvent", self.__custom_popup_notification ) notifications.register_custom_blink_notification( "LowDiskSpaceEvent", self.__custom_blink_notification ) notifications.register_custom_sound_notification( "LowDiskSpaceEvent", self.__custom_sound_notification ) except KeyError: pass client.register_event_handler("PluginEnabledEvent", self.__on_plugin_enabled) client.register_event_handler("PluginDisabledEvent", self.__on_plugin_disabled)
def enable(self): self.create_prefs_page() component.get("PluginManager").register_hook("on_apply_prefs", self.on_apply_prefs) component.get("PluginManager").register_hook("on_show_prefs", self.on_show_prefs) self.statusbar = component.get("StatusBar") self.status_item = self.statusbar.add_item( image=get_resource("green.png"), text="", callback=self.on_status_item_clicked, tooltip="MyScheduler") self.menu = gtk.CheckMenuItem(_("Force Start")) self.menu.connect("activate", self.on_menu_activated, None) self.menu.show() torrentmenu = component.get("MenuBar").torrentmenu torrentmenu.connect("show", self.on_menu_show, None) torrentmenu.insert(self.menu, 4) def on_state_deferred(state): self.state = state self.on_scheduler_event(state) client.myscheduler.get_state().addCallback(on_state_deferred) client.register_event_handler("SchedulerEvent", self.on_scheduler_event)
def enable(self): self.builder = Gtk.Builder() self.builder.add_from_file(get_resource('config.ui')) self.builder.connect_signals(self) self.opts_dialog = OptionsDialog() component.get('PluginManager').register_hook('on_apply_prefs', self.on_apply_prefs) component.get('PluginManager').register_hook('on_show_prefs', self.on_show_prefs) client.register_event_handler('AutoaddOptionsChangedEvent', self.on_options_changed_event) self.watchdirs = {} vbox = self.builder.get_object('watchdirs_vbox') sw = Gtk.ScrolledWindow() sw.set_shadow_type(Gtk.ShadowType.ETCHED_IN) sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) vbox.pack_start(sw, True, True, 0) self.store = self.create_model() self.treeView = Gtk.TreeView(self.store) self.treeView.connect('cursor-changed', self.on_listitem_activated) self.treeView.connect('row-activated', self.on_edit_button_clicked) self.treeView.set_rules_hint(True) self.create_columns(self.treeView) sw.add(self.treeView) sw.show_all() component.get('Preferences').add_page( _('AutoAdd'), self.builder.get_object('prefs_box'))
def load(self): log.debug('Adding Execute Preferences page') self.builder = Gtk.Builder() self.builder.add_from_file(common.get_resource('execute_prefs.ui')) self.builder.connect_signals(self) events = self.builder.get_object('event_combobox') store = Gtk.ListStore(str, str) for event in EVENTS: event_label = EVENT_MAP[event] store.append((event_label, event)) events.set_model(store) events.set_active(0) self.plugin.add_preferences_page( _('Execute'), self.builder.get_object('execute_box')) self.plugin.register_hook('on_show_prefs', self.load_commands) self.plugin.register_hook('on_apply_prefs', self.on_apply_prefs) self.load_commands() client.register_event_handler('ExecuteCommandAddedEvent', self.on_command_added_event) client.register_event_handler('ExecuteCommandRemovedEvent', self.on_command_removed_event)
def load(self): log.debug("Adding Execute Preferences page") self.glade = gtk.glade.XML(self.get_resource("execute_prefs.glade")) self.glade.signal_autoconnect( {"on_add_button_clicked": self.on_add_button_clicked}) events = self.glade.get_widget("event_combobox") store = gtk.ListStore(str, str) for event in EVENTS: event_label = EVENT_MAP[event] store.append((event_label, event)) events.set_model(store) events.set_active(0) self.plugin.add_preferences_page(_("Execute"), self.glade.get_widget("execute_box")) self.plugin.register_hook("on_show_prefs", self.load_commands) self.plugin.register_hook("on_apply_prefs", self.on_apply_prefs) self.load_commands() client.register_event_handler("ExecuteCommandAddedEvent", self.on_command_added_event) client.register_event_handler("ExecuteCommandRemovedEvent", self.on_command_removed_event)
def enable(self): self.builder = gtk.Builder() self.builder.add_from_file(get_resource("config.ui")) self.builder.connect_signals({ "on_button_clear_clicked": self.on_button_clear_clicked, }) component.get("Preferences").add_page( "TrafficLimits", self.builder.get_object("prefs_box")) component.get("PluginManager").register_hook("on_apply_prefs", self.on_apply_prefs) component.get("PluginManager").register_hook("on_show_prefs", self.on_show_prefs) self.status_item = component.get("StatusBar").add_item( image=get_resource("monitor.png"), text="", callback=self.on_status_item_clicked, tooltip="TrafficLimits plugin") def on_get_state(state): self.set_status(*state) self.state_deferred = client.trafficlimits.get_state().addCallback( on_get_state) client.register_event_handler("TrafficLimitUpdate", self.on_trafficlimit_update)
def enable(self): self.glade = gtk.glade.XML(get_resource("config.glade")) component.get("Preferences").add_page( "uTorrentImport", self.glade.get_widget("prefs_box")) component.get("PluginManager").register_hook("on_apply_prefs", self.on_apply_prefs) component.get("PluginManager").register_hook("on_show_prefs", self.on_show_prefs) signal_dictionary = { 'on_import_button_clicked': self.on_import_button_clicked, 'on_resume_toggled': self.on_resume_toggled } log.debug('utorrentimport: signals hooked!') self.glade.signal_autoconnect(signal_dictionary) self.use_wine_mappings = self.glade.get_widget('use_wine_mappings') self.force_recheck = self.glade.get_widget('force_recheck') self.resume = self.glade.get_widget('resume') self.resume_dat_entry = self.glade.get_widget('resume_dat_entry') self.log_view = self.glade.get_widget('log_view') client.register_event_handler('uTorrentImportLoggingEvent', self.log_to_user)
def enable(self): self.glade = gtk.glade.XML(get_resource("config.glade")) self.glade.signal_autoconnect({ "on_add_button_clicked": self.on_add_button_clicked, "on_edit_button_clicked": self.on_edit_button_clicked, "on_remove_button_clicked": self.on_remove_button_clicked }) self.opts_dialog = OptionsDialog() component.get("PluginManager").register_hook("on_apply_prefs", self.on_apply_prefs) component.get("PluginManager").register_hook("on_show_prefs", self.on_show_prefs) client.register_event_handler("AutoaddPlusOptionsChangedEvent", self.on_options_changed_event) self.watchdirs = {} vbox = self.glade.get_widget("watchdirs_vbox") sw = gtk.ScrolledWindow() sw.set_shadow_type(gtk.SHADOW_ETCHED_IN) sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) vbox.pack_start(sw, True, True, 0) self.store = self.create_model() self.treeView = gtk.TreeView(self.store) self.treeView.connect("cursor-changed", self.on_listitem_activated) self.treeView.connect("row-activated", self.on_edit_button_clicked) self.treeView.set_rules_hint(True) self.create_columns(self.treeView) sw.add(self.treeView) sw.show_all() component.get("Preferences").add_page(_("AutoAddPlus"), self.glade.get_widget("prefs_box"))
def enable(self): log.debug('Enabling %s FreeSpace', self.__class__.__name__) self.glade = gtk.glade.XML(get_resource("config.glade")) self.prefs = self.glade.get_widget('prefs_box') parent = self.prefs.get_parent() if parent: parent.remove(self.prefs) self.downloads_vbox = component.get("Preferences").builder.get_object( 'downloads_vbox') self.downloads_vbox.pack_start(self.prefs, False, True, 0) component.get("PluginManager").register_hook("on_apply_prefs", self.on_apply_prefs) component.get("PluginManager").register_hook("on_show_prefs", self.on_show_prefs) try: notifications = component.get("GtkPlugin.Notifications") notifications.register_custom_popup_notification( "LowDiskSpaceEvent", self.__custom_popup_notification) notifications.register_custom_blink_notification( "LowDiskSpaceEvent", self.__custom_blink_notification) notifications.register_custom_sound_notification( "LowDiskSpaceEvent", self.__custom_sound_notification) except KeyError: pass client.register_event_handler("PluginEnabledEvent", self.__on_plugin_enabled) client.register_event_handler("PluginDisabledEvent", self.__on_plugin_disabled)
def __on_connect_success(self, result): """ : add event handlers """ LOG.info('Connection was successful') client.register_event_handler('TorrentFinishedEvent', self.__on_download_completed) return result
def enable(self): self.glade = gtk.glade.XML(get_resource("config.glade")) component.get("Preferences").add_page("XBMCUpdater", self.glade.get_widget("vbox1")) component.get("PluginManager").register_hook("on_apply_prefs", self.on_apply_prefs) component.get("PluginManager").register_hook("on_show_prefs", self.on_show_prefs) client.register_event_handler("ReplacementAddedEvent", self.on_replacement_added_event) client.register_event_handler("ReplacementRemovedEvent", self.on_replacement_removed_event) self.load()
def __init__(self): log.debug('CoreConfig init..') component.Component.__init__(self, 'CoreConfig') self.config = {} def on_configvaluechanged_event(key, value): self.config[key] = value client.register_event_handler('ConfigValueChangedEvent', on_configvaluechanged_event)
def enable(self): self.createUI() self.on_show_prefs( ) # Necessary for the first time when the plugin is installed client.register_event_handler("YARSSConfigChangedEvent", self.cb_on_config_changed_event) client.register_event_handler("GtkUILogMessageEvent", self.cb_on_log_message_arrived_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)
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): 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 enable(self): self.last_config = None self.create_ui() self.on_show_prefs( ) # Necessary for the first time when the plugin is installed client.register_event_handler("IfaceWatchLogMessageEvent", self.cb_on_log_message_event) client.register_event_handler("IfaceWatchIPChangedEvent", self.cb_get_ip)
def enable(self): """Enables the system tray icon.""" self.builder = Builder() self.builder.add_from_file(resource_filename('deluge.ui.gtkui', os.path.join( 'glade', 'tray_menu.ui'))) self.builder.connect_signals(self) self.tray_menu = self.builder.get_object('tray_menu') if appindicator and self.config['enable_appindicator']: log.debug('Enabling the Application Indicator...') self.indicator = appindicator.Indicator('deluge', 'deluge', appindicator.CATEGORY_APPLICATION_STATUS) try: self.indicator.set_property('title', _('Deluge')) except TypeError: # Catch 'title' property error for previous appindicator versions pass # Pass the menu to the Application Indicator self.indicator.set_menu(self.tray_menu) # Make sure the status of the Show Window MenuItem is correct self._sig_win_hide = self.mainwindow.window.connect('hide', self._on_window_hide) self._sig_win_show = self.mainwindow.window.connect('show', self._on_window_show) if self.mainwindow.visible(): self.builder.get_object('menuitem_show_deluge').set_active(True) else: self.builder.get_object('menuitem_show_deluge').set_active(False) # Show the Application Indicator self.indicator.set_status(appindicator.STATUS_ACTIVE) else: log.debug('Enabling the system tray icon..') if windows_check(): self.tray = status_icon_new_from_pixbuf(get_logo(32)) else: self.tray = status_icon_new_from_icon_name('deluge') self.tray.connect('activate', self.on_tray_clicked) self.tray.connect('popup-menu', self.on_tray_popup) self.builder.get_object('download-limit-image').set_from_file(get_pixmap('downloading16.png')) self.builder.get_object('upload-limit-image').set_from_file(get_pixmap('seeding16.png')) client.register_event_handler('ConfigValueChangedEvent', self.config_value_changed) if client.connected(): # We're connected so we need to get some values from the core self.__start() else: # Hide menu widgets because we're not connected to a host. for widget in self.hide_widget_list: self.builder.get_object(widget).hide()
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)
def __init__(self, stdscr, encoding=None): self.batch_write = False self.lines = [] # A list of strings to be displayed based on the offset (scroll) self.lines = [] # The offset to display lines self.display_lines_offset = 0 # Holds the user input and is cleared on 'enter' self.input = "" self.input_incomplete = "" # Keep track of where the cursor is self.input_cursor = 0 # Keep a history of inputs self.input_history = [] self.input_history_index = 0 # Keep track of double-tabs self.tab_count = 0 # Get a handle to the main console self.console = component.get("ConsoleUI") # show the cursor curses.curs_set(2) BaseMode.__init__(self, stdscr, encoding) # This gets fired once we have received the torrents list from the core self.started_deferred = defer.Deferred() # Maintain a list of (torrent_id, name) for use in tab completion self.torrents = [] def on_session_state(result): def on_torrents_status(torrents): for torrent_id, status in torrents.items(): self.torrents.append((torrent_id, status["name"])) self.started_deferred.callback(True) client.core.get_torrents_status({ "id": result }, ["name"]).addCallback(on_torrents_status) client.core.get_session_state().addCallback(on_session_state) # Register some event handlers to keep the torrent list up-to-date client.register_event_handler("TorrentAddedEvent", self.on_torrent_added_event) client.register_event_handler("TorrentRemovedEvent", self.on_torrent_removed_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)
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)
def enable(self): client.register_event_handler('PluginEnabledEvent', self._json.get_remote_methods) client.register_event_handler('PluginDisabledEvent', self._json.get_remote_methods) if client.is_standalone(): component.get('Web.PluginManager').start() else: client.set_disconnect_callback(self._on_client_disconnect) default_host_id = component.get('DelugeWeb').config['default_daemon'] if default_host_id: return self.connect(default_host_id) return defer.succeed(True)
def __init__(self, parent=None): QtGui.QStatusBar.__init__(self, parent) component.Component.__init__(self, "StatusBar", interval=3) self.status_not_connected = StatusBarItem(self, text=_("Not Connected"), toolTip=_("Not Connected"), icon=IconLoader.themeIcon("network-offline"), clicked=self._show_connection_dialog) self.status_connections = StatusBarItem(self, visible=False, toolTip=_("Connections"), icon=IconLoader.themeIcon("network-workgroup"), context_menu=component.get("MainWindow").menu_max_connections) self.status_download = StatusBarItem(self, visible=False, toolTip=_("Download Speed"), icon=IconLoader.customIcon("downloading16.png"), context_menu=component.get("MainWindow").menu_download_speed) self.status_upload = StatusBarItem(self, visible=False, toolTip=_("Upload Speed"), icon=IconLoader.customIcon("seeding16.png"), context_menu=component.get("MainWindow").menu_upload_speed) self.status_protocol = StatusBarItem(self, visible=False, toolTip=_("Protocol Traffic Download/Upload"), icon=IconLoader.customIcon("traffic16.png"), clicked=self._show_network_preferences) self.status_disk_space = StatusBarItem(self, visible=False, toolTip=_("Free Disk Space"), icon=IconLoader.themeIcon("drive-harddisk"), clicked=self._show_preferences) self.status_health = StatusBarItem(self, visible=False, text=_("No Incoming Connections!"), toolTip=_("No Incoming Connections!"), icon=IconLoader.themeIcon("dialog-error"), clicked=self._show_network_preferences) self.status_dht = StatusBarItem(self, visible=False, toolTip=_("DHT Nodes"), icon=IconLoader.customIcon("dht16.png")) self.status_items = self.findChildren(StatusBarItem) self.core_config = {} client.register_event_handler("ConfigValueChangedEvent", self.on_client_configvaluechanged) self._time_sent_recv = (time.time(), 0, 0)
def start(self): for widget in self.change_sensitivity: self.main_builder.get_object(widget).set_sensitive(True) # Only show open_folder menuitem and separator if connected to a localhost daemon. localhost_items = [ 'menuitem_open_folder', 'separator4' ] if client.is_localhost(): for widget in localhost_items: self.builder.get_object(widget).show() self.builder.get_object(widget).set_no_show_all(False) else: for widget in localhost_items: self.builder.get_object(widget).hide() self.builder.get_object(widget).set_no_show_all(True) self.main_builder.get_object('separatormenuitem').set_visible(not self.config['standalone']) self.main_builder.get_object('menuitem_quitdaemon').set_visible(not self.config['standalone']) self.main_builder.get_object('menuitem_connectionmanager').set_visible(not self.config['standalone']) # Show the Torrent menu because we're connected to a host self.menu_torrent.show() if client.get_auth_level() == deluge.common.AUTH_LEVEL_ADMIN: # Get known accounts to allow changing ownership client.core.get_known_accounts().addCallback( self._on_known_accounts).addErrback(self._on_known_accounts_fail) client.register_event_handler('TorrentStateChangedEvent', self.on_torrentstatechanged_event) client.register_event_handler('TorrentResumedEvent', self.on_torrentresumed_event) client.register_event_handler('SessionPausedEvent', self.on_sessionpaused_event) client.register_event_handler('SessionResumedEvent', self.on_sessionresumed_event)
def enable(self): """Triggers when plugin is enabled.""" self.glade = gtk.glade.XML(self.get_resource('config.glade')) self.tv_trackers = self.glade.get_widget('tv_tracker') self.ed_login = self.glade.get_widget('ed_login') self.ed_password = self.glade.get_widget('ed_password') component.get('Preferences').add_page( self.plugin_id, self.glade.get_widget('prefs_box')) pmanager = component.get('PluginManager') pmanager.register_hook('on_apply_prefs', self.on_apply_prefs) # TODO Cope with tv_tarckers repopulation on plugin reenable. pmanager.register_hook('on_show_prefs', self.on_show_prefs) self.add_context_menu_items() self.status_updator = LoopingCall(self.update_status_bar) self.status_updator.start(60) client.register_event_handler('UpdatorrUpdateDoneEvent', self.on_update_done_event) client.register_event_handler('UpdatorrErrorEvent', self.on_update_error_event) client.register_event_handler('UpdatorrUpdatesCheckStartedEvent', self.on_updates_started_event) client.register_event_handler('UpdatorrUpdatesCheckFinishedEvent', self.on_updates_finished_event)
def __init__(self): component.Component.__init__(self, 'StatusBar', interval=3) main_builder = component.get('MainWindow').get_builder() self.statusbar = main_builder.get_object('statusbar') self.config = ConfigManager('gtk3ui.conf') # Status variables that are updated via callback self.max_connections_global = -1 self.num_connections = 0 self.max_download_speed = -1.0 self.download_rate = '' self.max_upload_speed = -1.0 self.upload_rate = '' self.dht_nodes = 0 self.dht_status = False self.health = False self.download_protocol_rate = 0.0 self.upload_protocol_rate = 0.0 self.config_value_changed_dict = { 'max_connections_global': self._on_max_connections_global, 'max_download_speed': self._on_max_download_speed, 'max_upload_speed': self._on_max_upload_speed, 'dht': self._on_dht, } self.current_warnings = [] # Add hbox to the statusbar after removing the initial label widget self.hbox = Gtk.Box.new(Gtk.Orientation.HORIZONTAL, spacing=10) align = Gtk.Alignment() align.set_padding(2, 0, 3, 0) align.add(self.hbox) frame = self.statusbar.get_children()[0] frame.remove(frame.get_children()[0]) frame.add(align) self.statusbar.show_all() # Create the not connected item self.not_connected_item = StatusBarItem( icon='network-offline-symbolic', text=_('Not Connected'), callback=self._on_notconnected_item_clicked, ) # Show the not connected status bar self.show_not_connected() # Hide if necessary self.visible(self.config['show_statusbar']) client.register_event_handler( 'ConfigValueChangedEvent', self.on_configvaluechanged_event )
def __init__(self, stdscr, encoding=None): self.batch_write = False self.lines = [] # A list of strings to be displayed based on the offset (scroll) self.lines = [] # The offset to display lines self.display_lines_offset = 0 # Holds the user input and is cleared on 'enter' self.input = "" self.input_incomplete = "" # Keep track of where the cursor is self.input_cursor = 0 # Keep a history of inputs self.input_history = [] self.input_history_index = 0 # Keep track of double-tabs self.tab_count = 0 # Get a handle to the main console self.console = component.get("ConsoleUI") # show the cursor curses.curs_set(2) BaseMode.__init__(self, stdscr, encoding) # This gets fired once we have received the torrents list from the core self.started_deferred = defer.Deferred() # Maintain a list of (torrent_id, name) for use in tab completion self.torrents = [] def on_session_state(result): def on_torrents_status(torrents): for torrent_id, status in torrents.items(): self.torrents.append((torrent_id, status["name"])) self.started_deferred.callback(True) client.core.get_torrents_status({"id": result}, ["name"]).addCallback(on_torrents_status) client.core.get_session_state().addCallback(on_session_state) # Register some event handlers to keep the torrent list up-to-date client.register_event_handler("TorrentAddedEvent", self.on_torrent_added_event) client.register_event_handler("TorrentRemovedEvent", self.on_torrent_removed_event)
def enable(self): self.create_prefs_page() component.get("PluginManager").register_hook("on_apply_prefs", self.on_apply_prefs) component.get("PluginManager").register_hook("on_show_prefs", self.on_show_prefs) self.status_item = component.get("StatusBar").add_item( image=get_resource("green.png"), text="", callback=self.on_status_item_clicked, tooltip="Scheduler" ) def on_get_state(state): self.status_item.set_image_from_file(get_resource(state.lower() + ".png")) self.state_deferred = client.scheduler.get_state().addCallback(on_get_state) client.register_event_handler("SchedulerEvent", self.on_scheduler_event)
def __init__(self): if Wnck: self.screen = Wnck.Screen.get_default() component.Component.__init__(self, "MainWindow", interval=2) self.config = ConfigManager("gtkui.conf") # Get the glade file for the main window self.main_glade = Gtk.Builder() self.main_glade.add_from_file( pkg_resources.resource_filename("deluge.ui.gtkui", "builder/main_window.ui")) self.window_signals = {} self.window = self.main_glade.get_object("main_window") self.window.set_icon(common.get_deluge_icon()) self.vpaned = self.main_glade.get_object("vpaned") self.initial_vpaned_position = self.config["window_pane_position"] # Load the window state self.load_window_state() # Keep track of window's minimization state so that we don't update the # UI when it is minimized. self.is_minimized = False self.window.drag_dest_set( Gtk.DestDefaults.ALL, [Gtk.TargetEntry.new('text/uri-list', 0, 80)], Gdk.DragAction.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("draw", 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) client.register_event_handler("TorrentFinishedEvent", self.on_torrentfinished_event)
def enable(self): client.register_event_handler('PluginEnabledEvent', self._json.get_remote_methods) client.register_event_handler('PluginDisabledEvent', self._json.get_remote_methods) if client.is_standalone(): component.get('Web.PluginManager').start() else: client.set_disconnect_callback(self._on_client_disconnect) default_host_id = component.get( 'DelugeWeb').config['default_daemon'] if default_host_id: return self.connect(default_host_id) return defer.succeed(True)
def _register_custom_provider(self, kind, eventtype, handler): if not self._handled_eventtype(eventtype, handler): return defer.succeed('Event not handled') if eventtype not in self.custom_notifications: def wrapper(*args, **kwargs): return self._handle_custom_providers(kind, eventtype, *args, **kwargs) self.custom_notifications[kind][eventtype] = (wrapper, handler) else: wrapper, handler = self.custom_notifications[kind][eventtype] try: component.get('EventManager').register_event_handler( eventtype, wrapper ) except KeyError: from deluge.ui.client import client client.register_event_handler(eventtype, wrapper)
def __init__(self): component.Component.__init__(self, 'StatusBar', interval=3) main_builder = component.get('MainWindow').get_builder() self.statusbar = main_builder.get_object('statusbar') self.config = ConfigManager('gtkui.conf') # Status variables that are updated via callback self.max_connections_global = -1 self.num_connections = 0 self.max_download_speed = -1.0 self.download_rate = '' self.max_upload_speed = -1.0 self.upload_rate = '' self.dht_nodes = 0 self.dht_status = False self.health = False self.download_protocol_rate = 0.0 self.upload_protocol_rate = 0.0 self.config_value_changed_dict = { 'max_connections_global': self._on_max_connections_global, 'max_download_speed': self._on_max_download_speed, 'max_upload_speed': self._on_max_upload_speed, 'dht': self._on_dht } self.current_warnings = [] # Add a HBox to the statusbar after removing the initial label widget self.hbox = gtk.HBox() self.hbox.set_spacing(10) align = gtk.Alignment() align.set_padding(2, 0, 3, 0) align.add(self.hbox) frame = self.statusbar.get_children()[0] frame.remove(frame.get_children()[0]) frame.add(align) self.statusbar.show_all() # Create the not connected item self.not_connected_item = StatusBarItem( stock=gtk.STOCK_STOP, text=_('Not Connected'), callback=self._on_notconnected_item_clicked) # Show the not connected status bar self.show_not_connected() # Hide if necessary self.visible(self.config['show_statusbar']) client.register_event_handler('ConfigValueChangedEvent', self.on_configvaluechanged_event)
def enable(self): self.create_prefs_page() component.get('PluginManager').register_hook('on_apply_prefs', self.on_apply_prefs) component.get('PluginManager').register_hook('on_show_prefs', self.on_show_prefs) self.statusbar = component.get('StatusBar') self.status_item = self.statusbar.add_item( image=get_resource('green.png'), text='', callback=self.on_status_item_clicked, tooltip='Scheduler') def on_state_deferred(state): self.state = state self.on_scheduler_event(state) client.scheduler.get_state().addCallback(on_state_deferred) client.register_event_handler('SchedulerEvent', self.on_scheduler_event)
def __init__(self): component.Component.__init__(self, "StatusBar", interval=3) self.window = component.get("MainWindow") self.statusbar = self.window.main_glade.get_widget("statusbar") self.config = ConfigManager("gtkui.conf") # Status variables that are updated via callback self.max_connections = -1 self.num_connections = 0 self.max_download_speed = -1.0 self.download_rate = 0.0 self.max_upload_speed = -1.0 self.upload_rate = 0.0 self.dht_nodes = 0 self.dht_status = False self.health = False self.download_protocol_rate = 0.0 self.upload_protocol_rate = 0.0 self.config_value_changed_dict = { "max_connections_global": self._on_max_connections_global, "max_download_speed": self._on_max_download_speed, "max_upload_speed": self._on_max_upload_speed, "dht": self._on_dht } self.current_warnings = [] # Add a HBox to the statusbar after removing the initial label widget self.hbox = gtk.HBox() self.hbox.set_spacing(10) frame = self.statusbar.get_children()[0] frame.remove(frame.get_children()[0]) frame.add(self.hbox) self.statusbar.show_all() # Create the not connected item self.not_connected_item = StatusBarItem( stock=gtk.STOCK_STOP, text=_("Not Connected"), callback=self._on_notconnected_item_clicked) # Show the not connected status bar self.show_not_connected() # Hide if necessary self.visible(self.config["show_statusbar"]) client.register_event_handler("ConfigValueChangedEvent", self.on_configvaluechanged_event)
def __init__(self): if wnck: self.screen = wnck.screen_get_default() component.Component.__init__(self, "MainWindow", interval=2) self.config = ConfigManager("gtkui.conf") # Get the glade file for the main window self.main_glade = gtk.glade.XML( pkg_resources.resource_filename("deluge.ui.gtkui", "glade/main_window.glade")) self.window = self.main_glade.get_widget("main_window") self.window.set_icon(common.get_deluge_icon()) self.vpaned = self.main_glade.get_widget("vpaned") self.initial_vpaned_position = self.config["window_pane_position"] # Load the window state self.load_window_state() # Keep track of window's minimization state so that we don't update the # UI when it is minimized. self.is_minimized = False self.window.drag_dest_set(gtk.DEST_DEFAULT_ALL, [('text/uri-list', 0, 80)], gtk.gdk.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) client.register_event_handler("TorrentFinishedEvent", self.on_torrentfinished_event)
def start(self): # This gets fired once we have received the torrents list from the core self.started_deferred = defer.Deferred() # Maintain a list of (torrent_id, name) for use in tab completion self.torrents = [] def on_session_state(result): def on_torrents_status(torrents): for torrent_id, status in torrents.items(): self.torrents.append((torrent_id, status["name"])) self.started_deferred.callback(True) client.core.get_torrents_status({"id": result}, ["name"]).addCallback(on_torrents_status) client.core.get_session_state().addCallback(on_session_state) # Register some event handlers to keep the torrent list up-to-date client.register_event_handler("TorrentAddedEvent", self.on_torrent_added_event) client.register_event_handler("TorrentRemovedEvent", self.on_torrent_removed_event)
def start(self): # This gets fired once we have received the torrents list from the core self.started_deferred = defer.Deferred() # Maintain a list of (torrent_id, name) for use in tab completion self.torrents = [] def on_session_state(result): def on_torrents_status(torrents): for torrent_id, status in torrents.items(): self.torrents.append((torrent_id, status["name"])) self.started_deferred.callback(True) client.core.get_torrents_status({"id": result}, ["name"]).addCallback(on_torrents_status) client.core.get_session_state().addCallback(on_session_state) # Register some event handlers to keep the torrent list up-to-date client.register_event_handler("TorrentAddedEvent", self.on_torrent_added_event) client.register_event_handler("TorrentRemovedEvent", self.on_torrent_removed_event)
def start(self): def on_session_state(result): self.torrents = [] self.events = [] def on_torrents_status(torrents): for torrent_id, status in torrents.items(): self.torrents.append((torrent_id, status['name'])) self.started_deferred.callback(True) client.core.get_torrents_status({'id': result}, ['name']).addCallback(on_torrents_status) d = client.core.get_session_state().addCallback(on_session_state) # Register event handlers to keep the torrent list up-to-date client.register_event_handler('TorrentAddedEvent', self.on_torrent_added_event) client.register_event_handler('TorrentRemovedEvent', self.on_torrent_removed_event) return d
def __init__(self, config_key, values, parent=None, suffix="", custom_label=None, custom_max=None): QtGui.QActionGroup.__init__(self, parent) self.config_key = config_key self.custom_label = custom_label self.custom_max = custom_max self.value = None for value in values: self.addAction( QtGui.QAction(unicode(value) + suffix, self, checkable=True, triggered=self._value_triggered) ).setData(value) self.addAction(QtGui.QAction(_("Unlimited"), self, checkable=True, triggered=self._value_triggered)).setData(-1) self.addAction(QtGui.QAction(self)).setSeparator(True) self.custom_action = self.addAction(QtGui.QAction(_("Other..."), self, triggered=self._custom_triggered)) client.register_event_handler("ConfigValueChangedEvent", self._client_configvaluechanged)
def __init__(self): component.Component.__init__(self, "StatusBar", interval=3) self.window = component.get("MainWindow") self.statusbar = self.window.main_glade.get_widget("statusbar") self.config = ConfigManager("gtkui.conf") # Status variables that are updated via callback self.max_connections = -1 self.num_connections = 0 self.max_download_speed = -1.0 self.download_rate = 0.0 self.max_upload_speed = -1.0 self.upload_rate = 0.0 self.dht_nodes = 0 self.dht_status = False self.health = False self.download_protocol_rate = 0.0 self.upload_protocol_rate = 0.0 self.config_value_changed_dict = { "max_connections_global": self._on_max_connections_global, "max_download_speed": self._on_max_download_speed, "max_upload_speed": self._on_max_upload_speed, "dht": self._on_dht } self.current_warnings = [] # Add a HBox to the statusbar after removing the initial label widget self.hbox = gtk.HBox() self.hbox.set_spacing(10) frame = self.statusbar.get_children()[0] frame.remove(frame.get_children()[0]) frame.add(self.hbox) self.statusbar.show_all() # Create the not connected item self.not_connected_item = StatusBarItem( stock=gtk.STOCK_STOP, text=_("Not Connected"), callback=self._on_notconnected_item_clicked) # Show the not connected status bar self.show_not_connected() # Hide if necessary self.visible(self.config["show_statusbar"]) client.register_event_handler("ConfigValueChangedEvent", self.on_configvaluechanged_event)
def enable(self): self.glade = gtk.glade.XML(get_resource("config.glade")) self.glade.signal_autoconnect({ "on_add_button_clicked": self.on_add_button_clicked, "on_edit_button_clicked": self.on_edit_button_clicked, "on_remove_button_clicked": self.on_remove_button_clicked }) self.opts_dialog = OptionsDialog() component.get("PluginManager").register_hook( "on_apply_prefs", self.on_apply_prefs ) component.get("PluginManager").register_hook( "on_show_prefs", self.on_show_prefs ) client.register_event_handler( "AutoaddOptionsChangedEvent", self.on_options_changed_event ) self.watchdirs = {} vbox = self.glade.get_widget("watchdirs_vbox") sw = gtk.ScrolledWindow() sw.set_shadow_type(gtk.SHADOW_ETCHED_IN) sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) vbox.pack_start(sw, True, True, 0) self.store = self.create_model() self.treeView = gtk.TreeView(self.store) self.treeView.connect("cursor-changed", self.on_listitem_activated) self.treeView.connect("row-activated", self.on_edit_button_clicked) self.treeView.set_rules_hint(True) self.create_columns(self.treeView) sw.add(self.treeView) sw.show_all() component.get("Preferences").add_page( "AutoAdd", self.glade.get_widget("prefs_box") ) self.on_show_prefs()
def __init__(self): if Wnck: self.screen = Wnck.Screen.get_default() component.Component.__init__(self, "MainWindow", interval=2) self.config = ConfigManager("gtkui.conf") # Get the glade file for the main window self.main_glade = Gtk.Builder() self.main_glade.add_from_file( pkg_resources.resource_filename("deluge.ui.gtkui", "builder/main_window.ui")) self.window_signals = {} self.window = self.main_glade.get_object("main_window") self.window.set_icon(common.get_deluge_icon()) self.vpaned = self.main_glade.get_object("vpaned") self.initial_vpaned_position = self.config["window_pane_position"] # Load the window state self.load_window_state() # Keep track of window's minimization state so that we don't update the # UI when it is minimized. self.is_minimized = False self.window.drag_dest_set(Gtk.DestDefaults.ALL, [Gtk.TargetEntry.new('text/uri-list', 0, 80)], Gdk.DragAction.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("draw", 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) client.register_event_handler("TorrentFinishedEvent", self.on_torrentfinished_event)
def enable(self): self.create_prefs_page() component.get("PluginManager").register_hook("on_apply_prefs", self.on_apply_prefs) component.get("PluginManager").register_hook("on_show_prefs", self.on_show_prefs) self.statusbar = component.get("StatusBar") self.status_item = self.statusbar.add_item( image=get_resource("green.png"), text="", callback=self.on_status_item_clicked, tooltip="Scheduler") def on_state_deferred(state): self.state = state self.on_scheduler_event(state) client.scheduler.get_state().addCallback(on_state_deferred) client.register_event_handler("SchedulerEvent", self.on_scheduler_event)
def __init__(self): if wnck: self.screen = wnck.screen_get_default() component.Component.__init__(self, "MainWindow", interval=2) self.config = ConfigManager("gtkui.conf") # Get the glade file for the main window self.main_glade = gtk.glade.XML( pkg_resources.resource_filename("deluge.ui.gtkui", "glade/main_window.glade")) self.window = self.main_glade.get_widget("main_window") self.window.set_icon(common.get_deluge_icon()) self.vpaned = self.main_glade.get_widget("vpaned") self.initial_vpaned_position = self.config["window_pane_position"] # Load the window state self.load_window_state() # Keep track of window's minimization state so that we don't update the # UI when it is minimized. self.is_minimized = False self.window.drag_dest_set(gtk.DEST_DEFAULT_ALL, [('text/uri-list', 0, 80)], gtk.gdk.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) client.register_event_handler("TorrentFinishedEvent", self.on_torrentfinished_event)
def add_listener(self, listener_id, event): """ Add a listener to the event queue. :param listener_id: A unique id for the listener :type listener_id: string :param event: The event name :type event: string """ if event not in self.__events: def on_event(*args): for listener in self.__events[event]: if listener not in self.__queue: self.__queue[listener] = [] self.__queue[listener].append((event, args)) client.register_event_handler(event, on_event) self.__handlers[event] = on_event self.__events[event] = [listener_id] elif listener_id not in self.__events[event]: self.__events[event].append(listener_id)
def enable(self): self.builder = gtk.Builder(); self.builder.add_from_file(get_resource("config.ui")) self.builder.connect_signals({ "on_button_clear_clicked": self.on_button_clear_clicked, }); component.get("Preferences").add_page("TrafficLimits", self.builder.get_object("prefs_box")) component.get("PluginManager").register_hook("on_apply_prefs", self.on_apply_prefs) component.get("PluginManager").register_hook("on_show_prefs", self.on_show_prefs) self.status_item = component.get("StatusBar").add_item( image=get_resource("monitor.png"), text="", callback=self.on_status_item_clicked, tooltip="TrafficLimits plugin" ) def on_get_state(state): self.set_status(*state) self.state_deferred = client.trafficlimits.get_state().addCallback(on_get_state) client.register_event_handler("TrafficLimitUpdate", self.on_trafficlimit_update)
def start(self): client.register_event_handler("TorrentStateChangedEvent", self.on_torrent_state_changed) client.register_event_handler("TorrentRemovedEvent", self.on_torrent_removed) client.register_event_handler("TorrentAddedEvent", self.on_torrent_added) def on_get_session_state(torrent_ids): for torrent_id in torrent_ids: # Let's at least store the torrent ids with empty statuses # so that upcoming queries or status updates don't throw errors. self.torrents.setdefault(torrent_id, [time.time(), {}]) self.cache_times.setdefault(torrent_id, {}) return client.core.get_session_state().addCallback(on_get_session_state)