def setup_tree_view(self, treeview): renderer = Gtk.CellRendererAccel() column = Gtk.TreeViewColumn("Action", renderer, text=ACTION) treeview.append_column(column) renderer = Gtk.CellRendererAccel( accel_mode=Gtk.CellRendererAccelMode.GTK, editable=True) column = Gtk.TreeViewColumn("Key", renderer, accel_mods=MASK, accel_key=VALUE) treeview.append_column(column) renderer.connect("accel_edited", self.accel_edited, treeview)
def __init__(self, builder): self.builder = builder self.dialog = builder.get_object("PreferencesDialog") self.button = builder.get_object("shortcut_button") hbox1 = builder.get_object("hbox1") self.new_task_default_binding = "<Primary>F12" self.gsettings_install_label_shown = False self.liststore = Gtk.ListStore(str, str) self.liststore.append(["", ""]) treeview = Gtk.TreeView(self.liststore) column_accel = Gtk.TreeViewColumn() treeview.append_column(column_accel) treeview.set_headers_visible(False) cell = Gtk.CellRendererAccel() cell.set_alignment(0.0, 1.0) cell.set_fixed_size(-1, 18) cell.set_property("accel-mode", Gtk.CellRendererAccelMode.OTHER) cell.connect("accel-edited", self._cellAccelEdit, self.liststore) cell.connect("accel-cleared", self._accel_cleared, self.liststore) self.cell = cell column_accel.pack_start(cell, True) column_accel.add_attribute(cell, "text", 1) hbox1.add(treeview)
def create_renderer(self, model): renderer = Gtk.CellRendererAccel() renderer.props.editable = True renderer.props.accel_mode = Gtk.CellRendererAccelMode.OTHER renderer.connect('accel-edited', self._on_accel_edited) renderer.connect('accel-cleared', self._on_accel_cleared) return renderer, 'text'
def __init__(self): Gtk.Window.__init__(self) self.set_title("CellRendererAccel") self.connect("destroy", Gtk.main_quit) self.liststore = Gtk.ListStore(str, str) self.liststore.append(["New", "<Primary>n"]) self.liststore.append(["Open", "<Primary>o"]) self.liststore.append(["Save", "<Primary>s"]) treeview = Gtk.TreeView() treeview.set_model(self.liststore) self.add(treeview) cellrenderertext = Gtk.CellRendererText() treeviewcolumn = Gtk.TreeViewColumn("Action") treeview.append_column(treeviewcolumn) treeviewcolumn.pack_start(cellrenderertext, True) treeviewcolumn.add_attribute(cellrenderertext, "text", 0) cellrendereraccel = Gtk.CellRendererAccel() cellrendereraccel.set_property("editable", True) cellrendereraccel.connect("accel-edited", self.on_accel_edited) cellrendereraccel.connect("accel-cleared", self.on_accel_cleared) treeviewcolumn = Gtk.TreeViewColumn("Accelerator") treeview.append_column(treeviewcolumn) treeviewcolumn.pack_start(cellrendereraccel, True) treeviewcolumn.add_attribute(cellrendereraccel, "text", 1)
def __init__(self): Gtk.Window.__init__(self, title="CellRendererAccel Example") self.set_default_size(200, 200) self.liststore = Gtk.ListStore(str, str) self.liststore.append(["Up", "Up"]) self.liststore.append(["Down", "Down"]) self.liststore.append(["Left", "Left"]) self.liststore.append(["Right", "Right"]) self.liststore.append(["Fire", "Return"]) self.liststore.append(["Menu", "Escape"]) treeview = Gtk.TreeView(model=self.liststore) renderer_text = Gtk.CellRendererText() column_text = Gtk.TreeViewColumn("Text", renderer_text, text=0) treeview.append_column(column_text) renderer_accel = Gtk.CellRendererAccel() renderer_accel.set_property("editable", True) renderer_accel.connect("accel-edited", self.on_accel_edited) renderer_accel.connect("accel-cleared", self.on_accel_cleared) column_accel = Gtk.TreeViewColumn("Accelerator", renderer_accel, text=1) treeview.append_column(column_accel) self.add(treeview)
def __init__(self): GObject.GObject.__init__(self) model = Gtk.ListStore( str, int, Gdk.ModifierType) # accel_path, accel_key, accel_mods def _append(data, accel_path, accel_key, accel_mods, changed): model.append((accel_path, accel_key, accel_mods)) Gtk.AccelMap.foreach(None, _append) model.set_sort_column_id(0, Gtk.SortType.ASCENDING) self.set_model(model) column = Gtk.TreeViewColumn(_('Action')) # T: Column header for keybinding list column.set_expand(True) column.set_sort_column_id(0) self.append_column(column) cr = Gtk.CellRendererText() cr.set_property('ellipsize', Pango.EllipsizeMode.MIDDLE) column.pack_start(cr, True) column.set_attributes(cr, text=0) column = Gtk.TreeViewColumn(_('Key Binding')) # T: Column header for keybinding list column.set_sort_column_id(1) self.append_column(column) cr = Gtk.CellRendererAccel() cr.set_property('editable', True) column.pack_start(cr, True) column.set_attributes(cr, accel_key=1, accel_mods=2) def _update(cr, tree_path, accel_key, accel_mods, hw_int): accel_path = model[tree_path][0] Gtk.AccelMap.change_entry(accel_path, accel_key, accel_mods, True) # Update of ListStore happens via AccelMap changed signal cr.connect('accel-edited', _update) def _clear(cr, tree_path): accel_path = model[tree_path][0] Gtk.AccelMap.change_entry(accel_path, 0, 0, False) cr.connect('accel-cleared', _clear) def _on_changed(map, accel_path, accel_key, accel_mods): for row in model: if row[0] == accel_path: row[1] = accel_key row[2] = accel_mods break else: model.append((accel_path, accel_key, accel_mods)) accelmap = Gtk.AccelMap.get() sid = accelmap.connect('changed', _on_changed) self.connect('destroy', lambda o: accelmap.disconnect(sid))
def setup_results_window(self): self.list_model = Gtk.ListStore(str, int, Gdk.ModifierType, Gio.SimpleAction, object, bool, bool) self.model_filter = self.list_model.filter_new() disable_groups = ["medialibrary"] style_context = self.entry.get_style_context() color_insensitive = gtk_style_context_get_color( style_context, Gtk.StateFlags.INSENSITIVE) for group in self.app.shortcuts.group_actions: if group not in disable_groups: for action, title, action_object in self.app.shortcuts.group_actions[ group]: accels = self.app.get_accels_for_action(action) accel = accels[0] if accels else "" accelerator_parsed = Gtk.accelerator_parse(accel) disabled = not action_object.props.enabled self.list_model.append([ title, accelerator_parsed.accelerator_key, accelerator_parsed.accelerator_mods, action_object, title.lower().split(" "), disabled, bool(accels) ]) self.model_filter.set_visible_func(self.filter_func) self.treeview = Gtk.TreeView.new_with_model(self.model_filter) self.treeview.props.headers_visible = False self.treeview.props.enable_search = False self.treeview.props.can_focus = False text_renderer = Gtk.CellRendererText() text_renderer.props.foreground_rgba = color_insensitive description_column = Gtk.TreeViewColumn("Description", text_renderer, text=0, foreground_set=5) description_column.set_fixed_width(400) self.treeview.append_column(description_column) accel_renderer = Gtk.CellRendererAccel() # The default is Gtk.CellRendererAccelMode.GTK, but with that one # accelerator "Left" appears as "Invalid" for some reason. accel_renderer.props.accel_mode = Gtk.CellRendererAccelMode.OTHER accel_renderer.props.foreground_rgba = color_insensitive accel_renderer.props.foreground_set = True shortcut_column = Gtk.TreeViewColumn("Shortcut", accel_renderer, accel_key=1, accel_mods=2, visible=6) self.treeview.append_column(shortcut_column) self.__select_row(self.model_filter.get_iter_first()) self.results_window.add(self.treeview) self.results_window.props.min_content_height = 300
def init_shortcut_tab(self): curr_mode = self.app.conf['shortcut-mode'] box = NoteTab() self.notebook.append_page(box, Gtk.Label(_('Shortcut'))) self.shortcut_win = Gtk.ScrolledWindow() disable_btn = Gtk.RadioButton(_('Disable Keyboard Shortcut')) disable_btn.connect('toggled', self.on_shortcut_btn_toggled, ShortcutMode.NONE) disable_btn.set_active(curr_mode == ShortcutMode.NONE) box.pack_start(disable_btn, False, False, 0) default_btn = Gtk.RadioButton(_('Use Default MultiMedia Key')) default_btn.connect('toggled', self.on_shortcut_btn_toggled, ShortcutMode.DEFAULT) default_btn.join_group(disable_btn) default_btn.set_active(curr_mode == ShortcutMode.DEFAULT) box.pack_start(default_btn, False, False, 0) custom_btn = Gtk.RadioButton(_('Use Custom Keyboard Shortcut')) custom_btn.connect('toggled', self.on_shortcut_btn_toggled, ShortcutMode.CUSTOM) custom_btn.join_group(default_btn) custom_btn.set_active(curr_mode == ShortcutMode.CUSTOM) box.pack_start(custom_btn, False, False, 0) self.shortcut_win.props.margin_left = 10 self.shortcut_win.set_sensitive(curr_mode == ShortcutMode.CUSTOM) box.pack_start(self.shortcut_win, True, True, 0) # disname, name, shortct key, shortcut modifiers self.shortcut_liststore = Gtk.ListStore(str, str, int, int) tv = Gtk.TreeView(model=self.shortcut_liststore) self.shortcut_win.add(tv) name_cell = Gtk.CellRendererText() name_col = Gtk.TreeViewColumn('Action', name_cell, text=DISNAME_COL) tv.append_column(name_col) key_cell = Gtk.CellRendererAccel(editable=True) key_cell.connect('accel-edited', self.on_shortcut_key_cell_edited) key_col = Gtk.TreeViewColumn('Shortcut Key', key_cell, accel_key=KEY_COL, accel_mods=MOD_COL) tv.append_column(key_col) for name in self.app.conf['custom-shortcut']: key = self.app.conf['custom-shortcut'][name] i18n_name = Config.SHORT_CUT_I18N[name] k, m = Gtk.accelerator_parse(key) self.shortcut_liststore.append([i18n_name, name, k, m])
def __keycode_button_clicked_cb(self, button): out = [] dlg = Gtk.MessageDialog(transient_for = self.get_toplevel(), buttons = Gtk.ButtonsType.CLOSE) message = _("Please press a key (or a key combination).\n" \ "The dialog will be closed when the key is released.") dlg.set_markup(message) dlg.set_title(_("Please press a key (or a key combination)")) sw = Gtk.ScrolledWindow() def __accel_edited_cb(c, path, keyval, state, keycode): out.append(keyval) out.append(state) out.append(keycode) dlg.response(Gtk.ResponseType.OK) model = Gtk.ListStore(GObject.TYPE_INT, GObject.TYPE_UINT, GObject.TYPE_UINT) accel_view = Gtk.TreeView(model = model) sw.add(accel_view) column = Gtk.TreeViewColumn() renderer = Gtk.CellRendererAccel(accel_mode=Gtk.CellRendererAccelMode.OTHER, editable=True) renderer.connect('accel-edited', __accel_edited_cb) column.pack_start(renderer, True) column.add_attribute(renderer, 'accel-mods', 0) column.add_attribute(renderer, 'accel-key', 1) column.add_attribute(renderer, 'keycode', 2) accel_view.append_column(column) it = model.append(None) area = dlg.get_message_area() area.pack_end(sw, True, True, 0) sw.show_all() id = dlg.run() dlg.destroy() if id != Gtk.ResponseType.OK or len(out) < 3: return keyval = out[0] state = out[1] keycode = out[2] for name, button, mask in self.__modifier_buttons: if state & mask: button.set_active(True) else: button.set_active(False) shortcut = Gtk.accelerator_name_with_keycode(None, keyval, keycode, state) shortcut = shortcut.replace('<Primary>', '<Control>') self.__keycode_entry.set_text(shortcut.rsplit('>', 1)[-1])
def __init__(self, window: MainWindow): """ :param keymanager: KeybindingManager instance """ super().__init__() self.set_border_width(5) self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.ALWAYS) self.__window = window self.__keybindings = self.__window.keybindings self.__keybindings_map = self.__window.keybindings_map # max number of keybindings for a single action self.__accel_column_num = 5 # Human name, action name, true value, shortcut 1, shortcut 2, ... model = [str, str, 'gboolean'] model.extend([ str, ] * self.__accel_column_num) treestore = self.__treestore = Gtk.TreeStore(*model) self.refresh_model() treeview = Gtk.TreeView(model=treestore) tvcol1 = Gtk.TreeViewColumn('Name') treeview.append_column(tvcol1) cell1 = Gtk.CellRendererText() tvcol1.pack_start(cell1, True) tvcol1.set_attributes(cell1, text=0, editable=2) for idx in range(self.__accel_column_num): tvc = Gtk.TreeViewColumn(f'Key {idx + 1}') treeview.append_column(tvc) accel_cell = Gtk.CellRendererAccel() accel_cell.connect('accel-edited', self._get_on_accel_edited(idx)) accel_cell.connect('accel-cleared', self._get_on_accel_cleared(idx)) tvc.pack_start(accel_cell, True) tvc.add_attribute(accel_cell, 'text', 3 + idx) tvc.add_attribute(accel_cell, 'editable', 2) # Allow sorting on the column tvcol1.set_sort_column_id(0) self.add(treeview) self.__action_treeiter_map = {}
def __init__(self, keymanager): """ @param keymanager: KeybindingManager instance. """ super(KeybindingEditorWindow, self).__init__() self.set_border_width(5) self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.ALWAYS) self.keymanager = keymanager accel_column_num = max([ len(self.keymanager.get_bindings_for_action(action)) for action in keybindings.BINDING_INFO.keys() ]) accel_column_num = self.accel_column_num = max([3, accel_column_num]) # Human name, action name, true value, shortcut 1, shortcut 2, ... model = [str, str, 'gboolean'] model.extend([ str, ] * accel_column_num) treestore = self.treestore = Gtk.TreeStore(*model) self.refresh_model() treeview = Gtk.TreeView(model=treestore) tvcol1 = Gtk.TreeViewColumn(_("Name")) treeview.append_column(tvcol1) cell1 = Gtk.CellRendererText() tvcol1.pack_start(cell1, True) tvcol1.set_attributes(cell1, text=0, editable=2) for idx in range(0, self.accel_column_num): tvc = Gtk.TreeViewColumn(_("Key %d") % (idx + 1)) treeview.append_column(tvc) accel_cell = Gtk.CellRendererAccel() accel_cell.connect("accel-edited", self.get_on_accel_edited(idx)) accel_cell.connect("accel-cleared", self.get_on_accel_cleared(idx)) tvc.pack_start(accel_cell, True) tvc.add_attribute(accel_cell, "text", 3 + idx) tvc.add_attribute(accel_cell, "editable", 2) # Allow sorting on the column tvcol1.set_sort_column_id(0) self.add_with_viewport(treeview)
def __init__(self, keybindings): super().__init__() self.set_orientation(Gtk.Orientation.VERTICAL) self._keybindings = keybindings scrolled_window = Gtk.ScrolledWindow() scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) self._store = Gtk.ListStore(str, str, int, int) self._tree_view = Gtk.TreeView() self._tree_view.set_model(self._store) self._tree_view.set_vexpand(True) self._tree_view.set_hexpand(True) self._tree_view.get_selection().set_mode(Gtk.SelectionMode.SINGLE) action_renderer = Gtk.CellRendererText() action_column = Gtk.TreeViewColumn() action_column.props.title = _('Action') action_column.props.expand = True action_column.pack_start(action_renderer, True) action_column.add_attribute(action_renderer, 'text', 1) self._tree_view.append_column(action_column) keybinding_renderer = Gtk.CellRendererAccel() keybinding_renderer.props.editable = True keybinding_renderer.connect('accel-edited', self._on_accel_edited) keybinding_column = Gtk.TreeViewColumn() keybinding_column.props.title = _('Modify') keybinding_column.pack_end(keybinding_renderer, False) keybinding_column.add_attribute(keybinding_renderer, 'accel-mods', KeybindingsWidget.Columns.MODS) keybinding_column.add_attribute(keybinding_renderer, 'accel-key', KeybindingsWidget.Columns.KEY) self._tree_view.append_column(keybinding_column) scrolled_window.add(self._tree_view) self.add(scrolled_window) self._refresh()
def __init__(self, preferences, widget): self.list = Gtk.ListStore(str, str) Preference.__init__(self, preferences, widget) self.widget.set_model(self.list) title_renderer = Gtk.CellRendererText() title_column = Gtk.TreeViewColumn(_('Action'), title_renderer, text=0) title_column.set_expand(True) title_column.set_cell_data_func(title_renderer, self.title_data_func) accel_renderer = Gtk.CellRendererAccel() accel_renderer.set_property('editable', True) accel_renderer.set_property('style', Pango.Style.OBLIQUE) accel_renderer.connect('accel-cleared', self.on_accel_cleared) accel_renderer.connect('accel-edited', self.on_accel_edited) accel_column = Gtk.TreeViewColumn(_('Shortcut'), accel_renderer, text=1) accel_column.set_expand(True) self.widget.append_column(title_column) self.widget.append_column(accel_column)
def __init__(self, settings): """Setup the preferences dialog interface, loading images, adding filters to file choosers and connecting some signals. """ self.hotkey_alread_used = False self.store = None super(PrefsDialog, self).__init__(gladefile('prefs.glade'), root='config-window') self.settings = settings self.add_callbacks(PrefsCallbacks(self)) # window cleanup handler self.window = self.get_widget('config-window') self.get_widget('config-window').connect('destroy', self.on_destroy) # setting evtbox title bg eventbox = self.get_widget('eventbox-title') eventbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(255, 255, 255, 255)) # images ipath = pixmapfile('guake-notification.png') self.get_widget('image_logo').set_from_file(ipath) ipath = pixmapfile('quick-open.png') self.get_widget('image_quick_open').set_from_file(ipath) # Model format: # 0: the keybinding path in gsettings (str, hidden), # 1: label (str) # 2: human readable accelerator (str) # 3: gtk accelerator (str, hidden) self.store = Gtk.TreeStore(str, str, str, str) treeview = self.get_widget('treeview-keys') treeview.set_model(self.store) treeview.set_rules_hint(True) # TODO PORT this is killing the editing of the accl # treeview.connect('button-press-event', self.start_editing) renderer = Gtk.CellRendererText() column = Gtk.TreeViewColumn(_('Action'), renderer, text=1) column.set_property('expand', True) treeview.append_column(column) renderer = Gtk.CellRendererAccel() renderer.set_property('editable', True) renderer.connect('accel-edited', self.on_accel_edited) renderer.connect('accel-cleared', self.on_accel_cleared) column = Gtk.TreeViewColumn(_('Shortcut'), renderer, text=2) column.pack_start(renderer, True) column.set_property('expand', False) column.add_attribute(renderer, "accel-mods", 0) column.add_attribute(renderer, "accel-key", 1) treeview.append_column(column) self.demo_terminal = GuakeTerminal(self.settings) self.demo_terminal_box = self.get_widget('demo_terminal_box') self.demo_terminal_box.add(self.demo_terminal) pid = self.spawn_sync_pid(None, self.demo_terminal) self.demo_terminal.pid = pid self.populate_shell_combo() self.populate_keys_tree() self.populate_display_n() self.load_configs() self.get_widget('config-window').hide()
def build(self, advanced): # Clear all the widgets from the content box widgets = self.content_box.get_children() for widget in widgets: self.content_box.remove(widget) self.notebook = Gtk.Notebook() tab = NotebookPage(_("Typing"), False) tab.add_widget(GSettingsCheckButton(_("Enable key repeat"), "org.gnome.settings-daemon.peripherals.keyboard", "repeat", None)) box = IndentedHBox() slider = GSettingsRange(_("Repeat delay:"), _("Short"), _("Long"), 100, 2000, False, "uint", False, "org.gnome.settings-daemon.peripherals.keyboard", "delay", "org.gnome.settings-daemon.peripherals.keyboard/repeat", adjustment_step = 10) box.pack_start(slider, True, True, 0) tab.add_widget(box) box = IndentedHBox() slider = GSettingsRange(_("Repeat speed:"), _("Slow"), _("Fast"), 20, 2000, True, "uint", True, "org.gnome.settings-daemon.peripherals.keyboard", "repeat-interval", "org.gnome.settings-daemon.peripherals.keyboard/repeat", adjustment_step = 1) box.pack_start(slider, True, True, 0) tab.add_widget(box) tab.add_widget(Gtk.Separator.new(Gtk.Orientation.HORIZONTAL)) tab.add_widget(GSettingsCheckButton(_("Text cursor blinks"), "org.gnome.desktop.interface", "cursor-blink", None)) box = IndentedHBox() slider = GSettingsRange(_("Blink speed:"), _("Slow"), _("Fast"), 100, 2500, True, "int", False, "org.gnome.desktop.interface", "cursor-blink-time", "org.gnome.desktop.interface/cursor-blink", adjustment_step = 10) box.pack_start(slider, True, True, 0) tab.add_widget(box) tab.add_widget(Gtk.Separator.new(Gtk.Orientation.HORIZONTAL)) tab.add_widget(Gtk.Label(_("Test Box"))) tab.add_widget(Gtk.Entry()) self.addNotebookTab(tab) tab = NotebookPage(_("Keyboard shortcuts"), True) headingbox = Gtk.Box.new(Gtk.Orientation.VERTICAL, 2) mainbox = Gtk.Box.new(Gtk.Orientation.HORIZONTAL, 2) headingbox.pack_start(mainbox, True, True, 2) headingbox.pack_end(Gtk.Label(_("To edit a keyboard binding, click it and press the new keys, or press backspace to clear it.")), False, False, 1) left_vbox = Gtk.Box.new(Gtk.Orientation.VERTICAL, 2) right_vbox = Gtk.Box.new(Gtk.Orientation.VERTICAL, 2) category_scroller = Gtk.ScrolledWindow.new(None, None) category_scroller.set_shadow_type(Gtk.ShadowType.IN) kb_name_scroller = Gtk.ScrolledWindow.new(None, None) kb_name_scroller.set_shadow_type(Gtk.ShadowType.IN) entry_scroller = Gtk.ScrolledWindow.new(None, None) entry_scroller.set_shadow_type(Gtk.ShadowType.IN) right_vbox.pack_start(kb_name_scroller, False, False, 2) right_vbox.pack_start(entry_scroller, False, False, 2) kb_name_scroller.set_property('min-content-height', 150) entry_scroller.set_property('min-content-height', 100) self.cat_tree = Gtk.TreeView.new() self.kb_tree = Gtk.TreeView.new() self.entry_tree = Gtk.TreeView.new() self.kb_tree.connect('row-activated', self.onCustomKeyBindingEdited) self.kb_tree.connect('button-press-event', self.onContextMenuPopup) self.kb_tree.connect('popup-menu', self.onContextMenuPopup) left_vbox.pack_start(category_scroller, True, True, 2) category_scroller.add(self.cat_tree) category_scroller.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.NEVER) kb_name_scroller.add(self.kb_tree) kb_name_scroller.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) entry_scroller.add(self.entry_tree) entry_scroller.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.NEVER) buttonbox = Gtk.ButtonBox.new(Gtk.Orientation.HORIZONTAL) self.add_custom_button = Gtk.Button(_("Add custom shortcut")) self.add_custom_button.connect('clicked', self.onAddCustomButtonClicked) self.remove_custom_button = Gtk.Button(_("Remove custom shortcut")) self.remove_custom_button.connect('clicked', self.onRemoveCustomButtonClicked) self.remove_custom_button.set_property('sensitive', False) buttonbox.pack_start(self.add_custom_button, False, False, 2) buttonbox.pack_start(self.remove_custom_button, False, False, 2) right_vbox.pack_end(buttonbox, False, False, 2) mainbox.pack_start(left_vbox, False, False, 2) mainbox.pack_start(right_vbox, True, True, 2) left_vbox.set_border_width(2) right_vbox.set_border_width(2) self.cat_store = Gtk.ListStore(str, # The category name object) # The category object self.kb_store = Gtk.ListStore( str, # Keybinding name object)# The keybinding object self.entry_store = Gtk.ListStore( str, # Keybinding entry object) # Keybinding object cell = Gtk.CellRendererText() cell.set_alignment(.5,0) cat_column = Gtk.TreeViewColumn(_("Categories"), cell, text=0) cat_column.set_alignment(.5) cat_column.set_property('min-width', 200) self.cat_tree.append_column(cat_column) self.cat_tree.connect("cursor-changed", self.onCategoryChanged) kb_name_cell = Gtk.CellRendererText() kb_name_cell.set_alignment(.5,.5) kb_column = Gtk.TreeViewColumn(_("Keyboard shortcuts"), kb_name_cell, text=0) kb_column.set_alignment(.5) self.kb_tree.append_column(kb_column) self.kb_tree.connect("cursor-changed", self.onKeyBindingChanged) entry_cell = Gtk.CellRendererAccel() entry_cell.set_alignment(.5,.5) entry_cell.connect('accel-edited', self.onEntryChanged, self.entry_store) entry_cell.connect('accel-cleared', self.onEntryCleared, self.entry_store) entry_cell.set_property('editable', True) try: # Only Ubuntu allows MODIFIER_TAP - using a single modifier as a keybinding entry_cell.set_property('accel-mode', Gtk.CellRendererAccelMode.MODIFIER_TAP) except Exception: # Pure GTK does not, so use OTHER entry_cell.set_property('accel-mode', Gtk.CellRendererAccelMode.OTHER) entry_column = Gtk.TreeViewColumn(_("Keyboard bindings"), entry_cell, text=0) entry_column.set_alignment(.5) self.entry_tree.append_column(entry_column) self.main_store = [] # categories Display name internal category self.main_store.append(KeyBindingCategory("Cinnamon", "cinnamon")) self.main_store.append(KeyBindingCategory(_("Windows"), "windows")) self.main_store.append(KeyBindingCategory(_("Workspace Management"), "ws-manage")) self.main_store.append(KeyBindingCategory(_("System"), "system")) self.main_store.append(KeyBindingCategory(_("Launchers"), "launchers")) self.main_store.append(KeyBindingCategory(_("Sound and Media"), "media")) self.main_store.append(KeyBindingCategory(_("Universal Access"), "accessibility")) self.main_store.append(KeyBindingCategory(_("Custom Shortcuts"), "custom")) for binding in KEYBINDINGS: for category in self.main_store: if category.int_name == binding[4]: category.add(KeyBinding(binding[0], binding[1], binding[2], binding[3], binding[4])) # print bindings.index(binding) # remove, only for catching segfaults when adding bindings for category in self.main_store: self.cat_store.append((category.label, category)) self.loadCustoms() self.cat_tree.set_model(self.cat_store) self.kb_tree.set_model(self.kb_store) self.entry_tree.set_model(self.entry_store) tab.add_widget(headingbox) self.addNotebookTab(tab) self.content_box.add(self.notebook) for tab in self.tabs: tab.build() self.content_box.show_all()
def __init__(self, parent, application): SettingsPage.__init__(self, parent, application, 'accelerators', _('Key bindings')) # create list box container = Gtk.ScrolledWindow() container.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.ALWAYS) container.set_shadow_type(Gtk.ShadowType.IN) self._accels = Gtk.TreeStore(str, str, int, int, int, int) self._accels.set_sort_column_id(Column.TITLE, Gtk.SortType.ASCENDING) self._list = Gtk.TreeView() self._list.set_model(self._accels) self._list.set_rules_hint(True) self._list.set_enable_search(True) self._list.set_search_column(Column.TITLE) # create and configure cell renderers cell_name = Gtk.CellRendererText() cell_primary = Gtk.CellRendererAccel() cell_secondary = Gtk.CellRendererAccel() cell_primary.set_property('accel-mode', Gtk.CellRendererAccelMode.OTHER) cell_primary.set_property('editable', True) cell_primary.connect('accel-edited', self.__accel_edited, True) cell_primary.connect('accel-cleared', self.__accel_cleared, True) cell_secondary.set_property('accel-mode', Gtk.CellRendererAccelMode.OTHER) cell_secondary.set_property('editable', True) cell_secondary.connect('accel-edited', self.__accel_edited, False) cell_secondary.connect('accel-cleared', self.__accel_cleared, False) # create and pack columns col_name = Gtk.TreeViewColumn(_('Description'), cell_name, markup=Column.TITLE) col_name.set_min_width(200) col_name.set_resizable(True) col_name.set_sort_column_id(Column.TITLE) col_name.set_sort_order(Gtk.SortType.ASCENDING) col_primary = Gtk.TreeViewColumn(_('Primary'), cell_primary, accel_key=Column.PRIMARY_KEY, accel_mods=Column.PRIMARY_MODS) col_primary.set_min_width(100) col_secondary = Gtk.TreeViewColumn(_('Secondary'), cell_secondary, accel_key=Column.SECONDARY_KEY, accel_mods=Column.SECONDARY_MODS) col_secondary.set_min_width(100) self._list.append_column(col_name) self._list.append_column(col_primary) self._list.append_column(col_secondary) # warning label label_warning = Gtk.Label( label=_('<b>Note:</b> You can only edit accelerators from ' 'objects created at least once in current session. ' 'To disable accelerator press <i>Backspace</i> ' 'in assign mode.')) label_warning.set_alignment(0, 0) label_warning.set_use_markup(True) label_warning.set_line_wrap(True) label_warning.connect('size-allocate', self._adjust_label) label_note = Gtk.Label( label=_('Double click on accelerator to assign new one.')) label_note.set_alignment(0, 0) # pack interface container.add(self._list) self.pack_start(label_warning, False, False, 0) self.pack_start(container, True, True, 0) self.pack_start(label_note, False, False, 0)
def __init__(self): super(NemoTerminalPreferencesWindow, self).__init__() self.set_icon_name("terminal") self.set_title(_("Nemo-Terminal Preferences")) self.set_skip_taskbar_hint(False) self.set_type_hint(Gdk.WindowTypeHint.NORMAL) self.set_default_size(-1, -1) self.connect("destroy", Gtk.main_quit) self.settings = Gio.Settings( schema_id="org.nemo.extensions.nemo-terminal") # Basic page = Page() frame = Gtk.Frame() frame.get_style_context().add_class("view") page.add(frame) box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) frame.add(box) switch = Gtk.Switch() self.settings.bind("default-visible", switch, "active", Gio.SettingsBindFlags.DEFAULT) widget = LabeledItem(_("Visible by default"), switch) box.pack_start(widget, False, False, 6) combo = Gtk.ComboBoxText() combo.append("top", _("Top")) combo.append("bottom", _("Bottom")) self.settings.bind("terminal-position", combo, "active-id", Gio.SettingsBindFlags.DEFAULT) widget = LabeledItem(_("Terminal position"), combo) box.pack_start(widget, False, False, 6) combo = Gtk.ComboBoxText() combo.append("None", _("Independent")) combo.append("Terminal follows Nemo", _("Terminal follows view location")) # combo.append("Nemo follows Terminal", _("View follows terminal location")) # combo.append("Nemo and Terminal Synchronized", _("Keep locations synchronized")) self.settings.bind("default-follow-mode", combo, "active-id", Gio.SettingsBindFlags.DEFAULT) widget = LabeledItem(_("Location mode"), combo) box.pack_start(widget, False, False, 6) switch = Gtk.Switch() self.settings.bind("audible-bell", switch, "active", Gio.SettingsBindFlags.DEFAULT) widget = LabeledItem(_("Terminal bell"), switch) box.pack_start(widget, False, False, 6) spinner = Gtk.SpinButton.new_with_range(5, 1000, 1) spinner.set_digits(0) self.settings.bind("default-terminal-height", spinner, "value", Gio.SettingsBindFlags.DEFAULT) widget = LabeledItem(_("Default number of lines for the terminal"), spinner) box.pack_start(widget, False, False, 6) frame = Gtk.Frame() treeview = Gtk.TreeView(headers_visible=False, enable_search=False, hover_selection=True) cell = Gtk.CellRendererAccel(editable=True, accel_mode=Gtk.CellRendererAccelMode.GTK, width=140, xalign=0.5, yalign=0.5) col = Gtk.TreeViewColumn("binding", cell, accel_key=0, accel_mods=1) treeview.append_column(col) store = Gtk.ListStore(int, Gdk.ModifierType) treeview.set_model(store) def update_accel_from_settings(settings, data=None): accel_string = settings.get_string("terminal-hotkey") k, m = Gtk.accelerator_parse(accel_string) store.clear() store.append((k, m)) self.settings.connect("changed::terminal-hotkey", update_accel_from_settings) update_accel_from_settings(self.settings) def on_accel_changed(accel, path, key, mods, code, data=None): name = Gtk.accelerator_name(key, mods) self.settings.set_string("terminal-hotkey", name) cell.set_property("text", Gtk.accelerator_get_label(key, mods)) def on_accel_cleared(accel, path, data=None): self.settings.set_string("terminal-hotkey", "") cell.connect("accel-edited", on_accel_changed) cell.connect("accel-cleared", on_accel_cleared) frame.add(treeview) widget = LabeledItem(_("Keyboard shortcut"), frame) box.pack_start(widget, False, False, 6) self.add_page(page, "main", _("Basic")) # Advanced page = Page() frame = Gtk.Frame() frame.get_style_context().add_class("view") page.add(frame) box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) frame.add(box) entry = Gtk.Entry() self.settings.bind("terminal-shell", entry, "text", Gio.SettingsBindFlags.DEFAULT) widget = LabeledItem( _("Shell to use (leave blank for system default)"), entry) box.pack_start(widget, False, False, 6) frame = Gtk.Frame() frame.get_style_context().add_class("view") page.add(frame) box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) frame.add(box) entry = Gtk.Entry() self.settings.bind("terminal-erase-line", entry, "text", Gio.SettingsBindFlags.DEFAULT) widget = LabeledItem(_("Terminal erase line key sequence"), entry) box.pack_start(widget, False, False, 6) entry = Gtk.Entry() self.settings.bind("terminal-restore-line", entry, "text", Gio.SettingsBindFlags.DEFAULT) widget = LabeledItem(_("Terminal restore line key sequence"), entry) box.pack_start(widget, False, False, 6) entry = Gtk.Entry() self.settings.bind("terminal-change-directory-command", entry, "text", Gio.SettingsBindFlags.DEFAULT) widget = LabeledItem(_("Change directory command"), entry) box.pack_start(widget, False, False, 6) box.pack_start(Gtk.Separator(orientation=Gtk.Orientation.HORIZONTAL), False, False, 6) button = Gtk.Button(_("Restore defaults")) button.set_valign(Gtk.Align.CENTER) def on_reset_clicked(button, data=None): for key in self.settings.list_keys(): self.settings.reset(key) button.connect("clicked", on_reset_clicked) widget = LabeledItem( _("Sequences must be escaped according to python rules. ") + _("'%s' is replaced by the quoted directory name."), button) widget.label_widget.set_line_wrap(True) widget.label_widget.set_max_width_chars(40) widget.label_widget.set_justify(Gtk.Justification.FILL) box.pack_start(widget, False, False, 6) self.add_page(page, "advanced", _("Advanced")) self.show_all() self.present()
def create_idtone_accels_config(self, parent): it, page_vbox = self.new_page_box( parent, _("Identify tone keyboard accelerators")) self.g_idtone_accels = Gtk.ListStore(GObject.TYPE_STRING, GObject.TYPE_STRING) notenames = ('c', 'cis', 'd', 'dis', 'e', 'f', 'fis', 'g', 'gis', 'a', 'ais', 'b') for notename in notenames: self.g_idtone_accels.append( (solfege.mpd.MusicalPitch.new_from_notename( notename).get_user_notename(), cfg.get_string('idtone/tone_%s_ak' % notename))) self.g_treeview = Gtk.TreeView(self.g_idtone_accels) renderer = Gtk.CellRendererText() column = Gtk.TreeViewColumn(_("Note name"), renderer, text=0) self.g_treeview.append_column(column) renderer = Gtk.CellRendererAccel() renderer.set_property('editable', True) def acc_ff(renderer, path, accel_key, accel_mods, hw_key): is_unique = True for notename in notenames: if (notename != notenames[int(path)] and cfg.get_string( 'idtone/tone_%s_ak' % notename) == unichr(accel_key)): is_unique = False break if not is_unique: gu.dialog_ok(_( u"The accelerator in use for the tone “%s”. You have to choose another key." ) % solfege.mpd.MusicalPitch.new_from_notename( notename).get_user_notename(), parent=self, msgtype=Gtk.MessageType.ERROR) return it = self.g_idtone_accels.get_iter(path) cfg.set_string('idtone/tone_%s_ak' % notenames[int(path)], unichr(accel_key)) self.g_idtone_accels.set(it, 1, unichr(accel_key)) return True renderer.connect('accel-edited', acc_ff) column = Gtk.TreeViewColumn(_i("keyboard|Key"), renderer, text=1) self.g_treeview.append_column(column) page_vbox.pack_start(self.g_treeview, True, True, 0) layouts = { 'ascii': (_('ASCII'), u'awsedfujikol'), 'dvorak': (_('Dvorak'), u'a,o.eughctrn'), } hbox = Gtk.HBox() page_vbox.pack_start(hbox, False, False, 0) def set_buttons(widget, layout): v = layouts[layout][1] idx = 0 it = self.g_idtone_accels.get_iter_first() while True: self.g_idtone_accels.set_value(it, 1, v[idx]) cfg.set_string('idtone/tone_%s_ak' % notenames[idx], v[idx]) it = self.g_idtone_accels.iter_next(it) idx += 1 if not it: break for key in layouts: btn = Gtk.Button(layouts[key][0]) btn.connect('clicked', set_buttons, key) hbox.pack_start(btn, True, True, 0)
def create_interval_accels_config(self, parent): it, page_vbox = self.new_page_box(parent, _("Interval keyboard accelerators")) self.g_interval_accels = Gtk.ListStore(GObject.TYPE_STRING, GObject.TYPE_STRING) intervals = [ 'minor2', 'major2', 'minor3', 'major3', 'perfect4', 'diminished5', 'perfect5', 'minor6', 'major6', 'minor7', 'major7', 'perfect8', 'minor9', 'major9', 'minor10', 'major10' ] for interval in intervals: self.g_interval_accels.append( (mpd.Interval.new_from_int( intervals.index(interval)).get_name(), cfg.get_string('interval_input/%s' % interval))) self.g_intervals_treeview = Gtk.TreeView(self.g_interval_accels) renderer = Gtk.CellRendererText() column = Gtk.TreeViewColumn(_("Interval"), renderer, text=0) self.g_intervals_treeview.append_column(column) renderer = Gtk.CellRendererAccel() renderer.set_property('editable', True) def acc_ff(renderer, path, accel_key, accel_mods, hw_key): is_unique = True for interval in intervals: if (interval != intervals[int(path)] and cfg.get_string( 'interval_input/%s' % interval) == unichr(accel_key)): is_unique = False break if not is_unique: gu.dialog_ok(_( u"The accelerator in use for “%s”. You have to choose another key." ) % mpd.Interval.new_from_int( intervals.index(interval)).get_name(), parent=self, msgtype=Gtk.MessageType.ERROR) return it = self.g_interval_accels.get_iter(path) cfg.set_string('interval_input/%s' % intervals[int(path)], unichr(accel_key)) self.g_interval_accels.set(it, 1, unichr(accel_key)) return True renderer.connect('accel-edited', acc_ff) column = Gtk.TreeViewColumn(_i("keyboard|Key"), renderer, text=1) self.g_intervals_treeview.append_column(column) page_vbox.pack_start(self.g_intervals_treeview, True, True, 0) hbox = Gtk.HBox() page_vbox.pack_start(hbox, False, False, 0) layouts = { 'ascii': (_('ASCII'), u'1qaz2wsx3edc4rfv'), 'dvorak': (_('Dvorak'), u"1'a;2,oq3.ej4puk"), } def set_buttons(widget, layout): v = layouts[layout][1] idx = 0 it = self.g_interval_accels.get_iter_first() while True: self.g_interval_accels.set_value(it, 1, v[idx]) cfg.set_string('interval_input/%s' % intervals[idx], v[idx]) it = self.g_interval_accels.iter_next(it) idx += 1 if not it: break for key in layouts: btn = Gtk.Button(layouts[key][0]) btn.connect('clicked', set_buttons, key) hbox.pack_start(btn, True, True, 0)
window = Gtk.Window() window.connect("destroy", lambda q: Gtk.main_quit()) liststore = Gtk.ListStore(str, str) liststore.append(["New", "<Primary>n"]) liststore.append(["Open", "<Primary>o"]) liststore.append(["Save", "<Primary>s"]) treeview = Gtk.TreeView(model=liststore) window.add(treeview) treeviewcolumn = Gtk.TreeViewColumn("Action") treeview.append_column(treeviewcolumn) cellrenderertext = Gtk.CellRendererText() treeviewcolumn.pack_start(cellrenderertext, True) treeviewcolumn.add_attribute(cellrenderertext, "text", 0) treeviewcolumn = Gtk.TreeViewColumn("Accelerator") treeview.append_column(treeviewcolumn) cellrendereraccel = Gtk.CellRendererAccel() cellrendereraccel.set_property("editable", True) cellrendereraccel.connect("accel-edited", accel_edited) cellrendereraccel.connect("accel-cleared", accel_cleared) treeviewcolumn.pack_start(cellrendereraccel, True) treeviewcolumn.add_attribute(cellrendereraccel, "text", 1) window.show_all() Gtk.main()
def __init__(self, settings): """Setup the preferences dialog interface, loading images, adding filters to file choosers and connecting some signals. """ super(PrefsDialog, self).__init__(gladefile('prefs.glade'), root='config-window') self.settings = settings self.add_callbacks(PrefsCallbacks(self)) # window cleanup handler self.window = self.get_widget('config-window') self.get_widget('config-window').connect('destroy', self.on_destroy) # setting evtbox title bg eventbox = self.get_widget('eventbox-title') eventbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(255, 255, 255, 255)) # images ipath = pixmapfile('guake-notification.png') self.get_widget('image_logo').set_from_file(ipath) ipath = pixmapfile('quick-open.png') self.get_widget('image_quick_open').set_from_file(ipath) # the first position in tree will store the keybinding path in gconf, # and the user doesn't worry with this, let's hide that =D model = Gtk.TreeStore(str, str, object, bool) treeview = self.get_widget('treeview-keys') treeview.set_model(model) treeview.set_rules_hint(True) # TODO PORT this is killing the editing of the accl # treeview.connect('button-press-event', self.start_editing) renderer = Gtk.CellRendererText() column = Gtk.TreeViewColumn('keypath', renderer, text=0) column.set_visible(False) treeview.append_column(column) renderer = Gtk.CellRendererText() column = Gtk.TreeViewColumn(_('Action'), renderer, text=1) column.set_property('expand', True) treeview.append_column(column) renderer = Gtk.CellRendererAccel() renderer.set_property('editable', True) renderer.connect('accel-edited', self.on_key_edited, model) renderer.connect('accel-cleared', self.on_key_cleared, model) column = Gtk.TreeViewColumn(_('Shortcut'), renderer) column.set_cell_data_func(renderer, self.cell_data_func) column.set_property('expand', False) treeview.append_column(column) self.demo_terminal = GuakeTerminal(self.settings) demo_terminal_box = self.get_widget('demo_terminal_box') demo_terminal_box.add(self.demo_terminal) pid = self.spawn_sync_pid(None, self.demo_terminal) self.demo_terminal.pid = pid self.populate_shell_combo() self.populate_keys_tree() self.populate_display_n() self.load_configs() self.get_widget('config-window').hide()
def _initMisc(self): main_box = BaseGrid() # Daemon settings section_container = SectionContainer(title=_("Daemon")) section_container.set_property("margin", 15) curr_prof_box = self.get_custom_base_grid(tooltip=_( "This is the current profile that the daemon will load.")) label = SettingsLabel(_("Current Profile")) label.set_property("expand", True) self._currentProfile = Gtk.ComboBoxText() self._currentProfile.connect("changed", self.on_current_profile_changed) curr_prof_box.attach(label, 0, 0, 1, 1) curr_prof_box.attach(self._currentProfile, 1, 0, 1, 1) section_container.add_row(curr_prof_box, 0, 1, 1, 1) # "Special" switch that initially takes its active state from "daemon-is-running" # setting but when toggled it switches the "toggle-daemon" setting. # The "toggle-daemon" setting is a "dummy" setting that will toggle the daemon status. # This was done to bypass my own inability to convert the "daemon handler" function # from JavaScript to Python. daemon_status_box = self.get_custom_base_grid( tooltip=_("Toggle and display the daemon status.")) label = SettingsLabel(_("Daemon Status")) label.set_property("expand", True) self._switchDaemon = Gtk.Switch() self._switchDaemon.set_active( self._settings.get_boolean("daemon-is-running")) def on_notify_active(widget, data): self._settings.set_boolean( "toggle-daemon", not self._settings.get_boolean("toggle-daemon")) # self._daemon.toggle() self._switch_handler = self._switchDaemon.connect( "notify::active", on_notify_active) def on_daemon_toggled(settings, key): if self._switch_handler: self._switchDaemon.disconnect(self._switch_handler) self._switch_handler = None self._switchDaemon.set_active( settings.get_boolean(key)) # key = "daemon-is-running" self._switch_handler = self._switchDaemon.connect( "notify::active", on_notify_active) self._settings.connect("changed::daemon-is-running", on_daemon_toggled) daemon_status_box.attach(label, 0, 0, 1, 1) daemon_status_box.attach(self._switchDaemon, 1, 0, 1, 1) section_container.add_row(daemon_status_box, 0, 2, 1, 1) self._switchAutoStart = Switch( key="auto-start", label=_("Autostart Daemon"), tooltip= _("When enabled, the daemon will be automatically started when the applet is loaded. If it is already running or this is disabled, no action will be taken." )) section_container.add_row(self._switchAutoStart, 0, 3, 1, 1) interval_box = self.get_custom_base_grid() label = SettingsLabel(_("Wallpaper Timer Interval (seconds)")) label.set_property("expand", True) self._interval = Gtk.SpinButton( adjustment=Gtk.Adjustment(lower=0.0, upper=84600.0, step_increment=1.0, page_increment=10.0, page_size=0.0)) self._interval.set_value(self._settings.get_int("interval")) self._interval.update() button = Gtk.Button(label=_("Save")) button.connect("clicked", self.on_spin_save_button_clicked, self._interval, "interval") interval_box.attach(label, 0, 1, 1, 1) interval_box.attach(self._interval, 1, 1, 1, 1) interval_box.attach(button, 2, 1, 1, 1) section_container.add_row(interval_box, 0, 4, 1, 1) main_box.attach(section_container, 0, 1, 1, 1) section_container = SectionContainer( title=_("Manage keyboard shortcuts")) section_container.set_property("margin", 15) # Create the storage for the keybindings self.accel_model = Gtk.ListStore() self.accel_model.set_column_types([ GObject.TYPE_STRING, GObject.TYPE_INT, GObject.TYPE_INT, GObject.TYPE_STRING ]) row = self.accel_model.insert(-1) [key, mods] = Gtk.accelerator_parse( self._settings.get_strv("next-wallpaper-shortcut")[0]) self.accel_model.set( row, [0, 1, 2, 3], [_("Next Wallpaper"), mods, key, "next-wallpaper-shortcut"]) row = self.accel_model.insert(-1) [key, mods] = Gtk.accelerator_parse( self._settings.get_strv("prev-wallpaper-shortcut")[0]) self.accel_model.set( row, [0, 1, 2, 3], [_("Previous Wallpaper"), mods, key, "prev-wallpaper-shortcut"]) row = self.accel_model.insert(-1) [key, mods] = Gtk.accelerator_parse( self._settings.get_strv("toggle-menu-shortcut")[0]) self.accel_model.set( row, [0, 1, 2, 3], [_("Open/Close Menu"), mods, key, "toggle-menu-shortcut"]) # Create the treeview to display keybindings treeview = Gtk.TreeView() treeview.props.has_tooltip = True treeview.connect("query-tooltip", self._on_keibinding_query_tooltip) treeview.set_property("hexpand", True) treeview.set_property("model", self.accel_model) treeview.set_property("margin", 0) treeview.set_hover_selection(True) treeview.set_activate_on_single_click(True) treeview.get_selection().set_mode(Gtk.SelectionMode.SINGLE) treeview.columns_autosize() treeview.set_grid_lines(Gtk.TreeViewGridLines.BOTH) treeview.set_enable_tree_lines(True) # Action text column cellrend = Gtk.CellRendererText() cellrend.set_property("xpad", 15) col = Gtk.TreeViewColumn() col.set_property("title", _("Shortcut action")) col.set_alignment(0.5) col.set_property("expand", True) col.pack_start(cellrend, True) col.add_attribute(cellrend, "text", 0) treeview.append_column(col) # keybinding column cellrend = Gtk.CellRendererAccel() cellrend.set_property("xpad", 15) cellrend.set_property("editable", True) cellrend.set_property("accel-mode", Gtk.CellRendererAccelMode.GTK) cellrend.connect("accel-edited", self.on_accel_edited) cellrend.connect("accel-cleared", self.on_accel_cleared) col = Gtk.TreeViewColumn() col.set_property("title", _("Shortcut")) col.set_alignment(0.5) col.pack_end(cellrend, False) col.add_attribute(cellrend, "accel-mods", 1) col.add_attribute(cellrend, "accel-key", 2) treeview.append_column(col) section_container.add_row(treeview, 0, 1, 1, 1, False) main_box.attach(section_container, 0, 2, 1, 1) self.stack.add_titled(main_box, "misc", _("Other"))