def test_signal_lookup(self): ids = GObject.signal_list_ids(C) self.assertEqual(ids[0], GObject.signal_lookup('my_signal', C)) self.assertEqual(ids[0], GObject.signal_lookup('my-signal', C)) with self.assertRaisesRegex(TypeError, 'type must be instantiable or an interface.*'): GObject.signal_lookup('NOT_A_SIGNAL_NAME', GObject.TYPE_INT) # Invalid signal names return 0 instead of raising self.assertEqual(GObject.signal_lookup('NOT_A_SIGNAL_NAME', C), 0)
def test_signal_lookup(self): ids = GObject.signal_list_ids(C) self.assertEqual(ids[0], GObject.signal_lookup('my_signal', C)) self.assertEqual(ids[0], GObject.signal_lookup('my-signal', C)) with self.assertRaisesRegex( TypeError, 'type must be instantiable or an interface.*'): GObject.signal_lookup('NOT_A_SIGNAL_NAME', GObject.TYPE_INT) # Invalid signal names return 0 instead of raising self.assertEqual(GObject.signal_lookup('NOT_A_SIGNAL_NAME', C), 0)
def attach_widget(self, parent, widget=None): if widget: self._widget = widget else: self._widget = parent self.notify('widget') self._enter_hid = self._widget.connect('enter-notify-event', self.__enter_notify_event_cb) self._leave_hid = self._widget.connect('leave-notify-event', self.__leave_notify_event_cb) if GObject.signal_lookup('clicked', self._widget) != 0: self._click_hid = self._widget.connect('clicked', self.__click_event_cb) self._touch_hid = self._widget.connect('touch-event', self.__touch_event_cb) self._release_hid = \ self._widget.connect('button-release-event', self.__button_release_event_cb) self._draw_hid = self._widget.connect_after('draw', self.__drawing_cb) self._long_pressed_hid = self._long_pressed_controller.connect( 'pressed', self.__long_pressed_event_cb, self._widget) self._long_pressed_controller.attach( self._widget, SugarGestures.EventControllerFlags.NONE) self.attach(parent)
def __init__(self, shell): # make sure the replaygain elements are available missing = [] required = ("rgvolume", "rglimiter") for e in required: if Gst.ElementFactory.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, parent, englabel=None, userdict={}, timeout=10): """ The PTK engine class for embedding in gtk3 (pyGObject) 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! GObject.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, obj, signal): '''Waits for a signal to be emitted on a specific GObject instance or class. :param obj: object monitor for the signal :type obj: GObject.GObject :param signal: signal name :type signal: str ''' WaitCondition.__init__(self) if isinstance(obj, type): if not issubclass(obj, GObject.GObject): raise TypeError("obj must be a GObject instance or class") self.object = None self.class_ = obj else: if not isinstance(obj, GObject.GObject): raise TypeError("obj must be a GObject instance or class") self.object = obj self.class_ = None if not GObject.signal_lookup(signal, obj): raise ValueError("gobject %r does not have a signal called %r" % (obj, signal)) self.signal = signal self._callback = None self._id = None self._destroy_id = None self.signal_args = None
def __init__(self, **args): self._enable_fullscreen_mode = True GObject.GObject.__init__(self, **args) self.set_decorated(False) self.maximize() self.connect("realize", self.__window_realize_cb) self.connect("key-press-event", self.__key_press_cb) # OSK support: canvas auto panning based on input focus if ( GObject.signal_lookup("request-clear-area", Window) != 0 and GObject.signal_lookup("unset-clear-area", Window) != 0 ): self.connect("size-allocate", self.__size_allocate_cb) self.connect("request-clear-area", self.__request_clear_area_cb) self.connect("unset-clear-area", self.__unset_clear_area_cb) self._clear_area_dy = 0 self._toolbar_box = None self._alerts = [] self._canvas = None self.tray = None self.__vbox = Gtk.VBox() self.__hbox = Gtk.HBox() self.__vbox.pack_start(self.__hbox, True, True, 0) self.__hbox.show() self.add_events( Gdk.EventMask.POINTER_MOTION_HINT_MASK | Gdk.EventMask.POINTER_MOTION_MASK | Gdk.EventMask.BUTTON_RELEASE_MASK | Gdk.EventMask.TOUCH_MASK ) self.connect("motion-notify-event", self.__motion_notify_cb) self.connect("button-release-event", self.__button_press_event_cb) self.add(self.__vbox) self.__vbox.show() self._is_fullscreen = False self._unfullscreen_button = UnfullscreenButton() self._unfullscreen_button.set_transient_for(self) self._unfullscreen_button.connect_button_clicked(self.__unfullscreen_button_clicked) self._unfullscreen_button_timeout_id = None
def __init__(self, **args): self._enable_fullscreen_mode = True GObject.GObject.__init__(self, **args) self.set_decorated(False) self.maximize() self.connect('realize', self.__window_realize_cb) self.connect_after('key-press-event', self.__key_press_cb) # OSK support: canvas auto panning based on input focus if GObject.signal_lookup('request-clear-area', Window) != 0 and \ GObject.signal_lookup('unset-clear-area', Window) != 0: self.connect('size-allocate', self.__size_allocate_cb) self.connect('request-clear-area', self.__request_clear_area_cb) self.connect('unset-clear-area', self.__unset_clear_area_cb) self._clear_area_dy = 0 self._toolbar_box = None self._alerts = [] self._canvas = None self.tray = None self.__vbox = Gtk.VBox() self.__hbox = Gtk.HBox() self.__vbox.pack_start(self.__hbox, True, True, 0) self.__hbox.show() self.add_events(Gdk.EventMask.POINTER_MOTION_HINT_MASK | Gdk.EventMask.POINTER_MOTION_MASK | Gdk.EventMask.BUTTON_RELEASE_MASK | Gdk.EventMask.TOUCH_MASK) self.connect('motion-notify-event', self.__motion_notify_cb) self.connect('button-release-event', self.__button_press_event_cb) self.add(self.__vbox) self.__vbox.show() self._is_fullscreen = False self._unfullscreen_button = UnfullscreenButton() self._unfullscreen_button.set_transient_for(self) self._unfullscreen_button.connect_button_clicked( self.__unfullscreen_button_clicked) self._unfullscreen_button_timeout_id = None
def arm(self, tasklet): '''See :class:`WaitCondition.arm`''' if self._id is None: self._callback = tasklet.wait_condition_fired if self.class_ is not None: self._id = GObject.add_emission_hook(self.class_, self.signal, self._signal_cb) else: self._id = self.object.connect(self.signal, self._signal_cb) if GObject.signal_lookup("destroy", self.object): self._destroy_id = self.object.connect("destroy", self._object_destroyed)
def notifiesConfigOption(cls, attrname): """Checks whether a signal is emitted when the setting is changed. Args: attrname (str): The attribute name used to access the setting. Returns: bool: True when the setting emits a signal when changed, False otherwise. """ signal_name = Notification.signalName(attrname) return bool(GObject.signal_lookup(signal_name, cls))
def onFocusIn( self, *args ): def dummy( *args ): pass signalId = GObject.signal_lookup( "focus-out-event", self.window ) while True: result = GObject.signal_handler_find( self.window, GObject.SignalMatchType.ID | GObject.SignalMatchType.UNBLOCKED, signalId, 0, None, dummy, dummy ) if result == 0: self.window.handler_unblock( self.loseFocusId ) else: break return False
def gobject_signal_blocked(gobject, signal_name): """ This is a context manager that can be used with the 'with' statement to execute a block of code while *signal_name* is blocked. :param gobject: The object to block the signal on. :type gobject: :py:class:`GObject.Object` :param str signal_name: The name of the signal to block. """ signal_id = GObject.signal_lookup(signal_name, gobject.__class__) handler_id = GObject.signal_handler_find(gobject, GObject.SignalMatchType.ID, signal_id, 0, None, 0, 0) GObject.signal_handler_block(gobject, handler_id) yield GObject.signal_handler_unblock(gobject, handler_id)
def __init__( self, window, notebook_parent, workspaces_enabled, terminal_spawned_cb, page_deleted_cb ): GObject.Object.__init__(self) if not GObject.signal_lookup('notebook-created', self): GObject.signal_new( 'notebook-created', self, GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE, (GObject.TYPE_PYOBJECT, GObject.TYPE_INT) ) self.current_notebook = 0 self.notebooks = {} self.window = window self.notebook_parent = notebook_parent self.terminal_spawned_cb = terminal_spawned_cb self.page_deleted_cb = page_deleted_cb if workspaces_enabled and gdk_is_x11_display(Gdk.Display.get_default()): # NOTE: Wnck didn't support non-X11 display backend, so we need to check if the display # is X11 or not, if not, it will not able to enable workspace-specific-tab-sets # # TODO: Is there anyway to support this in non-X11 display backend? self.screen = Wnck.Screen.get_default() self.screen.connect("active-workspace-changed", self.__workspace_changed_cb)
def do_activate(self): self.staticon = Gtk.StatusIcon () # FIXME: Support a scalable image! self.read_pix = Liferea.icon_create_from_file ("available.png") self.unread_pix = Liferea.icon_create_from_file ("unread.png") self.staticon.set_from_pixbuf(Liferea.icon_create_from_file("unread.png")) self.staticon.connect("activate", self.trayicon_click) self.staticon.connect("popup_menu", self.trayicon_popup) self.staticon.connect("size-changed", self.trayicon_size_changed) self.staticon.set_visible(True) self.menu = Gtk.Menu() menuitem_toggle = Gtk.MenuItem("Show / Hide") menuitem_quit = Gtk.MenuItem("Quit") menuitem_toggle.connect("activate", self.trayicon_toggle) menuitem_quit.connect("activate", self.trayicon_quit) self.menu.append(menuitem_toggle) self.menu.append(menuitem_quit) self.menu.show_all() self.window = self.shell.get_window() self.delete_signal_id = GObject.signal_lookup("delete_event", Gtk.Window) GObject.signal_handlers_block_matched (self.window, GObject.SignalMatchType.ID | GObject.SignalMatchType.DATA, self.delete_signal_id, 0, None, None, None) self.window.connect("delete_event", self.trayicon_minimize_on_close) self.window.connect("window-state-event", self.window_state_event_cb) # show the window if it is hidden when starting liferea self.window.deiconify() self.window.show() feedlist = self.shell.props.feed_list self.feedlist_new_items_cb(feedlist) sigid = feedlist.connect("new-items", self.feedlist_new_items_cb) self.feedlist_new_items_cb_id = sigid self.feedlist = feedlist
def __init__(self, *args, **kwargs): Gtk.Notebook.__init__(self, *args, **kwargs) self.last_terminal_focused = None self.set_name("notebook-teminals") self.set_tab_pos(Gtk.PositionType.BOTTOM) self.set_property("show-tabs", True) self.set_property("enable-popup", False) self.set_property("scrollable", True) self.set_property("show-border", False) self.set_property("visible", True) self.set_property("has-focus", True) self.set_property("can-focus", True) self.set_property("is-focus", True) self.set_property("expand", True) if GObject.signal_lookup('terminal-spawned', TerminalNotebook) == 0: GObject.signal_new( 'terminal-spawned', TerminalNotebook, GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE, (GObject.TYPE_PYOBJECT, GObject.TYPE_INT) ) GObject.signal_new( 'page-deleted', TerminalNotebook, GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE, () ) self.scroll_callback = NotebookScrollCallback(self) self.add_events(Gdk.EventMask.SCROLL_MASK) self.connect('scroll-event', self.scroll_callback.on_scroll) self.notebook_on_button_press_id = self.connect( "button-press-event", self.on_button_press, None ) self.new_page_button = Gtk.Button( image=Gtk.Image.new_from_icon_name("tab-new", Gtk.IconSize.MENU), visible=True ) self.new_page_button.connect("clicked", self.on_new_tab) self.set_action_widget(self.new_page_button, Gtk.PackType.END)
def disconnect_signal(source, signal): signal_id = GObject.signal_lookup(signal, source.__class__) handler_id = GObject.signal_handler_find(source, GObject.SignalMatchType.ID, signal_id, 0, None, 0, 0) source.disconnect(handler_id)
def test_signal_lookup_with_invalid_type(self): with self.assertRaisesRegex(TypeError, 'type must be instantiable or an interface.*'): GObject.signal_lookup('NOT_A_SIGNAL_NAME', GObject.TYPE_INVALID)
def notifiesConfigOption(cls, attrname): signal_name = Notification.signalName(attrname) GObject.signal_lookup(signal_name, cls)
def test_signal_lookup_with_invalid_type(self): with self.assertRaisesRegex( TypeError, 'type must be instantiable or an interface.*'): GObject.signal_lookup('NOT_A_SIGNAL_NAME', GObject.TYPE_INVALID)
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.SignalFlags.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" self.set_transient_for(frame.MainWindow) if modal: self.set_modal(True) box = gtk.VBox(spacing=10) box.set_border_width(10) self.vbox.pack_start(box, False, False, 0) box.show() if message: label = gtk.Label.new(message) box.pack_start(label, False, False, 0) label.set_line_wrap(True) label.show() self.entry = gtk.Entry() box.pack_start(self.entry, False, False, 0) 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.props.can_default = True self.action_area.pack_start(Cancelbutton, False, False, 0) Previousbutton = self.nicotine.CreateIconButton( gtk.STOCK_GO_BACK, "stock", self.previous, _("Previous")) Previousbutton.props.can_default = True self.action_area.pack_start(Previousbutton, False, False, 0) Nextbutton = self.nicotine.CreateIconButton(gtk.STOCK_GO_FORWARD, "stock", self.next, _("Next")) Nextbutton.props.can_default = True self.action_area.pack_start(Nextbutton, False, False, 0) Nextbutton.grab_default()
def notifiesConfigOption(cls, attrname): """ Whether a changed signal is emitted for the specified setting. """ signal_name = Notification.signalName(attrname) return bool(GObject.signal_lookup(signal_name, cls))
def install_signal(self, signal): if not GObject.signal_lookup(signal, self.__class__): GObject.signal_new(signal, self.__class__, GObject.SignalFlags.RUN_LAST, 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 gobject_signal_blocked(gobject, signal_name): signal_id = GObject.signal_lookup(signal_name, gobject.__class__) handler_id = GObject.signal_handler_find(gobject, GObject.SignalMatchType.ID, signal_id, 0, None, 0, 0) GObject.signal_handler_block(gobject, handler_id) yield GObject.signal_handler_unblock(gobject, handler_id)
def __init__(self, *args, **kwargs): Gtk.Notebook.__init__(self, *args, **kwargs) self.last_terminal_focused = None self.set_name("notebook-teminals") self.set_tab_pos(Gtk.PositionType.BOTTOM) self.set_property("show-tabs", True) self.set_property("enable-popup", False) self.set_property("scrollable", True) self.set_property("show-border", False) self.set_property("visible", True) self.set_property("has-focus", True) self.set_property("can-focus", True) self.set_property("is-focus", True) self.set_property("expand", True) if GObject.signal_lookup("terminal-spawned", TerminalNotebook) == 0: GObject.signal_new( "terminal-spawned", TerminalNotebook, GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE, (GObject.TYPE_PYOBJECT, GObject.TYPE_INT), ) GObject.signal_new( "page-deleted", TerminalNotebook, GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE, (), ) self.scroll_callback = NotebookScrollCallback(self) self.add_events(Gdk.EventMask.SCROLL_MASK) self.connect("scroll-event", self.scroll_callback.on_scroll) self.notebook_on_button_press_id = self.connect( "button-press-event", self.on_button_press, None) # Action box self.new_page_button = Gtk.Button( image=Gtk.Image.new_from_icon_name("tab-new", Gtk.IconSize.MENU), visible=True, ) self.new_page_button.connect("clicked", self.on_new_tab) self.hide_lose_focus_button = Gtk.Button(visible=True) self.hide_lose_focus_button.connect("clicked", self.on_hide_lose_focus) self.tab_selection_button = Gtk.Button( image=Gtk.Image.new_from_icon_name("pan-down-symbolic", Gtk.IconSize.MENU), visible=True, ) self.popover = Gtk.Popover() self.popover_window = None self.tab_selection_button.connect("clicked", self.on_tab_selection) self.action_box = Gtk.Box(visible=True) self.action_box.pack_start(self.new_page_button, 0, 0, 0) self.action_box.pack_end(self.tab_selection_button, 0, 0, 0) self.set_action_widget(self.action_box, Gtk.PackType.END) self.set_action_widget(self.hide_lose_focus_button, Gtk.PackType.START)