Example #1
0
    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
Example #2
0
    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
Example #4
0
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)
Example #5
0
 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)
Example #6
0
    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
Example #7
0
 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
Example #9
0
    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)
Example #10
0
    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()
Example #11
0
 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
Example #12
0
        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
Example #14
0
    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
Example #15
0
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
Example #16
0
    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
Example #17
0
 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
Example #19
0
    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
Example #20
0
 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    
Example #21
0
    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
Example #23
0
    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]()
Example #24
0
    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)
Example #26
0
    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)
Example #27
0
	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
Example #28
0
    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
Example #29
0
    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
Example #31
0
    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
Example #32
0
    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
Example #33
0
    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
Example #35
0
    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())
Example #36
0
    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)
Example #37
0
    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
Example #38
0
    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")
Example #39
0
    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
Example #40
0
    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
Example #41
0
    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
Example #42
0
    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
Example #43
0
    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()
Example #44
0
    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
Example #45
0
    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
Example #46
0
    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(
            )
Example #47
0
    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
Example #48
0
    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()
Example #49
0
    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)
Example #52
0
    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
Example #54
0
    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()
Example #55
0
    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