def on_entry_key_press(self, widget, evnt):
state = evnt.state & gtk.accelerator_get_default_mod_mask()
text = self._entry.get_text()
if evnt.keyval == gtk.keysyms.Escape and self._info_window:
if self._suspended:
self._suspended.resume()
if self._info_window:
self._info_window.destroy()
self._entry.set_sensitive(True)
return True
if evnt.keyval == gtk.keysyms.Escape:
if text:
self._entry.set_text('')
elif self._command_state:
self._command_state.clear()
self.prompt()
else:
self._view.grab_focus()
self.destroy()
return True
for handler in self._handlers:
if (handler[0] == None or handler[0] == state) and evnt.keyval == handler[1] and handler[2](handler[3], state):
return True
if self._info_window and self._info_window.empty():
self._info_window.destroy()
self._history_prefix = None
return False
def handle_key_press_event(self, event):
"""Handle a key press event.
By default, escape and alt + up will make the popup popdown.
Return, KP_Enter, KP_Space and Tab will make it confirm.
Subclasses can override this to handle more options.
:param event: the gdk event
:returns: ``True`` if the event was handled, ``False`` otherwise
"""
keyval = event.keyval
state = event.state & gtk.accelerator_get_default_mod_mask()
if (keyval == gtk.keysyms.Escape or
(state == gtk.gdk.MOD1_MASK and
(keyval == gtk.keysyms.Up or keyval == gtk.keysyms.KP_Up))):
self.popdown()
return True
elif keyval in [gtk.keysyms.Return,
gtk.keysyms.KP_Enter,
gtk.keysyms.KP_Space,
gtk.keysyms.Tab]:
self.confirm()
return True
return False
def _bp_edit_box_button_press_cb(self, evbox, event, dialog, editable):
modifiers = event.state & gtk.accelerator_get_default_mod_mask()
bp_name = button_press_name(event.button, modifiers)
if modifiers == 0 and event.button == 1:
self._bp_edit_dialog_set_error(
dialog,
_("%s cannot be bound by itself, without keyboard modifiers.")
% (escape(bp_name), ))
dialog.ok_btn.set_sensitive(False)
return
action = None
if bp_name != dialog.bp_name_orig:
action = self.bindings.get(bp_name, None)
if action is not None:
action_label = self.action_labels.get(action, action)
self._bp_edit_dialog_set_error(
dialog,
_("%s is already bound to the action '%s'") %
(escape(str(bp_name)), escape(str(action_label))))
dialog.ok_btn.set_sensitive(False)
else:
self._bp_edit_dialog_set_standard_hint(dialog)
dialog.bp_name = bp_name
dialog.bp_label.set_text(str(bp_name))
dialog.ok_btn.set_sensitive(True)
dialog.ok_btn.grab_focus()
def __keyPressEvent(self, widget, event, data=None):
_key = event.keyval
_rv = (_key == gtk.keysyms.Left or
_key == gtk.keysyms.Right or
_key == gtk.keysyms.Up or
_key == gtk.keysyms.Down)
if _rv:
_mods = event.state & gtk.accelerator_get_default_mod_mask()
_dx = _dy = None
if (_key == gtk.keysyms.Left):
_dx = -1.0
elif (_key == gtk.keysyms.Right):
_dx = 1.0
elif (_key == gtk.keysyms.Up):
_dy = 1.0
elif (_key == gtk.keysyms.Down):
_dy = -1.0
else:
raise ValueError, "Unexpected keyval: %d" % _key
if (_mods == gtk.gdk.CONTROL_MASK):
_scale = 0.25
elif (_mods == gtk.gdk.SHIFT_MASK):
_scale = 0.5
elif (_mods == gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK):
_scale = 1.0
else:
_scale = 0.05
if not _rv:
_tool = gtkimage.getTool()
if _tool is not None and _tool.hasHandler('key_press'):
_rv = _tool.getHandler('key_press')(gtkimage, widget,
event, _tool)
return _rv
def reset(self):
window = self.boss.get_main_window()
if self.__accel is not None:
window.remove_accel_group(self.__accel)
self.__accel = gtk.AccelGroup()
self.__map = {}
window.add_accel_group(self.__accel)
for option in self.options:
vals = option.value().split()
if len(vals) == 2:
mods, key = vals
if len(key) > 1:
key = key[0]
mod = gtk.accelerator_get_default_mod_mask()
if 'M' in mods:
mod = mod & gtk.gdk.MOD1_MASK
if 'S' in mods:
mod = mod & gtk.gdk.SHIFT_MASK
if 'C' in mods:
mod = mod & gtk.gdk.CONTROL_MASK
keyval = ord(key)
self.__accel.connect_group(keyval, mod, gtk.ACCEL_VISIBLE,
self.cb_keypress)
self.__map[(keyval, mod)] = self.COMMANDMAP[option._name]
self.__namemap[option.value()] = self.COMMANDMAP[option._name]
def _on__key_press_event(self, window, event):
"""
Mimics Combobox behavior
Escape or Alt+Up: Close
Enter, Return or Space: Select
"""
keyval = event.keyval
state = event.state & gtk.accelerator_get_default_mod_mask()
if (keyval == keysyms.Escape or
((keyval == keysyms.Up or keyval == keysyms.KP_Up) and
state == gdk.MOD1_MASK)):
self.popdown()
return True
elif keyval == keysyms.Tab:
self.popdown()
# XXX: private member of comboentry
self._comboentry._button.grab_focus()
return True
elif (keyval == keysyms.Return or
keyval == keysyms.space or
keyval == keysyms.KP_Enter or
keyval == keysyms.KP_Space):
model, treeiter = self._selection.get_selected()
self.emit('text-selected', model[treeiter][0])
return True
return False
def _on_entry_text_key_press_event(self, widget, event):
"""
Listen to key events on the entry widget.
Arrow up/down will change the value of the entry according to the
current selection in the list.
Enter will show the popup.
Return True whenever we want no other event listeners to be called.
"""
keyval = event.keyval
state = event.state & gtk.accelerator_get_default_mod_mask()
# Select new row with arrow up/down is pressed
if key_is_up_or_down(keyval):
self.handle_list_scroll(next=key_is_down(keyval),
set_entry=True)
return True
elif self.auto_completer.is_auto_completion_accelerator(keyval, state):
if self.auto_completer.auto_complete_enabled:
self.auto_completer.do_completion()
return True
# Show popup when Enter is pressed
elif key_is_enter(keyval):
# This sets the toggle active which results in
# on_button_toggle_dropdown_toggled being called which initiates the popup
self.button_toggle.set_active(True)
return True
return False
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_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_stored_values_treeview_key_press_event(self, widget, event):
"""
Mimics Combobox behavior
Escape or Alt+Up: Close
Enter or Return : Select
"""
keyval = event.keyval
state = event.state & gtk.accelerator_get_default_mod_mask()
# Edit selected row
if (keyval in [keysyms.Left, keysyms.Right, keysyms.space]):
path = self.get_selection_path()
if path:
self.on_edit_path(path, self.tree_column)
return True
elif key_is_up_or_down(keyval):
# Swap the row value
if event.state & gtk.gdk.CONTROL_MASK:
self.handle_list_scroll(next=key_is_down(keyval),
swap=True)
else:
self.handle_list_scroll(next=key_is_down(keyval))
return True
return super(StoredValuesList, self).on_treeview_key_press_event(widget, event)
def on_completion_popup_window_key_press_event(self, entry, event):
"""
"""
keyval = event.keyval
state = event.state & gtk.accelerator_get_default_mod_mask()
if key_is_up_or_down(keyval):
self.completion_popup.handle_list_scroll(next=key_is_down(keyval))
return True
elif key_is_enter(keyval):
path = self.completion_popup.get_selection_path()
if path:
self.completion_popup.set_entry_value(path, popdown=True)
return True
if self.is_auto_completion_accelerator(keyval, state)\
and self.auto_complete_enabled:
cursor = self.completion_popup.treeview.get_cursor()
value = self.completion_popup.get_selected_value()
if value:
pos = len(self.path_entry.get_text())
self.path_entry.set_text(value, set_file_chooser_folder=False)
self.do_completion()
return True
self.path_entry.entry.emit("key-press-event", event)
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_accelerator_key_press(self, entry, event):
mask = event.state & gtk.accelerator_get_default_mod_mask()
if event.keyval == gtk.keysyms.Escape:
entry.set_text(default(self.current_node.shortcut, ''))
self['commands'].grab_focus()
return True
elif event.keyval == gtk.keysyms.Delete \
or event.keyval == gtk.keysyms.BackSpace:
entry.set_text('')
self.remove_accelerator(self.current_node)
self.current_node.shortcut = None
self['commands'].grab_focus()
return True
elif event.keyval in range(gtk.keysyms.F1, gtk.keysyms.F12 + 1):
# New accelerator
if self.set_accelerator(event.keyval, mask):
entry.set_text(default(self.current_node.shortcut, ''))
self['commands'].grab_focus()
# Capture all `normal characters`
return True
elif gtk.gdk.keyval_to_unicode(event.keyval):
if mask:
# New accelerator
if self.set_accelerator(event.keyval, mask):
entry.set_text(default(self.current_node.shortcut, ''))
self['commands'].grab_focus()
# Capture all `normal characters`
return True
else:
return False
def on_accelerator_key_press(self, entry, event):
mask = event.state & gtk.accelerator_get_default_mod_mask()
if event.keyval == gtk.keysyms.Escape:
entry.set_text(default(self.current_node.shortcut, ''))
self['commands'].grab_focus()
return True
elif event.keyval == gtk.keysyms.Delete \
or event.keyval == gtk.keysyms.BackSpace:
entry.set_text('')
self.remove_accelerator(self.current_node)
self.current_node.shortcut = None
self['commands'].grab_focus()
return True
elif event.keyval in range(gtk.keysyms.F1, gtk.keysyms.F12 + 1):
# New accelerator
if self.set_accelerator(event.keyval, mask):
entry.set_text(default(self.current_node.shortcut, ''))
self['commands'].grab_focus()
# Capture all `normal characters`
return True
elif gtk.gdk.keyval_to_unicode(event.keyval):
if mask:
# New accelerator
if self.set_accelerator(event.keyval, mask):
entry.set_text(default(self.current_node.shortcut, ''))
self['commands'].grab_focus()
# Capture all `normal characters`
return True
else:
return False
def on_entry_accelerator_key_press(self, entry, event):
source_view = self['source_view_snippet']
if event.keyval == gdk.keyval_from_name('Escape'):
# Reset
entry.set_text(self.snippet.accelerator_display())
self.tree_view.grab_focus()
return True
elif event.keyval == gdk.keyval_from_name('Delete') or \
event.keyval == gdk.keyval_from_name('BackSpace'):
# Remove the accelerator
entry.set_text('')
self.snippet['accelerator'] = ''
self.tree_view.grab_focus()
self.snippet_changed()
return True
elif Library().valid_accelerator(event.keyval, event.state):
# New accelerator
self.set_accelerator(event.keyval, \
event.state & gtk.accelerator_get_default_mod_mask())
entry.set_text(self.snippet.accelerator_display())
self.snippet_changed()
self.tree_view.grab_focus()
else:
return True
def _bp_edit_box_button_press_cb(self, evbox, event, dialog, editable):
modifiers = event.state & gtk.accelerator_get_default_mod_mask()
bp_name = button_press_name(event.button, modifiers)
if modifiers == 0 and event.button == 1:
self._bp_edit_dialog_set_error(
dialog,
_("%s cannot be bound by itself, without keyboard modifiers.")
% escape(bp_name)
)
dialog.ok_btn.set_sensitive(False)
return
action = None
if bp_name != dialog.bp_name_orig:
action = self.bindings.get(bp_name, None)
if action is not None:
action_label = self.action_labels.get(action, action)
self._bp_edit_dialog_set_error(
dialog,
_("%s is already bound to the action '%s'") % (
escape(str(bp_name)),
escape(str(action_label))
)
)
dialog.ok_btn.set_sensitive(False)
else:
self._bp_edit_dialog_set_standard_hint(dialog)
dialog.bp_name = bp_name
dialog.bp_label.set_text(str(bp_name))
dialog.ok_btn.set_sensitive(True)
dialog.ok_btn.grab_focus()
def __keyPressEvent(self, widget, event, data=None):
_key = event.keyval
_rv = (_key == gtk.keysyms.Left or _key == gtk.keysyms.Right
or _key == gtk.keysyms.Up or _key == gtk.keysyms.Down)
if _rv:
_mods = event.state & gtk.accelerator_get_default_mod_mask()
_dx = _dy = None
if (_key == gtk.keysyms.Left):
_dx = -1.0
elif (_key == gtk.keysyms.Right):
_dx = 1.0
elif (_key == gtk.keysyms.Up):
_dy = 1.0
elif (_key == gtk.keysyms.Down):
_dy = -1.0
else:
raise ValueError, "Unexpected keyval: %d" % _key
if (_mods == gtk.gdk.CONTROL_MASK):
_scale = 0.25
elif (_mods == gtk.gdk.SHIFT_MASK):
_scale = 0.5
elif (_mods == gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK):
_scale = 1.0
else:
_scale = 0.05
if not _rv:
_tool = gtkimage.getTool()
if _tool is not None and _tool.hasHandler('key_press'):
_rv = _tool.getHandler('key_press')(gtkimage, widget, event,
_tool)
return _rv
def set_tortoise_keys(window, connect=True):
'Set default TortoiseHg keyboard accelerators'
if sys.platform == 'darwin':
mask = gtk.accelerator_get_default_mod_mask()
mask |= gtk.gdk.MOD1_MASK;
gtk.accelerator_set_default_mod_mask(mask)
mod = get_thg_modifier()
accelgroup = gtk.AccelGroup()
window.add_accel_group(accelgroup)
default_accelerators = [
(mod+'w', 'thg-close'),
(mod+'q', 'thg-exit'),
('F5', 'thg-refresh'),
(mod+'r', 'thg-refresh'),
(mod+'Return', 'thg-accept'),
]
for accelerator, signal in default_accelerators:
add_accelerator(window, signal, accelgroup, accelerator)
# connect ctrl-w and ctrl-q to every window
if connect:
window.connect('thg-close', thgclose)
window.connect('thg-exit', thgexit)
return accelgroup, mod
def on_entry_accelerator_key_press(self, entry, event):
source_view = self['source_view_snippet']
if event.keyval == gdk.keyval_from_name('Escape'):
# Reset
entry.set_text(self.snippet.accelerator_display())
self.tree_view.grab_focus()
return True
elif event.keyval == gdk.keyval_from_name('Delete') or \
event.keyval == gdk.keyval_from_name('BackSpace'):
# Remove the accelerator
entry.set_text('')
self.snippet['accelerator'] = ''
self.tree_view.grab_focus()
self.snippet_changed()
return True
elif Library().valid_accelerator(event.keyval, event.state):
# New accelerator
self.set_accelerator(event.keyval, \
event.state & gtk.accelerator_get_default_mod_mask())
entry.set_text(self.snippet.accelerator_display())
self.snippet_changed()
self.tree_view.grab_focus()
else:
return True
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 _bp_edit_box_button_press_cb(self, evbox, event, dialog, editable):
modifiers = event.state & gtk.accelerator_get_default_mod_mask()
bp_name = button_press_name(event.button, modifiers)
bp_displayname = button_press_displayname(event.button, modifiers)
if modifiers == 0 and event.button == 1:
self._bp_edit_dialog_set_error(
dialog,
_("{button} cannot be bound without modifier keys "
"(its meaning is fixed, sorry)").format(
button=lib.xml.escape(bp_displayname), ),
)
dialog.ok_btn.set_sensitive(False)
return
action = None
if bp_name != dialog.bp_name_orig:
action = self.bindings.get(bp_name, None)
if action is not None:
action_label = self.action_labels.get(action, action)
self._bp_edit_dialog_set_error(
dialog,
_("{button_combination} is already bound "
"to the action '{action_name}'").format(
button_combination=lib.xml.escape(str(bp_displayname)),
action_name=lib.xml.escape(str(action_label)),
),
)
dialog.ok_btn.set_sensitive(False)
else:
self._bp_edit_dialog_set_standard_hint(dialog)
dialog.bp_name = bp_name
dialog.bp_label.set_text(str(bp_displayname))
dialog.ok_btn.set_sensitive(True)
dialog.ok_btn.grab_focus()
def _key_press_cb(self, widget, event):
"""App-wide keypress handler for toplevel windows."""
if not self.enabled:
return
# See gtk sourcecode in gtkmenu.c function gtk_menu_key_press,
# which uses the same code as below when changing an accelerator.
keymap = gtk2compat.gdk.keymap_get_default()
# Instead of using event.keyval, we do it the lowlevel way.
# Reason: ignoring CAPSLOCK and checking if SHIFT was pressed
state = event.state & ~gdk.LOCK_MASK
if gtk2compat.USE_GTK3:
state = gdk.ModifierType(state)
res = keymap.translate_keyboard_state(event.hardware_keycode, state,
event.group)
if not res:
# PyGTK returns None when gdk_keymap_translate_keyboard_state()
# returns false. Not sure if this is a bug or a feature - the only
# time I have seen this happen is when I put my laptop into sleep
# mode.
logger.warning('translate_keyboard_state() returned None. '
'Strange key pressed?')
return
keyval_offset = 1 if gtk2compat.USE_GTK3 else 0
keyval = res[keyval_offset]
consumed_modifiers = res[keyval_offset+3]
# We want to ignore irrelevant modifiers like ScrollLock. The stored
# key binding does not include modifiers that affected its keyval.
modifiers = (
event.state
& gtk.accelerator_get_default_mod_mask()
& ~consumed_modifiers
)
# Except that key bindings are always stored in lowercase.
keyval_lower = gdk.keyval_to_lower(keyval)
if keyval_lower != keyval:
modifiers |= gdk.SHIFT_MASK
action = self.keymap.get((keyval_lower, modifiers))
if not action:
# try hardcoded keys
action = self.keymap2.get((keyval_lower, modifiers))
# Don't dispatch if the window is only sensitive to a subset of
# actions, and the action is not in that set.
if action is not None and isinstance(action, gtk.Action):
win_actions = self.window_actions.get(widget, None)
if win_actions is not None:
if action.get_name() not in win_actions:
return False
# If the lookup succeeded, activate the corresponding action.
if action:
return self.activate_keydown_event(action, event)
# Otherwise, dispatch the event to the active doc.
return self._dispatch_fallthru_key_press_event(widget, event)
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_button_press_event(self, view, event):
state = event.state & gtk.accelerator_get_default_mod_mask()
if state == gtk.gdk.CONTROL_MASK and event.button == 2:
self.reset_font_size()
return True
else:
return False
def on_button_press_event(self, view, event):
state = event.state & gtk.accelerator_get_default_mod_mask()
if state == gtk.gdk.CONTROL_MASK and event.button == 2:
self.reset_font_size()
return True
else:
return False
def on_key_press_event(self, view, event):
defmod = gtk.accelerator_get_default_mod_mask() & event.state
for handler in self._event_handlers:
if (not handler[3] or self._in_mode) and event.keyval in handler[0] and (defmod == handler[1]):
return handler[2](event)
return False
def _key_press_cb(self, widget, event):
"""App-wide keypress handler for toplevel windows."""
if not self.enabled:
return
# See gtk sourcecode in gtkmenu.c function gtk_menu_key_press,
# which uses the same code as below when changing an accelerator.
keymap = gtk2compat.gdk.keymap_get_default()
# Instead of using event.keyval, we do it the lowlevel way.
# Reason: ignoring CAPSLOCK and checking if SHIFT was pressed
state = event.state & ~gdk.LOCK_MASK
if gtk2compat.USE_GTK3:
state = gdk.ModifierType(state)
res = keymap.translate_keyboard_state(event.hardware_keycode, state,
event.group)
if not res:
# PyGTK returns None when gdk_keymap_translate_keyboard_state()
# returns false. Not sure if this is a bug or a feature - the only
# time I have seen this happen is when I put my laptop into sleep
# mode.
logger.warning('translate_keyboard_state() returned None. '
'Strange key pressed?')
return
keyval_offset = 1 if gtk2compat.USE_GTK3 else 0
keyval = res[keyval_offset]
consumed_modifiers = res[keyval_offset + 3]
# We want to ignore irrelevant modifiers like ScrollLock. The stored
# key binding does not include modifiers that affected its keyval.
modifiers = (event.state
& gtk.accelerator_get_default_mod_mask()
& ~consumed_modifiers)
# Except that key bindings are always stored in lowercase.
keyval_lower = gdk.keyval_to_lower(keyval)
if keyval_lower != keyval:
modifiers |= gdk.SHIFT_MASK
action = self.keymap.get((keyval_lower, modifiers))
if not action:
# try hardcoded keys
action = self.keymap2.get((keyval_lower, modifiers))
# Don't dispatch if the window is only sensitive to a subset of
# actions, and the action is not in that set.
if action is not None and isinstance(action, gtk.Action):
win_actions = self.window_actions.get(widget, None)
if win_actions is not None:
if action.get_name() not in win_actions:
return False
# If the lookup succeeded, activate the corresponding action.
if action:
return self.activate_keydown_event(action, event)
# Otherwise, dispatch the event to the active doc.
return self._dispatch_fallthru_key_press_event(widget, event)
def on_vte_key_press(self, term, event):
modifiers = event.state & gtk.accelerator_get_default_mod_mask()
if event.keyval == gtk.keysyms.F6:
if modifiers == gtk.gdk.SHIFT_MASK:
self.get_toplevel().child_focus(gtk.DIR_TAB_BACKWARD)
else:
self.get_toplevel().child_focus(gtk.DIR_TAB_FORWARD)
return True
return False
def on_scroll_event(self, widget, event):
"""
Handles scroll events from the treeview
"""
state = event.state & gtk.accelerator_get_default_mod_mask()
self.handle_list_scroll(next=event.direction == gdk.SCROLL_DOWN,
set_entry=widget != self.treeview)
return True
def on_key_press_event(self, view, event):
defmod = gtk.accelerator_get_default_mod_mask() & event.state
for handler in self._event_handlers:
if (not handler[3] or self._in_mode
) and event.keyval in handler[0] and (defmod == handler[1]):
return handler[2](event)
return False
def _on_entry_key_press_event(self, entry, event):
if (event.state & gtk.accelerator_get_default_mod_mask()) == gtk.gdk.CONTROL_MASK:
key_name = gtk.gdk.keyval_name(gtk.gdk.keyval_to_lower(event.keyval))
if key_name == "z":
self.undo()
return True
elif key_name == "y":
self.redo()
return True
def process_key_press(self, event, mode):
modifiers = gtk.accelerator_get_default_mod_mask()
shift = event.state & modifiers == gtk.gdk.SHIFT_MASK
handled = True
clear_attrs = True
if not self.editing:
return False
if (event.state & modifiers) & gtk.gdk.CONTROL_MASK:
if event.keyval == gtk.keysyms.a:
self.index = self.bindex = 0
self.end_index = len(self.text)
elif event.keyval == gtk.keysyms.Escape:
self.leave()
elif event.keyval == gtk.keysyms.Left:
if prefs.get_direction() == gtk.TEXT_DIR_LTR:
self.move_index_back(shift)
else:
self.move_index_forward(shift)
elif event.keyval == gtk.keysyms.Right:
if prefs.get_direction() == gtk.TEXT_DIR_RTL:
self.move_index_back(shift)
else:
self.move_index_forward(shift)
elif event.keyval == gtk.keysyms.Up:
self.move_index_up(shift)
elif event.keyval == gtk.keysyms.Down:
self.move_index_down(shift)
elif event.keyval == gtk.keysyms.Home:
if prefs.get_direction() == gtk.TEXT_DIR_LTR:
self.move_index_horizontal(shift, True) # move home
else:
self.move_index_horizontal(shift) # move end
self.move_index_horizontal(shift, True) # move home
elif event.keyval == gtk.keysyms.End:
self.move_index_horizontal(shift) # move
elif event.keyval == gtk.keysyms.BackSpace and self.editing:
self.backspace_char()
elif event.keyval == gtk.keysyms.Delete and self.editing:
self.delete_char()
elif len(event.string) != 0:
self.add_text(event.string)
clear_attrs = False
else:
handled = False
if clear_attrs:
del self.current_attrs
self.current_attrs = []
self.recalc_edges()
self.selection_changed()
self.emit("title_changed", self.text)
self.bindex = self.bindex_from_index(self.index)
self.emit("update_view")
return handled
def window_key_press_event(self, window, event, stack, model):
key = gtk.gdk.keyval_name(event.keyval)
state = event.state & gtk.accelerator_get_default_mod_mask()
if key == 'Control_L':
self._ctrl_l = True
if key == 'Control_R':
self._ctrl_r = True
if key in self.META_KEYS or not state & gtk.gdk.CONTROL_MASK:
return False
is_ctrl = state == gtk.gdk.CONTROL_MASK
is_ctrl_shift = state == gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK
is_tab_key = key in ('ISO_Left_Tab', 'Tab')
is_page_key = key in ('Page_Up', 'Page_Down')
is_up_dir = key in ('ISO_Left_Tab', 'Page_Up')
if not (((is_ctrl or is_ctrl_shift) and is_tab_key) or
(is_ctrl and is_page_key)):
self.end_switching()
return False
cur = window.get_active_tab()
if is_tab_key:
tabs = stack
else:
tabs = cur.parent.get_children()
tlen = len(tabs)
if cur and tlen > 1 and cur in tabs:
if is_up_dir:
i = -1
else:
i = 1
next = tabs[(tabs.index(cur) + i) % tlen]
model[stack.index(cur)][self.SELECTED_TAB_COLUMN] = False
model[stack.index(next)][self.SELECTED_TAB_COLUMN] = True
if is_tab_key:
view = self._view
tabwin = view.get_toplevel()
w, h = view.size_request()
tabwin.set_size_request(-1, min(h, self.MAX_TAB_WINDOW_HEIGHT))
tabwin.present()
self._tabbing = True
else:
self._paging = True
window.set_active_tab(next)
return True
def on_scroll_event(self, widget, event):
"""
Handles scroll events from text entry, toggle button and treeview
"""
state = event.state & gtk.accelerator_get_default_mod_mask()
swap = event.state & gtk.gdk.CONTROL_MASK
self.handle_list_scroll(next=event.direction == gdk.SCROLL_DOWN,
set_entry=widget != self.treeview, swap=swap)
return True
def on_vte_key_press(self, term, event):
modifiers = event.state & gtk.accelerator_get_default_mod_mask()
if event.keyval in (gtk.keysyms.Tab, gtk.keysyms.KP_Tab, gtk.keysyms.ISO_Left_Tab):
if modifiers == gtk.gdk.CONTROL_MASK:
self.get_toplevel().child_focus(gtk.DIR_TAB_FORWARD)
return True
elif modifiers == gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK:
self.get_toplevel().child_focus(gtk.DIR_TAB_BACKWARD)
return True
return False
def translate_keyboard_event(self, event): keymap = gtk.gdk.keymap_get_default() # translate keys properly keyval, egroup, level, consumed = keymap.translate_keyboard_state( event.hardware_keycode, event.state, event.group) modifiers = gtk.accelerator_get_default_mod_mask() & ~consumed state = event.state & modifiers return keyval, state
def on_vte_key_press(self, term, event):
modifiers = event.state & gtk.accelerator_get_default_mod_mask()
if event.keyval in (gtk.keysyms.Tab, gtk.keysyms.KP_Tab, gtk.keysyms.ISO_Left_Tab):
if modifiers == gtk.gdk.CONTROL_MASK:
self.get_toplevel().child_focus(gtk.DIR_TAB_FORWARD)
return True
elif modifiers == gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK:
self.get_toplevel().child_focus(gtk.DIR_TAB_BACKWARD)
return True
return False
def translate_keyboard_event(self, widget, event): keymap = gtk.gdk.keymap_get_for_display(widget.get_display()) # translate keys properly keyval, egroup, level, consumed = keymap.translate_keyboard_state( event.hardware_keycode, event.state, event.group) modifiers = gtk.accelerator_get_default_mod_mask() & ~consumed state = event.state & modifiers return keyval, state
def window_key_press_event(self, window, event, stack, model):
key = gtk.gdk.keyval_name(event.keyval)
state = event.state & gtk.accelerator_get_default_mod_mask()
if key == 'Control_L':
self._ctrl_l = True
if key == 'Control_R':
self._ctrl_r = True
if key in self.META_KEYS or not state & gtk.gdk.CONTROL_MASK:
return False
is_ctrl = state == gtk.gdk.CONTROL_MASK
is_ctrl_shift = state == gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK
is_tab_key = key in ('ISO_Left_Tab', 'Tab')
is_page_key = key in ('Page_Up', 'Page_Down')
is_up_dir = key in ('ISO_Left_Tab', 'Page_Up')
if not (((is_ctrl or is_ctrl_shift) and is_tab_key) or (is_ctrl and is_page_key)):
self.end_switching()
return False
cur = window.get_active_tab()
if is_tab_key:
tabs = stack
else:
tabs = cur.parent.get_children()
tlen = len(tabs)
if cur and tlen > 1 and cur in tabs:
if is_up_dir:
i = -1
else:
i = 1
next = tabs[(tabs.index(cur) + i) % tlen]
model[stack.index(cur)][self.SELECTED_TAB_COLUMN] = False
model[stack.index(next)][self.SELECTED_TAB_COLUMN] = True
if is_tab_key:
view = self._view
tabwin = view.get_toplevel()
w, h = view.size_request()
tabwin.set_size_request(-1, min(h, self.MAX_TAB_WINDOW_HEIGHT))
tabwin.present()
self._tabbing = True
else:
self._paging = True
window.set_active_tab(next)
return True
def process_button_down (self, event, mode, transformed):
modifiers = gtk.accelerator_get_default_mod_mask ()
self.button_down = True
if event.button == 1:
if event.type == gtk.gdk.BUTTON_PRESS:
self.emit ("select_link", event.state & modifiers)
self.emit ("update_view")
elif event.button == 3:
self.emit ("popup_requested", event, 2)
self.emit ("update_view")
return False
def on_trigger_entry_key_press(self, entry, event):
if event.keyval in (gtk.keysyms.Delete, gtk.keysyms.BackSpace):
entry.set_text('')
self.set_trigger(DEFAULT_TRIGGER)
elif self.is_valid_trigger(event.keyval, event.state):
modifiers = event.state & gtk.accelerator_get_default_mod_mask()
self.set_trigger((event.keyval, modifiers))
entry.set_text(self.get_trigger_display_text())
elif event.keyval == gtk.keysyms.Tab:
return False
return True
def process_button_down (self, event, mode, transformed):
modifiers = gtk.accelerator_get_default_mod_mask ()
if event.type == gtk.gdk.BUTTON_PRESS and not self.editing:
self.emit ("select_thought", event.state & modifiers)
if event.button == 1 and mode == BaseThought.MODE_TEXT and event.type == gtk.gdk._2BUTTON_PRESS:
if self.uri.find("http://") == -1:
webbrowser.open("http://" + self.uri)
else:
webbrowser.open(self.uri)
elif event.button == 3:
self.emit ("popup_requested", event, 1)
def _on_entry_key_press(self, entry, event):
if (event.state & gtk.accelerator_get_default_mod_mask()
) == gtk.gdk.CONTROL_MASK:
key_name = gtk.gdk.keyval_name(
gtk.gdk.keyval_to_lower(event.keyval))
if key_name == "z":
self.undo()
return True
elif key_name == "y":
self.redo()
return True
def on_trigger_entry_key_press(self, entry, event):
if event.keyval in (gtk.keysyms.Delete, gtk.keysyms.BackSpace):
entry.set_text('')
self.set_trigger(DEFAULT_TRIGGER)
elif self.is_valid_trigger(event.keyval, event.state):
modifiers = event.state & gtk.accelerator_get_default_mod_mask()
self.set_trigger((event.keyval, modifiers))
entry.set_text(self.get_trigger_display_text())
elif event.keyval == gtk.keysyms.Tab:
return False
return True
def on_completion_treeview_key_press_event(self, widget, event):
"""
"""
keyval = event.keyval
state = event.state & gtk.accelerator_get_default_mod_mask()
if key_is_up_or_down(keyval):
self.handle_list_scroll(next=key_is_down(keyval))
return True
return super(CompletionList, self).on_treeview_key_press_event(widget, event)
def process_button_down(self, event, transformed):
modifiers = gtk.accelerator_get_default_mod_mask()
self.button_down = True
if event.button == 1:
if event.type == gtk.gdk.BUTTON_PRESS:
self.emit("select_link", event.state & modifiers)
self.emit("update_view")
elif event.button == 3:
self.emit("popup_requested", event, 2)
self.emit("update_view")
return False
def is_valid_trigger(self, keyval, mod):
mod &= gtk.accelerator_get_default_mod_mask()
if keyval == gtk.keysyms.Escape:
return True
if mod and gtk.gdk.keyval_to_unicode(keyval):
return True
valid_keysyms = [
gtk.keysyms.Return, gtk.keysyms.Tab, gtk.keysyms.Left,
gtk.keysyms.Right, gtk.keysyms.Up, gtk.keysyms.Down
]
valid_keysyms.extend(range(gtk.keysyms.F1, gtk.keysyms.F12 + 1))
return mod and keyval in valid_keysyms
def current_modifiers(self):
"""Returns the current set of modifier keys as a Gdk bitmask.
For use in handlers for keypress events when the key in question is
itself a modifier, handlers of multiple types of event, and when the
triggering event isn't available. Pointer button event handling should
use ``event.state & gtk.accelerator_get_default_mod_mask()``.
"""
display = gdk.Display.get_default()
screen, x, y, modifiers = display.get_pointer()
modifiers &= gtk.accelerator_get_default_mod_mask()
return modifiers
def _on_entry__key_press_event(self, entry, event):
"""
Mimics Combobox behavior
Alt+Down: Open popup
"""
keyval, state = event.keyval, event.state
state &= gtk.accelerator_get_default_mod_mask()
if ((keyval == keysyms.Down or keyval == keysyms.KP_Down) and
state == gdk.MOD1_MASK):
self.popup()
return True
def __handleKeyPress(widget, event):
modifiers = gtk.accelerator_get_default_mod_mask()
# copy
if event.keyval == gtk.gdk.keyval_from_name("c"):
if (modifiers & event.state) == gtk.gdk.CONTROL_MASK:
clipboard.copyToClipboard(rightview)
# paste
if event.keyval == gtk.gdk.keyval_from_name("v"):
if (modifiers & event.state) == gtk.gdk.CONTROL_MASK:
clipboard.pasteClipboard(rightview)
# cut
if event.keyval == gtk.gdk.keyval_from_name("x"):
if (modifiers & event.state) == gtk.gdk.CONTROL_MASK:
clipboard.cutToClipboard(rightview)
def on_scroll_event(self, view, event):
state = event.state & gtk.accelerator_get_default_mod_mask()
if state != gtk.gdk.CONTROL_MASK:
return False
if event.direction == gtk.gdk.SCROLL_UP:
self.increase_font_size()
return True
elif event.direction == gtk.gdk.SCROLL_DOWN:
self.decrease_font_size()
return True
return False
def process_button_down(self, event, mode, transformed):
modifiers = gtk.accelerator_get_default_mod_mask()
self.button_down = True
if event.button == 1:
if event.type == gtk.gdk.BUTTON_PRESS:
self.emit("select_thought", event.state & modifiers)
self.emit("update_view")
if mode == MODE_EDITING and self.resizing != self.RESIZE_NONE:
self.orig_size = (self.ul, self.width, self.height)
self.want_move = True
return True
elif event.button == 3:
self.emit("popup_requested", event, 1)
self.emit("update_view")
def _key_pressed(self, widget, event):
modifiers = gtk.accelerator_get_default_mod_mask()
mapping = {
gtk.gdk.KEY_r: self._reload_tab,
gtk.gdk.KEY_w: self._close_current_tab,
gtk.gdk.KEY_t: self._open_new_tab,
gtk.gdk.KEY_l: self._focus_url_bar,
gtk.gdk.KEY_f: self._raise_find_dialog,
gtk.gdk.KEY_q: gtk.main_quit
}
if event.state & modifiers == gdk.ModifierType.CONTROL_MASK \
and event.keyval in mapping:
mapping[event.keyval]()
def trigger_accelerator(self, keyval, modifier):
"""Manually trigger accelerator"""
result = False
modifier = modifier & gtk.accelerator_get_default_mod_mask(
) # filter out unneeded mods
label = gtk.accelerator_get_label(keyval, modifier)
# trigger accelerator only if we have method connected
if label in self._method_names:
result = self._handle_activate(self._accel_group, self._window,
keyval, modifier)
return result
def on_key_press_event(self, view, event):
# Only take care of backspace and shift+backspace
mods = gtk.accelerator_get_default_mod_mask()
if event.keyval != gtk.keysyms.BackSpace or \
event.state & mods != 0 and event.state & mods != gtk.gdk.SHIFT_MASK:
return False
doc = view.get_buffer()
if doc.get_has_selection():
return False
cur = doc.get_iter_at_mark(doc.get_insert())
offset = cur.get_line_offset()
if offset == 0:
# We're at the begining of the line, so we can't obviously
# unindent in this case
return False
start = cur.copy()
prev = cur.copy()
prev.backward_char()
# If the previus chars are spaces, try to remove
# them until the previus tab stop
max_move = offset % view.get_tab_width()
if max_move == 0:
max_move = view.get_tab_width()
moved = 0
while moved < max_move and prev.get_char() == ' ':
start.backward_char()
moved += 1
if not prev.backward_char():
# we reached the start of the buffer
break
if moved == 0:
# The iterator hasn't moved, it was not a space
return False
# Actually delete the spaces
doc.begin_user_action()
doc.delete(start, cur)
doc.end_user_action()
return True
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)
