def add_new_signal(self, name, *args): parameters = () for element in args: parameters = parameters + (GObject.TYPE_PYOBJECT,) if not self.is_signal(name): GObject.signal_new(name, self, GObject.SignalFlags.RUN_LAST, None, parameters)
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.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 __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 initialize(self): # Install "KB Updated" signal GObject.signal_new('kb-updated', KB4Basico, GObject.SignalFlags.RUN_LAST, None, ()) # Get KB4IT version self.log.debug("Basico is using %s" % KB4IT().get_version()) # Clean KB4IT temporary folder shutil.rmtree(LPATH['TMP']) os.makedirs(LPATH['TMP']) self.log.debug("KB4IT temporary directory recreated") # Check settings / Initialize source_path = self.get_config_value('source_dir') if source_path is None: self.set_config_value('source_dir', LPATH['DOC_SOURCE']) target_path = self.get_config_value('target_dir') if target_path is None: self.set_config_value('target_dir', LPATH['DOC_TARGET']) force = self.get_config_value('force') if force is None: self.set_config_value('force', False) # Start listening to requests self.queue = queue.Queue() self.th = threading.Thread(name='update', target=self.update_kb) self.th.setDaemon(True) self.th.start() self.log.debug("KB Basico Manager started")
def __init__(self, application): self.layout_path = "" with open("/usr/local/lib/meteo/var.cfg", 'r') as f: self.layout_path = f.read().split('\n')[2].replace(" ", "") print(self.layout_path) self.last = 0 self.application = application self.builder = Gtk.Builder() self.builder.add_from_file(self.layout_path + "main.glade") self.main_window = self.builder.get_object("main_window") self.logo = self.builder.get_object("logo") self.img_path = "" with open('/usr/local/lib/meteo/var.cfg', 'r') as f: self.img_path = f.read().split('\n')[3].replace(" ", "") self.logo.set_from_file(self.img_path + "logov2.png") self.main_window.set_default_icon_from_file(self.img_path + "main_logo.png") self.year_layout = self.builder.get_object("year_layout") self.year_label = self.builder.get_object("year_label") self.menu1 = self.builder.get_object("menubar1") self.menu2 = self.builder.get_object("menubar2") self.year_layout.set_visible(True) self.builder.connect_signals(self) self.year_layout.set_visible(False) GObject.signal_new('on_reponse', self.main_window, GObject.SIGNAL_RUN_LAST, GObject.TYPE_PYOBJECT, (GObject.TYPE_PYOBJECT, )) self.main_window.connect('on_reponse', self.on_reponse) #GObject.signal_new('on_month_window_destroy', self.main_window, GObject.SIGNAL_RUN_LAST, GObject.TYPE_PYOBJECT, (GObject.TYPE_PYOBJECT,)) #self.main_window.connect("on_month_window_destroy", self.on_month_window_destroy) self.main_window.set_application(self.application) self.main_window.set_title('Météo') self.main_window.maximize() self.main_window.show()
def __init__(self,parent_window): Gtk.Button.__init__(self) self.autologin=False self.username="" self.timed=False self.time=30 self.box=Gtk.HBox(False,0) self.add(self.box) self.label_state=Gtk.Label(_("Disabled")) self.label_state.set_no_show_all(True) self.label_state.show() self.box.pack_start(self.label_state,True,True,2) self.label_user=Gtk.Label("USER") self.label_user.set_no_show_all(True) self.box.pack_start(self.label_user,False,False,2) self.label_time=Gtk.Label("TIME") self.label_time.set_no_show_all(True) self.box.pack_end(self.label_time,False,False,2) self.Separator = Gtk.Separator.new(Gtk.Orientation.VERTICAL) self.Separator.set_no_show_all(True) self.box.pack_end(self.Separator,False,False,2) self.connect("clicked",self._clicked) self.window = AutoLoginWindow(parent_window) self.window.connect("changed",self._changed) GObject.signal_new("changed", AutologinButton, GObject.SIGNAL_RUN_FIRST,GObject.TYPE_NONE, ())
def __init__(self, parent_window): Gtk.Button.__init__(self) self.autologin = False self.username = "" self.timed = False self.time = 30 self.box = Gtk.HBox(False, 0) self.add(self.box) self.label_state = Gtk.Label(_("Disabled")) self.label_state.set_no_show_all(True) self.label_state.show() self.box.pack_start(self.label_state, True, True, 2) self.label_user = Gtk.Label("USER") self.label_user.set_no_show_all(True) self.box.pack_start(self.label_user, False, False, 2) self.label_time = Gtk.Label("TIME") self.label_time.set_no_show_all(True) self.box.pack_end(self.label_time, False, False, 2) self.Separator = Gtk.Separator.new(Gtk.Orientation.VERTICAL) self.Separator.set_no_show_all(True) self.box.pack_end(self.Separator, False, False, 2) self.connect("clicked", self._clicked) self.window = AutoLoginWindow(parent_window) self.window.connect("changed", self._changed) GObject.signal_new("changed", AutologinButton, GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, ())
def __init__(self, lotto=None, tipps=None, file=None): self.file = file self.config = ConfigParser() self.config.read(os.path.expanduser("~/.local/share/lotto/preferences.ini")) if tipps == None: tipps = self.config.getint("tipps", "tipps") if lotto == None: self.lotto = Lotto([Tipp() for i in range(tipps)]) # @UnusedVariable else: self.lotto = lotto Gtk.Notebook.__init__(self) self.set_scrollable(True) GObject.type_register(LottoWidget) GObject.signal_new("reaload",LottoWidget,GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, []) self.tippwidgets = [] for i in range(self.lotto.get_n_tipps()): self.tippwidgets.append(TippWidget(self.lotto.get_nth_tipp(i))) self.append_page(child=self.tippwidgets[i],tab_label=Gtk.Label(label="tipp %s"%(i+1))) self.set_buttons()
def add_new_signal(self, name, *args): parameters = () for element in args: parameters = parameters + (GObject.TYPE_PYOBJECT,) if not self.is_signal(name): GObject.signal_new(name, self, GObject.SignalFlags.RUN_LAST, None, parameters)
def __init__(self, guake, *args, **kwargs): Gtk.Notebook.__init__(self, *args, **kwargs) self.guake = guake 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) GObject.signal_new('terminal-spawned', self, GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE, (GObject.TYPE_PYOBJECT, GObject.TYPE_INT)) GObject.signal_new('page-deleted', self, 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)
def __init__(self, lotto=None, tipps=None, file=None): self.file = file self.config = ConfigParser() self.config.read( os.path.expanduser("~/.local/share/lotto/preferences.ini")) if tipps == None: tipps = self.config.getint("tipps", "tipps") if lotto == None: self.lotto = Lotto([Tipp() for i in range(tipps)]) # @UnusedVariable else: self.lotto = lotto Gtk.Notebook.__init__(self) self.set_scrollable(True) GObject.type_register(LottoWidget) GObject.signal_new("reaload", LottoWidget, GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, []) self.tippwidgets = [] for i in range(self.lotto.get_n_tipps()): self.tippwidgets.append(TippWidget(self.lotto.get_nth_tipp(i))) self.append_page(child=self.tippwidgets[i], tab_label=Gtk.Label(label="tipp %s" % (i + 1))) self.set_buttons()
def __init__(self): super(BookmarkUtils, self).__init__() GObject.signal_new("bookmark_clicked", BookmarkUtils, GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE, (object,)) self.menu1 = Gtk.Menu() self.menu2 = Gtk.Menu() self.menubar = None
def __init__(self): super().__init__() self._icon_contexts = [] self._icon_size = 32 self._filter_term = "" self._use_regex = False self._selected_icon = None # Register a custom icon_selected signal for once dialog closes. GObject.type_register(IconChooserButton) GObject.signal_new("icon-selected", IconChooserButton, GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, [GObject.TYPE_STRING]) # Widgets go here self._icon = Gtk.Image.new_from_icon_name("gtk-search", Gtk.IconSize.MENU) self._icon.set_margin_left(2) open_icon = Gtk.Image.new_from_icon_name("document-open-symbolic", Gtk.IconSize.MENU) self._label = Gtk.Label("(Choose An Icon)") self._label.set_hexpand(True) self._label.set_halign(Gtk.Align.START) self._label.set_ellipsize(Pango.EllipsizeMode.END) box = Gtk.Box() box.set_spacing(4) box.pack_start(self._icon, False, False, 0) box.pack_start(self._label, False, True, 0) box.pack_start(open_icon, False, False, 2) self.add(box) self.connect("clicked", self._show_dialog)
def __init__(self): super(UPnPDeviceManager, self).__init__() GObject.threads_init() GObject.signal_new("device-available", UPnPDeviceManager, GObject.SIGNAL_RUN_LAST, GObject.TYPE_BOOLEAN, (GObject.TYPE_PYOBJECT,)) GObject.signal_new("device-unavailable", UPnPDeviceManager, GObject.SIGNAL_RUN_LAST, GObject.TYPE_BOOLEAN, (GObject.TYPE_PYOBJECT,)) atexit.register(self.cleanup_files) self.contexts = [] self.cps = [] self.devices = [] self.sources = [] self.renderers = [] self.device_services = {} self.introspections = {} self.created_files = [] # Get a default maincontext self.main_ctx = GLib.main_context_default() # Use the built in GUPnP Network Manager to listen on # all interfaces self.ctx_mgr = GUPnP.ContextManager.new(self.main_ctx, 0) self.ctx_mgr.connect("context_available", self.new_ctx) self.new_ctx(self.ctx_mgr, GUPnP.Context(interface="eth0"))
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 addConfigOption( cls, attrname, type_=None, section=None, key=None, environment=None, default=None, notify=False, ): """Adds a configuration option. This function should be called during module initialization, before the config file is actually read. By default, only options registered beforehand will be loaded. If you want to add configuration options after initialization, use the `readSettingSectionFromFile` method to force reading later on. Args: attrname (str): The attribute of this class for accessing the option. type_ (Optional[type]): The type of the attribute. Unnecessary if a `default` value is specified. section (Optional[str]): The section of the config file under which this option is saved. This section must have been added with addConfigSection(). Not necessary if `key` is not given. key (Optional[str]): The key under which this option is to be saved. By default the option will not be saved. notify (Optional[bool]): Whether this attribute should emit signals when modified. By default signals are not emitted. """ if section and section not in cls.options: raise ConfigError("You must add the section `%s` first" % section) if key and not section: raise ConfigError("You must specify a section for key `%s`" % key) if section and key in cls.options[section]: raise ConfigError("Key `%s` is already in use" % key) if hasattr(cls, attrname): raise ConfigError("Attribute `%s` is already in use" % attrname) if environment and environment in cls.environment: raise ConfigError("Env var `%s` is already in use" % environment) if not type_ and default is None: raise ConfigError("Attribute `%s` must have a type or a default" % attrname) if not type_: type_ = type(default) if notify: notification = Notification(attrname) setattr(cls, attrname, notification) setattr(cls, "_" + attrname, default) if notification.signame not in GObject.signal_list_names(cls): GObject.signal_new(notification.signame, cls, GObject.SignalFlags.RUN_LAST, None, ()) else: setattr(cls, attrname, default) if section and key: cls.options[section][attrname] = type_, key, environment cls.environment.add(environment) cls.defaults[attrname] = default
def addConfigOption(cls, attrname, type_=None, section=None, key=None, environment=None, default=None, notify=False,): """ Add a configuration option. This function should be called during module initialization, before the config file is actually read. By default, only options registered beforehand will be loaded. See mainwindow.py and medialibrary.py for examples of usage. If you want to add configuration options after initialization, use the readSettingSectionFromFile method to force reading later on. See tabsmanager.py for an example of such a scenario. @param attrname: the attribute of this class which represents the option @type attrname: C{str} @param type_: type of the attribute. Unnecessary if default is given. @type type_: a builtin or class @param section: The section of the config file under which this option is saved. This section must have been added with addConfigSection(). Not necessary if key is not given. @param key: the key under which this option is to be saved. Can be none if this option should not be saved. @type key: C{str} @param notify: whether or not this attribute should emit notification signals when modified (default is False). @type notify: C{boolean} """ if section and section not in cls.options: raise ConfigError("You must add the section \"%s\" first." % section) if key and not section: raise ConfigError("You must specify a section for key \"%s\"" % key) if section and key in cls.options[section]: raise ConfigError("Option \"%s\" is already in use.") if hasattr(cls, attrname): raise ConfigError("Settings attribute \"%s\" is already in use.") if environment and environment in cls.environment: raise ConfigError("Settings environment varaible \"%s\" is" "already in use.") if not type_ and default is None: raise ConfigError("Settings attribute \"%s\" has must have a" " type or a default." % attrname) if not type_: type_ = type(default) if notify: notification = Notification(attrname) setattr(cls, attrname, notification) setattr(cls, "_" + attrname, default) GObject.signal_new(notification.signame, cls, GObject.SIGNAL_RUN_LAST, None, ()) else: setattr(cls, attrname, default) if section and key: cls.options[section][attrname] = type_, key, environment cls.environment.add(environment) cls.defaults[attrname] = default
def initialize(self): # Be aware about when the whole gui is started GObject.signal_new('gui-started', Callback, GObject.SignalFlags.RUN_LAST, None, ()) self.connect('gui-started', self.gui_started) self.th = threading.Thread(name='startup', target=self.on_startup) self.th.setDaemon(True) self.th.start()
def initialize(self): ''' Setup AppLogic Service ''' GObject.signal_new('sap-download-complete', SAP, GObject.SignalFlags.RUN_LAST, None, ()) self.__fix_collections() self.connect_signals()
def addConfigOption(cls, attrname, type_=None, section=None, key=None, environment=None, default=None, notify=False,): """Adds a configuration option. This function should be called during module initialization, before the config file is actually read. By default, only options registered beforehand will be loaded. If you want to add configuration options after initialization, use the `readSettingSectionFromFile` method to force reading later on. Args: attrname (str): The attribute of this class for accessing the option. type_ (Optional[type]): The type of the attribute. Unnecessary if a `default` value is specified. section (Optional[str]): The section of the config file under which this option is saved. This section must have been added with addConfigSection(). Not necessary if `key` is not given. key (Optional[str]): The key under which this option is to be saved. By default the option will not be saved. notify (Optional[bool]): Whether this attribute should emit signals when modified. By default signals are not emitted. """ if section and section not in cls.options: raise ConfigError( "You must add the section \"%s\" first." % section) if key and not section: raise ConfigError( "You must specify a section for key \"%s\"" % key) if section and key in cls.options[section]: raise ConfigError("Option \"%s\" is already in use.") if hasattr(cls, attrname): raise ConfigError("Settings attribute \"%s\" is already in use.") if environment and environment in cls.environment: raise ConfigError("Settings environment varaible \"%s\" is" "already in use.") if not type_ and default is None: raise ConfigError("Settings attribute \"%s\" has must have a" " type or a default." % attrname) if not type_: type_ = type(default) if notify: notification = Notification(attrname) setattr(cls, attrname, notification) setattr(cls, "_" + attrname, default) GObject.signal_new(notification.signame, cls, GObject.SIGNAL_RUN_LAST, None, ()) else: setattr(cls, attrname, default) if section and key: cls.options[section][attrname] = type_, key, environment cls.environment.add(environment) cls.defaults[attrname] = default
def __init__(self, *args, **kwargs): Gtk.ImageMenuItem.__init__(self, *args, **kwargs) GObject.signal_new( 'value-changed', self, GObject.SignalFlags.RUN_LAST, GObject.TYPE_PYOBJECT, (GObject.TYPE_PYOBJECT, ), ) self.attach_slider()
def registerSignals(cls): GObject.type_register(cls) for name, args in cls.signals: GObject.signal_new( name, cls, GObject.SignalFlags.RUN_LAST, None, args, ) return cls
def __init__(self, name, *args, **kwargs): self.name = name if not self.__class__.signals_created: GObject.signal_new('value-changed', self, GObject.SignalFlags.RUN_LAST, GObject.TYPE_NONE, ()) GObject.signal_new('change-finished', self, GObject.SignalFlags.RUN_LAST, GObject.TYPE_NONE, ()) self.__class__.signals_created = True return super().__init__(*args, **kwargs)
def __init__(self, *args, **kwargs): Gtk.ImageMenuItem.__init__(self, *args, **kwargs) GObject.signal_new( 'value-changed', self, GObject.SIGNAL_RUN_LAST, GObject.TYPE_PYOBJECT, ( GObject.TYPE_PYOBJECT, ), ) self.attach_slider()
def _init_signals(self): GObject.signal_new('branch', self._window, GObject.SignalFlags.RUN_FIRST, None, (GObject.TYPE_PYOBJECT, )) GObject.signal_new('leaf', self._window, GObject.SignalFlags.RUN_FIRST, None, (GObject.TYPE_PYOBJECT, )) self._window.connect('key-press-event', self._on_key_press) self._window.connect('branch', self._open_branch) self._window.connect('leaf', self._exec_leaf) self._window.connect('destroy', Gtk.main_quit)
def __init__(self): self.window = Gtk.Window() GObject.signal_new('custom-signal', self.window, GObject.SIGNAL_RUN_LAST, GObject.TYPE_PYOBJECT, (GObject.TYPE_PYOBJECT,)) self.window.connect('custom-signal', self.custom_signal1_method) self.window.emit('custom-signal', 'hello from signal') self.window.connect('delete_event', Gtk.main_quit) self.window.connect('destroy', lambda quit: Gtk.main_quit()) self.window.show()
def __init__(self): self.window = Gtk.Window() self.window.set_title(_('Records of events')) self.window.set_position(Gtk.WindowPosition.CENTER) box = Gtk.Box() self.window.add(box) self.notebook = Gtk.Notebook() self.notebook.set_scrollable(True) self.window.set_focus(self.notebook) # List events self.list_events = PageListEventsView() self.notebook.append_page(self.list_events, Gtk.Label(_('List events'))) box.pack_start(self.notebook, True, True, 0) # Calendar self.calendar = PageCalendarView() self.notebook.append_page(self.calendar, Gtk.Label(_('Calendar'))) # Monthly summary self.monthly_summary = PageMonthlySummaryView() self.notebook.append_page(self.monthly_summary, Gtk.Label(_('Monthly summary'))) # New event self.new_event = NewEventView() box.pack_start(self.new_event, True, True, 0) # Signals GObject.signal_new('try-insert', GObject.Object, GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, (GObject.TYPE_INT,)) GObject.signal_new('remove-event', GObject.Object, GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, (GObject.TYPE_INT,)) GObject.signal_new('update-event', GObject.Object, GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, (GObject.TYPE_INT,)) GObject.signal_new('reload-list', GObject.Object, GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, ()) self.window.show_all()
def __init__(self, window, notebook_parent, workspaces_enabled, terminal_spawned_cb, page_deleted_cb): GObject.Object.__init__(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 self.screen = Wnck.Screen.get_default() if workspaces_enabled: self.screen.connect("active-workspace-changed", self.workspace_changed)
def registerSignals(cls): GObject.type_register(cls) for name, args in cls.signals: try: GObject.signal_new( name, cls, GObject.SignalFlags.RUN_LAST, None, args, ) except Exception as e: log.error( "Failed to create signal %s " % name + "for class %s in %s" % (cls.__name__, cls.__module__), ) return cls
class MainWindow(Gtk.Window): GObject.signal_new("interfaceListMsg", GObject.GObject, GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, ()) def __init__(self, setting): Gtk.Window.__init__(self, title='Create AP') self.setting = setting self._ = self.setting['language'].gettext self.initWindow() self.setting['runningAp'].registerPage(self.updateStatusPage) self.set_default_icon_from_file(self.setting['iconPath']) def show(self, page=None): self.show_all() self.updateStatusPage() if page != None: Gtk.Notebook.do_change_current_page( self.notebook, page - self.notebook.get_current_page()) def initWindow(self): self.connect("destroy", self.on_destroy) self.set_border_width(3) self.notebook = Gtk.Notebook() self.add(self.notebook) self.statusPage = StatusPage(self, self.setting) self.notebook.append_page(self.statusPage, Gtk.Label(self._('Running AP'))) self.editPage = EditPage(self, self.setting) self.notebook.append_page(self.editPage, Gtk.Label(self._('New AP'))) self.createPage = CreatePage(self, self.setting) self.notebook.append_page(self.createPage, Gtk.Label(self._('Create AP'))) self.settingPage = SettingPage(self, self.setting) self.notebook.append_page(self.settingPage, Gtk.Label(self._('Setting'))) self.aboutPage = AboutPage(self, self.setting) self.notebook.append_page(self.aboutPage, Gtk.Label(self._('About'))) def updateStatusPage(self, signal=None): self.statusPage.updateStatusPage() def on_destroy(self, widget): self.setting['runningAp'].unregisterPage() self.setting['createEditAp'] = None self.destroy() def changeCurrentPage(self, page): Gtk.Notebook.do_change_current_page(self.notebook, page) def showFirstPage(self): Gtk.Notebook.do_change_current_page(self.notebook, -self.notebook.get_current_page())
def register_signals(self, widget): """Register gobject signals in a way that avoids multiple inheritance""" existing = GObject.signal_list_names(widget) for signal in self.signals: if signal['name'] in existing: dbg('Container:: skipping signal %s for %s, already exists' % (signal['name'], widget)) else: dbg('Container:: registering signal for %s on %s' % (signal['name'], widget)) try: GObject.signal_new(signal['name'], widget, signal['flags'], signal['return_type'], signal['param_types']) except RuntimeError: err('Container:: registering signal for %s on %s failed' % (signal['name'], widget))
def __init__( self, window, notebook_parent, workspaces_enabled, terminal_spawned_cb, page_deleted_cb ): GObject.Object.__init__(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 self.screen = Wnck.Screen.get_default() if workspaces_enabled: self.screen.connect("active-workspace-changed", self.workspace_changed)
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) GObject.signal_new("print-this", GObject.TYPE_OBJECT, GObject.SIGNAL_RUN_LAST, GObject.TYPE_BOOLEAN, [GObject.TYPE_STRING]) self.button = Gtk.Button.new_with_label("Emit signals") self.button.connect("clicked", self.emit_signals) self.frame = Gtk.Frame.new("Some frame") self.frame.add(self.button) self.add(self.frame) self.connect("print-this", self.got_it) self.show_all() Gtk.main()
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) # Add custom signals to detect new word selected # GObject.signal_new(signal_name, type, flags, return_type, param_types) # param_types is a list example [GObject.TYPE_PYOBJECT, GObject.TYPE_STRING] GObject.signal_new("on-new-word-selected", Gtk.ApplicationWindow, GObject.SIGNAL_RUN_LAST, GObject.TYPE_BOOLEAN, [GObject.TYPE_PYOBJECT]) self.connect("on-new-word-selected", self.on_new_word_selected) self.app = self.props.application self.lookup_word = self.app.lookup_word self.updater_view = UpdaterView() self.noword_view = NoWordView() self.word_view = WordView() self.settings_view = SettingsView(app=self.app) self.stack = Gtk.Stack() self.stack.props.transition_type = Gtk.StackTransitionType.CROSSFADE self.stack.add_named(self.word_view, self.word_view.get_name()) self.stack.add_named(self.settings_view, self.settings_view.get_name()) self.stack.add_named(self.noword_view, self.noword_view.get_name()) self.stack.add_named(self.updater_view, self.updater_view.get_name()) self.headerbar = self.generate_headerbar() # self.props.resizable = False #set this and window will expand and retract based on child self.title = "QuickWord" self.set_keep_above(True) self.get_style_context().add_class("rounded") self.set_size_request( -1, -1) #set width to -1 to expand and retract based on content self.props.window_position = Gtk.WindowPosition.MOUSE self.set_titlebar(self.headerbar) self.add(self.stack) self.connect("key-press-event", self.on_key_press) self.show_all() self.on_start_settings() # hide all other views to enable window to expand and retract based on content self.noword_view.hide() self.settings_view.hide() self.updater_view.hide()
def __init__(self, window_parent): super().__init__() GObject.signal_new('colorlist-changed', self, GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE, ()) self.__window_parent = window_parent self.__color_selector = Gtk.ColorSelectionDialog( "Select a color", window_parent) self.__current_colortoolitem = None add_button = Gtk.ToolButton.new_from_stock(Gtk.STOCK_ADD) add_button.connect("clicked", self.__on_add_button_clicked) add_button.set_label(None) self.insert(add_button, 0) self.reset_colors()
def register_signals(self, widget): """Register gobject signals in a way that avoids multiple inheritance""" existing = GObject.signal_list_names(widget) for signal in self.signals: if signal['name'] in existing: dbg('Container:: skipping signal %s for %s, already exists' % ( signal['name'], widget)) else: dbg('Container:: registering signal for %s on %s' % (signal['name'], widget)) try: GObject.signal_new(signal['name'], widget, signal['flags'], signal['return_type'], signal['param_types']) except RuntimeError: err('Container:: registering signal for %s on %s failed' % (signal['name'], widget))
def __init__(self, **kwargs): self.ble_dfu = None self.ota_file = None self.manager = None self.current_mac = None self.asset = None self.asset_download_url = None self.tag = None self.conf = config() super().__init__(**kwargs) GObject.threads_init() self.full_list = get_quick_deploy_list() GObject.signal_new( "flash-signal", self, GObject.SIGNAL_RUN_LAST, GObject.TYPE_PYOBJECT, (GObject.TYPE_PYOBJECT,), )
def __init__(self, task_queue, pictures): super().__init__(type=Gtk.WindowType.TOPLEVEL) self.task_queue = task_queue self.pictures = pictures self.connect("delete-event", Gtk.main_quit) self.connect("key-press-event", self.on_keypress) self.overlay = Gtk.Overlay() self.image = Gtk.Image() self.overlay.add(self.image) self.star_label = Gtk.Label(self.NOT_FAVOURITE_CHAR) self.star_label.set_name('star') self.filename_label = Gtk.Label("FILENAME") self.filename_label.set_name('filename') self.hbox = Gtk.HBox() self.hbox.add(self.star_label) self.hbox.add(self.filename_label) self.hbox.props.valign = Gtk.Align.START self.hbox.props.halign = Gtk.Align.START self.overlay.add_overlay(self.hbox) self.loading_label = Gtk.Label(self.LOADING_TEXT) self.loading_label.set_name('loading') self.loading_label.props.valign = Gtk.Align.CENTER self.loading_label.props.halign = Gtk.Align.CENTER self.overlay.add_overlay(self.loading_label) self.add(self.overlay) self.show_all() self.fullscreen() GObject.signal_new('picture-loaded', self, GObject.SignalFlags.RUN_LAST, GObject.TYPE_PYOBJECT, (GObject.TYPE_PYOBJECT, )) self.connect('picture-loaded', self.on_picture_loaded)
def set_up(): GObject.type_register(CommandText) GObject.type_register(IconSelector) GObject.signal_new("text-changed", CommandText, GObject.SignalFlags.RUN_FIRST, None, (GObject.TYPE_STRING, )) GObject.signal_new("mode-changed", CommandText, GObject.SignalFlags.RUN_FIRST, None, (GObject.TYPE_STRING, )) GObject.signal_new("image-changed", IconSelector, GObject.SignalFlags.RUN_FIRST, None, (GObject.TYPE_STRING, )) GObject.signal_new("text-changed", IconSelector, GObject.SignalFlags.RUN_FIRST, None, (GObject.TYPE_STRING, )) GObject.signal_new("mode-changed", IconSelector, GObject.SignalFlags.RUN_FIRST, None, (GObject.TYPE_STRING, ))
def __init__(self, keyboard_widget, icp): self._last_ignore_configure_time = None self._last_configures = [] self._was_visible = False Gtk.Window.__init__(self, urgency_hint = False, width_request=self.MINIMUM_SIZE, height_request=self.MINIMUM_SIZE) KbdWindowBase.__init__(self, keyboard_widget, icp) WindowRectTracker.__init__(self) GObject.signal_new("quit-onboard", KbdWindow, GObject.SIGNAL_RUN_LAST, GObject.TYPE_BOOLEAN, ()) self._auto_position_poll_timer = Timer() self.restore_window_rect(startup = True) self.connect("map", self._on_map_event) self.connect("unmap", self._on_unmap_event) self.connect("delete-event", self._on_delete_event) self.connect("configure-event", self._on_configure_event) # Connect_after seems broken in Quantal, the callback is never called. #self.connect_after("configure-event", self._on_configure_event_after) self._osk_util.connect_root_property_notify(["_NET_WORKAREA", "_NET_CURRENT_DESKTOP"], self._on_root_property_notify) once = CallOnce(100).enqueue # call at most once per 100ms rect_changed = lambda x: once(self._on_config_rect_changed) config.window.position_notify_add(rect_changed) config.window.size_notify_add(rect_changed) dock_size_changed = lambda x: once(self._on_config_dock_size_changed) config.window.dock_size_notify_add(dock_size_changed)
def __init__(self, keyboard_widget, icp): self._last_ignore_configure_time = None self._last_configures = [] self._was_visible = False Gtk.Window.__init__(self, urgency_hint=False, width_request=self.MINIMUM_SIZE, height_request=self.MINIMUM_SIZE) KbdWindowBase.__init__(self, keyboard_widget, icp) WindowRectTracker.__init__(self) GObject.signal_new("quit-onboard", KbdWindow, GObject.SIGNAL_RUN_LAST, GObject.TYPE_BOOLEAN, ()) self._auto_position_poll_timer = Timer() self.restore_window_rect(startup=True) self.connect("map", self._on_map_event) self.connect("unmap", self._on_unmap_event) self.connect("delete-event", self._on_delete_event) self.connect("configure-event", self._on_configure_event) # Connect_after seems broken in Quantal, the callback is never called. #self.connect_after("configure-event", self._on_configure_event_after) self._osk_util.connect_root_property_notify( ["_NET_WORKAREA", "_NET_CURRENT_DESKTOP"], self._on_root_property_notify) once = CallOnce(100).enqueue # call at most once per 100ms rect_changed = lambda x: once(self._on_config_rect_changed) config.window.position_notify_add(rect_changed) config.window.size_notify_add(rect_changed) dock_size_changed = lambda x: once(self._on_config_dock_size_changed) config.window.dock_size_notify_add(dock_size_changed)
def __init__(self): Gtk.Window.__init__(self, title="带背景的文本编辑器") GObject.signal_new("changed", BEditDocument, GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, ()) self.grid = Gtk.Grid() self.add(self.grid) #载入历史记录 self.load_config() self.set_default_size(self.sizeWidth, self.sizeHeight) self.create_notebook() self.create_menubar() self.create_toolbar() self.create_find() self.on_new() self.set_style() # 图标来自 http://www.iconlet.com/info/85512_gedit-icon_128x128 self.set_icon_from_file(sys.path[0]+"/icons/bedit.png")
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 __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 __init__ ( self, _dir="gui", start_type="input" ): self.dir = DIR GObject.type_register ( configitem.ConfigItem ) GObject.type_register ( configfile.ConfigFile ) GObject.signal_new ( "new_config", configitem.ConfigItem, GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, ( configitem.ConfigItem, ) ) GObject.signal_new ( "remove_item", configitem.ConfigItem, GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, ( configfile.ConfigFile, ) ) GObject.signal_new ( "remove_config", configfile.ConfigFile, GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, ( configfile.ConfigFile, ) ) self.project = project.Project ( _dir, start_type, main_handlers, self.dir ) self.project.load_config ( self.project.files, "parser.cfg" ) self.config = "parser.cfg"
def test_illegals(self): self.assertRaises(TypeError, lambda: GObject.signal_new('test', None, 0, None, (GObject.TYPE_LONG,)))
self.m_timeout = GObject.timeout_add(DELAY2, self.on_down_timeout) def down(self): self.m_value -= 1 self.g_entry.set_text(mpd.int_to_user_octave_notename(self.m_value)) self.emit('value-changed', self.m_value) def get_value(self): return self.m_value def set_value(self, val): self.m_value = val self.g_entry.set_text(mpd.int_to_user_octave_notename(val)) GObject.signal_new('value-changed', NotenameSpinButton, GObject.SignalFlags.RUN_FIRST, None, (GObject.TYPE_PYOBJECT,)) class NotenameRangeController(object): def __init__(self, spin_low, spin_high, lowest_value, highest_value): self.g_spin_low = spin_low self.g_spin_low.connect('value-changed', self.on_low_changed) self.g_spin_high = spin_high self.g_spin_high.connect('value-changed', self.on_high_changed) self.m_lowest_value = mpd.notename_to_int(lowest_value) self.m_highest_value = mpd.notename_to_int(highest_value) def on_low_changed(self, widget, v): if widget.get_value() > self.g_spin_high.get_value():
if self.is_an_error: break self.next_event.wait() self.next_event.clear() if self.is_an_error: break self.next_event.wait(delay_time / 1000.0) if self.is_an_error: break self.next_event.clear() self.emit('sequence_finished') @staticmethod def get_function_group(sbrick_configuration, group): for gp in sbrick_configuration["functions"]: if group == gp["group"]: return gp return None @staticmethod def get_function_in_group(group, function): for f in group["functions"]: if function == f["label"]: return f return None GObject.type_register(SBrickSequencePlayer) GObject.signal_new("sequence_finished", SBrickSequencePlayer, GObject.SignalFlags.RUN_LAST, GObject.TYPE_NONE, ())
from gi.repository import GObject from lib.stdoutwrapper import StdOutWrapper from lib.xferpool import Xfer GObject.signal_new('log-event', StdOutWrapper, GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE, (object,)) GObject.signal_new('xfer-event', Xfer, GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE, ()) GObject.signal_new('xfer-finished', Xfer, GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE, (object,int,))
self.iconstack.set_visible_child_name('active') else: self.iconstack.set_visible_child_name('inactive') self._state = value def on_icon_pressed(self, widget, data): parent = self.get_parent() for i in range(0, parent.childlength): if i == self.position: parent.get_child(i).state = SideBarButtonState.ON parent.get_child(i).emit("sidebar-button-pressed") else: parent.get_child(i).state = SideBarButtonState.OFF def set_image_from_file(self, iconpath): try: pixbuf = GdkPixbuf.Pixbuf.new_from_file(iconpath) icon = Gtk.Image.new_from_pixbuf(pixbuf) except GLib.GError: icon = Gtk.Image.new_from_stock(Gtk.STOCK_MISSING_IMAGE, 22) return icon class SideBarButtonState(object): ON, OFF = True, False GObject.type_register(SideBarButton) GObject.signal_new("sidebar-button-pressed", SideBarButton, GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, ()) GObject.type_register(SideBar) GObject.signal_new("window-shown", SideBar, GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, ()) GObject.signal_new("stack-changed", SideBar, GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, [GObject.TYPE_STRING])
#!/usr/bin/python from gi.repository import Gtk, Gdk, GdkPixbuf, GLib, Gio, GObject,Notify class ImageEventBox(Gtk.EventBox): def __init__(self): super(ImageEventBox,self).__init__() GObject.type_register(ImageEventBox) #GObject.signal_new('image-load-complete', ImageEventBox, GObject.SIGNAL_RUN_FIRST | GObject.SIGNAL_ACTION, # GObject.TYPE_NONE, (GObject.TYPE_STRING, )) GObject.signal_new('image-load-init', ImageEventBox, GObject.SIGNAL_RUN_FIRST | GObject.SIGNAL_ACTION, GObject.TYPE_NONE, (GObject.TYPE_STRING, GObject.TYPE_OBJECT,GObject.TYPE_STRING, ))
self.emit("color-added") def get_selected_color(self): """Return the selected state of a particular color""" if self.selected_col is None: return None else: return self.selected_col.color def set_selected_color(self, col): """Defines the selected state of a displayed color, enables clear button when a color is selected""" self.unselect_color() if self.has_color(col): self.buttons_lookup[col].set_selected(True) self.selected_col = self.buttons_lookup[col] self.clear_button.set_sensitive(True) def unselect_color(self): """Deselect all colors""" if self.selected_col is not None: self.selected_col.set_selected(False) self.selected_col = None self.clear_button.set_sensitive(False) GObject.type_register(SimpleColorSelector) GObject.signal_new("color-changed", SimpleColorSelector, GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, ()) GObject.signal_new("color-added", SimpleColorSelector, GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, ())
def __init__(self): super(AuthWebKitScrolledWindow, self).__init__() self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) url = self._get_auth_url() w = WebKit.WebView.new() w.set_vexpand(True) w.load_uri(url) w.connect("document-load-finished", self._get_document_cb) self.add(w) self.show_all() def _get_document_cb(self, w, e): url = w.get_property('uri') re_token = re.compile(self.RE_TOKEN) if url.startswith(self.LOGIN_URL): self.emit("login-started", None) elif re_token.search(url): self.emit("token-acquired", url) elif url.startswith(self.ERROR_URL): self.emit("error-occurred", None) for signal in ["login-started", "token-acquired", "error-occurred"]: GObject.signal_new(signal, AuthWebKitScrolledWindow, GObject.SignalFlags.RUN_LAST, None, (GObject.TYPE_PYOBJECT,))
# noinspection PyUnusedLocal def on_sbrick_channel_stop(self, sbrick, channel): self.current_sbrick_channels[channel].stopped() def show_channels(self): children = self.channelBox.get_children() for child in children: self.channelBox.remove(child) for channelNumber in range(4): channel_box = None sb = self.sbrick_configuration["channelConfiguration"][channelNumber] cc = sb["type"] if cc == 'motor': channel_box = SBrickMotorChannelBox(channelNumber, sb) elif cc == 'servo': channel_box = SBrickServoChannelBox(channelNumber, sb) self.channelBox.pack_start(channel_box, False, False, 0) self.current_sbrick_channels.append(channel_box) self.channelBox.show_all() GObject.type_register(SBrickBox) GObject.signal_new("sbrick_connected", SBrickBox, GObject.SignalFlags.RUN_LAST, GObject.TYPE_NONE, ()) GObject.signal_new("sbrick_disconnected", SBrickBox, GObject.SignalFlags.RUN_LAST, GObject.TYPE_NONE, ()) GObject.signal_new("show_message", SBrickBox, GObject.SignalFlags.RUN_LAST, GObject.TYPE_NONE, [GObject.TYPE_STRING, GObject.TYPE_STRING, GObject.TYPE_STRING])
self.pack_start(self.prayerlabel, True, True, 0) self.timelabel = Gtk.Label(label=prayertime, halign=Gtk.Align.END, margin_bottom=6, margin_top=6, margin_right=12, margin_left=12) self.timelabel.set_use_markup(True) if state == True: self.timelabel.set_markup("<span color=\"#55c1ec\">"+prayertime+"</span>") else: self.timelabel.set_label(prayertime) self.pack_end(self.timelabel, True, True, 0) @property def time(self): return self._time @time.setter def time(self, value): self._time = value @property def name(self): return self._name @name.setter def name(self, value): self._name = value GObject.type_register(Home) GObject.signal_new("prayers-updated", Home, GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, [GObject.TYPE_STRING])
spin.connect("show", lambda w: w.grab_focus()) label = Gtk.Label(label="Days") entry.pack_start(spin, False, False, True, 0) entry.pack_start(label, False, False, True, 0) return entry """The "span-changed" signal is emitted when a new span has been selected or entered. Callback signature: def callback(SpanSelector, span, [user_param, ...]) """ GObject.signal_new("span-changed", SpanSelector, GObject.SignalFlags.RUN_LAST, None, (GObject.TYPE_FLOAT,)) """The "custom-span-added" signal is emitted after a custom span has been added, but before it has been selected. Callback signature: def callback(SpanSelector, span, [user_param, ...]) """ GObject.signal_new("custom-span-added", SpanSelector, GObject.SignalFlags.RUN_LAST, None, (GObject.TYPE_FLOAT,))
if struct.has_field("taglist"): taglist = struct.get_value("taglist") title = taglist.get_string("title")[1] if not title: title = "" title = correct_encoding(title) text = title if taglist.get_string('artist')[0]: artist = taglist.get_string('artist')[1] artist = correct_encoding(artist) text = artist + " - " + text if not text: text = self.bean.path if self._is_remote() and taglist.get_string("audio-codec")[0]: text = text + " || " + taglist.get_string("audio-codec")[1] if self._is_remote() and taglist.get_uint('bitrate')[0]: text = text + " || " + str(taglist.get_uint('bitrate')[1] / 1000) + _("kbps") self.emit('bitrate-changed', taglist.get_uint('bitrate')[1]) self.notify_title(text) elif type == Gst.MessageType.EOS: self.error_counter = 0 logging.info("MESSAGE_EOS") self.notify_eos() GObject.signal_new("title-changed", GStreamerEngine, GObject.SIGNAL_RUN_LAST, None, (object, str,)) GObject.signal_new("bitrate-changed", GStreamerEngine, GObject.SIGNAL_RUN_LAST, None, (int,)) GObject.signal_new("eos-signal", GStreamerEngine, GObject.SIGNAL_RUN_LAST, None, ())
def new_signal(self, name, arg_types): GObject.signal_new(name, Editor, GObject.SIGNAL_RUN_FIRST, None, arg_types)