def on_accelerator_key_press(self, entry, event): mask = event.state & Gtk.accelerator_get_default_mod_mask() if event.keyval == Gdk.KEY_Escape: entry.set_text(default(self.current_node.shortcut, "")) self["commands"].grab_focus() return True elif event.keyval == Gdk.KEY_Delete or event.keyval == Gdk.KEY_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(Gdk.KEY_F1, Gdk.KEY_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 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 == Gdk.KEY_Escape: self.update_accelerator_label() self['commands'].grab_focus() return True elif event.keyval in range(Gdk.KEY_F1, Gdk.KEY_F12 + 1): # New accelerator if self.set_accelerator(event.keyval, mask): self.update_accelerator_label() self['commands'].grab_focus() # Capture all `normal characters` return True elif Gdk.keyval_to_unicode(event.keyval): if mask: # New accelerator if self.set_accelerator(event.keyval, mask): self.update_accelerator_label() self['commands'].grab_focus() # Capture all `normal characters` return True else: return False
def on_key_press(self, term, event): modifiers = event.state & Gtk.accelerator_get_default_mod_mask() if event.keyval in (Gdk.KEY_X, Gdk.KEY_x): if modifiers == Gdk.ModifierType.CONTROL_MASK: self.on_cut_line_key_press(self); return False
def handle_keys(widget, event): print event modifiers = Gtk.accelerator_get_default_mod_mask() for mod in dir(Gdk.ModifierType): # just printing what the modifier is if (event.state & modifiers) == getattr(Gdk.ModifierType, mod): print (mod) print Gdk.keyval_name(event.keyval)
def _on_key_press(self, widget, event): modifiers = Gtk.accelerator_get_default_mod_mask() if (event.keyval == Gdk.KEY_f and (event.state & modifiers) == Gdk.ModifierType.CONTROL_MASK): self._show_searchbar(not self.toolbar.searchbar.get_child_revealed()) elif (event.keyval == Gdk.KEY_Escape and (event.state & modifiers) == 0): self._show_searchbar(False)
def __key_press_event_cb(self, view, event): buf = view.get_buffer() state = event.state & Gtk.accelerator_get_default_mod_mask() ctrl = state & Gdk.ModifierType.CONTROL_MASK if event.keyval == Gdk.KEY_Return: buf.process_command_line() return True if event.keyval in (Gdk.KEY_KP_Down, Gdk.KEY_Down): buf.history.down(buf.get_command_line()) return True if event.keyval in (Gdk.KEY_KP_Up, Gdk.KEY_Up): buf.history.up(buf.get_command_line()) return True if event.keyval in (Gdk.KEY_KP_Left, Gdk.KEY_Left, Gdk.KEY_BackSpace): return buf.is_cursor(at=True) if event.keyval in (Gdk.KEY_KP_Home, Gdk.KEY_Home): buf.place_cursor(buf.get_iter_at_mark(buf.prompt_mark)) return True if (ctrl and event.keyval == Gdk.KEY_d) or event.keyval == Gdk.KEY_Escape: return self.emit("eof") return False
def get_modifiers(self, state): modifiers = Gtk.accelerator_get_default_mod_mask() ctrl_on = (state & modifiers) == Gdk.ModifierType.CONTROL_MASK shift_on = (state & modifiers) == Gdk.ModifierType.SHIFT_MASK alt_on = (state & modifiers) == Gdk.ModifierType.MOD1_MASK caps_on = (state & modifiers) == Gdk.ModifierType.LOCK_MASK return (ctrl_on, shift_on, alt_on, caps_on)
def on_key_press_event(self, view, event): #Bail out if text is selected doc = view.get_buffer() if doc.get_has_selection(): return False # If we're at the begining of the line, # then, we don't have a need for anything special cur = doc.get_iter_at_mark(doc.get_insert()) offset = cur.get_line_offset() if offset == 0: return False #Collect some state helpers mods = Gtk.accelerator_get_default_mod_mask() shift_pressed = event.state & Gdk.ModifierType.SHIFT_MASK != 0 if event.keyval == Gdk.KEY_Return and event.state & mods == 0: return self.HandleReturn(doc, cur) if event.keyval == Gdk.KEY_Tab and not(shift_pressed): return self.HandleTab(doc, cur) if shift_pressed and event.keyval == Gdk.KEY_ISO_Left_Tab: return self.HandleShiftTab(doc, cur) # if event.keyval == Gdk.KEY_BackSpace: # return self.HandleBackSpace(doc, cur) return False # We didn't handle this event, pass it on
def on_vte_key_press(self, term, event): modifiers = event.state & Gtk.accelerator_get_default_mod_mask() if event.keyval in (Gdk.KEY_Tab, Gdk.KEY_KP_Tab, Gdk.KEY_ISO_Left_Tab): if modifiers == Gdk.ModifierType.CONTROL_MASK: self.get_toplevel().child_focus(Gtk.DirectionType.TAB_FORWARD) return True elif modifiers == Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK: self.get_toplevel().child_focus(Gtk.DirectionType.TAB_BACKWARD) return True for name in self._accels: path = self._accel_base + '/' + name entry = Gtk.AccelMap.lookup_entry(path) if entry and entry[0] and entry[1].accel_key == event.keyval and entry[1].accel_mods == modifiers: self._accels[name][2]() return True keyval_name = Gdk.keyval_name(Gdk.keyval_to_upper(event.keyval)) # Special case some Vte.Terminal shortcuts # so the global shortcuts do not override them if modifiers == Gdk.ModifierType.CONTROL_MASK and keyval_name in 'ACDEHKLRTUWZ': return False if modifiers == Gdk.ModifierType.MOD1_MASK and keyval_name in 'BF': return False return Gtk.accel_groups_activate(self.get_toplevel(), event.keyval, modifiers)
def _on_key_press(self, widget, event): modifiers = Gtk.accelerator_get_default_mod_mask() event_and_modifiers = (event.state & modifiers) if event_and_modifiers != 0: # Open search bar on Ctrl + F if (event.keyval == Gdk.KEY_f and event_and_modifiers == Gdk.ModifierType.CONTROL_MASK): self.toolbar.searchbar.toggle_bar() # Go back from Album view on Alt + Left if (event.keyval == Gdk.KEY_Left and event_and_modifiers == Gdk.ModifierType.MOD1_MASK): if (self.toolbar._state != ToolbarState.MAIN): self.curr_view.set_visible_child(self.curr_view._grid) self.toolbar.set_state(ToolbarState.MAIN) else: # Close search bar after Esc is pressed if event.keyval == Gdk.KEY_Escape: self.toolbar.searchbar.show_bar(False) # Also disable selection if self.toolbar._selectionMode: self.toolbar.set_selection_mode(False) # Open search bar when typing printable chars if it not opened # Make sure we skip unprintable chars and don't grab space press # (this is used for play/pause) if not self.toolbar.searchbar.get_reveal_child() and not event.keyval == Gdk.KEY_space: if (event_and_modifiers == Gdk.ModifierType.SHIFT_MASK or event_and_modifiers == 0) and \ GLib.unichar_isprint(chr(Gdk.keyval_to_unicode(event.keyval))): self.toolbar.searchbar.show_bar(True) else: if not self.toolbar.searchbar.get_reveal_child(): if event.keyval == Gdk.KEY_space and self.player.actionbar.get_visible(): self.player.play_pause()
def _on_key_press(self, view, event): """ Delegate key presses to sub-handlers """ sub_handlers = [ (config.MARK_TOGGLE, self._do_mark_toggle, ()), (config.MARK_UP, self._do_mark_vert, (True, False)), (config.MARK_DOWN, self._do_mark_vert, (False, False)), (config.MARK_ALT_UP, self._do_mark_vert, (True, True)), (config.MARK_ALT_DOWN, self._do_mark_vert, (False, True)), ] # Only valid if in imitation mode if self._marks: sub_handlers += [ (config.CLEAR_MARKS, self._do_clear_marks, ()), (config.BACKSPACE, self._do_delete, (-1,)), (config.DELETE, self._do_delete, (1,)), (config.INCR_NUM, self._do_increment, (0,)), (config.INCR_NUM1, self._do_increment, (1,)), (config.INCR_LOWER, self._do_increment, ('a',)), (config.INCR_UPPER, self._do_increment, ('A',)), ] # Find and call sub-handler keyval = Gdk.keyval_to_lower(event.keyval) # Accels always lowercase state = Gtk.accelerator_get_default_mod_mask() & event.state for accelerator, handler, args in sub_handlers: if keyval == accelerator[0] and state == accelerator[1]: handler(*args) return True 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 on_key_press_event(self, view, event): mods = Gtk.accelerator_get_default_mod_mask() # if tab or shift+tab: # with shift+tab key is GDK_ISO_Left_Tab (yay! on win32 and mac too!) if ((event.keyval == Gdk.KEY_Tab or event.keyval == Gdk.KEY_KP_Tab or event.keyval == Gdk.KEY_ISO_Left_Tab) and ((event.state & mods) == 0 or (event.state & mods) == Gdk.ModifierType.SHIFT_MASK)): if ((event.state & mods) == Gdk.ModifierType.SHIFT_MASK): doc = view.get_buffer() if doc.get_has_selection(): start_iter, end_iter = doc.get_selection_bounds() start_line_nb = start_iter.get_line() end_line_nb = end_iter.get_line() doc.begin_user_action() for i in xrange(start_line_nb, end_line_nb + 1): self.reverseTab(doc, i) doc.end_user_action() else: doc.begin_user_action() cursorLineNr = doc.get_iter_at_mark(doc.get_insert()).get_line() self.reverseTab(doc, cursorLineNr) doc.end_user_action() return True return False
def __on_key_press(self, widget, event=None): grid = System.properties.grid modifier_mask = Gtk.accelerator_get_default_mod_mask() event.state = event.state & modifier_mask if event.state == Gdk.ModifierType.CONTROL_MASK: if event.keyval == Gdk.KEY_Up: self.move_selected_blocks(0, -grid*5) return True if event.keyval == Gdk.KEY_Down: self.move_selected_blocks(0, grid*5) return True if event.keyval == Gdk.KEY_Left: self.move_selected_blocks(-grid*5, 0) return True if event.keyval == Gdk.KEY_Right: self.move_selected_blocks(grid*5, 0) return True if event.keyval == Gdk.KEY_Delete: self.delete() return True if event.keyval == Gdk.KEY_Up: self.move_selected_blocks(0, -grid) return True if event.keyval == Gdk.KEY_Down: self.move_selected_blocks(0, grid) return True if event.keyval == Gdk.KEY_Left: self.move_selected_blocks(-grid, 0) return True if event.keyval == Gdk.KEY_Right: self.move_selected_blocks(grid, 0) return True
def is_accel(event, *accels): """Checks if the given keypress Gdk.Event matches any of accelerator strings. example: is_accel(event, "<shift><ctrl>z") """ assert accels if event.type != Gdk.EventType.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() for accel in accels: 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 if (accel_keyval, accel_mod) == (keyval, event.state & default_mod): return True return False
def on_scroll_event(self, view, event): state = event.state & Gtk.accelerator_get_default_mod_mask() if state != Gdk.ModifierType.CONTROL_MASK: return False # Scroll to the keep the line in the centre of the screen anchored visible_rect = self.view.get_visible_rect() central_line_y = visible_rect.height / 2 + visible_rect.y central_line_iter, _ = self.view.get_line_at_y(central_line_y) self.view.scroll_to_iter(central_line_iter, 0, True, 0.5, 0.5) if event.direction == Gdk.ScrollDirection.UP: self.larger_text() return True elif event.direction == Gdk.ScrollDirection.DOWN: self.smaller_text() return True elif event.direction == Gdk.ScrollDirection.SMOOTH: if event.delta_y > 0: self.smaller_text() elif event.delta_y < 0: self.larger_text() return False
def on_button_press_event(self, eventbox, event): self.grab_focus() widget = eventbox.get_child() modifiers = Gtk.accelerator_get_default_mod_mask() ctrl = event.state & modifiers == Gdk.ModifierType.CONTROL_MASK shift = event.state & modifiers == Gdk.ModifierType.SHIFT_MASK selected_old = self.selected[:] self.secondary_cursor_at = self.cursor_at self.cursor_at = self.ordered_children.index(widget) if not ctrl: self.selected = [] if shift: if self.secondary_cursor_at is not None: cursors = [self.secondary_cursor_at, self.cursor_at] cursors.sort() smaller = cursors[0] greater = cursors[1] self.selected = self.ordered_children[smaller:greater+1] # When using shift, cursor should remain the same self.cursor_at, self.secondary_cursor_at = \ self.secondary_cursor_at, self.cursor_at else: self.secondary_cursor_at = self.cursor_at if ctrl: if widget in self.selected: self.selected.remove(widget) else: self.selected.append(widget) elif widget not in self.selected: self.selected.append(widget) self.update_selection(selected_old)
def on_window_key_press_event(self, window, event, notebooks): key = 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 & Gdk.ModifierType.CONTROL_MASK: return False is_ctrl = state == Gdk.ModifierType.CONTROL_MASK is_ctrl_shift = state == Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.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 print("Keyval:", str(event.keyval)) print(key) cur = window.get_active_tab() if cur: notebook = cur.get_parent() stack, model = notebooks[notebook] if is_page_key: tabs = stack else: tabs = notebook.get_children() tlen = len(tabs) if 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_page_key: view = self._view tabwin = view.get_toplevel() min_size, nat_size = view.get_preferred_size() tabwin.set_size_request(-1, min(nat_size.height, self.MAX_TAB_WINDOW_HEIGHT)) tabwin.present() self._tabbing = True else: self._paging = True window.set_active_tab(next) return True
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.get_keyval()[1] state = event.get_state() if state: state &= Gtk.accelerator_get_default_mod_mask() if (keyval == Gdk.KEY_Escape or (state == Gdk.ModifierType.MOD1_MASK and (keyval == Gdk.KEY_Up or keyval == Gdk.KEY_KP_Up))): self.popdown() return True elif keyval in [Gdk.KEY_Return, Gdk.KEY_KP_Enter, Gdk.KEY_KP_Space, Gdk.KEY_Tab]: self.confirm() return True return False
def move_selection_by_key(self, event): keyname = Gdk.keyval_name(event.keyval) modifiers = Gtk.accelerator_get_default_mod_mask() ctrl = event.state & modifiers == Gdk.ModifierType.CONTROL_MASK shift = event.state & modifiers == Gdk.ModifierType.SHIFT_MASK dif = {"Up": -self.columns, "Down": self.columns, "Left": -1, "Right":1} selected_old = self.selected[:] if ctrl: pass #TODO implement elif shift and self.cursor_at is not None: if (0 <= self.secondary_cursor_at + dif[keyname] < len(self.ordered_children)): self.secondary_cursor_at += dif[keyname] cursors = [self.secondary_cursor_at, self.cursor_at] cursors.sort() smaller = cursors[0] greater = cursors[1] self.selected = self.ordered_children[smaller:greater+1] self.update_selection(selected_old) elif self.cursor_at is not None: if self.secondary_cursor_at is not None: self.cursor_at = self.secondary_cursor_at if 0 <= self.cursor_at + dif[keyname] < len(self.ordered_children): self.cursor_at += dif[keyname] self.secondary_cursor_at = self.cursor_at self.selected = [self.ordered_children[self.cursor_at]] self.update_selection(selected_old) if self.cursor_at is None: self.cursor_at = 0 self.selected = [self.ordered_children[self.cursor_at]] self.update_selection([]) return True
def _on_album_event(self, evbox, event, data=None): modifiers = Gtk.accelerator_get_default_mod_mask() if ((event.get_state() & modifiers) == Gdk.ModifierType.CONTROL_MASK and not self.props.selection_mode): self.props.selection_mode = True if self.props.selection_mode: self.props.selected = not self.props.selected
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 handle_keys(self, widget, event): if event.keyval == Gdk.KEY_Escape: self.quit() modifiers = Gtk.accelerator_get_default_mod_mask() ctrl = (event.state & modifiers) == Gdk.ModifierType.CONTROL_MASK if ctrl and event.keyval in self.ctrl_keys_bind.keys(): self.ctrl_keys_bind[event.keyval]()
def on_button_press_event(self, view, event): state = event.state & Gtk.accelerator_get_default_mod_mask() if state == Gdk.ModifierType.CONTROL_MASK and event.button == 2: self.normal_size() return True else: return False
def on_key_press(self, view, event): keyval = Gdk.keyval_to_lower(event.keyval) mask = Gtk.accelerator_get_default_mod_mask() & event.state for shortcut in self.keymap.values(): if ((shortcut['accel'][0] == keyval) and (shortcut['accel'][1] == mask)): shortcut['action']() return(True) 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 = 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 = Gdk.ModifierType(event.state & ~Gdk.ModifierType.LOCK_MASK) 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 = res[1] consumed_modifiers = res[4] # 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.ModifierType.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_key_pressed(self, widget, event): defmod = Gtk.accelerator_get_default_mod_mask() & event.state if event.keyval == 0xff52 and defmod == Gdk.ModifierType.CONTROL_MASK: self.raise_selection() elif event.keyval == 0xff54 and defmod == Gdk.ModifierType.CONTROL_MASK: self.lower_selection() else: return False return True
def translate_keyboard_event(self, widget, event): keymap = Gdk.Keymap.get_for_display(widget.get_display()) # translate keys properly _wasmapped, keyval, egroup, level, consumed = keymap.translate_keyboard_state( event.hardware_keycode, event.get_state(), event.group) modifiers = Gtk.accelerator_get_default_mod_mask() & ~consumed state = event.get_state() & modifiers return keyval, state
def dialog_key_press_cb(self, source, event): keyval = event.keyval modifier_mask = event.state & gtk.accelerator_get_default_mod_mask() if gtk.accelerator_valid(keyval, modifier_mask): self.set_value(gtk.accelerator_name(keyval, modifier_mask)) self.emit('changed') gdk.Device.ungrab(gtk.get_current_event_device(), gtk.get_current_event_time()) self.dialog.hide()
def on_key_release_event(self, view, event): mods = Gtk.accelerator_get_default_mod_mask() # if tab or shift+tab: # with shift+tab key is GDK_ISO_Left_Tab (yay! on win32 and mac too!) if ((event.keyval == Gdk.KEY_Tab or event.keyval == Gdk.KEY_KP_Tab or event.keyval == Gdk.KEY_ISO_Left_Tab) and ((event.state & mods) == 0 or (event.state & mods) == Gdk.ModifierType.SHIFT_MASK)): doc = view.get_buffer() if doc.get_has_selection(): start_iter, end_iter = doc.get_selection_bounds() start_line_nb = start_iter.get_line() end_line_nb = end_iter.get_line() doc.begin_user_action() for i in xrange(start_line_nb, end_line_nb + 1): lineIterStart = doc.get_iter_at_line(i) while lineIterStart.get_char() == '\t': lineIterStart.forward_char() lineIterEnd = lineIterStart.copy() while True: lineIterEnd.forward_chars(8) if lineIterStart.get_text(lineIterEnd) == " ": doc.delete(lineIterStart, lineIterEnd) doc.insert(lineIterStart, "\t") lineIterEnd = lineIterStart.copy() else: break doc.end_user_action() else: # doc.begin_user_action() cursorLineNr = doc.get_iter_at_mark(doc.get_insert()).get_line() lineIterStart = doc.get_iter_at_line(cursorLineNr) while lineIterStart.get_char() == '\t': lineIterStart.forward_char() lineIterEnd = lineIterStart.copy() while True: lineIterEnd.forward_chars(8) if lineIterStart.get_text(lineIterEnd) == " ": doc.delete(lineIterStart, lineIterEnd) doc.insert(lineIterStart, "\t") lineIterEnd = lineIterStart.copy() else: break # doc.end_user_action() # print dir(doc) return False
def on_vte_key_press(self, term, event): modifiers = event.state & Gtk.accelerator_get_default_mod_mask() if event.keyval in (Gdk.KEY_Tab, Gdk.KEY_KP_Tab, Gdk.KEY_ISO_Left_Tab): if modifiers == Gdk.ModifierType.CONTROL_MASK: self.get_toplevel().child_focus(Gtk.DirectionType.TAB_FORWARD) return True elif modifiers == Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK: self.get_toplevel().child_focus(Gtk.DirectionType.TAB_BACKWARD) return True for name in self._accels: path = self._accel_base + '/' + name entry = Gtk.AccelMap.lookup_entry(path) if entry and entry[0] and entry[1].accel_key == event.keyval and entry[1].accel_mods == modifiers: self._accels[name][2]() return True return False
def _on_view_clicked(self, gesture, n_press, x, y): """Ctrl+click on self._songs_view triggers selection mode.""" _, state = Gtk.get_current_event_state() modifiers = Gtk.accelerator_get_default_mod_mask() if (state & modifiers == Gdk.ModifierType.CONTROL_MASK and not self.props.selection_mode): self.props.selection_mode = True # FIXME: In selection mode, star clicks might still trigger # activation. if self.props.selection_mode: path = self._songs_view.get_path_at_pos(x, y) if path is None: return iter_ = self._model.get_iter(path[0]) new_fav_status = not self._model[iter_][1] self._model[iter_][1] = new_fav_status self._model[iter_][7].props.selected = new_fav_status
def on_button_press(self, drawing_area, event): modifiers = Gtk.accelerator_get_default_mod_mask() if event.type == Gdk.EventType.BUTTON_PRESS and event.button == 1 and event.state & modifiers == 0: item_num = max( 0, min(int((event.y - 9) // self.view.line_height), len(self.includes))) if item_num == 0: document = self.data_provider.document self.data_provider.workspace.set_active_document(document) else: filename = self.includes[item_num - 1]['filename'] document = self.data_provider.workspace.open_document_by_filename( filename) document.content.scroll_cursor_onscreen() self.data_provider.workspace.active_document.view.source_view.grab_focus( )
def on_scroll_event(self, view, event): state = event.state & Gtk.accelerator_get_default_mod_mask() if state != Gdk.ModifierType.CONTROL_MASK: return False if event.direction == Gdk.ScrollDirection.UP: self.larger_text() return True elif event.direction == Gdk.ScrollDirection.DOWN: self.smaller_text() return True elif event.direction == Gdk.ScrollDirection.SMOOTH: if event.delta_y > 0: self.smaller_text() elif event.delta_y < 0: self.larger_text() return False
def _on_view_clicked(self, treeview, event): """Ctrl+click on self._view triggers selection mode. :param Gtk.TreeView treeview: self._view :param Gdk.EventButton event: clicked event """ modifiers = Gtk.accelerator_get_default_mod_mask() if ((event.get_state() & modifiers) == Gdk.ModifierType.CONTROL_MASK and not self.props.selection_mode): self._on_selection_mode_request() if (self.selection_mode and not self._star_handler.star_renderer_click): path, col, cell_x, cell_y = treeview.get_path_at_pos( *event.get_coords()) iter_ = self.model.get_iter(path) self.model[iter_][6] = not self.model[iter_][6] self.props.selected_items_count = len(self.get_selected_songs())
def on_button_press(self, button, event): """ Called when a button is pressed """ # Always grab focus is a workaround to do not loose first click self.grab_focus() self.reset_selection_status() # Only treats 1st button press if event.type == Gdk.EventType.BUTTON_PRESS: modifier = event.state & Gtk.accelerator_get_default_mod_mask() target = self.get_target_for(event) if target is None: if modifier == 0: # Unselects items if the user press any mouse button on an # empty area of the TreeView and no modifier key is active self.get_selection().unselect_all() return True # Ignore clicks on empty areas # Declare triggers_menu = event.triggers_context_menu() # Disable select function to to do not modify selection # Triggering menu will only accept selection if target.is_selected and (not modifier or triggers_menu): self.set_selection_status(False) # If it's not a DnD, it will be treated at button release event self.pending_events.append( DragTreeView.EventData(event, modifier, triggers_menu, target) ) # Calls `button_press` function on container (if present) try: button_press_function = self.container.button_press except AttributeError: return False else: return button_press_function(button, event)
def button_press_callback(self, widget, event, data=None): accel_mask = Gtk.accelerator_get_default_mod_mask() if event.state & accel_mask == Gdk.ModifierType.CONTROL_MASK and event.button == 1: # New Code instead of widget.get_pointer() - Wow! # I guess it is stupid to this in a CB. gdk_window = widget.get_window(1) display = Gdk.Display.get_default() seat = display.get_default_seat() pointer = seat.get_pointer() dev_pos = gdk_window.get_device_position(pointer) coords = dev_pos.x, dev_pos.y # coords = widget.get_pointer() # DeprecationWarning for pix in self.pix_list: """ D A +---+ | | +---+ C B """ w = pix.pb.get_width() h = pix.pb.get_height() ax = pix.x + w ay = pix.y bx = pix.x + w by = pix.y + h cx = pix.x cy = pix.y + h dx = pix.x dy = pix.y if check(ax, ay, bx, by, cx, cy, dx, dy, coords[0], coords[1]): self.moving_pic = True self.pic_moving = pix b = self.get_border_width() b = int(b) self.offset = (coords[0] - self.pic_moving.x, (coords[1] - b) - self.pic_moving.y) return True
def process_button_down(self, event, mode, transformed): modifiers = Gtk.accelerator_get_default_mod_mask() if event.button == 1: if event.type == Gtk.gdk.BUTTON_PRESS and not self.editing: self.emit("select_thought", event.state & modifiers) elif event.type == Gtk.gdk.BUTTON_PRESS and self.editing: x = int((transformed[0] - self.ul[0]) * Pango.SCALE) y = int((transformed[1] - self.ul[1]) * Pango.SCALE) loc = self.layout.xy_to_index(x, y) self.index = loc[0] if loc[0] >= len(self.text) - 1 or self.text[loc[0] + 1] == '\n': self.index += loc[1] self.bindex = self.bindex_from_index(self.index) if not (event.state & modifiers) & Gtk.gdk.SHIFT_MASK: self.end_index = self.index elif mode == BaseThought.MODE_EDITING and event.type == Gtk.gdk._2BUTTON_PRESS: if self.editing: self.move_index_horizontal(False) # go to the end self.index = 0 # and mark all else: self.emit("begin_editing") elif event.button == 2 and self.editing: x = int((transformed[0] - self.ul[0]) * Pango.SCALE) y = int((transformed[1] - self.ul[1]) * Pango.SCALE) loc = self.layout.xy_to_index(x, y) self.index = loc[0] if loc[0] >= len(self.text) - 1 or self.text[loc[0] + 1] == '\n': self.index += loc[1] self.bindex = self.bindex_from_index(self.index) self.end_index = self.index if os.name != 'nt': clip = Gtk.Clipboard(selection="PRIMARY") self.paste_text(clip) elif event.button == 3: self.emit("popup_requested", event, 1) del self.current_attrs self.current_attrs = [] self.recalc_edges() self.emit("update_view")
def _on_scroll(self, alsoself, event): modmask = Gtk.accelerator_get_default_mod_mask() if (event.state & modmask) in (0, Gdk.ModifierType.CONTROL_MASK): oldscale = self.scale newscale = self.scale if event.state & modmask == Gdk.ModifierType.CONTROL_MASK: factor = 1.2 else: factor = 1.05 if event.direction == Gdk.ScrollDirection.UP: newscale *= factor if event.direction == Gdk.ScrollDirection.DOWN: newscale /= factor if newscale == oldscale: return False self.scale = newscale self.queue_draw() return True if (event.state & modmask) == Gdk.ModifierType.SHIFT_MASK: oldscale = self.tunerscale newscale = self.tunerscale if event.direction == Gdk.ScrollDirection.UP: newscale *= 1.05 if event.direction == Gdk.ScrollDirection.DOWN: newscale /= 1.05 if newscale == oldscale: return False self.tunerscale = newscale return True return False
def _on_key_press(self, widget, event): key = event.keyval modifiers = Gtk.accelerator_get_default_mod_mask() modifiers = (event.state & modifiers) if modifiers: control_mask = Gdk.ModifierType.CONTROL_MASK shift_mask = Gdk.ModifierType.SHIFT_MASK alt_mask = Gdk.ModifierType.MOD1_MASK # TODO: Hiding this until link editing/hiding is more stable. # if ((key == Gdk.KEY_Return # or key == Gdk.KEY_KP_Enter # or key == Gdk.KEY_ISO_Enter) # and modifiers == control_mask): # buffer = self.get_buffer() # on_link, is_image, start, end = buffer.cursor_is_on_link() # if on_link: # self._popup_link_editor(start, end, is_image) pass
def _on__key_press_event(self, unused_window, event): """ Mimics Combobox behavior Escape, Enter or Alt+Up: Close Space: Select """ keyval = event.keyval state = event.state & Gtk.accelerator_get_default_mod_mask() if (keyval == Gdk.KEY_Escape or keyval in (Gdk.KEY_Return, Gdk.KEY_KP_Enter) or ((keyval == Gdk.KEY_Up or keyval == Gdk.KEY_KP_Up) and state == Gdk.ModifierType.MOD1_MASK)): self.popdown() return True processed, new_date = _according_to_keyval(keyval, state, self.get_date()) if processed and new_date: self.set_date(new_date) return processed
def _song_activated(self, widget, event): mod_mask = Gtk.accelerator_get_default_mod_mask() if ((event.get_state() & mod_mask) == Gdk.ModifierType.CONTROL_MASK and not self.props.selection_mode): self.props.selection_mode = True return (_, button) = event.get_button() if (button == Gdk.BUTTON_PRIMARY and not self.props.selection_mode): # self.emit('song-activated', widget) self._coremodel.set_playlist_model( PlayerPlaylist.Type.SEARCH_RESULT, self._model) self.player.play(widget.props.coresong) # FIXME: Need to ignore the event from the checkbox. # if self.props.selection_mode: # widget.props.selected = not widget.props.selected return True
def _on_key_press(self, widget, event): modifiers = Gtk.accelerator_get_default_mod_mask() event_and_modifiers = (event.state & modifiers) if event_and_modifiers != 0: # Open search bar on Ctrl + F if (event.keyval == Gdk.KEY_f and event_and_modifiers == Gdk.ModifierType.CONTROL_MASK): self.toolbar.searchbar.toggle_bar() # Go back from Album view on Alt + Left if (event.keyval == Gdk.KEY_Left and event_and_modifiers == Gdk.ModifierType.MOD1_MASK): if (self.toolbar._state != ToolbarState.MAIN): self.curr_view.set_visible_child(self.curr_view._grid) self.toolbar.set_state(ToolbarState.MAIN) else: if (event.keyval == Gdk.KEY_Delete): if self._stack.get_visible_child() == self.views[3]: self.views[3]._on_delete_activate(None) # Close search bar after Esc is pressed if event.keyval == Gdk.KEY_Escape: self.toolbar.searchbar.show_bar(False) # Also disable selection if self.toolbar._selectionMode: self.toolbar.set_selection_mode(False) # Open search bar when typing printable chars if it not opened # Make sure we skip unprintable chars and don't grab space press # (this is used for play/pause) if not self.toolbar.searchbar.get_reveal_child( ) and not event.keyval == Gdk.KEY_space: if (event_and_modifiers == Gdk.ModifierType.SHIFT_MASK or event_and_modifiers == 0) and \ GLib.unichar_isprint(chr(Gdk.keyval_to_unicode(event.keyval))): self.toolbar.searchbar.show_bar(True) else: if not self.toolbar.searchbar.get_reveal_child(): if event.keyval == Gdk.KEY_space and self.player.actionbar.get_visible( ): if self.get_focus() != self.player.playBtn: self.player.play_pause()
def _on_entry__key_press_event(self, unused_window, event): keyval = event.keyval state = event.state & Gtk.accelerator_get_default_mod_mask() if ((keyval == Gdk.KEY_Down or keyval == Gdk.KEY_KP_Down) and state == Gdk.ModifierType.MOD1_MASK): self._popup_date_picker() return True skip_minus = "" if not self.get_date(): skip_minus = "minus" if self.entry.get_property("cursor-position") in (4, 7): skip_minus = "minus" processed, new_date = _according_to_keyval(keyval, state, self.get_date(), skip=skip_minus, in_editbox=True) if processed and new_date: self.set_date(new_date) return processed
def _on_key_press(self, widget, event): mods = event.state & Gtk.accelerator_get_default_mod_mask() if event.keyval == self._search_key and mods == self._search_mods: self.searchbar.set_search_mode(not self.searchbar.get_search_mode()) return True keyname = Gdk.keyval_name(event.keyval) if keyname == 'Escape': if self.searchbar.get_search_mode(): self.searchbar.set_search_mode(False) return True elif keyname not in ['Up', 'Down']: if not self.entry.is_focus() and self.searchbar.get_search_mode(): if self.entry.im_context_filter_keypress(event): self.entry.grab_focus() l = self.entry.get_text_length() self.entry.select_region(l, l) return True return self.searchbar.handle_event(event) return False
def on_button_press(self, drawing_area, event): modifiers = Gtk.accelerator_get_default_mod_mask() if event.type == Gdk.EventType.BUTTON_PRESS and event.button == 1 and event.state & modifiers == 0: item_num = max( 0, min(int((event.y - 9) // self.view.line_height), len(self.nodes_in_line) - 1)) item = self.nodes_in_line[item_num]['item'] document = item[0] line_number = item[1] if document == None: filename = self.nodes_in_line[item_num]['item'][3] document = self.data_provider.workspace.open_document_by_filename( filename) self.data_provider.workspace.set_active_document(document) document.content.place_cursor(line_number) document.content.scroll_cursor_onscreen() self.data_provider.workspace.active_document.view.source_view.grab_focus( )
def on_window_key_press_event(self, window, event): if log.query(log.INFO): Gedit.debug_plugin_message( log.format("%s, key=%s", window, Gdk.keyval_name(event.keyval))) # we assume the key above tab has the keycode 49 # see https://gitlab.gnome.org/GNOME/metacity/blob/master/src/core/above-tab-keycode.c if event.hardware_keycode != 49: if log.query(log.DEBUG): Gedit.debug_plugin_message( log.format("keycode is %s, skipping", event.hardware_keycode)) return False action_name = None state = event.state & Gtk.accelerator_get_default_mod_mask() if state == CONTROL_MASK: action_name = 'next-tab-group' elif state == CONTROL_SHIFT_MASK: action_name = 'previous-tab-group' if action_name is None: if log.query(log.DEBUG): Gedit.debug_plugin_message( log.format("neither ctrl nor ctrl+shift held, skipping")) return False if log.query(log.DEBUG): Gedit.debug_plugin_message(log.format("activating %s", action_name)) window.lookup_action(action_name).activate() return True
def _on_key_press(self, widget, event): modifiers = Gtk.accelerator_get_default_mod_mask() event_and_modifiers = (event.state & modifiers) if (event_and_modifiers and event_and_modifiers == Gdk.ModifierType.CONTROL_MASK): if event.keyval == Gdk.KEY_b: self.insert_strong() elif event.keyval == Gdk.KEY_i: self.insert_emphasis() elif event.keyval == Gdk.KEY_k: self.insert_link() elif event.keyval == Gdk.KEY_f: self.set_utility_child(self.search_box) self.util_revealer.set_reveal_child(True) self.search_box.set_active_view(self.view) elif event.keyval == Gdk.KEY_t: self.fullscreen_statusbar_reveal(True) self.statusbar.show_tag_editor() elif event.keyval == Gdk.KEY_g: self.fullscreen_statusbar_reveal(True) self.statusbar.show_goal_editor()
def _song_activated(self, widget, event): if widget.props.select_click: widget.props.select_click = False return mod_mask = Gtk.accelerator_get_default_mod_mask() if ((event.get_state() & mod_mask) == Gdk.ModifierType.CONTROL_MASK and not self.props.selection_mode): self.props.selection_mode = True return if self.props.selection_mode: widget.props.select_click = True widget.props.selected = not widget.props.selected widget.props.coresong.props.selected = widget.props.selected return (_, button) = event.get_button() if (button == Gdk.BUTTON_PRIMARY and not self.props.selection_mode): self._coremodel.props.active_core_object = widget.props.coresong self._player.play(widget.props.coresong) return True
def _song_activated(self, widget, event): if widget.props.select_click: widget.props.select_click = False return mod_mask = Gtk.accelerator_get_default_mod_mask() if ((event.get_state() & mod_mask) == Gdk.ModifierType.CONTROL_MASK and not self.props.selection_mode): self.props.selection_mode = True widget.props.select_click = True widget.props.coresong.props.selected = True return (_, button) = event.get_button() if (button == Gdk.BUTTON_PRIMARY and not self.props.selection_mode): self.emit('song-activated', widget) if self.props.selection_mode: widget.props.select_click = True selection_state = widget.props.coresong.props.selected widget.props.coresong.props.selected = not selection_state return True
def on_event(self, view, event): if (event.type == Gdk.EventType.KEY_PRESS): keyval = Gdk.keyval_to_lower(event.keyval) mask = Gtk.accelerator_get_default_mod_mask() & event.state # start searching when the accelerator is used if ((keyval, mask) == self.accel): self.start_searching() return (True) # handle other keystrokes only in search mode elif (self.searching): key = Gdk.keyval_name(keyval) if (key == 'BackSpace'): self.search = self.search[:-1] self.update_search() return ('True') elif (self.is_searchable_key.match(key)): self.search += key self.update_search() return ('True') # don't exit if the user hits shift elif (key.startswith('Shift')): return ('True') # exit on Enter without inserting it and # select the function name elif (key == 'Return'): found = self.update_search() if (found is not None): self.doc.select_range(found[0], found[1]) self.stop_searching() return (True) else: self.stop_searching() return (False) # stop searching if the user clicks if (event.type == Gdk.EventType.BUTTON_PRESS): self.stop_searching() 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) 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 on_keypress(self, event): ''' returns whether the keypress has been handled. ''' modifiers = Gtk.accelerator_get_default_mod_mask() tab_keyvals = [ Gdk.keyval_from_name('Tab'), Gdk.keyval_from_name('ISO_Left_Tab') ] if event.keyval in tab_keyvals: if event.state & modifiers == 0: return self.on_tab_press() if not self.autocomplete.is_visible(): return False if event.keyval == Gdk.keyval_from_name('Down'): if event.state & modifiers == 0: self.autocomplete.view.select_next() return True if event.keyval == Gdk.keyval_from_name('Up'): if event.state & modifiers == 0: self.autocomplete.view.select_previous() return True if event.keyval == Gdk.keyval_from_name('Escape'): if event.state & modifiers == 0: self.cancel() return True if event.keyval == Gdk.keyval_from_name('Return'): if event.state & modifiers == 0: self.submit() return True return False
def on_keypress(self, event): ''' returns whether the keypress has been handled. ''' modifiers = Gtk.accelerator_get_default_mod_mask() if event.keyval == Gdk.keyval_from_name('Down'): if event.state & modifiers == 0: return self.on_down_press() if event.keyval == Gdk.keyval_from_name('Up'): if event.state & modifiers == 0: return self.on_up_press() if event.keyval == Gdk.keyval_from_name('Escape'): if event.state & modifiers == 0: return self.on_escape_press() if event.keyval == Gdk.keyval_from_name('Return'): if event.state & modifiers == 0: return self.on_return_press() tab_keyvals = [Gdk.keyval_from_name('Tab'), Gdk.keyval_from_name('ISO_Left_Tab')] if event.keyval in tab_keyvals: if event.state & modifiers == 0: return self.on_tab_press()
def on_scroll(self, widget, event): modifiers = Gtk.accelerator_get_default_mod_mask() if event.state & modifiers == Gdk.ModifierType.CONTROL_MASK: if event.delta_y != event.delta_x: self.zoom_momentum += event.delta_y - event.delta_x if (self.preview.presenter.scrolling_queue.empty()): zoom_level = min( max( self.preview.zoom_manager.get_zoom_level() * (1 - 0.1 * self.zoom_momentum), 0.25), 4) xoffset = (-event.x + event.x * zoom_level / self.preview.zoom_manager.get_zoom_level()) / ( zoom_level * self.preview.layout.hidpi_factor) yoffset = (-event.y + event.y * zoom_level / self.preview.zoom_manager.get_zoom_level()) / ( zoom_level * self.preview.layout.hidpi_factor) self.preview.zoom_manager.set_zoom_level(zoom_level) self.preview.scroll_by_offsets(xoffset, yoffset) self.zoom_momentum = 0 return True return False