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