From 8c1809b64d6472ab282e6cb3af91abcf7aa9bc8b Mon Sep 17 00:00:00 2001
From: Sam Sebastian <sebastiansam55@gmail.com>
Date: Thu, 13 Apr 2023 10:11:59 -0400
Subject: [PATCH 01/20] Add documentation, clipboard macro

---
 lib/autokey/macro.py | 72 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 72 insertions(+)

diff --git a/lib/autokey/macro.py b/lib/autokey/macro.py
index 62cf7af5..11e7ddda 100644
--- a/lib/autokey/macro.py
+++ b/lib/autokey/macro.py
@@ -5,6 +5,8 @@
 from autokey.model.key import Key, KEY_SPLIT_RE
 from autokey import common
 
+import autokey.scripting
+
 
 if common.USED_UI_TYPE == "QT":
     from PyQt5.QtWidgets import QAction
@@ -83,6 +85,7 @@ def __init__(self, engine):
         self.macros.append(FileContentsMacro())
         self.macros.append(CursorMacro())
         self.macros.append(SystemMacro(engine))
+        self.macros.append(ClipboardMacro())
 
     def get_menu(self, callback, menu=None):
         if common.USED_UI_TYPE == "QT":
@@ -180,6 +183,9 @@ def do_process(self, sections, i):
 
 
 class CursorMacro(AbstractMacro):
+    """
+    C{<cursor>} - Positions the text cursor at the indicated text position. There may only be one <cursor> macro in a snippet.
+    """
 
     ID = "cursor"
     TITLE = _("Position cursor")
@@ -196,6 +202,28 @@ def do_process(self, sections, i):
 
 
 class ScriptMacro(AbstractMacro):
+    """
+    C{<script>} - Runs an autokey script. The script's stdout is inserted into the snippet.
+
+    As of 0.96.0, Scripts outside of autokey can be executed by passing their absolute path (including ~, which is expanded to $HOME) to name= instead of a description.
+
+    Currently, the args argument expects a string containing comma separated values (CSV). 
+    The data is split at the , signs and is available as a list containing strings using the engine.get_macro_arguments() function. 
+    If there is no comma in the input data, the resulting list will contain a single item. Currently, the args argument is required. 
+    So if you don't need it, just feed in some dummy value. This behaviour might be improved in the future.
+
+    Running a Script using the script macro poses some limitations:
+
+    The keyboard built-in cannot be used. It is available and can in theory be used to type, but actually using it will break the Phrase processing.
+        * Because all scripts are executed even before the trigger abbreviation is removed and the whole phrase is pasted/typed in one go, scripts can't be used to type anywhere in the phrase text.
+    Simple rule: Do nothing that alters the current system GUI state.
+        * Do not use keyboard to type/send keys.
+        * Do not use mouse to do mouse clicks anywhere.
+        * Do not use system.exec_command to execute GUI manipulation/automation tools, like xdotool.
+
+    You may use the script to alter background system state, like starting or stopping system services, but simply restricting yourself to reading data in will yield the best results.
+    """
+
 
     ID = "script"
     TITLE = _("Run script")
@@ -214,6 +242,13 @@ def do_process(self, sections, i):
 
 
 class SystemMacro(AbstractMacro):
+    """
+    C{<system>} - Runs a system command. The command's stdout is inserted into the snippet.
+
+    C{System.exec_command(args["command"], getOutput=True)} is used to run the command.
+
+    Example: C{<system command="ls -l">}
+    """
 
     ID = "system"
     TITLE = _("Run system command")
@@ -234,6 +269,15 @@ def do_process(self, sections, i):
 
 
 class DateMacro(AbstractMacro):
+    """
+    C{<date>} - Inserts the current date and time. Has a C{format} parameter that allows you to set the format of the date/time string.
+
+    Uses Python3's datetime.datetime.strftime() to format the date/time string.
+
+    See https://docs.python.org/3/library/datetime.html#strftime-strptime-behavior for a full list of options.
+
+    Example: C{<date format="%Y-%m-%d %H:%M:%S">}
+    """
 
     ID = "date"
     TITLE = _("Insert date")
@@ -249,6 +293,16 @@ def do_process(self, sections, i):
 
 
 class FileContentsMacro(AbstractMacro):
+    """
+    C{<file>} - Inserts the contents of a file. Has a C{name} parameter that allows you to set the name of the file.
+
+    Reads a file from disk and inserts the file content into the phrase. The name parameter takes an absolute file path.
+    The full file content is read into the system memory and then placed into the phrase, so restrict yourself to small text files.
+    When using a 1MB large file, autokey will need about one million key strokes to type the content.
+    Typically, text editors dislike raw binary data, so only use text files.
+
+    This can be used to include another Phrase by specifying its full file path and treating it like an ordinary file.
+    """
 
     ID = "file"
     TITLE = _("Insert file contents")
@@ -262,3 +316,21 @@ def do_process(self, sections, i):
             sections[i] = inputFile.read()
 
         return sections
+
+class ClipboardMacro(AbstractMacro):
+    """
+    C{<clipboard>} - Inserts the contents of the clipboard.
+    """
+
+
+    ID = "clipboard"
+    TITLE = _("Insert clipboard contents")
+    ARGS = []
+
+    def __init__(self):
+        self.clipboard = autokey.scripting.Clipboard()
+
+    def do_process(self, sections, i):
+        macro_type, macro = self._extract_macro(sections[i])
+        sections[i] = self.clipboard.get_clipboard()
+        return sections
\ No newline at end of file

From 2ad3ee24151789753b1f2955934eefe721d912d3 Mon Sep 17 00:00:00 2001
From: Sam Sebastian <sebastiansam55@gmail.com>
Date: Wed, 19 Apr 2023 20:42:07 -0400
Subject: [PATCH 02/20] Update documentation to work with sphinx better

---
 CHANGELOG.rst                               |  66 ++++----
 CONTRIBUTORS.rst                            |   1 +
 lib/autokey/configmanager/configmanager.py  |  22 +--
 lib/autokey/gtkapp.py                       |   4 +-
 lib/autokey/headless_app.py                 |   2 +-
 lib/autokey/model/abstract_abbreviation.py  |   2 +-
 lib/autokey/qtapp.py                        |   2 +-
 lib/autokey/scripting/abstract_clipboard.py |  16 +-
 lib/autokey/scripting/clipboard_gtk.py      |  18 +-
 lib/autokey/scripting/clipboard_qt.py       |  20 +--
 lib/autokey/scripting/clipboard_tkinter.py  |  14 +-
 lib/autokey/scripting/common.py             |  12 +-
 lib/autokey/scripting/dialog_gtk.py         | 102 ++++++------
 lib/autokey/scripting/dialog_qt.py          | 122 +++++++-------
 lib/autokey/scripting/engine.py             | 175 ++++++++++----------
 lib/autokey/scripting/highlevel.py          |  50 +++---
 lib/autokey/scripting/keyboard.py           |  75 +++++----
 lib/autokey/scripting/mouse.py              |  68 ++++----
 lib/autokey/scripting/system.py             |  10 +-
 lib/autokey/scripting/window.py             | 134 ++++++++-------
 lib/autokey/service.py                      |   6 +-
 21 files changed, 470 insertions(+), 451 deletions(-)

diff --git a/CHANGELOG.rst b/CHANGELOG.rst
index 8acb0da3..060fe9a2 100644
--- a/CHANGELOG.rst
+++ b/CHANGELOG.rst
@@ -88,7 +88,7 @@ Scripting API
 
 - Deprecated: Confusingly named engine.create_abbreviation() and engine.create_hotkey() are deprecated and will be removed in the future. Use engine.create_phrase() with appropriate arguments instead.
 - Extended: engine.create_phrase() now supports multiple new optional arguments, allowing to fully configure the created phrase. It can set everything the GUI can do.
-- New: Scripts can use engine.get_triggered_abbreviation() to read which abbreviation triggered it’s execution.
+- New: Scripts can use engine.get_triggered_abbreviation() to read which abbreviation triggered it's execution.
   The function returns a tuple containing the abbreviation and the trigger character (the character that 'completed' or 'confirmed' the abbreviation. Both tuple elements are None if the script was not triggered by an abbreviation. The trigger character is None if the script was configured to 'trigger immediately'. The function always returns a tuple, so direct tuple unpacking like abbreviation, trigger = engine.get_triggered_abbreviation() will always work.
 - Allow creation of 'temporary' hotkeys and whole folders (which do not persist between sessions).
 - Allow overriding existing hotkeys when creating phrases with hotkeys.
@@ -97,7 +97,7 @@ Scripting API
 **keyboard API object**
 
 - keyboard.send_keys() got a new optional parameter send_mode, allowing to specify how the given text is sent. It basically offers the same pasting options as are available to AutoKey Phrases.
-- keyboard.send_keys() now raises a TypeError instead of a generic AssertionError, if parameters don’t match the expected types.
+- keyboard.send_keys() now raises a TypeError instead of a generic AssertionError, if parameters don't match the expected types.
 
 **New clipboard API method**
 - Change the default phrase send mode to `ctrl+v` (paste using clipboard) rather than sending keys one at a time.
@@ -115,12 +115,12 @@ Scripting API
 
 
 Command line interface
-++++++++++++++++++++++
+^^^^^^^^^^^^^^^^^^^^^^
 
 - Added a --version command line switch. It prints the current AutoKey version on the standard output and then exits.
 
 Graphical user interfaces
-+++++++++++++++++++++++++
+^^^^^^^^^^^^^^^^^^^^^^^^^
 
 - (GTK) Warn user about missing required and optional programs on startup.
 - (GTK) UI will now update when changes are detected to watched files.
@@ -129,7 +129,7 @@ Graphical user interfaces
 - Add setting to change GtkSourceView theme, (defaults to classic).
 
 Other
-+++++
+^^^^^
 
 - Add `wait_for_keyevent` scripting function.
 - Rewrote script error logging system, with a neat Script Error Dialog to go with it.
@@ -149,20 +149,20 @@ Bug fixes
 - Both QT and GTK versions will reload hotkeys after a keymap change event.
 - Fix locking issue
 - Expose Alt_GR as a hotkey modifier on GTK.
-- (GTK) Fixed GUI lock-up, if multiple script error notifications are posted in quick succession. The notifications are now rate-limited and won’t post more than one notification per second. Fixes issue #383 
+- (GTK) Fixed GUI lock-up, if multiple script error notifications are posted in quick succession. The notifications are now rate-limited and won't post more than one notification per second. Fixes issue #383 
 
 Scripting API
-+++++++++++++
+^^^^^^^^^^^^^
 
 - Fixed API call `system.exec_command()` crashing, if output capturing is active, but the executed command has empty output. Fixes issue #379
 
 Packaging
-+++++++++
+^^^^^^^^^
 
 - Fixed AutoKey PNG icon size. Now, the icon size is 96x96 pixels, fixing Lintian warnings on Debian. Fixes issue #369
 
 Other changes
----------
+-------------
 
 - Add CI for testing
 - Update pip installation requirements
@@ -277,7 +277,7 @@ Bug fixes
 - Force AutoKey to exit, if the X server connection closes, most probably at logout or session end. Fixes issue #198
 
 Qt tray icon fixes and improvements
-+++++++++++++++++++++++++++++++++++
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 - Added »View script error« entry to the Tray icon context menu, like in the GTK GUI. Part of issue #158
 - Tray icon turns red, when scripts raise an error, like in the GTK GUI. Part of issue #158
@@ -384,28 +384,28 @@ Resurrected, re-written and cleaned up the `autokey-qt` Qt GUI. `autokey-qt` is
 dependent on currently supported libraries.
 
 Added improvements
-++++++++++++++++++
+^^^^^^^^^^^^^^^^^^
 - The main window now keeps its complete state when closed and re-opened (excluding complete application restarts). This includes the currently selected item(s) in the tree view on the left of the main window, selected text and cursor position in the editor on the right if currently editing a script or phrase.
 - The entries in the popup menu, that is shown when a hotkey assigned to a folder is pressed, now show icons based on their type (folder, phrase or script). This also works when items are configured to be shown in the system tray icon context menu.
 - The *A* autokey application icons are now always displayed correctly, both in the main window and the system tray icon.
-- Various menu actions now have system dependent keyboard shortcuts, that should adjust to the expected default of the user’s current platform/desktop environment.
+- Various menu actions now have system dependent keyboard shortcuts, that should adjust to the expected default of the user's current platform/desktop environment.
 - Added icons and descriptive tooltip texts to various buttons.
 - The `enable monitoring` checkboxes (both in the `Settings` menu and the tray icon context menu) now properly react to pressing the global hotkey for this action and thus stay in sync. (Even if the hotkey is used while the menu is shown.)
 
 Regressions
-+++++++++++
+^^^^^^^^^^^
 - Customizing the main window toolbar entries and keyboard shortcuts to trigger various UI actions is no longer possible. This feature was provided by the KDE4 libraries and is currently dropped.
 - The previous, KDE4-based About dialogue is replaced with a very minimalistic one.
 - The settings dialogue heavily used the KDE4 functionalities. During the port to Qt5, the dialogue lost some visual style, but all core functionality is kept.
 
 Runtime dependencies
-++++++++++++++++++++
+^^^^^^^^^^^^^^^^^^^^
 - Removed dependencies on deprecated and unmaintained PyQt4 and PyKDE4 libraries.
 - Removed dependency on `dbus.mainloop.qt`, instead use the DBus support built into Qt5.
 - Now depend on PyQt5, the Qt5 SVG module and the Qt5 QScintilla2 module.
 
 Build-time dependencies
-+++++++++++++++++++++++
+^^^^^^^^^^^^^^^^^^^^^^^
 Optionally depend on `pyrcc5` command line tool to compile Qt resources into a Python module.
 
 Qt UI files are no longer compiled using `pykdeuic4`, Removed the old compiler wrapper script in commit 6eeeb92f_.
@@ -413,11 +413,11 @@ Qt UI files are no longer compiled using `pykdeuic4`, Removed the old compiler w
 .. _6eeeb92f: https://github.com/autokey/autokey/commit/6eeeb92f14c694979c1367d51350c1e6509329b1
 
 Known bugs
-++++++++++
+^^^^^^^^^^
 The system tray icon is shown, but non-functional, after enabling it in the settings dialogue. AutoKey Qt has to be restarted for the tray icon to start working. This should have no impact on the normal daily use.
 
 Changed features
-++++++++++++++++
+^^^^^^^^^^^^^^^^
 The `hide tray icon` entry in the tray icon context menu now hides the icon for the current session only. The entry does not permanently disable the tray icon any more without any confirmation. Now, the only way to permanently disable the tray icon is through using the appropriate setting in the settings dialogue.
 
 Fixed the broken `Clipboard` and `Mouse selection` phrase paste modes
@@ -431,20 +431,20 @@ Scripting API Changes
 ---------------------
 
 Additions
-+++++++++
+^^^^^^^^^
 
 - Added a colour picker dialogue to the GTK dialog class, because the used `zenity` now supports it.
 - The picked colour is returned as three integers using the ColourData NamedTuple, providing both index based access and attribute  access, using the channel names (`r`, `g`, `b`). Additionally, ColourData provides some conversion methods.
 
 Breaking changes
-++++++++++++++++
+^^^^^^^^^^^^^^^^
 - See Pull request `#148`_. The `dialog` classes for user input in scripts now return typed NamedTuple tuples instead of plain tuples. This change is safe as long as users do not perform needlessly restrictive type checks in their scripts (e.g. `if type(returned_data) == type(tuple()): ...`). User scripts doing so will break.
 - The KDialog based colour picker now also returns a ColourData instance instead of a HTML style hex string, thus making this portable between both GTK and Qt GUIs. AutoKey users previously using the old KDE GUI and using the colour picker dialogue have to port their scripts. A simple fix is using the `html_code` property of the returned ColourData instance.
 
 .. _`#148`: https://github.com/autokey/autokey/pull/148
 
 Fixes
-+++++
+^^^^^
 - Re-introduce the newline trimming for system.exec_command() function. During the porting to Python 3, the newline trimming was removed, causing users various issues with unexpected newline characters at end of output. Now properly remove the _last_ newline at end of command output. (See issues `#75`_, `#92`_, `#145`_)
 - Applied various code style improvements to the scripting module.
 
@@ -537,18 +537,18 @@ Internal changes: Changed the data structure of the input stack.
 Version 0.93.0 <2014-02-27 Thu>
 ===============================
 
-Added functions “acknowledge_gnome_notification” and “move_to_pat”, more details `here`_.
+Added functions "acknowledge_gnome_notification" and "move_to_pat", more details `here`_.
 
 .. _here: https://github.com/autokey/autokey/blob/master/new_features.rst
 
 Version 0.92.0 <2014-02-21 Fri>
 ===============================
-Added an interactive shell launcher, “autokey-shell”. “autokey-shell” allows you to run some AutoKey functions interactively. Read `this`_ for more details.
+Added an interactive shell launcher, "autokey-shell". "autokey-shell" allows you to run some AutoKey functions interactively. Read `this`_ for more details.
 
 
 Version 0.91.0 <2014-02-14 Fri>
 ===============================
-Added a new function “click_on_pat” for use in user scripts. See `this`_ for more details.
+Added a new function "click_on_pat" for use in user scripts. See `this`_ for more details.
 
 .. _this: https://github.com/autokey/autokey/blob/master/new_features.rst
 
@@ -562,21 +562,21 @@ Python 3 related changes
 Python 3 is less tolerant of circular imports so some files were split into several files. Those pieces of the original have their file names prefixed with the original's.
 
 Bug fixes
-+++++++++
+^^^^^^^^^
 Eliminate possible deadlock.
 Changed
 
 .. code-block:: python
 
-        p = subprocess.Popen([…], stdout=subprocess.PIPE)
+        p = subprocess.Popen([...], stdout=subprocess.PIPE)
         retCode = p.wait()
         output = p.stdout.read()[:-1] # Drop trailing newline
 
 to
 
-.. code:: python
+.. code-block:: python
 
-        p = subprocess.Popen([…], stdout=subprocess.PIPE)
+        p = subprocess.Popen([...], stdout=subprocess.PIPE)
         output = p.communicate()[0].decode()[:-1] # Drop trailing newline
         retCode = p.returncode
 
@@ -584,7 +584,7 @@ The former may cause a deadlock, for more information, see `Python docs`_. This
 
 .. _Python docs: http://docs.python.org/3/library/subprocess.html#subprocess.Popen.wait
 
-For a “gi.repository.Notify.Notification” object, test if method “attach_to_status_icon” exists before calling. After this fix, errors in user scripts will trigger a notification.
+For a "gi.repository.Notify.Notification" object, test if method "attach_to_status_icon" exists before calling. After this fix, errors in user scripts will trigger a notification.
 
 Respect XDG standard. Details `here`__.
 
@@ -595,13 +595,13 @@ Corrected a typo in manpage of autokey-run.
 For the GTK GUI, after script error is viewed, tray icon is reverted back to original.
 
 Other changes
-+++++++++++++
-In setup.py, the “/usr/” prefix to the directory names in the data_files argument were removed to allow for non-root install.
+^^^^^^^^^^^^^
+In setup.py, the "/usr/" prefix to the directory names in the data_files argument were removed to allow for non-root install.
 
-Removed the “WINDOWID” environment variable so that zenity is not tied to the window from which it was launched.
+Removed the "WINDOWID" environment variable so that zenity is not tied to the window from which it was launched.
 
-Modified the launcher and other files to allow for editable installs (“pip install -e”).
+Modified the launcher and other files to allow for editable installs ("pip install -e").
 
-Added an “about” dialog for the Python 3 port.
+Added an "about" dialog for the Python 3 port.
 
 Changed hyperlink for bug reports.
diff --git a/CONTRIBUTORS.rst b/CONTRIBUTORS.rst
index b0b3dfc9..1fbd4cfc 100644
--- a/CONTRIBUTORS.rst
+++ b/CONTRIBUTORS.rst
@@ -7,6 +7,7 @@ Please add a line to CHANGELOG.rst when creating PRs
 Please make sure tests pass before you submit PRs. To ensure this happens automatically, I recommend adding the following lines to the file `.git/hooks/pre-push`:
 
 .. code:: sh
+
     remote="$1"
     url="$2"
 
diff --git a/lib/autokey/configmanager/configmanager.py b/lib/autokey/configmanager/configmanager.py
index c51881d5..e97ace22 100644
--- a/lib/autokey/configmanager/configmanager.py
+++ b/lib/autokey/configmanager/configmanager.py
@@ -597,7 +597,7 @@ def config_altered(self, persistGlobal):
         Called when some element of configuration has been altered, to update
         the lists of phrases/folders.
 
-        @param persistGlobal: save the global configuration at the end of the process
+        :param persistGlobal: save the global configuration at the end of the process
         """
         logger.info("Configuration changed - rebuilding in-memory structures")
 
@@ -698,9 +698,9 @@ def check_abbreviation_unique(self, abbreviation, filterPattern, targetItem):
         """
         Checks that the given abbreviation is not already in use.
 
-        @param abbreviation: the abbreviation to check
-        @param filterPattern: The filter pattern associated with the abbreviation
-        @param targetItem: the phrase for which the abbreviation to be used
+        :param abbreviation: the abbreviation to check
+        :param filterPattern: The filter pattern associated with the abbreviation
+        :param targetItem: the phrase for which the abbreviation to be used
         """
         for item in itertools.chain(self.allFolders, self.allItems):
             if ConfigManager.item_has_abbreviation(item, abbreviation) and \
@@ -750,10 +750,10 @@ def check_hotkey_unique(self, modifiers, hotKey, newFilterPattern, targetItem):
         Checks that the given hotkey is not already in use. Also checks the
         special hotkeys configured from the advanced settings dialog.
 
-        @param modifiers: modifiers for the hotkey
-        @param hotKey: the hotkey to check
-        @param newFilterPattern:
-        @param targetItem: the phrase for which the hotKey to be used
+        :param modifiers: modifiers for the hotkey
+        :param hotKey: the hotkey to check
+        :param newFilterPattern:
+        :param targetItem: the phrase for which the hotKey to be used
         """
         item = self.get_item_with_hotkey(modifiers, hotKey, newFilterPattern)
         if item:
@@ -767,9 +767,9 @@ def get_item_with_hotkey(self, modifiers, hotKey, newFilterPattern=None):
         special hotkeys configured from the advanced settings dialog.
         Checks folders first, then phrases, then special hotkeys.
 
-        @param modifiers: modifiers for the hotkey
-        @param hotKey: the hotkey to check
-        @param newFilterPattern:
+        :param modifiers: modifiers for the hotkey
+        :param hotKey: the hotkey to check
+        :param newFilterPattern:
         """
         for item in self.globalHotkeys:
             if item.enabled and ConfigManager.item_has_same_hotkey(item,
diff --git a/lib/autokey/gtkapp.py b/lib/autokey/gtkapp.py
index 7379bcb1..571f7b24 100644
--- a/lib/autokey/gtkapp.py
+++ b/lib/autokey/gtkapp.py
@@ -141,7 +141,7 @@ def notify_error(self, error: autokey.model.script.ScriptErrorRecord):
         """
         Show an error notification popup.
 
-        @param error: The error that occurred in a Script
+        :param error: The error that occurred in a Script
         """
         message = "The script '{}' encountered an error".format(error.script_name)
         self.notifier.notify_error(message)
@@ -177,7 +177,7 @@ def show_error_dialog(self, message, details=None, dialog_type=Gtk.MessageType.E
         """
         Convenience method for showing an error dialog.
 
-        @param dialog_type: One of Gtk.MessageType.ERROR, Gtk.MessageType.WARNING , Gtk.MessageType.INFO, Gtk.MessageType.OTHER, Gtk.MessageType.QUESTION
+        :param dialog_type: One of Gtk.MessageType.ERROR, Gtk.MessageType.WARNING , Gtk.MessageType.INFO, Gtk.MessageType.OTHER, Gtk.MessageType.QUESTION
             defaults to Gtk.MessageType.ERROR
         """
         # TODO check if gtk threads entered.
diff --git a/lib/autokey/headless_app.py b/lib/autokey/headless_app.py
index 27679dc9..d8cac539 100644
--- a/lib/autokey/headless_app.py
+++ b/lib/autokey/headless_app.py
@@ -74,7 +74,7 @@ def shutdown(self):
     #     """
     #     Show an error notification popup.
 
-    #     @param error: The error that occurred in a Script
+    #     :param error: The error that occurred in a Script
     #     """
     #     message = "The script '{}' encountered an error".format(error.script_name)
     #     self.notifier.notify_error(message)
diff --git a/lib/autokey/model/abstract_abbreviation.py b/lib/autokey/model/abstract_abbreviation.py
index 08a55965..8b8f348d 100644
--- a/lib/autokey/model/abstract_abbreviation.py
+++ b/lib/autokey/model/abstract_abbreviation.py
@@ -106,7 +106,7 @@ def _should_trigger_abbreviation(self, buffer):
         Checks whether, based on the settings for the abbreviation and the given input,
         the abbreviation should trigger.
 
-        @param buffer Input buffer to be checked (as string)
+        :param buffer Input buffer to be checked (as string)
         """
         return any(self.__checkInput(buffer, abbr) for abbr in self.abbreviations)
 
diff --git a/lib/autokey/qtapp.py b/lib/autokey/qtapp.py
index c149548f..50dd066d 100644
--- a/lib/autokey/qtapp.py
+++ b/lib/autokey/qtapp.py
@@ -123,7 +123,7 @@ def notify_error(self, error: autokey.model.script.ScriptErrorRecord):
         """
         Show an error notification popup.
 
-        @param error: The error that occurred in a Script
+        :param error: The error that occurred in a Script
         """
         message = "The script '{}' encountered an error".format(error.script_name)
         self.exec_in_main(self.notifier.notify_error, message)
diff --git a/lib/autokey/scripting/abstract_clipboard.py b/lib/autokey/scripting/abstract_clipboard.py
index be69f87c..b182d4db 100644
--- a/lib/autokey/scripting/abstract_clipboard.py
+++ b/lib/autokey/scripting/abstract_clipboard.py
@@ -37,7 +37,7 @@ def fill_clipboard(self, contents: str):
 
         Usage: C{clipboard.fill_clipboard(contents)}
 
-        @param contents: string to be placed in the selection
+        :param contents: string to be placed in the selection
         """
         return
     @abstractmethod
@@ -47,8 +47,8 @@ def get_clipboard(self):
 
         Usage: C{clipboard.get_clipboard()}
 
-        @return: text contents of the clipboard
-        @rtype: C{str}
+        :return: text contents of the clipboard
+        :rtype: C{str}
         """
         return
 
@@ -59,7 +59,7 @@ def fill_selection(self, contents: str):
 
         Usage: C{clipboard.fill_selection(contents)}
 
-        @param contents: string to be placed in the selection
+        :param contents: string to be placed in the selection
         """
         return
     @abstractmethod
@@ -70,8 +70,8 @@ def get_selection(self):
 
         Usage: C{clipboard.get_selection()}
 
-        @return: text contents of the mouse selection
-        @rtype: C{str}
+        :return: text contents of the mouse selection
+        :rtype: C{str}
         """
         return
 
@@ -82,7 +82,7 @@ def set_clipboard_image(self, path: str):
 
         Usage: C{clipboard.set_clipboard_image(path)}
 
-        @param path: Path to image file
-        @raise OSError: If path does not exist
+        :param path: Path to image file
+        :raise OSError: If path does not exist
         """
         return
diff --git a/lib/autokey/scripting/clipboard_gtk.py b/lib/autokey/scripting/clipboard_gtk.py
index cdad37f7..640016aa 100644
--- a/lib/autokey/scripting/clipboard_gtk.py
+++ b/lib/autokey/scripting/clipboard_gtk.py
@@ -35,7 +35,7 @@ def __init__(self, app=None):
 
         Usage: Called when GtkClipboard is imported
 
-        @param app: refers to the application instance
+        :param app: refers to the application instance
         """
 
         self._clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
@@ -57,7 +57,7 @@ def fill_selection(self, contents):
 
         Usage: C{clipboard.fill_selection(contents)}
 
-        @param contents: string to be placed in the selection
+        :param contents: string to be placed in the selection
         """
         Gdk.threads_enter()
         try:
@@ -75,8 +75,8 @@ def get_selection(self):
 
         Usage: C{clipboard.get_selection()}
 
-        @return: text contents of the mouse selection
-        @rtype: C{str}
+        :return: text contents of the mouse selection
+        :rtype: C{str}
         """
         Gdk.threads_enter()
         text = self._selection.wait_for_text()
@@ -93,7 +93,7 @@ def fill_clipboard(self, contents):
 
         Usage: C{clipboard.fill_clipboard(contents)}
 
-        @param contents: string to be placed in the selection
+        :param contents: string to be placed in the selection
         """
         Gdk.threads_enter()
         if Gtk.get_major_version() >= 3:
@@ -108,8 +108,8 @@ def get_clipboard(self):
 
         Usage: C{clipboard.get_clipboard()}
 
-        @return: text contents of the clipboard
-        @rtype: C{str}
+        :return: text contents of the clipboard
+        :rtype: C{str}
         """
         Gdk.threads_enter()
         text = self._clipboard.wait_for_text()
@@ -127,8 +127,8 @@ def set_clipboard_image(self, path):
 
         Usage: C{clipboard.set_clipboard_image(path)}
 
-        @param path: Path to image file
-        @raise OSError: If path does not exist
+        :param path: Path to image file
+        :raise OSError: If path does not exist
 
         """
         image_path = Path(path).expanduser()
diff --git a/lib/autokey/scripting/clipboard_qt.py b/lib/autokey/scripting/clipboard_qt.py
index ace8e5b3..5c48c57f 100644
--- a/lib/autokey/scripting/clipboard_qt.py
+++ b/lib/autokey/scripting/clipboard_qt.py
@@ -23,7 +23,7 @@ def __init__(self, app=None):
 
         Usage: Called when QtClipboard is imported.
 
-        @param app: refers to the application instance
+        :param app: refers to the application instance
         """
         self.clipBoard = QApplication.clipboard()
         """
@@ -51,7 +51,7 @@ def fill_selection(self, contents):
 
         Usage: C{clipboard.fill_selection(contents)}
 
-        @param contents: string to be placed in the selection
+        :param contents: string to be placed in the selection
         """
         self.__execAsync(self.__fillSelection, contents)
 
@@ -61,7 +61,7 @@ def __fillSelection(self, string):
 
         Sets the selection text to the C{string} value
 
-        @param string: Value to change the selection to
+        :param string: Value to change the selection to
         """
         self.clipBoard.setText(string, QClipboard.Selection)
         if self.app:
@@ -73,8 +73,8 @@ def get_selection(self):
 
         Usage: C{clipboard.get_selection()}
 
-        @return: text contents of the mouse selection
-        @rtype: C{str}
+        :return: text contents of the mouse selection
+        :rtype: C{str}
         """
         self.__execAsync(self.__getSelection)
         return str(self.text)
@@ -90,7 +90,7 @@ def fill_clipboard(self, contents):
 
         Usage: C{clipboard.fill_clipboard(contents)}
 
-        @param contents: string to be placed in the selection
+        :param contents: string to be placed in the selection
         """
         self.__execAsync(self.__fillClipboard, contents)
 
@@ -100,8 +100,8 @@ def set_clipboard_image(self, path):
 
         Usage: C{clipboard.set_clipboard_image(path)}
 
-        @param path: Path to image file
-        @raise OSError: If path does not exist
+        :param path: Path to image file
+        :raise OSError: If path does not exist
         """
         self.__execAsync(self.__set_clipboard_image, path)
 
@@ -125,8 +125,8 @@ def get_clipboard(self):
 
         Usage: C{clipboard.get_clipboard()}
 
-        @return: text contents of the clipboard
-        @rtype: C{str}
+        :return: text contents of the clipboard
+        :rtype: C{str}
         """
         self.__execAsync(self.__getClipboard)
         return str(self.text)
diff --git a/lib/autokey/scripting/clipboard_tkinter.py b/lib/autokey/scripting/clipboard_tkinter.py
index f0537e35..c25aa0e8 100644
--- a/lib/autokey/scripting/clipboard_tkinter.py
+++ b/lib/autokey/scripting/clipboard_tkinter.py
@@ -44,7 +44,7 @@ def fill_selection(self, contents):
 
         Usage: C{clipboard.fill_selection(contents)}
 
-        @param contents: string to be placed in the selection
+        :param contents: string to be placed in the selection
         """
         logger.error("Headless app clipboard does not support setting selection clipboard")
         pass
@@ -58,8 +58,8 @@ def get_selection(self):
 
         Usage: C{clipboard.get_selection()}
 
-        @return: text contents of the mouse selection
-        @rtype: C{str}
+        :return: text contents of the mouse selection
+        :rtype: C{str}
         """
         text = self.tkroot.selection_get(selection="PRIMARY")
         if text is not None:
@@ -74,7 +74,7 @@ def fill_clipboard(self, contents):
 
         Usage: C{clipboard.fill_clipboard(contents)}
 
-        @param contents: string to be placed in the selection
+        :param contents: string to be placed in the selection
         """
         self.tkroot.clipboard_clear()
         self.tkroot.clipboard_append(contents)
@@ -90,8 +90,8 @@ def get_clipboard(self):
 
         Usage: C{clipboard.get_clipboard()}
 
-        @return: text contents of the clipboard
-        @rtype: C{str}
+        :return: text contents of the clipboard
+        :rtype: C{str}
         """
         text = self.tkroot.selection_get(selection="CLIPBOARD")
         if text is not None:
@@ -106,7 +106,7 @@ def set_clipboard_image(self, path):
 
         Usage: C{clipboard.set_clipboard_image(path)}
 
-        @param path: Path to image file
+        :param path: Path to image file
         """
         logger.error("Headless app clipboard does not support setting clipboard to image.")
         pass
diff --git a/lib/autokey/scripting/common.py b/lib/autokey/scripting/common.py
index 162630f5..a67d8c26 100644
--- a/lib/autokey/scripting/common.py
+++ b/lib/autokey/scripting/common.py
@@ -42,9 +42,9 @@ def from_html(html_style_colour_str: str):
         """
         Parser for KDialog output, which outputs a HTML style hex code like #55aa00
 
-        @param html_style_colour_str: HTML style hex string encoded colour. (#rrggbb)
-        @return: ColourData instance
-        @rtype: ColourData
+        :param html_style_colour_str: HTML style hex string encoded colour. (#rrggbb)
+        :return: ColourData instance
+        :rtype: ColourData
         """
         html_style_colour_str = html_style_colour_str.lstrip("#")
         components = list(map("".join, zip(*[iter(html_style_colour_str)]*2)))
@@ -56,9 +56,9 @@ def from_zenity_tuple_str(zenity_tuple_str: str):
         Parser for Zenity output, which outputs a named tuple-like string: "rgb(R, G, B)", where R, G, B are base10
         integers.
         
-        @param zenity_tuple_str: tuple-like string: "rgb(r, g, b), where r, g, b are base10 integers.
-        @return: ColourData instance
-        @rtype: ColourData
+        :param zenity_tuple_str: tuple-like string: "rgb(r, g, b), where r, g, b are base10 integers.
+        :return: ColourData instance
+        :rtype: ColourData
         """
         components = zenity_tuple_str.strip("rgb()").split(",")
         return ColourData(*map(int, components))
diff --git a/lib/autokey/scripting/dialog_gtk.py b/lib/autokey/scripting/dialog_gtk.py
index 5215d9ca..fc223393 100644
--- a/lib/autokey/scripting/dialog_gtk.py
+++ b/lib/autokey/scripting/dialog_gtk.py
@@ -50,11 +50,11 @@ def send_notification(self, title, message, icon="autokey", **kwargs):
         """
         Sends a notification using C{zenity}
 
-        @param title: Title to be used in the notification
-        @param message: Message displayed in the notification
-        @param icon: Icon for zenity to use. Defaults to Autokey icon
-        @return: A tuple containing the exit code and user input
-        @rtype: C{tuple(int, str)}
+        :param title: Title to be used in the notification
+        :param message: Message displayed in the notification
+        :param icon: Icon for zenity to use. Defaults to Autokey icon
+        :return: A tuple containing the exit code and user input
+        :rtype: C{tuple(int, str)}
 
         """
         return self._run_zenity("Autokey Notification", ["--notification", "--text", title+"\n"+message, "--window-icon", icon], kwargs)
@@ -65,10 +65,10 @@ def info_dialog(self, title="Information", message="", **kwargs):
 
         Usage: C{dialog.info_dialog(title="Information", message="", **kwargs)}
 
-        @param title: window title for the dialog
-        @param message: message displayed in the dialog
-        @return: a tuple containing the exit code and user input
-        @rtype: C{tuple(int, str)}
+        :param title: window title for the dialog
+        :param message: message displayed in the dialog
+        :return: a tuple containing the exit code and user input
+        :rtype: C{tuple(int, str)}
         """
         return self._run_zenity(title, ["--info", "--text", message], kwargs)
 
@@ -78,11 +78,11 @@ def input_dialog(self, title="Enter a value", message="Enter a value", default="
 
         Usage: C{dialog.input_dialog(title="Enter a value", message="Enter a value", default="", **kwargs)}
 
-        @param title: window title for the dialog
-        @param message: message displayed above the input box
-        @param default: default value for the input box
-        @return: a tuple containing the exit code and user input
-        @rtype: C{DialogData(int, str)}
+        :param title: window title for the dialog
+        :param message: message displayed above the input box
+        :param default: default value for the input box
+        :return: a tuple containing the exit code and user input
+        :rtype: C{DialogData(int, str)}
         """
         return self._run_zenity(title, ["--entry", "--text", message, "--entry-text", default], kwargs)
 
@@ -92,10 +92,10 @@ def password_dialog(self, title="Enter password", message="Enter password", **kw
 
         Usage: C{dialog.password_dialog(title="Enter password", message="Enter password")}
 
-        @param title: window title for the dialog
-        @param message: message displayed above the password input box
-        @return: a tuple containing the exit code and user input
-        @rtype: C{DialogData(int, str)}
+        :param title: window title for the dialog
+        :param message: message displayed above the password input box
+        :return: a tuple containing the exit code and user input
+        :rtype: C{DialogData(int, str)}
         """
         return self._run_zenity(title, ["--entry", "--text", message, "--hide-text"], kwargs)
 
@@ -105,9 +105,9 @@ def password_dialog(self, title="Enter password", message="Enter password", **kw
         
         Usage: C{dialog.combo_menu(options, title="Choose an option", message="Choose an option")}
         
-        @param options: list of options (strings) for the dialog
-        @param title: window title for the dialog
-        @param message: message displayed above the combobox      
+        :param options: list of options (strings) for the dialog
+        :param title: window title for the dialog
+        :param message: message displayed above the combobox      
         """
         #return self._run_zenity(title, ["--combobox", message] + options)
 
@@ -117,12 +117,12 @@ def list_menu(self, options, title="Choose a value", message="Choose a value", d
 
         Usage: C{dialog.list_menu(options, title="Choose a value", message="Choose a value", default=None, **kwargs)}
 
-        @param options: list of options (strings) for the dialog
-        @param title: window title for the dialog
-        @param message: message displayed above the list
-        @param default: default value to be selected
-        @return: a tuple containing the exit code and user choice
-        @rtype: C{DialogData(int, str)}
+        :param options: list of options (strings) for the dialog
+        :param title: window title for the dialog
+        :param message: message displayed above the list
+        :param default: default value to be selected
+        :return: a tuple containing the exit code and user choice
+        :rtype: C{DialogData(int, str)}
         """
 
         choices = []
@@ -146,12 +146,12 @@ def list_menu_multi(self, options, title="Choose one or more values", message="C
 
         Usage: C{dialog.list_menu_multi(options, title="Choose one or more values", message="Choose one or more values", defaults=[], **kwargs)}
 
-        @param options: list of options (strings) for the dialog
-        @param title: window title for the dialog
-        @param message: message displayed above the list
-        @param defaults: list of default values to be selected
-        @return: a tuple containing the exit code and user choice
-        @rtype: C{DialogData(int, List[str])}
+        :param options: list of options (strings) for the dialog
+        :param title: window title for the dialog
+        :param message: message displayed above the list
+        :param defaults: list of default values to be selected
+        :return: a tuple containing the exit code and user choice
+        :rtype: C{DialogData(int, List[str])}
         """
 
         if defaults is None:
@@ -178,9 +178,9 @@ def open_file(self, title="Open File", **kwargs):
 
         Usage: C{dialog.open_file(title="Open File", **kwargs)}
 
-        @param title: window title for the dialog
-        @return: a tuple containing the exit code and file path
-        @rtype: C{DialogData(int, str)}
+        :param title: window title for the dialog
+        :return: a tuple containing the exit code and file path
+        :rtype: C{DialogData(int, str)}
         """
         #if rememberAs is not None:
         #    return self._run_zenity(title, ["--getopenfilename", initialDir, fileTypes, ":" + rememberAs])
@@ -193,9 +193,9 @@ def save_file(self, title="Save As", **kwargs):
 
         Usage: C{dialog.save_file(title="Save As", **kwargs)}
 
-        @param title: window title for the dialog
-        @return: a tuple containing the exit code and file path
-        @rtype: C{DialogData(int, str)}
+        :param title: window title for the dialog
+        :return: a tuple containing the exit code and file path
+        :rtype: C{DialogData(int, str)}
         """
         #if rememberAs is not None:
         #    return self._run_zenity(title, ["--getsavefilename", initialDir, fileTypes, ":" + rememberAs])
@@ -208,10 +208,10 @@ def choose_directory(self, title="Select Directory", initialDir="~", **kwargs):
 
         Usage: C{dialog.choose_directory(title="Select Directory", **kwargs)}
 
-        @param title: window title for the dialog
-        @param initialDir:
-        @return: a tuple containing the exit code and path
-        @rtype: C{DialogData(int, str)}
+        :param title: window title for the dialog
+        :param initialDir:
+        :return: a tuple containing the exit code and path
+        :rtype: C{DialogData(int, str)}
         """
         #if rememberAs is not None:
         #    return self._run_zenity(title, ["--getexistingdirectory", initialDir, ":" + rememberAs])
@@ -224,9 +224,9 @@ def choose_colour(self, title="Select Colour", **kwargs):
 
         Usage: C{dialog.choose_colour(title="Select Colour")}
 
-        @param title: window title for the dialog
-        @return:
-        @rtype: C{DialogData(int, Optional[ColourData])}
+        :param title: window title for the dialog
+        :return:
+        :rtype: C{DialogData(int, Optional[ColourData])}
         """
         return_data = self._run_zenity(title, ["--color-selection"], kwargs)
         if return_data.successful:
@@ -241,11 +241,11 @@ def calendar(self, title="Choose a date", format_str="%Y-%m-%d", date="today", *
 
         Usage: C{dialog.calendar_dialog(title="Choose a date", format="%Y-%m-%d", date="YYYY-MM-DD", **kwargs)}
 
-        @param title: window title for the dialog
-        @param format_str: format of date to be returned
-        @param date: initial date as YYYY-MM-DD, otherwise today
-        @return: a tuple containing the exit code and date
-        @rtype: C{DialogData(int, str)}
+        :param title: window title for the dialog
+        :param format_str: format of date to be returned
+        :param date: initial date as YYYY-MM-DD, otherwise today
+        :return: a tuple containing the exit code and date
+        :rtype: C{DialogData(int, str)}
         """
         if re.match(r"[0-9]{4}-[0-9]{2}-[0-9]{2}", date):
             year = date[0:4]
diff --git a/lib/autokey/scripting/dialog_qt.py b/lib/autokey/scripting/dialog_qt.py
index 93a93a2d..f3259d7b 100644
--- a/lib/autokey/scripting/dialog_qt.py
+++ b/lib/autokey/scripting/dialog_qt.py
@@ -50,12 +50,12 @@ def send_notification(self, title, message, icon="autokey", timeout="10", **kwar
         """
         Sends a passive popup (notification) using C{kdialog}
 
-        @param title: Title to be used in the notification
-        @param message: Message to be displayed in the notification
-        @param icon: Icon to be used in the notification (Defaults to "autokey")
-        @param timeout: How long the notification will be on screen (Defaults to 10)
-        @return: A tuple containing the exit code and user input
-        @rtype: C{DialogData(int, str)}
+        :param title: Title to be used in the notification
+        :param message: Message to be displayed in the notification
+        :param icon: Icon to be used in the notification (Defaults to "autokey")
+        :param timeout: How long the notification will be on screen (Defaults to 10)
+        :return: A tuple containing the exit code and user input
+        :rtype: C{DialogData(int, str)}
         """
         return self._run_kdialog(title, ["--title", title, "--passivepopup", message, "--icon", icon, str(timeout)], kwargs)
 
@@ -65,10 +65,10 @@ def info_dialog(self, title="Information", message="", **kwargs):
 
         Usage: C{dialog.info_dialog(title="Information", message="", **kwargs)}
 
-        @param title: window title for the dialog
-        @param message: message displayed in the dialog
-        @return: a tuple containing the exit code and user input
-        @rtype: C{DialogData(int, str)}
+        :param title: window title for the dialog
+        :param message: message displayed in the dialog
+        :return: a tuple containing the exit code and user input
+        :rtype: C{DialogData(int, str)}
         """
         return self._run_kdialog(title, ["--msgbox", message], kwargs)
 
@@ -78,11 +78,11 @@ def input_dialog(self, title="Enter a value", message="Enter a value", default="
 
         Usage: C{dialog.input_dialog(title="Enter a value", message="Enter a value", default="", **kwargs)}
 
-        @param title: window title for the dialog
-        @param message: message displayed above the input box
-        @param default: default value for the input box
-        @return: a tuple containing the exit code and user input
-        @rtype: C{DialogData(int, str)}
+        :param title: window title for the dialog
+        :param message: message displayed above the input box
+        :param default: default value for the input box
+        :return: a tuple containing the exit code and user input
+        :rtype: C{DialogData(int, str)}
         """
         return self._run_kdialog(title, ["--inputbox", message, default], kwargs)
 
@@ -92,10 +92,10 @@ def password_dialog(self, title="Enter password", message="Enter password", **kw
 
         Usage: C{dialog.password_dialog(title="Enter password", message="Enter password", **kwargs)}
 
-        @param title: window title for the dialog
-        @param message: message displayed above the password input box
-        @return: a tuple containing the exit code and user input
-        @rtype: C{DialogData(int, str)}
+        :param title: window title for the dialog
+        :param message: message displayed above the password input box
+        :return: a tuple containing the exit code and user input
+        :rtype: C{DialogData(int, str)}
         """
         return self._run_kdialog(title, ["--password", message], kwargs)
 
@@ -105,11 +105,11 @@ def combo_menu(self, options, title="Choose an option", message="Choose an optio
 
         Usage: C{dialog.combo_menu(options, title="Choose an option", message="Choose an option", **kwargs)}
 
-        @param options: list of options (strings) for the dialog
-        @param title: window title for the dialog
-        @param message: message displayed above the combobox
-        @return: a tuple containing the exit code and user choice
-        @rtype: C{DialogData(int, str)}
+        :param options: list of options (strings) for the dialog
+        :param title: window title for the dialog
+        :param message: message displayed above the combobox
+        :return: a tuple containing the exit code and user choice
+        :rtype: C{DialogData(int, str)}
         """
         return self._run_kdialog(title, ["--combobox", message] + options, kwargs)
 
@@ -119,12 +119,12 @@ def list_menu(self, options, title="Choose a value", message="Choose a value", d
 
         Usage: C{dialog.list_menu(options, title="Choose a value", message="Choose a value", default=None, **kwargs)}
 
-        @param options: list of options (strings) for the dialog
-        @param title: window title for the dialog
-        @param message: message displayed above the list
-        @param default: default value to be selected
-        @return: a tuple containing the exit code and user choice
-        @rtype: C{DialogData(int, str)}
+        :param options: list of options (strings) for the dialog
+        :param title: window title for the dialog
+        :param message: message displayed above the list
+        :param default: default value to be selected
+        :return: a tuple containing the exit code and user choice
+        :rtype: C{DialogData(int, str)}
         """
 
         choices = []
@@ -150,12 +150,12 @@ def list_menu_multi(self, options, title="Choose one or more values", message="C
 
         Usage: C{dialog.list_menu_multi(options, title="Choose one or more values", message="Choose one or more values", defaults=[], **kwargs)}
 
-        @param options: list of options (strings) for the dialog
-        @param title: window title for the dialog
-        @param message: message displayed above the list
-        @param defaults: list of default values to be selected
-        @return: a tuple containing the exit code and user choice
-        @rtype: C{DialogData(int, List[str])}
+        :param options: list of options (strings) for the dialog
+        :param title: window title for the dialog
+        :param message: message displayed above the list
+        :param defaults: list of default values to be selected
+        :return: a tuple containing the exit code and user choice
+        :rtype: C{DialogData(int, List[str])}
         """
 
         if defaults is None:
@@ -184,12 +184,12 @@ def open_file(self, title="Open File", initialDir="~", fileTypes="*|All Files",
 
         Usage: C{dialog.open_file(title="Open File", initialDir="~", fileTypes="*|All Files", rememberAs=None, **kwargs)}
 
-        @param title: window title for the dialog
-        @param initialDir: starting directory for the file dialog
-        @param fileTypes: file type filter expression
-        @param rememberAs: gives an ID to this file dialog, allowing it to open at the last used path next time
-        @return: a tuple containing the exit code and file path
-        @rtype: C{DialogData(int, str)}
+        :param title: window title for the dialog
+        :param initialDir: starting directory for the file dialog
+        :param fileTypes: file type filter expression
+        :param rememberAs: gives an ID to this file dialog, allowing it to open at the last used path next time
+        :return: a tuple containing the exit code and file path
+        :rtype: C{DialogData(int, str)}
         """
         if rememberAs is not None:
             return self._run_kdialog(title, ["--getopenfilename", initialDir, fileTypes, ":" + rememberAs], kwargs)
@@ -202,12 +202,12 @@ def save_file(self, title="Save As", initialDir="~", fileTypes="*|All Files", re
 
         Usage: C{dialog.save_file(title="Save As", initialDir="~", fileTypes="*|All Files", rememberAs=None, **kwargs)}
 
-        @param title: window title for the dialog
-        @param initialDir: starting directory for the file dialog
-        @param fileTypes: file type filter expression
-        @param rememberAs: gives an ID to this file dialog, allowing it to open at the last used path next time
-        @return: a tuple containing the exit code and file path
-        @rtype: C{DialogData(int, str)}
+        :param title: window title for the dialog
+        :param initialDir: starting directory for the file dialog
+        :param fileTypes: file type filter expression
+        :param rememberAs: gives an ID to this file dialog, allowing it to open at the last used path next time
+        :return: a tuple containing the exit code and file path
+        :rtype: C{DialogData(int, str)}
         """
         if rememberAs is not None:
             return self._run_kdialog(title, ["--getsavefilename", initialDir, fileTypes, ":" + rememberAs], kwargs)
@@ -220,11 +220,11 @@ def choose_directory(self, title="Select Directory", initialDir="~", rememberAs=
 
         Usage: C{dialog.choose_directory(title="Select Directory", initialDir="~", rememberAs=None, **kwargs)}
 
-        @param title: window title for the dialog
-        @param initialDir: starting directory for the directory chooser dialog
-        @param rememberAs: gives an ID to this file dialog, allowing it to open at the last used path next time
-        @return: a tuple containing the exit code and chosen path
-        @rtype: C{DialogData(int, str)}
+        :param title: window title for the dialog
+        :param initialDir: starting directory for the directory chooser dialog
+        :param rememberAs: gives an ID to this file dialog, allowing it to open at the last used path next time
+        :return: a tuple containing the exit code and chosen path
+        :rtype: C{DialogData(int, str)}
         """
         if rememberAs is not None:
             return self._run_kdialog(title, ["--getexistingdirectory", initialDir, ":" + rememberAs], kwargs)
@@ -237,9 +237,9 @@ def choose_colour(self, title="Select Colour", **kwargs):
 
         Usage: C{dialog.choose_colour(title="Select Colour")}
 
-        @param title: window title for the dialog
-        @return: a tuple containing the exit code and colour
-        @rtype: C{DialogData(int, str)}
+        :param title: window title for the dialog
+        :return: a tuple containing the exit code and colour
+        :rtype: C{DialogData(int, str)}
         """
         return_data = self._run_kdialog(title, ["--getcolor"], kwargs)
         if return_data.successful:
@@ -255,10 +255,10 @@ def calendar(self, title="Choose a date", format_str="%Y-%m-%d", date="today", *
 
         Note: the format and date parameters are not currently used
 
-        @param title: window title for the dialog
-        @param format_str: format of date to be returned
-        @param date: initial date as YYYY-MM-DD, otherwise today
-        @return: a tuple containing the exit code and date
-        @rtype: C{DialogData(int, str)}
+        :param title: window title for the dialog
+        :param format_str: format of date to be returned
+        :param date: initial date as YYYY-MM-DD, otherwise today
+        :return: a tuple containing the exit code and date
+        :rtype: C{DialogData(int, str)}
         """
         return self._run_kdialog(title, ["--calendar", title], kwargs)
diff --git a/lib/autokey/scripting/engine.py b/lib/autokey/scripting/engine.py
index f86e9767..7eab38ef 100644
--- a/lib/autokey/scripting/engine.py
+++ b/lib/autokey/scripting/engine.py
@@ -77,14 +77,14 @@ def create_folder(self, title: str, parent_folder=None, temporary=False):
 
         Descriptions for the optional arguments:
 
-        @param parentFolder: Folder to make this folder a subfolder of. If
-        passed as a folder, it will be that folder within auotkey.
-        If passed as pathlib.Path, it will be created or added at that path.
-        Paths expand ~ to $HOME.
-        @param temporary: Folders created with temporary=True are
-                                    not persisted.
-                                    Used for single-source rc-style scripts.
-                                    Cannot be used if parent_folder is a Path.
+        :param parentFolder: Folder to make this folder a subfolder of. If
+            passed as a folder, it will be that folder within AutoKey.
+            If passed as pathlib.Path, it will be created or added at that path.
+            Paths expand ~ to $HOME.
+        :param temporary: Folders created with temporary=True are
+            not persisted.
+            Used for single-source rc-style scripts.
+            Cannot be used if parent_folder is a Path.
 
         If a folder of that name already exists, this will return it unchanged.
         If the folder wasn't already added to autokey, it will be.
@@ -171,12 +171,14 @@ def create_phrase(self, folder, name: str, contents: str,
         element and an unshifted (lowercase) key as the second element.
         Modifier keys must be given as a list of strings (or Key enum instances), with the following
         values permitted:
-            <ctrl>
-            <alt>
-            <super>
-            <hyper>
-            <meta>
-            <shift>
+        
+        - <ctrl>
+        - <alt>
+        - <super>
+        - <hyper>
+        - <meta>
+        - <shift>
+
         The key must be an unshifted character (i.e. lowercase) or a Key enum instance. Modifier keys from the list
         above are NOT allowed here. Example: (["<ctrl>", "<alt>"], "9") to assign "<Ctrl>+<Alt>+9" as a hotkey.
         The Key enum contains objects representing various special keys and is available as an attribute of the "engine"
@@ -187,41 +189,43 @@ def create_phrase(self, folder, name: str, contents: str,
         using the clipboard. It accepts items from the SendMode enumeration, which is also available from the engine
         object as engine.SendMode. The parameter defaults to
         engine.SendMode.KEYBOARD. Available send modes are:
-            KEYBOARD
-            CB_CTRL_V
-            CB_CTRL_SHIFT_V
-            CB_SHIFT_INSERT
-            SELECTION
+
+        - KEYBOARD
+        - CB_CTRL_V
+        - CB_CTRL_SHIFT_V
+        - CB_SHIFT_INSERT
+        - SELECTION
+
         To paste the Phrase using "<shift>+<insert>, set send_mode=engine.SendMode.CB_SHIFT_INSERT
 
         window_filter: Accepts a string which will be used as a regular expression to match window titles or
         applications using the WM_CLASS attribute.
 
-        @param folder: folder to place the abbreviation in, retrieved using C{engine.get_folder()}
-        @param name: Name/description for the phrase.
-        @param contents: the expansion text
-        @param abbreviations: Can be a single string or a list (or other iterable) of strings. Assigned to the Phrase
-        @param hotkey: A tuple containing a keyboard combination that will be assigned as a hotkey.
-                       First element is a list of modifiers, second element is the key.
-        @param send_mode: The pasting mode that will be used to expand the Phrase.
-                          Used to configure, how the Phrase is expanded. Defaults to typing using the "CTRL+V" method.
-        @param window_filter: A string containing a regular expression that will be used as the window filter.
-        @param show_in_system_tray: A boolean defaulting to False.
-                                    If set to True, the new Phrase will be shown in the tray icon context menu.
-        @param always_prompt: A boolean defaulting to False. If set to True,
-                              the Phrase expansion has to be manually confirmed, each time it is triggered.
-        @param temporary: Hotkeys created with temporary=True are
-                                    not persisted as .jsons, and are replaced if the description is not
-                                    unique within the folder.
-                                     Used for single-source rc-style scripts.
-        @param replace_existing_hotkey: If true, instead of warning if the hotkey
+        :param folder: folder to place the abbreviation in, retrieved using C{engine.get_folder()}
+        :param name: Name/description for the phrase.
+        :param contents: the expansion text
+        :param abbreviations: Can be a single string or a list (or other iterable) of strings. Assigned to the Phrase
+        :param hotkey: A tuple containing a keyboard combination that will be assigned as a hotkey.
+            First element is a list of modifiers, second element is the key.
+        :param send_mode: The pasting mode that will be used to expand the Phrase.
+            Used to configure, how the Phrase is expanded. Defaults to typing using the "CTRL+V" method.
+        :param window_filter: A string containing a regular expression that will be used as the window filter.
+        :param show_in_system_tray: A boolean defaulting to False.
+            If set to True, the new Phrase will be shown in the tray icon context menu.
+        :param always_prompt: A boolean defaulting to False. If set to True,
+            the Phrase expansion has to be manually confirmed, each time it is triggered.
+        :param temporary: Hotkeys created with temporary=True are
+            not persisted as .jsons, and are replaced if the description is not
+            unique within the folder.
+            Used for single-source rc-style scripts.
+        :param replace_existing_hotkey: If true, instead of warning if the hotkey
             is already in use by another phrase or folder, it removes the hotkey
             from those clashes and keeps this phrase's hotkey.
-        @raise ValueError: If a given abbreviation or hotkey is already in use or parameters are otherwise invalid
-        @return The created Phrase object. This object is NOT considered part of the public API and exposes the raw
-          internals of AutoKey. Ignore it, if you don’t need it or don’t know what to do with it.
-          It can be used for _really_ advanced use cases, where further customizations are desired. Use at your own
-          risk. No guarantees are made about the object’s structure. Read the AutoKey source code for details.
+        :raise ValueError: If a given abbreviation or hotkey is already in use or parameters are otherwise invalid
+        :return: The created Phrase object. This object is NOT considered part of the public API and exposes the raw
+            internals of AutoKey. Ignore it, if you don't need it or don't know what to do with it.
+            It can be used for _really_ advanced use cases, where further customizations are desired. Use at your own
+            risk. No guarantees are made about the object's structure. Read the AutoKey source code for details.
         """
 
         validateArguments(folder, name, contents,
@@ -284,11 +288,11 @@ def create_abbreviation(self, folder, description, abbr, contents):
         When the given abbreviation is typed, it will be replaced with the given
         text.
 
-        @param folder: folder to place the abbreviation in, retrieved using C{engine.get_folder()}
-        @param description: description for the phrase
-        @param abbr: the abbreviation that will trigger the expansion
-        @param contents: the expansion text
-        @raise Exception: if the specified abbreviation is not unique
+        :param folder: folder to place the abbreviation in, retrieved using C{engine.get_folder()}
+        :param description: description for the phrase
+        :param abbr: the abbreviation that will trigger the expansion
+        :param contents: the expansion text
+        :raise Exception: if the specified abbreviation is not unique
         """
         if not self.configManager.check_abbreviation_unique(abbr, None, None)[0]:
             raise Exception("The specified abbreviation is already in use")
@@ -305,7 +309,6 @@ def create_abbreviation(self, folder, description, abbr, contents):
     def create_hotkey(self, folder, description, modifiers, key, contents):
         """
         DEPRECATED. Use engine.create_phrase() with appropriate keyword arguments instead.
-
         Create a text hotkey
 
         Usage: C{engine.create_hotkey(folder, description, modifiers, key, contents)}
@@ -314,21 +317,21 @@ def create_hotkey(self, folder, description, modifiers, key, contents):
         text. Modifiers must be given as a list of strings, with the following
         values permitted:
 
-        <ctrl>
-        <alt>
-        <super>
-        <hyper>
-        <meta>
-        <shift>
+        - <ctrl>
+        - <alt>
+        - <super>
+        - <hyper>
+        - <meta>
+        - <shift>
 
         The key must be an unshifted character (i.e. lowercase)
 
-        @param folder: folder to place the abbreviation in, retrieved using C{engine.get_folder()}
-        @param description: description for the phrase
-        @param modifiers: modifiers to use with the hotkey (as a list)
-        @param key: the hotkey
-        @param contents: the expansion text
-        @raise Exception: if the specified hotkey is not unique
+        :param folder: folder to place the abbreviation in, retrieved using C{engine.get_folder()}
+        :param description: description for the phrase
+        :param modifiers: modifiers to use with the hotkey (as a list)
+        :param key: the hotkey
+        :param contents: the expansion text
+        :raise Exception: if the specified hotkey is not unique
         """
         modifiers.sort()
         if not self.configManager.check_hotkey_unique(modifiers, key, None, None)[0]:
@@ -349,9 +352,9 @@ def run_script(self, description, *args, **kwargs):
 
         Usage: C{engine.run_script(description, 'foo', 'bar', foobar='foobar'})}
 
-        @param description: description of the script to run. If parsable as
-        an absolute path to an existing file, that will be run instead.
-        @raise Exception: if the specified script does not exist
+        :param description: description of the script to run. If parsable as
+            an absolute path to an existing file, that will be run instead.
+        :raise Exception: if the specified script does not exist
         """
         self._script_args = args
         self._script_kwargs = kwargs
@@ -401,8 +404,8 @@ def get_script_arguments(self):
 
         Usage: C{engine.get_script_arguments()}
 
-        @return: the arguments
-        @rtype: C{list[Any]}
+        :return: the arguments
+        :rtype: C{list[Any]}
         """
         return self._script_args
 
@@ -413,8 +416,8 @@ def get_script_keyword_arguments(self):
 
         Usage: C{engine.get_script_keyword_arguments()}
 
-        @return: the arguments
-        @rtype: C{Dict[str, Any]}
+        :return: the arguments
+        :rtype: C{Dict[str, Any]}
         """
         return self._script_kwargs
 
@@ -424,8 +427,8 @@ def get_macro_arguments(self):
 
         Usage: C{engine.get_macro_arguments()}
 
-        @return: the arguments
-        @rtype: C{list(str())}
+        :return: the arguments
+        :rtype: C{list(str())}
         """
         return self._macro_args
 
@@ -435,7 +438,7 @@ def set_return_value(self, val):
 
         Usage: C{engine.set_return_value(val)}
 
-        @param val: value to be stored
+        :param val: value to be stored
         """
         self._return_value = val
 
@@ -450,15 +453,15 @@ def _get_return_value(self):
     def _set_triggered_abbreviation(self, abbreviation: str, trigger_character: str):
         """
         Used internally by AutoKey to provide the abbreviation and trigger that caused the script to execute.
-        @param abbreviation: Abbreviation that caused the script to execute
-        @param trigger_character: Possibly empty "trigger character". As defined in the abbreviation configuration.
+        :param abbreviation: Abbreviation that caused the script to execute
+        :param trigger_character: Possibly empty "trigger character". As defined in the abbreviation configuration.
         """
         self._triggered_abbreviation = abbreviation
         self._triggered_character = trigger_character
 
     def get_triggered_abbreviation(self) -> Tuple[Optional[str], Optional[str]]:
         """
-        This function can be queried by a script to get the abbreviation text that triggered it’s execution.
+        This function can be queried by a script to get the abbreviation text that triggered it's execution.
 
         If a script is triggered by an abbreviation, this function returns a tuple containing two strings. First element
         is the abbreviation text. The second element is the trigger character that finally caused the execution. It is
@@ -472,8 +475,8 @@ def get_triggered_abbreviation(self) -> Tuple[Optional[str], Optional[str]]:
         You can determine if the script was triggered by an abbreviation by simply testing the truth value of the first
         returned value.
 
-        @return: Abbreviation that triggered the script execution, if any.
-        @rtype: C{Tuple[Optional[str], Optional[str]]}
+        :return: Abbreviation that triggered the script execution, if any.
+        :rtype: C{Tuple[Optional[str], Optional[str]]}
         """
         return self._triggered_abbreviation, self._triggered_character
 
@@ -499,8 +502,8 @@ def validateAbbreviations(abbreviations):
     """
     Checks if the given abbreviations are a list/iterable of strings
 
-    @param abbreviations: Abbreviations list to be validated
-    @raise ValueError: Raises C{ValueError} if C{abbreviations} is anything other than C{str} or C{Iterable}
+    :param abbreviations: Abbreviations list to be validated
+    :raise ValueError: Raises C{ValueError} if C{abbreviations} is anything other than C{str} or C{Iterable}
     """
     if abbreviations is None:
         return
@@ -522,10 +525,10 @@ def check_abbreviation_unique(configmanager, abbreviations, window_filter):
     """
     Checks if the given abbreviations are unique
 
-    @param configmanager: ConfigManager Instance to check abbrevations
-    @param abbreviations: List of abbreviations to be checked
-    @param window_filter: Window filter that the abbreviation will apply to.
-    @raise ValueError: Raises C{ValueError} if an abbreviation is already in use.
+    :param configmanager: ConfigManager Instance to check abbrevations
+    :param abbreviations: List of abbreviations to be checked
+    :param window_filter: Window filter that the abbreviation will apply to.
+    :raise ValueError: Raises C{ValueError} if an abbreviation is already in use.
     """
     if not abbreviations:
         return
@@ -538,9 +541,9 @@ def check_hotkey_unique(configmanager, hotkey, window_filter):
     """
     Checks if the given hotkey is unique
 
-    @param configmanager: ConfigManager Instance used to check hotkey
-    @param hotkey: hotkey to be check if unique
-    @param window_filter: Window filter to be applied to the hotkey
+    :param configmanager: ConfigManager Instance used to check hotkey
+    :param hotkey: hotkey to be check if unique
+    :param window_filter: Window filter to be applied to the hotkey
     """
     if not hotkey:
         return
@@ -553,8 +556,8 @@ def isValidHotkeyType(item):
     """
     Checks if the hotkey is valid.
 
-    @param item: Hotkey to be checked
-    @return: Returns C{True} if hotkey is valid, C{False} otherwise
+    :param item: Hotkey to be checked
+    :return: Returns C{True} if hotkey is valid, C{False} otherwise
     """
     fail=False
     if isinstance(item, Key):
diff --git a/lib/autokey/scripting/highlevel.py b/lib/autokey/scripting/highlevel.py
index b55f6411..7162792d 100644
--- a/lib/autokey/scripting/highlevel.py
+++ b/lib/autokey/scripting/highlevel.py
@@ -35,13 +35,13 @@ def visgrep(scr: str, pat: str, tolerance: int = 0) -> int:
 
     
 
-    @param scr: path of PNG image to be grepped.
-    @param pat: path of pattern image (PNG) to look for in scr.
-    @param tolerance: An integer ≥ 0 to specify the level of tolerance for 'fuzzy' matches.
-    @raise ValueError: Raised if tolerance is negative or not convertable to int
-    @raise PatternNotFound: Raised if C{pat} not found.
-    @raise FileNotFoundError: Raised if either file is not found
-    @returns: Coordinates of the topleft point of the match, if any. Raises L{PatternNotFound} exception otherwise.
+    :param scr: path of PNG image to be grepped.
+    :param pat: path of pattern image (PNG) to look for in scr.
+    :param tolerance: An integer ≥ 0 to specify the level of tolerance for 'fuzzy' matches.
+    :raise ValueError: Raised if tolerance is negative or not convertable to int
+    :raise PatternNotFound: Raised if C{pat} not found.
+    :raise FileNotFoundError: Raised if either file is not found
+    :returns: Coordinates of the topleft point of the match, if any. Raises L{PatternNotFound} exception otherwise.
     """
     tol = int(tolerance)
     if tol < 0:
@@ -68,9 +68,9 @@ def get_png_dim(filepath: str) -> int:
     Usage: C{get_png_dim(filepath:str) -> (int)}
 
     Finds the dimension of a PNG.
-    @param filepath: file path of the PNG.
-    @returns: (width, height).
-    @raise Exception: Raised if the file is not a png
+    :param filepath: file path of the PNG.
+    :returns: (width, height).
+    :raise Exception: Raised if the file is not a png
     """
     if not imghdr.what(filepath) == 'png':
         raise Exception("not PNG")
@@ -82,9 +82,9 @@ def mouse_move(x: int, y: int, display: str=''):
     """
     Moves the mouse using xte C{mousemove} from xautomation
 
-    @param x: x location to move the mouse to
-    @param y: y location to move the mouse to
-    @param display: X display to pass to C{xte}
+    :param x: x location to move the mouse to
+    :param y: y location to move the mouse to
+    :param display: X display to pass to C{xte}
     """
     subprocess.call(['xte', '-x', display, "mousemove {} {}".format(int(x), int(y))])
 
@@ -93,9 +93,9 @@ def mouse_rmove(x: int, y: int, display: str=''):
     """
     Moves the mouse using xte C{mousermove} command from xautomation
 
-    @param x: x location to move the mouse to
-    @param y: y location to move the mouse to
-    @param display: X display to pass to C{xte}
+    :param x: x location to move the mouse to
+    :param y: y location to move the mouse to
+    :param display: X display to pass to C{xte}
     """
     subprocess.call(['xte', '-x', display, "mousermove {} {}".format(int(x), int(y))])
 
@@ -104,8 +104,8 @@ def mouse_click(button: int, display: str=''):
     """
     Clicks the mouse in the current location using xte C{mouseclick} from xautomation
 
-    @param button: Which button signal to send from the mouse
-    @param display: X display to pass to C{xte}
+    :param button: Which button signal to send from the mouse
+    :param display: X display to pass to C{xte}
     """
     subprocess.call(['xte', '-x', display, "mouseclick {}".format(int(button))])
 
@@ -114,7 +114,7 @@ def mouse_pos():
     """
     Returns the current location of the mouse.
 
-    @returns: Returns the mouse location in a C{list}
+    :returns: Returns the mouse location in a C{list}
     """
     tmp = subprocess.check_output("xmousepos").decode().split()
     return list(map(int, tmp))[:2]
@@ -126,12 +126,12 @@ def click_on_pat(pat: str, mousebutton: int=1, offset: (float, float)=None, tole
 
     Click on a pattern at a specified offset (x,y) in percent of the pattern dimension. x is the horizontal distance from the top left corner, y is the vertical distance from the top left corner. By default, the offset is (50,50), which means that the center of the pattern will be clicked at.
 
-    @param pat: path of pattern image (PNG) to click on.
-    @param mousebutton: mouse button number used for the click
-    @param offset: offset from the top left point of the match. (float,float)
-    @param tolerance: An integer ≥ 0 to specify the level of tolerance for 'fuzzy' matches. If negative or not convertible to int, raises ValueError.
-    @param restore_pos: return to the initial mouse position after the click.
-    @raises: L{PatternNotFound}: Raised when the pattern is not found on the screen
+    :param pat: path of pattern image (PNG) to click on.
+    :param mousebutton: mouse button number used for the click
+    :param offset: offset from the top left point of the match. (float,float)
+    :param tolerance: An integer ≥ 0 to specify the level of tolerance for 'fuzzy' matches. If negative or not convertible to int, raises ValueError.
+    :param restore_pos: return to the initial mouse position after the click.
+    :raises: L{PatternNotFound}: Raised when the pattern is not found on the screen
     """
     x0, y0 = mouse_pos()
     move_to_pat(pat, offset, tolerance)
diff --git a/lib/autokey/scripting/keyboard.py b/lib/autokey/scripting/keyboard.py
index 2ff4c13c..9327caa2 100644
--- a/lib/autokey/scripting/keyboard.py
+++ b/lib/autokey/scripting/keyboard.py
@@ -45,8 +45,8 @@ def send_keys(self, key_string, send_mode: typing.Union[
 
         Usage: C{keyboard.send_keys(keyString)}
 
-        @param key_string: string of keys to send. Special keys are only possible in keyboard mode.
-        @param send_mode: Determines how the string is sent.
+        :param key_string: string of keys to send. Special keys are only possible in keyboard mode.
+        :param send_mode: Determines how the string is sent.
         """
 
         if not isinstance(key_string, str):
@@ -67,8 +67,8 @@ def send_key(self, key, repeat=1):
 
         Usage: C{keyboard.send_key(key, repeat=1)}
 
-        @param key: they key to be sent (e.g. "s" or "<enter>")
-        @param repeat: number of times to repeat the key event
+        :param key: they key to be sent (e.g. "s" or "<enter>")
+        :param repeat: number of times to repeat the key event
         """
         for _ in range(repeat):
             self.mediator.send_key(key)
@@ -81,7 +81,7 @@ def press_key(self, key):
         Usage: C{keyboard.press_key(key)}
 
         The key will be treated as down until a matching release_key() is sent.
-        @param key: they key to be pressed (e.g. "s" or "<enter>")
+        :param key: they key to be pressed (e.g. "s" or "<enter>")
         """
         self.mediator.press_key(key)
 
@@ -93,7 +93,7 @@ def release_key(self, key):
 
         If the specified key was not made down using press_key(), the event will be
         ignored.
-        @param key: they key to be released (e.g. "s" or "<enter>")
+        :param key: they key to be released (e.g. "s" or "<enter>")
         """
         self.mediator.release_key(key)
 
@@ -106,8 +106,8 @@ def fake_keypress(self, key, repeat=1):
         Uses XTest to 'fake' a keypress. This is useful to send keypresses to some
         applications which won't respond to keyboard.send_key()
 
-        @param key: they key to be sent (e.g. "s" or "<enter>")
-        @param repeat: number of times to repeat the key event
+        :param key: they key to be sent (e.g. "s" or "<enter>")
+        :param repeat: number of times to repeat the key event
         """
         for _ in range(repeat):
             self.mediator.fake_keypress(key)
@@ -120,9 +120,9 @@ def wait_for_keypress(self, key, modifiers: list=None, timeOut=10.0):
 
         Note: this function cannot be used to wait for modifier keys on their own
 
-        @param key: they key to wait for
-        @param modifiers: list of modifiers that should be pressed with the key
-        @param timeOut: maximum time, in seconds, to wait for the keypress to occur
+        :param key: they key to wait for
+        :param modifiers: list of modifiers that should be pressed with the key
+        :param timeOut: maximum time, in seconds, to wait for the keypress to occur
         """
         if modifiers is None:
             modifiers = []
@@ -136,32 +136,35 @@ def wait_for_keyevent(self, check: Callable[[any,str,list,str], bool], name: str
         """
         Wait for a key event, potentially accumulating the intervening characters
         Usage: C{keyboard.wait_for_keypress(self, check, name=None, timeOut=10.0)}
-        @param check: a function that returns True or False to signify we've finished waiting
-        @param name: only one waiter can have this name. Used to prevent more threads waiting on this.
-        @param timeOut: maximum time, in seconds, to wait for the keypress to occur
+        :param check: a function that returns True or False to signify we've finished waiting
+        :param name: only one waiter can have this name. Used to prevent more threads waiting on this.
+        :param timeOut: maximum time, in seconds, to wait for the keypress to occur
         Example:
-        # Accumulate the traditional emacs C-u prefix arguments
-        # See https://www.gnu.org/software/emacs/manual/html_node/elisp/Prefix-Command-Arguments.html
-        def check(waiter,rawKey,modifiers,key,*args):
-            isCtrlU = (key == 'u' and len(modifiers) == 1 and modifiers[0] == '<ctrl>')
-            if isCtrlU: # If we get here, they've already pressed C-u at least 2x
-                try:
-                    val = int(waiter.result) * 4
-                    waiter.result = str(val)
-                except ValueError:
-                    waiter.result = "16"
-                return False
-            elif any(m == "<ctrl>" or m == "<alt>" or m == "<meta>" or m == "<super>" or m == "<hyper>" for m in modifiers):
-                # Some other control character is an indication we're done.
-                if waiter.result is None or waiter.result == "":
-                    waiter.result = "4"
-                store.set_global_value("emacs-prefix-arg", waiter.result)
-                return True
-            else: # accumulate as a string
-                waiter.result = waiter.result + key
-                return False
-                
-        keyboard.wait_for_keyevent(check, "emacs-prefix")
+
+        .. code-block:: python
+
+            # Accumulate the traditional emacs C-u prefix arguments
+            # See https://www.gnu.org/software/emacs/manual/html_node/elisp/Prefix-Command-Arguments.html
+            def check(waiter,rawKey,modifiers,key,*args):
+                isCtrlU = (key == 'u' and len(modifiers) == 1 and modifiers[0] == '<ctrl>')
+                if isCtrlU: # If we get here, they've already pressed C-u at least 2x
+                    try:
+                        val = int(waiter.result) * 4
+                        waiter.result = str(val)
+                    except ValueError:
+                        waiter.result = "16"
+                    return False
+                elif any(m == "<ctrl>" or m == "<alt>" or m == "<meta>" or m == "<super>" or m == "<hyper>" for m in modifiers):
+                    # Some other control character is an indication we're done.
+                    if waiter.result is None or waiter.result == "":
+                        waiter.result = "4"
+                    store.set_global_value("emacs-prefix-arg", waiter.result)
+                    return True
+                else: # accumulate as a string
+                    waiter.result = waiter.result + key
+                    return False
+                    
+            keyboard.wait_for_keyevent(check, "emacs-prefix")
         """
         if name is None or not any(elem.name == name for elem in self.mediator.listeners):
             w = waiter.Waiter(None, None, None, check, name, timeOut)
diff --git a/lib/autokey/scripting/mouse.py b/lib/autokey/scripting/mouse.py
index b7c660a0..9d96e74d 100644
--- a/lib/autokey/scripting/mouse.py
+++ b/lib/autokey/scripting/mouse.py
@@ -43,9 +43,9 @@ def click_relative(self, x, y, button):
 
         Usage: C{mouse.click_relative(x, y, button)}
 
-        @param x: x-coordinate in pixels, relative to upper left corner of window
-        @param y: y-coordinate in pixels, relative to upper left corner of window
-        @param button: mouse button to simulate (left=1, middle=2, right=3)
+        :param x: x-coordinate in pixels, relative to upper left corner of window
+        :param y: y-coordinate in pixels, relative to upper left corner of window
+        :param button: mouse button to simulate (left=1, middle=2, right=3)
         """
         self.interface.send_mouse_click(x, y, button, True)
 
@@ -55,9 +55,9 @@ def click_relative_self(self, x, y, button):
 
         Usage: C{mouse.click_relative_self(x, y, button)}
 
-        @param x: x-offset in pixels, relative to current mouse position
-        @param y: y-offset in pixels, relative to current mouse position
-        @param button: mouse button to simulate (left=1, middle=2, right=3)
+        :param x: x-offset in pixels, relative to current mouse position
+        :param y: y-offset in pixels, relative to current mouse position
+        :param button: mouse button to simulate (left=1, middle=2, right=3)
         """
         self.interface.send_mouse_click_relative(x, y, button)
 
@@ -67,9 +67,9 @@ def click_absolute(self, x, y, button):
 
         Usage: C{mouse.click_absolute(x, y, button)}
 
-        @param x: x-coordinate in pixels, relative to upper left corner of window
-        @param y: y-coordinate in pixels, relative to upper left corner of window
-        @param button: mouse button to simulate (left=1, middle=2, right=3)
+        :param x: x-coordinate in pixels, relative to upper left corner of window
+        :param y: y-coordinate in pixels, relative to upper left corner of window
+        :param button: mouse button to simulate (left=1, middle=2, right=3)
         """
         self.interface.send_mouse_click(x, y, button, False)
 
@@ -79,9 +79,9 @@ def wait_for_click(self, button, timeOut=10.0):
 
         Usage: C{mouse.wait_for_click(self, button, timeOut=10.0)}
 
-        @param button: they mouse button click to wait for as a button number, 1-9
-        @param timeOut: maximum time, in seconds, to wait for the keypress to occur
-        @return: Returns true if mouse is clicked, false if timeout is reached.
+        :param button: they mouse button click to wait for as a button number, 1-9
+        :param timeOut: maximum time, in seconds, to wait for the keypress to occur
+        :return: Returns true if mouse is clicked, false if timeout is reached.
         """
         button = int(button)
         w = autokey.iomediator.waiter.Waiter(None, None, button, None, None, timeOut)
@@ -96,8 +96,8 @@ def move_cursor(self, x,y):
 
         Usage: C{mouse.move_cursor(x,y)}
 
-        @param x: x-coordinate in pixels, relative to upper left corner of screen
-        @param y: y-coordinate in pixels, relative to upper left corner of screen
+        :param x: x-coordinate in pixels, relative to upper left corner of screen
+        :param y: y-coordinate in pixels, relative to upper left corner of screen
         """
         self.interface.move_cursor(x,y)
 
@@ -107,8 +107,8 @@ def move_relative(self, x, y):
 
         Usage: C{mouse.move_relative(x,y)}
 
-        @param x: x-coordinate in pixels, relative to upper left corner of window
-        @param y: y-coordinate in pixels, relative to upper left corner of window
+        :param x: x-coordinate in pixels, relative to upper left corner of window
+        :param y: y-coordinate in pixels, relative to upper left corner of window
         """
         self.interface.move_cursor(x,y,relative=True)
 
@@ -119,8 +119,8 @@ def move_relative_self(self, x, y):
 
         Usage: C{mouse.move_relative_self(x,y)}
 
-        @param x: x-coordinate in pixels, relative to current position of mouse cursor
-        @param y: y-coordinate in pixels, relative to current position of mouse cursor
+        :param x: x-coordinate in pixels, relative to current position of mouse cursor
+        :param y: y-coordinate in pixels, relative to current position of mouse cursor
         """
         self.interface.move_cursor(x, y, relative_self=True)
 
@@ -130,7 +130,7 @@ def press_button(self, button):
 
         Usage: C{mouse.press_button(button)}
 
-        @param button: the mouse button to press down
+        :param button: the mouse button to press down
         """
         x,y = self.interface.mouse_location()
         self.interface.mouse_press(x,y,button)
@@ -141,7 +141,7 @@ def release_button(self, button):
 
         Usage: C{mouse.release_button(button)}
 
-        @param button: the mouse button to press down
+        :param button: the mouse button to press down
         """
         x,y = self.interface.mouse_location()
         self.interface.mouse_release(x,y,button)
@@ -153,14 +153,14 @@ def select_area(self, startx, starty, endx, endy, button, scrollNumber=0, down=T
 
         Usage: C{mouse.select_area(startx, starty, endx, endy, button)}
 
-        @param startx: X coordinate of where to start the drag and select
-        @param starty: Y coordinate of where to start the drag and select
-        @param endx: X coordinate of where to end the drag and select
-        @param endy: Y coordinate of where to end the drag and select
-        @param button: What mouse button to press at the start coordinates and release at the end coordinates
-        @param scrollNumber: Number of times to scroll, defaults to 0
-        @param down: Boolean to choose which direction to scroll, True for down, False for up., defaults to scrolling down.
-        @param warp: If True method will return cursor to the position it was at at the start of execution
+        :param startx: X coordinate of where to start the drag and select
+        :param starty: Y coordinate of where to start the drag and select
+        :param endx: X coordinate of where to end the drag and select
+        :param endy: Y coordinate of where to end the drag and select
+        :param button: What mouse button to press at the start coordinates and release at the end coordinates
+        :param scrollNumber: Number of times to scroll, defaults to 0
+        :param down: Boolean to choose which direction to scroll, True for down, False for up., defaults to scrolling down.
+        :param warp: If True method will return cursor to the position it was at at the start of execution
         """
         #store mouse location
         x,y = self.interface.mouse_location()
@@ -186,8 +186,8 @@ def get_location(self):
 
         Usage: C{mouse.get_location()}
 
-        @return: x,y location of the mouse
-        @rtype: C{tuple(int,int)}
+        :return: x,y location of the mouse
+        :rtype: C{tuple(int,int)}
         """
         #minimal delay added to make sure location is correct
         time.sleep(0.05)
@@ -200,8 +200,8 @@ def get_relative_location(self):
 
         Usage: C{mouse.get_relative_location()}
         
-        @return: x,y location of the mouse relative to the top left hand corner of the window that has input focus
-        @rtype: C{tuple(int, int)}
+        :return: x,y location of the mouse relative to the top left hand corner of the window that has input focus
+        :rtype: C{tuple(int, int)}
         """
         time.sleep(0.05)
         return self.interface.relative_mouse_location()
@@ -214,7 +214,7 @@ def scroll_down(self, number):
         
         Usage: C{mouse.scroll_down()}
     
-        @param number: The number of times the scroll up signal will be fired.
+        :param number: The number of times the scroll up signal will be fired.
         """
         self.interface.scroll_down(number)
 
@@ -226,6 +226,6 @@ def scroll_up(self, number):
 
         Usage: C{mouse.scroll_up()}
 
-        @param number: The number of times the scroll up signal will be fired.
+        :param number: The number of times the scroll up signal will be fired.
         """
         self.interface.scroll_up(number)
\ No newline at end of file
diff --git a/lib/autokey/scripting/system.py b/lib/autokey/scripting/system.py
index bd921ab4..b53efe98 100644
--- a/lib/autokey/scripting/system.py
+++ b/lib/autokey/scripting/system.py
@@ -33,9 +33,9 @@ def exec_command(command, getOutput=True):
         AutoKey will not respond to any hotkeys/abbreviations etc until the process started
         by the command exits.
 
-        @param command: command to be executed (including any arguments) - e.g. "ls -l"
-        @param getOutput: whether to capture the (stdout) output of the command
-        @raise subprocess.CalledProcessError: if the command returns a non-zero exit code
+        :param command: command to be executed (including any arguments) - e.g. "ls -l"
+        :param getOutput: whether to capture the (stdout) output of the command
+        :raise subprocess.CalledProcessError: if the command returns a non-zero exit code
         """
         if getOutput:
             with subprocess.Popen(
@@ -60,8 +60,8 @@ def create_file(file_name, contents=""):
 
         Usage: C{system.create_file(fileName, contents="")}
 
-        @param fileName: full path to the file to be created
-        @param contents: contents to insert into the file
+        :param fileName: full path to the file to be created
+        :param contents: contents to insert into the file
         """
         with open(file_name, "w") as written_file:
             written_file.write(contents)
diff --git a/lib/autokey/scripting/window.py b/lib/autokey/scripting/window.py
index e8e836d9..dce33b72 100644
--- a/lib/autokey/scripting/window.py
+++ b/lib/autokey/scripting/window.py
@@ -37,8 +37,8 @@ class Window:
     Note: in all cases where a window title is required (with the exception of wait_for_focus()),
     two special values of window title are permitted:
 
-    :ACTIVE: - select the currently active window
-    :SELECT: - select the desired window by clicking on it
+    - :\:ACTIVE: - select the currently active window
+    - :\:SELECT: - select the desired window by clicking on it
     """
 
     def __init__(self, mediator):
@@ -53,9 +53,9 @@ def wait_for_focus(self, title, timeOut=5):
         If the window becomes active, returns True. Otherwise, returns False if
         the window has not become active by the time the timeout has elapsed.
 
-        @param title: title to match against (as a regular expression)
-        @param timeOut: period (seconds) to wait before giving up
-        @rtype: boolean
+        :param title: title to match against (as a regular expression)
+        :param timeOut: period (seconds) to wait before giving up
+        :rtype: boolean
         """
         regex = re.compile(title)
         waited = 0
@@ -77,13 +77,12 @@ def wait_for_exist(self, title, timeOut=5, by_hex=False):
 
         Usage: C{window.wait_for_exist(title, timeOut=5)}
 
-        If the window is in existence, returns True. Otherwise, returns False if
-        the window has not been created by the time the timeout has elapsed.
+        If the window is in existence, returns True. Otherwise, returns False if the window has not been created by the time the timeout has elapsed.
 
-        @param title: title to match against (as a regular expression)
-        @param timeOut: period (seconds) to wait before giving up
-        @param by_hex: If true, C{wmctrl} will interpret the C{title} as a hexid
-        @rtype: boolean
+        :param title: title to match against (as a regular expression)
+        :param timeOut: period (seconds) to wait before giving up
+        :param by_hex: If true, C{wmctrl} will interpret the C{title} as a hexid
+        :rtype: boolean
         """
         waited = 0
         while waited <= timeOut:
@@ -108,13 +107,12 @@ def activate(self, title, switchDesktop=False, matchClass=False, by_hex=False):
 
         Usage: C{window.activate(title, switchDesktop=False, matchClass=False)}
 
-        If switchDesktop is False (default), the window will be moved to the current desktop
-        and activated. Otherwise, switch to the window's current desktop and activate it there.
+        If switchDesktop is False (default), the window will be moved to the current desktop and activated. Otherwise, switch to the window's current desktop and activate it there.
 
-        @param title: window title to match against (as case-insensitive substring match)
-        @param switchDesktop: whether or not to switch to the window's current desktop
-        @param matchClass: if True, match on the window class instead of the title
-        @param by_hex: If true, C{wmctrl} will interpret the C{title} as a hexid
+        :param title: window title to match against (as case-insensitive substring match)
+        :param switchDesktop: whether or not to switch to the window's current desktop
+        :param matchClass: if True, match on the window class instead of the title
+        :param by_hex: If true, C{wmctrl} will interpret the C{title} as a hexid
         """
         if switchDesktop:
             xArgs = ["-a", title]
@@ -134,9 +132,9 @@ def close(self, title, matchClass=False, by_hex=False):
 
         Usage: C{window.close(title, matchClass=False)}
 
-        @param title: window title to match against (as case-insensitive substring match)
-        @param matchClass: if True, match on the window class instead of the title
-        @param by_hex: If true, C{wmctrl} will interpret the C{title} as a hexid
+        :param title: window title to match against (as case-insensitive substring match)
+        :param matchClass: if True, match on the window class instead of the title
+        :param by_hex: If true, C{wmctrl} will interpret the C{title} as a hexid
         """
         xArgs = ["-c", title]
         if matchClass:
@@ -155,13 +153,13 @@ def resize_move(self, title, xOrigin=-1, yOrigin=-1, width=-1, height=-1, matchC
         Leaving and of the position/dimension values as the default (-1) will cause that
         value to be left unmodified.
 
-        @param title: window title to match against (as case-insensitive substring match)
-        @param xOrigin: new x origin of the window (upper left corner)
-        @param yOrigin: new y origin of the window (upper left corner)
-        @param width: new width of the window
-        @param height: new height of the window
-        @param matchClass: if C{True}, match on the window class instead of the title
-        @param by_hex: If true, C{wmctrl} will interpret the C{title} as a hexid
+        :param title: window title to match against (as case-insensitive substring match)
+        :param xOrigin: new x origin of the window (upper left corner)
+        :param yOrigin: new y origin of the window (upper left corner)
+        :param width: new width of the window
+        :param height: new height of the window
+        :param matchClass: if C{True}, match on the window class instead of the title
+        :param by_hex: If true, C{wmctrl} will interpret the C{title} as a hexid
         """
         mvArgs = ["0", str(xOrigin), str(yOrigin), str(width), str(height)]
         xArgs = []
@@ -177,10 +175,10 @@ def move_to_desktop(self, title, deskNum, matchClass=False, by_hex=False):
 
         Usage: C{window.move_to_desktop(title, deskNum, matchClass=False)}
 
-        @param title: window title to match against (as case-insensitive substring match)
-        @param deskNum: desktop to move the window to (note: zero based)
-        @param matchClass: if True, match on the window class instead of the title
-        @param by_hex: If true, C{wmctrl} will interpret the C{title} as a hexid
+        :param title: window title to match against (as case-insensitive substring match)
+        :param deskNum: desktop to move the window to (note: zero based)
+        :param matchClass: if True, match on the window class instead of the title
+        :param by_hex: If true, C{wmctrl} will interpret the C{title} as a hexid
         """
         xArgs = []
         if matchClass:
@@ -195,7 +193,7 @@ def switch_desktop(self, deskNum):
 
         Usage: C{window.switch_desktop(deskNum)}
 
-        @param deskNum: desktop to switch to (note: zero based)
+        :param deskNum: desktop to switch to (note: zero based)
         """
         self._run_wmctrl(["-s", str(deskNum)])
 
@@ -205,15 +203,30 @@ def set_property(self, title, action, prop, matchClass=False, by_hex=False):
 
         Usage: C{window.set_property(title, action, prop, matchClass=False)}
 
-        Allowable actions: C{add, remove, toggle}
-        Allowable properties: C{modal, sticky, maximized_vert, maximized_horz, shaded, skip_taskbar,
-        skip_pager, hidden, fullscreen, above}
-
-        @param title: window title to match against (as case-insensitive substring match)
-        @param action: one of the actions listed above
-        @param prop: one of the properties listed above
-        @param matchClass: if True, match on the window class instead of the title
-        @param by_hex: If true, C{wmctrl} will interpret the C{title} as a hexid
+        Allowable actions:
+
+        - add
+        - remove
+        - toggle
+
+        Allowable properties: 
+
+        - modal
+        - sticky
+        - maximized_vert
+        - maximized_horz
+        - shaded
+        - skip_taskbar
+        - skip_pager
+        - hidden
+        - fullscreen
+        - above
+
+        :param title: window title to match against (as case-insensitive substring match)
+        :param action: one of the actions listed above
+        :param prop: one of the properties listed above
+        :param matchClass: if True, match on the window class instead of the title
+        :param by_hex: If true, C{wmctrl} will interpret the C{title} as a hexid
         """
         xArgs = []
         if matchClass:
@@ -228,8 +241,8 @@ def get_active_geometry(self):
 
         Usage: C{window.get_active_geometry()}
 
-        @return: a 4-tuple containing the x-origin, y-origin, width and height of the window (in pixels)
-        @rtype: C{tuple(int, int, int, int)}
+        :return: a 4-tuple containing the x-origin, y-origin, width and height of the window (in pixels)
+        :rtype: C{tuple(int, int, int, int)}
         """
         #wrapper for get_window_geometry()
         return self.get_window_geometry(":ACTIVE:")
@@ -240,8 +253,8 @@ def get_active_title(self):
 
         Usage: C{window.get_active_title()}
 
-        @return: the visible title of the currentle active window
-        @rtype: C{str}
+        :return: the visible title of the currentle active window
+        :rtype: C{str}
         """
         return self.mediator.interface.get_window_title()
 
@@ -251,8 +264,8 @@ def get_active_class(self):
 
         Usage: C{window.get_active_class()}
 
-        @return: the class of the currentle active window
-        @rtype: C{str}
+        :return: the class of the currently active window
+        :rtype: C{str}
         """
         return self.mediator.interface.get_window_class()
 
@@ -260,13 +273,13 @@ def center_window(self, title=":ACTIVE:", win_width=None, win_height=None, monit
         """
         Centers the active (or window selected by title) window. Requires xrandr for getting monitor sizes and offsets.
 
-        @param title: Title of the window to center (defaults to using the active window)
-        @param win_width: Width of the centered window, defaults to screenx/3. Use -1 to center without size change.
-        @param win_height: Height of the centered window, defaults to screeny/3. Use -1 to center without size change.
-        @param monitor: Monitor number (0 is primary, listed via C{xrandr --listactivemonitors} etc.)
-        @param matchClass: if True, match on the window class instead of the title
-        @raises ValueError: If title or desktop is not found by wmctrl
-        @param by_hex: If true, C{wmctrl} will interpret the C{title} as a hexid
+        :param title: Title of the window to center (defaults to using the active window)
+        :param win_width: Width of the centered window, defaults to screenx/3. Use -1 to center without size change.
+        :param win_height: Height of the centered window, defaults to screeny/3. Use -1 to center without size change.
+        :param monitor: Monitor number (0 is primary, listed via C{xrandr --listactivemonitors} etc.)
+        :param matchClass: if True, match on the window class instead of the title
+        :raises ValueError: If title or desktop is not found by wmctrl
+        :param by_hex: If true, C{wmctrl} will interpret the C{title} as a hexid
         """
         #could also use Gdk.Display.get_default().get_montiors etc.
         #Used xrandr for ease of cross Gtk/Qt use, wayland might require an alternate implementation
@@ -326,9 +339,8 @@ def get_window_list(self, filter_desktop=-1):
 
         C{title} is the title that you would usually see in your window manager of choice.
 
-        @param filter_desktop: String, (usually 0-n) to filter the windows by. Any window not on the given desktop will not be returned.
-        @return: C{[[hexid1, desktop1, hostname1, title1], [hexid2,desktop2,hostname2,title2], ...etc]}
-        Returns C{[]} if no windows are found.
+        :param filter_desktop: String, (usually 0-n) to filter the windows by. Any window not on the given desktop will not be returned.
+        :return: C{[[hexid1, desktop1, hostname1, title1], [hexid2,desktop2,hostname2,title2], ...etc]} Returns C{[]} if no windows are found.
         """
         returncode, output = self._run_wmctrl(["-lG"])
         matches = re.findall(WMCTRL_GEOM_REGEX, output, re.MULTILINE)
@@ -348,8 +360,8 @@ def get_window_hex(self, title):
         """
         Returns the hexid of the first window to match title.
 
-        @param title: Window title to match for returning hexid
-        @return: Returns hexid of the window to be used for other functions See L{get_window_geom}, L{visgrep_by_window_id}
+        :param title: Window title to match for returning hexid
+        :return: Returns hexid of the window to be used for other functions See L{get_window_geom}, L{visgrep_by_window_id}
 
         Returns C{None} if no matches are found
         """
@@ -368,8 +380,8 @@ def get_window_geometry(self, title, by_hex=False):
         top left hand corner of the window is and the width/height of the window.
 
 
-        @param title
-        @return: C{[offsetx, offsety, sizex, sizey]} Returns none if no matches are found
+        :param title
+        :return: C{[offsetx, offsety, sizex, sizey]} Returns none if no matches are found
         """
 
         index = -1 # by default use the window title for matching
diff --git a/lib/autokey/service.py b/lib/autokey/service.py
index 3d7df1d9..3a7ba6ea 100644
--- a/lib/autokey/service.py
+++ b/lib/autokey/service.py
@@ -291,7 +291,7 @@ def __updateStack(self, key):
         Update the input stack in non-hotkey mode, and determine if anything
         further is needed.
 
-        @return: True if further action is needed
+        :return: True if further action is needed
         """
 
         key = self.__map_special_key_to_escape_code(key)
@@ -338,7 +338,7 @@ def __checkTextMatches(self, folders, items, buffer, windowInfo, immediate=False
         Check for an abbreviation/predictive match among the given folder and items
         (scripts, phrases).
 
-        @return: a tuple possibly containing an item to execute, or a menu to show
+        :return: a tuple possibly containing an item to execute, or a menu to show
         """
         itemMatches = []
         folderMatches = []
@@ -394,7 +394,7 @@ def __haveMatch(self, data):
 
     def __menuRequired(self, folders, items, buffer):
         """
-        @return: a boolean indicating whether a menu is needed to allow the user to choose
+        :return: a boolean indicating whether a menu is needed to allow the user to choose
         """
         if len(folders) > 0:
             # Folders always need a menu

From 462518f1c7202de9e4167ef4b98c7cdbdadc2850 Mon Sep 17 00:00:00 2001
From: Sam Sebastian <sebastiansam55@gmail.com>
Date: Sat, 22 Apr 2023 09:34:20 -0400
Subject: [PATCH 03/20] Refactor interface, split out windowInterface,
 gnomeextension window interface.

---
 lib/autokey/interface.py             | 691 +++++++++++++++------------
 lib/autokey/iomediator/iomediator.py |   7 +-
 lib/autokey/scripting/window.py      |   6 +-
 3 files changed, 388 insertions(+), 316 deletions(-)

diff --git a/lib/autokey/interface.py b/lib/autokey/interface.py
index 15d2985b..74371c60 100644
--- a/lib/autokey/interface.py
+++ b/lib/autokey/interface.py
@@ -20,7 +20,7 @@
 A better name might be "keyboard_interface.py".
 """
 
-__all__ = ["XRecordInterface", "AtSpiInterface", "WindowInfo"]
+#__all__ = ["XRecordInterface", "AtSpiInterface"]
 
 import logging
 import typing
@@ -29,18 +29,23 @@
 import queue
 import subprocess
 import time
+import json
+import functools
+import copy
+import dbus
+from dbus.mainloop.glib import DBusGMainLoop
 
 import autokey.model.phrase
 if typing.TYPE_CHECKING:
     from autokey.iomediator.iomediator import IoMediator
 import autokey.configmanager.configmanager_constants as cm_constants
-from autokey.sys_interface.abstract_interface import AbstractSysInterface, AbstractMouseInterface, AbstractWindowInterface
+from autokey.sys_interface.abstract_interface import AbstractSysInterface, AbstractMouseInterface, AbstractWindowInterface, WindowInfo
 
 
 # Imported to enable threading in Xlib. See module description. Not an unused import statement.
 import Xlib.threaded as xlib_threaded
 
-# Delete again, as the reference is not needed anymore after the import side-effect has done it’s work.
+# Delete again, as the reference is not needed anymore after the import side-effect has done it's work.
 # This (hopefully) also prevents automatic code cleanup software from deleting an "unused" import and re-introduce
 # issues.
 del xlib_threaded
@@ -104,15 +109,210 @@ def str_or_bytes_to_bytes(x: typing.Union[str, bytes, memoryview]) -> bytes:
     raise RuntimeError("x must be str or bytes or memoryview object, type(x)={}, repr(x)={}".format(type(x), repr(x)))
 
 
-# This tuple is used to return requested window properties.
-WindowInfo = typing.NamedTuple("WindowInfo", [("wm_title", str), ("wm_class", str)])
 
+def queue_method(queue):
+    """
+    Adds the decorated method to the queue with `put_nowait`
+    """
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args):
+            queue.put_nowait((func, args))
+        return wrapper
+    return decorator
+
+class XWindowInterface(AbstractWindowInterface):
+    """
+    Window Read interface for x11/xorg.
+
+    Extends :class:`.AbstractWindowInterface`
+    """
+
+    def __init__(self):
+        self.localDisplay = display.Display()
+        # Window name atoms
+        self.__NameAtom = self.localDisplay.intern_atom("_NET_WM_NAME", True)
+        self.__VisibleNameAtom = self.localDisplay.intern_atom("_NET_WM_VISIBLE_NAME", True)
+
+
+    def get_window_info(self, window=None, traverse: bool=True) -> WindowInfo:
+        try:
+            if window is None:
+                window = self.localDisplay.get_input_focus().focus
+            return self._get_window_info(window, traverse)
+        except error.BadWindow:
+            logger.warning("Got BadWindow error while requesting window information.")
+            return self._create_window_info(window, "", "")
+
+    def get_window_title(self, window=None, traverse=True) -> str:
+        return self.get_window_info(window, traverse).wm_title
+
+    def get_window_class(self, window=None, traverse=True) -> str:
+        return self.get_window_info(window, traverse).wm_class
+    
+    def _get_window_info(self, window, traverse: bool, wm_title: str=None, wm_class: str=None) -> WindowInfo:
+        new_wm_title = self._try_get_window_title(window)
+        new_wm_class = self._try_get_window_class(window)
+
+        if not wm_title and new_wm_title:  # Found title, update known information
+            wm_title = new_wm_title
+        if not wm_class and new_wm_class:  # Found class, update known information
+            wm_class = new_wm_class
+
+        if traverse:
+            # Recursive operation on the parent window
+            if wm_title and wm_class:  # Both known, abort walking the tree and return the data.
+                return self._create_window_info(window, wm_title, wm_class)
+            else:  # At least one property is still not known. So walk the window tree up.
+                parent = window.query_tree().parent
+                # Stop traversal, if the parent is not a window. When querying the parent, at some point, an integer
+                # is returned. Then just stop following the tree.
+                if isinstance(parent, int):
+                    # At this point, wm_title or wm_class may still be None. The recursive call with traverse=False
+                    # will replace any None with an empty string. See below.
+                    return self._get_window_info(window, False, wm_title, wm_class)
+                else:
+                    return self._get_window_info(parent, traverse, wm_title, wm_class)
+
+        else:
+            # No recursion, so fill unknown values with empty strings.
+            if wm_title is None:
+                wm_title = ""
+            if wm_class is None:
+                wm_class = ""
+            return self._create_window_info(window, wm_title, wm_class)
+
+    def _create_window_info(self, window, wm_title: str, wm_class: str):
+        """
+        Creates a WindowInfo object from the window title and WM_CLASS.
+        Also checks for the Java XFocusProxyWindow workaround and applies it if needed:
+
+        Workaround for Java applications: Java AWT uses a XFocusProxyWindow class, so to get usable information,
+        the parent window needs to be queried. Credits: https://github.com/mooz/xkeysnail/pull/32
+        https://github.com/JetBrains/jdk8u_jdk/blob/master/src/solaris/classes/sun/awt/X11/XFocusProxyWindow.java#L35
+        """
+        if "FocusProxy" in wm_class:
+            parent = window.query_tree().parent
+            # Discard both the already known wm_class and window title, because both are known to be wrong.
+            return self._get_window_info(parent, False)
+        else:
+            return WindowInfo(wm_title=wm_title, wm_class=wm_class)
+
+    def _try_get_window_title(self, window) -> typing.Optional[str]:
+        atom = self._try_read_property(window, self.__VisibleNameAtom)
+        if atom is None:
+            atom = self._try_read_property(window, self.__NameAtom)
+        if atom:
+            value = atom.value  # type: typing.Union[str, bytes]
+            # based on python3-xlib version, atom.value may be a bytes object, then decoding is necessary.
+            return value.decode("utf-8") if isinstance(value, bytes) else value
+        else:
+            return None
+
+    @staticmethod
+    def _try_read_property(window, property_name: str):
+        """
+        Try to read the given property of the given window.
+        Returns the atom, if successful, None otherwise.
+        """
+        try:
+            return window.get_property(property_name, 0, 0, 255)
+        except error.BadAtom:
+            return None
+
+    @staticmethod
+    def _try_get_window_class(window) -> typing.Optional[str]:
+        wm_class = window.get_wm_class()
+        if wm_class:
+            return "{}.{}".format(wm_class[0], wm_class[1])
+        else:
+            return None
+
+class DBusInterface:
+    def __init__(self):
+        mainloop= DBusGMainLoop()
+        session_bus = dbus.SessionBus(mainloop=mainloop)
+        shell_obj = session_bus.get_object('org.gnome.Shell', '/org/gnome/Shell/Extensions/AutoKey')
+        self.dbus_interface = dbus.Interface(shell_obj, 'org.gnome.Shell.Extensions.AutoKey')
+
+class GnomeExtensionWindowInterface(DBusInterface, AbstractWindowInterface):
+    def __init__(self):
+        super().__init__()
+        
+
+    def get_window_info(self, window=None, traverse: bool=True) -> WindowInfo:
+        """
+        Returns a WindowInfo object containing the class and title.
+        """
+        window = self._active_window()
+        return WindowInfo(wm_class=window['wm_class'], wm_title=window['wm_title'])
+
+    def get_window_class(self, window=None, traverse=True) -> str:
+        """
+        Returns the window class of the currently focused window.
+        """
+        return self._active_window()['wm_class']
+        
+    
+    def get_window_title(self, window=None, traverse=True) -> str:
+        """
+        Returns the active window title
+        """
+        return self._active_window()['wm_title']
+
+    def _active_window(self):
+        #TODO probably can be done more efficiently with an additional dbus method in the gnome extension
+        window_list = self._dbus_window_list()
+        for window in window_list:
+            if window['focus']:
+                return window
+            
+    def _dbus_window_list(self):
+        #TODO consider how/if error handling can be implemented
+        try:
+            return json.loads(self.dbus_interface.List())
+        except dbus.exceptions.DBusException as e:
+            self.__init__() #reconnect to dbus
+            return json.loads(self.dbus_interface.List())
+            
+    def _dbus_close_window(self, window_id):
+        #TODO consider how/if error handling can be implemented
+        try:
+            self.dbus_interface.Close(window_id)
+        except dbus.exceptions.DBusException as e:
+            self.__init__()
+            self.dbus_interface.Close(window_id)
+
+    def _dbus_activate_window(self, window_id):
+        try:
+            self.dbus_interface.Activate(window_id)
+        except dbus.exceptions.DBusException as e:  
+            self.__init__()
+            self.dbus_interface.Activate(window_id)
+
+    def _dbus_move_window(self, window_id, x, y):
+        try:
+            self.dbus_interface.Move(window_id, x, y)
+        except dbus.exceptions.DBusException as e:
+            self.__init__()
+            self.dbus_interface.Move(window_id, x, y)
+
+    def _dbus_resize_window(self, window_id, width, height):
+        try:
+            self.dbus_interface.Resize(window_id, width, height)
+        except dbus.exceptions.DBusException as e:
+            self.__init__()
+            self.dbus_interface.Resize(window_id, width, height)
 
-class XInterfaceBase(threading.Thread, AbstractMouseInterface, AbstractWindowInterface):
+class XInterfaceBase(threading.Thread, AbstractMouseInterface):
     """
     Encapsulates the common functionality for the two X interface classes.
+
+    Extends :class:`.AbstractMouseInterface`
     """
 
+    queue = queue.Queue()
+
     def __init__(self, mediator, app):
         threading.Thread.__init__(self)
         self.setDaemon(True)
@@ -125,7 +325,6 @@ def __init__(self, mediator, app):
 
         # Event loop
         self.eventThread = threading.Thread(target=self.__eventLoop)
-        self.queue = queue.Queue()
 
         # Event listener
         self.listenerThread = threading.Thread(target=self.__flush_events_loop)
@@ -135,10 +334,6 @@ def __init__(self, mediator, app):
         # Set initial lock state
         self.__set_lock_keys_state()
 
-        # Window name atoms
-        self.__NameAtom = self.localDisplay.intern_atom("_NET_WM_NAME", True)
-        self.__VisibleNameAtom = self.localDisplay.intern_atom("_NET_WM_VISIBLE_NAME", True)
-
         #move detection of key map changes to X event thread in order to have QT and GTK detection
         # if not common.USING_QT:
             # self.keyMap = Gdk.Keymap.get_default()
@@ -149,8 +344,10 @@ def __init__(self, mediator, app):
         self.eventThread.start()
         self.listenerThread.start()
 
+    @queue_method(queue)
     def flush(self):
-        self.__enqueue(self.__flush)
+        self.localDisplay.flush()
+        self.lastChars = []
 
     def on_keys_changed(self, data=None):
         """
@@ -160,34 +357,51 @@ def on_keys_changed(self, data=None):
             logger.debug("Recorded keymap change event")
             self.__ignoreRemap = True
             time.sleep(0.2)
-            self.__enqueue(self.__ungrab_all_hotkeys)
-            self.__enqueue(self.__delayedInitMappings)
+            self.__ungrab_all_hotkeys()
+            self.__delayedInitMappings()
         else:
             logger.debug("Ignored keymap change event")
 
+    @queue_method(queue)
     def press_key(self, keyName):
-        self.__enqueue(self.__pressKey, keyName)
+        self.__sendKeyPressEvent(self.__lookupKeyCode(keyName), 0)
 
+    @queue_method(queue)
     def release_key(self, keyName):
-        self.__enqueue(self.__releaseKey, keyName)
+        self.__sendKeyReleaseEvent(self.__lookupKeyCode(keyName), 0)
 
+    @queue_method(queue)
     def handle_keypress(self, keyCode):
-        self.__enqueue(self.__handleKeyPress, keyCode)
+        focus = self.localDisplay.get_input_focus().focus
 
+        modifier = self.__decodeModifier(keyCode)
+        if modifier is not None:
+            self.mediator.handle_modifier_down(modifier)
+        else:
+            window_info = self.mediator.windowInterface.get_window_info(focus)
+            self.mediator.handle_keypress(keyCode, window_info)
+
+    @queue_method(queue)
     def handle_keyrelease(self, keyCode):
-        self.__enqueue(self.__handleKeyrelease, keyCode)
+        modifier = self.__decodeModifier(keyCode)
+        if modifier is not None:
+            self.mediator.handle_modifier_up(modifier)
 
+    @queue_method(queue)
     def grab_keyboard(self):
-        self.__enqueue(self.__grab_keyboard)
+        focus = self.localDisplay.get_input_focus().focus
+        focus.grab_keyboard(True, X.GrabModeAsync, X.GrabModeAsync, X.CurrentTime)
+        self.localDisplay.flush()
 
+    @queue_method(queue)
     def ungrab_keyboard(self):
-        self.__enqueue(self.__ungrabKeyboard)
+        self.localDisplay.ungrab_keyboard(X.CurrentTime)
+        self.localDisplay.flush()
 
     def grab_hotkey(self, item):
         self.__enqueue_hotkey_grab_ungrab(item, grab=True)
 
     def ungrab_hotkey(self, item):
-        import copy
         newItem = copy.copy(item)
         self.__enqueue_hotkey_grab_ungrab(newItem, grab=False)
 
@@ -211,43 +425,112 @@ def lookup_string(self, keyCode, shifted, numlock, altGrid):
             except ValueError:
                 return "<code%d>" % keyCode
 
+    @queue_method(queue)
     def send_string(self, string):
-        # Asynchronous send string.
-        self.__enqueue(self.__sendString, string)
+        """
+        Send a string of printable characters.
+        """
+        logger.debug("Sending string: %r", string)
+        # Determine if workaround is needed
+        if not cm.ConfigManager.SETTINGS[cm_constants.ENABLE_QT4_WORKAROUND]:
+            self.__checkWorkaroundNeeded()
+
+        # First find out if any chars need remapping
+        remapNeeded = self.__chars_need_remapping(string)
+        # Now we know chars need remapping, do it
+        self.__remap_characters(remapNeeded, string)
+
+        focus = self.localDisplay.get_input_focus().focus
+
+        for char in string:
+            try:
+                self.__send_keycode_for_char(char, focus)
+            except Exception as e:
+                logger.exception("Error sending char %r: %s", char, str(e))
+
+        self.__ignoreRemap = False
 
+    @queue_method(queue)
     def send_key(self, keyName):
         """
-        Send a specific non-printing key, eg Up, Left, etc
-        """
-        self.__enqueue(self.__sendKey, keyName)
+        Send a specific non-printing key, eg <up>, <left>, etc
 
+        :param keyName: Name of the key IE <up>, <left>
+        """
+        logger.debug("Send special key: [%r]", keyName)
+        self.__sendKeyCode(self.__lookupKeyCode(keyName))
 
+    @queue_method(queue)
     def send_modified_key(self, keyName, modifiers):
         """
         Send a modified key (e.g. when emulating a hotkey)
         """
-        self.__enqueue(self.__sendModifiedKey, keyName, modifiers)
+        logger.debug("Send modified key: modifiers: %s key: %s", modifiers, keyName)
+        try:
+            keyCode = self.__lookupKeyCode(keyName)
+            self.__send_keycode_with_modifiers_pressed(keyCode,
+                                                       modifiers)
+        except Exception as e:
+            logger.warning("Error sending modified key %r %r: %s", modifiers, keyName, str(e))
 
+    @queue_method(queue)
     def fake_keypress(self, keyName):
-         self.__enqueue(self.__fakeKeypress, keyName)
+        keyCode = self.__lookupKeyCode(keyName)
+        xtest.fake_input(self.rootWindow, X.KeyPress, keyCode)
+        self.localDisplay.sync()
+        xtest.fake_input(self.rootWindow, X.KeyRelease, keyCode)
+        self.localDisplay.sync()
 
 
+    @queue_method(queue)
     def fake_keydown(self, keyName):
-        self.__enqueue(self.__fakeKeydown, keyName)
+        keyCode = self.__lookupKeyCode(keyName)
+        xtest.fake_input(self.rootWindow, X.KeyPress, keyCode)
+        self.localDisplay.sync()
 
+    @queue_method(queue)
     def fake_keyup(self, keyName):
-        self.__enqueue(self.__fakeKeyup, keyName)
+        keyCode = self.__lookupKeyCode(keyName)
+        xtest.fake_input(self.rootWindow, X.KeyRelease, keyCode)
+        self.localDisplay.sync()
 
+    @queue_method(queue)
     def send_mouse_click(self, xCoord, yCoord, button, relative):
-        self.__enqueue(self.__sendMouseClick, xCoord, yCoord, button, relative)
+        # Get current pointer position so we can return it there
+        pos = self.rootWindow.query_pointer()
 
+        if relative:
+            focus = self.localDisplay.get_input_focus().focus
+            focus.warp_pointer(xCoord, yCoord)
+            xtest.fake_input(focus, X.ButtonPress, button, x=xCoord, y=yCoord)
+            xtest.fake_input(focus, X.ButtonRelease, button, x=xCoord, y=yCoord)
+        else:
+            self.rootWindow.warp_pointer(xCoord, yCoord)
+            xtest.fake_input(self.rootWindow, X.ButtonPress, button, x=xCoord, y=yCoord)
+            xtest.fake_input(self.rootWindow, X.ButtonRelease, button, x=xCoord, y=yCoord)
+
+        self.rootWindow.warp_pointer(pos.root_x, pos.root_y)
+
+        self.__flush()
+
+    @queue_method(queue)
     def mouse_press(self, xCoord, yCoord, button):
-        self.__enqueue(self.__mousePress, xCoord, yCoord, button)
+        focus = self.localDisplay.get_input_focus().focus
+        xtest.fake_input(focus, X.ButtonPress, button, x=xCoord, y=yCoord)
+        self.__flush()
 
+    @queue_method(queue)
     def mouse_release(self, xCoord, yCoord, button):
-        self.__enqueue(self.__mouseRelease, xCoord, yCoord, button)
+        focus = self.localDisplay.get_input_focus().focus
+        xtest.fake_input(focus, X.ButtonRelease, button, x=xCoord, y=yCoord)
+        self.__flush()
 
     def mouse_location(self):
+        """Returns the location of the Mouse as (x,y)
+
+        :return: Tuple of the Mouse Location(x,y)
+        :rtype: tuple
+        """
         pos = self.rootWindow.query_pointer()
         return (pos.root_x, pos.root_y)
 
@@ -260,35 +543,63 @@ def relative_mouse_location(self, window=None):
 
     def scroll_down(self, number):
         for i in range(0, number):
-            self.__enqueue(self.__scroll, Button.SCROLL_DOWN)
+            self.__scroll(Button.SCROLL_DOWN)
 
     def scroll_up(self, number):
         for i in range(0, number):
-            self.__enqueue(self.__scroll, Button.SCROLL_UP)
+            self.__scroll(Button.SCROLL_UP)
 
+    @queue_method(queue)
     def move_cursor(self, xCoord, yCoord, relative=False, relative_self=False):
-        self.__enqueue(self.__moveCursor, xCoord, yCoord, relative, relative_self)
+        if relative:
+            focus = self.localDisplay.get_input_focus().focus
+            focus.warp_pointer(xCoord, yCoord)
+            self.__flush()
+            return
+
+        if relative_self:
+            pos = self.rootWindow.query_pointer()
+            xCoord += pos.root_x
+            yCoord += pos.root_y
+
+        self.rootWindow.warp_pointer(xCoord,yCoord)
+        self.__flush()
 
+    @queue_method(queue)
     def send_mouse_click_relative(self, xoff, yoff, button):
-        self.__enqueue(self.__sendMouseClickRelative, xoff, yoff, button)
+        # Get current pointer position
+        pos = self.rootWindow.query_pointer()
 
-    def handle_mouseclick(self, button, x, y):
-        self.__enqueue(self.__handleMouseclick, button, x, y)
+        xCoord = pos.root_x + xoff
+        yCoord = pos.root_y + yoff
 
-    def get_window_info(self, window=None, traverse: bool=True) -> WindowInfo:
-        try:
-            if window is None:
-                window = self.localDisplay.get_input_focus().focus
-            return self._get_window_info(window, traverse)
-        except error.BadWindow:
-            logger.warning("Got BadWindow error while requesting window information.")
-            return self._create_window_info(window, "", "")
+        self.rootWindow.warp_pointer(xCoord, yCoord)
+        xtest.fake_input(self.rootWindow, X.ButtonPress, button, x=xCoord, y=yCoord)
+        xtest.fake_input(self.rootWindow, X.ButtonRelease, button, x=xCoord, y=yCoord)
 
-    def get_window_title(self, window=None, traverse=True) -> str:
-        return self.get_window_info(window, traverse).wm_title
+        self.rootWindow.warp_pointer(pos.root_x, pos.root_y)
+
+        self.__flush()
+
+    @queue_method(queue)
+    def handle_mouseclick(self, button, x, y):
+        # Sleep a bit to timing issues. A mouse click might change the active application.
+        # If so, the switch happens asynchronously somewhere during the execution of the first two queries below,
+        # causing the queried window title (and maybe the window class or even none of those) to be invalid.
+        time.sleep(0.005)  # TODO: may need some tweaking
+        window_info = self.mediator.windowInterface.get_window_info()
+
+        if x is None and y is None:
+            ret = self.localDisplay.get_input_focus().focus.query_pointer()
+            self.mediator.handle_mouse_click(ret.root_x, ret.root_y, ret.win_x, ret.win_y, button, window_info)
+        else:
+            focus = self.localDisplay.get_input_focus().focus
+            try:
+                rel = focus.translate_coords(self.rootWindow, x, y)
+                self.mediator.handle_mouse_click(x, y, rel.x, rel.y, button, window_info)
+            except:
+                self.mediator.handle_mouse_click(x, y, 0, 0, button, window_info)
 
-    def get_window_class(self, window=None, traverse=True) -> str:
-        return self.get_window_info(window, traverse).wm_class
 
     def cancel(self):
         logger.debug("XInterfaceBase: Try to exit event thread.")
@@ -325,6 +636,7 @@ def __eventLoop(self):
     def __enqueue(self, method: typing.Callable, *args):
         self.queue.put_nowait((method, args))
 
+    @queue_method(queue)
     def __delayedInitMappings(self):
         self.__initMappings()
         self.__ignoreRemap = False
@@ -337,7 +649,7 @@ def __initMappings(self):
         self.__build_usable_offsets()
         self.__build_modifier_mask_mapping()
 
-        self.__grab_all_hotkeys()
+        self.__grab_ungrab_all_hotkeys(grab=True)
         self.localDisplay.flush()
 
         self.__availableKeycodes = self.__get_unused_keycodes()
@@ -441,25 +753,20 @@ def __grab_ungrab_all_hotkeys(self, grab=True):
                 else:
                     self.__recursive_ungrab(item)
         if grab:
-            self.__enqueue(self.__recurseTree, self.rootWindow, hotkeys)
+            self.recurseTree(self.rootWindow, hotkeys)
         else:
-            self.__recurseTreeUngrab(self.rootWindow, hotkeys)
-
-    def __grab_all_hotkeys(self):
-        """
-        Run during startup to grab global and specific hotkeys in all open windows
-        """
-        self.__grab_ungrab_all_hotkeys(grab=True)
+            self.__recurse_tree_grab_ungrab(self.rootWindow, hotkeys, grab=False)
 
     def __enqueue_grab(self, item):
         self.__enqueue(self.__grabHotkey, item.hotKey, item.modifiers, self.rootWindow)
         if self.__needsMutterWorkaround(item):
             self.__enqueue(self.__grabRecurse, item, self.rootWindow, False)
 
-    def __recurseTree(self, parent, hotkeys):
+    @queue_method(queue)
+    def recurseTree(self, parent, hotkeys):
         self.__recurse_tree_grab_ungrab(parent, hotkeys, grab=True)
 
-
+    @queue_method(queue)
     def __ungrab_all_hotkeys(self):
         """
         Ungrab all hotkeys in preparation for keymap change
@@ -482,7 +789,7 @@ def __recurse_tree_grab_ungrab(self, parent, hotkeys, grab=True):
 
         for window in children:
             try:
-                window_info = self.get_window_info(window, False)
+                window_info = self.mediator.windowInterface.get_window_info(window, False)
 
                 if window_info.wm_title or window_info.wm_class:
                     for item in hotkeys:
@@ -499,10 +806,7 @@ def __recurse_tree_grab_ungrab(self, parent, hotkeys, grab=True):
                 ungrab = "" if grab else "un"
                 logger.exception("{}grab on window failed".format(ungrab))
 
-
-    def __recurseTreeUngrab(self, parent, hotkeys):
-        self.__recurse_tree_grab_ungrab(parent, hotkeys, grab=False)
-
+    @queue_method(queue)
     def __grabHotkeysForWindow(self, window):
         """
         Grab all hotkeys relevant to the window
@@ -511,7 +815,7 @@ def __grabHotkeysForWindow(self, window):
         """
         c = self.app.configManager
         hotkeys = c.hotKeys + c.hotKeyFolders
-        window_info = self.get_window_info(window)
+        window_info = self.mediator.windowInterface.get_window_info(window)
         for item in hotkeys:
             if item.get_applicable_regex() is not None and item._should_trigger_window_title(window_info):
                 self.__enqueue(self.__grabHotkey, item.hotKey, item.modifiers, window)
@@ -589,7 +893,7 @@ def __grab_ungrab_recurse(self, item, parent, checkWinInfo=True, grab=True):
             shouldTrigger = False
 
             if checkWinInfo:
-                window_info = self.get_window_info(window, False)
+                window_info = self.mediator.windowInterface.get_window_info(window, False)
                 shouldTrigger = item._should_trigger_window_title(window_info)
 
             if shouldTrigger or not checkWinInfo:
@@ -613,16 +917,6 @@ def __ungrabHotkey(self, key, modifiers, window):
         """
         self.__grab_ungrab_hotkey(key, modifiers, window, grab=False)
 
-
-    def __grab_keyboard(self):
-        focus = self.localDisplay.get_input_focus().focus
-        focus.grab_keyboard(True, X.GrabModeAsync, X.GrabModeAsync, X.CurrentTime)
-        self.localDisplay.flush()
-
-    def __ungrabKeyboard(self):
-        self.localDisplay.ungrab_keyboard(X.CurrentTime)
-        self.localDisplay.flush()
-
     def __findUsableKeycode(self, codeList):
         for code, offset in codeList:
             if offset in self.__usableOffsets:
@@ -683,30 +977,6 @@ def __get_usable_char_keycode_and_offset(self, char):
         keyCode, offset = self.__findUsableKeycode(keyCodeList)
         return keyCode, offset
 
-    def __sendString(self, string):
-        """
-        Send a string of printable characters.
-        """
-        logger.debug("Sending string: %r", string)
-        # Determine if workaround is needed
-        if not cm.ConfigManager.SETTINGS[cm_constants.ENABLE_QT4_WORKAROUND]:
-            self.__checkWorkaroundNeeded()
-
-        # First find out if any chars need remapping
-        remapNeeded = self.__chars_need_remapping(string)
-        # Now we know chars need remapping, do it
-        self.__remap_characters(remapNeeded, string)
-
-        focus = self.localDisplay.get_input_focus().focus
-
-        for char in string:
-            try:
-                self.__send_keycode_for_char(char, focus)
-            except Exception as e:
-                logger.exception("Error sending char %r: %s", char, str(e))
-
-        self.__ignoreRemap = False
-
     def __send_keycode_for_char(self, char, focus):
         # Offset encodes the modifiers needed to convert the base key press
         # into the desired result symbol.
@@ -744,7 +1014,7 @@ def __sendByTypingAsUnicodePoint(self, char, focus):
         ukeyCode, uOffset = self.__findUsableKeycode(ukeyCodeList)
         self.__send_keycode_with_modifiers_pressed(ukeyCode, [Key.CONTROL, Key.SHIFT], focus)
         self.__send_char_as_hex_string(char)
-        self.__pressKey(Key.ENTER)
+        self.__sendKeyPressEvent(self.__lookupKeyCode(Key.ENTER), 0)
 
     def __send_char_as_hex_string(self, char):
         char_as_hex_string = '{:X}'.format(ord(char))
@@ -758,72 +1028,15 @@ def __send_keycode_with_modifiers_pressed(self, keyCode, modifier_keys, focus=No
         mask = 0
         for modkey in modifier_keys: mask |= self.modMasks[modkey]
 
-        for modkey in modifier_keys: self.__pressKey(modkey)
+        for modkey in modifier_keys: self.__sendKeyPressEvent(self.__lookupKeyCode(modkey), 0)
         if focus:
             self.__sendKeyCode(keyCode, mask, focus)
         else:
             self.__sendKeyCode(keyCode, mask)
-        for modkey in modifier_keys: self.__releaseKey(modkey)
-
+        for modkey in modifier_keys: self.__sendKeyReleaseEvent(self.__lookupKeyCode(modkey), 0)
 
-    def __sendKey(self, keyName):
-        logger.debug("Send special key: [%r]", keyName)
-        self.__sendKeyCode(self.__lookupKeyCode(keyName))
-
-    def __fakeKeypress(self, keyName):
-        keyCode = self.__lookupKeyCode(keyName)
-        xtest.fake_input(self.rootWindow, X.KeyPress, keyCode)
-        self.localDisplay.sync()
-        xtest.fake_input(self.rootWindow, X.KeyRelease, keyCode)
-        self.localDisplay.sync()
-
-    def __fakeKeydown(self, keyName):
-        keyCode = self.__lookupKeyCode(keyName)
-        xtest.fake_input(self.rootWindow, X.KeyPress, keyCode)
-        self.localDisplay.sync()
-
-    def __fakeKeyup(self, keyName):
-        keyCode = self.__lookupKeyCode(keyName)
-        xtest.fake_input(self.rootWindow, X.KeyRelease, keyCode)
-        self.localDisplay.sync()
-
-    def __sendModifiedKey(self, keyName, modifiers):
-        logger.debug("Send modified key: modifiers: %s key: %s", modifiers, keyName)
-        try:
-            keyCode = self.__lookupKeyCode(keyName)
-            self.__send_keycode_with_modifiers_pressed(keyCode,
-                                                       modifiers)
-        except Exception as e:
-            logger.warning("Error sending modified key %r %r: %s", modifiers, keyName, str(e))
-
-    def __sendMouseClick(self, xCoord, yCoord, button, relative):
-        # Get current pointer position so we can return it there
-        pos = self.rootWindow.query_pointer()
-
-        if relative:
-            focus = self.localDisplay.get_input_focus().focus
-            focus.warp_pointer(xCoord, yCoord)
-            xtest.fake_input(focus, X.ButtonPress, button, x=xCoord, y=yCoord)
-            xtest.fake_input(focus, X.ButtonRelease, button, x=xCoord, y=yCoord)
-        else:
-            self.rootWindow.warp_pointer(xCoord, yCoord)
-            xtest.fake_input(self.rootWindow, X.ButtonPress, button, x=xCoord, y=yCoord)
-            xtest.fake_input(self.rootWindow, X.ButtonRelease, button, x=xCoord, y=yCoord)
-
-        self.rootWindow.warp_pointer(pos.root_x, pos.root_y)
-
-        self.__flush()
-
-    def __mousePress(self, xCoord, yCoord, button):
-        focus = self.localDisplay.get_input_focus().focus
-        xtest.fake_input(focus, X.ButtonPress, button, x=xCoord, y=yCoord)
-        self.__flush()
-
-    def __mouseRelease(self, xCoord, yCoord, button):
-        focus = self.localDisplay.get_input_focus().focus
-        xtest.fake_input(focus, X.ButtonRelease, button, x=xCoord, y=yCoord)
-        self.__flush()
 
+    @queue_method(queue)
     def __scroll(self, button):
         focus = self.localDisplay.get_input_focus().focus
         x,y = self.mouse_location()
@@ -831,45 +1044,10 @@ def __scroll(self, button):
         xtest.fake_input(self=focus, event_type=X.ButtonRelease, detail=button, x=x, y=y)
         self.__flush()
 
-    def __moveCursor(self, xCoord, yCoord, relative=False, relative_self=False):
-        if relative:
-            focus = self.localDisplay.get_input_focus().focus
-            focus.warp_pointer(xCoord, yCoord)
-            self.__flush()
-            return
-
-        if relative_self:
-            pos = self.rootWindow.query_pointer()
-            xCoord += pos.root_x
-            yCoord += pos.root_y
-
-        self.rootWindow.warp_pointer(xCoord,yCoord)
-        self.__flush()
-
-    def __sendMouseClickRelative(self, xoff, yoff, button):
-        # Get current pointer position
-        pos = self.rootWindow.query_pointer()
-
-        xCoord = pos.root_x + xoff
-        yCoord = pos.root_y + yoff
-
-        self.rootWindow.warp_pointer(xCoord, yCoord)
-        xtest.fake_input(self.rootWindow, X.ButtonPress, button, x=xCoord, y=yCoord)
-        xtest.fake_input(self.rootWindow, X.ButtonRelease, button, x=xCoord, y=yCoord)
-
-        self.rootWindow.warp_pointer(pos.root_x, pos.root_y)
-
-        self.__flush()
-
     def __flush(self):
         self.localDisplay.flush()
         self.lastChars = []
 
-    def __pressKey(self, keyName):
-        self.__sendKeyPressEvent(self.__lookupKeyCode(keyName), 0)
-
-    def __releaseKey(self, keyName):
-        self.__sendKeyReleaseEvent(self.__lookupKeyCode(keyName), 0)
 
     def __flush_events_loop(self):
         logger.debug("__flushEvents: Entering event loop.")
@@ -913,40 +1091,7 @@ def __flush_events(self):
 
             for window in createdWindows:
                 if window not in destroyedWindows:
-                    self.__enqueue(self.__grabHotkeysForWindow, window)
-
-    def __handleKeyPress(self, keyCode):
-        focus = self.localDisplay.get_input_focus().focus
-
-        modifier = self.__decodeModifier(keyCode)
-        if modifier is not None:
-            self.mediator.handle_modifier_down(modifier)
-        else:
-            window_info = self.get_window_info(focus)
-            self.mediator.handle_keypress(keyCode, window_info)
-
-    def __handleKeyrelease(self, keyCode):
-        modifier = self.__decodeModifier(keyCode)
-        if modifier is not None:
-            self.mediator.handle_modifier_up(modifier)
-
-    def __handleMouseclick(self, button, x, y):
-        # Sleep a bit to timing issues. A mouse click might change the active application.
-        # If so, the switch happens asynchronously somewhere during the execution of the first two queries below,
-        # causing the queried window title (and maybe the window class or even none of those) to be invalid.
-        time.sleep(0.005)  # TODO: may need some tweaking
-        window_info = self.get_window_info()
-
-        if x is None and y is None:
-            ret = self.localDisplay.get_input_focus().focus.query_pointer()
-            self.mediator.handle_mouse_click(ret.root_x, ret.root_y, ret.win_x, ret.win_y, button, window_info)
-        else:
-            focus = self.localDisplay.get_input_focus().focus
-            try:
-                rel = focus.translate_coords(self.rootWindow, x, y)
-                self.mediator.handle_mouse_click(x, y, rel.x, rel.y, button, window_info)
-            except:
-                self.mediator.handle_mouse_click(x, y, 0, 0, button, window_info)
+                    self.__grabHotkeysForWindow(window)
 
     def __decodeModifier(self, keyCode):
         """
@@ -967,7 +1112,7 @@ def __sendKeyCode(self, keyCode, modifiers=0, theWindow=None):
 
     def __checkWorkaroundNeeded(self):
         focus = self.localDisplay.get_input_focus().focus
-        window_info = self.get_window_info(focus)
+        window_info = self.mediator.windowInterface.get_window_info(focus)
         w = self.app.configManager.workAroundApps
         if w.match(window_info.wm_title) or w.match(window_info.wm_class):
             self.__enableQT4Workaround = True
@@ -1033,84 +1178,6 @@ def __lookupKeyCode(self, char: str) -> int:
                 logger.error("Unknown key name: %s", char)
                 raise
 
-    def _get_window_info(self, window, traverse: bool, wm_title: str=None, wm_class: str=None) -> WindowInfo:
-        new_wm_title = self._try_get_window_title(window)
-        new_wm_class = self._try_get_window_class(window)
-
-        if not wm_title and new_wm_title:  # Found title, update known information
-            wm_title = new_wm_title
-        if not wm_class and new_wm_class:  # Found class, update known information
-            wm_class = new_wm_class
-
-        if traverse:
-            # Recursive operation on the parent window
-            if wm_title and wm_class:  # Both known, abort walking the tree and return the data.
-                return self._create_window_info(window, wm_title, wm_class)
-            else:  # At least one property is still not known. So walk the window tree up.
-                parent = window.query_tree().parent
-                # Stop traversal, if the parent is not a window. When querying the parent, at some point, an integer
-                # is returned. Then just stop following the tree.
-                if isinstance(parent, int):
-                    # At this point, wm_title or wm_class may still be None. The recursive call with traverse=False
-                    # will replace any None with an empty string. See below.
-                    return self._get_window_info(window, False, wm_title, wm_class)
-                else:
-                    return self._get_window_info(parent, traverse, wm_title, wm_class)
-
-        else:
-            # No recursion, so fill unknown values with empty strings.
-            if wm_title is None:
-                wm_title = ""
-            if wm_class is None:
-                wm_class = ""
-            return self._create_window_info(window, wm_title, wm_class)
-
-    def _create_window_info(self, window, wm_title: str, wm_class: str):
-        """
-        Creates a WindowInfo object from the window title and WM_CLASS.
-        Also checks for the Java XFocusProxyWindow workaround and applies it if needed:
-
-        Workaround for Java applications: Java AWT uses a XFocusProxyWindow class, so to get usable information,
-        the parent window needs to be queried. Credits: https://github.com/mooz/xkeysnail/pull/32
-        https://github.com/JetBrains/jdk8u_jdk/blob/master/src/solaris/classes/sun/awt/X11/XFocusProxyWindow.java#L35
-        """
-        if "FocusProxy" in wm_class:
-            parent = window.query_tree().parent
-            # Discard both the already known wm_class and window title, because both are known to be wrong.
-            return self._get_window_info(parent, False)
-        else:
-            return WindowInfo(wm_title=wm_title, wm_class=wm_class)
-
-    def _try_get_window_title(self, window) -> typing.Optional[str]:
-        atom = self._try_read_property(window, self.__VisibleNameAtom)
-        if atom is None:
-            atom = self._try_read_property(window, self.__NameAtom)
-        if atom:
-            value = atom.value  # type: typing.Union[str, bytes]
-            # based on python3-xlib version, atom.value may be a bytes object, then decoding is necessary.
-            return value.decode("utf-8") if isinstance(value, bytes) else value
-        else:
-            return None
-
-    @staticmethod
-    def _try_read_property(window, property_name: str):
-        """
-        Try to read the given property of the given window.
-        Returns the atom, if successful, None otherwise.
-        """
-        try:
-            return window.get_property(property_name, 0, 0, 255)
-        except error.BadAtom:
-            return None
-
-    @staticmethod
-    def _try_get_window_class(window) -> typing.Optional[str]:
-        wm_class = window.get_wm_class()
-        if wm_class:
-            return "{}.{}".format(wm_class[0], wm_class[1])
-        else:
-            return None
-
 
 
 class XRecordInterface(XInterfaceBase, AbstractSysInterface):
diff --git a/lib/autokey/iomediator/iomediator.py b/lib/autokey/iomediator/iomediator.py
index 725ef0da..2ce425e9 100644
--- a/lib/autokey/iomediator/iomediator.py
+++ b/lib/autokey/iomediator/iomediator.py
@@ -21,7 +21,7 @@
 from autokey import common
 from autokey.configmanager.configmanager import ConfigManager
 from autokey.configmanager.configmanager_constants import INTERFACE_TYPE
-from autokey.interface import XRecordInterface, AtSpiInterface
+from autokey.interface import XRecordInterface, AtSpiInterface, XWindowInterface, GnomeExtensionWindowInterface
 from autokey.sys_interface.clipboard import Clipboard
 from autokey.model.phrase import SendMode
 
@@ -72,6 +72,11 @@ def __init__(self, service):
         else:
             self.interface = AtSpiInterface(self, self.app)
 
+        if True:
+            self.windowInterface = GnomeExtensionWindowInterface()
+        else:
+            self.windowInterface = XWindowInterface()
+
         self.clipboard = Clipboard()
 
         global CURRENT_INTERFACE
diff --git a/lib/autokey/scripting/window.py b/lib/autokey/scripting/window.py
index dce33b72..1f43f0a6 100644
--- a/lib/autokey/scripting/window.py
+++ b/lib/autokey/scripting/window.py
@@ -60,7 +60,7 @@ def wait_for_focus(self, title, timeOut=5):
         regex = re.compile(title)
         waited = 0
         while waited <= timeOut:
-            if regex.match(self.mediator.interface.get_window_title()):
+            if regex.match(self.mediator.windowInterface.get_window_title()):
                 return True
 
             if timeOut == 0:
@@ -256,7 +256,7 @@ def get_active_title(self):
         :return: the visible title of the currentle active window
         :rtype: C{str}
         """
-        return self.mediator.interface.get_window_title()
+        return self.mediator.windowInterface.get_window_title()
 
     def get_active_class(self):
         """
@@ -267,7 +267,7 @@ def get_active_class(self):
         :return: the class of the currently active window
         :rtype: C{str}
         """
-        return self.mediator.interface.get_window_class()
+        return self.mediator.windowInterface.get_window_class()
 
     def center_window(self, title=":ACTIVE:", win_width=None, win_height=None, monitor=0, matchClass=False, by_hex=False):
         """

From dba334583016174f0bed80b04105470ac2dfe7d3 Mon Sep 17 00:00:00 2001
From: Sam Sebastian <sebastiansam55@gmail.com>
Date: Sat, 22 Apr 2023 10:45:18 -0400
Subject: [PATCH 04/20] Add distinction between left and right modifiers

---
 CHANGELOG.rst                             |  16 ++
 lib/autokey/gtkui/data/hotkeysettings.xml | 148 ++++++++++++++--
 lib/autokey/gtkui/dialogs.py              |  51 ++++--
 lib/autokey/interface.py                  | 206 +++++++++++++---------
 lib/autokey/iomediator/iomediator.py      |  16 +-
 lib/autokey/model/abstract_hotkey.py      |  23 ++-
 lib/autokey/model/key.py                  |  47 ++++-
 7 files changed, 374 insertions(+), 133 deletions(-)

diff --git a/CHANGELOG.rst b/CHANGELOG.rst
index 060fe9a2..b4451a18 100644
--- a/CHANGELOG.rst
+++ b/CHANGELOG.rst
@@ -15,11 +15,27 @@ Important misc changes
 - Update action versions in build.yaml to latest.
 - Update Qt/GTK "Run" button in interface to run on F5
 - Update two links in the **README.rst** file.
+- Adds GNOME Window Extension for interacting with Windows on x11/wayland
 
 Features
 ---------
 Create a GUI-free headless entrypoint to autokey, which can be run without GUI libraries and controlled purely via scripting API
 
+Allows the distinction between left and right modifier keys for ``[Key.CONTROL, Key.ALT, Key.SUPER, Key.SHIFT, Key.HYPER, Key.META]``.
+
+At this time you cannot "mix and match", IE if you have a ``Key.CONTROL`` and ``Key.ALT`` as the hotkeys it will check for;
+``Key.LEFTCONTROL, Key.LEFTALT``
+and
+``Key.RIGHTCONTROL, Key.RIGHTALT``
+
+But not for;
+``Key.LEFTCONTROL, Key.RIGHTALT``
+``Key.RIGHTCONTROL, Key.RIGHTALT``
+
+This is considered a breaking change, prior it would, in effect, check for all of those scenarios. 
+
+Currently the left/right modifiers GUI option is only accessible via the GTK interface, but they should be respected if you manually update your config files.
+
 Bug fixes
 ---------
 
diff --git a/lib/autokey/gtkui/data/hotkeysettings.xml b/lib/autokey/gtkui/data/hotkeysettings.xml
index fa460962..4e72178b 100644
--- a/lib/autokey/gtkui/data/hotkeysettings.xml
+++ b/lib/autokey/gtkui/data/hotkeysettings.xml
@@ -76,8 +76,8 @@
                 <property name="spacing">5</property>
                 <property name="homogeneous">True</property>
                 <child>
-                  <object class="GtkToggleButton" id="controlButton">
-                    <property name="label" translatable="yes">Control</property>
+                  <object class="GtkToggleButton" id="rcontrolButton">
+                    <property name="label" translatable="yes">Right Control</property>
                     <property name="use_action_appearance">False</property>
                     <property name="visible">True</property>
                     <property name="can_focus">True</property>
@@ -91,8 +91,8 @@
                   </packing>
                 </child>
                 <child>
-                  <object class="GtkToggleButton" id="altButton">
-                    <property name="label" translatable="yes">Alt</property>
+                  <object class="GtkToggleButton" id="raltButton">
+                    <property name="label" translatable="yes">Right Alt</property>
                     <property name="use_action_appearance">False</property>
                     <property name="visible">True</property>
                     <property name="can_focus">True</property>
@@ -106,8 +106,8 @@
                   </packing>
                 </child>
                 <child>
-                  <object class="GtkToggleButton" id="altgrButton">
-                    <property name="label" translatable="yes">Alt GR</property>
+                  <object class="GtkToggleButton" id="rshiftButton">
+                    <property name="label" translatable="yes">Right Shift</property>
                     <property name="use_action_appearance">False</property>
                     <property name="visible">True</property>
                     <property name="can_focus">True</property>
@@ -121,8 +121,8 @@
                   </packing>
                 </child>
                 <child>
-                  <object class="GtkToggleButton" id="shiftButton">
-                    <property name="label" translatable="yes">Shift</property>
+                  <object class="GtkToggleButton" id="rsuperButton">
+                    <property name="label" translatable="yes">Right Super</property>
                     <property name="use_action_appearance">False</property>
                     <property name="visible">True</property>
                     <property name="can_focus">True</property>
@@ -136,8 +136,8 @@
                   </packing>
                 </child>
                 <child>
-                  <object class="GtkToggleButton" id="superButton">
-                    <property name="label" translatable="yes">Super</property>
+                  <object class="GtkToggleButton" id="rhyperButton">
+                    <property name="label" translatable="yes">Right Hyper</property>
                     <property name="use_action_appearance">False</property>
                     <property name="visible">True</property>
                     <property name="can_focus">True</property>
@@ -151,8 +151,8 @@
                   </packing>
                 </child>
                 <child>
-                  <object class="GtkToggleButton" id="hyperButton">
-                    <property name="label" translatable="yes">Hyper</property>
+                  <object class="GtkToggleButton" id="rmetaButton">
+                    <property name="label" translatable="yes">Right Meta</property>
                     <property name="use_action_appearance">False</property>
                     <property name="visible">True</property>
                     <property name="can_focus">True</property>
@@ -165,9 +165,97 @@
                     <property name="position">5</property>
                   </packing>
                 </child>
+              </object>
+              <packing>
+                <property name="expand">True</property>
+                <property name="fill">True</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkHBox" id="hbox3">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="spacing">5</property>
+                <property name="homogeneous">True</property>
+                <child>
+                  <object class="GtkToggleButton" id="lcontrolButton">
+                    <property name="label" translatable="yes">Left Control</property>
+                    <property name="use_action_appearance">False</property>
+                    <property name="visible">True</property>
+                    <property name="can_focus">True</property>
+                    <property name="receives_default">False</property>
+                    <property name="use_action_appearance">False</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkToggleButton" id="laltButton">
+                    <property name="label" translatable="yes">Left Alt</property>
+                    <property name="use_action_appearance">False</property>
+                    <property name="visible">True</property>
+                    <property name="can_focus">True</property>
+                    <property name="receives_default">False</property>
+                    <property name="use_action_appearance">False</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkToggleButton" id="lshiftButton">
+                    <property name="label" translatable="yes">Left Shift</property>
+                    <property name="use_action_appearance">False</property>
+                    <property name="visible">True</property>
+                    <property name="can_focus">True</property>
+                    <property name="receives_default">False</property>
+                    <property name="use_action_appearance">False</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">3</property>
+                  </packing>
+                </child>
                 <child>
-                  <object class="GtkToggleButton" id="metaButton">
-                    <property name="label" translatable="yes">Meta</property>
+                  <object class="GtkToggleButton" id="lsuperButton">
+                    <property name="label" translatable="yes">Left Super</property>
+                    <property name="use_action_appearance">False</property>
+                    <property name="visible">True</property>
+                    <property name="can_focus">True</property>
+                    <property name="receives_default">False</property>
+                    <property name="use_action_appearance">False</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">4</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkToggleButton" id="lhyperButton">
+                    <property name="label" translatable="yes">Left Hyper</property>
+                    <property name="use_action_appearance">False</property>
+                    <property name="visible">True</property>
+                    <property name="can_focus">True</property>
+                    <property name="receives_default">False</property>
+                    <property name="use_action_appearance">False</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">5</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkToggleButton" id="lmetaButton">
+                    <property name="label" translatable="yes">Left Meta</property>
                     <property name="use_action_appearance">False</property>
                     <property name="visible">True</property>
                     <property name="can_focus">True</property>
@@ -184,11 +272,37 @@
               <packing>
                 <property name="expand">True</property>
                 <property name="fill">True</property>
-                <property name="position">0</property>
+                <property name="position">1</property>
               </packing>
             </child>
             <child>
-              <object class="GtkHBox" id="hbox3">
+            <object class="GtkHBox" id="hbox5">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <child>
+                  <object class="GtkToggleButton" id="altgrButton">
+                    <property name="label" translatable="yes">Alt GR</property>
+                    <property name="use_action_appearance">False</property>
+                    <property name="visible">True</property>
+                    <property name="can_focus">True</property>
+                    <property name="receives_default">False</property>
+                    <property name="use_action_appearance">False</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">6</property>
+                  </packing>
+                </child>
+            </object>
+              <packing>
+                <property name="expand">True</property>
+                <property name="fill">True</property>
+                <property name="position">2</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkHBox" id="hbox4">
                 <property name="visible">True</property>
                 <property name="can_focus">False</property>
                 <child>
@@ -224,7 +338,7 @@
               <packing>
                 <property name="expand">True</property>
                 <property name="fill">True</property>
-                <property name="position">1</property>
+                <property name="position">3</property>
               </packing>
             </child>
           </object>
diff --git a/lib/autokey/gtkui/dialogs.py b/lib/autokey/gtkui/dialogs.py
index 74366edc..cea561a8 100644
--- a/lib/autokey/gtkui/dialogs.py
+++ b/lib/autokey/gtkui/dialogs.py
@@ -433,23 +433,50 @@ def __init__(self, parent, configManager, closure):
         self.closure = closure
         self.key = None
 
-        self.controlButton = builder.get_object("controlButton")
-        self.altButton = builder.get_object("altButton")
+        self.rcontrolButton = builder.get_object("rcontrolButton")
+        self.raltButton = builder.get_object("raltButton")
+        self.rshiftButton = builder.get_object("rshiftButton")
+        self.rsuperButton = builder.get_object("rsuperButton")
+        self.rhyperButton = builder.get_object("rhyperButton")
+        self.rmetaButton = builder.get_object("rmetaButton")
+
+        self.lcontrolButton = builder.get_object("lcontrolButton")
+        self.laltButton = builder.get_object("laltButton")
+        self.lshiftButton = builder.get_object("lshiftButton")
+        self.lsuperButton = builder.get_object("lsuperButton")
+        self.lhyperButton = builder.get_object("lhyperButton")
+        self.lmetaButton = builder.get_object("lmetaButton")
+
         self.altgrButton = builder.get_object("altgrButton")
-        self.shiftButton = builder.get_object("shiftButton")
-        self.superButton = builder.get_object("superButton")
-        self.hyperButton = builder.get_object("hyperButton")
-        self.metaButton = builder.get_object("metaButton")
         self.setButton = builder.get_object("setButton")
         self.keyLabel = builder.get_object("keyLabel")
         self.MODIFIER_BUTTONS = {
-            self.controlButton: Key.CONTROL,
-            self.altButton: Key.ALT,
+            # self.controlButton: Key.CONTROL,
+            self.lcontrolButton: Key.LEFTCONTROL,
+            self.rcontrolButton: Key.RIGHTCONTROL,
+
+            # self.altButton: Key.ALT,
+            self.laltButton: Key.LEFTALT,
+            self.raltButton: Key.RIGHTALT,
+
             self.altgrButton: Key.ALT_GR,
-            self.shiftButton: Key.SHIFT,
-            self.superButton: Key.SUPER,
-            self.hyperButton: Key.HYPER,
-            self.metaButton: Key.META,
+
+            # self.shiftButton: Key.SHIFT,
+            self.lshiftButton: Key.LEFTSHIFT,
+            self.rshiftButton: Key.RIGHTSHIFT,
+
+            # self.superButton: Key.SUPER,
+            self.lsuperButton: Key.LEFTSUPER,
+            self.rsuperButton: Key.RIGHTSUPER,
+
+            # self.hyperButton: Key.HYPER,
+            self.lhyperButton: Key.LEFTHYPER,
+            self.rhyperButton: Key.RIGHTHYPER,
+
+            # self.metaButton: Key.META,
+            self.lmetaButton: Key.LEFTMETA,
+            self.rmetaButton: Key.RIGHTMETA,
+
         }
 
         DialogBase.__init__(self)
diff --git a/lib/autokey/interface.py b/lib/autokey/interface.py
index 74371c60..2b57fcb8 100644
--- a/lib/autokey/interface.py
+++ b/lib/autokey/interface.py
@@ -266,6 +266,9 @@ def _active_window(self):
         for window in window_list:
             if window['focus']:
                 return window
+        # TODO seeing this a lot when I use a script to call `gnome-screenshot -a`, suspect it's just related to that focus behaves differently when that app runs?
+        logger.error("Unable to determine the active window")
+        return None
             
     def _dbus_window_list(self):
         #TODO consider how/if error handling can be implemented
@@ -671,7 +674,7 @@ def __build_modifier_mask_mapping(self):
         self.modMasks = {}
         mapping = self.localDisplay.get_modifier_mapping()
 
-        for keySym, ak in XK_TO_AK_MAP.items():
+        for ak, keySym in AK_TO_XK_MAP.items():
             if ak in MODIFIERS:
                 keyCodeList = self.localDisplay.keysym_to_keycodes(keySym)
                 found = False
@@ -1277,96 +1280,123 @@ def __pumpEvents(self):
 XK.load_keysym_group('xkb')
 
 XK_TO_AK_MAP = {
-           XK.XK_Shift_L: Key.SHIFT,
-           XK.XK_Shift_R: Key.SHIFT,
-           XK.XK_Caps_Lock: Key.CAPSLOCK,
-           XK.XK_Control_L: Key.CONTROL,
-           XK.XK_Control_R: Key.CONTROL,
-           XK.XK_Alt_L: Key.ALT,
-           XK.XK_Alt_R: Key.ALT,
-           XK.XK_ISO_Level3_Shift: Key.ALT_GR,
-           XK.XK_Super_L: Key.SUPER,
-           XK.XK_Super_R: Key.SUPER,
-           XK.XK_Hyper_L: Key.HYPER,
-           XK.XK_Hyper_R: Key.HYPER,
-           XK.XK_Meta_L: Key.META,
-           XK.XK_Meta_R: Key.META,
-           XK.XK_Num_Lock: Key.NUMLOCK,
-           #SPACE: Key.SPACE,
-           XK.XK_Tab: Key.TAB,
-           XK.XK_Left: Key.LEFT,
-           XK.XK_Right: Key.RIGHT,
-           XK.XK_Up: Key.UP,
-           XK.XK_Down: Key.DOWN,
-           XK.XK_Return: Key.ENTER,
-           XK.XK_BackSpace: Key.BACKSPACE,
-           XK.XK_Scroll_Lock: Key.SCROLL_LOCK,
-           XK.XK_Print: Key.PRINT_SCREEN,
-           XK.XK_Pause: Key.PAUSE,
-           XK.XK_Menu: Key.MENU,
-           XK.XK_F1: Key.F1,
-           XK.XK_F2: Key.F2,
-           XK.XK_F3: Key.F3,
-           XK.XK_F4: Key.F4,
-           XK.XK_F5: Key.F5,
-           XK.XK_F6: Key.F6,
-           XK.XK_F7: Key.F7,
-           XK.XK_F8: Key.F8,
-           XK.XK_F9: Key.F9,
-           XK.XK_F10: Key.F10,
-           XK.XK_F11: Key.F11,
-           XK.XK_F12: Key.F12,
-           XK.XK_F13: Key.F13,
-           XK.XK_F14: Key.F14,
-           XK.XK_F15: Key.F15,
-           XK.XK_F16: Key.F16,
-           XK.XK_F17: Key.F17,
-           XK.XK_F18: Key.F18,
-           XK.XK_F19: Key.F19,
-           XK.XK_F20: Key.F20,
-           XK.XK_F21: Key.F21,
-           XK.XK_F22: Key.F22,
-           XK.XK_F23: Key.F23,
-           XK.XK_F24: Key.F24,
-           XK.XK_F25: Key.F25,
-           XK.XK_F26: Key.F26,
-           XK.XK_F27: Key.F27,
-           XK.XK_F28: Key.F28,
-           XK.XK_F29: Key.F29,
-           XK.XK_F30: Key.F30,
-           XK.XK_F31: Key.F31,
-           XK.XK_F32: Key.F32,
-           XK.XK_F33: Key.F33,
-           XK.XK_F34: Key.F34,
-           XK.XK_F35: Key.F35,
-           XK.XK_Escape: Key.ESCAPE,
-           XK.XK_Insert: Key.INSERT,
-           XK.XK_Delete: Key.DELETE,
-           XK.XK_Home: Key.HOME,
-           XK.XK_End: Key.END,
-           XK.XK_Page_Up: Key.PAGE_UP,
-           XK.XK_Page_Down: Key.PAGE_DOWN,
-           XK.XK_KP_Insert: Key.NP_INSERT,
-           XK.XK_KP_Delete: Key.NP_DELETE,
-           XK.XK_KP_End: Key.NP_END,
-           XK.XK_KP_Down: Key.NP_DOWN,
-           XK.XK_KP_Page_Down: Key.NP_PAGE_DOWN,
-           XK.XK_KP_Left: Key.NP_LEFT,
-           XK.XK_KP_Begin: Key.NP_5,
-           XK.XK_KP_Right: Key.NP_RIGHT,
-           XK.XK_KP_Home: Key.NP_HOME,
-           XK.XK_KP_Up: Key.NP_UP,
-           XK.XK_KP_Page_Up: Key.NP_PAGE_UP,
-           XK.XK_KP_Divide: Key.NP_DIVIDE,
-           XK.XK_KP_Multiply: Key.NP_MULTIPLY,
-           XK.XK_KP_Add: Key.NP_ADD,
-           XK.XK_KP_Subtract: Key.NP_SUBTRACT,
-           XK.XK_KP_Enter: Key.ENTER,
-           XK.XK_space: ' '
-           }
+    
+    # XK.XK_Shift_L: Key.SHIFT,
+    XK.XK_Shift_L: Key.LEFTSHIFT,
+    XK.XK_Shift_R: Key.RIGHTSHIFT,
+
+    # XK.XK_Control_L: Key.CONTROL,
+    XK.XK_Control_L: Key.LEFTCONTROL,
+    XK.XK_Control_R: Key.RIGHTCONTROL,
+
+    # XK.XK_Alt_L: Key.ALT,
+    XK.XK_Alt_L: Key.LEFTALT,
+    XK.XK_Alt_R: Key.RIGHTALT,
+    
+    # XK.XK_Super_L: Key.SUPER,
+    XK.XK_Super_L: Key.LEFTSUPER,
+    XK.XK_Super_R: Key.RIGHTSUPER,
+
+    # XK.XK_Hyper_L: Key.HYPER,
+    XK.XK_Hyper_L: Key.LEFTHYPER,
+    XK.XK_Hyper_R: Key.RIGHTHYPER,
+
+    # XK.XK_Meta_L: Key.META,
+    XK.XK_Meta_L: Key.LEFTMETA,
+    XK.XK_Meta_R: Key.RIGHTMETA,
+
+    XK.XK_Caps_Lock: Key.CAPSLOCK,
+    XK.XK_Num_Lock: Key.NUMLOCK,
+
+    #SPACE: Key.SPACE,
+    XK.XK_Tab: Key.TAB,
+
+    XK.XK_Left: Key.LEFT,
+    XK.XK_Right: Key.RIGHT,
+    XK.XK_Up: Key.UP,
+    XK.XK_Down: Key.DOWN,
+
+    XK.XK_Return: Key.ENTER,
+    XK.XK_BackSpace: Key.BACKSPACE,
+    XK.XK_Scroll_Lock: Key.SCROLL_LOCK,
+    XK.XK_Print: Key.PRINT_SCREEN,
+    XK.XK_Pause: Key.PAUSE,
+    XK.XK_Menu: Key.MENU,
+
+    XK.XK_F1: Key.F1,
+    XK.XK_F2: Key.F2,
+    XK.XK_F3: Key.F3,
+    XK.XK_F4: Key.F4,
+    XK.XK_F5: Key.F5,
+    XK.XK_F6: Key.F6,
+    XK.XK_F7: Key.F7,
+    XK.XK_F8: Key.F8,
+    XK.XK_F9: Key.F9,
+    XK.XK_F10: Key.F10,
+    XK.XK_F11: Key.F11,
+    XK.XK_F12: Key.F12,
+    XK.XK_F13: Key.F13,
+    XK.XK_F14: Key.F14,
+    XK.XK_F15: Key.F15,
+    XK.XK_F16: Key.F16,
+    XK.XK_F17: Key.F17,
+    XK.XK_F18: Key.F18,
+    XK.XK_F19: Key.F19,
+    XK.XK_F20: Key.F20,
+    XK.XK_F21: Key.F21,
+    XK.XK_F22: Key.F22,
+    XK.XK_F23: Key.F23,
+    XK.XK_F24: Key.F24,
+    XK.XK_F25: Key.F25,
+    XK.XK_F26: Key.F26,
+    XK.XK_F27: Key.F27,
+    XK.XK_F28: Key.F28,
+    XK.XK_F29: Key.F29,
+    XK.XK_F30: Key.F30,
+    XK.XK_F31: Key.F31,
+    XK.XK_F32: Key.F32,
+    XK.XK_F33: Key.F33,
+    XK.XK_F34: Key.F34,
+    XK.XK_F35: Key.F35,
+
+    XK.XK_Escape: Key.ESCAPE,
+
+    XK.XK_Insert: Key.INSERT,
+    XK.XK_Delete: Key.DELETE,
+    XK.XK_Home: Key.HOME,
+    XK.XK_End: Key.END,
+    XK.XK_Page_Up: Key.PAGE_UP,
+    XK.XK_Page_Down: Key.PAGE_DOWN,
+
+    XK.XK_KP_Insert: Key.NP_INSERT,
+    XK.XK_KP_Delete: Key.NP_DELETE,
+    XK.XK_KP_End: Key.NP_END,
+    XK.XK_KP_Down: Key.NP_DOWN,
+    XK.XK_KP_Page_Down: Key.NP_PAGE_DOWN,
+    XK.XK_KP_Left: Key.NP_LEFT,
+    XK.XK_KP_Begin: Key.NP_5,
+    XK.XK_KP_Right: Key.NP_RIGHT,
+    XK.XK_KP_Home: Key.NP_HOME,
+    XK.XK_KP_Up: Key.NP_UP,
+    XK.XK_KP_Page_Up: Key.NP_PAGE_UP,
+    XK.XK_KP_Divide: Key.NP_DIVIDE,
+    XK.XK_KP_Multiply: Key.NP_MULTIPLY,
+    XK.XK_KP_Add: Key.NP_ADD,
+    XK.XK_KP_Subtract: Key.NP_SUBTRACT,
+    XK.XK_KP_Enter: Key.ENTER,
+    XK.XK_space: ' ',
+    XK.XK_ISO_Level3_Shift: Key.ALT_GR,
+    }
 
 AK_TO_XK_MAP = dict((v,k) for k, v in XK_TO_AK_MAP.items())
 
+AK_TO_XK_MAP[Key.SHIFT] = XK.XK_Shift_L
+AK_TO_XK_MAP[Key.CONTROL] = XK.XK_Control_L
+AK_TO_XK_MAP[Key.ALT] = XK.XK_Alt_L
+AK_TO_XK_MAP[Key.SUPER] = XK.XK_Super_L
+AK_TO_XK_MAP[Key.HYPER] = XK.XK_Hyper_L
+AK_TO_XK_MAP[Key.META] = XK.XK_Meta_L
+
 XK_TO_AK_NUMLOCKED = {
            XK.XK_KP_Insert: "0",
            XK.XK_KP_Delete: ".",
diff --git a/lib/autokey/iomediator/iomediator.py b/lib/autokey/iomediator/iomediator.py
index 2ce425e9..e009b342 100644
--- a/lib/autokey/iomediator/iomediator.py
+++ b/lib/autokey/iomediator/iomediator.py
@@ -55,17 +55,11 @@ def __init__(self, service):
         self.app = service.app
         
         # Modifier tracking
-        self.modifiers = {
-            Key.CONTROL: False,
-            Key.ALT: False,
-            Key.ALT_GR: False,
-            Key.SHIFT: False,
-            Key.SUPER: False,
-            Key.HYPER: False,
-            Key.META: False,
-            Key.CAPSLOCK: False,
-            Key.NUMLOCK: False
-        }
+        self.modifiers = {}
+        for key in MODIFIERS:
+            self.modifiers[key]=False
+
+
         
         if self.interfaceType == X_RECORD_INTERFACE:
             self.interface = XRecordInterface(self, self.app)
diff --git a/lib/autokey/model/abstract_hotkey.py b/lib/autokey/model/abstract_hotkey.py
index 2ab0f267..797dc119 100644
--- a/lib/autokey/model/abstract_hotkey.py
+++ b/lib/autokey/model/abstract_hotkey.py
@@ -18,7 +18,7 @@
 
 from autokey.model.triggermode import TriggerMode
 from autokey.model.abstract_window_filter import AbstractWindowFilter
-from autokey.model.key import Key
+from autokey.model.key import Key, UNIVERSAL_MODIFIERS, MAPPED_UNIVERSAL_MODIFIERS
 
 
 class AbstractHotkey(AbstractWindowFilter):
@@ -57,8 +57,27 @@ def unset_hotkey(self):
             self.modes.remove(TriggerMode.HOTKEY)
 
     def check_hotkey_has_properties(self, modifiers, key, windowTitle):
+        """
+        This method is run whenever a key is pressed for all of the scripts in autokey
+
+        :param modifiers: The modifiers that were pressed when the key was pressed
+        :param key: The key that was pressed
+        :param windowTitle: The title of the window that was active when the key was pressed
+        :return Boolean: Whether or not the hotkey matches
+        """
+        left_mods = []
+        right_mods = []
+        for modifier in self.modifiers:
+            if modifier in UNIVERSAL_MODIFIERS: # if one of the hotkey modifiers is universal. Generate a left and right version of the hotkey. the same way it does below and return if true?
+                left_mods.append(MAPPED_UNIVERSAL_MODIFIERS[modifier][0])
+                right_mods.append(MAPPED_UNIVERSAL_MODIFIERS[modifier][1])
+            else:
+                left_mods.append(modifier)
+                right_mods.append(modifier)
+
+        #print(modifiers, self.modifiers, left_mods, right_mods)
         if self.hotKey is not None and self._should_trigger_window_title(windowTitle):
-            return (self.modifiers == modifiers) and (self.hotKey == key)
+            return (self.modifiers == modifiers or left_mods == modifiers or right_mods == modifiers) and (self.hotKey == key)
         else:
             return False
 
diff --git a/lib/autokey/model/key.py b/lib/autokey/model/key.py
index 81af43af..fd91b95d 100644
--- a/lib/autokey/model/key.py
+++ b/lib/autokey/model/key.py
@@ -31,6 +31,26 @@ class Key(str, enum.Enum):
     CAPSLOCK = "<capslock>"
     NUMLOCK = "<numlock>"
     META = "<meta>"
+
+    # Left Modifier Keys
+    LEFTCONTROL = "<left_ctrl>"
+    LEFTALT = "<left_alt>"
+    LEFTSHIFT = "<left_shift>"
+    LEFTSUPER = "<left_super>"
+    LEFTHYPER = "<left_hyper>"
+    LEFTCAPSLOCK = "<left_capslock>"
+    LEFTNUMLOCK = "<left_numlock>"
+    LEFTMETA = "<left_meta>"
+
+    # Right Modifier Keys
+    RIGHTCONTROL = "<right_ctrl>"
+    RIGHTALT = "<right_alt>"
+    RIGHTSHIFT = "<right_shift>"
+    RIGHTSUPER = "<right_super>"
+    RIGHTHYPER = "<right_hyper>"
+    RIGHTCAPSLOCK = "<right_capslock>"
+    RIGHTNUMLOCK = "<right_numlock>"
+    RIGHTMETA = "<right_meta>"
     
     F1 = "<f1>"
     F2 = "<f2>"
@@ -120,6 +140,27 @@ def is_key(cls, key_string: str) -> bool:
 # Used to identify special keys in texts. Also include <codeXX> literals as defined in the _code_point_re.
 KEY_FIND_RE = re.compile("|".join(("|".join(Key), _code_point_re.pattern)), re.UNICODE)
 KEY_SPLIT_RE = re.compile("(<[^<>]+>\+?)")
-MODIFIERS = [Key.CONTROL, Key.ALT, Key.ALT_GR, Key.SHIFT, Key.SUPER, Key.HYPER, Key.META, Key.CAPSLOCK, Key.NUMLOCK]
-HELD_MODIFIERS = [Key.CONTROL, Key.ALT_GR, Key.ALT, Key.SUPER, Key.SHIFT, Key.HYPER, Key.META
-]
\ No newline at end of file
+
+# these types of modifiers are accepted as either left or right versions when used in hotkeys
+# when sent via keyboard they will send the LEFT version of the modifier
+UNIVERSAL_MODIFIERS = [Key.CONTROL, Key.ALT, Key.SUPER, Key.SHIFT, Key.HYPER, Key.META]
+MAPPED_UNIVERSAL_MODIFIERS = {
+    Key.CONTROL: [Key.LEFTCONTROL, Key.RIGHTCONTROL],
+    Key.ALT: [Key.LEFTALT, Key.RIGHTALT],
+    Key.SUPER: [Key.LEFTSUPER, Key.RIGHTSUPER],
+    Key.SHIFT: [Key.LEFTSHIFT, Key.RIGHTSHIFT],
+    Key.HYPER: [Key.LEFTHYPER, Key.RIGHTHYPER],
+    Key.META: [Key.LEFTMETA, Key.RIGHTMETA]
+}
+
+MODIFIERS = [
+    Key.CONTROL, Key.ALT, Key.ALT_GR, Key.SHIFT, Key.SUPER, Key.HYPER, Key.META, Key.CAPSLOCK, Key.NUMLOCK,
+    Key.LEFTCONTROL,Key.LEFTALT,Key.LEFTSHIFT,Key.LEFTSUPER,Key.LEFTHYPER,Key.LEFTMETA,
+    Key.RIGHTCONTROL,Key.RIGHTALT,Key.RIGHTSHIFT,Key.RIGHTSUPER,Key.RIGHTHYPER,Key.RIGHTMETA
+    ]
+HELD_MODIFIERS = [
+    Key.CONTROL, Key.ALT_GR, Key.ALT, Key.SUPER, Key.SHIFT, Key.HYPER, Key.META,
+    Key.LEFTCONTROL,Key.LEFTALT,Key.LEFTSHIFT,Key.LEFTSUPER,Key.LEFTHYPER,Key.LEFTMETA,
+    Key.RIGHTCONTROL,Key.RIGHTALT,Key.RIGHTSHIFT,Key.RIGHTSUPER,Key.RIGHTHYPER,Key.RIGHTMETA
+    ]
+

From 579c71d8faeba8edd0272136889ef845162e37e4 Mon Sep 17 00:00:00 2001
From: Sam Sebastian <sebastiansam55@gmail.com>
Date: Sat, 22 Apr 2023 10:51:27 -0400
Subject: [PATCH 05/20] Use XWindowInterface by default

---
 lib/autokey/iomediator/iomediator.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/autokey/iomediator/iomediator.py b/lib/autokey/iomediator/iomediator.py
index e009b342..00883cfd 100644
--- a/lib/autokey/iomediator/iomediator.py
+++ b/lib/autokey/iomediator/iomediator.py
@@ -66,7 +66,7 @@ def __init__(self, service):
         else:
             self.interface = AtSpiInterface(self, self.app)
 
-        if True:
+        if False:
             self.windowInterface = GnomeExtensionWindowInterface()
         else:
             self.windowInterface = XWindowInterface()

From 995cdcf764780cf50d3f3c230281e171495dafd1 Mon Sep 17 00:00:00 2001
From: Sam Sebastian <sebastiansam55@gmail.com>
Date: Sat, 22 Apr 2023 15:38:17 -0400
Subject: [PATCH 06/20] Add left/right modifiers to Qt interface

---
 lib/autokey/qtui/dialogs/hotkeysettings.py    |  22 ++--
 .../qtui/resources/ui/hotkeysettings.ui       | 115 +++++++++++++++---
 2 files changed, 112 insertions(+), 25 deletions(-)

diff --git a/lib/autokey/qtui/dialogs/hotkeysettings.py b/lib/autokey/qtui/dialogs/hotkeysettings.py
index 020db66d..e79744c7 100644
--- a/lib/autokey/qtui/dialogs/hotkeysettings.py
+++ b/lib/autokey/qtui/dialogs/hotkeysettings.py
@@ -63,13 +63,21 @@ def __init__(self, parent):
         self.grabber = None  # type: iomediator.KeyGrabber
 
         self.MODIFIER_BUTTONS = {
-            self.mod_control_button: Key.CONTROL,
-            self.mod_alt_button: Key.ALT,
-            # self.mod_altgr_button: Key.ALT_GR,
-            self.mod_shift_button: Key.SHIFT,
-            self.mod_super_button: Key.SUPER,
-            self.mod_hyper_button: Key.HYPER,
-            self.mod_meta_button: Key.META,
+            self.mod_right_control_button: Key.RIGHTCONTROL,
+            self.mod_right_alt_button: Key.RIGHTALT,
+            # self.mod_right_altgr_button: Key.ALT_GR,
+            self.mod_right_shift_button: Key.RIGHTSHIFT,
+            self.mod_right_super_button: Key.RIGHTSUPER,
+            self.mod_right_hyper_button: Key.RIGHTHYPER,
+            self.mod_right_meta_button: Key.RIGHTMETA,
+
+            self.mod_left_control_button: Key.LEFTCONTROL,
+            self.mod_left_alt_button: Key.LEFTALT,
+            # self.mod_left_altgr_button: Key.ALT_GR,
+            self.mod_left_shift_button: Key.LEFTSHIFT,
+            self.mod_left_super_button: Key.LEFTSUPER,
+            self.mod_left_hyper_button: Key.LEFTHYPER,
+            self.mod_left_meta_button: Key.LEFTMETA,
         }
 
     def _update_key(self, key):
diff --git a/lib/autokey/qtui/resources/ui/hotkeysettings.ui b/lib/autokey/qtui/resources/ui/hotkeysettings.ui
index 06edddab..61b19941 100644
--- a/lib/autokey/qtui/resources/ui/hotkeysettings.ui
+++ b/lib/autokey/qtui/resources/ui/hotkeysettings.ui
@@ -18,9 +18,9 @@
   </property>
   <layout class="QGridLayout" name="gridLayout">
    <item row="1" column="1">
-    <widget class="QPushButton" name="mod_alt_button">
+    <widget class="QPushButton" name="mod_left_alt_button">
      <property name="text">
-      <string>Alt</string>
+      <string>Left Alt</string>
      </property>
      <property name="checkable">
       <bool>true</bool>
@@ -28,9 +28,9 @@
     </widget>
    </item>
    <item row="1" column="4">
-    <widget class="QPushButton" name="mod_hyper_button">
+    <widget class="QPushButton" name="mod_left_hyper_button">
      <property name="text">
-      <string>Hyper</string>
+      <string>Left Hyper</string>
      </property>
      <property name="checkable">
       <bool>true</bool>
@@ -38,9 +38,9 @@
     </widget>
    </item>
    <item row="1" column="5">
-    <widget class="QPushButton" name="mod_meta_button">
+    <widget class="QPushButton" name="mod_left_meta_button">
      <property name="text">
-      <string>Meta</string>
+      <string>Left Meta</string>
      </property>
      <property name="checkable">
       <bool>true</bool>
@@ -61,9 +61,9 @@
     </spacer>
    </item>
    <item row="1" column="2">
-    <widget class="QPushButton" name="mod_shift_button">
+    <widget class="QPushButton" name="mod_left_shift_button">
      <property name="text">
-      <string>Shift</string>
+      <string>Left Shift</string>
      </property>
      <property name="checkable">
       <bool>true</bool>
@@ -71,9 +71,9 @@
     </widget>
    </item>
    <item row="1" column="0">
-    <widget class="QPushButton" name="mod_control_button">
+    <widget class="QPushButton" name="mod_left_control_button">
      <property name="text">
-      <string>Control</string>
+      <string>Left Control</string>
      </property>
      <property name="checkable">
       <bool>true</bool>
@@ -81,9 +81,82 @@
     </widget>
    </item>
    <item row="1" column="3">
-    <widget class="QPushButton" name="mod_super_button">
+    <widget class="QPushButton" name="mod_left_super_button">
      <property name="text">
-      <string>Super</string>
+      <string>Left Super</string>
+     </property>
+     <property name="checkable">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+      <item row="2" column="1">
+    <widget class="QPushButton" name="mod_right_alt_button">
+     <property name="text">
+      <string>Right Alt</string>
+     </property>
+     <property name="checkable">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+   <item row="2" column="4">
+    <widget class="QPushButton" name="mod_right_hyper_button">
+     <property name="text">
+      <string>Right Hyper</string>
+     </property>
+     <property name="checkable">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+   <item row="2" column="5">
+    <widget class="QPushButton" name="mod_right_meta_button">
+     <property name="text">
+      <string>Right Meta</string>
+     </property>
+     <property name="checkable">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+   <item row="5" column="0" colspan="6">
+    <spacer name="verticalSpacer">
+     <property name="orientation">
+      <enum>Qt::Vertical</enum>
+     </property>
+     <property name="sizeHint" stdset="0">
+      <size>
+       <width>81</width>
+       <height>27</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
+   <item row="2" column="2">
+    <widget class="QPushButton" name="mod_right_shift_button">
+     <property name="text">
+      <string>Right Shift</string>
+     </property>
+     <property name="checkable">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+   <item row="2" column="0">
+    <widget class="QPushButton" name="mod_right_control_button">
+     <property name="text">
+      <string>Right Control</string>
+     </property>
+     <property name="checkable">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+   <item row="2" column="3">
+    <widget class="QPushButton" name="mod_right_super_button">
+     <property name="text">
+      <string>Right Super</string>
      </property>
      <property name="checkable">
       <bool>true</bool>
@@ -138,12 +211,18 @@
   </layout>
  </widget>
  <tabstops>
-  <tabstop>mod_control_button</tabstop>
-  <tabstop>mod_alt_button</tabstop>
-  <tabstop>mod_shift_button</tabstop>
-  <tabstop>mod_super_button</tabstop>
-  <tabstop>mod_hyper_button</tabstop>
-  <tabstop>mod_meta_button</tabstop>
+  <tabstop>mod_left_control_button</tabstop>
+  <tabstop>mod_left_alt_button</tabstop>
+  <tabstop>mod_left_shift_button</tabstop>
+  <tabstop>mod_left_super_button</tabstop>
+  <tabstop>mod_left_hyper_button</tabstop>
+  <tabstop>mod_left_meta_button</tabstop>
+  <tabstop>mod_right_control_button</tabstop>
+  <tabstop>mod_right_alt_button</tabstop>
+  <tabstop>mod_right_shift_button</tabstop>
+  <tabstop>mod_right_super_button</tabstop>
+  <tabstop>mod_right_hyper_button</tabstop>
+  <tabstop>mod_right_meta_button</tabstop>
  </tabstops>
  <resources/>
  <connections>

From 7926b8619409a308486c2ec5ad1cb79556e66b58 Mon Sep 17 00:00:00 2001
From: Sam Sebastian <sebastiansam55@gmail.com>
Date: Tue, 25 Apr 2023 20:23:23 -0400
Subject: [PATCH 07/20] pull out gnome extension interfaces

---
 lib/autokey/gnome_interface.py |  96 ++++++++++++++++++++++++++++++
 lib/autokey/interface.py       | 103 ++++-----------------------------
 2 files changed, 106 insertions(+), 93 deletions(-)
 create mode 100644 lib/autokey/gnome_interface.py

diff --git a/lib/autokey/gnome_interface.py b/lib/autokey/gnome_interface.py
new file mode 100644
index 00000000..fdb1381a
--- /dev/null
+++ b/lib/autokey/gnome_interface.py
@@ -0,0 +1,96 @@
+
+import dbus
+import json
+from dbus.mainloop.glib import DBusGMainLoop
+
+
+from autokey.sys_interface.abstract_interface import AbstractSysInterface, AbstractMouseInterface, AbstractWindowInterface, WindowInfo
+
+logger = __import__("autokey.logger").logger.get_logger(__name__)
+
+class DBusInterface:
+    def __init__(self):
+        mainloop= DBusGMainLoop()
+        session_bus = dbus.SessionBus(mainloop=mainloop)
+        shell_obj = session_bus.get_object('org.gnome.Shell', '/org/gnome/Shell/Extensions/AutoKey')
+        self.dbus_interface = dbus.Interface(shell_obj, 'org.gnome.Shell.Extensions.AutoKey')
+
+class GnomeMouseReadInterface(DBusInterface):
+    def __init__(self):
+        super().__init__()
+
+    def mouse_location(self):
+        [x, y] = self.dbus_interface.GetMouseLocation()
+        return [int(x), int(y)]
+
+class GnomeExtensionWindowInterface(DBusInterface, AbstractWindowInterface):
+    def __init__(self):
+        super().__init__()
+        
+
+    def get_window_info(self, window=None, traverse: bool=True) -> WindowInfo:
+        """
+        Returns a WindowInfo object containing the class and title.
+        """
+        window = self._active_window()
+        return WindowInfo(wm_class=window['wm_class'], wm_title=window['wm_title'])
+
+    def get_window_class(self, window=None, traverse=True) -> str:
+        """
+        Returns the window class of the currently focused window.
+        """
+        return self._active_window()['wm_class']
+        
+    
+    def get_window_title(self, window=None, traverse=True) -> str:
+        """
+        Returns the active window title
+        """
+        return self._active_window()['wm_title']
+
+    def _active_window(self):
+        #TODO probably can be done more efficiently with an additional dbus method in the gnome extension
+        window_list = self._dbus_window_list()
+        for window in window_list:
+            if window['focus']:
+                return window
+        # TODO seeing this a lot when I use a script to call `gnome-screenshot -a`, suspect it's just related to that focus behaves differently when that app runs?
+        logger.error("Unable to determine the active window")
+        return None
+            
+    def _dbus_window_list(self):
+        #TODO consider how/if error handling can be implemented
+        try:
+            return json.loads(self.dbus_interface.List())
+        except dbus.exceptions.DBusException as e:
+            self.__init__() #reconnect to dbus
+            return json.loads(self.dbus_interface.List())
+            
+    def _dbus_close_window(self, window_id):
+        #TODO consider how/if error handling can be implemented
+        try:
+            self.dbus_interface.Close(window_id)
+        except dbus.exceptions.DBusException as e:
+            self.__init__()
+            self.dbus_interface.Close(window_id)
+
+    def _dbus_activate_window(self, window_id):
+        try:
+            self.dbus_interface.Activate(window_id)
+        except dbus.exceptions.DBusException as e:  
+            self.__init__()
+            self.dbus_interface.Activate(window_id)
+
+    def _dbus_move_window(self, window_id, x, y):
+        try:
+            self.dbus_interface.Move(window_id, x, y)
+        except dbus.exceptions.DBusException as e:
+            self.__init__()
+            self.dbus_interface.Move(window_id, x, y)
+
+    def _dbus_resize_window(self, window_id, width, height):
+        try:
+            self.dbus_interface.Resize(window_id, width, height)
+        except dbus.exceptions.DBusException as e:
+            self.__init__()
+            self.dbus_interface.Resize(window_id, width, height)
\ No newline at end of file
diff --git a/lib/autokey/interface.py b/lib/autokey/interface.py
index 2b57fcb8..f5ee3de4 100644
--- a/lib/autokey/interface.py
+++ b/lib/autokey/interface.py
@@ -29,17 +29,14 @@
 import queue
 import subprocess
 import time
-import json
-import functools
 import copy
-import dbus
-from dbus.mainloop.glib import DBusGMainLoop
+
 
 import autokey.model.phrase
 if typing.TYPE_CHECKING:
     from autokey.iomediator.iomediator import IoMediator
 import autokey.configmanager.configmanager_constants as cm_constants
-from autokey.sys_interface.abstract_interface import AbstractSysInterface, AbstractMouseInterface, AbstractWindowInterface, WindowInfo
+from autokey.sys_interface.abstract_interface import AbstractSysInterface, AbstractMouseInterface, AbstractWindowInterface, WindowInfo, queue_method
 
 
 # Imported to enable threading in Xlib. See module description. Not an unused import statement.
@@ -110,16 +107,6 @@ def str_or_bytes_to_bytes(x: typing.Union[str, bytes, memoryview]) -> bytes:
 
 
 
-def queue_method(queue):
-    """
-    Adds the decorated method to the queue with `put_nowait`
-    """
-    def decorator(func):
-        @functools.wraps(func)
-        def wrapper(*args):
-            queue.put_nowait((func, args))
-        return wrapper
-    return decorator
 
 class XWindowInterface(AbstractWindowInterface):
     """
@@ -228,84 +215,6 @@ def _try_get_window_class(window) -> typing.Optional[str]:
         else:
             return None
 
-class DBusInterface:
-    def __init__(self):
-        mainloop= DBusGMainLoop()
-        session_bus = dbus.SessionBus(mainloop=mainloop)
-        shell_obj = session_bus.get_object('org.gnome.Shell', '/org/gnome/Shell/Extensions/AutoKey')
-        self.dbus_interface = dbus.Interface(shell_obj, 'org.gnome.Shell.Extensions.AutoKey')
-
-class GnomeExtensionWindowInterface(DBusInterface, AbstractWindowInterface):
-    def __init__(self):
-        super().__init__()
-        
-
-    def get_window_info(self, window=None, traverse: bool=True) -> WindowInfo:
-        """
-        Returns a WindowInfo object containing the class and title.
-        """
-        window = self._active_window()
-        return WindowInfo(wm_class=window['wm_class'], wm_title=window['wm_title'])
-
-    def get_window_class(self, window=None, traverse=True) -> str:
-        """
-        Returns the window class of the currently focused window.
-        """
-        return self._active_window()['wm_class']
-        
-    
-    def get_window_title(self, window=None, traverse=True) -> str:
-        """
-        Returns the active window title
-        """
-        return self._active_window()['wm_title']
-
-    def _active_window(self):
-        #TODO probably can be done more efficiently with an additional dbus method in the gnome extension
-        window_list = self._dbus_window_list()
-        for window in window_list:
-            if window['focus']:
-                return window
-        # TODO seeing this a lot when I use a script to call `gnome-screenshot -a`, suspect it's just related to that focus behaves differently when that app runs?
-        logger.error("Unable to determine the active window")
-        return None
-            
-    def _dbus_window_list(self):
-        #TODO consider how/if error handling can be implemented
-        try:
-            return json.loads(self.dbus_interface.List())
-        except dbus.exceptions.DBusException as e:
-            self.__init__() #reconnect to dbus
-            return json.loads(self.dbus_interface.List())
-            
-    def _dbus_close_window(self, window_id):
-        #TODO consider how/if error handling can be implemented
-        try:
-            self.dbus_interface.Close(window_id)
-        except dbus.exceptions.DBusException as e:
-            self.__init__()
-            self.dbus_interface.Close(window_id)
-
-    def _dbus_activate_window(self, window_id):
-        try:
-            self.dbus_interface.Activate(window_id)
-        except dbus.exceptions.DBusException as e:  
-            self.__init__()
-            self.dbus_interface.Activate(window_id)
-
-    def _dbus_move_window(self, window_id, x, y):
-        try:
-            self.dbus_interface.Move(window_id, x, y)
-        except dbus.exceptions.DBusException as e:
-            self.__init__()
-            self.dbus_interface.Move(window_id, x, y)
-
-    def _dbus_resize_window(self, window_id, width, height):
-        try:
-            self.dbus_interface.Resize(window_id, width, height)
-        except dbus.exceptions.DBusException as e:
-            self.__init__()
-            self.dbus_interface.Resize(window_id, width, height)
 
 class XInterfaceBase(threading.Thread, AbstractMouseInterface):
     """
@@ -349,6 +258,9 @@ def __init__(self, mediator, app):
 
     @queue_method(queue)
     def flush(self):
+        """
+        Flush the X interface.
+        """
         self.localDisplay.flush()
         self.lastChars = []
 
@@ -367,6 +279,11 @@ def on_keys_changed(self, data=None):
 
     @queue_method(queue)
     def press_key(self, keyName):
+        """
+        Press passed keyName. 
+
+        :param keyName: 
+        """
         self.__sendKeyPressEvent(self.__lookupKeyCode(keyName), 0)
 
     @queue_method(queue)

From ca4843826abc839f7abd4650a660b8021ec383d9 Mon Sep 17 00:00:00 2001
From: Sam Sebastian <sebastiansam55@gmail.com>
Date: Tue, 25 Apr 2023 20:25:07 -0400
Subject: [PATCH 08/20] Add universal toggle (left or right modifier)

---
 lib/autokey/gtkui/data/hotkeysettings.xml | 331 +++++++++++++++-------
 lib/autokey/gtkui/dialogs.py              |  57 +++-
 2 files changed, 272 insertions(+), 116 deletions(-)

diff --git a/lib/autokey/gtkui/data/hotkeysettings.xml b/lib/autokey/gtkui/data/hotkeysettings.xml
index 4e72178b..b589dfbb 100644
--- a/lib/autokey/gtkui/data/hotkeysettings.xml
+++ b/lib/autokey/gtkui/data/hotkeysettings.xml
@@ -1,35 +1,35 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!-- Generated with glade 3.38.2 -->
 <interface>
-  <!-- interface-requires gtk+ 3.0 -->
+  <requires lib="gtk+" version="3.0"/>
   <object class="GtkDialog" id="hotkeysettings">
-    <property name="can_focus">False</property>
-    <property name="border_width">8</property>
+    <property name="can-focus">False</property>
+    <property name="border-width">8</property>
     <property name="title" translatable="yes">Set Hotkey</property>
     <property name="resizable">False</property>
     <property name="modal">True</property>
-    <property name="window_position">center-on-parent</property>
-    <property name="type_hint">dialog</property>
+    <property name="window-position">center-on-parent</property>
+    <property name="type-hint">dialog</property>
     <signal name="response" handler="on_response" swapped="no"/>
     <child internal-child="vbox">
       <object class="GtkBox" id="dialog-vbox2">
         <property name="visible">True</property>
-        <property name="can_focus">False</property>
+        <property name="can-focus">False</property>
         <property name="orientation">vertical</property>
         <property name="spacing">5</property>
         <child internal-child="action_area">
           <object class="GtkButtonBox" id="dialog-action_area2">
             <property name="visible">True</property>
-            <property name="can_focus">False</property>
-            <property name="layout_style">end</property>
+            <property name="can-focus">False</property>
+            <property name="layout-style">end</property>
             <child>
               <object class="GtkButton" id="cancelButton">
                 <property name="label">gtk-cancel</property>
-                <property name="use_action_appearance">False</property>
+                <property name="use-action-appearance">False</property>
                 <property name="visible">True</property>
-                <property name="can_focus">True</property>
-                <property name="receives_default">True</property>
-                <property name="use_action_appearance">False</property>
-                <property name="use_stock">True</property>
+                <property name="can-focus">True</property>
+                <property name="receives-default">True</property>
+                <property name="use-stock">True</property>
                 <signal name="clicked" handler="on_cancel" swapped="no"/>
               </object>
               <packing>
@@ -41,12 +41,11 @@
             <child>
               <object class="GtkButton" id="okButton">
                 <property name="label">gtk-ok</property>
-                <property name="use_action_appearance">False</property>
+                <property name="use-action-appearance">False</property>
                 <property name="visible">True</property>
-                <property name="can_focus">True</property>
-                <property name="receives_default">True</property>
-                <property name="use_action_appearance">False</property>
-                <property name="use_stock">True</property>
+                <property name="can-focus">True</property>
+                <property name="receives-default">True</property>
+                <property name="use-stock">True</property>
                 <signal name="clicked" handler="on_ok" swapped="no"/>
               </object>
               <packing>
@@ -59,30 +58,28 @@
           <packing>
             <property name="expand">False</property>
             <property name="fill">True</property>
-            <property name="pack_type">end</property>
+            <property name="pack-type">end</property>
             <property name="position">0</property>
           </packing>
         </child>
         <child>
-          <object class="GtkVBox" id="vbox2">
+          <object class="GtkBox" id="settingsBox">
             <property name="visible">True</property>
-            <property name="can_focus">False</property>
-            <property name="border_width">5</property>
+            <property name="can-focus">False</property>
+            <property name="border-width">5</property>
+            <property name="orientation">vertical</property>
             <property name="spacing">10</property>
             <child>
-              <object class="GtkHBox" id="hbox2">
+              <object class="GtkBox" id="universalSwitches">
                 <property name="visible">True</property>
-                <property name="can_focus">False</property>
+                <property name="can-focus">False</property>
                 <property name="spacing">5</property>
                 <property name="homogeneous">True</property>
                 <child>
-                  <object class="GtkToggleButton" id="rcontrolButton">
-                    <property name="label" translatable="yes">Right Control</property>
-                    <property name="use_action_appearance">False</property>
+                  <object class="GtkLabel">
                     <property name="visible">True</property>
-                    <property name="can_focus">True</property>
-                    <property name="receives_default">False</property>
-                    <property name="use_action_appearance">False</property>
+                    <property name="can-focus">False</property>
+                    <property name="label" translatable="yes">Universal:</property>
                   </object>
                   <packing>
                     <property name="expand">False</property>
@@ -91,13 +88,114 @@
                   </packing>
                 </child>
                 <child>
-                  <object class="GtkToggleButton" id="raltButton">
-                    <property name="label" translatable="yes">Right Alt</property>
-                    <property name="use_action_appearance">False</property>
+                  <object class="GtkSwitch" id="universalControl">
+                    <property name="name">&lt;ctrl&gt;</property>
+                    <property name="visible">True</property>
+                    <property name="can-focus">True</property>
+                    <signal name="notify::active" handler="on_switch_activate" swapped="no"/>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">False</property>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkSwitch" id="universalAlt">
+                    <property name="name">&lt;alt&gt;</property>
+                    <property name="visible">True</property>
+                    <property name="can-focus">True</property>
+                    <signal name="notify::active" handler="on_switch_activate" swapped="no"/>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">False</property>
+                    <property name="position">2</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkSwitch" id="universalShift">
+                    <property name="name">&lt;shift&gt;</property>
+                    <property name="visible">True</property>
+                    <property name="can-focus">True</property>
+                    <signal name="notify::active" handler="on_switch_activate" swapped="no"/>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">False</property>
+                    <property name="position">3</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkSwitch" id="universalSuper">
+                    <property name="name">&lt;super&gt;</property>
+                    <property name="visible">True</property>
+                    <property name="can-focus">True</property>
+                    <signal name="notify::active" handler="on_switch_activate" swapped="no"/>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">False</property>
+                    <property name="position">4</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkSwitch" id="universalMeta">
+                    <property name="name">&lt;meta&gt;</property>
+                    <property name="visible">True</property>
+                    <property name="can-focus">True</property>
+                    <signal name="notify::active" handler="on_switch_activate" swapped="no"/>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">False</property>
+                    <property name="position">5</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkSwitch" id="universalHyper">
+                    <property name="name">&lt;hyper&gt;</property>
+                    <property name="visible">True</property>
+                    <property name="can-focus">True</property>
+                    <signal name="notify::active" handler="on_switch_activate" swapped="no"/>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">False</property>
+                    <property name="position">6</property>
+                  </packing>
+                </child>
+              </object>
+              <packing>
+                <property name="expand">True</property>
+                <property name="fill">True</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkBox" id="rightModifiers">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="spacing">5</property>
+                <property name="homogeneous">True</property>
+                <child>
+                  <object class="GtkLabel">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkToggleButton" id="rcontrolButton">
+                    <property name="label" translatable="yes">Right Control</property>
+                    <property name="use-action-appearance">False</property>
                     <property name="visible">True</property>
-                    <property name="can_focus">True</property>
-                    <property name="receives_default">False</property>
-                    <property name="use_action_appearance">False</property>
+                    <property name="can-focus">True</property>
+                    <property name="receives-default">False</property>
                   </object>
                   <packing>
                     <property name="expand">False</property>
@@ -106,13 +204,12 @@
                   </packing>
                 </child>
                 <child>
-                  <object class="GtkToggleButton" id="rshiftButton">
-                    <property name="label" translatable="yes">Right Shift</property>
-                    <property name="use_action_appearance">False</property>
+                  <object class="GtkToggleButton" id="raltButton">
+                    <property name="label" translatable="yes">Right Alt</property>
+                    <property name="use-action-appearance">False</property>
                     <property name="visible">True</property>
-                    <property name="can_focus">True</property>
-                    <property name="receives_default">False</property>
-                    <property name="use_action_appearance">False</property>
+                    <property name="can-focus">True</property>
+                    <property name="receives-default">False</property>
                   </object>
                   <packing>
                     <property name="expand">False</property>
@@ -121,13 +218,12 @@
                   </packing>
                 </child>
                 <child>
-                  <object class="GtkToggleButton" id="rsuperButton">
-                    <property name="label" translatable="yes">Right Super</property>
-                    <property name="use_action_appearance">False</property>
+                  <object class="GtkToggleButton" id="rshiftButton">
+                    <property name="label" translatable="yes">Right Shift</property>
+                    <property name="use-action-appearance">False</property>
                     <property name="visible">True</property>
-                    <property name="can_focus">True</property>
-                    <property name="receives_default">False</property>
-                    <property name="use_action_appearance">False</property>
+                    <property name="can-focus">True</property>
+                    <property name="receives-default">False</property>
                   </object>
                   <packing>
                     <property name="expand">False</property>
@@ -136,13 +232,12 @@
                   </packing>
                 </child>
                 <child>
-                  <object class="GtkToggleButton" id="rhyperButton">
-                    <property name="label" translatable="yes">Right Hyper</property>
-                    <property name="use_action_appearance">False</property>
+                  <object class="GtkToggleButton" id="rsuperButton">
+                    <property name="label" translatable="yes">Right Super</property>
+                    <property name="use-action-appearance">False</property>
                     <property name="visible">True</property>
-                    <property name="can_focus">True</property>
-                    <property name="receives_default">False</property>
-                    <property name="use_action_appearance">False</property>
+                    <property name="can-focus">True</property>
+                    <property name="receives-default">False</property>
                   </object>
                   <packing>
                     <property name="expand">False</property>
@@ -153,11 +248,10 @@
                 <child>
                   <object class="GtkToggleButton" id="rmetaButton">
                     <property name="label" translatable="yes">Right Meta</property>
-                    <property name="use_action_appearance">False</property>
+                    <property name="use-action-appearance">False</property>
                     <property name="visible">True</property>
-                    <property name="can_focus">True</property>
-                    <property name="receives_default">False</property>
-                    <property name="use_action_appearance">False</property>
+                    <property name="can-focus">True</property>
+                    <property name="receives-default">False</property>
                   </object>
                   <packing>
                     <property name="expand">False</property>
@@ -165,57 +259,79 @@
                     <property name="position">5</property>
                   </packing>
                 </child>
+                <child>
+                  <object class="GtkToggleButton" id="rhyperButton">
+                    <property name="label" translatable="yes">Right Hyper</property>
+                    <property name="use-action-appearance">False</property>
+                    <property name="visible">True</property>
+                    <property name="can-focus">True</property>
+                    <property name="receives-default">False</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">6</property>
+                  </packing>
+                </child>
               </object>
               <packing>
                 <property name="expand">True</property>
                 <property name="fill">True</property>
-                <property name="position">0</property>
+                <property name="position">1</property>
               </packing>
             </child>
             <child>
-              <object class="GtkHBox" id="hbox3">
+              <object class="GtkBox" id="leftModifiers">
                 <property name="visible">True</property>
-                <property name="can_focus">False</property>
+                <property name="can-focus">False</property>
                 <property name="spacing">5</property>
                 <property name="homogeneous">True</property>
+                <child>
+                  <object class="GtkLabel">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
                 <child>
                   <object class="GtkToggleButton" id="lcontrolButton">
                     <property name="label" translatable="yes">Left Control</property>
-                    <property name="use_action_appearance">False</property>
+                    <property name="use-action-appearance">False</property>
                     <property name="visible">True</property>
-                    <property name="can_focus">True</property>
-                    <property name="receives_default">False</property>
-                    <property name="use_action_appearance">False</property>
+                    <property name="can-focus">True</property>
+                    <property name="receives-default">False</property>
                   </object>
                   <packing>
                     <property name="expand">False</property>
                     <property name="fill">True</property>
-                    <property name="position">0</property>
+                    <property name="position">1</property>
                   </packing>
                 </child>
                 <child>
                   <object class="GtkToggleButton" id="laltButton">
                     <property name="label" translatable="yes">Left Alt</property>
-                    <property name="use_action_appearance">False</property>
+                    <property name="use-action-appearance">False</property>
                     <property name="visible">True</property>
-                    <property name="can_focus">True</property>
-                    <property name="receives_default">False</property>
-                    <property name="use_action_appearance">False</property>
+                    <property name="can-focus">True</property>
+                    <property name="receives-default">False</property>
                   </object>
                   <packing>
                     <property name="expand">False</property>
                     <property name="fill">True</property>
-                    <property name="position">1</property>
+                    <property name="position">2</property>
                   </packing>
                 </child>
                 <child>
                   <object class="GtkToggleButton" id="lshiftButton">
                     <property name="label" translatable="yes">Left Shift</property>
-                    <property name="use_action_appearance">False</property>
+                    <property name="use-action-appearance">False</property>
                     <property name="visible">True</property>
-                    <property name="can_focus">True</property>
-                    <property name="receives_default">False</property>
-                    <property name="use_action_appearance">False</property>
+                    <property name="can-focus">True</property>
+                    <property name="receives-default">False</property>
                   </object>
                   <packing>
                     <property name="expand">False</property>
@@ -226,11 +342,10 @@
                 <child>
                   <object class="GtkToggleButton" id="lsuperButton">
                     <property name="label" translatable="yes">Left Super</property>
-                    <property name="use_action_appearance">False</property>
+                    <property name="use-action-appearance">False</property>
                     <property name="visible">True</property>
-                    <property name="can_focus">True</property>
-                    <property name="receives_default">False</property>
-                    <property name="use_action_appearance">False</property>
+                    <property name="can-focus">True</property>
+                    <property name="receives-default">False</property>
                   </object>
                   <packing>
                     <property name="expand">False</property>
@@ -239,13 +354,12 @@
                   </packing>
                 </child>
                 <child>
-                  <object class="GtkToggleButton" id="lhyperButton">
-                    <property name="label" translatable="yes">Left Hyper</property>
-                    <property name="use_action_appearance">False</property>
+                  <object class="GtkToggleButton" id="lmetaButton">
+                    <property name="label" translatable="yes">Left Meta</property>
+                    <property name="use-action-appearance">False</property>
                     <property name="visible">True</property>
-                    <property name="can_focus">True</property>
-                    <property name="receives_default">False</property>
-                    <property name="use_action_appearance">False</property>
+                    <property name="can-focus">True</property>
+                    <property name="receives-default">False</property>
                   </object>
                   <packing>
                     <property name="expand">False</property>
@@ -254,13 +368,12 @@
                   </packing>
                 </child>
                 <child>
-                  <object class="GtkToggleButton" id="lmetaButton">
-                    <property name="label" translatable="yes">Left Meta</property>
-                    <property name="use_action_appearance">False</property>
+                  <object class="GtkToggleButton" id="lhyperButton">
+                    <property name="label" translatable="yes">Left Hyper</property>
+                    <property name="use-action-appearance">False</property>
                     <property name="visible">True</property>
-                    <property name="can_focus">True</property>
-                    <property name="receives_default">False</property>
-                    <property name="use_action_appearance">False</property>
+                    <property name="can-focus">True</property>
+                    <property name="receives-default">False</property>
                   </object>
                   <packing>
                     <property name="expand">False</property>
@@ -272,21 +385,20 @@
               <packing>
                 <property name="expand">True</property>
                 <property name="fill">True</property>
-                <property name="position">1</property>
+                <property name="position">2</property>
               </packing>
             </child>
             <child>
-            <object class="GtkHBox" id="hbox5">
+              <object class="GtkBox" id="alternateModifierBox">
                 <property name="visible">True</property>
-                <property name="can_focus">False</property>
+                <property name="can-focus">False</property>
                 <child>
                   <object class="GtkToggleButton" id="altgrButton">
                     <property name="label" translatable="yes">Alt GR</property>
-                    <property name="use_action_appearance">False</property>
+                    <property name="use-action-appearance">False</property>
                     <property name="visible">True</property>
-                    <property name="can_focus">True</property>
-                    <property name="receives_default">False</property>
-                    <property name="use_action_appearance">False</property>
+                    <property name="can-focus">True</property>
+                    <property name="receives-default">False</property>
                   </object>
                   <packing>
                     <property name="expand">False</property>
@@ -294,22 +406,22 @@
                     <property name="position">6</property>
                   </packing>
                 </child>
-            </object>
+              </object>
               <packing>
                 <property name="expand">True</property>
                 <property name="fill">True</property>
-                <property name="position">2</property>
+                <property name="position">3</property>
               </packing>
             </child>
             <child>
-              <object class="GtkHBox" id="hbox4">
+              <object class="GtkBox" id="hotkeyBox">
                 <property name="visible">True</property>
-                <property name="can_focus">False</property>
+                <property name="can-focus">False</property>
                 <child>
                   <object class="GtkLabel" id="keyLabel">
                     <property name="visible">True</property>
-                    <property name="can_focus">False</property>
-                    <property name="xalign">0</property>
+                    <property name="can-focus">False</property>
+                    <property name="halign">start</property>
                     <property name="label" translatable="yes">Key: %s</property>
                   </object>
                   <packing>
@@ -321,24 +433,23 @@
                 <child>
                   <object class="GtkButton" id="setButton">
                     <property name="label" translatable="yes">Press to Set</property>
-                    <property name="use_action_appearance">False</property>
+                    <property name="use-action-appearance">False</property>
                     <property name="visible">True</property>
-                    <property name="can_focus">True</property>
-                    <property name="receives_default">False</property>
-                    <property name="use_action_appearance">False</property>
+                    <property name="can-focus">True</property>
+                    <property name="receives-default">False</property>
                     <signal name="clicked" handler="on_setButton_pressed" swapped="no"/>
                   </object>
                   <packing>
                     <property name="expand">False</property>
                     <property name="fill">True</property>
-                    <property name="position">1</property>
+                    <property name="position">2</property>
                   </packing>
                 </child>
               </object>
               <packing>
                 <property name="expand">True</property>
                 <property name="fill">True</property>
-                <property name="position">3</property>
+                <property name="position">4</property>
               </packing>
             </child>
           </object>
diff --git a/lib/autokey/gtkui/dialogs.py b/lib/autokey/gtkui/dialogs.py
index cea561a8..184d23aa 100644
--- a/lib/autokey/gtkui/dialogs.py
+++ b/lib/autokey/gtkui/dialogs.py
@@ -26,6 +26,7 @@
 import autokey.model.triggermode
 import autokey.model.constants
 import autokey.model.phrase
+from autokey.model.key import MAPPED_UNIVERSAL_MODIFIERS
 from autokey.model.triggermode import TriggerMode
 import autokey.iomediator.keygrabber
 import autokey.iomediator.windowgrabber
@@ -433,6 +434,13 @@ def __init__(self, parent, configManager, closure):
         self.closure = closure
         self.key = None
 
+        self.universalControl = builder.get_object("universalControl")
+        self.universalAlt = builder.get_object("universalAlt")
+        self.universalShift = builder.get_object("universalShift")
+        self.universalSuper = builder.get_object("universalSuper")
+        self.universalHyper = builder.get_object("universalHyper")
+        self.universalMeta = builder.get_object("universalMeta")
+
         self.rcontrolButton = builder.get_object("rcontrolButton")
         self.raltButton = builder.get_object("raltButton")
         self.rshiftButton = builder.get_object("rshiftButton")
@@ -451,34 +459,37 @@ def __init__(self, parent, configManager, closure):
         self.setButton = builder.get_object("setButton")
         self.keyLabel = builder.get_object("keyLabel")
         self.MODIFIER_BUTTONS = {
-            # self.controlButton: Key.CONTROL,
             self.lcontrolButton: Key.LEFTCONTROL,
             self.rcontrolButton: Key.RIGHTCONTROL,
 
-            # self.altButton: Key.ALT,
             self.laltButton: Key.LEFTALT,
             self.raltButton: Key.RIGHTALT,
 
             self.altgrButton: Key.ALT_GR,
 
-            # self.shiftButton: Key.SHIFT,
             self.lshiftButton: Key.LEFTSHIFT,
             self.rshiftButton: Key.RIGHTSHIFT,
 
-            # self.superButton: Key.SUPER,
             self.lsuperButton: Key.LEFTSUPER,
             self.rsuperButton: Key.RIGHTSUPER,
 
-            # self.hyperButton: Key.HYPER,
             self.lhyperButton: Key.LEFTHYPER,
             self.rhyperButton: Key.RIGHTHYPER,
 
-            # self.metaButton: Key.META,
             self.lmetaButton: Key.LEFTMETA,
             self.rmetaButton: Key.RIGHTMETA,
 
         }
 
+        self.MODIFIER_SWITCHES ={
+            self.universalControl: Key.CONTROL,
+            self.universalAlt: Key.ALT,
+            self.universalShift: Key.SHIFT,
+            self.universalSuper: Key.SUPER,
+            self.universalHyper: Key.HYPER,
+            self.universalMeta: Key.META,
+        }
+
         DialogBase.__init__(self)
 
     def load(self, item):
@@ -498,6 +509,9 @@ def activate_modifier_buttons(self, modifiers):
         for button, key in self.MODIFIER_BUTTONS.items():
             button.set_active(key in modifiers)
 
+        for button, key in self.MODIFIER_SWITCHES.items():
+            button.set_active(key in modifiers)
+
     def save(self, item):
         UI_common.save_hotkey_settings_dialog(self, item)
 
@@ -505,6 +519,9 @@ def reset(self):
         for button in self.MODIFIER_BUTTONS:
             button.set_active(False)
 
+        for button in self.MODIFIER_SWITCHES:
+            button.set_active(False)
+
         self._setKeyLabel(_("(None)"))
         self.key = None
         self.setButton.set_sensitive(True)
@@ -533,6 +550,12 @@ def get_active_modifiers(self):
         for button, key in self.MODIFIER_BUTTONS.items():
             if button.get_active():
                 modifiers.append(key)
+        for button, key in self.MODIFIER_SWITCHES.items():
+            if button.get_active():
+                for item in MAPPED_UNIVERSAL_MODIFIERS[key]: # remove the left/right modifier versions if the switch is active
+                    if item in modifiers:
+                        modifiers.remove(item)
+                modifiers.append(key)
         modifiers.sort()
         return modifiers
 
@@ -558,6 +581,28 @@ def on_setButton_pressed(self, widget, data=None):
         self.grabber = autokey.iomediator.keygrabber.KeyGrabber(self)
         self.grabber.start()
 
+    def on_switch_activate(self, widget, data=None):
+        # print(widget, widget.get_name())
+        name = widget.get_name()
+        if name == "<ctrl>":
+            self.lcontrolButton.set_active(False)
+            self.rcontrolButton.set_active(False)
+        elif name == "<alt>":
+            self.laltButton.set_active(False)
+            self.raltButton.set_active(False)
+        elif name == "<shift>":
+            self.lshiftButton.set_active(False)
+            self.rshiftButton.set_active(False)
+        elif name == "<super>":
+            self.lsuperButton.set_active(False)
+            self.rsuperButton.set_active(False)
+        elif name == "<meta>":
+            self.lmetaButton.set_active(False)
+            self.rmetaButton.set_active(False)
+        elif name == "<hyper>":
+            self.lhyperButton.set_active(False)
+            self.rhyperButton.set_active(False)
+
 
 class GlobalHotkeyDialog(HotkeySettingsDialog):
 

From a05b5b330446ea8fe0a6563534b145b40e7850f0 Mon Sep 17 00:00:00 2001
From: Sam Sebastian <sebastiansam55@gmail.com>
Date: Wed, 26 Apr 2023 20:49:29 -0400
Subject: [PATCH 09/20] Fix usage count, add some usage statistics

---
 lib/autokey/autokey_app.py                 | 43 +++++++++++++++++++++-
 lib/autokey/configmanager/configmanager.py |  4 ++
 lib/autokey/service.py                     |  5 ++-
 3 files changed, 49 insertions(+), 3 deletions(-)

diff --git a/lib/autokey/autokey_app.py b/lib/autokey/autokey_app.py
index 06dd6bd5..bf86032e 100644
--- a/lib/autokey/autokey_app.py
+++ b/lib/autokey/autokey_app.py
@@ -25,6 +25,7 @@
 import signal
 import subprocess
 from typing import NamedTuple, Iterable
+import re
 
 import autokey.model.script
 from autokey import common
@@ -112,8 +113,48 @@ def __initialise(self):
         self.__add_user_code_dir_to_path()
         self.__create_DBus_service()
         self.__register_ctrlc_handler()
+
+        # process command line commands here?
+        try:
+            self.usage_statistics()
+        except Exception as e:
+            logger.error(f"Usage statistics failure: {e}")
+
         logger.info("Autokey application services ready")
 
+    def usage_statistics(self):
+        for item in self.configManager.allItems:
+            # print(type(item))
+            if type(item) is autokey.model.phrase.Phrase:
+                # logger.info(item.description, item.usageCount, item.phrase)
+                logger.info(f"{item.description}, {item.usageCount} {self.getAPIUsage(item.phrase)}")
+            elif type(item) is autokey.model.script.Script:
+                logger.info(f"{item.description}, {item.usageCount} {self.getAPIUsage(item.code)}")
+
+                # apiCounts = checkCount(item.code)
+        print(self.configManager.allItems)
+
+    def getAPIUsage(self, code):
+        api_modules = ["engine","keyboard","mouse","highlevel","store","dialog","clipboard","system","window"]
+
+        reg = re.compile("("+"|".join(api_modules)+")\.(\w*)\(")
+
+        results = re.findall(reg, code)
+
+        # Create an empty dictionary to store the counts
+        count_dict = {}
+
+        # Loop through the list and count each item
+        for item in results:
+            if item in count_dict:
+                count_dict[item] += 1
+            else:
+                count_dict[item] = 1
+
+        return count_dict
+        
+
+
     def __create_DBus_service(self):
         logger.info("Creating DBus service")
         dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
@@ -279,7 +320,7 @@ def autokey_shutdown(self):
         Shut down the entire application.
         """
         logger.debug("Shutting down service and file monitor...")
+        self.monitor.stop()
         self.service.shutdown()
         self.dbusService.unregister()
-        self.monitor.stop()
         logger.debug("Finished shutting down service and file monitor...")
diff --git a/lib/autokey/configmanager/configmanager.py b/lib/autokey/configmanager/configmanager.py
index e97ace22..1b927fa5 100644
--- a/lib/autokey/configmanager/configmanager.py
+++ b/lib/autokey/configmanager/configmanager.py
@@ -89,6 +89,10 @@ def _try_persist_settings(config_manager):
         logger.exception(msg)
         raise Exception(msg)
 
+def save_files(config_manager):
+    logger.info("Persisting files")
+    for item in config_manager.allItems:
+        item.persist()
 
 def save_config(config_manager):
     logger.info("Persisting configuration")
diff --git a/lib/autokey/service.py b/lib/autokey/service.py
index 3a7ba6ea..d4350a1a 100644
--- a/lib/autokey/service.py
+++ b/lib/autokey/service.py
@@ -35,7 +35,7 @@
 from autokey.macro import MacroManager
 
 import autokey.scripting
-from autokey.configmanager.configmanager import ConfigManager, save_config
+from autokey.configmanager.configmanager import ConfigManager, save_config, save_files
 import autokey.configmanager.configmanager_constants as cm_constants
 
 logger = __import__("autokey.logger").logger.get_logger(__name__)
@@ -116,6 +116,7 @@ def shutdown(self, save=True):
         if self.mediator is not None: self.mediator.shutdown()
         if save:
             save_config(self.configManager)
+            save_files(self.configManager)
         logger.debug("Service shutdown completed.")
 
     def handle_mouseclick(self, rootX, rootY, relX, relY, button, windowTitle):
@@ -506,7 +507,7 @@ def clear_error_records(self):
 
     @threaded
     def execute_script(self, script: autokey.model.script.Script, buffer=''):
-        logger.debug("Script runner executing: %r", script)
+        logger.debug("Script runner executing: %r, usageCount: %r", script, script.usageCount)
 
         scope = self.scope.copy()
         scope["store"] = script.store

From 7b8aef6c5ad83d35c42e5093b1a55f1e46e316a4 Mon Sep 17 00:00:00 2001
From: Sam Sebastian <sebastiansam55@gmail.com>
Date: Fri, 28 Apr 2023 17:28:56 -0400
Subject: [PATCH 10/20] API and macro usage statistics

---
 lib/autokey/autokey_app.py | 20 +++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

diff --git a/lib/autokey/autokey_app.py b/lib/autokey/autokey_app.py
index bf86032e..2aa89057 100644
--- a/lib/autokey/autokey_app.py
+++ b/lib/autokey/autokey_app.py
@@ -123,16 +123,19 @@ def __initialise(self):
         logger.info("Autokey application services ready")
 
     def usage_statistics(self):
+        logger.info("----- AutoKey Usage Statistics -----")
         for item in self.configManager.allItems:
             # print(type(item))
             if type(item) is autokey.model.phrase.Phrase:
                 # logger.info(item.description, item.usageCount, item.phrase)
-                logger.info(f"{item.description}, {item.usageCount} {self.getAPIUsage(item.phrase)}")
+                logger.info(f"Phrase: {item.description}, Usage Count: {item.usageCount} {self.getMacroUsage(item.phrase)}")
             elif type(item) is autokey.model.script.Script:
-                logger.info(f"{item.description}, {item.usageCount} {self.getAPIUsage(item.code)}")
+                logger.info(f"Script: {item.description}, Usage Count: {item.usageCount} {self.getAPIUsage(item.code)}")
+        
+        for item in self.configManager.allFolders:
+            logger.info(f"Folder: {item.title}, Usage Count: {item.usageCount}")
 
-                # apiCounts = checkCount(item.code)
-        print(self.configManager.allItems)
+        logger.info("----- AutoKey Usage Statistics -----")
 
     def getAPIUsage(self, code):
         api_modules = ["engine","keyboard","mouse","highlevel","store","dialog","clipboard","system","window"]
@@ -152,7 +155,14 @@ def getAPIUsage(self, code):
                 count_dict[item] = 1
 
         return count_dict
-        
+    
+    def getMacroUsage(self, phrase):
+        macros = ["cursor", "script", "system", "date", "file", "clipboard"]
+
+        reg = re.compile("<("+"|".join(macros)+")")
+
+        results = re.findall(reg, phrase)
+        return results
 
 
     def __create_DBus_service(self):

From 12bb5dcd34bbd60ad4cc62b397759beb7702d022 Mon Sep 17 00:00:00 2001
From: Sam Sebastian <sebastiansam55@gmail.com>
Date: Fri, 28 Apr 2023 17:32:25 -0400
Subject: [PATCH 11/20] Update checking to be display server specific

---
 lib/autokey/UI_common_functions.py | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/lib/autokey/UI_common_functions.py b/lib/autokey/UI_common_functions.py
index 401a5533..ae1cd0b1 100644
--- a/lib/autokey/UI_common_functions.py
+++ b/lib/autokey/UI_common_functions.py
@@ -24,10 +24,13 @@
 qt_modules = ['PyQt5', 'PyQt5.QtGui', 'PyQt5.QtWidgets', 'PyQt5.QtCore',
             'PyQt5.Qsci']
 
-common_programs = ['wmctrl', 'ps', 'xrandr']
+# wmctrl, xrandr are x11 specific programs.
+x11_programs = ['wmctrl', 'xrandr']
+common_programs = ['ps']
 # Checking some of these appears to be redundant as some are provided by the same packages on my system but 
 # better safe than sorry.
-optional_programs = ['visgrep', 'import', 'png2pat', 'xte', 'xmousepos']
+x11_optional_programs = ['xte', 'xmousepos']
+optional_programs = ['visgrep', 'import', 'png2pat']
 gtk_programs = ['zenity']
 qt_programs = ['kdialog']
 
@@ -57,6 +60,9 @@ def checkProgramImports(programs, optional=False):
     return missing_programs
 
 def checkOptionalPrograms():
+    if os.environ.get("XDG_SESSION_TYPE") == "x11":
+        checkProgramImports(x11_optional_programs, optional=True)
+
     if common.USED_UI_TYPE == "QT":
         checkProgramImports(optional_programs, optional=True)
     elif common.USED_UI_TYPE == "GTK":
@@ -74,6 +80,10 @@ def getErrorMessage(item_type, missing_items):
 
 def checkRequirements():
     errorMessage = ""
+
+    if os.environ.get("XDG_SESSION_TYPE") == "x11":
+        missing_programs = checkProgramImports(x11_programs)
+
     if common.USED_UI_TYPE == "QT":
         missing_programs = checkProgramImports(common_programs+qt_programs)
         missing_modules = checkModuleImports(common_modules+qt_modules)

From 20376e1880b30e16d9b097ccb6e5f6b7c4ad271a Mon Sep 17 00:00:00 2001
From: Sam Sebastian <sebastiansam55@gmail.com>
Date: Sun, 21 May 2023 15:52:47 -0400
Subject: [PATCH 12/20] UInput Interface

---
 lib/autokey/UI_common_functions.py            |  37 +
 lib/autokey/iomediator/iomediator.py          |  31 +-
 .../sys_interface/abstract_interface.py       |  12 +
 lib/autokey/uinput_interface.py               | 714 ++++++++++++++++++
 4 files changed, 788 insertions(+), 6 deletions(-)
 create mode 100644 lib/autokey/uinput_interface.py

diff --git a/lib/autokey/UI_common_functions.py b/lib/autokey/UI_common_functions.py
index ae1cd0b1..97681df9 100644
--- a/lib/autokey/UI_common_functions.py
+++ b/lib/autokey/UI_common_functions.py
@@ -6,6 +6,7 @@
 import subprocess
 import sys
 import time
+import os
 
 from . import common
 import autokey.model.helpers
@@ -34,6 +35,42 @@
 gtk_programs = ['zenity']
 qt_programs = ['kdialog']
 
+def checkGnomeAutokeyExtension():
+    bus_name = "org.gnome.Shell"
+    object_path = "/org/gnome/Shell/Extensions/AutoKey"
+    interface_name = "org.gnome.Shell.Extensions.AutoKey"
+    check_dbus_object_exists(bus_name, object_path, interface_name)
+    pass
+
+
+def check_dbus_object_exists(bus_name, object_path, interface_name):
+    #keep dbus import here
+    import dbus
+    try:
+        # Connect to the D-Bus session bus
+        bus = dbus.SessionBus()
+
+        # Get a reference to the service and object
+        obj = bus.get_object(bus_name, object_path)
+
+        # Get a reference to the desired interface
+        interface = dbus.Interface(obj, interface_name)
+
+        # Call a method on the object (e.g., 'Get') and check if it returns a valid result
+        interface.List()  # Replace 'property_name' with an actual property name
+
+        # If the method call was successful, the object exists
+        return True
+
+    except dbus.exceptions.DBusException as e:
+        # Handle the exception and return False if the object does not exist
+        if e.get_dbus_name() == 'org.freedesktop.DBus.Error.UnknownObject':
+            return False
+        else:
+            # If the exception is not related to the unknown object, re-raise it
+            raise
+
+
 def checkModuleImports(modules):
     missing_modules = []
     for module in modules:
diff --git a/lib/autokey/iomediator/iomediator.py b/lib/autokey/iomediator/iomediator.py
index 00883cfd..995a4e7c 100644
--- a/lib/autokey/iomediator/iomediator.py
+++ b/lib/autokey/iomediator/iomediator.py
@@ -16,12 +16,13 @@
 import threading
 import time
 import queue
+import os
 
 import autokey
 from autokey import common
 from autokey.configmanager.configmanager import ConfigManager
 from autokey.configmanager.configmanager_constants import INTERFACE_TYPE
-from autokey.interface import XRecordInterface, AtSpiInterface, XWindowInterface, GnomeExtensionWindowInterface
+from autokey.gnome_interface import GnomeExtensionWindowInterface
 from autokey.sys_interface.clipboard import Clipboard
 from autokey.model.phrase import SendMode
 
@@ -59,14 +60,27 @@ def __init__(self, service):
         for key in MODIFIERS:
             self.modifiers[key]=False
 
-
+        # self.interfaceType="uinput"
+        session_type = os.environ.get("XDG_SESSION_TYPE")
+        if session_type == "wayland":
+            self.interfaceType = "uinput"
+        elif session_type == "x11":
+            pass
+        elif session_type is None:
+            pass
         
-        if self.interfaceType == X_RECORD_INTERFACE:
+
+        if self.interfaceType == "uinput":
+            from autokey.uinput_interface import UInputInterface
+            self.interface = UInputInterface(self, self.app)
+        elif self.interfaceType == X_RECORD_INTERFACE:
+            from autokey.interface import XRecordInterface, XWindowInterface
             self.interface = XRecordInterface(self, self.app)
         else:
+            from autokey.interface import AtSpiInterface, XWindowInterface
             self.interface = AtSpiInterface(self, self.app)
 
-        if False:
+        if self.interfaceType == "uinput":
             self.windowInterface = GnomeExtensionWindowInterface()
         else:
             self.windowInterface = XWindowInterface()
@@ -110,7 +124,9 @@ def set_modifier_state(self, modifier, state):
     
     def handle_modifier_down(self, modifier):
         """
-        Updates the state of the given modifier key to 'pressed'
+        Updates the state of the given modifier key to 'pressed'.
+
+        :param modifier: Should be AutoKey Key value
         """
         logger.debug("%s pressed", modifier)
         if modifier in (Key.CAPSLOCK, Key.NUMLOCK):
@@ -151,6 +167,7 @@ def run(self):
 
             # We make a copy here because the wait_for... functions modify the listeners,
             # and we want this processing cycle to complete before changing what happens
+            logger.debug("Raw Key: {} | Modifiers: {} | Key: {} | Window Info: {}".format(raw_key, modifiers, key, window_info))
             for target in self.listeners.copy():
                 target.handle_keypress(raw_key, modifiers, key, window_info)
 
@@ -183,6 +200,7 @@ def send_string(self, string: str):
     @staticmethod
     def _send_string(string, interface):
         modifiers = []
+        logger.debug("Sending string sections: %s", KEY_SPLIT_RE.split(string))
         for section in KEY_SPLIT_RE.split(string):
             if len(section) > 0:
                 if Key.is_key(section[:-1]) and section[-1] == '+' and section[:-1] in MODIFIERS:
@@ -236,7 +254,7 @@ def remove_string(self, string):
                 backspaces += 1
             else:
                 backspaces += len(section)
-                
+        logger.debug("Sending backspaces: %d", backspaces)
         self.send_backspace(backspaces)
 
     def send_key(self, key_name):
@@ -248,6 +266,7 @@ def press_key(self, key_name):
         self.interface.fake_keydown(key_name)
 
     def release_key(self, key_name):
+        logger.debug("Release key: %s", key_name)
         key_name = key_name.replace('\n', "<enter>")
         self.interface.fake_keyup(key_name)
 
diff --git a/lib/autokey/sys_interface/abstract_interface.py b/lib/autokey/sys_interface/abstract_interface.py
index 110d320e..efa77b48 100644
--- a/lib/autokey/sys_interface/abstract_interface.py
+++ b/lib/autokey/sys_interface/abstract_interface.py
@@ -15,6 +15,7 @@
 
 from abc import ABC, ABCMeta, abstractmethod
 import typing
+import functools
 
 from autokey import common
 from autokey.scripting import Clipboard as APIClipboard
@@ -24,6 +25,17 @@
 # This tuple is used to return requested window properties.
 WindowInfo = typing.NamedTuple("WindowInfo", [("wm_title", str), ("wm_class", str)])
 
+def queue_method(queue):
+    """
+    Adds the decorated method to the queue with `put_nowait`
+    """
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args):
+            queue.put_nowait((func, args))
+        return wrapper
+    return decorator
+
 class AbstractSysInterface(ABC, metaclass=ABCMeta):
     """
     This class aims to define all the methods needed to interact with the underlying
diff --git a/lib/autokey/uinput_interface.py b/lib/autokey/uinput_interface.py
new file mode 100644
index 00000000..d939e980
--- /dev/null
+++ b/lib/autokey/uinput_interface.py
@@ -0,0 +1,714 @@
+# items avaliable on inputevents
+# https://python-evdev.readthedocs.io/en/latest/apidoc.html#evdev.events.InputEvent
+# sec, usec, type, code, value
+
+
+import typing
+import threading
+import queue
+import os
+import grp
+import evdev
+import time
+import select
+import random
+import re
+
+from autokey.model.button import Button
+from autokey.model.phrase import SendMode
+from autokey.model.key import Key
+
+import evdev
+from evdev import ecodes as e
+
+logger = __import__("autokey.logger").logger.get_logger(__name__)
+
+from autokey.sys_interface.abstract_interface import AbstractSysInterface, queue_method
+from autokey.gnome_interface import GnomeMouseReadInterface
+
+
+class UInputInterface(threading.Thread, GnomeMouseReadInterface, AbstractSysInterface):
+    """
+    god this is complicated lol
+    """
+
+    inv_map = {}
+    char_map = {
+        "/":"KEY_SLASH", "'":"KEY_APOSTROPHE", ",":"KEY_COMMA", ".":"KEY_DOT", ";":"KEY_SEMICOLON",
+        "[":"KEY_LEFTBRACE", "]":"KEY_RIGHTBRACE", "\\":"KEY_BACKSLASH", "=":"KEY_EQUAL", "-":"KEY_MINUS", "`": "KEY_GRAVE",
+        " ":"KEY_SPACE", "\t": "KEY_TAB","\n": "KEY_ENTER"
+    }
+    #define as the left versions
+    shift_key = 42
+    ctrl_key = 29
+    alt_key = 56
+    meta_key = 125
+    #TODO other modifiers
+    #altgr_key
+    #TODO should this be raw scan code or evdev equivalent? evdev makes more sense to me here
+    #string.printable;
+    #0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c
+    #
+    shifted_chars = {
+        "!":"KEY_1", "@":"KEY_2", "#":"KEY_3", "$":"KEY_4", "%":"KEY_5", "^":"KEY_6", "&": "KEY_7", "*": "KEY_8", "(":"KEY_9", ")":"KEY_0",
+        "\"":"KEY_APOSTROPHE", ">": "KEY_DOT", "<": "KEY_COMMA", ":":"KEY_SEMICOLON", "{": "KEY_LEFTBRACE", "}": "KEY_RIGHTBRACE",
+        "?": "KEY_SLASH", "+": "KEY_EQUAL", "_":"KEY_MINUS", "~":"KEY_GRAVE", "|":"KEY_BACKSLASH"
+    }
+
+    """
+    str(AutoKey): str(evdev KEY_XXXX)
+    """
+    autokey_map = {
+        "<left>": "KEY_LEFT", "<right>": "KEY_RIGHT", "<up>": "KEY_UP", "<down>": "KEY_DOWN",
+        "<home>": "KEY_HOME", "<end>": "KEY_END", "<page_up>": "KEY_PAGEUP", "<page_down>": "KEY_PAGEDOWN",
+
+        # universal modifiers
+        "<shift>": "KEY_LEFTSHIFT", "<ctrl>": "KEY_LEFTCTRL", "<alt>": "KEY_LEFTALT",
+        "<meta>": "KEY_LEFTMETA", "<hyper>": "KEY_LEFTMETA", "<super>": "KEY_LEFTMETA",
+
+        # left modifiers
+        "<left_shift>": "KEY_LEFTSHIFT", "<left_ctrl>": "KEY_LEFTCTRL", "<left_alt>": "KEY_LEFTALT", "<left_meta>": "KEY_LEFTMETA", "<left_hyper>": "KEY_LEFTMETA",
+
+        # right modifiers
+        "<right_shift>": "KEY_RIGHTSHIFT", "<right_ctrl>": "KEY_RIGHTCTRL", "<right_alt>": "KEY_RIGHTALT", "<right_meta>": "KEY_RIGHTMETA", "<right_hyper>": "KEY_RIGHTMETA",
+
+        "<backspace>": "KEY_BACKSPACE", 
+        
+        
+        "<enter>": "KEY_ENTER", "\n": "KEY_ENTER",
+        "<tab>": "KEY_TAB", "\t": "KEY_TAB",
+        "<escape>": "KEY_ESCAPE"
+    }
+
+    """
+    str(evdev KEY_XXXX): str(AutoKey)
+    """
+    inv_autokey_map = {}
+
+    uinput_modifiers_to_ak_map = {
+        
+        "KEY_LEFTSHIFT" : Key.LEFTSHIFT,
+        "KEY_RIGHTSHIFT" : Key.RIGHTSHIFT,
+
+        "KEY_LEFTCTRL": Key.LEFTCONTROL,
+        "KEY_RIGHTCTRL": Key.RIGHTCONTROL,
+
+        "KEY_LEFTALT": Key.LEFTALT,
+        "KEY_RIGHTALT": Key.RIGHTALT,
+
+        "KEY_LEFTMETA": Key.LEFTMETA,
+        "KEY_RIGHTMETA": Key.RIGHTMETA,
+
+    }
+
+    uinput_keys_to_ak_map = {
+        "KEY_LEFT": Key.LEFT,
+        "KEY_RIGHT": Key.RIGHT,
+        "KEY_UP": Key.UP,
+        "KEY_DOWN": Key.DOWN,
+
+        "KEY_HOME": Key.HOME,
+        "KEY_END": Key.END,
+        "KEY_PAGEUP": Key.PAGE_UP,
+        "KEY_PAGEDOWN": Key.PAGE_DOWN,
+
+        "KEY_BACKSPACE": Key.BACKSPACE,
+
+        "KEY_ENTER": Key.ENTER,
+        "KEY_TAB": Key.TAB,
+
+        "KEY_ESC": Key.ESCAPE,
+
+        "KEY_F1": Key.F1,
+        "KEY_F2": Key.F2,
+        "KEY_F3": Key.F3,
+        "KEY_F4": Key.F4,
+        "KEY_F5": Key.F5,
+        "KEY_F6": Key.F6,
+        "KEY_F7": Key.F7,
+        "KEY_F8": Key.F8,
+        "KEY_F9": Key.F9,
+        "KEY_F10": Key.F10,
+        "KEY_F11": Key.F11,
+        "KEY_F12": Key.F12,
+
+    }
+
+
+    translation_map = {
+        "slash": "/", "apostrophe": "'", "comma": ",", "dot": ".", "semicolon": ";",
+        "space": " ", "tab": "\t", "enter": "\n", 
+        "backslash": "\\", "equal": "=", "minus": "-", "grave": "`",
+    }
+
+    queue = queue.Queue()
+
+    def __init__(self, mediator, app):
+        threading.Thread.__init__(self)
+        self.setDaemon(True)
+        self.setName("UInputInterface-thread")
+        self.mediator = mediator  # type: IoMediator
+        self.app = app
+        self.shutdown = False
+        self.sending = False
+        self.keyboard = None
+        self.mouse = None
+        time.sleep(1)
+
+        # Event loop
+        self.eventThread = threading.Thread(target=self.__eventLoop)
+
+        ### UINPUT init
+        self.validate()
+
+        ### UINPUT Listener one for keyboard and eventually one for mouse
+        # creating this before creating the new uinput device !important
+        devices = self.get_devices()
+
+        #TODO have to find a way to have user select which device to use (or try to find the right one)
+        # should allow user to manually set the input devices in the settings.
+        for dev in devices:
+            logger.debug("Found device: {}".format(dev.name))
+            if self.keyboard is None and re.search("keyboard", dev.name, re.IGNORECASE):
+                logger.debug("Found keyboard: {}".format(dev.name))
+                self.keyboard = self.grab_device(devices, dev.name)
+                self.keyboard.grab()
+            elif self.mouse is None and re.search("mouse", dev.name, re.IGNORECASE):
+                logger.debug("Found mouse: {}".format(dev.name))
+                self.mouse = self.grab_device(devices, dev.name)
+        #self.keyboard = self.grab_device(devices, "ZSA Technology Labs ErgoDox EZ")
+        #self.mouse = self.grab_device(devices, "Logitech MX Master 3")
+        # self.keyboard = self.grab_device(devices, "AT Translated Set 2 keyboard")
+        # self.keyboard.grab() # exclusive grab, no other process can use it, instead pass through input events via uinput
+        # self.mouse = self.grab_device(devices, "VirtualBox mouse integration")
+
+        if self.mouse is None or self.keyboard is None:
+            logger.error("Unable to find mouse or keyboard")
+            raise Exception("Unable to find mouse or keyboard")
+
+        self.devices = [self.keyboard, self.mouse]
+        logger.debug("Keyboard: {}, Path: {}".format(self.keyboard.name, self.keyboard.path))
+        logger.debug("Mouse: {}, Path: {}".format(self.mouse.name, self.mouse.path))
+        # logger.debug("Keyboard DIR: {}".format(dir(self.keyboard)))
+        
+        self.devices = {dev.fd: dev for dev in self.devices}
+
+
+        try:
+            # mouse = "/dev/input/event12"
+            # keyboard = "/dev/input/event4"
+            # creating a uinput device with the combined capabilities of the user's mouse and keyboard
+            # this will undoubtedly cause issues if user attempts to send signals not supported by their devices
+            self.ui = evdev.UInput.from_device(self.mouse.path, self.keyboard.path, name="autokey mouse and keyboard")
+
+        except Exception as ex:
+            logger.error("Unable to create UInput device. {}".format(ex))
+            logger.error("Check out how to resolve this issue here: https://github.com/philipl/evdevremapkeys/issues/24")
+            #print("Unable to create UInput device. {}".format(ex))
+
+        GnomeMouseReadInterface.__init__(self)
+
+
+        self.inv_map = self.__reverse_mapping(e.keys)
+        self.inv_autokey_map = self.__reverse_mapping(self.autokey_map)
+        logger.debug("Inverted Map:", self.inv_map)
+
+        # Event listener
+        self.listenerThread = threading.Thread(target=self.__flush_events_loop)
+
+        self.__initMappings()
+
+        self.eventThread.start()
+        self.listenerThread.start()
+
+
+    def __reverse_mapping(self, dictionary):
+        map = {}
+        for item in dictionary.items():
+            if type(item[1]) == list:
+                continue
+            else:
+                map[item[1]] = item[0]
+        return map
+
+    def validate(self):
+        """
+        Checks that UInput will work correctly
+
+        Prints out error message currently if that fails.
+        """
+        #TODO run checks that uinput will work as expected.
+        user = os.getlogin()
+        input_group = grp.getgrnam("input")
+        if user in input_group.gr_mem or os.geteuid()==0:
+            logger.info("input User membership good!")
+        else:
+            logger.error("User not in input group add yourself or run program as root")
+            logger.error(f"sudo usermod -a -G input {user}")
+            raise Exception("User not in input group add yourself or run program as root")
+
+    @queue_method(queue)
+    def clear_held_keys(self):
+        self.held_keys = self.keyboard.active_keys()
+        logger.debug("Clearing keys: {}".format(self.held_keys))
+        for key in self.held_keys:
+            self.ui.write(e.EV_KEY, key, 0)
+
+    @queue_method(queue)
+    def reapply_keys(self):
+        #self.held_keys = self.keyboard.active_keys()
+        logger.debug("Reapply held keys: {}".format(self.held_keys))
+        for key in self.held_keys:
+            self.ui.write(e.EV_KEY, key, 1)
+
+
+    @queue_method(queue)
+    def send_string(self, string):
+        """
+        Send a string of characters to be sent via the keyboard
+        Usage: C{ukeyboard.send_keys("This is a test string")}
+        :param string: str or list, use list if you want to send characters like KEY_LEFTCTRL
+        """
+        #print(keys)
+        # if type(string) == list:
+        #     for subset in string:
+        #         self.send_string(subset)
+        #     return
+        if type(string) == str and "KEY_" in string[:4]:
+            self.__send_key(string)
+            return
+        if type(string) == int:
+            self.__send_key(string)
+            return
+        
+        for key in string:
+            self.__send_key(key)
+
+    def paste_string(self, string, paste_command: SendMode):
+        raise NotImplementedError
+
+    @queue_method(queue)
+    def send_key(self, key_name):
+        self.__send_key(key_name)
+
+    @queue_method(queue)
+    def send_evdev_code(self, type_, code, value):
+        self.ui.write(type_, code, value)
+
+    def send_evdev_code_raw(self, type_, code, value):
+        """
+        Immediately sends the event instead of adding it to the queue.
+        """
+        self.ui.write(type_, code, value)
+
+    def __send_key(self, key, shifted=False, syn=True):
+        # print(f"Writing {key}")
+        evdev_keycode, shifted_ = self.translate_to_evdev(key)
+        #print(key, evdev_keycode, shifted_)
+        evdev_key = e.keys[evdev_keycode]
+        if shifted_:
+            shifted=True
+
+        #print(f"Keycode: {evdev_keycode}, Key: {evdev_key}", shifted_, shifted)
+        logger.debug("Sending key: {}, Shifted: {}, Untranslated: {}".format(evdev_key, shifted_, key))
+        if shifted:
+            self.ui.write(e.EV_MSC, e.MSC_SCAN, self.shift_key)
+            self.ui.write(e.EV_KEY, self.shift_key, 1)
+            self.syn_raw()
+            
+        self.ui.write(e.EV_MSC, e.MSC_SCAN, self.inv_map[evdev_key])
+        self.ui.write(e.EV_KEY, self.inv_map[evdev_key], 1)
+        if syn : self.syn_raw()
+
+        self.ui.write(e.EV_MSC, e.MSC_SCAN, self.inv_map[evdev_key])
+        self.ui.write(e.EV_KEY, self.inv_map[evdev_key], 0)
+        if syn : self.syn_raw()
+
+        if shifted:
+            self.ui.write(e.EV_MSC, e.MSC_SCAN, self.shift_key)
+            self.ui.write(e.EV_KEY, self.shift_key, 0)
+            self.syn_raw()
+
+    def get_delay(self):
+        #return 0.01+random.randrange(1,10)/1000
+        #return 0.001
+        return 0.005
+
+    @queue_method(queue)
+    def syn(self):
+        self.ui.write(e.EV_SYN, 0, 0)
+        time.sleep(self.get_delay()) #important to sleep here, otherwise the modifiers can be lost
+        
+    def syn_raw(self):
+        self.ui.write(e.EV_SYN, 0, 0)
+        time.sleep(self.get_delay()) #important to sleep here, otherwise the modifiers can be lost
+
+    @queue_method(queue)
+    def press_key(self, keyName):
+        self.__press_key(keyName, True)
+
+    @queue_method(queue)
+    def release_key(self, keyName):
+        self.__release_key(keyName, True)
+
+    def __release_key(self, key, syn=False):
+        evdev_keycode, shifted_ = self.translate_to_evdev(key)
+        #print(key, evdev_keycode, shifted_)
+        evdev_key = e.keys[evdev_keycode]
+        if shifted_:
+            shifted=True
+
+        self.ui.write(e.EV_MSC, e.MSC_SCAN, self.inv_map[evdev_key])
+        self.ui.write(e.EV_KEY, self.inv_map[evdev_key], 0)
+        if syn: self.syn_raw()
+
+    def  __press_key(self, key, syn=False):
+        evdev_keycode, shifted_ = self.translate_to_evdev(key)
+        #print(key, evdev_keycode, shifted_)
+        evdev_key = e.keys[evdev_keycode]
+        if shifted_:
+            shifted=True
+        self.ui.write(e.EV_MSC, e.MSC_SCAN, self.inv_map[evdev_key])
+        self.ui.write(e.EV_KEY, self.inv_map[evdev_key], 1)
+        if syn: self.syn_raw()
+
+    
+    # def wait_for_keypress(self, timeout=None):
+    #     raise NotImplementedError
+
+    
+    # def wait_for_keyevent(self, timeout=None):
+    #     raise NotImplementedError
+
+    def __initMappings(self):
+        """
+        Grabs hotkeys. Under X11 this means blocking the hotkeys from sending to individual applications. 
+        Not sure if this can be accomplished via uinput/wayland?
+        """
+        pass
+        self.__grab_hotkeys()
+
+    def __grab_hotkeys(self):
+        self.__grab_ungrab_all_hotkeys(grab=True)
+
+    def __ungrab_all_hotkeys(self):
+        self.__grab_ungrab_all_hotkeys(grab=False)
+
+    def __grab_ungrab_all_hotkeys(self, grab=True):
+        c = self.app.configManager
+        logger.debug("Starting UInput hotkey grabber:")
+        hotkeys = c.hotKeys + c.hotKeyFolders
+
+        for item in hotkeys:
+            logger.debug("Hotkey: {}, Modifier: {}".format(item.hotKey, item.modifiers))
+
+    def isModifier(self, keyCode):
+        """
+        """
+        for item in self.uinput_modifiers_to_ak_map:
+            if item == keyCode:
+                logger.debug("isModifier: {}, True".format(keyCode))
+                return True
+        logger.debug("isModifier: {}, False".format(keyCode))
+        return False
+        # if keyCode in self.uinput_to_ak_map:
+            # return True
+        # print(keyCode, self.modifiers, self.translate_to_evdev(keyCode))
+        # print(self.inv_map[keyCode[1]])
+    
+    @queue_method(queue)
+    def handle_keypress(self, keyCode):
+        window_info = self.mediator.windowInterface.get_window_info()
+        event_type = evdev.categorize(keyCode)
+        logger.debug("handle_keypress: KeyState:{}, Un:{}".format(event_type.keystate, event_type.keycode))
+        if self.isModifier(event_type.keycode):
+            # need to translate event_type.keycode to a Key. value from an evdev keycode
+            self.mediator.handle_modifier_down(self.uinput_modifiers_to_ak_map[event_type.keycode])
+        # else: 
+            # self.mediator.handle_keypress(self.translate_to_evdev(event_type.keycode), window_info)
+
+
+    @queue_method(queue)
+    def handle_keyrelease(self, keyCode):
+        window_info = self.mediator.windowInterface.get_window_info() #not used
+        event_type = evdev.categorize(keyCode)
+        logger.debug("handle_keyrelease: KeyState:{}, Un:{}".format(event_type.keystate, event_type.keycode))
+        if self.isModifier(event_type.keycode):
+            self.mediator.handle_modifier_up(self.uinput_modifiers_to_ak_map[event_type.keycode])
+        else:
+            self.mediator.handle_keypress(self.translate_to_evdev(event_type.keycode), window_info)
+
+    def __flush_events_loop(self):
+        logger.debug("__flushEvents: Entering event loop.")
+        while True:
+            try:
+                #logger.debug("__flushEvents: Waiting for events.")
+                self.__flush_events()
+                if self.shutdown:
+                    break
+            except Exception as e:
+                logger.exception(
+                    "Some exception occurred in the flush events loop: {}".format(e))
+        logger.debug("Left event loop.")
+
+    def __flush_events(self):
+        r,w,x = select.select(self.devices, [], [])
+        for fd in r:
+            for event in self.devices[fd].read(): # type: ignore
+                event_type = evdev.categorize(event)
+                held = self.keyboard.active_keys(verbose=True)
+
+                if type(event_type) is evdev.KeyEvent:
+                    
+                    # if event_type.scancode in iter(Button): #is a mouse button 
+                        # continue
+                        #logger.debug("__flush_events: Button State: {}, Button Code: {}".format(event_type.keystate, event_type.keycode))
+
+                    if event_type.keystate == 1 : #key down
+                        logger.debug("__flush_events: Key State: {}, Key Code: {}, Scan Code: {}".format(event_type.keystate, event_type.keycode, event_type.scancode))
+                        logger.debug("Held: {}".format(held))
+                        #logger.debug("Key: {}".format(event_type))
+                        self.handle_keypress(event)
+                    elif event_type.keystate == 0: #key up
+                        self.handle_keyrelease(event)
+                    elif event_type.keystate == 2: # hold event
+                        #TODO: handle hold event
+                        pass
+                    #TODO can also handle scroll events here
+                        
+                    
+                elif type(event_type) is evdev.RelEvent:
+                    pass
+                    #mouse movement event
+                    #logger.debug("Mouse: {}".format(event_type))
+                    #if event_type.
+                    #self.handle_mouseclick(event)
+                
+                
+                # pass through to autokey uinput device
+                if not self.sending and fd == self.keyboard.fd:
+                    self.ui.write(event.type, event.code, event.value)
+
+
+    def flush(self):
+        """
+        Currently not needed for UInput? But is a part of the AbstractSysInterface definition
+        """
+        pass
+
+
+    def __eventLoop(self):
+        while True:
+            method, args = self.queue.get()
+
+            if method is None and args is None:
+                break
+            elif method is not None and args is None:
+                logger.debug("__eventLoop: Got method {} with None arguments!".format(method))
+            try:
+                method(*args)
+            except Exception as e:
+                logger.exception("Error in UInput event loop thread: {}".format(e))
+
+            self.queue.task_done()
+
+
+    def grab_hotkey(self, item):
+        pass
+
+
+    def ungrab_hotkey(self, item):
+        pass
+
+
+    @queue_method(queue)
+    def grab_keyboard(self, ):
+        #TODO: something weird is happening with grab/ungrab
+        #self.keyboard.grab()
+
+        self.sending = True
+        
+        pass
+
+    @queue_method(queue)
+    def ungrab_keyboard(self, ):
+        #TODO: need to implement this
+        pass
+        self.sending = False
+        #self.keyboard.ungrab()
+
+    def handle_mouseclick(self, clickEvent):
+        self.mediator.handle_mouse_click(clickEvent)
+
+    def on_keys_changed(self, ):
+        raise NotImplementedError
+
+    @queue_method(queue)
+    def send_modified_key(self, key, modifiers):
+        """
+        modifiers are expected to be autokey style
+        """
+        from evdev import ecodes as e # not sure why this is needed here? Decorator maybe doing something weird?
+        logger.debug(f"Send modified key: {key}, Modifiers: {modifiers}")
+        evdev_keycode, shifted = self.translate_to_evdev(key)
+        evdev_key = e.keys[evdev_keycode]
+
+
+        try:
+            # down mods
+            for mod in modifiers:
+                #convert to KEY_ modifier
+                evdev_mod_key = self.autokey_map[mod]
+                self.ui.write(e.EV_MSC, e.MSC_SCAN, self.inv_map[evdev_mod_key])
+                self.ui.write(e.EV_KEY, self.inv_map[evdev_mod_key], 1)
+                self.syn_raw()
+            # send key up
+            self.ui.write(e.EV_MSC, e.MSC_SCAN, self.inv_map[evdev_key])
+            self.ui.write(e.EV_KEY, self.inv_map[evdev_key], 1)
+            self.syn_raw()
+
+            # send key down
+            self.ui.write(e.EV_MSC, e.MSC_SCAN, self.inv_map[evdev_key])
+            self.ui.write(e.EV_KEY, self.inv_map[evdev_key], 0)
+            self.syn_raw()
+
+
+            # up mods
+            for mod in modifiers:
+                #convert to KEY_ modifier
+                evdev_mod_key = self.autokey_map[mod]
+                self.ui.write(e.EV_MSC, e.MSC_SCAN, self.inv_map[evdev_mod_key])
+                self.ui.write(e.EV_KEY, self.inv_map[evdev_mod_key], 0)
+                self.syn_raw()
+            
+            pass
+        except Exception as e:
+            logger.warning("Error sending modified key %r %r: %s", modifiers, keyName, str(e))
+
+    
+    def cancel(self):
+        logger.debug("UInputInterface: Try to exit event thread.")
+        self.queue.put_nowait((None, None))
+        logger.debug("UInputInterface: Event thread exit marker enqueued.")
+        self.shutdown = True
+        logger.debug("UInputInterface: Shutdown flag set.")
+
+        self.listenerThread.join()
+        self.eventThread.join()
+
+        self.join()
+
+
+    def fake_keydown(self, key):
+        """
+        No such thing as "fake keydown" in UInput. This is passing through to press_key.
+        """
+        self.press_key(key)
+    
+    def fake_keypress(self, key):
+        """
+        No such thing as "fake keypress" in UInput. This is passing through to send_key.
+        """
+        #self.press_key(key)
+        self.send_key(key)
+    
+    def fake_keyup(self, key):
+        """
+        No such thing as "fake keyup" in UInput. This is passing through to release_key.
+        """
+        self.release_key(key)
+    
+    def get_devices(self):
+        return [evdev.InputDevice(path) for path in evdev.list_devices()]
+
+    def grab_device(self, devices, descriptor):
+        #determine if descriptor is a path or a name
+        return_device = None
+        if len(descriptor) <= 2: #assume that people don't have more than 99 input devices
+            descriptor = "/dev/input/event"+descriptor
+        if "/dev/" in descriptor: #assume function was passed a path
+            for device in devices:
+                if descriptor==device.path:
+                    device.close()
+                    return_device = evdev.InputDevice(device.path)
+                else:
+                    device.close()
+        else: #assume that function was passed a plain text name
+            for device in devices:
+                if descriptor==device.name:
+                    device.close()
+                    return_device = evdev.InputDevice(device.path)
+                else:
+                    device.close()
+
+        return return_device
+    
+
+    def translate_to_evdev(self, key):
+        """
+        Takes an input and tries to convert it to a evdev key code, primarily for internal use
+        Determination of type is based primarily on the key type in order;
+        if key is type str and the first 4 letters have "KEY_" we assume it is an evdev keycode and return from the inverted mapping of the ecodes.keys
+        elif the key is type int we will assume if is a raw evdev value and return it
+        elif len(key) == 1, assume that this is an ascii char, check if "KEY_"+key exists in any of the character maps and process accordingly
+        return (0, false)
+        """
+        if type(key)==str and "KEY_" in key[:4]: #if it is a "KEY_A" type value return evdev int from map
+            # print("Type str")
+            return self.inv_map[key], False
+        elif type(key)==int: #if it is type int it should be a evdev raw value
+            # print("Type int")
+            return key, False
+        elif len(key)==1:
+            #print("Type single char", key)
+            evdev_key = "KEY_"+key.upper()
+            if key in self.shifted_chars:
+                return self.inv_map[self.shifted_chars[key]], True
+            elif key in self.char_map:
+                return self.inv_map[self.char_map[key]], False
+            elif evdev_key in self.inv_map:
+                return self.inv_map[evdev_key], key.isupper()
+            elif evdev_key in self.char_map:
+                return self.inv_map[self.char_map[evdev_key]], key.isupper()
+        elif type(key)==str and key in self.autokey_map:
+            # print("Type <autokey>", key)
+            return self.inv_map[self.autokey_map[key]], False
+        return (0, False)
+    
+    def initialise(self):
+        pass
+
+    def run(self):
+        pass
+
+    def __processEvent(self):
+        pass
+
+    def lookup_string(self, keyCode, shifted, num_lock, altGrid):
+        """
+        
+        """
+        logger.debug("lookup_string: keyCode:{}, Translated:{}, Shifted: {}".format(keyCode, self.translate_to_evdev(keyCode[0]), shifted))
+
+        #if not shifted and not num_lock and not altGrid:
+        #TODO handle special keys like backslash etc.
+        code, shifted_ = self.translate_to_evdev(keyCode[0])
+        evdev_name = e.keys[code]
+        # modifiers
+        if evdev_name in self.uinput_modifiers_to_ak_map:
+            logger.debug("Modifier: {}".format(evdev_name))
+            return self.uinput_modifiers_to_ak_map[evdev_name]
+        # "keys" like f12 ESC etc.
+        if evdev_name in self.uinput_keys_to_ak_map:
+            logger.debug("Key: {}".format(evdev_name))
+            return self.uinput_keys_to_ak_map[evdev_name]
+        character = evdev_name.replace("KEY_", "")
+        if character.lower() in self.translation_map:
+            character = self.translation_map[character.lower()]
+        if shifted:
+            return character.upper()
+        else:
+            return character.lower()
+        #return self.translate_to_evdev(keyCode[0])
+        
+        #return e.keys[self.translate_to_evdev(keyCode)[0]]

From 7935b6a7a61eeefbead12cc3a64f34f9b57a7968 Mon Sep 17 00:00:00 2001
From: Sam Sebastian <sebastiansam55@gmail.com>
Date: Sat, 26 Aug 2023 08:20:53 -0400
Subject: [PATCH 13/20] update statistics to make them more anonymous

---
 lib/autokey/autokey_app.py | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/lib/autokey/autokey_app.py b/lib/autokey/autokey_app.py
index 2aa89057..a1ef7b9b 100644
--- a/lib/autokey/autokey_app.py
+++ b/lib/autokey/autokey_app.py
@@ -24,6 +24,7 @@
 import dbus.mainloop.glib
 import signal
 import subprocess
+import hashlib
 from typing import NamedTuple, Iterable
 import re
 
@@ -123,17 +124,20 @@ def __initialise(self):
         logger.info("Autokey application services ready")
 
     def usage_statistics(self):
+        def get_digest(value):
+            return hashlib.md5(str(value).encode()).hexdigest()[0:8]
+
         logger.info("----- AutoKey Usage Statistics -----")
         for item in self.configManager.allItems:
-            # print(type(item))
             if type(item) is autokey.model.phrase.Phrase:
                 # logger.info(item.description, item.usageCount, item.phrase)
-                logger.info(f"Phrase: {item.description}, Usage Count: {item.usageCount} {self.getMacroUsage(item.phrase)}")
+                logger.info(f"Phrase: {get_digest(item.description)}, Usage Count: {item.usageCount} {self.getMacroUsage(item.phrase)}")
             elif type(item) is autokey.model.script.Script:
-                logger.info(f"Script: {item.description}, Usage Count: {item.usageCount} {self.getAPIUsage(item.code)}")
+                logger.info(f"Script: {get_digest(item.description)}, Usage Count: {item.usageCount} {self.getAPIUsage(item.code)}")
         
         for item in self.configManager.allFolders:
-            logger.info(f"Folder: {item.title}, Usage Count: {item.usageCount}")
+            
+            logger.info(f"Folder: {get_digest(item.title)}, Usage Count: {item.usageCount}")
 
         logger.info("----- AutoKey Usage Statistics -----")
 

From 22f7f8e995bac17352c1e8014c7b0efd69654b66 Mon Sep 17 00:00:00 2001
From: Sam Sebastian <sebastiansam55@gmail.com>
Date: Sat, 26 Aug 2023 08:39:48 -0400
Subject: [PATCH 14/20] Add mouse/keyboard to preferences interface

---
 lib/autokey/gtkui/data/settingsdialog.xml | 473 ++++++++++++++--------
 lib/autokey/gtkui/settingsdialog.py       |  12 +-
 2 files changed, 315 insertions(+), 170 deletions(-)

diff --git a/lib/autokey/gtkui/data/settingsdialog.xml b/lib/autokey/gtkui/data/settingsdialog.xml
index 91eec601..fbe1313f 100644
--- a/lib/autokey/gtkui/data/settingsdialog.xml
+++ b/lib/autokey/gtkui/data/settingsdialog.xml
@@ -1,36 +1,33 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<!-- Generated with glade 3.22.1 -->
+<!-- Generated with glade 3.38.2 -->
 <interface>
   <requires lib="gtk+" version="3.0"/>
   <object class="GtkDialog" id="settingsdialog">
-    <property name="can_focus">False</property>
-    <property name="border_width">8</property>
+    <property name="can-focus">False</property>
+    <property name="border-width">8</property>
     <property name="title" translatable="yes">AutoKey - Preferences</property>
     <property name="modal">True</property>
-    <property name="window_position">center-on-parent</property>
-    <property name="type_hint">dialog</property>
-    <child>
-      <placeholder/>
-    </child>
+    <property name="window-position">center-on-parent</property>
+    <property name="type-hint">dialog</property>
     <child internal-child="vbox">
       <object class="GtkBox" id="dialog-vbox1">
         <property name="visible">True</property>
-        <property name="can_focus">False</property>
+        <property name="can-focus">False</property>
         <property name="orientation">vertical</property>
         <property name="spacing">2</property>
         <child internal-child="action_area">
           <object class="GtkButtonBox" id="dialog-action_area1">
             <property name="visible">True</property>
-            <property name="can_focus">False</property>
-            <property name="layout_style">end</property>
+            <property name="can-focus">False</property>
+            <property name="layout-style">end</property>
             <child>
               <object class="GtkButton" id="button1">
                 <property name="label">gtk-cancel</property>
-                <property name="use_action_appearance">False</property>
+                <property name="use-action-appearance">False</property>
                 <property name="visible">True</property>
-                <property name="can_focus">True</property>
-                <property name="receives_default">True</property>
-                <property name="use_stock">True</property>
+                <property name="can-focus">True</property>
+                <property name="receives-default">True</property>
+                <property name="use-stock">True</property>
                 <signal name="clicked" handler="on_cancel" swapped="no"/>
               </object>
               <packing>
@@ -42,13 +39,13 @@
             <child>
               <object class="GtkButton" id="button2">
                 <property name="label">gtk-ok</property>
-                <property name="use_action_appearance">False</property>
+                <property name="use-action-appearance">False</property>
                 <property name="visible">True</property>
-                <property name="can_focus">True</property>
-                <property name="can_default">True</property>
-                <property name="has_default">True</property>
-                <property name="receives_default">True</property>
-                <property name="use_stock">True</property>
+                <property name="can-focus">True</property>
+                <property name="can-default">True</property>
+                <property name="has-default">True</property>
+                <property name="receives-default">True</property>
+                <property name="use-stock">True</property>
                 <signal name="clicked" handler="on_save" swapped="no"/>
               </object>
               <packing>
@@ -61,52 +58,55 @@
           <packing>
             <property name="expand">False</property>
             <property name="fill">True</property>
-            <property name="pack_type">end</property>
+            <property name="pack-type">end</property>
             <property name="position">0</property>
           </packing>
         </child>
         <child>
           <object class="GtkNotebook" id="notebook1">
             <property name="visible">True</property>
-            <property name="can_focus">True</property>
+            <property name="can-focus">True</property>
             <child>
               <object class="GtkAlignment" id="alignment1">
                 <property name="visible">True</property>
-                <property name="can_focus">False</property>
+                <property name="can-focus">False</property>
                 <property name="yalign">0</property>
                 <property name="yscale">0</property>
-                <property name="top_padding">10</property>
-                <property name="bottom_padding">5</property>
-                <property name="left_padding">5</property>
-                <property name="right_padding">5</property>
+                <property name="top-padding">10</property>
+                <property name="bottom-padding">5</property>
+                <property name="left-padding">5</property>
+                <property name="right-padding">5</property>
                 <child>
-                  <object class="GtkVBox" id="vbox1">
+                  <object class="GtkBox" id="vbox1">
                     <property name="visible">True</property>
-                    <property name="can_focus">False</property>
+                    <property name="can-focus">False</property>
+                    <property name="orientation">vertical</property>
                     <property name="spacing">5</property>
                     <child>
                       <object class="GtkFrame" id="frame8">
                         <property name="visible">True</property>
-                        <property name="can_focus">False</property>
-                        <property name="label_xalign">0</property>
-                        <property name="shadow_type">none</property>
+                        <property name="can-focus">False</property>
+                        <property name="label-xalign">0</property>
+                        <property name="shadow-type">none</property>
                         <child>
                           <object class="GtkAlignment" id="alignment11">
                             <property name="visible">True</property>
-                            <property name="can_focus">False</property>
-                            <property name="left_padding">12</property>
+                            <property name="can-focus">False</property>
+                            <property name="left-padding">12</property>
                             <child>
-                              <object class="GtkVBox" id="vbox7">
+                              <object class="GtkBox" id="vbox7">
                                 <property name="visible">True</property>
-                                <property name="can_focus">False</property>
+                                <property name="can-focus">False</property>
+                                <property name="orientation">vertical</property>
                                 <child>
                                   <object class="GtkCheckButton" id="autoStartCheckbox">
                                     <property name="label" translatable="yes">Automatically start AutoKey at login</property>
-                                    <property name="use_action_appearance">False</property>
+                                    <property name="use-action-appearance">False</property>
                                     <property name="visible">True</property>
-                                    <property name="can_focus">True</property>
-                                    <property name="receives_default">False</property>
-                                    <property name="draw_indicator">True</property>
+                                    <property name="can-focus">True</property>
+                                    <property name="receives-default">False</property>
+                                    <property name="halign">start</property>
+                                    <property name="draw-indicator">True</property>
                                   </object>
                                   <packing>
                                     <property name="expand">True</property>
@@ -117,12 +117,12 @@
                                 <child>
                                   <object class="GtkCheckButton" id="autosaveCheckbox">
                                     <property name="label" translatable="yes">Automatically save changes without confirmation</property>
-                                    <property name="use_action_appearance">False</property>
+                                    <property name="use-action-appearance">False</property>
                                     <property name="visible">True</property>
-                                    <property name="can_focus">True</property>
-                                    <property name="receives_default">False</property>
-                                    <property name="use_action_appearance">False</property>
-                                    <property name="draw_indicator">True</property>
+                                    <property name="can-focus">True</property>
+                                    <property name="receives-default">False</property>
+                                    <property name="halign">start</property>
+                                    <property name="draw-indicator">True</property>
                                   </object>
                                   <packing>
                                     <property name="expand">True</property>
@@ -133,12 +133,12 @@
                                 <child>
                                   <object class="GtkCheckButton" id="showTrayCheckbox">
                                     <property name="label" translatable="yes">Show a notification icon</property>
-                                    <property name="use_action_appearance">False</property>
+                                    <property name="use-action-appearance">False</property>
                                     <property name="visible">True</property>
-                                    <property name="can_focus">True</property>
-                                    <property name="receives_default">False</property>
-                                    <property name="use_action_appearance">False</property>
-                                    <property name="draw_indicator">True</property>
+                                    <property name="can-focus">True</property>
+                                    <property name="receives-default">False</property>
+                                    <property name="halign">start</property>
+                                    <property name="draw-indicator">True</property>
                                     <signal name="toggled" handler="on_showTrayCheckbox_toggled" swapped="no"/>
                                   </object>
                                   <packing>
@@ -150,11 +150,12 @@
                                 <child>
                                   <object class="GtkCheckButton" id="disableCapslockCheckbox">
                                     <property name="label" translatable="yes">Disable handling of the Capslock key</property>
-                                    <property name="use_action_appearance">False</property>
+                                    <property name="use-action-appearance">False</property>
                                     <property name="visible">True</property>
-                                    <property name="can_focus">True</property>
-                                    <property name="receives_default">False</property>
-                                    <property name="draw_indicator">True</property>
+                                    <property name="can-focus">True</property>
+                                    <property name="receives-default">False</property>
+                                    <property name="halign">start</property>
+                                    <property name="draw-indicator">True</property>
                                   </object>
                                   <packing>
                                     <property name="expand">True</property>
@@ -165,11 +166,11 @@
                                 <child>
                                   <object class="GtkHBox" id="hbox4">
                                     <property name="visible">True</property>
-                                    <property name="can_focus">False</property>
+                                    <property name="can-focus">False</property>
                                     <child>
                                       <object class="GtkLabel" id="label18">
                                         <property name="visible">True</property>
-                                        <property name="can_focus">False</property>
+                                        <property name="can-focus">False</property>
                                         <property name="label" translatable="yes">Notification icon style (requires restart):</property>
                                       </object>
                                       <packing>
@@ -189,11 +190,11 @@
                                 <child>
                                   <object class="GtkHBox" id="hboxgtktheme">
                                     <property name="visible">True</property>
-                                    <property name="can_focus">False</property>
+                                    <property name="can-focus">False</property>
                                     <child>
                                       <object class="GtkLabel" id="label19">
                                         <property name="visible">True</property>
-                                        <property name="can_focus">False</property>
+                                        <property name="can-focus">False</property>
                                         <property name="label" translatable="yes">GTKSource Theme (requires restart):</property>
                                       </object>
                                       <packing>
@@ -217,9 +218,9 @@
                         <child type="label">
                           <object class="GtkLabel" id="label">
                             <property name="visible">True</property>
-                            <property name="can_focus">False</property>
+                            <property name="can-focus">False</property>
                             <property name="label" translatable="yes">&lt;b&gt;Application&lt;/b&gt;</property>
-                            <property name="use_markup">True</property>
+                            <property name="use-markup">True</property>
                           </object>
                         </child>
                       </object>
@@ -232,26 +233,28 @@
                     <child>
                       <object class="GtkFrame" id="frame2">
                         <property name="visible">True</property>
-                        <property name="can_focus">False</property>
-                        <property name="label_xalign">0</property>
-                        <property name="shadow_type">none</property>
+                        <property name="can-focus">False</property>
+                        <property name="label-xalign">0</property>
+                        <property name="shadow-type">none</property>
                         <child>
                           <object class="GtkAlignment" id="alignment3">
                             <property name="visible">True</property>
-                            <property name="can_focus">False</property>
-                            <property name="left_padding">12</property>
+                            <property name="can-focus">False</property>
+                            <property name="left-padding">12</property>
                             <child>
-                              <object class="GtkVBox" id="vbox3">
+                              <object class="GtkBox" id="vbox3">
                                 <property name="visible">True</property>
-                                <property name="can_focus">False</property>
+                                <property name="can-focus">False</property>
+                                <property name="orientation">vertical</property>
                                 <child>
                                   <object class="GtkCheckButton" id="allowKbNavCheckbox">
                                     <property name="label" translatable="yes">Allow keyboard navigation of popup menu</property>
-                                    <property name="use_action_appearance">False</property>
+                                    <property name="use-action-appearance">False</property>
                                     <property name="visible">True</property>
-                                    <property name="can_focus">True</property>
-                                    <property name="receives_default">False</property>
-                                    <property name="draw_indicator">True</property>
+                                    <property name="can-focus">True</property>
+                                    <property name="receives-default">False</property>
+                                    <property name="halign">start</property>
+                                    <property name="draw-indicator">True</property>
                                   </object>
                                   <packing>
                                     <property name="expand">True</property>
@@ -262,11 +265,12 @@
                                 <child>
                                   <object class="GtkCheckButton" id="sortByUsageCheckbox">
                                     <property name="label" translatable="yes">Sort menu items with most frequently used first</property>
-                                    <property name="use_action_appearance">False</property>
+                                    <property name="use-action-appearance">False</property>
                                     <property name="visible">True</property>
-                                    <property name="can_focus">True</property>
-                                    <property name="receives_default">False</property>
-                                    <property name="draw_indicator">True</property>
+                                    <property name="can-focus">True</property>
+                                    <property name="receives-default">False</property>
+                                    <property name="halign">start</property>
+                                    <property name="draw-indicator">True</property>
                                   </object>
                                   <packing>
                                     <property name="expand">True</property>
@@ -277,11 +281,12 @@
                                 <child>
                                   <object class="GtkCheckButton" id="triggerItemByInitial">
                                     <property name="label" translatable="yes">Trigger menu item by first initial</property>
-                                    <property name="use_action_appearance">False</property>
+                                    <property name="use-action-appearance">False</property>
                                     <property name="visible">True</property>
-                                    <property name="can_focus">True</property>
-                                    <property name="receives_default">False</property>
-                                    <property name="draw_indicator">True</property>
+                                    <property name="can-focus">True</property>
+                                    <property name="receives-default">False</property>
+                                    <property name="halign">start</property>
+                                    <property name="draw-indicator">True</property>
                                   </object>
                                   <packing>
                                     <property name="expand">True</property>
@@ -296,9 +301,9 @@
                         <child type="label">
                           <object class="GtkLabel" id="label5">
                             <property name="visible">True</property>
-                            <property name="can_focus">False</property>
+                            <property name="can-focus">False</property>
                             <property name="label" translatable="yes">&lt;b&gt;Popup Menu&lt;/b&gt;</property>
-                            <property name="use_markup">True</property>
+                            <property name="use-markup">True</property>
                           </object>
                         </child>
                       </object>
@@ -311,22 +316,23 @@
                     <child>
                       <object class="GtkFrame" id="frame3">
                         <property name="visible">True</property>
-                        <property name="can_focus">False</property>
-                        <property name="label_xalign">0</property>
-                        <property name="shadow_type">none</property>
+                        <property name="can-focus">False</property>
+                        <property name="label-xalign">0</property>
+                        <property name="shadow-type">none</property>
                         <child>
                           <object class="GtkAlignment" id="alignment4">
                             <property name="visible">True</property>
-                            <property name="can_focus">False</property>
-                            <property name="left_padding">12</property>
+                            <property name="can-focus">False</property>
+                            <property name="left-padding">12</property>
                             <child>
                               <object class="GtkCheckButton" id="enableUndoCheckbox">
                                 <property name="label" translatable="yes">Enable undo by pressing backspace</property>
-                                <property name="use_action_appearance">False</property>
+                                <property name="use-action-appearance">False</property>
                                 <property name="visible">True</property>
-                                <property name="can_focus">True</property>
-                                <property name="receives_default">False</property>
-                                <property name="draw_indicator">True</property>
+                                <property name="can-focus">True</property>
+                                <property name="receives-default">False</property>
+                                <property name="halign">start</property>
+                                <property name="draw-indicator">True</property>
                               </object>
                             </child>
                           </object>
@@ -334,9 +340,9 @@
                         <child type="label">
                           <object class="GtkLabel" id="label6">
                             <property name="visible">True</property>
-                            <property name="can_focus">False</property>
+                            <property name="can-focus">False</property>
                             <property name="label" translatable="yes">&lt;b&gt;Expansions&lt;/b&gt;</property>
-                            <property name="use_markup">True</property>
+                            <property name="use-markup">True</property>
                           </object>
                         </child>
                       </object>
@@ -346,6 +352,138 @@
                         <property name="position">2</property>
                       </packing>
                     </child>
+                    <child>
+                      <object class="GtkFrame">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="label-xalign">0</property>
+                        <property name="shadow-type">none</property>
+                        <child>
+                          <object class="GtkAlignment">
+                            <property name="visible">True</property>
+                            <property name="can-focus">False</property>
+                            <property name="left-padding">12</property>
+                            <child>
+                              <object class="GtkBox">
+                                <property name="visible">True</property>
+                                <property name="can-focus">False</property>
+                                <property name="orientation">vertical</property>
+                                <child>
+                                  <object class="GtkBox">
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">False</property>
+                                    <child>
+                                      <object class="GtkLabel">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="label" translatable="yes">Keyboard:</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">0</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkEntry" id="uinput_keyboard">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">True</property>
+                                        <property name="fill">True</property>
+                                        <property name="pack-type">end</property>
+                                        <property name="position">1</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkSeparator">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="padding">10</property>
+                                        <property name="position">2</property>
+                                      </packing>
+                                    </child>
+                                  </object>
+                                  <packing>
+                                    <property name="expand">False</property>
+                                    <property name="fill">True</property>
+                                    <property name="position">0</property>
+                                  </packing>
+                                </child>
+                                <child>
+                                  <object class="GtkBox">
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">False</property>
+                                    <child>
+                                      <object class="GtkLabel">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="label" translatable="yes">Mouse:</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">0</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkEntry" id="uinput_mouse">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">True</property>
+                                        <property name="fill">True</property>
+                                        <property name="pack-type">end</property>
+                                        <property name="position">1</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkSeparator">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="padding">10</property>
+                                        <property name="position">2</property>
+                                      </packing>
+                                    </child>
+                                  </object>
+                                  <packing>
+                                    <property name="expand">False</property>
+                                    <property name="fill">True</property>
+                                    <property name="position">1</property>
+                                  </packing>
+                                </child>
+                              </object>
+                            </child>
+                          </object>
+                        </child>
+                        <child type="label">
+                          <object class="GtkLabel">
+                            <property name="visible">True</property>
+                            <property name="can-focus">False</property>
+                            <property name="label" translatable="yes">&lt;b&gt;UInput Devices&lt;/b&gt;</property>
+                            <property name="use-markup">True</property>
+                          </object>
+                        </child>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">3</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <placeholder/>
+                    </child>
                   </object>
                 </child>
               </object>
@@ -353,52 +491,52 @@
             <child type="tab">
               <object class="GtkLabel" id="label1">
                 <property name="visible">True</property>
-                <property name="can_focus">False</property>
+                <property name="can-focus">False</property>
                 <property name="label" translatable="yes">General</property>
               </object>
               <packing>
-                <property name="tab_fill">False</property>
+                <property name="tab-fill">False</property>
               </packing>
             </child>
             <child>
               <object class="GtkAlignment" id="alignment5">
                 <property name="visible">True</property>
-                <property name="can_focus">False</property>
+                <property name="can-focus">False</property>
                 <property name="yalign">0</property>
                 <property name="yscale">0</property>
-                <property name="top_padding">10</property>
-                <property name="bottom_padding">5</property>
-                <property name="left_padding">5</property>
-                <property name="right_padding">5</property>
+                <property name="top-padding">10</property>
+                <property name="bottom-padding">5</property>
+                <property name="left-padding">5</property>
+                <property name="right-padding">5</property>
                 <child>
-                  <object class="GtkVBox" id="vbox4">
+                  <object class="GtkBox" id="vbox4">
                     <property name="visible">True</property>
-                    <property name="can_focus">False</property>
+                    <property name="can-focus">False</property>
+                    <property name="orientation">vertical</property>
                     <property name="spacing">10</property>
                     <child>
                       <object class="GtkFrame" id="frame4">
                         <property name="visible">True</property>
-                        <property name="can_focus">False</property>
-                        <property name="label_xalign">0</property>
-                        <property name="shadow_type">none</property>
+                        <property name="can-focus">False</property>
+                        <property name="label-xalign">0</property>
+                        <property name="shadow-type">none</property>
                         <child>
                           <object class="GtkAlignment" id="alignment6">
                             <property name="visible">True</property>
-                            <property name="can_focus">False</property>
-                            <property name="top_padding">5</property>
-                            <property name="bottom_padding">5</property>
-                            <property name="left_padding">12</property>
+                            <property name="can-focus">False</property>
+                            <property name="top-padding">5</property>
+                            <property name="bottom-padding">5</property>
+                            <property name="left-padding">12</property>
                             <child>
                               <object class="GtkHBox" id="hbox1">
                                 <property name="visible">True</property>
-                                <property name="can_focus">False</property>
+                                <property name="can-focus">False</property>
                                 <property name="spacing">5</property>
                                 <child>
                                   <object class="GtkLabel" id="label10">
                                     <property name="visible">True</property>
-                                    <property name="can_focus">False</property>
+                                    <property name="can-focus">False</property>
                                     <property name="label" translatable="yes">Hotkey:</property>
-                                    <property name="xalign">0</property>
                                   </object>
                                   <packing>
                                     <property name="expand">False</property>
@@ -409,9 +547,8 @@
                                 <child>
                                   <object class="GtkLabel" id="monitorKeyLabel">
                                     <property name="visible">True</property>
-                                    <property name="can_focus">False</property>
+                                    <property name="can-focus">False</property>
                                     <property name="label" translatable="yes">$hotkey</property>
-                                    <property name="xalign">0</property>
                                   </object>
                                   <packing>
                                     <property name="expand">True</property>
@@ -422,11 +559,11 @@
                                 <child>
                                   <object class="GtkButton" id="setMonitorButton">
                                     <property name="label" translatable="yes">Set</property>
-                                    <property name="use_action_appearance">False</property>
-                                    <property name="width_request">80</property>
+                                    <property name="use-action-appearance">False</property>
+                                    <property name="width-request">80</property>
                                     <property name="visible">True</property>
-                                    <property name="can_focus">True</property>
-                                    <property name="receives_default">True</property>
+                                    <property name="can-focus">True</property>
+                                    <property name="receives-default">True</property>
                                     <signal name="clicked" handler="on_setMonitorButton_pressed" swapped="no"/>
                                   </object>
                                   <packing>
@@ -438,12 +575,12 @@
                                 <child>
                                   <object class="GtkButton" id="clearMonitorButton">
                                     <property name="label">gtk-clear</property>
-                                    <property name="use_action_appearance">False</property>
-                                    <property name="width_request">80</property>
+                                    <property name="use-action-appearance">False</property>
+                                    <property name="width-request">80</property>
                                     <property name="visible">True</property>
-                                    <property name="can_focus">True</property>
-                                    <property name="receives_default">True</property>
-                                    <property name="use_stock">True</property>
+                                    <property name="can-focus">True</property>
+                                    <property name="receives-default">True</property>
+                                    <property name="use-stock">True</property>
                                     <signal name="clicked" handler="on_clearMonitorButton_pressed" swapped="no"/>
                                   </object>
                                   <packing>
@@ -459,9 +596,9 @@
                         <child type="label">
                           <object class="GtkLabel" id="label7">
                             <property name="visible">True</property>
-                            <property name="can_focus">False</property>
+                            <property name="can-focus">False</property>
                             <property name="label" translatable="yes">&lt;b&gt;Toggle monitoring using a hotkey&lt;/b&gt;</property>
-                            <property name="use_markup">True</property>
+                            <property name="use-markup">True</property>
                           </object>
                         </child>
                       </object>
@@ -474,27 +611,26 @@
                     <child>
                       <object class="GtkFrame" id="frame5">
                         <property name="visible">True</property>
-                        <property name="can_focus">False</property>
-                        <property name="label_xalign">0</property>
-                        <property name="shadow_type">none</property>
+                        <property name="can-focus">False</property>
+                        <property name="label-xalign">0</property>
+                        <property name="shadow-type">none</property>
                         <child>
                           <object class="GtkAlignment" id="alignment7">
                             <property name="visible">True</property>
-                            <property name="can_focus">False</property>
-                            <property name="top_padding">5</property>
-                            <property name="bottom_padding">5</property>
-                            <property name="left_padding">12</property>
+                            <property name="can-focus">False</property>
+                            <property name="top-padding">5</property>
+                            <property name="bottom-padding">5</property>
+                            <property name="left-padding">12</property>
                             <child>
                               <object class="GtkHBox" id="hbox2">
                                 <property name="visible">True</property>
-                                <property name="can_focus">False</property>
+                                <property name="can-focus">False</property>
                                 <property name="spacing">5</property>
                                 <child>
                                   <object class="GtkLabel" id="label12">
                                     <property name="visible">True</property>
-                                    <property name="can_focus">False</property>
+                                    <property name="can-focus">False</property>
                                     <property name="label" translatable="yes">Hotkey:</property>
-                                    <property name="xalign">0</property>
                                   </object>
                                   <packing>
                                     <property name="expand">False</property>
@@ -505,9 +641,8 @@
                                 <child>
                                   <object class="GtkLabel" id="configKeyLabel">
                                     <property name="visible">True</property>
-                                    <property name="can_focus">False</property>
+                                    <property name="can-focus">False</property>
                                     <property name="label" translatable="yes">$hotkey</property>
-                                    <property name="xalign">0</property>
                                   </object>
                                   <packing>
                                     <property name="expand">True</property>
@@ -518,11 +653,11 @@
                                 <child>
                                   <object class="GtkButton" id="setConfigButton">
                                     <property name="label" translatable="yes">Set</property>
-                                    <property name="use_action_appearance">False</property>
-                                    <property name="width_request">80</property>
+                                    <property name="use-action-appearance">False</property>
+                                    <property name="width-request">80</property>
                                     <property name="visible">True</property>
-                                    <property name="can_focus">True</property>
-                                    <property name="receives_default">True</property>
+                                    <property name="can-focus">True</property>
+                                    <property name="receives-default">True</property>
                                     <signal name="clicked" handler="on_setConfigButton_pressed" swapped="no"/>
                                   </object>
                                   <packing>
@@ -534,12 +669,12 @@
                                 <child>
                                   <object class="GtkButton" id="clearConfigButton">
                                     <property name="label">gtk-clear</property>
-                                    <property name="use_action_appearance">False</property>
-                                    <property name="width_request">80</property>
+                                    <property name="use-action-appearance">False</property>
+                                    <property name="width-request">80</property>
                                     <property name="visible">True</property>
-                                    <property name="can_focus">True</property>
-                                    <property name="receives_default">True</property>
-                                    <property name="use_stock">True</property>
+                                    <property name="can-focus">True</property>
+                                    <property name="receives-default">True</property>
+                                    <property name="use-stock">True</property>
                                     <signal name="clicked" handler="on_clearConfigButton_pressed" swapped="no"/>
                                   </object>
                                   <packing>
@@ -555,9 +690,9 @@
                         <child type="label">
                           <object class="GtkLabel" id="label8">
                             <property name="visible">True</property>
-                            <property name="can_focus">False</property>
+                            <property name="can-focus">False</property>
                             <property name="label" translatable="yes">&lt;b&gt;Show configuration window using a hotkey&lt;/b&gt;</property>
-                            <property name="use_markup">True</property>
+                            <property name="use-markup">True</property>
                           </object>
                         </child>
                       </object>
@@ -577,45 +712,45 @@
             <child type="tab">
               <object class="GtkLabel" id="label2">
                 <property name="visible">True</property>
-                <property name="can_focus">False</property>
+                <property name="can-focus">False</property>
                 <property name="label" translatable="yes">Special Hotkeys</property>
               </object>
               <packing>
                 <property name="position">1</property>
-                <property name="tab_fill">False</property>
+                <property name="tab-fill">False</property>
               </packing>
             </child>
             <child>
               <object class="GtkAlignment" id="alignment2">
                 <property name="visible">True</property>
-                <property name="can_focus">False</property>
-                <property name="top_padding">10</property>
-                <property name="bottom_padding">5</property>
-                <property name="left_padding">5</property>
-                <property name="right_padding">5</property>
+                <property name="can-focus">False</property>
+                <property name="top-padding">10</property>
+                <property name="bottom-padding">5</property>
+                <property name="left-padding">5</property>
+                <property name="right-padding">5</property>
                 <child>
                   <object class="GtkFrame" id="frame1">
                     <property name="visible">True</property>
-                    <property name="can_focus">False</property>
-                    <property name="label_xalign">0</property>
-                    <property name="shadow_type">none</property>
+                    <property name="can-focus">False</property>
+                    <property name="label-xalign">0</property>
+                    <property name="shadow-type">none</property>
                     <child>
                       <object class="GtkAlignment" id="alignment12">
                         <property name="visible">True</property>
-                        <property name="can_focus">False</property>
-                        <property name="left_padding">12</property>
+                        <property name="can-focus">False</property>
+                        <property name="left-padding">12</property>
                         <child>
-                          <object class="GtkVBox" id="vbox2">
+                          <object class="GtkBox" id="vbox2">
                             <property name="visible">True</property>
-                            <property name="can_focus">False</property>
+                            <property name="can-focus">False</property>
+                            <property name="orientation">vertical</property>
                             <child>
                               <object class="GtkLabel" id="label17">
                                 <property name="visible">True</property>
-                                <property name="can_focus">False</property>
+                                <property name="can-focus">False</property>
                                 <property name="ypad">5</property>
                                 <property name="label" translatable="yes">Any Python modules placed in this folder will be available for
 import by scripts.</property>
-                                <property name="xalign">0</property>
                               </object>
                               <packing>
                                 <property name="expand">False</property>
@@ -626,7 +761,7 @@ import by scripts.</property>
                             <child>
                               <object class="GtkFileChooserButton" id="userModuleChooserButton">
                                 <property name="visible">True</property>
-                                <property name="can_focus">False</property>
+                                <property name="can-focus">False</property>
                                 <property name="action">select-folder</property>
                                 <property name="title" translatable="yes">Select A Folder</property>
                               </object>
@@ -643,9 +778,9 @@ import by scripts.</property>
                     <child type="label">
                       <object class="GtkLabel" id="label16">
                         <property name="visible">True</property>
-                        <property name="can_focus">False</property>
+                        <property name="can-focus">False</property>
                         <property name="label" translatable="yes">&lt;b&gt;User Module Folder&lt;/b&gt;</property>
-                        <property name="use_markup">True</property>
+                        <property name="use-markup">True</property>
                       </object>
                     </child>
                   </object>
@@ -658,12 +793,12 @@ import by scripts.</property>
             <child type="tab">
               <object class="GtkLabel" id="label3">
                 <property name="visible">True</property>
-                <property name="can_focus">False</property>
+                <property name="can-focus">False</property>
                 <property name="label" translatable="yes">Script Engine</property>
               </object>
               <packing>
                 <property name="position">2</property>
-                <property name="tab_fill">False</property>
+                <property name="tab-fill">False</property>
               </packing>
             </child>
           </object>
diff --git a/lib/autokey/gtkui/settingsdialog.py b/lib/autokey/gtkui/settingsdialog.py
index 72039450..435f2c84 100644
--- a/lib/autokey/gtkui/settingsdialog.py
+++ b/lib/autokey/gtkui/settingsdialog.py
@@ -102,7 +102,13 @@ def __init__(self, parent, configManager):
         self.configKeyLabel = builder.get_object("configKeyLabel")
         self.clearConfigButton = builder.get_object("clearConfigButton")
         self.monitorKeyLabel = builder.get_object("monitorKeyLabel")
-        self.clearMonitorButton = builder.get_object("clearMonitorButton")    
+        self.clearMonitorButton = builder.get_object("clearMonitorButton")
+
+        # UInput Settings
+        self.uinput_keyboard = builder.get_object("uinput_keyboard")
+        self.uinput_mouse = builder.get_object("uinput_mouse")
+        self.uinput_keyboard.set_text(cm.ConfigManager.SETTINGS[cm_constants.KEYBOARD])
+        self.uinput_mouse.set_text(cm.ConfigManager.SETTINGS[cm_constants.MOUSE])
         
         self.useConfigHotkey = self.__loadHotkey(configManager.configHotkey, self.configKeyLabel, 
                                                  self.showConfigDlg, self.clearConfigButton)
@@ -134,6 +140,10 @@ def on_save(self, widget, data=None):
         cm.ConfigManager.SETTINGS[cm_constants.TRIGGER_BY_INITIAL] = self.triggerItemByInitial.get_active()
         cm.ConfigManager.SETTINGS[cm_constants.UNDO_USING_BACKSPACE] = self.enableUndoCheckbox.get_active()
         cm.ConfigManager.SETTINGS[cm_constants.NOTIFICATION_ICON] = ICON_NAME_MAP[self.iconStyleCombo.get_active_text()]
+
+        # UInput Settings
+        cm.ConfigManager.SETTINGS[cm_constants.KEYBOARD] = self.uinput_keyboard.get_text()
+        cm.ConfigManager.SETTINGS[cm_constants.MOUSE] = self.uinput_mouse.get_text()
         self._save_disable_capslock_setting()
         self.configManager.userCodeDir = self.userModuleChooserButton.get_current_folder()
         sys.path.append(self.configManager.userCodeDir)

From 2c521ec629c2ed1e76ef7a364ee3342ccffbacde Mon Sep 17 00:00:00 2001
From: Sam Sebastian <sebastiansam55@gmail.com>
Date: Sat, 26 Aug 2023 08:40:24 -0400
Subject: [PATCH 15/20] Add version check and method to get screen size

---
 lib/autokey/gnome_interface.py | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/lib/autokey/gnome_interface.py b/lib/autokey/gnome_interface.py
index fdb1381a..2499700f 100644
--- a/lib/autokey/gnome_interface.py
+++ b/lib/autokey/gnome_interface.py
@@ -15,6 +15,15 @@ def __init__(self):
         shell_obj = session_bus.get_object('org.gnome.Shell', '/org/gnome/Shell/Extensions/AutoKey')
         self.dbus_interface = dbus.Interface(shell_obj, 'org.gnome.Shell.Extensions.AutoKey')
 
+        version = self.dbus_interface.CheckVersion()
+        logger.debug("AutoKey Gnome Extension version: %s" % version)
+        if version == "0.1":
+            pass
+        else:
+            raise Exception("Incompatible version of AutoKey Gnome Extension")
+
+
+
 class GnomeMouseReadInterface(DBusInterface):
     def __init__(self):
         super().__init__()
@@ -26,7 +35,10 @@ def mouse_location(self):
 class GnomeExtensionWindowInterface(DBusInterface, AbstractWindowInterface):
     def __init__(self):
         super().__init__()
-        
+    
+    def get_screen_size(self):
+        x,y = self.dbus_interface.ScreenSize()
+        return [int(x), int(y)]
 
     def get_window_info(self, window=None, traverse: bool=True) -> WindowInfo:
         """

From 09d218c2341d5ba4c0c17154df6679f68596e422 Mon Sep 17 00:00:00 2001
From: Sam Sebastian <sebastiansam55@gmail.com>
Date: Sat, 26 Aug 2023 08:43:20 -0400
Subject: [PATCH 16/20] Add mouse and keyboard to config file

---
 lib/autokey/configmanager/configmanager.py           | 7 +++++--
 lib/autokey/configmanager/configmanager_constants.py | 3 +++
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/lib/autokey/configmanager/configmanager.py b/lib/autokey/configmanager/configmanager.py
index 1b927fa5..aa161b8e 100644
--- a/lib/autokey/configmanager/configmanager.py
+++ b/lib/autokey/configmanager/configmanager.py
@@ -37,7 +37,7 @@
     RECENT_ENTRIES_FOLDER, IS_FIRST_RUN, SERVICE_RUNNING, MENU_TAKES_FOCUS, SHOW_TRAY_ICON, SORT_BY_USAGE_COUNT, \
     PROMPT_TO_SAVE, ENABLE_QT4_WORKAROUND, UNDO_USING_BACKSPACE, WINDOW_DEFAULT_SIZE, HPANE_POSITION, COLUMN_WIDTHS, \
     SHOW_TOOLBAR, NOTIFICATION_ICON, WORKAROUND_APP_REGEX, TRIGGER_BY_INITIAL, SCRIPT_GLOBALS, INTERFACE_TYPE, \
-    DISABLED_MODIFIERS, GTK_THEME, GTK_TREE_VIEW_EXPANDED_ROWS, PATH_LAST_OPEN
+    DISABLED_MODIFIERS, GTK_THEME, GTK_TREE_VIEW_EXPANDED_ROWS, PATH_LAST_OPEN, KEYBOARD, MOUSE, DEVICES
 import autokey.configmanager.version_upgrading as version_upgrade
 import autokey.configmanager.predefined_user_files
 from autokey.iomediator.constants import X_RECORD_INTERFACE
@@ -219,7 +219,10 @@ class ConfigManager:
                 SCRIPT_GLOBALS: {},
                 GTK_THEME: "classic",
                 GTK_TREE_VIEW_EXPANDED_ROWS: [],
-                PATH_LAST_OPEN: "0"
+                PATH_LAST_OPEN: "0",
+                KEYBOARD: None,
+                MOUSE: None,
+                DEVICES: [],
                 }
 
     def __init__(self, app):
diff --git a/lib/autokey/configmanager/configmanager_constants.py b/lib/autokey/configmanager/configmanager_constants.py
index 315c482a..7838df33 100644
--- a/lib/autokey/configmanager/configmanager_constants.py
+++ b/lib/autokey/configmanager/configmanager_constants.py
@@ -51,3 +51,6 @@
 GTK_THEME = "gtkTheme"
 GTK_TREE_VIEW_EXPANDED_ROWS = "gtkExpandedRows"
 PATH_LAST_OPEN = "pathLastOpen"
+KEYBOARD= "keyboard"
+MOUSE = "mouse"
+DEVICES = "devices"
\ No newline at end of file

From 2ed32787007f24da24d637a2ebdbfb6d4047a22c Mon Sep 17 00:00:00 2001
From: Sam Sebastian <sebastiansam55@gmail.com>
Date: Sat, 26 Aug 2023 09:12:44 -0400
Subject: [PATCH 17/20] Update error dialog methods

---
 lib/autokey/gtkapp.py | 36 ++++++++++++++++++++++++++++++++----
 1 file changed, 32 insertions(+), 4 deletions(-)

diff --git a/lib/autokey/gtkapp.py b/lib/autokey/gtkapp.py
index 571f7b24..8a4605f7 100644
--- a/lib/autokey/gtkapp.py
+++ b/lib/autokey/gtkapp.py
@@ -23,6 +23,7 @@
 import os.path
 import time
 import threading
+import subprocess
 
 import gettext
 
@@ -180,10 +181,10 @@ def show_error_dialog(self, message, details=None, dialog_type=Gtk.MessageType.E
         :param dialog_type: One of Gtk.MessageType.ERROR, Gtk.MessageType.WARNING , Gtk.MessageType.INFO, Gtk.MessageType.OTHER, Gtk.MessageType.QUESTION
             defaults to Gtk.MessageType.ERROR
         """
-        # TODO check if gtk threads entered.
-            # Gdk.threads_enter()
-            # display error
-            # Gdk.threads_leave()
+        # TODO does this cause issues with other places the error dialog is shown?
+        # without this threads_enter/threads_leave it  would fail to show dialog/create 
+        # app indicator when error is thrown from uinput interfaced
+        Gdk.threads_enter()
         logger.debug("Displaying "+dialog_type.value_name+" Dialog")
         dlg = Gtk.MessageDialog(type=dialog_type, buttons=Gtk.ButtonsType.OK,
                                  message_format=message)
@@ -191,6 +192,33 @@ def show_error_dialog(self, message, details=None, dialog_type=Gtk.MessageType.E
             dlg.format_secondary_text(details)
         dlg.run()
         dlg.destroy()
+        Gdk.threads_leave()
+
+    def show_error_dialog_with_link(self, message, details=None, link_data=None, dialog_type=Gtk.MessageType.ERROR):
+        Gdk.threads_enter()
+        # logger.debug("Displaying )
+        label = Gtk.Label()
+        label.set_markup(f'<span foreground="white">{link_data}</span>')
+        # label.set_tooltip_text("Click to open file")
+        # label.set_cursor(Gdk.Cursor.new(Gdk.CursorType.HAND1))
+        # label.connect("activate-link", open_file_link, link_data)
+        
+        dialog = Gtk.MessageDialog(type=dialog_type, buttons=Gtk.ButtonsType.NONE, message_format=message)
+        open_button = dialog.add_button("Open", Gtk.ResponseType.YES)
+
+        dialog.get_message_area().add(label)
+
+        dialog.show_all()
+
+        response = dialog.run()
+
+        if response == Gtk.ResponseType.YES:
+            logger.info(f"Attempting to open {link_data}")
+            subprocess.Popen(['xdg-open', link_data])
+
+        dialog.destroy()
+        Gdk.threads_leave()
+
 
     def show_script_error(self, parent):
         """

From ecfdc8b3030cbecf412164435fd173699048286a Mon Sep 17 00:00:00 2001
From: Sam Sebastian <sebastiansam55@gmail.com>
Date: Sat, 26 Aug 2023 09:13:07 -0400
Subject: [PATCH 18/20] update where interfaces are created

---
 lib/autokey/iomediator/iomediator.py | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/lib/autokey/iomediator/iomediator.py b/lib/autokey/iomediator/iomediator.py
index 995a4e7c..2ad7f3cd 100644
--- a/lib/autokey/iomediator/iomediator.py
+++ b/lib/autokey/iomediator/iomediator.py
@@ -69,22 +69,23 @@ def __init__(self, service):
         elif session_type is None:
             pass
         
+        if self.interfaceType == "uinput":
+            self.windowInterface = GnomeExtensionWindowInterface()
+        else:
+            from autokey.interface import XWindowInterface
+            self.windowInterface = XWindowInterface()
+
 
         if self.interfaceType == "uinput":
             from autokey.uinput_interface import UInputInterface
             self.interface = UInputInterface(self, self.app)
         elif self.interfaceType == X_RECORD_INTERFACE:
-            from autokey.interface import XRecordInterface, XWindowInterface
+            from autokey.interface import XRecordInterface
             self.interface = XRecordInterface(self, self.app)
         else:
-            from autokey.interface import AtSpiInterface, XWindowInterface
+            from autokey.interface import AtSpiInterface
             self.interface = AtSpiInterface(self, self.app)
 
-        if self.interfaceType == "uinput":
-            self.windowInterface = GnomeExtensionWindowInterface()
-        else:
-            self.windowInterface = XWindowInterface()
-
         self.clipboard = Clipboard()
 
         global CURRENT_INTERFACE

From d67d5b38a1a6cfa781185577cb3851ddec3b07af Mon Sep 17 00:00:00 2001
From: Sam Sebastian <sebastiansam55@gmail.com>
Date: Sat, 26 Aug 2023 09:14:25 -0400
Subject: [PATCH 19/20] add mouse methods to interface. error popups

---
 lib/autokey/uinput_interface.py | 240 ++++++++++++++++++++++++++++++--
 1 file changed, 227 insertions(+), 13 deletions(-)

diff --git a/lib/autokey/uinput_interface.py b/lib/autokey/uinput_interface.py
index d939e980..9589600d 100644
--- a/lib/autokey/uinput_interface.py
+++ b/lib/autokey/uinput_interface.py
@@ -13,6 +13,7 @@
 import select
 import random
 import re
+import pathlib
 
 from autokey.model.button import Button
 from autokey.model.phrase import SendMode
@@ -21,9 +22,13 @@
 import evdev
 from evdev import ecodes as e
 
+from autokey.autokey_app import AutokeyApplication
+
 logger = __import__("autokey.logger").logger.get_logger(__name__)
 
-from autokey.sys_interface.abstract_interface import AbstractSysInterface, queue_method
+from autokey.sys_interface.abstract_interface import AbstractSysInterface, AbstractMouseInterface, queue_method
+import autokey.configmanager.configmanager as cm
+import autokey.configmanager.configmanager_constants as cm_constants
 from autokey.gnome_interface import GnomeMouseReadInterface
 
 
@@ -141,6 +146,19 @@ class UInputInterface(threading.Thread, GnomeMouseReadInterface, AbstractSysInte
         "backslash": "\\", "equal": "=", "minus": "-", "grave": "`",
     }
 
+    #TODO complete this
+    button_map = {
+        Button.LEFT: [e.BTN_LEFT, 0x90001],
+        Button.RIGHT: [e.BTN_RIGHT, 0x90002],
+        Button.MIDDLE: [e.BTN_MIDDLE, 0x90003],
+        #4: [e.BTN_SIDE, 0x90004],
+        #5: [e.BTN_EXTRA, 0x90005],
+        #6: [],
+        #7: [],
+        #8: [e.BTN_BACK, ]
+
+    }
+
     queue = queue.Queue()
 
     def __init__(self, mediator, app):
@@ -148,11 +166,12 @@ def __init__(self, mediator, app):
         self.setDaemon(True)
         self.setName("UInputInterface-thread")
         self.mediator = mediator  # type: IoMediator
-        self.app = app
+        self.app = app # type: AutokeyApplication
         self.shutdown = False
         self.sending = False
         self.keyboard = None
         self.mouse = None
+        self.capabilities = None
         time.sleep(1)
 
         # Event loop
@@ -166,25 +185,45 @@ def __init__(self, mediator, app):
         devices = self.get_devices()
 
         #TODO have to find a way to have user select which device to use (or try to find the right one)
+        # something like zenity --list --title="Select an Option" --text="Choose an option:" --column="Option" "Option 1" "Option 2" "Option 3"
+        # just grab the return and set it up
         # should allow user to manually set the input devices in the settings.
+        keyboard_name = cm.ConfigManager.SETTINGS[cm_constants.KEYBOARD]
+        mouse_name = cm.ConfigManager.SETTINGS[cm_constants.MOUSE]
+        if cm.ConfigManager.SETTINGS[cm_constants.KEYBOARD]:
+            logger.info("Grabbing keyboard from settings: {}".format(keyboard_name))
+            try:
+                self.keyboard = self.grab_device(devices, keyboard_name)
+            except Exception as error:
+                logger.error("Could not grab keyboard from settings: {}".format(error))
+        if cm.ConfigManager.SETTINGS[cm_constants.MOUSE]:
+            logger.info("Grabbing mouse from settings: {}".format(mouse_name))
+            try: 
+                self.mouse = self.grab_device(devices, mouse_name)
+            except Exception as error:
+                logger.error("Could not grab mouse from settings: {}".format(error))
+                # self.app.show_error_dialog("Could not grab mouse name from settings!")
+
+        # attempt to automatically determine keyboard and mouse devices based on device names
         for dev in devices:
             logger.debug("Found device: {}".format(dev.name))
             if self.keyboard is None and re.search("keyboard", dev.name, re.IGNORECASE):
-                logger.debug("Found keyboard: {}".format(dev.name))
+                logger.debug("Found device with keyboard in the name, grabbing it: {}".format(dev.name))
                 self.keyboard = self.grab_device(devices, dev.name)
                 self.keyboard.grab()
             elif self.mouse is None and re.search("mouse", dev.name, re.IGNORECASE):
-                logger.debug("Found mouse: {}".format(dev.name))
+                logger.debug("Found device with mouse in the name, grabbing it: {}".format(dev.name))
                 self.mouse = self.grab_device(devices, dev.name)
-        #self.keyboard = self.grab_device(devices, "ZSA Technology Labs ErgoDox EZ")
-        #self.mouse = self.grab_device(devices, "Logitech MX Master 3")
-        # self.keyboard = self.grab_device(devices, "AT Translated Set 2 keyboard")
-        # self.keyboard.grab() # exclusive grab, no other process can use it, instead pass through input events via uinput
-        # self.mouse = self.grab_device(devices, "VirtualBox mouse integration")
 
-        if self.mouse is None or self.keyboard is None:
-            logger.error("Unable to find mouse or keyboard")
-            raise Exception("Unable to find mouse or keyboard")
+        if self.mouse is None:
+            logger.error("Unable to find mouse")
+            self.app.show_error_dialog_with_link(f"Unable to find mouse {mouse_name}", f"Update in {cm_constants.CONFIG_FILE}", link_data=cm_constants.CONFIG_FILE)
+            self.app.shutdown()
+            # raise Exception("Unable to find mouse or keyboard")
+        if self.keyboard is None:
+            logger.error(f"Unable to find keyboard {keyboard_name}")
+            self.app.show_error_dialog_with_link(f"Unable to find keyboard {keyboard_name}", f"Update in {cm_constants.CONFIG_FILE}", link_data=cm_constants.CONFIG_FILE)
+            self.app.shutdown()
 
         self.devices = [self.keyboard, self.mouse]
         logger.debug("Keyboard: {}, Path: {}".format(self.keyboard.name, self.keyboard.path))
@@ -200,6 +239,12 @@ def __init__(self, mediator, app):
             # creating a uinput device with the combined capabilities of the user's mouse and keyboard
             # this will undoubtedly cause issues if user attempts to send signals not supported by their devices
             self.ui = evdev.UInput.from_device(self.mouse.path, self.keyboard.path, name="autokey mouse and keyboard")
+            self.capabilities = self.ui.capabilities(verbose=True)
+            logger.debug("Device capabilities: {}".format(self.capabilities))
+
+            logger.info("Supports ABS Movement: {}".format(self.supports_abs()))
+            logger.info("Supports REL Movement: {}".format(self.supports_rel()))
+            
 
         except Exception as ex:
             logger.error("Unable to create UInput device. {}".format(ex))
@@ -207,6 +252,7 @@ def __init__(self, mediator, app):
             #print("Unable to create UInput device. {}".format(ex))
 
         GnomeMouseReadInterface.__init__(self)
+        logger.debug("Screen size: {}".format(self.mediator.windowInterface.get_screen_size()))
 
 
         self.inv_map = self.__reverse_mapping(e.keys)
@@ -221,6 +267,31 @@ def __init__(self, mediator, app):
         self.eventThread.start()
         self.listenerThread.start()
 
+    def supports_abs(self):
+        has_abs_x = False
+        has_abs_y = False
+        if self.capabilities.get(('EV_ABS', 3)):
+            for item in self.capabilities[('EV_ABS', 3)]:
+                if item[0][0] == 'ABS_X':
+                    has_abs_x = True
+                if item[0][0] == 'ABS_Y':
+                    has_abs_y = True
+            return has_abs_x and has_abs_y
+        return False
+    
+    def supports_rel(self):
+        has_rel_x = False
+        has_rel_y = False
+
+        if self.capabilities.get(('EV_REL', 2)):
+            for item in self.capabilities[('EV_REL', 2)]:
+                if item[0] == 'REL_X':
+                    has_rel_x = True
+                if item[0] == 'REL_Y':
+                    has_rel_y = True
+            return has_rel_x and has_rel_y
+        return False
+
 
     def __reverse_mapping(self, dictionary):
         map = {}
@@ -246,6 +317,136 @@ def validate(self):
             logger.error("User not in input group add yourself or run program as root")
             logger.error(f"sudo usermod -a -G input {user}")
             raise Exception("User not in input group add yourself or run program as root")
+        
+    @queue_method(queue)
+    def send_mouse_click(self, xCoord, yCoord, button: Button, relative):
+        self.move_cursor(xCoord, yCoord, relative)
+
+        keycode = self.button_map[button][0]
+        scancode = self.button_map[button][1]
+
+        self.ui.write(e.EV_MSC, e.MSC_SCAN, scancode)
+        self.ui.write(e.EV_KEY, keycode, 1)
+        self.syn_raw()
+
+        self.ui.write(e.EV_MSC, e.MSC_SCAN, scancode)
+        self.ui.write(e.EV_KEY, keycode, 0)
+        self.syn_raw()
+    
+    @queue_method(queue)
+    def mouse_press(self, xCoord, yCoord, button):
+        self.move_cursor(xCoord, yCoord)
+
+        keycode = self.button_map[button][0]
+        scancode = self.button_map[button][1]
+
+        self.ui.write(e.EV_MSC, e.MSC_SCAN, scancode)
+        self.ui.write(e.EV_KEY, keycode, 1)
+        self.syn_raw()
+
+    @queue_method(queue)
+    def mouse_release(self, xCoord, yCoord, button):
+        self.move_cursor(xCoord, yCoord)
+
+        keycode = self.button_map[button][0]
+        scancode = self.button_map[button][1]
+
+        self.ui.write(e.EV_MSC, e.MSC_SCAN, scancode)
+        self.ui.write(e.EV_KEY, keycode, 0)
+        self.syn_raw()
+    
+    # implemented in GnomeMouseReadInterface
+    # def mouse_location(self):
+    #     raise NotImplementedError
+    
+    @queue_method(queue)
+    def relative_mouse_location(self, window=None):
+        # if window is None:
+        #     window = self.mediator.windowInterface.get_active_window()
+        
+        raise NotImplementedError
+    
+    @queue_method(queue)
+    def scroll_down(self, number):
+        for i in range(number):
+            self.ui.write(e.EV_REL, e.REL_WHEEL, -1)
+            self.ui.write(e.EV_REL, e.REL_WHEEL_HI_RES, -120)
+            self.syn_raw()
+    
+    @queue_method(queue)
+    def scroll_up(self, number):
+        for i in range(number):
+            self.ui.write(e.EV_REL, e.REL_WHEEL, 1)
+            self.ui.write(e.EV_REL, e.REL_WHEEL_HI_RES, 120)
+            self.syn_raw()
+    
+    @queue_method(queue)
+    def move_cursor(self, xCoord, yCoord, relative=False, relative_self=False):
+        raise NotImplementedError
+        # weirdly I could not find an easier way to do this in a few minutes of searching
+        def sign(val):
+            if val < 0:
+                return -1
+            elif val > 0:
+                return 1
+            else:
+                return 0
+
+        # REL_X - X axis, positive is right, negative is left.
+        # REL_Y - Y axis, positive is down, negative is up.
+        current_x, current_y = self.mouse_location()
+        screen_x, screen_y = self.mediator.windowInterface.get_screen_size()
+        count = 0
+        end_count = 1000
+
+        # check if we can use ABS/REL, currently REL is preferred.
+        rel_mov = self.supports_rel()
+        abs_mov = self.supports_abs()
+
+        while True:
+            # logger.debug("Current X: {}, Current Y: {}".format(current_x, current_y))
+            # logger.debug("X Coord: {}, Y Coord: {}".format(xCoord, yCoord))
+            # logger.debug("current_x == xCoord: {}, current_y == yCoord: {}".format(current_x == xCoord, current_y == yCoord))
+            
+            if current_x == xCoord and current_y == yCoord:
+                break
+            if rel_mov:
+                if current_x < xCoord:
+                    self.ui.write(e.EV_REL, e.REL_X, 1)
+                elif current_x > xCoord:
+                    self.ui.write(e.EV_REL, e.REL_X, -1)
+
+                if current_y < yCoord:
+                    self.ui.write(e.EV_REL, e.REL_Y, 1)
+                elif current_y > yCoord:
+                    self.ui.write(e.EV_REL, e.REL_Y, -1)
+            elif abs_mov:
+                raise NotImplementedError
+                # TODO: Implement ABS movement
+                # I think that if we were able to get the size of the screen we'd be able to more effectively move the mouse here
+                move_x = int(xCoord-current_x/screen_x*65535)*sign(xCoord-current_x)
+                move_y = int(yCoord-current_y/screen_y*65535)*sign(yCoord-current_y)
+
+
+
+                self.ui.write(e.EV_ABS, e.ABS_X, move_x)
+                self.ui.write(e.EV_ABS, e.ABS_Y, move_y)
+
+
+            # self.ui.write(e.EV_REL, e.REL_X, 1)
+            # self.ui.write(e.EV_REL, e.REL_Y, 1)
+            self.syn_raw()
+            current_x, current_y = self.mouse_location()
+
+            count = count+1
+            if count > end_count:
+                break
+
+
+    
+    def send_mouse_click_relative(self, xoff, yoff, button):
+        raise NotImplementedError
+
 
     @queue_method(queue)
     def clear_held_keys(self):
@@ -400,6 +601,16 @@ def __grab_ungrab_all_hotkeys(self, grab=True):
         hotkeys = c.hotKeys + c.hotKeyFolders
 
         for item in hotkeys:
+            if "code" in item.hotKey:
+                #this implies that it is a legacy x11 keycode, should we try to remap?
+                # not sure that this would be possible/practical
+                # need to tell the user this is an issue
+                self.app.show_error_dialog(f"Detected Legacy x11 keycode {item.hotKey} for {item}", )
+                # TODO: for some reason the above will prevent the rest of the application from starting?
+                logger.warning(f"Detected likely invalid hotkey: {item}")
+                #from interface import XK_TO_AK_MAP
+
+                pass
             logger.debug("Hotkey: {}, Modifier: {}".format(item.hotKey, item.modifiers))
 
     def isModifier(self, keyCode):
@@ -430,7 +641,7 @@ def handle_keypress(self, keyCode):
 
     @queue_method(queue)
     def handle_keyrelease(self, keyCode):
-        window_info = self.mediator.windowInterface.get_window_info() #not used
+        window_info = self.mediator.windowInterface.get_window_info()
         event_type = evdev.categorize(keyCode)
         logger.debug("handle_keyrelease: KeyState:{}, Un:{}".format(event_type.keystate, event_type.keycode))
         if self.isModifier(event_type.keycode):
@@ -454,6 +665,9 @@ def __flush_events_loop(self):
     def __flush_events(self):
         r,w,x = select.select(self.devices, [], [])
         for fd in r:
+            if not pathlib.Path(self.devices[fd].path).exists():
+                logger.error("__flush_events: Device {} does not exist.".format(fd))
+                continue
             for event in self.devices[fd].read(): # type: ignore
                 event_type = evdev.categorize(event)
                 held = self.keyboard.active_keys(verbose=True)

From ae672d1bb5cd18bc858b6fe46bc351c46f1d0b68 Mon Sep 17 00:00:00 2001
From: Sam Sebastian <sebastiansam55@gmail.com>
Date: Mon, 28 Aug 2023 08:09:21 -0400
Subject: [PATCH 20/20] update to allow mouse events to be used as hotkeys

---
 lib/autokey/uinput_interface.py | 29 ++++++++++++++++++++++-------
 1 file changed, 22 insertions(+), 7 deletions(-)

diff --git a/lib/autokey/uinput_interface.py b/lib/autokey/uinput_interface.py
index 9589600d..101dca18 100644
--- a/lib/autokey/uinput_interface.py
+++ b/lib/autokey/uinput_interface.py
@@ -147,7 +147,7 @@ class UInputInterface(threading.Thread, GnomeMouseReadInterface, AbstractSysInte
     }
 
     #TODO complete this
-    button_map = {
+    btn_map = {
         Button.LEFT: [e.BTN_LEFT, 0x90001],
         Button.RIGHT: [e.BTN_RIGHT, 0x90002],
         Button.MIDDLE: [e.BTN_MIDDLE, 0x90003],
@@ -158,6 +158,11 @@ class UInputInterface(threading.Thread, GnomeMouseReadInterface, AbstractSysInte
         #8: [e.BTN_BACK, ]
 
     }
+    inv_btn_map = {
+        "BTN_LEFT": Button.LEFT,
+        "BTN_RIGHT": Button.RIGHT,
+        "BTN_MIDDLE": Button.MIDDLE
+    }
 
     queue = queue.Queue()
 
@@ -322,8 +327,8 @@ def validate(self):
     def send_mouse_click(self, xCoord, yCoord, button: Button, relative):
         self.move_cursor(xCoord, yCoord, relative)
 
-        keycode = self.button_map[button][0]
-        scancode = self.button_map[button][1]
+        keycode = self.btn_map[button][0]
+        scancode = self.btn_map[button][1]
 
         self.ui.write(e.EV_MSC, e.MSC_SCAN, scancode)
         self.ui.write(e.EV_KEY, keycode, 1)
@@ -337,8 +342,8 @@ def send_mouse_click(self, xCoord, yCoord, button: Button, relative):
     def mouse_press(self, xCoord, yCoord, button):
         self.move_cursor(xCoord, yCoord)
 
-        keycode = self.button_map[button][0]
-        scancode = self.button_map[button][1]
+        keycode = self.btn_map[button][0]
+        scancode = self.btn_map[button][1]
 
         self.ui.write(e.EV_MSC, e.MSC_SCAN, scancode)
         self.ui.write(e.EV_KEY, keycode, 1)
@@ -348,8 +353,8 @@ def mouse_press(self, xCoord, yCoord, button):
     def mouse_release(self, xCoord, yCoord, button):
         self.move_cursor(xCoord, yCoord)
 
-        keycode = self.button_map[button][0]
-        scancode = self.button_map[button][1]
+        keycode = self.btn_map[button][0]
+        scancode = self.btn_map[button][1]
 
         self.ui.write(e.EV_MSC, e.MSC_SCAN, scancode)
         self.ui.write(e.EV_KEY, keycode, 0)
@@ -867,9 +872,16 @@ def translate_to_evdev(self, key):
         elif len(key) == 1, assume that this is an ascii char, check if "KEY_"+key exists in any of the character maps and process accordingly
         return (0, false)
         """
+        #TODO this could probably do with an optimization pass
         if type(key)==str and "KEY_" in key[:4]: #if it is a "KEY_A" type value return evdev int from map
             # print("Type str")
             return self.inv_map[key], False
+        elif type(key)==list and "BTN_" in key[0][:4]:
+            return self.inv_btn_map[key[0]], False
+        elif type(key)==str and "BTN_" in key[:4]:
+            return self.inv_btn_map[key], False
+        elif type(key)==Button:
+            return self.btn_map[key]
         elif type(key)==int: #if it is type int it should be a evdev raw value
             # print("Type int")
             return key, False
@@ -908,6 +920,9 @@ def lookup_string(self, keyCode, shifted, num_lock, altGrid):
         #TODO handle special keys like backslash etc.
         code, shifted_ = self.translate_to_evdev(keyCode[0])
         evdev_name = e.keys[code]
+        # for mouse buttons this returns a list like ['BTN_LEFT', 'BTN_MOUSE']
+        if type(evdev_name) is list:
+            evdev_name = evdev_name[0]
         # modifiers
         if evdev_name in self.uinput_modifiers_to_ak_map:
             logger.debug("Modifier: {}".format(evdev_name))