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 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 __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 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_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 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