def key_gtk2openbox(key, mods): result = "" if mods: s = gtk.accelerator_name(0, mods) svec = [replace_table_gtk2openbox[i] for i in s[1:-1].split('><')] result = '-'.join(svec) if key: k = gtk.accelerator_name(key, 0) if result != "": result += '-' result += k return result
def refresh_model(self): """ Initializes the model from data provided by the keybinding manager. """ self.treestore.clear() section_order = list( set(d['group'] for d in keybindings.BINDING_INFO.values())) section_order.sort() section_parent_map = {} for section_name in section_order: row = [section_name, None, False] row.extend([ None, ] * self.accel_column_num) section_parent_map[section_name] = self.treestore.append(None, row) action_treeiter_map = self.action_treeiter_map = {} # Sort actions by action name actions = sorted(keybindings.BINDING_INFO.items(), key=lambda item: item[1]['title']) for action_name, action_data in actions: title = action_data['title'] group_name = action_data['group'] old_bindings = self.keymanager.get_bindings_for_action(action_name) acc_list = [ "", ] * self.accel_column_num for idx in range(0, self.accel_column_num): if len(old_bindings) > idx: acc_list[idx] = gtk.accelerator_name(*old_bindings[idx]) row = [title, action_name, True] row.extend(acc_list) treeiter = self.treestore.append(section_parent_map[group_name], row) action_treeiter_map[action_name] = treeiter
def handle_key_event(self, event): ''' Internal function to handle key event. ''' modifiers = [] # Add Ctrl modifier. if event.state & gtk.gdk.CONTROL_MASK: modifiers.append("Ctrl") # Add Super modifiers. if event.state & gtk.gdk.SUPER_MASK: modifiers.append("Super") # Add Hyper modifiers. if event.state & gtk.gdk.HYPER_MASK: modifiers.append("Hyper") # Add Alt modifier. if event.state & gtk.gdk.MOD1_MASK: modifiers.append("Alt") if event.state & gtk.gdk.SHIFT_MASK: modifiers.append("Shift") modifiers.append(gtk.accelerator_name(event.keyval, 0)) key_name = " + ".join(modifiers) if key_name in self.keymap: self.keymap[key_name]()
def add(self, accel, callback, data=None): num = len(accel.accelerators) mapping = self.accelerators for i in range(num): parsed = gtk.accelerator_parse(accel.accelerators[i]) if not gtk.accelerator_valid(*parsed): return named = gtk.accelerator_name(*parsed) inmap = named in mapping if i == num - 1 and inmap: # Last one cannot be in the map return elif inmap and isinstance(mapping[named], AccelCallback): # It's already mapped... return else: if not inmap: mapping[named] = {} if i == num - 1: mapping[named] = AccelCallback(accel, callback, data) mapping = mapping[named]
def on_accel_edited(renderer, path, accel_key, accel_mods, hardware_keycode): iter = self.treestore.get_iter(path) col = column + 3 # accel cells start from 3 position old_accel = self.treestore.get(iter, col)[0] new_accel = gtk.accelerator_name(accel_key, accel_mods) self.treestore.set_value(iter, col, new_accel) action_name = self.treestore.get_value(iter, 1) affected_action = self.keymanager.edit_accel( action_name, new_accel, old_accel) # Find affected row and cell if affected_action == action_name: for idx in range(0, self.accel_column_num): if idx != column and self.treestore.get( iter, idx + 3)[0] == new_accel: self.treestore.set_value(iter, idx + 3, "") elif affected_action is not None: titer = self.action_treeiter_map[affected_action] for idx in range(0, self.accel_column_num): if self.treestore.get(titer, idx + 3)[0] == new_accel: self.treestore.set_value(titer, idx + 3, "") # updating gtk accelerator for label in menu if self.keymanager.get_bindings_for_action(action_name)[0] == ( accel_key, accel_mods): gtk.accel_map_change_entry( '<Actions>/mcomix-main/%s' % action_name, accel_key, accel_mods, True)
def _on_accelerator_entry_key_press(self, entry, event): """Callback for handling key events in the accelerator entry. Accelerators are added by pressing Ctrl, Shift and/or Alt in combination with the desired key. Delete and Backspace can be used to clear the entry. No other types of editing is possible.""" # Tab must be handled as normal. Otherwise we can't move from # the entry. if event.keyval == gtk.keysyms.Tab: return False modifiers = event.get_state() & gtk.accelerator_get_default_mod_mask() modifiers = int(modifiers) # Check if we should clear the entry clear_keys = [gtk.keysyms.Delete, gtk.keysyms.KP_Delete, gtk.keysyms.BackSpace] if modifiers == 0: if event.keyval in clear_keys: entry.set_text('') return True # Check if the accelerator is valid and add it to the entry if gtk.accelerator_valid(event.keyval, modifiers): accelerator = gtk.accelerator_name(event.keyval, modifiers) entry.set_text(accelerator) return True
def keyPressCommand(self, event): ''' Create command lines for variuos key presses. @param event: Key press at-spi event. @type event: Accessibility.DeviceEvent ''' if event.id in self.MODIFIERS or \ event.event_string.startswith('ISO'): return if event.modifiers in (0, gtk.gdk.SHIFT_MASK) and \ gtk.gdk.keyval_to_unicode(event.id): self.typed_text += unichr(gtk.gdk.keyval_to_unicode(event.id)) else: if self.frame_name: self.commands_queue.put_nowait('waittillguiexist("%s")\n' % \ self.frame_name) self.frame_name = '' if self.typed_text: self.commands_queue.put_nowait('generatekeyevent("%s")\n' % \ self.typed_text) self.typed_text = '' self.commands_queue.put_nowait('generatekeyevent("%s")\n' % \ gtk.accelerator_name(event.id, event.modifiers))
def create_entry(self, actwrap): d = gtk.Dialog(parent=None, flags=gtk.DIALOG_MODAL, title='Enter new keypress', buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT, gtk.STOCK_OK, gtk.RESPONSE_ACCEPT)) action = actwrap.action e = gtk.Entry() e.show() d.vbox.pack_start(e, expand=False) key, mod = gtk.accel_map_lookup_entry(action.accel_path) accel = gtk.accelerator_name(key, mod) e.set_text(accel) def _response(dlg, response): d.hide() if response == gtk.RESPONSE_ACCEPT: newaccel = e.get_text() action.set_accel(newaccel) actwrap.reset_markup() key, mod = gtk.accelerator_parse(newaccel) gtk.accel_map_change_entry(action.accel_path, key, mod, True) d.destroy() d.connect('response', _response) d.run()
def set_accelerator(self, keyval, mod): # Check whether accelerator already exists self.remove_accelerator(self.current_node) name = gtk.accelerator_name(keyval, mod) if name == '': self.current_node.shorcut = None self.save_current_tool() return True col = self.accelerator_collision(name, self.current_node) if col: dialog = gtk.MessageDialog( self.dialog, gtk.DIALOG_MODAL, gtk.MESSAGE_ERROR, gtk.BUTTONS_OK, _('This accelerator is already bound to %s') % (', '.join(map(lambda x: x.name, col)), )) dialog.run() dialog.destroy() self.add_accelerator(self.current_node) return False self.current_node.shortcut = name self.add_accelerator(self.current_node) self.save_current_tool() return True
def create_toggle_button(self, name, action, index, text='', accel_key=None): ''' create a togglebutton @param name: the button's name, a string @param action: one of ACTION Type Constants @param index: the button's index in button list, an int num @param text: the button's tooltip text, a string ''' button = ToggleButtonItem( (app_theme.get_pixbuf("action/" + name + "_normal.png"), app_theme.get_pixbuf("action/" + name + "_press.png"), app_theme.get_pixbuf("action/" + name + "_hover.png"), app_theme.get_pixbuf("action/" + name + "_press.png"), None), index, self._toggle_button_group.set_index, self._toggle_button_group.get_index) button.connect("pressed", self._toggle_button_pressed) button.connect("toggled", self._toggle_button_toggled, action) button.connect("enter-notify-event", self._show_tooltip, text) button.set_name(name) #self.toolbox.pack_start(button) self._toggle_button_group.pack_start(button) self._toggle_button_list.append(button) if accel_key: self.__button_accelerator_dict[gtk.accelerator_name( *gtk.accelerator_parse(accel_key))] = button
def next (self): while self.to_traverse != []: (w, prefix, level) = self.to_traverse.pop () if isinstance (w, gtk.MenuItem): accel_path = "" result = None for m in w.get_children(): if isinstance (m, gtk.Label): accel_path = prefix + m.get_text() accel = "" if isinstance (m, gtk.AccelLabel): key = gtk.accel_map_lookup_entry (prefix + m.get_text()) if key and key[0] != 0: accel = gtk.accelerator_name (key[0], key[1]) result = (w, accel_path, accel, level) if w.get_submenu (): self.to_traverse = self.to_traverse + \ [(c, accel_path + "/", level + 1) \ for c in w.get_submenu ()] if result: return result elif isinstance (w, gtk.Container): self.to_traverse = self.to_traverse + \ [(c, prefix, level + 1) for c in w.get_children ()] raise StopIteration
def refresh_model(self): """ Initializes the model from data provided by the keybinding manager. """ self.treestore.clear() section_order = list(set(d['group'] for d in keybindings.BINDING_INFO.values())) section_order.sort() section_parent_map = {} for section_name in section_order: row = [section_name, None, False] row.extend( [None,] * self.accel_column_num) section_parent_map[section_name] = self.treestore.append( None, row ) action_treeiter_map = self.action_treeiter_map = {} # Sort actions by action name actions = sorted(keybindings.BINDING_INFO.items(), key=lambda item: item[1]['title']) for action_name, action_data in actions: title = action_data['title'] group_name = action_data['group'] old_bindings = self.keymanager.get_bindings_for_action(action_name) acc_list = ["", ] * self.accel_column_num for idx in range(0, self.accel_column_num): if len(old_bindings) > idx: acc_list[idx] = gtk.accelerator_name(*old_bindings[idx]) row = [title, action_name, True] row.extend(acc_list) treeiter = self.treestore.append( section_parent_map[group_name], row ) action_treeiter_map[action_name] = treeiter
def on_wirelessHotkeyButton_changed(self, button = None, key = None, mods = None): if key == 0 and mods == 0: new = "disable" else: new = gtk.accelerator_name(key, mods) session = self.__connect_session_options() session.SetWirelessHotkey(self.__convert_gtk_to_xbindkeys(new))
def on_key_edited(self, renderer, path, keycode, mask, keyval, model): """Callback that handles key edition in cellrenderer. It makes some tests to validate the key, like looking for already in use keys and look for [A-Z][a-z][0-9] to avoid problems with these common keys. If all tests are ok, the value will be stored in gconf. """ giter = model.get_iter(path) gconf_path = model.get_value(giter, 0) oldkey = model.get_value(giter, 2) hotkey = KeyEntry(keycode, mask) key = gtk.accelerator_name(keycode, mask) keylabel = gtk.accelerator_get_label(keycode, mask) # we needn't to change anything, the user is trying to set the # same key that is already set. if oldkey == hotkey: return False # looking for already used keybindings def each_key(model, path, subiter): keyentry = model.get_value(subiter, 2) if keyentry and keyentry == hotkey: msg = _('The shortcut "%s" is already in use.') % keylabel raise ShowableError(_("Error setting keybinding."), msg, -1) model.foreach(each_key) # avoiding problems with common keys if (mask == 0 and keycode != 0) and ( (keycode >= ord("a") and keycode <= ord("z")) or (keycode >= ord("A") and keycode <= ord("Z")) or (keycode >= ord("0") and keycode <= ord("9")) ): dialog = gtk.MessageDialog( self.get_widget("config-window"), gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_WARNING, gtk.BUTTONS_OK, _( 'The shortcut "%s" cannot be used ' "because it will become impossible to " "type using this key.\n\n" "Please try with a key such as " "Control, Alt or Shift at the same " "time.\n" ) % key, ) dialog.run() dialog.destroy() return False # setting new value in ui giter = model.get_iter(path) model.set_value(giter, 2, hotkey) # setting the new value in gconf self.client.set_string(gconf_path, key)
def new(cls, gtk_action, parent): """Create a new GAction from a GtkAction and a GtkActionGroup""" # This code is similar to code in the loader, investigate # if we can use more code reusage name = gtk_action.get_name() label = gtk_action.get_property('label') short_label = gtk_action.get_property('short-label') is_important = gtk_action.get_property('is-important') tooltip = gtk_action.get_property('tooltip') stock_id = gtk_action.get_property('stock-id') or None gaction = cls(parent, name, label, short_label, is_important, tooltip, stock_id) # check if it has accelerator accel_entry = gtk.accel_map_lookup_entry('<Actions>/%s/%s' % (parent.name, name)) if accel_entry: key, modifier = accel_entry if key != 0: gaction.accelerator = gtk.accelerator_name(key, modifier) # check if it has signal handler callback = gtk_action.get_data('handler') if callback: gaction.callback = callback return gaction
def set_accelerator(self, keyval, mod): # Check whether accelerator already exists self.remove_accelerator(self.current_node) name = gtk.accelerator_name(keyval, mod) if name == '': self.current_node.shorcut = None self.save_current_tool() return True col = self.accelerator_collision(name, self.current_node) if col: dialog = gtk.MessageDialog(self.dialog, gtk.DIALOG_MODAL, gtk.MESSAGE_ERROR, gtk.BUTTONS_OK, _('This accelerator is already bound to %s') % (', '.join(map(lambda x: x.name, col)),)) dialog.run() dialog.destroy() self.add_accelerator(self.current_node) return False self.current_node.shortcut = name self.add_accelerator(self.current_node) self.save_current_tool() return True
def _on_capture_keypress(self, entry, event): # svn.gnome.org/viewcvs/gazpacho/trunk/gazpacho/actioneditor.py # Tab must be handled as normal. Otherwise we can't move from # the entry. if event.keyval == gtk.keysyms.Tab and not self._full_button.get_active(): return False modifiers = event.get_state() & gtk.accelerator_get_default_mod_mask() modifiers = int(modifiers) # Check if we should clear the entry clear_keys = [gtk.keysyms.Delete, gtk.keysyms.KP_Delete, gtk.keysyms.BackSpace] if modifiers == 0 and not self._full_button.get_active(): if event.keyval in clear_keys: entry.set_text('') self._current.set_value('') return True # Check if the accelerator is valid and add it to the entry if gtk.accelerator_valid(event.keyval, modifiers) or \ self._full_button.get_active(): accelerator = gtk.accelerator_name(event.keyval, modifiers) if self.free_accelerator(accelerator, self._current): entry.set_text(accelerator) self._current.set_value(accelerator) # deactive the dangerouse button again :-) self._full_button.set_active(False) return True
def on_cpuHotkeyButton_changed(self, button=None, key=None, mods=None): if key == 0 and mods == 0: new = "disable" else: new = gtk.accelerator_name(key, mods) session = self.__connect_session_options() session.SetCpuHotkey(self.__convert_gtk_to_xbindkeys(new))
def on_accel_edited(self, cellrenderer, path, accel_key, accel_mods, keycode): """ Updates accelerators display in the list """ accel = gtk.accelerator_name(accel_key, accel_mods) iter = self.list.get_iter(path) self.list.set_value(iter, 1, accel)
def keyPressCommand(self, event): if event.id in self.MODIFIERS or \ (event.event_string.startswith('ISO') and \ event.event_string != 'ISO_Left_Tab'): return if isinstance(event, pyatspi.event.DeviceEvent): # If it's a fake one, then it is a global WM hotkey, no need for context. self._prependContext() if event.modifiers in (0, gtk.gdk.SHIFT_MASK) and \ gtk.gdk.keyval_to_unicode(event.id): self.typed_text += unichr(gtk.gdk.keyval_to_unicode(event.id)) else: if self.frame_name: if isinstance(event, pyatspi.event.DeviceEvent): self.commands_queue.put_nowait( 'sequence.append(WaitForWindowActivate("%s", None))\n' % \ self.frame_name.replace('"','\"')) self.frame_name = '' if self.last_focused: name, path, role = self.last_focused self.commands_queue.put_nowait( '%ssequence.append(WaitForFocus("%s", acc_role=pyatspi.%s))\n' % \ (self._focus_comment, name.replace('"','\"'), repr(role))) self.last_focused = None if self.typed_text: self.commands_queue.put_nowait( 'sequence.append(TypeAction("%s"))\n' % \ self.typed_text.replace('"','\"')) self.typed_text = '' self.commands_queue.put_nowait( 'sequence.append(KeyComboAction("%s"))\n' % \ gtk.accelerator_name(event.id, event.modifiers))
def create_entry(self, actwrap): d = gtk.Dialog(parent=None, flags=gtk.DIALOG_MODAL, title='Enter new keypress', buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT, gtk.STOCK_OK, gtk.RESPONSE_ACCEPT) ) action = actwrap.action e = gtk.Entry() e.show() d.vbox.pack_start(e, expand=False) key, mod = gtk.accel_map_lookup_entry(action.accel_path) accel = gtk.accelerator_name(key, mod) e.set_text(accel) def _response(dlg, response): d.hide() if response == gtk.RESPONSE_ACCEPT: newaccel = e.get_text() action.set_accel(newaccel) actwrap.reset_markup() key, mod = gtk.accelerator_parse(newaccel) gtk.accel_map_change_entry(action.accel_path, key, mod, True) d.destroy() d.connect('response', _response) d.run()
def is_accel(event, accel): """Checks if the given gtk.gdk.Event matches an accelerator string example: is_accel(event, "<shift><ctrl>z") """ if event.type != gtk.gdk.KEY_PRESS: return False # ctrl+shift+x gives us ctrl+shift+X and accelerator_parse returns # lowercase values for matching, so lowercase it if possible keyval = event.keyval if not keyval & ~0xFF: keyval = ord(chr(keyval).lower()) default_mod = gtk.accelerator_get_default_mod_mask() accel_keyval, accel_mod = gtk.accelerator_parse(accel) # If the accel contains non default modifiers matching will never work and # since no one should use them, complain non_default = accel_mod & ~default_mod if non_default: print_w("Accelerator '%s' contains a non default modifier '%s'." % (accel, gtk.accelerator_name(0, non_default) or "")) # Remove everything except default modifiers and compare return (accel_keyval, accel_mod) == (keyval, event.state & default_mod)
def accel_group_callback(self, group, acceleratable, keyval, modifier): accel_name = gtk.accelerator_name(keyval, modifier) if accel_name in self.__button_accelerator_dict: button = self.__button_accelerator_dict[accel_name] button.pressed() button.released() #button.clicked() self.set_button_active(button.get_name(), True)
def get_accel_name(self): ''' converts the accelerator keyval and modifier mask into a string @return: a acceleratot string ''' if self.state is None or self.keyval is None: return '' return accelerator_name(self.keyval, self.state)
def update_label(self, key, mods): text = "" for mod in mod_table: if mods & mod: text = text + mod_table[mod] self.mod = text self.key = gtk.accelerator_name(key, 0) self.label1.set_text(self.mod + self.key)
def GotKey(self, widget, key, mods): self.shortcut = gtk.accelerator_name(key, mods) for mod in KeyModifier: if "%s_L" % mod in self.shortcut: self.shortcut = self.shortcut.replace("%s_L" % mod, "<%s>" % mod) if "%s_R" % mod in self.shortcut: self.shortcut = self.shortcut.replace("%s_R" % mod, "<%s>" % mod) gtk.main_quit()
def GotKey(self, widget, key, mods): self.shortcut = gtk.accelerator_name (key, mods) for mod in KeyModifier: if "%s_L" % mod in self.shortcut: self.shortcut = self.shortcut.replace ("%s_L" % mod, "<%s>" % mod) if "%s_R" % mod in self.shortcut: self.shortcut = self.shortcut.replace ("%s_R" % mod, "<%s>" % mod) gtk.main_quit()
def get_accel_name(self): ''' converts the accelerator keyval and modifier mask into a string @return: a acceleratot string ''' if self.state is None or self.keyval is None: return '' if self.keyval == 0 and self.state == gtk.gdk.SUPER_MASK: return 'Super' return gtk.accelerator_name(self.keyval, self.state)
def kbd_entry_press(self, widget, event, data=None): # capture keypresses here k = gtk.gdk.keyval_name(event.keyval) if k in self.modifier_keyvals: return modifiers = event.state & self.modifiers_mask label = gtk.accelerator_name(event.keyval, modifiers) widget.set_text(label) print 'Key %s pressed.' % label gtk.gdk.keyboard_ungrab()
def __create_model(self): store = gtk.ListStore( gobject.TYPE_PYOBJECT, gobject.TYPE_STRING) ids = gtk.stock_list_ids() ids.sort() for data in ids: info = StockItemInfo(stock_id=data) stock_item = gtk.stock_lookup(data) if stock_item: info.stock_item = stock_item else: # stock_id, label, modifier, keyval, translation_domain info.stock_item =('', '', 0, 0, '') # only show icons for stock IDs that have default icons icon_set = gtk.icon_factory_lookup_default(info.stock_id) if icon_set is None: info.small_icon = None else: # See what sizes this stock icon really exists at sizes = icon_set.get_sizes() n_sizes = len(sizes) # Use menu size if it exists, otherwise first size found size = sizes[0]; i = 0; while(i < n_sizes): if(sizes[i] == gtk.ICON_SIZE_MENU): size = gtk.ICON_SIZE_MENU break i += 1 info.small_icon = self.render_icon(info.stock_id, size) if(size != gtk.ICON_SIZE_MENU): # Make the result the proper size for our thumbnail w, h = gtk.icon_size_lookup(gtk.ICON_SIZE_MENU) scaled = info.small_icon.scale_simple(w, h, 'bilinear') info.small_icon = scaled if info.stock_item[3] == 0: info.accel_str = "" else: info.accel_str = \ gtk.accelerator_name(info.stock_item[3], info.stock_item[2]) iter = store.append() store.set(iter, 0, info, 1, info.stock_id) return store
def on_accel_edited(self, renderer, path, accel_key, accel_mods, hardware_keycode): iter = self.actions.get_iter(path) accel = accelerator_name(accel_key, accel_mods) name = self.actions.get_value(iter, 0) path = shortcuts.get_path_by_name(name) accel_map_change_entry(path, accel_key, accel_mods, True) shortcuts.names_by_key.clear() self.actions.set_value(iter, 1, accel) self.actions.set_value(iter, 4, self.get_weight(path, accel_key, accel_mods))
def on_accel_edited(self, renderer, path, accel_key, accel_mods, hardware_keycode): iter = self.actions.get_iter(path) accel = accelerator_name(accel_key, accel_mods) name = self.actions.get_value(iter, 0) shortcuts[name] = accel self.actions.set_value(iter, 1, accel) self.actions.set_value(iter, 4, WEIGHT_BOLD) replace_accelerator(name, accel, False)
def _cellAccelEdit(self, cell, path, accel_key, accel_mods, code, model): """ Accelerator is modified """ self.show_input = gtk.accelerator_get_label(accel_key, accel_mods) self.new_task_binding = gtk.accelerator_name(accel_key, accel_mods) if check_invalidity(self.new_task_binding, accel_key, accel_mods): self._show_warning(gtk.Button(_("Warning")), self.show_input) return self.binding_backup = self.new_task_binding iter = model.get_iter(path) model.set_value(iter, 1, self.show_input) save_new_binding(self.new_task_binding, self.button.get_active())
def on_key_edited(self, renderer, path, keycode, mask, keyval, model): """Callback that handles key edition in cellrenderer. It makes some tests to validate the key, like looking for already in use keys and look for [A-Z][a-z][0-9] to avoid problems with these common keys. If all tests are ok, the value will be stored in gconf. """ giter = model.get_iter(path) gconf_path = model.get_value(giter, 0) oldkey = model.get_value(giter, 2) hotkey = KeyEntry(keycode, mask) key = gtk.accelerator_name(keycode, mask) keylabel = gtk.accelerator_get_label(keycode, mask) # we needn't to change anything, the user is trying to set the # same key that is already set. if oldkey == hotkey: return False # looking for already used keybindings def each_key(model, path, subiter): keyentry = model.get_value(subiter, 2) if keyentry and keyentry == hotkey: msg = _("The shortcut \"%s\" is already in use.") % keylabel raise ShowableError(_('Error setting keybinding.'), msg, -1) model.foreach(each_key) # avoiding problems with common keys if ((mask == 0 and keycode != 0) and ((keycode >= ord('a') and keycode <= ord('z')) or (keycode >= ord('A') and keycode <= ord('Z')) or (keycode >= ord('0') and keycode <= ord('9')))): dialog = gtk.MessageDialog( self.get_widget('config-window'), gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_WARNING, gtk.BUTTONS_OK, _("The shortcut \"%s\" cannot be used " "because it will become impossible to " "type using this key.\n\n" "Please try with a key such as " "Control, Alt or Shift at the same " "time.\n") % key) dialog.run() dialog.destroy() return False # setting new value in ui giter = model.get_iter(path) model.set_value(giter, 2, hotkey) # setting the new value in gconf self.client.set_string(gconf_path, key)
def setup_accelerator(self): accelerator = stock.get_accelerator(self._stock_id) logger.debug(str(accelerator)) try: if accelerator[1] > 0: self.toolitem.props.accelerator = gtk.accelerator_name( accelerator[1], accelerator[0]) except: logger.error( 'Could not set up accelerator; if toogletoolbutton, update your sugar version' )
def _on_mnemonic_activate(self, widget, group_cycling, keyval): """ Callback for the mnemonic activate signal. If we're currently editing the accelerator we have to disable the usual mnemonic action and use the keyval for as an accelerator value. """ if self._accel_editing: key = gtk.accelerator_name(keyval, self.mnemonic_modifier) self.accelerator.set_text(key) return True return False
def replace_generics(self, name, keys): if name in self.default_generics and set(self.default_generics[name]) == set(keys): self.changed_generics.pop(name, None) else: if keys or name in self.default_generics: self.changed_generics[name] = [(gtk.accelerator_name(*km), pr) for km, pr in keys] else: self.changed_generics.pop(name, None) self.generic_shortcuts.setdefault(name, [])[:] = [] for km, pr in keys: self.generic_shortcuts[name].append((km, pr))
def on_dialoggetkey_key_press_event(self, _widget, event): self.imagekeybindingaux.hide() self.labelkeybindingaux.hide() self._press_time = event.time keyval, state = self.translate_keyboard_event(event) keyname = gtk.accelerator_name(keyval, state) if keyname == 'Escape': self._return(None) elif keyname == 'BackSpace': self._return('') self.update_accelerator_label(keyval, state)
def on_dialoggetkey_key_press_event(self, widget, event): self.imagekeybindingaux.hide() self.labelkeybindingaux.hide() self._press_time = event.time keyval, state = self.translate_keyboard_event(widget, event) keyname = gtk.accelerator_name(keyval, state) if keyname == 'Escape': self._return(None) elif keyname == 'BackSpace': self._return('') self.update_accelerator_label(keyval, state)
def activate(self, key, mod): named = gtk.accelerator_name(key, mod) if not named in self.accelerators: return None accel = self.accelerators[named] if isinstance(accel, AccelCallback): return accel else: return AccelGroup(self, named, accel)
def __create_model(self): store = gtk.ListStore(gobject.TYPE_PYOBJECT, gobject.TYPE_STRING) ids = gtk.stock_list_ids() ids.sort() for data in ids: info = StockItemInfo(stock_id=data) stock_item = gtk.stock_lookup(data) if stock_item: info.stock_item = stock_item else: # stock_id, label, modifier, keyval, translation_domain info.stock_item = ('', '', 0, 0, '') # only show icons for stock IDs that have default icons icon_set = gtk.icon_factory_lookup_default(info.stock_id) if icon_set is None: info.small_icon = None else: # See what sizes this stock icon really exists at sizes = icon_set.get_sizes() n_sizes = len(sizes) # Use menu size if it exists, otherwise first size found size = sizes[0] i = 0 while (i < n_sizes): if (sizes[i] == gtk.ICON_SIZE_MENU): size = gtk.ICON_SIZE_MENU break i += 1 info.small_icon = self.render_icon(info.stock_id, size) if (size != gtk.ICON_SIZE_MENU): # Make the result the proper size for our thumbnail w, h = gtk.icon_size_lookup(gtk.ICON_SIZE_MENU) scaled = info.small_icon.scale_simple(w, h, 'bilinear') info.small_icon = scaled if info.stock_item[3] == 0: info.accel_str = "" else: info.accel_str = \ gtk.accelerator_name(info.stock_item[3], info.stock_item[2]) iter = store.append() store.set(iter, 0, info, 1, info.stock_id) return store
def set_label(self, key=None, mods=None): if self.label: if key != None and mods != None: self.emit("current-changed", key, mods) gtk.Button.set_label(self, self.label) return if key == None and mods == None: key = self.key mods = self.mods label = gtk.accelerator_name(key, mods) if not len(label): label = _("Disabled") gtk.Button.set_label(self, label)
def save(self): """ Stores the keybindings that have been set to disk. """ # Collect keybindings for all registered actions action_to_keys = {} for action, bindings in self._action_to_bindings.iteritems(): if bindings is not None: action_to_keys[action] = [ gtk.accelerator_name(keyval, modifiers) for (keyval, modifiers) in bindings ] fp = file(constants.KEYBINDINGS_CONF_PATH, "w") json.dump(action_to_keys, fp, indent=2) fp.close()
def HandleGrabberChanged(grabber, key, mods, label, selector): new = gtk.accelerator_name(key, mods) mods = "" for mod in KeyModifier: if "%s_L" % mod in new: new = new.replace("%s_L" % mod, "<%s>" % mod) if "%s_R" % mod in new: new = new.replace("%s_R" % mod, "<%s>" % mod) if "<%s>" % mod in new: mods += "%s|" % mod mods.rstrip("|") label.set_text(self.GetLabelText(new)) selector.current = mods
def save(self): """ Stores the keybindings that have been set to disk. """ # Collect keybindings for all registered actions action_to_keys = {} for action, bindings in self._action_to_bindings.iteritems(): if bindings is not None: action_to_keys[action] = [ gtk.accelerator_name(keyval, modifiers) for (keyval, modifiers) in bindings ] fp = open(constants.KEYBINDINGS_CONF_PATH, "w") json.dump(action_to_keys, fp, indent=2) fp.close()
def button_press_name(button, mods): """Converts button number & modifier mask to a prefs-storable string. Analogous to `gtk.accelerator_name()`. Buttonpress names look similar to GDK accelerator names, for example ``<Control><Shift>Button2`` or ``<Primary><Alt>Button4`` for newer versions of GTK. If the button is equal to zero (see `button_press_parse()`), `None` is returned. """ button = int(button) mods = int(mods) if button <= 0: return None mods = gdk.ModifierType(mods) modif_name = gtk.accelerator_name(0, mods) return modif_name + "Button%d" % (button, )
def on_dialoggetkey_key_release_event(self, widget, event): if not self._press_time: return keyval, state = self.translate_keyboard_event(widget, event) self.update_accelerator_label(0, 0) if gtk.accelerator_valid(keyval, state): key = gtk.accelerator_name(keyval, state) if (self._previous_key is not None and key == self._previous_key): self._return(None) return if self._check_callback is None or self._check_callback(key): self._return(key) else: self.imagekeybindingaux.show() self.labelkeybindingaux.show()
def handle_keypress(self, xevent): # type: (XKeyPress) -> None """Dispatch C{XKeyPress} events to their callbacks.""" keysig = (xevent.detail, xevent.state) if keysig not in self._keys: logging.error( "Received an event for an unrecognized keybind: " "%s, %s", xevent.detail, xevent.state) return # Display a meaningful debug message # FIXME: Only call this code if --debug # FIXME: Proper "index" arg for keycode_to_keysym ksym = self.xdisp.keycode_to_keysym(keysig[0], 0) kbstr = gtk.accelerator_name(ksym, keysig[1]) # pylint: disable=E1101 logging.debug("Received keybind: %s", kbstr) # Call the associated callback self._keys[keysig]()