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