def set_field(self, db, field): self._db = db self._field = field if self.child is not None and self.child.get_parent() is self: self.remove(self.child) if field.hidden: # Do nothing for hidden fields. return control = None change_cb = self._on_widget__value_changed for handler in self.set_field_handlers: cont, widget, control = handler(self, db, field, change_cb) if not cont: if control is None: control = widget if field.fget or field.readonly: if hasattr(control.props, 'editable'): control.props.editable = False # Make it appear insensitive even though it's # just read-only. style = control.get_style() insensitive_bg = style.bg[gtk.STATE_INSENSITIVE] control.modify_base(gtk.STATE_NORMAL, insensitive_bg) if hasattr(control.props, 'can-focus'): control.props.can_focus = False if hasattr(control.props, 'has-focus'): control.props.has_focus = False if gobject.signal_lookup('create-clicked', control): control.connect( 'create-clicked', self._on_widget__create_clicked) if gobject.signal_lookup('update-clicked', control): control.connect( 'update-clicked', self._on_widget__update_clicked) if gobject.signal_lookup('view-clicked', control): control.connect( 'view-clicked', self._on_widget__view_clicked) widget.show() width, height = widget.size_request() # Restore normal height to large widgets. if height > self.props.height_request: self.props.height_request = -1 self.pack_start(widget) self.child = widget # Hide or show units label as appropriate. if field.units: self._units_label.show() self._units_label.set_text(field.units) else: self._units_label.hide() return # We couldn't find an endpoint handler. raise ValueError( 'Could not find an endpoint set_field handler for %r' % self.child)
def __init__(self): gobject.GObject.__init__(self) # A signal all controls can emit when requesting to become active. # Right now this means getting control of the AudioControl if gobject.signal_lookup('control_request_active', Control) == 0: gobject.signal_new('control_request_active', Control, gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, []) # The control wishes to close if gobject.signal_lookup('control_request_close', Control) == 0: gobject.signal_new('control_request_close', Control, gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, []) self._is_active = False
def __init__(self, shell): # make sure the replaygain elements are available missing = [] required = ("rgvolume", "rglimiter") for e in required: if gst.element_factory_find(e) is None: missing.append(e) if len(missing) > 0: msg = _( "The GStreamer elements required for ReplayGain processing are not available. The missing elements are: %s" ) % ", ".join(missing) RB.error_dialog(shell.props.window, _("ReplayGain GStreamer plugins not available"), msg) raise Exception(msg) self.shell_player = shell.props.shell_player self.player = self.shell_player.props.player self.settings = Gio.Settings("org.gnome.rhythmbox.plugins.replaygain") self.settings.connect("changed::limiter", self.limiter_changed_cb) self.previous_gain = [] self.fallback_gain = 0.0 self.resetting_rgvolume = False # we use different means to hook into the playback pipeline depending on # the playback backend in use if gobject.signal_lookup("get-stream-filters", self.player): self.setup_xfade_mode() self.deactivate_backend = self.deactivate_xfade_mode else: self.setup_playbin2_mode() self.deactivate_backend = self.deactivate_playbin2_mode
def __init__(self, name, format="%a %b %d %Y", parent_window=None): try: if not gobject.signal_lookup("on-change-cbcalendar", self): gobject.signal_new("on-change-cbcalendar", self, gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (float, )) except: pass self.format = format self._name = name self.parent_window = parent_window gtk.HBox.__init__(self) self.entry = gtk.Entry() self.button = gtk.Button() arrow = gtk.Arrow(gtk.ARROW_DOWN, gtk.SHADOW_IN) self.button.add(arrow) self.entry.set_editable(False) self.button.connect("pressed", self.show_calendar) self.pack_start(self.entry, False, False) self.pack_start(self.button, False, False) self._value = 0 self.direction = 'down' self.show_all()
def __init__(self, shell): # make sure the replaygain elements are available missing = [] required = ("rgvolume", "rglimiter") for e in required: if gst.element_factory_find(e) is None: missing.append(e) if len(missing) > 0: msg = _("The GStreamer elements required for ReplayGain processing are not available. The missing elements are: %s") % ", ".join(missing) RB.error_dialog(shell.props.window, _("ReplayGain GStreamer plugins not available"), msg) raise Exception(msg) self.shell_player = shell.props.shell_player self.player = self.shell_player.props.player self.settings = Gio.Settings("org.gnome.rhythmbox.plugins.replaygain") self.settings.connect("changed::limiter", self.limiter_changed_cb) self.previous_gain = [] self.fallback_gain = 0.0 self.resetting_rgvolume = False # we use different means to hook into the playback pipeline depending on # the playback backend in use if gobject.signal_lookup("get-stream-filters", self.player): self.setup_xfade_mode() self.deactivate_backend = self.deactivate_xfade_mode else: self.setup_playbin2_mode() self.deactivate_backend = self.deactivate_playbin2_mode
def __init__(self, shell): # make sure the replaygain elements are available missing = [] required = ("rgvolume", "rglimiter") for e in required: if gst.element_factory_find(e) is None: missing.append(e) if len(missing) > 0: msg = _("The GStreamer elements required for ReplayGain processing are not available. The missing elements are: %s") % ", ".join(missing) rb.error_dialog(shell.props.window, _("ReplayGain GStreamer plugins not available"), msg) raise Exception(msg) self.shell_player = shell.props.shell_player self.player = self.shell_player.props.player self.gconf = gconf.client_get_default() self.gconf.add_dir(config.GCONF_DIR, preload=False) self.gconf.notify_add(config.GCONF_KEYS['limiter'], self.limiter_changed_cb) self.previous_gain = [] self.fallback_gain = 0.0 self.resetting_rgvolume = False # we use different means to hook into the playback pipeline depending on # the playback backend in use if gobject.signal_lookup("get-stream-filters", self.player): self.setup_xfade_mode() self.deactivate_backend = self.deactivate_xfade_mode else: self.setup_playbin2_mode() self.deactivate_backend = self.deactivate_playbin2_mode
def __init__(self, settings = {}, number_of_settings=1, hidden_on_load=False): self.title = None self.gobject = gobject.GObject() if gobject.signal_lookup('settings-changed', self.gobject) == 0: gobject.signal_new( "settings-changed", gobject.GObject, gobject.SIGNAL_ACTION, gobject.TYPE_NONE, (str, gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT)) if gobject.signal_lookup('loading-settings', self.gobject) == 0: gobject.signal_new( "loading-settings", gobject.GObject, gobject.SIGNAL_ACTION, gobject.TYPE_NONE, (int,)) if gobject.signal_lookup('settings-changed', self.gobject) == 0: gobject.signal_new( "settings-changed", gobject.GObject, gobject.SIGNAL_ACTION, gobject.TYPE_NONE, (str, gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT)) if gobject.signal_lookup('settings-loaded', self.gobject) == 0: gobject.signal_new( "settings-loaded", gobject.GObject, gobject.SIGNAL_ACTION, gobject.TYPE_NONE, (str, gobject.TYPE_PYOBJECT)) self.gobject.loading = True self.gobject.__loaded = False self.__gui_initialized = False self.gobject.number_of_settings = number_of_settings if 'hidden_on_load' not in dir(self): self.hidden_on_load = hidden_on_load self.threading = async.ThreadedClass() self.settings = settings gtk.VBox.__init__(self) self.set_spacing(0) if '_build_interface' in dir(self): self.__build_interface_real = self._build_interface self._build_interface = self.__build_interface_wrapper else: self.__gui_initialized = True
def supportsSignal(self, signalName): """ Checks to see if a GTK object supports a signal. Checks to see if a GTK object supports a signal, via the gobject.signal_lookup method. Returns True if it is supported, false otherwise. """ return gobject.signal_lookup(signalName, self.widget.__class__) != 0
def register_callbacks(self, signals): ''' Called by any class that is interested in receiving events from this object to register callbacks. Return: dict of bound signals. Use it to unregister your class, once no longer required. ''' handlers = {} for key in signals.keys(): if gobject.signal_lookup(key, self.__class__): handlers[key] = self.connect(key, signals[key]) return handlers
def __init__(self, settings={}, number_of_settings=1, hidden_on_load=False): self.title = None self.gobject = gobject.GObject() if gobject.signal_lookup('settings-changed', self.gobject) == 0: gobject.signal_new( "settings-changed", gobject.GObject, gobject.SIGNAL_ACTION, gobject.TYPE_NONE, (str, gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT)) if gobject.signal_lookup('loading-settings', self.gobject) == 0: gobject.signal_new("loading-settings", gobject.GObject, gobject.SIGNAL_ACTION, gobject.TYPE_NONE, (int, )) if gobject.signal_lookup('settings-changed', self.gobject) == 0: gobject.signal_new( "settings-changed", gobject.GObject, gobject.SIGNAL_ACTION, gobject.TYPE_NONE, (str, gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT)) if gobject.signal_lookup('settings-loaded', self.gobject) == 0: gobject.signal_new("settings-loaded", gobject.GObject, gobject.SIGNAL_ACTION, gobject.TYPE_NONE, (str, gobject.TYPE_PYOBJECT)) self.gobject.loading = True self.gobject._loaded = False self._gui_initialized = False self.gobject.number_of_settings = number_of_settings if 'hidden_on_load' not in dir(self): self.hidden_on_load = hidden_on_load self.threading = async .ThreadedClass() self.settings = settings gtk.VBox.__init__(self) self.set_spacing(0) if '_build_interface' in dir(self): self._build_interface_real = self._build_interface self._build_interface = self._build_interface_wrapper else: self._gui_initialized = True
def do_setup_pipeline(self): self.src = gst.element_make_from_uri(gst.URI_SRC, self.fromuri) self.remuxbin = RemuxBin(self.start_time, self.stop_time) self.sink = gst.element_make_from_uri(gst.URI_SINK, self.touri) self.resolution = UNKNOWN if gobject.signal_lookup('allow-overwrite', self.sink.__class__): self.sink.connect('allow-overwrite', lambda *x: True) self.add(self.src, self.remuxbin, self.sink) self.src.link(self.remuxbin) self.remuxbin.link(self.sink)
def __init__(self, initial_value=0, parent_window=None): gtk.Dialog.__init__(self) try: if not gobject.signal_lookup("on-change-calendar-window", self): gobject.signal_new("on-change-calendar-window", self, gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (float,)) except: pass self.set_modal(True) if parent_window: parent_window.set_transient_for(self) hbox = gtk.HBox() self.calendar = gtk.Calendar() buttonCurrent = gtk.Button() buttonDelete = gtk.Button() buttonCurrent.add(gtk.Label("Current")) buttonDelete.add(gtk.Label("Delete")) hbox.pack_start(buttonCurrent) hbox.pack_start(buttonDelete) self.vbox.pack_start(self.calendar, False, False) self.vbox.pack_start(hbox) self.set_decorated(False) self.set_position(gtk.WIN_POS_NONE) self.set_property("skip-taskbar-hint", True) buttonCurrent.connect("pressed", self.do_select_current) buttonDelete.connect("pressed", self.do_select_none) self.calendar.connect("day-selected-double-click", self.do_select_day) self.connect("focus-out-event", self.do_hide_calendar) self.value = initial_value # if there are a value, select the day if self.value: year, month, day, hour, minute, second, dow, doy, isdst = time.localtime(self.value) self.calendar.select_month(month-1, year) self.calendar.select_day(day) self.show_all() self.action_area.hide()
def __init__(self, initial_value=0, parent_window=None): gtk.Dialog.__init__(self) try: if not gobject.signal_lookup("on-change-calendar-window", self): gobject.signal_new("on-change-calendar-window", self, gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (float, )) except: pass self.set_modal(True) if parent_window: parent_window.set_transient_for(self) hbox = gtk.HBox() self.calendar = gtk.Calendar() buttonCurrent = gtk.Button() buttonDelete = gtk.Button() buttonCurrent.add(gtk.Label("Current")) buttonDelete.add(gtk.Label("Delete")) hbox.pack_start(buttonCurrent) hbox.pack_start(buttonDelete) self.vbox.pack_start(self.calendar, False, False) self.vbox.pack_start(hbox) self.set_decorated(False) self.set_position(gtk.WIN_POS_NONE) self.set_property("skip-taskbar-hint", True) buttonCurrent.connect("pressed", self.do_select_current) buttonDelete.connect("pressed", self.do_select_none) self.calendar.connect("day-selected-double-click", self.do_select_day) self.connect("focus-out-event", self.do_hide_calendar) self.value = initial_value # if there are a value, select the day if self.value: year, month, day, hour, minute, second, dow, doy, isdst = time.localtime( self.value) self.calendar.select_month(month - 1, year) self.calendar.select_day(day) self.show_all() self.action_area.hide()
def add_action_widget(self, child, response_id): if not gobject.type_is_a(child, gtk.Widget): print 'Not a Widget' #FIXME: return print '#TODO: add response data' print child if type(child) is gtk.Button: signal_id = gobject.signal_lookup('clicked', type(child)) else: signal_id = gobject.signal_lookup('activate', type(child)) if signal_id: print 'TODO: check if this is correct.' signal = gobject.signal_name(signal_id) child.connect(signal, MessageArea.__action_widget_activated, self) #FIXME: else: print "Only 'activatable' widgets can be packed into the action area of a MessageArea" if response_id != gtk.RESPONSE_HELP: self.action_area.pack_start(child, False, False, 0) else: self.action_area.pack_end(child, False, False, 0)
def _handle_clipboard(self, widget, signal): """ This finds the currently focused widget. If no widget is focused or the focused widget doesn't support the given clipboard operation use the treeview (False), otherwise signal the widget to handel the clipboard operation (True). """ widget = self._get_focus_widget(self) if widget is None or widget is self.treeview: return False if gobject.signal_lookup(signal + "-clipboard", widget): widget.emit(signal + "-clipboard") return True else: return False
def __init__(self, offline=False): logging.basicConfig(level=defs.log_level) gobject.GObject.__init__(self) self.builder = gtk.Builder() ui_file = "%s/notification.ui" % defs.WALLBOX_DATA_DIR self.builder.add_from_file(ui_file) self.builder.connect_signals(self, None) self.window = self.builder.get_object("notification_window") self.window.connect("configure-event", self.on_window_resize) self.entry_status = self.builder.get_object("entry_status") self.scrolledwindow = self.builder.get_object("scrolledwindow") self.comments = {} self.comment_handler_id = None self.progressbar_refresh = self.builder.get_object( "progressbar_refresh") if gobject.signal_lookup("has-unread", Notification) == 0: gobject.signal_new \ ("has-unread", Notification, gobject.SIGNAL_RUN_LAST, \ gobject.TYPE_NONE, (gobject.TYPE_INT,)) bus = dbus.SessionBus() obj = bus.get_object ("org.wallbox.PostOfficeService", \ "/org/wallbox/PostOfficeObject") self.office = dbus.Interface \ (obj, "org.wallbox.PostOfficeInterface") self.office.connect_to_signal \ ("status_changed", self.on_office_status_changed, \ dbus_interface="org.wallbox.PostOfficeInterface") self.office.connect_to_signal \ ("refresh_status_changed", self.on_refresh_status_changed, \ dbus_interface="org.wallbox.PostOfficeInterface") self.init_view() self.office.refresh() self.on_office_status_changed(1) self.view_refresh()
def add_field(self, labelText, fieldWidget): self.fields.append(fieldWidget) if self.autoUpdate: fieldWidget.connect("new-value", self.emit_search_updated) else: if gobject.signal_lookup("activate", fieldWidget.get_widget()): fieldWidget.get_widget().connect("activate", self.emit_search_updated) label = gtk.Label(labelText) label.set_alignment(0.0, 0.5) currentNRows = self.get_property("n-rows") nColumns = self.get_property("n-columns") self.attach(label, nColumns - 2, nColumns - 1, currentNRows - 1, currentNRows, gtk.FILL) self.attach(fieldWidget.widget, nColumns - 1, nColumns - 0, currentNRows - 1, currentNRows, gtk.EXPAND | gtk.FILL) self.resize(currentNRows + 1, nColumns) self.show_all()
def __init__ (self, offline=False): logging.basicConfig (level=defs.log_level) gobject.GObject.__init__(self) self.builder = gtk.Builder () ui_file = "%s/notification.ui" % defs.WALLBOX_DATA_DIR self.builder.add_from_file (ui_file) self.builder.connect_signals (self, None) self.window = self.builder.get_object ("notification_window") self.window.connect ("configure-event", self.on_window_resize) self.entry_status = self.builder.get_object ("entry_status") self.scrolledwindow = self.builder.get_object ("scrolledwindow") self.comments = {} self.comment_handler_id = None self.progressbar_refresh = self.builder.get_object ("progressbar_refresh") if gobject.signal_lookup ("has-unread", Notification) == 0: gobject.signal_new \ ("has-unread", Notification, gobject.SIGNAL_RUN_LAST, \ gobject.TYPE_NONE, (gobject.TYPE_INT,)) bus = dbus.SessionBus () obj = bus.get_object ("org.wallbox.PostOfficeService", \ "/org/wallbox/PostOfficeObject") self.office = dbus.Interface \ (obj, "org.wallbox.PostOfficeInterface") self.office.connect_to_signal \ ("status_changed", self.on_office_status_changed, \ dbus_interface="org.wallbox.PostOfficeInterface") self.office.connect_to_signal \ ("refresh_status_changed", self.on_refresh_status_changed, \ dbus_interface="org.wallbox.PostOfficeInterface") self.init_view () self.office.refresh () self.on_office_status_changed (1) self.view_refresh ()
def __init__(self, shell): # make sure the replaygain elements are available missing = [] required = ("rgvolume", "rglimiter") for e in required: if gst.element_factory_find(e) is None: missing.append(e) if len(missing) > 0: msg = _( "The GStreamer elements required for ReplayGain processing are not available. The missing elements are: %s" ) % ", ".join(missing) rb.error_dialog(shell.props.window, _("ReplayGain GStreamer plugins not available"), msg) raise Exception(msg) self.shell_player = shell.props.shell_player self.player = self.shell_player.props.player self.gconf = gconf.client_get_default() self.gconf.add_dir(config.GCONF_DIR, preload=False) self.gconf.notify_add(config.GCONF_KEYS['limiter'], self.limiter_changed_cb) self.previous_gain = [] self.fallback_gain = 0.0 self.resetting_rgvolume = False # we use different means to hook into the playback pipeline depending on # the playback backend in use if gobject.signal_lookup("get-stream-filters", self.player): self.setup_xfade_mode() self.deactivate_backend = self.deactivate_xfade_mode else: self.setup_playbin2_mode() self.deactivate_backend = self.deactivate_playbin2_mode
def on_activate(self, widget): if 'plugins' not in gajim.interface.instances: return if hasattr(self, 'page_num'): # 'Available' tab exists return self.installed_plugins_model = gajim.interface.instances[ 'plugins'].installed_plugins_model self.notebook = gajim.interface.instances['plugins'].plugins_notebook id_ = self.notebook.connect('switch-page', self.on_notebook_switch_page) self.connected_ids[id_] = self.notebook self.window = gajim.interface.instances['plugins'].window id_ = self.window.connect('destroy', self.on_win_destroy) self.connected_ids[id_] = self.window self.GTK_BUILDER_FILE_PATH = self.local_file_path('config_dialog.ui') self.xml = gtk.Builder() self.xml.set_translation_domain('gajim_plugins') self.xml.add_objects_from_file(self.GTK_BUILDER_FILE_PATH, ['hpaned2', 'image1']) self.hpaned = self.xml.get_object('hpaned2') self.page_num = self.notebook.append_page(self.hpaned, gtk.Label(_('Available'))) widgets_to_extract = ('plugin_name_label1', 'available_treeview', 'progressbar', 'inslall_upgrade_button', 'plugin_authors_label1', 'plugin_authors_label1', 'plugin_homepage_linkbutton1') for widget_name in widgets_to_extract: setattr(self, widget_name, self.xml.get_object(widget_name)) attr_list = pango.AttrList() attr_list.insert(pango.AttrWeight(pango.WEIGHT_BOLD, 0, -1)) self.plugin_name_label1.set_attributes(attr_list) self.available_plugins_model = gtk.ListStore(gtk.gdk.Pixbuf, gobject.TYPE_PYOBJECT, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_BOOLEAN, gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT) self.available_treeview.set_model(self.available_plugins_model) self.available_treeview.set_rules_hint(True) self.available_plugins_model.set_sort_column_id(2, gtk.SORT_ASCENDING) self.progressbar.set_property('no-show-all', True) renderer = gtk.CellRendererText() col = gtk.TreeViewColumn(_('Plugin')) cell = gtk.CellRendererPixbuf() col.pack_start(cell, False) col.add_attribute(cell, 'pixbuf', C_PIXBUF) col.pack_start(renderer, True) col.add_attribute(renderer, 'text', C_NAME) col.set_resizable(True) col.set_property('expand', True) col.set_sizing(gtk.TREE_VIEW_COLUMN_GROW_ONLY) self.available_treeview.append_column(col) col = gtk.TreeViewColumn(_('Installed\nversion'), renderer, text=C_LOCAL_VERSION) self.available_treeview.append_column(col) col = gtk.TreeViewColumn(_('Available\nversion'), renderer, text=C_VERSION) col.set_property('expand', False) self.available_treeview.append_column(col) renderer = gtk.CellRendererToggle() renderer.set_property('activatable', True) renderer.connect('toggled', self.available_plugins_toggled_cb) col = gtk.TreeViewColumn(_('Install /\nUpgrade'), renderer, active=C_UPGRADE) self.available_treeview.append_column(col) if gobject.signal_lookup('error_signal', self.window) is 0: gobject.signal_new('error_signal', self.window, gobject.SIGNAL_RUN_LAST, gobject.TYPE_STRING, (gobject.TYPE_STRING,)) gobject.signal_new('plugin_downloaded', self.window, gobject.SIGNAL_RUN_LAST, gobject.TYPE_STRING, (gobject.TYPE_PYOBJECT,)) id_ = self.window.connect('error_signal', self.on_some_ftp_error) self.connected_ids[id_] = self.window id_ = self.window.connect('plugin_downloaded', self.on_plugin_downloaded) self.connected_ids[id_] = self.window selection = self.available_treeview.get_selection() selection.connect('changed', self.available_plugins_treeview_selection_changed) selection.set_mode(gtk.SELECTION_SINGLE) self._clear_available_plugin_info() self.plugin_description_textview = HtmlTextView() sw = self.xml.get_object('scrolledwindow1') sw.add(self.plugin_description_textview) self.xml.connect_signals(self) self.window.show_all()
def addShortcut(accelGroup, widget, shortcut, callback, *args): """ Adds a shortcut identified by a string to the widget and sets the callback to the shortcut. The shortcut string looks like this: <ctrl><shift>2 => (l/r)-CTRL + (l/r)-shift + 2 There are max. 3 modifier (ctrl/shift/alt/...) allowed. """ match = shortExp.match(shortcut) if not match: logging.error("addShortcut: No pattern match for %s" % (shortcut)) return None vGroups = [g for g in match.groups() if g] if not vGroups: logging.error("addShortcut: No filled groups for %s" % (shortcut)) return None mask = 0 for group in vGroups[:-1]: if group == "<ctrl>": mask |= CONTROL_MASK if group == "<shift>": mask |= SHIFT_MASK if group == "<alt>": mask |= MOD1_MASK key = vGroups[-1] if len(key) > 1: keyval = keyval_from_name(key) if not keyval: logging.error("addShortcut: Too much chars for (%s)." % (key)) return None else: keyval = ord(key) # name like shortCut_ctrl_shift_2 signame = "shortCut_"+"_".join([i.strip("<>") for i in vGroups]) if not signal_lookup(signame, widget): signal_new(signame, widget, SIGNAL_ACTION, None, ()) widget.add_accelerator( signame, accelGroup, keyval, mask, ACCEL_VISIBLE) handler = widget.connect(signame, callback, shortcut, *args) if not regmap.has_key(accelGroup): regmap[accelGroup] = {} if not regmap[accelGroup].has_key(widget): regmap[accelGroup][widget]=[ (handler,vGroups,keyval,mask) ] else: regmap[accelGroup][widget].append( (handler,vGroups,keyval,mask) ) return handler
def __init__(self, headers=None, rows=None, types=None, combos=None, combotypes=None, selection_type=None): if gobject.signal_lookup('toggled', self) == 0: gobject.signal_new( "toggled", self, gobject.SIGNAL_ACTION, gobject.TYPE_NONE, ( gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT )) if gobject.signal_lookup('changed', self) == 0: gobject.signal_new( "changed", self, gobject.SIGNAL_ACTION, gobject.TYPE_NONE, ( gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT )) if gobject.signal_lookup('right-click', self) == 0: gobject.signal_new( 'right-click', self, gobject.SIGNAL_ACTION, gobject.TYPE_NONE, ( gobject.TYPE_OBJECT, gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT, gtk.gdk.Event )) if gobject.signal_lookup('double-click', self) == 0: gobject.signal_new( 'double-click', self, gobject.SIGNAL_ACTION, gobject.TYPE_NONE, ( gobject.TYPE_OBJECT, gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT, gtk.gdk.Event )) self._fallback_pixbuf = None # Remember: First cell is index if rows is None: rows = [] if len(rows): self.rows = self.__failsafe_rows(rows) if types is None: self._cell_types, self._render_types = self.__convert_rows_to_types(self.rows) else: self._cell_types, self._render_types = self.__convert_rows_to_types([types]) elif types is not None: self.rows = rows self._cell_types, self._render_types = self.__convert_rows_to_types([types]) else: raise(ValueError, "You need to supply either rows or types.") number_of_combocols = len([ col for col in self._cell_types if col is list ]) if combos is not None: if type(combos[0][0]) not in (tuple, list): self._combos = [ [ [row] for row in combo ] for combo in combos ] else: self._combos = combos if combotypes is not None: self._combocols = combotypes else: self._combocols = [] for combo in self._combos: if type(combo[0]) in (list, tuple): self._combocols.append([str] * len(combo[0])) else: self._combocols.append([str]) self._combomodels = [ gtk.ListStore(*column) for column in self._combocols ] for combo_nr, combo in enumerate(self._combos): for row in combo: self._combomodels[combo_nr].append( self._create_model_row_from_row(row, self._combocols[combo_nr]) ) else: if number_of_combocols: raise(ValueError, "When using Combo renderers, you need to assign the comborows.") if headers is None: headers = [ '' for i in range(len(self._cell_types)-1) ] self.headers = headers self.selection_type = selection_type gtk.VBox.__init__(self) self._create_widgets() self._create_headers() self.fill()
def on_copy_tree(self): """Callback for copy on whole tree""" widget = self._main_window.get_focus() if gobject.signal_lookup("copy-tree-clipboard", widget) != 0: widget.emit("copy-tree-clipboard")
def __init__(self, frame, message="", default_text='', textview=None, modal=True): gtk.Dialog.__init__(self) # Test if the signal is already binded since we do not clear it # when we destroy FindDialog if not gobject.signal_lookup("find-click", gtk.Window): gobject.signal_new( "find-click", gtk.Window, gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_STRING,) ) self.textview = textview self.nicotine = frame self.connect("delete-event", self.quit) # The destroy event shoul clean up the reference to FindDialog # in the NicotineFrame object self.connect("destroy", self.destroy) self.nextPosition = None self.currentPosition = None self.lastdirection = "next" if modal: self.set_modal(True) box = gtk.VBox(spacing=10) box.set_border_width(10) self.vbox.pack_start(box) box.show() if message: label = gtk.Label(message) box.pack_start(label, False, False) label.set_line_wrap(True) label.show() self.entry = gtk.Entry() box.pack_start(self.entry, False, False) self.entry.show() self.entry.grab_focus() self.entry.connect("activate", self.next) Cancelbutton = self.nicotine.CreateIconButton( gtk.STOCK_CANCEL, "stock", self.quit, _("Cancel") ) Cancelbutton.set_flags(gtk.CAN_DEFAULT) self.action_area.pack_start(Cancelbutton) Previousbutton = self.nicotine.CreateIconButton( gtk.STOCK_GO_BACK, "stock", self.previous, _("Previous") ) Previousbutton.set_flags(gtk.CAN_DEFAULT) self.action_area.pack_start(Previousbutton) Nextbutton = self.nicotine.CreateIconButton( gtk.STOCK_GO_FORWARD, "stock", self.next, _("Next") ) Nextbutton.set_flags(gtk.CAN_DEFAULT) self.action_area.pack_start(Nextbutton) Nextbutton.grab_default()
def widgetHasSignal(widget, signalName): if widget.isInstanceOf(gtk.TreeView): # Ignore this for treeviews: as they have no title/label they can't really get confused with other stuff return widget.get_model() is not None else: return gobject.signal_lookup(signalName, widget.widget) != 0
def __init__(cls, name, bases, dict): gobject.GObjectMeta.__init__(cls, name, bases, dict) # merge all the properties from the base classes properties = [] properties_by_name = {} for base in bases + (cls,): if hasattr(base, "properties"): for p in base.properties: existing_p = properties_by_name.get(p.name) if existing_p is None: tmp = copy.copy(p) properties.append(tmp) properties_by_name[p.name] = tmp else: if existing_p.default is not None: p.default = existing_p.default if existing_p.fset is not None: p.fset = existing_p.fset if existing_p.fget is not None: p.fget = existing_p.fget for p in properties: p.signal = False p.signal_name = None if "properties" in dict: for p in cls.properties: properties_by_name[p.name].signal = p.signal cls.properties = properties cls.properties_by_name = properties_by_name # create signals for p in cls.properties: if p.signal: # a signal is only created when explicitly mentioned in the # class itself (and not when it is inherited). p.signal_name = ("on-%s-changed" % p.name).replace("_", "-") # avoid signals to be created twice. This happes when a plugin # is loaded twice. (for example in the unittests) if gobject.signal_lookup(p.signal_name, cls) == 0: gobject.signal_new(p.signal_name, cls, gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, ()) # assign the derived default, get and set functions for p in cls.properties: # default if p.fdefault is not None: derived_fdefault = dict.get(p.fdefault.__name__) if derived_fdefault is not None: p.fdefault = derived_fdefault # get derived_fget = dict.get(p.fget.__name__) if derived_fget is not None: p.fget = derived_fget # set derived_fset = dict.get(p.fset.__name__) if derived_fset is not None: p.fset = derived_fset # merge the edit fields with those from the ancestors if not hasattr(cls, "dialog_fields"): cls.dialog_fields = set([]) for base in bases: if hasattr(base, "dialog_fields"): cls.dialog_fields |= base.dialog_fields # create a nodeinfo if needed if not hasattr(cls, "info"): from node import NodeInfo cls.info = NodeInfo() # merge the node info with that from the ancestors d = {} for base in bases: if hasattr(base, "info"): d.update(base.info.__dict__) d.update(cls.info.__dict__) cls.info.__dict__ = d
def __init__(self, headers=None, rows=None, types=None, combos=None, combotypes=None, selection_type=None): if gobject.signal_lookup('toggled', self) == 0: gobject.signal_new( "toggled", self, gobject.SIGNAL_ACTION, gobject.TYPE_NONE, ( gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT )) if gobject.signal_lookup('changed', self) == 0: gobject.signal_new( "changed", self, gobject.SIGNAL_ACTION, gobject.TYPE_NONE, ( gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT )) if gobject.signal_lookup('right-click', self) == 0: gobject.signal_new( 'right-click', self, gobject.SIGNAL_ACTION, gobject.TYPE_NONE, ( gobject.TYPE_OBJECT, gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT, gtk.gdk.Event )) if gobject.signal_lookup('double-click', self) == 0: gobject.signal_new( 'double-click', self, gobject.SIGNAL_ACTION, gobject.TYPE_NONE, ( gobject.TYPE_OBJECT, gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT, gtk.gdk.Event )) self._fallback_pixbuf = None # Remember: First cell is index if rows is None: rows = [] if len(rows): self.rows = self._failsafe_rows(rows) if types is None: self._cell_types, self._render_types = self._convert_rows_to_types(self.rows) else: self._cell_types, self._render_types = self._convert_rows_to_types([types]) elif types is not None: self.rows = rows self._cell_types, self._render_types = self._convert_rows_to_types([types]) else: raise(ValueError, "You need to supply either rows or types.") number_of_combocols = len([ col for col in self._cell_types if col is list ]) if combos is not None: if type(combos[0][0]) not in (tuple, list): self._combos = [ [ [row] for row in combo ] for combo in combos ] else: self._combos = combos if combotypes is not None: self._combocols = combotypes else: self._combocols = [] for combo in self._combos: if type(combo[0]) in (list, tuple): self._combocols.append([str] * len(combo[0])) else: self._combocols.append([str]) self._combomodels = [ gtk.ListStore(*column) for column in self._combocols ] for combo_nr, combo in enumerate(self._combos): for row in combo: self._combomodels[combo_nr].append( self._create_model_row_from_row(row, self._combocols[combo_nr]) ) else: if number_of_combocols: raise(ValueError, "When using Combo renderers, you need to assign the comborows.") if headers is None: headers = [ '' for i in range(len(self._cell_types)-1) ] self.headers = headers self.selection_type = selection_type gtk.VBox.__init__(self) self._create_widgets() self._create_headers() self.fill()
def event_central(self, obj, event): ## This routine runs many times. Once for every kind ## of event the actor is getting. ## filter out only the mouse events. if event.type not in Mouserizer.__clutter_mouse_event_types: return Mouserizer.YES_CONTINUE_EMITTING ## filter out buttons we are NOT going to deal with if hasattr(event, "button"): b = 1 << (event.button - 1) #print bin(b)," vs ", bin(self.buttons) if not(b & self.buttons !=0 ): return Mouserizer.NO_STOP_EMITTING # is this wise? ## event_central ONLY runs when cursor is ## over the actor -- thus ENTER is implied. ## Make a note of PRESS/RELEASE if event.type==clutter.BUTTON_PRESS: self.ui_state = self.ui_state | Mouserizer.__FLAG_PRESSING # set bit if event.type==clutter.BUTTON_RELEASE: self.ui_state = self.ui_state | Mouserizer.__FLAG_RELEASING # set bit ## Make a note of MOTION ## First, clear it. self.ui_state = self.ui_state & ~Mouserizer.__FLAG_MOVING # clear bit if event.type==clutter.MOTION: self.ui_state = self.ui_state | Mouserizer.__FLAG_MOVING # set bit ## Now, what kinds of stuff is this actor interested in? ## DO META EVENTS - "More than" events. e.g. 'Click' is press, then release. if (self.ui & Mouserizer.CLICKABLE) != 0: # test bit if self.ui_state == Mouserizer.__PATTERN_CLICK: if event.click_count > 1: self.emit('double-click', event) else: ## A single click is fired just before double-click...! self.emit('single-click', event) if (self.ui & Mouserizer.DRAGABLE) !=0: # test bit if self.ui_state == Mouserizer.__PATTERN_DRAG_START: self.ui_state=self.ui_state | Mouserizer.__FLAG_DRAGGING # set bit self.draglet = DragEnvelope( self, event ) ## Phew! I thought I was fcuked! In order to get dragging to ## work when the pointer is NOT ON the Actor, I had to revert ## to grab_pointer* -- and that needs connecting. I connected the ## two appropriate event to *this* same function! And it works :D ## ## * grab_pointer causes the entire window (stage?) to focus on the ## Actor passed -- so I get all motion and release events even where ## the Actor aint. ## ! Not sure what kind of recursive issues this may throw at me :( clutter.grab_pointer( self ) self.connect('motion-event', self.event_central) self.connect('button-release-event', self.event_central) self.emit('drag-start', self.draglet ) elif self.ui_state == Mouserizer.__PATTERN_DRAG: self.draglet.calcPos( event ) # A 'draglet' is a little wrapper containing the event and some tricks. ## Who is under me? Only do if PICK_UNDER flag is set. if self.__PICK_UNDER: self.hide() a = self.stage.get_actor_at_pos(clutter.PICK_REACTIVE, int(event.x),int(event.y)) self.show() ## a is! ## Only emit if a has a drag-over signal: if gobject.signal_lookup('drag-over', a ): print a, " under me" a.emit('drag-over', self.draglet) self.emit('dragging', self.draglet) elif self.ui_state == Mouserizer.__PATTERN_DROP: self.draglet.calcPos( event ) self.ui_state= self.ui_state & ~Mouserizer.__FLAG_DRAGGING # clear bit clutter.ungrab_pointer() self.emit("drop", self.draglet) del(self.draglet) ## META EVENTS are done. ## Flip opposites off. if event.type==clutter.BUTTON_PRESS: self.ui_state = self.ui_state & ~Mouserizer.__FLAG_RELEASING # clear bit if event.type==clutter.BUTTON_RELEASE: self.ui_state = self.ui_state & ~Mouserizer.__FLAG_PRESSING # clear bit self.ui_state = self.ui_state & ~Mouserizer.__FLAG_RELEASING # clear bit self.ui_state = self.ui_state & ~Mouserizer.__FLAG_DRAGGING # clear bit return Mouserizer.YES_CONTINUE_EMITTING
def __init__(self, frame, message="", default_text='', textview=None, modal=True): gtk.Dialog.__init__(self) # Test if the signal is already binded since we do not clear it # when we destroy FindDialog if not gobject.signal_lookup("find-click", gtk.Window): gobject.signal_new("find-click", gtk.Window, gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_STRING, )) self.textview = textview self.nicotine = frame self.connect("delete-event", self.quit) # The destroy event shoul clean up the reference to FindDialog # in the NicotineFrame object self.connect("destroy", self.destroy) self.nextPosition = None self.currentPosition = None self.lastdirection = "next" if modal: self.set_modal(True) box = gtk.VBox(spacing=10) box.set_border_width(10) self.vbox.pack_start(box) box.show() if message: label = gtk.Label(message) box.pack_start(label, False, False) label.set_line_wrap(True) label.show() self.entry = gtk.Entry() box.pack_start(self.entry, False, False) self.entry.show() self.entry.grab_focus() self.entry.connect("activate", self.next) Previousbutton = self.nicotine.CreateIconButton( gtk.STOCK_GO_BACK, "stock", self.previous, _("Previous")) Previousbutton.set_flags(gtk.CAN_DEFAULT) self.action_area.pack_start(Previousbutton) Nextbutton = self.nicotine.CreateIconButton(gtk.STOCK_GO_FORWARD, "stock", self.next, _("Next")) Nextbutton.set_flags(gtk.CAN_DEFAULT) self.action_area.pack_start(Nextbutton) Nextbutton.grab_default() Cancelbutton = self.nicotine.CreateIconButton(gtk.STOCK_CANCEL, "stock", self.quit, _("Cancel")) Cancelbutton.set_flags(gtk.CAN_DEFAULT) self.action_area.pack_start(Cancelbutton)
def install_signal(self, signal): if not gobject.signal_lookup(signal, self.__class__): gobject.signal_new(signal, self.__class__, gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT, ))
def install_signal(self, signal): if not gobject.signal_lookup(signal, self.__class__): gobject.signal_new(signal, self.__class__, gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,))
def __init__(self): if not gobject.signal_lookup("output", ShellCommandJob): gobject.signal_new("output", ShellCommandJob, \ gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, \ [str]) if not gtk.main_level(): gtk.gdk.threads_init() # _DEBE_ llamarse _ANTES_ del gtk.main por temas del GIL.
def __init__(self, parent, englabel=None, userdict={}, timeout=10): """ The PTK engine class for embedding in gtk applications. To use create an instance of this or a subclass. It uses the parent object for signals. engine.disconnect() should also be called before the application exits. Important. It uses the a the gtk mainloop to post/bind events and starts a communications thread, therefore gtk.gdk.threads_init() must be called before the main loop is started! gtk.gdk.threads_init() gtk.main() Signals to use: 'engine_disconnect' - sent went the engine disconnects. Methods/attributes you might want to overload: _get_welcome() - Returns a string welcome message. self.eng_prompts - these are the prompts used by the controlling console. """ self.parent = parent #add the engine disconnect signal if gobject.signal_lookup("engine_disconnect", self.parent) == 0: gobject.signal_new("engine_disconnect", self.parent, gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,()) Engine.__init__(self, englabel, userdict, timeout)
def __init__(self, name, format="%a %b %d %Y", parent_window=None): try: if not gobject.signal_lookup("on-change-cbcalendar", self): gobject.signal_new("on-change-cbcalendar", self, gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (float,)) except: pass self.format = format self._name = name self.parent_window = parent_window gtk.HBox.__init__(self) self.entry = gtk.Entry() self.button = gtk.Button() arrow = gtk.Arrow(gtk.ARROW_DOWN, gtk.SHADOW_IN) self.button.add(arrow) self.entry.set_editable(False) self.button.connect("pressed", self.show_calendar) self.pack_start(self.entry, False, False) self.pack_start(self.button, False, False) self._value = 0 self.direction = 'down' self.show_all()