version 0.7.0

Fix bottom rect in horizontal layout not covering all windows. Fix pep8
issues. Add README and CHANGELOG entries.

.gitattributes

@@ -1,8 +1,9 @@
-kitty/wcwidth9.h linguist-generated=true
+kitty/wcwidth-std.h linguist-generated=true
 kitty/emoji.h linguist-generated=true
 kitty/keys.h linguist-generated=true
 kitty/charsets.c linguist-generated=true
 kitty/key_encoding.py linguist-generated=true
+kitty/unicode-data.c
 kitty/rgb.py linguist-generated=true
 kitty/gl-wrapper.* linguist-generated=true
 kitty/khrplatform.h linguist-generated=true

.travis.yml

@@ -56,7 +56,7 @@ matrix:
           env:
             - RUN_FLAKE=1 BUILD_PKG=1
           language: python
-          python: "3.5"
+          python: "3.6"
           addons:
             apt:
               packages:
@@ -95,7 +95,7 @@ install: |
         if [[ "$USE_BREW" == "1" ]]; then
             brew update;
             brew install python3;
-            brew install harfbuzz --without-glib --without-gobject-introspection --without-graphite2 --without-icu4c --without-freetype --without-cairo;
+            brew install harfbuzz --without-glib --without-gobject-introspection --without-graphite2 --without-icu4c --without-freetype;
         else
             mkdir -p $SW;
             curl https://download.calibre-ebook.com/travis/kitty/osx.tar.xz | tar xJ -C $SW;
@@ -123,6 +123,7 @@ before_script:
     - $PYTHON setup.py build --debug --verbose $SANITIZE_ARG;
 
 script:
+    - if grep -Inr '\s$' kitty kitty_tests *.py *.asciidoc .gitattributes .gitignore; then echo Trailing whitespace found, aborting.; exit 1; fi
     - if [[ -z $SANITIZE_ARG ]]; then $PYTHON test.py; else ./asan-launcher test.py; fi
     - if [[ "$RUN_FLAKE" == "1" ]]; then flake8 --count .; fi
     - if [[ "$BUILD_PKG" == "1" ]]; then $PYTHON setup.py linux-package; fi

CHANGELOG.rst

@@ -3,6 +3,79 @@ Changelog
 
 kitty is a feature full, cross-platform, *fast*, GPU based terminal emulator.
 
+version 0.7.0 [2018-01-24]
+---------------------------
+
+- Allow controlling kitty from the shell prompt/scripts. You can
+  open/close/rename windows and tabs and even send input to specific windows.
+  See the README for details.
+
+- Add option to put tab bar at the top instead of the bottom
+
+- Add option to override the default shell
+
+- Add "Horizontal" and "Vertical" window layouts
+
+- Sessions: Allow setting titles and working directories for individual windows 
+
+- Option to copy to clipboard on mouse select
+
+- Fix incorrect reporting of mouse move events when using the SGR protocol
+
+- Make alt+backspace delete the previous word
+
+- Take the mouse wheel multiplier option in to account when generating fake key
+  scroll events
+
+- macOS: Fix closing top-level window does not transfer focus to other
+  top-level windows.
+
+- macOS: Fix alt+arrow keys not working when disabling the macos_option_as_alt
+  config option.
+
+- kitty icat: Workaround for bug in ImageMagick that would cause some images
+  to fail to display at certain sizes.
+
+- Fix rendering of text with ligature fonts that do not use dummy glyphs
+
+- Fix a regression that caused copying of the selection to clipboard to only
+  copy the visible part of the selection
+
+- Fix incorrect handling of some unicode combining marks that are not re-ordered
+
+- Fix handling on non-BMP combining characters
+
+- Drop the dependency on libunistring
+
+
+version 0.6.1 [2017-12-28]
+---------------------------
+
+- Add an option to fade the text in inactive windows
+
+- Add new actions to open windows/tabs/etc. with the working directory set to 
+  the working directory of the current window.
+
+- Automatically adjust cell size when DPI changes, for example when kitty is
+  moved from one monitor to another with a different DPI
+
+- Ensure underlines are rendered even for fonts with very poor metrics
+
+- Fix some emoji glyphs not colored on Linux
+
+- Internal wcwidth() implementation is now auto-generated from the unicode
+  standard database
+
+- Allow configuring the modifiers to use for rectangular selection with the
+  mouse.
+
+- Fix incorrect minimum wayland version in the build script
+
+- Fix a crash when detecting a URL that ends at the end of the line
+
+- Fix regression that broke drawing of hollow cursor when window loses focus
+
+
 version 0.6.0 [2017-12-18]
 ---------------------------
 

Makefile

@@ -21,3 +21,11 @@ debug:
 # Build with the ASAN and UBSAN sanitizers
 asan:
 	python3 setup.py build $(VVAL) --debug --sanitize
+
+logo/kitty.iconset/icon_256x256.png: logo/kitty.svg logo/make.py
+	logo/make.py
+
+rendered_logo: logo/kitty.iconset/icon_256x256.png
+
+app: rendered_logo
+	python3 setup.py app $(VVAL)

README.asciidoc

@@ -51,30 +51,30 @@ image::https://travis-ci.org/kovidgoyal/kitty.svg?branch=master[Build status, li
 
 == Major Features
 
-* Supports tiling multiple terminal windows side by side in different
-layouts without needing to use an extra program like tmux
-
-* Supports all modern terminal features: graphics (images), unicode,
-true-color, OpenType ligatures, mouse protocol, focus tracking, bracketed paste and so on.
-
-* Supports startup sessions which allow you to specify the window/tab layout,
-working directories and programs to run on startup.
-
 * Uses OpenGL for rendering, offloads rendering to the GPU for lower system
 load and buttery smooth scrolling. Uses threaded rendering to minimize input
 latency.
 
+* Supports all modern terminal features: graphics (images), unicode,
+true-color, OpenType ligatures, mouse protocol, focus tracking, bracketed paste and so on.
+
+* Supports tiling multiple terminal windows side by side in different
+layouts without needing to use an extra program like tmux
+
+* Can be controlled from scripts or the shell prompt, even over SSH.
+
+* Supports startup sessions which allow you to specify the window/tab layout,
+working directories and programs to run on startup.
+
 * Cross-platform support: kitty currently works on Linux and macOS, but because
 it uses only OpenGL for rendering, it should be trivial to port to other
-platforms. 
+platforms.
 
 * Allows you to open the scrollback buffer and window contents in a separate
 window using arbitrary programs of your choice. This is useful for browsing
 the history comfortably in a pager or editor and also for doing things like
 opening URLs using only the keyboard.
 
-* Easily hackable (UI layer written in python, inner loops in C for
-speed). Less than fifteen thousand lines of code.
 
 image::screenshot.png?raw=true[Screenshot, showing three programs in the "Tall" layout]
 
@@ -89,8 +89,7 @@ the following dependencies are installed first.
 === Dependencies
 
 * python >= 3.5
-* harfbuzz >= 1.5.0 
-* libunistring 
+* harfbuzz >= 1.5.0
 * zlib
 * libpng
 * freetype (not needed on macOS)
@@ -98,6 +97,7 @@ the following dependencies are installed first.
 * ImageMagick (optional, needed to use the `kitty icat` tool to display images in the terminal)
 * gcc or clang (required only for building)
 * pkg-config (required only for building)
+* For building on Linux in addition to the above dependencies you might also need to install the `-dev` packages for `xcursor`, `xrandr`, `xinerama` and `xkbcommon-x11`, if they are not already installed by your distro.
 
 === Install and run from source
 
@@ -119,7 +119,9 @@ python3 /path/to/kitty/folder
 
 === Linux packages
 
-* Arch linux: AUR git package https://aur.archlinux.org/packages/kitty-git/
+* Arch Linux: AUR git package https://aur.archlinux.org/packages/kitty-git/
+
+* Arch Linux: AUR stable package https://aur.archlinux.org/packages/kitty/
 
 * NixOS / nixpkgs: https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/misc/kitty/default.nix
 
@@ -222,12 +224,21 @@ windows are:
 
 |Increase font size   | {sc_increase_font_size}
 |Decrease font size   | {sc_decrease_font_size}
-|Restore font size    | {sc_restore_font_size} 
+|Restore font size    | {sc_restore_font_size}
 |Toggle fullscreen    | {sc_toggle_fullscreen}
 |Pass current selection to program | {sc_pass_selection_to_program}
 |===
 
 
+== Controlling kitty from scripts
+
+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].
+
 
 == The scrollback buffer
 
@@ -254,8 +265,10 @@ hold down `ctrl+shift` and click on a URL to open it in a browser.
 Currently, there are three layouts available,
 
 * Stack -- Only a single maximized window is shown at a time
-* Tall -- One window is shown full height on the left, the rest of the windows are shown one below the other on the right.
+* Tall -- One window is shown full height on the left, the rest of the windows are shown one below the other on the right
 * Grid -- All windows are shown in a grid
+* 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.
 
@@ -283,11 +296,13 @@ command line flag. For example:
 ....
 # Set the window layout for the current tab
 layout tall
-# Set the working directory for the current tab
+# Set the working directory for windows in the current tab
 cd ~
 # Create a window and run the specified command in it
 launch zsh
 launch vim
+# Set the title for the next window
+title Chat with x
 launch irssi --profile x
 
 # Create a new tab (the part after new_tab is the optional tab name which will
@@ -337,14 +352,14 @@ render loop to reduce CPU usage. See the link:kitty/kitty.conf[config file] for
 You can generate detailed per-function performance data using
 link:https://github.com/gperftools/gperftools[gperftools]. Build kitty with the
 `--profile` flag which will create an executable called `kitty-profile`.  Run
-that and perform the task you want to analyse, for example, scrolling a large 
+that and perform the task you want to analyse, for example, scrolling a large
 file with `less`. After you quit, function call statistics will be printed to
 `stdout` and you can use tools like *kcachegrind* for more detailed analysis.
 
 Here are some CPU usage numbers for the task of scrolling a file continuously in less.
 The CPU usage is for the terminal process and X together and is measured using htop.
-The measurements are taken at the same font and window size for all terminals on a 
-`Intel(R) Core(TM) i7-4820K CPU @ 3.70GHz` CPU with a 
+The measurements are taken at the same font and window size for all terminals on a
+`Intel(R) Core(TM) i7-4820K CPU @ 3.70GHz` CPU with a
 `Advanced Micro Devices, Inc. [AMD/ATI] Cape Verde XT [Radeon HD 7770/8760 / R7 250X]` GPU.
 
 |===
@@ -417,33 +432,21 @@ the approach using ligatures.
 
 === How do I build kitty.app on macOS?
 
-You dont need to build kitty.app to run kitty from source. Simply install the dependencies
-listed above using brew/MacPorts or similar and then compile and run with:
+Install `optipng` and `librsvg` using `brew` or similar (needed for the logo generation step).
 
+And run:
 ```
-make 
-python3 .
+make app
 ```
 
-You can also create a shell script to run kitty:
+This `kitty.app` unlike the released one does not include its own copy of
+python and the other dependencies. So if you ever un-install/upgrade those dependencies
+you might have to rebuild the app.
 
-```
-#!/bin/sh
-exec python3 /path/to/kitty/source/dir
-```
-
-And using something like link:https://mathiasbynens.be/notes/shell-script-mac-apps[app-wrapper-for-shell-script]
-you can create a simple launcher app to run the shell script.
-
-If you only want to make some small changes to a python file, you can do that
-and simply replace the corresponding file inside an existing kitty.app. (Note
-that kitty.app will contain `.pyo` files which are compiled versions of `.py`
-files, delete the `.pyo` file and replace it with a `.py` file).
-
-Finally, note that the released kitty.dmg is built automatically by using the
-`kitty` branch of
+Note that the released kitty.dmg includes all dependencies, unlike the
+`kitty.app` built above and is built automatically by using the `kitty` branch of
 link:https://github.com/kovidgoyal/build-calibre[build-calibre] however, that
-is designed to run on linux and is not for the faint of heart.
+is designed to run on Linux and is not for the faint of heart.
 
 == A tribute
 
@@ -456,7 +459,7 @@ kitty, I ran headlong into more and more gnarly corners of terminal behavior.
 On all those occasions, either the excellent documentation at
 link:http://invisible-island.net/xterm/ctlseqs/ctlseqs.html[xterm-ctlseqs] or
 investigating the behavior and code of xterm or vttest were invaluable tools to
-aid my understanding. 
+aid my understanding.
 
 My achievements, if any, in developing kitty would not have been possible without
 his prior work and the generous sharing of knowledge accumulated over decades.

__main__.py

@@ -4,12 +4,52 @@
 
 import sys
 
-if len(sys.argv) > 1 and sys.argv[1] == 'icat':
+
+def icat(args):
     from kitty.icat import main
-    main(sys.argv[1:])
-elif len(sys.argv) > 1 and sys.argv[1] == 'list-fonts':
+    main(args)
+
+
+def list_fonts(args):
     from kitty.fonts.list import main
-    main(sys.argv[1:])
-else:
-    from kitty.main import main
+    main(args)
+
+
+def remote_control(args):
+    from kitty.remote_control import main
+    main(args)
+
+
+def namespaced(args):
+    func = namespaced_entry_points[args[1]]
+    func(args[1:])
+
+
+entry_points = {
+    # These two are here for backwards compat
+    'icat': icat,
+    'list-fonts': list_fonts,
+
+    '@': remote_control,
+    '+': namespaced,
+}
+namespaced_entry_points = {k: v for k, v in entry_points.items() if k[0] not in '+@'}
+
+
+def main():
+    first_arg = '' if len(sys.argv) < 2 else sys.argv[1]
+    func = entry_points.get(first_arg)
+    if func is None:
+        if first_arg.startswith('@'):
+            remote_control(['@', first_arg[1:]] + sys.argv[2:])
+        elif first_arg.startswith('+'):
+            namespaced(['+', first_arg[1:]] + sys.argv[2:])
+        else:
+            from kitty.main import main
+            main()
+    else:
+        func(sys.argv[1:])
+
+
+if __name__ == '__main__':
     main()

count-lines-of-code

@@ -1,2 +1,2 @@
 #!/bin/bash
-cloc --exclude-list-file <(echo -e 'kitty/wcwidth9.h\nkitty/glfw.c\nkitty/keys.h\nkitty/charsets.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') kitty

gen-emoji.py

@@ -1,75 +0,0 @@
-#!/usr/bin/env python3
-# vim:fileencoding=utf-8
-# License: GPL v3 Copyright: 2017, Kovid Goyal <kovid at kovidgoyal.net>
-
-import os
-from collections import defaultdict
-from functools import partial
-from itertools import groupby
-from operator import itemgetter
-from urllib.request import urlopen
-
-os.chdir(os.path.dirname(os.path.abspath(__file__)))
-
-raw = urlopen('http://unicode.org/Public/emoji/5.0/emoji-data.txt').read().decode('utf-8')
-seen = set()
-cmap = defaultdict(set)
-for line in raw.splitlines():
-    line = line.strip()
-    if not line or line.startswith('#'):
-        continue
-    spec, rest = line.partition(';')[::2]
-    spec, rest = spec.strip(), rest.strip().split(' ', 1)[0].strip()
-    if '.' in spec:
-        spec = tuple(map(lambda x: int(x, 16), filter(None, spec.split('.'))))
-        spec = set(range(spec[0], spec[1] + 1))
-    else:
-        spec = {int(spec, 16)}
-    cmap[rest] |= spec
-    seen |= spec
-items = list(seen)
-
-
-def get_ranges(items):
-    items.sort()
-    for k, g in groupby(enumerate(items), lambda m: m[0]-m[1]):
-        group = tuple(map(itemgetter(1), g))
-        a, b = group[0], group[-1]
-        if a == b:
-            yield a
-        else:
-            yield a, b
-
-
-def write_case(spec, p):
-    if isinstance(spec, tuple):
-        p('\t\tcase 0x{:x} ... 0x{:x}:'.format(*spec))
-    else:
-        p('\t\tcase 0x{:x}:'.format(spec))
-
-
-with open('kitty/emoji.h', 'w') as f:
-    p = partial(print, file=f)
-    p('#pragma once')
-    p('#include "data-types.h"\n')
-    p('START_ALLOW_CASE_RANGE')
-    p('static inline bool is_emoji(uint32_t code) {')
-    p('\tswitch(code) {')
-    for spec in get_ranges(items):
-        last = spec[1] if isinstance(spec, tuple) else spec
-        if last < 0x231a:
-            continue
-        write_case(spec, p)
-        p('\t\t\treturn true;')
-    p('\t\tdefault: return false;')
-    p('\t}')
-    p('\treturn false; \n}')
-    p('static inline bool is_emoji_modifier(uint32_t code) {')
-    p('\tswitch(code) {')
-    for spec in get_ranges(list(cmap['Emoji_Modifier'])):
-        write_case(spec, p)
-        p('\t\t\treturn true;')
-    p('\t\tdefault: return false;')
-    p('\t}')
-    p('\treturn false; \n}')
-    p('END_ALLOW_CASE_RANGE')

gen-wcwidth.py

@@ -0,0 +1,243 @@
+#!/usr/bin/env python3
+# vim:fileencoding=utf-8
+# License: GPL v3 Copyright: 2017, Kovid Goyal <kovid at kovidgoyal.net>
+
+import os
+import sys
+from contextlib import contextmanager
+from datetime import date
+from functools import partial
+from itertools import groupby
+from operator import itemgetter
+from urllib.request import urlopen
+
+# We ignore the first few emojis as they are widely assumed to be single width
+# in legacy applications
+FIRST_EMOJI = 0x2194
+os.chdir(os.path.dirname(os.path.abspath(__file__)))
+
+
+def get_data(fname, folder='UCD'):
+    url = f'https://www.unicode.org/Public/{folder}/latest/{fname}'
+    bn = os.path.basename(url)
+    local = os.path.join('/tmp', bn)
+    if os.path.exists(local):
+        data = open(local, 'rb').read()
+    else:
+        data = urlopen(url).read()
+        open(local, 'wb').write(data)
+    for line in data.decode('utf-8').splitlines():
+        line = line.strip()
+        if line and not line.startswith('#'):
+            yield line
+
+
+# Map of class names to set of codepoints in class
+class_maps = {}
+marks = set()
+not_assigned = set(range(0, sys.maxunicode))
+
+
+def parse_ucd():
+    first = None
+    for line in get_data('ucd/UnicodeData.txt'):
+        parts = [x.strip() for x in line.split(';')]
+        codepoint = int(parts[0], 16)
+        category = parts[2]
+        s = class_maps.setdefault(category, set())
+        desc = parts[1]
+        codepoints = (codepoint,)
+        if first is None:
+            if desc.endswith(', First>'):
+                first = codepoint
+                continue
+        else:
+            codepoints = range(first, codepoint + 1)
+            first = None
+        for codepoint in codepoints:
+            s.add(codepoint)
+            not_assigned.discard(codepoint)
+            if category.startswith('M'):
+                marks.add(codepoint)
+
+
+def split_two(line):
+    spec, rest = line.split(';', 1)
+    spec, rest = spec.strip(), rest.strip().split(' ', 1)[0].strip()
+    if '..' in spec:
+        chars = tuple(map(lambda x: int(x, 16), filter(None, spec.split('.'))))
+        chars = set(range(chars[0], chars[1] + 1))
+    else:
+        chars = {int(spec, 16)}
+    return chars, rest
+
+
+all_emoji = set()
+emoji_categories = {}
+
+
+def parse_emoji():
+    for line in get_data('emoji-data.txt', 'emoji'):
+        chars, rest = split_two(line)
+        if max(chars) >= FIRST_EMOJI:
+            s = emoji_categories.setdefault(rest, set())
+            s |= chars
+            all_emoji.update(chars)
+
+
+doublewidth, ambiguous = set(), set()
+
+
+def parse_eaw():
+    global doublewidth, ambiguous
+    seen = set()
+    for line in get_data('ucd/EastAsianWidth.txt'):
+        chars, eaw = split_two(line)
+        if eaw == 'A':
+            ambiguous |= chars
+            seen |= chars
+        elif eaw == 'W' or eaw == 'F':
+            doublewidth |= chars
+            seen |= chars
+    doublewidth |= set(range(0x3400, 0x4DBF + 1)) - seen
+    doublewidth |= set(range(0x4E00, 0x9FFF + 1)) - seen
+    doublewidth |= set(range(0xF900, 0xFAFF + 1)) - seen
+    doublewidth |= set(range(0x20000, 0x2FFFD + 1)) - seen
+    doublewidth |= set(range(0x30000, 0x3FFFD + 1)) - seen
+
+
+def get_ranges(items):
+    items.sort()
+    for k, g in groupby(enumerate(items), lambda m: m[0]-m[1]):
+        group = tuple(map(itemgetter(1), g))
+        a, b = group[0], group[-1]
+        if a == b:
+            yield a
+        else:
+            yield a, b
+
+
+def write_case(spec, p):
+    if isinstance(spec, tuple):
+        p('\t\tcase 0x{:x} ... 0x{:x}:'.format(*spec))
+    else:
+        p('\t\tcase 0x{:x}:'.format(spec))
+
+
+@contextmanager
+def create_header(path):
+    f = open(path, 'w')
+    p = partial(print, file=f)
+    p('// unicode data, built from the unicode standard on:', date.today())
+    p('// see gen-wcwidth.py')
+    if path.endswith('.h'):
+        p('#pragma once')
+    p('#include "data-types.h"\n')
+    p('START_ALLOW_CASE_RANGE')
+    p()
+    yield p
+    p()
+    p('END_ALLOW_CASE_RANGE')
+    f.close()
+
+
+def gen_emoji():
+    with create_header('kitty/emoji.h') as p:
+        p('static inline bool\nis_emoji(char_type code) {')
+        p('\tswitch(code) {')
+        for spec in get_ranges(list(all_emoji)):
+            write_case(spec, p)
+            p('\t\t\treturn true;')
+        p('\t\tdefault: return false;')
+        p('\t}')
+        p('\treturn false;\n}')
+        p('static inline bool\nis_emoji_modifier(char_type code) {')
+        p('\tswitch(code) {')
+        for spec in get_ranges(list(emoji_categories['Emoji_Modifier'])):
+            write_case(spec, p)
+            p('\t\t\treturn true;')
+        p('\t\tdefault: return false;')
+        p('\t}')
+        p('\treturn false;\n}')
+
+
+def category_test(name, p, classes, comment, static=False):
+    static = 'static inline ' if static else ''
+    chars = set()
+    for c in classes:
+        chars |= class_maps[c]
+    p(f'{static}bool\n{name}(char_type code) {{')
+    p(f'\t// {comment} ({len(chars)} codepoints)' + ' {{' '{')
+    p('\tswitch(code) {')
+    for spec in get_ranges(list(chars)):
+        write_case(spec, p)
+        p(f'\t\t\treturn true;')
+    p('\t} // }}}\n')
+    p('\treturn false;\n}\n')
+
+
+def gen_ucd():
+    with create_header('kitty/unicode-data.c') as p:
+        p('#include "unicode-data.h"')
+        category_test('is_combining_char', p, {c for c in class_maps if c.startswith('M')}, 'M category (marks)')
+        category_test('is_ignored_char', p, 'Cc Cf Cs'.split(), 'Control characters (Cc Cf Cs)')
+        category_test('is_word_char', p, {c for c in class_maps if c[0] in 'LN'}, 'L and N categories')
+        category_test('is_CZ_category', p, {c for c in class_maps if c[0] in 'CZ'}, 'C and Z categories')
+        category_test('is_P_category', p, {c for c in class_maps if c[0] == 'P'}, 'P category (punctuation)')
+        mark_map = [0] + list(sorted(marks))
+        p('char_type codepoint_for_mark(combining_type m) {')
+        p(f'\tstatic char_type map[{len(mark_map)}] =', '{', ', '.join(map(str, mark_map)), '}; // {{{ mapping }}}')
+        p('\tif (m < arraysz(map)) return map[m];')
+        p('\treturn 0;')
+        p('}\n')
+        p('combining_type mark_for_codepoint(char_type c) {')
+        p('\tswitch(c) { // {{{')
+        rmap = {c: m for m, c in enumerate(mark_map)}
+        for spec in get_ranges(mark_map):
+            if isinstance(spec, tuple):
+                s = rmap[spec[0]]
+                p(f'\t\tcase {spec[0]} ... {spec[1]}: return {s} + c - {spec[0]};')
+            else:
+                p(f'\t\tcase {spec}: return {rmap[spec]};')
+        p('default: return 0;')
+        p('\t} // }}}')
+        p('}\n')
+
+
+def gen_wcwidth():
+    seen = set()
+
+    def add(p, comment, chars_, ret):
+        chars = chars_ - seen
+        seen.update(chars)
+        p(f'\t\t// {comment} ({len(chars)} codepoints)' + ' {{' '{')
+        for spec in get_ranges(list(chars)):
+            write_case(spec, p)
+            p(f'\t\t\treturn {ret};')
+        p('\t\t// }}}\n')
+
+    with create_header('kitty/wcwidth-std.h') as p:
+        p('static int\nwcwidth_std(int32_t code) {')
+        p('\tswitch(code) {')
+
+        non_printing = class_maps['Cc'] | class_maps['Cf'] | class_maps['Cs']
+        add(p, 'Non-printing characters', non_printing, -1)
+        add(p, 'Marks', marks, -1)
+        add(p, 'Private use', class_maps['Co'], -3)
+        add(p, 'East Asian ambiguous width', ambiguous, -2)
+        add(p, 'East Asian double width', doublewidth, 2)
+        add(p, 'Emoji', all_emoji, 2)
+
+        add(p, 'Not assigned in the unicode character database', not_assigned, -1)
+
+        p('\t\tdefault: return 1;')
+        p('\t}')
+        p('\treturn 1;\n}')
+
+
+parse_ucd()
+parse_emoji()
+parse_eaw()
+gen_ucd()
+gen_wcwidth()
+gen_emoji()

glfw/cocoa_platform.h

@@ -88,9 +88,10 @@ typedef struct _GLFWwindowNS
 
     GLFWbool        maximized;
 
-    // Cached window and framebuffer sizes used to filter out duplicate events
+    // Cached window properties to filter out duplicate events
     int             width, height;
     int             fbWidth, fbHeight;
+    float           xscale, yscale;
 
     // The total sum of the distances the cursor has been warped
     // since the last cursor motion event was processed

glfw/cocoa_window.m

@@ -43,6 +43,7 @@
  #define NSEventModifierFlagControl NSControlKeyMask
  #define NSEventModifierFlagOption NSAlternateKeyMask
  #define NSEventModifierFlagShift NSShiftKeyMask
+ #define NSEventModifierFlagCapsLock NSAlphaShiftKeyMask
  #define NSEventModifierFlagDeviceIndependentFlagsMask NSDeviceIndependentModifierFlagsMask
  #define NSEventMaskAny NSAnyEventMask
  #define NSEventTypeApplicationDefined NSApplicationDefined
@@ -177,6 +178,8 @@ static int translateFlags(NSUInteger flags)
         mods |= GLFW_MOD_ALT;
     if (flags & NSEventModifierFlagCommand)
         mods |= GLFW_MOD_SUPER;
+    if (flags & NSEventModifierFlagCapsLock)
+        mods |= GLFW_MOD_CAPS_LOCK;
 
     return mods;
 }
@@ -571,6 +574,16 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
         window->ns.fbHeight = fbRect.size.height;
         _glfwInputFramebufferSize(window, fbRect.size.width, fbRect.size.height);
     }
+
+    const float xscale = fbRect.size.width / contentRect.size.width;
+    const float yscale = fbRect.size.height / contentRect.size.height;
+
+    if (xscale != window->ns.xscale || yscale != window->ns.yscale)
+    {
+        window->ns.xscale = xscale;
+        window->ns.yscale = yscale;
+        _glfwInputWindowContentScale(window, xscale, yscale);
+    }
 }
 
 - (void)drawRect:(NSRect)rect
@@ -1087,8 +1100,8 @@ static GLFWbool createNativeWindow(_GLFWwindow* window,
             [window->ns.object zoom:nil];
     }
 
-    if (wndconfig->ns.frame)
-        [window->ns.object setFrameAutosaveName:[NSString stringWithUTF8String:wndconfig->title]];
+    if (strlen(wndconfig->ns.frameName))
+        [window->ns.object setFrameAutosaveName:[NSString stringWithUTF8String:wndconfig->ns.frameName]];
 
     window->ns.view = [[GLFWContentView alloc] initWithGlfwWindow:window];
 
@@ -1475,6 +1488,20 @@ int _glfwPlatformWindowMaximized(_GLFWwindow* window)
     return [window->ns.object isZoomed];
 }
 
+int _glfwPlatformWindowHovered(_GLFWwindow* window)
+{
+    const NSPoint point = [NSEvent mouseLocation];
+
+    if ([NSWindow windowNumberAtPoint:point belowWindowWithWindowNumber:0] !=
+        [window->ns.object windowNumber])
+    {
+        return GLFW_FALSE;
+    }
+
+    return NSPointInRect(point,
+        [window->ns.object convertRectToScreen:[window->ns.view bounds]]);
+}
+
 int _glfwPlatformFramebufferTransparent(_GLFWwindow* window)
 {
     return ![window->ns.object isOpaque] && ![window->ns.view isOpaque];

glfw/context.c

@@ -321,10 +321,11 @@ const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired,
     return closest;
 }
 
-GLFWbool _glfwRefreshContextAttribs(const _GLFWctxconfig* ctxconfig)
+GLFWbool _glfwRefreshContextAttribs(_GLFWwindow* window,
+                                    const _GLFWctxconfig* ctxconfig)
 {
     int i;
-    _GLFWwindow* window;
+    _GLFWwindow* previous;
     const char* version;
     const char* prefixes[] =
     {
@@ -334,11 +335,12 @@ GLFWbool _glfwRefreshContextAttribs(const _GLFWctxconfig* ctxconfig)
         NULL
     };
 
-    window = _glfwPlatformGetTls(&_glfw.contextSlot);
-
     window->context.source = ctxconfig->source;
     window->context.client = GLFW_OPENGL_API;
 
+    previous = _glfwPlatformGetTls(&_glfw.contextSlot);;
+    glfwMakeContextCurrent((GLFWwindow*) window);
+
     window->context.GetIntegerv = (PFNGLGETINTEGERVPROC)
         window->context.getProcAddress("glGetIntegerv");
     window->context.GetString = (PFNGLGETSTRINGPROC)
@@ -346,6 +348,7 @@ GLFWbool _glfwRefreshContextAttribs(const _GLFWctxconfig* ctxconfig)
     if (!window->context.GetIntegerv || !window->context.GetString)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR, "Entry point retrieval is broken");
+        glfwMakeContextCurrent((GLFWwindow*) previous);
         return GLFW_FALSE;
     }
 
@@ -363,6 +366,7 @@ GLFWbool _glfwRefreshContextAttribs(const _GLFWctxconfig* ctxconfig)
                             "OpenGL ES version string retrieval is broken");
         }
 
+        glfwMakeContextCurrent((GLFWwindow*) previous);
         return GLFW_FALSE;
     }
 
@@ -394,6 +398,7 @@ GLFWbool _glfwRefreshContextAttribs(const _GLFWctxconfig* ctxconfig)
                             "No version found in OpenGL ES version string");
         }
 
+        glfwMakeContextCurrent((GLFWwindow*) previous);
         return GLFW_FALSE;
     }
 
@@ -423,6 +428,7 @@ GLFWbool _glfwRefreshContextAttribs(const _GLFWctxconfig* ctxconfig)
                             window->context.major, window->context.minor);
         }
 
+        glfwMakeContextCurrent((GLFWwindow*) previous);
         return GLFW_FALSE;
     }
 
@@ -438,6 +444,7 @@ GLFWbool _glfwRefreshContextAttribs(const _GLFWctxconfig* ctxconfig)
         {
             _glfwInputError(GLFW_PLATFORM_ERROR,
                             "Entry point retrieval is broken");
+            glfwMakeContextCurrent((GLFWwindow*) previous);
             return GLFW_FALSE;
         }
     }
@@ -544,6 +551,7 @@ GLFWbool _glfwRefreshContextAttribs(const _GLFWctxconfig* ctxconfig)
         window->context.swapBuffers(window);
     }
 
+    glfwMakeContextCurrent((GLFWwindow*) previous);
     return GLFW_TRUE;
 }
 

glfw/glfw.py

@@ -52,7 +52,7 @@ def init_env(env, pkg_config, at_least_version, module='x11'):
             ans.ldpaths.extend(('-framework', f))
 
     elif module == 'wayland':
-        at_least_version('wayland-protocols', 1, 1)
+        at_least_version('wayland-protocols', *sinfo['wayland_protocols'])
         ans.wayland_packagedir = os.path.abspath(pkg_config('wayland-protocols', '--variable=pkgdatadir')[0])
         ans.wayland_scanner = os.path.abspath(pkg_config('wayland-scanner', '--variable=wayland_scanner')[0])
         ans.wayland_protocols = tuple(sinfo[module]['protocols'])
@@ -69,6 +69,8 @@ def init_env(env, pkg_config, at_least_version, module='x11'):
 def build_wayland_protocols(env, run_tool, emphasis, newer, dest_dir):
     for protocol in env.wayland_protocols:
         src = os.path.join(env.wayland_packagedir, protocol)
+        if not os.path.exists(src):
+            raise SystemExit('The wayland-protocols package on your system is missing the {} protocol definition file'.format(protocol))
         for ext in 'hc':
             dest = wayland_protocol_file_name(src, ext)
             dest = os.path.join(dest_dir, dest)
@@ -80,6 +82,7 @@ def build_wayland_protocols(env, run_tool, emphasis, newer, dest_dir):
 
 def collect_source_information():
     raw = open('src/CMakeLists.txt').read()
+    mraw = open('CMakeLists.txt').read()
 
     def extract_sources(group, start_pos=0):
         for which in 'HEADERS SOURCES'.split():
@@ -91,8 +94,11 @@ def collect_source_information():
                 ).group(1).strip().split()
             )
 
+    wayland_protocols = re.search('WaylandProtocols\s+(\S+)\s+', mraw).group(1)
+    wayland_protocols = list(map(int, wayland_protocols.split('.')))
     ans = {
         'common': dict(extract_sources('common')),
+        'wayland_protocols': wayland_protocols,
     }
     for group in 'cocoa win32 x11 wayland osmesa'.split():
         m = re.search('_GLFW_' + group.upper(), raw)
@@ -242,9 +248,10 @@ def main():
     sinfo = collect_source_information()
     files_to_copy = set()
     for x in sinfo.values():
-        headers, sources = x['headers'], x['sources']
-        for name in headers + sources:
-            files_to_copy.add(os.path.abspath(os.path.join('src', name)))
+        if isinstance(x, dict):
+            headers, sources = x['headers'], x['sources']
+            for name in headers + sources:
+                files_to_copy.add(os.path.abspath(os.path.join('src', name)))
     glfw_header = os.path.abspath('include/GLFW/glfw3.h')
     glfw_native_header = os.path.abspath('include/GLFW/glfw3native.h')
     os.chdir(base)

glfw/glfw3.h

@@ -493,17 +493,37 @@ extern "C" {
  *  @{ */
 
 /*! @brief If this bit is set one or more Shift keys were held down.
+ *
+ *  If this bit is set one or more Shift keys were held down.
  */
 #define GLFW_MOD_SHIFT           0x0001
 /*! @brief If this bit is set one or more Control keys were held down.
+ *
+ *  If this bit is set one or more Control keys were held down.
  */
 #define GLFW_MOD_CONTROL         0x0002
 /*! @brief If this bit is set one or more Alt keys were held down.
+ *
+ *  If this bit is set one or more Alt keys were held down.
  */
 #define GLFW_MOD_ALT             0x0004
 /*! @brief If this bit is set one or more Super keys were held down.
+ *
+ *  If this bit is set one or more Super keys were held down.
  */
 #define GLFW_MOD_SUPER           0x0008
+/*! @brief If this bit is set the Caps Lock key is enabled.
+ *
+ *  If this bit is set the Caps Lock key is enabled and the @ref
+ *  GLFW_LOCK_KEY_MODS input mode is set.
+ */
+#define GLFW_MOD_CAPS_LOCK       0x0010
+/*! @brief If this bit is set the Num Lock key is enabled.
+ *
+ *  If this bit is set the Num Lock key is enabled and the @ref
+ *  GLFW_LOCK_KEY_MODS input mode is set.
+ */
+#define GLFW_MOD_NUM_LOCK        0x0020
 
 /*! @} */
 
@@ -794,6 +814,7 @@ extern "C" {
  *  [window attribute](@ref GLFW_TRANSPARENT_FRAMEBUFFER_attrib).
  */
 #define GLFW_TRANSPARENT_FRAMEBUFFER 0x0002000A
+#define GLFW_HOVERED                0x0002000B
 
 /*! @brief Framebuffer bit depth hint.
  *
@@ -944,8 +965,11 @@ extern "C" {
 #define GLFW_CONTEXT_CREATION_API   0x0002200B
 
 #define GLFW_COCOA_RETINA_FRAMEBUFFER 0x00023001
-#define GLFW_COCOA_FRAME_AUTOSAVE     0x00023002
+#define GLFW_COCOA_FRAME_NAME         0x00023002
 #define GLFW_COCOA_GRAPHICS_SWITCHING 0x00023003
+
+#define GLFW_X11_CLASS_NAME         0x00024001
+#define GLFW_X11_INSTANCE_NAME      0x00024002
 /*! @} */
 
 #define GLFW_NO_API                          0
@@ -963,6 +987,7 @@ extern "C" {
 #define GLFW_CURSOR                 0x00033001
 #define GLFW_STICKY_KEYS            0x00033002
 #define GLFW_STICKY_MOUSE_BUTTONS   0x00033003
+#define GLFW_LOCK_KEY_MODS          0x00033004
 
 #define GLFW_CURSOR_NORMAL          0x00034001
 #define GLFW_CURSOR_HIDDEN          0x00034002
@@ -1025,9 +1050,6 @@ extern "C" {
 
 #define GLFW_COCOA_CHDIR_RESOURCES  0x00051001
 #define GLFW_COCOA_MENUBAR          0x00051002
-
-#define GLFW_X11_WM_CLASS_NAME      0x00052001
-#define GLFW_X11_WM_CLASS_CLASS     0x00052002
 /*! @} */
 
 #define GLFW_DONT_CARE              -1
@@ -1046,7 +1068,7 @@ extern "C" {
  *  @sa @ref glfwGetProcAddress
  *
  *  @since Added in version 3.0.
- 
+ *
  *  @ingroup context
  */
 typedef void (*GLFWglproc)(void);
@@ -1257,6 +1279,24 @@ typedef void (* GLFWwindowmaximizefun)(GLFWwindow*,int);
  */
 typedef void (* GLFWframebuffersizefun)(GLFWwindow*,int,int);
 
+/*! @brief The function signature for window content scale callbacks.
+ *
+ *  This is the function signature for window content scale callback
+ *  functions.
+ *
+ *  @param[in] window The window whose content scale changed.
+ *  @param[in] xscale The new x-axis content scale of the window.
+ *  @param[in] yscale The new y-axis content scale of the window.
+ *
+ *  @sa @ref window_scale
+ *  @sa @ref glfwSetWindowContentScaleCallback
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup window
+ */
+typedef void (* GLFWwindowcontentscalefun)(GLFWwindow*,float,float);
+
 /*! @brief The function signature for mouse button callbacks.
  *
  *  This is the function signature for mouse button callback functions.
@@ -1623,8 +1663,7 @@ GLFWAPI void glfwTerminate(void);
 
 /*! @brief Sets the specified init hint to the desired value.
  *
- *  This function sets hints for the next initialization of GLFW.  Only integer
- *  type hints can be set with this function.
+ *  This function sets hints for the next initialization of GLFW.
  *
  *  The values you set hints to are never reset by GLFW, but they only take
  *  effect during initialization.  Once GLFW has been initialized, any values
@@ -1633,7 +1672,7 @@ GLFWAPI void glfwTerminate(void);
  *
  *  Some hints are platform specific.  These may be set on any platform but they
  *  will only affect their specific platform.  Other platforms will ignore them.
- *  Setting these hints requires no platform specific headers or functions. 
+ *  Setting these hints requires no platform specific headers or functions.
  *
  *  @param[in] hint The [init hint](@ref init_hints) to set.
  *  @param[in] value The new value of the init hint.
@@ -1647,7 +1686,6 @@ GLFWAPI void glfwTerminate(void);
  *
  *  @sa init_hints
  *  @sa glfwInit
- *  @sa glfwInitHintString
  *
  *  @since Added in version 3.3.
  *
@@ -1655,40 +1693,6 @@ GLFWAPI void glfwTerminate(void);
  */
 GLFWAPI void glfwInitHint(int hint, int value);
 
-/*! @brief Sets the specified init hint to the desired value.
- *
- *  This function sets hints for the next initialization of GLFW.  Only string
- *  type hints can be set with this function.
- *
- *  The values you set hints to are never reset by GLFW, but they only take
- *  effect during initialization.  Once GLFW has been initialized, any values
- *  you set will be ignored until the library is terminated and initialized
- *  again.
- *
- *  Some hints are platform specific.  These may be set on any platform but they
- *  will only affect their specific platform.  Other platforms will ignore them.
- *  Setting these hints requires no platform specific headers or functions. 
- *
- *  @param[in] hint The [init hint](@ref init_hints) to set.
- *  @param[in] value The new value of the init hint.
- *
- *  @errors Possible errors include @ref GLFW_INVALID_ENUM and @ref
- *  GLFW_INVALID_VALUE.
- *
- *  @remarks This function may be called before @ref glfwInit.
- *
- *  @thread_safety This function must only be called from the main thread.
- *
- *  @sa init_hints
- *  @sa glfwInit
- *  @sa glfwInitHint
- *
- *  @since Added in version 3.3.
- *
- *  @ingroup init
- */
-GLFWAPI void glfwInitHintString(int hint, const char* value);
-
 /*! @brief Retrieves the version of the GLFW library.
  *
  *  This function retrieves the major, minor and revision numbers of the GLFW
@@ -1985,6 +1989,56 @@ GLFWAPI void glfwGetMonitorContentScale(GLFWmonitor* monitor, float* xscale, flo
  */
 GLFWAPI const char* glfwGetMonitorName(GLFWmonitor* monitor);
 
+/*! @brief Sets the user pointer of the specified monitor.
+ *
+ *  This function sets the user-defined pointer of the specified monitor.  The
+ *  current value is retained until the monitor is disconnected.  The initial
+ *  value is `NULL`.
+ *
+ *  This function may be called from the monitor callback, even for a monitor
+ *  that is being disconnected.
+ *
+ *  @param[in] monitor The monitor whose pointer to set.
+ *  @param[in] pointer The new value.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @sa @ref monitor_userptr
+ *  @sa @ref glfwGetMonitorUserPointer
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup monitor
+ */
+GLFWAPI void glfwSetMonitorUserPointer(GLFWmonitor* monitor, void* pointer);
+
+/*! @brief Returns the user pointer of the specified monitor.
+ *
+ *  This function returns the current value of the user-defined pointer of the
+ *  specified monitor.  The initial value is `NULL`.
+ *
+ *  This function may be called from the monitor callback, even for a monitor
+ *  that is being disconnected.
+ *
+ *  @param[in] monitor The monitor whose pointer to return.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @sa @ref monitor_userptr
+ *  @sa @ref glfwSetMonitorUserPointer
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup monitor
+ */
+GLFWAPI void* glfwGetMonitorUserPointer(GLFWmonitor* monitor);
+
 /*! @brief Sets the monitor configuration callback.
  *
  *  This function sets the monitor configuration callback, or removes the
@@ -2184,6 +2238,7 @@ GLFWAPI void glfwSetGammaRamp(GLFWmonitor* monitor, const GLFWgammaramp* ramp);
  *
  *  @sa @ref window_hints
  *  @sa @ref glfwWindowHint
+ *  @sa @ref glfwWindowHintString
  *
  *  @since Added in version 3.0.
  *
@@ -2194,14 +2249,20 @@ GLFWAPI void glfwDefaultWindowHints(void);
 /*! @brief Sets the specified window hint to the desired value.
  *
  *  This function sets hints for the next call to @ref glfwCreateWindow.  The
- *  hints, once set, retain their values until changed by a call to @ref
- *  glfwWindowHint or @ref glfwDefaultWindowHints, or until the library is
- *  terminated.
+ *  hints, once set, retain their values until changed by a call to this
+ *  function or @ref glfwDefaultWindowHints, or until the library is terminated.
+ *
+ *  Only integer value hints can be set with this function.  String value hints
+ *  are set with @ref glfwWindowHintString.
  *
  *  This function does not check whether the specified hint values are valid.
  *  If you set hints to invalid values this will instead be reported by the next
  *  call to @ref glfwCreateWindow.
  *
+ *  Some hints are platform specific.  These may be set on any platform but they
+ *  will only affect their specific platform.  Other platforms will ignore them.
+ *  Setting these hints requires no platform specific headers or functions.
+ *
  *  @param[in] hint The [window hint](@ref window_hints) to set.
  *  @param[in] value The new value of the window hint.
  *
@@ -2211,6 +2272,7 @@ GLFWAPI void glfwDefaultWindowHints(void);
  *  @thread_safety This function must only be called from the main thread.
  *
  *  @sa @ref window_hints
+ *  @sa @ref glfwWindowHintString
  *  @sa @ref glfwDefaultWindowHints
  *
  *  @since Added in version 3.0.  Replaces `glfwOpenWindowHint`.
@@ -2219,6 +2281,44 @@ GLFWAPI void glfwDefaultWindowHints(void);
  */
 GLFWAPI void glfwWindowHint(int hint, int value);
 
+/*! @brief Sets the specified window hint to the desired value.
+ *
+ *  This function sets hints for the next call to @ref glfwCreateWindow.  The
+ *  hints, once set, retain their values until changed by a call to this
+ *  function or @ref glfwDefaultWindowHints, or until the library is terminated.
+ *
+ *  Only string type hints can be set with this function.  Integer value hints
+ *  are set with @ref glfwWindowHint.
+ *
+ *  This function does not check whether the specified hint values are valid.
+ *  If you set hints to invalid values this will instead be reported by the next
+ *  call to @ref glfwCreateWindow.
+ *
+ *  Some hints are platform specific.  These may be set on any platform but they
+ *  will only affect their specific platform.  Other platforms will ignore them.
+ *  Setting these hints requires no platform specific headers or functions.
+ *
+ *  @param[in] hint The [window hint](@ref window_hints) to set.
+ *  @param[in] value The new value of the window hint.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_INVALID_ENUM.
+ *
+ *  @pointer_lifetime The specified string is copied before this function
+ *  returns.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_hints
+ *  @sa @ref glfwWindowHint
+ *  @sa @ref glfwDefaultWindowHints
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwWindowHintString(int hint, const char* value);
+
 /*! @brief Creates a window and its associated context.
  *
  *  This function creates a window and its associated OpenGL or OpenGL ES
@@ -2329,9 +2429,8 @@ GLFWAPI void glfwWindowHint(int hint, int value);
  *  `CMake/MacOSXBundleInfo.plist.in` in the source tree.
  *
  *  @remark @macos When activating frame autosaving with
- *  [GLFW_COCOA_FRAME_AUTOSAVE](@ref GLFW_COCOA_FRAME_AUTOSAVE_hint), the
- *  specified window size may be overriden by a previously saved size and
- *  position.
+ *  [GLFW_COCOA_FRAME_NAME](@ref GLFW_COCOA_FRAME_NAME_hint), the specified
+ *  window size and position may be overriden by previously saved values.
  *
  *  @remark @x11 Some window managers will not respect the placement of
  *  initially hidden windows.
@@ -2341,15 +2440,12 @@ GLFWAPI void glfwWindowHint(int hint, int value);
  *  query the final size, position or other attributes directly after window
  *  creation.
  *
- *  @remark @x11 The name and class of the `WM_CLASS` window property will by
- *  default be set to the window title passed to this function.  Set the @ref
- *  GLFW_X11_WM_CLASS_NAME and @ref GLFW_X11_WM_CLASS_CLASS init hints before
- *  initialization to override this. You can also set the title int he following
- *  special format, which allows setting the two parts of the WM_CLASS property
- *  and the window title independently:
- *  <01> WM_CLASS name <30> WM_CLASS class <30> title
- *  Here <01> refers to the byte value 01 (ASCII start-of-header) and <30> refers
- *  to the byte value 30 (ASCII record separator).
+ *  @remark @x11 The class part of the `WM_CLASS` window property will by
+ *  default be set to the window title passed to this function.  The instance
+ *  part will use the contents of the `RESOURCE_NAME` environment variable, if
+ *  present and not empty, or fall back to the window title.  Set the @ref
+ *  GLFW_X11_CLASS_NAME and @ref GLFW_X11_INSTANCE_NAME window hints to override
+ *  this.
  *
  *  @remark @wayland The window frame is currently unimplemented, as if
  *  [GLFW_DECORATED](@ref GLFW_DECORATED_hint) was always set to `GLFW_FALSE`.
@@ -2836,6 +2932,7 @@ GLFWAPI void glfwGetWindowFrameSize(GLFWwindow* window, int* left, int* top, int
  *  @thread_safety This function must only be called from the main thread.
  *
  *  @sa @ref window_scale
+ *  @sa @ref glfwSetWindowContentScaleCallback
  *  @sa @ref glfwGetMonitorContentScale
  *
  *  @since Added in version 3.3.
@@ -3237,7 +3334,7 @@ GLFWAPI int glfwGetWindowAttrib(GLFWwindow* window, int attrib);
  *  The supported attributes are [GLFW_DECORATED](@ref GLFW_DECORATED_attrib),
  *  [GLFW_RESIZABLE](@ref GLFW_RESIZABLE_attrib),
  *  [GLFW_FLOATING](@ref GLFW_FLOATING_attrib) and
- *  [GLFW_AUTO_ICONIFY](@ref GLFW_AUTO_ICONIFY_attrib).   
+ *  [GLFW_AUTO_ICONIFY](@ref GLFW_AUTO_ICONIFY_attrib).
  *
  *  Some of these attributes are ignored for full screen windows.  The new
  *  value will take effect if the window is later made windowed.
@@ -3525,6 +3622,30 @@ GLFWAPI GLFWwindowmaximizefun glfwSetWindowMaximizeCallback(GLFWwindow* window,
  */
 GLFWAPI GLFWframebuffersizefun glfwSetFramebufferSizeCallback(GLFWwindow* window, GLFWframebuffersizefun cbfun);
 
+/*! @brief Sets the window content scale callback for the specified window.
+ *
+ *  This function sets the window content scale callback of the specified window,
+ *  which is called when the content scale of the specified window changes.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] cbfun The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_scale
+ *  @sa @ref glfwGetWindowContentScale
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup window
+ */
+GLFWAPI GLFWwindowcontentscalefun glfwSetWindowContentScaleCallback(GLFWwindow* window, GLFWwindowcontentscalefun cbfun);
+
 /*! @brief Processes all pending events.
  *
  *  This function processes only those events that are already in the event
@@ -3689,12 +3810,12 @@ GLFWAPI void glfwPostEmptyEvent(void);
 /*! @brief Returns the value of an input option for the specified window.
  *
  *  This function returns the value of an input option for the specified window.
- *  The mode must be one of @ref GLFW_CURSOR, @ref GLFW_STICKY_KEYS or
- *  @ref GLFW_STICKY_MOUSE_BUTTONS.
+ *  The mode must be one of @ref GLFW_CURSOR, @ref GLFW_STICKY_KEYS,
+ *  @ref GLFW_STICKY_MOUSE_BUTTONS or @ref GLFW_LOCK_KEY_MODS.
  *
  *  @param[in] window The window to query.
- *  @param[in] mode One of `GLFW_CURSOR`, `GLFW_STICKY_KEYS` or
- *  `GLFW_STICKY_MOUSE_BUTTONS`.
+ *  @param[in] mode One of `GLFW_CURSOR`, `GLFW_STICKY_KEYS`,
+ *  `GLFW_STICKY_MOUSE_BUTTONS` or `GLFW_LOCK_KEY_MODS`.
  *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
  *  GLFW_INVALID_ENUM.
@@ -3712,8 +3833,8 @@ GLFWAPI int glfwGetInputMode(GLFWwindow* window, int mode);
 /*! @brief Sets an input option for the specified window.
  *
  *  This function sets an input mode option for the specified window.  The mode
- *  must be one of @ref GLFW_CURSOR, @ref GLFW_STICKY_KEYS or
- *  @ref GLFW_STICKY_MOUSE_BUTTONS.
+ *  must be one of @ref GLFW_CURSOR, @ref GLFW_STICKY_KEYS,
+ *  @ref GLFW_STICKY_MOUSE_BUTTONS or @ref GLFW_LOCK_KEY_MODS.
  *
  *  If the mode is `GLFW_CURSOR`, the value must be one of the following cursor
  *  modes:
@@ -3739,9 +3860,15 @@ GLFWAPI int glfwGetInputMode(GLFWwindow* window, int mode);
  *  you are only interested in whether mouse buttons have been pressed but not
  *  when or in which order.
  *
+ *  If the mode is `GLFW_LOCK_KEY_MODS`, the value must be either `GLFW_TRUE` to
+ *  enable lock key modifier bits, or `GLFW_FALSE` to disable them.  If enabled,
+ *  callbacks that receive modifier bits will also have the @ref
+ *  GLFW_MOD_CAPS_LOCK bit set when the event was generated with Caps Lock on,
+ *  and the @ref GLFW_MOD_NUM_LOCK bit when Num Lock was on.
+ *
  *  @param[in] window The window whose input mode to set.
- *  @param[in] mode One of `GLFW_CURSOR`, `GLFW_STICKY_KEYS` or
- *  `GLFW_STICKY_MOUSE_BUTTONS`.
+ *  @param[in] mode One of `GLFW_CURSOR`, `GLFW_STICKY_KEYS`,
+ *  `GLFW_STICKY_MOUSE_BUTTONS` or `GLFW_LOCK_KEY_MODS`.
  *  @param[in] value The new value of the specified input mode.
  *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
@@ -4481,10 +4608,10 @@ GLFWAPI const unsigned char* glfwGetJoystickButtons(int jid, int* count);
  *  it with the corresponding direction.
  *
  *  @code
- *  if (hats[2] & GLFW_HAT_RIGHT)                                
- *  {                                                            
- *      // State of hat 2 could be right-up, right or right-down 
- *  }                                                            
+ *  if (hats[2] & GLFW_HAT_RIGHT)
+ *  {
+ *      // State of hat 2 could be right-up, right or right-down
+ *  }
  *  @endcode
  *
  *  If the specified joystick is not present this function will return `NULL`
@@ -4588,6 +4715,56 @@ GLFWAPI const char* glfwGetJoystickName(int jid);
  */
 GLFWAPI const char* glfwGetJoystickGUID(int jid);
 
+/*! @brief Sets the user pointer of the specified joystick.
+ *
+ *  This function sets the user-defined pointer of the specified joystick.  The
+ *  current value is retained until the joystick is disconnected.  The initial
+ *  value is `NULL`.
+ *
+ *  This function may be called from the joystick callback, even for a joystick
+ *  that is being disconnected.
+ *
+ *  @param[in] joystick The joystick whose pointer to set.
+ *  @param[in] pointer The new value.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @sa @ref joystick_userptr
+ *  @sa @ref glfwGetJoystickUserPointer
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup input
+ */
+GLFWAPI void glfwSetJoystickUserPointer(int jid, void* pointer);
+
+/*! @brief Returns the user pointer of the specified joystick.
+ *
+ *  This function returns the current value of the user-defined pointer of the
+ *  specified joystick.  The initial value is `NULL`.
+ *
+ *  This function may be called from the joystick callback, even for a joystick
+ *  that is being disconnected.
+ *
+ *  @param[in] joystick The joystick whose pointer to return.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @sa @ref joystick_userptr
+ *  @sa @ref glfwSetJoystickUserPointer
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup input
+ */
+GLFWAPI void* glfwGetJoystickUserPointer(int jid);
+
 /*! @brief Returns whether the specified joystick has a gamepad mapping.
  *
  *  This function returns whether the specified joystick is both present and has
@@ -4864,7 +5041,7 @@ GLFWAPI void glfwSetTime(double time);
  *  1&nbsp;/&nbsp;frequency seconds.  To get the frequency, call @ref
  *  glfwGetTimerFrequency.
  *
- *  @return The value of the timer, or zero if an 
+ *  @return The value of the timer, or zero if an
  *  [error](@ref error_handling) occurred.
  *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.

glfw/init.c

@@ -53,10 +53,6 @@ static _GLFWinitconfig _glfwInitHints =
     {
         GLFW_TRUE,  // macOS menu bar
         GLFW_TRUE   // macOS bundle chdir
-    },
-    {
-        "",         // X11 WM_CLASS name
-        ""          // X11 WM_CLASS class
     }
 };
 
@@ -260,27 +256,7 @@ GLFWAPI void glfwInitHint(int hint, int value)
     }
 
     _glfwInputError(GLFW_INVALID_ENUM,
-                    "Invalid integer type init hint 0x%08X", hint);
-}
-
-GLFWAPI void glfwInitHintString(int hint, const char* value)
-{
-    assert(value != NULL);
-
-    switch (hint)
-    {
-        case GLFW_X11_WM_CLASS_NAME:
-            strncpy(_glfwInitHints.x11.className, value,
-                    sizeof(_glfwInitHints.x11.className) - 1);
-            return;
-        case GLFW_X11_WM_CLASS_CLASS:
-            strncpy(_glfwInitHints.x11.classClass, value,
-                    sizeof(_glfwInitHints.x11.classClass) - 1);
-            return;
-    }
-
-    _glfwInputError(GLFW_INVALID_ENUM,
-                    "Invalid string type init hint 0x%08X", hint);
+                    "Invalid init hint 0x%08X", hint);
 }
 
 GLFWAPI void glfwGetVersion(int* major, int* minor, int* rev)

glfw/input.c

@@ -57,6 +57,58 @@ static _GLFWmapping* findMapping(const char* guid)
     return NULL;
 }
 
+// Checks whether a gamepad mapping element is present in the hardware
+//
+static GLFWbool isValidElementForJoystick(const _GLFWmapelement* e,
+                                          const _GLFWjoystick* js)
+{
+    if (e->type == _GLFW_JOYSTICK_HATBIT && (e->value >> 4) >= js->hatCount)
+        return GLFW_FALSE;
+    else if (e->type == _GLFW_JOYSTICK_BUTTON && e->value >= js->buttonCount)
+        return GLFW_FALSE;
+    else if (e->type == _GLFW_JOYSTICK_AXIS && e->value >= js->axisCount)
+        return GLFW_FALSE;
+
+    return GLFW_TRUE;
+}
+
+// Finds a mapping based on joystick GUID and verifies element indices
+//
+static _GLFWmapping* findValidMapping(const _GLFWjoystick* js)
+{
+    _GLFWmapping* mapping = findMapping(js->guid);
+    if (mapping)
+    {
+        int i;
+
+        for (i = 0;  i <= GLFW_GAMEPAD_BUTTON_LAST;  i++)
+        {
+            if (!isValidElementForJoystick(mapping->buttons + i, js))
+            {
+                _glfwInputError(GLFW_INVALID_VALUE,
+                                "Invalid button in gamepad mapping %s (%s)",
+                                mapping->guid,
+                                mapping->name);
+                return NULL;
+            }
+        }
+
+        for (i = 0;  i <= GLFW_GAMEPAD_AXIS_LAST;  i++)
+        {
+            if (!isValidElementForJoystick(mapping->axes + i, js))
+            {
+                _glfwInputError(GLFW_INVALID_VALUE,
+                                "Invalid axis in gamepad mapping %s (%s)",
+                                mapping->guid,
+                                mapping->name);
+                return NULL;
+            }
+        }
+    }
+
+    return mapping;
+}
+
 // Parses an SDL_GameControllerDB line and adds it to the mapping list
 //
 static GLFWbool parseMapping(_GLFWmapping* mapping, const char* string)
@@ -193,6 +245,9 @@ void _glfwInputKey(_GLFWwindow* window, int key, int scancode, int action, int m
             action = GLFW_REPEAT;
     }
 
+    if (!window->lockKeyMods)
+        mods &= ~(GLFW_MOD_CAPS_LOCK | GLFW_MOD_NUM_LOCK);
+
     if (window->callbacks.key)
         window->callbacks.key((GLFWwindow*) window, key, scancode, action, mods);
 }
@@ -202,6 +257,9 @@ void _glfwInputChar(_GLFWwindow* window, unsigned int codepoint, int mods, GLFWb
     if (codepoint < 32 || (codepoint > 126 && codepoint < 160))
         return;
 
+    if (!window->lockKeyMods)
+        mods &= ~(GLFW_MOD_CAPS_LOCK | GLFW_MOD_NUM_LOCK);
+
     if (window->callbacks.charmods)
         window->callbacks.charmods((GLFWwindow*) window, codepoint, mods);
 
@@ -223,6 +281,9 @@ void _glfwInputMouseClick(_GLFWwindow* window, int button, int action, int mods)
     if (button < 0 || button > GLFW_MOUSE_BUTTON_LAST)
         return;
 
+    if (!window->lockKeyMods)
+        mods &= ~(GLFW_MOD_CAPS_LOCK | GLFW_MOD_NUM_LOCK);
+
     if (action == GLFW_RELEASE && window->stickyMouseButtons)
         window->mouseButtons[button] = _GLFW_STICK;
     else
@@ -318,9 +379,9 @@ _GLFWjoystick* _glfwAllocJoystick(const char* name,
     js->axisCount   = axisCount;
     js->buttonCount = buttonCount;
     js->hatCount    = hatCount;
-    js->mapping     = findMapping(guid);
 
     strcpy(js->guid, guid);
+    js->mapping = findValidMapping(js);
 
     return js;
 }
@@ -354,6 +415,8 @@ GLFWAPI int glfwGetInputMode(GLFWwindow* handle, int mode)
             return window->stickyKeys;
         case GLFW_STICKY_MOUSE_BUTTONS:
             return window->stickyMouseButtons;
+        case GLFW_LOCK_KEY_MODS:
+            return window->lockKeyMods;
     }
 
     _glfwInputError(GLFW_INVALID_ENUM, "Invalid input mode 0x%08X", mode);
@@ -409,7 +472,7 @@ GLFWAPI void glfwSetInputMode(GLFWwindow* handle, int mode, int value)
             }
         }
 
-        window->stickyKeys = value ? GLFW_TRUE : GLFW_FALSE;
+        window->stickyKeys = value;
     }
     else if (mode == GLFW_STICKY_MOUSE_BUTTONS)
     {
@@ -429,8 +492,10 @@ GLFWAPI void glfwSetInputMode(GLFWwindow* handle, int mode, int value)
             }
         }
 
-        window->stickyMouseButtons = value ? GLFW_TRUE : GLFW_FALSE;
+        window->stickyMouseButtons = value;
     }
+    else if (mode == GLFW_LOCK_KEY_MODS)
+        window->lockKeyMods = value ? GLFW_TRUE : GLFW_FALSE;
     else
         _glfwInputError(GLFW_INVALID_ENUM, "Invalid input mode 0x%08X", mode);
 }
@@ -914,6 +979,38 @@ GLFWAPI const char* glfwGetJoystickGUID(int jid)
     return js->guid;
 }
 
+GLFWAPI void glfwSetJoystickUserPointer(int jid, void* pointer)
+{
+    _GLFWjoystick* js;
+
+    assert(jid >= GLFW_JOYSTICK_1);
+    assert(jid <= GLFW_JOYSTICK_LAST);
+
+    _GLFW_REQUIRE_INIT();
+
+    js = _glfw.joysticks + jid;
+    if (!js->present)
+        return;
+
+    js->userPointer = pointer;
+}
+
+GLFWAPI void* glfwGetJoystickUserPointer(int jid)
+{
+    _GLFWjoystick* js;
+
+    assert(jid >= GLFW_JOYSTICK_1);
+    assert(jid <= GLFW_JOYSTICK_LAST);
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+
+    js = _glfw.joysticks + jid;
+    if (!js->present)
+        return NULL;
+
+    return js->userPointer;
+}
+
 GLFWAPI GLFWjoystickfun glfwSetJoystickCallback(GLFWjoystickfun cbfun)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
@@ -973,7 +1070,7 @@ GLFWAPI int glfwUpdateGamepadMappings(const char* string)
     {
         _GLFWjoystick* js = _glfw.joysticks + jid;
         if (js->present)
-            js->mapping = findMapping(js->guid);
+            js->mapping = findValidMapping(js);
     }
 
     return GLFW_TRUE;
@@ -1085,8 +1182,8 @@ GLFWAPI int glfwGetGamepadState(int jid, GLFWgamepadstate* state)
             state->axes[i] = js->axes[js->mapping->axes[i].value];
         else if (js->mapping->buttons[i].type == _GLFW_JOYSTICK_HATBIT)
         {
-            const unsigned int hat = js->mapping->buttons[i].value >> 4;
-            const unsigned int bit = js->mapping->buttons[i].value & 0xf;
+            const unsigned int hat = js->mapping->axes[i].value >> 4;
+            const unsigned int bit = js->mapping->axes[i].value & 0xf;
             if (js->hats[hat] & bit)
                 state->axes[i] = 1.f;
         }

glfw/internal.h

@@ -281,10 +281,6 @@ struct _GLFWinitconfig
         GLFWbool  menubar;
         GLFWbool  chdir;
     } ns;
-    struct {
-        char      className[256];
-        char      classClass[256];
-    } x11;
 };
 
 /*! @brief Window configuration.
@@ -308,8 +304,12 @@ struct _GLFWwndconfig
     GLFWbool      centerCursor;
     struct {
         GLFWbool  retina;
-        GLFWbool  frame;
+        char      frameName[256];
     } ns;
+    struct {
+        char      className[256];
+        char      instanceName[256];
+    } x11;
 };
 
 /*! @brief Context configuration.
@@ -419,6 +419,7 @@ struct _GLFWwindow
 
     GLFWbool            stickyKeys;
     GLFWbool            stickyMouseButtons;
+    GLFWbool            lockKeyMods;
     int                 cursorMode;
     char                mouseButtons[GLFW_MOUSE_BUTTON_LAST + 1];
     char                keys[GLFW_KEY_LAST + 1];
@@ -436,6 +437,7 @@ struct _GLFWwindow
         GLFWwindowiconifyfun    iconify;
         GLFWwindowmaximizefun   maximize;
         GLFWframebuffersizefun  fbsize;
+        GLFWwindowcontentscalefun scale;
         GLFWmousebuttonfun      mouseButton;
         GLFWcursorposfun        cursorPos;
         GLFWcursorenterfun      cursorEnter;
@@ -455,6 +457,7 @@ struct _GLFWwindow
 struct _GLFWmonitor
 {
     char*           name;
+    void*           userPointer;
 
     // Physical dimensions in millimeters.
     int             widthMM, heightMM;
@@ -513,6 +516,7 @@ struct _GLFWjoystick
     unsigned char*  hats;
     int             hatCount;
     char*           name;
+    void*           userPointer;
     char            guid[33];
     _GLFWmapping*   mapping;
 
@@ -687,6 +691,7 @@ int _glfwPlatformWindowFocused(_GLFWwindow* window);
 int _glfwPlatformWindowIconified(_GLFWwindow* window);
 int _glfwPlatformWindowVisible(_GLFWwindow* window);
 int _glfwPlatformWindowMaximized(_GLFWwindow* window);
+int _glfwPlatformWindowHovered(_GLFWwindow* window);
 int _glfwPlatformFramebufferTransparent(_GLFWwindow* window);
 float _glfwPlatformGetWindowOpacity(_GLFWwindow* window);
 void _glfwPlatformSetWindowResizable(_GLFWwindow* window, GLFWbool enabled);
@@ -752,6 +757,14 @@ void _glfwInputWindowSize(_GLFWwindow* window, int width, int height);
  */
 void _glfwInputFramebufferSize(_GLFWwindow* window, int width, int height);
 
+/*! @brief Notifies shared code that a window content scale has changed.
+ *  @param[in] window The window that received the event.
+ *  @param[in] xscale The new x-axis content scale of the window.
+ *  @param[in] yscale The new y-axis content scale of the window.
+ *  @ingroup event
+ */
+void _glfwInputWindowContentScale(_GLFWwindow* window, float xscale, float yscale);
+
 /*! @brief Notifies shared code that a window has been iconified or restored.
  *  @param[in] window The window that received the event.
  *  @param[in] iconified `GLFW_TRUE` if the window was iconified, or
@@ -952,7 +965,8 @@ const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired,
  *  unusable.
  *  @ingroup utility
  */
-GLFWbool _glfwRefreshContextAttribs(const _GLFWctxconfig* ctxconfig);
+GLFWbool _glfwRefreshContextAttribs(_GLFWwindow* window,
+                                    const _GLFWctxconfig* ctxconfig);
 
 /*! @brief Checks whether the desired context attributes are valid.
  *  @param[in] ctxconfig The context attributes to check.

glfw/mappings.h

@@ -51,7 +51,7 @@
 // 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. 
+//    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.

glfw/monitor.c

@@ -351,6 +351,24 @@ GLFWAPI const char* glfwGetMonitorName(GLFWmonitor* handle)
     return monitor->name;
 }
 
+GLFWAPI void glfwSetMonitorUserPointer(GLFWmonitor* handle, void* pointer)
+{
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+    assert(monitor != NULL);
+
+    _GLFW_REQUIRE_INIT();
+    monitor->userPointer = pointer;
+}
+
+GLFWAPI void* glfwGetMonitorUserPointer(GLFWmonitor* handle)
+{
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+    assert(monitor != NULL);
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    return monitor->userPointer;
+}
+
 GLFWAPI GLFWmonitorfun glfwSetMonitorCallback(GLFWmonitorfun cbfun)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
@@ -406,16 +424,16 @@ GLFWAPI void glfwSetGamma(GLFWmonitor* handle, float gamma)
 
     for (i = 0;  i < 256;  i++)
     {
-        double value;
+        float value;
 
         // Calculate intensity
-        value = i / 255.0;
+        value = i / 255.f;
         // Apply gamma curve
-        value = pow(value, 1.0 / gamma) * 65535.0 + 0.5;
+        value = powf(value, 1.f / gamma) * 65535.f + 0.5f;
 
         // Clamp to value range
-        if (value > 65535.0)
-            value = 65535.0;
+        if (value > 65535.f)
+            value = 65535.f;
 
         values[i] = (unsigned short) value;
     }

glfw/null_window.c

@@ -165,6 +165,11 @@ int _glfwPlatformWindowMaximized(_GLFWwindow* window)
     return GLFW_FALSE;
 }
 
+int _glfwPlatformWindowHovered(_GLFWwindow* window)
+{
+    return GLFW_FALSE;
+}
+
 int _glfwPlatformFramebufferTransparent(_GLFWwindow* window)
 {
     return GLFW_FALSE;

glfw/source-info.json

@@ -79,6 +79,10 @@
       "osmesa_context.c"
     ]
   }, 
+  "wayland_protocols": [
+    1, 
+    6
+  ], 
   "win32": {
     "headers": [
       "win32_platform.h", 

glfw/wgl_context.c

@@ -329,21 +329,52 @@ static void destroyContextWGL(_GLFWwindow* window)
     }
 }
 
-// Initialize WGL-specific extensions
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Initialize WGL
 //
-static void loadWGLExtensions(void)
+GLFWbool _glfwInitWGL(void)
 {
     PIXELFORMATDESCRIPTOR pfd;
-    HGLRC rc;
-    HDC dc = GetDC(_glfw.win32.helperWindowHandle);;
+    HGLRC prc, rc;
+    HDC pdc, dc;
 
-    _glfw.wgl.extensionsLoaded = GLFW_TRUE;
+    if (_glfw.wgl.instance)
+        return GLFW_TRUE;
+
+    _glfw.wgl.instance = LoadLibraryA("opengl32.dll");
+    if (!_glfw.wgl.instance)
+    {
+        _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
+                             "WGL: Failed to load opengl32.dll");
+        return GLFW_FALSE;
+    }
+
+    _glfw.wgl.CreateContext = (PFN_wglCreateContext)
+        GetProcAddress(_glfw.wgl.instance, "wglCreateContext");
+    _glfw.wgl.DeleteContext = (PFN_wglDeleteContext)
+        GetProcAddress(_glfw.wgl.instance, "wglDeleteContext");
+    _glfw.wgl.GetProcAddress = (PFN_wglGetProcAddress)
+        GetProcAddress(_glfw.wgl.instance, "wglGetProcAddress");
+    _glfw.wgl.GetCurrentDC = (PFN_wglGetCurrentDC)
+        GetProcAddress(_glfw.wgl.instance, "wglGetCurrentDC");
+    _glfw.wgl.GetCurrentContext = (PFN_wglGetCurrentContext)
+        GetProcAddress(_glfw.wgl.instance, "wglGetCurrentContext");
+    _glfw.wgl.MakeCurrent = (PFN_wglMakeCurrent)
+        GetProcAddress(_glfw.wgl.instance, "wglMakeCurrent");
+    _glfw.wgl.ShareLists = (PFN_wglShareLists)
+        GetProcAddress(_glfw.wgl.instance, "wglShareLists");
 
     // NOTE: A dummy context has to be created for opengl32.dll to load the
     //       OpenGL ICD, from which we can then query WGL extensions
     // NOTE: This code will accept the Microsoft GDI ICD; accelerated context
     //       creation failure occurs during manual pixel format enumeration
 
+    dc = GetDC(_glfw.win32.helperWindowHandle);;
+
     ZeroMemory(&pfd, sizeof(pfd));
     pfd.nSize = sizeof(pfd);
     pfd.nVersion = 1;
@@ -355,7 +386,7 @@ static void loadWGLExtensions(void)
     {
         _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
                              "WGL: Failed to set pixel format for dummy context");
-        return;
+        return GLFW_FALSE;
     }
 
     rc = wglCreateContext(dc);
@@ -363,15 +394,19 @@ static void loadWGLExtensions(void)
     {
         _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
                              "WGL: Failed to create dummy context");
-        return;
+        return GLFW_FALSE;
     }
 
+    pdc = wglGetCurrentDC();
+    prc = wglGetCurrentContext();
+
     if (!wglMakeCurrent(dc, rc))
     {
         _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
                              "WGL: Failed to make dummy context current");
+        wglMakeCurrent(pdc, prc);
         wglDeleteContext(rc);
-        return;
+        return GLFW_FALSE;
     }
 
     // NOTE: Functions must be loaded first as they're needed to retrieve the
@@ -414,43 +449,8 @@ static void loadWGLExtensions(void)
     _glfw.wgl.ARB_context_flush_control =
         extensionSupportedWGL("WGL_ARB_context_flush_control");
 
-    wglMakeCurrent(dc, NULL);
+    wglMakeCurrent(pdc, prc);
     wglDeleteContext(rc);
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-//////                       GLFW internal API                      //////
-//////////////////////////////////////////////////////////////////////////
-
-// Initialize WGL
-//
-GLFWbool _glfwInitWGL(void)
-{
-    if (_glfw.wgl.instance)
-        return GLFW_TRUE;
-
-    _glfw.wgl.instance = LoadLibraryA("opengl32.dll");
-    if (!_glfw.wgl.instance)
-    {
-        _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
-                             "WGL: Failed to load opengl32.dll");
-        return GLFW_FALSE;
-    }
-
-    _glfw.wgl.CreateContext = (PFN_wglCreateContext)
-        GetProcAddress(_glfw.wgl.instance, "wglCreateContext");
-    _glfw.wgl.DeleteContext = (PFN_wglDeleteContext)
-        GetProcAddress(_glfw.wgl.instance, "wglDeleteContext");
-    _glfw.wgl.GetProcAddress = (PFN_wglGetProcAddress)
-        GetProcAddress(_glfw.wgl.instance, "wglGetProcAddress");
-    _glfw.wgl.GetCurrentDC = (PFN_wglGetCurrentDC)
-        GetProcAddress(_glfw.wgl.instance, "wglGetCurrentDC");
-    _glfw.wgl.MakeCurrent = (PFN_wglMakeCurrent)
-        GetProcAddress(_glfw.wgl.instance, "wglMakeCurrent");
-    _glfw.wgl.ShareLists = (PFN_wglShareLists)
-        GetProcAddress(_glfw.wgl.instance, "wglShareLists");
-
     return GLFW_TRUE;
 }
 
@@ -480,9 +480,6 @@ GLFWbool _glfwCreateContextWGL(_GLFWwindow* window,
     PIXELFORMATDESCRIPTOR pfd;
     HGLRC share = NULL;
 
-    if (!_glfw.wgl.extensionsLoaded)
-        loadWGLExtensions();
-
     if (ctxconfig->share)
         share = ctxconfig->share->context.wgl.handle;
 

glfw/wgl_context.h

@@ -86,6 +86,7 @@ typedef HGLRC (WINAPI * PFN_wglCreateContext)(HDC);
 typedef BOOL (WINAPI * PFN_wglDeleteContext)(HGLRC);
 typedef PROC (WINAPI * PFN_wglGetProcAddress)(LPCSTR);
 typedef HDC (WINAPI * PFN_wglGetCurrentDC)(void);
+typedef HGLRC (WINAPI * PFN_wglGetCurrentContext)(void);
 typedef BOOL (WINAPI * PFN_wglMakeCurrent)(HDC,HGLRC);
 typedef BOOL (WINAPI * PFN_wglShareLists)(HGLRC,HGLRC);
 
@@ -94,6 +95,7 @@ typedef BOOL (WINAPI * PFN_wglShareLists)(HGLRC,HGLRC);
 #define wglDeleteContext _glfw.wgl.DeleteContext
 #define wglGetProcAddress _glfw.wgl.GetProcAddress
 #define wglGetCurrentDC _glfw.wgl.GetCurrentDC
+#define wglGetCurrentContext _glfw.wgl.GetCurrentContext
 #define wglMakeCurrent _glfw.wgl.MakeCurrent
 #define wglShareLists _glfw.wgl.ShareLists
 
@@ -124,11 +126,10 @@ typedef struct _GLFWlibraryWGL
     PFN_wglDeleteContext                DeleteContext;
     PFN_wglGetProcAddress               GetProcAddress;
     PFN_wglGetCurrentDC                 GetCurrentDC;
+    PFN_wglGetCurrentContext            GetCurrentContext;
     PFN_wglMakeCurrent                  MakeCurrent;
     PFN_wglShareLists                   ShareLists;
 
-    GLFWbool                            extensionsLoaded;
-
     PFNWGLSWAPINTERVALEXTPROC           SwapIntervalEXT;
     PFNWGLGETPIXELFORMATATTRIBIVARBPROC GetPixelFormatAttribivARB;
     PFNWGLGETEXTENSIONSSTRINGEXTPROC    GetExtensionsStringEXT;

glfw/win32_init.c

@@ -351,9 +351,10 @@ static HWND createHelperWindow(void)
         dbi.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
         dbi.dbcc_classguid = GUID_DEVINTERFACE_HID;
 
-        RegisterDeviceNotificationW(window,
-                                    (DEV_BROADCAST_HDR*) &dbi,
-                                    DEVICE_NOTIFY_WINDOW_HANDLE);
+        _glfw.win32.deviceNotificationHandle =
+            RegisterDeviceNotificationW(window,
+                                        (DEV_BROADCAST_HDR*) &dbi,
+                                        DEVICE_NOTIFY_WINDOW_HANDLE);
     }
 
     while (PeekMessageW(&msg, _glfw.win32.helperWindowHandle, 0, 0, PM_REMOVE))
@@ -543,6 +544,9 @@ int _glfwPlatformInit(void)
 
 void _glfwPlatformTerminate(void)
 {
+    if (_glfw.win32.deviceNotificationHandle)
+        UnregisterDeviceNotification(_glfw.win32.deviceNotificationHandle);
+
     if (_glfw.win32.helperWindowHandle)
         DestroyWindow(_glfw.win32.helperWindowHandle);
 

glfw/win32_platform.h

@@ -105,12 +105,11 @@
 #endif
 
 #if WINVER < 0x0601
-typedef struct tagCHANGEFILTERSTRUCT
+typedef struct
 {
     DWORD cbSize;
     DWORD ExtStatus;
-
-} CHANGEFILTERSTRUCT, *PCHANGEFILTERSTRUCT;
+} CHANGEFILTERSTRUCT;
 #ifndef MSGFLT_ALLOW
  #define MSGFLT_ALLOW 1
 #endif
@@ -129,13 +128,13 @@ typedef struct
 #endif /*Windows Vista*/
 
 #ifndef DPI_ENUMS_DECLARED
-typedef enum PROCESS_DPI_AWARENESS
+typedef enum
 {
     PROCESS_DPI_UNAWARE = 0,
     PROCESS_SYSTEM_DPI_AWARE = 1,
     PROCESS_PER_MONITOR_DPI_AWARE = 2
 } PROCESS_DPI_AWARENESS;
-typedef enum MONITOR_DPI_TYPE
+typedef enum
 {
     MDT_EFFECTIVE_DPI = 0,
     MDT_ANGULAR_DPI = 1,
@@ -209,7 +208,7 @@ typedef HRESULT (WINAPI * PFN_DirectInput8Create)(HINSTANCE,DWORD,REFIID,LPVOID*
 
 // user32.dll function pointer typedefs
 typedef BOOL (WINAPI * PFN_SetProcessDPIAware)(void);
-typedef BOOL (WINAPI * PFN_ChangeWindowMessageFilterEx)(HWND,UINT,DWORD,PCHANGEFILTERSTRUCT);
+typedef BOOL (WINAPI * PFN_ChangeWindowMessageFilterEx)(HWND,UINT,DWORD,CHANGEFILTERSTRUCT*);
 #define SetProcessDPIAware _glfw.win32.user32.SetProcessDPIAware_
 #define ChangeWindowMessageFilterEx _glfw.win32.user32.ChangeWindowMessageFilterEx_
 
@@ -289,6 +288,7 @@ typedef struct _GLFWwindowWin32
 typedef struct _GLFWlibraryWin32
 {
     HWND                helperWindowHandle;
+    HDEVNOTIFY          deviceNotificationHandle;
     DWORD               foregroundLockTimeout;
     int                 acquiredMonitorCount;
     char*               clipboardString;

glfw/win32_window.c

@@ -384,14 +384,18 @@ static int getKeyMods(void)
 {
     int mods = 0;
 
-    if (GetKeyState(VK_SHIFT) & (1 << 31))
+    if (GetKeyState(VK_SHIFT) & 0x8000)
         mods |= GLFW_MOD_SHIFT;
-    if (GetKeyState(VK_CONTROL) & (1 << 31))
+    if (GetKeyState(VK_CONTROL) & 0x8000)
         mods |= GLFW_MOD_CONTROL;
-    if (GetKeyState(VK_MENU) & (1 << 31))
+    if (GetKeyState(VK_MENU) & 0x8000)
         mods |= GLFW_MOD_ALT;
-    if ((GetKeyState(VK_LWIN) | GetKeyState(VK_RWIN)) & (1 << 31))
+    if ((GetKeyState(VK_LWIN) | GetKeyState(VK_RWIN)) & 0x8000)
         mods |= GLFW_MOD_SUPER;
+    if (GetKeyState(VK_CAPITAL) & 1)
+        mods |= GLFW_MOD_CAPS_LOCK;
+    if (GetKeyState(VK_NUMLOCK) & 1)
+        mods |= GLFW_MOD_NUM_LOCK;
 
     return mods;
 }
@@ -402,14 +406,18 @@ static int getAsyncKeyMods(void)
 {
     int mods = 0;
 
-    if (GetAsyncKeyState(VK_SHIFT) & (1 << 31))
+    if (GetAsyncKeyState(VK_SHIFT) & 0x8000)
         mods |= GLFW_MOD_SHIFT;
-    if (GetAsyncKeyState(VK_CONTROL) & (1 << 31))
+    if (GetAsyncKeyState(VK_CONTROL) & 0x8000)
         mods |= GLFW_MOD_CONTROL;
-    if (GetAsyncKeyState(VK_MENU) & (1 << 31))
+    if (GetAsyncKeyState(VK_MENU) & 0x8000)
         mods |= GLFW_MOD_ALT;
-    if ((GetAsyncKeyState(VK_LWIN) | GetAsyncKeyState(VK_RWIN)) & (1 << 31))
+    if ((GetAsyncKeyState(VK_LWIN) | GetAsyncKeyState(VK_RWIN)) & 0x8000)
         mods |= GLFW_MOD_SUPER;
+    if (GetAsyncKeyState(VK_CAPITAL) & 1)
+        mods |= GLFW_MOD_CAPS_LOCK;
+    if (GetAsyncKeyState(VK_NUMLOCK) & 1)
+        mods |= GLFW_MOD_NUM_LOCK;
 
     return mods;
 }
@@ -988,6 +996,14 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
             return 0;
         }
 
+        case WM_DPICHANGED:
+        {
+            const float xscale = HIWORD(wParam) / 96.f;
+            const float yscale = LOWORD(wParam) / 96.f;
+            _glfwInputWindowContentScale(window, xscale, yscale);
+            break;
+        }
+
         case WM_SETCURSOR:
         {
             if (LOWORD(lParam) == HTCLIENT)
@@ -1443,7 +1459,7 @@ void _glfwPlatformMaximizeWindow(_GLFWwindow* window)
 
 void _glfwPlatformShowWindow(_GLFWwindow* window)
 {
-    ShowWindow(window->win32.handle, SW_SHOW);
+    ShowWindow(window->win32.handle, SW_SHOWNA);
 }
 
 void _glfwPlatformHideWindow(_GLFWwindow* window)
@@ -1567,6 +1583,11 @@ int _glfwPlatformWindowMaximized(_GLFWwindow* window)
     return IsZoomed(window->win32.handle);
 }
 
+int _glfwPlatformWindowHovered(_GLFWwindow* window)
+{
+    return cursorInClientArea(window);
+}
+
 int _glfwPlatformFramebufferTransparent(_GLFWwindow* window)
 {
     return window->win32.transparent && _glfwIsCompositionEnabledWin32();

glfw/window.c

@@ -94,6 +94,12 @@ void _glfwInputFramebufferSize(_GLFWwindow* window, int width, int height)
         window->callbacks.fbsize((GLFWwindow*) window, width, height);
 }
 
+void _glfwInputWindowContentScale(_GLFWwindow* window, float xscale, float yscale)
+{
+    if (window->callbacks.scale)
+        window->callbacks.scale((GLFWwindow*) window, xscale, yscale);
+}
+
 void _glfwInputWindowDamage(_GLFWwindow* window)
 {
     if (window->callbacks.refresh)
@@ -127,7 +133,6 @@ GLFWAPI GLFWwindow* glfwCreateWindow(int width, int height,
     _GLFWctxconfig ctxconfig;
     _GLFWwndconfig wndconfig;
     _GLFWwindow* window;
-    _GLFWwindow* previous;
 
     assert(title != NULL);
     assert(width >= 0);
@@ -191,33 +196,20 @@ GLFWAPI GLFWwindow* glfwCreateWindow(int width, int height,
     window->numer       = GLFW_DONT_CARE;
     window->denom       = GLFW_DONT_CARE;
 
-    // Save the currently current context so it can be restored later
-    previous = _glfwPlatformGetTls(&_glfw.contextSlot);
-    if (ctxconfig.client != GLFW_NO_API)
-        glfwMakeContextCurrent(NULL);
-
     // Open the actual window and create its context
     if (!_glfwPlatformCreateWindow(window, &wndconfig, &ctxconfig, &fbconfig))
     {
-        glfwMakeContextCurrent((GLFWwindow*) previous);
         glfwDestroyWindow((GLFWwindow*) window);
         return NULL;
     }
 
     if (ctxconfig.client != GLFW_NO_API)
     {
-        window->context.makeCurrent(window);
-
-        // Retrieve the actual (as opposed to requested) context attributes
-        if (!_glfwRefreshContextAttribs(&ctxconfig))
+        if (!_glfwRefreshContextAttribs(window, &ctxconfig))
         {
-            glfwMakeContextCurrent((GLFWwindow*) previous);
             glfwDestroyWindow((GLFWwindow*) window);
             return NULL;
         }
-
-        // Restore the previously current context (or NULL)
-        glfwMakeContextCurrent((GLFWwindow*) previous);
     }
 
     if (!window->monitor)
@@ -349,9 +341,6 @@ GLFWAPI void glfwWindowHint(int hint, int value)
         case GLFW_COCOA_RETINA_FRAMEBUFFER:
             _glfw.hints.window.ns.retina = value ? GLFW_TRUE : GLFW_FALSE;
             return;
-        case GLFW_COCOA_FRAME_AUTOSAVE:
-            _glfw.hints.window.ns.frame = value ? GLFW_TRUE : GLFW_FALSE;
-            return;
         case GLFW_COCOA_GRAPHICS_SWITCHING:
             _glfw.hints.context.nsgl.offline = value ? GLFW_TRUE : GLFW_FALSE;
             return;
@@ -396,6 +385,31 @@ GLFWAPI void glfwWindowHint(int hint, int value)
     _glfwInputError(GLFW_INVALID_ENUM, "Invalid window hint 0x%08X", hint);
 }
 
+GLFWAPI void glfwWindowHintString(int hint, const char* value)
+{
+    assert(value != NULL);
+
+    _GLFW_REQUIRE_INIT();
+
+    switch (hint)
+    {
+        case GLFW_COCOA_FRAME_NAME:
+            strncpy(_glfw.hints.window.ns.frameName, value,
+                    sizeof(_glfw.hints.window.ns.frameName) - 1);
+            return;
+        case GLFW_X11_CLASS_NAME:
+            strncpy(_glfw.hints.window.x11.className, value,
+                    sizeof(_glfw.hints.window.x11.className) - 1);
+            return;
+        case GLFW_X11_INSTANCE_NAME:
+            strncpy(_glfw.hints.window.x11.instanceName, value,
+                    sizeof(_glfw.hints.window.x11.instanceName) - 1);
+            return;
+    }
+
+    _glfwInputError(GLFW_INVALID_ENUM, "Invalid window hint string 0x%08X", hint);
+}
+
 GLFWAPI void glfwDestroyWindow(GLFWwindow* handle)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
@@ -781,6 +795,8 @@ GLFWAPI int glfwGetWindowAttrib(GLFWwindow* handle, int attrib)
             return _glfwPlatformWindowVisible(window);
         case GLFW_MAXIMIZED:
             return _glfwPlatformWindowMaximized(window);
+        case GLFW_HOVERED:
+            return _glfwPlatformWindowHovered(window);
         case GLFW_TRANSPARENT_FRAMEBUFFER:
             return _glfwPlatformFramebufferTransparent(window);
         case GLFW_RESIZABLE:
@@ -1015,6 +1031,17 @@ GLFWAPI GLFWframebuffersizefun glfwSetFramebufferSizeCallback(GLFWwindow* handle
     return cbfun;
 }
 
+GLFWAPI GLFWwindowcontentscalefun glfwSetWindowContentScaleCallback(GLFWwindow* handle,
+                                                                    GLFWwindowcontentscalefun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.scale, cbfun);
+    return cbfun;
+}
+
 GLFWAPI void glfwPollEvents(void)
 {
     _GLFW_REQUIRE_INIT();

glfw/wl_init.c

@@ -54,6 +54,8 @@ static void pointerHandleEnter(void* data,
     _glfw.wl.pointerSerial = serial;
     _glfw.wl.pointerFocus = window;
 
+    window->wl.hovered = GLFW_TRUE;
+
     _glfwPlatformSetCursor(window, window->wl.currentCursor);
     _glfwInputCursorEnter(window, GLFW_TRUE);
 }
@@ -68,6 +70,8 @@ static void pointerHandleLeave(void* data,
     if (!window)
         return;
 
+    window->wl.hovered = GLFW_FALSE;
+
     _glfw.wl.pointerSerial = serial;
     _glfw.wl.pointerFocus = NULL;
     _glfwInputCursorEnter(window, GLFW_FALSE);
@@ -132,11 +136,14 @@ static void pointerHandleAxis(void* data,
 {
     _GLFWwindow* window = _glfw.wl.pointerFocus;
     double scrollFactor;
-    double x = 0.0, y = 0.0;
+    double x = 0, y = 0;
 
     if (!window)
         return;
 
+    assert(axis == WL_POINTER_AXIS_HORIZONTAL_SCROLL ||
+           axis == WL_POINTER_AXIS_VERTICAL_SCROLL);
+
     /* Wayland scroll events are in pointer motion coordinate space (think
      * two finger scroll). The factor 10 is commonly used to convert to
      * "scroll step means 1.0. */
@@ -152,9 +159,6 @@ static void pointerHandleAxis(void* data,
             x = 0.0;
             y = wl_fixed_to_double(value) * scrollFactor;
             break;
-        default:
-            assert(GLFW_FALSE);
-            break;
     }
 
     _glfwInputScroll(window, x, y);
@@ -264,6 +268,10 @@ static void keyboardHandleKeymap(void* data,
         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,
@@ -409,6 +417,10 @@ static void keyboardHandleModifiers(void* data,
         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;
 }
 
@@ -763,15 +775,22 @@ void _glfwPlatformTerminate(void)
     _glfwTerminateJoysticksLinux();
 
 #ifdef HAVE_XKBCOMMON_COMPOSE_H
-    xkb_compose_state_unref(_glfw.wl.xkb.composeState);
+    if (_glfw.wl.xkb.composeState)
+        xkb_compose_state_unref(_glfw.wl.xkb.composeState);
 #endif
 
-    xkb_keymap_unref(_glfw.wl.xkb.keymap);
-    xkb_state_unref(_glfw.wl.xkb.state);
-    xkb_context_unref(_glfw.wl.xkb.context);
+    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);
 
-    dlclose(_glfw.wl.xkb.handle);
-    _glfw.wl.xkb.handle = NULL;
+    if (_glfw.wl.xkb.handle)
+    {
+        _glfw_dlclose(_glfw.wl.xkb.handle);
+        _glfw.wl.xkb.handle = NULL;
+    }
 
     if (_glfw.wl.cursorTheme)
         wl_cursor_theme_destroy(_glfw.wl.cursorTheme);
@@ -818,4 +837,3 @@ const char* _glfwPlatformGetVersionString(void)
 #endif
         ;
 }
-

glfw/wl_platform.h

@@ -117,6 +117,7 @@ typedef struct _GLFWwindowWayland
     int                         width, height;
     GLFWbool                    visible;
     GLFWbool                    maximized;
+    GLFWbool                    hovered;
     GLFWbool                    transparent;
     struct wl_surface*          surface;
     struct wl_egl_window*       native;
@@ -183,6 +184,8 @@ typedef struct _GLFWlibraryWayland
         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;

glfw/wl_window.c

@@ -125,6 +125,7 @@ static void checkScaleChange(_GLFWwindow* window)
         wl_surface_set_buffer_scale(window->wl.surface, scale);
         wl_egl_window_resize(window->wl.native, scaledWidth, scaledHeight, 0, 0);
         _glfwInputFramebufferSize(window, scaledWidth, scaledHeight);
+        _glfwInputWindowContentScale(window, scale, scale);
     }
 }
 
@@ -700,6 +701,11 @@ int _glfwPlatformWindowMaximized(_GLFWwindow* window)
     return window->wl.maximized;
 }
 
+int _glfwPlatformWindowHovered(_GLFWwindow* window)
+{
+    return window->wl.hovered;
+}
+
 int _glfwPlatformFramebufferTransparent(_GLFWwindow* window)
 {
     return window->wl.transparent;

glfw/x11_window.c

@@ -212,6 +212,10 @@ static int translateState(int state)
         mods |= GLFW_MOD_ALT;
     if (state & Mod4Mask)
         mods |= GLFW_MOD_SUPER;
+    if (state & LockMask)
+        mods |= GLFW_MOD_CAPS_LOCK;
+    if (state & Mod2Mask)
+        mods |= GLFW_MOD_NUM_LOCK;
 
     return mods;
 }
@@ -703,49 +707,34 @@ static GLFWbool createNativeWindow(_GLFWwindow* window,
 
     updateNormalHints(window, wndconfig->width, wndconfig->height);
 
-    // Set ICCCM WM_CLASS property and window title
+    // Set ICCCM WM_CLASS property
     {
         XClassHint* hint = XAllocClassHint();
-        char *wm_cclass = NULL, *wm_cname = NULL;
-        const char *real_title = wndconfig->title;
 
-        if (strlen(_glfw.hints.init.x11.className) &&
-            strlen(_glfw.hints.init.x11.classClass))
+        if (strlen(wndconfig->x11.instanceName) &&
+            strlen(wndconfig->x11.className))
         {
-            hint->res_name = (char*) _glfw.hints.init.x11.className;
-            hint->res_class = (char*) _glfw.hints.init.x11.classClass;
-        }
-        else if (strlen(real_title))
-        {
-            if (*real_title == 1) {
-                char *p = strchr(real_title, 30);
-                if (p && p > real_title + 1) {
-                    wm_cname = calloc(p - real_title + 1, 1);
-                    if (wm_cname) memcpy(wm_cname, real_title + 1, p - real_title - 1);
-                    hint->res_name = wm_cname;
-                    char *q = strchr(p + 1, 30);
-                    if (q && q > p + 1) {
-                        wm_cclass = calloc(q - p + 1, 1);
-                        if (wm_cclass) memcpy(wm_cclass, p + 1, q - p - 1);
-                        hint->res_class = wm_cclass;
-                        real_title = q + 1;
-                    }
-                }
-            } else {
-                hint->res_name = (char*) real_title;
-                hint->res_class = (char*) real_title;
-            }
+            hint->res_name = (char*) wndconfig->x11.instanceName;
+            hint->res_class = (char*) wndconfig->x11.className;
         }
         else
         {
-            hint->res_name = (char*) "glfw-application";
-            hint->res_class = (char*) "GLFW-Application";
+            const char* resourceName = getenv("RESOURCE_NAME");
+            if (resourceName && strlen(resourceName))
+                hint->res_name = (char*) resourceName;
+            else if (strlen(wndconfig->title))
+                hint->res_name = (char*) wndconfig->title;
+            else
+                hint->res_name = (char*) "glfw-application";
+
+            if (strlen(wndconfig->title))
+                hint->res_class = (char*) wndconfig->title;
+            else
+                hint->res_class = (char*) "GLFW-Application";
         }
 
         XSetClassHint(_glfw.x11.display, window->x11.handle, hint);
         XFree(hint);
-        free(wm_cclass); free(wm_cname);
-        _glfwPlatformSetWindowTitle(window, real_title);
     }
 
     // Announce support for Xdnd (drag and drop)
@@ -756,6 +745,7 @@ static GLFWbool createNativeWindow(_GLFWwindow* window,
                         PropModeReplace, (unsigned char*) &version, 1);
     }
 
+    _glfwPlatformSetWindowTitle(window, wndconfig->title);
 
     if (_glfw.x11.im)
     {
@@ -2468,6 +2458,28 @@ int _glfwPlatformWindowMaximized(_GLFWwindow* window)
     return maximized;
 }
 
+int _glfwPlatformWindowHovered(_GLFWwindow* window)
+{
+    Window w = _glfw.x11.root;
+    while (w)
+    {
+        Window root;
+        int rootX, rootY, childX, childY;
+        unsigned int mask;
+
+        if (!XQueryPointer(_glfw.x11.display, w,
+                           &root, &w, &rootX, &rootY, &childX, &childY, &mask))
+        {
+            return GLFW_FALSE;
+        }
+
+        if (w == window->x11.handle)
+            return GLFW_TRUE;
+    }
+
+    return GLFW_FALSE;
+}
+
 int _glfwPlatformFramebufferTransparent(_GLFWwindow* window)
 {
     if (!window->x11.transparent)

graphics-protocol.asciidoc

@@ -8,7 +8,7 @@ to render arbitrary pixel (raster) graphics to the screen of the terminal
 emulator. The major design goals are
 
  * Should not require terminal emulators to understand image formats.
- * Should allow specifying graphics to be drawn at individual pixel positions. 
+ * Should allow specifying graphics to be drawn at individual pixel positions.
  * The graphics should integrate with the text, in particular it should be possible to draw graphics
    below as well as above the text, with alpha blending. The graphics should also scroll with the text, automatically.
  * Should use optimizations when the client is running on the same computer as the terminal emulator.
@@ -21,7 +21,7 @@ To see a quick demo, inside a kitty terminal run:
 kitty icat path/to/some/image.png
 ```
 
-You can also see a screenshot with more sophisticated features such as alpha-blending and text over graphics 
+You can also see a screenshot with more sophisticated features such as alpha-blending and text over graphics
 link:https://github.com/kovidgoyal/kitty/issues/33#issuecomment-334436100[here].
 
 toc::[]
@@ -33,7 +33,7 @@ window size in pixels and the number of cells per row and column. This can be do
 Some C code to demonstrate its use
 
 ```C
-struct ttysize ts; 
+struct ttysize ts;
 ioctl(0, TIOCGWINSZ, &ts);
 printf("number of columns: %i, number of rows: %i, screen width: %i, screen height: %i\n", sz.ws_col, sz.ws_row, sz.ws_xpixel, sz.ws_ypixel);
 ```
@@ -50,7 +50,7 @@ All graphics escape codes are of the form:
 ```
 
 This is a so-called _Application Programming Command (APC)_. Most terminal
-emulators ignore APC codes, making it safe to use.  
+emulators ignore APC codes, making it safe to use.
 
 The control data is a comma-separated list of `key=value` pairs.  The payload
 is arbitrary binary data, base64-encoded to prevent interoperation problems
@@ -124,12 +124,12 @@ The transmission medium is specified using the `t` key. The `t` key defaults to
 and can take the values:
 
 |===
-| Value of `t` | Meaning 
+| Value of `t` | Meaning
 
 | d | Direct (the data is transmitted within the escape code itself)
 | f | A simple file
 | t | A temporary file, the terminal emulator will delete the file after reading the pixel data
-| s | A http://man7.org/linux/man-pages/man7/shm_overview.7.html[POSIX shared memory object]. The terminal emulator will delete it after reading the pixel data 
+| s | A http://man7.org/linux/man-pages/man7/shm_overview.7.html[POSIX shared memory object]. The terminal emulator will delete it after reading the pixel data
 |===
 
 ==== Local client
@@ -175,9 +175,9 @@ if the data is split into three chunks, the client would send the following
 sequence of escape codes to the terminal emulator:
 
 ```
-<ESC>_Gs=100,v=30,m=1;<encoded pixel data first chunk><ESC>\                  
-<ESC>_Gm=1;<encoded pixel data second chunk><ESC>\                  
-<ESC>_Gm=0;<encoded pixel data last chunk><ESC>\                  
+<ESC>_Gs=100,v=30,m=1;<encoded pixel data first chunk><ESC>\
+<ESC>_Gm=1;<encoded pixel data second chunk><ESC>\
+<ESC>_Gm=0;<encoded pixel data last chunk><ESC>\
 ```
 
 Note that only the first escape code needs to have the full set of control
@@ -189,7 +189,7 @@ before sending any other graphics related escape codes.
 === Detecting available transmission mediums
 
 Since a client has no a-priori knowledge of whether it shares a filesystem/shared memory
-with the terminal emulator, it can send an id with the control data, using the `i` key 
+with the terminal emulator, it can send an id with the control data, using the `i` key
 (which can be an arbitrary positive integer up to 4294967295, it must not be zero).
 If it does so, the terminal emulator will reply after trying to load the image, saying
 whether loading was successful or not. For example:
@@ -207,7 +207,7 @@ to which the terminal emulator will reply (after trying to load the data):
 Here the `i` value will be the same as was sent by the client in the original
 request.  The message data will be a ASCII encoded string containing only
 printable characters and spaces. The string will be `OK` if reading the pixel
-data succeeded or an error message. 
+data succeeded or an error message.
 
 Sometimes, using an id is not appropriate, for example, if you do not want to
 replace a previously sent image with the same id, or if you are sending a dummy
@@ -245,7 +245,7 @@ be re-transmitted.
 === Controlling displayed image layout
 
 The image is rendered at the current cursor position, from the upper left corner of
-the current cell. You can also specify extra `X=3` and `Y=4` pixel offsets to display from 
+the current cell. You can also specify extra `X=3` and `Y=4` pixel offsets to display from
 a different origin within the cell. Note that the offsets must be smaller that the size of the cell.
 
 By default, the entire image will be displayed (images wider than the available
@@ -255,7 +255,7 @@ the top-left corner, width and height of the source rectangle.
 
 You can also ask the terminal emulator to display the image in a specified rectangle
 (num of columns / num of lines), using the control codes `c,r`. `c` is the number of columns
-and `r` the number of rows. The image will be scaled (enlarged/shrunk) as needed to fit 
+and `r` the number of rows. The image will be scaled (enlarged/shrunk) as needed to fit
 the specified area. Note that if you specify a start cell offset via the `X,Y` keys, it is not
 added to the number of rows/columns.
 
@@ -269,7 +269,7 @@ allows rendering of text on top of images.
 
 Images can be deleted by using the delete action `a=d`. If specified without any
 other keys, it will delete all images visible on screen. To delete specific images,
-use the `d` key as described in the table below. Note that each value of d has 
+use the `d` key as described in the table below. Note that each value of d has
 both a lowercase and an uppercase variant. The lowercase variant only deletes the
 images without necessarily freeing up the stored image data, so that the images can be
 re-displayed without needing to resend the data. The uppercase variants will delete
@@ -278,7 +278,7 @@ scrollback buffer. The values of the `x` and `y` keys are the same as cursor pos
 x=1, y=1 is the top left cell).
 
 |===
-| Value of `d` | Meaning 
+| Value of `d` | Meaning
 
 | `a` or `A` | Delete all images visible on screen
 | `i` or `I` | Delete all images with the specified id, specified using the `i` key.
@@ -313,7 +313,7 @@ delete older images to make space for the new one.
 == Control data reference
 
 The table below shows all the control data keys as well as what values they can
-take, and the default value they take when missing. All integers are 32-bit. 
+take, and the default value they take when missing. All integers are 32-bit.
 
 [cols="^1,<3,^1,<6"]
 |===

kitty/blit_vertex.glsl

@@ -5,10 +5,10 @@
 #define bottom  -1.0f
 
 const vec2 pos_map[] = vec2[4](
-    vec2(right, top),  
-    vec2(right, bottom),  
-    vec2(left, bottom),  
-    vec2(left, top)   
+    vec2(right, top),
+    vec2(right, bottom),
+    vec2(left, bottom),
+    vec2(left, top)
 );
 
 out vec2 texcoord;

kitty/border_vertex.glsl

@@ -11,10 +11,10 @@ const int RIGHT = 2;
 const int BOTTOM = 3;
 
 const uvec2 pos_map[] = uvec2[4](
-    uvec2(RIGHT, TOP),  
-    uvec2(RIGHT, BOTTOM),  
-    uvec2(LEFT, BOTTOM),  
-    uvec2(LEFT, TOP)   
+    uvec2(RIGHT, TOP),
+    uvec2(RIGHT, BOTTOM),
+    uvec2(LEFT, BOTTOM),
+    uvec2(LEFT, TOP)
 );
 
 vec2 to_opengl(uint x, uint y) {

kitty/boss.py

@@ -2,26 +2,28 @@
 # vim:fileencoding=utf-8
 # License: GPL v3 Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
 
+import re
 from gettext import gettext as _
 from weakref import WeakValueDictionary
 
 from .cli import create_opts, parse_args
 from .config import MINIMUM_FONT_SIZE, cached_values, initial_window_size
-from .constants import set_boss, wakeup
+from .constants import appname, set_boss, wakeup
 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,
-    layout_sprite_map, mark_os_window_for_close, show_window,
-    toggle_fullscreen, viewport_for_window
+    layout_sprite_map, mark_os_window_for_close, set_clipboard_string,
+    set_dpi_from_os_window, show_window, toggle_fullscreen,
+    viewport_for_window
 )
 from .fonts.render import prerender, resize_fonts, set_font_family
 from .keys import get_shortcut
+from .remote_control import handle_cmd
 from .session import create_session
-from .tabs import SpecialWindow, TabManager
+from .tabs import SpecialWindow, SpecialWindowInstance, TabManager
 from .utils import (
-    encode_wm_class, end_startup_notification, get_primary_selection,
-    init_startup_notification, open_url, safe_print, set_primary_selection,
-    single_instance
+    end_startup_notification, get_primary_selection, init_startup_notification,
+    open_url, safe_print, set_primary_selection, single_instance
 )
 
 
@@ -79,18 +81,84 @@ class Boss:
         startup_session = create_session(opts, args)
         self.add_os_window(startup_session, os_window_id=os_window_id)
 
-    def add_os_window(self, startup_session, os_window_id=None, wclass=None, wname=None, size=None, visible=True):
+    def add_os_window(self, startup_session, os_window_id=None, wclass=None, wname=None, size=None, startup_id=None):
+        dpi_changed = False
         if os_window_id is None:
             w, h = initial_window_size(self.opts) if size is None else size
-            os_window_id = create_os_window(w, h, encode_wm_class(wname or self.args.name, wclass or self.args.cls), visible)
+            cls = wclass or self.args.cls or appname
+            os_window_id = create_os_window(w, h, appname, wname or self.args.name or cls, cls)
+            if startup_id:
+                ctx = init_startup_notification(os_window_id, startup_id)
+            dpi_changed = show_window(os_window_id)
+            if startup_id:
+                end_startup_notification(ctx)
         tm = TabManager(os_window_id, self.opts, self.args, startup_session)
         self.os_window_map[os_window_id] = tm
-        return os_window_id
+        if dpi_changed:
+            self.on_dpi_change(os_window_id)
+
+    def list_os_windows(self):
+        for os_window_id, tm in self.os_window_map.items():
+            yield {
+                'id': os_window_id,
+                'tabs': list(tm.list_tabs()),
+            }
+
+    def match_windows(self, match):
+        field, exp = match.split(':', 1)
+        pat = re.compile(exp)
+        for tm in self.os_window_map.values():
+            for tab in tm:
+                for window in tab:
+                    if window.matches(field, pat):
+                        yield window
+
+    def tab_for_window(self, window):
+        for tm in self.os_window_map.values():
+            for tab in tm:
+                for w in tab:
+                    if w.id == window.id:
+                        return tab
+
+    def match_tabs(self, match):
+        field, exp = match.split(':', 1)
+        pat = re.compile(exp)
+        tms = tuple(self.os_window_map.values())
+        found = False
+        if field in ('title', 'id'):
+            for tm in tms:
+                for tab in tm:
+                    if tab.matches(field, pat):
+                        yield tab
+                        found = True
+        if not found:
+            tabs = {self.tab_for_window(w) for w in self.match_windows(match)}
+            for tab in tabs:
+                if tab:
+                    yield tab
+
+    def set_active_window(self, window):
+        for tm in self.os_window_map.values():
+            for tab in tm:
+                for w in tab:
+                    if w.id == window.id:
+                        if tab is not self.active_tab:
+                            tm.set_active_tab(tab)
+                        tab.set_active_window(w)
+                        return
+
+    def _new_os_window(self, args, cwd_from=None):
+        sw = self.args_to_special_window(args, cwd_from) if args else None
+        startup_session = create_session(self.opts, special_window=sw, cwd_from=cwd_from)
+        self.add_os_window(startup_session)
 
     def new_os_window(self, *args):
-        sw = self.args_to_special_window(args) if args else None
-        startup_session = create_session(self.opts, special_window=sw)
-        return self.add_os_window(startup_session)
+        self._new_os_window(args)
+
+    def new_os_window_with_cwd(self, *args):
+        w = self.active_window
+        cwd_from = w.child.pid if w is not None else None
+        self._new_os_window(args, cwd_from)
 
     def add_child(self, window):
         self.child_monitor.add_child(window.id, window.child.pid, window.child.child_fd, window.screen)
@@ -106,15 +174,24 @@ class Boss:
                 args.args = rest
                 opts = create_opts(args)
                 session = create_session(opts, args)
-                os_window_id = self.add_os_window(session, wclass=args.cls, wname=args.name, size=initial_window_size(opts), visible=False)
-                if startup_id:
-                    ctx = init_startup_notification(os_window_id, startup_id)
-                show_window(os_window_id)
-                if startup_id:
-                    end_startup_notification(ctx)
+                self.add_os_window(session, wclass=args.cls, wname=args.name, size=initial_window_size(opts), startup_id=startup_id)
             else:
                 safe_print('Unknown message received from peer, ignoring')
 
+    def handle_remote_cmd(self, cmd, window=None):
+        response = None
+        if self.opts.allow_remote_control:
+            try:
+                response = handle_cmd(self, window, cmd)
+            except Exception as err:
+                import traceback
+                response = {'ok': False, 'error': str(err), 'tb': traceback.format_exc()}
+        else:
+            response = {'ok': False, 'error': 'Remote control is disabled. Add allow_remote_control yes to your kitty.conf'}
+        if response is not None:
+            if window is not None:
+                window.send_cmd_response(response)
+
     def on_child_death(self, window_id):
         window = self.window_id_map.pop(window_id, None)
         if window is None:
@@ -162,10 +239,16 @@ class Boss:
         if tm is not None:
             tm.activate_tab_at(x)
 
-    def on_window_resize(self, os_window_id, w, h):
+    def on_window_resize(self, os_window_id, w, h, dpi_changed):
         tm = self.os_window_map.get(os_window_id)
         if tm is not None:
-            tm.resize()
+            if dpi_changed:
+                if set_dpi_from_os_window(os_window_id):
+                    self.on_dpi_change(os_window_id)
+                else:
+                    tm.resize()
+            else:
+                tm.resize()
 
     def increase_font_size(self):
         self.change_font_size(
@@ -182,10 +265,9 @@ class Boss:
     def restore_font_size(self):
         self.change_font_size(self.opts.font_size)
 
-    def change_font_size(self, new_size):
-        if new_size == self.current_font_size:
-            return
-        self.current_font_size = new_size
+    def _change_font_size(self, new_size=None):
+        if new_size is not None:
+            self.current_font_size = new_size
         old_cell_width, old_cell_height = viewport_for_window()[-2:]
         windows = tuple(filter(None, self.window_id_map.values()))
         resize_fonts(self.current_font_size)
@@ -199,6 +281,14 @@ class Boss:
             tm.refresh_sprite_positions()
         glfw_post_empty_event()
 
+    def change_font_size(self, new_size):
+        if new_size == self.current_font_size:
+            return
+        self._change_font_size(new_size)
+
+    def on_dpi_change(self, os_window_id):
+        self._change_font_size()
+
     @property
     def active_tab_manager(self):
         os_window_id = current_os_window()
@@ -326,6 +416,8 @@ class Boss:
             text = w.text_for_selection()
             if text:
                 set_primary_selection(text)
+                if self.opts.copy_on_select:
+                    set_clipboard_string(text)
 
     def goto_tab(self, tab_num):
         tm = self.active_tab_manager
@@ -342,7 +434,7 @@ class Boss:
         if tm is not None:
             tm.next_tab(-1)
 
-    def args_to_special_window(self, args):
+    def args_to_special_window(self, args, cwd_from=None):
         args = list(args)
         stdin = None
         w = self.active_window
@@ -368,23 +460,42 @@ class Boss:
                 if not arg:
                     continue
             cmd.append(arg)
-        return SpecialWindow(cmd, stdin)
+        return SpecialWindow(cmd, stdin, cwd_from=cwd_from)
 
-    def new_tab(self, *args):
+    def _new_tab(self, args, cwd_from=None):
         special_window = None
         if args:
-            special_window = self.args_to_special_window(args)
+            if isinstance(args, SpecialWindowInstance):
+                special_window = args
+            else:
+                special_window = self.args_to_special_window(args, cwd_from=cwd_from)
         tm = self.active_tab_manager
         if tm is not None:
-            tm.new_tab(special_window=special_window)
+            tm.new_tab(special_window=special_window, cwd_from=cwd_from)
 
-    def new_window(self, *args):
+    def new_tab(self, *args):
+        self._new_tab(args)
+
+    def new_tab_with_cwd(self, *args):
+        w = self.active_window
+        cwd_from = w.child.pid if w is not None else None
+        self._new_tab(args, cwd_from=cwd_from)
+
+    def _new_window(self, args, cwd_from=None):
         tab = self.active_tab
         if tab is not None:
             if args:
-                tab.new_special_window(self.args_to_special_window(args))
+                tab.new_special_window(self.args_to_special_window(args, cwd_from=cwd_from))
             else:
-                tab.new_window()
+                tab.new_window(cwd_from=cwd_from)
+
+    def new_window(self, *args):
+        self._new_window(args)
+
+    def new_window_with_cwd(self, *args):
+        w = self.active_window
+        cwd_from = w.child.pid if w is not None else None
+        self._new_window(args, cwd_from=cwd_from)
 
     def move_tab_forward(self):
         tm = self.active_tab_manager

kitty/cell_fragment.glsl

@@ -19,6 +19,7 @@ in float bg_alpha;
 
 #ifdef NEEDS_FOREGROUND
 uniform sampler2DArray sprites;
+uniform float inactive_text_alpha;
 in vec3 sprite_pos;
 in vec3 underline_pos;
 in vec3 strike_pos;
@@ -34,7 +35,7 @@ vec4 alpha_blend(vec3 over, float over_alpha, vec3 under, float under_alpha) {
     // Alpha blend two colors returning the resulting color pre-multiplied by its alpha
     // and its alpha.
     // See https://en.wikipedia.org/wiki/Alpha_compositing
-    float alpha = mix(under_alpha, 1.0f, over_alpha);  
+    float alpha = mix(under_alpha, 1.0f, over_alpha);
     vec3 combined_color = mix(under * under_alpha, over, over_alpha);
     return vec4(combined_color, alpha);
 }
@@ -45,7 +46,7 @@ vec3 premul_blend(vec3 over, float over_alpha, vec3 under) {
 
 vec4 alpha_blend_premul(vec3 over, float over_alpha, vec3 under, float under_alpha) {
     // Same as alpha_blend() except that it assumes over and under are both premultiplied.
-    float alpha = mix(under_alpha, 1.0f, over_alpha);  
+    float alpha = mix(under_alpha, 1.0f, over_alpha);
     return vec4(premul_blend(over, over_alpha, under), alpha);
 }
 // }}}
@@ -60,7 +61,7 @@ vec4 calculate_foreground() {
     // Since strike and text are the same color, we simply add the alpha values
     float combined_alpha = min(text_alpha + strike_alpha, 1.0f);
     // Underline color might be different, so alpha blend
-    return alpha_blend(decoration_fg, underline_alpha, fg, combined_alpha);
+    return alpha_blend(decoration_fg, underline_alpha * inactive_text_alpha, fg, combined_alpha * inactive_text_alpha);
 }
 #endif
 
@@ -70,7 +71,7 @@ void main() {
     final_color = vec4(background.rgb * bg_alpha, bg_alpha);
 #else
     final_color = vec4(background.rgb, 1.0f);
-#endif 
+#endif
 #endif
 
 #ifdef SPECIAL
@@ -78,10 +79,10 @@ void main() {
     final_color = vec4(background.rgb * bg_alpha, bg_alpha);
 #else
     final_color = vec4(background.rgb, bg_alpha);
-#endif 
+#endif
 #endif
 
-#if defined(FOREGROUND) || defined(SIMPLE) 
+#if defined(FOREGROUND) || defined(SIMPLE)
     // FOREGROUND or SIMPLE
     vec4 fg = calculate_foreground();  // pre-multiplied foreground
 
@@ -99,7 +100,7 @@ void main() {
     final_color = alpha_blend_premul(fg.rgb, fg.a, background * bg_alpha, bg_alpha);
     final_color = vec4(final_color.rgb / final_color.a, final_color.a);
 #else
-    // since background alpha is 1.0, it is effectively premultipled
+    // since background alpha is 1.0, it is effectively pre-multiplied
     final_color = vec4(premul_blend(fg.rgb, fg.a, background), 1.0f);
     final_color = vec4(final_color.rgb / final_color.a, final_color.a);
 #endif

kitty/cell_vertex.glsl

@@ -12,7 +12,7 @@ layout(std140) uniform CellRenderData {
 
     uint xnum, ynum, cursor_x, cursor_y, cursor_w;
 
-    uint color_table[256]; 
+    uint color_table[256];
 };
 
 // Have to use fixed locations here as all variants of the cell program share the same VAO
@@ -21,7 +21,7 @@ layout(location=1) in uvec4 sprite_coords;
 layout(location=2) in uint is_selected;
 
 
-    
+
 const uvec2 cell_pos_map[] = uvec2[4](
     uvec2(1, 0),  // right, top
     uvec2(1, 1),  // right, bottom
@@ -118,27 +118,27 @@ float is_cursor(uint x, uint y) {
 void main() {
 
     // set cell vertex position  {{{
-    uint instance_id = uint(gl_InstanceID); 
+    uint instance_id = uint(gl_InstanceID);
     /* The current cell being rendered */
-    uint r = instance_id / xnum; 
-    uint c = instance_id - r * xnum; 
+    uint r = instance_id / xnum;
+    uint c = instance_id - r * xnum;
 
-    /* The position of this vertex, at a corner of the cell  */ 
-    float left = xstart + c * dx; 
-    float top = ystart - r * dy; 
-    vec2 xpos = vec2(left, left + dx); 
-    vec2 ypos = vec2(top, top - dy); 
-    uvec2 pos = cell_pos_map[gl_VertexID]; 
+    /* The position of this vertex, at a corner of the cell  */
+    float left = xstart + c * dx;
+    float top = ystart - r * dy;
+    vec2 xpos = vec2(left, left + dx);
+    vec2 ypos = vec2(top, top - dy);
+    uvec2 pos = cell_pos_map[gl_VertexID];
     gl_Position = vec4(xpos[pos.x], ypos[pos.y], 0, 1);
 
     // }}}
-    
+
     // 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]; 
+    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];
     float cursor = is_cursor(c, r);
     vec3 bg = to_color(colors[bg_index], default_colors[bg_index]);
     // }}}
@@ -150,7 +150,7 @@ void main() {
     sprite_pos = to_sprite_pos(pos, sprite_coords.x, sprite_coords.y, sprite_coords.z & Z_MASK);
     colored_sprite = float((sprite_coords.z & COLOR_MASK) >> 14);
 
-    // Foreground 
+    // Foreground
     uint resolved_fg = resolve_color(colors[fg_index], default_colors[fg_index]);
     foreground = color_to_vec(resolved_fg);
     // Selection
@@ -165,7 +165,7 @@ void main() {
     foreground = choose_color(cursor, bg, foreground);
     decoration_fg = choose_color(cursor, bg, decoration_fg);
 #endif
-    // }}} 
+    // }}}
 
     // Background {{{
 #ifdef NEEDS_BACKROUND

kitty/charsets.c

@@ -43,7 +43,7 @@ static uint32_t charset_translations[5][256] = {
     0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
     0x00f0, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7,
     0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x00ff
-  }, 
+  },
   /* VT100 graphics mapped to Unicode */
   {
     0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
@@ -81,7 +81,7 @@ static uint32_t charset_translations[5][256] = {
   },
   /* IBM Codepage 437 mapped to Unicode */
   {
-    0x0000, 0x263a, 0x263b, 0x2665, 0x2666, 0x2663, 0x2660, 0x2022, 
+    0x0000, 0x263a, 0x263b, 0x2665, 0x2666, 0x2663, 0x2660, 0x2022,
     0x25d8, 0x25cb, 0x25d9, 0x2642, 0x2640, 0x266a, 0x266b, 0x263c,
     0x25b6, 0x25c0, 0x2195, 0x203c, 0x00b6, 0x00a7, 0x25ac, 0x21a8,
     0x2191, 0x2193, 0x2192, 0x2190, 0x221f, 0x2194, 0x25b2, 0x25bc,
@@ -113,7 +113,7 @@ static uint32_t charset_translations[5][256] = {
     0x03a6, 0x0398, 0x03a9, 0x03b4, 0x221e, 0x03c6, 0x03b5, 0x2229,
     0x2261, 0x00b1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00f7, 0x2248,
     0x00b0, 0x2219, 0x00b7, 0x221a, 0x207f, 0x00b2, 0x25a0, 0x00a0
-  }, 
+  },
   // VAX 42 map
   {
     0x0000, 0x263a, 0x263b, 0x2665, 0x2666, 0x2663, 0x2660, 0x2022,
@@ -183,13 +183,13 @@ static uint32_t charset_translations[5][256] = {
     0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
     0x00f0, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7,
     0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x00ff
-  }, 
+  },
 
 };
 
-uint32_t* 
+uint32_t*
 translation_table(uint32_t which) {
-    switch(which){ 
+    switch(which){
         case 'B':
             return charset_translations[0];
         case '0':
@@ -208,7 +208,7 @@ translation_table(uint32_t which) {
 uint32_t *latin1_charset = charset_translations[0];
 
 // UTF-8 decode taken from: http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
- 
+
 static const uint8_t utf8_data[] = {
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 00..1f
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 20..3f
@@ -226,7 +226,7 @@ static const uint8_t utf8_data[] = {
   1,3,1,1,1,1,1,3,1,3,1,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // s7..s8
 };
 
-uint32_t 
+uint32_t
 decode_utf8(uint32_t* state, uint32_t* codep, uint8_t byte) {
   uint32_t type = utf8_data[byte];
 
@@ -278,7 +278,7 @@ base64_decode(const uint32_t *src, size_t src_sz, uint8_t *dest, size_t dest_cap
     if (!src_sz) { *dest_sz = 0; return NULL; }
     if (src_sz % 4 != 0) return "base64 encoded data must have a length that is a multiple of four";
     *dest_sz = (src_sz / 4) * 3;
-    if (src[src_sz - 1] == '=') (*dest_sz)--; 
+    if (src[src_sz - 1] == '=') (*dest_sz)--;
     if (src[src_sz - 2] == '=') (*dest_sz)--;
     if (*dest_sz > dest_capacity) return "output buffer too small";
     for (size_t i = 0, j = 0; i < src_sz;) {

kitty/child-monitor.c

@@ -95,7 +95,7 @@ set_thread_name(const char *name) {
 #define FREE_CHILD(x) \
     Py_CLEAR((x).screen); x = EMPTY_CHILD;
 
-#define XREF_CHILD(x, OP) OP(x.screen); 
+#define XREF_CHILD(x, OP) OP(x.screen);
 #define INCREF_CHILD(x) XREF_CHILD(x, Py_INCREF)
 #define DECREF_CHILD(x) XREF_CHILD(x, Py_DECREF)
 
@@ -138,12 +138,12 @@ self_pipe(int fds[2]) {
 static PyObject *
 new(PyTypeObject *type, PyObject *args, PyObject UNUSED *kwds) {
     ChildMonitor *self;
-    PyObject *dump_callback, *death_notify; 
+    PyObject *dump_callback, *death_notify;
     int talk_fd = -1;
     int ret;
 
     if (the_monitor) { PyErr_SetString(PyExc_RuntimeError, "Can have only a single ChildMonitor instance"); return NULL; }
-    if (!PyArg_ParseTuple(args, "OO|i", &death_notify, &dump_callback, &talk_fd)) return NULL; 
+    if (!PyArg_ParseTuple(args, "OO|i", &death_notify, &dump_callback, &talk_fd)) return NULL;
     if ((ret = pthread_mutex_init(&children_lock, NULL)) != 0) {
         PyErr_Format(PyExc_RuntimeError, "Failed to create children_lock mutex: %s", strerror(ret));
         return NULL;
@@ -163,7 +163,7 @@ new(PyTypeObject *type, PyObject *args, PyObject UNUSED *kwds) {
         self->dump_callback = dump_callback; Py_INCREF(dump_callback);
         parse_func = parse_worker_dump;
     } else parse_func = parse_worker;
-    self->count = 0; 
+    self->count = 0;
     fds[0].fd = wakeup_fds[0]; fds[1].fd = signal_fds[0];
     fds[0].events = POLLIN; fds[1].events = POLLIN;
     the_monitor = self;
@@ -187,7 +187,7 @@ dealloc(ChildMonitor* self) {
     }
     close(wakeup_fds[0]);
     close(wakeup_fds[1]);
-    close(signal_fds[0]); 
+    close(signal_fds[0]);
     close(signal_fds[1]);
 }
 
@@ -243,7 +243,7 @@ add_child(ChildMonitor *self, PyObject *args) {
 #define A(attr) &add_queue[add_queue_count].attr
     if (!PyArg_ParseTuple(args, "kiiO", A(id), A(pid), A(fd), A(screen))) {
         children_mutex(unlock);
-        return NULL; 
+        return NULL;
     }
 #undef A
     INCREF_CHILD(add_queue[add_queue_count]);
@@ -259,12 +259,12 @@ schedule_write_to_child(unsigned long id, const char *data, size_t sz) {
     bool found = false;
     children_mutex(lock);
     for (size_t i = 0; i < self->count; i++) {
-        if (children[i].id == id) { 
+        if (children[i].id == id) {
             found = true;
             Screen *screen = children[i].screen;
             screen_mutex(lock, write);
             size_t space_left = screen->write_buf_sz - screen->write_buf_used;
-            if (space_left < sz) { 
+            if (space_left < sz) {
                 if (screen->write_buf_used + sz > 100 * 1024 * 1024) {
                     fprintf(stderr, "Too much data being sent to child with id: %lu, ignoring it\n", id);
                     screen_mutex(unlock, write);
@@ -295,7 +295,7 @@ needs_write(ChildMonitor UNUSED *self, PyObject *args) {
 #define needs_write_doc "needs_write(id, data) -> Queue data to be written to child."
     unsigned long id, sz;
     const char *data;
-    if (!PyArg_ParseTuple(args, "ks#", &id, &data, &sz)) return NULL; 
+    if (!PyArg_ParseTuple(args, "ks#", &id, &data, &sz)) return NULL;
     if (schedule_write_to_child(id, data, sz)) { Py_RETURN_TRUE; }
     Py_RETURN_FALSE;
 }
@@ -332,7 +332,7 @@ parse_input(ChildMonitor *self) {
     PyObject *msg = NULL;
     children_mutex(lock);
     while (remove_queue_count) {
-        remove_queue_count--; 
+        remove_queue_count--;
         remove_notify[remove_count] = remove_queue[remove_queue_count].id;
         remove_count++;
         FREE_CHILD(remove_queue[remove_queue_count]);
@@ -517,13 +517,23 @@ collect_cursor_info(CursorRenderInfo *ans, Window *w, double now, OSWindow *os_w
     ColorProfile *cp = rd->screen->color_profile;
     ans->shape = cursor->shape ? cursor->shape : OPT(cursor_shape);
     ans->color = colorprofile_to_color(cp, cp->overridden.cursor_color, cp->configured.cursor_color);
-    if (ans->shape == CURSOR_BLOCK) return;
+    ans->is_focused = os_window->is_focused;
+    if (ans->shape == CURSOR_BLOCK && ans->is_focused) return;
     double left = rd->xstart + cursor->x * rd->dx;
     double top = rd->ystart - cursor->y * rd->dy;
     unsigned long mult = MAX(1, screen_current_char_width(rd->screen));
     double right = left + (ans->shape == CURSOR_BEAM ? cursor_width(1.5, true, os_window) : rd->dx * mult);
     double bottom = top - rd->dy;
-    if (ans->shape == CURSOR_UNDERLINE) top = bottom + cursor_width(2.0, false, os_window);
+	switch (ans->shape) {
+        case CURSOR_UNDERLINE:
+            top = bottom + cursor_width(2.0, false, os_window);
+            break;
+        case CURSOR_BLOCK:
+            top -= 2.0 / os_window->viewport_height;  // 1px adjustment for width of line
+            break;
+        default:
+            break;
+	}
     ans->left = left; ans->right = right; ans->top = top; ans->bottom = bottom;
 }
 
@@ -544,13 +554,13 @@ update_window_title(Window *w, OSWindow *os_window) {
 static PyObject*
 simple_render_screen(PyObject UNUSED *self, PyObject *args) {
 #define simple_render_screen_doc "Render a Screen object, with no cursor"
-    Screen *screen; 
+    Screen *screen;
     float xstart, ystart, dx, dy;
     static ssize_t vao_idx = -1, gvao_idx = -1;
     if (vao_idx == -1) vao_idx = create_cell_vao();
     if (gvao_idx == -1) gvao_idx = create_graphics_vao();
     if (!PyArg_ParseTuple(args, "O!ffff", &Screen_Type, &screen, &xstart, &ystart, &dx, &dy)) return NULL;
-    draw_cells(vao_idx, gvao_idx, xstart, ystart, dx, dy, screen, current_os_window());
+    draw_cells(vao_idx, gvao_idx, xstart, ystart, dx, dy, screen, current_os_window(), true);
     Py_RETURN_NONE;
 }
 
@@ -563,7 +573,7 @@ render_os_window(OSWindow *os_window, double now, unsigned int *active_window_id
 #define WD w->render_data
         if (w->visible && WD.screen) {
             if (w->last_drag_scroll_at > 0) {
-                if (now - w->last_drag_scroll_at >= 0.02) { 
+                if (now - w->last_drag_scroll_at >= 0.02) {
                     if (drag_scroll(w, os_window)) {
                         w->last_drag_scroll_at = now;
                         set_maximum_wait(0.02);
@@ -576,8 +586,8 @@ render_os_window(OSWindow *os_window, double now, unsigned int *active_window_id
                 collect_cursor_info(&WD.screen->cursor_render_info, w, now, os_window);
                 update_window_title(w, os_window);
             } else WD.screen->cursor_render_info.is_visible = false;
-            draw_cells(WD.vao_idx, WD.gvao_idx, WD.xstart, WD.ystart, WD.dx, WD.dy, WD.screen, os_window);
-            if (is_active_window && WD.screen->cursor_render_info.is_visible && WD.screen->cursor_render_info.shape != CURSOR_BLOCK) {
+            draw_cells(WD.vao_idx, WD.gvao_idx, WD.xstart, WD.ystart, WD.dx, WD.dy, WD.screen, os_window, is_active_window);
+            if (is_active_window && WD.screen->cursor_render_info.is_visible && (!WD.screen->cursor_render_info.is_focused || WD.screen->cursor_render_info.shape != CURSOR_BLOCK)) {
                 draw_cursor(&WD.screen->cursor_render_info, os_window->is_focused);
             }
             if (WD.screen->start_visual_bell_at != 0) {
@@ -592,7 +602,7 @@ render_os_window(OSWindow *os_window, double now, unsigned int *active_window_id
 static inline void
 render(double now) {
     double time_since_last_render = now - last_render_at;
-    if (time_since_last_render < OPT(repaint_delay)) { 
+    if (time_since_last_render < OPT(repaint_delay)) {
         set_maximum_wait(OPT(repaint_delay) - time_since_last_render);
         return;
     }
@@ -608,11 +618,11 @@ render(double now) {
             w->viewport_size_dirty = false;
         }
         unsigned int active_window_id = 0;
-        render_os_window(w, now, &active_window_id);
         Tab *active_tab = w->tabs + w->active_tab;
         BorderRects *br = &active_tab->border_rects;
         draw_borders(br->vao_idx, br->num_border_rects, br->rect_buf, br->is_dirty, w->viewport_width, w->viewport_height);
-        if (TD.screen && w->num_tabs > 1) draw_cells(TD.vao_idx, 0, TD.xstart, TD.ystart, TD.dx, TD.dy, TD.screen, w);
+        if (TD.screen && w->num_tabs > 1) draw_cells(TD.vao_idx, 0, TD.xstart, TD.ystart, TD.dx, TD.dy, TD.screen, w, true);
+        render_os_window(w, now, &active_window_id);
         swap_window_buffers(w);
         w->last_active_tab = w->active_tab; w->last_num_tabs = w->num_tabs; w->last_active_window_id = active_window_id;
         br->is_dirty = false;
@@ -663,7 +673,7 @@ cm_thread_write(PyObject UNUSED *self, PyObject *args) {
     if (!PyArg_ParseTuple(args, "is#", &fd, &buf, &sz)) return NULL;
     ThreadWriteData *data = alloc_twd(sz);
     if (data == NULL) return PyErr_NoMemory();
-    data->fd = fd; 
+    data->fd = fd;
     memcpy(data->buf, buf, data->sz);
     int ret = pthread_create(&thread, NULL, thread_write, data);
     if (ret != 0) { free_twd(data); return PyErr_SetFromErrno(PyExc_OSError); }
@@ -716,7 +726,7 @@ main_loop(ChildMonitor *self) {
                     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);
                 }
-                remove_os_window(os_window->id); 
+                remove_os_window(os_window->id);
             } else has_open_windows = true;
         }
     }
@@ -748,7 +758,7 @@ hangup(pid_t pid) {
     if (errno == ESRCH) return;
     if (errno != 0) { perror("Failed to get process group id for child"); return; }
     if (killpg(pgid, SIGHUP) != 0) {
-        if (errno != ESRCH) perror("Failed to kill child"); 
+        if (errno != ESRCH) perror("Failed to kill child");
     }
 }
 
@@ -763,7 +773,7 @@ cleanup_child(ssize_t i) {
 static inline void
 remove_children(ChildMonitor *self) {
     if (self->count > 0) {
-        size_t count = 0; 
+        size_t count = 0;
         for (ssize_t i = self->count - 1; i >= 0; i--) {
             if (children[i].needs_removal) {
                 count++;
@@ -839,7 +849,7 @@ write_to_child(int fd, Screen *screen) {
     while (written < screen->write_buf_used) {
         ret = write(fd, screen->write_buf + written, screen->write_buf_used - written);
         if (ret > 0) { written += ret; }
-        else if (ret == 0) { 
+        else if (ret == 0) {
             // could mean anything, ignore
             break;
         } else {
@@ -858,7 +868,7 @@ io_loop(void *data) {
     // The I/O thread loop
     size_t i;
     int ret;
-    bool has_more, data_received; 
+    bool has_more, data_received;
     Screen *screen;
     ChildMonitor *self = (ChildMonitor*)data;
     set_thread_name("KittyChildMon");
@@ -880,7 +890,7 @@ io_loop(void *data) {
         ret = poll(fds, self->count + EXTRA_FDS, -1);
         if (ret > 0) {
             if (fds[0].revents && POLLIN) drain_fd(fds[0].fd); // wakeup
-            if (fds[1].revents && POLLIN) { 
+            if (fds[1].revents && POLLIN) {
                 data_received = true;
                 drain_fd(fds[1].fd);
                 children_mutex(lock);
@@ -891,7 +901,7 @@ io_loop(void *data) {
                 if (fds[EXTRA_FDS + i].revents & (POLLIN | POLLHUP)) {
                     data_received = true;
                     has_more = read_bytes(fds[EXTRA_FDS + i].fd, children[i].screen);
-                    if (!has_more) { 
+                    if (!has_more) {
                         // child is dead
                         children_mutex(lock);
                         children[i].needs_removal = true;
@@ -968,7 +978,7 @@ handle_peer(ChildMonitor *self, int s) {
 static void*
 talk_loop(void *data) {
     // The I/O thread loop
-    
+
     ChildMonitor *self = (ChildMonitor*)data;
     set_thread_name("KittyTalkMon");
 
@@ -986,7 +996,7 @@ talk_loop(void *data) {
     return 0;
 }
 // }}}
- 
+
 // Boilerplate {{{
 static PyMethodDef methods[] = {
     METHOD(add_child, METH_VARARGS)
@@ -1007,11 +1017,11 @@ PyTypeObject ChildMonitor_Type = {
     PyVarObject_HEAD_INIT(NULL, 0)
     .tp_name = "fast_data_types.ChildMonitor",
     .tp_basicsize = sizeof(ChildMonitor),
-    .tp_dealloc = (destructor)dealloc, 
-    .tp_flags = Py_TPFLAGS_DEFAULT,        
+    .tp_dealloc = (destructor)dealloc,
+    .tp_flags = Py_TPFLAGS_DEFAULT,
     .tp_doc = "ChildMonitor",
     .tp_methods = methods,
-    .tp_new = new,                
+    .tp_new = new,
 };
 
 static PyMethodDef module_methods[] = {
@@ -1023,10 +1033,9 @@ bool
 init_child_monitor(PyObject *module) {
     if (PyType_Ready(&ChildMonitor_Type) < 0) return false;
     if (PyModule_AddObject(module, "ChildMonitor", (PyObject *)&ChildMonitor_Type) != 0) return false;
-    Py_INCREF(&ChildMonitor_Type); 
+    Py_INCREF(&ChildMonitor_Type);
     if (PyModule_AddFunctions(module, module_methods) != 0) return false;
     return true;
 }
 
 // }}}
-

kitty/child.c

@@ -0,0 +1,113 @@
+/*
+ * child.c
+ * Copyright (C) 2018 Kovid Goyal <kovid at kovidgoyal.net>
+ *
+ * Distributed under terms of the GPL3 license.
+ */
+
+#include "data-types.h"
+#include <unistd.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <string.h>
+
+static inline char**
+serialize_string_tuple(PyObject *src) {
+    Py_ssize_t sz = PyTuple_GET_SIZE(src);
+    char **ans = calloc(sz + 1, sizeof(char*));
+    if (!ans) fatal("Out of memory");
+    for (Py_ssize_t i = 0; i < sz; i++) ans[i] = PyUnicode_AsUTF8(PyTuple_GET_ITEM(src, i));
+    return ans;
+}
+
+extern char **environ;
+
+static inline void
+write_to_stderr(const char *text) {
+    size_t sz = strlen(text);
+    size_t written = 0;
+    while(written < sz) {
+        ssize_t amt = write(2, text + written, sz - written);
+        if (amt == 0) break;
+        if (amt < 0) {
+            if (errno == EAGAIN || errno == EINTR) continue;
+            break;
+        }
+        written += amt;
+    }
+}
+
+static PyObject*
+spawn(PyObject *self UNUSED, PyObject *args) {
+    PyObject *argv_p, *env_p;
+    int master, slave, stdin_read_fd, stdin_write_fd;
+    char* cwd;
+    if (!PyArg_ParseTuple(args, "sO!O!iiii", &cwd, &PyTuple_Type, &argv_p, &PyTuple_Type, &env_p, &master, &slave, &stdin_read_fd, &stdin_write_fd)) return NULL;
+    char name[2048] = {0};
+    if (ttyname_r(slave, name, sizeof(name) - 1) != 0) { PyErr_SetFromErrno(PyExc_OSError); return NULL; }
+    char **argv = serialize_string_tuple(argv_p);
+    char **env = serialize_string_tuple(env_p);
+
+#define exit_on_err(m) { write_to_stderr(m); write_to_stderr(": "); write_to_stderr(strerror(errno)); exit(EXIT_FAILURE); }
+    pid_t pid = fork();
+    switch(pid) {
+        case 0:
+            // child
+            // Use only signal-safe functions (man 7 signal-safety)
+            if (chdir(cwd) != 0) { if (chdir("/") != 0) {} };  // ignore failure to chdir to /
+            if (setsid() == -1) exit_on_err("setsid() in child process failed");
+            if (dup2(slave, 1) == -1) exit_on_err("dup2() failed for fd number 1");
+            if (dup2(slave, 2) == -1) exit_on_err("dup2() failed for fd number 2");
+            if (stdin_read_fd > -1) {
+                if (dup2(stdin_read_fd, 0) == -1) exit_on_err("dup2() failed for fd number 0");
+                close(stdin_read_fd);
+                close(stdin_write_fd);
+            } else {
+                if (dup2(slave, 0) == -1) exit_on_err("dup2() failed for fd number 0");
+            }
+            close(slave);
+            close(master);
+            for (int c = 3; c < 201; c++) close(c);
+
+            // Establish the controlling terminal (see man 7 credentials)
+            int tfd = open(name, O_RDWR);
+            if (tfd == -1) exit_on_err("Failed to open controlling terminal");
+            close(tfd);
+
+            environ = env;
+            execvp(argv[0], argv);
+            // Report the failure and exec a shell instead, so that we are not left
+            // with a forked but not exec'ed process
+            write_to_stderr("Failed to launch child: ");
+            write_to_stderr(argv[0]);
+            write_to_stderr("\nWith error: ");
+            write_to_stderr(strerror(errno));
+            write_to_stderr("\nPress Enter to exit.\n");
+            execlp("sh", "sh", "-c", "read w", NULL);
+            exit(EXIT_FAILURE);
+            break;
+        case -1:
+            PyErr_SetFromErrno(PyExc_OSError);
+            break;
+        default:
+            break;
+    }
+#undef exit_on_err
+    free(argv);
+    free(env);
+    if (PyErr_Occurred()) return NULL;
+    return PyLong_FromLong(pid);
+}
+
+static PyMethodDef module_methods[] = {
+    METHODB(spawn, METH_VARARGS),
+    {NULL, NULL, 0, NULL}        /* Sentinel */
+};
+
+
+bool
+init_child(PyObject *module) {
+    if (PyModule_AddFunctions(module, module_methods) != 0) return false;
+    return true;
+}

kitty/child.py

@@ -4,11 +4,26 @@
 
 import fcntl
 import os
-import sys
 
 import kitty.fast_data_types as fast_data_types
 
-from .constants import terminfo_dir
+from .constants import terminfo_dir, is_macos
+
+
+def cwd_of_process(pid):
+    if is_macos:
+        from kitty.fast_data_types import cwd_of_process
+        ans = cwd_of_process(pid)
+    else:
+        ans = '/proc/{}/cwd'.format(pid)
+    return os.path.realpath(ans)
+
+
+def cmdline_of_process(pid):
+    if is_macos:
+        # TODO: macOS implementation, see DarwinProcess.c in htop for inspiration
+        raise NotImplementedError()
+    return open('/proc/{}/cmdline'.format(pid), 'rb').read().decode('utf-8').split('\0')
 
 
 def remove_cloexec(fd):
@@ -20,9 +35,17 @@ class Child:
     child_fd = pid = None
     forked = False
 
-    def __init__(self, argv, cwd, opts, stdin=None, env=None):
+    def __init__(self, argv, cwd, opts, stdin=None, env=None, cwd_from=None):
         self.argv = argv
-        self.cwd = os.path.abspath(os.path.expandvars(os.path.expanduser(cwd or os.getcwd())))
+        if cwd_from is not None:
+            try:
+                cwd = cwd_of_process(cwd_from)
+            except Exception:
+                import traceback
+                traceback.print_exc()
+        else:
+            cwd = os.path.expandvars(os.path.expanduser(cwd or os.getcwd()))
+        self.cwd = os.path.abspath(cwd)
         self.opts = opts
         self.stdin = stdin
         self.env = env or {}
@@ -38,44 +61,34 @@ class Child:
         if stdin is not None:
             stdin_read_fd, stdin_write_fd = os.pipe()
             remove_cloexec(stdin_read_fd)
-        env = self.env
-        pid = os.fork()
-        if pid == 0:  # child
-            try:
-                os.chdir(self.cwd)
-            except EnvironmentError:
-                os.chdir('/')
-            os.setsid()
-            for i in range(3):
-                if stdin is not None and i == 0:
-                    os.dup2(stdin_read_fd, i)
-                    os.close(stdin_read_fd), os.close(stdin_write_fd)
-                else:
-                    os.dup2(slave, i)
-            os.close(slave), os.close(master)
-            os.closerange(3, 200)
-            # Establish the controlling terminal (see man 7 credentials)
-            os.close(os.open(os.ttyname(1), os.O_RDWR))
-            os.environ.update(env)
-            os.environ['TERM'] = self.opts.term
-            os.environ['COLORTERM'] = 'truecolor'
-            if os.path.isdir(terminfo_dir):
-                os.environ['TERMINFO'] = terminfo_dir
-            try:
-                os.execvp(self.argv[0], self.argv)
-            except Exception as err:
-                # Report he failure and exec a shell instead so that
-                # we are not left with a forked but not execed process
-                print('Could not launch:', self.argv[0])
-                print('\t', err)
-                print('\nPress Enter to exit:', end=' ')
-                sys.stdout.flush()
-                os.execvp('/bin/sh', ['/bin/sh', '-c', 'read w'])
-        else:  # master
-            os.close(slave)
-            self.pid = pid
-            self.child_fd = master
-            if stdin is not None:
-                os.close(stdin_read_fd)
-                fast_data_types.thread_write(stdin_write_fd, stdin)
-            return pid
+        else:
+            stdin_read_fd = stdin_write_fd = -1
+        env = os.environ.copy()
+        env.update(self.env)
+        env['TERM'] = self.opts.term
+        env['COLORTERM'] = 'truecolor'
+        if os.path.isdir(terminfo_dir):
+            env['TERMINFO'] = terminfo_dir
+        env = tuple('{}={}'.format(k, v) for k, v in env.items())
+        pid = fast_data_types.spawn(self.cwd, tuple(self.argv), env, master, slave, stdin_read_fd, stdin_write_fd)
+        os.close(slave)
+        self.pid = pid
+        self.child_fd = master
+        if stdin is not None:
+            os.close(stdin_read_fd)
+            fast_data_types.thread_write(stdin_write_fd, stdin)
+        return pid
+
+    @property
+    def cmdline(self):
+        try:
+            return cmdline_of_process(self.pid)
+        except Exception:
+            return list(self.argv)
+
+    @property
+    def current_cwd(self):
+        try:
+            return cwd_of_process(self.pid)
+        except Exception:
+            pass

kitty/cli.py

@@ -206,7 +206,7 @@ def prettify(text):
     def sub(m):
         t = m.group(2)
         for ch in m.group(1):
-            t = {'C': cyan, '_': italic, '*': bold}[ch](t)
+            t = {'C': cyan, '_': italic, '*': bold, 'G': green, 'T': title}[ch](t)
         return t
 
     text = re.sub(r'[|]([a-zA-Z_*]+?) (.+?)[|]', sub, text)
@@ -263,18 +263,25 @@ def print_help_for_seq(seq, usage, message, appname):
         if leading_indent is None:
             leading_indent = indent
         j = '\n' + (' ' * indent)
-        a((' ' * leading_indent) + j.join(wrap(text, limit=linesz - indent)))
+        lines = []
+        for l in text.splitlines():
+            if l:
+                lines.extend(wrap(l, limit=linesz - indent))
+            else:
+                lines.append('')
+        a((' ' * leading_indent) + j.join(lines))
 
     usage = usage or '[program-to-run ...]'
     a('{}: {} [options] {}'.format(title('Usage'), bold(yellow(appname)), usage))
     a('')
     message = message or (
-        'Run the |_ {appname}| terminal emulator. You can also specify the |_ program| to run inside |_ {appname}| as normal'
+        'Run the |G {appname}| terminal emulator. You can also specify the |_ program| to run inside |_ {appname}| as normal'
         ' arguments following the |_ options|. For example: {appname} /bin/sh'
     ).format(appname=appname)
     wa(prettify(message))
     a('')
-    a('{}:'.format(title('Options')))
+    if seq:
+        a('{}:'.format(title('Options')))
     for opt in seq:
         if isinstance(opt, str):
             a('{}:'.format(title(opt)))

kitty/cocoa_window.m

@@ -12,6 +12,8 @@
 #include <AvailabilityMacros.h>
 // Needed for _NSGetProgname
 #include <crt_externs.h>
+typedef void* rusage_info_t;  // needed for libproc.h
+#include <libproc.h>
 
 #if (MAC_OS_X_VERSION_MAX_ALLOWED < 101200)
 #define NSWindowStyleMaskResizable NSResizableWindowMask
@@ -22,7 +24,7 @@
 
 static NSMenuItem* title_menu = NULL;
 
-static NSString* 
+static NSString*
 find_app_name(void) {
     size_t i;
     NSDictionary* infoDictionary = [[NSBundle mainBundle] infoDictionary];
@@ -141,7 +143,7 @@ cocoa_update_title(PyObject *pytitle) {
 bool
 cocoa_make_window_resizable(void *w) {
     NSWindow *window = (NSWindow*)w;
-    
+
     @try {
         [window setStyleMask:
             [window styleMask] | NSWindowStyleMaskResizable];
@@ -166,8 +168,19 @@ cocoa_get_lang(PyObject UNUSED *self) {
     return Py_BuildValue("s", [locale UTF8String]);
 }
 
+PyObject*
+cwd_of_process(PyObject *self UNUSED, PyObject *pid_) {
+    long pid = PyLong_AsLong(pid_);
+    struct proc_vnodepathinfo vpi;
+    int ret = proc_pidinfo(pid, PROC_PIDVNODEPATHINFO, 0, &vpi, sizeof(vpi));
+    if (ret < 0) { PyErr_SetFromErrno(PyExc_OSError); return NULL; }
+    return PyUnicode_FromString(vpi.pvi_cdir.vip_path);
+}
+
+
 static PyMethodDef module_methods[] = {
-    {"cocoa_get_lang", (PyCFunction)cocoa_get_lang, METH_NOARGS, ""}, 
+    {"cocoa_get_lang", (PyCFunction)cocoa_get_lang, METH_NOARGS, ""},
+    {"cwd_of_process", (PyCFunction)cwd_of_process, METH_O, ""},
     {NULL, NULL, 0, NULL}        /* Sentinel */
 };
 

kitty/colors.c

@@ -42,7 +42,7 @@ PyObject* create_256_color_table() {
         uint8_t v = 8 + i * 10;
         FG_BG_256[j] = (v << 16) | (v << 8) | v;
     }
-    
+
     PyObject *ans = PyTuple_New(255);
     if (ans == NULL) return PyErr_NoMemory();
     for (i=0; i < 255; i++) {
@@ -62,7 +62,7 @@ new(PyTypeObject *type, PyObject UNUSED *args, PyObject UNUSED *kwds) {
         if (FG_BG_256[255] == 0) create_256_color_table();
         memcpy(self->color_table, FG_BG_256, sizeof(FG_BG_256));
         memcpy(self->orig_color_table, FG_BG_256, sizeof(FG_BG_256));
-        self->dirty = true; 
+        self->dirty = true;
     }
     return (PyObject*) self;
 }
@@ -93,7 +93,7 @@ update_ansi_color_table(ColorProfile *self, PyObject *val) {
     Py_RETURN_NONE;
 }
 
-color_type 
+color_type
 colorprofile_to_color(ColorProfile *self, color_type entry, color_type defval) {
     color_type t = entry & 0xFF, r;
     switch(t) {
@@ -128,7 +128,7 @@ as_color(ColorProfile *self, PyObject *val) {
         default:
             ans = Py_None; Py_INCREF(Py_None);
     }
-    if (ans == NULL) ans = Py_BuildValue("BBB", (unsigned char)(col >> 16), (unsigned char)((col >> 8) & 0xFF), (unsigned char)(col & 0xFF)); 
+    if (ans == NULL) ans = Py_BuildValue("BBB", (unsigned char)(col >> 16), (unsigned char)((col >> 8) & 0xFF), (unsigned char)(col & 0xFF));
     return ans;
 }
 
@@ -177,13 +177,13 @@ copy_color_table_to_buffer(ColorProfile *self, color_type *buf, int offset, size
     }
     self->dirty = false;
 }
- 
+
 static PyObject*
 color_table_address(ColorProfile *self) {
 #define color_table_address_doc "Pointer address to start of color table"
     return PyLong_FromVoidPtr((void*)self->color_table);
 }
- 
+
 
 // Boilerplate {{{
 
@@ -227,13 +227,13 @@ PyTypeObject ColorProfile_Type = {
     PyVarObject_HEAD_INIT(NULL, 0)
     .tp_name = "fast_data_types.ColorProfile",
     .tp_basicsize = sizeof(ColorProfile),
-    .tp_dealloc = (destructor)dealloc, 
-    .tp_flags = Py_TPFLAGS_DEFAULT,        
+    .tp_dealloc = (destructor)dealloc,
+    .tp_flags = Py_TPFLAGS_DEFAULT,
     .tp_doc = "ColorProfile",
     .tp_members = members,
     .tp_methods = methods,
     .tp_getset = getsetters,
-    .tp_new = new,                
+    .tp_new = new,
 };
 
 INIT_TYPE(ColorProfile)

kitty/config.py

@@ -12,13 +12,15 @@ import tempfile
 from collections import namedtuple
 
 from . import fast_data_types as defines
+from .config_utils import (
+    init_config, parse_config_base, positive_float, positive_int, to_bool,
+    to_color, unit_float
+)
 from .constants import config_dir
 from .fast_data_types import CURSOR_BEAM, CURSOR_BLOCK, CURSOR_UNDERLINE
 from .layout import all_layouts
-from .rgb import to_color
 from .utils import safe_print
 
-key_pat = re.compile(r'([a-zA-Z][a-zA-Z0-9_-]*)\s+(.+)$')
 MINIMUM_FONT_SIZE = 4
 
 
@@ -44,14 +46,10 @@ def to_cursor_shape(x):
         )
 
 
-def to_bool(x):
-    return x.lower() in 'y yes true'.split()
-
-
 def parse_mods(parts):
 
     def map_mod(m):
-        return {'CTRL': 'CONTROL', 'CMD': 'CONTROL'}.get(m, m)
+        return {'CTRL': 'CONTROL', 'CMD': 'SUPER', 'OPTION': 'ALT'}.get(m, m)
 
     mods = 0
     for m in parts:
@@ -94,7 +92,7 @@ def parse_shortcut(sc):
 
 
 KeyAction = namedtuple('KeyAction', 'func args')
-shlex_actions = {'pass_selection_to_program', 'new_window', 'new_tab'}
+shlex_actions = {'pass_selection_to_program', 'new_window', 'new_tab', 'new_os_window', 'new_window_with_cwd', 'new_tab_with_cwd', 'new_os_window_with_cwd'}
 
 
 def parse_key_action(action):
@@ -174,7 +172,7 @@ def parse_symbol_map(val):
 
 
 def parse_send_text_bytes(text):
-    return ast.literal_eval("'''" + text + "'''").encode('utf-8')
+    return ast.literal_eval("'''" + text.replace("'''", "'\\''") + "'''").encode('utf-8')
 
 
 def parse_send_text(val, keymap):
@@ -195,7 +193,7 @@ def parse_send_text(val, keymap):
     return parse_key(key_str, keymap)
 
 
-def to_open_url_modifiers(val):
+def to_modifiers(val):
     return parse_mods(val.split('+'))
 
 
@@ -209,18 +207,6 @@ def to_layout_names(raw):
     return parts
 
 
-def positive_int(x):
-    return max(0, int(x))
-
-
-def positive_float(x):
-    return max(0, float(x))
-
-
-def unit_float(x):
-    return max(0, min(float(x), 1))
-
-
 def adjust_line_height(x):
     if x.endswith('%'):
         return float(x[:-1].strip()) / 100.0
@@ -240,7 +226,7 @@ def tab_separator(x):
             x = x[1:-1]
             break
     if not x.strip():
-        x = defaults.tab_separator
+        x = ('\xa0' * len(x)) if x else defaults.tab_separator
     return x
 
 
@@ -248,6 +234,10 @@ def tab_font_style(x):
     return {'bold-italic': (True, True), 'bold': (True, False), 'italic': (False, True)}.get(x.lower().replace('_', '-'), (False, False))
 
 
+def tab_bar_edge(x):
+    return {'top': 1, 'bottom': 3}.get(x.lower(), 3)
+
+
 def url_style(x):
     return url_style.map.get(x, url_style.map['curly'])
 
@@ -256,6 +246,7 @@ url_style.map = dict(((v, i) for i, v in enumerate('none single double curly'.sp
 
 
 type_map = {
+    'allow_remote_control': to_bool,
     'adjust_line_height': adjust_line_height,
     'scrollback_lines': positive_int,
     'scrollback_pager': shlex.split,
@@ -264,7 +255,8 @@ type_map = {
     'font_size_delta': positive_float,
     'focus_follows_mouse': to_bool,
     'cursor_shape': to_cursor_shape,
-    'open_url_modifiers': to_open_url_modifiers,
+    'open_url_modifiers': to_modifiers,
+    'rectangle_select_modifiers': to_modifiers,
     'repaint_delay': positive_int,
     'input_delay': positive_int,
     'window_border_width': positive_float,
@@ -290,20 +282,40 @@ type_map = {
     'tab_separator': tab_separator,
     'active_tab_font_style': tab_font_style,
     'inactive_tab_font_style': tab_font_style,
+    'inactive_text_alpha': unit_float,
     'url_style': url_style,
     'prefer_color_emoji': to_bool,
+    'copy_on_select': to_bool,
+    'tab_bar_edge': tab_bar_edge,
 }
 
 for name in (
     'foreground background cursor active_border_color inactive_border_color'
     ' selection_foreground selection_background url_color'
 ).split():
-    type_map[name] = lambda x: to_color(x, validate=True)
+    type_map[name] = to_color
 for i in range(16):
-    type_map['color%d' % i] = lambda x: to_color(x, validate=True)
+    type_map['color%d' % i] = to_color
 for a in ('active', 'inactive'):
     for b in ('foreground', 'background'):
-        type_map['%s_tab_%s' % (a, b)] = lambda x: to_color(x, validate=True)
+        type_map['%s_tab_%s' % (a, b)] = to_color
+
+
+def special_handling(key, val, ans):
+    if key == 'map':
+        parse_key(val, ans['keymap'])
+        return True
+    if key == 'symbol_map':
+        ans['symbol_map'].update(parse_symbol_map(val))
+        return True
+    if key == 'send_text':
+        # For legacy compatibility
+        parse_send_text(val, ans['keymap'])
+        return True
+
+
+defaults = None
+default_config_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'kitty.conf')
 
 
 def parse_config(lines, check_keys=True):
@@ -311,46 +323,14 @@ def parse_config(lines, check_keys=True):
         'keymap': {},
         'symbol_map': {},
     }
-    if check_keys:
-        all_keys = defaults._asdict()
-    for line in lines:
-        line = line.strip()
-        if not line or line.startswith('#'):
-            continue
-        m = key_pat.match(line)
-        if m is not None:
-            key, val = m.groups()
-            if key == 'map':
-                parse_key(val, ans['keymap'])
-                continue
-            if key == 'symbol_map':
-                ans['symbol_map'].update(parse_symbol_map(val))
-                continue
-            if key == 'send_text':
-                # For legacy compatibility
-                parse_send_text(val, ans['keymap'])
-                continue
-            if check_keys:
-                if key not in all_keys:
-                    safe_print(
-                        'Ignoring unknown config key: {}'.format(key),
-                        file=sys.stderr
-                    )
-                    continue
-            tm = type_map.get(key)
-            if tm is not None:
-                val = tm(val)
-            ans[key] = val
+    parse_config_base(lines, defaults, type_map, special_handling, ans, check_keys=check_keys)
     return ans
 
 
-with open(
-    os.path.join(os.path.dirname(os.path.abspath(__file__)), 'kitty.conf'), 'rb'
-) as f:
-    defaults = parse_config(f.read().decode('utf-8').splitlines(), check_keys=False)
-Options = namedtuple('Defaults', ','.join(defaults.keys()))
-defaults = Options(**defaults)
-actions = frozenset(a.func for a in defaults.keymap.values()) | frozenset({'combine', 'send_text', 'goto_tab'})
+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'.split()
+)
 no_op_actions = frozenset({'noop', 'no-op', 'no_op'})
 
 

kitty/config_utils.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python
+# vim:fileencoding=utf-8
+# License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
+
+import re
+import sys
+from collections import namedtuple
+
+from .utils import safe_print
+from .rgb import to_color as as_color
+
+key_pat = re.compile(r'([a-zA-Z][a-zA-Z0-9_-]*)\s+(.+)$')
+
+
+def to_color(x):
+    return as_color(x, validate=True)
+
+
+def positive_int(x):
+    return max(0, int(x))
+
+
+def positive_float(x):
+    return max(0, float(x))
+
+
+def unit_float(x):
+    return max(0, min(float(x), 1))
+
+
+def to_bool(x):
+    return x.lower() in 'y yes true'.split()
+
+
+def parse_config_base(
+    lines, defaults, type_map, special_handling, ans, check_keys=True
+):
+    if check_keys:
+        all_keys = defaults._asdict()
+    for line in lines:
+        line = line.strip()
+        if not line or line.startswith('#'):
+            continue
+        m = key_pat.match(line)
+        if m is not None:
+            key, val = m.groups()
+            if special_handling(key, val, ans):
+                continue
+            if check_keys:
+                if key not in all_keys:
+                    safe_print(
+                        'Ignoring unknown config key: {}'.format(key),
+                        file=sys.stderr
+                    )
+                    continue
+            tm = type_map.get(key)
+            if tm is not None:
+                val = tm(val)
+            ans[key] = val
+
+
+def init_config(defaults_path, parse_config):
+    with open(defaults_path, encoding='utf-8') as f:
+        defaults = parse_config(f.read().splitlines(), check_keys=False)
+    Options = namedtuple('Defaults', ','.join(defaults.keys()))
+    defaults = Options(**defaults)
+    return Options, defaults

kitty/constants.py

@@ -10,7 +10,7 @@ from collections import namedtuple
 from .fast_data_types import set_boss as set_c_boss
 
 appname = 'kitty'
-version = (0, 6, 0)
+version = (0, 7, 0)
 str_version = '.'.join(map(str, version))
 _plat = sys.platform.lower()
 is_macos = 'darwin' in _plat
@@ -22,9 +22,8 @@ WindowGeometry = namedtuple('WindowGeometry', 'left top right bottom xnum ynum')
 
 
 def _get_config_dir():
-    # This must be called before calling setApplicationName
     if 'KITTY_CONFIG_DIRECTORY' in os.environ:
-        return os.path.abspath(os.path.expanduser(os.environ['VISE_CONFIG_DIRECTORY']))
+        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')))
     ans = os.path.join(candidate, appname)

kitty/control-codes.h

@@ -69,7 +69,7 @@
 // Sharp control codes
 // -------------------
 
-// Align display 
+// Align display
 #define DECALN '8'
 
 // Esc control codes
@@ -180,7 +180,7 @@
 
 // Scroll down by the specified number of lines
 #define SD 'T'
- 
+
 // *Erase character*: Erase the indicated # of characters on the
 // current line.
 #define ECH 'X'
@@ -212,7 +212,7 @@
 
 // *Select graphics rendition*: The terminal can display the following
 // character attributes that change the character display without
-// changing the character 
+// changing the character
 #define SGR 'm'
 
 // *Device status report*.

kitty/core_text.m

@@ -86,7 +86,7 @@ dealloc(CTFace* self) {
 static PyObject*
 font_descriptor_to_python(CTFontDescriptorRef descriptor) {
     NSURL *url = (NSURL *) CTFontDescriptorCopyAttribute(descriptor, kCTFontURLAttribute);
-    NSString *psName = (NSString *) CTFontDescriptorCopyAttribute(descriptor, kCTFontNameAttribute);  
+    NSString *psName = (NSString *) CTFontDescriptorCopyAttribute(descriptor, kCTFontNameAttribute);
     NSString *family = (NSString *) CTFontDescriptorCopyAttribute(descriptor, kCTFontFamilyNameAttribute);
     NSString *style = (NSString *) CTFontDescriptorCopyAttribute(descriptor, kCTFontStyleNameAttribute);
     NSDictionary *traits = (NSDictionary *) CTFontDescriptorCopyAttribute(descriptor, kCTFontTraitsAttribute);
@@ -94,8 +94,8 @@ font_descriptor_to_python(CTFontDescriptorRef descriptor) {
     NSNumber *weightVal = traits[(id)kCTFontWeightTrait];
     NSNumber *widthVal = traits[(id)kCTFontWidthTrait];
 
-    PyObject *ans = Py_BuildValue("{ssssssss sOsOsO sfsfsI}", 
-            "path", [[url path] UTF8String], 
+    PyObject *ans = Py_BuildValue("{ssssssss sOsOsO sfsfsI}",
+            "path", [[url path] UTF8String],
             "postscript_name", [psName UTF8String],
             "family", [family UTF8String],
             "style", [style UTF8String],
@@ -148,7 +148,7 @@ static PyObject*
 coretext_all_fonts(PyObject UNUSED *_self) {
     static CTFontCollectionRef collection = NULL;
     if (collection == NULL) collection = CTFontCollectionCreateFromAvailableFonts(NULL);
-    NSArray *matches = (NSArray *) CTFontCollectionCreateMatchingFontDescriptors(collection);  
+    NSArray *matches = (NSArray *) CTFontCollectionCreateMatchingFontDescriptors(collection);
     PyObject *ans = PyTuple_New([matches count]), *temp;
     if (ans == NULL) return PyErr_NoMemory();
     for (unsigned int i = 0; i < [matches count]; i++) {
@@ -173,14 +173,14 @@ find_substitute_face(CFStringRef str, CTFontRef old_font) {
         if (new_font == old_font) { CFRelease(new_font); continue; }
         return new_font;
     }
-    PyErr_SetString(PyExc_ValueError, "CoreText returned the same font as a fallback font"); 
+    PyErr_SetString(PyExc_ValueError, "CoreText returned the same font as a fallback font");
     return NULL;
 }
 
 PyObject*
 create_fallback_face(PyObject *base_face, Cell* cell, bool UNUSED bold, bool UNUSED italic) {
     CTFace *self = (CTFace*)base_face;
-    char text[128] = {0};
+    char text[256] = {0};
     cell_as_utf8(cell, true, text, ' ');
     CFStringRef str = CFStringCreateWithCString(NULL, text, kCFStringEncodingUTF8);
     if (str == NULL) return PyErr_NoMemory();
@@ -190,7 +190,7 @@ create_fallback_face(PyObject *base_face, Cell* cell, bool UNUSED bold, bool UNU
     return (PyObject*)ct_face(new_font);
 }
 
-unsigned int 
+unsigned int
 glyph_id_for_codepoint(PyObject *s, char_type ch) {
     CTFace *self = (CTFace*)s;
     unichar chars[2] = {0};
@@ -200,6 +200,15 @@ glyph_id_for_codepoint(PyObject *s, char_type ch) {
     return glyphs[0];
 }
 
+bool
+is_glyph_empty(PyObject *s, glyph_index g) {
+    CTFace *self = (CTFace*)s;
+    CGGlyph gg = g;
+    CGRect bounds;
+    CTFontGetBoundingRectsForGlyphs(self->ct_font, kCTFontOrientationHorizontal, &gg, &bounds, 1);
+    return bounds.size.width <= 0;
+}
+
 static inline float
 scaled_point_sz() {
     return ((global_state.logical_dpi_x + global_state.logical_dpi_y) / 144.0) * global_state.font_sz_in_pts;
@@ -216,7 +225,7 @@ set_size_for_face(PyObject *s, unsigned int UNUSED desired_height, bool force) {
     return true;
 }
 
-hb_font_t* 
+hb_font_t*
 harfbuzz_font_for_face(PyObject* s) {
     CTFace *self = (CTFace*)s;
     if (!self->hb_font) {
@@ -227,7 +236,7 @@ harfbuzz_font_for_face(PyObject* s) {
     return self->hb_font;
 }
 
-void 
+void
 cell_metrics(PyObject *s, unsigned int* cell_width, unsigned int* cell_height, unsigned int* baseline, unsigned int* underline_position, unsigned int* underline_thickness) {
     // See https://developer.apple.com/library/content/documentation/StringsTextFonts/Conceptual/TextAndWebiPhoneOS/TypoFeatures/TextSystemFeatures.html
     CTFace *self = (CTFace*)s;
@@ -241,10 +250,10 @@ cell_metrics(PyObject *s, unsigned int* cell_width, unsigned int* cell_height, u
         if (glyphs[i]) {
             w = (unsigned int)(ceilf(
                         CTFontGetAdvancesForGlyphs(self->ct_font, kCTFontOrientationHorizontal, glyphs+i, NULL, 1)));
-            if (w > width) width = w; 
+            if (w > width) width = w;
         }
     }
-    *cell_width = MAX(1, width); 
+    *cell_width = MAX(1, width);
     *underline_position = floor(self->ascent - self->underline_position + 0.5);
     *underline_thickness = (unsigned int)ceil(MAX(0.1, self->underline_thickness));
     *baseline = (unsigned int)self->ascent;
@@ -252,7 +261,7 @@ cell_metrics(PyObject *s, unsigned int* cell_width, unsigned int* cell_height, u
     // Let CoreText's layout engine calculate the line height. Slower, but hopefully more accurate.
     CFStringRef ts = CFSTR("test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test");
     CFMutableAttributedStringRef test_string = CFAttributedStringCreateMutable(kCFAllocatorDefault, CFStringGetLength(ts));
-    CFAttributedStringReplaceString(test_string, CFRangeMake(0, 0), ts); 
+    CFAttributedStringReplaceString(test_string, CFRangeMake(0, 0), ts);
     CFAttributedStringSetAttribute(test_string, CFRangeMake(0, CFStringGetLength(ts)), kCTFontAttributeName, self->ct_font);
     CGMutablePathRef path = CGPathCreateMutable();
     CGPathAddRect(path, NULL, CGRectMake(10, 10, 200, 200));
@@ -263,7 +272,7 @@ cell_metrics(PyObject *s, unsigned int* cell_width, unsigned int* cell_height, u
     CTFrameGetLineOrigins(test_frame, CFRangeMake(0, 1), &origin1);
     CTFrameGetLineOrigins(test_frame, CFRangeMake(1, 1), &origin2);
     CGFloat line_height = origin1.y - origin2.y;
-    CFRelease(test_frame); CFRelease(path); CFRelease(framesetter); 
+    CFRelease(test_frame); CFRelease(path); CFRelease(framesetter);
     *cell_height = MAX(4, (unsigned int)ceilf(line_height));
 #undef count
 }
@@ -278,7 +287,7 @@ face_from_descriptor(PyObject *descriptor) {
     return (PyObject*) ct_face(font);
 }
 
-PyObject* 
+PyObject*
 face_from_path(const char *path, int UNUSED index) {
     CFStringRef s = CFStringCreateWithCString(NULL, path, kCFStringEncodingUTF8);
     CFURLRef url = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, s, kCFURLPOSIXPathStyle, false);
@@ -315,7 +324,7 @@ render_color_glyph(CTFontRef font, uint8_t *buf, int glyph_id, unsigned int widt
     if (ctx == NULL) fatal("Out of memory");
     CGContextSetShouldAntialias(ctx, true);
     CGContextSetShouldSmoothFonts(ctx, true);  // sub-pixel antialias
-    CGContextSetRGBFillColor(ctx, 1, 1, 1, 1); 
+    CGContextSetRGBFillColor(ctx, 1, 1, 1, 1);
     CGAffineTransform transform = CGAffineTransformIdentity;
     CGContextSetTextDrawingMode(ctx, kCGTextFill);
     CGGlyph glyph = glyph_id;
@@ -353,7 +362,7 @@ render_glyphs(CTFontRef font, unsigned int width, unsigned int height, unsigned
     CGContextSetGrayFillColor(render_ctx, 1, 1); // white glyphs
     CGContextSetTextDrawingMode(render_ctx, kCGTextFill);
     CGContextSetTextMatrix(render_ctx, CGAffineTransformIdentity);
-    CGContextSetTextPosition(render_ctx, 0, height - baseline); 
+    CGContextSetTextPosition(render_ctx, 0, height - baseline);
     CTFontDrawGlyphs(font, glyphs, positions, num_glyphs, render_ctx);
 }
 
@@ -420,7 +429,7 @@ static PyMethodDef methods[] = {
 static PyObject *
 repr(CTFace *self) {
     char buf[1024] = {0};
-    snprintf(buf, sizeof(buf)/sizeof(buf[0]), "ascent=%.1f, descent=%.1f, leading=%.1f, point_sz=%.1f, scaled_point_sz=%.1f, underline_position=%.1f underline_thickness=%.1f", 
+    snprintf(buf, sizeof(buf)/sizeof(buf[0]), "ascent=%.1f, descent=%.1f, leading=%.1f, point_sz=%.1f, scaled_point_sz=%.1f, underline_position=%.1f underline_thickness=%.1f",
         (self->ascent), (self->descent), (self->leading), (self->point_sz), (self->scaled_point_sz), (self->underline_position), (self->underline_thickness));
     return PyUnicode_FromFormat(
         "Face(family=%U, full_name=%U, postscript_name=%U, path=%U, units_per_em=%u, %s)",
@@ -455,8 +464,8 @@ PyTypeObject CTFace_Type = {
     PyVarObject_HEAD_INIT(NULL, 0)
     .tp_name = "fast_data_types.CTFace",
     .tp_basicsize = sizeof(CTFace),
-    .tp_dealloc = (destructor)dealloc, 
-    .tp_flags = Py_TPFLAGS_DEFAULT,        
+    .tp_dealloc = (destructor)dealloc,
+    .tp_flags = Py_TPFLAGS_DEFAULT,
     .tp_doc = "CoreText Font face",
     .tp_methods = methods,
     .tp_members = members,
@@ -465,10 +474,10 @@ PyTypeObject CTFace_Type = {
 
 
 
-int 
+int
 init_CoreText(PyObject *module) {
     if (PyType_Ready(&CTFace_Type) < 0) return 0;
-    if (PyModule_AddObject(module, "CTFace", (PyObject *)&CTFace_Type) != 0) return 0; 
+    if (PyModule_AddObject(module, "CTFace", (PyObject *)&CTFace_Type) != 0) return 0;
     if (PyModule_AddFunctions(module, module_methods) != 0) return 0;
     if (Py_AtExit(finalize) != 0) {
         PyErr_SetString(PyExc_RuntimeError, "Failed to register the CoreText at exit handler");

kitty/cursor.c

@@ -39,7 +39,7 @@ repr(Cursor *self) {
     );
 }
 
-void 
+void
 cursor_reset_display_attrs(Cursor *self) {
     self->bg = 0; self->fg = 0; self->decoration_fg = 0;
     self->decoration = 0; self->bold = false; self->italic = false; self->reverse = false; self->strikethrough = false;
@@ -50,25 +50,25 @@ static inline void
 parse_color(unsigned int *params, unsigned int *i, unsigned int count, uint32_t *result) {
     unsigned int attr;
     uint8_t r, g, b;
-    if (*i < count) { 
+    if (*i < count) {
         attr = params[(*i)++];
-        switch(attr) { 
-            case 5: 
-                if (*i < count) *result = (params[(*i)++] & 0xFF) << 8 | 1; 
-                break; 
+        switch(attr) {
+            case 5:
+                if (*i < count) *result = (params[(*i)++] & 0xFF) << 8 | 1;
+                break;
             case 2: \
-                if (*i < count - 2) { 
-                    /* Ignore the first parameter in a four parameter RGB */ 
-                    /* sequence (unused color space id), see https://github.com/kovidgoyal/kitty/issues/227 */ 
-                    if (*i < count - 3) (*i)++; 
-                    r = params[(*i)++] & 0xFF; 
-                    g = params[(*i)++] & 0xFF; 
-                    b = params[(*i)++] & 0xFF; 
-                    *result = r << 24 | g << 16 | b << 8 | 2; 
+                if (*i < count - 2) {
+                    /* Ignore the first parameter in a four parameter RGB */
+                    /* sequence (unused color space id), see https://github.com/kovidgoyal/kitty/issues/227 */
+                    if (*i < count - 3) (*i)++;
+                    r = params[(*i)++] & 0xFF;
+                    g = params[(*i)++] & 0xFF;
+                    b = params[(*i)++] & 0xFF;
+                    *result = r << 24 | g << 16 | b << 8 | 2;
                 }
-                break; 
-        } 
-    } 
+                break;
+        }
+    }
 }
 
 
@@ -109,13 +109,13 @@ START_ALLOW_CASE_RANGE
                 self->strikethrough = false;  break;
             case 30 ... 37:
                 self->fg = ((attr - 30) << 8) | 1;  break;
-            case 38: 
+            case 38:
                 SET_COLOR(fg);
             case 39:
                 self->fg = 0;  break;
             case 40 ... 47:
                 self->bg = ((attr - 40) << 8) | 1;  break;
-            case 48: 
+            case 48:
                 SET_COLOR(bg);
             case 49:
                 self->bg = 0;  break;
@@ -124,7 +124,7 @@ START_ALLOW_CASE_RANGE
             case 100 ... 107:
                 self->bg = ((attr - 100 + 8) << 8) | 1;  break;
             case DECORATION_FG_CODE:
-                SET_COLOR(decoration_fg); 
+                SET_COLOR(decoration_fg);
             case DECORATION_FG_CODE + 1:
                 self->decoration_fg = 0; break;
         }
@@ -149,7 +149,7 @@ apply_sgr_to_cells(Cell *first_cell, unsigned int cell_count, unsigned int *para
         attr = params[i++];
         switch(attr) {
             case 0:
-                RANGE { cell->attrs &= WIDTH_MASK; cell->fg = 0; cell->bg = 0; cell->decoration_fg = 0; } 
+                RANGE { cell->attrs &= WIDTH_MASK; cell->fg = 0; cell->bg = 0; cell->decoration_fg = 0; }
                 break;
             case 1:
                 SET(BOLD_SHIFT);
@@ -177,13 +177,13 @@ apply_sgr_to_cells(Cell *first_cell, unsigned int cell_count, unsigned int *para
 START_ALLOW_CASE_RANGE
             case 30 ... 37:
                 SIMPLE(fg, ((attr - 30) << 8) | 1);
-            case 38: 
+            case 38:
                 SET_COLOR(fg);
             case 39:
                 SIMPLE(fg, 0);
             case 40 ... 47:
                 SIMPLE(bg, ((attr - 40) << 8) | 1);
-            case 48: 
+            case 48:
                 SET_COLOR(bg);
             case 49:
                 SIMPLE(bg, 0);
@@ -224,14 +224,14 @@ color_as_sgr(char *buf, size_t sz, unsigned long val, unsigned simple_code, unsi
 static inline const char*
 decoration_as_sgr(uint8_t decoration) {
     switch(decoration) {
-        case 1: return "4"; 
-        case 2: return "4:2";  
+        case 1: return "4";
+        case 2: return "4:2";
         case 3: return "4:3";
         default: return "24";
     }
 }
 
-const char* 
+const char*
 cursor_as_sgr(Cursor *self, Cursor *prev) {
     static char buf[128];
 #define SZ sizeof(buf) - (p - buf) - 2
@@ -267,8 +267,8 @@ void cursor_reset(Cursor *self) {
 
 void cursor_copy_to(Cursor *src, Cursor *dest) {
 #define CCY(x) dest->x = src->x;
-    CCY(x); CCY(y); CCY(shape); CCY(blink); 
-    CCY(bold); CCY(italic); CCY(strikethrough); CCY(reverse); CCY(decoration); CCY(fg); CCY(bg); CCY(decoration_fg); 
+    CCY(x); CCY(y); CCY(shape); CCY(blink);
+    CCY(bold); CCY(italic); CCY(strikethrough); CCY(reverse); CCY(decoration); CCY(fg); CCY(bg); CCY(decoration_fg);
 }
 
 static PyObject*
@@ -317,21 +317,21 @@ PyTypeObject Cursor_Type = {
     PyVarObject_HEAD_INIT(NULL, 0)
     .tp_name = "fast_data_types.Cursor",
     .tp_basicsize = sizeof(Cursor),
-    .tp_dealloc = (destructor)dealloc, 
+    .tp_dealloc = (destructor)dealloc,
     .tp_repr = (reprfunc)repr,
-    .tp_flags = Py_TPFLAGS_DEFAULT,        
+    .tp_flags = Py_TPFLAGS_DEFAULT,
     .tp_doc = "Cursors",
-    .tp_richcompare = richcmp,                   
+    .tp_richcompare = richcmp,
     .tp_methods = methods,
-    .tp_members = members,            
+    .tp_members = members,
     .tp_getset = getseters,
-    .tp_new = new,                
+    .tp_new = new,
 };
 
 RICHCMP(Cursor)
 
 // }}}
- 
+
 Cursor*
 cursor_copy(Cursor *self) {
     Cursor* ans;

kitty/data-types.c

@@ -163,8 +163,8 @@ static PyMethodDef module_methods[] = {
 static struct PyModuleDef module = {
    .m_base = PyModuleDef_HEAD_INIT,
    .m_name = "fast_data_types",   /* name of module */
-   .m_doc = NULL, 
-   .m_size = -1,       
+   .m_doc = NULL,
+   .m_size = -1,
    .m_methods = module_methods
 };
 
@@ -180,10 +180,12 @@ extern bool init_fontconfig_library(PyObject*);
 extern bool init_desktop(PyObject*);
 extern bool init_fonts(PyObject*);
 extern bool init_glfw(PyObject *m);
+extern bool init_child(PyObject *m);
 extern bool init_state(PyObject *module);
 extern bool init_keys(PyObject *module);
 extern bool init_graphics(PyObject *module);
 extern bool init_shaders(PyObject *module);
+extern bool init_mouse(PyObject *module);
 #ifdef __APPLE__
 extern int init_CoreText(PyObject *);
 extern bool init_cocoa(PyObject *module);
@@ -211,10 +213,12 @@ PyInit_fast_data_types(void) {
         if (!init_ColorProfile(m)) return NULL;
         if (!init_Screen(m)) return NULL;
         if (!init_glfw(m)) return NULL;
+        if (!init_child(m)) return NULL;
         if (!init_state(m)) return NULL;
         if (!init_keys(m)) return NULL;
         if (!init_graphics(m)) return NULL;
         if (!init_shaders(m)) return NULL;
+        if (!init_mouse(m)) return NULL;
 #ifdef __APPLE__
         if (!init_CoreText(m)) return NULL;
         if (!init_cocoa(m)) return NULL;
@@ -227,7 +231,7 @@ PyInit_fast_data_types(void) {
 
 #define OOF(n) #n, offsetof(Cell, n)
         if (PyModule_AddObject(m, "CELL", Py_BuildValue("{sI sI sI sI sI sI sI sI sI}",
-                    OOF(ch), OOF(fg), OOF(bg), OOF(decoration_fg), OOF(cc), OOF(sprite_x), OOF(sprite_y), OOF(sprite_z), "size", sizeof(Cell))) != 0) return NULL;
+                    OOF(ch), OOF(fg), OOF(bg), OOF(decoration_fg), OOF(cc_idx), OOF(sprite_x), OOF(sprite_y), OOF(sprite_z), "size", sizeof(Cell))) != 0) return NULL;
 #undef OOF
         PyModule_AddIntConstant(m, "BOLD", BOLD_SHIFT);
         PyModule_AddIntConstant(m, "ITALIC", ITALIC_SHIFT);

kitty/data-types.h

@@ -25,12 +25,13 @@
 #define MIN(x, y) (((x) > (y)) ? (y) : (x))
 #define xstr(s) str(s)
 #define str(s) #s
+#define arraysz(x) (sizeof(x)/sizeof(x[0]))
 #define fatal(...) { fprintf(stderr, __VA_ARGS__); fprintf(stderr, "\n"); exit(EXIT_FAILURE); }
 
 typedef unsigned long long id_type;
 typedef uint32_t char_type;
 typedef uint32_t color_type;
-typedef uint32_t combining_type;
+typedef uint16_t combining_type;
 typedef uint32_t pixel;
 typedef unsigned int index_type;
 typedef uint16_t sprite_index;
@@ -55,8 +56,6 @@ typedef enum MouseShapes { BEAM, HAND, ARROW } MouseShape;
 #define REVERSE_SHIFT 6
 #define STRIKE_SHIFT 7
 #define COL_MASK 0xFFFFFFFF
-#define CC_MASK 0xFFFF
-#define CC_SHIFT 16
 #define UTF8_ACCEPT 0
 #define UTF8_REJECT 1
 #define DECORATION_FG_CODE 58
@@ -69,7 +68,7 @@ typedef enum MouseShapes { BEAM, HAND, ARROW } MouseShape;
 
 #define CURSOR_TO_ATTRS(c, w) \
     ((w) | (((c->decoration & 3) << DECORATION_SHIFT) | ((c->bold & 1) << BOLD_SHIFT) | \
-            ((c->italic & 1) << ITALIC_SHIFT) | ((c->reverse & 1) << REVERSE_SHIFT) | ((c->strikethrough & 1) << STRIKE_SHIFT))) 
+            ((c->italic & 1) << ITALIC_SHIFT) | ((c->reverse & 1) << REVERSE_SHIFT) | ((c->strikethrough & 1) << STRIKE_SHIFT)))
 
 #define ATTRS_TO_CURSOR(a, c) \
     (c)->decoration = (a >> DECORATION_SHIFT) & 3; (c)->bold = (a >> BOLD_SHIFT) & 1; (c)->italic = (a >> ITALIC_SHIFT) & 1; \
@@ -133,11 +132,12 @@ typedef struct {
 } Region;
 
 typedef struct {
-    char_type ch;
     color_type fg, bg, decoration_fg;
-    combining_type cc;
     sprite_index sprite_x, sprite_y, sprite_z;
     attrs_type attrs;
+    // The following are only needed on the CPU, not the GPU
+    char_type ch;
+    combining_type cc_idx[2];
 } Cell;
 
 typedef struct {
@@ -181,7 +181,7 @@ typedef struct {
 } Cursor;
 
 typedef struct {
-    bool is_visible;
+    bool is_visible, is_focused;
     CursorShape shape;
     unsigned int x, y;
     double left, right, top, bottom;
@@ -221,7 +221,7 @@ typedef struct {
 #define PARSER_BUF_SZ (8 * 1024)
 #define READ_BUF_SZ (1024*1024)
 
-#define clear_sprite_position(cell) (cell).sprite_x = 0; (cell).sprite_y = 0; (cell).sprite_z = 0; 
+#define clear_sprite_position(cell) (cell).sprite_x = 0; (cell).sprite_y = 0; (cell).sprite_z = 0;
 
 #define left_shift_line(line, at, num) \
     for(index_type __i__ = (at); __i__ < (line)->xnum - (num); __i__++) { \
@@ -243,7 +243,7 @@ typedef struct {
     }
 
 
-// Global functions 
+// Global functions
 const char* base64_decode(const uint32_t *src, size_t src_sz, uint8_t *dest, size_t dest_capacity, size_t *dest_sz);
 Line* alloc_line();
 Cursor* alloc_cursor();
@@ -278,7 +278,7 @@ void mouse_event(int, int);
 void focus_in_event();
 void wakeup_io_loop(bool);
 void scroll_event(double, double);
-void fake_scroll(bool);
+void fake_scroll(int, bool);
 void set_special_key_combo(int glfw_key, int mods);
 void on_text_input(unsigned int codepoint, int mods);
 void on_key_input(int key, int scancode, int action, int mods);

kitty/emoji.h

@@ -1,9 +1,17 @@
+// unicode data, built from the unicode standard on: 2018-01-18
+// see gen-wcwidth.py
 #pragma once
 #include "data-types.h"
 
 START_ALLOW_CASE_RANGE
-static inline bool is_emoji(uint32_t code) {
+
+static inline bool
+is_emoji(char_type code) {
 	switch(code) {
+		case 0x2194 ... 0x2199:
+			return true;
+		case 0x21a9 ... 0x21aa:
+			return true;
 		case 0x231a ... 0x231b:
 			return true;
 		case 0x2328:
@@ -274,14 +282,16 @@ static inline bool is_emoji(uint32_t code) {
 			return true;
 		default: return false;
 	}
-	return false; 
+	return false;
 }
-static inline bool is_emoji_modifier(uint32_t code) {
+static inline bool
+is_emoji_modifier(char_type code) {
 	switch(code) {
 		case 0x1f3fb ... 0x1f3ff:
 			return true;
 		default: return false;
 	}
-	return false; 
+	return false;
 }
+
 END_ALLOW_CASE_RANGE

kitty/fontconfig.c

@@ -131,9 +131,9 @@ add_charset(FcPattern *pat, size_t num) {
         charset = FcCharSetCreate();
         if (charset == NULL) { PyErr_NoMemory(); goto end; }
         for (size_t i = 0; i < num; i++) {
-            if (!FcCharSetAddChar(charset, char_buf[i])) { 
-                PyErr_SetString(PyExc_RuntimeError, "Failed to add character to fontconfig charset"); 
-                goto end; 
+            if (!FcCharSetAddChar(charset, char_buf[i])) {
+                PyErr_SetString(PyExc_RuntimeError, "Failed to add character to fontconfig charset");
+                goto end;
             }
         }
         AP(FcPatternAddCharSet, FC_CHARSET, charset, "charset");
@@ -214,7 +214,7 @@ static PyMethodDef module_methods[] = {
     {NULL, NULL, 0, NULL}        /* Sentinel */
 };
 
-bool 
+bool
 init_fontconfig_library(PyObject *module) {
     if (!FcInit()) {
         PyErr_SetString(PyExc_RuntimeError, "Failed to initialize the fontconfig library");

kitty/fonts.c

@@ -1,4 +1,5 @@
 /*
+ * vim:fileencoding=utf-8
  * fonts.c
  * Copyright (C) 2017 Kovid Goyal <kovid at kovidgoyal.net>
  *
@@ -8,11 +9,11 @@
 #include "fonts.h"
 #include "state.h"
 #include "emoji.h"
+#include "unicode-data.h"
 
 #define MISSING_GLYPH 4
 #define MAX_NUM_EXTRA_GLYPHS 8
 
-typedef uint16_t glyph_index;
 typedef void (*send_sprite_to_gpu_func)(unsigned int, unsigned int, unsigned int, pixel*);
 send_sprite_to_gpu_func current_send_sprite_to_gpu = NULL;
 static PyObject *python_send_to_gpu_impl = NULL;
@@ -36,11 +37,15 @@ struct SpritePosition {
     ExtraGlyphs extra_glyphs;
 };
 
+#define SPECIAL_FILLED_MASK 1
+#define SPECIAL_VALUE_MASK 2
+#define EMPTY_FILLED_MASK 4
+#define EMPTY_VALUE_MASK 8
 
 struct SpecialGlyphCache {
     SpecialGlyphCache *next;
     glyph_index glyph;
-    bool is_special, filled;
+    uint8_t data;
 };
 
 typedef struct {
@@ -51,13 +56,13 @@ typedef struct {
 
 static GPUSpriteTracker sprite_tracker = {0};
 static hb_buffer_t *harfbuzz_buffer = NULL;
-static char_type shape_buffer[2048] = {0};
+static char_type shape_buffer[4096] = {0};
 
 
 typedef struct {
     PyObject *face;
     // Map glyphs to sprite map co-ords
-    SpritePosition sprite_map[1024]; 
+    SpritePosition sprite_map[1024];
     SpecialGlyphCache special_glyph_cache[1024];
     bool bold, italic;
 } Font;
@@ -79,7 +84,7 @@ static Fonts fonts = {0};
 
 // Sprites {{{
 
-static inline void 
+static inline void
 sprite_map_set_error(int error) {
     switch(error) {
         case 1:
@@ -150,20 +155,20 @@ sprite_position_for(Font *font, glyph_index glyph, ExtraGlyphs *extra_glyphs, ui
     return s;
 }
 
-static SpecialGlyphCache*
-special_glyph_cache_for(Font *font, glyph_index glyph) {
+static inline SpecialGlyphCache*
+special_glyph_cache_for(Font *font, glyph_index glyph, uint8_t mask) {
     SpecialGlyphCache *s = font->special_glyph_cache + (glyph & 0x3ff);
     // Optimize for the common case of glyph under 1024 already in the cache
-    if (LIKELY(s->glyph == glyph && s->filled)) return s;  // Cache hit
+    if (LIKELY(s->glyph == glyph && s->data & mask)) return s;  // Cache hit
     while(true) {
-        if (s->filled) {
+        if (s->data & mask) {
             if (s->glyph == glyph) return s;  // Cache hit
         } else {
             break;
         }
         if (!s->next) {
             s->next = calloc(1, sizeof(SpecialGlyphCache));
-            if (s->next == NULL) return NULL; 
+            if (s->next == NULL) return NULL;
         }
         s = s->next;
     }
@@ -211,7 +216,7 @@ clear_sprite_map(Font *font) {
 
 void
 clear_special_glyph_cache(Font *font) {
-#define CLEAR(s) s->filled = false; s->glyph = 0; 
+#define CLEAR(s) s->data = 0; s->glyph = 0;
     SpecialGlyphCache *s;
     for (size_t i = 0; i < sizeof(font->special_glyph_cache)/sizeof(font->special_glyph_cache[0]); i++) {
         s = font->special_glyph_cache + i;
@@ -247,14 +252,14 @@ init_font(Font *f, PyObject *descriptor, bool bold, bool italic, bool is_face) {
     PyObject *face;
     if (is_face) { face = descriptor; Py_INCREF(face); }
     else { face = desc_to_face(descriptor); if (face == NULL) return false; }
-    f->face = face; 
+    f->face = face;
     f->bold = bold; f->italic = italic;
     return true;
 }
 
 static inline void
-del_font(Font *f) { 
-    Py_CLEAR(f->face); 
+del_font(Font *f) {
+    Py_CLEAR(f->face);
     free_maps(f);
     f->bold = false; f->italic = false;
 }
@@ -262,7 +267,7 @@ del_font(Font *f) {
 static unsigned int cell_width = 0, cell_height = 0, baseline = 0, underline_position = 0, underline_thickness = 0;
 static pixel *canvas = NULL;
 #define CELLS_IN_CANVAS ((MAX_NUM_EXTRA_GLYPHS + 1) * 3)
-static inline void 
+static inline void
 clear_canvas(void) { memset(canvas, 0, CELLS_IN_CANVAS * cell_width * cell_height * sizeof(pixel)); }
 
 static void
@@ -289,6 +294,8 @@ update_cell_metrics() {
     if (cell_height < 4) { PyErr_SetString(PyExc_ValueError, "line height too small after adjustment"); return NULL; }
     if (cell_height > 1000) { PyErr_SetString(PyExc_ValueError, "line height too large after adjustment"); return NULL; }
     underline_position = MIN(cell_height - 1, underline_position);
+    // ensure there is at least a couple of pixels available to render styled underlines
+    while (underline_position > baseline + 1 && cell_height - underline_position < 2) underline_position--;
     if (line_height_adjustment > 1) {
         baseline += MIN(cell_height - 1, (unsigned)line_height_adjustment / 2);
         underline_position += MIN(cell_height - 1, (unsigned)line_height_adjustment / 2);
@@ -318,31 +325,20 @@ face_has_codepoint(PyObject* face, char_type cp) {
     return glyph_id_for_codepoint(face, cp) > 0;
 }
 
-static inline bool 
+static inline bool
 has_cell_text(Font *self, Cell *cell) {
     if (!face_has_codepoint(self->face, cell->ch)) return false;
-    if (cell->cc) {
-        if (!face_has_codepoint(self->face, cell->cc & CC_MASK)) return false;
-        char_type cc = cell->cc >> 16;
-        if (cc && !face_has_codepoint(self->face, cc)) return false;
+    for (unsigned i = 0; i < arraysz(cell->cc_idx) && cell->cc_idx[i]; i++) {
+        if (!face_has_codepoint(self->face, codepoint_for_mark(cell->cc_idx[i]))) return false;
     }
     return true;
 }
 
+
 static inline ssize_t
-fallback_font(Cell *cell) {
-    bool bold = (cell->attrs >> BOLD_SHIFT) & 1;
-    bool italic = (cell->attrs >> ITALIC_SHIFT) & 1;
-    ssize_t f;
-
-    for (size_t i = 0, j = fonts.first_fallback_font_idx; i < fonts.fallback_fonts_count; i++, j++)  {
-        Font *ff = fonts.fonts +j;
-        if (ff->bold == bold && ff->italic == italic && has_cell_text(ff, cell)) {
-            return j;
-        }
-    }
-
+load_fallback_font(Cell *cell, bool bold, bool italic) {
     if (fonts.fallback_fonts_count > 100) { fprintf(stderr, "Too many fallback fonts\n"); return MISSING_FONT; }
+    ssize_t f;
 
     if (bold) f = fonts.italic_font_idx > 0 ? fonts.bi_font_idx : fonts.bold_font_idx;
     else f = italic ? fonts.italic_font_idx : fonts.medium_font_idx;
@@ -363,6 +359,31 @@ fallback_font(Cell *cell) {
     return ans;
 }
 
+
+static inline ssize_t
+fallback_font(Cell *cell) {
+    bool bold = (cell->attrs >> BOLD_SHIFT) & 1;
+    bool italic = (cell->attrs >> ITALIC_SHIFT) & 1;
+
+    // Load the emoji fallback font first as on Linux there are a bunch of
+    // non-color fonts that provide some emoji glyphs.
+    if (fonts.fallback_fonts_count < 1) {
+        Cell c = {0};
+        c.ch = 0x1f648;  // 🙈
+        load_fallback_font(&c, false, false);
+    }
+
+    // Check if one of the existing fallback fonts has this text
+    for (size_t i = 0, j = fonts.first_fallback_font_idx; i < fonts.fallback_fonts_count; i++, j++)  {
+        Font *ff = fonts.fonts +j;
+        if (ff->bold == bold && ff->italic == italic && has_cell_text(ff, cell)) {
+            return j;
+        }
+    }
+
+    return load_fallback_font(cell, bold, italic);
+}
+
 static inline ssize_t
 in_symbol_maps(char_type ch) {
     for (size_t i = 0; i < fonts.symbol_maps_count; i++) {
@@ -441,7 +462,7 @@ render_alpha_mask(uint8_t *alpha_mask, pixel* dest, Region *src_rect, Region *de
     }
 }
 
-static void 
+static void
 render_box_cell(Cell *cell) {
     int error = 0;
     glyph_index glyph = box_glyph_id(cell->ch);
@@ -467,19 +488,17 @@ render_box_cell(Cell *cell) {
 }
 
 static inline void
-load_hb_buffer(Cell *first_cell, index_type num_cells) {  
+load_hb_buffer(Cell *first_cell, index_type num_cells) {
     index_type num;
     hb_buffer_clear_contents(harfbuzz_buffer);
     while (num_cells) {
         attrs_type prev_width = 0;
-        for (num = 0; num_cells && num < sizeof(shape_buffer)/sizeof(shape_buffer[0]) - 20; first_cell++, num_cells--) {
+        for (num = 0; num_cells && num < arraysz(shape_buffer) - 20 - arraysz(first_cell->cc_idx); first_cell++, num_cells--) {
             if (prev_width == 2) { prev_width = 0; continue; }
             shape_buffer[num++] = first_cell->ch;
             prev_width = first_cell->attrs & WIDTH_MASK;
-            if (first_cell->cc) {
-                shape_buffer[num++] = first_cell->cc & CC_MASK;
-                combining_type cc2 = first_cell->cc >> 16;
-                if (cc2) shape_buffer[num++] = cc2 & CC_MASK;
+            for (unsigned i = 0; i < arraysz(first_cell->cc_idx) && first_cell->cc_idx[i]; i++) {
+                shape_buffer[num++] = codepoint_for_mark(first_cell->cc_idx[i]);
             }
         }
         hb_buffer_add_utf32(harfbuzz_buffer, shape_buffer, num, 0, num);
@@ -521,10 +540,10 @@ render_group(unsigned int num_cells, unsigned int num_glyphs, Cell *cells, hb_gl
     render_glyphs_in_cells(font->face, font->bold, font->italic, info, positions, num_glyphs, canvas, cell_width, cell_height, num_cells, baseline, &was_colored);
     if (PyErr_Occurred()) PyErr_Print();
 
-    for (unsigned int i = 0; i < num_cells; i++) { 
+    for (unsigned int i = 0; i < num_cells; i++) {
         sprite_position[i]->rendered = true;
         sprite_position[i]->colored = was_colored;
-        set_cell_sprite(cells + i, sprite_position[i]); 
+        set_cell_sprite(cells + i, sprite_position[i]);
         pixel *buf = num_cells == 1 ? canvas : extract_cell_from_canvas(i, num_cells);
         current_send_sprite_to_gpu(sprite_position[i]->x, sprite_position[i]->y, sprite_position[i]->z, buf);
     }
@@ -538,28 +557,84 @@ typedef struct {
     char_type current_codepoint;
 } CellData;
 
+typedef struct {
+    unsigned int first_glyph_idx, first_cell_idx, num_glyphs, num_cells;
+} Group;
+
+typedef struct {
+    uint32_t previous_cluster;
+    bool prev_was_special, prev_was_empty;
+    CellData current_cell_data;
+    Group *groups;
+    size_t groups_capacity, group_idx, glyph_idx, cell_idx, num_cells, num_glyphs;
+    Cell *first_cell, *last_cell;
+    hb_glyph_info_t *info;
+    hb_glyph_position_t *positions;
+} GroupState;
+
+static GroupState group_state = {0};
+
+static inline unsigned int
+num_codepoints_in_cell(Cell *cell) {
+    unsigned int ans = 1;
+    for (unsigned i = 0; i < arraysz(cell->cc_idx) && cell->cc_idx[i]; i++) ans++;
+    return ans;
+}
+
+static inline void
+shape(Cell *first_cell, index_type num_cells, hb_font_t *font) {
+    if (group_state.groups_capacity <= 2 * num_cells) {
+        group_state.groups_capacity = MAX(128, 2 * num_cells);  // avoid unnecessary reallocs
+        group_state.groups = realloc(group_state.groups, sizeof(Group) * group_state.groups_capacity);
+        if (!group_state.groups) fatal("Out of memory");
+    }
+    group_state.previous_cluster = UINT32_MAX;
+    group_state.prev_was_special = false;
+    group_state.prev_was_empty = false;
+    group_state.current_cell_data.cell = first_cell; group_state.current_cell_data.num_codepoints = num_codepoints_in_cell(first_cell); group_state.current_cell_data.codepoints_consumed = 0; group_state.current_cell_data.current_codepoint = first_cell->ch;
+    memset(group_state.groups, 0, sizeof(Group) * group_state.groups_capacity);
+    group_state.group_idx = 0;
+    group_state.glyph_idx = 0;
+    group_state.cell_idx = 0;
+    group_state.num_cells = num_cells;
+    group_state.first_cell = first_cell;
+    group_state.last_cell = first_cell + (num_cells ? num_cells - 1 : 0);
+    load_hb_buffer(first_cell, num_cells);
+    hb_shape(font, harfbuzz_buffer, NULL, 0);
+    unsigned int info_length, positions_length;
+    group_state.info = hb_buffer_get_glyph_infos(harfbuzz_buffer, &info_length);
+    group_state.positions = hb_buffer_get_glyph_positions(harfbuzz_buffer, &positions_length);
+    if (!group_state.info || !group_state.positions) group_state.num_glyphs = 0;
+    else group_state.num_glyphs = MIN(info_length, positions_length);
+}
 
 static inline bool
 is_special_glyph(glyph_index glyph_id, Font *font, CellData* cell_data) {
     // A glyph is special if the codepoint it corresponds to matches a
     // different glyph in the font
-    SpecialGlyphCache *s = special_glyph_cache_for(font, glyph_id);
+    SpecialGlyphCache *s = special_glyph_cache_for(font, glyph_id, SPECIAL_FILLED_MASK);
     if (s == NULL) return false;
-    if (!s->filled) {
-        s->is_special = cell_data->current_codepoint ? (
-            glyph_id != glyph_id_for_codepoint(font->face, cell_data->current_codepoint) ? true : false) 
+    if (!(s->data & SPECIAL_FILLED_MASK)) {
+        bool is_special = cell_data->current_codepoint ? (
+            glyph_id != glyph_id_for_codepoint(font->face, cell_data->current_codepoint) ? true : false)
             :
             false;
-        s->filled = true;
-    } 
-    return s->is_special;
+        uint8_t val = is_special ? SPECIAL_VALUE_MASK : 0;
+        s->data |= val | SPECIAL_FILLED_MASK;
+    }
+    return s->data & SPECIAL_VALUE_MASK;
 }
 
-static inline unsigned int
-num_codepoints_in_cell(Cell *cell) {
-    unsigned int ans = 1;
-    if (cell->cc) ans += ((cell->cc >> CC_SHIFT) & CC_MASK) ? 2 : 1;
-    return ans;
+static inline bool
+is_empty_glyph(glyph_index glyph_id, Font *font) {
+    // A glyph is empty if its metrics have a width of zero
+    SpecialGlyphCache *s = special_glyph_cache_for(font, glyph_id, EMPTY_FILLED_MASK);
+    if (s == NULL) return false;
+    if (!(s->data & EMPTY_FILLED_MASK)) {
+        uint8_t val = is_glyph_empty(font->face, glyph_id) ? EMPTY_VALUE_MASK : 0;
+        s->data |= val | EMPTY_FILLED_MASK;
+    }
+    return s->data & EMPTY_VALUE_MASK;
 }
 
 static inline unsigned int
@@ -579,100 +654,140 @@ check_cell_consumed(CellData *cell_data, Cell *last_cell) {
             case 0:
                 cell_data->current_codepoint = cell_data->cell->ch;
                 break;
-            case 1:
-                cell_data->current_codepoint = cell_data->cell->cc & CC_MASK;
-                break;
-            case 2:
-                cell_data->current_codepoint = (cell_data->cell->cc >> CC_SHIFT) & CC_MASK;
-                break;
             default:
-                cell_data->current_codepoint = 0;
+                cell_data->current_codepoint = codepoint_for_mark(cell_data->cell->cc_idx[cell_data->codepoints_consumed - 1]);
                 break;
         }
     }
     return 0;
 }
 
-static inline glyph_index
-next_group(Font *font, unsigned int *num_group_cells, unsigned int *num_group_glyphs, Cell *cells, hb_glyph_info_t *info, unsigned int max_num_glyphs, unsigned int max_num_cells, ExtraGlyphs *extra_glyphs) {
-    // See https://github.com/behdad/harfbuzz/issues/615 for a discussion of
-    // how to break text into cells. In addition, we have to deal with
-    // monospace ligature fonts that use dummy glyphs of zero size to implement
-    // their ligatures.
-    
-    CellData cell_data;
-    cell_data.cell = cells; cell_data.num_codepoints = num_codepoints_in_cell(cells); cell_data.codepoints_consumed = 0; cell_data.current_codepoint = cells->ch;
-#define LIMIT (MAX_NUM_EXTRA_GLYPHS + 1)
-    glyph_index glyphs_in_group[LIMIT];
-    unsigned int ncells = 0, nglyphs = 0, n;
-    uint32_t previous_cluster = UINT32_MAX, cluster;
-    Cell *last_cell = cells + max_num_cells;
-    unsigned int cell_limit = MIN(max_num_cells, LIMIT + 1), glyph_limit = MIN(LIMIT, max_num_glyphs);
-    bool is_special, prev_was_special = false;
-
-    while(nglyphs < glyph_limit && ncells < cell_limit) {
-        glyph_index glyph_id = info[nglyphs].codepoint;
-        cluster = info[nglyphs].cluster;
-        is_special = is_special_glyph(glyph_id, font, &cell_data);
-        if (prev_was_special && !is_special) break; 
-        glyphs_in_group[nglyphs++] = glyph_id;
-        // Soak up a number of codepoints indicated by the difference in cluster numbers.
-        if (cluster > previous_cluster || nglyphs == 1) {
-            n = nglyphs == 1 ? 1 : cluster - previous_cluster;
-            unsigned int before = ncells;
-            while(n-- && ncells < max_num_cells) ncells += check_cell_consumed(&cell_data, last_cell);
-            if (ncells > before && !is_special) break;
-        }
-        previous_cluster = cluster;
-        prev_was_special = is_special;
-    }
-    *num_group_cells = MAX(1, MIN(ncells, cell_limit));
-    *num_group_glyphs = MAX(1, MIN(nglyphs, glyph_limit));
-    memset(extra_glyphs, 0, sizeof(ExtraGlyphs));
-
-    switch(nglyphs) {
-        case 0:
-        case 1:
-            break;
-        default:
-            memcpy(&extra_glyphs->data, glyphs_in_group + 1, sizeof(glyph_index) * MIN(MAX_NUM_EXTRA_GLYPHS, nglyphs - 1));
-            break;
-    }
-#undef LIMIT
-    return glyphs_in_group[0];
-}
-
-static inline unsigned int
-shape(Cell *first_cell, index_type num_cells, hb_font_t *font, hb_glyph_info_t **info, hb_glyph_position_t **positions) {
-    load_hb_buffer(first_cell, num_cells);
-    hb_shape(font, harfbuzz_buffer, NULL, 0);
-    unsigned int info_length, positions_length;
-    *info = hb_buffer_get_glyph_infos(harfbuzz_buffer, &info_length);
-    *positions = hb_buffer_get_glyph_positions(harfbuzz_buffer, &positions_length);
-    if (!info || !positions) return 0;
-    return MIN(info_length, positions_length);
-}
-
 
 static inline void
 shape_run(Cell *first_cell, index_type num_cells, Font *font) {
-    hb_glyph_info_t *info;
-    hb_glyph_position_t *positions;
-    unsigned int num_glyphs = shape(first_cell, num_cells, harfbuzz_font_for_face(font->face), &info, &positions);
+    shape(first_cell, num_cells, harfbuzz_font_for_face(font->face));
 #if 0
         // You can also generate this easily using hb-shape --show-extents --cluster-level=1 --shapers=ot /path/to/font/file text
-        hb_buffer_serialize_glyphs(harfbuzz_buffer, 0, num_glyphs, (char*)canvas, sizeof(pixel) * CELLS_IN_CANVAS * cell_width * cell_height, NULL, harfbuzz_font_for_face(font->face), HB_BUFFER_SERIALIZE_FORMAT_TEXT, HB_BUFFER_SERIALIZE_FLAG_DEFAULT | HB_BUFFER_SERIALIZE_FLAG_GLYPH_EXTENTS);
+        hb_buffer_serialize_glyphs(harfbuzz_buffer, 0, group_state.num_glyphs, (char*)canvas, sizeof(pixel) * CELLS_IN_CANVAS * cell_width * cell_height, NULL, harfbuzz_font_for_face(font->face), HB_BUFFER_SERIALIZE_FORMAT_TEXT, HB_BUFFER_SERIALIZE_FLAG_DEFAULT | HB_BUFFER_SERIALIZE_FLAG_GLYPH_EXTENTS);
         printf("\n%s\n", (char*)canvas);
         clear_canvas();
 #endif
-    unsigned int run_pos = 0, cell_pos = 0, num_group_glyphs, num_group_cells;
-    ExtraGlyphs extra_glyphs;
-    glyph_index first_glyph;
-    while(run_pos < num_glyphs && cell_pos < num_cells) {
-        first_glyph = next_group(font, &num_group_cells, &num_group_glyphs, first_cell + cell_pos, info + run_pos, num_glyphs - run_pos, num_cells - cell_pos, &extra_glyphs);
-        /* printf("Group: num_group_cells: %u num_group_glyphs: %u\n", num_group_cells, num_group_glyphs); */
-        render_group(num_group_cells, num_group_glyphs, first_cell + cell_pos, info + run_pos, positions + run_pos, font, first_glyph, &extra_glyphs);
-        run_pos += num_group_glyphs; cell_pos += num_group_cells;
+    /* Now distribute the glyphs into groups of cells
+     * Considerations to keep in mind:
+     * Group sizes should be as small as possible for best performance
+     * Combining chars can result in multiple glyphs rendered into a single cell
+     * Emoji and East Asian wide chars can cause a single glyph to be rendered over multiple cells
+     * Ligature fonts, take two common approaches:
+     * 1. ABC becomes EMPTY, EMPTY, WIDE GLYPH this means we have to render N glyphs in N cells (example Fira Code)
+     * 2. ABC becomes WIDE GLYPH this means we have to render one glyph in N cells (example Operator Mono Lig)
+     *
+     * We rely on the cluster numbers from harfbuzz to tell us how many unicode codepoints a glyph corresponds to.
+     * Then we check if the glyph is a ligature glyph (is_special_glyph) and if it is an empty glyph. These three
+     * datapoints give us enough information to satisfy the constraint above, for a wide variety of fonts.
+     */
+    uint32_t cluster, next_cluster;
+    bool add_to_current_group;
+#define G(x) (group_state.x)
+#define MAX_GLYPHS_IN_GROUP (MAX_NUM_EXTRA_GLYPHS + 1)
+    while (G(glyph_idx) < G(num_glyphs) && G(cell_idx) < G(num_cells)) {
+        glyph_index glyph_id = G(info)[G(glyph_idx)].codepoint;
+        cluster = G(info)[G(glyph_idx)].cluster;
+        bool is_special = is_special_glyph(glyph_id, font, &G(current_cell_data));
+        bool is_empty = is_special && is_empty_glyph(glyph_id, font);
+        uint32_t num_codepoints_used_by_glyph = 0;
+        bool is_last_glyph = G(glyph_idx) == G(num_glyphs) - 1;
+        Group *current_group = G(groups) + G(group_idx);
+        if (is_last_glyph) {
+            num_codepoints_used_by_glyph = UINT32_MAX;
+        } else {
+            next_cluster = G(info)[G(glyph_idx) + 1].cluster;
+            if (next_cluster > cluster) num_codepoints_used_by_glyph = next_cluster - cluster;
+        }
+        if (!current_group->num_glyphs) {
+            add_to_current_group = true;
+        } else {
+            if (is_special) {
+                add_to_current_group = G(prev_was_empty);
+            } else {
+                add_to_current_group = !G(prev_was_special);
+            }
+        }
+        if (current_group->num_glyphs >= MAX_GLYPHS_IN_GROUP || current_group->num_cells >= MAX_GLYPHS_IN_GROUP) add_to_current_group = false;
+
+        if (!add_to_current_group) { G(group_idx)++; current_group = G(groups) + G(group_idx); }
+        if (!current_group->num_glyphs++) {
+            current_group->first_glyph_idx = G(glyph_idx);
+            current_group->first_cell_idx = G(cell_idx);
+        }
+#define MOVE_GLYPH_TO_NEXT_GROUP(start_cell_idx) { \
+    current_group->num_glyphs--; \
+    G(group_idx)++; current_group = G(groups) + G(group_idx); \
+    current_group->first_cell_idx = start_cell_idx; \
+    current_group->num_glyphs = 1; \
+    current_group->first_glyph_idx = G(glyph_idx); \
+}
+        if (is_last_glyph) {
+            // soak up all remaining cells
+            if (G(cell_idx) < G(num_cells)) {
+                unsigned int num_left = G(num_cells) - G(cell_idx);
+                if (current_group->num_cells + num_left > MAX_GLYPHS_IN_GROUP) MOVE_GLYPH_TO_NEXT_GROUP(G(cell_idx));
+                current_group->num_cells += num_left;
+                if (current_group->num_cells > MAX_GLYPHS_IN_GROUP) current_group->num_cells = MAX_GLYPHS_IN_GROUP;  // leave any trailing cells empty
+                G(cell_idx) += num_left;
+            }
+        } else {
+            unsigned int num_cells_consumed = 0, start_cell_idx = G(cell_idx);
+            while (num_codepoints_used_by_glyph && G(cell_idx) < G(num_cells)) {
+                unsigned int w = check_cell_consumed(&G(current_cell_data), G(last_cell));
+                G(cell_idx) += w;
+                num_cells_consumed += w;
+                num_codepoints_used_by_glyph--;
+            }
+            if (num_cells_consumed) {
+                if (num_cells_consumed > MAX_GLYPHS_IN_GROUP) {
+                    // Nasty, a single glyph used more than MAX_GLYPHS_IN_GROUP cells, we cannot render this case correctly
+                    fprintf(stderr, "The glyph: %u needs more than %u cells, cannot render it\n", glyph_id, MAX_GLYPHS_IN_GROUP);
+                    current_group->num_glyphs--;
+                    while (num_cells_consumed) {
+                        G(group_idx)++; current_group = G(groups) + G(group_idx);
+                        current_group->num_glyphs = 1; current_group->first_glyph_idx = G(glyph_idx);
+                        current_group->num_cells = MIN(num_cells_consumed, MAX_GLYPHS_IN_GROUP);
+                        current_group->first_cell_idx = start_cell_idx;
+                        start_cell_idx += current_group->num_cells;
+                        num_cells_consumed -= current_group->num_cells;
+                    }
+                } else {
+                    if (num_cells_consumed + current_group->num_cells > MAX_GLYPHS_IN_GROUP) MOVE_GLYPH_TO_NEXT_GROUP(start_cell_idx);
+                    current_group->num_cells += num_cells_consumed;
+                    if (!is_special) {  // not a ligature, end the group
+                        G(group_idx)++; current_group = G(groups) + G(group_idx);
+                    }
+                }
+            }
+        }
+
+        G(prev_was_special) = is_special;
+        G(prev_was_empty) = is_empty;
+        G(previous_cluster) = cluster;
+        G(glyph_idx)++;
+    }
+#undef MOVE_GLYPH_TO_NEXT_GROUP
+#undef MAX_GLYPHS_IN_GROUP
+}
+
+static inline void
+render_groups(Font *font) {
+    unsigned idx = 0;
+    ExtraGlyphs ed;
+    while (idx <= G(group_idx)) {
+        Group *group = G(groups) + idx;
+        if (!group->num_cells) break;
+        /* printf("Group: idx: %u num_cells: %u num_glyphs: %u first_glyph_idx: %u first_cell_idx: %u total_num_glyphs: %zu\n", */
+        /*         idx, group->num_cells, group->num_glyphs, group->first_glyph_idx, group->first_cell_idx, group_state.num_glyphs); */
+        glyph_index primary = group->num_glyphs ? G(info)[group->first_glyph_idx].codepoint : 0;
+        for (unsigned i = 1; i < MIN(arraysz(ed.data) + 1, group->num_glyphs); i++) ed.data[i-1] = G(info)[group->first_glyph_idx + i].codepoint;
+        render_group(group->num_cells, group->num_glyphs, G(first_cell) + group->first_cell_idx, G(info) + group->first_glyph_idx, G(positions) + group->first_glyph_idx, font, primary, &ed);
+        idx++;
     }
 }
 
@@ -691,31 +806,33 @@ test_shape(PyObject UNUSED *self, PyObject *args) {
         if (face == NULL) return NULL;
         font = calloc(1, sizeof(Font));
         font->face = face;
-    } 
-    hb_glyph_info_t *info;
-    hb_glyph_position_t *positions;
-    unsigned int num_glyphs = shape(line->cells, num, harfbuzz_font_for_face(font->face), &info, &positions);
+    }
+    shape_run(line->cells, num, font);
 
     PyObject *ans = PyList_New(0);
-    unsigned int run_pos = 0, cell_pos = 0, num_group_glyphs, num_group_cells;
-    ExtraGlyphs extra_glyphs; 
+    unsigned int idx = 0;
     glyph_index first_glyph;
-    while(run_pos < num_glyphs && cell_pos < num) {
-        first_glyph = next_group(font, &num_group_cells, &num_group_glyphs, line->cells + cell_pos, info + run_pos, num_glyphs - run_pos, num - cell_pos, &extra_glyphs);
+    while (idx <= G(group_idx)) {
+        Group *group = G(groups) + idx;
+        if (!group->num_cells) break;
+        first_glyph = group->num_glyphs ? G(info)[group->first_glyph_idx].codepoint : 0;
+
         PyObject *eg = PyTuple_New(MAX_NUM_EXTRA_GLYPHS);
-        for (size_t g = 0; g < MAX_NUM_EXTRA_GLYPHS; g++) PyTuple_SET_ITEM(eg, g, Py_BuildValue("H", extra_glyphs.data[g]));
-        PyList_Append(ans, Py_BuildValue("IIIN", num_group_cells, num_group_glyphs, first_glyph, eg));
-        run_pos += num_group_glyphs; cell_pos += num_group_cells;
+        for (size_t g = 0; g < MAX_NUM_EXTRA_GLYPHS; g++) PyTuple_SET_ITEM(eg, g, Py_BuildValue("H", g + 1 < group->num_glyphs ? G(info)[group->first_glyph_idx + g].codepoint : 0));
+        PyList_Append(ans, Py_BuildValue("IIIN", group->num_cells, group->num_glyphs, first_glyph, eg));
+        idx++;
     }
     if (face) { Py_CLEAR(face); free(font); }
     return ans;
 }
+#undef G
 
-static inline void 
+static inline void
 render_run(Cell *first_cell, index_type num_cells, ssize_t font_idx) {
     switch(font_idx) {
         default:
             shape_run(first_cell, num_cells, &fonts.fonts[font_idx]);
+            render_groups(&fonts.fonts[font_idx]);
             break;
         case BLANK_FONT:
             while(num_cells--) set_sprite(first_cell++, 0, 0, 0);
@@ -761,7 +878,7 @@ set_font(PyObject UNUSED *m, PyObject *args) {
     for (size_t i = 0; i < fonts.fonts_count; i++) del_font(fonts.fonts + i);
     ensure_space_for(&fonts, fonts, Font, num_fonts, fonts_capacity, 5, true);
     fonts.fonts_count = 1;
-#define A(attr, bold, italic) { if(attr) { if (!init_font(&fonts.fonts[fonts.fonts_count], attr, bold, italic, false)) return NULL; fonts.attr##_font_idx = fonts.fonts_count++; } else fonts.attr##_font_idx = -1; } 
+#define A(attr, bold, italic) { if(attr) { if (!init_font(&fonts.fonts[fonts.fonts_count], attr, bold, italic, false)) return NULL; fonts.attr##_font_idx = fonts.fonts_count++; } else fonts.attr##_font_idx = -1; }
     A(medium, false, false);
     A(bold, true, false); A(italic, false, true); A(bi, true, true);
 #undef A
@@ -793,6 +910,7 @@ finalize(void) {
     for (size_t i = 0; i < fonts.fonts_count; i++) del_font(fonts.fonts + i);
     free(fonts.symbol_maps); free(fonts.fonts);
     if (harfbuzz_buffer) hb_buffer_destroy(harfbuzz_buffer);
+    free(group_state.groups);
 }
 
 static PyObject*
@@ -923,15 +1041,14 @@ error:
 
 static PyObject*
 get_fallback_font(PyObject UNUSED *self, PyObject *args) {
-    PyObject *text; 
+    PyObject *text;
     int bold, italic;
     if (!PyArg_ParseTuple(args, "Upp", &text, &bold, &italic)) return NULL;
-    static Py_UCS4 char_buf[16];
-    if (!PyUnicode_AsUCS4(text, char_buf, sizeof(char_buf)/sizeof(char_buf[0]), 1)) return NULL;
     Cell cell = {0};
+    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];
-    if (PyUnicode_GetLength(text) > 1) cell.cc |= char_buf[1] & CC_MASK;
-    if (PyUnicode_GetLength(text) > 2) cell.cc |= (char_buf[2] & CC_MASK) << 16;
+    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]);
     if (bold) cell.attrs |= 1 << BOLD_SHIFT;
     if (italic) cell.attrs |= 1 << ITALIC_SHIFT;
     ssize_t ans = fallback_font(&cell);
@@ -956,7 +1073,7 @@ static PyMethodDef module_methods[] = {
     {NULL, NULL, 0, NULL}        /* Sentinel */
 };
 
-bool 
+bool
 init_fonts(PyObject *module) {
     if (Py_AtExit(finalize) != 0) {
         PyErr_SetString(PyExc_RuntimeError, "Failed to register the fonts module at exit handler");

kitty/fonts.h

@@ -14,10 +14,12 @@
 
 
 // API that font backends need to implement
+typedef uint16_t glyph_index;
 unsigned int glyph_id_for_codepoint(PyObject *, char_type);
+bool is_glyph_empty(PyObject *, glyph_index);
 hb_font_t* harfbuzz_font_for_face(PyObject*);
 bool set_size_for_face(PyObject*, unsigned int, bool);
-void cell_metrics(PyObject*, unsigned int*, unsigned int*, unsigned int*, unsigned int*, unsigned int*); 
+void cell_metrics(PyObject*, unsigned int*, unsigned int*, unsigned int*, unsigned int*, unsigned int*);
 bool render_glyphs_in_cells(PyObject *f, bool bold, bool italic, hb_glyph_info_t *info, hb_glyph_position_t *positions, unsigned int num_glyphs, pixel *canvas, unsigned int cell_width, unsigned int cell_height, unsigned int num_cells, unsigned int baseline, bool *was_colored);
 PyObject* create_fallback_face(PyObject *base_face, Cell* cell, bool bold, bool italic);
 PyObject* specialize_font_descriptor(PyObject *base_descriptor);

kitty/fonts/render.py

@@ -73,7 +73,7 @@ def resize_fonts(new_sz):
 
 def add_line(buf, cell_width, position, thickness, cell_height):
     y = position - thickness // 2
-    while thickness > 0 and y > -1 and y < cell_height - 1:
+    while thickness > 0 and y > -1 and y < cell_height:
         thickness -= 1
         ctypes.memset(ctypes.addressof(buf) + (cell_width * y), 255, cell_width)
         y += 1

kitty/freetype.c

@@ -38,7 +38,7 @@ PyTypeObject Face_Type;
 
 static PyObject* FreeType_Exception = NULL;
 
-void 
+void
 set_freetype_error(const char* prefix, int err_code) {
     int i = 0;
 #undef FTERRORS_H_
@@ -54,7 +54,7 @@ set_freetype_error(const char* prefix, int err_code) {
 
 #ifdef FT_ERRORS_H
 #include FT_ERRORS_H
-#else 
+#else
     FT_ERROR_START_LIST FT_ERROR_END_LIST
 #endif
 
@@ -121,8 +121,8 @@ set_font_size(Face *self, FT_F26Dot6 char_width, FT_F26Dot6 char_height, FT_UInt
                 return true;
             }
         }
-        set_freetype_error("Failed to set char size, with error:", error); 
-        return false; 
+        set_freetype_error("Failed to set char size, with error:", error);
+        return false;
     }
     return !error;
 }
@@ -170,7 +170,7 @@ init_ft_face(Face *self, PyObject *path, int hinting, int hintstyle) {
 PyObject*
 ft_face_from_data(const uint8_t* data, size_t sz, void *extra_data, free_extra_data_func fed, PyObject *path, int hinting, int hintstyle, float apple_leading) {
     Face *ans = (Face*)Face_Type.tp_alloc(&Face_Type, 0);
-    if (ans == NULL) return NULL; 
+    if (ans == NULL) return NULL;
     int error = FT_New_Memory_Face(library, data, sz, 0, &ans->face);
     if(error) { set_freetype_error("Failed to load memory face, with error:", error); Py_CLEAR(ans); return NULL; }
     if (!init_ft_face(ans, path, hinting, hintstyle)) { Py_CLEAR(ans); return NULL; }
@@ -232,7 +232,7 @@ face_from_descriptor(PyObject *descriptor) {
     }
     return (PyObject*)self;
 }
- 
+
 PyObject*
 face_from_path(const char *path, int index) {
     Face *ans = (Face*)Face_Type.tp_alloc(&Face_Type, 0);
@@ -265,7 +265,7 @@ repr(Face *self) {
 }
 
 
-static inline bool 
+static inline bool
 load_glyph(Face *self, int glyph_index, int load_type) {
     int flags = get_load_flags(self->hinting, self->hintstyle, load_type);
     int error = FT_Load_Glyph(self->face, glyph_index, flags);
@@ -285,7 +285,7 @@ calc_cell_width(Face *self) {
     return ans;
 }
 
-void 
+void
 cell_metrics(PyObject *s, unsigned int* cell_width, unsigned int* cell_height, unsigned int* baseline, unsigned int* underline_position, unsigned int* underline_thickness) {
     Face *self = (Face*)s;
     *cell_width = calc_cell_width(self);
@@ -295,11 +295,22 @@ cell_metrics(PyObject *s, unsigned int* cell_width, unsigned int* cell_height, u
     *underline_thickness = MAX(1, font_units_to_pixels(self, self->underline_thickness));
 }
 
-unsigned int 
+unsigned int
 glyph_id_for_codepoint(PyObject *s, char_type cp) {
     return FT_Get_Char_Index(((Face*)s)->face, cp);
 }
 
+
+bool
+is_glyph_empty(PyObject *s, glyph_index g) {
+    Face *self = (Face*)s;
+    if (!load_glyph(self, g, FT_LOAD_DEFAULT)) { PyErr_Print(); return false; }
+#define M self->face->glyph->metrics
+    /* printf("glyph: %u horiBearingX: %ld horiBearingY: %ld width: %ld height: %ld\n", g, M.horiBearingX, M.horiBearingY, M.width, M.height); */
+    return M.width == 0;
+#undef M
+}
+
 hb_font_t*
 harfbuzz_font_for_face(PyObject *self) { return ((Face*)self)->harfbuzz_font; }
 
@@ -376,12 +387,12 @@ downsample_bitmap(ProcessedBitmap *bm, unsigned int width, unsigned int cell_hei
             for (unsigned int y=sr; y < MIN(sr + factor, bm->rows); y++) {
                 uint8_t *p = bm->buf + (y * bm->stride) + sc * 4;
                 for (unsigned int x=sc; x < MIN(sc + factor, bm->width); x++, count++) {
-                    b += *(p++); g += *(p++); r += *(p++); a += *(p++); 
+                    b += *(p++); g += *(p++); r += *(p++); a += *(p++);
                 }
             }
             if (count) {
                 d[0] = b / count; d[1] = g / count; d[2] = r / count; d[3] = a / count;
-            } 
+            }
 
         }
     }
@@ -506,7 +517,7 @@ render_glyphs_in_cells(PyObject *f, bool bold, bool italic, hb_glyph_info_t *inf
         y = (float)positions[i].y_offset / 64.0f;
         if ((*was_colored || self->face->glyph->metrics.width > 0) && bm.width > 0) place_bitmap_in_canvas(canvas, &bm, canvas_width, cell_height, x_offset, y, &self->face->glyph->metrics, baseline);
         x += (float)positions[i].x_advance / 64.0f;
-        if (bm.needs_free) free(bm.buf); 
+        if (bm.needs_free) free(bm.buf);
     }
 
     // center the glyphs in the canvas
@@ -560,8 +571,8 @@ PyTypeObject Face_Type = {
     PyVarObject_HEAD_INIT(NULL, 0)
     .tp_name = "fast_data_types.Face",
     .tp_basicsize = sizeof(Face),
-    .tp_dealloc = (destructor)dealloc, 
-    .tp_flags = Py_TPFLAGS_DEFAULT,        
+    .tp_dealloc = (destructor)dealloc,
+    .tp_flags = Py_TPFLAGS_DEFAULT,
     .tp_doc = "FreeType Font face",
     .tp_methods = methods,
     .tp_members = members,
@@ -573,11 +584,11 @@ free_freetype() {
     FT_Done_FreeType(library);
 }
 
-bool 
+bool
 init_freetype_library(PyObject *m) {
     if (PyType_Ready(&Face_Type) < 0) return 0;
-    if (PyModule_AddObject(m, "Face", (PyObject *)&Face_Type) != 0) return 0; 
-    Py_INCREF(&Face_Type); 
+    if (PyModule_AddObject(m, "Face", (PyObject *)&Face_Type) != 0) return 0;
+    Py_INCREF(&Face_Type);
     FreeType_Exception = PyErr_NewException("fast_data_types.FreeTypeError", NULL, NULL);
     if (FreeType_Exception == NULL) return false;
     if (PyModule_AddObject(m, "FreeTypeError", FreeType_Exception) != 0) return false;

kitty/gl.h

@@ -22,24 +22,24 @@ static void
 check_for_gl_error(const char *name, void UNUSED *funcptr, int UNUSED len_args, ...) {
 #define f(msg) fatal("OpenGL error: %s (calling function: %s)", msg, name); break;
     GLenum code = glad_glGetError();
-    switch(code) { 
+    switch(code) {
         case GL_NO_ERROR: break;
-        case GL_INVALID_ENUM: 
-            f("An enum value is invalid (GL_INVALID_ENUM)"); 
-        case GL_INVALID_VALUE: 
-            f("An numeric value is invalid (GL_INVALID_VALUE)"); 
-        case GL_INVALID_OPERATION: 
-            f("This operation is invalid (GL_INVALID_OPERATION)"); 
-        case GL_INVALID_FRAMEBUFFER_OPERATION: 
-            f("The framebuffer object is not complete (GL_INVALID_FRAMEBUFFER_OPERATION)"); 
-        case GL_OUT_OF_MEMORY: 
-            f("There is not enough memory left to execute the command. (GL_OUT_OF_MEMORY)"); 
-        case GL_STACK_UNDERFLOW: 
-            f("An attempt has been made to perform an operation that would cause an internal stack to underflow. (GL_STACK_UNDERFLOW)"); 
-        case GL_STACK_OVERFLOW: 
-            f("An attempt has been made to perform an operation that would cause an internal stack to underflow. (GL_STACK_OVERFLOW)"); 
-        default: 
-            fatal("An unknown OpenGL error occurred with code: %d (calling function: %s)", code, name); 
+        case GL_INVALID_ENUM:
+            f("An enum value is invalid (GL_INVALID_ENUM)");
+        case GL_INVALID_VALUE:
+            f("An numeric value is invalid (GL_INVALID_VALUE)");
+        case GL_INVALID_OPERATION:
+            f("This operation is invalid (GL_INVALID_OPERATION)");
+        case GL_INVALID_FRAMEBUFFER_OPERATION:
+            f("The framebuffer object is not complete (GL_INVALID_FRAMEBUFFER_OPERATION)");
+        case GL_OUT_OF_MEMORY:
+            f("There is not enough memory left to execute the command. (GL_OUT_OF_MEMORY)");
+        case GL_STACK_UNDERFLOW:
+            f("An attempt has been made to perform an operation that would cause an internal stack to underflow. (GL_STACK_UNDERFLOW)");
+        case GL_STACK_OVERFLOW:
+            f("An attempt has been made to perform an operation that would cause an internal stack to underflow. (GL_STACK_OVERFLOW)");
+        default:
+            fatal("An unknown OpenGL error occurred with code: %d (calling function: %s)", code, name);
             break;
     }
 }
@@ -59,6 +59,9 @@ gl_init() {
         ARB_TEST(texture_storage);
 #undef ARB_TEST
         glad_loaded = true;
+        if (GLVersion.major < OPENGL_REQUIRED_VERSION_MAJOR || (GLVersion.major == OPENGL_REQUIRED_VERSION_MAJOR && GLVersion.minor < OPENGL_REQUIRED_VERSION_MINOR)) {
+            fatal("OpenGL version is %d.%d, version >= 3.3 required for kitty", GLVersion.major, GLVersion.minor);
+        }
     }
 }
 
@@ -73,7 +76,7 @@ update_surface_size(int w, int h, GLuint offscreen_texture_id) {
 
 void
 free_texture(GLuint *tex_id) {
-    glDeleteTextures(1, tex_id); 
+    glDeleteTextures(1, tex_id);
     *tex_id = 0;
 }
 
@@ -288,7 +291,7 @@ add_buffer_to_vao(ssize_t vao_idx, GLenum usage) {
 static void
 add_located_attribute_to_vao(ssize_t vao_idx, GLint aloc, GLint size, GLenum data_type, GLsizei stride, void *offset, GLuint divisor) {
     VAO *vao = vaos + vao_idx;
-    if (!vao->num_buffers) fatal("You must create a buffer for this attribute first"); 
+    if (!vao->num_buffers) fatal("You must create a buffer for this attribute first");
     ssize_t buf = vao->buffers[vao->num_buffers - 1];
     bind_buffer(buf);
     glEnableVertexAttribArray(aloc);
@@ -315,7 +318,7 @@ add_located_attribute_to_vao(ssize_t vao_idx, GLint aloc, GLint size, GLenum dat
 static inline void
 add_attribute_to_vao(int p, ssize_t vao_idx, const char *name, GLint size, GLenum data_type, GLsizei stride, void *offset, GLuint divisor) {
     GLint aloc = attrib_location(p, name);
-    if (aloc == -1) fatal("No attribute named: %s found in this program", name); 
+    if (aloc == -1) fatal("No attribute named: %s found in this program", name);
     add_located_attribute_to_vao(vao_idx, aloc, size, data_type, stride, offset, divisor);
 }
 

kitty/glfw-wrapper.c

@@ -23,9 +23,6 @@ load_glfw(const char* path) {
     *(void **) (&glfwInitHint_impl) = dlsym(handle, "glfwInitHint");
     if (glfwInitHint_impl == NULL) fail("Failed to load glfw function glfwInitHint with error: %s", dlerror());
 
-    *(void **) (&glfwInitHintString_impl) = dlsym(handle, "glfwInitHintString");
-    if (glfwInitHintString_impl == NULL) fail("Failed to load glfw function glfwInitHintString with error: %s", dlerror());
-
     *(void **) (&glfwGetVersion_impl) = dlsym(handle, "glfwGetVersion");
     if (glfwGetVersion_impl == NULL) fail("Failed to load glfw function glfwGetVersion with error: %s", dlerror());
 
@@ -56,6 +53,12 @@ load_glfw(const char* path) {
     *(void **) (&glfwGetMonitorName_impl) = dlsym(handle, "glfwGetMonitorName");
     if (glfwGetMonitorName_impl == NULL) fail("Failed to load glfw function glfwGetMonitorName with error: %s", dlerror());
 
+    *(void **) (&glfwSetMonitorUserPointer_impl) = dlsym(handle, "glfwSetMonitorUserPointer");
+    if (glfwSetMonitorUserPointer_impl == NULL) fail("Failed to load glfw function glfwSetMonitorUserPointer with error: %s", dlerror());
+
+    *(void **) (&glfwGetMonitorUserPointer_impl) = dlsym(handle, "glfwGetMonitorUserPointer");
+    if (glfwGetMonitorUserPointer_impl == NULL) fail("Failed to load glfw function glfwGetMonitorUserPointer with error: %s", dlerror());
+
     *(void **) (&glfwSetMonitorCallback_impl) = dlsym(handle, "glfwSetMonitorCallback");
     if (glfwSetMonitorCallback_impl == NULL) fail("Failed to load glfw function glfwSetMonitorCallback with error: %s", dlerror());
 
@@ -80,6 +83,9 @@ load_glfw(const char* path) {
     *(void **) (&glfwWindowHint_impl) = dlsym(handle, "glfwWindowHint");
     if (glfwWindowHint_impl == NULL) fail("Failed to load glfw function glfwWindowHint with error: %s", dlerror());
 
+    *(void **) (&glfwWindowHintString_impl) = dlsym(handle, "glfwWindowHintString");
+    if (glfwWindowHintString_impl == NULL) fail("Failed to load glfw function glfwWindowHintString with error: %s", dlerror());
+
     *(void **) (&glfwCreateWindow_impl) = dlsym(handle, "glfwCreateWindow");
     if (glfwCreateWindow_impl == NULL) fail("Failed to load glfw function glfwCreateWindow with error: %s", dlerror());
 
@@ -197,6 +203,9 @@ load_glfw(const char* path) {
     *(void **) (&glfwSetFramebufferSizeCallback_impl) = dlsym(handle, "glfwSetFramebufferSizeCallback");
     if (glfwSetFramebufferSizeCallback_impl == NULL) fail("Failed to load glfw function glfwSetFramebufferSizeCallback with error: %s", dlerror());
 
+    *(void **) (&glfwSetWindowContentScaleCallback_impl) = dlsym(handle, "glfwSetWindowContentScaleCallback");
+    if (glfwSetWindowContentScaleCallback_impl == NULL) fail("Failed to load glfw function glfwSetWindowContentScaleCallback with error: %s", dlerror());
+
     *(void **) (&glfwPollEvents_impl) = dlsym(handle, "glfwPollEvents");
     if (glfwPollEvents_impl == NULL) fail("Failed to load glfw function glfwPollEvents with error: %s", dlerror());
 
@@ -287,6 +296,12 @@ load_glfw(const char* path) {
     *(void **) (&glfwGetJoystickGUID_impl) = dlsym(handle, "glfwGetJoystickGUID");
     if (glfwGetJoystickGUID_impl == NULL) fail("Failed to load glfw function glfwGetJoystickGUID with error: %s", dlerror());
 
+    *(void **) (&glfwSetJoystickUserPointer_impl) = dlsym(handle, "glfwSetJoystickUserPointer");
+    if (glfwSetJoystickUserPointer_impl == NULL) fail("Failed to load glfw function glfwSetJoystickUserPointer with error: %s", dlerror());
+
+    *(void **) (&glfwGetJoystickUserPointer_impl) = dlsym(handle, "glfwGetJoystickUserPointer");
+    if (glfwGetJoystickUserPointer_impl == NULL) fail("Failed to load glfw function glfwGetJoystickUserPointer with error: %s", dlerror());
+
     *(void **) (&glfwJoystickIsGamepad_impl) = dlsym(handle, "glfwJoystickIsGamepad");
     if (glfwJoystickIsGamepad_impl == NULL) fail("Failed to load glfw function glfwJoystickIsGamepad with error: %s", dlerror());
 

kitty/glfw-wrapper.h

@@ -251,17 +251,37 @@
  *  @{ */
 
 /*! @brief If this bit is set one or more Shift keys were held down.
+ *
+ *  If this bit is set one or more Shift keys were held down.
  */
 #define GLFW_MOD_SHIFT           0x0001
 /*! @brief If this bit is set one or more Control keys were held down.
+ *
+ *  If this bit is set one or more Control keys were held down.
  */
 #define GLFW_MOD_CONTROL         0x0002
 /*! @brief If this bit is set one or more Alt keys were held down.
+ *
+ *  If this bit is set one or more Alt keys were held down.
  */
 #define GLFW_MOD_ALT             0x0004
 /*! @brief If this bit is set one or more Super keys were held down.
+ *
+ *  If this bit is set one or more Super keys were held down.
  */
 #define GLFW_MOD_SUPER           0x0008
+/*! @brief If this bit is set the Caps Lock key is enabled.
+ *
+ *  If this bit is set the Caps Lock key is enabled and the @ref
+ *  GLFW_LOCK_KEY_MODS input mode is set.
+ */
+#define GLFW_MOD_CAPS_LOCK       0x0010
+/*! @brief If this bit is set the Num Lock key is enabled.
+ *
+ *  If this bit is set the Num Lock key is enabled and the @ref
+ *  GLFW_LOCK_KEY_MODS input mode is set.
+ */
+#define GLFW_MOD_NUM_LOCK        0x0020
 
 /*! @} */
 
@@ -552,6 +572,7 @@
  *  [window attribute](@ref GLFW_TRANSPARENT_FRAMEBUFFER_attrib).
  */
 #define GLFW_TRANSPARENT_FRAMEBUFFER 0x0002000A
+#define GLFW_HOVERED                0x0002000B
 
 /*! @brief Framebuffer bit depth hint.
  *
@@ -702,8 +723,11 @@
 #define GLFW_CONTEXT_CREATION_API   0x0002200B
 
 #define GLFW_COCOA_RETINA_FRAMEBUFFER 0x00023001
-#define GLFW_COCOA_FRAME_AUTOSAVE     0x00023002
+#define GLFW_COCOA_FRAME_NAME         0x00023002
 #define GLFW_COCOA_GRAPHICS_SWITCHING 0x00023003
+
+#define GLFW_X11_CLASS_NAME         0x00024001
+#define GLFW_X11_INSTANCE_NAME      0x00024002
 /*! @} */
 
 #define GLFW_NO_API                          0
@@ -721,6 +745,7 @@
 #define GLFW_CURSOR                 0x00033001
 #define GLFW_STICKY_KEYS            0x00033002
 #define GLFW_STICKY_MOUSE_BUTTONS   0x00033003
+#define GLFW_LOCK_KEY_MODS          0x00033004
 
 #define GLFW_CURSOR_NORMAL          0x00034001
 #define GLFW_CURSOR_HIDDEN          0x00034002
@@ -783,9 +808,6 @@
 
 #define GLFW_COCOA_CHDIR_RESOURCES  0x00051001
 #define GLFW_COCOA_MENUBAR          0x00051002
-
-#define GLFW_X11_WM_CLASS_NAME      0x00052001
-#define GLFW_X11_WM_CLASS_CLASS     0x00052002
 /*! @} */
 
 #define GLFW_DONT_CARE              -1
@@ -804,7 +826,7 @@
  *  @sa @ref glfwGetProcAddress
  *
  *  @since Added in version 3.0.
- 
+ *
  *  @ingroup context
  */
 typedef void (*GLFWglproc)(void);
@@ -1015,6 +1037,24 @@ typedef void (* GLFWwindowmaximizefun)(GLFWwindow*,int);
  */
 typedef void (* GLFWframebuffersizefun)(GLFWwindow*,int,int);
 
+/*! @brief The function signature for window content scale callbacks.
+ *
+ *  This is the function signature for window content scale callback
+ *  functions.
+ *
+ *  @param[in] window The window whose content scale changed.
+ *  @param[in] xscale The new x-axis content scale of the window.
+ *  @param[in] yscale The new y-axis content scale of the window.
+ *
+ *  @sa @ref window_scale
+ *  @sa @ref glfwSetWindowContentScaleCallback
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup window
+ */
+typedef void (* GLFWwindowcontentscalefun)(GLFWwindow*,float,float);
+
 /*! @brief The function signature for mouse button callbacks.
  *
  *  This is the function signature for mouse button callback functions.
@@ -1359,10 +1399,6 @@ typedef void (*glfwInitHint_func)(int, int);
 glfwInitHint_func glfwInitHint_impl;
 #define glfwInitHint glfwInitHint_impl
 
-typedef void (*glfwInitHintString_func)(int, const char*);
-glfwInitHintString_func glfwInitHintString_impl;
-#define glfwInitHintString glfwInitHintString_impl
-
 typedef void (*glfwGetVersion_func)(int*, int*, int*);
 glfwGetVersion_func glfwGetVersion_impl;
 #define glfwGetVersion glfwGetVersion_impl
@@ -1403,6 +1439,14 @@ typedef const char* (*glfwGetMonitorName_func)(GLFWmonitor*);
 glfwGetMonitorName_func glfwGetMonitorName_impl;
 #define glfwGetMonitorName glfwGetMonitorName_impl
 
+typedef void (*glfwSetMonitorUserPointer_func)(GLFWmonitor*, void*);
+glfwSetMonitorUserPointer_func glfwSetMonitorUserPointer_impl;
+#define glfwSetMonitorUserPointer glfwSetMonitorUserPointer_impl
+
+typedef void* (*glfwGetMonitorUserPointer_func)(GLFWmonitor*);
+glfwGetMonitorUserPointer_func glfwGetMonitorUserPointer_impl;
+#define glfwGetMonitorUserPointer glfwGetMonitorUserPointer_impl
+
 typedef GLFWmonitorfun (*glfwSetMonitorCallback_func)(GLFWmonitorfun);
 glfwSetMonitorCallback_func glfwSetMonitorCallback_impl;
 #define glfwSetMonitorCallback glfwSetMonitorCallback_impl
@@ -1435,6 +1479,10 @@ typedef void (*glfwWindowHint_func)(int, int);
 glfwWindowHint_func glfwWindowHint_impl;
 #define glfwWindowHint glfwWindowHint_impl
 
+typedef void (*glfwWindowHintString_func)(int, const char*);
+glfwWindowHintString_func glfwWindowHintString_impl;
+#define glfwWindowHintString glfwWindowHintString_impl
+
 typedef GLFWwindow* (*glfwCreateWindow_func)(int, int, const char*, GLFWmonitor*, GLFWwindow*);
 glfwCreateWindow_func glfwCreateWindow_impl;
 #define glfwCreateWindow glfwCreateWindow_impl
@@ -1591,6 +1639,10 @@ typedef GLFWframebuffersizefun (*glfwSetFramebufferSizeCallback_func)(GLFWwindow
 glfwSetFramebufferSizeCallback_func glfwSetFramebufferSizeCallback_impl;
 #define glfwSetFramebufferSizeCallback glfwSetFramebufferSizeCallback_impl
 
+typedef GLFWwindowcontentscalefun (*glfwSetWindowContentScaleCallback_func)(GLFWwindow*, GLFWwindowcontentscalefun);
+glfwSetWindowContentScaleCallback_func glfwSetWindowContentScaleCallback_impl;
+#define glfwSetWindowContentScaleCallback glfwSetWindowContentScaleCallback_impl
+
 typedef void (*glfwPollEvents_func)();
 glfwPollEvents_func glfwPollEvents_impl;
 #define glfwPollEvents glfwPollEvents_impl
@@ -1711,6 +1763,14 @@ typedef const char* (*glfwGetJoystickGUID_func)(int);
 glfwGetJoystickGUID_func glfwGetJoystickGUID_impl;
 #define glfwGetJoystickGUID glfwGetJoystickGUID_impl
 
+typedef void (*glfwSetJoystickUserPointer_func)(int, void*);
+glfwSetJoystickUserPointer_func glfwSetJoystickUserPointer_impl;
+#define glfwSetJoystickUserPointer glfwSetJoystickUserPointer_impl
+
+typedef void* (*glfwGetJoystickUserPointer_func)(int);
+glfwGetJoystickUserPointer_func glfwGetJoystickUserPointer_impl;
+#define glfwGetJoystickUserPointer glfwGetJoystickUserPointer_impl
+
 typedef int (*glfwJoystickIsGamepad_func)(int);
 glfwJoystickIsGamepad_func glfwJoystickIsGamepad_impl;
 #define glfwJoystickIsGamepad glfwJoystickIsGamepad_impl

kitty/glfw.c

@@ -21,12 +21,14 @@ update_os_window_viewport(OSWindow *window, bool notify_boss) {
     int w, h;
     glfwGetFramebufferSize(window->handle, &window->viewport_width, &window->viewport_height);
     glfwGetWindowSize(window->handle, &w, &h);
+    double xr = window->viewport_x_ratio, yr = window->viewport_y_ratio;
     window->viewport_x_ratio = (double)window->viewport_width / (double)w;
     window->viewport_y_ratio = (double)window->viewport_height / (double)h;
+    bool dpi_changed = (xr != 0.0 && xr != window->viewport_x_ratio) || (yr != 0.0 && yr != window->viewport_y_ratio);
     window->viewport_size_dirty = true;
     window->has_pending_resizes = false;
     if (notify_boss) {
-        call_boss(on_window_resize, "Kii", window->id, window->viewport_width, window->viewport_height);
+        call_boss(on_window_resize, "KiiO", window->id, window->viewport_width, window->viewport_height, dpi_changed ? Py_True : Py_False);
     }
     window->last_resize_at = monotonic();
 }
@@ -34,7 +36,7 @@ update_os_window_viewport(OSWindow *window, bool notify_boss) {
 
 // callbacks {{{
 
-void 
+void
 update_os_window_references() {
     for (size_t i = 0; i < global_state.num_os_windows; i++) {
         OSWindow *w = global_state.os_windows + i;
@@ -68,10 +70,10 @@ is_window_ready_for_callbacks() {
 
 static inline void
 show_mouse_cursor(GLFWwindow *w) {
-    if (glfwGetInputMode(w, GLFW_CURSOR) != GLFW_CURSOR_NORMAL) { glfwSetInputMode(w, GLFW_CURSOR, GLFW_CURSOR_NORMAL); } 
+    if (glfwGetInputMode(w, GLFW_CURSOR) != GLFW_CURSOR_NORMAL) { glfwSetInputMode(w, GLFW_CURSOR, GLFW_CURSOR_NORMAL); }
 }
 
-static void 
+static void
 framebuffer_size_callback(GLFWwindow *w, int width, int height) {
     if (!set_callback_window(w)) return;
     if (width > 100 && height > 100) {
@@ -86,7 +88,7 @@ framebuffer_size_callback(GLFWwindow *w, int width, int height) {
     global_state.callback_os_window = NULL;
 }
 
-static void 
+static void
 char_mods_callback(GLFWwindow *w, unsigned int codepoint, int mods) {
     if (!set_callback_window(w)) return;
     global_state.callback_os_window->cursor_blink_zero_time = monotonic();
@@ -94,7 +96,7 @@ char_mods_callback(GLFWwindow *w, unsigned int codepoint, int mods) {
     global_state.callback_os_window = NULL;
 }
 
-static void 
+static void
 key_callback(GLFWwindow *w, int key, int scancode, int action, int mods) {
     if (!set_callback_window(w)) return;
     global_state.callback_os_window->cursor_blink_zero_time = monotonic();
@@ -105,7 +107,7 @@ key_callback(GLFWwindow *w, int key, int scancode, int action, int mods) {
     global_state.callback_os_window = NULL;
 }
 
-static void 
+static void
 mouse_button_callback(GLFWwindow *w, int button, int action, int mods) {
     if (!set_callback_window(w)) return;
     show_mouse_cursor(w);
@@ -118,7 +120,7 @@ mouse_button_callback(GLFWwindow *w, int button, int action, int mods) {
     global_state.callback_os_window = NULL;
 }
 
-static void 
+static void
 cursor_pos_callback(GLFWwindow *w, double x, double y) {
     if (!set_callback_window(w)) return;
     show_mouse_cursor(w);
@@ -131,7 +133,7 @@ cursor_pos_callback(GLFWwindow *w, double x, double y) {
     global_state.callback_os_window = NULL;
 }
 
-static void 
+static void
 scroll_callback(GLFWwindow *w, double xoffset, double yoffset) {
     if (!set_callback_window(w)) return;
     show_mouse_cursor(w);
@@ -141,13 +143,40 @@ scroll_callback(GLFWwindow *w, double xoffset, double yoffset) {
     global_state.callback_os_window = NULL;
 }
 
-static void 
+static struct {
+    id_type entries[16];
+    int next_entry;
+} focus_history;
+
+#ifdef __APPLE__
+static inline id_type
+pop_focus_history() {
+    int index = --focus_history.next_entry;
+    if (index < 0) {
+        focus_history.next_entry = index = 0;
+    }
+
+    id_type result = focus_history.entries[index];
+    focus_history.entries[index] = 0;
+
+    return result;
+}
+#endif
+
+static inline void
+push_focus_history(OSWindow *w) {
+    focus_history.entries[focus_history.next_entry++] = w->id;
+    focus_history.next_entry %= (sizeof(focus_history.entries) / sizeof(*(focus_history.entries)));
+}
+
+static void
 window_focus_callback(GLFWwindow *w, int focused) {
     if (!set_callback_window(w)) return;
     global_state.callback_os_window->is_focused = focused ? true : false;
     if (focused) {
-        show_mouse_cursor(w); 
+        show_mouse_cursor(w);
         focus_in_event();
+        push_focus_history(global_state.callback_os_window);
     }
     double now = monotonic();
     global_state.callback_os_window->last_mouse_activity_at = now;
@@ -158,7 +187,7 @@ window_focus_callback(GLFWwindow *w, int focused) {
     global_state.callback_os_window = NULL;
 }
 
-static void 
+static void
 drop_callback(GLFWwindow *w, int count, const char **paths) {
     if (!set_callback_window(w)) return;
     PyObject *p = PyTuple_New(count);
@@ -201,7 +230,7 @@ set_default_window_icon(PyObject UNUSED *self, PyObject *args) {
 
 static GLFWwindow *current_os_window_ctx = NULL;
 
-void 
+void
 make_os_window_context_current(OSWindow *w) {
     if (w->handle != current_os_window_ctx) {
         current_os_window_ctx = w->handle;
@@ -246,8 +275,8 @@ current_monitor(GLFWwindow *window) {
 }
 
 
-static inline void
-set_dpi_from_window(OSWindow *w) {
+void
+set_dpi_from_os_window(OSWindow *w) {
     GLFWmonitor *monitor = NULL;
     if (w) { monitor = current_monitor(w->handle); }
     if (monitor == NULL) monitor = glfwGetPrimaryMonitor();
@@ -265,13 +294,14 @@ set_dpi_from_window(OSWindow *w) {
 
 static PyObject*
 create_os_window(PyObject UNUSED *self, PyObject *args) {
-    int width, height, visible = 1, swap_interval = 0, x = -1, y = -1;
-    char *title;
+    int width, height, swap_interval = 0, x = -1, y = -1;
+    char *title, *wm_class_class, *wm_class_name;
     PyObject *load_programs = NULL;
-    if (!PyArg_ParseTuple(args, "iis|pOiii", &width, &height, &title, &visible, &load_programs, &swap_interval, &x, &y)) return NULL;
+    if (!PyArg_ParseTuple(args, "iisss|Oiii", &width, &height, &title, &wm_class_name, &wm_class_class, &load_programs, &swap_interval, &x, &y)) return NULL;
     bool is_first_window = standard_cursor == NULL;
 
     if (is_first_window) {
+        glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
         glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, OPENGL_REQUIRED_VERSION_MAJOR);
         glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, OPENGL_REQUIRED_VERSION_MINOR);
         glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
@@ -288,15 +318,19 @@ create_os_window(PyObject UNUSED *self, PyObject *args) {
         click_cursor = glfwCreateStandardCursor(GLFW_HAND_CURSOR);
         arrow_cursor = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
         if (standard_cursor == NULL || click_cursor == NULL || arrow_cursor == NULL) {
-            PyErr_SetString(PyExc_ValueError, "Failed to create standard mouse cursors"); return NULL; 
+            PyErr_SetString(PyExc_ValueError, "Failed to create standard mouse cursors"); return NULL;
         }
     }
 
+#ifndef __APPLE__
+    glfwWindowHintString(GLFW_X11_INSTANCE_NAME, wm_class_name);
+    glfwWindowHintString(GLFW_X11_CLASS_NAME, wm_class_class);
+#endif
+
     if (global_state.num_os_windows >= MAX_CHILDREN) {
         PyErr_SetString(PyExc_ValueError, "Too many windows");
         return NULL;
     }
-    glfwWindowHint(GLFW_VISIBLE, visible ? GLFW_TRUE : GLFW_FALSE);
     bool want_semi_transparent = (1.0 - OPT(background_opacity) > 0.1) ? true : false;
     glfwWindowHint(GLFW_TRANSPARENT_FRAMEBUFFER, want_semi_transparent);
     GLFWwindow *glfw_window = glfwCreateWindow(width, height, title, NULL, global_state.num_os_windows ? global_state.os_windows[0].handle : NULL);
@@ -309,8 +343,8 @@ create_os_window(PyObject UNUSED *self, PyObject *args) {
     if (x != -1 && y != -1) glfwSetWindowPos(glfw_window, x, y);
     current_os_window_ctx = glfw_window;
     glfwSwapInterval(swap_interval);  // a value of 1 makes mouse selection laggy
-    if (is_first_window) { 
-        set_dpi_from_window(NULL);
+    if (is_first_window) {
+        set_dpi_from_os_window(NULL);
         gl_init();
         PyObject *ret = PyObject_CallFunction(load_programs, "i", glfwGetWindowAttrib(glfw_window, GLFW_TRANSPARENT_FRAMEBUFFER));
         if (ret == NULL) return NULL;
@@ -364,28 +398,59 @@ static PyObject*
 show_window(PyObject UNUSED *self, PyObject *args) {
     id_type os_window_id;
     int yes = 1;
+    bool dpi_changed = false;
     if (!PyArg_ParseTuple(args, "K|p", &os_window_id, &yes)) return NULL;
     for (size_t i = 0; i < global_state.num_os_windows; i++) {
         OSWindow *w = global_state.os_windows + i;
         if (w->id == os_window_id) {
-            if (yes) glfwShowWindow(w->handle); else glfwHideWindow(w->handle);
+            if (yes) {
+                bool first_show = !w->shown_once;
+                glfwShowWindow(w->handle);
+                w->shown_once = true;
+                push_focus_history(w);
+                if (first_show) {
+                    double before_x = global_state.logical_dpi_x, before_y = global_state.logical_dpi_y;
+                    set_dpi_from_os_window(w);
+                    dpi_changed = before_x != global_state.logical_dpi_x || before_y != global_state.logical_dpi_y;
+                    w->has_pending_resizes = true;
+                    global_state.has_pending_resizes = true;
+                }
+            } else glfwHideWindow(w->handle);
             break;
         }
     }
-    Py_RETURN_NONE;
+    if (dpi_changed) Py_RETURN_TRUE;
+    Py_RETURN_FALSE;
 }
 
 void
 destroy_os_window(OSWindow *w) {
     if (w->handle) {
-        glfwDestroyWindow(w->handle); 
+        glfwDestroyWindow(w->handle);
         if (current_os_window_ctx == w->handle) current_os_window_ctx = NULL;
     }
     w->handle = NULL;
+#ifdef __APPLE__
+    // On macOS when closing a window, any other existing windows belonging to the same application do not
+    // automatically get focus, so we do it manually.
+    bool change_focus = true;
+    while (change_focus) {
+        id_type new_focus_id = pop_focus_history();
+        if (new_focus_id == 0) break;
+        for (size_t i = 0; i < global_state.num_os_windows; i++) {
+            OSWindow *c = global_state.os_windows + i;
+            if (c->id != w->id && c->handle && c->shown_once && (c->id == new_focus_id)) {
+                glfwFocusWindow(c->handle);
+                change_focus = false;
+                break;
+            }
+        }
+    }
+#endif
 }
 
 // Global functions {{{
-static void 
+static void
 error_callback(int error, const char* description) {
     fprintf(stderr, "[glfw error %d]: %s\n", error, description);
 }
@@ -522,11 +587,11 @@ toggle_fullscreen(PyObject UNUSED *self) {
     }
 }
 
-void 
+void
 ring_audio_bell(OSWindow *w) {
     static double last_bell_at = -1;
     double now = monotonic();
-    if (now - last_bell_at <= 0.1) return; 
+    if (now - last_bell_at <= 0.1) return;
     last_bell_at = now;
     if (w->handle) {
         glfwWindowBell(w->handle, OPT(x11_bell_volume));
@@ -555,7 +620,7 @@ hide_mouse(OSWindow *w) {
     }
 }
 
-void 
+void
 swap_window_buffers(OSWindow *w) {
     glfwSwapBuffers(w->handle);
 }
@@ -571,7 +636,7 @@ wakeup_main_loop() {
     glfwPostEmptyEvent();
 }
 
-void 
+void
 mark_os_window_for_close(OSWindow* w, bool yes) {
     glfwSetWindowShouldClose(w->handle, yes);
 }
@@ -694,14 +759,14 @@ static PyMethodDef module_methods[] = {
     METHODB(x11_window_id, METH_O),
     METHODB(set_primary_selection, METH_VARARGS),
     METHODB(glfw_poll_events, METH_NOARGS),
-    {"glfw_init", (PyCFunction)glfw_init, METH_VARARGS, ""}, 
-    {"glfw_terminate", (PyCFunction)glfw_terminate, METH_NOARGS, ""}, 
-    {"glfw_wait_events", (PyCFunction)glfw_wait_events, METH_VARARGS, ""}, 
-    {"glfw_post_empty_event", (PyCFunction)glfw_post_empty_event, METH_NOARGS, ""}, 
-    {"glfw_get_physical_dpi", (PyCFunction)glfw_get_physical_dpi, METH_NOARGS, ""}, 
-    {"glfw_get_key_name", (PyCFunction)glfw_get_key_name, METH_VARARGS, ""}, 
-    {"glfw_primary_monitor_size", (PyCFunction)primary_monitor_size, METH_NOARGS, ""}, 
-    {"glfw_primary_monitor_content_scale", (PyCFunction)primary_monitor_content_scale, METH_NOARGS, ""}, 
+    {"glfw_init", (PyCFunction)glfw_init, METH_VARARGS, ""},
+    {"glfw_terminate", (PyCFunction)glfw_terminate, METH_NOARGS, ""},
+    {"glfw_wait_events", (PyCFunction)glfw_wait_events, METH_VARARGS, ""},
+    {"glfw_post_empty_event", (PyCFunction)glfw_post_empty_event, METH_NOARGS, ""},
+    {"glfw_get_physical_dpi", (PyCFunction)glfw_get_physical_dpi, METH_NOARGS, ""},
+    {"glfw_get_key_name", (PyCFunction)glfw_get_key_name, METH_VARARGS, ""},
+    {"glfw_primary_monitor_size", (PyCFunction)primary_monitor_size, METH_NOARGS, ""},
+    {"glfw_primary_monitor_content_scale", (PyCFunction)primary_monitor_content_scale, METH_NOARGS, ""},
     {NULL, NULL, 0, NULL}        /* Sentinel */
 };
 
@@ -710,8 +775,6 @@ bool
 init_glfw(PyObject *m) {
     if (PyModule_AddFunctions(m, module_methods) != 0) return false;
 #define ADDC(n) if(PyModule_AddIntConstant(m, #n, n) != 0) return false;
-    ADDC(GLFW_X11_WM_CLASS_NAME)
-    ADDC(GLFW_X11_WM_CLASS_CLASS)
     ADDC(GLFW_RELEASE);
     ADDC(GLFW_PRESS);
     ADDC(GLFW_REPEAT);

kitty/graphics.c

@@ -81,7 +81,7 @@ static inline void
 remove_from_array(void *array, size_t item_size, size_t idx, size_t array_count) {
     size_t num_to_right = array_count - 1 - idx;
     uint8_t *p = (uint8_t*)array;
-    if (num_to_right > 0) memmove(p + (idx * item_size), p + ((idx + 1) * item_size), num_to_right * item_size);  
+    if (num_to_right > 0) memmove(p + (idx * item_size), p + ((idx + 1) * item_size), num_to_right * item_size);
     memset(p + (item_size * (array_count - 1)), 0, item_size);
 }
 
@@ -130,7 +130,7 @@ trim_predicate(Image *img) {
 static int
 oldest_last(const void* a, const void *b) {
     double ans = ((Image*)(b))->atime - ((Image*)(a))->atime;
-    return ans < 0 ? -1 : (ans == 0 ? 0 : 1); 
+    return ans < 0 ? -1 : (ans == 0 ? 0 : 1);
 }
 
 static inline void
@@ -171,7 +171,7 @@ mmap_img_file(GraphicsManager UNUSED *self, Image *img, int fd, size_t sz, off_t
         sz = s.st_size;
     }
     void *addr = mmap(0, sz, PROT_READ, MAP_SHARED, fd, offset);
-    if (addr == MAP_FAILED) ABRT(EBADF, "Failed to map image file fd: %d at offset: %zd with size: %zu with error: [%d] %s", fd, offset, sz, errno, strerror(errno)); 
+    if (addr == MAP_FAILED) ABRT(EBADF, "Failed to map image file fd: %d at offset: %zd with size: %zu with error: [%d] %s", fd, offset, sz, errno, strerror(errno));
     img->load_data.mapped_file = addr;
     img->load_data.mapped_file_sz = sz;
     return true;
@@ -267,7 +267,7 @@ inflate_png_inner(struct png_jmp_data *d, uint8_t *buf, size_t bufsz) {
     if (!info) ABRT(ENOMEM, "Failed to create PNG info structure");
 
     if (setjmp(jb)) goto err;
-    
+
     png_set_read_fn(png, &f, read_png_from_buffer);
     png_read_info(png, info);
     png_byte color_type, bit_depth;
@@ -312,7 +312,7 @@ inflate_png(GraphicsManager UNUSED *self, Image *img, uint8_t *buf, size_t bufsz
     if (d.ok) {
         free_load_data(&img->load_data);
         img->load_data.buf = d.decompressed;
-        img->load_data.buf_capacity = d.sz; 
+        img->load_data.buf_capacity = d.sz;
         img->load_data.buf_used = d.sz;
         img->load_data.data_sz = d.sz;
         img->width = d.width; img->height = d.height;
@@ -376,7 +376,7 @@ handle_add_command(GraphicsManager *self, const GraphicsCommand *g, const uint8_
         img->atime = monotonic(); img->used_storage = 0;
         img->width = g->data_width; img->height = g->data_height;
         switch(fmt) {
-            case PNG:  
+            case PNG:
                 if (g->data_sz > MAX_DATA_SZ) ABRT(EINVAL, "PNG data size too large");
                 img->load_data.is_4byte_aligned = true;
                 img->load_data.is_opaque = false;
@@ -513,7 +513,7 @@ create_add_response(GraphicsManager UNUSED *self, bool data_loaded, uint32_t iid
     if (iid) {
         if (!has_add_respose) {
             if (!data_loaded) return NULL;
-            snprintf(add_response, 10, "OK"); 
+            snprintf(add_response, 10, "OK");
         }
         snprintf(rbuf, sizeof(rbuf)/sizeof(rbuf[0]) - 1, "Gi=%u;%s", iid, add_response);
         return rbuf;
@@ -541,18 +541,18 @@ update_dest_rect(ImageRef *ref, uint32_t num_cols, uint32_t num_rows) {
         t = ref->src_width + ref->cell_x_offset;
         num_cols = t / global_state.cell_width;
         if (t > num_cols * global_state.cell_width) num_cols += 1;
-    } 
+    }
     if (num_rows == 0) {
         t = ref->src_height + ref->cell_y_offset;
         num_rows = t / global_state.cell_height;
         if (t > num_rows * global_state.cell_height) num_rows += 1;
-    } 
+    }
     ref->effective_num_rows = num_rows;
     ref->effective_num_cols = num_cols;
 }
 
 
-static void 
+static void
 handle_put_command(GraphicsManager *self, const GraphicsCommand *g, Cursor *c, bool *is_dirty, Image *img) {
     has_add_respose = false;
     if (img == NULL) img = img_by_client_id(self, g->id);
@@ -584,12 +584,12 @@ handle_put_command(GraphicsManager *self, const GraphicsCommand *g, Cursor *c, b
     c->x += ref->effective_num_cols; c->y += ref->effective_num_rows - 1;
 }
 
-static int 
-cmp_by_zindex_and_image(const void *a_, const void *b_) { 
+static int
+cmp_by_zindex_and_image(const void *a_, const void *b_) {
     const ImageRenderData *a = (const ImageRenderData*)a_, *b = (const ImageRenderData*)b_;
     int ans = a->z_index - b->z_index;
     if (ans == 0) ans = a->image_id - b->image_id;
-    return ans; 
+    return ans;
 }
 
 bool
@@ -656,9 +656,9 @@ filter_refs(GraphicsManager *self, const void* data, bool free_images, bool (*fi
     size_t i, j;
 
     if (self->image_count) {
-        for (i = self->image_count; i-- > 0;) { 
+        for (i = self->image_count; i-- > 0;) {
             img = self->images + i;
-            for (j = img->refcnt; j-- > 0;) { 
+            for (j = img->refcnt; j-- > 0;) {
                 ref = img->refs + j;
                 if (filter_func(ref, img, data)) {
                     remove_from_array(img->refs, sizeof(ImageRef), j, img->refcnt--);
@@ -718,7 +718,7 @@ scroll_filter_margins_func(ImageRef* ref, Image* img, const void* data) {
     return false;
 }
 
-void 
+void
 grman_scroll_images(GraphicsManager *self, const ScrollData *data) {
     filter_refs(self, data, true, data->has_margins ? scroll_filter_margins_func : scroll_filter_func);
 }
@@ -728,9 +728,14 @@ clear_filter_func(ImageRef *ref, Image UNUSED *img, const void UNUSED *data) {
     return ref->start_row + (int32_t)ref->effective_num_rows > 0;
 }
 
+static inline bool
+clear_all_filter_func(ImageRef *ref UNUSED, Image UNUSED *img, const void UNUSED *data) {
+    return true;
+}
+
 void
-grman_clear(GraphicsManager *self) {
-    filter_refs(self, NULL, true, clear_filter_func);
+grman_clear(GraphicsManager *self, bool all) {
+    filter_refs(self, NULL, true, all ? clear_all_filter_func : clear_filter_func);
 }
 
 static inline bool
@@ -799,18 +804,18 @@ handle_delete_command(GraphicsManager *self, const GraphicsCommand *g, Cursor *c
 
 // }}}
 
-void 
+void
 grman_resize(GraphicsManager *self, index_type UNUSED old_lines, index_type UNUSED lines, index_type UNUSED old_columns, index_type UNUSED columns) {
     self->layers_dirty = true;
 }
 
-void 
+void
 grman_rescale(GraphicsManager *self, unsigned int UNUSED old_cell_width, unsigned int UNUSED old_cell_height) {
     ImageRef *ref; Image *img;
     self->layers_dirty = true;
-    for (size_t i = self->image_count; i-- > 0;) { 
+    for (size_t i = self->image_count; i-- > 0;) {
         img = self->images + i;
-        for (size_t j = img->refcnt; j-- > 0;) { 
+        for (size_t j = img->refcnt; j-- > 0;) {
             ref = img->refs + j;
             ref->cell_x_offset = MIN(ref->cell_x_offset, global_state.cell_width - 1);
             ref->cell_y_offset = MIN(ref->cell_y_offset, global_state.cell_height - 1);
@@ -925,7 +930,7 @@ W(update_layers) {
     for (size_t i = 0; i < self->count; i++) {
         ImageRenderData *r = self->render_data + i;
 #define R(offset) Py_BuildValue("{sf sf sf sf}", "left", r->vertices[offset + 8], "top", r->vertices[offset + 1], "right", r->vertices[offset], "bottom", r->vertices[offset + 5])
-        PyTuple_SET_ITEM(ans, i, 
+        PyTuple_SET_ITEM(ans, i,
             Py_BuildValue("{sN sN sI si sI}", "src_rect", R(0), "dest_rect", R(2), "group_count", r->group_count, "z_index", r->z_index, "image_id", r->image_id)
         );
 #undef R
@@ -950,10 +955,10 @@ PyTypeObject GraphicsManager_Type = {
     PyVarObject_HEAD_INIT(NULL, 0)
     .tp_name = "fast_data_types.GraphicsManager",
     .tp_basicsize = sizeof(GraphicsManager),
-    .tp_dealloc = (destructor)dealloc, 
-    .tp_flags = Py_TPFLAGS_DEFAULT,        
+    .tp_dealloc = (destructor)dealloc,
+    .tp_flags = Py_TPFLAGS_DEFAULT,
     .tp_doc = "GraphicsManager",
-    .tp_new = new,                
+    .tp_new = new,
     .tp_methods = methods,
     .tp_members = members,
 };
@@ -969,7 +974,7 @@ static PyMethodDef module_methods[] = {
 bool
 init_graphics(PyObject *module) {
     if (PyType_Ready(&GraphicsManager_Type) < 0) return false;
-    if (PyModule_AddObject(module, "GraphicsManager", (PyObject *)&GraphicsManager_Type) != 0) return false; 
+    if (PyModule_AddObject(module, "GraphicsManager", (PyObject *)&GraphicsManager_Type) != 0) return false;
     if (PyModule_AddFunctions(module, module_methods) != 0) return false;
     Py_INCREF(&GraphicsManager_Type);
     return true;

kitty/graphics.h

@@ -83,7 +83,7 @@ typedef struct {
 } ScrollData;
 
 GraphicsManager* grman_alloc();
-void grman_clear(GraphicsManager*);
+void grman_clear(GraphicsManager*, bool);
 const char* grman_handle_command(GraphicsManager *self, const GraphicsCommand *g, const uint8_t *payload, Cursor *c, bool *is_dirty);
 bool grman_update_layers(GraphicsManager *self, unsigned int scrolled_by, float screen_left, float screen_top, float dx, float dy, unsigned int num_cols, unsigned int num_rows);
 void grman_scroll_images(GraphicsManager *self, const ScrollData*);

kitty/graphics_fragment.glsl

@@ -2,12 +2,14 @@
 #define ALPHA_TYPE
 
 uniform sampler2D image;
+uniform float inactive_text_alpha;
 
 in vec2 texcoord;
 out vec4 color;
 
 void main() {
     color = texture(image, texcoord);
+    color.a *= inactive_text_alpha;
 #ifdef PREMULT
     color = vec4(color.rgb * color.a, color.a);
 #endif

kitty/history.c

@@ -58,7 +58,7 @@ dealloc(HistoryBuf* self) {
     Py_TYPE(self)->tp_free((PyObject*)self);
 }
 
-static inline index_type 
+static inline index_type
 index_of(HistoryBuf *self, index_type lnum) {
     // The index (buffer position) of the line with line number lnum
     // This is reverse indexing, i.e. lnum = 0 corresponds to the *last* line in the buffer.
@@ -67,7 +67,7 @@ index_of(HistoryBuf *self, index_type lnum) {
     return (self->start_of_data + idx) % self->ynum;
 }
 
-static inline void 
+static inline void
 init_line(HistoryBuf *self, index_type num, Line *l) {
     // Initialize the line l, setting its pointer to the offsets for the line at index (buffer position) num
     l->cells = lineptr(self, num);
@@ -75,22 +75,28 @@ init_line(HistoryBuf *self, index_type num, Line *l) {
     l->has_dirty_text = self->line_attrs[num] & TEXT_DIRTY_MASK ? true : false;
 }
 
-void 
+void
 historybuf_init_line(HistoryBuf *self, index_type lnum, Line *l) {
     init_line(self, index_of(self, lnum), l);
 }
 
-void 
+void
 historybuf_mark_line_clean(HistoryBuf *self, index_type y) {
     self->line_attrs[index_of(self, y)] &= ~TEXT_DIRTY_MASK;
 }
 
-void 
+void
 historybuf_mark_line_dirty(HistoryBuf *self, index_type y) {
     self->line_attrs[index_of(self, y)] |= TEXT_DIRTY_MASK;
 }
 
-static inline index_type 
+inline void
+historybuf_clear(HistoryBuf *self) {
+    self->count = 0;
+    self->start_of_data = 0;
+}
+
+static inline index_type
 historybuf_push(HistoryBuf *self) {
     index_type idx = (self->start_of_data + self->count) % self->ynum;
     init_line(self, idx, self->line);
@@ -124,7 +130,7 @@ historybuf_resize(HistoryBuf *self, index_type lines) {
     return true;
 }
 
-void 
+void
 historybuf_add_line(HistoryBuf *self, const Line *line) {
     index_type idx = historybuf_push(self);
     copy_line(line, self->line);
@@ -234,11 +240,11 @@ PyTypeObject HistoryBuf_Type = {
     PyVarObject_HEAD_INIT(NULL, 0)
     .tp_name = "fast_data_types.HistoryBuf",
     .tp_basicsize = sizeof(HistoryBuf),
-    .tp_dealloc = (destructor)dealloc, 
-    .tp_flags = Py_TPFLAGS_DEFAULT,        
+    .tp_dealloc = (destructor)dealloc,
+    .tp_flags = Py_TPFLAGS_DEFAULT,
     .tp_doc = "History buffers",
     .tp_methods = methods,
-    .tp_members = members,            
+    .tp_members = members,
     .tp_str = (reprfunc)__str__,
     .tp_new = new
 };
@@ -258,9 +264,9 @@ HistoryBuf *alloc_historybuf(unsigned int lines, unsigned int columns) {
 
 #define is_src_line_continued(src_y) (map_src_index(src_y) < src->ynum - 1 ? (src->line_attrs[map_src_index(src_y + 1)] & CONTINUED_MASK) : false)
 
-#define next_dest_line(cont) dest->line_attrs[historybuf_push(dest)] = cont & CONTINUED_MASK; dest->line->continued = cont; 
+#define next_dest_line(cont) dest->line_attrs[historybuf_push(dest)] = cont & CONTINUED_MASK; dest->line->continued = cont;
 
-#define first_dest_line next_dest_line(false); 
+#define first_dest_line next_dest_line(false);
 
 #include "rewrap.h"
 

kitty/icat.py

@@ -7,22 +7,20 @@ import fcntl
 import mimetypes
 import os
 import re
-import selectors
 import signal
 import struct
 import subprocess
 import sys
 import termios
-import tty
 import zlib
 from base64 import standard_b64encode
 from collections import namedtuple
 from math import ceil, floor
 from tempfile import NamedTemporaryFile
-from time import monotonic
 
 from kitty.constants import appname
 from kitty.cli import parse_args
+from kitty.utils import read_with_timeout
 
 try:
     fsenc = sys.getfilesystemencoding() or 'utf-8'
@@ -56,6 +54,13 @@ are in cells (i.e. cursor positions) with the origin |_ (0, 0)| at
 the top-left corner of the screen.
 
 
+--scale-up
+type=bool-set
+When used in combination with |_ --place| it will cause images that
+are smaller than the specified area to be scaled up to use as much
+of the specified area as possible.
+
+
 --clear
 type=bool-set
 Remove all images currently displayed on the screen.
@@ -98,14 +103,18 @@ def options_spec():
 Size = namedtuple('Size', 'rows cols width height')
 
 
-def screen_size(refresh=False):
-    if refresh or getattr(screen_size, 'ans', None) is None:
+def screen_size():
+    if screen_size.changed:
         s = struct.pack('HHHH', 0, 0, 0, 0)
         x = fcntl.ioctl(1, termios.TIOCGWINSZ, s)
         screen_size.ans = Size(*struct.unpack('HHHH', x))
+        screen_size.changed = False
     return screen_size.ans
 
 
+screen_size.changed = True
+
+
 def write_gr_cmd(cmd, payload=None):
     cmd = ','.join('{}={}'.format(k, v) for k, v in cmd.items())
     w = sys.stdout.buffer.write
@@ -131,6 +140,17 @@ def fit_image(width, height, pwidth, pheight):
     return int(width), int(height)
 
 
+def calculate_in_cell_x_offset(width, cell_width, align):
+    if align == 'left':
+        return 0
+    extra_pixels = width % cell_width
+    if not extra_pixels:
+        return 0
+    if align == 'right':
+        return cell_width - extra_pixels
+    return (cell_width - extra_pixels) // 2
+
+
 def set_cursor(cmd, width, height, align):
     ss = screen_size()
     cw = int(ss.width / ss.cols)
@@ -139,12 +159,9 @@ def set_cursor(cmd, width, height, align):
         w, h = fit_image(width, height, ss.width, height)
         ch = int(ss.height / ss.rows)
         num_of_rows_needed = int(ceil(height / ch))
-        y_off = height % ch
         cmd['c'], cmd['r'] = ss.cols, num_of_rows_needed
-        cmd['Y'] = y_off
     else:
-        x_off = width % cw
-        cmd['X'] = x_off
+        cmd['X'] = calculate_in_cell_x_offset(width, cw, align)
         extra_cells = 0
         if align == 'center':
             extra_cells = (ss.cols - num_of_cells_needed) // 2
@@ -159,8 +176,7 @@ def set_cursor_for_place(place, cmd, width, height, align):
     ss = screen_size()
     cw = int(ss.width / ss.cols)
     num_of_cells_needed = int(ceil(width / cw))
-    x_off = width % cw
-    cmd['X'] = x_off
+    cmd['X'] = calculate_in_cell_x_offset(width, cw, align)
     extra_cells = 0
     if align == 'center':
         extra_cells = (place.width - num_of_cells_needed) // 2
@@ -221,14 +237,29 @@ def identify(path):
     return ImageData(parts[0].lower(), int(parts[1]), int(parts[2]), mode)
 
 
-def convert(path, m, available_width, available_height):
+def convert(path, m, available_width, available_height, scale_up):
     width, height = m.width, m.height
     cmd = ['convert', '-background', 'none', path]
+    if scale_up:
+        if width < available_width:
+            r = available_width / width
+            width, height = available_width, int(height * r)
     if width > available_width or height > available_height:
         width, height = fit_image(width, height, available_width, available_height)
         cmd += ['-resize', '{}x{}'.format(width, height)]
     with NamedTemporaryFile(prefix='icat-', suffix='.' + m.mode, delete=False) as outfile:
         run_imagemagick(path, cmd + [outfile.name])
+    # ImageMagick sometimes generated rgba images smaller than the specified
+    # size. See https://github.com/kovidgoyal/kitty/issues/276 for examples
+    sz = os.path.getsize(outfile.name)
+    bytes_per_pixel = 3 if m.mode == 'rgb' else 4
+    expected_size = bytes_per_pixel * width * height
+    if sz < expected_size:
+        missing = expected_size - sz
+        if missing % (bytes_per_pixel * width) != 0:
+            raise SystemExit('ImageMagick failed to convert {} correctly, it generated {} < {} of data'.format(path, sz, expected_size))
+        height -= missing // (bytes_per_pixel * width)
+
     return outfile.name, width, height
 
 
@@ -238,6 +269,7 @@ def process(path, args):
     available_width = args.place.width * (ss.width / ss.cols) if args.place else ss.width
     available_height = args.place.height * (ss.height / ss.rows) if args.place else 10 * m.height
     needs_scaling = m.width > available_width or m.height > available_height
+    needs_scaling = needs_scaling or args.scale_up
     if m.fmt == 'png' and not needs_scaling:
         outfile = path
         transmit_mode = 'f'
@@ -246,7 +278,7 @@ def process(path, args):
     else:
         fmt = 24 if m.mode == 'rgb' else 32
         transmit_mode = 't'
-        outfile, width, height = convert(path, m, available_width, available_height)
+        outfile, width, height = convert(path, m, available_width, available_height, args.scale_up)
     show(outfile, width, height, fmt, transmit_mode, align=args.align, place=args.place)
     if not args.place:
         print()  # ensure cursor is on a new line
@@ -261,17 +293,11 @@ def scan(d):
 
 
 def detect_support(wait_for=10, silent=False):
-    fd = sys.stdin.fileno()
-    old = termios.tcgetattr(fd)
-    oldfl = fcntl.fcntl(fd, fcntl.F_GETFL)
-    fcntl.fcntl(fd, fcntl.F_SETFL, oldfl | os.O_NONBLOCK)
     if not silent:
         print('Checking for graphics ({}s max. wait)...'.format(wait_for), end='\r')
     sys.stdout.flush()
-    tty.setraw(fd)
     try:
         received = b''
-        start_time = monotonic()
         responses = {}
 
         def parse_responses():
@@ -282,29 +308,20 @@ def detect_support(wait_for=10, silent=False):
                     if iid not in responses:
                         responses[iid] = m.group(2) == b'OK'
 
-        def read():
+        def more_needed(data):
             nonlocal received
-            d = sys.stdin.buffer.read()
-            if not d:  # EOF
-                responses[1] = responses[2] = False
-                return
-            received += d
+            received += data
             parse_responses()
+            return 1 not in responses or 2 not in responses
 
         with NamedTemporaryFile() as f:
             f.write(b'abcd'), f.flush()
             write_gr_cmd(dict(a='q', s=1, v=1, i=1), standard_b64encode(b'abcd'))
             write_gr_cmd(dict(a='q', s=1, v=1, i=2, t='f'), standard_b64encode(f.name.encode(fsenc)))
-            sel = selectors.DefaultSelector()
-            sel.register(sys.stdin, selectors.EVENT_READ, read)
-            while monotonic() - start_time < wait_for and 1 not in responses and 2 not in responses:
-                for key, mask in sel.select(0.1):
-                    read()
+            read_with_timeout(more_needed, timeout=wait_for)
     finally:
         if not silent:
             sys.stdout.buffer.write(b'\033[J'), sys.stdout.flush()
-        termios.tcsetattr(fd, termios.TCSADRAIN, old)
-        fcntl.fcntl(fd, fcntl.F_SETFL, oldfl)
     detect_support.has_files = bool(responses.get(2))
     return responses.get(1, False)
 
@@ -324,7 +341,7 @@ def main(args=sys.argv):
         ' Directories are scanned recursively for image files.')
     args, items = parse_args(args[1:], options_spec, 'image-file ...', msg, '{} icat'.format(appname))
 
-    signal.signal(signal.SIGWINCH, lambda: screen_size(refresh=True))
+    signal.signal(signal.SIGWINCH, lambda signum, frame: setattr(screen_size, 'changed', True))
     if not sys.stdout.isatty() or not sys.stdin.isatty():
         raise SystemExit(
             'Must be run in a terminal, stdout and/or stdin is currently not a terminal'

kitty/keys.c

@@ -61,7 +61,7 @@ static inline bool
 is_modifier_key(int key) {
     switch(key) {
         case GLFW_KEY_LEFT_SHIFT:
-        case GLFW_KEY_RIGHT_SHIFT: 
+        case GLFW_KEY_RIGHT_SHIFT:
         case GLFW_KEY_LEFT_ALT:
         case GLFW_KEY_RIGHT_ALT:
         case GLFW_KEY_LEFT_CONTROL:
@@ -83,7 +83,7 @@ get_localized_key(int key, int scancode) {
         // key names {{{
         K('A', A); K('a', A);
         K('B', B); K('b', B);
-        K('C', C); K('c', C); 
+        K('C', C); K('c', C);
         K('D', D); K('d', D);
         K('E', E); K('e', E);
         K('F', F); K('f', F);
@@ -176,7 +176,9 @@ on_key_input(int key, int scancode, int action, int mods) {
         screen_history_scroll(screen, SCROLL_FULL, false);  // scroll back to bottom
     }
 #ifdef __APPLE__
-    if (!OPT(macos_option_as_alt) && IS_ALT_MODS(mods)) return;
+    if (!OPT(macos_option_as_alt) && IS_ALT_MODS(mods) && !(
+                key == GLFW_KEY_UP || key == GLFW_KEY_DOWN || key == GLFW_KEY_LEFT || key == GLFW_KEY_RIGHT)  // alt+arrow keys do not generate text on macOS
+       ) return;
 #endif
     if (
             action == GLFW_PRESS ||
@@ -188,12 +190,14 @@ on_key_input(int key, int scancode, int action, int mods) {
 }
 
 void
-fake_scroll(bool upwards) {
+fake_scroll(int amount, bool upwards) {
     Window *w = active_window();
     if (!w) return;
-    Screen *screen = w->render_data.screen;
-    send_key_to_child(w, upwards ? GLFW_KEY_UP : GLFW_KEY_DOWN, 0, GLFW_PRESS);
-    if (screen->modes.mEXTENDED_KEYBOARD) send_key_to_child(w, upwards ? GLFW_KEY_UP : GLFW_KEY_DOWN, 0, GLFW_RELEASE);
+    int key = upwards ? GLFW_KEY_UP : GLFW_KEY_DOWN;
+    while (amount-- > 0) {
+        send_key_to_child(w, key, 0, GLFW_PRESS);
+        send_key_to_child(w, key, 0, GLFW_RELEASE);
+    }
 }
 
 #define PYWRAP1(name) static PyObject* py##name(PyObject UNUSED *self, PyObject *args)
@@ -209,7 +213,7 @@ PYWRAP1(key_to_bytes) {
 }
 
 static PyMethodDef module_methods[] = {
-    M(key_to_bytes, METH_VARARGS), 
+    M(key_to_bytes, METH_VARARGS),
     {0}
 };
 

kitty/keys.h

@@ -487,12 +487,12 @@ static inline const char*
 key_lookup(uint8_t key, KeyboardMode mode, uint8_t mods, uint8_t action) {
   switch(mode) {
     case NORMAL:
-      switch(action & 3) { case 3: return NULL; 
+      switch(action & 3) { case 3: return NULL;
         case 0: // RELEASE
           return NULL;
 
         case 1: // PRESS
-          switch (mods & 0xf) { 
+          switch (mods & 0xf) {
               case 0x0:
                 switch(key & 0x7f) { default: return NULL;
                   case 50: // ESCAPE
@@ -760,6 +760,14 @@ key_lookup(uint8_t key, KeyboardMode mode, uint8_t mods, uint8_t action) {
                 } // end switch(key)
               case 0x3:
                 switch(key & 0x7f) { default: return NULL;
+                  case 3: // MINUS
+                    return "\x01\x1f";
+                  case 5: // SLASH
+                    return "\x01\x7f";
+                  case 8: // 2
+                    return "\x01\x00";
+                  case 12: // 6
+                    return "\x01\x1e";
                   case 50: // ESCAPE
                     return "\x01\x1b";
                   case 51: // ENTER
@@ -920,7 +928,7 @@ key_lookup(uint8_t key, KeyboardMode mode, uint8_t mods, uint8_t action) {
                   case 52: // TAB
                     return "\x02\x1b\x09";
                   case 53: // BACKSPACE
-                    return "\x02\x1b\x7f";
+                    return "\x01\x17";
                   case 54: // INSERT
                     return "\x06\x1b\x5b\x32\x3b\x33\x7e";
                   case 55: // DELETE
@@ -1071,7 +1079,7 @@ key_lookup(uint8_t key, KeyboardMode mode, uint8_t mods, uint8_t action) {
                   case 52: // TAB
                     return "\x03\x1b\x5b\x5a";
                   case 53: // BACKSPACE
-                    return "\x02\x1b\x7f";
+                    return "\x01\x17";
                   case 54: // INSERT
                     return "\x06\x1b\x5b\x32\x3b\x34\x7e";
                   case 55: // DELETE
@@ -1690,7 +1698,7 @@ key_lookup(uint8_t key, KeyboardMode mode, uint8_t mods, uint8_t action) {
           }  // end switch(mods)
 
         case 2: // REPEAT
-          switch (mods & 0xf) { 
+          switch (mods & 0xf) {
               case 0x0:
                 switch(key & 0x7f) { default: return NULL;
                   case 50: // ESCAPE
@@ -1958,6 +1966,14 @@ key_lookup(uint8_t key, KeyboardMode mode, uint8_t mods, uint8_t action) {
                 } // end switch(key)
               case 0x3:
                 switch(key & 0x7f) { default: return NULL;
+                  case 3: // MINUS
+                    return "\x01\x1f";
+                  case 5: // SLASH
+                    return "\x01\x7f";
+                  case 8: // 2
+                    return "\x01\x00";
+                  case 12: // 6
+                    return "\x01\x1e";
                   case 50: // ESCAPE
                     return "\x01\x1b";
                   case 51: // ENTER
@@ -2118,7 +2134,7 @@ key_lookup(uint8_t key, KeyboardMode mode, uint8_t mods, uint8_t action) {
                   case 52: // TAB
                     return "\x02\x1b\x09";
                   case 53: // BACKSPACE
-                    return "\x02\x1b\x7f";
+                    return "\x01\x17";
                   case 54: // INSERT
                     return "\x06\x1b\x5b\x32\x3b\x33\x7e";
                   case 55: // DELETE
@@ -2269,7 +2285,7 @@ key_lookup(uint8_t key, KeyboardMode mode, uint8_t mods, uint8_t action) {
                   case 52: // TAB
                     return "\x03\x1b\x5b\x5a";
                   case 53: // BACKSPACE
-                    return "\x02\x1b\x7f";
+                    return "\x01\x17";
                   case 54: // INSERT
                     return "\x06\x1b\x5b\x32\x3b\x34\x7e";
                   case 55: // DELETE
@@ -2891,12 +2907,12 @@ key_lookup(uint8_t key, KeyboardMode mode, uint8_t mods, uint8_t action) {
 
 
       case APPLICATION:
-        switch(action & 3) { case 3: return NULL; 
+        switch(action & 3) { case 3: return NULL;
           case 0: // RELEASE
             return NULL;
 
           case 1: // PRESS
-            switch (mods & 0xf) { 
+            switch (mods & 0xf) {
                 case 0x0:
                   switch(key & 0x7f) { default: return NULL;
                     case 50: // ESCAPE
@@ -3164,6 +3180,14 @@ key_lookup(uint8_t key, KeyboardMode mode, uint8_t mods, uint8_t action) {
                   } // end switch(key)
                 case 0x3:
                   switch(key & 0x7f) { default: return NULL;
+                    case 3: // MINUS
+                      return "\x01\x1f";
+                    case 5: // SLASH
+                      return "\x01\x7f";
+                    case 8: // 2
+                      return "\x01\x00";
+                    case 12: // 6
+                      return "\x01\x1e";
                     case 50: // ESCAPE
                       return "\x01\x1b";
                     case 51: // ENTER
@@ -3324,7 +3348,7 @@ key_lookup(uint8_t key, KeyboardMode mode, uint8_t mods, uint8_t action) {
                     case 52: // TAB
                       return "\x02\x1b\x09";
                     case 53: // BACKSPACE
-                      return "\x02\x1b\x7f";
+                      return "\x01\x17";
                     case 54: // INSERT
                       return "\x06\x1b\x5b\x32\x3b\x33\x7e";
                     case 55: // DELETE
@@ -3475,7 +3499,7 @@ key_lookup(uint8_t key, KeyboardMode mode, uint8_t mods, uint8_t action) {
                     case 52: // TAB
                       return "\x03\x1b\x5b\x5a";
                     case 53: // BACKSPACE
-                      return "\x02\x1b\x7f";
+                      return "\x01\x17";
                     case 54: // INSERT
                       return "\x06\x1b\x5b\x32\x3b\x34\x7e";
                     case 55: // DELETE
@@ -4094,7 +4118,7 @@ key_lookup(uint8_t key, KeyboardMode mode, uint8_t mods, uint8_t action) {
             }  // end switch(mods)
 
           case 2: // REPEAT
-            switch (mods & 0xf) { 
+            switch (mods & 0xf) {
                 case 0x0:
                   switch(key & 0x7f) { default: return NULL;
                     case 50: // ESCAPE
@@ -4362,6 +4386,14 @@ key_lookup(uint8_t key, KeyboardMode mode, uint8_t mods, uint8_t action) {
                   } // end switch(key)
                 case 0x3:
                   switch(key & 0x7f) { default: return NULL;
+                    case 3: // MINUS
+                      return "\x01\x1f";
+                    case 5: // SLASH
+                      return "\x01\x7f";
+                    case 8: // 2
+                      return "\x01\x00";
+                    case 12: // 6
+                      return "\x01\x1e";
                     case 50: // ESCAPE
                       return "\x01\x1b";
                     case 51: // ENTER
@@ -4522,7 +4554,7 @@ key_lookup(uint8_t key, KeyboardMode mode, uint8_t mods, uint8_t action) {
                     case 52: // TAB
                       return "\x02\x1b\x09";
                     case 53: // BACKSPACE
-                      return "\x02\x1b\x7f";
+                      return "\x01\x17";
                     case 54: // INSERT
                       return "\x06\x1b\x5b\x32\x3b\x33\x7e";
                     case 55: // DELETE
@@ -4673,7 +4705,7 @@ key_lookup(uint8_t key, KeyboardMode mode, uint8_t mods, uint8_t action) {
                     case 52: // TAB
                       return "\x03\x1b\x5b\x5a";
                     case 53: // BACKSPACE
-                      return "\x02\x1b\x7f";
+                      return "\x01\x17";
                     case 54: // INSERT
                       return "\x06\x1b\x5b\x32\x3b\x34\x7e";
                     case 55: // DELETE
@@ -5295,9 +5327,9 @@ key_lookup(uint8_t key, KeyboardMode mode, uint8_t mods, uint8_t action) {
 
 
         case EXTENDED:
-          switch(action & 3) { case 3: return NULL; 
+          switch(action & 3) { case 3: return NULL;
             case 0: // RELEASE
-              switch (mods & 0xf) { 
+              switch (mods & 0xf) {
                   case 0x0:
                     switch(key & 0x7f) { default: return NULL;
                       case 0: // SPACE
@@ -9061,7 +9093,7 @@ key_lookup(uint8_t key, KeyboardMode mode, uint8_t mods, uint8_t action) {
               }  // end switch(mods)
 
             case 1: // PRESS
-              switch (mods & 0xf) { 
+              switch (mods & 0xf) {
                   case 0x0:
                     switch(key & 0x7f) { default: return NULL;
                       case 0: // SPACE
@@ -12825,7 +12857,7 @@ key_lookup(uint8_t key, KeyboardMode mode, uint8_t mods, uint8_t action) {
               }  // end switch(mods)
 
             case 2: // REPEAT
-              switch (mods & 0xf) { 
+              switch (mods & 0xf) {
                   case 0x0:
                     switch(key & 0x7f) { default: return NULL;
                       case 0: // SPACE

kitty/keys.py

@@ -26,10 +26,17 @@ def modify_complex_key(name, amt):
 
 control_codes = {}
 smkx_key_map = {}
-alt_codes = {defines.GLFW_KEY_TAB: b'\033\t', defines.GLFW_KEY_ENTER: b'\033\r', defines.GLFW_KEY_ESCAPE: b'\033\033', defines.GLFW_KEY_BACKSPACE: b'\033\177'}
+alt_codes = {
+    defines.GLFW_KEY_TAB: b'\033\t',
+    defines.GLFW_KEY_ENTER: b'\033\r',
+    defines.GLFW_KEY_ESCAPE: b'\033\033',
+    # alt+bs matches iTerm and gnome-terminal
+    defines.GLFW_KEY_BACKSPACE: b'\x17'
+}
 shift_alt_codes = alt_codes.copy()
 shift_alt_codes[defines.GLFW_KEY_TAB] = key_as_bytes('kcbt')
 alt_mods = (defines.GLFW_MOD_ALT, defines.GLFW_MOD_SHIFT | defines.GLFW_MOD_ALT)
+ctrl_shift_mod = defines.GLFW_MOD_SHIFT | defines.GLFW_MOD_CONTROL
 
 for kf, kn in {
     defines.GLFW_KEY_UP: 'kcuu1',
@@ -183,6 +190,18 @@ SHIFTED_PRINTABLE.update(pmap(
     "{|}~"
 ))
 
+ASCII_C0_SHIFTED = {
+    # ^@
+    '2': b'\x00',
+    # ^^
+    '6': b'\x1e',
+    # ^_
+    'MINUS': b'\x1f',
+    # ^?
+    'SLASH': b'\x7f',
+}
+CTRL_SHIFT_KEYS = {getattr(defines, 'GLFW_KEY_' + k): v for k, v in ASCII_C0_SHIFTED.items()}
+
 
 def key_to_bytes(key, smkx, extended, mods, action):
     if extended:
@@ -191,6 +210,8 @@ def key_to_bytes(key, smkx, extended, mods, action):
     if mods == defines.GLFW_MOD_CONTROL and key in control_codes:
         # Map Ctrl-key to ascii control code
         data.extend(control_codes[key])
+    elif mods == ctrl_shift_mod and key in CTRL_SHIFT_KEYS:
+        data.extend(CTRL_SHIFT_KEYS[key])
     elif mods in alt_mods:
         if key in alt_codes:
             data.extend((alt_codes if mods == defines.GLFW_MOD_ALT else shift_alt_codes)[key])
@@ -275,13 +296,13 @@ def generate_key_table():
         i += 1
         ind('case {}:'.format(mode))
         i += 1
-        ind('switch(action & 3) { case 3: return NULL; ')
+        ind('switch(action & 3) { case 3: return NULL;')
         for action in (defines.GLFW_RELEASE, defines.GLFW_PRESS, defines.GLFW_REPEAT):
             i += 1
             ind('case {}: // {}'.format(action, 'RELEASE PRESS REPEAT'.split()[action]))
             i += 1
             if action != defines.GLFW_RELEASE or mode == 'EXTENDED':
-                ind('switch (mods & 0xf) { ')
+                ind('switch (mods & 0xf) {')
                 i += 1
                 for mods in range(16):
                     key_bytes = {}

kitty/kitty.conf

@@ -8,7 +8,7 @@
 # bold_font Operator Mono Medium
 # italic_font Operator Mono Book Italic
 # bold_italic_font Operator Mono Medium Italic
-# 
+#
 # You can get a list of full family names available on your computer by running
 # kitty list-fonts
 font_family      monospace
@@ -24,7 +24,7 @@ font_size        11.0
 font_size_delta 2
 
 
-# Adjust the line height. 
+# Adjust the line height.
 # You can use either numbers, which are interpreted as pixels or percentages
 # (number followed by %), which are interpreted as percentages of the
 # unmodified line height. You can use negative pixels or percentages less than
@@ -32,7 +32,7 @@ font_size_delta 2
 adjust_line_height 0
 
 # 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 
+# 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
@@ -73,7 +73,7 @@ cursor           #cccccc
 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 
+# disable blinking. Note that numbers smaller than repaint_delay will be
 # limited to repaint_delay.
 cursor_blink_interval     0.5
 
@@ -104,6 +104,10 @@ click_interval 0.5
 # 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.
+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
@@ -149,6 +153,17 @@ open_url_modifiers ctrl+shift
 # 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
+
 # Choose whether to use the system implementation of wcwidth() (used to
 # control how many cells a character is rendered in).  If you use the system
 # implementation, then kitty and any programs running in it will agree. The
@@ -177,14 +192,23 @@ active_border_color #00ff00
 # The color for the border of inactive windows
 inactive_border_color #cccccc
 
-# Tab-bar customization
+# 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
-tab_separator " ┇"
 
 
 # The 16 terminal colors. There are 8 basic colors, each color has a dull and
@@ -226,10 +250,10 @@ color15  #ffffff
 # Key mapping
 # 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
-# 
+#
 # You can use the special action no_op to unmap a keyboard shortcut that is
 # assigned in the default configuration.
-# 
+#
 # You can combine multiple actions to be triggered by a single shortcut, using the
 # syntax below:
 # map key combine <separator> action1 <separator> action2 <separator> action3 ...
@@ -246,7 +270,7 @@ map shift+insert        paste_from_selection
 # pass_selection_to_program. By default, the system's open program is used, but
 # you can specify your own, for example:
 # map ctrl+shift+o      pass_selection_to_program firefox
-map ctrl+shift+o        pass_selection_to_program 
+map ctrl+shift+o        pass_selection_to_program
 
 # Scrolling
 map ctrl+shift+up        scroll_line_up
@@ -260,8 +284,8 @@ map ctrl+shift+end       scroll_end
 map ctrl+shift+h         show_scrollback
 
 # Window management
-map ctrl+shift+enter    new_window 
-map ctrl+shift+n        new_os_window 
+map ctrl+shift+enter    new_window
+map ctrl+shift+n        new_os_window
 map ctrl+shift+w        close_window
 map ctrl+shift+]        next_window
 map ctrl+shift+[        previous_window
@@ -278,14 +302,20 @@ map ctrl+shift+7        seventh_window
 map ctrl+shift+8        eighth_window
 map ctrl+shift+9        ninth_window
 map ctrl+shift+0        tenth_window
-# You can also open a new window running an arbitrary program, for example:
+# You can open a new window running an arbitrary program, for example:
 # map ctrl+shift+y      new_window mutt
-# You can also pass the current selection to the new program by using the @selection placeholder
+#
+# You can pass the current selection to the new program by using the @selection placeholder
 # map ctrl+shift+y      new_window less @selection
-# Finally, you can even send the contents of the current screen + history buffer as stdin using
+#
+# You can even send the contents of the current screen + history buffer as stdin using
 # the placeholders @text (which is the plain text) and @ansi (which includes text styling escape codes)
 # For example, the following command opens the scrollback buffer in less in a new window.
 # map ctrl+shift+y      new_window @ansi less +G -R
+#
+# 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
@@ -301,7 +331,7 @@ map ctrl+shift+,        move_tab_backward
 # 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.
+# commands to run when using new_tab and use new_tab_with_cwd.
 
 
 # Miscellaneous
@@ -334,20 +364,27 @@ map ctrl+shift+f11      toggle_fullscreen
 # 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
+
 # Hide the kitty window's title bar on macOS.
 macos_hide_titlebar no
 
-# Use the option key as an alt key. With this set to no, kitty will use 
+# Use the option key as an alt key. With this set to no, kitty will use
 # the macOS native Option+Key = unicode character behavior. This will
 # break any Alt+key keyboard shortcuts in your terminal programs, but you
 # can use the macOS unicode input technique.

kitty/layout.py

@@ -6,13 +6,13 @@ from collections import namedtuple
 from itertools import islice
 
 from .constants import WindowGeometry
-from .fast_data_types import pt_to_px, viewport_for_window
+from .fast_data_types import pt_to_px, viewport_for_window, Region
 
-viewport_width = viewport_height = available_height = 400
+central = Region((0, 0, 199, 199, 200, 200))
 cell_width = cell_height = 20
 
 
-def layout_dimension(length, cell_length, number_of_windows=1, border_length=0, margin_length=0, padding_length=0, left_align=False):
+def layout_dimension(start_at, length, cell_length, number_of_windows=1, border_length=0, margin_length=0, padding_length=0, left_align=False):
     number_of_cells = length // cell_length
     border_length += padding_length
     space_needed_for_border = number_of_windows * 2 * border_length
@@ -24,7 +24,9 @@ def layout_dimension(length, cell_length, number_of_windows=1, border_length=0,
         extra = length - number_of_cells * cell_length
     cells_per_window = number_of_cells // number_of_windows
     extra -= space_needed
-    pos = 0 if left_align else (extra // 2)
+    pos = start_at
+    if not left_align:
+        pos += extra // 2
     pos += border_length + margin_length
     inner_length = cells_per_window * cell_length
     window_length = 2 * (border_length + margin_length) + inner_length
@@ -73,30 +75,30 @@ class Layout:
 
     def xlayout(self, num):
         return layout_dimension(
-            viewport_width, cell_width, num, self.border_width,
+            central.left, central.width, cell_width, num, self.border_width,
             margin_length=self.margin_width, padding_length=self.padding_width)
 
     def ylayout(self, num, left_align=True):
         return layout_dimension(
-            available_height, cell_height, num, self.border_width, left_align=left_align,
+            central.top, central.height, cell_height, num, self.border_width, left_align=left_align,
             margin_length=self.margin_width, padding_length=self.padding_width)
 
     def simple_blank_rects(self, first_window, last_window):
-        br, vh = self.blank_rects, available_height
-        left_blank_rect(first_window, br, vh), top_blank_rect(first_window, br, vh), right_blank_rect(last_window, br, vh)
+        br = self.blank_rects
+        left_blank_rect(first_window, br), top_blank_rect(first_window, br), right_blank_rect(last_window, br)
 
     def between_blank_rect(self, left_window, right_window):
-        self.blank_rects.append(Rect(left_window.geometry.right, 0, right_window.geometry.left, available_height))
+        self.blank_rects.append(Rect(left_window.geometry.right, central.top, right_window.geometry.left, central.bottom + 1))
 
     def bottom_blank_rect(self, window):
-        self.blank_rects.append(Rect(window.geometry.left, window.geometry.bottom, window.geometry.right, available_height))
+        self.blank_rects.append(Rect(window.geometry.left, window.geometry.bottom, window.geometry.right, central.bottom + 1))
 
     def set_active_window(self, windows, active_window_idx):
         pass
 
     def __call__(self, windows, active_window_idx):
-        global viewport_width, viewport_height, cell_width, cell_height, available_height
-        viewport_width, viewport_height, available_height, cell_width, cell_height = viewport_for_window(self.os_window_id)
+        global central, cell_width, cell_height
+        central, tab_bar, vw, vh, cell_width, cell_height = viewport_for_window(self.os_window_id)
         self.do_layout(windows, active_window_idx)
 
     def do_layout(self, windows, active_window_idx):
@@ -108,35 +110,38 @@ def window_geometry(xstart, xnum, ystart, ynum):
 
 
 def layout_single_window(margin_length, padding_length):
-    xstart, xnum = next(layout_dimension(viewport_width, cell_width, margin_length=margin_length, padding_length=padding_length))
-    ystart, ynum = next(layout_dimension(available_height, cell_height, margin_length=margin_length, padding_length=padding_length))
+    xstart, xnum = next(layout_dimension(central.left, central.width, cell_width, margin_length=margin_length, padding_length=padding_length))
+    ystart, ynum = next(layout_dimension(central.top, central.height, cell_height, margin_length=margin_length, padding_length=padding_length))
     return window_geometry(xstart, xnum, ystart, ynum)
 
 
-def left_blank_rect(w, rects, vh):
-    if w.geometry.left > 0:
-        rects.append(Rect(0, 0, w.geometry.left, vh))
+def left_blank_rect(w, rects):
+    lt = w.geometry.left
+    if lt > central.left:
+        rects.append(Rect(central.left, central.top, lt, central.bottom + 1))
 
 
-def right_blank_rect(w, rects, vh):
-    if w.geometry.right < viewport_width:
-        rects.append(Rect(w.geometry.right, 0, viewport_width, vh))
+def right_blank_rect(w, rects):
+    r = w.geometry.right
+    if r < central.right:
+        rects.append(Rect(r, central.top, central.right + 1, central.bottom + 1))
 
 
-def top_blank_rect(w, rects, vh):
-    if w.geometry.top > 0:
-        rects.append(Rect(0, 0, viewport_width, w.geometry.top))
+def top_blank_rect(w, rects):
+    t = w.geometry.top
+    if t > central.top:
+        rects.append(Rect(central.left, central.top, central.right + 1, t))
 
 
-def bottom_blank_rect(w, rects, vh):
-    if w.geometry.bottom < available_height:
-        rects.append(Rect(0, w.geometry.bottom, viewport_width, vh))
+def bottom_blank_rect(w, rects):
+    b = w.geometry.bottom
+    if b < central.bottom:
+        rects.append(Rect(central.left, b, central.right + 1, central.bottom + 1))
 
 
 def blank_rects_for_window(w):
     ans = []
-    vh = available_height
-    left_blank_rect(w, ans, vh), top_blank_rect(w, ans, vh), right_blank_rect(w, ans, vh), bottom_blank_rect(w, ans, vh)
+    left_blank_rect(w, ans), top_blank_rect(w, ans), right_blank_rect(w, ans), bottom_blank_rect(w, ans)
     return ans
 
 
@@ -237,4 +242,61 @@ class Grid(Tall):
             self.between_blank_rect(win_col_map[i][0], win_col_map[i + 1][0])
 
 
+class Vertical(Layout):
+
+    name = 'vertical'
+
+    def do_layout(self, windows, active_window_idx):
+        self.blank_rects = []
+        window_count = len(windows)
+        if window_count == 1:
+            wg = layout_single_window(self.margin_width, self.padding_width)
+            windows[0].set_geometry(0, wg)
+            self.blank_rects = blank_rects_for_window(windows[0])
+            return
+
+        xlayout = self.xlayout(1)
+        xstart, xnum = next(xlayout)
+        ylayout = self.ylayout(window_count)
+
+        for i in range(window_count):
+            ystart, ynum = next(ylayout)
+            windows[i].set_geometry(i, window_geometry(xstart, xnum, ystart, ynum))
+
+        # left, top and right blank rects
+        self.simple_blank_rects(windows[0], windows[-1])
+        # bottom blank rect
+        self.bottom_blank_rect(windows[-1])
+
+
+class Horizontal(Layout):
+
+    name = 'horizontal'
+
+    def do_layout(self, windows, active_window_idx):
+        self.blank_rects = []
+        window_count = len(windows)
+        if window_count == 1:
+            wg = layout_single_window(self.margin_width, self.padding_width)
+            windows[0].set_geometry(0, wg)
+            self.blank_rects = blank_rects_for_window(windows[0])
+            return
+
+        xlayout = self.xlayout(window_count)
+        ylayout = self.ylayout(1)
+        ystart, ynum = next(ylayout)
+
+        for i in range(window_count):
+            xstart, xnum = next(xlayout)
+            windows[i].set_geometry(i, window_geometry(xstart, xnum, ystart, ynum))
+            if i > 0:
+                # between blank rect
+                self.between_blank_rect(windows[i - 1], windows[i])
+
+        # left, top and right blank rects
+        self.simple_blank_rects(windows[0], windows[-1])
+        # bottom blank rect
+        self.blank_rects.append(Rect(windows[0].geometry.left, windows[0].geometry.bottom, windows[-1].geometry.right, central.bottom + 1))
+
+
 all_layouts = {o.name: o for o in globals().values() if isinstance(o, type) and issubclass(o, Layout) and o is not Layout}

kitty/line-buf.c

@@ -22,7 +22,7 @@ clear_chars_to(LineBuf* linebuf, index_type y, char_type ch) {
     clear_chars_in_line(lineptr(linebuf, y), linebuf->xnum, ch);
 }
 
-void 
+void
 linebuf_clear(LineBuf *self, char_type ch) {
     memset(self->buf, 0, self->xnum * self->ynum * sizeof(Cell));
     memset(self->line_attrs, 0, self->ynum * sizeof(line_attrs_type));
@@ -97,8 +97,8 @@ new(PyTypeObject *type, PyObject *args, PyObject UNUSED *kwds) {
 static void
 dealloc(LineBuf* self) {
     PyMem_Free(self->buf);
-    PyMem_Free(self->line_map); 
-    PyMem_Free(self->line_attrs); 
+    PyMem_Free(self->line_map);
+    PyMem_Free(self->line_attrs);
     PyMem_Free(self->scratch);
     Py_CLEAR(self->line);
     Py_TYPE(self)->tp_free((PyObject*)self);
@@ -109,7 +109,7 @@ init_line(LineBuf *lb, Line *l, index_type ynum) {
     l->cells = lineptr(lb, ynum);
 }
 
-void 
+void
 linebuf_init_line(LineBuf *self, index_type idx) {
     self->line->ynum = idx;
     self->line->xnum = self->xnum;
@@ -131,12 +131,12 @@ line(LineBuf *self, PyObject *y) {
     return (PyObject*)self->line;
 }
 
-unsigned int 
+unsigned int
 linebuf_char_width_at(LineBuf *self, index_type x, index_type y) {
     return (lineptr(self, self->line_map[y])[x].attrs) & WIDTH_MASK;
 }
 
-void 
+void
 linebuf_set_attribute(LineBuf *self, unsigned int shift, unsigned int val) {
     for (index_type y = 0; y < self->ynum; y++) {
         set_attribute_on_line(lineptr(self, y), shift, val, self->xnum);
@@ -192,7 +192,7 @@ allocate_line_storage(Line *line, bool initialize) {
     return true;
 }
 
-static inline PyObject* 
+static inline PyObject*
 create_line_copy_inner(LineBuf* self, index_type y) {
     Line src, *line;
     line = alloc_line();
@@ -237,7 +237,7 @@ clear_line_(Line *l, index_type xnum) {
     l->has_dirty_text = false;
 }
 
-void 
+void
 linebuf_clear_line(LineBuf *self, index_type y) {
     Line l;
     init_line(self, &l, self->line_map[y]);
@@ -254,7 +254,7 @@ clear_line(LineBuf *self, PyObject *val) {
     Py_RETURN_NONE;
 }
 
-void 
+void
 linebuf_index(LineBuf* self, index_type top, index_type bottom) {
     if (top >= self->ynum - 1 || bottom >= self->ynum || bottom <= top) return;
     index_type old_top = self->line_map[top];
@@ -276,7 +276,7 @@ pyw_index(LineBuf *self, PyObject *args) {
     Py_RETURN_NONE;
 }
 
-void 
+void
 linebuf_reverse_index(LineBuf *self, index_type top, index_type bottom) {
     if (top >= self->ynum - 1 || bottom >= self->ynum || bottom <= top) return;
     index_type old_bottom = self->line_map[bottom];
@@ -308,7 +308,7 @@ is_continued(LineBuf *self, PyObject *val) {
     Py_RETURN_FALSE;
 }
 
-void 
+void
 linebuf_insert_lines(LineBuf *self, unsigned int num, unsigned int y, unsigned int bottom) {
     index_type i;
     if (y >= self->ynum || y > bottom || bottom >= self->ynum) return;
@@ -344,7 +344,7 @@ insert_lines(LineBuf *self, PyObject *args) {
     Py_RETURN_NONE;
 }
 
-void 
+void
 linebuf_delete_lines(LineBuf *self, index_type num, index_type y, index_type bottom) {
     index_type i;
     index_type ylimit = bottom + 1;
@@ -368,7 +368,7 @@ linebuf_delete_lines(LineBuf *self, index_type num, index_type y, index_type bot
         self->line_attrs[i] = 0;
     }
 }
- 
+
 static PyObject*
 delete_lines(LineBuf *self, PyObject *args) {
 #define delete_lines_doc "delete_lines(num, y, bottom) -> Delete num lines at y, only changing lines in the range [y, bottom]."
@@ -377,13 +377,21 @@ delete_lines(LineBuf *self, PyObject *args) {
     linebuf_delete_lines(self, num, y, bottom);
     Py_RETURN_NONE;
 }
- 
+
 static PyObject*
 as_ansi(LineBuf *self, PyObject *callback) {
 #define as_ansi_doc "as_ansi(callback) -> The contents of this buffer as ANSI escaped text. callback is called with each successive line."
     static Py_UCS4 t[5120];
     Line l = {.xnum=self->xnum};
-    for(index_type i = 0; i < self->ynum; i++) {
+    // remove trailing empty lines
+    index_type ylimit = self->ynum - 1;
+    do {
+        init_line(self, (&l), self->line_map[ylimit]);
+        if (line_as_ansi(&l, t, 5120) != 0) break;
+        ylimit--;
+    } while(ylimit > 0);
+
+    for(index_type i = 0; i <= ylimit; i++) {
         l.continued = ((i < self->ynum - 1) ? self->line_attrs[i+1] : self->line_attrs[i]) & CONTINUED_MASK;
         init_line(self, (&l), self->line_map[i]);
         index_type num = line_as_ansi(&l, t, 5120);
@@ -453,11 +461,11 @@ PyTypeObject LineBuf_Type = {
     PyVarObject_HEAD_INIT(NULL, 0)
     .tp_name = "fast_data_types.LineBuf",
     .tp_basicsize = sizeof(LineBuf),
-    .tp_dealloc = (destructor)dealloc, 
-    .tp_flags = Py_TPFLAGS_DEFAULT,        
+    .tp_dealloc = (destructor)dealloc,
+    .tp_flags = Py_TPFLAGS_DEFAULT,
     .tp_doc = "Line buffers",
     .tp_methods = methods,
-    .tp_members = members,            
+    .tp_members = members,
     .tp_str = (reprfunc)__str__,
     .tp_new = new
 };
@@ -485,7 +493,7 @@ copy_old(LineBuf *self, PyObject *y) {
 
 #include "rewrap.h"
 
-void 
+void
 linebuf_rewrap(LineBuf *self, LineBuf *other, index_type *num_content_lines_before, index_type *num_content_lines_after, HistoryBuf *historybuf) {
     index_type first, i;
     bool is_empty = true;
@@ -510,9 +518,9 @@ linebuf_rewrap(LineBuf *self, LineBuf *other, index_type *num_content_lines_befo
     } while(is_empty && first > 0);
 
     if (is_empty) {  // All lines are empty
-        *num_content_lines_after = 0; 
+        *num_content_lines_after = 0;
         *num_content_lines_before = 0;
-        return; 
+        return;
     }
 
     rewrap_inner(self, other, first + 1, historybuf);

kitty/line.c

@@ -34,18 +34,14 @@ line_length(Line *self) {
     return 0;
 }
 
-PyObject* 
-line_text_at(char_type ch, combining_type cc) {
+PyObject*
+cell_text(Cell *cell) {
     PyObject *ans;
-    if (LIKELY(cc == 0)) {
-        ans = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, &ch, 1);
-    } else {
-        Py_UCS4 buf[3];
-        buf[0] = ch; buf[1] = cc & CC_MASK; buf[2] = cc >> 16;
-        Py_UCS4 normalized = normalize(ch, buf[1], buf[2]);
-        if (normalized) ans = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, &normalized, 1);
-        else ans = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, buf, buf[2] ? 3 : 2);
-    }
+    unsigned num = 1;
+    static Py_UCS4 buf[arraysz(cell->cc_idx) + 1];
+    buf[0] = cell->ch;
+    for (unsigned i = 0; i < arraysz(cell->cc_idx) && cell->cc_idx[i]; i++) buf[num++] = codepoint_for_mark(cell->cc_idx[i]);
+    ans = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, buf, num);
     return ans;
 }
 
@@ -67,7 +63,7 @@ find_colon_slash(Line *self, index_type x, index_type limit) {
         if (!is_url_char(ch)) return false;
         switch(state) {
             case ANY:
-                if (ch == '/') state = FIRST_SLASH; 
+                if (ch == '/') state = FIRST_SLASH;
                 break;
             case FIRST_SLASH:
                 state = ch == '/' ? SECOND_SLASH : ANY;
@@ -139,7 +135,7 @@ line_url_end_at(Line *self, index_type x, bool check_short) {
     index_type ans = x;
     if (x >= self->xnum || (check_short && self->xnum <= MIN_URL_LEN + 3)) return 0;
     while (ans < self->xnum && is_url_char(self->cells[ans].ch)) ans++;
-    ans--;
+    if (ans) ans--;
     while (ans > x && can_strip_from_end_of_url(self->cells[ans].ch)) ans--;
     return ans;
 }
@@ -162,7 +158,7 @@ static PyObject*
 text_at(Line* self, Py_ssize_t xval) {
 #define text_at_doc "[x] -> Return the text in the specified cell"
     if ((unsigned)xval >= self->xnum) { PyErr_SetString(PyExc_IndexError, "Column number out of bounds"); return NULL; }
-    return line_text_at(self->cells[xval].ch, self->cells[xval].cc);
+    return cell_text(self->cells + xval);
 }
 
 size_t
@@ -170,13 +166,7 @@ cell_as_unicode(Cell *cell, bool include_cc, Py_UCS4 *buf, char_type zero_char)
     size_t n = 1;
     buf[0] = cell->ch ? cell->ch : zero_char;
     if (include_cc) {
-        char_type cc = cell->cc;
-        Py_UCS4 cc1 = cc & CC_MASK, cc2;
-        if (cc1) {
-            buf[1] = cc1; n++;
-            cc2 = cc >> 16;
-            if (cc2) { buf[2] = cc2; n++; }
-        }
+        for (unsigned i = 0; i < arraysz(cell->cc_idx) && cell->cc_idx[i]; i++) buf[n++] = codepoint_for_mark(cell->cc_idx[i]);
     }
     return n;
 }
@@ -185,13 +175,7 @@ size_t
 cell_as_utf8(Cell *cell, bool include_cc, char *buf, char_type zero_char) {
     size_t n = encode_utf8(cell->ch ? cell->ch : zero_char, buf);
     if (include_cc) {
-        char_type cc = cell->cc;
-        Py_UCS4 cc1 = cc & CC_MASK, cc2;
-        if (cc1) {
-            n += encode_utf8(cc1, buf + n);
-            cc2 = cc >> 16;
-            if (cc2) { n += encode_utf8(cc2, buf + n); }
-        }
+        for (unsigned i = 0; i < arraysz(cell->cc_idx) && cell->cc_idx[i]; i++) n += encode_utf8(codepoint_for_mark(cell->cc_idx[i]), buf + n);
     }
     buf[n] = 0;
     return n;
@@ -202,9 +186,9 @@ PyObject*
 unicode_in_range(Line *self, index_type start, index_type limit, bool include_cc, char leading_char) {
     size_t n = 0;
     static Py_UCS4 buf[4096];
-    if (leading_char) buf[n++] = leading_char; 
+    if (leading_char) buf[n++] = leading_char;
     char_type previous_width = 0;
-    for(index_type i = start; i < limit && n < sizeof(buf)/sizeof(buf[0]) - 4; i++) {
+    for(index_type i = start; i < limit && n < arraysz(buf) - 2 - arraysz(self->cells->cc_idx); i++) {
         char_type ch = self->cells[i].ch;
         if (ch == 0) {
             if (previous_width == 2) { previous_width = 0; continue; };
@@ -241,9 +225,10 @@ write_sgr(const char *val, Py_UCS4 *buf, index_type buflen, index_type *i) {
 index_type
 line_as_ansi(Line *self, Py_UCS4 *buf, index_type buflen) {
 #define WRITE_SGR(val) { if (!write_sgr(val, buf, buflen, &i)) return i; }
-#define WRITE_CH(val) if (i > buflen - 1) return i; buf[i++] = val; 
+#define WRITE_CH(val) if (i > buflen - 1) return i; buf[i++] = val;
 
     index_type limit = xlimit_for_line(self), i=0;
+    if (limit == 0) return 0;
     char_type previous_width = 0;
 
     WRITE_SGR("0");
@@ -264,12 +249,8 @@ line_as_ansi(Line *self, Py_UCS4 *buf, index_type buflen) {
         t = prev_cursor; prev_cursor = cursor; cursor = t;
         if (*sgr) WRITE_SGR(sgr);
         WRITE_CH(ch);
-        char_type cc = self->cells[pos].cc;
-        Py_UCS4 cc1 = cc & CC_MASK;
-        if (cc1) {
-            WRITE_CH(cc1);
-            cc1 = cc >> 16;
-            if (cc1) { WRITE_CH(cc1); }
+        for(unsigned c = 0; c < arraysz(self->cells[pos].cc_idx) && self->cells[pos].cc_idx[c]; c++) {
+            WRITE_CH(codepoint_for_mark(self->cells[pos].cc_idx[c]));
         }
         previous_width = attrs & WIDTH_MASK;
     }
@@ -316,12 +297,14 @@ width(Line *self, PyObject *val) {
     return PyLong_FromUnsignedLong((unsigned long) (attrs & WIDTH_MASK));
 }
 
-void 
+void
 line_add_combining_char(Line *self, uint32_t ch, unsigned int x) {
-    if (!self->cells[x].ch) return;  // dont allow adding combining chars to a null cell
-    combining_type c = self->cells[x].cc;
-    if (c & CC_MASK) self->cells[x].cc = (c & CC_MASK) | ( (ch & CC_MASK) << CC_SHIFT );
-    else self->cells[x].cc = ch & CC_MASK;
+    Cell *cell = self->cells + x;
+    if (!cell->ch) return;  // dont allow adding combining chars to a null cell
+    for (unsigned i = 0; i < arraysz(cell->cc_idx); i++) {
+        if (!cell->cc_idx[i]) { cell->cc_idx[i] = mark_for_codepoint(ch); return; }
+    }
+    cell->cc_idx[arraysz(cell->cc_idx) - 1] = mark_for_codepoint(ch);
 }
 
 static PyObject*
@@ -371,7 +354,7 @@ set_text(Line* self, PyObject *args) {
         self->cells[i].fg = fg;
         self->cells[i].bg = bg;
         self->cells[i].decoration_fg = dfg;
-        self->cells[i].cc = 0;
+        memset(self->cells[i].cc_idx, 0, sizeof(self->cells[i].cc_idx));
     }
 
     Py_RETURN_NONE;
@@ -398,12 +381,12 @@ cursor_from(Line* self, PyObject *args) {
     return (PyObject*)ans;
 }
 
-void 
+void
 line_clear_text(Line *self, unsigned int at, unsigned int num, char_type ch) {
     attrs_type width = ch ? 1 : 0;
 #define PREFIX \
     for (index_type i = at; i < MIN(self->xnum, at + num); i++) { \
-        self->cells[i].ch = ch; self->cells[i].cc = 0; \
+        self->cells[i].ch = ch; memset(self->cells[i].cc_idx, 0, sizeof(self->cells[i].cc_idx)); \
         self->cells[i].attrs = (self->cells[i].attrs & ATTRS_MASK_WITHOUT_WIDTH) | width; \
     }
     if (CHAR_IS_BLANK(ch)) {
@@ -423,17 +406,17 @@ clear_text(Line* self, PyObject *args) {
     Py_RETURN_NONE;
 }
 
-void 
+void
 line_apply_cursor(Line *self, Cursor *cursor, unsigned int at, unsigned int num, bool clear_char) {
     char_type attrs = CURSOR_TO_ATTRS(cursor, 1);
     color_type fg = (cursor->fg & COL_MASK), bg = (cursor->bg & COL_MASK);
     color_type dfg = cursor->decoration_fg & COL_MASK;
     if (!clear_char) attrs = attrs & ATTRS_MASK_WITHOUT_WIDTH;
-    
+
     for (index_type i = at; i < self->xnum && i < at + num; i++) {
         if (clear_char) {
             self->cells[i].ch = BLANK_CHAR;
-            self->cells[i].cc = 0;
+            memset(self->cells[i].cc_idx, 0, sizeof(self->cells[i].cc_idx));
             self->cells[i].attrs = attrs;
             clear_sprite_position(self->cells[i]);
         } else {
@@ -496,8 +479,8 @@ left_shift(Line *self, PyObject *args) {
     if (num > 0) left_shift_line(self, at, num);
     Py_RETURN_NONE;
 }
- 
-void 
+
+void
 line_set_char(Line *self, unsigned int at, uint32_t ch, unsigned int width, Cursor *cursor, bool UNUSED is_second) {
     if (cursor == NULL) {
         self->cells[at].attrs = (self->cells[at].attrs & ATTRS_MASK_WITHOUT_WIDTH) | width;
@@ -508,7 +491,7 @@ line_set_char(Line *self, unsigned int at, uint32_t ch, unsigned int width, Curs
         self->cells[at].decoration_fg = cursor->decoration_fg & COL_MASK;
     }
     self->cells[at].ch = ch;
-    self->cells[at].cc = 0;
+    memset(self->cells[at].cc_idx, 0, sizeof(self->cells[at].cc_idx));
 }
 
 static PyObject*
@@ -556,7 +539,7 @@ richcmp(PyObject *obj1, PyObject *obj2, int op);
 
 
 static PySequenceMethods sequence_methods = {
-    .sq_length = __len__,                  
+    .sq_length = __len__,
     .sq_item = (ssizeargfunc)text_at
 };
 
@@ -577,7 +560,7 @@ static PyMethodDef methods[] = {
     METHOD(url_start_at, METH_O)
     METHOD(url_end_at, METH_O)
     METHOD(sprite_at, METH_O)
-        
+
     {NULL}  /* Sentinel */
 };
 
@@ -590,7 +573,7 @@ PyTypeObject Line_Type = {
     .tp_str = (reprfunc)as_unicode,
     .tp_as_sequence = &sequence_methods,
     .tp_flags = Py_TPFLAGS_DEFAULT,
-    .tp_richcompare = richcmp,                   
+    .tp_richcompare = richcmp,
     .tp_doc = "Lines",
     .tp_methods = methods,
     .tp_new = new
@@ -605,7 +588,7 @@ Line *alloc_line() {
 RICHCMP(Line)
 INIT_TYPE(Line)
 // }}}
- 
+
 static PyObject*
 copy_char(Line* self, PyObject *args) {
     unsigned int src, dest;
@@ -618,4 +601,3 @@ copy_char(Line* self, PyObject *args) {
     COPY_CELL(self, src, to, dest);
     Py_RETURN_NONE;
 }
-

kitty/lineops.h

@@ -12,7 +12,7 @@ static inline void
 set_attribute_on_line(Cell *cells, uint32_t shift, uint32_t val, index_type xnum) {
     // Set a single attribute on all cells in the line
     attrs_type mask = shift == DECORATION_SHIFT ? 3 : 1;
-    attrs_type aval = (val & mask) << shift; 
+    attrs_type aval = (val & mask) << shift;
     mask = ~(mask << shift);
     for (index_type i = 0; i < xnum; i++) cells[i].attrs = (cells[i].attrs & mask) | aval;
 }
@@ -44,7 +44,6 @@ xlimit_for_line(Line *line) {
     return xlimit;
 }
 
-PyObject* line_text_at(char_type, combining_type);
 void line_clear_text(Line *self, unsigned int at, unsigned int num, char_type ch);
 void line_apply_cursor(Line *self, Cursor *cursor, unsigned int at, unsigned int num, bool clear_char);
 void line_set_char(Line *, unsigned int , uint32_t , unsigned int , Cursor *, bool);
@@ -79,3 +78,4 @@ void historybuf_init_line(HistoryBuf *self, index_type num, Line *l);
 void historybuf_mark_line_clean(HistoryBuf *self, index_type y);
 void historybuf_mark_line_dirty(HistoryBuf *self, index_type y);
 void historybuf_refresh_sprite_positions(HistoryBuf *self);
+void historybuf_clear(HistoryBuf *self);

kitty/main.py

@@ -12,15 +12,15 @@ from .borders import load_borders_program
 from .boss import Boss
 from .cli import create_opts, parse_args
 from .config import initial_window_size, load_cached_values, save_cached_values
-from .constants import glfw_path, is_macos, is_wayland, logo_data_file
+from .constants import appname, glfw_path, is_macos, is_wayland, logo_data_file
 from .fast_data_types import (
     change_wcwidth, create_os_window, glfw_init, glfw_terminate,
     install_sigchld_handler, set_default_window_icon, set_options, show_window
 )
 from .fonts.box_drawing import set_scale
 from .utils import (
-    detach, encode_wm_class, end_startup_notification,
-    init_startup_notification, single_instance
+    detach, end_startup_notification, init_startup_notification,
+    single_instance
 )
 from .window import load_shader_programs
 
@@ -42,7 +42,7 @@ def run_app(opts, args):
     set_options(opts, is_wayland, args.debug_gl)
     load_cached_values()
     w, h = initial_window_size(opts)
-    window_id = create_os_window(w, h, encode_wm_class(args.name, args.cls), False, load_all_shaders)
+    window_id = create_os_window(w, h, appname, args.name or args.cls or appname, args.cls or appname, load_all_shaders)
     startup_ctx = init_startup_notification(window_id)
     show_window(window_id)
     if not is_wayland and not is_macos:  # no window icons on wayland
@@ -109,14 +109,20 @@ def main():
             locale.setlocale(locale.LC_ALL, '')
         except Exception:
             print('Failed to set locale with no LANG, ignoring', file=sys.stderr)
+
+    # Ensure kitty is in PATH
     rpath = getattr(sys, 'bundle_exe_dir', None)
-    if rpath:
-        # Ensure kitty bin directory is in PATH
-        items = frozenset(os.environ['PATH'].split(os.pathsep))
-        if rpath not in items:
-            os.environ['PATH'] += os.pathsep + rpath
-    if os.environ.pop('KITTY_LAUNCHED_BY_LAUNCH_SERVICES',
-                      None) == '1' and getattr(sys, 'frozen', True):
+    items = frozenset(os.environ['PATH'].split(os.pathsep))
+    if not rpath:
+        for candidate in items:
+            if os.access(os.path.join(candidate, 'kitty'), os.X_OK):
+                break
+        else:
+            rpath = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'launcher')
+    if rpath and rpath not in items:
+        os.environ['PATH'] += os.pathsep + rpath
+
+    if os.environ.pop('KITTY_LAUNCHED_BY_LAUNCH_SERVICES', None) == '1':
         os.chdir(os.path.expanduser('~'))
     if not os.path.isdir(os.getcwd()):
         os.chdir(os.path.expanduser('~'))

kitty/modes.h

@@ -16,7 +16,7 @@
 /* *Insert/Replace Mode*: When enabled, new display characters move
    old display characters to the right. Characters moved past the
    right margin are lost. Otherwise, new display characters replace
-   old display characters at the cursor position. 
+   old display characters at the cursor position.
 */
 #define IRM 4
 

kitty/mouse.c

@@ -42,24 +42,21 @@ button_map(int button) {
 
 static char mouse_event_buf[64];
 
-int
-encode_mouse_event(Window *w, int button, MouseAction action, int mods) {
-    unsigned int x = w->mouse_cell_x + 1, y = w->mouse_cell_y + 1; // 1 based indexing
+static inline int
+encode_mouse_event_impl(unsigned int x, unsigned int y, int mouse_tracking_protocol, int button, MouseAction action, int mods) {
     unsigned int cb = 0;
-    Screen *screen = w->render_data.screen;
-
     if (action == MOVE) {
-        if (screen->modes.mouse_tracking_protocol != SGR_PROTOCOL) cb = 3;
+        cb = 3;
     } else {
         cb = button_map(button);
         if (cb == UINT_MAX) return 0;
     }
     if (action == DRAG || action == MOVE) cb |= MOTION_INDICATOR;
-    else if (action == RELEASE && screen->modes.mouse_tracking_protocol != SGR_PROTOCOL) cb = 3;
+    else if (action == RELEASE && mouse_tracking_protocol != SGR_PROTOCOL) cb = 3;
     if (mods & GLFW_MOD_SHIFT) cb |= SHIFT_INDICATOR;
     if (mods & GLFW_MOD_ALT) cb |= ALT_INDICATOR;
     if (mods & GLFW_MOD_CONTROL) cb |= CONTROL_INDICATOR;
-    switch(screen->modes.mouse_tracking_protocol) {
+    switch(mouse_tracking_protocol) {
         case SGR_PROTOCOL:
             return snprintf(mouse_event_buf, sizeof(mouse_event_buf), "<%d;%d;%d%s", cb, x, y, action == RELEASE ? "m" : "M");
             break;
@@ -67,7 +64,7 @@ encode_mouse_event(Window *w, int button, MouseAction action, int mods) {
             return snprintf(mouse_event_buf, sizeof(mouse_event_buf), "%d;%d;%dM", cb + 32, x, y);
             break;
         case UTF8_PROTOCOL:
-            mouse_event_buf[0] = 'M'; mouse_event_buf[1] = cb + 32; 
+            mouse_event_buf[0] = 'M'; mouse_event_buf[1] = cb + 32;
             unsigned int sz = 2;
             sz += encode_utf8(x + 32, mouse_event_buf + sz);
             sz += encode_utf8(y + 32, mouse_event_buf + sz);
@@ -84,6 +81,14 @@ encode_mouse_event(Window *w, int button, MouseAction action, int mods) {
     return 0;
 }
 
+static int
+encode_mouse_event(Window *w, int button, MouseAction action, int mods) {
+    unsigned int x = w->mouse_cell_x + 1, y = w->mouse_cell_y + 1; // 1 based indexing
+    Screen *screen = w->render_data.screen;
+    return encode_mouse_event_impl(x, y, screen->modes.mouse_tracking_protocol, button, action, mods);
+
+}
+
 static inline bool
 contains_mouse(Window *w) {
     WindowGeometry *g = &w->geometry;
@@ -111,7 +116,7 @@ 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 == (GLFW_MOD_CONTROL | GLFW_MOD_ALT));
+        else screen_start_selection(screen, w->mouse_cell_x, w->mouse_cell_y, modifiers == (int)OPT(rectangle_select_modifiers));
     } 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);
@@ -264,7 +269,7 @@ HANDLER(handle_button_event) {
     Screen *screen = w->render_data.screen;
     if (!screen) return;
     bool handle_in_kitty = (
-            modifiers == GLFW_MOD_SHIFT || 
+            modifiers == GLFW_MOD_SHIFT ||
             screen->modes.mouse_tracking_mode == 0 ||
             button == GLFW_MOUSE_BUTTON_MIDDLE ||
             (modifiers == (int)OPT(open_url_modifiers) && button == GLFW_MOUSE_BUTTON_LEFT)
@@ -297,7 +302,7 @@ HANDLER(handle_event) {
             for (int i = 0; i < GLFW_MOUSE_BUTTON_5; i++) { if (global_state.callback_os_window->mouse_button_pressed[i]) { button = i; break; } }
             handle_move_event(w, button, modifiers, window_idx);
             break;
-        case GLFW_MOUSE_BUTTON_LEFT:  
+        case GLFW_MOUSE_BUTTON_LEFT:
         case GLFW_MOUSE_BUTTON_RIGHT:
         case GLFW_MOUSE_BUTTON_MIDDLE:
         case GLFW_MOUSE_BUTTON_4:
@@ -309,15 +314,25 @@ HANDLER(handle_event) {
     }
 }
 
-static inline void 
+static inline void
 handle_tab_bar_mouse(int button, int UNUSED modifiers) {
     if (button != GLFW_MOUSE_BUTTON_LEFT || !global_state.callback_os_window->mouse_button_pressed[button]) return;
     call_boss(activate_tab_at, "Kd", global_state.callback_os_window->id, global_state.callback_os_window->mouse_x);
 }
 
+static inline bool
+mouse_in_region(Region *r) {
+    if (r->left == r->right) return false;
+	if (global_state.callback_os_window->mouse_y < r->top || global_state.callback_os_window->mouse_y > r->bottom) return false;
+	if (global_state.callback_os_window->mouse_x < r->left || global_state.callback_os_window->mouse_x > r->right) return false;
+	return true;
+}
+
 static inline Window*
 window_for_event(unsigned int *window_idx, bool *in_tab_bar) {
-    *in_tab_bar = global_state.callback_os_window->num_tabs > 1 && global_state.callback_os_window->mouse_y >= global_state.callback_os_window->viewport_height - global_state.cell_height;
+    Region central, tab_bar;
+	os_window_regions(global_state.callback_os_window, &central, &tab_bar);
+	*in_tab_bar = mouse_in_region(&tab_bar);
     if (!*in_tab_bar && global_state.callback_os_window->num_tabs > 0) {
         Tab *t = global_state.callback_os_window->tabs + global_state.callback_os_window->active_tab;
         for (unsigned int i = 0; i < t->num_windows; i++) {
@@ -347,9 +362,9 @@ mouse_event(int button, int modifiers) {
     bool in_tab_bar;
     unsigned int window_idx = 0;
     Window *w = window_for_event(&window_idx, &in_tab_bar);
-    if (in_tab_bar) { 
+    if (in_tab_bar) {
         mouse_cursor_shape = HAND;
-        handle_tab_bar_mouse(button, modifiers); 
+        handle_tab_bar_mouse(button, modifiers);
     } else if(w) {
         handle_event(w, button, modifiers, window_idx);
     }
@@ -375,8 +390,28 @@ scroll_event(double UNUSED xoffset, double yoffset) {
                 int sz = encode_mouse_event(w, upwards ? GLFW_MOUSE_BUTTON_4 : GLFW_MOUSE_BUTTON_5, PRESS, 0);
                 if (sz > 0) { mouse_event_buf[sz] = 0; write_escape_code_to_child(screen, CSI, mouse_event_buf); }
             } else {
-                fake_scroll(upwards);
+                fake_scroll(abs(s), upwards);
             }
         }
     }
 }
+
+static PyObject*
+test_encode_mouse(PyObject *self UNUSED, PyObject *args) {
+    unsigned int x, y;
+    int mouse_tracking_protocol, button, action, mods;
+    if (!PyArg_ParseTuple(args, "IIiiii", &x, &y, &mouse_tracking_protocol, &button, &action, &mods)) return NULL;
+    int sz = encode_mouse_event_impl(x, y, mouse_tracking_protocol, button, action, mods);
+    return PyUnicode_FromStringAndSize(mouse_event_buf, sz);
+}
+
+static PyMethodDef module_methods[] = {
+    METHODB(test_encode_mouse, METH_VARARGS),
+    {NULL, NULL, 0, NULL}        /* Sentinel */
+};
+
+bool
+init_mouse(PyObject *module) {
+    if (PyModule_AddFunctions(module, module_methods) != 0) return false;
+    return true;
+}

kitty/parser.c

@@ -62,7 +62,7 @@ utf8(char_type codepoint) {
 
 
 #ifdef DUMP_COMMANDS
-static void 
+static void
 _report_error(PyObject *dump_callback, const char *fmt, ...) {
     va_list argptr;
     va_start(argptr, fmt);
@@ -74,7 +74,7 @@ _report_error(PyObject *dump_callback, const char *fmt, ...) {
     }
 }
 
-static void 
+static void
 _report_params(PyObject *dump_callback, const char *name, unsigned int *params, unsigned int count, Region *r) {
     static char buf[MAX_PARAMS*3] = {0};
     unsigned int i, p=0;
@@ -126,7 +126,7 @@ _report_params(PyObject *dump_callback, const char *name, unsigned int *params,
 #define REPORT_ERROR(...) fprintf(stderr, "%s ", ERROR_PREFIX); fprintf(stderr, __VA_ARGS__); fprintf(stderr, "\n");
 
 #define REPORT_COMMAND(...)
-#define REPORT_VA_COMMAND(...) 
+#define REPORT_VA_COMMAND(...)
 #define REPORT_DRAW(ch)
 #define REPORT_PARAMS(...)
 #define FLUSH_DRAW
@@ -142,7 +142,7 @@ _report_params(PyObject *dump_callback, const char *name, unsigned int *params,
 static inline void
 screen_nel(Screen *screen) { screen_carriage_return(screen); screen_linefeed(screen); }
 
-static inline void 
+static inline void
 handle_normal_mode_char(Screen *screen, uint32_t ch, PyObject DUMP_UNUSED *dump_callback) {
 #define CALL_SCREEN_HANDLER(name) REPORT_COMMAND(name); name(screen); break;
     switch(ch) {
@@ -191,11 +191,11 @@ handle_normal_mode_char(Screen *screen, uint32_t ch, PyObject DUMP_UNUSED *dump_
 } // }}}
 
 // Esc mode {{{
-static inline void 
+static inline void
 handle_esc_mode_char(Screen *screen, uint32_t ch, PyObject DUMP_UNUSED *dump_callback) {
-#define CALL_ED(name) REPORT_COMMAND(name); name(screen); SET_STATE(0); 
-#define CALL_ED1(name, ch) REPORT_COMMAND(name, ch); name(screen, ch); SET_STATE(0); 
-#define CALL_ED2(name, a, b) REPORT_COMMAND(name, a, b); name(screen, a, b); SET_STATE(0); 
+#define CALL_ED(name) REPORT_COMMAND(name); name(screen); SET_STATE(0);
+#define CALL_ED1(name, ch) REPORT_COMMAND(name, ch); name(screen, ch); SET_STATE(0);
+#define CALL_ED2(name, a, b) REPORT_COMMAND(name, a, b); name(screen, a, b); SET_STATE(0);
     switch(screen->parser_buf_pos) {
         case 0:
             switch (ch) {
@@ -223,9 +223,9 @@ handle_esc_mode_char(Screen *screen, uint32_t ch, PyObject DUMP_UNUSED *dump_cal
                     CALL_ED(screen_save_cursor); break;
                 case ESC_DECRC:
                     CALL_ED(screen_restore_cursor); break;
-                case ESC_DECPNM: 
+                case ESC_DECPNM:
                     CALL_ED(screen_normal_keypad_mode); break;
-                case ESC_DECPAM: 
+                case ESC_DECPAM:
                     CALL_ED(screen_alternate_keypad_mode); break;
                 case '%':
                 case '(':
@@ -240,7 +240,7 @@ handle_esc_mode_char(Screen *screen, uint32_t ch, PyObject DUMP_UNUSED *dump_cal
                     screen->parser_buf[screen->parser_buf_pos++] = ch;
                     break;
                 default:
-                    REPORT_ERROR("%s0x%x", "Unknown char after ESC: ", ch); 
+                    REPORT_ERROR("%s0x%x", "Unknown char after ESC: ", ch);
                     SET_STATE(0); break;
             }
             break;
@@ -363,11 +363,11 @@ dispatch_osc(Screen *screen, PyObject DUMP_UNUSED *dump_callback) {
         case '$':
 
 
-static inline void 
+static inline void
 screen_cursor_up2(Screen *s, unsigned int count) { screen_cursor_up(s, count, false, -1); }
-static inline void 
+static inline void
 screen_cursor_back1(Screen *s, unsigned int count) { screen_cursor_back(s, count, -1); }
-static inline void 
+static inline void
 screen_tabn(Screen *s, unsigned int count) { for (index_type i=0; i < MAX(1, count); i++) screen_tab(s); }
 static inline void
 save_cursor(Screen *s, unsigned int UNUSED param, bool private) {
@@ -481,8 +481,8 @@ parse_sgr(Screen *screen, uint32_t *buf, unsigned int num, unsigned int *params,
                         READ_PARAM;
                         num_start = i + 1;
                         break;
-                    case COLOR: 
-                    case COLOR1: 
+                    case COLOR:
+                    case COLOR1:
                     case COLOR3:
                         REPORT_ERROR("Invalid SGR code containing disallowed character: %s", utf8(buf[i]));
                         return;
@@ -510,7 +510,7 @@ parse_sgr(Screen *screen, uint32_t *buf, unsigned int num, unsigned int *params,
             break;
         case COLOR3:
             if (i > num_start && num_params < MAX_PARAMS) READ_PARAM;
-            if (num_params != 5) { 
+            if (num_params != 5) {
                 REPORT_ERROR("Invalid SGR code containing incomplete semi-colon separated color sequence");
                 break;
             }
@@ -532,7 +532,7 @@ parse_region(Region *r, uint32_t *buf, unsigned int num) {
             default:
                 if (i > start) params[num_params++] = utoi(buf + start, i - start);
                 else if (i == start && buf[i] == ';') params[num_params++] = 0;
-                start = i + 1; 
+                start = i + 1;
                 break;
         }
     }
@@ -541,16 +541,16 @@ parse_region(Region *r, uint32_t *buf, unsigned int num) {
         case 0:
             break;
         case 1:
-            r->top = params[0]; 
+            r->top = params[0];
             break;
         case 2:
-            r->top = params[0]; r->left = params[1]; 
+            r->top = params[0]; r->left = params[1];
             break;
         case 3:
-            r->top = params[0]; r->left = params[1]; r->bottom = params[2]; 
+            r->top = params[0]; r->left = params[1]; r->bottom = params[2];
             break;
         default:
-            r->top = params[0]; r->left = params[1]; r->bottom = params[2]; r->right = params[3]; 
+            r->top = params[0]; r->left = params[1]; r->bottom = params[2]; r->right = params[3];
             break;
     }
     return i;
@@ -639,83 +639,83 @@ dispatch_csi(Screen *screen, PyObject DUMP_UNUSED *dump_callback) {
     }
     if (i > start) params[num_params++] = utoi(buf + start, i - start);
     switch(code) {
-        case ICH: 
-            CALL_CSI_HANDLER1(screen_insert_characters, 1); 
-        case CUU: 
-            CALL_CSI_HANDLER1(screen_cursor_up2, 1); 
-        case CUD: 
-        case VPR: 
-            CALL_CSI_HANDLER1(screen_cursor_down, 1); 
-        case CUF: 
-        case HPR: 
-            CALL_CSI_HANDLER1(screen_cursor_forward, 1); 
-        case CUB: 
-            CALL_CSI_HANDLER1(screen_cursor_back1, 1); 
-        case CNL:  
-            CALL_CSI_HANDLER1(screen_cursor_down1, 1); 
-        case CPL:  
-            CALL_CSI_HANDLER1(screen_cursor_up1, 1); 
-        case CHA: 
-        case HPA: 
-            CALL_CSI_HANDLER1(screen_cursor_to_column, 1); 
-        case VPA: 
-            CALL_CSI_HANDLER1(screen_cursor_to_line, 1); 
+        case ICH:
+            CALL_CSI_HANDLER1(screen_insert_characters, 1);
+        case CUU:
+            CALL_CSI_HANDLER1(screen_cursor_up2, 1);
+        case CUD:
+        case VPR:
+            CALL_CSI_HANDLER1(screen_cursor_down, 1);
+        case CUF:
+        case HPR:
+            CALL_CSI_HANDLER1(screen_cursor_forward, 1);
+        case CUB:
+            CALL_CSI_HANDLER1(screen_cursor_back1, 1);
+        case CNL:
+            CALL_CSI_HANDLER1(screen_cursor_down1, 1);
+        case CPL:
+            CALL_CSI_HANDLER1(screen_cursor_up1, 1);
+        case CHA:
+        case HPA:
+            CALL_CSI_HANDLER1(screen_cursor_to_column, 1);
+        case VPA:
+            CALL_CSI_HANDLER1(screen_cursor_to_line, 1);
         case CBT:
-            CALL_CSI_HANDLER1(screen_backtab, 1); 
+            CALL_CSI_HANDLER1(screen_backtab, 1);
         case CHT:
-            CALL_CSI_HANDLER1(screen_tabn, 1); 
-        case CUP:  
-        case HVP: 
-            CALL_CSI_HANDLER2(screen_cursor_position, 1, 1); 
-        case ED: 
-            CALL_CSI_HANDLER1P(screen_erase_in_display, 0, '?'); 
-        case EL: 
-            CALL_CSI_HANDLER1P(screen_erase_in_line, 0, '?'); 
-        case IL: 
-            CALL_CSI_HANDLER1(screen_insert_lines, 1); 
-        case DL: 
-            CALL_CSI_HANDLER1(screen_delete_lines, 1); 
-        case DCH: 
-            CALL_CSI_HANDLER1(screen_delete_characters, 1); 
-        case ECH: 
-            CALL_CSI_HANDLER1(screen_erase_characters, 1); 
-        case DA: 
-            CALL_CSI_HANDLER1S(report_device_attributes, 0); 
-        case TBC: 
-            CALL_CSI_HANDLER1(screen_clear_tab_stop, 0); 
-        case SM: 
-            SET_MODE(screen_set_mode); 
-        case RM: 
-            SET_MODE(screen_reset_mode); 
-        case DSR: 
-            CALL_CSI_HANDLER1P(report_device_status, 0, '?'); 
-        case SC: 
-            CALL_CSI_HANDLER1P(save_cursor, 0, '?'); 
-        case RC: 
-            CALL_CSI_HANDLER1P(restore_cursor, 0, '?'); 
-        case 'r': 
+            CALL_CSI_HANDLER1(screen_tabn, 1);
+        case CUP:
+        case HVP:
+            CALL_CSI_HANDLER2(screen_cursor_position, 1, 1);
+        case ED:
+            CALL_CSI_HANDLER1P(screen_erase_in_display, 0, '?');
+        case EL:
+            CALL_CSI_HANDLER1P(screen_erase_in_line, 0, '?');
+        case IL:
+            CALL_CSI_HANDLER1(screen_insert_lines, 1);
+        case DL:
+            CALL_CSI_HANDLER1(screen_delete_lines, 1);
+        case DCH:
+            CALL_CSI_HANDLER1(screen_delete_characters, 1);
+        case ECH:
+            CALL_CSI_HANDLER1(screen_erase_characters, 1);
+        case DA:
+            CALL_CSI_HANDLER1S(report_device_attributes, 0);
+        case TBC:
+            CALL_CSI_HANDLER1(screen_clear_tab_stop, 0);
+        case SM:
+            SET_MODE(screen_set_mode);
+        case RM:
+            SET_MODE(screen_reset_mode);
+        case DSR:
+            CALL_CSI_HANDLER1P(report_device_status, 0, '?');
+        case SC:
+            CALL_CSI_HANDLER1P(save_cursor, 0, '?');
+        case RC:
+            CALL_CSI_HANDLER1P(restore_cursor, 0, '?');
+        case 'r':
             if (!start_modifier && !end_modifier) {
                 // DECSTBM
-                CALL_CSI_HANDLER2(screen_set_margins, 0, 0); 
+                CALL_CSI_HANDLER2(screen_set_margins, 0, 0);
             }
             REPORT_ERROR("Unknown CSI r sequence with start and end modifiers: '%c' '%c'", start_modifier, end_modifier);
             break;
         case 'x':
             if (!start_modifier && end_modifier == '*') {
-                CALL_CSI_HANDLER1(screen_decsace, 0); 
+                CALL_CSI_HANDLER1(screen_decsace, 0);
             }
             REPORT_ERROR("Unknown CSI x sequence with start and end modifiers: '%c' '%c'", start_modifier, end_modifier);
             break;
-        case DECSCUSR: 
-            CALL_CSI_HANDLER1M(screen_set_cursor, 1); 
+        case DECSCUSR:
+            CALL_CSI_HANDLER1M(screen_set_cursor, 1);
         case SU:
-            CALL_CSI_HANDLER1(screen_scroll, 1); 
+            CALL_CSI_HANDLER1(screen_scroll, 1);
         case SD:
-            CALL_CSI_HANDLER1(screen_reverse_scroll, 1); 
+            CALL_CSI_HANDLER1(screen_reverse_scroll, 1);
         case DECSTR:
             if (end_modifier == '$') {
                 // DECRQM
-                CALL_CSI_HANDLER1P(report_mode_status, 0, '?'); 
+                CALL_CSI_HANDLER1P(report_mode_status, 0, '?');
             } else {
                 REPORT_ERROR("Unknown DECSTR CSI sequence with start and end modifiers: '%c' '%c'", start_modifier, end_modifier);
             }
@@ -727,6 +727,17 @@ dispatch_csi(Screen *screen, PyObject DUMP_UNUSED *dump_callback) {
 // }}}
 
 // DCS mode {{{
+
+static inline bool
+startswith(const uint32_t *string, size_t sz, const char *prefix) {
+    size_t l = strlen(prefix);
+    if (sz < l) return false;
+    for (size_t i = 0; i < l; i++) {
+        if (string[i] != (unsigned char)prefix[i]) return false;
+    }
+    return true;
+}
+
 static inline void
 dispatch_dcs(Screen *screen, PyObject DUMP_UNUSED *dump_callback) {
     if (screen->parser_buf_pos < 2) return;
@@ -739,11 +750,23 @@ dispatch_dcs(Screen *screen, PyObject DUMP_UNUSED *dump_callback) {
                     REPORT_OSC2(screen_request_capabilities, (char)screen->parser_buf[0], string);
                     screen_request_capabilities(screen, (char)screen->parser_buf[0], string);
                     Py_DECREF(string);
-                }
+                } else PyErr_Clear();
             } else {
                 REPORT_ERROR("Unrecognized DCS %c code: 0x%x", (char)screen->parser_buf[0], screen->parser_buf[1]);
             }
             break;
+        case '@':
+            if (startswith(screen->parser_buf + 1, screen->parser_buf_pos - 2, "kitty-cmd{")) {
+                PyObject *cmd = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, screen->parser_buf + 10, screen->parser_buf_pos - 10);
+                if (cmd != NULL) {
+                    REPORT_OSC2(screen_handle_cmd, (char)screen->parser_buf[0], cmd);
+                    screen_handle_cmd(screen, cmd);
+                    Py_DECREF(cmd);
+                } else PyErr_Clear();
+            } else {
+                REPORT_ERROR("Unrecognized DCS @ code: 0x%x", screen->parser_buf[1]);
+            }
+            break;
         default:
             REPORT_ERROR("Unrecognized DCS code: 0x%x", screen->parser_buf[0]);
             break;
@@ -758,19 +781,19 @@ parse_graphics_code(Screen *screen, PyObject UNUSED *dump_callback) {
     unsigned int pos = 1;
     enum GR_STATES { KEY, EQUAL, UINT, INT, FLAG, AFTER_VALUE, PAYLOAD };
     enum GR_STATES state = KEY, value_state = FLAG;
-    enum KEYS { 
-        action='a', 
+    enum KEYS {
+        action='a',
         delete_action='d',
         transmission_type='t',
         compressed='o',
         format = 'f',
         more = 'm',
         id = 'i',
-        width = 'w', 
+        width = 'w',
         height = 'h',
         x_offset = 'x',
         y_offset = 'y',
-        data_height = 'v', 
+        data_height = 'v',
         data_width = 's',
         data_sz = 'S',
         data_offset = 'O',
@@ -778,7 +801,7 @@ parse_graphics_code(Screen *screen, PyObject UNUSED *dump_callback) {
         num_lines = 'r',
         cell_x_offset = 'X',
         cell_y_offset = 'Y',
-        z_index = 'z'  
+        z_index = 'z'
     };
     enum KEYS key = 'a';
     static GraphicsCommand g;
@@ -840,8 +863,8 @@ parse_graphics_code(Screen *screen, PyObject UNUSED *dump_callback) {
                 is_negative = false;
                 if(screen->parser_buf[pos] == '-') { is_negative = true; pos++; }
 #define U(x) case x: g.x = is_negative ? 0 - (int32_t)code : (int32_t)code; break
-                READ_UINT; 
-                switch(key) { 
+                READ_UINT;
+                switch(key) {
                     U(z_index);
                     default: break;
                 }
@@ -851,9 +874,9 @@ parse_graphics_code(Screen *screen, PyObject UNUSED *dump_callback) {
             case UINT:
                 READ_UINT;
 #define U(x) case x: g.x = code; break
-                switch(key) { 
+                switch(key) {
                     U(format); U(more); U(id); U(data_sz); U(data_offset); U(width); U(height); U(x_offset); U(y_offset); U(data_height); U(data_width); U(num_cells); U(num_lines); U(cell_x_offset); U(cell_y_offset);
-                    default: break; 
+                    default: break;
                 }
                 state = AFTER_VALUE;
                 break;
@@ -869,7 +892,7 @@ parse_graphics_code(Screen *screen, PyObject UNUSED *dump_callback) {
                         state = PAYLOAD;
                         break;
                     default:
-                        REPORT_ERROR("Malformed graphics control block, expecting a comma or semi-colon after a value, found: 0x%x", screen->parser_buf[pos - 1]); 
+                        REPORT_ERROR("Malformed graphics control block, expecting a comma or semi-colon after a value, found: 0x%x", screen->parser_buf[pos - 1]);
                         return;
                 }
                 break;
@@ -879,7 +902,7 @@ parse_graphics_code(Screen *screen, PyObject UNUSED *dump_callback) {
                 err = base64_decode(screen->parser_buf + pos, sz, payload, sizeof(payload), &g.payload_sz);
                 if (err != NULL) { REPORT_ERROR("Failed to parse graphics command payload with error: %s", err); return; }
                 pos = screen->parser_buf_pos;
-                break;  
+                break;
         }
     }
     switch(state) {
@@ -887,16 +910,16 @@ parse_graphics_code(Screen *screen, PyObject UNUSED *dump_callback) {
             REPORT_ERROR("Malformed graphics control block, no = after key"); return;
         case INT:
         case UINT:
-            REPORT_ERROR("Malformed graphics control block, expecting an integer value"); return; 
+            REPORT_ERROR("Malformed graphics control block, expecting an integer value"); return;
         case FLAG:
-            REPORT_ERROR("Malformed graphics control block, expecting a flag value"); return; 
+            REPORT_ERROR("Malformed graphics control block, expecting a flag value"); return;
         default:
             break;
     }
 #define A(x) #x, g.x
 #define U(x) #x, (unsigned int)(g.x)
 #define I(x) #x, (int)(g.x)
-    REPORT_VA_COMMAND("s {sc sc sc sc sI sI sI sI sI  sI sI sI sI sI sI sI sI sI sI  sI si} y#", "graphics_command", 
+    REPORT_VA_COMMAND("s {sc sc sc sc sI sI sI sI sI  sI sI sI sI sI sI sI sI sI sI  sI si} y#", "graphics_command",
             A(action), A(delete_action), A(transmission_type), A(compressed),
             U(format), U(more), U(id), U(data_sz), U(data_offset),
             U(width), U(height), U(x_offset), U(y_offset), U(data_height), U(data_width), U(num_cells), U(num_lines), U(cell_x_offset), U(cell_y_offset),
@@ -1027,7 +1050,7 @@ accumulate_csi(Screen *screen, uint32_t ch, PyObject DUMP_UNUSED *dump_callback)
         REPORT_ERROR("CSI sequence too long, ignoring"); \
         SET_STATE(0); \
         return false; \
-    } 
+    }
 
     switch(ch) {
         IS_DIGIT
@@ -1073,8 +1096,8 @@ END_ALLOW_CASE_RANGE
         case HTS:
             handle_normal_mode_char(screen, ch, dump_callback);
             break;
-        case NUL: 
-        case DEL: 
+        case NUL:
+        case DEL:
             break;  // no-op
         default:
             REPORT_ERROR("Invalid character in CSI: 0x%x, ignoring the sequence", ch);
@@ -1116,7 +1139,7 @@ dispatch_unicode_char(Screen *screen, uint32_t codepoint, PyObject DUMP_UNUSED *
 
 extern uint32_t *latin1_charset;
 
-static inline void 
+static inline void
 _parse_bytes(Screen *screen, uint8_t *buf, Py_ssize_t len, PyObject DUMP_UNUSED *dump_callback) {
     uint32_t prev = screen->utf8_state;
     for (unsigned int i = 0; i < (unsigned int)len; i++) {

kitty/remote_control.py

@@ -0,0 +1,488 @@
+#!/usr/bin/env python
+# vim:fileencoding=utf-8
+# License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
+
+import json
+import re
+import sys
+import types
+from functools import partial
+
+from .cli import emph, parse_args
+from .config import parse_send_text_bytes
+from .constants import appname, version
+from .tabs import SpecialWindow
+from .utils import non_blocking_read, read_with_timeout
+
+
+def cmd(short_desc, desc=None, options_spec=None, no_response=False):
+
+    def w(func):
+        func.short_desc = short_desc
+        func.desc = desc or short_desc
+        func.name = func.__name__[4:].replace('_', '-')
+        func.options_spec = options_spec
+        func.is_cmd = True
+        func.impl = lambda: globals()[func.__name__[4:]]
+        func.no_response = no_response
+        return func
+    return w
+
+
+def parse_subcommand_cli(func, args):
+    opts, items = parse_args(args[1:], (func.options_spec or '\n').format, '...', 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:
+|_ field:regexp|. Where field can be one of: id, title, pid, cwd, cmdline.
+You can use the |_ ls| command to get a list of windows. Note that for
+numeric fields such as id and pid the expression is interpreted as a number,
+not a regular expression.
+'''
+MATCH_TAB_OPTION = '''\
+--match -m
+The tab to match. Match specifications are of the form:
+|_ field:regexp|. Where field can be one of: id, title, pid, cwd, cmdline.
+You can use the |_ ls| command to get a list of tabs. Note that for
+numeric fields such as id and pid the expression is interpreted as a number,
+not a regular expression. When using title or id, first a matching tab is
+looked for and if not found a matching window is looked for, and the tab
+for that window is used.
+'''
+
+
+@cmd(
+    'Send arbitrary text to specified windows',
+    'Send arbitrary text to specified windows. The text follows Python'
+    ' escaping rules. So you can use escapes like |_ \\x1b| to send control codes'
+    ' and |_ \\u21fa| to send unicode characters. If you use the |_ --match| option'
+    ' the text will be sent to all matched windows. By default, text is sent to'
+    ' only the currently active window.',
+    options_spec=MATCH_WINDOW_OPTION + '''\n
+--stdin
+type=bool-set
+Read the text to be sent from |_ stdin|. Note that in this case the text is sent as is,
+not interpreted for escapes. If stdin is a terminal, you can press Ctrl-D to end reading.
+
+
+--from-file
+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
+)
+def cmd_send_text(global_opts, opts, args):
+    limit = 1024
+    ret = {'match': opts.match, 'is_binary': False}
+
+    def pipe(src=sys.stdin):
+        ret['is_binary'] = True
+        import select
+        with non_blocking_read() as fd:
+            keep_going = True
+            while keep_going:
+                rd = select.select([fd], [], [])
+                if rd:
+                    data = sys.stdin.buffer.read()
+                    if not data:
+                        break
+                    data = data.decode('utf-8')
+                    if '\x04' in data:
+                        data = data[:data.index('\x04')]
+                        keep_going = False
+                    while data:
+                        ret['text'] = data[:limit]
+                        yield ret
+                        data = data[limit:]
+                else:
+                    break
+
+    def chunks(text):
+        ret['is_binary'] = False
+        while text:
+            ret['text'] = text[:limit]
+            yield ret
+            text = text[limit:]
+
+    def file_pipe(path):
+        ret['is_binary'] = True
+        with open(path, encoding='utf-8') as f:
+            while True:
+                data = f.read(limit)
+                if not data:
+                    break
+                ret['text'] = data
+                yield ret
+
+    sources = []
+    if opts.stdin:
+        sources.append(pipe())
+
+    if opts.from_file:
+        sources.append(file_pipe(opts.from_file))
+
+    text = ' '.join(args)
+    sources.append(chunks(text))
+
+    def chain():
+        for src in sources:
+            yield from src
+    return chain()
+
+
+def send_text(boss, window, payload):
+    windows = [boss.active_window]
+    match = payload['match']
+    if match:
+        windows = tuple(boss.match_windows(match))
+    data = payload['text'].encode('utf-8') if payload['is_binary'] else parse_send_text_bytes(payload['text'])
+    for window in windows:
+        if window is not None:
+            window.write_to_child(data)
+
+
+@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
+)
+def cmd_set_window_title(global_opts, opts, args):
+    return {'title': ' '.join(args), 'match': opts.match}
+
+
+def set_window_title(boss, window, payload):
+    windows = [window or boss.active_window]
+    match = payload['match']
+    if match:
+        windows = tuple(boss.match_windows(match))
+        if not windows:
+            raise ValueError('No matching windows for expression: {}'.format(match))
+    for window in windows:
+        if window:
+            window.set_title(payload['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
+)
+def cmd_set_tab_title(global_opts, opts, args):
+    return {'title': ' '.join(args), 'match': opts.match}
+
+
+def set_tab_title(boss, window, payload):
+    match = payload['match']
+    if match:
+        tabs = tuple(boss.match_tabs(match))
+        if not tabs:
+            raise ValueError('No matching windows for expression: {}'.format(match))
+    else:
+        tabs = [boss.tab_for_window(window) if window else boss.active_tab]
+    for tab in tabs:
+        if tab:
+            tab.set_title(payload['title'])
+
+
+@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.
+'''
+)
+def cmd_close_window(global_opts, opts, args):
+    return {'match': opts.match, 'self': opts.self}
+
+
+def close_window(boss, window, payload):
+    match = payload['match']
+    if match:
+        windows = tuple(boss.match_windows(match))
+        if not windows:
+            raise ValueError('No matching windows for expression: {}'.format(match))
+    else:
+        windows = [window if window and payload['self'] else boss.active_window]
+    for window in windows:
+        if window:
+            boss.close_window(window)
+
+
+@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.
+'''
+)
+def cmd_close_tab(global_opts, opts, args):
+    return {'match': opts.match, 'self': opts.self}
+
+
+def close_tab(boss, window, payload):
+    match = payload['match']
+    if match:
+        tabs = tuple(boss.match_tabs(match))
+        if not tabs:
+            raise ValueError('No matching windows for expression: {}'.format(match))
+    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)
+
+
+@cmd(
+    'Open new window',
+    'Open a new window in the specified tab. If you use the |_ --match| option'
+    ' the first matching tab is used. Otherwise the currently active tab is used.'
+    ' Prints out the id of the newly opened window. Any command line arguments'
+    ' are assumed to be the command line used to run in the new window, if none'
+    ' are provided, the default shell is run. For example:\n'
+    '|_ kitty @ new-window --title Email mutt|',
+    options_spec=MATCH_TAB_OPTION + '''\n
+--title
+The title for the new window. By default it will use the title set by the
+program running in it.
+
+
+--cwd
+The initial working directory for the new window.
+
+
+--keep-focus
+type=bool-set
+Keep the current window focused instead of switching to the newly opened window
+
+
+--new-tab
+type=bool-set
+Open a new tab
+
+
+--tab-title
+When using --new-tab set the title of the tab.
+'''
+)
+def cmd_new_window(global_opts, opts, args):
+    return {'match': opts.match, 'title': opts.title, 'cwd': opts.cwd,
+            'new_tab': opts.new_tab, 'tab_title': opts.tab_title,
+            'keep_focus': opts.keep_focus, 'args': args or []}
+
+
+def new_window(boss, window, payload):
+    w = SpecialWindow(cmd=payload['args'] or None, override_title=payload['title'], cwd=payload['cwd'])
+    old_window = boss.active_window
+    if payload['new_tab']:
+        boss._new_tab(w)
+        tab = boss.active_tab
+        if payload['tab_title']:
+            tab.set_title(payload['tab_title'])
+        wid = boss.active_window.id
+        if payload['keep_focus'] and old_window:
+            boss.set_active_window(old_window)
+        return str(wid)
+
+    match = payload['match']
+    if match:
+        tabs = tuple(boss.match_tabs(match))
+        if not tabs:
+            raise ValueError('No matching windows for expression: {}'.format(match))
+    else:
+        tabs = [boss.active_tab]
+    tab = tabs[0]
+    w = tab.new_special_window(w)
+    if payload['keep_focus'] and old_window:
+        boss.set_active_window(old_window)
+    return str(w.id)
+
+
+@cmd(
+    'Focus the specified window',
+    options_spec=MATCH_WINDOW_OPTION
+)
+def cmd_focus_window(global_opts, opts, args):
+    return {'match': opts.match}
+
+
+def focus_window(boss, window, payload):
+    windows = [window or boss.active_window]
+    match = payload['match']
+    if match:
+        windows = tuple(boss.match_windows(match))
+        if not windows:
+            raise ValueError('No matching windows for expression: {}'.format(match))
+    for window in windows:
+        if window:
+            boss.set_active_window(window)
+            break
+
+
+@cmd(
+    'Get text from the specified window',
+    options_spec=MATCH_WINDOW_OPTION + '''\n
+--extent
+default=screen
+choices=screen, all, selection
+What text to get. The default of screen means all text currently on the screen. all means
+all the screen+scrollback and selection means currently selected text.
+
+
+--ansi
+type=bool-set
+By default, only plain text is returned. If you specify this flag, the text will
+include the formatting escape codes for colors/bold/italic/etc. Note that when
+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.
+'''
+)
+def cmd_get_text(global_opts, opts, args):
+    return {'match': opts.match, 'extent': opts.extent, 'ansi': opts.ansi, 'self': opts.self}
+
+
+def get_text(boss, window, payload):
+    match = payload['match']
+    if match:
+        windows = tuple(boss.match_windows(match))
+        if not windows:
+            raise ValueError('No matching windows for expression: {}'.format(match))
+    else:
+        windows = [window if window and payload['self'] else boss.active_window]
+    window = windows[0]
+    if payload['extent'] == 'selection':
+        ans = window.text_for_selection()
+    else:
+        f = window.buffer_as_ansi if payload['ansi'] else window.buffer_as_text
+        ans = f(add_history=payload['extent'] == 'all')
+    return ans
+
+
+cmap = {v.name: v for v in globals().values() if hasattr(v, 'is_cmd')}
+
+
+def handle_cmd(boss, window, cmd):
+    cmd = json.loads(cmd)
+    v = cmd['version']
+    if tuple(v)[:2] > version[:2]:
+        return {'ok': False, 'error': 'The kitty client you are using to send remote commands is newer than this kitty instance. This is not supported.'}
+    c = cmap[cmd['cmd']]
+    func = partial(c.impl(), boss, window)
+    payload = cmd.get('payload')
+    ans = func() if payload is None else func(payload)
+    response = {'ok': True}
+    if ans is not None:
+        response['data'] = ans
+    if not c.no_response:
+        return response
+
+
+global_options_spec = partial('''\
+
+'''.format, appname=appname)
+
+
+def read_from_stdin(send, no_response):
+    send = ('@kitty-cmd' + json.dumps(send)).encode('ascii')
+    out = sys.stdout if sys.stdout.isatty() else sys.stderr
+    if not out.isatty():
+        raise SystemExit('Neither stdout nor stderr is a terminal')
+    out.buffer.write(b'\x1bP' + send + b'\x1b\\')
+    out.flush()
+    if no_response:
+        return {'ok': True}
+    if not sys.stdin.isatty():
+        raise SystemExit('stdin is not a terminal')
+
+    received = b''
+    dcs = re.compile(br'\x1bP@kitty-cmd([^\x1b]+)\x1b\\')
+    match = None
+
+    def more_needed(data):
+        nonlocal received, match
+        received += data
+        match = dcs.search(received)
+        return match is None
+
+    read_with_timeout(more_needed)
+    if match is None:
+        raise SystemExit('Failed to receive response from ' + appname)
+    response = json.loads(match.group(1).decode('ascii'))
+    return response
+
+
+def main(args):
+    all_commands = tuple(sorted(cmap))
+    cmds = ('  |G {}|\n    {}'.format(cmap[c].name, cmap[c].short_desc) for c in all_commands)
+    msg = (
+        'Control {appname} by sending it commands. Add'
+        ' |_ allow_remote_control yes| to kitty.conf for this'
+        ' to work.\n\n|T Commands|:\n{cmds}\n\n'
+        'You can get help for each individual command by using:\n'
+        '{appname} @ |_ command| -h'
+    ).format(appname=appname, cmds='\n'.join(cmds))
+
+    global_opts, items = parse_args(args[1:], global_options_spec, 'command ...', msg, '{} @'.format(appname))
+
+    if not items:
+        raise SystemExit('You must specify a command')
+    cmd = items[0]
+    try:
+        func = cmap[cmd]
+    except KeyError:
+        raise SystemExit('{} is not a known command. Known commands are: {}'.format(
+            emph(cmd), ', '.join(all_commands)))
+    opts, items = parse_subcommand_cli(func, items)
+    payload = func(global_opts, opts, items)
+    send = {
+        'cmd': cmd,
+        'version': version,
+    }
+    if func.no_response and isinstance(payload, types.GeneratorType):
+        for item in payload:
+            send['payload'] = item
+            read_from_stdin(send, func.no_response)
+        return
+    if payload is not None:
+        send['payload'] = payload
+    response = read_from_stdin(send, func.no_response)
+    if not response.get('ok'):
+        if response.get('tb'):
+            print(response['tb'], file=sys.stderr)
+        raise SystemExit(response['error'])
+    if 'data' in response:
+        print(response['data'])

kitty/rewrap.h

@@ -7,7 +7,7 @@
 
 #pragma once
 
-#ifndef BufType 
+#ifndef BufType
 #define BufType LineBuf
 #endif
 
@@ -41,13 +41,13 @@
 #define is_src_line_continued(src_y) (src_y < src->ynum - 1 ? (src->line_attrs[src_y + 1] & CONTINUED_MASK) : false)
 #endif
 
-static inline void 
+static inline void
 copy_range(Line *src, index_type src_at, Line* dest, index_type dest_at, index_type num) {
     memcpy(dest->cells + dest_at, src->cells + src_at, num * sizeof(Cell));
 }
 
 
-static void 
+static void
 rewrap_inner(BufType *src, BufType *dest, const index_type src_limit, HistoryBuf UNUSED *historybuf) {
     bool src_line_is_continued = false;
     index_type src_y = 0, src_x = 0, dest_x = 0, dest_y = 0, num = 0, src_x_limit = 0;
@@ -60,7 +60,7 @@ rewrap_inner(BufType *src, BufType *dest, const index_type src_limit, HistoryBuf
         if (!src_line_is_continued) {
             // Trim trailing blanks since there is a hard line break at the end of this line
             while(src_x_limit && (src->line->cells[src_x_limit - 1].ch) == BLANK_CHAR) src_x_limit--;
-            
+
         }
         while (src_x < src_x_limit) {
             if (dest_x >= dest->xnum) { next_dest_line(true); dest_x = 0; }

kitty/screen.c

@@ -13,20 +13,24 @@
 #include "screen.h"
 #include <structmember.h>
 #include <limits.h>
-#include <sys/types.h>                                                                                          
+#include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include "unicode-data.h"
 #include "modes.h"
-#include "wcwidth9.h"
+#include "wcwidth-std.h"
 #include "control-codes.h"
 
 static const ScreenModes empty_modes = {0, .mDECAWM=true, .mDECTCEM=true, .mDECARM=true};
 static Selection EMPTY_SELECTION = {0};
+typedef struct {
+    unsigned int x; int y;
+} FullSelectionBoundary;
+
 
 // Constructor/destructor {{{
 
-static inline void 
+static inline void
 init_tabstops(bool *tabstops, index_type count) {
     // In terminfo we specify the number of initial tabstops (it) as 8
     for (unsigned int t=0; t < count; t++) {
@@ -40,7 +44,7 @@ init_tabstops(bool *tabstops, index_type count) {
         self->g_charset = self->g0_charset; \
         self->utf8_state = 0; \
         self->utf8_codepoint = 0; \
-        self->use_latin1 = false; 
+        self->use_latin1 = false;
 #define CALLBACK(...) \
     if (self->callbacks != Py_None) { \
         PyObject *callback_ret = PyObject_CallMethod(self->callbacks, __VA_ARGS__); \
@@ -84,7 +88,7 @@ new(PyTypeObject *type, PyObject *args, PyObject UNUSED *kwds) {
         self->main_linebuf = alloc_linebuf(lines, columns); self->alt_linebuf = alloc_linebuf(lines, columns);
         self->linebuf = self->main_linebuf;
         self->historybuf = alloc_historybuf(MAX(scrollback, lines), columns);
-        self->main_grman = grman_alloc(); 
+        self->main_grman = grman_alloc();
         self->alt_grman = grman_alloc();
         self->grman = self->main_grman;
         self->main_tabstops = PyMem_Calloc(2 * self->columns, sizeof(bool));
@@ -99,11 +103,11 @@ new(PyTypeObject *type, PyObject *args, PyObject UNUSED *kwds) {
     return (PyObject*) self;
 }
 
-void 
+void
 screen_reset(Screen *self) {
     if (self->linebuf == self->alt_linebuf) screen_toggle_screen_buffer(self);
     linebuf_clear(self->linebuf, BLANK_CHAR);
-    grman_clear(self->grman);
+    grman_clear(self->grman, false);
     self->modes = empty_modes;
 #define R(name) self->color_profile->overridden.name = 0
     R(default_fg); R(default_bg); R(cursor_color); R(highlight_fg); R(highlight_bg);
@@ -121,7 +125,7 @@ screen_reset(Screen *self) {
     set_color_table_color(self, 104, NULL);
 }
 
-static inline HistoryBuf* 
+static inline HistoryBuf*
 realloc_hb(HistoryBuf *old, unsigned int lines, unsigned int columns) {
     HistoryBuf *ans = alloc_historybuf(lines, columns);
     if (ans == NULL) { PyErr_NoMemory(); return NULL; }
@@ -129,7 +133,7 @@ realloc_hb(HistoryBuf *old, unsigned int lines, unsigned int columns) {
     return ans;
 }
 
-static inline LineBuf* 
+static inline LineBuf*
 realloc_lb(LineBuf *old, unsigned int lines, unsigned int columns, index_type *nclb, index_type *ncla, HistoryBuf *hb) {
     LineBuf *ans = alloc_linebuf(lines, columns);
     if (ans == NULL) { PyErr_NoMemory(); return NULL; }
@@ -137,7 +141,7 @@ realloc_lb(LineBuf *old, unsigned int lines, unsigned int columns, index_type *n
     return ans;
 }
 
-static bool 
+static bool
 screen_resize(Screen *self, unsigned int lines, unsigned int columns) {
     lines = MAX(1, lines); columns = MAX(1, columns);
 
@@ -203,7 +207,7 @@ screen_rescale_images(Screen *self, unsigned int old_cell_width, unsigned int ol
 }
 
 
-static bool 
+static bool
 screen_change_scrollback_size(Screen *self, unsigned int size) {
     if (size != self->historybuf->ynum) return historybuf_resize(self->historybuf, size);
     return true;
@@ -221,13 +225,13 @@ static void
 dealloc(Screen* self) {
     pthread_mutex_destroy(&self->read_buf_lock);
     pthread_mutex_destroy(&self->write_buf_lock);
-    Py_CLEAR(self->main_grman); 
+    Py_CLEAR(self->main_grman);
     Py_CLEAR(self->alt_grman);
     PyMem_RawFree(self->write_buf);
     Py_CLEAR(self->callbacks);
     Py_CLEAR(self->test_child);
-    Py_CLEAR(self->cursor); 
-    Py_CLEAR(self->main_linebuf); 
+    Py_CLEAR(self->cursor);
+    Py_CLEAR(self->main_linebuf);
     Py_CLEAR(self->alt_linebuf);
     Py_CLEAR(self->historybuf);
     Py_CLEAR(self->color_profile);
@@ -236,8 +240,8 @@ dealloc(Screen* self) {
 } // }}}
 
 // Draw text {{{
- 
-void 
+
+void
 screen_change_charset(Screen *self, uint32_t which) {
     switch(which) {
         case 0:
@@ -247,7 +251,7 @@ screen_change_charset(Screen *self, uint32_t which) {
     }
 }
 
-void 
+void
 screen_designate_charset(Screen *self, uint32_t which, uint32_t as) {
     bool change_g = false;
     switch(which) {
@@ -267,7 +271,7 @@ screen_designate_charset(Screen *self, uint32_t which, uint32_t as) {
 
 static int (*wcwidth_impl)(wchar_t) = wcwidth;
 
-unsigned int 
+unsigned int
 safe_wcwidth(uint32_t ch) {
     int ans = wcwidth_impl(ch);
     if (ans < 0) ans = 1;
@@ -275,8 +279,8 @@ safe_wcwidth(uint32_t ch) {
 }
 
 void
-change_wcwidth(bool use9) {
-    wcwidth_impl = (use9) ? wcwidth9 : wcwidth;
+change_wcwidth(bool use_std) {
+    wcwidth_impl = use_std ? wcwidth_std : wcwidth;
 }
 
 
@@ -334,9 +338,9 @@ screen_align(Screen *self) {
 
 // Graphics {{{
 
-void 
+void
 screen_alignment_display(Screen *self) {
-    // http://www.vt100.net/docs/vt510-rm/DECALN.html 
+    // http://www.vt100.net/docs/vt510-rm/DECALN.html
     screen_cursor_position(self, 1, 1);
     self->margin_top = 0; self->margin_bottom = self->lines - 1;
     for (unsigned int y = 0; y < self->linebuf->ynum; y++) {
@@ -346,7 +350,7 @@ screen_alignment_display(Screen *self) {
     }
 }
 
-void 
+void
 select_graphic_rendition(Screen *self, unsigned int *params, unsigned int count, Region *region_) {
     if (region_) {
         Region region = *region_;
@@ -387,28 +391,29 @@ write_to_child(Screen *self, const char *data, size_t sz) {
 
 void
 write_escape_code_to_child(Screen *self, unsigned char which, const char *data) {
-    static char buf[512];
-    size_t sz;
+    const char *prefix, *suffix = self->modes.eight_bit_controls ? "\x9c" : "\033\\";
     switch(which) {
         case DCS:
-            sz = snprintf(buf, sizeof(buf) - 1, "%s%s%s", self->modes.eight_bit_controls ? "\x90" : "\033P", data, self->modes.eight_bit_controls ? "\x9c" : "\033\\");
+            prefix = self->modes.eight_bit_controls ? "\x90" : "\033P";
             break;
         case CSI:
-            sz = snprintf(buf, sizeof(buf) - 1, "%s%s", self->modes.eight_bit_controls ? "\x9b" : "\033[", data);
+            prefix = self->modes.eight_bit_controls ? "\x9b" : "\033["; suffix = "";
             break;
         case OSC:
-            sz = snprintf(buf, sizeof(buf) - 1, "%s%s%s", self->modes.eight_bit_controls ? "\x9d" : "\033]", data, self->modes.eight_bit_controls ? "\x9c" : "\033\\");
+            prefix = self->modes.eight_bit_controls ? "\x9d" : "\033]";
             break;
         case PM:
-            sz = snprintf(buf, sizeof(buf) - 1, "%s%s%s", self->modes.eight_bit_controls ? "\x9e" : "\033^", data, self->modes.eight_bit_controls ? "\x9c" : "\033\\");
+            prefix = self->modes.eight_bit_controls ? "\x9e" : "\033^";
             break;
         case APC:
-            sz = snprintf(buf, sizeof(buf) - 1, "%s%s%s", self->modes.eight_bit_controls ? "\x9f" : "\033_", data, self->modes.eight_bit_controls ? "\x9c" : "\033\\");
+            prefix = self->modes.eight_bit_controls ? "\x9f" : "\033_";
             break;
         default:
             fatal("Unknown escape code to write: %u", which);
     }
-    write_to_child(self, buf, sz);
+    write_to_child(self, prefix, strlen(prefix));
+    write_to_child(self, data, strlen(data));
+    if (suffix[0]) write_to_child(self, suffix, strlen(suffix));
 }
 
 void
@@ -418,7 +423,7 @@ screen_handle_graphics_command(Screen *self, const GraphicsCommand *cmd, const u
     if (response != NULL) write_escape_code_to_child(self, APC, response);
     if (x != self->cursor->x || y != self->cursor->y) {
         if (self->cursor->x >= self->columns) { self->cursor->x = 0; self->cursor->y++; }
-        if (self->cursor->y > self->margin_bottom) screen_scroll(self, self->cursor->y - self->margin_bottom); 
+        if (self->cursor->y > self->margin_bottom) screen_scroll(self, self->cursor->y - self->margin_bottom);
         screen_ensure_bounds(self, false);
     }
 }
@@ -427,10 +432,10 @@ screen_handle_graphics_command(Screen *self, const GraphicsCommand *cmd, const u
 // Modes {{{
 
 
-void 
+void
 screen_toggle_screen_buffer(Screen *self) {
     bool to_alt = self->linebuf == self->main_linebuf;
-    grman_clear(self->alt_grman);  // always clear the alt buffer graphics to free up resources, since it has to be cleared when switching back to it anyway
+    grman_clear(self->alt_grman, true);  // always clear the alt buffer graphics to free up resources, since it has to be cleared when switching back to it anyway
     if (to_alt) {
         linebuf_clear(self->alt_linebuf, BLANK_CHAR);
         screen_save_cursor(self);
@@ -452,7 +457,7 @@ screen_toggle_screen_buffer(Screen *self) {
 void screen_normal_keypad_mode(Screen UNUSED *self) {} // Not implemented as this is handled by the GUI
 void screen_alternate_keypad_mode(Screen UNUSED *self) {}  // Not implemented as this is handled by the GUI
 
-static inline void 
+static inline void
 set_mode_from_const(Screen *self, unsigned int mode, bool val) {
 #define SIMPLE_MODE(name) \
     case name: \
@@ -481,40 +486,40 @@ set_mode_from_const(Screen *self, unsigned int mode, bool val) {
         case DECNRCM:
             break;  // we ignore these modes
         case DECCKM:
-            self->modes.mDECCKM = val; 
+            self->modes.mDECCKM = val;
             break;
-        case DECTCEM: 
-            self->modes.mDECTCEM = val; 
+        case DECTCEM:
+            self->modes.mDECTCEM = val;
             break;
-        case DECSCNM: 
+        case DECSCNM:
             // Render screen in reverse video
             if (self->modes.mDECSCNM != val) {
-                self->modes.mDECSCNM = val; 
+                self->modes.mDECSCNM = val;
                 self->is_dirty = true;
             }
             break;
-        case DECOM: 
-            self->modes.mDECOM = val; 
+        case DECOM:
+            self->modes.mDECOM = val;
             // According to `vttest`, DECOM should also home the cursor, see
             // vttest/main.c:303.
             screen_cursor_position(self, 1, 1);
             break;
-        case DECAWM: 
+        case DECAWM:
             self->modes.mDECAWM = val; break;
-        case DECCOLM: 
+        case DECCOLM:
             // When DECCOLM mode is set, the screen is erased and the cursor
             // moves to the home position.
-            self->modes.mDECCOLM = val; 
+            self->modes.mDECCOLM = val;
             screen_erase_in_display(self, 2, false);
             screen_cursor_position(self, 1, 1);
             break;
         case CONTROL_CURSOR_BLINK:
-            self->cursor->blink = val; 
+            self->cursor->blink = val;
             break;
         case ALTERNATE_SCREEN:
             if (val && self->linebuf == self->main_linebuf) screen_toggle_screen_buffer(self);
             else if (!val && self->linebuf != self->main_linebuf) screen_toggle_screen_buffer(self);
-            break;  
+            break;
         default:
             private = mode >= 1 << 5;
             if (private) mode >>= 5;
@@ -524,7 +529,7 @@ set_mode_from_const(Screen *self, unsigned int mode, bool val) {
 #undef MOUSE_MODE
 }
 
-void 
+void
 screen_set_mode(Screen *self, unsigned int mode) {
     set_mode_from_const(self, mode, true);
 }
@@ -534,7 +539,7 @@ screen_decsace(Screen *self, unsigned int val) {
     self->modes.mDECSACE = val == 2 ? true : false;
 }
 
-void 
+void
 screen_reset_mode(Screen *self, unsigned int mode) {
     set_mode_from_const(self, mode, false);
 }
@@ -561,12 +566,12 @@ screen_is_cursor_visible(Screen *self) {
     return self->modes.mDECTCEM;
 }
 
-void 
+void
 screen_backspace(Screen *self) {
     screen_cursor_back(self, 1, -1);
 }
 
-void 
+void
 screen_tab(Screen *self) {
     // Move to the next tab space, or the end of the screen if there aren't anymore left.
     unsigned int found = 0;
@@ -579,7 +584,7 @@ screen_tab(Screen *self) {
     }
 }
 
-void 
+void
 screen_backtab(Screen *self, unsigned int count) {
     // Move back count tabs
     if (!count) count = 1;
@@ -593,7 +598,7 @@ screen_backtab(Screen *self, unsigned int count) {
     }
 }
 
-void 
+void
 screen_clear_tab_stop(Screen *self, unsigned int how) {
     switch(how) {
         case 0:
@@ -610,13 +615,13 @@ screen_clear_tab_stop(Screen *self, unsigned int how) {
     }
 }
 
-void 
+void
 screen_set_tab_stop(Screen *self) {
     if (self->cursor->x < self->columns)
         self->tabstops[self->cursor->x] = true;
 }
 
-void 
+void
 screen_cursor_back(Screen *self, unsigned int count/*=1*/, int move_direction/*=-1*/) {
     if (count == 0) count = 1;
     if (move_direction < 0 && count > self->cursor->x) self->cursor->x = 0;
@@ -624,12 +629,12 @@ screen_cursor_back(Screen *self, unsigned int count/*=1*/, int move_direction/*=
     screen_ensure_bounds(self, false);
 }
 
-void 
+void
 screen_cursor_forward(Screen *self, unsigned int count/*=1*/) {
     screen_cursor_back(self, count, 1);
 }
 
-void 
+void
 screen_cursor_up(Screen *self, unsigned int count/*=1*/, bool do_carriage_return/*=false*/, int move_direction/*=-1*/) {
     if (count == 0) count = 1;
     if (move_direction < 0 && count > self->cursor->y) self->cursor->y = 0;
@@ -638,22 +643,22 @@ screen_cursor_up(Screen *self, unsigned int count/*=1*/, bool do_carriage_return
     if (do_carriage_return) self->cursor->x = 0;
 }
 
-void 
+void
 screen_cursor_up1(Screen *self, unsigned int count/*=1*/) {
     screen_cursor_up(self, count, true, -1);
 }
 
-void 
+void
 screen_cursor_down(Screen *self, unsigned int count/*=1*/) {
     screen_cursor_up(self, count, false, 1);
 }
 
-void 
+void
 screen_cursor_down1(Screen *self, unsigned int count/*=1*/) {
     screen_cursor_up(self, count, true, 1);
 }
 
-void 
+void
 screen_cursor_to_column(Screen *self, unsigned int column) {
     unsigned int x = MAX(column, 1) - 1;
     if (x != self->cursor->x) {
@@ -683,7 +688,7 @@ screen_cursor_to_column(Screen *self, unsigned int column) {
     linebuf_clear_line(self->linebuf, bottom); \
     self->is_dirty = true;
 
-void 
+void
 screen_index(Screen *self) {
     // Move cursor down one line, scrolling screen if needed
     unsigned int top = self->margin_top, bottom = self->margin_bottom;
@@ -692,7 +697,7 @@ screen_index(Screen *self) {
     } else screen_cursor_down(self, 1);
 }
 
-void 
+void
 screen_scroll(Screen *self, unsigned int count) {
     // Scroll the screen up by count lines, not moving the cursor
     unsigned int top = self->margin_top, bottom = self->margin_bottom;
@@ -708,7 +713,7 @@ screen_scroll(Screen *self, unsigned int count) {
     INDEX_GRAPHICS(1) \
     self->is_dirty = true;
 
-void 
+void
 screen_reverse_index(Screen *self) {
     // Move cursor up one line, scrolling screen if needed
     unsigned int top = self->margin_top, bottom = self->margin_bottom;
@@ -717,7 +722,7 @@ screen_reverse_index(Screen *self) {
     } else screen_cursor_up(self, 1, false, -1);
 }
 
-void 
+void
 screen_reverse_scroll(Screen *self, unsigned int count) {
     // Scroll the screen down by count lines, not moving the cursor
     count = MIN(self->lines, count);
@@ -729,21 +734,21 @@ screen_reverse_scroll(Screen *self, unsigned int count) {
 }
 
 
-void 
+void
 screen_carriage_return(Screen *self) {
     if (self->cursor->x != 0) {
         self->cursor->x = 0;
     }
 }
 
-void 
+void
 screen_linefeed(Screen *self) {
     screen_index(self);
     if (self->modes.mLNM) screen_carriage_return(self);
     screen_ensure_bounds(self, false);
 }
 
-static inline Savepoint* 
+static inline Savepoint*
 savepoints_push(SavepointBuffer *self) {
     Savepoint *ans = self->buf + ((self->start_of_data + self->count) % SAVEPOINTS_SZ);
     if (self->count == SAVEPOINTS_SZ) self->start_of_data = (self->start_of_data + 1) % SAVEPOINTS_SZ;
@@ -751,7 +756,7 @@ savepoints_push(SavepointBuffer *self) {
     return ans;
 }
 
-static inline Savepoint* 
+static inline Savepoint*
 savepoints_pop(SavepointBuffer *self) {
     if (self->count == 0) return NULL;
     self->count--;
@@ -766,7 +771,7 @@ savepoints_pop(SavepointBuffer *self) {
     sp->g_charset = self->g_charset; \
     sp->use_latin1 = self->use_latin1;
 
-void 
+void
 screen_save_cursor(Screen *self) {
     SavepointBuffer *pts = self->linebuf == self->main_linebuf ? &self->main_savepoints : &self->alt_savepoints;
     Savepoint *sp = savepoints_push(pts);
@@ -777,7 +782,7 @@ screen_save_cursor(Screen *self) {
     COPY_CHARSETS(self, sp);
 }
 
-void 
+void
 screen_restore_cursor(Screen *self) {
     SavepointBuffer *pts = self->linebuf == self->main_linebuf ? &self->main_savepoints : &self->alt_savepoints;
     Savepoint *sp = savepoints_pop(pts);
@@ -796,7 +801,7 @@ screen_restore_cursor(Screen *self) {
     }
 }
 
-void 
+void
 screen_ensure_bounds(Screen *self, bool force_use_margins/*=false*/) {
     unsigned int top, bottom;
     if (force_use_margins || self->modes.mDECOM) {
@@ -808,7 +813,7 @@ screen_ensure_bounds(Screen *self, bool force_use_margins/*=false*/) {
     self->cursor->y = MAX(top, MIN(self->cursor->y, bottom));
 }
 
-void 
+void
 screen_cursor_position(Screen *self, unsigned int line, unsigned int column) {
     line = (line == 0 ? 1 : line) - 1;
     column = (column == 0 ? 1: column) - 1;
@@ -820,7 +825,7 @@ screen_cursor_position(Screen *self, unsigned int line, unsigned int column) {
     screen_ensure_bounds(self, false);
 }
 
-void 
+void
 screen_cursor_to_line(Screen *self, unsigned int line) {
     screen_cursor_position(self, line, self->cursor->x + 1);
 }
@@ -829,7 +834,7 @@ screen_cursor_to_line(Screen *self, unsigned int line) {
 
 // Editing {{{
 
-void 
+void
 screen_erase_in_line(Screen *self, unsigned int how, bool private) {
     /*Erases a line in a specific way.
 
@@ -870,7 +875,7 @@ screen_erase_in_line(Screen *self, unsigned int how, bool private) {
     }
 }
 
-void 
+void
 screen_erase_in_display(Screen *self, unsigned int how, bool private) {
     /* Erases display in a specific way.
 
@@ -882,6 +887,7 @@ screen_erase_in_display(Screen *self, unsigned int how, bool private) {
               including cursor position.
             * ``2`` -- Erases complete display. All lines are erased
               and changed to single-width. Cursor does not move.
+            * ``3`` -- Erase complete display and scrollback buffer as well.
         :param bool private: when ``True`` character attributes are left unchanged
     */
     unsigned int a, b;
@@ -891,7 +897,8 @@ screen_erase_in_display(Screen *self, unsigned int how, bool private) {
         case 1:
             a = 0; b = self->cursor->y; break;
         case 2:
-            grman_clear(self->grman);
+        case 3:
+            grman_clear(self->grman, how == 3);
             a = 0; b = self->lines; break;
         default:
             return;
@@ -911,9 +918,16 @@ screen_erase_in_display(Screen *self, unsigned int how, bool private) {
     if (how != 2) {
         screen_erase_in_line(self, how, private);
     }
+    if (how == 3 && self->linebuf == self->main_linebuf) {
+        historybuf_clear(self->historybuf);
+        if (self->scrolled_by != 0) {
+            self->scrolled_by = 0;
+            self->scroll_changed = true;
+        }
+    }
 }
 
-void 
+void
 screen_insert_lines(Screen *self, unsigned int count) {
     unsigned int top = self->margin_top, bottom = self->margin_bottom;
     if (count == 0) count = 1;
@@ -924,7 +938,7 @@ screen_insert_lines(Screen *self, unsigned int count) {
     }
 }
 
-void 
+void
 screen_delete_lines(Screen *self, unsigned int count) {
     unsigned int top = self->margin_top, bottom = self->margin_bottom;
     if (count == 0) count = 1;
@@ -935,7 +949,7 @@ screen_delete_lines(Screen *self, unsigned int count) {
     }
 }
 
-void 
+void
 screen_insert_characters(Screen *self, unsigned int count) {
     unsigned int top = self->margin_top, bottom = self->margin_bottom;
     if (count == 0) count = 1;
@@ -950,7 +964,7 @@ screen_insert_characters(Screen *self, unsigned int count) {
     }
 }
 
-void 
+void
 screen_delete_characters(Screen *self, unsigned int count) {
     // Delete characters, later characters are moved left
     unsigned int top = self->margin_top, bottom = self->margin_bottom;
@@ -966,7 +980,7 @@ screen_delete_characters(Screen *self, unsigned int count) {
     }
 }
 
-void 
+void
 screen_erase_characters(Screen *self, unsigned int count) {
     // Delete characters replacing them by spaces
     if (count == 0) count = 1;
@@ -984,7 +998,7 @@ screen_erase_characters(Screen *self, unsigned int count) {
 
 void
 screen_use_latin1(Screen *self, bool on) {
-    self->use_latin1 = on; self->utf8_state = 0; self->utf8_codepoint = 0; 
+    self->use_latin1 = on; self->utf8_state = 0; self->utf8_codepoint = 0;
     CALLBACK("use_utf8", "O", on ? Py_False : Py_True);
 }
 
@@ -999,12 +1013,12 @@ screen_invert_colors(Screen *self) {
     return inverted;
 }
 
-void 
-screen_bell(Screen *self) {  
+void
+screen_bell(Screen *self) {
     request_window_attention(self->window_id, OPT(enable_audio_bell));
-} 
+}
 
-void 
+void
 report_device_attributes(Screen *self, unsigned int mode, char start_modifier) {
     if (mode == 0) {
         switch(start_modifier) {
@@ -1018,7 +1032,7 @@ report_device_attributes(Screen *self, unsigned int mode, char start_modifier) {
     }
 }
 
-void 
+void
 report_device_status(Screen *self, unsigned int which, bool private) {
     // We dont implement the private device status codes, since I haven't come
     // across any programs that use them
@@ -1042,7 +1056,7 @@ report_device_status(Screen *self, unsigned int which, bool private) {
     }
 }
 
-void 
+void
 report_mode_status(Screen *self, unsigned int which, bool private) {
     unsigned int q = private ? which << 5 : which;
     unsigned int ans = 0;
@@ -1071,7 +1085,7 @@ report_mode_status(Screen *self, unsigned int which, bool private) {
     if (sz > 0) write_escape_code_to_child(self, CSI, buf);
 }
 
-void 
+void
 screen_set_margins(Screen *self, unsigned int top, unsigned int bottom) {
     if (!top) top = 1;
     if (!bottom) bottom = self->lines;
@@ -1089,7 +1103,7 @@ screen_set_margins(Screen *self, unsigned int top, unsigned int bottom) {
     }
 }
 
-void 
+void
 screen_set_cursor(Screen *self, unsigned int mode, uint8_t secondary) {
     uint8_t shape; bool blink;
     switch(secondary) {
@@ -1110,29 +1124,34 @@ screen_set_cursor(Screen *self, unsigned int mode, uint8_t secondary) {
     }
 }
 
-void 
+void
 set_title(Screen *self, PyObject *title) {
     CALLBACK("title_changed", "O", title);
 }
 
-void 
+void
 set_icon(Screen *self, PyObject *icon) {
     CALLBACK("icon_changed", "O", icon);
 }
 
-void 
+void
 set_dynamic_color(Screen *self, unsigned int code, PyObject *color) {
     if (color == NULL) { CALLBACK("set_dynamic_color", "Is", code, ""); }
     else { CALLBACK("set_dynamic_color", "IO", code, color); }
 }
 
-void 
+void
 set_color_table_color(Screen *self, unsigned int code, PyObject *color) {
     if (color == NULL) { CALLBACK("set_color_table_color", "Is", code, ""); }
     else { CALLBACK("set_color_table_color", "IO", code, color); }
 }
 
-void 
+void
+screen_handle_cmd(Screen *self, PyObject *cmd) {
+    CALLBACK("handle_remote_cmd", "O", cmd);
+}
+
+void
 screen_request_capabilities(Screen *self, char c, PyObject *q) {
     static char buf[128];
     int shape = 0;
@@ -1219,6 +1238,7 @@ screen_update_cell_data(Screen *self, void *address, size_t UNUSED sz) {
     }
 }
 
+
 static inline bool
 is_selection_empty(Screen *self, unsigned int start_x, unsigned int start_y, unsigned int end_x, unsigned int end_y) {
     return (start_x >= self->columns || start_y >= self->lines || end_x >= self->columns || end_y >= self->lines || (start_x == end_x && start_y == end_y)) ? true : false;
@@ -1238,6 +1258,13 @@ selection_coord(Screen *self, unsigned int x, unsigned int y, unsigned int ydelt
     }
 }
 
+static inline void
+full_selection_coord(Screen *self, unsigned int x, unsigned int y, unsigned int ydelta, FullSelectionBoundary *ans) {
+    ans->x = MIN(x, self->columns - 1);
+    ans->y = y - ydelta;
+    if (y >= self->lines) { ans->x = self->columns - 1; ans->y = self->lines - 1; }
+}
+
 #define selection_limits_(which, left, right) { \
     SelectionBoundary a, b; \
     selection_coord(self, self->which.start_x, self->which.start_y, self->which.start_scrolled_by, &a); \
@@ -1246,46 +1273,65 @@ selection_coord(Screen *self, unsigned int x, unsigned int y, unsigned int ydelt
     else { *(left) = b; *(right) = a; } \
 }
 
+#define full_selection_limits_(which, left, right) { \
+    FullSelectionBoundary a, b; \
+    full_selection_coord(self, self->which.start_x, self->which.start_y, self->which.start_scrolled_by, &a); \
+    full_selection_coord(self, self->which.end_x, self->which.end_y, self->which.end_scrolled_by, &b); \
+    if (a.y < b.y || (a.y == b.y && a.x <= b.x)) { *(left) = a; *(right) = b; } \
+    else { *(left) = b; *(right) = a; } \
+}
+
+
 static inline Line*
 visual_line_(Screen *self, index_type y) {
     if (self->scrolled_by) {
         if (y < self->scrolled_by) {
             historybuf_init_line(self->historybuf, self->scrolled_by - 1 - y, self->historybuf->line);
             return self->historybuf->line;
-        } 
+        }
         y -= self->scrolled_by;
     }
     linebuf_init_line(self->linebuf, y);
     return self->linebuf->line;
 }
 
-#define iterate_over_rectangle(start, end) { \
-    index_type min_y = MIN(start->y, end->y), max_y = MAX(start->y, end->y); \
+static inline Line*
+range_line_(Screen *self, int y) {
+    if (y < 0) {
+        historybuf_init_line(self->historybuf, -y, self->historybuf->line);
+        return self->historybuf->line;
+    }
+    linebuf_init_line(self->linebuf, y);
+    return self->linebuf->line;
+}
+
+#define iterate_over_rectangle(start, end, line_func, y_type) { \
+    y_type min_y = MIN(start->y, end->y), max_y = MAX(start->y, end->y); \
     index_type min_x = MIN(start->x, end->x), max_x = MAX(start->x, end->x); \
-    for (index_type y = min_y; y <= max_y; y++) { \
-        Line *line = visual_line_(self, y); \
+    for (y_type y = min_y; y <= max_y; y++) { \
+        Line *line = line_func(self, y); \
         index_type xlimit = xlimit_for_line(line); \
         xlimit = MIN(max_x + 1, xlimit); \
-        index_type x_start = min_x; \
+        index_type x_start = min_x;
 
-#define iterate_over_region(start, end) { \
-    for (index_type y = start->y; y <= end->y; y++) { \
-        Line *line = visual_line_(self, y); \
+#define iterate_over_region(start, end, line_func, y_type) { \
+    for (y_type y = start->y; y <= end->y; y++) { \
+        Line *line = line_func(self, y); \
         index_type xlimit = xlimit_for_line(line); \
         if (y == end->y) xlimit = MIN(end->x + 1, xlimit); \
         index_type x_start = y == start->y ? start->x : 0;
- 
+
 
 static inline void
 apply_selection(Screen *self, uint8_t *data, SelectionBoundary *start, SelectionBoundary *end, uint8_t set_mask, bool rectangle_select) {
-    if (is_selection_empty(self, start->x, start->y, end->x, end->y)) return; 
+    if (is_selection_empty(self, start->x, start->y, end->x, end->y)) return;
     if (rectangle_select) {
-        iterate_over_rectangle(start, end)
+        iterate_over_rectangle(start, end, visual_line_, index_type)
             uint8_t *line_start = data + self->columns * y;
             for (index_type x = x_start; x < xlimit; x++) line_start[x] |= set_mask;
         }}
     } else {
-        iterate_over_region(start, end)
+        iterate_over_region(start, end, visual_line_, index_type)
             uint8_t *line_start = data + self->columns * y;
             for (index_type x = x_start; x < xlimit; x++) line_start[x] |= set_mask;
         }}
@@ -1304,35 +1350,35 @@ screen_apply_selection(Screen *self, void *address, size_t size) {
     apply_selection(self, address, &self->last_rendered_url_start, &self->last_rendered_url_end, 2, false);
 }
 
-static inline PyObject*
-text_for_range(Screen *self, SelectionBoundary start, SelectionBoundary end, bool rectangle_select, bool insert_newlines) {
-    int num_of_lines = end.y - start.y + 1, i = 0;
-    PyObject *ans = PyTuple_New(num_of_lines);
-    if (ans == NULL) return PyErr_NoMemory();
-#define action \
-        char leading_char = (i > 0 && insert_newlines && !line->continued) ? '\n' : 0; \
-        PyObject *text = unicode_in_range(line, x_start, xlimit, true, leading_char); \
-        if (text == NULL) { Py_DECREF(ans); return PyErr_NoMemory(); } \
-        PyTuple_SET_ITEM(ans, i++, text);
-
-    if (rectangle_select) {
-        iterate_over_rectangle((&start), (&end))
-            action
-    } }} else {
-        iterate_over_region((&start), (&end))
-            action
-    } }}
-#undef action
-    return ans;
+#define text_for_range_action(ans, insert_newlines) { \
+    char leading_char = (i > 0 && insert_newlines && !line->continued) ? '\n' : 0; \
+    PyObject *text = unicode_in_range(line, x_start, xlimit, true, leading_char); \
+    if (text == NULL) { Py_DECREF(ans); return PyErr_NoMemory(); } \
+    PyTuple_SET_ITEM(ans, i++, text); \
 }
 
+#define text_for_range(ans, start, end, rectangle_select, insert_newlines, line_func, y_type) { \
+    int num_of_lines = end.y - start.y + 1, i = 0; \
+    ans = PyTuple_New(num_of_lines); \
+    if (ans == NULL) return PyErr_NoMemory(); \
+    if (rectangle_select) { \
+        iterate_over_rectangle((&start), (&end), line_func, y_type) \
+            text_for_range_action(ans, insert_newlines); \
+    } }} else { \
+        iterate_over_region((&start), (&end), line_func, y_type) \
+            text_for_range_action(ans, insert_newlines); \
+    } }} \
+}
+
+
 bool
 screen_open_url(Screen *self) {
     SelectionBoundary start, end;
     selection_limits_(url_range, &start, &end);
     if (is_selection_empty(self, start.x, start.y, end.x, end.y)) return false;
-    PyObject *text = text_for_range(self, start, end, false, false);
-    if (text) { call_boss(open_url_lines, "(O)", text); Py_CLEAR(text); }
+    PyObject *url;
+    text_for_range(url, start, end, false, false, visual_line_, index_type);
+    if (url) { call_boss(open_url_lines, "(O)", url); Py_CLEAR(url); }
     else PyErr_Print();
     return true;
 }
@@ -1343,10 +1389,10 @@ screen_open_url(Screen *self) {
 #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 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 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; }
 #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; }
 #define WRAP2(name, defval1, defval2) static PyObject* name(Screen *self, PyObject *args) { unsigned int a=defval1, b=defval2; if(!PyArg_ParseTuple(args, "|II", &a, &b)) return NULL; screen_##name(self, a, b); Py_RETURN_NONE; }
+#define WRAP2B(name) static PyObject* name(Screen *self, PyObject *args) { unsigned int a, b; int p; if(!PyArg_ParseTuple(args, "IIp", &a, &b, &p)) return NULL; screen_##name(self, a, b, (bool)p); Py_RETURN_NONE; }
 
 static PyObject*
 refresh_sprite_positions(Screen *self) {
@@ -1397,7 +1443,7 @@ visual_line(Screen *self, PyObject *args) {
     if (y >= self->lines) { Py_RETURN_NONE; }
     return Py_BuildValue("O", visual_line_(self, y));
 }
- 
+
 static PyObject*
 draw(Screen *self, PyObject *src) {
     if (!PyUnicode_Check(src)) { PyErr_SetString(PyExc_TypeError, "A unicode string is required"); return NULL; }
@@ -1418,7 +1464,7 @@ reset_mode(Screen *self, PyObject *args) {
     screen_reset_mode(self, mode);
     Py_RETURN_NONE;
 }
- 
+
 static PyObject*
 _select_graphic_rendition(Screen *self, PyObject *args) {
     unsigned int params[256] = {0};
@@ -1479,23 +1525,27 @@ 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*
 change_scrollback_size(Screen *self, PyObject *args) {
-    unsigned int count = 1; 
-    if (!PyArg_ParseTuple(args, "|I", &count)) return NULL; 
+    unsigned int count = 1;
+    if (!PyArg_ParseTuple(args, "|I", &count)) return NULL;
     if (!screen_change_scrollback_size(self, MAX(self->lines, count))) return NULL;
     Py_RETURN_NONE;
 }
 
 static PyObject*
 text_for_selection(Screen *self) {
-    SelectionBoundary start, end;
-    selection_limits_(selection, &start, &end);
-    if (is_selection_empty(self, start.x, start.y, end.x, end.y)) return PyTuple_New(0);
-    return text_for_range(self, start, end, self->rectangle_select, true);
+    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);
+    return ans;
 }
- 
+
 bool
 screen_selection_range_for_line(Screen *self, index_type y, index_type *start, index_type *end) {
     if (y >= self->lines) { return false; }
@@ -1526,7 +1576,7 @@ screen_selection_range_for_word(Screen *self, index_type x, index_type y, index_
     } else {
         start = x, end = x;
         while(start > 0 && is_ok(start - 1)) start--;
-        while(end < self->columns - 1 && is_ok(end + 1)) end++; 
+        while(end < self->columns - 1 && is_ok(end + 1)) end++;
     }
     *s = start; *e = end;
     return true;
@@ -1592,7 +1642,7 @@ screen_start_selection(Screen *self, index_type x, index_type y, bool rectangle_
 void
 screen_mark_url(Screen *self, index_type start_x, index_type start_y, index_type end_x, index_type end_y) {
 #define A(attr, val) self->url_range.attr = val;
-    A(start_x, start_x); A(end_x, end_x); A(start_y, start_y); A(end_y, end_y); A(start_scrolled_by, self->scrolled_by); A(end_scrolled_by, self->scrolled_by); 
+    A(start_x, start_x); A(end_x, end_x); A(start_y, start_y); A(end_y, end_y); A(start_scrolled_by, self->scrolled_by); A(end_scrolled_by, self->scrolled_by);
 #undef A
 }
 
@@ -1602,19 +1652,19 @@ screen_update_selection(Screen *self, index_type x, index_type y, bool ended) {
     if (ended) self->selection.in_progress = false;
 }
 
-static PyObject* 
+static PyObject*
 mark_as_dirty(Screen *self) {
     self->is_dirty = true;
     Py_RETURN_NONE;
 }
 
-static PyObject* 
+static PyObject*
 current_char_width(Screen *self) {
 #define current_char_width_doc "The width of the character under the cursor"
     return PyLong_FromUnsignedLong(screen_current_char_width(self));
 }
 
-static PyObject* 
+static PyObject*
 is_main_linebuf(Screen *self) {
     PyObject *ans = (self->linebuf == self->main_linebuf) ? Py_True : Py_False;
     Py_INCREF(ans);
@@ -1694,6 +1744,8 @@ static PyMethodDef methods[] = {
     MND(carriage_return, METH_NOARGS)
     MND(set_tab_stop, METH_NOARGS)
     MND(clear_tab_stop, METH_VARARGS)
+    MND(start_selection, METH_VARARGS)
+    MND(update_selection, METH_VARARGS)
     MND(reverse_index, METH_NOARGS)
     MND(mark_as_dirty, METH_NOARGS)
     MND(resize, METH_VARARGS)
@@ -1743,17 +1795,17 @@ static PyMemberDef members[] = {
     {"history_line_added_count", T_UINT, offsetof(Screen, history_line_added_count), 0, "history_line_added_count"},
     {NULL}
 };
- 
+
 PyTypeObject Screen_Type = {
     PyVarObject_HEAD_INIT(NULL, 0)
     .tp_name = "fast_data_types.Screen",
     .tp_basicsize = sizeof(Screen),
-    .tp_dealloc = (destructor)dealloc, 
-    .tp_flags = Py_TPFLAGS_DEFAULT,        
+    .tp_dealloc = (destructor)dealloc,
+    .tp_flags = Py_TPFLAGS_DEFAULT,
     .tp_doc = "Screen",
     .tp_methods = methods,
     .tp_members = members,
-    .tp_new = new,                
+    .tp_new = new,
     .tp_getset = getsetters,
 };
 

kitty/screen.h

@@ -26,7 +26,7 @@ typedef struct {
     unsigned int start_x, start_y, start_scrolled_by, end_x, end_y, end_scrolled_by;
     bool in_progress;
 } Selection;
-    
+
 typedef struct {
     PyObject_HEAD
 
@@ -75,8 +75,8 @@ void screen_erase_in_display(Screen *, unsigned int, bool);
 void screen_draw(Screen *screen, uint32_t codepoint);
 void screen_ensure_bounds(Screen *self, bool use_margins);
 void screen_toggle_screen_buffer(Screen *self);
-void screen_normal_keypad_mode(Screen *self); 
-void screen_alternate_keypad_mode(Screen *self);  
+void screen_normal_keypad_mode(Screen *self);
+void screen_alternate_keypad_mode(Screen *self);
 void screen_change_default_color(Screen *self, unsigned int which, uint32_t col);
 void screen_alignment_display(Screen *self);
 void screen_reverse_index(Screen *self);
@@ -106,6 +106,7 @@ void screen_delete_characters(Screen *self, unsigned int count);
 void screen_erase_characters(Screen *self, unsigned int count);
 void screen_set_margins(Screen *self, unsigned int top, unsigned int bottom);
 void screen_change_charset(Screen *, uint32_t to);
+void screen_handle_cmd(Screen *, PyObject *cmd);
 void screen_designate_charset(Screen *, uint32_t which, uint32_t as);
 void screen_use_latin1(Screen *, bool);
 void set_title(Screen *self, PyObject*);

kitty/session.py

@@ -18,6 +18,7 @@ class Tab:
         self.enabled_layouts = opts.enabled_layouts
         self.layout = (self.enabled_layouts or ['tall'])[0]
         self.cwd = None
+        self.next_title = None
 
 
 class Session:
@@ -31,6 +32,9 @@ class Session:
             del self.tabs[-1]
         self.tabs.append(Tab(opts, name))
 
+    def set_next_title(self, title):
+        self.tabs[-1].next_title = title.strip()
+
     def set_layout(self, val):
         if val not in all_layouts:
             raise ValueError('{} is not a valid layout'.format(val))
@@ -41,7 +45,10 @@ class Session:
             cmd = shlex.split(cmd) if isinstance(cmd, str) else cmd
         else:
             cmd = None
-        self.tabs[-1].windows.append(cmd)
+        from .tabs import SpecialWindow
+        t = self.tabs[-1]
+        t.windows.append(SpecialWindow(cmd, cwd=t.cwd, override_title=t.next_title))
+        t.next_title = None
 
     def add_special_window(self, sw):
         self.tabs[-1].windows.append(sw)
@@ -57,6 +64,15 @@ class Session:
         self.tabs[-1].cwd = val
 
 
+def resolved_shell(opts):
+    ans = opts.shell
+    if ans == '.':
+        ans = [shell_path]
+    else:
+        ans = shlex.split(ans)
+    return ans
+
+
 def parse_session(raw, opts):
     ans = Session()
     ans.add_tab(opts)
@@ -77,15 +93,17 @@ def parse_session(raw, opts):
                 ans.set_enabled_layouts(rest)
             elif cmd == 'cd':
                 ans.set_cwd(rest)
+            elif cmd == 'title':
+                ans.set_next_title(rest)
             else:
                 raise ValueError('Unknown command in session file: {}'.format(cmd))
     for t in ans.tabs:
         if not t.windows:
-            t.windows.append([shell_path])
+            t.windows.append(resolved_shell(opts))
     return ans
 
 
-def create_session(opts, args=None, special_window=None):
+def create_session(opts, args=None, special_window=None, cwd_from=None):
     if args and args.session:
         with open(args.session) as f:
             return parse_session(f.read(), opts)
@@ -99,12 +117,11 @@ def create_session(opts, args=None, special_window=None):
     ans.add_tab(opts)
     ans.tabs[-1].layout = current_layout
     if special_window is None:
-        cmd = args.args if args and args.args else [shell_path]
+        cmd = args.args if args and args.args else resolved_shell(opts)
+        from kitty.tabs import SpecialWindow
+        k = {'cwd_from': cwd_from}
         if getattr(args, 'title', None):
-            from kitty.tabs import SpecialWindow
-            ans.add_window(SpecialWindow(cmd, override_title=args.title))
-        else:
-            ans.add_window(cmd)
-    else:
-        ans.add_special_window(special_window)
+            k['override_title'] = args.title
+        special_window = SpecialWindow(cmd, **k)
+    ans.add_special_window(special_window)
     return ans

kitty/shaders.c

@@ -35,14 +35,14 @@ copy_image_sub_data(GLuint src_texture_id, GLuint dest_texture_id, unsigned int
         size_t sz = width * height * num_levels;
         pixel *src = malloc(sz * sizeof(pixel));
         if (src == NULL) { fatal("Out of memory."); }
-        glBindTexture(GL_TEXTURE_2D_ARRAY, src_texture_id); 
-        glGetTexImage(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, GL_UNSIGNED_BYTE, src); 
-        glBindTexture(GL_TEXTURE_2D_ARRAY, dest_texture_id); 
-        glPixelStorei(GL_UNPACK_ALIGNMENT, 4); 
-        glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, width, height, num_levels, GL_RGBA, GL_UNSIGNED_BYTE, src); 
+        glBindTexture(GL_TEXTURE_2D_ARRAY, src_texture_id);
+        glGetTexImage(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, GL_UNSIGNED_BYTE, src);
+        glBindTexture(GL_TEXTURE_2D_ARRAY, dest_texture_id);
+        glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
+        glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, width, height, num_levels, GL_RGBA, GL_UNSIGNED_BYTE, src);
         free(src);
     } else {
-        glCopyImageSubData(src_texture_id, GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, dest_texture_id, GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, width, height, num_levels); 
+        glCopyImageSubData(src_texture_id, GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, dest_texture_id, GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, width, height, num_levels);
     }
 }
 
@@ -50,24 +50,24 @@ copy_image_sub_data(GLuint src_texture_id, GLuint dest_texture_id, unsigned int
 static void
 realloc_sprite_texture() {
     GLuint tex;
-    glGenTextures(1, &tex); 
-    glBindTexture(GL_TEXTURE_2D_ARRAY, tex); 
+    glGenTextures(1, &tex);
+    glBindTexture(GL_TEXTURE_2D_ARRAY, tex);
     // We use GL_NEAREST otherwise glyphs that touch the edge of the cell
     // often show a border between cells
     glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 
+    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     unsigned int xnum, ynum, z, znum, width, height, src_ynum;
     sprite_tracker_current_layout(&xnum, &ynum, &z);
     znum = z + 1;
     width = xnum * global_state.cell_width; height = ynum * global_state.cell_height;
-    glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, width, height, znum); 
+    glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, width, height, znum);
     if (sprite_map.texture_id) {
         // need to re-alloc
         src_ynum = MAX(1, sprite_map.last_ynum);
         copy_image_sub_data(sprite_map.texture_id, tex, width, src_ynum * global_state.cell_height, sprite_map.last_num_of_layers);
-        glDeleteTextures(1, &sprite_map.texture_id); 
+        glDeleteTextures(1, &sprite_map.texture_id);
     }
     glBindTexture(GL_TEXTURE_2D_ARRAY, 0);
     sprite_map.last_num_of_layers = znum;
@@ -80,40 +80,40 @@ ensure_sprite_map() {
     if (!sprite_map.texture_id) realloc_sprite_texture();
     // We have to rebind since we dont know if the texture was ever bound
     // in the context of the current OSWindow
-    glActiveTexture(GL_TEXTURE0 + SPRITE_MAP_UNIT); 
-    glBindTexture(GL_TEXTURE_2D_ARRAY, sprite_map.texture_id); 
+    glActiveTexture(GL_TEXTURE0 + SPRITE_MAP_UNIT);
+    glBindTexture(GL_TEXTURE_2D_ARRAY, sprite_map.texture_id);
 }
 
-void 
+void
 send_sprite_to_gpu(unsigned int x, unsigned int y, unsigned int z, pixel *buf) {
     unsigned int xnum, ynum, znum;
     sprite_tracker_current_layout(&xnum, &ynum, &znum);
     if ((int)znum >= sprite_map.last_num_of_layers || (znum == 0 && (int)ynum > sprite_map.last_ynum)) realloc_sprite_texture();
-    glBindTexture(GL_TEXTURE_2D_ARRAY, sprite_map.texture_id); 
-    glPixelStorei(GL_UNPACK_ALIGNMENT, 4); 
+    glBindTexture(GL_TEXTURE_2D_ARRAY, sprite_map.texture_id);
+    glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
     x *= global_state.cell_width; y *= global_state.cell_height;
-    glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, x, y, z, global_state.cell_width, global_state.cell_height, 1, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, buf); 
+    glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, x, y, z, global_state.cell_width, global_state.cell_height, 1, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, buf);
 }
 
 void
 send_image_to_gpu(GLuint *tex_id, const void* data, GLsizei width, GLsizei height, bool is_opaque, bool is_4byte_aligned) {
     if (!(*tex_id)) { glGenTextures(1, tex_id);  }
-    glBindTexture(GL_TEXTURE_2D, *tex_id); 
-    glPixelStorei(GL_UNPACK_ALIGNMENT, is_4byte_aligned ? 4 : 1); 
+    glBindTexture(GL_TEXTURE_2D, *tex_id);
+    glPixelStorei(GL_UNPACK_ALIGNMENT, is_4byte_aligned ? 4 : 1);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, is_opaque ? GL_RGB : GL_RGBA, GL_UNSIGNED_BYTE, data);  
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, is_opaque ? GL_RGB : GL_RGBA, GL_UNSIGNED_BYTE, data);
 }
 
 static bool limits_updated = false;
 
-static void 
+static void
 layout_sprite_map() {
     if (!limits_updated) {
-        glGetIntegerv(GL_MAX_TEXTURE_SIZE, &(sprite_map.max_texture_size)); 
-        glGetIntegerv(GL_MAX_ARRAY_TEXTURE_LAYERS, &(sprite_map.max_array_texture_layers)); 
+        glGetIntegerv(GL_MAX_TEXTURE_SIZE, &(sprite_map.max_texture_size));
+        glGetIntegerv(GL_MAX_ARRAY_TEXTURE_LAYERS, &(sprite_map.max_array_texture_layers));
 #ifdef __APPLE__
         // Since on Apple we could have multiple GPUs, with different capabilities,
         // upper bound the values according to the data from http://developer.apple.com/graphicsimaging/opengl/capabilities/
@@ -201,6 +201,14 @@ create_graphics_vao() {
     return vao_idx;
 }
 
+struct CellUniformData {
+    bool constants_set;
+    GLint gploc, gpploc, cploc, cfploc;
+    GLfloat prev_inactive_text_alpha;
+};
+
+static struct CellUniformData cell_uniform_data = {0, .prev_inactive_text_alpha=-1};
+
 static inline void
 cell_update_uniform_block(ssize_t vao_idx, Screen *screen, int uniform_buffer, GLfloat xstart, GLfloat ystart, GLfloat dx, GLfloat dy, CursorRenderInfo *cursor, bool inverted) {
     struct CellRenderData {
@@ -220,15 +228,15 @@ cell_update_uniform_block(ssize_t vao_idx, Screen *screen, int uniform_buffer, G
         copy_color_table_to_buffer(screen->color_profile, (GLuint*)rd, cell_program_layouts[CELL_PROGRAM].color_table.offset / sizeof(GLuint), cell_program_layouts[CELL_PROGRAM].color_table.stride / sizeof(GLuint));
     }
     // Cursor position
-    if (cursor->is_visible && cursor->shape == CURSOR_BLOCK) { 
-        rd->cursor_x = screen->cursor->x, rd->cursor_y = screen->cursor->y; 
+    if (cursor->is_visible && cursor->shape == CURSOR_BLOCK && cursor->is_focused) {
+        rd->cursor_x = screen->cursor->x, rd->cursor_y = screen->cursor->y;
     } else {
-        rd->cursor_x = screen->columns, rd->cursor_y = screen->lines; 
+        rd->cursor_x = screen->columns, rd->cursor_y = screen->lines;
     }
     rd->cursor_w = rd->cursor_x + MAX(1, screen_current_char_width(screen)) - 1;
 
     rd->xnum = screen->columns; rd->ynum = screen->lines;
-    
+
     rd->xstart = xstart; rd->ystart = ystart; rd->dx = dx; rd->dy = dy;
     unsigned int x, y, z;
     sprite_tracker_current_layout(&x, &y, &z);
@@ -284,19 +292,13 @@ static void
 draw_graphics(int program, ssize_t vao_idx, ssize_t gvao_idx, ImageRenderData *data, GLuint start, GLuint count) {
     bind_program(program);
     bind_vertex_array(gvao_idx);
-    static bool graphics_constants_set = false;
-    if (!graphics_constants_set) { 
-        glUniform1i(glGetUniformLocation(program_id(GRAPHICS_PROGRAM), "image"), GRAPHICS_UNIT);  
-        glUniform1i(glGetUniformLocation(program_id(GRAPHICS_PREMULT_PROGRAM), "image"), GRAPHICS_UNIT);  
-        graphics_constants_set = true; 
-    }
-    glActiveTexture(GL_TEXTURE0 + GRAPHICS_UNIT); 
+    glActiveTexture(GL_TEXTURE0 + GRAPHICS_UNIT);
 
     GLuint base = 4 * start;
     glEnable(GL_SCISSOR_TEST);
     for (GLuint i=0; i < count;) {
         ImageRenderData *rd = data + start + i;
-        glBindTexture(GL_TEXTURE_2D, rd->texture_id); 
+        glBindTexture(GL_TEXTURE_2D, rd->texture_id);
         // You could reduce the number of draw calls by using
         // glDrawArraysInstancedBaseInstance but Apple chose to abandon OpenGL
         // before implementing it.
@@ -311,8 +313,8 @@ draw_graphics(int program, ssize_t vao_idx, ssize_t gvao_idx, ImageRenderData *d
 
 static void
 draw_cells_simple(ssize_t vao_idx, ssize_t gvao_idx, Screen *screen) {
-    bind_program(CELL_PROGRAM); 
-    glDrawArraysInstanced(GL_TRIANGLE_FAN, 0, 4, screen->lines * screen->columns); 
+    bind_program(CELL_PROGRAM);
+    glDrawArraysInstanced(GL_TRIANGLE_FAN, 0, 4, screen->lines * screen->columns);
     if (screen->grman->count) {
         glEnable(GL_BLEND);
         BLEND_ONTO_OPAQUE;
@@ -323,18 +325,18 @@ draw_cells_simple(ssize_t vao_idx, ssize_t gvao_idx, Screen *screen) {
 
 static void
 draw_cells_interleaved(ssize_t vao_idx, ssize_t gvao_idx, Screen *screen) {
-    bind_program(CELL_BG_PROGRAM); 
-    glDrawArraysInstanced(GL_TRIANGLE_FAN, 0, 4, screen->lines * screen->columns); 
+    bind_program(CELL_BG_PROGRAM);
+    glDrawArraysInstanced(GL_TRIANGLE_FAN, 0, 4, screen->lines * screen->columns);
     glEnable(GL_BLEND);
     BLEND_ONTO_OPAQUE;
 
     if (screen->grman->num_of_negative_refs) draw_graphics(GRAPHICS_PROGRAM, vao_idx, gvao_idx, screen->grman->render_data, 0, screen->grman->num_of_negative_refs);
 
-    bind_program(CELL_SPECIAL_PROGRAM); 
-    glDrawArraysInstanced(GL_TRIANGLE_FAN, 0, 4, screen->lines * screen->columns); 
+    bind_program(CELL_SPECIAL_PROGRAM);
+    glDrawArraysInstanced(GL_TRIANGLE_FAN, 0, 4, screen->lines * screen->columns);
 
-    bind_program(CELL_FG_PROGRAM); 
-    glDrawArraysInstanced(GL_TRIANGLE_FAN, 0, 4, screen->lines * screen->columns); 
+    bind_program(CELL_FG_PROGRAM);
+    glDrawArraysInstanced(GL_TRIANGLE_FAN, 0, 4, screen->lines * screen->columns);
 
     if (screen->grman->num_of_positive_refs) draw_graphics(GRAPHICS_PROGRAM, vao_idx, gvao_idx, screen->grman->render_data, screen->grman->num_of_negative_refs, screen->grman->num_of_positive_refs);
 
@@ -350,25 +352,25 @@ draw_cells_interleaved_premult(ssize_t vao_idx, ssize_t gvao_idx, Screen *screen
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     }
     glBindTexture(GL_TEXTURE_2D, 0);
     glBindFramebuffer(GL_DRAW_FRAMEBUFFER, offscreen_framebuffer);
     glFramebufferTexture(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, os_window->offscreen_texture_id, 0);
     /* if (glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) fatal("offscreen framebuffer not complete"); */
 
-    bind_program(CELL_BG_PROGRAM); 
-    glDrawArraysInstanced(GL_TRIANGLE_FAN, 0, 4, screen->lines * screen->columns); 
+    bind_program(CELL_BG_PROGRAM);
+    glDrawArraysInstanced(GL_TRIANGLE_FAN, 0, 4, screen->lines * screen->columns);
     glEnable(GL_BLEND);
     BLEND_PREMULT;
 
     if (screen->grman->num_of_negative_refs) draw_graphics(GRAPHICS_PREMULT_PROGRAM, vao_idx, gvao_idx, screen->grman->render_data, 0, screen->grman->num_of_negative_refs);
 
-    bind_program(CELL_SPECIAL_PROGRAM); 
-    glDrawArraysInstanced(GL_TRIANGLE_FAN, 0, 4, screen->lines * screen->columns); 
+    bind_program(CELL_SPECIAL_PROGRAM);
+    glDrawArraysInstanced(GL_TRIANGLE_FAN, 0, 4, screen->lines * screen->columns);
 
-    bind_program(CELL_FG_PROGRAM); 
-    glDrawArraysInstanced(GL_TRIANGLE_FAN, 0, 4, screen->lines * screen->columns); 
+    bind_program(CELL_FG_PROGRAM);
+    glDrawArraysInstanced(GL_TRIANGLE_FAN, 0, 4, screen->lines * screen->columns);
 
     if (screen->grman->num_of_positive_refs) draw_graphics(GRAPHICS_PREMULT_PROGRAM, vao_idx, gvao_idx, screen->grman->render_data, screen->grman->num_of_negative_refs, screen->grman->num_of_positive_refs);
 
@@ -377,20 +379,41 @@ draw_cells_interleaved_premult(ssize_t vao_idx, ssize_t gvao_idx, Screen *screen
 
     // Now render the framebuffer to the screen reversing alpha pre-multiplication
     glEnable(GL_SCISSOR_TEST);
-    bind_program(BLIT_PROGRAM); bind_vertex_array(blit_vertex_array); 
+    bind_program(BLIT_PROGRAM); bind_vertex_array(blit_vertex_array);
     static bool blit_constants_set = false;
-    if (!blit_constants_set) { 
-        glUniform1i(glGetUniformLocation(program_id(BLIT_PROGRAM), "image"), BLIT_UNIT);  
-        blit_constants_set = true; 
+    if (!blit_constants_set) {
+        glUniform1i(glGetUniformLocation(program_id(BLIT_PROGRAM), "image"), BLIT_UNIT);
+        blit_constants_set = true;
     }
-    glActiveTexture(GL_TEXTURE0 + BLIT_UNIT); 
-    glBindTexture(GL_TEXTURE_2D, os_window->offscreen_texture_id); 
-    glDrawArrays(GL_TRIANGLE_FAN, 0, 4); 
+    glActiveTexture(GL_TEXTURE0 + BLIT_UNIT);
+    glBindTexture(GL_TEXTURE_2D, os_window->offscreen_texture_id);
+    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
     glDisable(GL_SCISSOR_TEST);
 }
 
-void 
-draw_cells(ssize_t vao_idx, ssize_t gvao_idx, GLfloat xstart, GLfloat ystart, GLfloat dx, GLfloat dy, Screen *screen, OSWindow *os_window) {
+static inline void
+set_cell_uniforms(float current_inactive_text_alpha) {
+    if (!cell_uniform_data.constants_set) {
+        cell_uniform_data.gploc = glGetUniformLocation(program_id(GRAPHICS_PROGRAM), "inactive_text_alpha");
+        cell_uniform_data.gpploc = glGetUniformLocation(program_id(GRAPHICS_PREMULT_PROGRAM), "inactive_text_alpha");
+        cell_uniform_data.cploc = glGetUniformLocation(program_id(CELL_PROGRAM), "inactive_text_alpha");
+        cell_uniform_data.cfploc = glGetUniformLocation(program_id(CELL_FG_PROGRAM), "inactive_text_alpha");
+#define S(prog, name, val) { bind_program(prog); glUniform1i(glGetUniformLocation(program_id(prog), #name), val); }
+        S(GRAPHICS_PROGRAM, image, GRAPHICS_UNIT); S(GRAPHICS_PREMULT_PROGRAM, image, GRAPHICS_UNIT);
+        S(CELL_PROGRAM, sprites, SPRITE_MAP_UNIT); S(CELL_FG_PROGRAM, sprites, SPRITE_MAP_UNIT);
+#undef S
+        cell_uniform_data.constants_set = true;
+    }
+    if (current_inactive_text_alpha != cell_uniform_data.prev_inactive_text_alpha) {
+        cell_uniform_data.prev_inactive_text_alpha = current_inactive_text_alpha;
+#define S(prog, loc) { bind_program(prog); glUniform1f(cell_uniform_data.loc, current_inactive_text_alpha); }
+        S(CELL_PROGRAM, cploc); S(CELL_FG_PROGRAM, cfploc); S(GRAPHICS_PROGRAM, gploc); S(GRAPHICS_PREMULT_PROGRAM, gpploc);
+#undef S
+    }
+}
+
+void
+draw_cells(ssize_t vao_idx, ssize_t gvao_idx, GLfloat xstart, GLfloat ystart, GLfloat dx, GLfloat dy, Screen *screen, OSWindow *os_window, bool is_active_window) {
     if (os_window->clear_count < 2) {
         os_window->clear_count++;
 #define C(shift) (((GLfloat)((OPT(background) >> shift) & 0xFF)) / 255.0f)
@@ -400,22 +423,17 @@ draw_cells(ssize_t vao_idx, ssize_t gvao_idx, GLfloat xstart, GLfloat ystart, GL
     }
 
     cell_prepare_to_render(vao_idx, gvao_idx, screen, xstart, ystart, dx, dy);
+    float current_inactive_text_alpha = screen->cursor_render_info.is_focused && is_active_window ? 1.0 : OPT(inactive_text_alpha);
+    set_cell_uniforms(current_inactive_text_alpha);
     GLfloat w = (GLfloat)screen->columns * dx, h = (GLfloat)screen->lines * dy;
 #define SCALE(w, x) ((GLfloat)(os_window->viewport_##w) * (GLfloat)(x))
     glScissor(
-            (GLint)(SCALE(width, (xstart + 1.0f) / 2.0f)), 
+            (GLint)(SCALE(width, (xstart + 1.0f) / 2.0f)),
             (GLint)(SCALE(height, ((ystart - h) + 1.0f) / 2.0f)),
             (GLsizei)(ceilf(SCALE(width, w / 2.0f))),
             (GLsizei)(ceilf(SCALE(height, h / 2.0f)))
     );
 #undef SCALE
-    static bool cell_constants_set = false;
-    if (!cell_constants_set) { 
-        bind_program(CELL_PROGRAM);
-        glUniform1i(glGetUniformLocation(program_id(CELL_PROGRAM), "sprites"), SPRITE_MAP_UNIT);  
-        glUniform1i(glGetUniformLocation(program_id(CELL_FG_PROGRAM), "sprites"), SPRITE_MAP_UNIT);  
-        cell_constants_set = true; 
-    }
     if (os_window->is_semi_transparent) {
         if (screen->grman->count) draw_cells_interleaved_premult(vao_idx, gvao_idx, screen, os_window);
         else draw_cells_simple(vao_idx, gvao_idx, screen);
@@ -446,12 +464,12 @@ init_cursor_program() {
 #undef SET_LOC
 }
 
-void 
+void
 draw_cursor(CursorRenderInfo *cursor, bool is_focused) {
-    bind_program(CURSOR_PROGRAM); bind_vertex_array(cursor_vertex_array); 
-    glUniform3f(cursor_uniform_locations[CURSOR_color], ((cursor->color >> 16) & 0xff) / 255.0, ((cursor->color >> 8) & 0xff) / 255.0, (cursor->color & 0xff) / 255.0); 
-    glUniform4f(cursor_uniform_locations[CURSOR_pos], cursor->left, cursor->top, cursor->right, cursor->bottom); 
-    glDrawArrays(is_focused ? GL_TRIANGLE_FAN : GL_LINE_LOOP, 0, 4); 
+    bind_program(CURSOR_PROGRAM); bind_vertex_array(cursor_vertex_array);
+    glUniform3f(cursor_uniform_locations[CURSOR_color], ((cursor->color >> 16) & 0xff) / 255.0, ((cursor->color >> 8) & 0xff) / 255.0, (cursor->color & 0xff) / 255.0);
+    glUniform4f(cursor_uniform_locations[CURSOR_pos], cursor->left, cursor->top, cursor->right, cursor->bottom);
+    glDrawArrays(is_focused ? GL_TRIANGLE_FAN : GL_LINE_LOOP, 0, 4);
     unbind_vertex_array(); unbind_program();
 }
 // }}}
@@ -522,11 +540,11 @@ compile_program(PyObject UNUSED *self, PyObject *args) {
     if (which < 0 || which >= NUM_PROGRAMS) { PyErr_Format(PyExc_ValueError, "Unknown program: %d", which); return NULL; }
     if (programs[which].id != 0) { PyErr_SetString(PyExc_ValueError, "program already compiled"); return NULL; }
     programs[which].id = glCreateProgram();
-    vertex_shader_id = compile_shader(GL_VERTEX_SHADER, vertex_shader); 
-    fragment_shader_id = compile_shader(GL_FRAGMENT_SHADER, fragment_shader); 
-    glAttachShader(programs[which].id, vertex_shader_id); 
-    glAttachShader(programs[which].id, fragment_shader_id); 
-    glLinkProgram(programs[which].id); 
+    vertex_shader_id = compile_shader(GL_VERTEX_SHADER, vertex_shader);
+    fragment_shader_id = compile_shader(GL_FRAGMENT_SHADER, fragment_shader);
+    glAttachShader(programs[which].id, vertex_shader_id);
+    glAttachShader(programs[which].id, fragment_shader_id);
+    glLinkProgram(programs[which].id);
     GLint ret = GL_FALSE;
     glGetProgramiv(programs[which].id, GL_LINK_STATUS, &ret);
     if (ret != GL_TRUE) {
@@ -550,8 +568,8 @@ end:
 #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; } 
+#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; }
 #define NO_ARG(name) PYWRAP0(name) { name(); Py_RETURN_NONE; }
 #define NO_ARG_INT(name) PYWRAP0(name) { return PyLong_FromSsize_t(name()); }
 
@@ -622,7 +640,7 @@ init_shaders(PyObject *module) {
     C(GL_UNPACK_ALIGNMENT);
     C(GL_R8); C(GL_RED); C(GL_UNSIGNED_BYTE); C(GL_UNSIGNED_SHORT); C(GL_R32UI); C(GL_RGB32UI); C(GL_RGBA);
     C(GL_TEXTURE_BUFFER); C(GL_STATIC_DRAW); C(GL_STREAM_DRAW); C(GL_DYNAMIC_DRAW);
-    C(GL_SRC_ALPHA); C(GL_ONE_MINUS_SRC_ALPHA); 
+    C(GL_SRC_ALPHA); C(GL_ONE_MINUS_SRC_ALPHA);
     C(GL_WRITE_ONLY); C(GL_READ_ONLY); C(GL_READ_WRITE);
     C(GL_BLEND); C(GL_FLOAT); C(GL_UNSIGNED_INT); C(GL_ARRAY_BUFFER); C(GL_UNIFORM_BUFFER);
 

kitty/state.c

@@ -20,12 +20,12 @@ GlobalState global_state = {{0}};
             (count)--; \
             break; \
         } \
-    }} 
+    }}
 
 #define WITH_OS_WINDOW(os_window_id) \
     for (size_t o = 0; o < global_state.num_os_windows; o++) { \
         OSWindow *os_window = global_state.os_windows + o; \
-        if (os_window->id == os_window_id) { 
+        if (os_window->id == os_window_id) {
 #define END_WITH_OS_WINDOW break; }}
 
 #define WITH_TAB(os_window_id, tab_id) \
@@ -50,7 +50,7 @@ GlobalState global_state = {{0}};
     }}
 
 
-OSWindow* 
+OSWindow*
 current_os_window() {
     if (global_state.callback_os_window) return global_state.callback_os_window;
     for (size_t i = 0; i < global_state.num_os_windows; i++) {
@@ -187,7 +187,7 @@ remove_os_window(id_type os_window_id) {
         found = true;
         make_os_window_context_current(os_window);
     END_WITH_OS_WINDOW
-    if (found) { 
+    if (found) {
         WITH_OS_WINDOW_REFS
             REMOVER(global_state.os_windows, os_window_id, global_state.num_os_windows, OSWindow, destroy_os_window_item, global_state.capacity);
         END_WITH_OS_WINDOW_REFS
@@ -242,6 +242,31 @@ add_borders_rect(id_type os_window_id, id_type tab_id, uint32_t left, uint32_t t
 }
 
 
+void
+os_window_regions(OSWindow *os_window, Region *central, Region *tab_bar) {
+    if (os_window->num_tabs > 1) {
+        switch(OPT(tab_bar_edge)) {
+            case TOP_EDGE:
+                central->left = 0; central->top = global_state.cell_height; central->right = os_window->viewport_width - 1;
+                central->bottom = os_window->viewport_height - 1;
+                tab_bar->left = central->left; tab_bar->right = central->right; tab_bar->top = 0;
+                tab_bar->bottom = central->top - 1;
+                break;
+            default:
+                central->left = 0; central->top = 0; central->right = os_window->viewport_width - 1;
+                central->bottom = os_window->viewport_height - global_state.cell_height - 1;
+                tab_bar->left = central->left; tab_bar->right = central->right; tab_bar->top = central->bottom + 1;
+                tab_bar->bottom = os_window->viewport_height - 1;
+                break;
+        }
+    } else {
+        memset(tab_bar, 0, sizeof(Region));
+        central->left = 0; central->top = 0; central->right = os_window->viewport_width - 1;
+        central->bottom = os_window->viewport_height - 1;
+    }
+}
+
+
 // Python API {{{
 #define PYWRAP0(name) static PyObject* py##name(PyObject UNUSED *self)
 #define PYWRAP1(name) static PyObject* py##name(PyObject UNUSED *self, PyObject *args)
@@ -311,12 +336,15 @@ PYWRAP1(set_options) {
     S(cursor_blink_interval, PyFloat_AsDouble);
     S(cursor_stop_blinking_after, PyFloat_AsDouble);
     S(background_opacity, PyFloat_AsDouble);
+    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);
     S(open_url_modifiers, PyLong_AsUnsignedLong);
+    S(rectangle_select_modifiers, PyLong_AsUnsignedLong);
     S(click_interval, PyFloat_AsDouble);
     S(url_color, color_as_int);
     S(background, color_as_int);
@@ -337,7 +365,7 @@ PYWRAP1(set_options) {
     Py_DECREF(ret); if (PyErr_Occurred()) return NULL;
 
     PyObject *al = PyObject_GetAttrString(opts, "adjust_line_height");
-    if (PyFloat_Check(al)) { 
+    if (PyFloat_Check(al)) {
         OPT(adjust_line_height_frac) = (float)PyFloat_AsDouble(al);
         OPT(adjust_line_height_px) = 0;
     } else {
@@ -362,15 +390,47 @@ PYWRAP1(set_tab_bar_render_data) {
     Py_RETURN_NONE;
 }
 
+static PyTypeObject RegionType;
+static PyStructSequence_Field region_fields[] = {
+    {"left", ""}, {"top", ""}, {"right", ""}, {"bottom", ""}, {"width", ""}, {"height", ""}, {NULL, NULL}
+};
+static PyStructSequence_Desc region_desc = {"Region", NULL, region_fields, 6};
+
+static inline PyObject*
+wrap_region(Region *r) {
+    PyObject *ans = PyStructSequence_New(&RegionType);
+    if (ans) {
+        PyStructSequence_SET_ITEM(ans, 0, PyLong_FromUnsignedLong(r->left));
+        PyStructSequence_SET_ITEM(ans, 1, PyLong_FromUnsignedLong(r->top));
+        PyStructSequence_SET_ITEM(ans, 2, PyLong_FromUnsignedLong(r->right));
+        PyStructSequence_SET_ITEM(ans, 3, PyLong_FromUnsignedLong(r->bottom));
+        PyStructSequence_SET_ITEM(ans, 4, PyLong_FromUnsignedLong(r->right - r->left + 1));
+        PyStructSequence_SET_ITEM(ans, 5, PyLong_FromUnsignedLong(r->bottom - r->top + 1));
+    }
+    return ans;
+}
+
 PYWRAP1(viewport_for_window) {
     id_type os_window_id = 0;
+    int vw = 100, vh = 100;
     PA("|K", &os_window_id);
+    Region central = {0}, tab_bar = {0};
     WITH_OS_WINDOW(os_window_id)
-        int available_height = os_window->viewport_height;
-        if (os_window->num_tabs > 1) available_height -= global_state.cell_height;
-        return Py_BuildValue("iiiII", os_window->viewport_width, os_window->viewport_height, available_height, global_state.cell_width, global_state.cell_height);
+        os_window_regions(os_window, &central, &tab_bar);
+        vw = os_window->viewport_width; vh = os_window->viewport_height;
+        goto end;
     END_WITH_OS_WINDOW
-    return Py_BuildValue("iiII", 400, 400, global_state.cell_width, global_state.cell_height);
+end:
+    return Py_BuildValue("NNiiII", wrap_region(&central), wrap_region(&tab_bar), vw, vh, global_state.cell_width, global_state.cell_height);
+}
+
+PYWRAP1(set_dpi_from_os_window) {
+    id_type os_window_id = PyLong_AsUnsignedLongLong(args);
+    WITH_OS_WINDOW(os_window_id)
+        set_dpi_from_os_window(os_window);
+        Py_RETURN_TRUE;
+    END_WITH_OS_WINDOW
+    Py_RETURN_FALSE;
 }
 
 PYWRAP1(mark_os_window_for_close) {
@@ -476,6 +536,7 @@ static PyMethodDef module_methods[] = {
     MW(set_logical_dpi, METH_VARARGS),
     MW(pt_to_px, METH_O),
     MW(pt_to_px_ceil, METH_O),
+    MW(set_dpi_from_os_window, METH_O),
     MW(add_tab, METH_O),
     MW(add_window, METH_VARARGS),
     MW(update_window_title, METH_VARARGS),
@@ -498,10 +559,13 @@ static PyMethodDef module_methods[] = {
     {NULL, NULL, 0, NULL}        /* Sentinel */
 };
 
-bool 
+bool
 init_state(PyObject *module) {
     global_state.cell_width = 1; global_state.cell_height = 1;
     if (PyModule_AddFunctions(module, module_methods) != 0) return false;
+    if (PyStructSequence_InitType2(&RegionType, &region_desc) != 0) return false;
+    Py_INCREF((PyObject *) &RegionType);
+    PyModule_AddObject(module, "Region", (PyObject *) &RegionType);
     return true;
 }
 // }}}

kitty/state.h

@@ -10,11 +10,14 @@
 
 #define OPT(name) global_state.opts.name
 
+typedef enum { LEFT_EDGE, TOP_EDGE, RIGHT_EDGE, BOTTOM_EDGE } Edge;
+
 typedef struct {
     double visual_bell_duration, cursor_blink_interval, cursor_stop_blinking_after, mouse_hide_wait, click_interval, wheel_scroll_multiplier;
     bool enable_audio_bell;
     CursorShape cursor_shape;
     unsigned int open_url_modifiers;
+    unsigned int rectangle_select_modifiers;
     unsigned int url_style;
     char_type select_by_word_characters[256]; size_t select_by_word_characters_count;
     color_type url_color, background;
@@ -26,6 +29,8 @@ typedef struct {
     int x11_bell_volume;
     float adjust_line_height_frac;
     float background_opacity;
+    float inactive_text_alpha;
+    Edge tab_bar_edge;
 } Options;
 
 typedef struct {
@@ -105,6 +110,7 @@ typedef struct {
     double last_resize_at;
     bool has_pending_resizes;
     bool is_semi_transparent;
+    bool shown_once;
     uint32_t offscreen_texture_id;
     unsigned int clear_count;
 } OSWindow;
@@ -146,6 +152,7 @@ void mark_os_window_for_close(OSWindow* w, bool yes);
 void update_os_window_viewport(OSWindow *window, bool);
 bool should_os_window_close(OSWindow* w);
 bool should_os_window_be_rendered(OSWindow* w);
+void set_dpi_from_os_window(OSWindow *w);
 void wakeup_main_loop();
 void event_loop_wait(double timeout);
 void swap_window_buffers(OSWindow *w);
@@ -156,12 +163,13 @@ void set_os_window_title(OSWindow *w, const char *title);
 OSWindow* os_window_for_kitty_window(id_type);
 OSWindow* add_os_window();
 OSWindow* current_os_window();
+void os_window_regions(OSWindow*, Region *main, Region *tab_bar);
 bool drag_scroll(Window *, OSWindow*);
 void draw_borders(ssize_t vao_idx, unsigned int num_border_rects, BorderRect *rect_buf, bool rect_data_is_dirty, uint32_t viewport_width, uint32_t viewport_height);
 ssize_t create_cell_vao();
 ssize_t create_graphics_vao();
 ssize_t create_border_vao();
-void draw_cells(ssize_t, ssize_t, float, float, float, float, Screen *, OSWindow *);
+void draw_cells(ssize_t, ssize_t, float, float, float, float, Screen *, OSWindow *, bool);
 void draw_cursor(CursorRenderInfo *, bool);
 void update_surface_size(int, int, uint32_t);
 void free_texture(uint32_t*);

kitty/tabs.py

@@ -9,29 +9,28 @@ from functools import partial
 from .borders import Borders
 from .child import Child
 from .config import build_ansi_color_table
-from .constants import (
-    WindowGeometry, appname, get_boss, is_macos, is_wayland, shell_path
-)
+from .constants import WindowGeometry, appname, get_boss, is_macos, is_wayland
 from .fast_data_types import (
     DECAWM, Screen, add_tab, glfw_post_empty_event, remove_tab, remove_window,
     set_active_tab, set_active_window, set_tab_bar_render_data, swap_tabs,
     swap_windows, viewport_for_window, x11_window_id
 )
 from .layout import Rect, all_layouts
+from .session import resolved_shell
 from .utils import color_as_int
 from .window import Window, calculate_gl_geometry
 
 TabbarData = namedtuple('TabbarData', 'title is_active is_last')
-SpecialWindowInstance = namedtuple('SpecialWindow', 'cmd stdin override_title')
+SpecialWindowInstance = namedtuple('SpecialWindow', 'cmd stdin override_title cwd_from cwd')
 
 
-def SpecialWindow(cmd, stdin=None, override_title=None):
-    return SpecialWindowInstance(cmd, stdin, override_title)
+def SpecialWindow(cmd, stdin=None, override_title=None, cwd_from=None, cwd=None):
+    return SpecialWindowInstance(cmd, stdin, override_title, cwd_from, cwd)
 
 
 class Tab:  # {{{
 
-    def __init__(self, tab_manager, session_tab=None, special_window=None):
+    def __init__(self, tab_manager, session_tab=None, special_window=None, cwd_from=None):
         self.tab_manager_ref = weakref.ref(tab_manager)
         self.os_window_id = tab_manager.os_window_id
         self.id = add_tab(self.os_window_id)
@@ -50,7 +49,7 @@ class Tab:  # {{{
             sl = self.enabled_layouts[0]
             self.current_layout = all_layouts[sl](self.os_window_id, self.opts, self.borders.border_width, self.windows)
             if special_window is None:
-                self.new_window()
+                self.new_window(cwd_from=cwd_from)
             else:
                 self.new_special_window(special_window)
         else:
@@ -75,6 +74,12 @@ class Tab:  # {{{
     def title(self):
         return getattr(self.active_window, 'title', appname)
 
+    def set_title(self, title):
+        self.name = title or ''
+        tm = self.tab_manager_ref()
+        if tm is not None:
+            tm.title_changed(self.name)
+
     def title_changed(self, window):
         if window is self.active_window:
             tm = self.tab_manager_ref()
@@ -109,12 +114,12 @@ class Tab:  # {{{
                 w.set_visible_in_layout(i, True)
             self.relayout()
 
-    def launch_child(self, use_shell=False, cmd=None, stdin=None):
+    def launch_child(self, use_shell=False, cmd=None, stdin=None, cwd_from=None, cwd=None):
         if cmd is None:
             if use_shell:
-                cmd = [shell_path]
+                cmd = resolved_shell(self.opts)
             else:
-                cmd = self.args.args or [shell_path]
+                cmd = self.args.args or resolved_shell(self.opts)
         env = {}
         if not is_macos and not is_wayland:
             try:
@@ -122,12 +127,12 @@ class Tab:  # {{{
             except Exception:
                 import traceback
                 traceback.print_exc()
-        ans = Child(cmd, self.cwd, self.opts, stdin, env)
+        ans = Child(cmd, cwd or self.cwd, self.opts, stdin, env, cwd_from)
         ans.fork()
         return ans
 
-    def new_window(self, use_shell=True, cmd=None, stdin=None, override_title=None):
-        child = self.launch_child(use_shell=use_shell, cmd=cmd, stdin=stdin)
+    def new_window(self, use_shell=True, cmd=None, stdin=None, override_title=None, cwd_from=None, cwd=None):
+        child = self.launch_child(use_shell=use_shell, cmd=cmd, stdin=stdin, cwd_from=cwd_from, cwd=cwd)
         window = Window(self, child, self.opts, self.args, override_title=override_title)
         # Must add child before laying out so that resize_pty succeeds
         get_boss().add_child(window)
@@ -138,7 +143,7 @@ class Tab:  # {{{
         return window
 
     def new_special_window(self, special_window):
-        self.new_window(False, *special_window)
+        return self.new_window(False, *special_window)
 
     def close_window(self):
         if self.windows:
@@ -202,6 +207,17 @@ class Tab:  # {{{
     def move_window_backward(self):
         self.move_window(-1)
 
+    def list_windows(self):
+        for w in self:
+            yield w.as_dict()
+
+    def matches(self, field, pat):
+        if field == 'id':
+            return pat.pattern == str(self.id)
+        if field == 'title':
+            return pat.search(self.name or self.title) is not None
+        return False
+
     def __iter__(self):
         yield from iter(self.windows)
 
@@ -228,7 +244,7 @@ class TabBar:  # {{{
         self.num_tabs = 1
         self.cell_width = 1
         self.data_buffer_size = 0
-        self.layout_changed = None
+        self.laid_out_once = False
         self.dirty = True
         self.screen = s = Screen(None, 1, 10)
         s.color_profile.update_ansi_color_table(build_ansi_color_table(opts))
@@ -255,25 +271,29 @@ class TabBar:  # {{{
         self.active_bg = as_rgb(color_as_int(opts.active_tab_background))
         self.active_fg = as_rgb(color_as_int(opts.active_tab_foreground))
 
-    def layout(self, viewport_width, viewport_height, cell_width, cell_height):
+    def layout(self):
+        central, tab_bar, vw, vh, cell_width, cell_height = viewport_for_window(self.os_window_id)
+        if tab_bar.width < 2:
+            return
         self.cell_width = cell_width
         s = self.screen
+        viewport_width = tab_bar.width
         ncells = viewport_width // cell_width
         s.resize(1, ncells)
         s.reset_mode(DECAWM)
-        self.layout_changed = True
+        self.laid_out_once = True
         margin = (viewport_width - ncells * cell_width) // 2
         self.window_geometry = g = WindowGeometry(
-            margin, viewport_height - cell_height, viewport_width - margin, viewport_height, s.columns, s.lines)
+            margin, tab_bar.top, viewport_width - margin, tab_bar.bottom, s.columns, s.lines)
         if margin > 0:
-            self.tab_bar_blank_rects = (Rect(0, g.top, g.left, g.bottom), Rect(g.right - 1, g.top, viewport_width, g.bottom))
+            self.blank_rects = (Rect(0, g.top, g.left, g.bottom + 1), Rect(g.right - 1, g.top, viewport_width, g.bottom + 1))
         else:
-            self.tab_bar_blank_rects = ()
-        self.screen_geometry = sg = calculate_gl_geometry(g, viewport_width, viewport_height, cell_width, cell_height)
+            self.blank_rects = ()
+        self.screen_geometry = sg = calculate_gl_geometry(g, vw, vh, cell_width, cell_height)
         set_tab_bar_render_data(self.os_window_id, sg.xstart, sg.ystart, sg.dx, sg.dy, self.screen)
 
     def update(self, data):
-        if self.layout_changed is None:
+        if not self.laid_out_once:
             return
         s = self.screen
         s.cursor.x = 0
@@ -321,31 +341,35 @@ class TabManager:  # {{{
         self.opts, self.args = opts, args
         self.tabs = []
         self.tab_bar = TabBar(self.os_window_id, opts)
-        self.tab_bar.layout(*self.tab_bar_layout_data)
         self.active_tab_idx = 0
 
         for t in startup_session.tabs:
             self._add_tab(Tab(self, session_tab=t))
         self._set_active_tab(max(0, min(startup_session.active_tab_idx, len(self.tabs) - 1)))
-        if len(self.tabs) > 1:
-            self.tabbar_visibility_changed()
         self.update_tab_bar()
 
     def refresh_sprite_positions(self):
         self.tab_bar.screen.refresh_sprite_positions()
 
     def _add_tab(self, tab):
+        before = len(self.tabs)
         self.tabs.append(tab)
+        if len(self.tabs) > 1 and before < 2:
+            self.tabbar_visibility_changed()
 
     def _remove_tab(self, tab):
+        before = len(self.tabs)
         remove_tab(self.os_window_id, tab.id)
         self.tabs.remove(tab)
+        if len(self.tabs) < 2 and before > 1:
+            self.tabbar_visibility_changed()
 
     def _set_active_tab(self, idx):
         self.active_tab_idx = idx
         set_active_tab(self.os_window_id, idx)
 
     def tabbar_visibility_changed(self):
+        self.tab_bar.layout()
         self.resize(only_tabs=True)
         glfw_post_empty_event()
 
@@ -355,23 +379,30 @@ class TabManager:  # {{{
 
     def resize(self, only_tabs=False):
         if not only_tabs:
-            self.tab_bar.layout(*self.tab_bar_layout_data)
+            self.tab_bar.layout()
             self.update_tab_bar()
         for tab in self.tabs:
             tab.relayout()
 
-    def set_active_tab(self, idx):
+    def set_active_tab_idx(self, idx):
         self._set_active_tab(idx)
         self.active_tab.relayout_borders()
         self.update_tab_bar()
 
+    def set_active_tab(self, tab):
+        try:
+            idx = self.tabs.index(tab)
+        except Exception:
+            return
+        self.set_active_tab_idx(idx)
+
     def next_tab(self, delta=1):
         if len(self.tabs) > 1:
-            self.set_active_tab((self.active_tab_idx + len(self.tabs) + delta) % len(self.tabs))
+            self.set_active_tab_idx((self.active_tab_idx + len(self.tabs) + delta) % len(self.tabs))
 
     def goto_tab(self, tab_num):
         if tab_num < len(self.tabs) and 0 <= tab_num:
-            self.set_active_tab(tab_num)
+            self.set_active_tab_idx(tab_num)
 
     def __iter__(self):
         return iter(self.tabs)
@@ -379,6 +410,14 @@ class TabManager:  # {{{
     def __len__(self):
         return len(self.tabs)
 
+    def list_tabs(self):
+        for tab in self:
+            yield {
+                'id': tab.id,
+                'title': tab.name or tab.title,
+                'windows': list(tab.list_windows()),
+            }
+
     @property
     def active_tab(self):
         return self.tabs[self.active_tab_idx] if self.tabs else None
@@ -401,28 +440,17 @@ class TabManager:  # {{{
     def title_changed(self, new_title):
         self.update_tab_bar()
 
-    def new_tab(self, special_window=None):
-        needs_resize = len(self.tabs) == 1
+    def new_tab(self, special_window=None, cwd_from=None):
         idx = len(self.tabs)
-        self._add_tab(Tab(self, special_window=special_window))
+        self._add_tab(Tab(self, special_window=special_window, cwd_from=cwd_from))
         self._set_active_tab(idx)
         self.update_tab_bar()
-        if needs_resize:
-            self.tabbar_visibility_changed()
 
     def remove(self, tab):
-        needs_resize = len(self.tabs) == 2
         self._remove_tab(tab)
         self._set_active_tab(max(0, min(self.active_tab_idx, len(self.tabs) - 1)))
         self.update_tab_bar()
         tab.destroy()
-        if needs_resize:
-            self.tabbar_visibility_changed()
-
-    @property
-    def tab_bar_layout_data(self):
-        vw, vh, ah, cw, ch = viewport_for_window(self.os_window_id)
-        return vw, vh, cw, ch
 
     @property
     def tab_bar_data(self):
@@ -436,7 +464,7 @@ class TabManager:  # {{{
     def activate_tab_at(self, x):
         i = self.tab_bar.tab_at(x)
         if i is not None:
-            self.set_active_tab(i)
+            self.set_active_tab_idx(i)
 
     @property
     def blank_rects(self):

kitty/unicode-data.h

@@ -1,41 +1,24 @@
 #pragma once
+#include "data-types.h"
 
-#include <unictype.h>
-#include <uninorm.h>
-
-static inline bool 
-is_combining_char(uint32_t ch) {
-    return uc_combining_class(ch) != UC_CCC_NR;
-}
-    
-
-static inline bool 
-is_ignored_char(uint32_t ch) {
-    return uc_is_general_category_withtable(ch, UC_CATEGORY_MASK_Cc | UC_CATEGORY_MASK_Cf | UC_CATEGORY_MASK_Cs);
-}
-
-static inline bool 
-is_word_char(uint32_t ch) {
-    return uc_is_general_category_withtable(ch, UC_CATEGORY_MASK_L | UC_CATEGORY_MASK_N);
-}
+bool is_combining_char(char_type ch);
+bool is_ignored_char(char_type ch);
+bool is_word_char(char_type ch);
+bool is_CZ_category(char_type);
+bool is_P_category(char_type);
+char_type codepoint_for_mark(combining_type m);
+combining_type mark_for_codepoint(char_type c);
 
 static inline bool
 is_url_char(uint32_t ch) {
-    return ch && !uc_is_general_category_withtable(ch, UC_CATEGORY_MASK_C | UC_CATEGORY_MASK_Z);
-}
-
-static inline uint32_t
-normalize(uint32_t ch, uint32_t cc1, uint32_t cc2) {
-    uint32_t ans = uc_composition(ch, cc1);
-    if (ans && cc2) ans = uc_composition(ans, cc2);
-    return ans;
+    return ch && !is_CZ_category(ch);
 }
 
 static inline bool
 can_strip_from_end_of_url(uint32_t ch) {
     // remove trailing punctuation
     return (
-        (uc_is_general_category_withtable(ch, UC_CATEGORY_MASK_P) && ch != '/') ||
+        (is_P_category(ch) && ch != '/') ||
         ch == '>'
     ) ? true : false;
 }

kitty/utils.py

@@ -12,6 +12,7 @@ import shlex
 import socket
 import string
 import subprocess
+import sys
 import tempfile
 from contextlib import contextmanager
 from functools import lru_cache
@@ -266,7 +267,34 @@ def single_instance(group_id=None):
     return True
 
 
-def encode_wm_class(name, cls, title=appname):
-    if is_macos:
-        return title
-    return '\x01' + (name or cls) + '\x1e' + cls + '\x1e' + title
+@contextmanager
+def non_blocking_read(src=sys.stdin):
+    import termios
+    import tty
+    import fcntl
+    fd = src.fileno()
+    if src.isatty():
+        old = termios.tcgetattr(fd)
+        tty.setraw(fd)
+    oldfl = fcntl.fcntl(fd, fcntl.F_GETFL)
+    fcntl.fcntl(fd, fcntl.F_SETFL, oldfl | os.O_NONBLOCK)
+    yield fd
+    if src.isatty():
+        termios.tcsetattr(fd, termios.TCSADRAIN, old)
+    fcntl.fcntl(fd, fcntl.F_SETFL, oldfl)
+
+
+def read_with_timeout(more_needed, timeout=10, src=sys.stdin):
+    import select
+    start_time = monotonic()
+    with non_blocking_read(src) as fd:
+        while timeout > monotonic() - start_time:
+            rd = select.select([fd], [], [], max(0, timeout - (monotonic() - start_time)))[0]
+            if rd:
+                data = sys.stdin.buffer.read()
+                if not data:
+                    break  # eof
+                if not more_needed(data):
+                    break
+            else:
+                break

kitty/window.py

@@ -2,6 +2,7 @@
 # vim:fileencoding=utf-8
 # License: GPL v3 Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
 
+import json
 import sys
 import weakref
 from collections import deque
@@ -87,7 +88,7 @@ class Window:
 
     def __init__(self, tab, child, opts, args, override_title=None):
         self.override_title = override_title
-        self.title = self.override_title or appname
+        self.child_title = appname
         self.id = add_window(tab.os_window_id, tab.id, self.title)
         if not self.id:
             raise Exception('No tab with id: {} in OS Window: {} was found, or the window counter wrapped'.format(tab.id, tab.os_window_id))
@@ -103,9 +104,37 @@ class Window:
         self.screen = Screen(self, 24, 80, opts.scrollback_lines, self.id)
         setup_colors(self.screen, opts)
 
+    @property
+    def title(self):
+        return self.override_title or self.child_title
+
     def __repr__(self):
         return 'Window(title={}, id={})'.format(self.title, self.id)
 
+    def as_dict(self):
+        return dict(
+            id=self.id,
+            title=self.override_title or self.title,
+            pid=self.child.pid,
+            cwd=self.child.current_cwd or self.child.cwd, cmdline=self.child.cmdline
+        )
+
+    def matches(self, field, pat):
+        if field == 'id':
+            return pat.pattern == str(self.id)
+        if field == 'pid':
+            return pat.pattern == str(self.child.pid)
+        if field == 'title':
+            return pat.search(self.override_title or self.title) is not None
+        if field in 'cwd':
+            return pat.search(self.child.current_cwd or self.child.cwd) is not None
+        if field == 'cmdline':
+            for x in self.child.cmdline:
+                if pat.search(x) is not None:
+                    return True
+            return False
+        return False
+
     def set_visible_in_layout(self, window_idx, val):
         val = bool(val)
         if val is not self.is_visible_in_layout:
@@ -119,7 +148,7 @@ class Window:
         wakeup()
 
     def update_position(self, window_geometry):
-        vw, vh, ah, cw, ch = viewport_for_window(self.os_window_id)
+        central, tab_bar, vw, vh, cw, ch = viewport_for_window(self.os_window_id)
         self.screen_geometry = sg = calculate_gl_geometry(window_geometry, vw, vh, cw, ch)
         return sg
 
@@ -163,6 +192,17 @@ class Window:
             if get_boss().child_monitor.needs_write(self.id, data) is not True:
                 print('Failed to write to child %d as it does not exist' % self.id, file=sys.stderr)
 
+    def title_updated(self):
+        update_window_title(self.os_window_id, self.tab_id, self.id, self.title)
+        t = self.tabref()
+        if t is not None:
+            t.title_changed(self)
+        glfw_post_empty_event()
+
+    def set_title(self, title):
+        self.override_title = title or None
+        self.title_updated()
+
     # screen callbacks {{{
     def use_utf8(self, on):
         get_boss().child_monitor.set_iutf8(self.window_id, on)
@@ -176,13 +216,9 @@ class Window:
                 self.screen.send_escape_code_to_child(CSI, 'O')
 
     def title_changed(self, new_title):
+        self.child_title = sanitize_title(new_title or appname)
         if self.override_title is None:
-            self.title = sanitize_title(new_title or appname)
-            update_window_title(self.os_window_id, self.tab_id, self.id, self.title)
-            t = self.tabref()
-            if t is not None:
-                t.title_changed(self)
-            glfw_post_empty_event()
+            self.title_updated()
 
     def icon_changed(self, new_icon):
         pass  # TODO: Implement this
@@ -258,6 +294,12 @@ class Window:
     def request_capabilities(self, q):
         self.screen.send_escape_code_to_child(DCS, get_capabilities(q))
 
+    def handle_remote_cmd(self, cmd):
+        get_boss().handle_remote_cmd(cmd, self)
+
+    def send_cmd_response(self, response):
+        self.screen.send_escape_code_to_child(DCS, '@kitty-cmd' + json.dumps(response))
+
     # }}}
 
     def text_for_selection(self):
@@ -270,14 +312,20 @@ class Window:
             self.screen.reset_callbacks()
         self.screen = None
 
-    def buffer_as_ansi(self):
+    def buffer_as_ansi(self, add_history=True):
         data = []
-        self.screen.historybuf.as_ansi(data.append)
+        if add_history:
+            self.screen.historybuf.as_ansi(data.append)
         self.screen.linebuf.as_ansi(data.append)
         return ''.join(data)
 
-    def buffer_as_text(self):
-        return str(self.screen.historybuf) + '\n' + str(self.screen.linebuf)
+    def buffer_as_text(self, add_history=True):
+        ans = str(self.screen.linebuf).rstrip('\n')
+        if add_history:
+            h = str(self.screen.historybuf)
+            if h.strip():
+                ans = h + '\n' + ans
+        return ans
 
     # actions {{{
 

kitty_tests/datatypes.py

@@ -140,7 +140,7 @@ class TestDataTypes(BaseTest):
 
         lb = filled_line_buf(5, 5, filled_cursor())
         l0 = lb.line(0)
-        l0.add_combining_char(1, 'a')
+        l0.add_combining_char(1, '\u0300')
         l0.clear_text(1, 2)
         self.ae(str(l0), '0  00')
         self.assertEqualAttributes(l0.cursor_from(1), l0.cursor_from(0))
@@ -164,14 +164,14 @@ class TestDataTypes(BaseTest):
             lb.line(0)[lb.xnum]
         l0 = lb.line(0)
         l0.set_text(' ', 0, len(' '), C())
-        l0.add_combining_char(0, '1')
-        self.ae(l0[0], ' 1')
-        l0.add_combining_char(0, '2')
-        self.ae(l0[0], ' 12')
-        l0.add_combining_char(0, '3')
-        self.ae(l0[0], ' 13')
+        l0.add_combining_char(0, '\u0300')
+        self.ae(l0[0], ' \u0300')
+        l0.add_combining_char(0, '\U000e0100')
+        self.ae(l0[0], ' \u0300\U000e0100')
+        l0.add_combining_char(0, '\u0302')
+        self.ae(l0[0], ' \u0300\u0302')
         self.ae(l0[1], '\0')
-        self.ae(str(l0), ' 13')
+        self.ae(str(l0), ' \u0300\u0302')
         t = 'Testing with simple text'
         lb = LineBuf(2, len(t))
         l0 = lb.line(0)
@@ -269,6 +269,9 @@ class TestDataTypes(BaseTest):
         no_url('http: //acme.com')
         no_url('http:/ /acme.com')
 
+        l4 = create(' xxxxxtekljhgdkjgd')
+        self.ae(l4.url_end_at(0), 0)
+
     def rewrap(self, lb, lb2):
         hb = HistoryBuf(lb2.ynum, lb2.xnum)
         cy = lb.rewrap(lb2, hb)

kitty_tests/fonts.py

@@ -80,6 +80,7 @@ class Rendering(BaseTest):
 
             self.ae(groups('abcd'), [(1, 1) for i in range(4)])
             self.ae(groups('A=>>B!=C', path='kitty_tests/FiraCode-Medium.otf'), [(1, 1), (3, 3), (1, 1), (2, 2), (1, 1)])
+            self.ae(groups('==!=<>==<><><>', path='kitty_tests/FiraCode-Medium.otf'), [(2, 2), (2, 2), (2, 2), (2, 2), (2, 2), (2, 2), (2, 2)])
             colon_glyph = shape_string('9:30', path='kitty_tests/FiraCode-Medium.otf')[1][2]
             self.assertNotEqual(colon_glyph, shape_string(':', path='kitty_tests/FiraCode-Medium.otf')[0][2])
             self.ae(colon_glyph, 998)

kitty_tests/keys.py

@@ -78,3 +78,30 @@ class TestParser(BaseTest):
                 keycode = getattr(defines, 'GLFW_KEY_' + key)
                 base_key = smkx_key_map[keycode]
                 km(modify_key_bytes(base_key, num).decode('ascii')[1:], key)
+
+    def test_encode_mouse_event(self):
+        PRESS, RELEASE, DRAG, MOVE = range(4)
+        NORMAL_PROTOCOL, UTF8_PROTOCOL, SGR_PROTOCOL, URXVT_PROTOCOL = range(4)
+        L, M, R = defines.GLFW_MOUSE_BUTTON_LEFT, defines.GLFW_MOUSE_BUTTON_MIDDLE, defines.GLFW_MOUSE_BUTTON_RIGHT
+        protocol = SGR_PROTOCOL
+
+        def enc(button=L, action=PRESS, mods=0, x=1, y=1):
+            return defines.test_encode_mouse(x, y, protocol, button, action, mods)
+
+        self.ae(enc(), '<0;1;1M')
+        self.ae(enc(action=RELEASE), '<0;1;1m')
+        self.ae(enc(action=MOVE), '<35;1;1M')
+        self.ae(enc(action=DRAG), '<32;1;1M')
+
+        self.ae(enc(R), '<2;1;1M')
+        self.ae(enc(R, action=RELEASE), '<2;1;1m')
+        self.ae(enc(R, action=DRAG), '<34;1;1M')
+
+        self.ae(enc(M), '<1;1;1M')
+        self.ae(enc(M, action=RELEASE), '<1;1;1m')
+        self.ae(enc(M, action=DRAG), '<33;1;1M')
+
+        self.ae(enc(x=1234, y=5678), '<0;1234;5678M')
+        self.ae(enc(mods=defines.GLFW_MOD_SHIFT), '<4;1;1M')
+        self.ae(enc(mods=defines.GLFW_MOD_ALT), '<8;1;1M')
+        self.ae(enc(mods=defines.GLFW_MOD_CONTROL), '<16;1;1M')

kitty_tests/screen.py

@@ -367,3 +367,16 @@ class TestScreen(BaseTest):
         s.cursor.y = 2
         s.erase_characters(2)
         self.ae(s.linebuf.dirty_lines(), [0, 1, 2])
+
+    def test_selection_as_text(self):
+        s = self.create_screen()
+        for i in range(2 * s.lines):
+            if i != 0:
+                s.carriage_return(), s.linefeed()
+            s.draw(str(i) * s.columns)
+        s.start_selection(0, 0, False)
+        s.update_selection(4, 4, True)
+        expected = ('55555', '\n66666', '\n77777', '\n88888', '\n99999')
+        self.ae(s.text_for_selection(), expected)
+        s.scroll(2, True)
+        self.ae(s.text_for_selection(), expected)

launcher/kitty

@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+# vim:fileencoding=utf-8
+# License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
+
+import os
+import sys
+
+base = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, base)
+with open(os.path.join(base, '__main__.py')) as f:
+    src = f.read()
+code = compile(src, f.name, 'exec')
+exec(code, {'__name__': '__main__'})