version 0.8.3

Includes proper fix for Wayland key repeat

.gitignore

@@ -4,6 +4,7 @@
 tags
 build
 linux-package
+kitty.app
 logo/*.iconset
 compile_commands.json
 glad/out

CHANGELOG.rst

@@ -3,6 +3,54 @@ Changelog
 
 kitty is a feature full, cross-platform, *fast*, GPU based terminal emulator.
 
+version 0.8.3 [2018-03-29]
+-----------------------------
+
+- Fix a regression that broke the visual bell and invert screen colors escape
+  code
+
+- Allow double-click and triple-click + drag to extend selections word at a
+  time or line at a time
+
+- Add a keyboard shortcut to set the tab title
+
+- Fix setting window title to empty via OSC escape code not working correctly
+
+- Linux: Fix cell width calculation incorrect for some fonts (cell widths are
+  now calculated by actually rendering bitmaps, which is slower but more
+  accurate)
+
+- Allow specifying a system wide kitty config file, for all users
+
+- Add a --debug-config command line flag to output data about the system and
+  kitty configuration.
+
+- Wayland: Fix auto-repeat of keys not working
+
+
+version 0.8.2 [2018-03-17]
+-----------------------------
+
+- Allow extending existing selections by right clicking
+
+- Add a configurable keyboard shortcut and remote command to set the font size to a specific value
+
+- Add an option to have kitty close the window when the main processes running in it exits, even if there are still background processes writing to that terminal
+
+- Add configurable keyboard shortcuts to switch to a specific layout
+
+- Add a keyboard shortcut to edit the kitty config file easily 
+
+- macOS: Fix restoring of window size not correct on Retina screens
+
+- macOS: Add a facility to specify command line arguments when running kitty from the GUI 
+
+- Add a focus-tab remote command
+
+- Fix screen not being refreshed immediately after moving a window.
+
+- Fix a crash when getting the contents of the scrollback buffer as text
+
 version 0.8.1 [2018-03-09]
 -----------------------------
 

README.asciidoc

@@ -6,6 +6,7 @@
 :sc_close_window: pass:quotes[`ctrl+shift+w`]
 :sc_copy_to_clipboard: pass:quotes[`ctrl+shift+c`]
 :sc_decrease_font_size: pass:quotes[`ctrl+shift+minus`]
+:sc_edit_config_file: pass:quotes[`ctrl+shift+f2`]
 :sc_eighth_window: pass:quotes[`ctrl+shift+8`]
 :sc_fifth_window: pass:quotes[`ctrl+shift+5`]
 :sc_first_window: pass:quotes[`ctrl+shift+1`]
@@ -38,6 +39,7 @@
 :sc_scroll_page_down: pass:quotes[`ctrl+shift+page_down`]
 :sc_scroll_page_up: pass:quotes[`ctrl+shift+page_up`]
 :sc_second_window: pass:quotes[`ctrl+shift+2`]
+:sc_set_tab_title: pass:quotes[`ctrl+shift+alt+t`]
 :sc_seventh_window: pass:quotes[`ctrl+shift+7`]
 :sc_show_scrollback: pass:quotes[`ctrl+shift+h`]
 :sc_sixth_window: pass:quotes[`ctrl+shift+6`]
@@ -131,6 +133,8 @@ python3 .
 
 * Gentoo: https://packages.gentoo.org/packages/x11-terms/kitty
 
+* openSUSE: https://build.opensuse.org/package/show/X11:terminals/kitty
+
 === macOS packages
 
 kitty is available as a macOS `dmg` file for easy installation from the
@@ -199,6 +203,7 @@ windows are:
 |Next layout | {sc_next_layout}
 |Move tab forward | {sc_move_tab_forward}
 |Move tab backward | {sc_move_tab_backward}
+|Set tab title | {sc_set_tab_title}
 
 |===
 
@@ -234,6 +239,7 @@ windows are:
 |Input unicode character | {sc_input_unicode_character}
 |Click URL using the keyboard | {sc_run_simple_kitten_text_url_hints}
 |Pass current selection to program | {sc_pass_selection_to_program}
+|Edit kitty config file| {sc_edit_config_file}
 |===
 
 
@@ -241,10 +247,11 @@ windows are:
 
 You can control kitty from the command line/scripts by sending it messages.
 You can tell kitty to open/close/rename tabs and windows. You can even send
-arbitrary input/text to any specified window. Messages can be sent using
-`kitty @`. Note that you must set `allow_remote_control yes` in your
-kitty.conf to use this feature.  It even works over SSH connections.  This
-feature is best illustrated with a link:remote-control.asciidoc[tutorial].
+arbitrary input/text to any specified window. Messages can be sent using `kitty
+@`. Note that you must set `allow_remote_control yes` in your
+link:kitty/kitty.conf[kitty.conf] to use this feature.  It even works over SSH
+connections.  This feature is best illustrated with a
+link:remote-control.asciidoc[tutorial].
 
 
 == The scrollback buffer
@@ -286,8 +293,9 @@ image::hints_mode.png?raw=true[URL hints mode]
 
 == Miscellaneous features
 
-You can double click to select a word and triple click to select a line. You can also
-hold down `ctrl+shift` and click on a URL to open it in a browser.
+* You can also hold down `ctrl+shift` and click on a URL to open it in a browser.
+* You can double click to select a word and triple click to select a line.
+* You can right click to extend a previous selection
 
 
 == Layouts
@@ -300,7 +308,9 @@ Currently, there are five layouts available,
 * Horizontal -- All windows are shown side-by-side
 * Vertical -- All windows are shown one below the other
 
-You can switch between layouts using the {sc_next_layout} key combination.
+You can switch between layouts using the {sc_next_layout} key combination. You can
+also create shortcuts to select particular layouts, and choose which layouts
+you want to enable/disable, see link:kitty/kitty.conf[kitty.conf] for examples.
 
 Writing a new layout only requires about fifty lines of code, so if there is
 some layout you want, take a look at link:kitty/layout.py[layout.py] and submit
@@ -309,13 +319,17 @@ a pull request!
 
 == Configuration
 
-kitty is highly customizable, everything from keyboard shortcuts, to
-painting frames-per-second. See the heavily commented
-link:kitty/kitty.conf[default config file]. By default kitty looks for a
-config file in the OS config directory (usually
-`~/.config/kitty/kitty.conf` on Linux and
+kitty is highly customizable, everything from keyboard shortcuts, to painting
+frames-per-second. See the heavily commented link:kitty/kitty.conf[default
+config file] for an overview of all customization possibilities.
+
+By default kitty looks for a config file in the OS config directories (usually
+`~/.config/kitty/kitty.conf` and additionally
 `~/Library/Preferences/kitty/kitty.conf` on macOS) but you can pass a specific
-path via the `--config` option.
+path via the `--config` option or use the `KITTY_CONFIG_DIRECTORY` environment
+variable. See the help for the `--config` option in `kitty --help` for full
+details.
+
 
 == Startup Sessions
 
@@ -432,6 +446,8 @@ installs the terminfo file and `kitty` that installs the main program.
 This allows users to install the terminfo file on servers into which they ssh,
 without needing to install all of kitty.
 
+You also need `tic` to compile the terminfo files, it is usually found in the development package of `ncurses`
+
 This applies to creating packages for kitty for macOS package managers such as
 brew or MacPorts as well.
 
@@ -449,16 +465,16 @@ let the character overflow into neighboring cells, which is fine if the
 neighboring cell is empty, but looks terrible if it is not.
 
 Some programs, like powerline, vim with fancy gutter symbols/status-bar, etc.
-use unicode characters from the private use area to represent symbols. Often
+misuse unicode characters from the private use area to represent symbols. Often
 these symbols are square and should be rendered in two cells.  However, since
 private use area symbols all have their width set to one in the unicode
-standard, kitty renders them either smaller or truncated. The exception (as of
-kitty 0.8.1) is if these characters are followed by a space or empty cell in
-which case kitty makes use of the extra cell to render them in two cells.
+standard, kitty renders them either smaller or truncated. The exception is if
+these characters are followed by a space or empty cell in which case kitty
+makes use of the extra cell to render them in two cells.
 
 === How do I build kitty.app on macOS?
 
-Install `optipng` and `librsvg` using `brew` or similar (needed for the logo generation step).
+Install `imagemagick`, `optipng` and `librsvg` using `brew` or similar (needed for the logo generation step).
 
 And run:
 ```
@@ -489,10 +505,11 @@ let &t_ut=''
 See link:https://github.com/kovidgoyal/kitty/blob/master/protocol-extensions.asciidoc#setting-text-styles-colors-in-arbitrary-regions-of-the-screen[here]
 for why kitty does not support background color erase.
 
-== I get errors about the terminal being unknown or opening the terminal failing when SSHing into a different computer?
+=== I get errors about the terminal being unknown or opening the terminal failing when SSHing into a different computer?
 
-This happens because the kitty terminfo files are not available on the server. Either install kitty on the server,
-or simply copy over the terminfo files, using:
+This happens because the kitty terminfo files are not available on the server.
+Either install kitty on the server, or simply copy over the terminfo files,
+using:
 
 ....
 ssh myserver mkdir -p \~/.terminfo
@@ -500,8 +517,24 @@ infocmp xterm-kitty | ssh myserver "cat > /tmp/kitty.terminfo"
 ssh myserver tic -x -o \~/.terminfo /tmp/kitty.terminfo
 ....
 
-Really, the correct solution for this is to convince the OpenSSH maintainers to have ssh do this
-automatically when connecting to a server.
+Really, the correct solution for this is to convince the OpenSSH maintainers to
+have ssh do this automatically when connecting to a server, so that all
+terminals work transparently.
+
+
+=== How do I specify command line options for kitty on macOS?
+
+Apple does not want you to use command line options with GUI applications. To
+workaround that limitation, kitty will read command line options from the file
+`~/Library/Preferences/kitty/macos-launch-services-cmdline` when it is launched
+from the GUI, i.e. by clicking the kitty application icon or using `open -a kitty`.
+Note that this file is *only read* when running via the GUI.
+
+You can, of course, also run kitty from a terminal with command line options, using:
+`/Applications/kitty.app/Contents/MacOS/kitty`.
+
+And within kitty itself, you can always run kitty using just `kitty` as it
+cleverly adds itself to the PATH.
 
 == Resources on terminal behavior
 

count-lines-of-code

@@ -1,2 +1,2 @@
 #!/bin/bash
-cloc --exclude-list-file <(echo -e 'kitty/wcwidth-std.h\nkitty/glfw.c\nkitty/keys.h\nkitty/charsets.c\nkitty/unicode-data.c\nkitty/key_encoding.py\nkitty/rgb.py\nkitty/gl.h\nkitty/gl-wrapper.h\nkitty/gl-wrapper.c\nkitty/khrplatform.h\nkitty/glfw-wrapper.h\nkitty/glfw-wrapper.c\nkitty/emoji.h') kitty
+cloc --exclude-list-file <(echo -e 'kitty/wcwidth-std.h\nkitty/glfw.c\nkitty/keys.h\nkitty/charsets.c\nkitty/unicode-data.c\nkitty/key_encoding.py\nkitty/rgb.py\nkitty/gl.h\nkitty/gl-wrapper.h\nkitty/gl-wrapper.c\nkitty/khrplatform.h\nkitty/glfw-wrapper.h\nkitty/glfw-wrapper.c\nkitty/emoji.h\nkittens/unicode_input/names.h') kitty kittens

glfw/cocoa_window.m

@@ -582,6 +582,9 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
         window->ns.xscale = xscale;
         window->ns.yscale = yscale;
         _glfwInputWindowContentScale(window, xscale, yscale);
+
+        if (window->ns.layer)
+            [window->ns.layer setContentsScale:[window->ns.object backingScaleFactor]];
     }
 }
 
@@ -1358,7 +1361,7 @@ void _glfwPlatformRequestWindowAttention(_GLFWwindow* window)
     [NSApp requestUserAttention:NSInformationalRequest];
 }
 
-int _glfwPlatformWindowBell(_GLFWwindow* window, int64_t param)
+int _glfwPlatformWindowBell(_GLFWwindow* window)
 {
     NSBeep();
     return GLFW_TRUE;
@@ -1871,6 +1874,7 @@ VkResult _glfwPlatformCreateWindowSurface(VkInstance instance,
         return VK_ERROR_EXTENSION_NOT_PRESENT;
     }
 
+    [window->ns.layer setContentsScale:[window->ns.object backingScaleFactor]];
     [window->ns.view setWantsLayer:YES];
 
     memset(&sci, 0, sizeof(sci));
@@ -1902,4 +1906,3 @@ GLFWAPI id glfwGetCocoaWindow(GLFWwindow* handle)
     _GLFW_REQUIRE_INIT_OR_RETURN(nil);
     return window->ns.object;
 }
-

glfw/glfw.py

@@ -10,6 +10,10 @@ import sys
 
 _plat = sys.platform.lower()
 is_macos = 'darwin' in _plat
+is_freebsd = 'freebsd' in _plat
+is_netbsd = 'netbsd' in _plat
+is_dragonflybsd = 'dragonfly' in _plat
+is_bsd = is_freebsd or is_netbsd or is_dragonflybsd
 base = os.path.dirname(os.path.abspath(__file__))
 
 
@@ -100,13 +104,14 @@ def collect_source_information():
         'common': dict(extract_sources('common')),
         'wayland_protocols': wayland_protocols,
     }
+    joystick = 'null' if is_bsd else 'linux'
     for group in 'cocoa win32 x11 wayland osmesa'.split():
         m = re.search('_GLFW_' + group.upper(), raw)
         ans[group] = dict(extract_sources('glfw', m.start()))
-        if group == 'x11':
-            ans[group]['headers'].append('linux_joystick.h')
-            ans[group]['sources'].append('linux_joystick.c')
-        elif group == 'wayland':
+        if group in ('x11', 'wayland'):
+            ans[group]['headers'].append('{}_joystick.h'.format(joystick))
+            ans[group]['sources'].append('{}_joystick.c'.format(joystick))
+        if group == 'wayland':
             ans[group]['protocols'] = p = []
             for m in re.finditer(r'WAYLAND_PROTOCOLS_PKGDATADIR\}/(.+?)"?$', raw, flags=re.M):
                 p.append(m.group(1))

glfw/glfw3.h

@@ -3188,13 +3188,9 @@ GLFWAPI void glfwRequestWindowAttention(GLFWwindow* window);
 /*! @brief Sounds an audible bell associated with the window
  *
  *  This function sounds an audible bell, on platforms where it is
- *  supported. Currently (macOS, Windows and X11).
+ *  supported. Currently (macOS, Windows, X11 and Wayland).
  *
  *  @param[in] window The window with which the bell is associated.
- *  @param[in] param The meaning of this parameter is platform dependent. On
- *  X11 it corresponds to the percentage controlling bell volume (see man
- *  XBell). On Windows it is the type of sound to make, see the MSDN docs for
- *  MessageBeep. On macOS, it is ignored.
  *  @return GLFW_TRUE if the bell succeeded otherwise GLFW_FALSE
  *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
@@ -3209,7 +3205,7 @@ GLFWAPI void glfwRequestWindowAttention(GLFWwindow* window);
  *
  *  @ingroup window
  */
-GLFWAPI int glfwWindowBell(GLFWwindow* window, int64_t param);
+GLFWAPI int glfwWindowBell(GLFWwindow* window);
 
 
 /*! @brief Returns the monitor that the window uses for full screen mode.
@@ -4901,7 +4897,7 @@ GLFWAPI const char* glfwGetGamepadName(int jid);
  *
  *  Not all devices have all the buttons or axes provided by @ref
  *  GLFWgamepadstate.  Unavailable buttons and axes will always report
- *  `GLFW_RELEASE` and 1.0 respectively.
+ *  `GLFW_RELEASE` and 0.0 respectively.
  *
  *  @param[in] jid The [joystick](@ref joysticks) to query.
  *  @param[out] state The gamepad input state of the joystick.
@@ -5546,4 +5542,3 @@ GLFWAPI VkResult glfwCreateWindowSurface(VkInstance instance, GLFWwindow* window
 #endif
 
 #endif /* _glfw3_h_ */
-

glfw/internal.h

@@ -128,7 +128,7 @@ typedef enum VkStructureType
     VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
     VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000,
     VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
-    VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000053000,
+    VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000,
     VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
 } VkStructureType;
 
@@ -653,7 +653,7 @@ void _glfwPlatformMaximizeWindow(_GLFWwindow* window);
 void _glfwPlatformShowWindow(_GLFWwindow* window);
 void _glfwPlatformHideWindow(_GLFWwindow* window);
 void _glfwPlatformRequestWindowAttention(_GLFWwindow* window);
-int _glfwPlatformWindowBell(_GLFWwindow* window, int64_t);
+int _glfwPlatformWindowBell(_GLFWwindow* window);
 void _glfwPlatformFocusWindow(_GLFWwindow* window);
 void _glfwPlatformSetWindowMonitor(_GLFWwindow* window, _GLFWmonitor* monitor,
                                    int xpos, int ypos, int width, int height,
@@ -769,4 +769,3 @@ void _glfwTerminateVulkan(void);
 const char* _glfwGetVulkanResultString(VkResult result);
 
 char* _glfw_strdup(const char* source);
-

glfw/nsgl_context.m

@@ -175,7 +175,7 @@ GLFWbool _glfwCreateContextNSGL(_GLFWwindow* window,
         //       Info.plist for unbundled applications
         // HACK: This assumes that NSOpenGLPixelFormat will remain
         //       a straightforward wrapper of its CGL counterpart
-#if MAC_OS_X_VERSION_MAX_ALLOWED >= 100800
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1080
         addAttrib(kCGLPFASupportsAutomaticGraphicsSwitching);
 #endif /*MAC_OS_X_VERSION_MAX_ALLOWED*/
     }

glfw/null_window.c

@@ -205,7 +205,7 @@ void _glfwPlatformRequestWindowAttention(_GLFWwindow* window)
 {
 }
 
-int _glfwPlatformWindowBell(_GLFWwindow* window, int64_t param)
+int _glfwPlatformWindowBell(_GLFWwindow* window)
 {
     return GLFW_FALSE;
 }
@@ -323,4 +323,3 @@ VkResult _glfwPlatformCreateWindowSurface(VkInstance instance,
     // This seems like the most appropriate error to return here
     return VK_ERROR_INITIALIZATION_FAILED;
 }
-

glfw/source-info.json

@@ -55,12 +55,13 @@
   "wayland": {
     "headers": [
       "wl_platform.h", 
-      "linux_joystick.h", 
       "posix_time.h", 
       "posix_thread.h", 
+      "xkb_glfw.h", 
       "xkb_unicode.h", 
       "egl_context.h", 
-      "osmesa_context.h"
+      "osmesa_context.h", 
+      "linux_joystick.h"
     ], 
     "protocols": [
       "stable/xdg-shell/xdg-shell.xml", 
@@ -73,12 +74,12 @@
       "wl_init.c", 
       "wl_monitor.c", 
       "wl_window.c", 
-      "linux_joystick.c", 
       "posix_time.c", 
       "posix_thread.c", 
       "xkb_unicode.c", 
       "egl_context.c", 
-      "osmesa_context.c"
+      "osmesa_context.c", 
+      "linux_joystick.c"
     ]
   }, 
   "wayland_protocols": [

glfw/win32_window.c

@@ -1474,9 +1474,9 @@ void _glfwPlatformRequestWindowAttention(_GLFWwindow* window)
     FlashWindow(window->win32.handle, TRUE);
 }
 
-int _glfwPlatformWindowBell(_GLFWwindow* window, int64_t param)
+int _glfwPlatformWindowBell(_GLFWwindow* window)
 {
-    return MessageBeep(0xFFFFFFFF & param) ? GLFW_TRUE : GLFW_FALSE;
+    return MessageBeep(0xFFFFFFFF) ? GLFW_TRUE : GLFW_FALSE;
 }
 
 void _glfwPlatformFocusWindow(_GLFWwindow* window)
@@ -2014,4 +2014,3 @@ GLFWAPI HWND glfwGetWin32Window(GLFWwindow* handle)
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     return window->win32.handle;
 }
-

glfw/window.c

@@ -768,14 +768,14 @@ GLFWAPI void glfwRequestWindowAttention(GLFWwindow* handle)
     _glfwPlatformRequestWindowAttention(window);
 }
 
-GLFWAPI int glfwWindowBell(GLFWwindow* handle, int64_t param)
+GLFWAPI int glfwWindowBell(GLFWwindow* handle)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
     _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
 
-    return _glfwPlatformWindowBell(window, param);
+    return _glfwPlatformWindowBell(window);
 }
 
 GLFWAPI void glfwHideWindow(GLFWwindow* handle)
@@ -1106,4 +1106,3 @@ GLFWAPI void glfwPostEmptyEvent(void)
 
     _glfwPlatformPostEmptyEvent();
 }
-

glfw/wl_init.c

@@ -32,7 +32,6 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/mman.h>
-#include <sys/timerfd.h>
 #include <unistd.h>
 #include <wayland-client.h>
 
@@ -350,16 +349,7 @@ static void keyboardHandleKeymap(void* data,
                                  int fd,
                                  uint32_t size)
 {
-    struct xkb_keymap* keymap;
-    struct xkb_state* state;
-
-#ifdef HAVE_XKBCOMMON_COMPOSE_H
-    struct xkb_compose_table* composeTable;
-    struct xkb_compose_state* composeState;
-#endif
-
     char* mapStr;
-    const char* locale;
 
     if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1)
     {
@@ -372,78 +362,10 @@ static void keyboardHandleKeymap(void* data,
         close(fd);
         return;
     }
-
-    keymap = xkb_keymap_new_from_string(_glfw.wl.xkb.context,
-                                        mapStr,
-                                        XKB_KEYMAP_FORMAT_TEXT_V1,
-                                        0);
+    xkb_glfw_compile_keymap(mapStr);
     munmap(mapStr, size);
     close(fd);
 
-    if (!keymap)
-    {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Wayland: Failed to compile keymap");
-        return;
-    }
-
-    state = xkb_state_new(keymap);
-    if (!state)
-    {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Wayland: Failed to create XKB state");
-        xkb_keymap_unref(keymap);
-        return;
-    }
-
-    // Look up the preferred locale, falling back to "C" as default.
-    locale = getenv("LC_ALL");
-    if (!locale)
-        locale = getenv("LC_CTYPE");
-    if (!locale)
-        locale = getenv("LANG");
-    if (!locale)
-        locale = "C";
-
-#ifdef HAVE_XKBCOMMON_COMPOSE_H
-    composeTable =
-        xkb_compose_table_new_from_locale(_glfw.wl.xkb.context, locale,
-                                          XKB_COMPOSE_COMPILE_NO_FLAGS);
-    if (composeTable)
-    {
-        composeState =
-            xkb_compose_state_new(composeTable, XKB_COMPOSE_STATE_NO_FLAGS);
-        xkb_compose_table_unref(composeTable);
-        if (composeState)
-            _glfw.wl.xkb.composeState = composeState;
-        else
-            _glfwInputError(GLFW_PLATFORM_ERROR,
-                            "Wayland: Failed to create XKB compose state");
-    }
-    else
-    {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Wayland: Failed to create XKB compose table");
-    }
-#endif
-
-    xkb_keymap_unref(_glfw.wl.xkb.keymap);
-    xkb_state_unref(_glfw.wl.xkb.state);
-    _glfw.wl.xkb.keymap = keymap;
-    _glfw.wl.xkb.state = state;
-
-    _glfw.wl.xkb.controlMask =
-        1 << xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Control");
-    _glfw.wl.xkb.altMask =
-        1 << xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Mod1");
-    _glfw.wl.xkb.shiftMask =
-        1 << xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Shift");
-    _glfw.wl.xkb.superMask =
-        1 << xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Mod4");
-    _glfw.wl.xkb.capsLockMask =
-        1 << xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Lock");
-    _glfw.wl.xkb.numLockMask =
-        1 << xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Mod2");
 }
 
 static void keyboardHandleEnter(void* data,
@@ -482,15 +404,6 @@ static void keyboardHandleLeave(void* data,
     _glfwInputWindowFocus(window, GLFW_FALSE);
 }
 
-static int toGLFWKeyCode(uint32_t key)
-{
-    if (key < sizeof(_glfw.wl.keycodes) / sizeof(_glfw.wl.keycodes[0]))
-        return _glfw.wl.keycodes[key];
-
-    return GLFW_KEY_UNKNOWN;
-}
-
-#ifdef HAVE_XKBCOMMON_COMPOSE_H
 static xkb_keysym_t composeSymbol(xkb_keysym_t sym)
 {
     if (sym == XKB_KEY_NoSymbol || !_glfw.wl.xkb.composeState)
@@ -510,9 +423,8 @@ static xkb_keysym_t composeSymbol(xkb_keysym_t sym)
             return sym;
     }
 }
-#endif
 
-static GLFWbool inputChar(_GLFWwindow* window, uint32_t key)
+static void inputChar(_GLFWwindow* window, uint32_t key, GLFWbool *shouldRepeat)
 {
     uint32_t code, numSyms;
     long cp;
@@ -521,24 +433,23 @@ static GLFWbool inputChar(_GLFWwindow* window, uint32_t key)
 
     code = key + 8;
     numSyms = xkb_state_key_get_syms(_glfw.wl.xkb.state, code, &syms);
+    *shouldRepeat = xkb_keymap_key_repeats(_glfw.wl.xkb.keymap, code);
 
     if (numSyms == 1)
     {
-#ifdef HAVE_XKBCOMMON_COMPOSE_H
         sym = composeSymbol(syms[0]);
-#else
-        sym = syms[0];
-#endif
         cp = _glfwKeySym2Unicode(sym);
         if (cp != -1)
         {
             const int mods = _glfw.wl.xkb.modifiers;
             const int plain = !(mods & (GLFW_MOD_CONTROL | GLFW_MOD_ALT));
+            if (*shouldRepeat) {
+                _glfw.wl.keyRepeatInfo.codepoint = cp;
+                _glfw.wl.keyRepeatInfo.plain = plain;
+            }
             _glfwInputChar(window, cp, mods, plain);
         }
     }
-
-    return xkb_keymap_key_repeats(_glfw.wl.xkb.keymap, syms[0]);
 }
 
 static void keyboardHandleKey(void* data,
@@ -551,34 +462,32 @@ static void keyboardHandleKey(void* data,
     int keyCode;
     int action;
     _GLFWwindow* window = _glfw.wl.keyboardFocus;
-    GLFWbool shouldRepeat;
-    struct itimerspec timer = {};
 
     if (!window)
         return;
 
-    keyCode = toGLFWKeyCode(key);
+    keyCode = xkb_glfw_to_glfw_key_code(key);
     action = state == WL_KEYBOARD_KEY_STATE_PRESSED
             ? GLFW_PRESS : GLFW_RELEASE;
+    _glfw.wl.keyRepeatInfo.nextRepeatAt = 0;
+    _glfw.wl.keyRepeatInfo.codepoint = -1;
 
     _glfwInputKey(window, keyCode, key, action,
                   _glfw.wl.xkb.modifiers);
 
     if (action == GLFW_PRESS)
     {
-        shouldRepeat = inputChar(window, key);
+        GLFWbool shouldRepeat = GLFW_FALSE;
+        inputChar(window, key, &shouldRepeat);
 
         if (shouldRepeat && _glfw.wl.keyboardRepeatRate > 0)
         {
-            _glfw.wl.keyboardLastKey = keyCode;
-            _glfw.wl.keyboardLastScancode = key;
-            timer.it_interval.tv_sec = _glfw.wl.keyboardRepeatRate / 1000;
-            timer.it_interval.tv_nsec = (_glfw.wl.keyboardRepeatRate % 1000) * 1000000;
-            timer.it_value.tv_sec = _glfw.wl.keyboardRepeatDelay / 1000;
-            timer.it_value.tv_nsec = (_glfw.wl.keyboardRepeatDelay % 1000) * 1000000;
+            _glfw.wl.keyRepeatInfo.glfwKeyCode = keyCode;
+            _glfw.wl.keyRepeatInfo.scancode = key;
+            _glfw.wl.keyRepeatInfo.nextRepeatAt = glfwGetTime() + (double)(_glfw.wl.keyboardRepeatDelay) / 1000.0;
+            _glfw.wl.keyRepeatInfo.keyboardFocus = window;
         }
     }
-    timerfd_settime(_glfw.wl.timerfd, 0, &timer, NULL);
 }
 
 static void keyboardHandleModifiers(void* data,
@@ -589,41 +498,9 @@ static void keyboardHandleModifiers(void* data,
                                     uint32_t modsLocked,
                                     uint32_t group)
 {
-    xkb_mod_mask_t mask;
-    unsigned int modifiers = 0;
-
-    if (!_glfw.wl.xkb.keymap)
-        return;
-
-    xkb_state_update_mask(_glfw.wl.xkb.state,
-                          modsDepressed,
-                          modsLatched,
-                          modsLocked,
-                          0,
-                          0,
-                          group);
-
-    mask = xkb_state_serialize_mods(_glfw.wl.xkb.state,
-                                    XKB_STATE_MODS_DEPRESSED |
-                                    XKB_STATE_LAYOUT_DEPRESSED |
-                                    XKB_STATE_MODS_LATCHED |
-                                    XKB_STATE_LAYOUT_LATCHED);
-    if (mask & _glfw.wl.xkb.controlMask)
-        modifiers |= GLFW_MOD_CONTROL;
-    if (mask & _glfw.wl.xkb.altMask)
-        modifiers |= GLFW_MOD_ALT;
-    if (mask & _glfw.wl.xkb.shiftMask)
-        modifiers |= GLFW_MOD_SHIFT;
-    if (mask & _glfw.wl.xkb.superMask)
-        modifiers |= GLFW_MOD_SUPER;
-    if (mask & _glfw.wl.xkb.capsLockMask)
-        modifiers |= GLFW_MOD_CAPS_LOCK;
-    if (mask & _glfw.wl.xkb.numLockMask)
-        modifiers |= GLFW_MOD_NUM_LOCK;
-    _glfw.wl.xkb.modifiers = modifiers;
+    xkb_glfw_update_modifiers(modsDepressed, modsLatched, modsLocked, group);
 }
 
-#ifdef WL_KEYBOARD_REPEAT_INFO_SINCE_VERSION
 static void keyboardHandleRepeatInfo(void* data,
                                      struct wl_keyboard* keyboard,
                                      int32_t rate,
@@ -635,7 +512,6 @@ static void keyboardHandleRepeatInfo(void* data,
     _glfw.wl.keyboardRepeatRate = rate;
     _glfw.wl.keyboardRepeatDelay = delay;
 }
-#endif
 
 static const struct wl_keyboard_listener keyboardListener = {
     keyboardHandleKeymap,
@@ -643,9 +519,7 @@ static const struct wl_keyboard_listener keyboardListener = {
     keyboardHandleLeave,
     keyboardHandleKey,
     keyboardHandleModifiers,
-#ifdef WL_KEYBOARD_REPEAT_INFO_SINCE_VERSION
     keyboardHandleRepeatInfo,
-#endif
 };
 
 static void seatHandleCapabilities(void* data,
@@ -798,140 +672,6 @@ static const struct wl_registry_listener registryListener = {
     registryHandleGlobalRemove
 };
 
-// Create key code translation tables
-//
-static void createKeyTables(void)
-{
-    int scancode;
-
-    memset(_glfw.wl.keycodes, -1, sizeof(_glfw.wl.keycodes));
-    memset(_glfw.wl.scancodes, -1, sizeof(_glfw.wl.scancodes));
-
-    _glfw.wl.keycodes[KEY_GRAVE]      = GLFW_KEY_GRAVE_ACCENT;
-    _glfw.wl.keycodes[KEY_1]          = GLFW_KEY_1;
-    _glfw.wl.keycodes[KEY_2]          = GLFW_KEY_2;
-    _glfw.wl.keycodes[KEY_3]          = GLFW_KEY_3;
-    _glfw.wl.keycodes[KEY_4]          = GLFW_KEY_4;
-    _glfw.wl.keycodes[KEY_5]          = GLFW_KEY_5;
-    _glfw.wl.keycodes[KEY_6]          = GLFW_KEY_6;
-    _glfw.wl.keycodes[KEY_7]          = GLFW_KEY_7;
-    _glfw.wl.keycodes[KEY_8]          = GLFW_KEY_8;
-    _glfw.wl.keycodes[KEY_9]          = GLFW_KEY_9;
-    _glfw.wl.keycodes[KEY_0]          = GLFW_KEY_0;
-    _glfw.wl.keycodes[KEY_SPACE]      = GLFW_KEY_SPACE;
-    _glfw.wl.keycodes[KEY_MINUS]      = GLFW_KEY_MINUS;
-    _glfw.wl.keycodes[KEY_EQUAL]      = GLFW_KEY_EQUAL;
-    _glfw.wl.keycodes[KEY_Q]          = GLFW_KEY_Q;
-    _glfw.wl.keycodes[KEY_W]          = GLFW_KEY_W;
-    _glfw.wl.keycodes[KEY_E]          = GLFW_KEY_E;
-    _glfw.wl.keycodes[KEY_R]          = GLFW_KEY_R;
-    _glfw.wl.keycodes[KEY_T]          = GLFW_KEY_T;
-    _glfw.wl.keycodes[KEY_Y]          = GLFW_KEY_Y;
-    _glfw.wl.keycodes[KEY_U]          = GLFW_KEY_U;
-    _glfw.wl.keycodes[KEY_I]          = GLFW_KEY_I;
-    _glfw.wl.keycodes[KEY_O]          = GLFW_KEY_O;
-    _glfw.wl.keycodes[KEY_P]          = GLFW_KEY_P;
-    _glfw.wl.keycodes[KEY_LEFTBRACE]  = GLFW_KEY_LEFT_BRACKET;
-    _glfw.wl.keycodes[KEY_RIGHTBRACE] = GLFW_KEY_RIGHT_BRACKET;
-    _glfw.wl.keycodes[KEY_A]          = GLFW_KEY_A;
-    _glfw.wl.keycodes[KEY_S]          = GLFW_KEY_S;
-    _glfw.wl.keycodes[KEY_D]          = GLFW_KEY_D;
-    _glfw.wl.keycodes[KEY_F]          = GLFW_KEY_F;
-    _glfw.wl.keycodes[KEY_G]          = GLFW_KEY_G;
-    _glfw.wl.keycodes[KEY_H]          = GLFW_KEY_H;
-    _glfw.wl.keycodes[KEY_J]          = GLFW_KEY_J;
-    _glfw.wl.keycodes[KEY_K]          = GLFW_KEY_K;
-    _glfw.wl.keycodes[KEY_L]          = GLFW_KEY_L;
-    _glfw.wl.keycodes[KEY_SEMICOLON]  = GLFW_KEY_SEMICOLON;
-    _glfw.wl.keycodes[KEY_APOSTROPHE] = GLFW_KEY_APOSTROPHE;
-    _glfw.wl.keycodes[KEY_Z]          = GLFW_KEY_Z;
-    _glfw.wl.keycodes[KEY_X]          = GLFW_KEY_X;
-    _glfw.wl.keycodes[KEY_C]          = GLFW_KEY_C;
-    _glfw.wl.keycodes[KEY_V]          = GLFW_KEY_V;
-    _glfw.wl.keycodes[KEY_B]          = GLFW_KEY_B;
-    _glfw.wl.keycodes[KEY_N]          = GLFW_KEY_N;
-    _glfw.wl.keycodes[KEY_M]          = GLFW_KEY_M;
-    _glfw.wl.keycodes[KEY_COMMA]      = GLFW_KEY_COMMA;
-    _glfw.wl.keycodes[KEY_DOT]        = GLFW_KEY_PERIOD;
-    _glfw.wl.keycodes[KEY_SLASH]      = GLFW_KEY_SLASH;
-    _glfw.wl.keycodes[KEY_BACKSLASH]  = GLFW_KEY_BACKSLASH;
-    _glfw.wl.keycodes[KEY_ESC]        = GLFW_KEY_ESCAPE;
-    _glfw.wl.keycodes[KEY_TAB]        = GLFW_KEY_TAB;
-    _glfw.wl.keycodes[KEY_LEFTSHIFT]  = GLFW_KEY_LEFT_SHIFT;
-    _glfw.wl.keycodes[KEY_RIGHTSHIFT] = GLFW_KEY_RIGHT_SHIFT;
-    _glfw.wl.keycodes[KEY_LEFTCTRL]   = GLFW_KEY_LEFT_CONTROL;
-    _glfw.wl.keycodes[KEY_RIGHTCTRL]  = GLFW_KEY_RIGHT_CONTROL;
-    _glfw.wl.keycodes[KEY_LEFTALT]    = GLFW_KEY_LEFT_ALT;
-    _glfw.wl.keycodes[KEY_RIGHTALT]   = GLFW_KEY_RIGHT_ALT;
-    _glfw.wl.keycodes[KEY_LEFTMETA]   = GLFW_KEY_LEFT_SUPER;
-    _glfw.wl.keycodes[KEY_RIGHTMETA]  = GLFW_KEY_RIGHT_SUPER;
-    _glfw.wl.keycodes[KEY_MENU]       = GLFW_KEY_MENU;
-    _glfw.wl.keycodes[KEY_NUMLOCK]    = GLFW_KEY_NUM_LOCK;
-    _glfw.wl.keycodes[KEY_CAPSLOCK]   = GLFW_KEY_CAPS_LOCK;
-    _glfw.wl.keycodes[KEY_PRINT]      = GLFW_KEY_PRINT_SCREEN;
-    _glfw.wl.keycodes[KEY_SCROLLLOCK] = GLFW_KEY_SCROLL_LOCK;
-    _glfw.wl.keycodes[KEY_PAUSE]      = GLFW_KEY_PAUSE;
-    _glfw.wl.keycodes[KEY_DELETE]     = GLFW_KEY_DELETE;
-    _glfw.wl.keycodes[KEY_BACKSPACE]  = GLFW_KEY_BACKSPACE;
-    _glfw.wl.keycodes[KEY_ENTER]      = GLFW_KEY_ENTER;
-    _glfw.wl.keycodes[KEY_HOME]       = GLFW_KEY_HOME;
-    _glfw.wl.keycodes[KEY_END]        = GLFW_KEY_END;
-    _glfw.wl.keycodes[KEY_PAGEUP]     = GLFW_KEY_PAGE_UP;
-    _glfw.wl.keycodes[KEY_PAGEDOWN]   = GLFW_KEY_PAGE_DOWN;
-    _glfw.wl.keycodes[KEY_INSERT]     = GLFW_KEY_INSERT;
-    _glfw.wl.keycodes[KEY_LEFT]       = GLFW_KEY_LEFT;
-    _glfw.wl.keycodes[KEY_RIGHT]      = GLFW_KEY_RIGHT;
-    _glfw.wl.keycodes[KEY_DOWN]       = GLFW_KEY_DOWN;
-    _glfw.wl.keycodes[KEY_UP]         = GLFW_KEY_UP;
-    _glfw.wl.keycodes[KEY_F1]         = GLFW_KEY_F1;
-    _glfw.wl.keycodes[KEY_F2]         = GLFW_KEY_F2;
-    _glfw.wl.keycodes[KEY_F3]         = GLFW_KEY_F3;
-    _glfw.wl.keycodes[KEY_F4]         = GLFW_KEY_F4;
-    _glfw.wl.keycodes[KEY_F5]         = GLFW_KEY_F5;
-    _glfw.wl.keycodes[KEY_F6]         = GLFW_KEY_F6;
-    _glfw.wl.keycodes[KEY_F7]         = GLFW_KEY_F7;
-    _glfw.wl.keycodes[KEY_F8]         = GLFW_KEY_F8;
-    _glfw.wl.keycodes[KEY_F9]         = GLFW_KEY_F9;
-    _glfw.wl.keycodes[KEY_F10]        = GLFW_KEY_F10;
-    _glfw.wl.keycodes[KEY_F11]        = GLFW_KEY_F11;
-    _glfw.wl.keycodes[KEY_F12]        = GLFW_KEY_F12;
-    _glfw.wl.keycodes[KEY_F13]        = GLFW_KEY_F13;
-    _glfw.wl.keycodes[KEY_F14]        = GLFW_KEY_F14;
-    _glfw.wl.keycodes[KEY_F15]        = GLFW_KEY_F15;
-    _glfw.wl.keycodes[KEY_F16]        = GLFW_KEY_F16;
-    _glfw.wl.keycodes[KEY_F17]        = GLFW_KEY_F17;
-    _glfw.wl.keycodes[KEY_F18]        = GLFW_KEY_F18;
-    _glfw.wl.keycodes[KEY_F19]        = GLFW_KEY_F19;
-    _glfw.wl.keycodes[KEY_F20]        = GLFW_KEY_F20;
-    _glfw.wl.keycodes[KEY_F21]        = GLFW_KEY_F21;
-    _glfw.wl.keycodes[KEY_F22]        = GLFW_KEY_F22;
-    _glfw.wl.keycodes[KEY_F23]        = GLFW_KEY_F23;
-    _glfw.wl.keycodes[KEY_F24]        = GLFW_KEY_F24;
-    _glfw.wl.keycodes[KEY_KPSLASH]    = GLFW_KEY_KP_DIVIDE;
-    _glfw.wl.keycodes[KEY_KPDOT]      = GLFW_KEY_KP_MULTIPLY;
-    _glfw.wl.keycodes[KEY_KPMINUS]    = GLFW_KEY_KP_SUBTRACT;
-    _glfw.wl.keycodes[KEY_KPPLUS]     = GLFW_KEY_KP_ADD;
-    _glfw.wl.keycodes[KEY_KP0]        = GLFW_KEY_KP_0;
-    _glfw.wl.keycodes[KEY_KP1]        = GLFW_KEY_KP_1;
-    _glfw.wl.keycodes[KEY_KP2]        = GLFW_KEY_KP_2;
-    _glfw.wl.keycodes[KEY_KP3]        = GLFW_KEY_KP_3;
-    _glfw.wl.keycodes[KEY_KP4]        = GLFW_KEY_KP_4;
-    _glfw.wl.keycodes[KEY_KP5]        = GLFW_KEY_KP_5;
-    _glfw.wl.keycodes[KEY_KP6]        = GLFW_KEY_KP_6;
-    _glfw.wl.keycodes[KEY_KP7]        = GLFW_KEY_KP_7;
-    _glfw.wl.keycodes[KEY_KP8]        = GLFW_KEY_KP_8;
-    _glfw.wl.keycodes[KEY_KP9]        = GLFW_KEY_KP_9;
-    _glfw.wl.keycodes[KEY_KPCOMMA]    = GLFW_KEY_KP_DECIMAL;
-    _glfw.wl.keycodes[KEY_KPEQUAL]    = GLFW_KEY_KP_EQUAL;
-    _glfw.wl.keycodes[KEY_KPENTER]    = GLFW_KEY_KP_ENTER;
-
-    for (scancode = 0;  scancode < 256;  scancode++)
-    {
-        if (_glfw.wl.keycodes[scancode] > 0)
-            _glfw.wl.scancodes[_glfw.wl.keycodes[scancode]] = scancode;
-    }
-}
-
 
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW platform API                      //////
@@ -971,53 +711,7 @@ int _glfwPlatformInit(void)
     _glfw.wl.egl.window_resize = (PFN_wl_egl_window_resize)
         _glfw_dlsym(_glfw.wl.egl.handle, "wl_egl_window_resize");
 
-    _glfw.wl.xkb.handle = _glfw_dlopen("libxkbcommon.so.0");
-    if (!_glfw.wl.xkb.handle)
-    {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Wayland: Failed to open libxkbcommon");
-        return GLFW_FALSE;
-    }
-
-    _glfw.wl.xkb.context_new = (PFN_xkb_context_new)
-        _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_context_new");
-    _glfw.wl.xkb.context_unref = (PFN_xkb_context_unref)
-        _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_context_unref");
-    _glfw.wl.xkb.keymap_new_from_string = (PFN_xkb_keymap_new_from_string)
-        _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_keymap_new_from_string");
-    _glfw.wl.xkb.keymap_unref = (PFN_xkb_keymap_unref)
-        _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_keymap_unref");
-    _glfw.wl.xkb.keymap_mod_get_index = (PFN_xkb_keymap_mod_get_index)
-        _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_keymap_mod_get_index");
-    _glfw.wl.xkb.keymap_key_repeats = (PFN_xkb_keymap_key_repeats)
-        _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_keymap_key_repeats");
-    _glfw.wl.xkb.state_new = (PFN_xkb_state_new)
-        _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_state_new");
-    _glfw.wl.xkb.state_unref = (PFN_xkb_state_unref)
-        _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_state_unref");
-    _glfw.wl.xkb.state_key_get_syms = (PFN_xkb_state_key_get_syms)
-        _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_state_key_get_syms");
-    _glfw.wl.xkb.state_update_mask = (PFN_xkb_state_update_mask)
-        _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_state_update_mask");
-    _glfw.wl.xkb.state_serialize_mods = (PFN_xkb_state_serialize_mods)
-        _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_state_serialize_mods");
-
-#ifdef HAVE_XKBCOMMON_COMPOSE_H
-    _glfw.wl.xkb.compose_table_new_from_locale = (PFN_xkb_compose_table_new_from_locale)
-        _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_compose_table_new_from_locale");
-    _glfw.wl.xkb.compose_table_unref = (PFN_xkb_compose_table_unref)
-        _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_compose_table_unref");
-    _glfw.wl.xkb.compose_state_new = (PFN_xkb_compose_state_new)
-        _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_compose_state_new");
-    _glfw.wl.xkb.compose_state_unref = (PFN_xkb_compose_state_unref)
-        _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_compose_state_unref");
-    _glfw.wl.xkb.compose_state_feed = (PFN_xkb_compose_state_feed)
-        _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_compose_state_feed");
-    _glfw.wl.xkb.compose_state_get_status = (PFN_xkb_compose_state_get_status)
-        _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_compose_state_get_status");
-    _glfw.wl.xkb.compose_state_get_one_sym = (PFN_xkb_compose_state_get_one_sym)
-        _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_compose_state_get_one_sym");
-#endif
+    load_glfw_xkb();
 
     _glfw.wl.display = wl_display_connect(NULL);
     if (!_glfw.wl.display)
@@ -1030,15 +724,7 @@ int _glfwPlatformInit(void)
     _glfw.wl.registry = wl_display_get_registry(_glfw.wl.display);
     wl_registry_add_listener(_glfw.wl.registry, &registryListener, NULL);
 
-    createKeyTables();
-
-    _glfw.wl.xkb.context = xkb_context_new(0);
-    if (!_glfw.wl.xkb.context)
-    {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Wayland: Failed to initialize xkb context");
-        return GLFW_FALSE;
-    }
+    create_glfw_xkb_context();
 
     // Sync so we got all registry objects
     wl_display_roundtrip(_glfw.wl.display);
@@ -1046,15 +732,13 @@ int _glfwPlatformInit(void)
     // Sync so we got all initial output events
     wl_display_roundtrip(_glfw.wl.display);
 
+#ifdef __linux__
     if (!_glfwInitJoysticksLinux())
         return GLFW_FALSE;
+#endif
 
     _glfwInitTimerPOSIX();
 
-    _glfw.wl.timerfd = -1;
-    if (_glfw.wl.seatVersion >= 4)
-        _glfw.wl.timerfd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC);
-
     if (_glfw.wl.pointer && _glfw.wl.shm)
     {
         _glfw.wl.cursorTheme = wl_cursor_theme_load(NULL, 32, _glfw.wl.shm);
@@ -1073,7 +757,9 @@ int _glfwPlatformInit(void)
 
 void _glfwPlatformTerminate(void)
 {
+#ifdef __linux__
     _glfwTerminateJoysticksLinux();
+#endif
     _glfwTerminateEGL();
     if (_glfw.wl.egl.handle)
     {
@@ -1081,21 +767,7 @@ void _glfwPlatformTerminate(void)
         _glfw.wl.egl.handle = NULL;
     }
 
-#ifdef HAVE_XKBCOMMON_COMPOSE_H
-    if (_glfw.wl.xkb.composeState)
-        xkb_compose_state_unref(_glfw.wl.xkb.composeState);
-#endif
-    if (_glfw.wl.xkb.keymap)
-        xkb_keymap_unref(_glfw.wl.xkb.keymap);
-    if (_glfw.wl.xkb.state)
-        xkb_state_unref(_glfw.wl.xkb.state);
-    if (_glfw.wl.xkb.context)
-        xkb_context_unref(_glfw.wl.xkb.context);
-    if (_glfw.wl.xkb.handle)
-    {
-        _glfw_dlclose(_glfw.wl.xkb.handle);
-        _glfw.wl.xkb.handle = NULL;
-    }
+    release_glfw_xkb();
 
     if (_glfw.wl.cursorTheme)
         wl_cursor_theme_destroy(_glfw.wl.cursorTheme);
@@ -1154,4 +826,3 @@ const char* _glfwPlatformGetVersionString(void)
 #endif
         ;
 }
-

glfw/wl_platform.h

@@ -25,10 +25,6 @@
 //========================================================================
 
 #include <wayland-client.h>
-#include <xkbcommon/xkbcommon.h>
-#ifdef HAVE_XKBCOMMON_COMPOSE_H
-#include <xkbcommon/xkbcommon-compose.h>
-#endif
 #include <dlfcn.h>
 
 typedef VkFlags VkWaylandSurfaceCreateFlagsKHR;
@@ -47,7 +43,13 @@ typedef VkBool32 (APIENTRY *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR
 
 #include "posix_thread.h"
 #include "posix_time.h"
+#ifdef __linux__
 #include "linux_joystick.h"
+#else
+#include "null_joystick.h"
+#endif
+#define GLFW_XKB_GLOBAL_NAME _glfw.wl.xkb
+#include "xkb_glfw.h"
 #include "xkb_unicode.h"
 #include "egl_context.h"
 #include "osmesa_context.h"
@@ -101,46 +103,6 @@ typedef void (* PFN_wl_egl_window_resize)(struct wl_egl_window*, int, int, int,
 #define wl_egl_window_destroy _glfw.wl.egl.window_destroy
 #define wl_egl_window_resize _glfw.wl.egl.window_resize
 
-typedef struct xkb_context* (* PFN_xkb_context_new)(enum xkb_context_flags);
-typedef void (* PFN_xkb_context_unref)(struct xkb_context*);
-typedef struct xkb_keymap* (* PFN_xkb_keymap_new_from_string)(struct xkb_context*, const char*, enum xkb_keymap_format, enum xkb_keymap_compile_flags);
-typedef void (* PFN_xkb_keymap_unref)(struct xkb_keymap*);
-typedef xkb_mod_index_t (* PFN_xkb_keymap_mod_get_index)(struct xkb_keymap*, const char*);
-typedef int (* PFN_xkb_keymap_key_repeats)(struct xkb_keymap*, xkb_keycode_t);
-typedef struct xkb_state* (* PFN_xkb_state_new)(struct xkb_keymap*);
-typedef void (* PFN_xkb_state_unref)(struct xkb_state*);
-typedef int (* PFN_xkb_state_key_get_syms)(struct xkb_state*, xkb_keycode_t, const xkb_keysym_t**);
-typedef enum xkb_state_component (* PFN_xkb_state_update_mask)(struct xkb_state*, xkb_mod_mask_t, xkb_mod_mask_t, xkb_mod_mask_t, xkb_layout_index_t, xkb_layout_index_t, xkb_layout_index_t);
-typedef xkb_mod_mask_t (* PFN_xkb_state_serialize_mods)(struct xkb_state*, enum xkb_state_component);
-#define xkb_context_new _glfw.wl.xkb.context_new
-#define xkb_context_unref _glfw.wl.xkb.context_unref
-#define xkb_keymap_new_from_string _glfw.wl.xkb.keymap_new_from_string
-#define xkb_keymap_unref _glfw.wl.xkb.keymap_unref
-#define xkb_keymap_mod_get_index _glfw.wl.xkb.keymap_mod_get_index
-#define xkb_keymap_key_repeats _glfw.wl.xkb.keymap_key_repeats
-#define xkb_state_new _glfw.wl.xkb.state_new
-#define xkb_state_unref _glfw.wl.xkb.state_unref
-#define xkb_state_key_get_syms _glfw.wl.xkb.state_key_get_syms
-#define xkb_state_update_mask _glfw.wl.xkb.state_update_mask
-#define xkb_state_serialize_mods _glfw.wl.xkb.state_serialize_mods
-
-#ifdef HAVE_XKBCOMMON_COMPOSE_H
-typedef struct xkb_compose_table* (* PFN_xkb_compose_table_new_from_locale)(struct xkb_context*, const char*, enum xkb_compose_compile_flags);
-typedef void (* PFN_xkb_compose_table_unref)(struct xkb_compose_table*);
-typedef struct xkb_compose_state* (* PFN_xkb_compose_state_new)(struct xkb_compose_table*, enum xkb_compose_state_flags);
-typedef void (* PFN_xkb_compose_state_unref)(struct xkb_compose_state*);
-typedef enum xkb_compose_feed_result (* PFN_xkb_compose_state_feed)(struct xkb_compose_state*, xkb_keysym_t);
-typedef enum xkb_compose_status (* PFN_xkb_compose_state_get_status)(struct xkb_compose_state*);
-typedef xkb_keysym_t (* PFN_xkb_compose_state_get_one_sym)(struct xkb_compose_state*);
-#define xkb_compose_table_new_from_locale _glfw.wl.xkb.compose_table_new_from_locale
-#define xkb_compose_table_unref _glfw.wl.xkb.compose_table_unref
-#define xkb_compose_state_new _glfw.wl.xkb.compose_state_new
-#define xkb_compose_state_unref _glfw.wl.xkb.compose_state_unref
-#define xkb_compose_state_feed _glfw.wl.xkb.compose_state_feed
-#define xkb_compose_state_get_status _glfw.wl.xkb.compose_state_get_status
-#define xkb_compose_state_get_one_sym _glfw.wl.xkb.compose_state_get_one_sym
-#endif
-
 #define _GLFW_DECORATION_WIDTH 4
 #define _GLFW_DECORATION_TOP 24
 #define _GLFW_DECORATION_VERTICAL (_GLFW_DECORATION_TOP + _GLFW_DECORATION_WIDTH)
@@ -241,52 +203,15 @@ typedef struct _GLFWlibraryWayland
 
     int32_t                     keyboardRepeatRate;
     int32_t                     keyboardRepeatDelay;
-    int                         keyboardLastKey;
-    int                         keyboardLastScancode;
-    int                         timerfd;
-    short int                   keycodes[256];
-    short int                   scancodes[GLFW_KEY_LAST + 1];
-
     struct {
-        void*                   handle;
-        struct xkb_context*     context;
-        struct xkb_keymap*      keymap;
-        struct xkb_state*       state;
-
-#ifdef HAVE_XKBCOMMON_COMPOSE_H
-        struct xkb_compose_state* composeState;
-#endif
-
-        xkb_mod_mask_t          controlMask;
-        xkb_mod_mask_t          altMask;
-        xkb_mod_mask_t          shiftMask;
-        xkb_mod_mask_t          superMask;
-        xkb_mod_mask_t          capsLockMask;
-        xkb_mod_mask_t          numLockMask;
-        unsigned int            modifiers;
-
-        PFN_xkb_context_new context_new;
-        PFN_xkb_context_unref context_unref;
-        PFN_xkb_keymap_new_from_string keymap_new_from_string;
-        PFN_xkb_keymap_unref keymap_unref;
-        PFN_xkb_keymap_mod_get_index keymap_mod_get_index;
-        PFN_xkb_keymap_key_repeats keymap_key_repeats;
-        PFN_xkb_state_new state_new;
-        PFN_xkb_state_unref state_unref;
-        PFN_xkb_state_key_get_syms state_key_get_syms;
-        PFN_xkb_state_update_mask state_update_mask;
-        PFN_xkb_state_serialize_mods state_serialize_mods;
-
-#ifdef HAVE_XKBCOMMON_COMPOSE_H
-        PFN_xkb_compose_table_new_from_locale compose_table_new_from_locale;
-        PFN_xkb_compose_table_unref compose_table_unref;
-        PFN_xkb_compose_state_new compose_state_new;
-        PFN_xkb_compose_state_unref compose_state_unref;
-        PFN_xkb_compose_state_feed compose_state_feed;
-        PFN_xkb_compose_state_get_status compose_state_get_status;
-        PFN_xkb_compose_state_get_one_sym compose_state_get_one_sym;
-#endif
-    } xkb;
+        long                    codepoint;
+        int                     plain;
+        int                     glfwKeyCode;
+        int                     scancode;
+        double                  nextRepeatAt;
+        _GLFWwindow*            keyboardFocus;
+    } keyRepeatInfo;
+    _GLFWXKBData                xkb;
 
     _GLFWwindow*                pointerFocus;
     _GLFWwindow*                keyboardFocus;
@@ -336,4 +261,3 @@ typedef struct _GLFWcursorWayland
 
 
 void _glfwAddOutputWayland(uint32_t name, uint32_t version);
-

glfw/wl_window.c

@@ -35,7 +35,6 @@
 #include <string.h>
 #include <fcntl.h>
 #include <sys/mman.h>
-#include <sys/timerfd.h>
 #include <poll.h>
 
 
@@ -690,16 +689,34 @@ static GLFWbool createXdgSurface(_GLFWwindow* window)
     return GLFW_TRUE;
 }
 
+static void
+dispatchPendingKeyRepeats() {
+    if (_glfw.wl.keyRepeatInfo.nextRepeatAt <= 0 || _glfw.wl.keyRepeatInfo.keyboardFocus != _glfw.wl.keyboardFocus || _glfw.wl.keyboardRepeatRate == 0) return;
+    double now = glfwGetTime();
+    const int mods = _glfw.wl.xkb.modifiers;
+    while (_glfw.wl.keyRepeatInfo.nextRepeatAt <= now) {
+        _glfwInputKey(_glfw.wl.keyRepeatInfo.keyboardFocus, _glfw.wl.keyRepeatInfo.glfwKeyCode, _glfw.wl.keyRepeatInfo.scancode, GLFW_REPEAT, mods);
+        if (_glfw.wl.keyRepeatInfo.codepoint > -1) _glfwInputChar(_glfw.wl.keyRepeatInfo.keyboardFocus, _glfw.wl.keyRepeatInfo.codepoint, mods, _glfw.wl.keyRepeatInfo.plain);
+        _glfw.wl.keyRepeatInfo.nextRepeatAt += 1.0 / _glfw.wl.keyboardRepeatRate;
+        now = glfwGetTime();
+    }
+}
+
+static int
+adjustTimeoutForKeyRepeat(int timeout) {
+    if (_glfw.wl.keyRepeatInfo.nextRepeatAt <= 0 || _glfw.wl.keyRepeatInfo.keyboardFocus != _glfw.wl.keyboardFocus || _glfw.wl.keyboardRepeatRate == 0) return timeout;
+    double now = glfwGetTime();
+    if (timeout < 0 || now + timeout / 1000. > _glfw.wl.keyRepeatInfo.nextRepeatAt) {
+        timeout = _glfw.wl.keyRepeatInfo.nextRepeatAt <= now ? 0 : ( (_glfw.wl.keyRepeatInfo.nextRepeatAt - now) * 1000 + 1 );
+    }
+    return timeout;
+}
+
 static void
 handleEvents(int timeout)
 {
     struct wl_display* display = _glfw.wl.display;
-    struct pollfd fds[] = {
-        { wl_display_get_fd(display), POLLIN },
-        { _glfw.wl.timerfd, POLLIN },
-    };
-    ssize_t read_ret;
-    uint64_t repeats, i;
+    struct pollfd pfd = { wl_display_get_fd(display), POLLIN };
 
     while (wl_display_prepare_read(display) != 0)
         wl_display_dispatch_pending(display);
@@ -719,9 +736,12 @@ handleEvents(int timeout)
         return;
     }
 
-    if (poll(fds, 2, timeout) > 0)
+    dispatchPendingKeyRepeats();
+    timeout = adjustTimeoutForKeyRepeat(timeout);
+
+    if (poll(&pfd, 1, timeout) > 0)
     {
-        if (fds[0].revents & POLLIN)
+        if (pfd.revents & POLLIN)
         {
             wl_display_read_events(display);
             wl_display_dispatch_pending(display);
@@ -731,22 +751,12 @@ handleEvents(int timeout)
             wl_display_cancel_read(display);
         }
 
-        if (fds[1].revents & POLLIN)
-        {
-            read_ret = read(_glfw.wl.timerfd, &repeats, sizeof(repeats));
-            if (read_ret != 8)
-                return;
-
-            for (i = 0; i < repeats; ++i)
-                _glfwInputKey(_glfw.wl.keyboardFocus, _glfw.wl.keyboardLastKey,
-                              _glfw.wl.keyboardLastScancode, GLFW_REPEAT,
-                              _glfw.wl.xkb.modifiers);
-        }
     }
     else
     {
         wl_display_cancel_read(display);
     }
+    dispatchPendingKeyRepeats();
 }
 
 // Translates a GLFW standard cursor to a theme cursor name
@@ -1079,11 +1089,15 @@ void _glfwPlatformRequestWindowAttention(_GLFWwindow* window)
                     "Wayland: Window attention request not implemented yet");
 }
 
-int _glfwPlatformWindowBell(_GLFWwindow* window, int64_t param)
+int _glfwPlatformWindowBell(_GLFWwindow* window)
 {
-    // TODO
-    _glfwInputError(GLFW_PLATFORM_ERROR,
-                    "Wayland: Window bell request not implemented yet");
+    // TODO: Use an actual Wayland API to implement this when one becomes available
+    int fd = open("/dev/tty", O_WRONLY | O_CLOEXEC);
+    if (fd > -1) {
+        int ret = write(fd, "\x07", 1) == 1 ? GLFW_TRUE : GLFW_FALSE;
+        close(fd);
+        return ret;
+    }
     return GLFW_FALSE;
 }
 
@@ -1236,7 +1250,7 @@ const char* _glfwPlatformGetScancodeName(int scancode)
 
 int _glfwPlatformGetKeyScancode(int key)
 {
-    return _glfw.wl.scancodes[key];
+    return _glfw.wl.xkb.scancodes[key];
 }
 
 int _glfwPlatformCreateCursor(_GLFWcursor* cursor,
@@ -1547,4 +1561,3 @@ GLFWAPI struct wl_surface* glfwGetWaylandWindow(GLFWwindow* handle)
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     return window->wl.surface;
 }
-

glfw/x11_window.c

@@ -2340,9 +2340,9 @@ void _glfwPlatformRequestWindowAttention(_GLFWwindow* window)
                   0, 1, 0);
 }
 
-int _glfwPlatformWindowBell(_GLFWwindow* window, int64_t param)
+int _glfwPlatformWindowBell(_GLFWwindow* window)
 {
-    return XkbBell(_glfw.x11.display, window->x11.handle, (int)param, (Atom)0) ? GLFW_TRUE : GLFW_FALSE;
+    return XkbBell(_glfw.x11.display, window->x11.handle, 100, (Atom)0) ? GLFW_TRUE : GLFW_FALSE;
 }
 
 void _glfwPlatformFocusWindow(_GLFWwindow* window)
@@ -3044,4 +3044,3 @@ GLFWAPI const char* glfwGetX11SelectionString(void)
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     return getSelectionString(_glfw.x11.PRIMARY);
 }
-

glfw/xkb_glfw.h

@@ -0,0 +1,374 @@
+//========================================================================
+// GLFW 3.3 XKB - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2014 Kovid Goyal <kovid@kovidgoyal.net>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#pragma once
+
+#include <xkbcommon/xkbcommon.h>
+#include <xkbcommon/xkbcommon-compose.h>
+
+typedef struct xkb_context* (* PFN_xkb_context_new)(enum xkb_context_flags);
+typedef void (* PFN_xkb_context_unref)(struct xkb_context*);
+typedef struct xkb_keymap* (* PFN_xkb_keymap_new_from_string)(struct xkb_context*, const char*, enum xkb_keymap_format, enum xkb_keymap_compile_flags);
+typedef void (* PFN_xkb_keymap_unref)(struct xkb_keymap*);
+typedef xkb_mod_index_t (* PFN_xkb_keymap_mod_get_index)(struct xkb_keymap*, const char*);
+typedef int (* PFN_xkb_keymap_key_repeats)(struct xkb_keymap*, xkb_keycode_t);
+typedef struct xkb_state* (* PFN_xkb_state_new)(struct xkb_keymap*);
+typedef void (* PFN_xkb_state_unref)(struct xkb_state*);
+typedef int (* PFN_xkb_state_key_get_syms)(struct xkb_state*, xkb_keycode_t, const xkb_keysym_t**);
+typedef enum xkb_state_component (* PFN_xkb_state_update_mask)(struct xkb_state*, xkb_mod_mask_t, xkb_mod_mask_t, xkb_mod_mask_t, xkb_layout_index_t, xkb_layout_index_t, xkb_layout_index_t);
+typedef xkb_mod_mask_t (* PFN_xkb_state_serialize_mods)(struct xkb_state*, enum xkb_state_component);
+
+#define xkb_context_new GLFW_XKB_GLOBAL_NAME.context_new
+#define xkb_context_unref GLFW_XKB_GLOBAL_NAME.context_unref
+#define xkb_keymap_new_from_string GLFW_XKB_GLOBAL_NAME.keymap_new_from_string
+#define xkb_keymap_unref GLFW_XKB_GLOBAL_NAME.keymap_unref
+#define xkb_keymap_mod_get_index GLFW_XKB_GLOBAL_NAME.keymap_mod_get_index
+#define xkb_keymap_key_repeats GLFW_XKB_GLOBAL_NAME.keymap_key_repeats
+#define xkb_state_new GLFW_XKB_GLOBAL_NAME.state_new
+#define xkb_state_unref GLFW_XKB_GLOBAL_NAME.state_unref
+#define xkb_state_key_get_syms GLFW_XKB_GLOBAL_NAME.state_key_get_syms
+#define xkb_state_update_mask GLFW_XKB_GLOBAL_NAME.state_update_mask
+#define xkb_state_serialize_mods GLFW_XKB_GLOBAL_NAME.state_serialize_mods
+
+typedef struct xkb_compose_table* (* PFN_xkb_compose_table_new_from_locale)(struct xkb_context*, const char*, enum xkb_compose_compile_flags);
+typedef void (* PFN_xkb_compose_table_unref)(struct xkb_compose_table*);
+typedef struct xkb_compose_state* (* PFN_xkb_compose_state_new)(struct xkb_compose_table*, enum xkb_compose_state_flags);
+typedef void (* PFN_xkb_compose_state_unref)(struct xkb_compose_state*);
+typedef enum xkb_compose_feed_result (* PFN_xkb_compose_state_feed)(struct xkb_compose_state*, xkb_keysym_t);
+typedef enum xkb_compose_status (* PFN_xkb_compose_state_get_status)(struct xkb_compose_state*);
+typedef xkb_keysym_t (* PFN_xkb_compose_state_get_one_sym)(struct xkb_compose_state*);
+
+#define xkb_compose_table_new_from_locale GLFW_XKB_GLOBAL_NAME.compose_table_new_from_locale
+#define xkb_compose_table_unref GLFW_XKB_GLOBAL_NAME.compose_table_unref
+#define xkb_compose_state_new GLFW_XKB_GLOBAL_NAME.compose_state_new
+#define xkb_compose_state_unref GLFW_XKB_GLOBAL_NAME.compose_state_unref
+#define xkb_compose_state_feed GLFW_XKB_GLOBAL_NAME.compose_state_feed
+#define xkb_compose_state_get_status GLFW_XKB_GLOBAL_NAME.compose_state_get_status
+#define xkb_compose_state_get_one_sym GLFW_XKB_GLOBAL_NAME.compose_state_get_one_sym
+
+
+typedef struct {
+    void*                   handle;
+    struct xkb_context*     context;
+    struct xkb_keymap*      keymap;
+    struct xkb_state*       state;
+    struct xkb_compose_state* composeState;
+    short int               keycodes[256];
+    short int               scancodes[GLFW_KEY_LAST + 1];
+
+    xkb_mod_mask_t          controlMask;
+    xkb_mod_mask_t          altMask;
+    xkb_mod_mask_t          shiftMask;
+    xkb_mod_mask_t          superMask;
+    xkb_mod_mask_t          capsLockMask;
+    xkb_mod_mask_t          numLockMask;
+    unsigned int            modifiers;
+
+    PFN_xkb_context_new context_new;
+    PFN_xkb_context_unref context_unref;
+    PFN_xkb_keymap_new_from_string keymap_new_from_string;
+    PFN_xkb_keymap_unref keymap_unref;
+    PFN_xkb_keymap_mod_get_index keymap_mod_get_index;
+    PFN_xkb_keymap_key_repeats keymap_key_repeats;
+    PFN_xkb_state_new state_new;
+    PFN_xkb_state_unref state_unref;
+    PFN_xkb_state_key_get_syms state_key_get_syms;
+    PFN_xkb_state_update_mask state_update_mask;
+    PFN_xkb_state_serialize_mods state_serialize_mods;
+
+    PFN_xkb_compose_table_new_from_locale compose_table_new_from_locale;
+    PFN_xkb_compose_table_unref compose_table_unref;
+    PFN_xkb_compose_state_new compose_state_new;
+    PFN_xkb_compose_state_unref compose_state_unref;
+    PFN_xkb_compose_state_feed compose_state_feed;
+    PFN_xkb_compose_state_get_status compose_state_get_status;
+    PFN_xkb_compose_state_get_one_sym compose_state_get_one_sym;
+} _GLFWXKBData;
+
+#define bind_xkb_sym(name) GLFW_XKB_GLOBAL_NAME.name = (PFN_xkb_##name) _glfw_dlsym(GLFW_XKB_GLOBAL_NAME.handle, "xkb_" #name)
+#define load_glfw_xkb() {\
+    GLFW_XKB_GLOBAL_NAME.handle = _glfw_dlopen("libxkbcommon.so.0"); \
+    if (!GLFW_XKB_GLOBAL_NAME.handle) \
+    { \
+        _glfwInputError(GLFW_PLATFORM_ERROR, \
+                        "Failed to open libxkbcommon"); \
+        return GLFW_FALSE; \
+    } \
+    bind_xkb_sym(context_new); \
+    bind_xkb_sym(context_unref); \
+    bind_xkb_sym(keymap_new_from_string); \
+    bind_xkb_sym(keymap_unref); \
+    bind_xkb_sym(keymap_mod_get_index); \
+    bind_xkb_sym(keymap_key_repeats); \
+    bind_xkb_sym(state_new); \
+    bind_xkb_sym(state_unref); \
+    bind_xkb_sym(state_key_get_syms); \
+    bind_xkb_sym(state_update_mask); \
+    bind_xkb_sym(state_serialize_mods); \
+    bind_xkb_sym(compose_table_new_from_locale); \
+    bind_xkb_sym(compose_table_unref); \
+    bind_xkb_sym(compose_state_new); \
+    bind_xkb_sym(compose_state_unref); \
+    bind_xkb_sym(compose_state_feed); \
+    bind_xkb_sym(compose_state_get_status); \
+    bind_xkb_sym(compose_state_get_one_sym); \
+}
+
+#define release_glfw_xkb() {\
+    if (GLFW_XKB_GLOBAL_NAME.composeState) { \
+        xkb_compose_state_unref(GLFW_XKB_GLOBAL_NAME.composeState); \
+        GLFW_XKB_GLOBAL_NAME.composeState = NULL; \
+    } \
+    if (GLFW_XKB_GLOBAL_NAME.keymap) { \
+        xkb_keymap_unref(GLFW_XKB_GLOBAL_NAME.keymap); \
+        GLFW_XKB_GLOBAL_NAME.keymap = NULL; \
+    } \
+    if (GLFW_XKB_GLOBAL_NAME.state) { \
+        xkb_state_unref(GLFW_XKB_GLOBAL_NAME.state); \
+        GLFW_XKB_GLOBAL_NAME.state = NULL; \
+    } \
+    if (GLFW_XKB_GLOBAL_NAME.context) { \
+        xkb_context_unref(GLFW_XKB_GLOBAL_NAME.context); \
+        GLFW_XKB_GLOBAL_NAME.context = NULL; \
+    } \
+    if (GLFW_XKB_GLOBAL_NAME.handle) { \
+        _glfw_dlclose(GLFW_XKB_GLOBAL_NAME.handle); \
+        GLFW_XKB_GLOBAL_NAME.handle = NULL; \
+    } \
+}
+
+#define create_glfw_xkb_context() {\
+    GLFW_XKB_GLOBAL_NAME.context = xkb_context_new(0); \
+    if (!GLFW_XKB_GLOBAL_NAME.context) \
+    { \
+        _glfwInputError(GLFW_PLATFORM_ERROR, \
+                        "Failed to initialize XKB context"); \
+        return GLFW_FALSE; \
+    } \
+    int scancode; \
+    memset(GLFW_XKB_GLOBAL_NAME.keycodes, -1, sizeof(GLFW_XKB_GLOBAL_NAME.keycodes)); \
+    memset(GLFW_XKB_GLOBAL_NAME.scancodes, -1, sizeof(GLFW_XKB_GLOBAL_NAME.scancodes)); \
+\
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_GRAVE]      = GLFW_KEY_GRAVE_ACCENT; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_1]          = GLFW_KEY_1; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_2]          = GLFW_KEY_2; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_3]          = GLFW_KEY_3; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_4]          = GLFW_KEY_4; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_5]          = GLFW_KEY_5; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_6]          = GLFW_KEY_6; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_7]          = GLFW_KEY_7; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_8]          = GLFW_KEY_8; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_9]          = GLFW_KEY_9; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_0]          = GLFW_KEY_0; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_SPACE]      = GLFW_KEY_SPACE; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_MINUS]      = GLFW_KEY_MINUS; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_EQUAL]      = GLFW_KEY_EQUAL; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_Q]          = GLFW_KEY_Q; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_W]          = GLFW_KEY_W; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_E]          = GLFW_KEY_E; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_R]          = GLFW_KEY_R; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_T]          = GLFW_KEY_T; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_Y]          = GLFW_KEY_Y; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_U]          = GLFW_KEY_U; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_I]          = GLFW_KEY_I; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_O]          = GLFW_KEY_O; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_P]          = GLFW_KEY_P; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_LEFTBRACE]  = GLFW_KEY_LEFT_BRACKET; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_RIGHTBRACE] = GLFW_KEY_RIGHT_BRACKET; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_A]          = GLFW_KEY_A; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_S]          = GLFW_KEY_S; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_D]          = GLFW_KEY_D; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_F]          = GLFW_KEY_F; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_G]          = GLFW_KEY_G; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_H]          = GLFW_KEY_H; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_J]          = GLFW_KEY_J; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_K]          = GLFW_KEY_K; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_L]          = GLFW_KEY_L; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_SEMICOLON]  = GLFW_KEY_SEMICOLON; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_APOSTROPHE] = GLFW_KEY_APOSTROPHE; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_Z]          = GLFW_KEY_Z; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_X]          = GLFW_KEY_X; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_C]          = GLFW_KEY_C; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_V]          = GLFW_KEY_V; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_B]          = GLFW_KEY_B; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_N]          = GLFW_KEY_N; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_M]          = GLFW_KEY_M; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_COMMA]      = GLFW_KEY_COMMA; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_DOT]        = GLFW_KEY_PERIOD; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_SLASH]      = GLFW_KEY_SLASH; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_BACKSLASH]  = GLFW_KEY_BACKSLASH; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_ESC]        = GLFW_KEY_ESCAPE; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_TAB]        = GLFW_KEY_TAB; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_LEFTSHIFT]  = GLFW_KEY_LEFT_SHIFT; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_RIGHTSHIFT] = GLFW_KEY_RIGHT_SHIFT; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_LEFTCTRL]   = GLFW_KEY_LEFT_CONTROL; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_RIGHTCTRL]  = GLFW_KEY_RIGHT_CONTROL; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_LEFTALT]    = GLFW_KEY_LEFT_ALT; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_RIGHTALT]   = GLFW_KEY_RIGHT_ALT; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_LEFTMETA]   = GLFW_KEY_LEFT_SUPER; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_RIGHTMETA]  = GLFW_KEY_RIGHT_SUPER; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_MENU]       = GLFW_KEY_MENU; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_NUMLOCK]    = GLFW_KEY_NUM_LOCK; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_CAPSLOCK]   = GLFW_KEY_CAPS_LOCK; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_PRINT]      = GLFW_KEY_PRINT_SCREEN; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_SCROLLLOCK] = GLFW_KEY_SCROLL_LOCK; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_PAUSE]      = GLFW_KEY_PAUSE; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_DELETE]     = GLFW_KEY_DELETE; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_BACKSPACE]  = GLFW_KEY_BACKSPACE; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_ENTER]      = GLFW_KEY_ENTER; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_HOME]       = GLFW_KEY_HOME; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_END]        = GLFW_KEY_END; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_PAGEUP]     = GLFW_KEY_PAGE_UP; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_PAGEDOWN]   = GLFW_KEY_PAGE_DOWN; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_INSERT]     = GLFW_KEY_INSERT; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_LEFT]       = GLFW_KEY_LEFT; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_RIGHT]      = GLFW_KEY_RIGHT; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_DOWN]       = GLFW_KEY_DOWN; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_UP]         = GLFW_KEY_UP; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_F1]         = GLFW_KEY_F1; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_F2]         = GLFW_KEY_F2; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_F3]         = GLFW_KEY_F3; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_F4]         = GLFW_KEY_F4; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_F5]         = GLFW_KEY_F5; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_F6]         = GLFW_KEY_F6; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_F7]         = GLFW_KEY_F7; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_F8]         = GLFW_KEY_F8; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_F9]         = GLFW_KEY_F9; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_F10]        = GLFW_KEY_F10; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_F11]        = GLFW_KEY_F11; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_F12]        = GLFW_KEY_F12; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_F13]        = GLFW_KEY_F13; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_F14]        = GLFW_KEY_F14; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_F15]        = GLFW_KEY_F15; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_F16]        = GLFW_KEY_F16; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_F17]        = GLFW_KEY_F17; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_F18]        = GLFW_KEY_F18; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_F19]        = GLFW_KEY_F19; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_F20]        = GLFW_KEY_F20; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_F21]        = GLFW_KEY_F21; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_F22]        = GLFW_KEY_F22; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_F23]        = GLFW_KEY_F23; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_F24]        = GLFW_KEY_F24; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_KPSLASH]    = GLFW_KEY_KP_DIVIDE; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_KPDOT]      = GLFW_KEY_KP_MULTIPLY; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_KPMINUS]    = GLFW_KEY_KP_SUBTRACT; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_KPPLUS]     = GLFW_KEY_KP_ADD; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_KP0]        = GLFW_KEY_KP_0; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_KP1]        = GLFW_KEY_KP_1; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_KP2]        = GLFW_KEY_KP_2; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_KP3]        = GLFW_KEY_KP_3; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_KP4]        = GLFW_KEY_KP_4; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_KP5]        = GLFW_KEY_KP_5; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_KP6]        = GLFW_KEY_KP_6; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_KP7]        = GLFW_KEY_KP_7; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_KP8]        = GLFW_KEY_KP_8; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_KP9]        = GLFW_KEY_KP_9; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_KPCOMMA]    = GLFW_KEY_KP_DECIMAL; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_KPEQUAL]    = GLFW_KEY_KP_EQUAL; \
+    GLFW_XKB_GLOBAL_NAME.keycodes[KEY_KPENTER]    = GLFW_KEY_KP_ENTER; \
+\
+    for (scancode = 0;  scancode < 256;  scancode++) \
+    { \
+        if (GLFW_XKB_GLOBAL_NAME.keycodes[scancode] > 0) \
+            GLFW_XKB_GLOBAL_NAME.scancodes[GLFW_XKB_GLOBAL_NAME.keycodes[scancode]] = scancode; \
+    } \
+\
+}
+
+
+#define xkb_glfw_compile_keymap(map_str) { \
+    const char* locale = NULL; \
+    struct xkb_state* state = NULL;  \
+    struct xkb_keymap* keymap = NULL; \
+    struct xkb_compose_table* compose_table = NULL;  \
+    struct xkb_compose_state* compose_state = NULL;  \
+\
+    keymap = xkb_keymap_new_from_string(GLFW_XKB_GLOBAL_NAME.context, map_str, XKB_KEYMAP_FORMAT_TEXT_V1, 0); \
+    if (!keymap) _glfwInputError(GLFW_PLATFORM_ERROR, "Failed to compile XKB keymap"); \
+    else { \
+        state = xkb_state_new(keymap); \
+        if (!state) { \
+            _glfwInputError(GLFW_PLATFORM_ERROR, "Failed to create XKB state"); \
+            xkb_keymap_unref(keymap); keymap = NULL; \
+        } else { \
+            /* Look up the preferred locale, falling back to "C" as default. */ \
+            locale = getenv("LC_ALL"); \
+            if (!locale) locale = getenv("LC_CTYPE"); \
+            if (!locale) locale = getenv("LANG"); \
+            if (!locale) locale = "C"; \
+            compose_table = xkb_compose_table_new_from_locale(GLFW_XKB_GLOBAL_NAME.context, locale, XKB_COMPOSE_COMPILE_NO_FLAGS); \
+            if (!compose_table) { \
+                _glfwInputError(GLFW_PLATFORM_ERROR, "Failed to create XKB compose table"); \
+                xkb_keymap_unref(keymap); keymap = NULL; \
+                xkb_state_unref(state); state = NULL; \
+            } else { \
+                compose_state = xkb_compose_state_new(compose_table, XKB_COMPOSE_STATE_NO_FLAGS); \
+                xkb_compose_table_unref(compose_table); compose_table = NULL; \
+                if (!compose_state) { \
+                    _glfwInputError(GLFW_PLATFORM_ERROR, "Failed to create XKB compose state"); \
+                    xkb_keymap_unref(keymap); keymap = NULL; \
+                    xkb_state_unref(state); state = NULL; \
+                }\
+            } \
+        } \
+    } \
+    if (keymap && state && compose_state) { \
+        if (GLFW_XKB_GLOBAL_NAME.composeState) xkb_compose_state_unref(GLFW_XKB_GLOBAL_NAME.composeState); \
+        GLFW_XKB_GLOBAL_NAME.composeState = compose_state; \
+        if (GLFW_XKB_GLOBAL_NAME.keymap) xkb_keymap_unref(GLFW_XKB_GLOBAL_NAME.keymap); \
+        GLFW_XKB_GLOBAL_NAME.keymap = keymap; \
+        if (GLFW_XKB_GLOBAL_NAME.state) xkb_state_unref(GLFW_XKB_GLOBAL_NAME.state); \
+        GLFW_XKB_GLOBAL_NAME.state = state; \
+    }\
+    if (GLFW_XKB_GLOBAL_NAME.keymap) { \
+        GLFW_XKB_GLOBAL_NAME.controlMask = 1 << xkb_keymap_mod_get_index(GLFW_XKB_GLOBAL_NAME.keymap, "Control"); \
+        GLFW_XKB_GLOBAL_NAME.altMask = 1 << xkb_keymap_mod_get_index(GLFW_XKB_GLOBAL_NAME.keymap, "Mod1"); \
+        GLFW_XKB_GLOBAL_NAME.shiftMask = 1 << xkb_keymap_mod_get_index(GLFW_XKB_GLOBAL_NAME.keymap, "Shift"); \
+        GLFW_XKB_GLOBAL_NAME.superMask = 1 << xkb_keymap_mod_get_index(GLFW_XKB_GLOBAL_NAME.keymap, "Mod4"); \
+        GLFW_XKB_GLOBAL_NAME.capsLockMask = 1 << xkb_keymap_mod_get_index(GLFW_XKB_GLOBAL_NAME.keymap, "Lock"); \
+        GLFW_XKB_GLOBAL_NAME.numLockMask = 1 << xkb_keymap_mod_get_index(GLFW_XKB_GLOBAL_NAME.keymap, "Mod2"); \
+    } \
+}
+
+
+#define xkb_glfw_update_modifiers(depressed, latched, locked, group) {\
+    xkb_mod_mask_t mask; \
+    unsigned int modifiers = 0; \
+    if (!GLFW_XKB_GLOBAL_NAME.keymap) return; \
+    xkb_state_update_mask(GLFW_XKB_GLOBAL_NAME.state, depressed, latched, locked, 0, 0, group); \
+    mask = xkb_state_serialize_mods(GLFW_XKB_GLOBAL_NAME.state, XKB_STATE_MODS_DEPRESSED | XKB_STATE_LAYOUT_DEPRESSED | XKB_STATE_MODS_LATCHED | XKB_STATE_LAYOUT_LATCHED); \
+    if (mask & GLFW_XKB_GLOBAL_NAME.controlMask) modifiers |= GLFW_MOD_CONTROL; \
+    if (mask & GLFW_XKB_GLOBAL_NAME.altMask) modifiers |= GLFW_MOD_ALT; \
+    if (mask & GLFW_XKB_GLOBAL_NAME.shiftMask) modifiers |= GLFW_MOD_SHIFT; \
+    if (mask & GLFW_XKB_GLOBAL_NAME.superMask) modifiers |= GLFW_MOD_SUPER; \
+    if (mask & GLFW_XKB_GLOBAL_NAME.capsLockMask) modifiers |= GLFW_MOD_CAPS_LOCK; \
+    if (mask & GLFW_XKB_GLOBAL_NAME.numLockMask) modifiers |= GLFW_MOD_NUM_LOCK; \
+    GLFW_XKB_GLOBAL_NAME.modifiers = modifiers; \
+}
+
+
+#define xkb_glfw_to_glfw_key_code(key) \
+    ((key < sizeof(GLFW_XKB_GLOBAL_NAME.keycodes) / sizeof(GLFW_XKB_GLOBAL_NAME.keycodes[0])) ? GLFW_XKB_GLOBAL_NAME.keycodes[key] : GLFW_KEY_UNKNOWN)

kittens/ask/main.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python
+# vim:fileencoding=utf-8
+# License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
+
+import json
+import os
+import readline
+import sys
+
+from kitty.cli import parse_args
+from kitty.constants import cache_dir
+
+from ..tui.operations import alternate_screen, styled
+
+
+def get_history_items():
+    return list(map(readline.get_history_item, range(1, readline.get_current_history_length() + 1)))
+
+
+def sort_key(item):
+    return len(item), item.lower()
+
+
+class HistoryCompleter:
+
+    def __init__(self, name=None):
+        self.matches = []
+        self.history_path = None
+        if name:
+            ddir = os.path.join(cache_dir(), 'ask')
+            try:
+                os.makedirs(ddir)
+            except FileExistsError:
+                pass
+            self.history_path = os.path.join(ddir, name)
+
+    def complete(self, text, state):
+        response = None
+        if state == 0:
+            history_values = get_history_items()
+            if text:
+                self.matches = sorted(
+                        (h for h in history_values if h and h.startswith(text)), key=sort_key)
+            else:
+                self.matches = []
+        try:
+            response = self.matches[state]
+        except IndexError:
+            response = None
+        return response
+
+    def __enter__(self):
+        if self.history_path:
+            if os.path.exists(self.history_path):
+                readline.read_history_file(self.history_path)
+            readline.set_completer(self.complete)
+            readline.parse_and_bind('tab: complete')
+        return self
+
+    def __exit__(self, *a):
+        if self.history_path:
+            readline.write_history_file(self.history_path)
+
+
+def option_text():
+    return '''\
+--type -t
+choices=line
+default=line
+Type of input. Defaults to asking for a line of text.
+
+
+--message -m
+The message to display to the user. If not specified a default
+message is shown.
+
+
+--name -n
+The name for this question. Used to store history of previous answers which can
+be used for completions and via the browse history readline bindings.
+'''
+
+
+def real_main(args):
+    msg = 'Ask the user for input'
+    try:
+        args, items = parse_args(args[1:], option_text, '', msg, 'kitty ask')
+    except SystemExit as e:
+        print(e.args[0])
+        input('Press enter to quit...')
+        raise SystemExit(1)
+
+    readline.read_init_file()
+
+    with alternate_screen(), HistoryCompleter(args.name):
+        if args.message:
+            print(styled(args.message, bold=True))
+
+        prompt = '> '
+        try:
+            ans = input(prompt)
+        except (KeyboardInterrupt, EOFError):
+            return
+    print('OK:', json.dumps(ans))
+
+
+def main(args=sys.argv):
+    try:
+        real_main(args)
+    except Exception as e:
+        import traceback
+        traceback.print_exc(file=sys.stdout)
+        input('Press enter to quit...')
+        raise SystemExit(1)

kittens/tui/operations.py

@@ -2,6 +2,7 @@
 # vim:fileencoding=utf-8
 # License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
 
+import sys
 from contextlib import contextmanager
 
 from kitty.terminfo import string_capabilities
@@ -151,3 +152,11 @@ def cursor(write):
     write(SAVE_CURSOR)
     yield
     write(RESTORE_CURSOR)
+
+
+@contextmanager
+def alternate_screen(f=None):
+    f = f or sys.stdout
+    print(set_mode('ALTERNATE_SCREEN'), end='', file=f)
+    yield
+    print(reset_mode('ALTERNATE_SCREEN'), end='', file=f)

kittens/unicode_input/main.py

@@ -3,7 +3,6 @@
 # License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
 
 import os
-import shlex
 import string
 import subprocess
 import sys
@@ -11,7 +10,7 @@ from functools import lru_cache
 from gettext import gettext as _
 
 from kitty.config import cached_values_for
-from kitty.constants import config_dir
+from kitty.constants import config_dir, editor
 from kitty.fast_data_types import wcswidth
 from kitty.key_encoding import (
     DOWN, ESCAPE, F1, F2, F3, F4, F12, LEFT, RELEASE, RIGHT, SHIFT, TAB, UP,
@@ -426,7 +425,6 @@ class UnicodeInput(Handler):
         if not os.path.exists(favorites_path):
             with open(favorites_path, 'wb') as f:
                 f.write(serialize_favorites(load_favorites()).encode('utf-8'))
-        editor = shlex.split(os.environ.get('EDITOR', 'vim'))
         with self.suspend():
             p = subprocess.Popen(editor + [favorites_path])
             if p.wait() == 0:

kittens/unicode_input/unicode_names.c

@@ -8,7 +8,7 @@
 #include "names.h"
 
 static PyObject*
-all_words(PyObject *self UNUSED) {
+all_words(PYNOARG) {
     PyObject *ans = PyTuple_New(arraysz(idx_to_word));
     if (!ans) return NULL;
     for (size_t i = 0; i < arraysz(idx_to_word); i++) {

kittens/url_hints/main.py

@@ -231,7 +231,7 @@ expression instead.
 
 --url-prefixes
 default={0}
-Comma separeted list of recognized URL prefixes. Defaults to:
+Comma separated list of recognized URL prefixes. Defaults to:
 {0}
 '''.format, ','.join(sorted(URL_PREFIXES)))
 

kitty/boss.py

@@ -3,6 +3,7 @@
 # License: GPL v3 Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
 
 import atexit
+import json
 import re
 import socket
 from functools import partial
@@ -10,8 +11,10 @@ from gettext import gettext as _
 from weakref import WeakValueDictionary
 
 from .cli import create_opts, parse_args
-from .config import MINIMUM_FONT_SIZE, initial_window_size
-from .constants import appname, set_boss
+from .config import (
+    MINIMUM_FONT_SIZE, initial_window_size, prepare_config_file_for_editing
+)
+from .constants import appname, editor, set_boss
 from .fast_data_types import (
     ChildMonitor, create_os_window, current_os_window, destroy_global_data,
     destroy_sprite_map, get_clipboard_string, glfw_post_empty_event,
@@ -122,7 +125,10 @@ class Boss:
             }
 
     def match_windows(self, match):
-        field, exp = match.split(':', 1)
+        try:
+            field, exp = match.split(':', 1)
+        except ValueError:
+            return
         pat = re.compile(exp)
         for tm in self.os_window_map.values():
             for tab in tm:
@@ -138,7 +144,10 @@ class Boss:
                         return tab
 
     def match_tabs(self, match):
-        field, exp = match.split(':', 1)
+        try:
+            field, exp = match.split(':', 1)
+        except ValueError:
+            return
         pat = re.compile(exp)
         tms = tuple(self.os_window_map.values())
         found = False
@@ -188,13 +197,14 @@ class Boss:
                 response = handle_cmd(self, window, cmd)
             except Exception as err:
                 import traceback
-                response = {'ok': False, 'error': str(err), 'tb': traceback.format_exc()}
+                response = {'ok': False, 'error': str(err)}
+                if not getattr(err, 'hide_traceback', False):
+                    response['tb'] = traceback.format_exc()
         else:
             response = {'ok': False, 'error': 'Remote control is disabled. Add allow_remote_control yes to your kitty.conf'}
         return response
 
     def peer_message_received(self, msg):
-        import json
         msg = msg.decode('utf-8')
         cmd_prefix = '\x1bP@kitty-cmd'
         if msg.startswith(cmd_prefix):
@@ -286,19 +296,16 @@ class Boss:
                 tm.resize()
 
     def increase_font_size(self):
-        self.change_font_size(
+        self.set_font_size(
             min(
                 self.opts.font_size * 5, self.current_font_size +
                 self.opts.font_size_delta))
 
     def decrease_font_size(self):
-        self.change_font_size(
-            max(
-                MINIMUM_FONT_SIZE, self.current_font_size -
-                self.opts.font_size_delta))
+        self.set_font_size(self.current_font_size - self.opts.font_size_delta)
 
     def restore_font_size(self):
-        self.change_font_size(self.opts.font_size)
+        self.set_font_size(self.opts.font_size)
 
     def _change_font_size(self, new_size=None, on_dpi_change=False):
         if new_size is not None:
@@ -316,7 +323,8 @@ class Boss:
             tm.refresh_sprite_positions()
         glfw_post_empty_event()
 
-    def change_font_size(self, new_size):
+    def set_font_size(self, new_size):
+        new_size = max(MINIMUM_FONT_SIZE, new_size)
         if new_size == self.current_font_size:
             return
         self._change_font_size(new_size)
@@ -410,6 +418,13 @@ class Boss:
                 SpecialWindow(
                     self.opts.scrollback_pager, data, _('History'), overlay_for=window.id))
 
+    def edit_config_file(self, *a):
+        confpath = prepare_config_file_for_editing()
+        # On macOS vim fails to handle SIGWINCH if it occurs early, so add a
+        # small delay.
+        cmd = ['kitty', '+runpy', 'import os, sys, time; time.sleep(0.05); os.execvp(sys.argv[1], sys.argv[1:])'] + editor + [confpath]
+        self.new_os_window(*cmd)
+
     def input_unicode_character(self):
         w = self.active_window
         tab = self.active_tab
@@ -420,10 +435,17 @@ class Boss:
                     overlay_for=w.id))
             overlay_window.action_on_close = partial(self.send_unicode_character, w.id)
 
+    def get_output(self, source_window, num_lines=1):
+        output = ''
+        s = source_window.screen
+        for i in range(min(num_lines, s.lines)):
+            output += str(s.linebuf.line(i))
+        return output
+
     def send_unicode_character(self, target_window_id, source_window):
         w = self.window_id_map.get(target_window_id)
         if w is not None:
-            output = str(source_window.screen.linebuf.line(0))
+            output = self.get_output(source_window)
             if output.startswith('OK: '):
                 try:
                     text = chr(int(output.partition(' ')[2], 16))
@@ -433,6 +455,28 @@ class Boss:
                 else:
                     w.paste(text)
 
+    def set_tab_title(self):
+        w = self.active_window
+        tab = self.active_tab
+        if w is not None and tab is not None and w.overlay_for is None:
+            args = ['--name=tab-title', '--message', _('Enter the new title for this tab below.')]
+            overlay_window = tab.new_special_window(
+                SpecialWindow(
+                    ['kitty', '+runpy', 'from kittens.ask.main import main; main()'] + args,
+                    overlay_for=w.id))
+            overlay_window.action_on_close = partial(self.do_set_tab_title, tab.id)
+
+    def do_set_tab_title(self, tab_id, source_window):
+        output = self.get_output(source_window)
+        if output.startswith('OK: '):
+            title = json.loads(output.partition(' ')[2].strip())
+            tm = self.active_tab_manager
+            if tm is not None and title:
+                for tab in tm.tabs:
+                    if tab.id == tab_id:
+                        tab.set_title(title)
+                        break
+
     def run_simple_kitten(self, type_of_input, kitten, *args):
         import shlex
         w = self.active_window
@@ -507,6 +551,11 @@ class Boss:
         if tm is not None:
             tm.goto_tab(tab_num - 1)
 
+    def set_active_tab(self, tab):
+        tm = self.active_tab_manager
+        if tm is not None:
+            tm.set_active_tab(tab)
+
     def next_tab(self):
         tm = self.active_tab_manager
         if tm is not None:

kitty/cell_vertex.glsl

@@ -6,9 +6,7 @@
 layout(std140) uniform CellRenderData {
     float xstart, ystart, dx, dy, sprite_dx, sprite_dy, background_opacity;
 
-    uint default_fg, default_bg, highlight_fg, highlight_bg, cursor_color, url_color, url_style;
-
-    int color1, color2;
+    uint default_fg, default_bg, highlight_fg, highlight_bg, cursor_color, url_color, url_style, inverted;
 
     uint xnum, ynum, cursor_x, cursor_y, cursor_w;
 
@@ -21,7 +19,7 @@ layout(location=1) in uvec4 sprite_coords;
 layout(location=2) in uint is_selected;
 
 
-
+const int fg_index_map[] = int[3](0, 1, 0);
 const uvec2 cell_pos_map[] = uvec2[4](
     uvec2(1, 0),  // right, top
     uvec2(1, 1),  // right, bottom
@@ -135,10 +133,10 @@ void main() {
 
     // set cell color indices {{{
     uvec2 default_colors = uvec2(default_fg, default_bg);
-    ivec2 color_indices = ivec2(color1, color2);
     uint text_attrs = sprite_coords[3];
-    int fg_index = color_indices[(text_attrs >> 6) & REVERSE_MASK];
-    int bg_index = color_indices[1 - fg_index];
+    uint is_inverted = ((text_attrs >> 6) & REVERSE_MASK) + inverted;
+    int fg_index = fg_index_map[is_inverted];
+    int bg_index = 1 - fg_index;
     float cursor = is_cursor(c, r);
     vec3 bg = to_color(colors[bg_index], default_colors[bg_index]);
     // }}}

kitty/child-monitor.c

@@ -71,7 +71,7 @@ static unsigned long remove_notify[MAX_CHILDREN] = {0};
 static size_t add_queue_count = 0, remove_queue_count = 0;
 static struct pollfd fds[MAX_CHILDREN + EXTRA_FDS] = {{0}};
 static pthread_mutex_t children_lock;
-static bool signal_received = false;
+static bool kill_signal_received = false;
 static ChildMonitor *the_monitor = NULL;
 static uint8_t drain_buf[1024];
 static int signal_fds[2], wakeup_fds[2];
@@ -139,10 +139,9 @@ new(PyTypeObject *type, PyObject *args, PyObject UNUSED *kwds) {
     if (!self_pipe(wakeup_fds)) return PyErr_SetFromErrno(PyExc_OSError);
     if (!self_pipe(signal_fds)) return PyErr_SetFromErrno(PyExc_OSError);
     struct sigaction act = {.sa_handler=handle_signal};
-    if (sigaction(SIGINT, &act, NULL) != 0) return PyErr_SetFromErrno(PyExc_OSError);
-    if (sigaction(SIGTERM, &act, NULL) != 0) return PyErr_SetFromErrno(PyExc_OSError);
-    if (siginterrupt(SIGINT, false) != 0) return PyErr_SetFromErrno(PyExc_OSError);
-    if (siginterrupt(SIGTERM, false) != 0) return PyErr_SetFromErrno(PyExc_OSError);
+#define SA(which) { if (sigaction(which, &act, NULL) != 0) return PyErr_SetFromErrno(PyExc_OSError); if (siginterrupt(which, false) != 0) return PyErr_SetFromErrno(PyExc_OSError);}
+    SA(SIGINT); SA(SIGTERM); SA(SIGCHLD);
+#undef SA
     self = (ChildMonitor *)type->tp_alloc(type, 0);
     self->talk_fd = talk_fd;
     self->listen_fd = listen_fd;
@@ -199,8 +198,9 @@ static void wakeup_talk_loop(bool);
 static bool talk_thread_started = false;
 
 static PyObject *
-start(ChildMonitor *self) {
+start(PyObject *s, PyObject *a UNUSED) {
 #define start_doc "start() -> Start the I/O thread"
+    ChildMonitor *self = (ChildMonitor*)s;
     if (self->talk_fd > -1 || self->listen_fd > -1) {
         if (pthread_create(&self->talk_thread, NULL, talk_loop, self) != 0) return PyErr_SetFromErrno(PyExc_OSError);
         talk_thread_started = true;
@@ -213,7 +213,7 @@ start(ChildMonitor *self) {
 
 
 static PyObject *
-wakeup(ChildMonitor UNUSED *self) {
+wakeup(PYNOARG) {
 #define wakeup_doc "wakeup() -> wakeup the ChildMonitor I/O thread, forcing it to exit from poll() if it is waiting there."
     wakeup_io_loop(false);
     Py_RETURN_NONE;
@@ -286,10 +286,11 @@ needs_write(ChildMonitor UNUSED *self, PyObject *args) {
 }
 
 static PyObject *
-shutdown_monitor(ChildMonitor *self) {
+shutdown_monitor(ChildMonitor *self, PyObject *a UNUSED) {
 #define shutdown_monitor_doc "shutdown_monitor() -> Shutdown the monitor loop."
     signal(SIGINT, SIG_DFL);
     signal(SIGTERM, SIG_DFL);
+    signal(SIGCHLD, SIG_DFL);
     self->shutting_down = true;
     wakeup_talk_loop(false);
     wakeup_io_loop(false);
@@ -344,7 +345,7 @@ parse_input(ChildMonitor *self) {
         } else fatal("Out of memory");
     }
 
-    if (UNLIKELY(signal_received)) {
+    if (UNLIKELY(kill_signal_received)) {
         global_state.close_all_windows = true;
     } else {
         count = self->count;
@@ -568,7 +569,8 @@ simple_render_screen(PyObject UNUSED *self, PyObject *args) {
 static inline bool
 prepare_to_render_os_window(OSWindow *os_window, double now, unsigned int *active_window_id, color_type *active_window_bg, unsigned int *num_visible_windows) {
 #define TD os_window->tab_bar_render_data
-    bool needs_render = false;
+    bool needs_render = os_window->needs_render;
+    os_window->needs_render = false;
     if (TD.screen && os_window->num_tabs > 1) {
         if (send_cell_data_to_gpu(TD.vao_idx, 0, TD.xstart, TD.ystart, TD.dx, TD.dy, TD.screen, os_window)) needs_render = true;
     }
@@ -734,7 +736,7 @@ process_pending_resizes(double now) {
 }
 
 static PyObject*
-main_loop(ChildMonitor *self) {
+main_loop(ChildMonitor *self, PyObject *a UNUSED) {
 #define main_loop_doc "The main thread loop"
     bool has_open_windows = true;
 
@@ -753,7 +755,7 @@ main_loop(ChildMonitor *self) {
             OSWindow *os_window = global_state.os_windows + w - 1;
             if (should_os_window_close(os_window)) {
                 destroy_os_window(os_window);
-                call_boss(on_os_window_closed, "Kii", os_window->id, os_window->viewport_width, os_window->viewport_height);
+                call_boss(on_os_window_closed, "Kii", os_window->id, os_window->window_width, os_window->window_height);
                 for (size_t t=0; t < os_window->num_tabs; t++) {
                     Tab *tab = os_window->tabs + t;
                     for (size_t w = 0; w < tab->num_windows; w++) mark_child_for_close(self, tab->windows[w].id);
@@ -873,6 +875,58 @@ drain_fd(int fd) {
     }
 }
 
+static inline void
+read_signals(int fd, bool *kill_signal, bool *child_died) {
+    static char buf[256];
+    while(true) {
+        ssize_t len = read(fd, buf, sizeof(buf));
+        if (len < 0) {
+            if (errno == EINTR) continue;
+            if (errno != EIO) perror("Call to read() from read_signals() failed");
+            break;
+        }
+        for (ssize_t i = 0; i < len; i++) {
+            switch(buf[i]) {
+                case SIGCHLD:
+                    *child_died = true; break;
+                case SIGINT:
+                case SIGTERM:
+                    *kill_signal = true; break;
+                default:
+                    break;
+            }
+        }
+        break;
+    }
+}
+
+static inline void
+mark_child_for_removal(ChildMonitor *self, pid_t pid) {
+    children_mutex(lock);
+    for (size_t i = 0; i < self->count; i++) {
+        if (children[i].pid == pid) {
+            children[i].needs_removal = true;
+            break;
+        }
+    }
+    children_mutex(unlock);
+}
+
+static inline void
+reap_children(ChildMonitor *self, bool enable_close_on_child_death) {
+    int status;
+    pid_t pid;
+    (void)self;
+    while(true) {
+        pid = waitpid(-1, &status, WNOHANG);
+        if (pid == -1) {
+            if (errno != EINTR) break;
+        } else if (pid > 0) {
+            if (enable_close_on_child_death) mark_child_for_removal(self, pid);
+        } else break;
+    }
+}
+
 static inline void
 write_to_child(int fd, Screen *screen) {
     size_t written = 0;
@@ -924,10 +978,10 @@ io_loop(void *data) {
             if (fds[0].revents && POLLIN) drain_fd(fds[0].fd); // wakeup
             if (fds[1].revents && POLLIN) {
                 data_received = true;
-                drain_fd(fds[1].fd);
-                children_mutex(lock);
-                signal_received = true;
-                children_mutex(unlock);
+                bool kill_signal = false, child_died = false;
+                read_signals(fds[1].fd, &kill_signal, &child_died);
+                if (kill_signal) { children_mutex(lock); kill_signal_received = true; children_mutex(unlock); }
+                if (child_died) reap_children(self, OPT(close_on_child_death));
             }
             for (i = 0; i < self->count; i++) {
                 if (fds[EXTRA_FDS + i].revents & (POLLIN | POLLHUP)) {
@@ -1256,7 +1310,7 @@ PyTypeObject ChildMonitor_Type = {
 };
 
 static PyObject*
-safe_pipe(PyObject *self UNUSED) {
+safe_pipe(PYNOARG) {
     int fds[2] = {0};
     if (!self_pipe(fds)) return PyErr_SetFromErrno(PyExc_OSError);
     return Py_BuildValue("ii", fds[0], fds[1]);

kitty/cli.py

@@ -2,16 +2,16 @@
 # vim:fileencoding=utf-8
 # License: GPL v3 Copyright: 2017, Kovid Goyal <kovid at kovidgoyal.net>
 
+import os
 import re
 import subprocess
 import sys
 from collections import deque
 
-from .config import load_config
-from .constants import appname, defconf, is_macos, str_version
+from .config import defaults, load_config
+from .constants import appname, defconf, is_macos, is_wayland, str_version
 from .layout import all_layouts
 
-is_macos
 OPTIONS = '''
 --class
 dest=cls
@@ -32,9 +32,21 @@ only use this if you are running a program that does not set titles.
 
 --config
 type=list
-default={config_path}
 Specify a path to the configuration file(s) to use.
-Can be specified multiple times to read multiple configuration files in sequence, which are merged.
+Can be specified multiple times to read multiple configuration files in
+sequence, which are merged.  Use the special value NONE to not load a config
+file.
+
+If this option is not specified, config files are searched for in the order:
+"$XDG_CONFIG_HOME/kitty/kitty.conf", "~/.config/kitty/kitty.conf", {macos_confpath}
+"$XDG_CONFIG_DIRS/kitty/kitty.conf". The first one that exists is used as the
+config file.
+
+If the environment variable "KITTY_CONFIG_DIRECTORY" is specified, that
+directory is always used and the above searching does not happen.
+
+If "/etc/xdg/kitty/kitty.conf" exists it is used as a base config file onto
+which any user config files are merged.
 
 
 --override -o
@@ -122,6 +134,11 @@ Debug OpenGL commands. This will cause all OpenGL calls to check for errors inst
 --debug-font-fallback
 type=bool-set
 Print out information about the selection of fallback fonts for characters not present in the main font.
+
+
+--debug-config
+type=bool-set
+Print out information about the system and kitty configuration.
 '''
 
 
@@ -201,10 +218,10 @@ def parse_option_spec(spec=OPTIONS):
                     current_cmd['choices'] = {x.strip() for x in current_cmd['choices'].split(',')}
         elif state is HELP:
             if line:
-                current_cmd['help'] += ' ' + line
+                current_cmd['help'] += ' ' + line.lstrip()
             else:
                 if prev_line:
-                    current_cmd['help'] += '\n'
+                    current_cmd['help'] += '\n\n\t'
                 else:
                     state = NORMAL
                     (seq if current_cmd.get('condition', True) else disabled).append(current_cmd)
@@ -286,8 +303,9 @@ def print_help_for_seq(seq, usage, message, appname):
                 lines.append('')
         a((' ' * leading_indent) + j.join(lines))
 
-    usage = usage or '[program-to-run ...]'
-    a('{}: {} [options] {}'.format(title('Usage'), bold(yellow(appname)), usage))
+    usage = '[program-to-run ...]' if usage is None else usage
+    optstring = '[options] ' if seq else ''
+    a('{}: {} {}{}'.format(title('Usage'), bold(yellow(appname)), optstring, usage))
     a('')
     message = message or (
         'Run the |G {appname}| terminal emulator. You can also specify the |_ program| to run inside |_ {appname}| as normal'
@@ -452,7 +470,7 @@ def parse_cmdline(oc, disabled, args=None):
 def options_spec():
     if not hasattr(options_spec, 'ans'):
         options_spec.ans = OPTIONS.format(
-            appname=appname, config_path=defconf,
+            appname=appname, macos_confpath='~/Library/Preferences/kitty/kitty.conf' if is_macos else '',
             window_layout_choices=', '.join(all_layouts)
         )
     return options_spec.ans
@@ -465,8 +483,85 @@ def parse_args(args=None, ospec=options_spec, usage=None, message=None, appname=
     return parse_cmdline(oc, disabled, args=args)
 
 
-def create_opts(args):
-    config = args.config or (defconf, )
+SYSTEM_CONF = '/etc/xdg/kitty/kitty.conf'
+
+
+def resolve_config(config_files_on_cmd_line):
+    if config_files_on_cmd_line:
+        if 'NONE' not in config_files_on_cmd_line:
+            yield SYSTEM_CONF
+            for cf in config_files_on_cmd_line:
+                yield cf
+    else:
+        yield SYSTEM_CONF
+        yield defconf
+
+
+def print_shortcut(key, action):
+    if not getattr(print_shortcut, 'maps', None):
+        from kitty.keys import defines
+        v = vars(defines)
+        mmap = {m.split('_')[-1].lower(): x for m, x in v.items() if m.startswith('GLFW_MOD_')}
+        kmap = {k.split('_')[-1].lower(): x for k, x in v.items() if k.startswith('GLFW_KEY_')}
+        krmap = {v: k for k, v in kmap.items()}
+        print_shortcut.maps = mmap, krmap
+    mmap, krmap = print_shortcut.maps
+    names = []
+    mods, key = key
+    for name, val in mmap.items():
+        if mods & val:
+            names.append(name)
+    if key:
+        names.append(krmap[key])
+    print('\t', '+'.join(names), action)
+
+
+def compare_keymaps(final, initial):
+    added = set(final) - set(initial)
+    removed = set(initial) - set(final)
+    changed = {k for k in set(final) & set(initial) if final[k] != initial[k]}
+    if added:
+        print(title('Added shortcuts:'))
+        for k in added:
+            print_shortcut(k, final[k])
+    if removed:
+        print(title('Removed shortcuts:'))
+        for k in removed:
+            print_shortcut(k, initial[k])
+    if changed:
+        print(title('Changed shortcuts:'))
+        for k in changed:
+            print_shortcut(k, final[k])
+
+
+def compare_opts(opts):
+    print('\nConfig options different from defaults:')
+    for f in sorted(defaults._fields):
+        if getattr(opts, f) != getattr(defaults, f):
+            if f == 'keymap':
+                compare_keymaps(opts.keymap, defaults.keymap)
+            else:
+                print(title('{:20s}'.format(f)), getattr(opts, f))
+
+
+def create_opts(args, debug_config=False):
+    config = tuple(resolve_config(args.config))
+    if debug_config:
+        print(version())
+        print(' '.join(os.uname()))
+        if is_macos:
+            print(' '.join(subprocess.check_output(['sw_vers']).decode('utf-8').splitlines()).strip())
+        else:
+            print('Running under:', green('Wayland' if is_wayland else 'X11'))
+        if os.path.exists('/etc/issue'):
+            print(open('/etc/issue', encoding='utf-8', errors='replace').read().strip())
+        if os.path.exists('/etc/lsb-release'):
+            print(open('/etc/lsb-release', encoding='utf-8', errors='replace').read().strip())
+        config = tuple(x for x in config if os.path.exists(x))
+        if config:
+            print(green('Loaded config files:'), ', '.join(config))
     overrides = (a.replace('=', ' ', 1) for a in args.override or ())
     opts = load_config(*config, overrides=overrides)
+    if debug_config:
+        compare_opts(opts)
     return opts

kitty/cocoa_window.m

@@ -59,11 +59,35 @@ find_app_name(void) {
     return @"kitty";
 }
 
+@interface GlobalMenuTarget : NSObject
++ (GlobalMenuTarget *) shared_instance;
+@end
+
+@implementation GlobalMenuTarget
+
+- (void) show_preferences              : (id)sender {
+    (void)sender;
+    call_boss(edit_config_file, NULL);
+}
+
++ (GlobalMenuTarget *) shared_instance
+{
+    static GlobalMenuTarget *sharedGlobalMenuTarget = nil;
+    @synchronized(self)
+    {
+        if (!sharedGlobalMenuTarget)
+            sharedGlobalMenuTarget = [[GlobalMenuTarget alloc] init];
+        return sharedGlobalMenuTarget;
+    }
+}
+
+@end
 
 void
 cocoa_create_global_menu(void) {
     NSString* app_name = find_app_name();
     NSMenu* bar = [[NSMenu alloc] init];
+    GlobalMenuTarget *global_menu_target = [GlobalMenuTarget shared_instance];
     [NSApp setMainMenu:bar];
 
     NSMenuItem* appMenuItem =
@@ -75,6 +99,9 @@ cocoa_create_global_menu(void) {
                        action:@selector(orderFrontStandardAboutPanel:)
                        keyEquivalent:@""];
     [appMenu addItem:[NSMenuItem separatorItem]];
+    NSMenuItem* preferences_menu_item = [[NSMenuItem alloc] initWithTitle:@"Preferences..." action:@selector(show_preferences:) keyEquivalent:@","];
+    [preferences_menu_item setTarget:global_menu_target];
+    [appMenu addItem:preferences_menu_item];
     [appMenu addItemWithTitle:[NSString stringWithFormat:@"Hide %@", app_name]
                        action:@selector(hide:)
                 keyEquivalent:@"h"];
@@ -124,7 +151,7 @@ cocoa_create_global_menu(void) {
      setKeyEquivalentModifierMask:NSEventModifierFlagControl | NSEventModifierFlagCommand];
     [NSApp setWindowsMenu:windowMenu];
     [windowMenu release];
-
+    [preferences_menu_item release];
 
     [bar release];
 }

kitty/colors.c

@@ -133,7 +133,7 @@ as_color(ColorProfile *self, PyObject *val) {
 }
 
 static PyObject*
-reset_color_table(ColorProfile *self) {
+reset_color_table(ColorProfile *self, PyObject *a UNUSED) {
 #define reset_color_table_doc "Reset all customized colors back to defaults"
     memcpy(self->color_table, self->orig_color_table, sizeof(FG_BG_256));
     self->dirty = true;
@@ -179,7 +179,7 @@ copy_color_table_to_buffer(ColorProfile *self, color_type *buf, int offset, size
 }
 
 static PyObject*
-color_table_address(ColorProfile *self) {
+color_table_address(ColorProfile *self, PyObject *a UNUSED) {
 #define color_table_address_doc "Pointer address to start of color table"
     return PyLong_FromVoidPtr((void*)self->color_table);
 }

kitty/config.py

@@ -17,7 +17,7 @@ from .config_utils import (
     init_config, parse_config_base, positive_float, positive_int, to_bool,
     to_color, unit_float
 )
-from .constants import cache_dir
+from .constants import cache_dir, defconf
 from .fast_data_types import CURSOR_BEAM, CURSOR_BLOCK, CURSOR_UNDERLINE
 from .layout import all_layouts
 from .utils import log_error
@@ -50,7 +50,7 @@ def to_cursor_shape(x):
 def parse_mods(parts):
 
     def map_mod(m):
-        return {'CTRL': 'CONTROL', 'CMD': 'SUPER', 'OPTION': 'ALT'}.get(m, m)
+        return {'CTRL': 'CONTROL', 'CMD': 'SUPER', '⌘': 'SUPER', '⌥': 'ALT', 'OPTION': 'ALT'}.get(m, m)
 
     mods = 0
     for m in parts:
@@ -111,6 +111,10 @@ def parse_key_action(action):
         args = rest.split(' ', 2)
     elif func == 'goto_tab':
         args = (max(0, int(rest)), )
+    elif func == 'goto_layout':
+        args = [rest]
+    elif func == 'set_font_size':
+        args = (float(rest),)
     elif func in shlex_actions:
         args = shlex.split(rest)
     return KeyAction(func, args)
@@ -270,6 +274,7 @@ type_map = {
     'repaint_delay': positive_int,
     'input_delay': positive_int,
     'sync_to_monitor': to_bool,
+    'close_on_child_death': to_bool,
     'window_border_width': positive_float,
     'window_margin_width': positive_float,
     'window_padding_width': positive_float,
@@ -288,7 +293,6 @@ type_map = {
     'macos_option_as_alt': to_bool,
     'macos_titlebar_color': macos_titlebar_color,
     'box_drawing_scale': box_drawing_scale,
-    'x11_bell_volume': int,
     'background_opacity': unit_float,
     'tab_separator': tab_separator,
     'active_tab_font_style': tab_font_style,
@@ -348,7 +352,7 @@ def parse_config(lines, check_keys=True):
 
 Options, defaults = init_config(default_config_path, parse_config)
 actions = frozenset(a.func for a in defaults.keymap.values()) | frozenset(
-    'combine send_text goto_tab new_tab_with_cwd new_window_with_cwd new_os_window_with_cwd'.
+    'combine send_text goto_tab goto_layout set_font_size new_tab_with_cwd new_window_with_cwd new_os_window_with_cwd'.
     split()
 )
 no_op_actions = frozenset({'noop', 'no-op', 'no_op'})
@@ -463,3 +467,27 @@ def initial_window_size(opts, cached_values):
         except Exception:
             log_error('Invalid cached window size, ignoring')
     return w, h
+
+
+def commented_out_default_config():
+    with open(default_config_path, encoding='utf-8', errors='replace') as f:
+        config = f.read()
+    lines = []
+    for line in config.splitlines():
+        if line.strip() and not line.startswith('#'):
+            line = '# ' + line
+        lines.append(line)
+    config = '\n'.join(lines)
+    return config
+
+
+def prepare_config_file_for_editing():
+    if not os.path.exists(defconf):
+        d = os.path.dirname(defconf)
+        try:
+            os.makedirs(d)
+        except FileExistsError:
+            pass
+        with open(defconf, 'w') as f:
+            f.write(commented_out_default_config())
+    return defconf

kitty/config_utils.py

@@ -56,7 +56,7 @@ def parse_config_base(
 
 
 def init_config(defaults_path, parse_config):
-    with open(defaults_path, encoding='utf-8') as f:
+    with open(defaults_path, encoding='utf-8', errors='replace') as f:
         defaults = parse_config(f.read().splitlines(), check_keys=False)
     Options = namedtuple('Defaults', ','.join(defaults.keys()))
     defaults = Options(**defaults)

kitty/constants.py

@@ -4,17 +4,19 @@
 
 import os
 import pwd
+import shlex
 import sys
 from collections import namedtuple
 
 from .fast_data_types import set_boss as set_c_boss
 
 appname = 'kitty'
-version = (0, 8, 1)
+version = (0, 8, 3)
 str_version = '.'.join(map(str, version))
 _plat = sys.platform.lower()
 is_macos = 'darwin' in _plat
 base = os.path.dirname(os.path.abspath(__file__))
+editor = shlex.split(os.environ.get('EDITOR', 'vim'))
 
 
 ScreenGeometry = namedtuple('ScreenGeometry', 'xstart ystart xnum ynum dx dy')
@@ -25,7 +27,22 @@ def _get_config_dir():
     if 'KITTY_CONFIG_DIRECTORY' in os.environ:
         return os.path.abspath(os.path.expanduser(os.environ['KITTY_CONFIG_DIRECTORY']))
 
-    candidate = os.path.abspath(os.path.expanduser(os.environ.get('XDG_CONFIG_HOME') or ('~/Library/Preferences' if is_macos else '~/.config')))
+    locations = []
+    if 'XDG_CONFIG_HOME' in os.environ:
+        locations.append(os.path.abspath(os.path.expanduser(os.environ['XDG_CONFIG_HOME'])))
+    locations.append(os.path.expanduser('~/.config'))
+    if is_macos:
+        locations.append(os.path.expanduser('~/Library/Preferences'))
+    if 'XDG_CONFIG_DIRS' in os.environ:
+        for loc in os.environ['XDG_CONFIG_DIRS'].split(os.pathsep):
+            locations.append(os.path.abspath(os.path.expanduser(os.environ['XDG_CONFIG_HOME'])))
+    for loc in locations:
+        if loc:
+            q = os.path.join(loc, appname)
+            if os.access(q, os.W_OK) and os.path.exists(os.path.join(q, 'kitty.conf')):
+                return q
+
+    candidate = os.path.abspath(os.path.expanduser(os.environ.get('XDG_CONFIG_HOME') or '~/.config'))
     ans = os.path.join(candidate, appname)
     os.makedirs(ans, exist_ok=True)
     return ans
@@ -44,10 +61,7 @@ def _get_cache_dir():
     else:
         candidate = os.environ.get('XDG_CACHE_HOME', '~/.cache')
         candidate = os.path.join(os.path.expanduser(candidate), appname)
-    try:
-        os.makedirs(candidate)
-    except FileExistsError:
-        pass
+    os.makedirs(candidate, exist_ok=True)
     return candidate
 
 

kitty/cursor.c

@@ -253,7 +253,7 @@ cursor_as_sgr(Cursor *self, Cursor *prev) {
 }
 
 static PyObject *
-reset_display_attrs(Cursor *self) {
+reset_display_attrs(Cursor *self, PyObject *a UNUSED) {
 #define reset_display_attrs_doc "Reset all display attributes to unset"
     cursor_reset_display_attrs(self);
     Py_RETURN_NONE;
@@ -272,7 +272,7 @@ void cursor_copy_to(Cursor *src, Cursor *dest) {
 }
 
 static PyObject*
-copy(Cursor *self);
+copy(Cursor *self, PyObject*);
 #define copy_doc "Create a clone of this cursor"
 
 // Boilerplate {{{
@@ -342,7 +342,7 @@ cursor_copy(Cursor *self) {
 }
 
 static PyObject*
-copy(Cursor *self) {
+copy(Cursor *self, PyObject *a UNUSED) {
     return (PyObject*)cursor_copy(self);
 }
 

kitty/data-types.c

@@ -17,7 +17,6 @@
 #include <stddef.h>
 #include <termios.h>
 #include <signal.h>
-#include <sys/wait.h>
 #ifdef WITH_PROFILER
 #include <gperftools/profiler.h>
 #endif
@@ -88,31 +87,6 @@ pyset_iutf8(PyObject UNUSED *self, PyObject *args) {
     Py_RETURN_NONE;
 }
 
-static void
-handle_sigchld(int UNUSED signum, siginfo_t *sinfo, void UNUSED *unused) {
-    if (sinfo->si_code != CLD_EXITED) return;
-    int sav_errno = errno, status;
-    while(true) {
-        if (waitpid(sinfo->si_pid, &status, WNOHANG) == -1) {
-            if (errno != EINTR) break;
-        } else break;
-    }
-    // wakeup I/O loop as without this on macOS sometimes poll() does not detect the fd close, so
-    // kitty does not detect child death.
-    wakeup_io_loop(true);
-    errno = sav_errno;
-}
-
-static PyObject*
-install_sigchld_handler(PyObject UNUSED *self) {
-    struct sigaction sa;
-    sa.sa_flags = SA_SIGINFO;
-    sa.sa_sigaction = handle_sigchld;
-    sigemptyset(&sa.sa_mask);
-    if (sigaction(SIGCHLD, &sa, NULL) == -1) return PyErr_SetFromErrno(PyExc_OSError);
-    Py_RETURN_NONE;
-}
-
 #ifdef WITH_PROFILER
 static PyObject*
 start_profiler(PyObject UNUSED *self, PyObject *args) {
@@ -135,7 +109,6 @@ static PyMethodDef module_methods[] = {
     {"parse_bytes", (PyCFunction)parse_bytes, METH_VARARGS, ""},
     {"parse_bytes_dump", (PyCFunction)parse_bytes_dump, METH_VARARGS, ""},
     {"redirect_std_streams", (PyCFunction)redirect_std_streams, METH_VARARGS, ""},
-    {"install_sigchld_handler", (PyCFunction)install_sigchld_handler, METH_NOARGS, ""},
 #ifdef __APPLE__
     METHODB(user_cache_dir, METH_NOARGS),
 #endif

kitty/data-types.h

@@ -18,6 +18,7 @@
 #define OPENGL_REQUIRED_VERSION_MAJOR 3
 #define OPENGL_REQUIRED_VERSION_MINOR 3
 #define UNUSED __attribute__ ((unused))
+#define PYNOARG PyObject *__a1 UNUSED, PyObject *__a2 UNUSED
 #define EXPORTED __attribute__ ((visibility ("default")))
 #define LIKELY(x)    __builtin_expect (!!(x), 1)
 #define UNLIKELY(x)  __builtin_expect (!!(x), 0)
@@ -208,7 +209,7 @@ typedef struct {
 
 #define clear_sprite_position(cell) (cell).sprite_x = 0; (cell).sprite_y = 0; (cell).sprite_z = 0;
 
-#define left_shift_line(line, at, num) \
+#define left_shift_line(line, at, num) { \
     for(index_type __i__ = (at); __i__ < (line)->xnum - (num); __i__++) { \
         COPY_CELL(line, __i__ + (num), line, __i__) \
     } \
@@ -216,7 +217,8 @@ typedef struct {
         (line)->cells[(at)].ch = BLANK_CHAR; \
         (line)->cells[(at)].attrs = BLANK_CHAR ? 1 : 0; \
         clear_sprite_position((line)->cells[(at)]); \
-    }
+    }\
+}
 
 #define ensure_space_for(base, array, type, num, capacity, initial_cap, zero_mem) \
     if ((base)->capacity < num) { \

kitty/fonts.c

@@ -1066,7 +1066,7 @@ concat_cells(PyObject UNUSED *self, PyObject *args) {
 }
 
 static PyObject*
-current_fonts(PyObject UNUSED *self) {
+current_fonts(PYNOARG) {
     PyObject *ans = PyDict_New();
     if (!ans) return NULL;
 #define SET(key, val) {if (PyDict_SetItemString(ans, #key, fonts.fonts[val].face) != 0) { goto error; }}
@@ -1097,7 +1097,7 @@ get_fallback_font(PyObject UNUSED *self, PyObject *args) {
     static Py_UCS4 char_buf[2 + arraysz(cell.cc_idx)];
     if (!PyUnicode_AsUCS4(text, char_buf, arraysz(char_buf), 1)) return NULL;
     cell.ch = char_buf[0];
-    for (unsigned i = 0; i + 1 < PyUnicode_GetLength(text) && i < arraysz(cell.cc_idx); i++) cell.cc_idx[i] = mark_for_codepoint(char_buf[i + 1]);
+    for (unsigned i = 0; i + 1 < (unsigned) PyUnicode_GetLength(text) && i < arraysz(cell.cc_idx); i++) cell.cc_idx[i] = mark_for_codepoint(char_buf[i + 1]);
     if (bold) cell.attrs |= 1 << BOLD_SHIFT;
     if (italic) cell.attrs |= 1 << ITALIC_SHIFT;
     ssize_t ans = fallback_font(&cell);

kitty/freetype.c

@@ -278,8 +278,12 @@ calc_cell_width(Face *self) {
     unsigned int ans = 0;
     for (char_type i = 32; i < 128; i++) {
         int glyph_index = FT_Get_Char_Index(self->face, i);
-        if (load_glyph(self, glyph_index, FT_LOAD_DEFAULT)) {
-            ans = MAX(ans, (unsigned long)ceilf((float)self->face->glyph->metrics.horiAdvance / 64.f));
+        // We actually render the bitmap and get its width even though this is very slow, because
+        // there are fonts for which the horizontal advance is incorrect, see https://github.com/kovidgoyal/kitty/issues/352
+        if (load_glyph(self, glyph_index, FT_LOAD_RENDER)) {
+            unsigned int horizontal_advance = (unsigned int)ceilf((float)self->face->glyph->metrics.horiAdvance / 64.f);
+            ans = MAX(ans, self->face->glyph->bitmap.width);
+            ans = MAX(ans, horizontal_advance);
         }
     }
     return ans;
@@ -532,7 +536,8 @@ render_glyphs_in_cells(PyObject *f, bool bold, bool italic, hb_glyph_info_t *inf
 }
 
 static PyObject*
-display_name(Face *self) {
+display_name(PyObject *s, PyObject *a UNUSED) {
+    Face *self = (Face*)s;
     const char *psname = FT_Get_Postscript_Name(self->face);
     if (psname) return Py_BuildValue("s", psname);
     Py_INCREF(self->path);
@@ -540,8 +545,8 @@ display_name(Face *self) {
 }
 
 static PyObject*
-extra_data(Face *self) {
-    return PyLong_FromVoidPtr(self->extra_data);
+extra_data(PyObject *self, PyObject *a UNUSED) {
+    return PyLong_FromVoidPtr(((Face*)self)->extra_data);
 }
 
 // Boilerplate {{{

kitty/glfw-wrapper.h

@@ -1585,7 +1585,7 @@ typedef void (*glfwRequestWindowAttention_func)(GLFWwindow*);
 glfwRequestWindowAttention_func glfwRequestWindowAttention_impl;
 #define glfwRequestWindowAttention glfwRequestWindowAttention_impl
 
-typedef int (*glfwWindowBell_func)(GLFWwindow*, int64_t);
+typedef int (*glfwWindowBell_func)(GLFWwindow*);
 glfwWindowBell_func glfwWindowBell_impl;
 #define glfwWindowBell glfwWindowBell_impl
 

kitty/glfw.c

@@ -30,6 +30,8 @@ update_os_window_viewport(OSWindow *window, bool notify_boss) {
     window->has_pending_resizes = false;
     window->viewport_width = MAX(window->viewport_width, 100);
     window->viewport_height = MAX(window->viewport_height, 100);
+    window->window_width = MAX(w, 100);
+    window->window_height = MAX(h, 100);
     if (notify_boss) {
         call_boss(on_window_resize, "KiiO", window->id, window->viewport_width, window->viewport_height, dpi_changed ? Py_True : Py_False);
     }
@@ -481,7 +483,7 @@ glfw_init(PyObject UNUSED *self, PyObject *args) {
 }
 
 PyObject*
-glfw_terminate(PyObject UNUSED *self) {
+glfw_terminate(PYNOARG) {
     glfwTerminate();
     Py_RETURN_NONE;
 }
@@ -499,13 +501,13 @@ glfw_wait_events(PyObject UNUSED *self, PyObject *args) {
 }
 
 PyObject*
-glfw_post_empty_event(PyObject UNUSED *self) {
+glfw_post_empty_event(PYNOARG) {
     glfwPostEmptyEvent();
     Py_RETURN_NONE;
 }
 
 PyObject*
-glfw_poll_events(PyObject UNUSED *self) {
+glfw_poll_events(PYNOARG) {
     glfwPollEvents();
     Py_RETURN_NONE;
 }
@@ -523,7 +525,7 @@ get_physical_dpi(GLFWmonitor *m) {
 }
 
 PyObject*
-glfw_get_physical_dpi(PyObject UNUSED *self) {
+glfw_get_physical_dpi(PYNOARG) {
     GLFWmonitor *m = glfwGetPrimaryMonitor();
     if (m == NULL) { PyErr_SetString(PyExc_ValueError, "Failed to get primary monitor"); return NULL; }
     return get_physical_dpi(m);
@@ -548,14 +550,14 @@ glfw_window_hint(PyObject UNUSED *self, PyObject *args) {
 // }}}
 
 static PyObject*
-get_clipboard_string(PyObject UNUSED *self) {
+get_clipboard_string(PYNOARG) {
     OSWindow *w = current_os_window();
     if (w) return Py_BuildValue("s", glfwGetClipboardString(w->handle));
     return Py_BuildValue("s", "");
 }
 
 static PyObject*
-get_content_scale_for_window(PyObject UNUSED *self) {
+get_content_scale_for_window(PYNOARG) {
     OSWindow *w = global_state.callback_os_window ? global_state.callback_os_window : global_state.os_windows;
     float xscale, yscale;
     glfwGetWindowContentScale(w->handle, &xscale, &yscale);
@@ -572,7 +574,7 @@ set_clipboard_string(PyObject UNUSED *self, PyObject *args) {
 }
 
 static PyObject*
-toggle_fullscreen(PyObject UNUSED *self) {
+toggle_fullscreen(PYNOARG) {
     GLFWmonitor *monitor;
     OSWindow *w = current_os_window();
     if (!w) Py_RETURN_NONE;
@@ -602,7 +604,7 @@ ring_audio_bell(OSWindow *w) {
     if (now - last_bell_at <= 0.1) return;
     last_bell_at = now;
     if (w->handle) {
-        glfwWindowBell(w->handle, OPT(x11_bell_volume));
+        glfwWindowBell(w->handle);
     }
 }
 
@@ -662,14 +664,14 @@ should_os_window_close(OSWindow* w) {
 }
 
 static PyObject*
-primary_monitor_size(PyObject UNUSED *self) {
+primary_monitor_size(PYNOARG) {
     GLFWmonitor* monitor = glfwGetPrimaryMonitor();
     const GLFWvidmode* mode = glfwGetVideoMode(monitor);
     return Py_BuildValue("ii", mode->width, mode->height);
 }
 
 static PyObject*
-primary_monitor_content_scale(PyObject UNUSED *self) {
+primary_monitor_content_scale(PYNOARG) {
     GLFWmonitor* monitor = glfwGetPrimaryMonitor();
     float xscale, yscale;
     glfwGetMonitorContentScale(monitor, &xscale, &yscale);
@@ -677,7 +679,7 @@ primary_monitor_content_scale(PyObject UNUSED *self) {
 }
 
 static PyObject*
-x11_display(PyObject UNUSED *self) {
+x11_display(PYNOARG) {
     if (glfwGetX11Display) {
         return PyLong_FromVoidPtr(glfwGetX11Display());
     } else log_error("Failed to load glfwGetX11Display");
@@ -699,7 +701,7 @@ x11_window_id(PyObject UNUSED *self, PyObject *os_wid) {
 }
 
 static PyObject*
-get_primary_selection(PyObject UNUSED *self) {
+get_primary_selection(PYNOARG) {
     if (glfwGetX11SelectionString) {
         return Py_BuildValue("y", glfwGetX11SelectionString());
     } else log_error("Failed to load glfwGetX11SelectionString");

kitty/graphics.c

@@ -509,7 +509,7 @@ handle_add_command(GraphicsManager *self, const GraphicsCommand *g, const uint8_
 
 static inline const char*
 create_add_response(GraphicsManager UNUSED *self, bool data_loaded, uint32_t iid) {
-    static char rbuf[sizeof(add_response)/sizeof(add_response[0])];
+    static char rbuf[sizeof(add_response)/sizeof(add_response[0]) + 64];
     if (iid) {
         if (!has_add_respose) {
             if (!data_loaded) return NULL;

kitty/history.c

@@ -161,7 +161,7 @@ __str__(HistoryBuf *self) {
     if (lines == NULL) return PyErr_NoMemory();
     for (index_type i = 0; i < self->count; i++) {
         init_line(self, index_of(self, i), self->line);
-        PyObject *t = PyObject_Str((PyObject*)self->line);
+        PyObject *t = line_as_unicode(self->line);
         if (t == NULL) { Py_CLEAR(lines); return NULL; }
         PyTuple_SET_ITEM(lines, i, t);
     }
@@ -215,7 +215,7 @@ as_text(HistoryBuf *self, PyObject *args) {
 
 
 static PyObject*
-dirty_lines(HistoryBuf *self) {
+dirty_lines(HistoryBuf *self, PyObject *a UNUSED) {
 #define dirty_lines_doc "dirty_lines() -> Line numbers of all lines that have dirty text."
     PyObject *ans = PyList_New(0);
     for (index_type i = 0; i < self->ynum; i++) {

kitty/keys.h

@@ -1747,6 +1747,7 @@ key_lookup(uint8_t key, KeyboardMode mode, uint8_t mods, uint8_t action) {
                     return "\x01\x0d";
                 } // end switch(key)
           }  // end switch(mods)
+          break;
 
         case 2: // REPEAT
           switch (mods & 0xf) {
@@ -3005,8 +3006,10 @@ key_lookup(uint8_t key, KeyboardMode mode, uint8_t mods, uint8_t action) {
                     return "\x01\x0d";
                 } // end switch(key)
           }  // end switch(mods)
+          break;
 
       }  // end switch(action) in mode NORMAL
+      break;
 
 
       case APPLICATION:
@@ -4271,6 +4274,7 @@ key_lookup(uint8_t key, KeyboardMode mode, uint8_t mods, uint8_t action) {
                       return "\x01\x0d";
                   } // end switch(key)
             }  // end switch(mods)
+            break;
 
           case 2: // REPEAT
             switch (mods & 0xf) {
@@ -5529,8 +5533,10 @@ key_lookup(uint8_t key, KeyboardMode mode, uint8_t mods, uint8_t action) {
                       return "\x01\x0d";
                   } // end switch(key)
             }  // end switch(mods)
+            break;
 
         }  // end switch(action) in mode APPLICATION
+        break;
 
 
         case EXTENDED:
@@ -9134,6 +9140,7 @@ key_lookup(uint8_t key, KeyboardMode mode, uint8_t mods, uint8_t action) {
                         return "\x05\x4b\x72\x50\x42\x68";
                     } // end switch(key)
               }  // end switch(mods)
+              break;
 
             case 1: // PRESS
               switch (mods & 0xf) {
@@ -12738,6 +12745,7 @@ key_lookup(uint8_t key, KeyboardMode mode, uint8_t mods, uint8_t action) {
                         return "\x05\x4b\x70\x50\x42\x68";
                     } // end switch(key)
               }  // end switch(mods)
+              break;
 
             case 2: // REPEAT
               switch (mods & 0xf) {
@@ -16342,8 +16350,10 @@ key_lookup(uint8_t key, KeyboardMode mode, uint8_t mods, uint8_t action) {
                         return "\x05\x4b\x74\x50\x42\x68";
                     } // end switch(key)
               }  // end switch(mods)
+              break;
 
           }  // end switch(action) in mode EXTENDED
+          break;
 
 
       }

kitty/keys.py

@@ -336,13 +336,15 @@ def generate_key_table():
                         ind('return NULL;')
                     i -= 2
                 i -= 1
-                ind('}  // end switch(mods)\n')
+                ind('}  // end switch(mods)')
+                ind('break;\n')
                 i -= 1
             else:
                 ind('return NULL;\n')
                 i -= 1
             i -= 1
-        ind('}}  // end switch(action) in mode {}\n\n'.format(mode))
+        ind('}}  // end switch(action) in mode {}'.format(mode))
+        ind('break;\n\n')
         i -= 1
     i -= 1
     ind('}')

kitty/kitty.conf

@@ -1,5 +1,6 @@
 # vim:fileencoding=utf-8:ft=conf
 
+# Fonts {{{
 # Font family. You can also specify different fonts for the
 # bold/italic/bold-italic variants. By default they are derived automatically,
 # by the OSes font system. Setting them manually is useful for font families
@@ -11,6 +12,7 @@
 #
 # You can get a list of full family names available on your computer by running
 # kitty list-fonts
+# The default values shown below rely on your OS to choose an appropriate monospace font family.
 font_family      monospace
 italic_font      auto
 bold_font        auto
@@ -32,12 +34,189 @@ font_size_delta 2
 adjust_line_height 0
 adjust_column_width 0
 
+# Symbol mapping (special font for specified unicode code points). Map the
+# specified unicode codepoints to a particular font. Useful if you need special
+# rendering for some symbols, such as for Powerline. Avoids the need for
+# patched fonts. Each unicode code point is specified in the form U+<code point
+# in hexadecimal>. You can specify multiple code points, separated by commas
+# and ranges separated by hyphens. symbol_map itself can be specified multiple times.
+# Syntax is:
+#
+# symbol_map codepoints Font Family Name
+#
+# For example:
+#
+# symbol_map U+E0A0-U+E0A2,U+E0B0-U+E0B3 PowerlineSymbols
+
 # Change the sizes of the lines used for the box drawing unicode characters
 # These values are in pts. They will be scaled by the monitor DPI to arrive at
 # a pixel value. There must be four values corresponding to thin, normal, thick,
 # and very thick lines;
 box_drawing_scale 0.001, 1, 1.5, 2
+# }}}
 
+
+# Cursor customization {{{
+# The cursor color
+cursor           #cccccc
+
+# The cursor shape can be one of (block, beam, underline)
+cursor_shape     block
+
+# The interval (in seconds) at which to blink the cursor. Set to zero to
+# disable blinking. Note that numbers smaller than repaint_delay will be
+# limited to repaint_delay.
+cursor_blink_interval     0.5
+
+# Stop blinking cursor after the specified number of seconds of keyboard inactivity. Set to
+# zero to never stop blinking.
+cursor_stop_blinking_after 15.0
+# }}}
+
+
+# Scrollback {{{
+# Number of lines of history to keep in memory for scrolling back
+scrollback_lines 2000
+
+# Program with which to view scrollback in a new window. The scrollback buffer is passed as
+# STDIN to this program. If you change it, make sure the program you use can
+# handle ANSI escape sequences for colors and text formatting.
+scrollback_pager less +G -R
+
+# Wheel scroll multiplier (modify the amount scrolled by the mouse wheel). Use negative
+# numbers to change scroll direction.
+wheel_scroll_multiplier 5.0
+# }}}
+
+
+# Mouse {{{
+# The color and style for highlighting URLs on mouse-over. url_style can be one of:
+# none, single, double, curly
+url_color #0087BD
+url_style curly
+
+# The modifier keys to press when clicking with the mouse on URLs to open the URL
+open_url_modifiers ctrl+shift
+
+# The program with which to open URLs that are clicked on. The special value "default" means to
+# use the operating system's default URL handler.
+open_url_with default
+
+# Copy to clipboard on select. With this enabled, simply selecting text with
+# the mouse will cause the text to be copied to clipboard. Useful on platforms
+# such as macOS/Wayland that do not have the concept of primary selections. Note
+# that this is a security risk, as all programs, including websites open in your
+# browser can read the contents of the clipboard.
+copy_on_select no
+
+# The modifiers to use rectangular selection (i.e. to select text in a
+# rectangular block with the mouse)
+rectangle_select_modifiers ctrl+alt
+
+# Characters considered part of a word when double clicking. In addition to these characters
+# any character that is marked as an alpha-numeric character in the unicode
+# database will be matched.
+select_by_word_characters :@-./_~?&=%+#
+
+# The interval between successive clicks to detect double/triple clicks (in seconds)
+click_interval 0.5
+
+# Hide mouse cursor after the specified number of seconds of the mouse not being used. Set to
+# zero to disable mouse cursor hiding.
+mouse_hide_wait 3.0
+
+# Set the active window to the window under the mouse when moving the mouse around
+focus_follows_mouse no
+# }}}
+
+
+# Performance tuning {{{
+# Delay (in milliseconds) between screen updates. Decreasing it, increases
+# frames-per-second (FPS) at the cost of more CPU usage. The default value
+# yields ~100 FPS which is more than sufficient for most uses. Note that to
+# actually achieve 100FPS you have to either set sync_to_monitor to no or use a
+# monitor with a high refresh rate.
+repaint_delay    10
+
+# Delay (in milliseconds) before input from the program running in the terminal
+# is processed. Note that decreasing it will increase responsiveness, but also
+# increase CPU usage and might cause flicker in full screen programs that
+# redraw the entire screen on each loop, because kitty is so fast that partial
+# screen updates will be drawn.
+input_delay 3
+
+# Sync screen updates to the refresh rate of the monitor. This prevents
+# tearing (https://en.wikipedia.org/wiki/Screen_tearing) when scrolling. However,
+# it limits the rendering speed to the refresh rate of your monitor. With a
+# very high speed mouse/high keyboard repeat rate, you may notice some slight input latency.
+# If so, set this to no.
+sync_to_monitor yes
+# }}}
+
+
+# Audio/visual bell {{{
+# Visual bell duration. Flash the screen when a bell occurs for the specified number of
+# seconds. Set to zero to disable.
+visual_bell_duration 0.0
+
+# Enable/disable the audio bell. Useful in environments that require silence.
+enable_audio_bell yes
+# }}}
+
+
+# Window layout {{{
+# If enabled, the window size will be remembered so that new instances of kitty will have the same
+# size as the previous instance. If disabled, the window will initially have size configured
+# by initial_window_width/height, in pixels.
+remember_window_size   yes
+initial_window_width   640
+initial_window_height  400
+
+# The enabled window layouts. A comma separated list of layout names. The special value * means
+# all layouts. The first listed layout will be used as the startup layout.
+# For a list of available layouts, see the README.
+enabled_layouts *
+
+# The width (in pts) of window borders. Will be rounded to the nearest number of pixels based on screen resolution.
+# Note that borders are displayed only when more than one window is visible. They are meant to separate multiple windows.
+window_border_width 1
+
+# The window margin (in pts) (blank area outside the border)
+window_margin_width 0
+
+# The window padding (in pts) (blank area between the text and the window border)
+window_padding_width 0
+
+# The color for the border of the active window
+active_border_color #00ff00
+
+# The color for the border of inactive windows
+inactive_border_color #cccccc
+
+# Fade the text in inactive windows by the specified amount (a number between
+# zero and one, with 0 being fully faded).
+inactive_text_alpha 1.0
+# }}}
+
+
+# Tab bar {{{
+# Which edge to show the tab bar on, top or bottom
+tab_bar_edge bottom
+
+# The separator between tabs in the tab bar
+tab_separator " ┇"
+
+# Tab bar colors and styles
+active_tab_foreground #000
+active_tab_background #eee
+active_tab_font_style bold-italic
+inactive_tab_foreground #444
+inactive_tab_background #999
+inactive_tab_font_style normal
+# }}}
+
+
+# Color scheme {{{
 # The foreground color
 foreground       #dddddd
 
@@ -62,155 +241,6 @@ selection_foreground #000000
 # The background for selections
 selection_background #FFFACD
 
-# The color and style for highlighting URLs on mouse-over. url_style can be one of:
-# none, single, double, curly
-url_color #0087BD
-url_style curly
-
-# The cursor color
-cursor           #cccccc
-
-# The cursor shape can be one of (block, beam, underline)
-cursor_shape     block
-
-# The interval (in seconds) at which to blink the cursor. Set to zero to
-# disable blinking. Note that numbers smaller than repaint_delay will be
-# limited to repaint_delay.
-cursor_blink_interval     0.5
-
-# Stop blinking cursor after the specified number of seconds of keyboard inactivity. Set to
-# zero to never stop blinking.
-cursor_stop_blinking_after 15.0
-
-# Number of lines of history to keep in memory for scrolling back
-scrollback_lines 2000
-
-# Program with which to view scrollback in a new window. The scrollback buffer is passed as
-# STDIN to this program. If you change it, make sure the program you use can
-# handle ANSI escape sequences for colors and text formatting.
-scrollback_pager less +G -R
-
-# Wheel scroll multiplier (modify the amount scrolled by the mouse wheel). Use negative
-# numbers to change scroll direction.
-wheel_scroll_multiplier 5.0
-
-# The interval between successive clicks to detect double/triple clicks (in seconds)
-click_interval 0.5
-
-# Characters considered part of a word when double clicking. In addition to these characters
-# any character that is marked as an alpha-numeric character in the unicode
-# database will be matched.
-select_by_word_characters :@-./_~?&=%+#
-
-# The shell program to execute. The default value of . means
-# to use whatever shell is set as the default shell for the current user.
-# Note that on macOS if you change this, you might need to add --login to
-# ensure that the shell starts in interactive mode and reads its rc files.
-shell .
-
-# Hide mouse cursor after the specified number of seconds of the mouse not being used. Set to
-# zero to disable mouse cursor hiding.
-mouse_hide_wait 3.0
-
-# Set the active window to the window under the mouse when moving the mouse around
-focus_follows_mouse no
-
-# The enabled window layouts. A comma separated list of layout names. The special value * means
-# all layouts. The first listed layout will be used as the startup layout.
-# For a list of available layouts, see the file layouts.py
-enabled_layouts *
-
-# If enabled, the window size will be remembered so that new instances of kitty will have the same
-# size as the previous instance. If disabled, the window will initially have size configured
-# by initial_window_width/height, in pixels.
-remember_window_size   yes
-initial_window_width   640
-initial_window_height  400
-
-# Delay (in milliseconds) between screen updates. Decreasing it, increases
-# frames-per-second (FPS) at the cost of more CPU usage. The default value
-# yields ~100 FPS which is more than sufficient for most uses. Note that to
-# actually achieve 100FPS you have to either set sync_to_monitor to no or use a
-# monitor with a high refresh rate.
-repaint_delay    10
-
-# Delay (in milliseconds) before input from the program running in the terminal
-# is processed. Note that decreasing it will increase responsiveness, but also
-# increase CPU usage and might cause flicker in full screen programs that
-# redraw the entire screen on each loop, because kitty is so fast that partial
-# screen updates will be drawn.
-input_delay 3
-
-# Sync screen updates to the refresh rate of the monitor. This prevents
-# tearing (https://en.wikipedia.org/wiki/Screen_tearing) when scrolling. However,
-# it limits the rendering speed to the refresh rate of your monitor. With a
-# very high speed mouse/high keyboard repeat rate, you may notice some slight input latency.
-# If so, set this to no.
-sync_to_monitor yes
-
-# Visual bell duration. Flash the screen when a bell occurs for the specified number of
-# seconds. Set to zero to disable.
-visual_bell_duration 0.0
-
-# Enable/disable the audio bell. Useful in environments that require silence.
-enable_audio_bell yes
-
-# The modifier keys to press when clicking with the mouse on URLs to open the URL
-open_url_modifiers ctrl+shift
-
-# The program with which to open URLs that are clicked on. The special value "default" means to
-# use the operating system's default URL handler.
-open_url_with default
-
-# The modifiers to use rectangular selection (i.e. to select text in a
-# rectangular block with the mouse)
-rectangle_select_modifiers ctrl+alt
-
-
-# Allow other programs to control kitty. If you turn this on other programs can
-# control all aspects of kitty, including sending text to kitty windows,
-# opening new windows, closing windows, reading the content of windows, etc.
-# Note that this even works over ssh connections.
-allow_remote_control no
-
-# The value of the TERM environment variable to set
-term xterm-kitty
-
-# The width (in pts) of window borders. Will be rounded to the nearest number of pixels based on screen resolution.
-# Note that borders are displayed only when more than one window is visible. They are meant to separate multiple windows.
-window_border_width 1
-
-# The window margin (in pts) (blank area outside the border)
-window_margin_width 0
-
-# The window padding (in pts) (blank area between the text and the window border)
-window_padding_width 0
-
-# The color for the border of the active window
-active_border_color #00ff00
-
-# The color for the border of inactive windows
-inactive_border_color #cccccc
-
-# Fade the text in inactive windows by the specified amount (a number between
-# zero and one, with 0 being fully faded).
-inactive_text_alpha 1.0
-
-# Which edge to show the tab bar on, top or bottom
-tab_bar_edge bottom
-
-# The separator between tabs in the tab bar
-tab_separator " ┇"
-
-# Tab bar colors and styles
-active_tab_foreground #000
-active_tab_background #eee
-active_tab_font_style bold-italic
-inactive_tab_foreground #444
-inactive_tab_background #999
-inactive_tab_font_style normal
-
-
 # The 16 terminal colors. There are 8 basic colors, each color has a dull and
 # bright version.
 
@@ -245,9 +275,42 @@ color14  #14ffff
 # white
 color7   #dddddd
 color15  #ffffff
+# }}}
 
 
-# Key mapping
+# Advanced {{{
+
+# The shell program to execute. The default value of . means
+# to use whatever shell is set as the default shell for the current user.
+# Note that on macOS if you change this, you might need to add --login to
+# ensure that the shell starts in interactive mode and reads its startup rc files.
+shell .
+
+# Close the window when the child process (shell) exits. If no (the default),
+# the terminal will remain open when the child exits as long as there are still
+# processes outputting to the terminal (for example disowned or backgrounded
+# processes). If yes, the window will close as soon as the child process exits.
+# Note that setting it to yes means that any background processes still using
+# the terminal can fail silently because their stdout/stderr/stdin no longer
+# work.
+close_on_child_death no
+
+# Allow other programs to control kitty. If you turn this on other programs can
+# control all aspects of kitty, including sending text to kitty windows,
+# opening new windows, closing windows, reading the content of windows, etc.
+# Note that this even works over ssh connections.
+allow_remote_control no
+
+# The value of the TERM environment variable to set. Changing this can break
+# many terminal programs, only change it if you know what you are doing, not
+# because you read some advice on Stack Overflow to change it.
+term xterm-kitty
+
+
+# }}}
+
+
+# Keyboard shortcuts {{{
 # For a list of key names, see: http://www.glfw.org/docs/latest/group__keys.html
 # For a list of modifier names, see: http://www.glfw.org/docs/latest/group__mods.html
 #
@@ -261,7 +324,7 @@ color15  #ffffff
 # map ctrl+shift+e combine : new_window : next_layout
 # this will create a new window and switch to the next available layout
 
-# Clipboard
+# Clipboard {{{
 map ctrl+shift+v        paste_from_clipboard
 map ctrl+shift+s        paste_from_selection
 map ctrl+shift+c        copy_to_clipboard
@@ -271,8 +334,9 @@ map shift+insert        paste_from_selection
 # you can specify your own, for example:
 # map ctrl+shift+o      pass_selection_to_program firefox
 map ctrl+shift+o        pass_selection_to_program
+# }}}
 
-# Scrolling
+# Scrolling {{{
 map ctrl+shift+up        scroll_line_up
 map ctrl+shift+down      scroll_line_down
 map ctrl+shift+k         scroll_line_up
@@ -282,8 +346,9 @@ map ctrl+shift+page_down scroll_page_down
 map ctrl+shift+home      scroll_home
 map ctrl+shift+end       scroll_end
 map ctrl+shift+h         show_scrollback
+# }}}
 
-# Window management
+# Window management {{{
 map ctrl+shift+enter    new_window
 map ctrl+shift+n        new_os_window
 map ctrl+shift+w        close_window
@@ -317,9 +382,9 @@ map ctrl+shift+0        tenth_window
 # You can open a new window with the current working directory set to the
 # working directory of the current window using
 # map ctrl+alt+enter    new_window_with_cwd
+# }}}
 
-
-# Tab management
+# Tab management {{{
 map ctrl+shift+right    next_tab
 map ctrl+shift+left     previous_tab
 map ctrl+shift+t        new_tab
@@ -327,21 +392,35 @@ map ctrl+shift+q        close_tab
 map ctrl+shift+l        next_layout
 map ctrl+shift+.        move_tab_forward
 map ctrl+shift+,        move_tab_backward
+map ctrl+shift+alt+t    set_tab_title
 # You can also create shortcuts to go to specific tabs, with 1 being the first tab
 # map ctrl+alt+1          goto_tab 1
 # map ctrl+alt+2          goto_tab 2
 
 # Just as with new_window above, you can also pass the name of arbitrary
 # commands to run when using new_tab and use new_tab_with_cwd.
+# }}}
 
+# Layout management {{{
+# You can create shortcuts to switch to specific layouts
+# map ctrl+alt+1          goto_layout tall
+# map ctrl+alt+2          goto_layout stack
+# }}}
 
-# Miscellaneous
+# Font sizes {{{
 map ctrl+shift+equal    increase_font_size
 map ctrl+shift+minus    decrease_font_size
 map ctrl+shift+backspace restore_font_size
+# To setup shortcuts for specific font sizes, follow the example below:
+# map ctrl+shift+f6     set_font_size 10.0
+# map ctrl+shift+f7     set_font_size 20.5
+# }}}
+
+# Miscellaneous {{{
 map ctrl+shift+f11      toggle_fullscreen
 map ctrl+shift+u        input_unicode_character
-# Open a currently visible URL using the keyboard. The program used ot open the URL is specified in open_url_with.
+map ctrl+shift+f2       edit_config_file
+# Open a currently visible URL using the keyboard. The program used to open the URL is specified in open_url_with.
 # You can customize how the URLs are detected and opened by specifying command line options to
 # url_hints. For example:
 # map ctrl+shift+e        run_simple_kitten text url_hints --program firefox --regex "http://[^ ]+"
@@ -363,30 +442,12 @@ map ctrl+shift+e        run_simple_kitten text url_hints
 # to the start of the line (same as pressing the Home key):
 # map ctrl+alt+a send_text normal Word\x1b[H
 # map ctrl+alt+a send_text application Word\x1bOH
+# }}}
 
-# Symbol mapping (special font for specified unicode code points). Map the
-# specified unicode codepoints to a particular font. Useful if you need special
-# rendering for some symbols, such as for Powerline. Avoids the need for
-# patched fonts. Each unicode code point is specified in the form U+<code point
-# in hexadecimal>. You can specify multiple code points, separated by commas
-# and ranges separated by hyphens. symbol_map itself can be specified multiple times.
-# Syntax is:
-#
-# symbol_map codepoints Font Family Name
-#
-# For example:
-#
-# symbol_map U+E0A0-U+E0A2,U+E0B0-U+E0B3 PowerlineSymbols
+# }}}
 
 
-# OS specific tweaks
-
-# Copy to clipboard on select. With this enabled, simply selecting text with
-# the mouse will cause the text to be copied to clipboard. Useful on platforms
-# such as macOS/Wayland that do not have the concept of primary selections. Note
-# that this is a security risk, as all programs, including websites open in your
-# browser can read the contents of the clipboard.
-copy_on_select no
+# OS specific tweaks {{{
 
 # Change the color of the kitty window's titlebar on macOS. A value of "system"
 # means to use the default system color, a value of "background" means to use
@@ -402,7 +463,4 @@ macos_hide_titlebar no
 # break any Alt+key keyboard shortcuts in your terminal programs, but you
 # can use the macOS unicode input technique.
 macos_option_as_alt yes
-
-# The number is a percentage of maximum volume.
-# See man XBell for details.
-x11_bell_volume 80
+# }}}

kitty/line-buf.c

@@ -46,7 +46,7 @@ linebuf_mark_line_clean(LineBuf *self, index_type y) {
 }
 
 static PyObject*
-clear(LineBuf *self) {
+clear(LineBuf *self, PyObject *a UNUSED) {
 #define clear_doc "Clear all lines in this LineBuf"
     linebuf_clear(self, BLANK_CHAR);
     Py_RETURN_NONE;
@@ -167,7 +167,7 @@ set_continued(LineBuf *self, PyObject *args) {
 }
 
 static PyObject*
-dirty_lines(LineBuf *self) {
+dirty_lines(LineBuf *self, PyObject *a UNUSED) {
 #define dirty_lines_doc "dirty_lines() -> Line numbers of all lines that have dirty text."
     PyObject *ans = PyList_New(0);
     for (index_type i = 0; i < self->ynum; i++) {
@@ -424,7 +424,7 @@ __str__(LineBuf *self) {
     if (lines == NULL) return PyErr_NoMemory();
     for (index_type i = 0; i < self->ynum; i++) {
         init_line(self, self->line, self->line_map[i]);
-        PyObject *t = PyObject_Str((PyObject*)self->line);
+        PyObject *t = line_as_unicode(self->line);
         if (t == NULL) { Py_CLEAR(lines); return NULL; }
         PyTuple_SET_ITEM(lines, i, t);
     }

kitty/line.c

@@ -199,8 +199,8 @@ unicode_in_range(Line *self, index_type start, index_type limit, bool include_cc
     return PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, buf, n);
 }
 
-static PyObject *
-as_unicode(Line* self) {
+PyObject *
+line_as_unicode(Line* self) {
     return unicode_in_range(self, 0, xlimit_for_line(self), true, 0);
 }
 
@@ -263,7 +263,7 @@ line_as_ansi(Line *self, Py_UCS4 *buf, index_type buflen) {
 }
 
 static PyObject*
-as_ansi(Line* self) {
+as_ansi(Line* self, PyObject *a UNUSED) {
 #define as_ansi_doc "Return the line's contents with ANSI (SGR) escape codes for formatting"
     static Py_UCS4 t[5120] = {0};
     index_type num = line_as_ansi(self, t, 5120);
@@ -272,7 +272,7 @@ as_ansi(Line* self) {
 }
 
 static PyObject*
-is_continued(Line* self) {
+is_continued(Line* self, PyObject *a UNUSED) {
 #define is_continued_doc "Return the line's continued flag"
     PyObject *ans = self->continued ? Py_True : Py_False;
     Py_INCREF(ans);
@@ -281,7 +281,7 @@ is_continued(Line* self) {
 
 static PyObject*
 __repr__(Line* self) {
-    PyObject *s = as_unicode(self);
+    PyObject *s = line_as_unicode(self);
     if (s == NULL) return NULL;
     PyObject *ans = PyObject_Repr(s);
     Py_CLEAR(s);
@@ -570,7 +570,7 @@ PyTypeObject Line_Type = {
     .tp_basicsize = sizeof(Line),
     .tp_dealloc = (destructor)dealloc,
     .tp_repr = (reprfunc)__repr__,
-    .tp_str = (reprfunc)as_unicode,
+    .tp_str = (reprfunc)line_as_unicode,
     .tp_as_sequence = &sequence_methods,
     .tp_flags = Py_TPFLAGS_DEFAULT,
     .tp_richcompare = richcmp,

kitty/lineops.h

@@ -57,10 +57,10 @@ unsigned int line_length(Line *self);
 size_t cell_as_unicode(Cell *cell, bool include_cc, Py_UCS4 *buf, char_type);
 size_t cell_as_utf8(Cell *cell, bool include_cc, char *buf, char_type);
 PyObject* unicode_in_range(Line *self, index_type start, index_type limit, bool include_cc, char leading_char);
+PyObject* line_as_unicode(Line *);
 
 void linebuf_init_line(LineBuf *, index_type);
 void linebuf_clear(LineBuf *, char_type ch);
-void linebuf_init_line(LineBuf *, index_type);
 void linebuf_index(LineBuf* self, index_type top, index_type bottom);
 void linebuf_reverse_index(LineBuf *self, index_type top, index_type bottom);
 void linebuf_clear_line(LineBuf *self, index_type y);
@@ -105,7 +105,7 @@ void historybuf_clear(HistoryBuf *self);
             index_type num = line_as_ansi(line, buf, columns * 100 - 2); \
             t = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, buf, num); \
         } else { \
-            t = PyObject_Str((PyObject*)line); \
+            t = line_as_unicode(line); \
         } \
         if (t == NULL) goto end; \
         ret = PyObject_CallFunctionObjArgs(callback, t, NULL); \

kitty/main.py

@@ -4,7 +4,6 @@
 
 import locale
 import os
-import signal
 import sys
 from contextlib import contextmanager
 
@@ -12,10 +11,10 @@ from .borders import load_borders_program
 from .boss import Boss
 from .cli import create_opts, parse_args
 from .config import cached_values_for, initial_window_size
-from .constants import appname, glfw_path, is_macos, is_wayland, logo_data_file
+from .constants import appname, glfw_path, is_macos, is_wayland, logo_data_file, config_dir
 from .fast_data_types import (
-    create_os_window, glfw_init, glfw_terminate, install_sigchld_handler,
-    set_default_window_icon, set_options, show_window
+    create_os_window, glfw_init, glfw_terminate, set_default_window_icon,
+    set_options, show_window
 )
 from .fonts.box_drawing import set_scale
 from .utils import (
@@ -93,6 +92,20 @@ def setup_profiling(args):
             print('To view the graphical call data, use: kcachegrind', cg)
 
 
+def macos_cmdline():
+    try:
+        with open(os.path.join(config_dir, 'macos-launch-services-cmdline')) as f:
+            raw = f.read()
+    except FileNotFoundError:
+        return []
+    import shlex
+    raw = raw.strip()
+    ans = shlex.split(raw)
+    if ans and ans[0] == 'kitty':
+        del ans[0]
+    return ans
+
+
 def _main():
     try:
         sys.setswitchinterval(1000.0)  # we have only a single python thread
@@ -124,12 +137,21 @@ def _main():
     if rpath and rpath not in items:
         os.environ['PATH'] += os.pathsep + rpath
 
-    if os.environ.pop('KITTY_LAUNCHED_BY_LAUNCH_SERVICES', None) == '1':
+    args = sys.argv[1:]
+    if is_macos and os.environ.pop('KITTY_LAUNCHED_BY_LAUNCH_SERVICES', None) == '1':
         os.chdir(os.path.expanduser('~'))
-    if not os.path.isdir(os.getcwd()):
+        args = macos_cmdline()
+    try:
+        cwd_ok = os.path.isdir(os.getcwd())
+    except Exception:
+        cwd_ok = False
+    if not cwd_ok:
         os.chdir(os.path.expanduser('~'))
-    args, rest = parse_args()
+    args, rest = parse_args(args=args)
     args.args = rest
+    if args.debug_config:
+        create_opts(args, debug_config=True)
+        return
     if getattr(args, 'detach', False):
         detach()
     if args.cmd:
@@ -152,9 +174,7 @@ def _main():
     try:
         with setup_profiling(args):
             # Avoid needing to launch threads to reap zombies
-            install_sigchld_handler()
             run_app(opts, args)
-            signal.signal(signal.SIGCHLD, signal.SIG_DFL)
     finally:
         glfw_terminate()
 

kitty/mouse.c

@@ -16,12 +16,14 @@
 static MouseShape mouse_cursor_shape = BEAM;
 typedef enum MouseActions { PRESS, RELEASE, DRAG, MOVE } MouseAction;
 
+// Encoding of mouse events {{{
 #define SHIFT_INDICATOR  (1 << 2)
 #define ALT_INDICATOR (1 << 3)
 #define CONTROL_INDICATOR (1 << 4)
 #define MOTION_INDICATOR  (1 << 5)
 #define EXTRA_BUTTON_INDICATOR (1 << 6)
 
+
 static inline unsigned int
 button_map(int button) {
     switch(button) {
@@ -89,6 +91,8 @@ encode_mouse_event(Window *w, int button, MouseAction action, int mods) {
 
 }
 
+// }}}
+
 static inline bool
 contains_mouse(Window *w) {
     WindowGeometry *g = &w->geometry;
@@ -116,10 +120,9 @@ update_drag(bool from_button, Window *w, bool is_release, int modifiers) {
     Screen *screen = w->render_data.screen;
     if (from_button) {
         if (is_release) screen_update_selection(screen, w->mouse_cell_x, w->mouse_cell_y, true);
-        else screen_start_selection(screen, w->mouse_cell_x, w->mouse_cell_y, modifiers == (int)OPT(rectangle_select_modifiers));
+        else screen_start_selection(screen, w->mouse_cell_x, w->mouse_cell_y, modifiers == (int)OPT(rectangle_select_modifiers), EXTEND_CELL);
     } else if (screen->selection.in_progress) {
         screen_update_selection(screen, w->mouse_cell_x, w->mouse_cell_y, false);
-        call_boss(set_primary_selection, NULL);
     }
 }
 
@@ -147,6 +150,14 @@ drag_scroll(Window *w, OSWindow *frame) {
     return false;
 }
 
+static inline void
+extend_selection(Window *w) {
+    Screen *screen = w->render_data.screen;
+    if (screen_has_selection(screen)) {
+        screen_update_selection(screen, w->mouse_cell_x, w->mouse_cell_y, false);
+    }
+}
+
 static inline void
 extend_url(Screen *screen, Line *line, index_type *x, index_type *y) {
     unsigned int count = 0;
@@ -220,20 +231,22 @@ multi_click(Window *w, unsigned int count) {
     Screen *screen = w->render_data.screen;
     index_type start, end;
     bool found_selection = false;
+    SelectionExtendMode mode = EXTEND_CELL;
     switch(count) {
         case 2:
             found_selection = screen_selection_range_for_word(screen, w->mouse_cell_x, w->mouse_cell_y, &start, &end);
+            mode = EXTEND_WORD;
             break;
         case 3:
             found_selection = screen_selection_range_for_line(screen, w->mouse_cell_y, &start, &end);
+            mode = EXTEND_LINE;
             break;
         default:
             break;
     }
     if (found_selection) {
-        screen_start_selection(screen, start, w->mouse_cell_y, false);
-        screen_update_selection(screen, end, w->mouse_cell_y, true);
-        call_boss(set_primary_selection, NULL);
+        screen_start_selection(screen, start, w->mouse_cell_y, false, mode);
+        screen_update_selection(screen, end, w->mouse_cell_y, false);
     }
 }
 
@@ -279,16 +292,15 @@ HANDLER(handle_button_event) {
             case GLFW_MOUSE_BUTTON_LEFT:
                 update_drag(true, w, is_release, modifiers);
                 if (is_release) {
-                    if (modifiers == (int)OPT(open_url_modifiers)) {
-                        open_url(w);
-                    } else {
-                        if (is_release) add_click(w, button, modifiers, window_idx);
-                    }
-                }
+                    if (modifiers == (int)OPT(open_url_modifiers)) open_url(w);
+                } else add_click(w, button, modifiers, window_idx);
                 break;
             case GLFW_MOUSE_BUTTON_MIDDLE:
                 if (is_release && !modifiers) { call_boss(paste_from_selection, NULL); return; }
                 break;
+            case GLFW_MOUSE_BUTTON_RIGHT:
+                if (is_release) { extend_selection(w); }
+                break;
         }
     } else {
         int sz = encode_mouse_event(w, button, is_release ? RELEASE : PRESS, modifiers);

kitty/parser.c

@@ -310,7 +310,7 @@ dispatch_osc(Screen *screen, PyObject DUMP_UNUSED *dump_callback) {
     }
     if (i > 0) {
         code = utoi(screen->parser_buf, i);
-        if (i < limit - 1 && screen->parser_buf[i] == ';') i++;
+        if (i < limit && screen->parser_buf[i] == ';') i++;
     }
     PyObject *string = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, screen->parser_buf + i, limit - i);
     if (string != NULL) {

kitty/remote_control.py

@@ -16,10 +16,19 @@ from .tabs import SpecialWindow
 from .utils import non_blocking_read, parse_address_spec, read_with_timeout
 
 
-def cmd(short_desc, desc=None, options_spec=None, no_response=False):
+class MatchError(ValueError):
+
+    hide_traceback = True
+
+    def __init__(self, expression, target='windows'):
+        ValueError.__init__(self, 'No matching {} for expression: {}'.format(target, expression))
+
+
+def cmd(short_desc, desc=None, options_spec=None, no_response=False, argspec='...'):
 
     def w(func):
         func.short_desc = short_desc
+        func.argspec = argspec
         func.desc = desc or short_desc
         func.name = func.__name__[4:].replace('_', '-')
         func.options_spec = options_spec
@@ -31,29 +40,10 @@ def cmd(short_desc, desc=None, options_spec=None, no_response=False):
 
 
 def parse_subcommand_cli(func, args):
-    opts, items = parse_args(args[1:], (func.options_spec or '\n').format, '...', func.desc, '{} @ {}'.format(appname, func.name))
+    opts, items = parse_args(args[1:], (func.options_spec or '\n').format, func.argspec, func.desc, '{} @ {}'.format(appname, func.name))
     return opts, items
 
 
-@cmd(
-    'List all tabs/windows',
-    'List all windows. The list is returned as JSON tree. The top-level is a list of'
-    ' operating system {appname} windows. Each OS window has an |_ id| and a list'
-    ' of |_ tabs|. Each tab has its own |_ id|, a |_ title| and a list of |_ windows|.'
-    ' Each window has an |_ id|, |_ title|, |_ current working directory|, |_ process id (PID)| and'
-    ' |_ command-line| of the process running in the window.\n\n'
-    'You can use these criteria to select windows/tabs for the other commands.'.format(appname=appname)
-)
-def cmd_ls(global_opts, opts, args):
-    pass
-
-
-def ls(boss, window):
-    data = list(boss.list_os_windows())
-    data = json.dumps(data, indent=2, sort_keys=True)
-    return data
-
-
 MATCH_WINDOW_OPTION = '''\
 --match -m
 The window to match. Match specifications are of the form:
@@ -74,6 +64,47 @@ for that window is used.
 '''
 
 
+# ls {{{
+@cmd(
+    'List all tabs/windows',
+    'List all windows. The list is returned as JSON tree. The top-level is a list of'
+    ' operating system {appname} windows. Each OS window has an |_ id| and a list'
+    ' of |_ tabs|. Each tab has its own |_ id|, a |_ title| and a list of |_ windows|.'
+    ' Each window has an |_ id|, |_ title|, |_ current working directory|, |_ process id (PID)| and'
+    ' |_ command-line| of the process running in the window.\n\n'
+    'You can use these criteria to select windows/tabs for the other commands.'.format(appname=appname),
+    argspec=''
+)
+def cmd_ls(global_opts, opts, args):
+    pass
+
+
+def ls(boss, window):
+    data = list(boss.list_os_windows())
+    data = json.dumps(data, indent=2, sort_keys=True)
+    return data
+# }}}
+
+
+# set_font_size {{{
+@cmd(
+    'Set the font size in all windows',
+    'Sets the font size to the specified size, in pts.',
+    argspec='FONT_SIZE'
+)
+def cmd_set_font_size(global_opts, opts, args):
+    try:
+        return {'size': float(args[0])}
+    except IndexError:
+        raise SystemExit('No font size specified')
+
+
+def set_font_size(boss, window, payload):
+    boss.set_font_size(payload['size'])
+# }}}
+
+
+# send_text {{{
 @cmd(
     'Send arbitrary text to specified windows',
     'Send arbitrary text to specified windows. The text follows Python'
@@ -92,7 +123,8 @@ not interpreted for escapes. If stdin is a terminal, you can press Ctrl-D to end
 Path to a file whose contents you wish to send. Note that in this case the file contents
 are sent as is, not interpreted for escapes.
 ''',
-    no_response=True
+    no_response=True,
+    argspec='[TEXT TO SEND]'
 )
 def cmd_send_text(global_opts, opts, args):
     limit = 1024
@@ -162,15 +194,18 @@ def send_text(boss, window, payload):
     for window in windows:
         if window is not None:
             window.write_to_child(data)
+# }}}
 
 
+# set_window_title {{{
 @cmd(
     'Set the window title',
     'Set the title for the specified window(s). If you use the |_ --match| option'
     ' the title will be set for all matched windows. By default, only the window'
     ' in which the command is run is affected. If you do not specify a title, the'
     ' last title set by the child process running in the window will be used.',
-    options_spec=MATCH_WINDOW_OPTION
+    options_spec=MATCH_WINDOW_OPTION,
+    argspec='TITLE ...'
 )
 def cmd_set_window_title(global_opts, opts, args):
     return {'title': ' '.join(args), 'match': opts.match}
@@ -182,19 +217,22 @@ def set_window_title(boss, window, payload):
     if match:
         windows = tuple(boss.match_windows(match))
         if not windows:
-            raise ValueError('No matching windows for expression: {}'.format(match))
+            raise MatchError(match)
     for window in windows:
         if window:
             window.set_title(payload['title'])
+# }}}
 
 
+# set_tab_title {{{
 @cmd(
     'Set the tab title',
     'Set the title for the specified tab(s). If you use the |_ --match| option'
     ' the title will be set for all matched tabs. By default, only the tab'
     ' in which the command is run is affected. If you do not specify a title, the'
     ' title of the currently active window in the tab is used.',
-    options_spec=MATCH_TAB_OPTION
+    options_spec=MATCH_TAB_OPTION,
+    argspec='TITLE ...'
 )
 def cmd_set_tab_title(global_opts, opts, args):
     return {'title': ' '.join(args), 'match': opts.match}
@@ -205,21 +243,24 @@ def set_tab_title(boss, window, payload):
     if match:
         tabs = tuple(boss.match_tabs(match))
         if not tabs:
-            raise ValueError('No matching windows for expression: {}'.format(match))
+            raise MatchError(match, 'tabs')
     else:
         tabs = [boss.tab_for_window(window) if window else boss.active_tab]
     for tab in tabs:
         if tab:
             tab.set_title(payload['title'])
+# }}}
 
 
+# close_window {{{
 @cmd(
     'Close the specified window(s)',
     options_spec=MATCH_WINDOW_OPTION + '''\n
 --self
 type=bool-set
 If specified close the window this command is run in, rather than the active window.
-'''
+''',
+    argspec=''
 )
 def cmd_close_window(global_opts, opts, args):
     return {'match': opts.match, 'self': opts.self}
@@ -230,21 +271,24 @@ def close_window(boss, window, payload):
     if match:
         windows = tuple(boss.match_windows(match))
         if not windows:
-            raise ValueError('No matching windows for expression: {}'.format(match))
+            raise MatchError(match)
     else:
         windows = [window if window and payload['self'] else boss.active_window]
     for window in windows:
         if window:
             boss.close_window(window)
+# }}}
 
 
+# close_tab {{{
 @cmd(
     'Close the specified tab(s)',
     options_spec=MATCH_TAB_OPTION + '''\n
 --self
 type=bool-set
 If specified close the tab this command is run in, rather than the active tab.
-'''
+''',
+    argspec=''
 )
 def cmd_close_tab(global_opts, opts, args):
     return {'match': opts.match, 'self': opts.self}
@@ -255,15 +299,17 @@ def close_tab(boss, window, payload):
     if match:
         tabs = tuple(boss.match_tabs(match))
         if not tabs:
-            raise ValueError('No matching windows for expression: {}'.format(match))
+            raise MatchError(match, 'tabs')
     else:
         tabs = [boss.tab_for_window(window) if window and payload['self'] else boss.active_tab]
     for tab in tabs:
         if window:
             if tab:
                 boss.close_tab(tab)
+# }}}
 
 
+# new_window {{{
 @cmd(
     'Open new window',
     'Open a new window in the specified tab. If you use the |_ --match| option'
@@ -294,7 +340,8 @@ Open a new tab
 
 --tab-title
 When using --new-tab set the title of the tab.
-'''
+''',
+    argspec='[CMD ...]'
 )
 def cmd_new_window(global_opts, opts, args):
     return {'match': opts.match, 'title': opts.title, 'cwd': opts.cwd,
@@ -319,7 +366,7 @@ def new_window(boss, window, payload):
     if match:
         tabs = tuple(boss.match_tabs(match))
         if not tabs:
-            raise ValueError('No matching windows for expression: {}'.format(match))
+            raise MatchError(match, 'tabs')
     else:
         tabs = [boss.active_tab]
     tab = tabs[0]
@@ -327,11 +374,14 @@ def new_window(boss, window, payload):
     if payload['keep_focus'] and old_window:
         boss.set_active_window(old_window)
     return str(w.id)
+# }}}
 
 
+# focus_window {{{
 @cmd(
     'Focus the specified window',
-    options_spec=MATCH_WINDOW_OPTION
+    options_spec=MATCH_WINDOW_OPTION,
+    argspec='',
 )
 def cmd_focus_window(global_opts, opts, args):
     return {'match': opts.match}
@@ -343,13 +393,36 @@ def focus_window(boss, window, payload):
     if match:
         windows = tuple(boss.match_windows(match))
         if not windows:
-            raise ValueError('No matching windows for expression: {}'.format(match))
+            raise MatchError(match)
     for window in windows:
         if window:
             boss.set_active_window(window)
             break
+# }}}
 
 
+# focus_tab {{{
+@cmd(
+    'Focus the specified tab',
+    'The active window in the specified tab will be focused.',
+    options_spec=MATCH_TAB_OPTION,
+    argspec='',
+)
+def cmd_focus_tab(global_opts, opts, args):
+    return {'match': opts.match}
+
+
+def focus_tab(boss, window, payload):
+    match = payload['match']
+    tabs = tuple(boss.match_tabs(match))
+    if not tabs:
+        raise MatchError(match, 'tabs')
+    tab = tabs[0]
+    boss.set_active_tab(tab)
+# }}}
+
+
+# get_text {{{
 @cmd(
     'Get text from the specified window',
     options_spec=MATCH_WINDOW_OPTION + '''\n
@@ -370,7 +443,8 @@ getting the current selection, the result is always plain text.
 --self
 type=bool-set
 If specified get text from the window this command is run in, rather than the active window.
-'''
+''',
+    argspec=''
 )
 def cmd_get_text(global_opts, opts, args):
     return {'match': opts.match, 'extent': opts.extent, 'ansi': opts.ansi, 'self': opts.self}
@@ -381,7 +455,7 @@ def get_text(boss, window, payload):
     if match:
         windows = tuple(boss.match_windows(match))
         if not windows:
-            raise ValueError('No matching windows for expression: {}'.format(match))
+            raise MatchError(match)
     else:
         windows = [window if window and payload['self'] else boss.active_window]
     window = windows[0]
@@ -390,6 +464,7 @@ def get_text(boss, window, payload):
     else:
         ans = window.as_text(as_ansi=bool(payload['ansi']), add_history=True)
     return ans
+# }}}
 
 
 cmap = {v.name: v for v in globals().values() if hasattr(v, 'is_cmd')}

kitty/screen.c

@@ -219,7 +219,7 @@ screen_change_scrollback_size(Screen *self, unsigned int size) {
 }
 
 static PyObject*
-reset_callbacks(Screen *self) {
+reset_callbacks(Screen *self, PyObject *a UNUSED) {
     Py_CLEAR(self->callbacks);
     self->callbacks = Py_None;
     Py_INCREF(self->callbacks);
@@ -1066,7 +1066,7 @@ bool
 screen_invert_colors(Screen *self) {
     bool inverted = false;
     if (self->start_visual_bell_at > 0) {
-        if (monotonic() - self->start_visual_bell_at <= global_state.opts.visual_bell_duration) inverted = true;
+        if (monotonic() - self->start_visual_bell_at <= OPT(visual_bell_duration)) inverted = true;
         else self->start_visual_bell_at = 0;
     }
     if (self->modes.mDECSCNM) inverted = inverted ? false : true;
@@ -1076,6 +1076,7 @@ screen_invert_colors(Screen *self) {
 void
 screen_bell(Screen *self) {
     request_window_attention(self->window_id, OPT(enable_audio_bell));
+    if (OPT(visual_bell_duration) > 0.0f) self->start_visual_bell_at = monotonic();
 }
 
 void
@@ -1397,13 +1398,20 @@ apply_selection(Screen *self, uint8_t *data, SelectionBoundary *start, Selection
 
 }
 
+bool
+screen_has_selection(Screen *self) {
+    SelectionBoundary start, end;
+    selection_limits_(selection, &start, &end);
+    return !is_selection_empty(self, start.x, start.y, end.x, end.y);
+}
+
 void
 screen_apply_selection(Screen *self, void *address, size_t size) {
     memset(address, 0, size);
     self->last_selection_scrolled_by = self->scrolled_by;
     self->selection_updated_once = true;
     selection_limits_(selection, &self->last_rendered_selection_start, &self->last_rendered_selection_end);
-    apply_selection(self, address, &self->last_rendered_selection_start, &self->last_rendered_selection_end, 1, self->rectangle_select);
+    apply_selection(self, address, &self->last_rendered_selection_start, &self->last_rendered_selection_end, 1, self->selection.rectangle_select);
     selection_limits_(url_range, &self->last_rendered_url_start, &self->last_rendered_url_end);
     apply_selection(self, address, &self->last_rendered_url_start, &self->last_rendered_url_end, 2, false);
 }
@@ -1444,8 +1452,8 @@ screen_open_url(Screen *self) {
 // }}}
 
 // Python interface {{{
-#define WRAP0(name) static PyObject* name(Screen *self) { screen_##name(self); Py_RETURN_NONE; }
-#define WRAP0x(name) static PyObject* xxx_##name(Screen *self) { screen_##name(self); Py_RETURN_NONE; }
+#define WRAP0(name) static PyObject* name(Screen *self, PyObject *a UNUSED) { screen_##name(self); Py_RETURN_NONE; }
+#define WRAP0x(name) static PyObject* xxx_##name(Screen *self, PyObject *a UNUSED) { screen_##name(self); Py_RETURN_NONE; }
 #define WRAP1(name, defval) static PyObject* name(Screen *self, PyObject *args) { unsigned int v=defval; if(!PyArg_ParseTuple(args, "|I", &v)) return NULL; screen_##name(self, v); Py_RETURN_NONE; }
 #define WRAP1B(name, defval) static PyObject* name(Screen *self, PyObject *args) { unsigned int v=defval; int b=false; if(!PyArg_ParseTuple(args, "|Ip", &v, &b)) return NULL; screen_##name(self, v, b); Py_RETURN_NONE; }
 #define WRAP1E(name, defval, ...) static PyObject* name(Screen *self, PyObject *args) { unsigned int v=defval; if(!PyArg_ParseTuple(args, "|I", &v)) return NULL; screen_##name(self, v, __VA_ARGS__); Py_RETURN_NONE; }
@@ -1458,7 +1466,7 @@ as_text(Screen *self, PyObject *args) {
 }
 
 static PyObject*
-refresh_sprite_positions(Screen *self) {
+refresh_sprite_positions(Screen *self, PyObject *a UNUSED) {
     self->is_dirty = true;
     for (index_type i = 0; i < self->lines; i++) {
         linebuf_mark_line_dirty(self->main_linebuf, i);
@@ -1572,13 +1580,13 @@ set_mode(Screen *self, PyObject *args) {
 }
 
 static PyObject*
-reset_dirty(Screen *self) {
+reset_dirty(Screen *self, PyObject *a UNUSED) {
     screen_reset_dirty(self);
     Py_RETURN_NONE;
 }
 
 static PyObject*
-is_using_alternate_linebuf(Screen *self) {
+is_using_alternate_linebuf(Screen *self, PyObject *a UNUSED) {
     if (self->linebuf == self->alt_linebuf) Py_RETURN_TRUE;
     Py_RETURN_FALSE;
 }
@@ -1619,9 +1627,17 @@ WRAP0(carriage_return)
 WRAP2(resize, 1, 1)
 WRAP2(set_margins, 1, 1)
 WRAP2(rescale_images, 1, 1)
-WRAP2B(start_selection)
 WRAP2B(update_selection)
 
+static PyObject*
+start_selection(Screen *self, PyObject *args) {
+    unsigned int x, y;
+    int rectangle_select = 0, extend_mode = EXTEND_CELL;
+    if (!PyArg_ParseTuple(args, "II|pp", &x, &y, &rectangle_select, &extend_mode)) return NULL;
+    screen_start_selection(self, x, y, rectangle_select, extend_mode);
+    Py_RETURN_NONE;
+}
+
 static PyObject*
 change_scrollback_size(Screen *self, PyObject *args) {
     unsigned int count = 1;
@@ -1631,12 +1647,12 @@ change_scrollback_size(Screen *self, PyObject *args) {
 }
 
 static PyObject*
-text_for_selection(Screen *self) {
+text_for_selection(Screen *self, PyObject *a UNUSED) {
     FullSelectionBoundary start, end;
     full_selection_limits_(selection, &start, &end);
     PyObject *ans = NULL;
     if (start.y == end.y && start.x == end.x) ans = PyTuple_New(0);
-    else text_for_range(ans, start, end, self->rectangle_select, true, range_line_, int);
+    else text_for_range(ans, start, end, self->selection.rectangle_select, true, range_line_, int);
     return ans;
 }
 
@@ -1726,10 +1742,10 @@ screen_is_selection_dirty(Screen *self) {
 }
 
 void
-screen_start_selection(Screen *self, index_type x, index_type y, bool rectangle_select) {
-    self->rectangle_select = rectangle_select;
+screen_start_selection(Screen *self, index_type x, index_type y, bool rectangle_select, SelectionExtendMode extend_mode) {
 #define A(attr, val) self->selection.attr = val;
-    A(start_x, x); A(end_x, x); A(start_y, y); A(end_y, y); A(start_scrolled_by, self->scrolled_by); A(end_scrolled_by, self->scrolled_by); A(in_progress, true);
+    A(start_x, x); A(end_x, x); A(start_y, y); A(end_y, y); A(start_scrolled_by, self->scrolled_by); A(end_scrolled_by, self->scrolled_by);
+    A(in_progress, true); A(rectangle_select, rectangle_select); A(extend_mode, extend_mode);
 #undef A
 }
 
@@ -1744,29 +1760,43 @@ void
 screen_update_selection(Screen *self, index_type x, index_type y, bool ended) {
     self->selection.end_x = x; self->selection.end_y = y; self->selection.end_scrolled_by = self->scrolled_by;
     if (ended) self->selection.in_progress = false;
+    index_type start, end;
+    bool found = false;
+    switch(self->selection.extend_mode) {
+        case EXTEND_WORD:
+            found = screen_selection_range_for_word(self, x, y, &start, &end);
+            break;
+        case EXTEND_LINE:
+            found = screen_selection_range_for_line(self, y, &start, &end);
+            break;
+        case EXTEND_CELL:
+            break;
+    }
+    if (found) self->selection.end_x = end;
+    call_boss(set_primary_selection, NULL);
 }
 
 static PyObject*
-mark_as_dirty(Screen *self) {
+mark_as_dirty(Screen *self, PyObject *a UNUSED) {
     self->is_dirty = true;
     Py_RETURN_NONE;
 }
 
 static PyObject*
-current_char_width(Screen *self) {
+current_char_width(Screen *self, PyObject *a UNUSED) {
 #define current_char_width_doc "The width of the character under the cursor"
     return PyLong_FromUnsignedLong(screen_current_char_width(self));
 }
 
 static PyObject*
-is_main_linebuf(Screen *self) {
+is_main_linebuf(Screen *self, PyObject *a UNUSED) {
     PyObject *ans = (self->linebuf == self->main_linebuf) ? Py_True : Py_False;
     Py_INCREF(ans);
     return ans;
 }
 
 static PyObject*
-toggle_alt_screen(Screen *self) {
+toggle_alt_screen(Screen *self, PyObject *a UNUSED) {
     screen_toggle_screen_buffer(self);
     Py_RETURN_NONE;
 }

kitty/screen.h

@@ -22,9 +22,12 @@ typedef struct {
     unsigned int x, y;
 } SelectionBoundary;
 
+typedef enum SelectionExtendModes { EXTEND_CELL, EXTEND_WORD, EXTEND_LINE } SelectionExtendMode;
+
 typedef struct {
     unsigned int start_x, start_y, start_scrolled_by, end_x, end_y, end_scrolled_by;
-    bool in_progress;
+    bool in_progress, rectangle_select;
+    SelectionExtendMode extend_mode;
 } Selection;
 
 #define SAVEPOINTS_SZ 256
@@ -61,7 +64,7 @@ typedef struct {
     Selection selection;
     SelectionBoundary last_rendered_selection_start, last_rendered_selection_end, last_rendered_url_start, last_rendered_url_end;
     Selection url_range;
-    bool use_latin1, selection_updated_once, is_dirty, scroll_changed, rectangle_select;
+    bool use_latin1, selection_updated_once, is_dirty, scroll_changed;
     Cursor *cursor;
     SavepointBuffer main_savepoints, alt_savepoints;
     SavemodesBuffer modes_savepoints;
@@ -150,12 +153,13 @@ void report_device_status(Screen *self, unsigned int which, bool UNUSED);
 void report_mode_status(Screen *self, unsigned int which, bool);
 void screen_apply_selection(Screen *self, void *address, size_t size);
 bool screen_is_selection_dirty(Screen *self);
+bool screen_has_selection(Screen*);
 bool screen_invert_colors(Screen *self);
 void screen_update_cell_data(Screen *self, void *address, size_t sz);
 bool screen_is_cursor_visible(Screen *self);
 bool screen_selection_range_for_line(Screen *self, index_type y, index_type *start, index_type *end);
 bool screen_selection_range_for_word(Screen *self, index_type x, index_type y, index_type *start, index_type *end);
-void screen_start_selection(Screen *self, index_type x, index_type y, bool);
+void screen_start_selection(Screen *self, index_type x, index_type y, bool, SelectionExtendMode);
 void screen_update_selection(Screen *self, index_type x, index_type y, bool ended);
 bool screen_history_scroll(Screen *self, int amt, bool upwards);
 Line* screen_visual_line(Screen *self, index_type y);

kitty/shaders.c

@@ -214,9 +214,7 @@ cell_update_uniform_block(ssize_t vao_idx, Screen *screen, int uniform_buffer, G
     struct CellRenderData {
         GLfloat xstart, ystart, dx, dy, sprite_dx, sprite_dy, background_opacity;
 
-        GLuint default_fg, default_bg, highlight_fg, highlight_bg, cursor_color, url_color, url_style;
-
-        GLint color1, color2;
+        GLuint default_fg, default_bg, highlight_fg, highlight_bg, cursor_color, url_color, url_style, inverted;
 
         GLuint xnum, ynum, cursor_x, cursor_y, cursor_w;
     };
@@ -241,7 +239,7 @@ cell_update_uniform_block(ssize_t vao_idx, Screen *screen, int uniform_buffer, G
     unsigned int x, y, z;
     sprite_tracker_current_layout(&x, &y, &z);
     rd->sprite_dx = 1.0f / (float)x; rd->sprite_dy = 1.0f / (float)y;
-    rd->color1 = inverted & 1; rd->color2 = 1 - (inverted & 1);
+    rd->inverted = inverted ? 1 : 0;
     rd->background_opacity = OPT(background_opacity);
 
 #define COLOR(name) colorprofile_to_color(screen->color_profile, screen->color_profile->overridden.name, screen->color_profile->configured.name)
@@ -587,9 +585,8 @@ end:
     Py_RETURN_NONE;
 }
 
-#define PYWRAP0(name) static PyObject* py##name(PyObject UNUSED *self)
+#define PYWRAP0(name) static PyObject* py##name(PYNOARG)
 #define PYWRAP1(name) static PyObject* py##name(PyObject UNUSED *self, PyObject *args)
-#define PYWRAP2(name) static PyObject* py##name(PyObject UNUSED *self, PyObject *args, PyObject *kw)
 #define PA(fmt, ...) if(!PyArg_ParseTuple(args, fmt, __VA_ARGS__)) return NULL;
 #define ONE_INT(name) PYWRAP1(name) { name(PyLong_AsSsize_t(args)); Py_RETURN_NONE; }
 #define TWO_INT(name) PYWRAP1(name) { int a, b; PA("ii", &a, &b); name(a, b); Py_RETURN_NONE; }

kitty/state.c

@@ -201,6 +201,7 @@ static inline void
 set_active_tab(id_type os_window_id, unsigned int idx) {
     WITH_OS_WINDOW(os_window_id)
         os_window->active_tab = idx;
+        os_window->needs_render = true;
     END_WITH_OS_WINDOW
 }
 
@@ -208,6 +209,7 @@ static inline void
 set_active_window(id_type os_window_id, id_type tab_id, unsigned int idx) {
     WITH_TAB(os_window_id, tab_id)
         tab->active_window = idx;
+        osw->needs_render = true;
     END_WITH_TAB;
 }
 
@@ -268,9 +270,8 @@ os_window_regions(OSWindow *os_window, Region *central, Region *tab_bar) {
 
 
 // Python API {{{
-#define PYWRAP0(name) static PyObject* py##name(PyObject UNUSED *self)
+#define PYWRAP0(name) static PyObject* py##name(PYNOARG)
 #define PYWRAP1(name) static PyObject* py##name(PyObject UNUSED *self, PyObject *args)
-#define PYWRAP2(name) static PyObject* py##name(PyObject UNUSED *self, PyObject *args, PyObject *kw)
 #define PA(fmt, ...) if(!PyArg_ParseTuple(args, fmt, __VA_ARGS__)) return NULL;
 #define ONE_UINT(name) PYWRAP1(name) { name((unsigned int)PyLong_AsUnsignedLong(args)); Py_RETURN_NONE; }
 #define TWO_UINT(name) PYWRAP1(name) { unsigned int a, b; PA("II", &a, &b); name(a, b); Py_RETURN_NONE; }
@@ -339,7 +340,6 @@ PYWRAP1(set_options) {
     S(inactive_text_alpha, PyFloat_AsDouble);
     S(cursor_shape, PyLong_AsLong);
     S(url_style, PyLong_AsUnsignedLong);
-    S(x11_bell_volume, PyLong_AsLong);
     S(tab_bar_edge, PyLong_AsLong);
     S(mouse_hide_wait, PyFloat_AsDouble);
     S(wheel_scroll_multiplier, PyFloat_AsDouble);
@@ -353,6 +353,7 @@ PYWRAP1(set_options) {
     S(repaint_delay, repaint_delay);
     S(input_delay, repaint_delay);
     S(sync_to_monitor, PyObject_IsTrue);
+    S(close_on_child_death, PyObject_IsTrue);
     S(macos_option_as_alt, PyObject_IsTrue);
     S(macos_hide_titlebar, PyObject_IsTrue);
 

kitty/state.h

@@ -26,11 +26,11 @@ typedef struct {
     bool macos_option_as_alt, macos_hide_titlebar;
     int adjust_line_height_px, adjust_column_width_px;
     float adjust_line_height_frac, adjust_column_width_frac;
-    int x11_bell_volume;
     float background_opacity;
     float inactive_text_alpha;
     Edge tab_bar_edge;
     bool sync_to_monitor;
+    bool close_on_child_death;
 } Options;
 
 typedef struct {
@@ -97,11 +97,11 @@ typedef struct {
     void *handle;
     id_type id;
     OSWindowGeometry before_fullscreen;
-    int viewport_width, viewport_height;
+    int viewport_width, viewport_height, window_width, window_height;
     double viewport_x_ratio, viewport_y_ratio;
     Tab *tabs;
     unsigned int active_tab, num_tabs, capacity, last_active_tab, last_num_tabs, last_active_window_id;
-    bool focused_at_last_render;
+    bool focused_at_last_render, needs_render;
     ScreenRenderData tab_bar_render_data;
     bool is_focused;
     double cursor_blink_zero_time, last_mouse_activity_at;
@@ -136,7 +136,7 @@ typedef struct {
 
 extern GlobalState global_state;
 
-#define call_boss(name, ...) { \
+#define call_boss(name, ...) if (global_state.boss) { \
     PyObject *cret_ = PyObject_CallMethod(global_state.boss, #name, __VA_ARGS__); \
     if (cret_ == NULL) { PyErr_Print(); } \
     else Py_DECREF(cret_); \

kitty/tabs.py

@@ -17,7 +17,7 @@ from .fast_data_types import (
 )
 from .layout import Rect, all_layouts
 from .session import resolved_shell
-from .utils import color_as_int
+from .utils import color_as_int, log_error
 from .window import Window, calculate_gl_geometry
 
 TabbarData = namedtuple('TabbarData', 'title is_active is_last')
@@ -38,7 +38,7 @@ class Tab:  # {{{
             raise Exception('No OS window with id {} found, or tab counter has wrapped'.format(self.os_window_id))
         self.opts, self.args = tab_manager.opts, tab_manager.args
         self.name = getattr(session_tab, 'name', '')
-        self.enabled_layouts = list(getattr(session_tab, 'enabled_layouts', None) or self.opts.enabled_layouts)
+        self.enabled_layouts = [x.lower() for x in getattr(session_tab, 'enabled_layouts', None) or self.opts.enabled_layouts]
         self.borders = Borders(self.os_window_id, self.id, self.opts)
         self.windows = deque()
         self.active_window_idx = 0
@@ -116,6 +116,14 @@ class Tab:  # {{{
             self.current_layout = self.create_layout_object(nl)
             self.relayout()
 
+    def goto_layout(self, layout_name):
+        layout_name = layout_name.lower()
+        if layout_name not in self.enabled_layouts:
+            log_error('Unknown or disabled layout: {}'.format(layout_name))
+            return
+        self.current_layout = self.create_layout_object(layout_name)
+        self.relayout()
+
     def launch_child(self, use_shell=False, cmd=None, stdin=None, cwd_from=None, cwd=None):
         if cmd is None:
             if use_shell:

kitty_tests/parser.py

@@ -182,6 +182,9 @@ class TestParser(BaseTest):
         c.clear()
         pb('\033]2;;;;\x07', ('set_title', ';;;'))
         self.ae(c.titlebuf, ';;;')
+        c.clear()
+        pb('\033]2;\x07', ('set_title', ''))
+        self.ae(c.titlebuf, '')
         pb('\033]110\x07', ('set_dynamic_color', 110, ''))
         self.ae(c.colorbuf, '')
 

linux-launcher.c

@@ -94,7 +94,7 @@ int main(int argc, char *argv[]) {
 #ifdef FOR_LAUNCHER
     num = snprintf(lib, PATH_MAX, "%s%s", exe_dir, "/../Frameworks/kitty");
 #else
-    num = snprintf(lib, PATH_MAX, "%s%s", exe_dir, "/../lib/kitty");
+    num = snprintf(lib, PATH_MAX, "%s%s%s%s", exe_dir, "/../", LIB_DIR_NAME, "/kitty");
 #endif
 #endif
 

remote-control.asciidoc

@@ -57,9 +57,14 @@ Let's change the title of the current tab:
 
    kitty @ set-tab-title Master Tab
 
-Now lets switch to the newly opened tab.
+Now lets switch to the newly opened tab:
 
-   kitty @ focus-window --match title:New
+   kitty @ focus-tab --match title:New
+
+Similarly, to focus the previously opened output window (which will also switch
+back to the old tab, automatically):
+
+   kitty @ focus-window --match title:Output
 
 You can get a listing of available tabs and windows, by running:
 

setup.py

@@ -3,6 +3,7 @@
 # License: GPL v3 Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
 
 import argparse
+import glob
 import importlib
 import json
 import os
@@ -484,18 +485,23 @@ def build_linux_launcher(args, launcher_dir='.', for_bundle=False, sh_launcher=F
         cflags.append('-DPYVER="{}"'.format(sysconfig.get_python_version()))
     elif sh_launcher:
         cflags.append('-DFOR_LAUNCHER')
+    cflags.append('-DLIB_DIR_NAME="{}"'.format(args.libdir_name.strip('/')))
     pylib = get_python_flags(cflags)
     exe = 'kitty-profile' if args.profile else 'kitty'
+    cflags += shlex.split(os.environ.get('CFLAGS', ''))
+    ldflags = shlex.split(os.environ.get('LDFLAGS', ''))
     cmd = [env.cc] + cflags + [
         'linux-launcher.c', '-o',
         os.path.join(launcher_dir, exe)
-    ] + libs + pylib
+    ] + ldflags + libs + pylib
     run_tool(cmd)
 
 
 def package(args, for_bundle=False, sh_launcher=False):  # {{{
     ddir = args.prefix
-    libdir = os.path.join(ddir, 'lib', 'kitty')
+    if for_bundle or sh_launcher:
+        args.libdir_name = 'lib'
+    libdir = os.path.join(ddir, args.libdir_name.strip('/'), 'kitty')
     if os.path.exists(libdir):
         shutil.rmtree(libdir)
     os.makedirs(os.path.join(libdir, 'logo'))
@@ -543,7 +549,7 @@ Comment=A modern, hackable, featureful, OpenGL based terminal emulator
 TryExec=kitty
 Exec=kitty
 Icon=kitty
-Categories=System;
+Categories=System;TerminalEmulator;
 '''
             )
     # }}}
@@ -592,14 +598,37 @@ Categories=System;
 
 
 def clean():
-    for f in subprocess.check_output(
-        'git ls-files --others --ignored --exclude-from=.gitignore'.split()
-    ).decode('utf-8').splitlines():
-        if f.startswith('logo/kitty.iconset') or f.startswith('dev/'):
-            continue
-        os.unlink(f)
-        if os.sep in f and not os.listdir(os.path.dirname(f)):
-            os.rmdir(os.path.dirname(f))
+    os.chdir(os.path.dirname(os.path.abspath(__file__)))
+    if os.path.exists('.git'):
+        for f in subprocess.check_output(
+            'git ls-files --others --ignored --exclude-from=.gitignore'.split()
+        ).decode('utf-8').splitlines():
+            if f.startswith('logo/kitty.iconset') or f.startswith('dev/'):
+                continue
+            os.unlink(f)
+            if os.sep in f and not os.listdir(os.path.dirname(f)):
+                os.rmdir(os.path.dirname(f))
+        return
+    # Not a git checkout, clean manually
+
+    def safe_remove(*entries):
+        for x in entries:
+            if os.path.exists(x):
+                if os.path.isdir(x):
+                    shutil.rmtree(x)
+                else:
+                    os.unlink(x)
+
+    safe_remove('build', 'compile_commands.json', 'linux-package', 'kitty.app')
+    for root, dirs, files in os.walk('.'):
+        remove_dirs = {d for d in dirs if d == '__pycache__'}
+        [(shutil.rmtree(os.path.join(root, d)), dirs.remove(d)) for d in remove_dirs]
+        for f in files:
+            ext = f.rpartition('.')[-1]
+            if ext in ('so', 'dylib', 'pyc', 'pyo'):
+                os.unlink(os.path.join(root, f))
+    for x in glob.glob('glfw/wayland-*-protocol.[ch]'):
+        os.unlink(x)
 
 
 def option_parser():
@@ -650,6 +679,11 @@ def option_parser():
         action='store_true',
         help='Use the -pg compile flag to add profiling information'
     )
+    p.add_argument(
+        '--libdir-name',
+        default='lib',
+        help='The name of the directory inside --prefix in which to store compiled files. Defaults to "lib"'
+    )
     return p