def rebind_key(keystring, is_bound): if is_bound: print("binding", keystring) keybinder.bind(keystring, relay_key, keystring) else: print("unbinding", keystring) keybinder.unbind(keystring)
def __init__(self): # =>public window props Gtk.Window.__init__(self, title="Kimia-Dict (V " + glob.VERSION + ")" # type_hint=Gdk.WindowTypeHint.TOOLBAR ) self.set_default_size(800, 500) self.set_icon_from_file("./assets/img/logo.png") self.set_position(Gtk.WindowPosition.CENTER) #=>connect to destory main window # self.connect("destroy", self.on_destroy) self.connect("delete_event", self.on_delete) #=>connect to key events of main window self.connect("key-press-event", self.on_key_press_event) # =>set toolbar MainBox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) MainToolbar = menu.ToolBar() MainBox.pack_start(MainToolbar, False, False, 0) # =>set search box MainSearch = search.SearchBox() MainBox.pack_start(MainSearch, False, False, 10) # =>set content sw = Gtk.ScrolledWindow() mcontent = search.content sw.add_with_viewport(mcontent) MainBox.pack_start(sw, True, True, 0) # =>add MainBox to main window self.add(MainBox) # =>init keybinder Keybinder.init() # =>handle global shortuct by 'shortcut_callback' Keybinder.bind(glob.KEYDISPLAY, self.show_shortcut_callback, "keystring %s (user data)" % glob.KEYDISPLAY) # =>show all widgets and window self.show_all()
def bootstrap(self): self._items = [] section = self.options.get('simple-section', self.SIMPLE_SECTION) default_type = self.options.get('simple-section-default', self.SIMPLE_SECTION_DEFAULT) if not self.klemmbrett.config.has_section(section): raise KeyError("No config section %s defined" % (section,)) for label, value in self.klemmbrett.config.items(section): target = default_type if self._TYPE_SEPERATOR in label: target, label = label.split(self._TYPE_SEPERATOR, 1) self._items.append((label, {target: value})) prefix = self.options.get('complex-section-prefix', self.COMPLEX_SECTION_PREFIX) for section in self.klemmbrett.config.sections(): if not section.startswith(prefix): continue options = dict(self.klemmbrett.config.items(section)) label = section[len(prefix):] self._items.append((label, options)) if "shortcut" in options: _keybinder.bind( options['shortcut'], _ft.partial(self.set, widget = None, text = label), )
def set_hotkey(self, accel_name): if self._current_accel_name: Keybinder.unbind(self._current_accel_name) self._current_accel_name = None Keybinder.bind(accel_name, self.on_hotkey_press) self._current_accel_name = accel_name
def bootstrap(self): """ Setup all destinations and shortcuts and start the rpc server """ self._destinations = self.get_destinations() # initialize standard stuff #_notify.init("Klemmbrett") self._current_suggestion = None # binding to accept the suggested text into the clipboard _keybinder.bind( self.options.get('accept-suggestion-shortcut', self.DEFAULT_ACCEPT_BINDING), self._accept_suggestion, ) _keybinder.bind( self.options.get('user-history-shortcut', self.DEFAULT_USERHISTORY_BINDING), self._show_histories, ) _plugins.PopupPlugin.bootstrap(self) self._start_server()
def _enable(eventname, exaile, eventdata): global initialized if not initialized: Keybinder.init() initialized = True for k in KEYS: Keybinder.bind(k, on_media_key, exaile)
def __init__(self, silent = False): super(KazamSuperIndicator, self).__init__() self.blink_icon = BLINK_STOP_ICON self.blink_state = False self.blink_mode = BLINK_SLOW self.recording = False self.silent = silent logger.debug("Indicatior silent: {0}".format(self.silent)) self.menu = Gtk.Menu() self.menuitem_settings = Gtk.MenuItem(_("Settings")) self.menuitem_settings.set_sensitive(True) self.menuitem_settings.connect("activate", self.on_menuitem_settings_activate) self.menuitem_separator1 = Gtk.SeparatorMenuItem() self.menuitem_start = Gtk.MenuItem(_("Start recording")) self.menuitem_start.set_sensitive(True) self.menuitem_start.connect("activate", self.on_menuitem_start_activate) self.menuitem_pause = Gtk.CheckMenuItem(_("Pause recording")) self.menuitem_pause.set_sensitive(False) self.menuitem_pause.connect("toggled", self.on_menuitem_pause_activate) self.menuitem_finish = Gtk.MenuItem(_("Finish recording")) self.menuitem_finish.set_sensitive(False) self.menuitem_finish.connect("activate", self.on_menuitem_finish_activate) self.menuitem_separator2 = Gtk.SeparatorMenuItem() self.menuitem_quit = Gtk.MenuItem(_("Quit")) self.menuitem_quit.connect("activate", self.on_menuitem_quit_activate) self.menu.append(self.menuitem_settings) self.menu.append(self.menuitem_separator1) self.menu.append(self.menuitem_start) self.menu.append(self.menuitem_pause) self.menu.append(self.menuitem_finish) self.menu.append(self.menuitem_separator2) self.menu.append(self.menuitem_quit) self.menu.show_all() # # Setup keybindings - Hardcore way # try: from gi.repository import Keybinder logger.debug("Trying to bind hotkeys.") Keybinder.init() Keybinder.bind("<Super><Ctrl>R", self.cb_hotkeys, "start-request") Keybinder.bind("<Super><Ctrl>F", self.cb_hotkeys, "stop-request") Keybinder.bind("<Super><Ctrl>P", self.cb_hotkeys, "pause-request") Keybinder.bind("<Super><Ctrl>W", self.cb_hotkeys, "show-request") Keybinder.bind("<Super><Ctrl>Q", self.cb_hotkeys, "quit-request") self.recording = False except ImportError: logger.info("Unable to import Keybinder, hotkeys not available.")
def run_keybinder(callback): Keybinder.init() Keybinder.bind('<Ctrl><Alt>space', callback) try: GLib.MainLoop().run() except KeyboardInterrupt: GLib.MainLoop().quit()
def initialize(self): """ Unbind previous hotkeys, re-read config & bind new hotkeys. """ for operation, key in self.hotkeys.items(): Keybinder.unbind(key) self.hotkeys = self.load_keys() for operation, key in self.hotkeys.items(): Keybinder.bind(key, self.fire_hook, operation)
def run_keybinder(callback): # for wayland DBusGMainLoop(set_as_default=True) dbus_menu = DbusMenu() Keybinder.bind('<Alt>space', callback, dbus_menu) #GLib.timeout_add_seconds(1, callback) try: GLib.MainLoop().run() except KeyboardInterrupt: GLib.MainLoop().quit()
def __init__(self): self.recorder = Recorder() keybinder.init() keybinder.bind('<Control>Escape', self.callback, None) self.overlay = Overlay() self.overlay.connect('trigger', lambda *args: self.start_recording(*self.overlay.get_selection())) self.overlay.show_all()
def bind_show_app_hotkey(self, accel_name): if self._current_accel_name == accel_name: return if self._current_accel_name: Keybinder.unbind(self._current_accel_name) self._current_accel_name = None logger.info("Trying to bind app hotkey: %s" % accel_name) Keybinder.bind(accel_name, self.cb_toggle_visibility) self._current_accel_name = accel_name
def __init__(self): self.indicator = appindicator.Indicator.new(APPINDICATOR_ID, self.get_current_state_icon(), appindicator.IndicatorCategory.SYSTEM_SERVICES) self.indicator.set_status(appindicator.IndicatorStatus.ACTIVE) self.indicator.set_menu(self.build_menu()) self.update_mic_state() Notify.init(APPINDICATOR_ID) Keybinder.init() Keybinder.set_use_cooked_accelerators(False) Keybinder.bind(keystr, self.callback_toggle_mic, "keystring %s (user data)" % keystr) print ("Press '" + keystr + "' to toggle microphone mute")
def set_app_show(self, new): ''' This is a specific method to set just the show accelerator. We use the value from gsettings to first unbind the current key, so in the process of changing the hotkey, we expect the API user to first call this method and later change gsettings. ''' if platform.system() == 'Windows': self.app.set_hotkey(new) else: Keybinder.unbind(self.shortcuts['app-show']) Keybinder.bind(new, self.app.on_show)
def __init__(self, data): """Create a new UIObject instance, including loading its uiFile and all UI-related objects. Instance attributes: data -- An instance of a pykickstart Handler object. The Hub never directly uses this instance. Instead, it passes it down into Spokes when they are created and applied. The Hub simply stores this instance so it doesn't need to be passed by the user. skipTo -- If this attribute is set to something other than None, it must be the name of a class (as a string). Then, the interface will skip to the first instance of that class in the action list instead of going on to whatever the next action is normally. Note that actions may only skip ahead, never backwards. Also, standalone spokes may not skip to an individual spoke off a hub. They can only skip to the hub itself. """ common.UIObject.__init__(self, data) if self.__class__ is GUIObject: raise TypeError("GUIObject is an abstract class") self.skipTo = None self.applyOnSkip = False self.builder = Gtk.Builder() self.builder.set_translation_domain(self.translationDomain) self._window = None if self.builderObjects: self.builder.add_objects_from_file(self._findUIFile(), self.builderObjects) else: self.builder.add_from_file(self._findUIFile()) self.builder.connect_signals(self) # Keybinder from GI needs to be initialized before use Keybinder.init() Keybinder.bind("<Shift>Print", self._handlePrntScreen, []) self._automaticEntry = False self._autostepRunning = False self._autostepDone = False self._autostepDoneCallback = None # this indicates if the screen is the last spoke to be processed for a hub self.lastAutostepSpoke = False
def __init__(self): self.app = "xkb-indicator" self.indicator = appindicator.Indicator.new( self.app, "ibus-keyboard", category=appindicator.IndicatorCategory.OTHER) self.indicator.set_status(appindicator.IndicatorStatus.ACTIVE) self.indicator.set_menu(self.build_menu()) self.indicator.set_label(label(), self.app) Keybinder.bind("<Alt>space", self.toggle) Keybinder.init()
def __init__(self, data): """Create a new UIObject instance, including loading its uiFile and all UI-related objects. Instance attributes: data -- An instance of a pykickstart Handler object. The Hub never directly uses this instance. Instead, it passes it down into Spokes when they are created and applied. The Hub simply stores this instance so it doesn't need to be passed by the user. skipTo -- If this attribute is set to something other than None, it must be the name of a class (as a string). Then, the interface will skip to the first instance of that class in the action list instead of going on to whatever the next action is normally. Note that actions may only skip ahead, never backwards. Also, standalone spokes may not skip to an individual spoke off a hub. They can only skip to the hub itself. """ common.UIObject.__init__(self, data) if self.__class__ is GUIObject: raise TypeError("GUIObject is an abstract class") self.skipTo = None self.applyOnSkip = False self.builder = Gtk.Builder() self.builder.set_translation_domain(self.translationDomain) self._window = None if self.builderObjects: self.builder.add_objects_from_file(self._findUIFile(), self.builderObjects) else: self.builder.add_from_file(self._findUIFile()) self.builder.connect_signals(self) # Keybinder from GI needs to be initialized before use Keybinder.init() Keybinder.bind("<Shift>Print", self._handlePrntScreen, []) self._automaticEntry = False self._autostepRunning = False self._autostepDone = False self._autostepDoneCallback = None # this indicates if the screen is the last spoke to be processed for a hub self.lastAutostepSpoke = False
def __init__(self): self.indicator = AppIndicator3.Indicator.new( 'tasker', 'tasker', AppIndicator3.IndicatorCategory.APPLICATION_STATUS) self.load_preferences() self.indicator.set_menu(self.build_menu()) self.indicator.set_label('', '') self.indicator.set_status(AppIndicator3.IndicatorStatus.ACTIVE) self.set_icon(True) self.load_todos() Keybinder.init() Keybinder.bind('<Super><Ctrl>T', self.callback) Gtk.main()
def __init__(self, silent = False): super(KazamSuperIndicator, self).__init__() self.blink_icon = BLINK_STOP_ICON self.blink_state = False self.blink_mode = BLINK_SLOW self.recording = False self.silent = silent logger.debug("Indicatior silent: {0}".format(self.silent)) self.menu = Gtk.Menu() self.menuitem_start = Gtk.MenuItem(_("Start recording")) self.menuitem_start.set_sensitive(True) self.menuitem_start.connect("activate", self.on_menuitem_start_activate) self.menuitem_pause = Gtk.CheckMenuItem(_("Pause recording")) self.menuitem_pause.set_sensitive(False) self.menuitem_pause.connect("toggled", self.on_menuitem_pause_activate) self.menuitem_finish = Gtk.MenuItem(_("Finish recording")) self.menuitem_finish.set_sensitive(False) self.menuitem_finish.connect("activate", self.on_menuitem_finish_activate) self.menuitem_separator = Gtk.SeparatorMenuItem() self.menuitem_quit = Gtk.MenuItem(_("Quit")) self.menuitem_quit.connect("activate", self.on_menuitem_quit_activate) self.menu.append(self.menuitem_start) self.menu.append(self.menuitem_pause) self.menu.append(self.menuitem_finish) self.menu.append(self.menuitem_separator) self.menu.append(self.menuitem_quit) self.menu.show_all() # # Setup keybindings - Hardcore way # try: from gi.repository import Keybinder logger.debug("Trying to bind hotkeys.") Keybinder.init() Keybinder.bind("<Super><Ctrl>R", self.cb_hotkeys, "start-request") Keybinder.bind("<Super><Ctrl>F", self.cb_hotkeys, "stop-request") Keybinder.bind("<Super><Ctrl>P", self.cb_hotkeys, "pause-request") Keybinder.bind("<Super><Ctrl>W", self.cb_hotkeys, "show-request") Keybinder.bind("<Super><Ctrl>Q", self.cb_hotkeys, "quit-request") self.recording = False except ImportError: logger.info("Unable to import Keybinder, hotkeys not available.")
def bind(self): if self.bound: self.unbind() try: print('Binding shortcut %s to popup glipper' % self.key_combination) keybinder.bind(self.key_combination, self.on_keyboard_shortcut) self.bound = True except KeyError: # if the requested keybinding conflicts with an existing one, a KeyError will be thrown self.bound = False self.emit('changed', self.bound)
def bind_hotkey(self, accel_name): if not IS_X11 or self._current_accel_name == accel_name: return if self._current_accel_name: Keybinder.unbind(self._current_accel_name) self._current_accel_name = None logger.info("Trying to bind app hotkey: %s", accel_name) Keybinder.bind(accel_name, lambda _: self.window.show_window()) self._current_accel_name = accel_name if FIRST_RUN: display_name = Gtk.accelerator_get_label(*Gtk.accelerator_parse(accel_name)) show_notification("Ulauncher", f"Hotkey is set to {display_name}")
def bind_show_app_hotkey(self, accel_name): if is_wayland_compatibility_on(): return if self._current_accel_name == accel_name: return if self._current_accel_name: Keybinder.unbind(self._current_accel_name) self._current_accel_name = None logger.info("Trying to bind app hotkey: %s" % accel_name) Keybinder.bind(accel_name, self.toggle_window) self._current_accel_name = accel_name self.notify_hotkey_change(accel_name)
def __init__(self): self.bound_keys = [] self.workarea = Workarea() self.callable_actions = dict self.__define_callable_actions() notify2.init("Azulejo") Keybinder.init() Keybinder.bind("<Super>y", WindowTools.print_window_info, None) Keybinder.bind("<Super>c", self.switch_config_files, None) self.bind_keys(configuration.get_config_data_first_time()) Gtk.main()
def bind_show_app_hotkey(self, accel_name): if is_wayland_compatibility_on(): return if self._current_accel_name == accel_name: return if self._current_accel_name: Keybinder.unbind(self._current_accel_name) self._current_accel_name = None logger.info("Trying to bind app hotkey: %s", accel_name) Keybinder.bind(accel_name, self.toggle_window) self._current_accel_name = accel_name self.notify_hotkey_change(accel_name)
def plugin_main(app, fullpath): import gi gi.require_version('Notify', '0.7') gi.require_version('Keybinder', '3.0') from gi.repository import Keybinder, Notify global notification notification = Notify.Notification() Keybinder.init() Keybinder.bind("<Ctrl><Alt>v", lambda *a: grab_notify(app)) Keybinder.bind("<Ctrl><Alt>m", lambda *a: notifier(app)) Notify.init("anubad") notification.set_icon_from_pixbuf(app.pixbuf_logo)
def bind_key(keystr, keybinding_target=KEYBINDING_DEFAULT): """ Bind @keystr, unbinding any previous key for @keybinding_target. If @keystr is a false value, any previous key will be unbound. """ keybinding_target = int(keybinding_target) if Keybinder is None: return False def callback(keystr): return GetKeyboundObject()._keybinding(keybinding_target) if not _is_sane_keybinding(keystr): pretty.print_error(__name__, "Refusing to bind key", repr(keystr)) return False succ = True if keystr: try: succ = Keybinder.bind(keystr, callback) pretty.print_debug(__name__, "binding", repr(keystr)) GetKeyboundObject().emit_bound_key_changed(keystr, True) except KeyError as exc: pretty.print_error(__name__, exc) succ = False if succ: old_keystr = get_currently_bound_key(keybinding_target) if old_keystr and old_keystr != keystr: Keybinder.unbind(old_keystr) pretty.print_debug(__name__, "unbinding", repr(old_keystr)) GetKeyboundObject().emit_bound_key_changed(old_keystr, False) _register_bound_key(keystr, keybinding_target) return succ
def _bind(self, hotkey, func): gtk_hotkey = self._gtk_hotkey(hotkey) bound = Keybinder.bind(gtk_hotkey, lambda *args, **kwargs: func()) if bound: logger.debug("Bound hotkey %r (gtk_hotkey = %r)", hotkey, gtk_hotkey) else: logger.error("Unable to bind hotkey %r (gtk_hotkey = %r)", hotkey, gtk_hotkey)
def __init__(self, name, callback): self._callback = callback self._worked = [] for keystring, action in self._EVENTS.items(): if Keybinder.bind(keystring, self._bind_cb, None): self._worked.append(keystring)
def register_callbacks(self): """Connect the GTK+ signals we care about""" self.connect('key-press-event', self.on_key_press) self.connect('button-press-event', self.on_button_press) self.connect('delete_event', self.on_delete_event) self.connect('destroy', self.on_destroy_event) self.connect('window-state-event', self.on_window_state_changed) self.connect('focus-out-event', self.on_focus_out) self.connect('focus-in-event', self.on_focus_in) # Attempt to grab a global hotkey for hiding the window. # If we fail, we'll never hide the window, iconifying instead. if self.config['keybindings']['hide_window'] != None: if display_manager() == 'X11': try: self.hidebound = Keybinder.bind( self.config['keybindings']['hide_window'].replace('<Shift>',''), self.on_hide_window) except (KeyError, NameError): pass if not self.hidebound: err('Unable to bind hide_window key, another instance/window has it.') self.hidefunc = self.iconify else: self.hidefunc = self.hide
def register_callbacks(self): """Connect the GTK+ signals we care about""" self.connect('key-press-event', self.on_key_press) self.connect('button-press-event', self.on_button_press) self.connect('delete_event', self.on_delete_event) self.connect('destroy', self.on_destroy_event) self.connect('window-state-event', self.on_window_state_changed) self.connect('focus-out-event', self.on_focus_out) self.connect('focus-in-event', self.on_focus_in) # Attempt to grab a global hotkey for hiding the window. # If we fail, we'll never hide the window, iconifying instead. if self.config['keybindings']['hide_window'] != None: if display_manager() == 'X11': try: self.hidebound = Keybinder.bind( self.config['keybindings']['hide_window'].replace( '<Shift>', ''), self.on_hide_window) except (KeyError, NameError): pass if not self.hidebound: err('Unable to bind hide_window key, another instance/window has it.' ) self.hidefunc = self.iconify else: self.hidefunc = self.hide
def bind_key(keystr, keybinding_target=KEYBINDING_DEFAULT): """ Bind @keystr, unbinding any previous key for @keybinding_target. If @keystr is a false value, any previous key will be unbound. """ keybinding_target = int(keybinding_target) if Keybinder is None: return False def callback(keystr): return GetKeyboundObject()._keybinding(keybinding_target) if not _is_sane_keybinding(keystr): pretty.print_error(__name__, "Refusing to bind key", repr(keystr)) return False succ = True if keystr: try: succ = Keybinder.bind(keystr, callback) pretty.print_debug(__name__, "binding", repr(keystr)) GetKeyboundObject().emit_bound_key_changed(keystr, True) except KeyError as exc: pretty.print_error(__name__, exc) succ = False if succ: old_keystr = get_currently_bound_key(keybinding_target) if old_keystr and old_keystr != keystr: Keybinder.unbind(old_keystr) pretty.print_debug(__name__, "unbinding", repr(old_keystr)) GetKeyboundObject().emit_bound_key_changed(old_keystr, False) _register_bound_key(keystr, keybinding_target) return succ
def __init__(self, name, callback): self._callback = callback self._worked = [] for keystring, action in self._EVENTS.items(): if Keybinder.bind(keystring, self._bind_cb, None): self._worked.append(keystring)
def on_exaile_loaded(self): if not self.__exaile: return # Plugin has been disabled in the meantime Keybinder.init() for k in KEYS: if not Keybinder.bind(k, on_media_key, self.__exaile): LOGGER.warning("Failed to set key binding using Keybinder.") self.__exaile.plugins.disable_plugin(__name__) return
def bind_key(cls): Keybinder.init() shortcut = MetaData.get_snapshoot_shortcut() if Keybinder.bind(shortcut, cls.callback, ""): if cls.old_key_shortcut is not None: Keybinder.unbind(cls.old_key_shortcut) cls.old_key_shortcut = shortcut else: logging.error("Bind shortcut key failed ")
def bind_key(cls): Keybinder.init() shortcut = MetaData.get_snapshoot_shortcut() if Keybinder.bind(shortcut,cls.callback,""): if cls.old_key_shortcut is not None: Keybinder.unbind(cls.old_key_shortcut) cls.old_key_shortcut = shortcut else: logging.error("Bind shortcut key failed ")
def bind_toggle_key(self, key): self.unbind_toggle_key() self.debug(f"Binding toggle key {key}") success = Keybinder.bind(key, self.toggle) if success: self._toggle_key = key return success else: self.debug(f"Failed to bind toggle key {key}") return success
def handleKeys(self): if len(self.boundKeys)>0: for key in self.boundKeys: #keybinder.unbind(key) pass self.boundKeys = [] config = configparser.ConfigParser() config.read(self.keyCfg) sections = config.sections() for s in sections: self.cmd = cmd = config.get(s, 'Exec') key = config.get(s, 'Key') try: keybinder.bind(key, self.callback, cmd) self.boundKeys.append(key) except: print("Error: can't bind ", key, "key")
def on_startup(self, app): ''' This method handles the startup signal. As per GNOME guidelines this is where most of the work to create the window should be done. ''' self.create_directories() self.settings = Gio.Settings(schema=self.schema_id + '.preferences') self.win_settings = Gio.Settings(schema=self.schema_id + '.window') self.width = self.win_settings['width'] self.height = self.win_settings['height'] self.general_settings = self.settings.get_child('general') self.set_autostart(self.general_settings['autostart']) self.closehide = self.general_settings['closehide'] self.about_dialog = None self.preferences_dialog = None logging.basicConfig(filename=self.log_file, level=logging.DEBUG, format='%(asctime)s %(levelname)s: %(message)s') self.window = Gtk.ApplicationWindow(application=app) self.window.connect('size-allocate', self.on_size_allocate) self.window.connect('delete-event', self.on_window_delete) self.window.set_title(self.title) self.window.set_default_size(self.width, self.height) self.window.set_position(Gtk.WindowPosition.MOUSE) self.window.set_titlebar(HeaderBar(self)) # We need to set the icon here as a backup, the gnome system monitor # for instance, and for whatever reason, doesn't choose the right icon # sometimes, particularly after hiding the window, and showing again. self.window.set_icon_name(self.icon) self.main_view = MainView(self) self.window.add(self.main_view) self.add_actions() builder = Gtk.Builder.new_from_file(self.gui_ui) app_menu = builder.get_object('app_menu') self.set_app_menu(app_menu) Keybinder.init() shortcuts = self.settings.get_child('shortcuts') Keybinder.bind(shortcuts['app-show'], self.on_show)
def bind(binding, func, *args, **kwargs): """Wrapper for keybinder.bind() allowing kwargs.""" def run(_, __): func(*args, **kwargs) try: Keybinder.unbind(binding) except: pass success = Keybinder.bind(binding, run, None) if not success: print "Error binding '%s'" % binding
def add_global_shortcut(self): ''' This method adds a global shortcut, the shortcut used to show the application. ''' shortcuts = self.settings.get_child('shortcuts') if platform.system() == 'Windows': self.modifiers = { Gdk.ModifierType.SHIFT_MASK: ['VK_SHIFT'], Gdk.ModifierType.CONTROL_MASK: ['VK_CONTROL'], Gdk.ModifierType.MOD1_MASK: ['VK_MENU'], Gdk.ModifierType.SUPER_MASK: ['VK_LWIN', 'VK_RWIN'] } hook_manager = pyHook.HookManager() hook_manager.KeyDown = self.on_keyboard_event self.set_hotkey(shortcuts['app-show']) hook_manager.HookKeyboard() else: Keybinder.init() Keybinder.bind(shortcuts['app-show'], self.on_show)
def init_keybinder(player): try: import gi gi.require_version("Keybinder", "3.0") from gi.repository import Keybinder except (ValueError, ImportError): return False Keybinder.init() signals = { "XF86AudioPrev": "prev", "XF86AudioNext": "next", "XF86AudioStop": "stop", "XF86AudioPlay": "play" } for sig, action in signals.items(): Keybinder.bind(sig, make_keybinder_cb(player, action), None) return True
def add_global_shortcut(self): ''' This method adds a global shortcut, the shortcut used to show the application. ''' shortcuts = self.settings.get_child('shortcuts') if platform.system() == 'Windows': self.modifiers = {Gdk.ModifierType.SHIFT_MASK: ['VK_SHIFT'], Gdk.ModifierType.CONTROL_MASK: ['VK_CONTROL'], Gdk.ModifierType.MOD1_MASK: ['VK_MENU'], Gdk.ModifierType.SUPER_MASK: ['VK_LWIN', 'VK_RWIN']} hook_manager = pyHook.HookManager() hook_manager.KeyDown = self.on_keyboard_event self.set_hotkey(shortcuts['app-show']) hook_manager.HookKeyboard() else: Keybinder.init() Keybinder.bind(shortcuts['app-show'], self.on_show)
def bind_keys(self, config_data): for action in config_data: keybinds = action['keybind'] function_name = action['function'] function = self.callable_actions[function_name] parameters = action['parameters'] dispacher_parameters = [function, keybinds, parameters] for keybind in keybinds: if Keybinder.bind(keybind, self.dispatcher, dispacher_parameters): self.bound_keys.append(keybind) else: print keybind, "was not bound successfully"
def bind_tab(self, bind=True): if bind: Keybinder.bind(self.super + 'Tab', self.tab_key, False) Keybinder.bind(self.super + '<Shift>Tab', self.tab_key, True) for i, key in enumerate(self.monkeys): Keybinder.bind(self.super + '<Ctrl>' + key, self.tab_key, False, i) Keybinder.bind(self.super + '<Ctrl><Shift>' + key, self.tab_key, False, i) else: Keybinder.unbind(self.super + 'Tab') Keybinder.unbind(self.super + '<Shift>Tab') for i, key in enumerate(self.monkeys): Keybinder.unbind(self.super + '<Ctrl>' + key) Keybinder.unbind(self.super + '<Ctrl><Shift>' + key)
def __init__(self): self.display = display.Display() Keybinder.init() Keybinder.bind("<Ctrl>9", self.on_snippets_activated) menu = Gtk.Menu() item = Gtk.MenuItem() item.set_label("Editor") item.connect("activate", self.on_editor_activated) item.show() menu.append(item) item = Gtk.MenuItem() item.set_label("Exit") item.connect("activate", Gtk.main_quit) item.show() menu.append(item) self.status_icon = AppIndicator3.Indicator.new( "linux-snippets", "onboard-mono", AppIndicator3.IndicatorCategory.APPLICATION_STATUS ) self.status_icon.set_icon_theme_path(os.getcwd()+"/res/") self.status_icon.set_icon("icon") self.status_icon.set_status(AppIndicator3.IndicatorStatus.ACTIVE) self.status_icon.set_menu(menu) self.editor = e_w.EditorWindow() self.editor.connect("delete-event", self.on_window_deleted) self.snippets = sn_w.SnippetsWindow(self.on_snippets_completed) self.snippets.connect("delete-event", self.on_window_deleted)
def bind_tab(self, bind=True): if bind: Keybinder.bind(self.super + 'Tab', self.tab_key, False) Keybinder.bind(self.super + '<Shift>Tab', self.tab_key, True) for i, key in enumerate(self.monkeys): Keybinder.bind(self.super + '<Ctrl>' + key, self.tab_key, False, i) Keybinder.bind(self.super + '<Ctrl><Shift>' + key, self.tab_key, False, i) else: Keybinder.unbind(self.super + 'Tab') Keybinder.unbind(self.super + '<Shift>Tab') for i, key in enumerate(self.monkeys): Keybinder.unbind(self.super + '<Ctrl>' + key) Keybinder.unbind(self.super + '<Ctrl><Shift>' + key)
def bind_keybinder(self): try: import gi gi.require_version('Keybinder', '3.0') # Gdk needed for Keybinder from gi.repository import Keybinder, Gdk Keybinder.init() except: return False Keybinder.bind('XF86AudioPlay', self.window.playpause, None) Keybinder.bind('XF86AudioStop', self.window.user_pause, None) Keybinder.bind('XF86AudioNext', self.window.next_song, None) Keybinder.bind('XF86AudioPrev', self.window.bring_to_top, None) logging.info("Bound media keys with keybinder") self.method = 'keybinder' return True
def bind_keybinder(self): try: import gi gi.require_version('Keybinder', '3.0') # Gdk needed for Keybinder from gi.repository import Keybinder Keybinder.init() except (ValueError, ImportError): return False Keybinder.bind('XF86AudioPlay', self.window.playpause, None) Keybinder.bind('XF86AudioStop', self.window.user_pause, None) Keybinder.bind('XF86AudioNext', self.window.next_song, None) Keybinder.bind('XF86AudioPrev', self.window.bring_to_top, None) logging.info("Bound media keys with keybinder") self.method = 'keybinder' return True
def __init__(self): Gtk.Window.__init__(self, type=Gtk.WindowType.TOPLEVEL) Keybinder.init() # Deactivating WM keybindings keybindings = Gio.Settings.new('org.gnome.desktop.wm.keybindings') wm_hotkey = lambda t: keybindings.get_value(t)[0] if wm_hotkey('switch-input-source') or wm_hotkey('switch-input-source-backward'): self.show_message("Unity-Kbd-Switcher is going to deactivate the following WM keybindings\n" + "You can set them later in settings if you'll decide to discontinue using.\n" + "\n" + "switch-input-source: " + wm_hotkey('switch-input-source') + "\n" + "switch-input-source-backward: " + wm_hotkey('switch-input-source-backward') + "\n") keybindings.set_value('switch-input-source', GLib.Variant('as', [''])) keybindings.set_value('switch-input-source-backward', GLib.Variant('as', [''])) # Initializing GSettings self.source_settings = Gio.Settings.new('org.gnome.desktop.input-sources') self.source_settings.connect("changed::current", self.on_current_changed) self.source_settings.connect("changed::sources", self.on_sources_changed) # Loading config rc = "%s/.kbdrc" % os.getenv("HOME") if not os.path.isfile(rc): self.generate_default_rc(rc) keymap = {} execfile(rc) self.keymap = keymap self.current_layout = None self.on_sources_changed(None, None) self.on_current_changed(None, None) # Binding global hotkeys for key in self.keymap.keys(): print "Binding %s" % key if not Keybinder.bind(key, self.on_global_key_activated, None): self.show_message("Could not bind '%s'" % key) # Usual Gtk Stuff self.connect("destroy", Gtk.main_quit) self.connect("delete_event", Gtk.main_quit) signal.signal(signal.SIGINT, signal.SIG_DFL) internals.app = self Gtk.main()
def __init__(self, player): self.player = player self.logger = logging.getLogger('KeyboardClient') try: import gi gi.require_version('Keybinder', '3.0') from gi.repository import Keybinder Keybinder.init() Keybinder.bind('XF86AudioPlay', self._on_XF86AudioPlay) Keybinder.bind('XF86AudioNext', self._on_XF86AudioNext) Keybinder.bind('XF86AudioPrev', self._on_XF86AudioPrev) except ValueError: self.logger.warning( 'Keybinder is needed on Linux for MediaKey binding')
def __init__(self, keys=False, spacing=3): super().__init__() self.icon = Gtk.Label() self.text = Gtk.Label() box = Gtk.Box(spacing=spacing) box.pack_start(self.icon, False, False, 0) box.pack_start(self.text, False, False, 0) self.add(box) self.icon.show() self.text.show() box.show() self.show() self.build_popup() self.set_events(Gdk.EventMask.BUTTON_PRESS_MASK) self.connect("button-press-event", self.click) self.pulse_bus = dbus.connection.Connection(pulse_bus_address()) self.pulse_core = self.pulse_bus.get_object(None, "/org/pulseaudio/core1") self.pulse_core.ListenForSignal("org.PulseAudio.Core1.FallbackSinkUpdated", [self.pulse_core], dbus_interface="org.PulseAudio.Core1") self.pulse_core.ListenForSignal("org.PulseAudio.Core1.FallbackSinkUnset", [self.pulse_core], dbus_interface="org.PulseAudio.Core1") self.default_sink = None self.updateSink(self.pulse_core.Get("org.PulseAudio.Core1", "FallbackSink", dbus_interface=PROPS)) self.pulse_bus.add_signal_receiver(self.updateSink, "FallbackSinkUpdated") self.pulse_bus.add_signal_receiver(self.unsetSink, "FallbackSinkUnset") self.pulse_bus.add_signal_receiver(self.updateVolume, "VolumeUpdated") self.pulse_bus.add_signal_receiver(self.updateMute, "MuteUpdated") if keys: Keybinder.bind("AudioMute", self.toggleMute) Keybinder.bind("AudioRaiseVolume", self.changeVolume, +5) Keybinder.bind("AudioLowerVolume", self.changeVolume, -5)
def run(self): # self.win = Gtk.Window() self.win = Gtk.Window(type=Gtk.WindowType.POPUP) self.win.set_border_width(1) width = 400 relative_top = 0.25 self.win.set_size_request(width, -1) self.win.move( (Gdk.Screen.get_default().width() / 2) - width / 2, Gdk.Screen.get_default().height() * relative_top, ) self.win.connect("delete-event", Gtk.main_quit) self.win.connect("show", self.handle_show) self.win.set_type_hint(Gdk.WindowTypeHint.UTILITY) self.win.set_resizable(False) self.win.set_decorated(False) vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) vbox.set_homogeneous(False) self.win.add(vbox) self.entry = Gtk.Entry() self.entry.override_font( Pango.FontDescription.from_string(self.config["entry_font"])) self.entry.connect("key-press-event", self.handle_key_press) self.entry.connect("changed", self.handle_input) vbox.pack_start(self.entry, False, True, 0) self.store = Gtk.ListStore(GdkPixbuf.Pixbuf, str, object) self.tree = Gtk.TreeView(self.store) self.tree.override_font(Pango.FontDescription.from_string(self.config["name_font"])) self.tree.set_headers_visible(False) self.tree.get_selection().set_mode(Gtk.SelectionMode.BROWSE) self.content_renderer = Gtk.CellRendererText() content_column = Gtk.TreeViewColumn("Name", self.content_renderer, markup=1) self.icon_renderer = Gtk.CellRendererPixbuf() icon_column = Gtk.TreeViewColumn("Icon", self.icon_renderer, pixbuf=0) self.tree.append_column(icon_column) self.tree.append_column(content_column) self.tree.set_search_column(-1) def handle_selection_changed(selection): tree_iter = selection.get_selected()[1] if not tree_iter: return self.tree.scroll_to_cell(self.store.get_path(tree_iter)) self.tree.get_selection().connect("changed", handle_selection_changed) self.scrolled = Gtk.ScrolledWindow() self.scrolled.set_policy(Gtk.PolicyType.ALWAYS, Gtk.PolicyType.AUTOMATIC) self.scrolled.add(self.tree) vbox.pack_start(self.scrolled, False, False, 0) signal.signal(signal.SIGINT, signal.SIG_DFL) accel_group = Gtk.AccelGroup() def connect_accel(accel, func): accel_group.connect(accel[0], accel[1], 0, func) def connection_multiple_accels(accels, func): for accel in accels: connect_accel(accel, func) hide_accel = Gtk.accelerator_parse("Escape") connect_accel(hide_accel, self.hide) quit_accel = Gtk.accelerator_parse("<Ctrl>q") connect_accel(quit_accel, Gtk.main_quit) launch_accel = Gtk.accelerator_parse("Return") connect_accel(launch_accel, self.launch_choice) Keybinder.init() Keybinder.bind(self.config["show_binding"], self.show, None) self.win.add_accel_group(accel_group) self.win.show_all() self.scrolled.hide() # Gdk.keyboard_grab(self.win.get_window(), False, Gdk.CURRENT_TIME) Gtk.main()
example-gi-py3.py Looked at a pull request that was built for py2.x, but overwrote the original py instead of making a separate example. I wouldn't have accepted that pull request either. The keybinder.init() part wasn't in the original example. [email protected] public domain """ import gi gi.require_version('Gtk', '3.0') gi.require_version('Keybinder', '3.0') from gi.repository import Gtk from gi.repository import Keybinder def callback(keystr, user_data): print ("Handling", user_data) print ("Event time:", Keybinder.get_current_event_time()) Gtk.main_quit() if __name__ == '__main__': keystr = "<Ctrl><Alt>M" Keybinder.init() Keybinder.bind(keystr, callback, "keystring %s (user data)" % keystr) print ("Press", keystr, "to handle keybinding and quit") Gtk.main()
if keystr == KeyBinds.pomodoro.value: handler.btn_pomodoro_clicked_cb(None) elif keystr == KeyBinds.short_break.value: handler.btn_short_break_clicked_cb(None) elif keystr == KeyBinds.long_break.value: handler.btn_long_break_clicked_cb(None) elif keystr == KeyBinds.timer.value: if handler.watch and handler.watch.is_alive(): handler.btn_stop_clicked_cb(None) else: handler.btn_start_clicked_cb(None) elif keystr == KeyBinds.reset.value: handler.btn_reset_clicked_cb(None) elif keystr == KeyBinds.quit.value: handler.window_destroy_cb(None) if __name__ == "__main__": handler = Handler builder = Gtk.Builder() builder.add_from_file("./pomodoro.glade") window = builder.get_object("window") lbl_time = builder.get_object("lbl_time") handler = Handler(lbl_time) builder.connect_signals(handler) window.show_all() Keybinder.init() for keystr in KeyBinds: Keybinder.bind(keystr.value, callback) Gtk.main()
def bind_all_key(self, key_toggle, key_copy, key_paste): """Bind all keys used with tida""" Keybinder.bind(key_toggle, self.callback_toggle_visibility, "asd") Keybinder.bind(key_copy, self.callback_copy, "asd") Keybinder.bind(key_paste, self.callback_paste, "asd")
def __init__(self, fullscreen): """Create a new anaconda main window. :param bool fullscreen: if True, fullscreen the window, if false maximize """ Gtk.Window.__init__(self) # Hide the titlebar when maximized if the window manager allows it. # This makes anaconda look full-screenish but without covering parts # needed to interact with the window manager, like the GNOME top bar. self.set_hide_titlebar_when_maximized(True) # The Anaconda and Initial Setup windows might sometimes get decorated with # a titlebar which contains the __init__.py header text by default. # As all Anaconda and Initial Setup usually have a very distinct title text # inside the window, the titlebar text is redundant and should be disabled. self.set_title(_(WINDOW_TITLE_TEXT)) # Set the icon used in the taskbar of window managers that have a taskbar # The "anaconda" icon is part of fedora-logos self.set_icon_name("anaconda") # Treat an attempt to close the window the same as hitting quit self.connect("delete-event", self._on_delete_event) # Create a black, 50% opacity pixel that will be scaled to fit the lightbox overlay # The confusing list of unnamed parameters is: # bytes, colorspace (there is no other colorspace), has-alpha, # bits-per-sample (has to be 8), width, height, # rowstride (bytes between row starts, but we only have one row) self._transparent_base = GdkPixbuf.Pixbuf.new_from_bytes(GLib.Bytes.new([0, 0, 0, 127]), GdkPixbuf.Colorspace.RGB, True, 8, 1, 1, 1) # Contain everything in an overlay so the window can be overlayed with the transparency # for the lightbox effect self._overlay = Gtk.Overlay() self._overlay_img = None self._overlay.connect("get-child-position", self._on_overlay_get_child_position) self._overlay_depth = 0 # Create a stack and a list of what's been added to the stack # Double the stack transition duration since the default 200ms is too # quick to get the point across self._stack = Gtk.Stack(transition_duration=400) self._stack_contents = set() # Create an accel group for the F12 accelerators added after window transitions self._accel_group = Gtk.AccelGroup() self.add_accel_group(self._accel_group) # Make the window big if fullscreen: self.fullscreen() else: self.maximize() self._overlay.add(self._stack) self.add(self._overlay) self.show_all() self._current_action = None # Help button mnemonics handling self._mnemonic_signal = None # we have a sensible initial value, just in case self._saved_help_button_label = _("Help!") # Apply the initial language attributes self._language = None self.reapply_language() # Keybinder from GI needs to be initialized before use Keybinder.init() Keybinder.bind("<Shift>Print", self._handle_print_screen, []) self._screenshot_index = 0