Merge pull request #81 from rbreaves/hotfix

- 3 Fixes, ibus install logic, kde-init, display env set

.gitattributes

@@ -0,0 +1,3 @@
+*.py linguist-detectable=false
+*.json liguist-detectable=false
+*.c linguist-detectable=true

.xkb/symbols/mac_gui

@@ -1,32 +1,131 @@
+hidden partial modifier_keys
+xkb_symbols "swapescape" {
+    key <CAPS> { [ Escape ] };
+    key <ESC>  { [ Caps_Lock ] };
+};
 default partial xkb_symbols "mac_levelssym" {
-    // LEFT to Begin Line
+    // LEFT to Begin Line or Beginning of word
     replace key <LEFT> {
         type[Group1]= "ONE_LEVEL_CTRL",
-        symbols[Group1]= [         Left,         Left, NoSymbol ],
-        actions[Group1]= [      NoAction(),      NoAction(), RedirectKey(key=<HOME>,clearmods=Control)]
+        symbols[Group1]= [         Left,         Left, NoSymbol,NoSymbol,Left ],
+        actions[Group1]= [
+            NoAction(),
+            RedirectKey(key=<LEFT>,modifiers=Control,clearmods=Mod1),
+            RedirectKey(key=<HOME>,clearmods=Control),
+            RedirectKey(key=<HOME>,modifiers=Shift,clearmods=Control+Mod1),
+            RedirectKey(key=<LEFT>,modifiers=Shift+Control,clearmods=Mod1)
+        ]
     };
-    // Right to End of Line
+    // Right to End of Line or end of word
     replace key <RGHT> {
         type[Group1]= "ONE_LEVEL_CTRL",
-        symbols[Group1]= [         Right,         Right, NoSymbol ],
-        actions[Group1]= [      NoAction(),      NoAction(), RedirectKey(key=<END>,clearmods=Control)]
+        symbols[Group1]= [         Right,         Right, NoSymbol, NoSymbol,Right ],
+        actions[Group1]= [
+            NoAction(),
+            RedirectKey(key=<RGHT>,modifiers=Control,clearmods=Mod1),
+            RedirectKey(key=<END>,clearmods=Control),
+            RedirectKey(key=<END>,modifiers=Shift,clearmods=Control+Mod1),
+            RedirectKey(key=<RGHT>,modifiers=Shift+Control,clearmods=Mod1)
+        ]
     };
     // Up to Mac Home
     replace key <UP> {
         type[Group1]= "ONE_LEVEL_CTRL",
-        symbols[Group1]= [         Up,         Up, NoSymbol ],
-        actions[Group1]= [      NoAction(),      NoAction(), RedirectKey(key=<HOME>)]
+        symbols[Group1]= [
+            Up,
+            Up,
+            NoSymbol
+        ],
+        actions[Group1]= [
+            NoAction(),
+            NoAction(),
+            RedirectKey(key=<HOME>)
+        ]
     };
     // Down to Mac End
     replace key <DOWN> {
         type[Group1]= "ONE_LEVEL_CTRL",
-        symbols[Group1]= [         Down,         Down, NoSymbol ],
-        actions[Group1]= [      NoAction(),      NoAction(), RedirectKey(key=<END>)]
+        symbols[Group1]= [
+            Down,
+            Down,
+            NoSymbol
+        ],
+        actions[Group1]= [
+            NoAction(),
+            NoAction(),
+            RedirectKey(key=<END>)
+        ]
     };
-    // CTRL BKSP to DELETE
-    // replace key <BKSP> {
-    //    type[Group1]= "TWO_LEVEL_CTRL",
-    //    symbols[Group1]= [       BackSpace,       BackSpace, NoSymbol ],
-    //    actions[Group1]= [      NoAction(),      NoAction(), RedirectKey(key=<DELE>,clearmods=Control)]
+    // Alt BKSP to DELETE
+    replace key <BKSP> {
+       type[Group1]= "ONE_LEVEL_CTRL",
+       symbols[Group1]= [
+           BackSpace,
+           BackSpace,
+           NoSymbol
+       ],
+       actions[Group1]= [
+           NoAction(),
+           RedirectKey(key=<DELE>,clearmods=Mod1),
+           NoAction()
+       ]
+    };
+    // // Full Print Screen
+    // // GalliumOS
+    // replace key <AE03> {
+    //     type[Group1]= "ONE_LEVEL_CTRL",
+    //     symbols[Group1]= [         3,         3, 3, F5 ],
+    //     actions[Group1]= [      NoAction(),      NoAction(), NoAction(), RedirectKey(key=<FK05>,clearmods=Shift) ]
+    // };
+    // // Region Print Screen
+    // // GalliumOS
+    // replace key <AE04> {
+    //     type[Group1]= "ONE_LEVEL_CTRL",
+    //     symbols[Group1]= [         4,         4, 4, F5 ],
+    //     actions[Group1]= [      NoAction(),      NoAction(), NoAction(), RedirectKey(key=<FK05>) ]
+    // };
+    // // Full Print Screen
+    // // Standard Ubuntu
+    // replace key <AE03> {
+    //     type[Group1]= "ONE_LEVEL_CTRL",
+    //     symbols[Group1]= [         3,         3, 3, F5 ],
+    //     actions[Group1]= [      NoAction(),      NoAction(), RedirectKey(key=<PRSC>,clearmods=Shift+Control) ]
+    // };
+    // // Region Print Screen
+    // // Standard Ubuntu
+    // replace key <AE04> {
+    //     type[Group1]= "ONE_LEVEL_CTRL",
+    //     symbols[Group1]= [         4,         4, 4, F5 ],
+    //     actions[Group1]= [      NoAction(),      NoAction(), RedirectKey(key=<PRSC>,clearmods=Control) ]
     // };
 };
+partial xkb_symbols "mac_chrome" {
+    // Back Button
+    replace key <LEFT> {
+        type[Group1]= "ONE_LEVEL_CTRL",
+        symbols[Group1]= [
+            Left,
+            Left,
+            Left
+        ],
+        actions[Group1]= [
+            NoAction(),
+            RedirectKey(key=<UP>),
+            RedirectKey(key=<LEFT>,modifiers=Mod1,clearmods=Control)
+        ]
+    };
+    // Forwards Button
+    replace key <RGHT> {
+        type[Group1]= "ONE_LEVEL_CTRL",
+        symbols[Group1]= [
+            Right,
+            Right,
+            Right
+        ],
+        actions[Group1]= [
+            NoAction(),
+            RedirectKey(key=<DOWN>),
+            RedirectKey(key=<RGHT>,modifiers=Mod1,clearmods=Control)
+        ]
+    };
+};

.xkb/symbols/mac_term

@@ -1,4 +1,4 @@
-default partial xkb_symbols "mac_levelssym" {
+default partial xkb_symbols "mac_apple" {
     key <LWIN> {
       repeat= no,
       type= "ONE_LEVEL",
@@ -11,4 +11,105 @@ default partial xkb_symbols "mac_levelssym" {
       symbols[Group1]= [ Hyper_R ],
       actions[group1]=[ SetMods(modifiers=Shift+Control) ]
     };
+};
+partial xkb_symbols "mac_win" {
+    key <LALT> {
+      repeat= no,
+      type= "ONE_LEVEL",
+      symbols[Group1]= [ Hyper_L ],
+      actions[group1]=[ SetMods(modifiers=Shift+Control) ]
+    };
+    key <RALT> {
+      repeat= no,
+      type= "ONE_LEVEL",
+      symbols[Group1]= [ Hyper_R ],
+      actions[group1]=[ SetMods(modifiers=Shift+Control) ]
+    };
+};
+partial xkb_symbols "mac_global" {
+    // Page Up
+    replace key <UP> {
+        type[Group1]= "ONE_LEVEL_CTRL",
+        symbols[Group1]= [
+        Up,
+        Up,
+        NoSymbol ],
+        actions[Group1]= [
+            NoAction(),
+            NoAction(),
+            RedirectKey(key=<PGUP>,clearmods=Shift+Control)
+        ]
+    };
+    // Page Down
+    replace key <DOWN> {
+        type[Group1]= "ONE_LEVEL_CTRL",
+        symbols[Group1]= [
+            Down,
+            Down,
+            NoSymbol
+        ],
+        actions[Group1]= [
+            NoAction(),
+            NoAction(),
+            RedirectKey(key=<PGDN>,clearmods=Shift+Control)
+        ]
+    };
+    // HOME
+    replace key <LEFT> {
+        type[Group1]= "ONE_LEVEL_CTRL",
+        symbols[Group1]= [
+            Left,
+            Left,
+            NoSymbol
+        ],
+        actions[Group1]= [
+            NoAction(),
+            NoAction(),
+            RedirectKey(key=<HOME>,clearmods=Shift+Control)
+        ]
+    };
+    // END
+    replace key <RGHT> {
+        type[Group1]= "ONE_LEVEL_CTRL",
+        symbols[Group1]= [
+            Right,
+            Right,
+            NoSymbol
+        ],
+        actions[Group1]= [
+            NoAction(),
+            NoAction(),
+            RedirectKey(key=<END>,clearmods=Shift+Control)
+        ]
+    };
+    // Full Print Screen
+    // Standard Ubuntu
+    replace key <AE03> {
+        type[Group1]= "ONE_LEVEL_CTRL",
+        symbols[Group1]= [
+            3,
+            numbersign,
+            NoSymbol
+        ],
+        actions[Group1]= [
+            NoAction(),
+            NoAction(),
+            RedirectKey(key=<PRSC>,clearmods=Shift+Control)
+        ]
+    };
+    // Region Print Screen
+    // Standard Ubuntu
+    replace key <AE04> {
+        type[Group1]= "ONE_LEVEL_CTRL",
+        symbols[Group1]= [
+            4,
+            dollar,
+            NoSymbol
+        ],
+        actions[Group1]= [
+            NoAction(),
+            NoAction(),
+            RedirectKey(key=<PRSC>,clearmods=Control)
+        ]
+    };
 };

.xkb/symbols/mac_term_chromebook

@@ -11,4 +11,90 @@ default partial xkb_symbols "mac_levelssym" {
       symbols[Group1]= [ Hyper_R ],
       actions[group1]=[ SetMods(modifiers=Shift+Control) ]
     };
+    // Page Up
+    replace key <UP> {
+        type[Group1]= "ONE_LEVEL_CTRL",
+        symbols[Group1]= [
+            Up,
+            Up,
+            NoSymbol
+        ],
+        actions[Group1]= [
+            NoAction(),
+            NoAction(),
+            RedirectKey(key=<PGUP>,clearmods=Shift+Control)
+        ]
+    };
+    // Page Down
+    replace key <DOWN> {
+        type[Group1]= "ONE_LEVEL_CTRL",
+        symbols[Group1]= [
+            Down,
+            Down,
+            NoSymbol
+        ],
+        actions[Group1]= [
+            NoAction(),
+            NoAction(),
+            RedirectKey(key=<PGDN>,clearmods=Shift+Control)
+        ]
+    };
+    // HOME
+    replace key <LEFT> {
+        type[Group1]= "ONE_LEVEL_CTRL",
+        symbols[Group1]= [
+            Left,
+            Left,
+            NoSymbol
+        ],
+        actions[Group1]= [
+            NoAction(),
+            NoAction(),
+            RedirectKey(key=<HOME>,clearmods=Shift+Control)
+        ]
+    };
+    // END
+    replace key <RGHT> {
+        type[Group1]= "ONE_LEVEL_CTRL",
+        symbols[Group1]= [
+            Right,
+            Right,
+            NoSymbol
+        ],
+        actions[Group1]= [
+            NoAction(),
+            NoAction(),
+            RedirectKey(key=<END>,clearmods=Shift+Control)
+        ]
+    };
+    // Full Print Screen
+    // GalliumOS
+    replace key <AE03> {
+        type[Group1]= "ONE_LEVEL_CTRL",
+        symbols[Group1]= [
+            3,
+            numbersign,
+            F5
+        ],
+        actions[Group1]= [
+            NoAction(),
+            NoAction(),
+            RedirectKey(key=<FK05>,clearmods=Shift)
+        ]
+    };
+    // Region Print Screen
+    // GalliumOS
+    replace key <AE04> {
+        type[Group1]= "ONE_LEVEL_CTRL",
+        symbols[Group1]= [
+            4,
+            dollar,
+            F5
+        ],
+        actions[Group1]= [
+            NoAction(),
+            NoAction(),
+            RedirectKey(key=<FK05>)
+        ]
+    };
 };

.xkb/types/mac_gui

@@ -1,20 +1,15 @@
 default partial xkb_types "addmac_levels" {
     type "ONE_LEVEL_CTRL" {
-        modifiers= Shift+Control;
-        map[Shift]= Level2;
+        modifiers= Mod1+Control+Shift;
+        map[Mod1]= Level2;
         map[Control]= Level3;
-        map[Shift+Control]= Level3;
+        map[Mod1+Control]= Level3;
+        map[Shift+Control]= Level4;
+        map[Shift+Mod1] = Level5;
         level_name[Level1]= "Base";
-        level_name[Level2]= "Caps";
-        level_name[Level3]= "With Control";
-    };
-    type "TWO_LEVEL_CTRL" {
-        modifiers= Shift+Control;
-        map[Shift]= Level2;
-        map[Control]= Level3;
-        map[Shift+Control]= Level3;
-        level_name[Level1]= "Base";
-        level_name[Level2]= "Caps";
-        level_name[Level3]= "With Control";
+        level_name[Level2]= "Alt";
+        level_name[Level3]= "Control";
+        level_name[Level4]= "Shift with Control";
+        level_name[Level5] = "Shift Alt";
     };
 };

.xkb/types/mac_term

@@ -0,0 +1,10 @@
+default partial xkb_types "addmac_levels" {
+    type "ONE_LEVEL_CTRL" {
+        modifiers= Shift+Control;
+        map[Shift]= Level2;
+        map[Shift+Control]= Level3;
+        level_name[Level1]= "Base";
+        level_name[Level2]= "Alt";
+        level_name[Level3]= "With Control";
+    };
+};

README.md

@@ -1,29 +1,22 @@
 # Kinto
 
+![kinto_carrot](https://user-images.githubusercontent.com/10969616/77842401-4744b500-7157-11ea-854a-d7dec6f9a250.gif)
+
 ![alt text](https://raw.githubusercontent.com/rbreaves/kinto/master/Kinto.png)
 
 [![GitHub release](https://img.shields.io/github/release/rbreaves/kinto.svg)](https://github.com/rbreaves/kinto/releases/latest)
 
-![alt text](https://github.com/rbreaves/kinto/blob/master/splash.png)
-
 \- Type in Linux like it's a Mac. \-
 
-Cmd = Ctrl+Shift for all terminals.
-
-Note: As of version 1.0 Kinto no longer maps Cmd/Alt to Super while using the Terminal, it is now mapping to Ctrl+Shift by default. Please reset your terminal's keymaps back to their defaults.
-
-Gnome-terminal reset
-```
-dconf reset -f /org/gnome/terminal/legacy/keybindings/
-```
+Seamless copy and paste with all apps and terminals. Also the only linux remapper that is aware of your cursor/caret status - meaning it avoids shortcut conflicts within an app versus wordwise shortcuts when a text field is in use.
 
 ## What does this do exactly?
 
 Kinto works for standard Windows, Apple and Chromebook keyboards. The following however describes the dynamic rebinding based on a standard Windows keyboard. (Alt location is Cmd for Apple keyboards)
 
-- Normal apps - Alt will be Ctrl, Win/Super will be Alt, Ctrl will be Win/Super
+- Normal apps - Alt → Ctrl, Win/Super → Alt, Ctrl → Win/Super
 
-- Terminal apps - Alt will be Ctrl+Shift, Win/Super will be Alt, Ctrl will be Ctrl
+- Terminal apps - Alt → Ctrl+Shift, Win/Super → Alt, Ctrl → Ctrl
 
 - Cursor/word-wise shortcut keys have been added to align with macOS keyboard shortcuts.
 
@@ -32,11 +25,14 @@ Kinto works for standard Windows, Apple and Chromebook keyboards. The following
 - Python (initial install only)
 - systemd
 - x11
-- Debian/Ubuntu based distro 16.04+
+- IBus*
+- Fedora/RHEL/Manjaro/Arch/Debian/Ubuntu based distro 16.04+
 
-If you need kintox11 recompiled for your distro please let me know and I will add a binary for your distro if my binary fails.
+Binary is included and will be installed, but you can also compile kintox11.c on your system. You will need to compile and install json-c first as its libraries will be required to compile and run the program.
 
-You can also attempt to compile kintox11.c on your system as well, but you will need to compile and install json-c first as its libraries will be required to compile and run the program.
+*IBus is needed to support wordwise during browser app usage as the keymap will need to change slightly depending if the cursor/caret is on screen waiting for input. Setup.py will set it but you can manually set it as well or check your current Input Method.
+
+On most distros you can confirm navigate to your "Language Support" and set "Keyboard input method system:" to IBus for full word-wise support with web browsers. 
 
 Wayland support is planned, but not ready yet.
 
@@ -59,6 +55,276 @@ sudo apt install python3
 ./setup.py
 ```
 
+To Uninstall Kinto
+
+```
+./uninstall.sh
+```
+
+## Other Notes Related to Install
+
+**Manjaro with Gnome there are issues.** 
+
+Please see this ticket for more information.
+
+https://github.com/rbreaves/kinto/issues/59
+
+https://wiki.archlinux.org/index.php/IBus
+
+**For other Arch based distros.**
+
+Append the following and logoff and back on, but only after running setup.py to install all packages and the kinto service. Please report if there are any difficulties.
+nano ~/.bashrc
+```
+export GTK_IM_MODULE=xim
+export XMODIFIERS=@im=ibus
+export QT_IM_MODULE=xim
+```
+
+## How to Upgrade Kinto
+
+Simply bring down the latest in either the master branch or dev, but dev is sometimes in flux as new features are being developed. Then you can re-run the setup.py installer, it will stop the service and re-install Kinto.
+
+Note: If you have made any custom changes to ~/.xkb or ~/.config/kinto then you will need to backup or rename those directories before running an update.
+
+```
+git pull origin master
+./setup.py
+```
+
+## How to Control Kinto
+
+Under systemd this is how you control Kinto.
+
+Status
+```
+systemctl --user status keyswap
+```
+
+Stop (your keymap will return to normal)
+```
+systemctl --user stop keyswap
+```
+
+Start
+```
+systemctl --user start keyswap
+```
+
+Restart
+```
+systemctl --user restart keyswap
+```
+
+Enable
+```
+systemctl --user enable keyswap
+```
+
+Disable
+```
+systemctl --user disable keyswap
+```
+
+## How to Add Setxkbmap Option inside Kinto
+
+To summarize you'll need to pull the partial out of the symbols file the option resides in and then add that to the mac_gui file and lastly reference it in the keymap file(s) you want it in.
+
+symbols directory
+```
+/usr/share/X11/xkb/symbols/ 
+```
+
+symbols file
+```
+~/.xkb/symbols/mac_gui
+```
+
+keymap files
+```
+~/.xkb/keymap/kbd.mac.gui
+~/.xkb/keymap/kbd.mac.term
+```
+
+A more detailed explaination is here.
+https://github.com/rbreaves/kinto/issues/50#issuecomment-595953373
+
+## How to Add or Change keymaps for Applications
+
+Note: All of the following is already done in Kinto (but may also change as improvements are made). The following is purely for documentation and example sake as they are real examples of how to leverage the json config to support additional keymaps.
+
+**First it is important to understand how Kinto operates.**
+
+1. It listens for any focus/active window changes
+2. It applies the proper keymap based on the programs name.
+3. It may monitor your caret/cursor input status, if the app is known to cause shortcut conflicts with wordwise
+4. It runs anywhere from 1 to 3 commands to fully remap your computer.
+
+Ok great, we've covered the basics, now what are your options on modifying functionality?
+It depends.
+
+Do you want to remap keys using xkb or xbindkeys with xdotool, or something else entirely?
+The choice is yours, but I'd recommend xbindkeys with xdotool for anyone that doesn't want to spend the time or learn xkb. I prefer xkb but it completely remaps your keyboard and it could break things if done poorly.
+
+**How to Remap using XBindKeys with Xdotool - Firefox**
+
+1. By default Firefox is mapped with the standard gui based xkb config, and only if no input has focus does it then run xbindkeys to map the Cmd+Left/Right arrow key location to the Back and Forwards functionality you'd expect.
+
+2. The xbindkeys script takes into account the xkb mapping being the base because it is actually remapping Home and End to Back and Forwards as there is no real reason to reload an entire xkb layout.
+
+~/.config/kinto/user_config.json
+```
+...
+{
+    "name": "firefox",
+    "run": "setxkbmap -option;xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.gui $DISPLAY",
+    "run_onInput": "killall xbindkeys > /dev/null 2>&1",
+    "run_offInput": "killall xbindkeys > /dev/null 2>&1;xbindkeys -f $HOME/.config/kinto/.firefox-nw",
+    "symbols": "",
+    "types": "",
+    "de": [
+	2
+    ],
+    "appnames": [
+	"Firefox"
+    ]
+},
+...
+```
+~/.config/kinto/.firefox-nw
+```
+"xdotool key --delay 0 --clearmodifiers Control_L+bracketleft"
+  // Alt/Cmd + Left
+  Home + Release
+
+"xdotool key --delay 0 --clearmodifiers Control_L+bracketright"
+  // Alt/Cmd + Right
+  End + Release
+  
+# Note additional keymaps can easily be added to this file and I will accept any PR's with keymaps that align with macs
+```
+
+Once you have made your changes you can restart the Kinto service and the changes will take affect.
+```
+systemctl --user restart keyswap
+```
+
+Under normal circumstances this keymap would not have worked well had Firefox not included 2 keymap options for going forwards or back. In the next example, Chrome, you will see how to solve this very same problem but in xkb format and it is the only way to fix it for Chrome due to conflicting with wordwise shortcuts.
+
+Also the choice of xdotool over something like xte (xautomation) was explicit, xdotool allows you to hold down a modifier and continue to repeat the action(s) and xte does not.
+
+**How to Remap Using XKB - Chrome**
+
+This gets to be a little more complicated, but this is what you have to do to accomplish the same on the xkb level.
+
+**Summary**
+1. Copy ~/.xkb/keymap/kbd.mac.gui and append the name of the app. (e.g. chrome)
+2. Edit ~/.xkb/keymap/kbd.mac.gui.chrome
+3. Add new keybindings to ~/.xkb/symbols/mac_gui
+4. Only edit types if you absolutely need to add another modifier level (~/.xkb/types/mac_gui)
+
+Understand that as you add or modify the ~/.xkb/symbols/ files that these two groups **symbols[Group1]** and **actions[Group1]** will be following the order of the modifier levels that are configured in the related ~/.xkb/types/mac_gui or mac_term file.
+
+Also you will have to discover the proper xkb names for keys and that they will often follow *two different* labels/names. eg RGHT vs Right ... **replace key \<RGHT\>** vs **symbols[Group1]= [ Right, ...**.
+
+A good place to get the proper names/labels are these two files.
+```
+/usr/share/X11/xkb/symbols/us
+/usr/share/X11/xkb/symbols/inet
+```
+
+Ok, so here are the detailed instructions.
+
+1. cp ~/.xkb/keymap/kbd.mac.gui ~/.xkb/keymap/kbd.mac.gui.chrome
+
+2. nano ~/.xkb/keymap/kbd.mac.gui.chrome
+```
+# Change mac_gui(mac_levelssym)
+...
+xkb_symbols   { include "pc+us+us:2+inet(evdev)+ctrl(swap_lwin_lctl)+ctrl(swap_rwin_rctl)+mac_gui(mac_levelssym)"	};
+...
+# To +mac_gui(mac_chrome)
+xkb_symbols   { include "pc+us+us:2+inet(evdev)+ctrl(swap_lwin_lctl)+ctrl(swap_rwin_rctl)+mac_gui(mac_chrome)"	};
+...
+};
+```
+
+3. Add your new "partial xkb_symbols" via nano ~/.xkb/symbols/mac_gui
+```
+partial xkb_symbols "mac_chrome" {
+    // Back Button
+    replace key <LEFT> {
+        type[Group1]= "ONE_LEVEL_CTRL",
+        symbols[Group1]= [
+            Left,
+            Left,
+            Left
+        ],
+        actions[Group1]= [
+            NoAction(),
+            RedirectKey(key=<UP>),
+            RedirectKey(key=<LEFT>,modifiers=Mod1,clearmods=Control)
+        ]
+    };
+    // Forwards Button
+    replace key <RGHT> {
+        type[Group1]= "ONE_LEVEL_CTRL",
+        symbols[Group1]= [
+            Right,
+            Right,
+            Right
+        ],
+        actions[Group1]= [
+            NoAction(),
+            RedirectKey(key=<DOWN>),
+            RedirectKey(key=<RGHT>,modifiers=Mod1,clearmods=Control)
+        ]
+    };
+```
+
+~/.config/kinto/user_config.json
+```
+{
+    "name": "chrome",
+    "run": "setxkbmap -option;xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.gui.chrome $DISPLAY",
+    "run_onInput": "xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.gui $DISPLAY",
+    "run_offInput": "xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.gui.chrome $DISPLAY",
+    "symbols": "",
+    "types": "",
+    "de": [
+	2
+    ],
+    "appnames": [
+	"Chromium",
+	"Chromium-browser",
+	"Google-chrome"
+    ]
+}
+```
+4. Not making changes to types but it looks like this. It contains 5 levels of modifiers, Base, Alt, Control, Shift+Control, and Shift+Alt. Additional Levels can and may be added later, but please do not change the order of the Levels or existing symbols files will break!! You can add new levels however without issue.
+```
+default partial xkb_types "addmac_levels" {
+    type "ONE_LEVEL_CTRL" {
+        modifiers= Mod1+Control+Shift;
+        map[Mod1]= Level2;
+        map[Control]= Level3;
+        map[Mod1+Control]= Level3;
+        map[Shift+Control]= Level4;
+        map[Shift+Mod1] = Level5;
+        level_name[Level1]= "Base";
+        level_name[Level2]= "Alt";
+        level_name[Level3]= "Control";
+        level_name[Level4]= "Shift with Control";
+        level_name[Level5] = "Shift Alt";
+    };
+};
+```
+
+Once you have made your changes you can restart the Kinto service and the changes will take affect.
+```
+systemctl --user restart keyswap
+```
+
 ## JSON config files
 
 Features
@@ -70,20 +336,51 @@ Located at ~/.config/kinto/ you will find user_config.json which will look like
 You can also add additional Desktop Environment related tweaks to user_config.json in the install directory as well and the installer will prompt you to install them. You may also fork and submit any json or additional .xkb configurations to me for approval if you believe it makes Linux more like typing on a Mac.
 
 ```
-{"config":[{
+{"config":[
+	//
+	// Each config category contains the category name, and references to the de tweaks
+	// And contains the default run commands plus what behavior they should exhibit for
+	// input fields on/off focus, if any.
+	// Symbols and types are not currently used - may later replace the need for static
+	// files with xkbcomp.
+	//
+	// If you use xbindkeys outside of Kinto then you may want to remove xbindkeys from
+	// this config after setup or rewrite the command to exclude your own xbindkeys.
+	//
+	{
 		"name":"gui",
 		"run":"setxkbmap -option;xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.gui $DISPLAY",
 		"de":[2],
+		"appnames":[ "" ],
+		"run_onInput":"",
+		"run_offInput": "killall xbindkeys > /dev/null 2>&1",
+		"symbols":"",
+		"types":"",
+		"de":[],
 		"appnames":[ "" ]
 	},
 	{
 		"name":"term",
 		"run":"setxkbmap -option;xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.term $DISPLAY",
 		"de":[2],
-		"appnames":[ "Gnome-terminal","konsole","io.elementary.terminal","terminator","sakura","guake","tilda","xterm","eterm" ]
+		"appnames":[ "Gnome-terminal","konsole","io.elementary.terminal","terminator","sakura","guake","tilda","xterm","eterm" ],
+		"run_onInput":"",
+		"run_offInput": "killall xbindkeys > /dev/null 2>&1",
+		"symbols":"",
+		"types":"",
+		"de":[],
+		"appnames":[ "" ]
 	}],
+	// Init - Array that references de objects by their ID and runs the "run" command
+	// when the app initially runs.
 	"init": [1],
+	// detypes - DE's with support or planned support
 	"detypes":["gnome2","gnome3","kde4","kde5","xfce","i3wm"],
+	// de - tweak objects and initial command to be ran on start.
+	//
+	//    Intent - init or gui_term, to signify what type of tweak it is.
+	//      run, run_term, run_gui - run is only relevant for init, and the
+	//      other two relate to gui_term and running under those modes.
 	"de":[{
 		"id": 1,
 		"type": ["gnome3"],
@@ -120,40 +417,6 @@ You can also add additional Desktop Environment related tweaks to user_config.js
 }
 ```
 
-## How to Control Kinto
-
-Under systemd this is how you control Kinto.
-
-Status
-```
-systemctl --user status keyswap
-```
-
-Stop
-```
-systemctl --user stop keyswap
-```
-
-Start
-```
-systemctl --user start keyswap
-```
-
-Restart
-```
-systemctl --user restart keyswap
-```
-
-Enable
-```
-systemctl --user enable keyswap
-```
-
-Disable
-```
-systemctl --user disable keyswap
-```
-
 ## Learning macOS style hotkeys on Linux
 
 You can use websites like https://www.shortcutfoo.com in Google Chrome while using the terminal style keymap, but Firefox is not compatible due to detecting "cmd" as keycode 224. Chrome detects Win/Super/Cmd as keycode 91 on all OS's.
@@ -165,19 +428,59 @@ systemctl --user stop keyswap && setxkbmap -option;setxkbmap -option altwin:swap
 
 ## Troubleshooting
 
+### Does not start when you log in or after you reboot?
+
+1. Check the status
+```
+systemctl --user status keyswap
+```
+2. Check the service journal
+```
+journalctl --user-unit=keyswap.service -b
+```
+
+You may need to manually set your DISPLAY in the systemd service file. Normally it pulls in the proper DISPLAY value but if it doesn't you can try this.
+
+```
+echo $DISPLAY
+
+# :0.0
+```
+
+nano ~/.config/systemd/user/keyswap.service
+```
+...
+[Service]
+Type=simple
+Restart=always
+Environment=DISPLAY=:0.0
+...
+```
+
+If you continue to have issues then open a ticket and send me the info.
+
 ### Keyswap is not occurring, but it was working.
 
 Now that Kinto is using a custom written C program I am not aware of any specific bugs or issues, but you can start here if you having difficulties and please report it if it is reproducible.
-
-1. Restart Kinto
+1. Get status
+```
+systemctl --user status keyswap
+```
+2. Restart Kinto
 ```
 systemctl --user restart keyswap
 ```
-2. Check the Status of Kinto and open a ticket with the output.
+3. Check the Status again and open a ticket if you need to.
 ```
 systemctl --user status keyswap
 ```
 
+You can also do the following to see if it is an actual issue with kintox11 not running or your service file.
+```
+cd ~/.config/kinto
+./kintox11
+```
+
 ## Language Support
 I'd appreciate any help from people with non-US based keyboards, to help ensure that these keymaps and keyswap methods work in all or most languages.
 
@@ -194,8 +497,28 @@ https://superuser.com/questions/385748/binding-superc-superv-to-copy-and-paste
 
 ## More information about Kinto
 
+https://medium.com/@benreaves/kinto-v1-0-released-2018e6401d2e
 https://medium.com/@benreaves/kinto-a-mac-inspired-keyboard-mapping-for-linux-58f731817c0
 
 ## License
 
 GPL v2
+
+## Credits and Contributions
+
+I would just like to thank a few people here directly that have helped me tremendously with completing this project and without their support, direct, indirect or otherwise I would have had difficulty completing this undertaking. I will list these things off in chronological order mostly.
+
+First off I'd like to thank the Stackoverflow and Stackexchange community. I have probably rubbed some mods the wrong way over there, but the people from the community in general are extremely helpful and gracious and without their contributions would have made this much more difficult. The person I'd like to thank most though from over there is Glen Whitney. Without his detailed explaining of how to rebind keys in xkb this would not have come together at all, as every other remapping solution were non-starters as complexity increases.
+
+Secondarily I'd like to thank Christian Eriksson*, as he provided information that kept me up at night.. literally. Even after I implemented a similar bash script to one he had suggested I knew that fully implementing a c/c++ solution was where Kinto needed to head to and his explaination was better than I remember it being now that I have gone back to read it again. He also never provided a full implementation of a c/c++ solution - he did hit on the pain points pretty well of what one would need to do and watch out for. I am not sure where I got the first example code of implementing a c based solution, but he definitely went over it well.
+
+
+Kui and his gist file** was really the c based solution that I found had the fewest issues to resolve to making it a reliable solution. It didn't account for all failures very well, aka BadWindow issues, but it made for a great foundation on which Kintox11 is built. I cannot thank him enough for putting it out there for others to work with.
+
+Lastly these four people were also very helpful to me as well. @probonopd for being one of the first people to install and use Kinto and gave me the initial feedback to include wordwise support! He also has really great articles*** posted on HackerNews & Medium about UI/UX design. Another person I'd like to thank is @owzim, his feedback allowed me to rapidly iterate and fix several bugs to support additional platforms better. The last two are members of the #ubuntu channel in IRC on freenode, tarzeau ( @alexmyczko ) and sarnold. Alex contributing a proper Makefile, so the project can be packaged properly, and sarnold help me find that IBus could resolve an issue I was having with needing to detect the caret status.
+
+If I left anyone out then I apologize, that was not intentional. I am happy to say that this project is at a state of completion. Bug fixes will primarily be the only activity happening going forward and possibly a rewrite for Wayland at some point. Contributions as mentioned above are welcomed, and will be merged into master if they help with the goal of making typing on linux more like a mac.
+
+*https://askubuntu.com/questions/1010276/can-i-act-on-the-event-that-a-window-opens-without-polling
+**https://gist.github.com/kui/2622504
+***https://medium.com/@probonopd/make-it-simple-linux-desktop-usability-part-1-5fa0fb369b42

defaults.json

@@ -9,39 +9,39 @@
 		"type":"windows",
 		"active": false,
 		"description":"Standard Windows 104 Keyboards",
-		"gui":"setxkbmap -option;xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.gui $DISPLAY",
-		"term":"setxkbmap -option;xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.term $DISPLAY",
+		"gui":"xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.gui $DISPLAY 2>&1 | grep -v XF86FullScreen",
+		"term":"xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.term $DISPLAY 2>&1 | grep -v XF86FullScreen",
 		"xkb_symbols_gui":"+altwin(ctrl_alt_win)+mac_gui(mac_levelssym)",
-		"xkb_symbols_term":"+altwin(swap_alt_win)+mac_term(mac_levelssym)",
+		"xkb_symbols_term":"+altwin(swap_alt_win)+mac_term(mac_win)+mac_term(mac_global)",
 		"xkb_types_gui":"+mac_gui(addmac_levels)",
-		"xkb_types_term":""
+		"xkb_types_term":"+mac_term(addmac_levels)"
 	},
 	{
 		"id": 2,
-		"name":"Mac - hid driver",
+		"name":"Mac - hid driver (Recommended - Also supports Windows keyboards)",
 		"type":"mac",
 		"active": false,
 		"description":"Standard Mac Keyboards with Apple driver",
-		"gui":"setxkbmap -option;xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.gui $DISPLAY",
-		"term":"setxkbmap -option;xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.term $DISPLAY",
+		"gui":"xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.gui $DISPLAY 2>&1 | grep -v XF86FullScreen",
+		"term":"xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.term $DISPLAY 2>&1 | grep -v XF86FullScreen",
 		"xkb_symbols_gui":"+altwin(ctrl_alt_win)+mac_gui(mac_levelssym)",
-		"xkb_symbols_term":"+altwin(swap_alt_win)+mac_term(mac_levelssym)",
+		"xkb_symbols_term":"+altwin(swap_alt_win)+mac_term(mac_win)+mac_term(mac_global)",
 		"xkb_types_gui":"+mac_gui(addmac_levels)",
-		"xkb_types_term":"",
+		"xkb_types_term":"+mac_term(addmac_levels)",
 		"hack": "echo '1' | sudo tee -a /sys/module/hid_apple/parameters/swap_opt_cmd;echo 'options hid_apple swap_opt_cmd=1' | sudo tee -a /etc/modprobe.d/hid_apple.conf;sudo update-initramfs -u -k all"
 	},
 	{
 		"id": 3,
-		"name":"Mac Only",
+		"name":"Mac Only (VMs & non-official Apple keyboards)",
 		"type":"mac",
 		"active": true,
 		"description":"Standard Mac Keyboards",
-		"gui":"setxkbmap -option;xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.gui $DISPLAY",
-		"term":"setxkbmap -option;xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.term $DISPLAY",
+		"gui":"xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.gui $DISPLAY 2>&1 | grep -v XF86FullScreen",
+		"term":"xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.term $DISPLAY 2>&1 | grep -v XF86FullScreen",
 		"xkb_symbols_gui":"+ctrl(swap_lwin_lctl)+ctrl(swap_rwin_rctl)+mac_gui(mac_levelssym)",
-		"xkb_symbols_term":"+altwin(alt_super_win)+mac_term(mac_levelssym)",
+		"xkb_symbols_term":"+altwin(alt_super_win)+mac_term(mac_apple)+mac_term(mac_global)",
 		"xkb_types_gui":"+mac_gui(addmac_levels)",
-		"xkb_types_term":""
+		"xkb_types_term":"+mac_term(addmac_levels)"
 	},
 	{
 		"id": 4,
@@ -49,12 +49,12 @@
 		"type":"chromebook",
 		"active": false,
 		"description":"Standard Chromebook Keyboards",
-		"gui":"setxkbmap -option;xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.chromebook.gui $DISPLAY",
-		"term":"setxkbmap -option;xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.term $DISPLAY",
+		"gui":"xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.gui $DISPLAY 2>&1 | grep -v XF86FullScreen",
+		"term":"xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.term $DISPLAY 2>&1 | grep -v XF86FullScreen",
 		"xkb_symbols_gui":"+chromebook(swap_lalt_lctrl)+mac_gui(mac_levelssym)",
 		"xkb_symbols_term":"+altwin(swap_alt_win)+mac_term_chromebook(mac_levelssym)",
 		"xkb_types_gui":"+mac_gui(addmac_levels)",
-		"xkb_types_term":""
+		"xkb_types_term":"+mac_term(addmac_levels)"
 	},
 	{
 		"id": 5,
@@ -62,13 +62,13 @@
 		"type":"chromebook",
 		"active": false,
 		"description":"Chromebook with Windows 104 Keyboard",
-		"gui":"setxkbmap -option;xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.chromebook.gui $DISPLAY; setxkbmap -device $usbid -option altwin:ctrl_alt_win",
-		"term":"setxkbmap -option;xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.term $DISPLAY",
-		"fallbackgui":"setxkbmap -option;xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.chromebook.gui $DISPLAY",
+		"gui":"xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.gui $DISPLAY 2>&1 | grep -v XF86FullScreen; setxkbmap -device $usbid -option altwin:ctrl_alt_win",
+		"term":"xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.term $DISPLAY 2>&1 | grep -v XF86FullScreen",
+		"fallbackgui":"xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.gui $DISPLAY 2>&1 | grep -v XF86FullScreen",
 		"xkb_symbols_gui":"+chromebook(swap_lalt_lctrl)+mac_gui(mac_levelssym)",
 		"xkb_symbols_term":"+altwin(swap_alt_win)+mac_term_chromebook(mac_levelssym)",
 		"xkb_types_gui":"+mac_gui(addmac_levels)",
-		"xkb_types_term":""
+		"xkb_types_term":"+mac_term(addmac_levels)"
 	},
 	{
 		"id": 6,
@@ -76,11 +76,11 @@
 		"type":"chromebook",
 		"active": false,
 		"description":"Chromebook with Mac Keyboard",
-		"gui":"setxkbmap -option;setxkbmap -option ctrl:swap_lwin_lctl; xkbcomp -w0 -i $internalid -I$HOME/.xkb ~/.xkb/keymap/kbd.chromebook.gui $DISPLAY",
-		"term":"setxkbmap -option;xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.term $DISPLAY",
+		"gui":"setxkbmap -option ctrl:swap_lwin_lctl; xkbcomp -w0 -i $internalid -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.gui $DISPLAY 2>&1 | grep -v XF86FullScreen",
+		"term":"xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.term $DISPLAY 2>&1 | grep -v XF86FullScreen",
 		"xkb_symbols_gui":"+chromebook(swap_lalt_lctrl)+mac_gui(mac_levelssym)",
 		"xkb_symbols_term":"+altwin(swap_alt_win)+mac_term_chromebook(mac_levelssym)",
 		"xkb_types_gui":"+mac_gui(addmac_levels)",
-		"xkb_types_term":""
+		"xkb_types_term":"+mac_term(addmac_levels)"
 	}]
 }

keyswap_service.sh

@@ -1,13 +1,26 @@
 #!/bin/bash
 
-swapcmd="\/bin\/bash\ \/home\/`whoami`\/.config\/kinto\/xactive.sh"
+systemctl --user stop keyswap >/dev/null 2>&1
+systemctl --user disable keyswap >/dev/null 2>&1
+systemctl --user stop keyswap.timer >/dev/null 2>&1
+systemctl --user disable keyswap.timer >/dev/null 2>&1
 mkdir -p ~/.config/systemd/user
 mkdir -p ~/.config/autostart
 cp ./system-config/keyswap.service ~/.config/systemd/user/keyswap.service
-cp ./system-config/keyswap.sh ~/.config/autostart/keyswap.sh
+cp ./system-config/kinto.desktop ~/.config/autostart/kinto.desktop
+cp ./system-config/keyswap.timer ~/.config/systemd/user/keyswap.timer
 cp ./kintox11/binary/kintox11 ~/.config/kinto/kintox11
 cp ./system-config/xactive.sh ~/.config/kinto/xactive.sh
+cp ./system-config/caret_status.sh ~/.config/kinto/caret_status.sh
+cp ./system-config/cleanup.sh ~/.config/kinto/cleanup.sh
+cp ./system-config/.firefox-nw ~/.config/kinto/.firefox-nw
 sed -i "s/{username}/`whoami`/g" ~/.config/systemd/user/keyswap.service
+sed -i "s/{displayid}/`echo "$DISPLAY"`/g" ~/.config/systemd/user/keyswap.service
+# if [ "${#DISPLAY}" -gt 2 ]
+# 	then
+sed -i "s/#Environment/Environment/g" ~/.config/systemd/user/keyswap.service
+# fi
+systemctl --user daemon-reload
 sed -i "s/ExecStart=/ExecStart=${swapcmd}/g" ~/.config/systemd/user/keyswap.service
-systemctl --user enable keyswap
-systemctl --user start keyswap
+systemctl --user enable keyswap.timer
+systemctl --user start keyswap.timer

kintopy/kinto.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python
+#
+# Kinto - Python implementation of Xlib
+#
+# Based on code by Stephan Sokolow
+# Source: https://gist.github.com/ssokolow/e7c9aae63fb7973e4d64cff969a78ae8
+from contextlib import contextmanager
+import Xlib
+import Xlib.display
+
+# Connect to the X server and get the root window
+disp = Xlib.display.Display()
+root = disp.screen().root
+
+# Prepare the property names we use so they can be fed into X11 APIs
+NET_ACTIVE_WINDOW = disp.intern_atom('_NET_ACTIVE_WINDOW')
+NET_WM_NAME = disp.intern_atom('_NET_WM_NAME')  # UTF-8
+WM_NAME = disp.intern_atom('WM_NAME')           # Legacy encoding
+NET_WM_CLASS = disp.intern_atom('_NET_WM_CLASS')  # UTF-8
+WM_CLASS = disp.intern_atom('WM_CLASS')
+
+last_seen = { 'xid': None, 'title': None }
+
+@contextmanager
+def window_obj(win_id):
+    """Simplify dealing with BadWindow (make it either valid or None)"""
+    window_obj = None
+    if win_id:
+        try:
+            window_obj = disp.create_resource_object('window', win_id)
+        except Xlib.error.XError:
+            pass
+    yield window_obj
+
+def get_active_window():
+    """Return a (window_obj, focus_has_changed) tuple for the active window."""
+    win_id = root.get_full_property(NET_ACTIVE_WINDOW,Xlib.X.AnyPropertyType).value[0]
+
+    focus_changed = (win_id != last_seen['xid'])
+    if focus_changed:
+        with window_obj(last_seen['xid']) as old_win:
+            if old_win:
+                old_win.change_attributes(event_mask=Xlib.X.NoEventMask)
+
+        last_seen['xid'] = win_id
+        with window_obj(win_id) as new_win:
+            if new_win:
+                new_win.change_attributes(event_mask=Xlib.X.PropertyChangeMask)
+
+    return win_id, focus_changed
+
+def _get_window_class_inner(win_obj):
+    for atom in (NET_WM_CLASS, WM_CLASS):
+        try:
+            window_class = win_obj.get_full_property(atom, 0)
+
+        except UnicodeDecodeError:  # Apparently a Debian distro package bug
+            title = "<could not decode characters>"
+        else:
+            if window_class:
+                win_class = window_class.value.split('\x00')[1]
+                if isinstance(win_class, bytes):
+                    # Apparently COMPOUND_TEXT is so arcane that this is how
+                    # tools like xprop deal with receiving it these days
+                    win_class = win_class.split('\x00')[1].decode('latin1', 'replace')
+                return win_class
+            else:
+                title = "<unnamed window>"
+
+    return "{} (XID: {})".format(title, win_obj.id)
+
+def get_window_class(win_id):
+    """Look up the window name for a given X11 window ID"""
+    if not win_id:
+        last_seen['title'] = "<no window id>"
+        return last_seen['title']
+
+    title_changed = False
+    with window_obj(win_id) as wobj:
+        if wobj:
+            win_title = _get_window_class_inner(wobj)
+            title_changed = (win_title != last_seen['title'])
+            last_seen['title'] = win_title
+
+    return last_seen['title'], title_changed
+
+def handle_xevent(event):
+    # Loop through, ignoring events until we're notified of focus/title change
+    if event.type != Xlib.X.PropertyNotify:
+        return
+
+    changed = False
+    if event.atom == NET_ACTIVE_WINDOW:
+        if get_active_window()[1]:
+            changed = changed or get_window_class(last_seen['xid'])[1]
+    elif event.atom in (NET_WM_CLASS, WM_CLASS):
+        changed = changed or get_window_class(last_seen['xid'])[1]
+
+    if changed:
+        handle_change(last_seen)
+
+def handle_change(new_state):
+    """Replace this with whatever you want to actually do"""
+    print(new_state['title'])
+
+if __name__ == '__main__':
+    # Listen for _NET_ACTIVE_WINDOW changes
+    root.change_attributes(event_mask=Xlib.X.PropertyChangeMask)
+
+    # Prime last_seen with whatever window was active when we started this
+    get_window_class(get_active_window()[0])
+    handle_change(last_seen)
+
+    while True:  # next_event() sleeps until we get an event
+        handle_xevent(disp.next_event())

kintox11/src/Makefile

@@ -0,0 +1,5 @@
+CFLAGS=-g $(shell pkg-config --cflags json-c xmu)
+LDFLAGS=-g $(shell pkg-config --libs json-c xmu)
+
+all:
+	$(CC) kintox11.c $(CFLAGS) $(LDFLAGS) -lm -o kintox11

kintox11/src/kintox11.c

@@ -10,7 +10,7 @@
 //
 // To compile with static library json-c 
 // Make sure archive with object files exist ar -t /usr/local/lib/libjson-c.a
-// gcc -L/usr/local/lib/ kintox11.c -ljson-c -lXmu -lXt -lX11 -o kintox11
+// gcc -L/usr/local/lib/ kintox11.c -ljson-c -lXmu -lXt -lX11 -O2 -o kintox11
 //
 
 #include <stdlib.h>
@@ -18,12 +18,103 @@
 #include <locale.h>
 #include <string.h>
 #include <ctype.h>
+#include <unistd.h>
 #include <X11/Xlib.h>           // `apt-get install libx11-dev`
 #include <X11/Xmu/WinUtil.h>    // `apt-get install libxmu-dev`
 #include <json-c/json.h>        // `apt install libjson-c-dev`
+#include <sys/select.h>
+#include <math.h>
+#include <sys/time.h>
+
+long long timeInMilliseconds(void) {
+    struct timeval tv;
+
+    gettimeofday(&tv,NULL);
+    return (((long long)tv.tv_sec)*1000)+(tv.tv_usec/1000);
+}
+
+static int wait_fd(int fd, double seconds)
+{
+  struct timeval tv;
+  fd_set in_fds;
+  FD_ZERO(&in_fds);
+  FD_SET(fd, &in_fds);
+  tv.tv_sec = trunc(seconds);
+  tv.tv_usec = (seconds - trunc(seconds))*1000000;
+  return select(fd+1, &in_fds, 0, 0, &tv);
+}
+
+int XNextEventTimeout(Display *d, XEvent *e, double seconds, long long event_ts, int last_event, long long *event_ts_ptr, int *last_event_ptr)
+{
+  if (XPending(d) || wait_fd(ConnectionNumber(d),seconds)) {
+      while (1) {
+        XNextEvent(d, e);
+
+        long long int new_ts = timeInMilliseconds();
+
+        // Make sure window dragging or resizing is not occuring
+        if(!(e->type == 22 && (e->type == last_event) && timeInMilliseconds()-event_ts < 419)){
+          *event_ts_ptr = new_ts;
+          *last_event_ptr = e->type;
+          break;
+        }
+        *event_ts_ptr = new_ts;
+        *last_event_ptr = e->type;
+      }
+      return 0;
+  } else {
+      return 1;
+  }
+}
 
 Bool xerror = False;
 
+char *trimwhitespace(char *str)
+{
+  char *end;
+  // Trim leading space
+  while(isspace((unsigned char)*str)) str++;
+  if(*str == 0)  // All spaces?
+    return str;
+  // Trim trailing space
+  end = str + strlen(str) - 1;
+  while(end > str && isspace((unsigned char)*end)) end--;
+  // Write new null terminator character
+  end[1] = '\0';
+  return str;
+}
+
+int check_caret()
+{
+  int caretint;
+  char * fpname;
+  fpname = malloc(sizeof(char)*20);
+  strcpy(fpname,"/tmp/kinto/caret");
+  if( access( fpname, F_OK ) != -1 ) {
+    char *buffer = NULL;
+    size_t size = 0;
+    FILE *fp = fopen(fpname, "r");
+    fseek(fp, 0, SEEK_END);
+    size = ftell(fp);
+    rewind(fp);
+    buffer = malloc((size + 1) * sizeof(*buffer));
+    fread(buffer, size, 1, fp);
+    buffer[size] = '\0';
+    trimwhitespace(buffer);
+    caretint = atoi(buffer);
+    if(caretint == 1){
+      // printf("caret: %s\n", buffer);
+      return 1;
+    }
+    // printf("found nothing\n");
+    return 0;
+  }
+  else{
+    // printf("file %s does not exist\n",fpname);
+    return 0;
+  }
+}
+
 int in_int(int a[],int size,int item) 
 { 
     int i,pos=-1; 
@@ -58,19 +149,30 @@ int strcicmp(char const *a, char const *b)
 }
 
 Display* open_display(){
+  int i;
   Display* d = XOpenDisplay(NULL);
+  for (i = 0; i < 60; i++) {
+    if(d == NULL){
+      printf("fail to open X server display...\n");
+    }
+    else{
+      break;
+    }
+    sleep(1);
+  }
   if(d == NULL){
-    printf("fail to open X server display...\n");
+    printf("fail to open X server display for 1 minute...\n");
+    printf("Kintox11 is now exiting...\n");
     exit(1);
   }
   return d;
 }
 
 int handle_error(Display* display, XErrorEvent* error){
-  // printf("X11 error: type=%d, serial=%lu, code=%d\n",
-  //   error->type, error->serial, (int)error->error_code);
-  // xerror = True;
-  return 0;
+  printf("X11 error: type=%d, serial=%lu, code=%d\n",
+    error->type, error->serial, (int)error->error_code);
+  xerror = True;
+  return 1;
 }
 
 Window get_focus_window(Display* d){
@@ -88,6 +190,54 @@ Window get_focus_window(Display* d){
   return w;
 }
 
+// get the top window.
+// a top window have the following specifications.
+//  * the start window is contained the descendent windows.
+//  * the parent window is the root window.
+Window get_top_window(Display* d, Window start, int etype, int last_event, char const *current_app){
+  Window w = start;
+  Window parent = start;
+  Window root = None;
+  Window *children;
+  unsigned int nchildren;
+  Status s;
+
+  // Checking for Destroy and Unmap Notify events here too
+  // Sometimes they still get passed through and if so need
+  // to be ignored or XQueryTree will cause a segmentation fault
+  while (parent != root && parent != 0 && !(etype == 17 || etype == 18)) {
+    w = parent;
+
+    s = XQueryTree(d, w, &root, &parent, &children, &nchildren); // see man
+
+    if (s)
+      XFree(children);
+
+    if(xerror){
+      printf("fail to get top window: %ld, e.type: %d, last_event: %d, current_app: %s\n",w,etype,last_event, current_app);
+      break;
+    }
+
+    // printf("  get parent (window: %d)\n", (int)w);
+  }
+
+  // printf("success (window: %d)\n", (int)w);
+  // printf("hello\n");
+
+  return w;
+}
+
+// search a named window (that has a WM_STATE prop)
+// on the descendent windows of the argment Window.
+Window get_named_window(Display* d, Window start){
+  Window w;
+  // printf("getting named window ... ");
+  w = XmuClientWindow(d, start); // see man
+  // if(w == start)
+  //   printf("fail\n");
+  // printf("success (window: %d)\n", (int) w);
+  return w;
+}
 
 const char * str_window_class(Display* d, Window w, char *prior_app ){
   Status s;
@@ -118,17 +268,18 @@ int main(void){
   FILE *fp;
   char buffer[10240];
   struct json_object *parsed_json, *config, *config_obj, 
-  *config_obj_name, *config_obj_run, *config_obj_de, 
-  *config_obj_appnames, *appnames_obj, *init, *de, 
-  *de_obj, *de_obj_id, *de_obj_active, *de_obj_run,
-  *de_obj_runterm,*de_obj_rungui;
+  *config_obj_name, *config_obj_run, *config_obj_run_oninput, 
+  *config_obj_run_offinput, *config_obj_de, *config_obj_appnames,
+  *appnames_obj, *init, *de, *de_obj, *de_obj_id, *de_obj_active, 
+  *de_obj_run, *de_obj_runterm,*de_obj_rungui;
 
   int arraylen;
   int appnames_len, init_len, de_len, config_de_len;
   int system(const char *command);
 
   size_t i,n,r; 
-
+  
+  printf("Importing user_config.json...\n");
   fp = fopen("user_config.json","r");
   fread(buffer, 10240, 1, fp);
   fclose(fp);
@@ -145,6 +296,8 @@ int main(void){
 
   const char *name_array[arraylen];
   const char *run_array[arraylen];
+  const char *run_oninput_array[arraylen];
+  const char *run_offinput_array[arraylen];
   int init_array[init_len];
 
   int de_id_array[de_len];
@@ -193,10 +346,16 @@ int main(void){
 
   for (i = 0; i < arraylen; i++) {
     config_obj = json_object_array_get_idx(config, i);
+
     config_obj_name = json_object_object_get(config_obj, "name");
     config_obj_run = json_object_object_get(config_obj, "run");
+    config_obj_run_oninput = json_object_object_get(config_obj, "run_onInput");
+    config_obj_run_offinput = json_object_object_get(config_obj, "run_offInput");
+
     name_array[i] = json_object_get_string(config_obj_name);
     run_array[i] = json_object_get_string(config_obj_run);
+    run_oninput_array[i] = json_object_get_string(config_obj_run_oninput);
+    run_offinput_array[i] = json_object_get_string(config_obj_run_offinput);
     // printf("%s\n%s\n", json_object_get_string(config_obj_name), json_object_get_string(config_obj_run));
 
     config_obj_appnames = json_object_object_get(config_obj, "appnames");
@@ -209,13 +368,13 @@ int main(void){
       }
       else{
         appnames_array[i][n] = json_object_get_string(json_object_array_get_idx(config_obj_appnames, n));
-        // printf("%s i:%ld n:%ld %s\n",name_array[i],i,n,appnames_array[i][n]);
+        //printf("%s i:%ld n:%ld %s\n",name_array[i],i,n,appnames_array[i][n]);
       }
     }
     if(appnames_max > appnames_len){
       for (n = appnames_len; n < appnames_max; n++){
         appnames_array[i][n] = NULL;
-        // printf("%s i:%ld n:%ld %s\n",name_array[i],i,n,appnames_array[i][n]);
+        //printf("%s i:%ld n:%ld %s\n",name_array[i],i,n,appnames_array[i][n]);
       }
     }
 
@@ -233,6 +392,8 @@ int main(void){
 
     }
   }
+  
+  printf("Data from user_config.json imported successfully.\n");
 
   for (i = 0; i < init_len; i++) {
     init_array[i] = json_object_get_int(json_object_array_get_idx(init, i));
@@ -243,6 +404,7 @@ int main(void){
 
   Display* d;
   Window w;
+  char *name;
 
   // for XmbTextPropertyToTextList
   setlocale(LC_ALL, ""); // see man locale
@@ -251,90 +413,173 @@ int main(void){
   XSelectInput(d, DefaultRootWindow(d), SubstructureNotifyMask);
   XSetErrorHandler(handle_error);
 
+  char * run_normal;
+  char * run_onInput;
+  char * run_offInput;
   char * prior_app;
+  char * current_app;
+  char * prior_category;
+  char * current_category;
+  run_onInput = malloc(sizeof(char)*400);
+  run_offInput = malloc(sizeof(char)*400);
+  run_normal = malloc(sizeof(char)*400);
   prior_app = malloc(sizeof(char)*100);
+  current_app = malloc(sizeof(char)*100);
+  prior_category = malloc(sizeof(char)*100);
+  current_category = malloc(sizeof(char)*100);
   strcpy(prior_app,"none");
+  strcpy(prior_category,"none");
 
   int remap_bool = 2;
 
+  printf("Starting keyswap...\n");
+
   // get active window
   w = get_focus_window(d);
+  w = get_top_window(d, w, 0, 0, current_app);
+  w = get_named_window(d, w);
+
+  // XFetchName(d, w, &name);
+  // printf("window:%#x name:%s\n", w, name);
+  printf("First window name: %s \n",str_window_class(d, w,prior_app));
 
   int breakouter;
+  int last_event=0;
+  Bool ran_onInput = 0;
+  long long int event_ts = timeInMilliseconds();
 
   for (;;)
   {
+    strcpy(current_app,str_window_class(d, w,prior_app));
+    int category_idx;
+    // printf("current: %s\n",current_app);
     breakouter = 0;
-    // printf("%s\n","1");
-    // printf("%s\n",str_window_class(d, w,prior_app));
-    if(strcmp(str_window_class(d, w,prior_app),prior_app)){
-      // printf("%s\n","2");
-      for(i = 0; i < arraylen; ++i){
-        if(breakouter == 0){
-          if(strcmp(name_array[i],"gui")){
-            // printf("%s\n","3");
-            for(n = 0; n < appnames_max; ++n){
-              if (appnames_array[i][n] != NULL){
-                // printf("%s\n",appnames_array[i][n]);
-                // If statement for triggering terminal config
-                if((strcicmp(appnames_array[i][n], str_window_class(d, w,prior_app)) == 0 && (remap_bool == 1 || remap_bool == 2))) {
-                  // printf("1st if %s i:%ld n:%ld %s\n",name_array[i],i,n,appnames_array[i][n]);
-                  printf("%s\n",name_array[i]);
-                  system(run_array[i]);
-                  for(r = 0; r < config_de_max; r++){
-                    if(config_de_array[i][r] != -1){
-                      int de_id_idx = in_int(de_id_array, de_len, config_de_array[i][r]);
-                      // printf("Running de command: %s\n",de_run_array[de_id_idx]);
-                      system(de_runterm_array[de_id_idx]);
-                    }
-                  }
-                  remap_bool = 0;
-                  fflush(stdout);
-                  breakouter = 1;
-                  break;
-                } // Else command for ignoring similar app category based on config
-                else if((strcicmp(appnames_array[i][n], str_window_class(d, w,prior_app)) == 0 && remap_bool == 0)){
-                  // printf("2nd elseif %s i:%ld n:%ld %s\n",name_array[i],i,n,appnames_array[i][n]);
-                  // printf("%s\n","4");
-                  breakouter = 1;
-                  break;
-                } // Else command for triggering gui config
-                else if ((i == arraylen-1 || appnames_array[i][n+1] == NULL) && (remap_bool == 0 || remap_bool == 2)){
-                  char *find = "gui";
-                  int gui_idx = in(name_array, arraylen, find);
 
-                  if(gui_idx >= 0) {
-                    printf("%s\n",name_array[gui_idx]);
-                    system(run_array[gui_idx]);
-                  }
-                  for(r = 0; r < config_de_max; r++){
-                    if(config_de_array[gui_idx][r] != -1){
-                      int de_id_idx = in_int(de_id_array, de_len, config_de_array[gui_idx][r]);
-                      // printf("Running de command: %s\n",de_run_array[de_id_idx]);
-                      system(de_rungui_array[de_id_idx]);
-                    }
-                  }
-                  // printf("3rd elseif %s i:%ld n:%ld %s\n",name_array[i],i,n,appnames_array[i][n]);
-                  remap_bool = 1;
-                  fflush(stdout);
-                  breakouter = 1;
-                  break;
-                }
-              }
-            }
+    // Cycle through category name array
+    // printf("%d\n",arraylen);
+    for(i = 0; i < arraylen; ++i){
+      // Cycle through the maximum App name array in each category
+      for(n = 0; n < appnames_max; ++n){
+        if (appnames_array[i][n] != NULL){
+          // printf("%s\n",appnames_array[i][n]);
+          if(strcicmp(appnames_array[i][n], current_app) == 0){
+            strcpy(current_category,name_array[i]);
+            category_idx = i;
+            // printf("Match found: %s: %s\n",current_category,current_app);
+            breakouter = 1;
+            break;
           }
         }
-        else{
+        else if(i == arraylen-1 && breakouter==0){
+          // printf("No match found, default to gui");
+          strcpy(current_category,"gui");
+          category_idx = in(name_array, arraylen, current_category);
+          // printf("Match found: %s: %s\n",current_category,current_app);
+          break;
+        }
+        else if(appnames_array[i][n] == NULL){
+          break;
+        }
+        if(breakouter==1){
           break;
         }
       }
     }
-    // printf("%s\n","5");
-    strcpy(prior_app,str_window_class(d, w, prior_app));
 
+    if(strcicmp(prior_category, current_category) != 0){
+      printf("%s: %s\n",current_category,current_app);
+      // printf("run: %s\n",run_array[category_idx]);
+      system(run_array[category_idx]);
+      strcpy(run_normal,run_array[category_idx]);
+      ran_onInput = 0;
+      strcpy(run_onInput,run_oninput_array[category_idx]);
+      strcpy(run_offInput,run_offinput_array[category_idx]);
+      system(run_offInput);
+      for(r = 0; r < config_de_max; r++){
+        if(config_de_array[category_idx][r] != -1){
+          int de_id_idx = in_int(de_id_array, de_len, config_de_array[category_idx][r]);
+          if(strcicmp(current_category, "term") == 0){
+            // printf("Running de term command: %s\n",de_runterm_array[de_id_idx]);
+            system(de_runterm_array[de_id_idx]);
+          }
+          else{
+            // printf("Running de gui command: %s\n",de_rungui_array[de_id_idx]);
+            system(de_rungui_array[de_id_idx]);
+          }
+        }
+      }
+    }
+    else if(strcicmp(prior_app, current_app) != 0){
+      int indent = strlen(current_category)+2;
+      printf("%*c%s\n", indent, ' ',current_app);
+    }
+
+    fflush(stdout);
+
+    strcpy(prior_app,current_app);
+    strcpy(prior_category,current_category);
+
+    // printf("run_onInput: %ld\n",strlen(run_onInput));
     XEvent e;
-    XNextEvent(d, &e);
-    w = get_focus_window(d);
+    if(strlen(run_onInput) > 0){
+      while(XNextEventTimeout(d, &e, .5, event_ts, last_event, &event_ts, &last_event)){
+        if(check_caret() && ran_onInput == 0){
+          // printf("run_onInput: %s\n",run_onInput);
+          system(run_onInput);
+          ran_onInput = 1;
+        }
+        else if(!check_caret() && ran_onInput == 1){
+          // printf("run_offInput: %s\n",run_offInput);
+          system(run_offInput);
+          ran_onInput = 0;
+        }
+      }
+    }
+    else{
+      while (1) {
+        XNextEvent(d, &e);
+        // Make sure window dragging or resizing is not occuring
+        if(!(e.type == 22 && (e.type == last_event) && timeInMilliseconds()-event_ts < 300)){
+          // printf("%d == %d\n",e.type, last_event);
+          // printf("Timestamp: %lld\n",timeInMilliseconds()-event_ts);
+          event_ts = timeInMilliseconds();
+          last_event = e.type;
+          break;
+        }
+        event_ts = timeInMilliseconds();
+        last_event = e.type;
+      }
+    }
 
+    // if(strcicmp(current_app, "plasmashell") == 0){
+    //   XNextEvent(d, &e);
+    // }
+    // if(strcicmp(current_app, "plasmashell") == 0 && e.type == 18 && last_event == 22){
+    //   XNextEvent(d, &e);
+    // }
+    // if(strcicmp(prior_app, "plasmashell") == 0){
+    //   XNextEvent(d, &e);
+    // }
+    // if(strcicmp(current_app, "dolphin") == 0){
+    //   XNextEvent(d, &e);
+    // }
+    // if(strcicmp(prior_app, "dolphin") == 0){
+    //   XNextEvent(d, &e);
+    // }
+    // if(strcicmp(current_app, "dolphin") == 0  && e.type == 18 && last_event == 16){
+    //   XNextEvent(d, &e);
+    // }
+
+    // Reference http://www.rahul.net/kenton/xproto/xevents_errors.html
+    // event type 17 - DestroyNotify
+    // event type 18 - UnmapNotify
+    // Dismiss the following events by initiating another XNextEvent
+    while(e.type == 17 || e.type == 18){
+      XNextEvent(d, &e);
+    }
+
+    w = get_focus_window(d);
+    w = get_top_window(d, w, e.type, last_event, current_app);
+    w = get_named_window(d, w);
   }
 }

setup.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-import json, time, os
+import json, time, os, sys
 from shutil import copyfile
 from subprocess import PIPE, Popen
 from prekinto import *
@@ -15,6 +15,87 @@ def cmdline(command):
     )
     return process.communicate()[0]
 
+def requirements(pkgm):
+	print(bcolors.CYELLOW + "You need to install some packages, " +run_pkg+ ", for Kinto to fully remap browsers during input focus.\n" + bcolors.ENDC)
+	print("sudo " + pkgm + " " + run_pkg + "\n")
+	run_install = yn_choice(bcolors.CYELLOW + "Would you like to run it now? (Will require sudo privileges.)\n" + bcolors.ENDC)
+	if(run_install):
+		os.system("sudo " + pkgm  + run_pkg)
+		print("\n")
+
+def install_ibus():
+	print(bcolors.CYELLOW + "You need to set IBus as the default Input Method for full word-wise support and re-run this installer.\n" + bcolors.ENDC)
+	print(bcolors.CYELLOW + "Confirm the IBus Setup by saying Yes and then closing the window.\n" + bcolors.ENDC)
+	print("ibus-setup\n")
+	print("im-config -n ibus\n")
+	run_install = yn_choice(bcolors.CYELLOW + "Would you like to run it now? (Will require logoff and logon.)\n" + bcolors.ENDC)
+	if(run_install):
+		os.system("ibus-setup")
+		os.system("im-config -n ibus")
+		print("\n")
+		input("IBus has been set as the default Input Method.\nPress any key to exit and re-run after logoff & logon...")
+		sys.exit()
+
+# check_x11 = cmdline("env | grep -i x11").strip()
+check_x11 = cmdline("env | grep -i x11 || loginctl show-session \"$XDG_SESSION_ID\" -p Type | awk -F= '{print $2}'").strip()
+
+if len(check_x11) == 0:
+	print("You are not using x11, please logout and back in using x11/Xorg")
+	sys.exit()
+
+check_xbind = cmdline("which xbindkeys 2>/dev/null").strip()
+check_xdotool = cmdline("which xdotool 2>/dev/null").strip()
+check_ibus = cmdline("which ibus-setup 2>/dev/null").strip()
+
+pkgm = cmdline("which apt-get 2>/dev/null").strip()
+
+if len(pkgm) == 0:
+	pkgm = cmdline("which dnf 2>/dev/null").strip()
+	if len(pkgm) > 0:
+		pkgm += " check-update;sudo dnf install -y "
+else:
+	pkgm += " update; sudo apt-get install -y "
+
+if len(pkgm) == 0:
+	pkgm = cmdline("which pacman 2>/dev/null").strip()
+	if len(pkgm) > 0:
+		pkgm += " -Syy; sudo pacman -S "
+
+
+if len(pkgm) == 0:
+	print("No supported package manager found. Exiting...")
+	sys.exit()
+
+
+runpkg = 0
+run_pkg = ""
+
+if len(check_xbind) > 0 and len(check_xdotool) > 0 and len(check_ibus) > 0:
+	print("Xbindkeys, xdotool and IBus requirement is installed.")
+if len(check_xbind) == 0:
+	run_pkg = "xbindkeys"
+	runpkg = 1
+if len(check_xdotool) == 0:
+	run_pkg += " xdotool"
+	runpkg = 1
+if len(check_ibus) == 0:
+	# may differ with distro, but for now
+	run_pkg += " ibus"
+	runpkg = 1
+
+if runpkg != 0:
+	requirements(pkgm)
+
+if not os.path.exists(homedir + '/.config/ibus/bus') and cmdline("ls ~/.config/ibus/bus -1rt") == "":
+	install_ibus()
+
+try:
+	f = open("defaults.json")
+except IOError:
+	print("defaults.json file is missing. Will exit.\n")
+	exit()
+f.close()
+
 try:
 	f = open("defaults.json")
 except IOError:
@@ -90,22 +171,29 @@ if 'hack' in keyboardconfigs[defaultkb-1]:
 		os.system(keyboardconfigs[defaultkb-1]['hack'])
 
 # Setup the selected keyboards config
-os.system("cp -rf ./.xkb ~/.xkb")
+os.system("cp -TRv ./.xkb ~/.xkb/")
 if os.path.isdir(homedir + "/.xkb/keymap") == False:
 	os.mkdir(homedir + "/.xkb/keymap")
 	time.sleep(0.5)
 os.system('setxkbmap -option')
 os.system('setxkbmap -print > ~/.xkb/keymap/kbd.mac.gui')
+os.system('setxkbmap -print > ~/.xkb/keymap/kbd.mac.gui.nw')
+os.system('setxkbmap -print > ~/.xkb/keymap/kbd.mac.gui.chrome')
 os.system('setxkbmap -print > ~/.xkb/keymap/kbd.mac.term')
 time.sleep(0.5)
 
-symbols_gui_line = cmdline("cat ~/.xkb/keymap/kbd.mac.gui | grep -n 'xkb_symbols' | cut -f1 -d:").strip()
-types_gui_line = cmdline("cat ~/.xkb/keymap/kbd.mac.gui | grep -n 'xkb_types' | cut -f1 -d:").strip()
-symbols_term_line = cmdline("cat ~/.xkb/keymap/kbd.mac.term | grep -n 'xkb_symbols' | cut -f1 -d:").strip()
+symbols_line = cmdline("cat ~/.xkb/keymap/kbd.mac.gui | grep -n 'xkb_symbols' | cut -f1 -d:").strip()
+types_line = cmdline("cat ~/.xkb/keymap/kbd.mac.gui | grep -n 'xkb_types' | cut -f1 -d:").strip()
 
-cmdline('sed -i '' -e "' + symbols_gui_line + 's/\\"/' + keyboardconfigs[defaultkb-1]['xkb_symbols_gui'] + '\\"/2" ~/.xkb/keymap/kbd.mac.gui')
-cmdline('sed -i '' -e "' + types_gui_line + 's/\\"/' + keyboardconfigs[defaultkb-1]['xkb_types_gui'] + '\\"/2" ~/.xkb/keymap/kbd.mac.gui')
-cmdline('sed -i '' -e "' + symbols_term_line + 's/\\"/' + keyboardconfigs[defaultkb-1]['xkb_symbols_term'] + '\\"/2" ~/.xkb/keymap/kbd.mac.term')
+cmdline('sed -i '' -e "' + symbols_line + 's/\\"/' + keyboardconfigs[defaultkb-1]['xkb_symbols_gui'] + '\\"/2" ~/.xkb/keymap/kbd.mac.gui')
+cmdline('sed -i '' -e "' + types_line + 's/\\"/' + keyboardconfigs[defaultkb-1]['xkb_types_gui'] + '\\"/2" ~/.xkb/keymap/kbd.mac.gui')
+cmdline('sed -i '' -e "' + symbols_line + 's/\\"/' + keyboardconfigs[defaultkb-1]['xkb_symbols_term'] + '\\"/2" ~/.xkb/keymap/kbd.mac.term')
+cmdline('sed -i '' -e "' + types_line + 's/\\"/' + keyboardconfigs[defaultkb-1]['xkb_types_term'] + '\\"/2" ~/.xkb/keymap/kbd.mac.term')
+
+cmdline('sed -i '' -e "' + symbols_line + 's/\\"/' + keyboardconfigs[defaultkb-1]['xkb_symbols_gui'].replace("+mac_gui(mac_levelssym)","") + '\\"/2" ~/.xkb/keymap/kbd.mac.gui.nw')
+cmdline('sed -i '' -e "' + symbols_line + 's/\\"/' + keyboardconfigs[defaultkb-1]['xkb_symbols_gui'].replace("+mac_gui(mac_levelssym)","+mac_gui(mac_chrome)") + '\\"/2" ~/.xkb/keymap/kbd.mac.gui.chrome')
+cmdline('sed -i '' -e "' + types_line + 's/\\"/' + keyboardconfigs[defaultkb-1]['xkb_types_gui'] + '\\"/2" ~/.xkb/keymap/kbd.mac.gui.nw')
+cmdline('sed -i '' -e "' + types_line + 's/\\"/' + keyboardconfigs[defaultkb-1]['xkb_types_gui'] + '\\"/2" ~/.xkb/keymap/kbd.mac.gui.chrome')
 
 
 user_file = homedir + '/.config/kinto/user_config.json'
@@ -125,31 +213,42 @@ if(onetime):
 	print(bcolors.CYELLOW + "Please enter your init tweak(s) (eg 1 or 1 2 3 - leave blank to skip): " + bcolors.ENDC)
 	defaultinit = [int(i) for i in input().split()]
 	if len(defaultinit) != 0:
-		user_config['init'] = defaultinit
+		user_config['init'] = [intents[defaultinit[0]-1]['id']]
 
 print("\nDynamic shortcut tweaks\n")
 
 intents = [obj for obj in user_config['de'] if(obj['intent'] == "gui_term")]
+tweaks = []
+tweaks_selected = []
 
 for index, k in enumerate(intents):
 	print(color_arr[default-1] + bcolors.BOLD + str(index+1) + '. ' + k['name'] + bcolors.ENDC)
 	print(bcolors.CYELLOW + 'Description: ' + k['description'] + bcolors.ENDC)
 	print(bcolors.CYELLOW + 'run in gui mode: ' + k['run_gui'].replace(";", "\n") + bcolors.ENDC)
 	print(bcolors.CYELLOW + 'run in terminal mode: ' + k['run_term'].replace(";", "\n") + bcolors.ENDC + '\n')
+	tweaks.append(k['id'])
 
 print(bcolors.CYELLOW + "Please enter your dynamic shortcut tweak(s) (eg 1 or 1 2 3 - leave blank to skip): " + bcolors.ENDC)
 defaultde = [int(i) for i in input().split()]
-if len(defaultde) != 0:
-	# gui
-	user_config['config'][0]['de'] = defaultde
-	# term
-	user_config['config'][1]['de'] = defaultde
 
 for d in defaultde:
-    user_config['de'][d-1]['active'] = True
+    user_config['de'][tweaks[d-1]]['active'] = True
+    tweaks_selected.append(tweaks[d-1])
+
+if len(defaultde) != 0:
+	# gui
+	user_config['config'][0]['de'] = tweaks_selected
+	# term
+	user_config['config'][1]['de'] = tweaks_selected
+	# firefox
+	user_config['config'][2]['de'] = tweaks_selected
+	# chrome
+	user_config['config'][3]['de'] = tweaks_selected
 
 user_config['config'][0]['run'] = keyboardconfigs[defaultkb-1]['gui']
 user_config['config'][1]['run'] = keyboardconfigs[defaultkb-1]['term']
+user_config['config'][2]['run'] = keyboardconfigs[defaultkb-1]['gui']
+user_config['config'][3]['run'] = keyboardconfigs[defaultkb-1]['gui'].replace("kbd.mac.gui","kbd.mac.gui.chrome")
 
 os.remove(user_file)
 with open(user_file, 'w') as f:

system-config/.chrome-nw

@@ -0,0 +1,7 @@
+"xdotool key --delay 0 --clearmodifiers Alt+Left"
+  Control + Left + Release
+  #Home + release
+
+"xdotool key --delay 0 --clearmodifiers Alt+Right"
+  Control + Right + Release
+  #End + release

system-config/.chrome-ww

@@ -0,0 +1,5 @@
+"xdotool key --delay 0 --clearmodifiers Home"
+  Control + Left + Release
+
+"xdotool key --delay 0 --clearmodifiers End"
+  Control + Right + Release

system-config/.firefox-nw

@@ -0,0 +1,7 @@
+#"xte 'keydown Control_L' 'key bracketleft' 'keyup Control_L'"
+"xdotool key --delay 0 --clearmodifiers Control_L+bracketleft"
+  Home + Release
+
+#"xte 'keydown Control_R' 'key bracketright' 'keyup Control_R'"
+"xdotool key --delay 0 --clearmodifiers Control_L+bracketright"
+  End + Release

system-config/caret_status.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+mkdir -p /tmp/kinto
+
+IBUSADD=$(cat ~/.config/ibus/bus/`ls ~/.config/ibus/bus -1rt | tail -n1` | awk -F'IBUS_ADDRESS=' '{print $2}' | xargs)
+dbus-monitor --address $IBUSADD "path='/org/freedesktop/IBus/Panel',interface='org.freedesktop.IBus.Panel',member='FocusOut'" 2> /dev/null | grep --line-buffered -o -P '(?<=object path \"/org/freedesktop/IBus/InputContext_).*(?=[\"])' |
+while read ln
+do
+  printf '%s\n' "$ln" > /tmp/kinto/caret
+done

system-config/cleanup.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+setxkbmap -option
+# force command to run silently and report true
+killall xbindkeys > /dev/null 2>&1 || :
+# rm /tmp/kinto/caret

system-config/keyswap.service

@@ -4,12 +4,13 @@ PartOf=graphical-session.target
 
 [Service]
 Type=simple
-#User={username}
-#Group={username}
-Environment=DISPLAY=:0
 Restart=always
+# eg DISPLAY=:0.0
+#Environment=DISPLAY={displayid}
+RestartSec=1
 WorkingDirectory=/home/{username}/.config/kinto
-ExecStart=
+ExecStart=/bin/bash -c "/home/{username}/.config/kinto/xactive.sh carrots"
+ExecStop=/bin/bash /home/{username}/.config/kinto/cleanup.sh
 
 [Install]
 WantedBy=default.target

system-config/keyswap.sh

@@ -1,3 +0,0 @@
-#/bin/bash
-
-systemctl --user start keyswap

system-config/keyswap.timer

@@ -0,0 +1,11 @@
+# keyswap.timer
+[Unit]
+Description=Runs the keyswap.service 5 seconds after boot up
+
+[Timer]
+#OnBootSec=5s
+OnActiveSec=5s
+Unit=keyswap.service
+
+[Install]
+WantedBy=default.target

system-config/kinto.desktop

@@ -0,0 +1,8 @@
+[Desktop Entry]
+Name=Kinto
+GenericName=Kinto
+Comment=Make Linux Type Like it's a Mac
+Exec=/bin/sleep 5 /usr/bin/systemctl --user start keyswap
+Terminal=false
+Type=Application
+X-GNOME-Autostart-enabled=true

system-config/xactive.sh

@@ -1,3 +1,4 @@
 #!/bin/bash
 
+./caret_status.sh &
 ./kintox11

uninstall.sh

@@ -2,7 +2,7 @@
 
 systemctl --user stop keyswap
 systemctl --user disable keyswap
-rm -rf ~/.config/autostart/keyswap.sh
+rm -rf ~/.config/autostart/kinto.desktop
 rm -rf ~/.config/kinto
 rm -rf ~/.xkb
 

user_config.json

@@ -1,15 +1,43 @@
 {"config":[{
 		"name":"gui",
 		"run":"",
+		"run_onInput":"",
+		"run_offInput": "killall xbindkeys > /dev/null 2>&1",
+		"symbols":"",
+		"types":"",
 		"de":[],
 		"appnames":[ "" ]
 	},
 	{
 		"name":"term",
 		"run":"",
+		"run_onInput":"",
+		"run_offInput": "killall xbindkeys > /dev/null 2>&1",
+		"symbols":"",
+		"types":"",
 		"de":[],
 		"appnames":[ "Gnome-terminal","konsole","io.elementary.terminal","terminator","sakura","guake","tilda","xterm","eterm" ]
-	}],
+	},
+	{
+        "name": "firefox",
+        "run": "",
+        "run_onInput": "killall xbindkeys > /dev/null 2>&1",
+        "run_offInput": "killall xbindkeys > /dev/null 2>&1;xbindkeys -f $HOME/.config/kinto/.firefox-nw",
+        "symbols": "",
+        "types": "",
+        "de": [],
+        "appnames": [ "Firefox" ]
+    },
+    {
+        "name": "chrome",
+        "run": "",
+        "run_onInput": "xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.gui $DISPLAY",
+        "run_offInput": "xkbcomp -w0 -I$HOME/.xkb ~/.xkb/keymap/kbd.mac.gui.chrome $DISPLAY",
+        "symbols": "",
+        "types": "",
+        "de": [],
+        "appnames": [ "Chromium","Chromium-browser","Google-chrome","Epiphany" ]
+    }],
 	"init": [],
 	"detypes":["gnome2","gnome3","kde4","kde5","xfce","i3wm"],
 	"de":[{