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 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, 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 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)
