Beispiel #1
0
    def on_key_press_event(self, widget, event):
        mods = event.get_state() & (Gdk.ModifierType.SHIFT_MASK
                                    | Gdk.ModifierType.CONTROL_MASK
                                    | Gdk.ModifierType.MOD1_MASK
                                    | Gdk.ModifierType.SUPER_MASK
                                    | Gdk.ModifierType.HYPER_MASK
                                    | Gdk.ModifierType.META_MASK)

        if event.keyval in (Gdk.KEY_Escape, Gdk.KEY_Return) and not mods:
            if event.keyval == Gdk.KEY_Escape:
                self.emit("changed", self.key, self.mods)
            self.end_key_grab()
            self.set_label()
            return

        key = Gdk.keyval_to_lower(event.keyval)
        if (key == Gdk.KEY_ISO_Left_Tab):
            key = Gdk.KEY_Tab

        if Gtk.accelerator_valid(key, mods) or (key == Gdk.KEY_Tab and mods):
            self.set_label(key, mods)
            self.end_key_grab()
            self.key = key
            self.mods = mods
            self.emit("changed", self.key, self.mods)
            return

        self.set_label(key, mods)
 def try_to_show(self):
     accel_name = self.read_accel_from_file()
     if accel_name != "":
         key, mods = Gtk.accelerator_parse(accel_name)
         if Gtk.accelerator_valid(key, mods):
             self.accel_name = self.accel_to_qt(accel_name)
             self.entry.set_text(self.accel_name)
Beispiel #3
0
    def add(self, accel, callback, data=None):
        num = len(accel.accelerators)
        mapping = self.accelerators

        for i in range(num):
            parsed = Gtk.accelerator_parse(accel.accelerators[i])

            if not Gtk.accelerator_valid(*parsed):
                return

            named = Gtk.accelerator_name(*parsed)
            inmap = named in mapping

            if i == num - 1 and inmap:
                # Last one cannot be in the map
                return
            elif inmap and isinstance(mapping[named], AccelCallback):
                # It's already mapped...
                return
            else:
                if not inmap:
                    mapping[named] = {}

                if i == num - 1:
                    mapping[named] = AccelCallback(accel, callback, data)

                mapping = mapping[named]
Beispiel #4
0
    def do_key_press_event(self, event):
        """Handles key press events and detects valid accelerators."""
        keyval = event.keyval
        mask = event.state

        if keyval == Gdk.KEY_Escape:
            self.destroy()
            return

        self.accelerator = Gtk.accelerator_name(keyval, mask)

        accelerator = Gtk.accelerator_get_label(keyval, mask)
        self.accelerator_label.set_markup("<span size='20000'><b>%s</b></span>"
                                          % accelerator)
        valid = Gtk.accelerator_valid(keyval, mask)

        self.conflicting_action = self.app.shortcuts.get_conflicting_action(
            self.customised_item.action_name, keyval, mask)
        if valid and self.conflicting_action:
            title = self.app.shortcuts.titles[self.conflicting_action]
            self.conflict_label.set_markup(
                _("This key combination is already used by <b>%s</b>."
                  " Press Replace to use it for <b>%s</b> instead.")
                % (title, self.customised_item.title))

        # Set visibility according to the booleans set above.
        self.apply_button.set_visible(valid and not bool(self.conflicting_action))
        self.accelerator_label.set_visible(valid)
        self.conflict_label.set_visible(valid and bool(self.conflicting_action))
        self.replace_button.set_visible(valid and bool(self.conflicting_action))
        self.invalid_label.set_visible(not valid)
Beispiel #5
0
    def init_tools(self):
      
        #the following is copied from windowactivatable.py and modified as necessary
        
        i = 1                    # counting tool actions
        accel_counter = 1        # counting tool actions without custom accel
        for tool in self._tool_preferences.tools:
            # hopefully unique action name
            name = "Tool%sAction" % i

            actionlink = "win." + name
            item = Gio.MenuItem.new(_(tool.label), actionlink)
            item.set_attribute_value("hidden-when",
                                    GLib.Variant.new_string("action-disabled"))
            self.latex_tools_menu.append_item(item)

            accelerator = None
            if tool.accelerator and len(tool.accelerator) > 0:
                key,mods = Gtk.accelerator_parse(tool.accelerator)
                if Gtk.accelerator_valid(key,mods):
                    accelerator = tool.accelerator
            if not accelerator:
                accelerator = "<Ctrl><Alt>%s" % accel_counter
                accel_counter += 1
            self.app.add_accelerator(accelerator, actionlink, None)
            i += 1
Beispiel #6
0
    def _init_tool_actions(self):
        """
         - Load defined Tools
         - create and init ToolActions from them
         - hook them in the window UI
         - create a map from extensions to lists of ToolActions
        """
        items_ui = ""
        self._action_handlers = {}

        # this is used for enable/disable actions by name (None = every extension)
        self._tool_action_extensions = {None: []}
        self._tool_action_group = Gtk.ActionGroup("LaTeXPluginToolActions")

        i = 1                    # counting tool actions
        accel_counter = 1        # counting tool actions without custom accel
        for tool in self._tool_preferences.tools:
            # hopefully unique action name
            name = "Tool%sAction" % i

            # update extension-tool mapping
            for extension in tool.extensions:
                try:
                    self._tool_action_extensions[extension].append(name)
                except KeyError:
                    # extension not yet mapped
                    self._tool_action_extensions[extension] = [name]

            # create action
            action = ToolAction(tool)
            gtk_action = Gtk.Action(name, action.label, action.tooltip, action.stock_id)
            self._action_handlers[gtk_action] = gtk_action.connect("activate", lambda gtk_action, action: action.activate(self._window_context), action)
            
            # create simple actions to be used by menu (created in appactivatable.py)
            simpleaction = Gio.SimpleAction(name=name)
            simpleaction.connect("activate", lambda _a, _b, action: action.activate(self._window_context), action)
            self.window.add_action(simpleaction)

            accelerator = None
            if tool.accelerator and len(tool.accelerator) > 0:
                key,mods = Gtk.accelerator_parse(tool.accelerator)
                if Gtk.accelerator_valid(key,mods):
                    accelerator = tool.accelerator
            if not accelerator:
                accelerator = "<Ctrl><Alt>%s" % accel_counter
                accel_counter += 1
            self._tool_action_group.add_action_with_accel(gtk_action, accelerator)

            # add UI definition
            items_ui += """<menuitem action="%s" />""" % name
            i += 1
        items_ui +="""<separator/>"""

        tool_ui = self._tool_ui_template.substitute({
                            "items": items_ui,
                            "toolbar_name": self._toolbar_name})
        
        self._ui_manager.insert_action_group(self._tool_action_group, -1)
        self._tool_ui_id = self._ui_manager.add_ui_from_string(tool_ui)
Beispiel #7
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()
Beispiel #8
0
    def on_dialoggetkey_key_release_event(self, widget, event):
        if not self._press_time:
            return
        keyval, state = self.translate_keyboard_event(widget, event)
        self.update_accelerator_label(0, 0)

        state = Gdk.ModifierType(state)
        if Gtk.accelerator_valid(keyval, state):
            key = Gtk.accelerator_name(keyval, state)
            if (self._previous_key is not None and
                    key == self._previous_key):
                self.return_cancel()
                return
            if self._check_callback is None or self._check_callback(key):
                self._return(key)
            else:
                self.imagekeybindingaux.show()
                self.labelkeybindingaux.show()
Beispiel #9
0
    def remove_real(self, accelerators, accels):
        if not accels:
            return

        parsed = Gtk.accelerator_parse(accels[0])

        if not Gtk.accelerator_valid(*parsed):
            return

        named = Gtk.accelerator_name(*parsed)

        if not named in accelerators:
            return

        if len(accels) == 1:
            del accelerators[named]
        else:
            self.remove_real(accelerators[named], accels[1:])

            if not accelerators[named]:
                del accelerators[named]
Beispiel #10
0
    def init_snippet_data(self, node):
        if node == None:
            return

        self.override = node.attrib.get('override')

        self.properties = {}
        props = SnippetData.PROPS.copy()

        # Store all properties present
        for child in node:
            if child.tag in props:
                del props[child.tag]

                # Normalize accelerator
                if child.tag == 'accelerator' and child.text != None:
                    keyval, mod = Gtk.accelerator_parse(child.text)

                    if Gtk.accelerator_valid(keyval, mod):
                        child.text = Gtk.accelerator_name(keyval, mod)
                    else:
                        child.text = ''

                if self.can_modify():
                    self.properties[child.tag] = child
                else:
                    self.properties[child.tag] = child.text or ''

        # Create all the props that were not found so we stay consistent
        for prop in props:
            if self.can_modify():
                child = et.SubElement(node, prop)

                child.text = props[prop]
                self.properties[prop] = child
            else:
                self.properties[prop] = props[prop]

        self.check_validation()
Beispiel #11
0
    def on_key_press_event(self, widget, event):
        #mods = event.get_state() & Gtk.accelerator_get_default_mod_mask()
        mods = event.get_state()

        if event.keyval in (Gdk.KEY_Escape, Gdk.KEY_Return) and not mods:
            if event.keyval == Gdk.KEY_Escape:
                self.emit("changed", self.key, self.mods)
            self.end_key_grab()
            self.set_label()
            return

        key = Gdk.keyval_to_lower(event.keyval)
        if (key == Gdk.KEY_ISO_Left_Tab):
            key = Gdk.KEY_Tab

        if Gtk.accelerator_valid(key, mods) or (key == Gdk.KEY_Tab and mods):
            self.set_label(key, mods)
            self.end_key_grab()
            self.key = key
            self.mods = mods
            self.emit("changed", self.key, self.mods)
            return

        self.set_label(key, mods)
Beispiel #12
0
    def _edit_dialog_key_press_cb(self, dialog, event, editable):
        if event.type != Gdk.EventType.KEY_PRESS:
            return False
        if event.is_modifier:
            return False
        if self._USE_NORMAL_DIALOG_KEYS:
            if event.keyval == Gdk.KEY_Return:
                dialog.response(Gtk.ResponseType.OK)
                return True
            elif event.keyval == Gdk.KEY_Escape:
                dialog.response(Gtk.ResponseType.CANCEL)
                return True
            elif event.keyval == Gdk.KEY_BackSpace:
                dialog.response(Gtk.ResponseType.REJECT)
                return True

        # Stolen from GTK 2.24's gtk/gtkmenu.c (gtk_menu_key_press())
        # Figure out what modifiers went into determining the key symbol
        keymap = Gdk.Keymap.get_default()
        bound, keyval, effective_group, level, consumed_modifiers = (
            keymap.translate_keyboard_state(
                event.hardware_keycode,
                event.state,
                event.group,
            ))
        keyval = Gdk.keyval_to_lower(keyval)
        mods = Gdk.ModifierType(
            event.state
            & Gtk.accelerator_get_default_mod_mask()
            & ~consumed_modifiers)

        # If lowercasing affects the keysym, then we need to include
        # SHIFT in the modifiers. We re-upper case when we match against
        # the keyval, but display and save in caseless form.
        if keyval != event.keyval:
            mods |= Gdk.ModifierType.SHIFT_MASK
        accel_label = Gtk.accelerator_get_label(keyval, mods)
        # So we get (<Shift>j, Shift+J) but just (plus, +). As I
        # understand it.

        if not Gtk.accelerator_valid(keyval, mods):
            return True

        clash_accel_path = None
        clash_action_label = None
        for path, kv, m, changed in self._get_accel_map_entries():
            if (kv, m) == (keyval, mods):
                clash_accel_path = path
                clash_action_label = self._action_labels.get(
                    clash_accel_path,
                    _("Unknown Action"),
                )
                break
        if clash_accel_path == dialog.accel_path:  # no change
            self._edit_dialog_set_standard_hint(dialog)
            label = str(accel_label)
            dialog.accel_label_widget.set_text(label)
        elif clash_accel_path:
            markup_tmpl = _(
                "<b>{accel} is already in use for '{action}'. "
                "The existing assignment will be replaced.</b>"
            )
            markup = markup_tmpl.format(
                accel=lib.xml.escape(accel_label),
                action=lib.xml.escape(clash_action_label),
            )
            self._edit_dialog_set_hint(dialog, markup)
            label = "%s (replace)" % (accel_label,)
            dialog.accel_label_widget.set_text(str(label))
        else:
            self._edit_dialog_set_standard_hint(dialog)
            label = "%s (changed)" % (accel_label,)
            dialog.accel_label_widget.set_text(label)
        dialog.result_mods = mods
        dialog.result_keyval = keyval
        return True
Beispiel #13
0
 def __valid__(self):
     return gtk.accelerator_valid(*(gtk.accelerator_parse(self.value)))