#!/usr/bin/python3
import gettext
import json
import os
import subprocess
from pathlib import Path
from html import escape
import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gdk, Gio, Gtk
from KeybindingWidgets import ButtonKeybinding, CellRendererKeybinding
from SettingsWidgets import SidePage
from bin import util
from xapp.GSettingsWidgets import *
gettext.install("cinnamon", "/usr/share/locale")
# Keybindings page - check if we need to store custom
# keybindings to gsettings key as well as GConf (In Mint 14 this is changed)
CUSTOM_KEYS_PARENT_SCHEMA = "org.cinnamon.desktop.keybindings"
CUSTOM_KEYS_BASENAME = "/org/cinnamon/desktop/keybindings/custom-keybindings"
CUSTOM_KEYS_SCHEMA = "org.cinnamon.desktop.keybindings.custom-keybinding"
MUFFIN_KEYBINDINGS_SCHEMA = "org.cinnamon.desktop.keybindings.wm"
MEDIA_KEYS_SCHEMA = "org.cinnamon.desktop.keybindings.media-keys"
CINNAMON_SCHEMA = "org.cinnamon.desktop.keybindings"
ENABLED_SCHEMA = "org.cinnamon"
OLD_SETTINGS_DIR = Path.joinpath(Path.home(), ".cinnamon/configs/")
SETTINGS_DIR = Path.joinpath(Path.home(), ".config/cinnamon/spices/")
MASKS = [Gdk.ModifierType.CONTROL_MASK, Gdk.ModifierType.MOD1_MASK,
Gdk.ModifierType.SHIFT_MASK, Gdk.ModifierType.SUPER_MASK]
CATEGORIES = [
# Label id parent
#(child)Label id parent
[_("General"), "general", None, "preferences-desktop-keyboard-shortcuts"],
[_("Troubleshooting"), "trouble", "general", None],
[_("Windows"), "windows", None, "preferences-system-windows"],
[_("Positioning"), "win-position", "windows", None],
[_("Tiling and Snapping"), "win-tiling", "windows", None],
[_("Inter-workspace"), "win-workspaces", "windows", None],
[_("Inter-monitor"), "win-monitors", "windows", None],
[_("Workspaces"), "workspaces", None, "video-display"],
[_("Direct Navigation"), "ws-navi", "workspaces", None],
[_("System"), "system", None, "preferences-system"],
[_("Hardware"), "sys-hw", "system", None],
[_("Screenshots and Recording"),"sys-screen", "system", None],
[_("Launchers"), "launchers", None, "applications-utilities"],
[_("Sound and Media"), "media", None, "applications-multimedia"],
[_("Quiet Keys"), "media-quiet", "media", None],
[_("Universal Access"), "accessibility", None, "preferences-desktop-accessibility"],
[_("Custom Shortcuts"), "custom", None, "cinnamon-panel-launcher"],
[_("Pointer"), "pointer", "general", None],
[_("Spices"), "spices", None, "cinnamon"]
]
KEYBINDINGS = [
# KB Label Schema Key name Array? Category
# General
[_("Show the window selection screen"), MUFFIN_KEYBINDINGS_SCHEMA, "switch-to-workspace-down", "general"],
[_("Show the workspace selection screen"), MUFFIN_KEYBINDINGS_SCHEMA, "switch-to-workspace-up", "general"],
[_("Show desktop"), MUFFIN_KEYBINDINGS_SCHEMA, "show-desktop", "general"],
[_("Show Desklets"), CINNAMON_SCHEMA, "show-desklets", "general"],
[_("Cycle through open windows"), MUFFIN_KEYBINDINGS_SCHEMA, "switch-windows", "general"],
[_("Cycle backwards through open windows"), MUFFIN_KEYBINDINGS_SCHEMA, "switch-windows-backward", "general"],
[_("Cycle through windows from all workspaces"), MUFFIN_KEYBINDINGS_SCHEMA, "switch-panels", "general"],
[_("Cycle backwards through windows from all workspaces"), MUFFIN_KEYBINDINGS_SCHEMA, "switch-panels-backward", "general"],
[_("Cycle through open windows of the same application"), MUFFIN_KEYBINDINGS_SCHEMA, "switch-group", "general"],
[_("Cycle backwards through open windows of the same application"), MUFFIN_KEYBINDINGS_SCHEMA, "switch-group-backward", "general"],
[_("Run dialog"), MUFFIN_KEYBINDINGS_SCHEMA, "panel-run-dialog", "general"],
# General - Troubleshooting
[_("Toggle Looking Glass"), CINNAMON_SCHEMA, "looking-glass-keybinding", "trouble"],
# General - Pointer
[_("Move pointer to the next monitor"), CINNAMON_SCHEMA, "pointer-next-monitor", "pointer"],
[_("Move pointer to the previous monitor"), CINNAMON_SCHEMA, "pointer-previous-monitor", "pointer"],
# Windows
[_("Maximize window"), MUFFIN_KEYBINDINGS_SCHEMA, "maximize", "windows"],
[_("Unmaximize window"), MUFFIN_KEYBINDINGS_SCHEMA, "unmaximize", "windows"],
[_("Minimize window"), MUFFIN_KEYBINDINGS_SCHEMA, "minimize", "windows"],
[_("Close window"), MUFFIN_KEYBINDINGS_SCHEMA, "close", "windows"],
[_("Activate window menu"), MUFFIN_KEYBINDINGS_SCHEMA, "activate-window-menu", "windows"],
[_("Raise window"), MUFFIN_KEYBINDINGS_SCHEMA, "raise", "windows"],
[_("Lower window"), MUFFIN_KEYBINDINGS_SCHEMA, "lower", "windows"],
[_("Toggle maximization state"), MUFFIN_KEYBINDINGS_SCHEMA, "toggle-maximized", "windows"],
[_("Toggle fullscreen state"), MUFFIN_KEYBINDINGS_SCHEMA, "toggle-fullscreen", "windows"],
[_("Toggle shaded state"), MUFFIN_KEYBINDINGS_SCHEMA, "toggle-shaded", "windows"],
[_("Toggle always on top"), MUFFIN_KEYBINDINGS_SCHEMA, "toggle-above", "windows"],
[_("Toggle showing window on all workspaces"), MUFFIN_KEYBINDINGS_SCHEMA, "toggle-on-all-workspaces", "windows"],
[_("Increase opacity"), MUFFIN_KEYBINDINGS_SCHEMA, "increase-opacity", "windows"],
[_("Decrease opacity"), MUFFIN_KEYBINDINGS_SCHEMA, "decrease-opacity", "windows"],
[_("Toggle vertical maximization"), MUFFIN_KEYBINDINGS_SCHEMA, "maximize-vertically", "windows"],
[_("Toggle horizontal maximization"), MUFFIN_KEYBINDINGS_SCHEMA, "maximize-horizontally", "windows"],
# Windows - Positioning
[_("Resize window"), MUFFIN_KEYBINDINGS_SCHEMA, "begin-resize", "win-position"],
[_("Move window"), MUFFIN_KEYBINDINGS_SCHEMA, "begin-move", "win-position"],
[_("Center window in screen"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-center", "win-position"],
[_("Move window to upper-right"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-corner-ne", "win-position"],
[_("Move window to upper-left"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-corner-nw", "win-position"],
[_("Move window to lower-right"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-corner-se", "win-position"],
[_("Move window to lower-left"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-corner-sw", "win-position"],
[_("Move window to right edge"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-side-e", "win-position"],
[_("Move window to top edge"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-side-n", "win-position"],
[_("Move window to bottom edge"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-side-s", "win-position"],
[_("Move window to left edge"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-side-w", "win-position"],
# Windows - Tiling and Snapping
[_("Push tile left"), MUFFIN_KEYBINDINGS_SCHEMA, "push-tile-left", "win-tiling"],
[_("Push tile right"), MUFFIN_KEYBINDINGS_SCHEMA, "push-tile-right", "win-tiling"],
[_("Push tile up"), MUFFIN_KEYBINDINGS_SCHEMA, "push-tile-up", "win-tiling"],
[_("Push tile down"), MUFFIN_KEYBINDINGS_SCHEMA, "push-tile-down", "win-tiling"],
# Windows - Workspace-related
[_("Move window to new workspace"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-workspace-new", "win-workspaces"],
[_("Move window to left workspace"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-workspace-left", "win-workspaces"],
[_("Move window to right workspace"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-workspace-right", "win-workspaces"],
[_("Move window to workspace above"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-workspace-up", "win-workspaces"],
[_("Move window to workspace below"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-workspace-down", "win-workspaces"],
[_("Move window to workspace 1"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-workspace-1", "win-workspaces"],
[_("Move window to workspace 2"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-workspace-2", "win-workspaces"],
[_("Move window to workspace 3"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-workspace-3", "win-workspaces"],
[_("Move window to workspace 4"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-workspace-4", "win-workspaces"],
[_("Move window to workspace 5"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-workspace-5", "win-workspaces"],
[_("Move window to workspace 6"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-workspace-6", "win-workspaces"],
[_("Move window to workspace 7"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-workspace-7", "win-workspaces"],
[_("Move window to workspace 8"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-workspace-8", "win-workspaces"],
[_("Move window to workspace 9"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-workspace-9", "win-workspaces"],
[_("Move window to workspace 10"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-workspace-10", "win-workspaces"],
[_("Move window to workspace 11"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-workspace-11", "win-workspaces"],
[_("Move window to workspace 12"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-workspace-12", "win-workspaces"],
# Windows - Monitor-related
[_("Move window to left monitor"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-monitor-left", "win-monitors"],
[_("Move window to right monitor"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-monitor-right", "win-monitors"],
[_("Move window to monitor above"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-monitor-up", "win-monitors"],
[_("Move window to monitor below"), MUFFIN_KEYBINDINGS_SCHEMA, "move-to-monitor-down", "win-monitors"],
# Workspaces
[_("Switch to left workspace"), MUFFIN_KEYBINDINGS_SCHEMA, "switch-to-workspace-left", "workspaces"],
[_("Switch to right workspace"), MUFFIN_KEYBINDINGS_SCHEMA, "switch-to-workspace-right", "workspaces"],
# Workspaces - Direct Nav
[_("Switch to workspace 1"), MUFFIN_KEYBINDINGS_SCHEMA, "switch-to-workspace-1", "ws-navi"],
[_("Switch to workspace 2"), MUFFIN_KEYBINDINGS_SCHEMA, "switch-to-workspace-2", "ws-navi"],
[_("Switch to workspace 3"), MUFFIN_KEYBINDINGS_SCHEMA, "switch-to-workspace-3", "ws-navi"],
[_("Switch to workspace 4"), MUFFIN_KEYBINDINGS_SCHEMA, "switch-to-workspace-4", "ws-navi"],
[_("Switch to workspace 5"), MUFFIN_KEYBINDINGS_SCHEMA, "switch-to-workspace-5", "ws-navi"],
[_("Switch to workspace 6"), MUFFIN_KEYBINDINGS_SCHEMA, "switch-to-workspace-6", "ws-navi"],
[_("Switch to workspace 7"), MUFFIN_KEYBINDINGS_SCHEMA, "switch-to-workspace-7", "ws-navi"],
[_("Switch to workspace 8"), MUFFIN_KEYBINDINGS_SCHEMA, "switch-to-workspace-8", "ws-navi"],
[_("Switch to workspace 9"), MUFFIN_KEYBINDINGS_SCHEMA, "switch-to-workspace-9", "ws-navi"],
[_("Switch to workspace 10"), MUFFIN_KEYBINDINGS_SCHEMA, "switch-to-workspace-10", "ws-navi"],
[_("Switch to workspace 11"), MUFFIN_KEYBINDINGS_SCHEMA, "switch-to-workspace-11", "ws-navi"],
[_("Switch to workspace 12"), MUFFIN_KEYBINDINGS_SCHEMA, "switch-to-workspace-12", "ws-navi"],
# System
[_("Log out"), MEDIA_KEYS_SCHEMA, "logout", "system"],
[_("Shut down"), MEDIA_KEYS_SCHEMA, "shutdown", "system"],
[_("Lock screen"), MEDIA_KEYS_SCHEMA, "screensaver", "system"],
[_("Suspend"), MEDIA_KEYS_SCHEMA, "suspend", "system"],
[_("Hibernate"), MEDIA_KEYS_SCHEMA, "hibernate", "system"],
[_("Restart Cinnamon"), MEDIA_KEYS_SCHEMA, "restart-cinnamon", "system"],
# System - Screenshots
[_("Take a screenshot of an area"), MEDIA_KEYS_SCHEMA, "area-screenshot", "sys-screen"],
[_("Copy a screenshot of an area to clipboard"), MEDIA_KEYS_SCHEMA, "area-screenshot-clip", "sys-screen"],
[_("Take a screenshot"), MEDIA_KEYS_SCHEMA, "screenshot", "sys-screen"],
[_("Copy a screenshot to clipboard"), MEDIA_KEYS_SCHEMA, "screenshot-clip", "sys-screen"],
[_("Take a screenshot of a window"), MEDIA_KEYS_SCHEMA, "window-screenshot", "sys-screen"],
[_("Copy a screenshot of a window to clipboard"), MEDIA_KEYS_SCHEMA, "window-screenshot-clip", "sys-screen"],
[_("Toggle recording desktop (must restart Cinnamon)"), MUFFIN_KEYBINDINGS_SCHEMA, "toggle-recording", "sys-screen"],
# System - Hardware
[_("Switch monitor configurations"), MUFFIN_KEYBINDINGS_SCHEMA, "switch-monitor", "sys-hw"],
[_("Rotate display"), MUFFIN_KEYBINDINGS_SCHEMA, "rotate-monitor", "sys-hw"],
[_("Orientation Lock"), MEDIA_KEYS_SCHEMA, "video-rotation-lock", "sys-hw"],
[_("Increase screen brightness"), MEDIA_KEYS_SCHEMA, "screen-brightness-up", "sys-hw"],
[_("Decrease screen brightness"), MEDIA_KEYS_SCHEMA, "screen-brightness-down", "sys-hw"],
[_("Toggle keyboard backlight"), MEDIA_KEYS_SCHEMA, "kbd-brightness-toggle", "sys-hw"],
[_("Increase keyboard backlight level"), MEDIA_KEYS_SCHEMA, "kbd-brightness-up", "sys-hw"],
[_("Decrease keyboard backlight level"), MEDIA_KEYS_SCHEMA, "kbd-brightness-down", "sys-hw"],
[_("Toggle touchpad state"), MEDIA_KEYS_SCHEMA, "touchpad-toggle", "sys-hw"],
[_("Turn touchpad on"), MEDIA_KEYS_SCHEMA, "touchpad-on", "sys-hw"],
[_("Turn touchpad off"), MEDIA_KEYS_SCHEMA, "touchpad-off", "sys-hw"],
[_("Show power statistics"), MEDIA_KEYS_SCHEMA, "battery", "sys-hw"],
# Launchers
[_("Launch terminal"), MEDIA_KEYS_SCHEMA, "terminal", "launchers"],
[_("Launch help browser"), MEDIA_KEYS_SCHEMA, "help", "launchers"],
[_("Launch calculator"), MEDIA_KEYS_SCHEMA, "calculator", "launchers"],
[_("Launch email client"), MEDIA_KEYS_SCHEMA, "email", "launchers"],
[_("Launch web browser"), MEDIA_KEYS_SCHEMA, "www", "launchers"],
[_("Home folder"), MEDIA_KEYS_SCHEMA, "home", "launchers"],
[_("Search"), MEDIA_KEYS_SCHEMA, "search", "launchers"],
# Sound and Media
[_("Volume mute"), MEDIA_KEYS_SCHEMA, "volume-mute", "media"],
[_("Volume down"), MEDIA_KEYS_SCHEMA, "volume-down", "media"],
[_("Volume up"), MEDIA_KEYS_SCHEMA, "volume-up", "media"],
[_("Mic mute"), MEDIA_KEYS_SCHEMA, "mic-mute", "media"],
[_("Launch media player"), MEDIA_KEYS_SCHEMA, "media", "media"],
[_("Play"), MEDIA_KEYS_SCHEMA, "play", "media"],
[_("Pause playback"), MEDIA_KEYS_SCHEMA, "pause", "media"],
[_("Stop playback"), MEDIA_KEYS_SCHEMA, "stop", "media"],
[_("Previous track"), MEDIA_KEYS_SCHEMA, "previous", "media"],
[_("Next track"), MEDIA_KEYS_SCHEMA, "next", "media"],
[_("Eject"), MEDIA_KEYS_SCHEMA, "eject", "media"],
[_("Rewind"), MEDIA_KEYS_SCHEMA, "audio-rewind", "media"],
[_("Fast-forward"), MEDIA_KEYS_SCHEMA, "audio-forward", "media"],
[_("Repeat"), MEDIA_KEYS_SCHEMA, "audio-repeat", "media"],
[_("Shuffle"), MEDIA_KEYS_SCHEMA, "audio-random", "media"],
# Sound and Media Quiet
[_("Volume mute (Quiet)"), MEDIA_KEYS_SCHEMA, "mute-quiet", "media-quiet"], # Not sure this is even necessary
[_("Volume down (Quiet)"), MEDIA_KEYS_SCHEMA, "volume-down-quiet", "media-quiet"],
[_("Volume up (Quiet)"), MEDIA_KEYS_SCHEMA, "volume-up-quiet", "media-quiet"],
# Universal Access
[_("Zoom in"), CINNAMON_SCHEMA, "magnifier-zoom-in", "accessibility"],
[_("Zoom out"), CINNAMON_SCHEMA, "magnifier-zoom-out", "accessibility"],
[_("Turn screen reader on or off"), MEDIA_KEYS_SCHEMA, "screenreader", "accessibility"],
[_("Turn on-screen keyboard on or off"), MEDIA_KEYS_SCHEMA, "on-screen-keyboard", "accessibility"],
[_("Increase text size"), MEDIA_KEYS_SCHEMA, "increase-text-size", "accessibility"],
[_("Decrease text size"), MEDIA_KEYS_SCHEMA, "decrease-text-size", "accessibility"],
[_("High contrast on or off"), MEDIA_KEYS_SCHEMA, "toggle-contrast", "accessibility"]
]
# keybindings.js listens for changes to 'custom-list'. Any time we create a shortcut
# or add/remove individual keybindings, we need to cause this list to change.
#
# Use a dummy entry to trigger this by alternately adding and removing it to the list.
DUMMY_CUSTOM_ENTRY = "__dummy__"
def ensureCustomListChanges(custom_list):
if DUMMY_CUSTOM_ENTRY in custom_list:
custom_list.remove(DUMMY_CUSTOM_ENTRY)
else:
custom_list.append(DUMMY_CUSTOM_ENTRY)
class Module:
comment = _("Manage keyboard settings and shortcuts")
name = "keyboard"
category = "hardware"
def __init__(self, content_box):
keywords = _("keyboard, shortcut, hotkey")
sidePage = SidePage(_("Keyboard"), "cs-keyboard", keywords, content_box, module=self)
self.sidePage = sidePage
self.current_category = None
self.last_selected_category = None
self.last_selected_binding = None
self.loaded = False
self.binding_categories = {}
self.main_store = []
self.cat_store = None
self.kb_root_store = None
self.kb_store = None
self.entry_store = None
self.cat_tree = None
self.kb_tree = None
self.entry_tree = None
self.color_found = None
self.placeholder_rgba = None
self.kb_search_entry = None
self.kb_search_handler_id = None
self.add_custom_button = None
self.remove_custom_button = None
self.search_choice = "shortcuts"
self.last_accel_string = ""
def on_module_selected(self):
if not self.loaded:
print("Loading Keyboard module")
self.sidePage.stack = SettingsStack()
self.sidePage.add_widget(self.sidePage.stack)
# Typing
page = SettingsPage()
settings = page.add_section(_("Key repeat"))
self.sidePage.stack.add_titled(page, "typing", _("Typing"))
switch = GSettingsSwitch(_("Enable key repeat"), "org.cinnamon.desktop.peripherals.keyboard", "repeat")
settings.add_row(switch)
slider = GSettingsRange(_("Repeat delay:"), "org.cinnamon.desktop.peripherals.keyboard", "delay", _("Short"), _("Long"), 100, 2000, show_value=False)
settings.add_reveal_row(slider, "org.cinnamon.desktop.peripherals.keyboard", "repeat")
slider = GSettingsRange(_("Repeat speed:"), "org.cinnamon.desktop.peripherals.keyboard", "repeat-interval", _("Slow"), _("Fast"), 20, 2000, log=True, show_value=False, flipped=True)
settings.add_reveal_row(slider, "org.cinnamon.desktop.peripherals.keyboard", "repeat")
settings = page.add_section(_("Text cursor"))
switch = GSettingsSwitch(_("Text cursor blinks"), "org.cinnamon.desktop.interface", "cursor-blink")
settings.add_row(switch)
slider = GSettingsRange(_("Blink speed:"), "org.cinnamon.desktop.interface", "cursor-blink-time", _("Slow"), _("Fast"), 100, 2500, show_value=False, flipped=True)
settings.add_reveal_row(slider, "org.cinnamon.desktop.interface", "cursor-blink")
# vbox.add(Gtk.Label.new(_("Test Box")))
# vbox.add(Gtk.Entry())
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
vbox.set_border_width(6)
vbox.set_spacing(6)
self.sidePage.stack.add_titled(vbox, "shortcuts", _("Shortcuts"))
self.sidePage.stack.connect("notify::visible-child-name", self.stack_page_changed)
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.new(_("To edit a keyboard binding, click it and press the new keys, or press backspace to clear it.")), False, False, 1)
paned = Gtk.Paned(orientation = Gtk.Orientation.HORIZONTAL)
paned.set_wide_handle(True)
left_vbox = Gtk.Box.new(Gtk.Orientation.VERTICAL, 2)
right_vbox = Gtk.Box.new(Gtk.Orientation.VERTICAL, 2)
self.search_vbox = Gtk.Box.new(Gtk.Orientation.HORIZONTAL, 2)
paned.add1(left_vbox)
right_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
paned.add2(right_box)
# Text entry search field
self.kb_search_entry = Gtk.Entry(placeholder_text=_("Type to search shortcuts"))
self.kb_search_handler_id = self.kb_search_entry.connect("changed", self.on_kb_search_changed)
# Binding entry search field
self.kb_search_frame = Gtk.Frame()
self.kb_search_frame.set_shadow_type(Gtk.ShadowType.IN)
frame_style = self.kb_search_frame.get_style_context()
frame_style.add_class("view")
self.color_found, self.placeholder_rgba = frame_style.lookup_color("placeholder_text_color")
self.kb_search_frame.set_no_show_all(True)
self.kb_search_binding = ButtonKeybinding()
self.kb_search_binding.set_valign(Gtk.Align.CENTER)
self.kb_search_binding.keybinding_cell.default_value = False
tooltip_text = _("Press Escape to cancel the search.")
self.kb_search_binding.set_tooltip_text(tooltip_text)
text_string = _("Click to search by accelerator")
self.kb_search_binding.keybinding_cell.text_string = text_string
if self.color_found:
self.kb_search_binding.keybinding_cell.set_property("foreground-rgba", self.placeholder_rgba)
self.kb_search_binding.connect('accel-edited', self.onSearchBindingChanged)
self.kb_search_binding.connect('accel-cleared', self.onSearchBindingCleared)
self.kb_search_frame.add(self.kb_search_binding)
# Search option dropdown
self.kb_search_type = Gtk.ComboBox()
options = [(_("Shortcuts"), "shortcuts"),
(_("Bindings"), "bindings")]
model = Gtk.ListStore(str, str)
for option in options:
model.append(option)
self.kb_search_type.set_model(model)
cell = Gtk.CellRendererText()
self.kb_search_type.pack_start(cell, False)
self.kb_search_type.add_attribute(cell, "text", 0)
self.kb_search_type.set_active(0)
self.kb_search_type.connect("changed", self.on_kb_search_type_changed)
# Search menu
self.search_vbox.pack_start(self.kb_search_entry, True, True, 2)
self.search_vbox.pack_start(self.kb_search_frame, True, True, 2)
self.search_vbox.pack_end(self.kb_search_type, False, False, 2)
right_box.pack_start(self.search_vbox, False, False, 2)
right_scroller = Gtk.ScrolledWindow.new(None, None)
right_scroller.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.NEVER)
right_scroller.add(right_vbox)
right_box.pack_start(right_scroller, True, True, 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, True, True, 2)
right_vbox.pack_start(entry_scroller, True, True, 2)
kb_name_scroller.set_property('min-content-height', 150)
self.cat_tree = Gtk.TreeView(enable_search=False, search_column=-1)
self.kb_tree = Gtk.TreeView(enable_search=False, search_column=-1)
self.entry_tree = Gtk.TreeView(enable_search=False, search_column=-1)
self.kb_tree.connect('row-activated', self.onCustomKeyBindingEdited)
self.kb_tree.connect('button-release-event', self.onContextMenuPopup)
self.kb_tree.connect('key-release-event', self.onContextMenuPopup)
self.kb_tree.connect('map', self.bindingHighlightOnMap)
self.kb_tree.connect('focus-in-event', self.bindingHighlightOnMap)
self.kb_tree.connect('unmap', self.bindingHighlightOnUnmap)
self.kb_tree.connect('focus-out-event', self.bindingHighlightOnUnmap)
self.kb_tree.connect('destroy', self.bindingHighlightOff)
self.entry_tree.connect('focus-in-event', self.bindingHighlightOnMap)
self.entry_tree.connect('focus-out-event', self.bindingHighlightOnUnmap)
left_vbox.pack_start(category_scroller, True, True, 2)
category_scroller.add(self.cat_tree)
category_scroller.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
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.AUTOMATIC)
buttonbox = Gtk.ButtonBox.new(Gtk.Orientation.HORIZONTAL)
self.add_custom_button = Gtk.Button.new_with_label(_("Add custom shortcut"))
self.add_custom_button.connect('clicked', self.onAddCustomButtonClicked)
self.remove_custom_button = Gtk.Button.new_with_label(_("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(paned, True, True, 2)
self.cat_store = Gtk.TreeStore(str, # Icon name or None
str, # The category name
object) # The category object
self.kb_root_store = Gtk.ListStore(str, # Keybinding name
object) # The keybinding object
self.kb_store = Gtk.TreeModelFilter(child_model=self.kb_root_store)
self.kb_store.set_visible_func(self.kb_store_visible_func)
self.entry_store = Gtk.ListStore(str) # Accel string
cell = Gtk.CellRendererText()
cell.set_alignment(0, 0)
pb_cell = Gtk.CellRendererPixbuf()
cat_column = Gtk.TreeViewColumn(_("Categories"))
cat_column.pack_start(pb_cell, False)
cat_column.pack_start(cell, True)
cat_column.add_attribute(pb_cell, "icon-name", 0)
cat_column.add_attribute(cell, "text", 1)
cat_column.set_alignment(0)
cat_column.set_property('min-width', 200)
self.cat_tree.append_column(cat_column)
self.cat_tree.connect("cursor-changed", self.onCategoryChanged)
self.cat_tree.connect("button-release-event", self.onCategorySelected)
self.cat_tree.connect("key-release-event", self.onCategorySelected)
self.cat_tree.connect("row-activated", self.onCategoryChanged)
self.cat_tree.connect("map", self.categoryHighlightOnMap)
self.cat_tree.connect("focus-in-event", self.categoryHighlightOnMap)
self.cat_tree.connect("unmap", self.categoryHighlightUnmap)
self.cat_tree.connect("destroy", self.categoryHighlightOff)
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_cell_data_func(kb_name_cell, self.kb_name_cell_data_func)
kb_column.set_alignment(.5)
self.kb_tree.append_column(kb_column)
self.kb_tree.connect("cursor-changed", self.onKeyBindingChanged)
entry_cell = CellRendererKeybinding(self.entry_tree)
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)
entry_column = Gtk.TreeViewColumn(_("Keyboard bindings"), entry_cell, accel_string=0)
entry_column.connect("clicked", self.bindingHighlightOnMap)
entry_column.set_alignment(.5)
self.entry_tree.append_column(entry_column)
self.entry_tree.set_tooltip_text(CellRendererKeybinding.TOOLTIP_TEXT)
self.current_category = None
self.main_store = []
settings = Gio.Settings.new(ENABLED_SCHEMA)
enabled_extensions = set()
enabled_spices = set()
for applets in settings.get_strv("enabled-applets"):
applet = applets.split(":")[3]
enabled_spices.add((applet, 'applets'))
for desklets in settings.get_strv("enabled-desklets"):
desklet = desklets.split(":")[0]
enabled_spices.add((desklet, 'desklets'))
for extension in settings.get_strv("enabled-extensions"):
enabled_extensions.add(extension)
enabled_spices.add((extension, 'extensions'))
keyboard_spices = sorted(enabled_spices)
spice_keybinds = {}
spice_properties = {}
for spice, _type in keyboard_spices:
for settings_dir in (OLD_SETTINGS_DIR, SETTINGS_DIR):
config_path = Path.joinpath(settings_dir, spice)
if Path.exists(config_path):
configs = [x for x in os.listdir(config_path) if x.endswith(".json")]
if not all(x.split(".json")[0].isdigit() for x in configs) and any(x.split(".json")[0].isdigit() for x in configs):
for index, value in enumerate(configs):
if not value.split(".json")[0].isdigit():
configs.pop(index)
for config in configs:
config_json = Path.joinpath(config_path, config)
_id = config.split(".json")[0]
key_name = f"{spice} {_id}" if _id.isdigit() else spice
with open(config_json, encoding="utf-8") as config_file:
_config = json.load(config_file)
for key, val in _config.items():
if isinstance(val, dict) and val.get("type") == "keybinding":
spice_properties.setdefault(key_name, {})
spice_properties[key_name]["highlight"] = spice not in enabled_extensions
spice_properties[key_name]["path"] = str(config_json)
spice_properties[key_name]["type"] = _type
spice_keybinds.setdefault(key_name, {})
spice_keybinds[key_name].setdefault(key, {})
spice_keybinds[key_name][key] = {val.get("description"): val.get("value").split("::")}
for spice, bindings in spice_keybinds.items():
name, *_id = spice.split()
properties = {spice: spice_properties[spice]}
_type = spice_properties[spice]["type"]
if "@cinnamon.org" in name:
with open(f"/usr/share/cinnamon/{_type}/{name}/metadata.json", encoding="utf-8") as metadata:
json_data = json.load(metadata)
category_label = _(json_data["name"])
else:
home = os.path.expanduser("~")
gettext.bindtextdomain(name, f"{home}/.local/share/locale")
gettext.textdomain(name)
try:
with open(f"{home}/.local/share/cinnamon/{_type}/{name}/metadata.json", encoding="utf-8") as metadata:
json_data = json.load(metadata)
category_label = gettext.gettext(_(json_data["name"]))
except FileNotFoundError:
continue
if not _id:
cat_label = category_label if category_label else name
CATEGORIES.append([cat_label, name, "spices", None, properties])
instance_num = 1
elif name != CATEGORIES[-1][2]:
cat_label = category_label if category_label else name
CATEGORIES.append([cat_label, name, "spices", None, None])
instance_num = 1
label = _("Instance") + f" {instance_num}"
CATEGORIES.append([label, f"{name}_{instance_num}", name, None, properties])
instance_num = 2
elif name == CATEGORIES[-1][2]:
label = _("Instance") + f" {instance_num}"
CATEGORIES.append([label, f"{name}_{instance_num}", name, None, properties])
instance_num += 1
properties = spice if spice_properties[spice]["highlight"] is True else None
for binding_key, binding_values in bindings.items():
if "@cinnamon.org" in name:
binding_label = _(list(binding_values.keys())[0])
else:
home = os.path.expanduser("~")
gettext.bindtextdomain(name, f"{home}/.local/share/locale")
gettext.textdomain(name)
binding_label = gettext.gettext(list(binding_values.keys())[0])
binding_schema = spice_properties[spice]["path"]
binding_category = f"{name}_{instance_num - 1}" if _id else name
KEYBINDINGS.append([binding_label, binding_schema, binding_key, binding_category, properties])
self.binding_categories[binding_category] = category_label
cat_lookup = {}
for cat in CATEGORIES:
cat_lookup[cat[1]] = cat[0]
elem = None
if len(cat) > 4:
elem = cat[4]
self.main_store.append(KeyBindingCategory(cat[0], cat[1], cat[2], cat[3], elem))
for binding in KEYBINDINGS:
self.binding_categories.setdefault(binding[3], cat_lookup[binding[3]])
for category in self.main_store:
if category.int_name == binding[3]:
elem = None
if len(binding) > 4:
elem = binding[4]
category.add(KeyBinding(binding[0], binding[1], binding[2], binding[3], elem))
cat_iters = {}
longest_cat_label = " "
for category in self.main_store:
if not category.parent:
cat_iters[category.int_name] = self.cat_store.append(None)
else:
cat_iters[category.int_name] = self.cat_store.append(cat_iters[category.parent])
if category.icon:
self.cat_store.set_value(cat_iters[category.int_name], 0, category.icon)
self.cat_store.set_value(cat_iters[category.int_name], 1, category.label)
self.cat_store.set_value(cat_iters[category.int_name], 2, category)
if len(category.label) > len(longest_cat_label):
longest_cat_label = category.label
layout = self.cat_tree.create_pango_layout(longest_cat_label)
w, *__ = layout.get_pixel_size()
paned.set_position(max(w, 200))
self.cat_tree.set_model(self.cat_store)
self.kb_tree.set_model(self.kb_store)
self.entry_tree.set_model(self.entry_store)
self.populate_kb_tree()
vbox.pack_start(headingbox, True, True, 0)
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
vbox.set_border_width(6)
vbox.set_spacing(6)
if util.get_session_type() != "wayland":
self.sidePage.stack.add_titled(vbox, "layouts", _("Layouts"))
try:
widget = self.sidePage.content_box.c_manager.get_c_widget("region")
except:
widget = None
if widget:
cheat_box = Gtk.Box.new(Gtk.Orientation.VERTICAL, 2)
cheat_box.pack_start(widget, True, True, 2)
cheat_box.set_vexpand(False)
widget.show()
vbox.pack_start(cheat_box, True, True, 0)
self.kb_search_entry.grab_focus()
def stack_page_changed(self, stack, pspec, data=None):
if stack.get_visible_child_name() == "shortcuts":
# we grab_focus() twice to work-around a potential search exception
self.cat_tree.grab_focus()
self.kb_search_entry.grab_focus()
def onCategorySelected(self, tree, event=None):
for mask in MASKS:
if hasattr(event, "state") and event.state & mask == mask:
return
# Remove the highlight due to a binding if it exists
if self.last_selected_binding:
self.bindingHighlightOnUnmap()
model, tree_iter = tree.get_selection().get_selected()
category = model.get_value(tree_iter, 2) if tree_iter else None
if category and self.search_choice == "bindings":
self.onSearchBindingCleared(None)
self.categoryHighlightOnMap()
if not category or not category.properties:
self.categoryHighlightUnmap()
return
# If the category hasn't changed, do nothing
if self.last_selected_category and next(iter(category.properties)) == next(iter(self.last_selected_category)):
self.categoryHighlightOnMap()
return
if hasattr(event, "type") and event.type != Gdk.EventType.FOCUS_CHANGE:
self.categoryHighlightUnmap()
self.last_selected_category = category.properties
# Turn highlighting on (if applicable) if the category switched
self.categoryHighlightOnMap()
def onCategoryChanged(self, tree):
self.kb_search_entry.handler_block(self.kb_search_handler_id)
self.kb_search_entry.set_text("")
self.kb_search_entry.handler_unblock(self.kb_search_handler_id)
if tree.get_selection():
categories, tree_iter = tree.get_selection().get_selected()
if tree_iter:
category = categories.get_value(tree_iter, 2)
self.current_category = category
self.kb_store.refilter()
self.remove_custom_button.set_property("sensitive", category.int_name == "custom")
def on_kb_search_changed(self, entry, data=None):
self.cat_tree.get_selection().unselect_all()
self.bindingHighlightOnUnmap()
self.current_category = None
self.last_selected_category = None
self.last_selected_binding = None
self.kb_store.refilter()
def on_kb_search_type_changed(self, entry):
model = self.kb_search_type.get_model()
option = self.kb_search_type.get_active()
self.search_choice = model[option][1]
if self.search_choice == "shortcuts":
self.onSearchBindingCleared(None)
self.kb_search_frame.hide()
self.kb_search_binding.hide()
self.kb_search_entry.show()
else:
self.kb_search_entry.handler_block(self.kb_search_handler_id)
self.kb_search_entry.set_text("")
self.kb_search_entry.handler_unblock(self.kb_search_handler_id)
self.kb_store.refilter()
self.kb_search_entry.hide()
self.kb_search_binding.show()
self.kb_search_frame.show()
self.bindingHighlightOnUnmap()
self.categoryHighlightUnmap()
def populate_kb_tree(self):
self.kb_root_store.clear()
self.current_category = None
self.kb_search_entry.handler_block(self.kb_search_handler_id)
self.kb_search_entry.set_text("")
self.kb_search_entry.handler_unblock(self.kb_search_handler_id)
for category in self.main_store:
for keybinding in category.keybindings:
self.kb_root_store.append((keybinding.label, keybinding))
self.loadCustoms()
def kb_name_cell_data_func(self, column, cell, model, tree_iter, data=None):
binding = model.get_value(tree_iter, 1)
if binding and self.kb_search_entry.get_text() or self.kb_search_binding.get_accel_string():
category = escape(self.binding_categories[binding.category])
__, *num = binding.category.split("_")
_id = f" {num[0]}" if num else ""
label = escape(binding.label)
markup = f"({category}{_id}) {label}"
cell.set_property("markup", markup)
else:
cell.set_property("text", binding.label)
def kb_store_visible_func(self, model, tree_iter, data=None):
if self.search_choice == "shortcuts":
if not self.current_category and not self.kb_search_entry.get_text():
return False
keybinding = self.kb_root_store.get_value(tree_iter, 1)
search = self.kb_search_entry.get_text().lower().strip()
if search:
return search in keybinding.label.lower().strip()
if self.current_category and hasattr(self.current_category, 'int_name'):
return keybinding.category == self.current_category.int_name
else:
if not self.current_category and not self.kb_search_binding.get_accel_string():
return False
keybinding = self.kb_root_store.get_value(tree_iter, 1)
search = self.kb_search_binding.get_accel_string()
if search:
entries = [Gtk.accelerator_parse_with_keycode(entry) for entry in keybinding.entries]
return Gtk.accelerator_parse_with_keycode(search) in entries
if self.current_category and hasattr(self.current_category, 'int_name'):
return keybinding.category == self.current_category.int_name
def loadCustoms(self):
tree_iter = self.kb_root_store.get_iter_first()
while tree_iter:
# Removing a row moves the iter to the next row, which may also be
# custom, so we don't want to call iter_next() until we hit a row
# that isn't, otherwise we may skip one.
keybinding = self.kb_root_store.get_value(tree_iter, 1)
if keybinding.category == "custom":
if not self.kb_root_store.remove(tree_iter):
break
continue
tree_iter = self.kb_root_store.iter_next(tree_iter)
parent = Gio.Settings.new(CUSTOM_KEYS_PARENT_SCHEMA)
custom_list = parent.get_strv("custom-list")
for entry in custom_list:
if entry == DUMMY_CUSTOM_ENTRY:
continue
custom_path = CUSTOM_KEYS_BASENAME+"/"+entry+"/"
schema = Gio.Settings.new_with_path(CUSTOM_KEYS_SCHEMA, custom_path)
custom_kb = CustomKeyBinding(entry,
schema.get_string("name"),
schema.get_string("command"),
schema.get_strv("binding"))
self.kb_root_store.append((custom_kb.label, custom_kb))
self.binding_categories.setdefault("custom", _("Custom Shortcuts"))
def onKeyBindingChanged(self, tree):
self.entry_store.clear()
if tree.get_selection():
keybindings, tree_iter = tree.get_selection().get_selected()
if tree_iter and self.search_choice == "bindings" and self.kb_search_binding.accel_string:
pass
elif tree_iter and self.search_choice == "bindings" and self.last_accel_string and self.kb_search_binding.accel_string:
if self.last_accel_string != self.kb_search_binding.accel_string:
if self.color_found:
self.kb_search_binding.keybinding_cell.set_property("foreground-rgba", self.placeholder_rgba)
self.last_accel_string = self.kb_search_binding.accel_string
self.kb_search_binding.keybinding_cell.set_value(None)
self.kb_search_binding.accel_string = ""
self.kb_search_binding.load_model()
if tree_iter:
keybinding = keybindings.get_value(tree_iter, 1)
for entry in keybinding.entries:
if entry != "_invalid_":
self.entry_store.append((entry,))
self.remove_custom_button.set_property('sensitive', isinstance(keybinding, CustomKeyBinding))
if self.search_choice == "bindings" and self.kb_search_binding.accel_string:
self.last_accel_string = self.kb_search_binding.accel_string
def onEntryChanged(self, cell, path, accel_string, accel_label, entry_store):
keybindings, kb_iter = self.kb_tree.get_selection().get_selected()
if kb_iter:
current_keybinding = keybindings.get_value(kb_iter, 1)
# Check for duplicates
for category in self.main_store:
for keybinding in category.keybindings:
for entry in keybinding.entries:
found = False
if Gtk.accelerator_parse_with_keycode(accel_string) == Gtk.accelerator_parse_with_keycode(entry):
found = True
if found and keybinding.label != current_keybinding.label:
dialog = Gtk.MessageDialog(None,
Gtk.DialogFlags.DESTROY_WITH_PARENT,
Gtk.MessageType.QUESTION,
Gtk.ButtonsType.YES_NO,
None)
dialog.set_default_size(400, 200)
msg = _("This key combination, %(combination)s is currently in use by %(old)s. ")
msg += _("If you continue, the combination will be reassigned to %(new)s.\n\n")
msg += _("Do you want to continue with this operation?")
dialog.set_markup(msg % {'combination': escape(accel_label), 'old': escape(keybinding.label), 'new': escape(current_keybinding.label)})
dialog.show_all()
response = dialog.run()
dialog.destroy()
if response == Gtk.ResponseType.YES:
keybinding.setBinding(keybinding.entries.index(entry), None)
else:
return
current_keybinding.setBinding(int(path), accel_string)
self.onKeyBindingChanged(self.kb_tree)
self.entry_tree.get_selection().select_path(path)
def onEntryCleared(self, cell, path, entry_store):
keybindings, kb_iter = self.kb_tree.get_selection().get_selected()
if kb_iter:
current_keybinding = keybindings.get_value(kb_iter, 1)
current_keybinding.setBinding(int(path), None)
self.onKeyBindingChanged(self.kb_tree)
self.entry_tree.get_selection().select_path(path)
def onSearchBindingChanged(self, cell, path, accel_string):
if self.color_found:
self.kb_search_binding.keybinding_cell.set_property("foreground-rgba", None)
self.kb_store.refilter()
self.current_category = None
self.cat_tree.get_selection().unselect_all()
self.bindingHighlightOff()
def onSearchBindingCleared(self, cell):
if self.color_found:
self.kb_search_binding.keybinding_cell.set_property("foreground-rgba", self.placeholder_rgba)
self.kb_search_binding.keybinding_cell.set_value(None)
self.kb_search_binding.accel_string = ""
self.kb_search_binding.load_model()
self.kb_store.refilter()
def onAddCustomButtonClicked(self, button):
dialog = AddCustomDialog(False)
dialog.show_all()
response = dialog.run()
if response in (Gtk.ResponseType.CANCEL, Gtk.ResponseType.DELETE_EVENT):
dialog.destroy()
return
parent = Gio.Settings.new(CUSTOM_KEYS_PARENT_SCHEMA)
array = parent.get_strv("custom-list")
num_array = []
for entry in array:
if entry == DUMMY_CUSTOM_ENTRY:
continue
num_array.append(int(entry.replace("custom", "")))
num_array.sort()
i = 0
while True:
if i in num_array:
i += 1
else:
break
new_str = "custom" + str(i)
array.append(new_str)
ensureCustomListChanges(array)
parent.set_strv("custom-list", array)
new_path = CUSTOM_KEYS_BASENAME + "/custom" + str(i) + "/"
new_schema = Gio.Settings.new_with_path(CUSTOM_KEYS_SCHEMA, new_path)
new_schema.set_string("name", dialog.name_entry.get_text())
new_schema.set_string("command", dialog.command_entry.get_text())
new_schema.set_strv("binding", ())
self.loadCustoms()
self.kb_store.refilter()
for index, cat in enumerate(self.cat_store):
if cat[2].int_name == "custom":
self.cat_tree.set_cursor(str(index), self.cat_tree.get_column(0), False)
for index, keybinding in enumerate(self.kb_store):
if keybinding[0] == dialog.name_entry.get_text():
self.kb_tree.set_cursor(str(index), self.kb_tree.get_column(0), False)
dialog.destroy()
def onRemoveCustomButtonClicked(self, button):
keybindings, tree_iter = self.kb_tree.get_selection().get_selected()
if tree_iter:
keybinding = keybindings.get_value(tree_iter, 1)
custom_path = CUSTOM_KEYS_BASENAME + "/" + keybinding.path + "/"
custom_schema = Gio.Settings.new_with_path(CUSTOM_KEYS_SCHEMA, custom_path)
custom_schema.delay()
custom_schema.reset("name")
custom_schema.reset("command")
custom_schema.reset("binding")
custom_schema.apply()
Gio.Settings.sync()
parent_settings = Gio.Settings(CUSTOM_KEYS_PARENT_SCHEMA)
array = parent_settings.get_strv("custom-list")
existing = False
for entry in array:
if keybinding.path == entry:
existing = True
break
if existing:
array.remove(keybinding.path)
ensureCustomListChanges(array)
parent_settings.set_strv("custom-list", array)
self.loadCustoms()
self.kb_store.refilter()
def onCustomKeyBindingEdited(self, kb_treeview, column, kb_column):
keybindings, tree_iter = kb_treeview.get_selection().get_selected()
if tree_iter:
keybinding = keybindings.get_value(tree_iter, 1)
if isinstance(keybinding, KeyBinding):
return
dialog = AddCustomDialog(True)
dialog.name_entry.set_text(keybinding.label)
dialog.command_entry.set_text(keybinding.action)
dialog.show_all()
response = dialog.run()
if response != Gtk.ResponseType.OK:
dialog.destroy()
return
keybinding.label = dialog.name_entry.get_text()
keybinding.action = dialog.command_entry.get_text()
keybinding.writeSettings()
for index, keybinding in enumerate(self.kb_store):
if keybinding[0] == dialog.name_entry.get_text():
self.kb_tree.set_cursor(str(index), self.kb_tree.get_column(0), False)
dialog.destroy()
self.loadCustoms()
self.kb_store.refilter()
def onContextMenuPopup(self, tree, event=None):
for mask in MASKS:
if hasattr(event, 'state') and event.state & mask == mask:
return
model, tree_iter = tree.get_selection().get_selected()
binding = model.get_value(tree_iter, 1) if tree_iter else None
if self.last_selected_binding and binding and hasattr(binding, "properties") and self.last_selected_binding != binding.properties:
self.bindingHighlightOnUnmap()
search_input_text = False
if self.kb_search_entry.get_text():
search_input_text = True
if binding and hasattr(binding, "category"):
for index, category in enumerate(self.cat_store):
if category[2].int_name == binding.category:
if not category[2].parent:
self.cat_tree.set_cursor(Gtk.TreePath(str(index)), None, False)
break
else:
for category in self.main_store:
if category.int_name == binding.category:
cat_iter = self.recurseCatTree(self.cat_store.get_iter_first(), binding.category)
_path = self.cat_store.get_path(cat_iter)
self.cat_tree.expand_to_path(_path)
self.cat_tree.set_cursor(_path)
break
if binding and hasattr(binding, "properties") and binding.properties:
if not self.current_category:
self.current_category = binding.properties
if self.last_selected_binding and self.last_selected_binding == binding.properties:
if event and event.type != Gdk.EventType.BUTTON_RELEASE or event.button != 3:
return
self.last_selected_binding = binding.properties
self.bindingHighlightOnMap()
if tree_iter:
if search_input_text or self.kb_search_binding.accel_string:
self.onSearchBindingCleared(None)
return
if isinstance(binding, CustomKeyBinding):
return
if event:
if event.type != Gdk.EventType.BUTTON_RELEASE or event.button != 3:
return
button = event.button
event_time = event.time
info = tree.get_path_at_pos(int(event.x), int(event.y))
if info:
path, col, *__ = info
tree.grab_focus()
tree.set_cursor(path, col, 0)
else:
path = model.get_path(tree_iter)
button = 0
event_time = 0
tree.grab_focus()
popup = Gtk.Menu()
popup.attach_to_widget(tree, None)
popup_reset_item = Gtk.MenuItem(_("Reset to default"))
popup_reset_item.show()
popup.append(popup_reset_item)
popup_reset_item.connect('activate', self.onResetToDefault, binding)
popup.popup(None, None, None, None, button, event_time)
return True
def recurseCatTree(self, tree_iter, binding_category):
result = None
model = self.cat_tree.get_model()
while not result and tree_iter:
category_name = model.get_value(tree_iter, 2).int_name
if category_name == binding_category:
result = tree_iter
break
if self.cat_store.iter_has_child(tree_iter):
child_iter = self.cat_store.iter_children(tree_iter)
result = self.recurseCatTree(child_iter, binding_category)
tree_iter = self.cat_store.iter_next(tree_iter)
return result
def onResetToDefault(self, popup, keybinding):
keybinding.resetDefaults()
self.onKeyBindingChanged(self.kb_tree)
def categoryHighlightOnMap(self, *args):
# Turn highlighting on (if applicable)
if not self.last_selected_category:
return
if self.last_selected_category and next(iter(self.last_selected_category.values())).get("highlight", False):
highlight_on = next(iter(self.last_selected_category))
_uuid, *_id = highlight_on.split()
_id = f"'{_id[0]}'" if _id else _uuid
subprocess.run(["/usr/bin/cinnamon-dbus-command", "highlightXlet",
_uuid, _id, "True"],
stdout=subprocess.DEVNULL, check=False)
def categoryHighlightUnmap(self, *args):
# Turn highlighting off (if applicable)
if self.last_selected_category and next(iter(self.last_selected_category.values())).get("highlight", False):
highlight_off = next(iter(self.last_selected_category))
_uuid, *_id = highlight_off.split()
_id = f"'{_id[0]}'" if _id else _uuid
subprocess.run(["/usr/bin/cinnamon-dbus-command", "highlightXlet",
_uuid, _id, "False"],
stdout=subprocess.DEVNULL, check=False)
def categoryHighlightOff(self, *args):
# Unset highlighting (if applicable) e.g. when closing the window
self.categoryHighlightUnmap()
self.last_selected_category = None
def bindingHighlightOnMap(self, *args):
# Turn highlighting on (if applicable)
if self.last_selected_binding:
_uuid, *_id = self.last_selected_binding.split()
_id = f"'{_id[0]}'" if _id else _uuid
subprocess.run(["/usr/bin/cinnamon-dbus-command", "highlightXlet",
_uuid, _id, "True"],
stdout=subprocess.DEVNULL, check=False)
def bindingHighlightOnUnmap(self, *args):
# Turn highlighting off (if applicable)
if self.last_selected_binding:
_uuid, *_id = self.last_selected_binding.split()
_id = f"'{_id[0]}'" if _id else _uuid
subprocess.run(["/usr/bin/cinnamon-dbus-command", "highlightXlet",
_uuid, _id, "False"],
stdout=subprocess.DEVNULL, check=False)
def bindingHighlightOff(self, *args):
# Unset highlighting (if applicable) e.g. when closing the window
self.bindingHighlightOnUnmap()
self.last_selected_binding = None
class KeyBindingCategory:
def __init__(self, label, int_name, parent, icon, properties=None):
self.label = label
self.parent = parent
self.icon = icon
self.int_name = int_name
self.properties = properties
self.keybindings = []
def add(self, keybinding):
self.keybindings.append(keybinding)
def clear(self):
del self.keybindings[:]
class KeyBinding:
def __init__(self, label, schema, key, category, properties=None):
self.key = key
self.category = category
self.label = label
self.schema = schema
self.entries = []
self.settings = Gio.Settings.new(schema) if "/" not in schema else schema
self.properties = properties
self.loadSettings()
def loadSettings(self):
del self.entries[:]
self.entries = self.get_array(self.settings.get_strv(self.key)) if "/" not in self.settings else self.getConfigSettings()
def getConfigSettings(self):
with open(self.schema, encoding="utf-8") as config_file:
config = json.load(config_file)
keybinds = config[self.key]["value"].split("::")
if len(keybinds) < 2:
keybinds.append("")
return keybinds
def get_array(self, raw_array):
result = []
for entry in raw_array:
result.append(entry)
while len(result) < 3:
result.append("")
return result
def setBinding(self, index, val):
self.entries[index] = val if val else ""
self.writeSettings()
def writeSettings(self):
array = []
for entry in self.entries:
if entry:
array.append(entry)
if "/" not in self.schema:
self.settings.set_strv(self.key, array)
else:
with open(self.schema, encoding="utf-8") as config_file:
config = json.load(config_file)
config[self.key]["value"] = "::".join(array) if array else "::"
with open(self.schema, "w", encoding="utf-8") as config_file:
config_file.write(json.dumps(config, indent=4))
def resetDefaults(self):
if "/" not in self.schema:
self.settings.reset(self.key)
else:
with open(self.schema, encoding="utf-8") as config_file:
config = json.load(config_file)
config[self.key]["value"] = config[self.key]["default"]
with open(self.schema, "w", encoding="utf-8") as config_file:
config_file.write(json.dumps(config, indent=4))
self.loadSettings()
class CustomKeyBinding:
def __init__(self, path, label, action, binding):
self.category = "custom"
self.path = path
self.label = label
self.action = action
self.entries = self.get_array(binding)
def get_array(self, raw_array):
result = []
for entry in raw_array:
result.append(entry)
while len(result) < 3:
result.append("")
return result
def setBinding(self, index, val):
self.entries[index] = val if val else ""
self.writeSettings()
def writeSettings(self):
custom_path = CUSTOM_KEYS_BASENAME+"/"+self.path+"/"
settings = Gio.Settings.new_with_path(CUSTOM_KEYS_SCHEMA, custom_path)
settings.set_string("name", self.label)
settings.set_string("command", self.action)
array = []
for entry in self.entries:
if entry:
array.append(entry)
settings.set_strv("binding", array)
# Touch the custom-list key, this will trigger a rebuild in cinnamon
parent = Gio.Settings.new(CUSTOM_KEYS_PARENT_SCHEMA)
custom_list = parent.get_strv("custom-list")
ensureCustomListChanges(custom_list)
parent.set_strv("custom-list", custom_list)
class AddCustomDialog(Gtk.Dialog):
def __init__(self, edit_mode):
if edit_mode:
ok_button_label = _("Update")
else:
ok_button_label = _("Add")
super(AddCustomDialog, self).__init__(_("Add custom shortcut"),
None,
0,
(ok_button_label, Gtk.ResponseType.OK,
_("Cancel"), Gtk.ResponseType.CANCEL))
self.set_default_size(350, 100)
name_box = Gtk.Box.new(Gtk.Orientation.HORIZONTAL, 2)
command_box = Gtk.Box.new(Gtk.Orientation.HORIZONTAL, 2)
name_box.pack_start(Gtk.Label.new(_("Name:")), False, False, 2)
command_box.pack_start(Gtk.Label.new(_("Command:")), False, False, 2)
self.name_entry = Gtk.Entry()
self.name_entry.connect('changed', self.onEntriesChanged)
self.command_entry = Gtk.Entry()
self.command_entry.connect('changed', self.onEntriesChanged)
name_box.pack_start(self.name_entry, True, True, 2)
command_box.pack_start(self.command_entry, True, True, 2)
self.file_picker = Gtk.FileChooserButton(_("Select a file"), Gtk.FileChooserAction.OPEN)
self.file_picker.connect('file-set', self.onFilePicked)
command_box.pack_start(self.file_picker, False, False, 2)
self.vbox.pack_start(name_box, True, True, 2)
self.vbox.pack_start(command_box, True, True, 2)
self.onEntriesChanged(self)
def onFilePicked(self, widget):
file = self.file_picker.get_file()
self.command_entry.set_text(file.get_path().replace(" ", r"\ "))
def onEntriesChanged(self, widget):
ok_enabled = self.name_entry.get_text().strip() and self.command_entry.get_text().strip()
self.set_response_sensitive(Gtk.ResponseType.OK, ok_enabled)