def on_key_press_event (self, widget, event): mods = event.state & gtk.accelerator_get_default_mod_mask () if event.keyval in (gtk.keysyms.Escape, gtk.keysyms.Return) \ and not mods: if event.keyval == gtk.keysyms.Escape: self.emit ("changed", self.key, self.mods) self.end_key_grab () self.set_label () return key = gtk.gdk.keyval_to_lower (event.keyval) if (key == gtk.keysyms.ISO_Left_Tab): key = gtk.keysyms.Tab if gtk.accelerator_valid (key, mods) \ or (key == gtk.keysyms.Tab and mods): self.set_label (key, mods) self.end_key_grab () self.key = key self.mods = mods self.emit ("changed", self.key, self.mods) return self.set_label (key, mods)
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 add_action_with_accel(self, action, accel): # print "add_action_with_accel" _keyval = None _mods = None _name = action.get_name() _path = "/".join(['<Actions>', self.name, _name]) if accel is None: # print "accel is None" _sid = action.get_property('stock-id') if _sid != '': # print "sid = '%s'" % _sid _data = gtk.stock_lookup(_sid) if _data is not None and _data[3] != 0: # print "data: " + str(_data) _mods = _data[2] _keyval = _data[3] else: _k, _m = gtk.accelerator_parse(accel) if gtk.accelerator_valid(_k, _m): _keyval = _k _mods = _m if _keyval is not None: # print "calling gtk.accel_map_change_entry()" # print "Path: " + _path # print "Key: " + str(_keyval) # print "Mods: " + str(_mods) if not gtk.accel_map_change_entry(_path, _keyval, _mods, True): print "Failed to change accel_map for '%s'" % _path action.set_accel_path(_path) self.add_action(action)
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_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 on_key_press_event(self, widget, event): mods = event.state & gtk.accelerator_get_default_mod_mask() if event.keyval in (gtk.keysyms.Escape, gtk.keysyms.Return) \ and not mods: if event.keyval == gtk.keysyms.Escape: self.emit("changed", self.key, self.mods) self.end_key_grab() self.set_label() return key = gtk.gdk.keyval_to_lower(event.keyval) if (key == gtk.keysyms.ISO_Left_Tab): key = gtk.keysyms.Tab if gtk.accelerator_valid (key, mods) \ or (key == gtk.keysyms.Tab and mods): self.set_label(key, mods) self.end_key_grab() self.key = key self.mods = mods self.emit("changed", self.key, self.mods) return self.set_label(key, mods)
def set_accelerator_name(self, value): if value == None: value = "" (keyval, mods) = gtk.accelerator_parse(value) if gtk.accelerator_valid(keyval, mods): self.entry.set_text(value) return
def getAccelerator(self, title): realAcc = guiConfig.getCompositeValue("gui_accelerators", title) if realAcc: key, mod = gtk.accelerator_parse(realAcc) if gtk.accelerator_valid(key, mod): return realAcc else: plugins.printWarning("Keyboard accelerator '" + realAcc + "' for action '" \ + title + "' is not valid, ignoring ...")
def __validate_accelerator(self, accelerator): if not accelerator: return False from Exceptions import DuplicateAcceleratorError if accelerator in self.__accelerators: raise DuplicateAcceleratorError from gtk import accelerator_parse, accelerator_valid keyval, modifier = accelerator_parse(accelerator) if accelerator_valid(keyval, modifier): return False from Exceptions import InvalidAcceleratorError raise InvalidAcceleratorError
def on_completion_config_dialog_key_release_event(widget, event): # We are listening for a new key if set_key_button.get_active(): state = event.state & gtk.accelerator_get_default_mod_mask() accelerator_mask = state.numerator # If e.g. only CTRL key is pressed. if not gtk.accelerator_valid(event.keyval, accelerator_mask): accelerator_mask = 0 self.auto_completer.accelerator_string = gtk.accelerator_name(event.keyval, accelerator_mask) self.accelerator_label.set_text(gtk.accelerator_get_label(event.keyval, accelerator_mask)) # Reset widgets set_key_button.set_active(False) set_widgets_sensitive(True)
def on_key(self, widget, event): self.keys = event.keyval, event.state if not gtk.accelerator_valid(event.keyval, event.state): self.__label.set_markup("<b>%s</b> - invalid accelerator!"%gtk.accelerator_get_label(event.keyval, event.state)) return action = self.accel_is_used(event.keyval, event.state) if action: self.__label.set_markup("<b>%s</b> - accelerator used by action:\n \"%s\"!"%(gtk.accelerator_get_label(event.keyval, event.state), action)) return self.__dialog.response(gtk.RESPONSE_APPLY)
def bind(self, accel, callback): """Bind a global key combination to a callback. @param accel: An accelerator as either a string to be parsed by C{gtk.accelerator_parse()} or a tuple as returned by it.) @param callback: The function to call when the key is pressed. @type accel: C{str} or C{(int, gtk.gdk.ModifierType)} or C{(int, int)} @type callback: C{function} @returns: A boolean indicating whether the provided keybinding was parsed successfully. (But not whether it was registered successfully due to the asynchronous nature of the C{XGrabKey} request.) @rtype: C{bool} """ if isinstance(accel, basestring): # pylint: disable=no-member keysym, modmask = gtk.accelerator_parse(accel) else: keysym, modmask = accel if not gtk.accelerator_valid(keysym, modmask): # pylint: disable=E1101 logging.error("Invalid keybinding: %s", accel) return False if modmask > 2**16 - 1: logging.error("Modifier out of range for XGrabKey " "(int(modmask) > 65535). " "Did you use <Super> instead of <Mod4>?") return False # Convert to what XGrabKey expects keycode = self.xdisp.keysym_to_keycode(keysym) if isinstance(modmask, gtk.gdk.ModifierType): modmask = modmask.real # Ignore modifiers like Mod2 (NumLock) and Lock (CapsLock) for mmask in self._vary_modmask(modmask, self.ignored_modifiers): self._keys.setdefault(keycode, []).append((mmask, callback)) self.xroot.grab_key(keycode, mmask, 1, X.GrabModeAsync, X.GrabModeAsync) # If we don't do this, then nothing works. # I assume it flushes the XGrabKey calls to the server. self.xdisp.sync() if self.keybind_failed: self.keybind_failed = False logging.warning("Failed to bind key. It may already be in use: %s", accel)
def bind(self, accel, callback): """Bind a global key combination to a callback. @param accel: An accelerator as either a string to be parsed by C{gtk.accelerator_parse()} or a tuple as returned by it.) @param callback: The function to call when the key is pressed. @type accel: C{str} or C{(int, gtk.gdk.ModifierType)} or C{(int, int)} @type callback: C{function} @returns: A boolean indicating whether the provided keybinding was parsed successfully. (But not whether it was registered successfully due to the asynchronous nature of the C{XGrabKey} request.) @rtype: C{bool} """ if isinstance(accel, basestring): keysym, modmask = gtk.accelerator_parse(accel) else: keysym, modmask = accel if not gtk.accelerator_valid(keysym, modmask): logging.error("Invalid keybinding: %s", accel) return False if modmask > 2**16 - 1: logging.error("Modifier out of range for XGrabKey " "(int(modmask) > 65535). " "Did you use <Super> instead of <Mod4>?") return False # Convert to what XGrabKey expects keycode = self.xdisp.keysym_to_keycode(keysym) if isinstance(modmask, gtk.gdk.ModifierType): modmask = modmask.real # Ignore modifiers like Mod2 (NumLock) and Lock (CapsLock) for mmask in self._vary_modmask(modmask, self.ignored_modifiers): self._keys.setdefault(keycode, []).append((mmask, callback)) self.xroot.grab_key(keycode, mmask, 1, X.GrabModeAsync, X.GrabModeAsync) # If we don't do this, then nothing works. # I assume it flushes the XGrabKey calls to the server. self.xdisp.sync() if self.keybind_failed: self.keybind_failed = False logging.warning("Failed to bind key. It may already be in use: %s", accel)
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 on_key(self, widget, event): self.keys = event.keyval, event.state if not gtk.accelerator_valid(event.keyval, event.state): self.__label.set_markup( "<b>%s</b> - invalid accelerator!" % gtk.accelerator_get_label(event.keyval, event.state)) return action = self.accel_is_used(event.keyval, event.state) if action: self.__label.set_markup( "<b>%s</b> - accelerator used by action:\n \"%s\"!" % (gtk.accelerator_get_label(event.keyval, event.state), action)) return self.__dialog.response(gtk.RESPONSE_APPLY)
def get_accelerators(self): substitutions = (('ctrl+', '<Ctrl>'), ('alt+', '<Alt>'), ('caps+', '<Shift>')) accelerators = {} if self.__layout.has_key('accelerators'): for layout_accel in self.__layout['accelerators']: # Attempt to sanitize TGCM/Win accelerators shortcut = layout_accel['key'] for orig, final in substitutions: shortcut = shortcut.replace(orig, final) # Check accelerator if it is valid action_id = layout_accel['action'] key, mod = gtk.accelerator_parse(shortcut) if gtk.accelerator_valid(key, mod): accelerators[action_id] = shortcut return accelerators
def on_key_press(self, widget, event): mods = event.state & gtk.accelerator_get_default_mod_mask() key = gtk.gdk.keyval_to_lower(event.keyval) if not mods and event.keyval == gtk.keysyms.Escape: self.mods = "" self.key = "" self.end_grab() return if not mods and event.keyval == gtk.keysyms.Return: self.end_grab() return if gtk.accelerator_valid(key, mods) \ or key == gtk.keysyms.Tab: # gtk won't allow to bind tab key self.update_label(key, mods)
def on_dialoggetkey_key_release_event(self, widget, event): if not self._press_time: return keyval, state = self.translate_keyboard_event(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 on_keypress( self, widget, event ): # modified from gnome deskbar-applet's DeskbarPreferencesUI.py if not self.editing: return keymap = gtk.gdk.keymap_get_default() translation = keymap.translate_keyboard_state(event.hardware_keycode, event.state, event.group) if translation == None: # FIXME: metacity can also handle raw keycodes with modifiers (but can compiz?) accel_name = "%#x" % event.hardware_keycode else: (keyval, egroup, level, consumed_modifiers) = translation upper = event.keyval accel_keyval = gtk.gdk.keyval_to_lower(upper) # Put shift back if it changed the case of the key, not otherwise. if upper != accel_keyval and (consumed_modifiers & gtk.gdk.SHIFT_MASK): consumed_modifiers &= ~(gtk.gdk.SHIFT_MASK) # filter consumed/ignored modifiers ignored_modifiers = gtk.gdk.MOD2_MASK | gtk.gdk.MOD5_MASK accel_mods = event.state & gtk.gdk.MODIFIER_MASK & ~( consumed_modifiers | ignored_modifiers) if accel_mods == 0 and accel_keyval == gtk.keysyms.Escape: self.abort_editing() return if accel_mods == 0 and accel_keyval == gtk.keysyms.BackSpace: self.set('disabled') return if not gtk.accelerator_valid(accel_keyval, accel_mods): return # just modifiers accel_name = gtk.accelerator_name(accel_keyval, accel_mods) #self.set_accelerator(accel_keyval, event.hardware_keycode, accel_mods) #self.__old_value = None #self.emit('accel-edited', accel_name, accel_keyval, accel_mods, event.hardware_keycode) self.set(accel_name)
def remove_real(self, accelerators, accels): if not accels: return parsed = gtk.accelerator_parse(accels[0]) if not gtk.accelerator_valid(*parsed): return named = gtk.accelerator_name(*parsed) if not named in accelerators: return if len(accels) == 1: del accelerators[named] else: self.remove_real(accelerators[named], accels[1:]) if not accelerators[named]: del accelerators[named]
def parse_accel(self, accel # type: str ): # type: (...) -> Tuple[Optional[int], Optional[int]] """Convert an accelerator string into the form XGrabKey needs.""" keysym, modmask = gtk.accelerator_parse(accel) # pylint: disable=E1101 if not gtk.accelerator_valid(keysym, modmask): # pylint: disable=E1101 logging.error("Invalid keybinding: %s", accel) return None, None if modmask > 2**16 - 1: logging.error("Modifier out of range for XGrabKey " "(int(modmask) > 65535). " "Did you use <Super> instead of <Mod4>?") return None, None # Convert to what XGrabKey expects keycode = self.xdisp.keysym_to_keycode(keysym) if isinstance(modmask, gtk.gdk.ModifierType): modmask = modmask.real return keycode, modmask
def init_snippet_data(self, node): if node == None: return self.override = node.attrib.get('override') self.properties = {} props = SnippetData.PROPS.copy() # Store all properties present for child in node: if child.tag in props: del props[child.tag] # Normalize accelerator if child.tag == 'accelerator' and child.text != None: keyval, mod = gtk.accelerator_parse(child.text) if gtk.accelerator_valid(keyval, mod): child.text = gtk.accelerator_name(keyval, mod) else: child.text = '' if self.can_modify(): self.properties[child.tag] = child else: self.properties[child.tag] = child.text or '' # Create all the props that were not found so we stay consistent for prop in props: if self.can_modify(): child = et.SubElement(node, prop) child.text = props[prop] self.properties[prop] = child else: self.properties[prop] = props[prop] self.check_validation()
def parse_accel( self, accel # type: str ): # type: (...) -> Tuple[Optional[int], Optional[int]] """Convert an accelerator string into the form XGrabKey needs.""" keysym, modmask = gtk.accelerator_parse(accel) # pylint: disable=E1101 if not gtk.accelerator_valid(keysym, modmask): # pylint: disable=E1101 logging.error("Invalid keybinding: %s", accel) return None, None if modmask > 2**16 - 1: logging.error("Modifier out of range for XGrabKey " "(int(modmask) > 65535). " "Did you use <Super> instead of <Mod4>?") return None, None # Convert to what XGrabKey expects keycode = self.xdisp.keysym_to_keycode(keysym) if isinstance(modmask, gtk.gdk.ModifierType): modmask = modmask.real return keycode, modmask
def on_keypress(self, widget, event): # modified from gnome deskbar-applet's DeskbarPreferencesUI.py if not self.editing: return keymap = gtk.gdk.keymap_get_default() translation = keymap.translate_keyboard_state(event.hardware_keycode, event.state, event.group) if translation == None: # FIXME: metacity can also handle raw keycodes with modifiers (but can compiz?) accel_name = "%#x"%event.hardware_keycode else: (keyval, egroup, level, consumed_modifiers) = translation upper = event.keyval accel_keyval = gtk.gdk.keyval_to_lower(upper) # Put shift back if it changed the case of the key, not otherwise. if upper != accel_keyval and (consumed_modifiers & gtk.gdk.SHIFT_MASK): consumed_modifiers &= ~(gtk.gdk.SHIFT_MASK) # filter consumed/ignored modifiers ignored_modifiers = gtk.gdk.MOD2_MASK | gtk.gdk.MOD5_MASK accel_mods = event.state & gtk.gdk.MODIFIER_MASK & ~(consumed_modifiers | ignored_modifiers) if accel_mods == 0 and accel_keyval == gtk.keysyms.Escape: self.abort_editing() return if accel_mods == 0 and accel_keyval == gtk.keysyms.BackSpace: self.set('disabled') return if not gtk.accelerator_valid(accel_keyval, accel_mods): return # just modifiers accel_name = gtk.accelerator_name(accel_keyval, accel_mods) #self.set_accelerator(accel_keyval, event.hardware_keycode, accel_mods) #self.__old_value = None #self.emit('accel-edited', accel_name, accel_keyval, accel_mods, event.hardware_keycode) self.set(accel_name)
def __on_key_press_event(self, entry, event): accel_mods = 0 edited = False keymap = gtk.gdk.keymap_get_default() translation = keymap.translate_keyboard_state(event.hardware_keycode, event.state, event.group) if translation == None: consumed_modifiers = 0 else: (keyval, egroup, level, consumed_modifiers) = translation accel_keyval = gtk.gdk.keyval_to_lower(event.keyval) if (accel_keyval == gtk.keysyms.ISO_Left_Tab): accel_keyval = gtk.keysyms.Tab accel_mods = event.state & gtk.accelerator_get_default_mod_mask() # Filter consumed modifiers accel_mods &= ~consumed_modifiers # Put shift back if it changed the case of the key, not otherwise. if (accel_keyval != event.keyval): accel_mods |= gtk.gdk.SHIFT_MASK if accel_mods == 0: if accel_keyval == gtk.keysyms.Escape: self.__revert() return True # Do not make keyboard unusable if (((accel_mods == 0 or accel_mods == gtk.gdk.SHIFT_MASK) and accel_keyval >= gtk.keysyms.a and accel_keyval <= gtk.keysyms.z) # alphabet or (accel_mods == 0 and ((accel_keyval >= 48 and accel_keyval <= 57) # number keys or (accel_keyval >= gtk.keysyms.kana_fullstop and accel_keyval <= gtk.keysyms.semivoicedsound) or (accel_keyval >= gtk.keysyms.Arabic_comma and accel_keyval <= gtk.keysyms.Arabic_sukun) or (accel_keyval >= gtk.keysyms.Serbian_dje and accel_keyval <= gtk.keysyms.Cyrillic_HARDSIGN) or (accel_keyval >= gtk.keysyms.Greek_ALPHAaccent and accel_keyval <= gtk.keysyms.Greek_omega) or (accel_keyval >= gtk.keysyms.hebrew_doublelowline and accel_keyval <= gtk.keysyms.hebrew_taf) or (accel_keyval >= gtk.keysyms.Thai_kokai and accel_keyval <= gtk.keysyms.Thai_lekkao) or (accel_keyval >= gtk.keysyms.Hangul and accel_keyval <= gtk.keysyms.Hangul_Special) or (accel_keyval >= gtk.keysyms.Hangul_Kiyeom and accel_keyval <= gtk.keysyms.Hangul_J_YeorinHieuh))) or (accel_mods == 0 and accel_keyval in self.FORBIDDEN_KEYS) or (accel_keyval == 0 and accel_mods != 0)): dialog = gtk.MessageDialog( self.entry.get_toplevel(), gtk.DIALOG_DESTROY_WITH_PARENT | gtk.DIALOG_MODAL, gtk.MESSAGE_WARNING, gtk.BUTTONS_CANCEL, _("The shortcut \"%s\" cannot be used because it will prevent correct operation of your keyboard.\nPlease try with a key such as Control, Alt or Shift at the same time.\n" ) % gtk.accelerator_name(accel_keyval, accel_mods)) dialog.run() dialog.destroy() self.__revert() return True if not gtk.accelerator_valid(accel_keyval, accel_mods): self.__revert() return True accel_name = self.__convert_keysym_state_to_string( accel_keyval, event.hardware_keycode, accel_mods) self.set_accelerator(accel_keyval, accel_mods, event.hardware_keycode) self.__old_value = None self.emit('accel-edited', accel_name, accel_keyval, accel_mods, event.hardware_keycode) return True
""" To make shortcuts work both AccelMap and AccelGroup have to know about them. """ import gtk key, mod = gtk.accelerator_parse("<ctrl>s") assert gtk.accelerator_valid(key, mod) PATH = "<MyApp-MainWindow>/Save" gtk.accel_map_add_entry(PATH, key, mod) group = gtk.AccelGroup() group.connect_by_path(PATH, gtk.main_quit) window = gtk.Window() assert not gtk.accel_groups_from_object(window) window.add_accel_group(group) window.show_all() gtk.main()
def __on_key_press_event(self, entry, event): accel_mods = 0 edited = False keymap = gtk.gdk.keymap_get_default() translation = keymap.translate_keyboard_state(event.hardware_keycode, event.state, event.group) if translation == None: consumed_modifiers = 0 else: (keyval, egroup, level, consumed_modifiers) = translation accel_keyval = gtk.gdk.keyval_to_lower(event.keyval) if (accel_keyval == gtk.keysyms.ISO_Left_Tab): accel_keyval = gtk.keysyms.Tab accel_mods = event.state & gtk.accelerator_get_default_mod_mask() # Filter consumed modifiers accel_mods &= ~consumed_modifiers # Put shift back if it changed the case of the key, not otherwise. if (accel_keyval != event.keyval): accel_mods |= gtk.gdk.SHIFT_MASK if accel_mods == 0: if accel_keyval == gtk.keysyms.Escape: self.__revert() return True # Do not make keyboard unusable if ( ((accel_mods == 0 or accel_mods == gtk.gdk.SHIFT_MASK) and accel_keyval >= gtk.keysyms.a and accel_keyval <= gtk.keysyms.z) # alphabet or (accel_mods == 0 and ( (accel_keyval >= 48 and accel_keyval <= 57) # number keys or (accel_keyval >= gtk.keysyms.kana_fullstop and accel_keyval <= gtk.keysyms.semivoicedsound) or (accel_keyval >= gtk.keysyms.Arabic_comma and accel_keyval <= gtk.keysyms.Arabic_sukun) or (accel_keyval >= gtk.keysyms.Serbian_dje and accel_keyval <= gtk.keysyms.Cyrillic_HARDSIGN) or (accel_keyval >= gtk.keysyms.Greek_ALPHAaccent and accel_keyval <= gtk.keysyms.Greek_omega) or (accel_keyval >= gtk.keysyms.hebrew_doublelowline and accel_keyval <= gtk.keysyms.hebrew_taf) or (accel_keyval >= gtk.keysyms.Thai_kokai and accel_keyval <= gtk.keysyms.Thai_lekkao) or (accel_keyval >= gtk.keysyms.Hangul and accel_keyval <= gtk.keysyms.Hangul_Special) or (accel_keyval >= gtk.keysyms.Hangul_Kiyeom and accel_keyval <= gtk.keysyms.Hangul_J_YeorinHieuh) )) or (accel_mods == 0 and accel_keyval in self.FORBIDDEN_KEYS) or (accel_keyval == 0 and accel_mods != 0) ): dialog = gtk.MessageDialog (self.entry.get_toplevel(), gtk.DIALOG_DESTROY_WITH_PARENT | gtk.DIALOG_MODAL, gtk.MESSAGE_WARNING, gtk.BUTTONS_CANCEL, _("The shortcut \"%s\" cannot be used because it will prevent correct operation of your keyboard.\nPlease try with a key such as Control, Alt or Shift at the same time.\n") % gtk.accelerator_name(accel_keyval, accel_mods) ) dialog.run() dialog.destroy() self.__revert() return True if not gtk.accelerator_valid(accel_keyval, accel_mods): self.__revert() return True accel_name = self.__convert_keysym_state_to_string(accel_keyval, event.hardware_keycode, accel_mods) self.set_accelerator(accel_keyval, accel_mods, event.hardware_keycode) self.__old_value = None self.emit('accel-edited', accel_name, accel_keyval, accel_mods, event.hardware_keycode) return True