version 0.27.1

Provide the currently supported fish completion script when requesting
version 2.

.gitattributes

@@ -15,6 +15,8 @@ kittens/diff/options/parse.py linguist-generated=true
 glfw/*.c linguist-vendored=true
 glfw/*.h linguist-vendored=true
 kittens/unicode_input/names.h linguist-generated=true
+tools/wcswidth/std.go linguist-generated=true
 
 *.py  text diff=python
 *.m  text diff=objc
+*.go text diff=go

.github/workflows/ci.py

@@ -30,8 +30,13 @@ def install_deps():
     print('Installing kitty dependencies...')
     sys.stdout.flush()
     if is_macos:
-        items = (x.split()[1].strip('"') for x in open('Brewfile').readlines() if x.strip().startswith('brew '))
-        run('brew', 'install', 'fish', *items)
+        items = [x.split()[1].strip('"') for x in open('Brewfile').readlines() if x.strip().startswith('brew ')]
+        openssl = 'openssl'
+        items.remove('go')  # already installed by ci.yml
+        import ssl
+        if ssl.OPENSSL_VERSION_INFO[0] == 1:
+            openssl += '@1.1'
+        run('brew', 'install', 'fish', openssl, *items)
     else:
         run('sudo apt-get update')
         run('sudo apt-get install -y libgl1-mesa-dev libxi-dev libxrandr-dev libxinerama-dev ca-certificates'
@@ -59,7 +64,7 @@ def build_kitty():
 
 
 def test_kitty():
-    run('./kitty/launcher/kitty +launch test.py')
+    run('./test.py')
 
 
 def package_kitty():
@@ -125,6 +130,12 @@ def main():
         package_kitty()
     elif action == 'test':
         test_kitty()
+    elif action == 'gofmt':
+        q = subprocess.check_output('gofmt -s -l tools'.split())
+        if q.strip():
+            q = '\n'.join(filter(lambda x: not x.rstrip().endswith('_generated.go'), q.decode().strip().splitlines())).strip()
+            if q:
+                raise SystemExit(q)
     else:
         raise SystemExit(f'Unknown action: {action}')
 

.github/workflows/ci.yml

@@ -5,6 +5,10 @@ env:
     ASAN_OPTIONS: leak_check_at_exit=0
     LC_ALL: en_US.UTF-8
     LANG: en_US.UTF-8
+    GO_INSTALL_VERSION: ">=1.20.0"
+
+permissions:
+  contents: read # to fetch code (actions/checkout)
 
 jobs:
     linux:
@@ -20,15 +24,15 @@ jobs:
                 cc: [gcc, clang]
                 include:
                     - python: a
-                      pyver: 3.7
+                      pyver: "3.8"
                       sanitize: 0
 
                     - python: b
-                      pyver: 3.8
+                      pyver: "3.11"
                       sanitize: 1
 
                     - python: c
-                      pyver: 3.9
+                      pyver: "3.9"
                       sanitize: 1
 
 
@@ -41,20 +45,26 @@ jobs:
                       cc: gcc
 
         steps:
-            - name: Checkout source code
-              uses: actions/checkout@v3
-              with:
-                fetch-depth: 10
-            - name: Set up Python ${{ matrix.pyver }}
-              uses: actions/setup-python@v3
-              with:
-                python-version: ${{ matrix.pyver }}
+          - name: Checkout source code
+            uses: actions/checkout@v3
+            with:
+              fetch-depth: 10
 
-            - name: Build kitty
-              run: python .github/workflows/ci.py build
+          - name: Set up Python ${{ matrix.pyver }}
+            uses: actions/setup-python@v3
+            with:
+              python-version: ${{ matrix.pyver }}
 
-            - name: Test kitty
-              run: python .github/workflows/ci.py test
+          - name: Install Go
+            uses: actions/setup-go@v3
+            with:
+              go-version: ${{ env.GO_INSTALL_VERSION }}
+
+          - name: Build kitty
+            run: python .github/workflows/ci.py build
+
+          - name: Test kitty
+            run: python .github/workflows/ci.py test
 
     linux-package:
         name: Linux package
@@ -62,36 +72,53 @@ jobs:
         env:
             CFLAGS: -funsigned-char
         steps:
-            - name: Checkout source code
-              uses: actions/checkout@v3
-              with:
-                fetch-depth: 10
+          - name: Checkout source code
+            uses: actions/checkout@v3
+            with:
+              fetch-depth: 0  # needed for :commit: docs role
 
-            - name: Test for trailing whitespace
-              run: if grep -Inr '\s$' kitty kitty_tests kittens docs *.py *.asciidoc *.rst .gitattributes .gitignore; then echo Trailing whitespace found, aborting.; exit 1; fi
+          - name: Test for trailing whitespace
+            run: if grep -Inr '\s$' kitty kitty_tests kittens docs *.py *.asciidoc *.rst *.go .gitattributes .gitignore; then echo Trailing whitespace found, aborting.; exit 1; fi
 
-            - name: Set up Python
-              uses: actions/setup-python@v3
-              with:
-                python-version: 3.8
+          - name: Set up Python
+            uses: actions/setup-python@v3
+            with:
+              python-version: "3.10"
 
-            - name: Install build-only deps
-              run: pip install -r docs/requirements.txt flake8 mypy types-requests types-docutils
+          - name: Install Go
+            uses: actions/setup-go@v3
+            with:
+              go-version: ${{ env.GO_INSTALL_VERSION }}
 
-            - name: Run pyflakes
-              run: python -m flake8 --count .
+          - name: Install build-only deps
+            run: python -m pip install -r docs/requirements.txt ruff mypy types-requests types-docutils
 
-            - name: Build kitty package
-              run: python .github/workflows/ci.py package
+          - name: Run ruff
+            run: ruff .
 
-            - name: Run mypy
-              run: python test.py mypy
+          - name: Run gofmt
+            run: go version && python .github/workflows/ci.py gofmt
 
-            - name: Build man page
-              run: make FAIL_WARN=1 man
+          - name: Build kitty package
+            run: python .github/workflows/ci.py package
 
-            - name: Build HTML docs
-              run: make FAIL_WARN=1 html
+          - name: Build kitty
+            run: python setup.py build --debug
+
+          - name: Build static kitty-tool
+            run: python setup.py build-static-binaries
+
+          - name: Run mypy
+            run: which python && python -m mypy --version && ./test.py mypy
+
+          - name: Run go vet
+            run: go version && go vet ./...
+
+          - name: Build man page
+            run: make FAIL_WARN=1 man
+
+          - name: Build HTML docs
+            run: make FAIL_WARN=1 html
 
     bundle:
         name: Bundle test (${{ matrix.os }})
@@ -102,31 +129,52 @@ jobs:
         env:
             KITTY_BUNDLE: 1
         steps:
-            - name: Checkout source code
-              uses: actions/checkout@master
-              with:
-                fetch-depth: 10
+          - name: Checkout source code
+            uses: actions/checkout@master
+            with:
+              fetch-depth: 10
 
-            - name: Build kitty
-              run: which python3 && python3 .github/workflows/ci.py build
+          - name: Install Go
+            uses: actions/setup-go@v3
+            with:
+              go-version: ${{ env.GO_INSTALL_VERSION }}
 
-            - name: Test kitty
-              run: python3 .github/workflows/ci.py test
+          - name: Build kitty
+            run: which python3 && python3 .github/workflows/ci.py build
+
+          - name: Test kitty
+            run: python3 .github/workflows/ci.py test
 
     brew:
         name: macOS Brew
         runs-on: macos-latest
         steps:
-            - name: Checkout source code
-              uses: actions/checkout@master
-              with:
-                  fetch-depth: 10
+          - name: Checkout source code
+            uses: actions/checkout@master
+            with:
+              fetch-depth: 0  # needed for :commit: docs role
 
-            - name: Build kitty
-              run: python3 .github/workflows/ci.py build
+          - name: Set up Python
+            uses: actions/setup-python@v3
+            with:
+              python-version: "3.10"
 
-            - name: Test kitty
-              run: python3 .github/workflows/ci.py test
+          - name: Install Go
+            uses: actions/setup-go@v3
+            with:
+              go-version: ${{ env.GO_INSTALL_VERSION }}
 
-            - name: Build kitty package
-              run: python3 .github/workflows/ci.py package
+          - name: Build kitty
+            run: python3 .github/workflows/ci.py build
+
+          - name: Test kitty
+            run: python3 .github/workflows/ci.py test
+
+          - name: Install deps for docs
+            run: python3 -m pip install -r docs/requirements.txt
+
+          - name: Builds docs
+            run: make FAIL_WARN=1 docs
+
+          - name: Build kitty package
+            run: python3 .github/workflows/ci.py package

.github/workflows/codeql-analysis.yml

@@ -9,12 +9,25 @@ on:
   schedule:
     - cron: '0 22 * * 5'
 
+permissions:
+  contents: read # to fetch code (actions/checkout)
+
 jobs:
   CodeQL-Build:
 
+    permissions:
+      contents: read # to fetch code (actions/checkout)
+      security-events: write # to upload SARIF results (github/codeql-action/analyze)
+
     runs-on: ubuntu-latest
 
     steps:
+
+    - name: Install Go
+      uses: actions/setup-go@v3
+      with:
+        go-version: ">=1.20.0"
+
     - name: Checkout repository
       uses: actions/checkout@v3
       with:
@@ -24,7 +37,7 @@ jobs:
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
+      uses: github/codeql-action/init@v2
       with:
         languages: python, c
         setup-python-dependencies: false

.gitignore

@@ -2,15 +2,17 @@
 *.pyc
 *.pyo
 *_stub.pyi
+*_generated.go
+*_generated.h
 /.dmypy.json
 /tags
 /build/
 /linux-package/
 /kitty.app/
-/compile_commands.json
-/link_commands.json
 /glad/out/
-/kitty/launcher/
+/kitty/launcher/kitt*
+/tools/cmd/at/*_generated.go
+*_generated.go
 /*.dSYM/
 __pycache__/
 /glfw/wayland-*-client-protocol.[ch]
@@ -18,5 +20,6 @@ __pycache__/
 /docs/generated/
 /.mypy_cache
 .DS_Store
+.cache
 bypy/b
 bypy/virtual-machines.conf

Brewfile

@@ -5,3 +5,4 @@ brew "python"
 brew "imagemagick"
 brew "harfbuzz"
 brew "sphinx-doc"
+brew "go"

CONTRIBUTING.md

@@ -7,6 +7,11 @@ When reporting a bug, provide full details of your environment, that means, at
 a minimum, kitty version, OS and OS version, kitty config (ideally a minimal
 config to reproduce the issue with).
 
+Note that bugs and feature requests are often closed quickly as they are either
+fixed or deemed wontfix/invalid. In my experience, this is the only scaleable way to
+manage a bug tracker. Feel free to continue to post to a closed bug report
+if you would like to discuss the issue further. Being closed does not mean you
+will not get any more responses.
 
 ### Contributing code
 

Makefile

@@ -35,6 +35,12 @@ profile:
 app:
 	python3 setup.py kitty.app $(VVAL)
 
+linux-package: FORCE
+	rm -rf linux-package
+	python3 setup.py linux-package
+
+FORCE:
+
 man:
 	$(MAKE) -C docs man
 

__main__.py

@@ -1,185 +1,7 @@
 #!/usr/bin/env python3
 # License: GPL v3 Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
 
-import os
-import sys
-from typing import List
-
-
-def icat(args: List[str]) -> None:
-    from kittens.runner import run_kitten as rk
-    sys.argv = args
-    rk('icat')
-
-
-def list_fonts(args: List[str]) -> None:
-    from kitty.fonts.list import main as list_main
-    list_main(args)
-
-
-def remote_control(args: List[str]) -> None:
-    from kitty.remote_control import main as rc_main
-    rc_main(args)
-
-
-def runpy(args: List[str]) -> None:
-    if len(args) < 2:
-        raise SystemExit('Usage: kitty +runpy "some python code"')
-    sys.argv = ['kitty'] + args[2:]
-    exec(args[1])
-
-
-def hold(args: List[str]) -> None:
-    import subprocess
-    ret = 1
-    try:
-        ret = subprocess.Popen(args[1:]).wait()
-    except KeyboardInterrupt:
-        pass
-    except FileNotFoundError:
-        print(f'Could not find {args[1]!r} to execute', file=sys.stderr)
-    except Exception as e:
-        print(e, file=sys.stderr)
-    from kitty.utils import hold_till_enter
-    hold_till_enter()
-    raise SystemExit(ret)
-
-
-def complete(args: List[str]) -> None:
-    from kitty.complete import main as complete_main
-    complete_main(args[1:], entry_points, namespaced_entry_points)
-
-
-def open_urls(args: List[str]) -> None:
-    setattr(sys, 'cmdline_args_for_open', True)
-    sys.argv = ['kitty'] + args[1:]
-    from kitty.main import main as kitty_main
-    kitty_main()
-
-
-def launch(args: List[str]) -> None:
-    import runpy
-    sys.argv = args[1:]
-    try:
-        exe = args[1]
-    except IndexError:
-        raise SystemExit(
-            'usage: kitty +launch script.py [arguments to be passed to script.py ...]\n\n'
-            'script.py will be run with full access to kitty code. If script.py is '
-            'prefixed with a : it will be searched for in PATH'
-        )
-    if exe.startswith(':'):
-        import shutil
-        q = shutil.which(exe[1:])
-        if not q:
-            raise SystemExit(f'{exe[1:]} not found in PATH')
-        exe = q
-    if not os.path.exists(exe):
-        raise SystemExit(f'{exe} does not exist')
-    runpy.run_path(exe, run_name='__main__')
-
-
-def shebang(args: List[str]) -> None:
-    script_path = args[1]
-    cmd = args[2:]
-    if cmd == ['__ext__']:
-        cmd = [os.path.splitext(script_path)[1][1:].lower()]
-    try:
-        f = open(script_path)
-    except FileNotFoundError:
-        raise SystemExit(f'The file {script_path} does not exist')
-    with f:
-        if f.read(2) == '#!':
-            line = f.readline().strip()
-            _plat = sys.platform.lower()
-            is_macos: bool = 'darwin' in _plat
-            if is_macos:
-                cmd = line.split(' ')
-            else:
-                cmd = line.split(' ', maxsplit=1)
-    os.execvp(cmd[0], cmd + [script_path])
-
-
-def run_kitten(args: List[str]) -> None:
-    try:
-        kitten = args[1]
-    except IndexError:
-        from kittens.runner import list_kittens
-        list_kittens()
-        raise SystemExit(1)
-    sys.argv = args[1:]
-    from kittens.runner import run_kitten as rk
-    rk(kitten)
-
-
-def edit_config_file(args: List[str]) -> None:
-    from kitty.cli import create_default_opts
-    from kitty.fast_data_types import set_options
-    from kitty.utils import edit_config_file as f
-    set_options(create_default_opts())
-    f()
-
-
-def namespaced(args: List[str]) -> None:
-    try:
-        func = namespaced_entry_points[args[1]]
-    except KeyError:
-        pass
-    else:
-        func(args[1:])
-        return
-    raise SystemExit(f'{args[1]} is not a known entry point. Choices are: ' + ', '.join(namespaced_entry_points))
-
-
-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 '+@'}
-namespaced_entry_points['hold'] = hold
-namespaced_entry_points['complete'] = complete
-namespaced_entry_points['runpy'] = runpy
-namespaced_entry_points['launch'] = launch
-namespaced_entry_points['open'] = open_urls
-namespaced_entry_points['kitten'] = run_kitten
-namespaced_entry_points['edit-config'] = edit_config_file
-namespaced_entry_points['shebang'] = shebang
-
-
-def setup_openssl_environment() -> None:
-    # Use our bundled CA certificates instead of the system ones, since
-    # many systems come with no certificates in a useable form or have various
-    # locations for the certificates.
-    d = os.path.dirname
-    ext_dir: str = getattr(sys, 'kitty_extensions_dir')
-    if 'darwin' in sys.platform.lower():
-        cert_file = os.path.join(d(d(d(ext_dir))), 'cacert.pem')
-    else:
-        cert_file = os.path.join(d(ext_dir), 'cacert.pem')
-    os.environ['SSL_CERT_FILE'] = cert_file
-    setattr(sys, 'kitty_ssl_env_var', 'SSL_CERT_FILE')
-
-
-def main() -> None:
-    if getattr(sys, 'frozen', False) and getattr(sys, 'kitty_extensions_dir', ''):
-        setup_openssl_environment()
-    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 as kitty_main
-            kitty_main()
-    else:
-        func(sys.argv[1:])
-
 
 if __name__ == '__main__':
+    from kitty.entry_points import main
     main()

bypy/init_env.py

@@ -11,9 +11,8 @@ import sys
 import tempfile
 from contextlib import suppress
 
-from bypy.constants import (
-    LIBDIR, PREFIX, PYTHON, SRC as KITTY_DIR, ismacos, worker_env
-)
+from bypy.constants import LIBDIR, PREFIX, PYTHON, ismacos, worker_env
+from bypy.constants import SRC as KITTY_DIR
 from bypy.utils import run_shell, walk
 
 
@@ -63,20 +62,31 @@ def build_frozen_launcher(extra_include_dirs):
 
 def run_tests(kitty_exe):
     with tempfile.TemporaryDirectory() as tdir:
-        env = {
+        uenv = {
             'KITTY_CONFIG_DIRECTORY': os.path.join(tdir, 'conf'),
             'KITTY_CACHE_DIRECTORY': os.path.join(tdir, 'cache')
         }
-        [os.mkdir(x) for x in env.values()]
-        cmd = [kitty_exe, '+runpy', 'from kitty_tests.main import run_tests; run_tests()']
+        [os.mkdir(x) for x in uenv.values()]
+        env = os.environ.copy()
+        env.update(uenv)
+        cmd = [kitty_exe, '+runpy', 'from kitty_tests.main import run_tests; run_tests(report_env=True)']
         print(*map(shlex.quote, cmd), flush=True)
-        if subprocess.call(cmd, env=env) != 0:
-            print('Checking of kitty build failed', file=sys.stderr)
+        if subprocess.call(cmd, env=env, cwd=build_frozen_launcher.writeable_src_dir) != 0:
+            print('Checking of kitty build failed, in directory:', build_frozen_launcher.writeable_src_dir, file=sys.stderr)
             os.chdir(os.path.dirname(kitty_exe))
             run_shell()
             raise SystemExit('Checking of kitty build failed')
 
 
+def build_frozen_tools(kitty_exe):
+    cmd = SETUP_CMD + ['--prefix', os.path.dirname(kitty_exe)] + ['build-frozen-tools']
+    if run(*cmd, cwd=build_frozen_launcher.writeable_src_dir) != 0:
+        print('Building of frozen kitten failed', file=sys.stderr)
+        os.chdir(KITTY_DIR)
+        run_shell()
+        raise SystemExit('Building of kitten launcher failed')
+
+
 def sanitize_source_folder(path: str) -> None:
     for q in walk(path):
         if os.path.splitext(q)[1] not in ('.py', '.glsl', '.ttf', '.otf'):

bypy/linux.conf

@@ -1,3 +1,3 @@
 image 'https://cloud-images.ubuntu.com/releases/bionic/release/ubuntu-18.04-server-cloudimg-{}.img'
 
-deps 'bison flex libxcursor-dev libxrandr-dev libxi-dev libxinerama-dev libgl1-mesa-dev libxcb-xkb-dev libfontconfig1-dev libdbus-1-dev'
+deps 'bison flex libxcursor-dev libxrandr-dev libxi-dev libxinerama-dev libgl1-mesa-dev libx11-xcb-dev libxcb-xkb-dev libfontconfig1-dev libdbus-1-dev'

bypy/linux/__main__.py

@@ -10,12 +10,8 @@ import subprocess
 import tarfile
 import time
 
-from bypy.constants import (
-    OUTPUT_DIR, PREFIX, is64bit, python_major_minor_version
-)
-from bypy.freeze import (
-    extract_extension_modules, freeze_python, path_to_freeze_dir
-)
+from bypy.constants import OUTPUT_DIR, PREFIX, is64bit, python_major_minor_version
+from bypy.freeze import extract_extension_modules, freeze_python, path_to_freeze_dir
 from bypy.utils import get_dll_path, mkdtemp, py_compile, walk
 
 j = os.path.join
@@ -143,6 +139,7 @@ def copy_python(env):
         iv['sanitize_source_folder'](os.path.join(env.py_dir, x))
     py_compile(env.py_dir)
     freeze_python(env.py_dir, pdir, env.obj_dir, ext_map, develop_mode_env_var='KITTY_DEVELOP_FROM', remove_pyc_files=True)
+    shutil.rmtree(env.py_dir)
 
 
 def build_launcher(env):
@@ -219,7 +216,7 @@ def create_tarfile(env, compression_level='9'):
     print('Compressing archive...')
     ans = f'{dist.rpartition(".")[0]}.txz'
     start_time = time.time()
-    subprocess.check_call(['xz', '--threads=0', '-f', f'-{compression_level}', dist])
+    subprocess.check_call(['xz', '--verbose', '--threads=0', '-f', f'-{compression_level}', dist])
     secs = time.time() - start_time
     print('Compressed in {} minutes {} seconds'.format(secs // 60, secs % 60))
     os.rename(f'{dist}.xz', ans)
@@ -237,10 +234,12 @@ def main():
     files = find_binaries(env)
     fix_permissions(files)
     add_ca_certs(env)
+    kitty_exe = os.path.join(env.base, 'bin', 'kitty')
+    iv['build_frozen_tools'](kitty_exe)
     if not args.dont_strip:
         strip_binaries(files)
     if not args.skip_tests:
-        iv['run_tests'](os.path.join(env.base, 'bin', 'kitty'))
+        iv['run_tests'](kitty_exe)
     create_tarfile(env, args.compression_level)
 
 

bypy/macos.conf

@@ -1,4 +1,4 @@
-# Requires installation of XCode 10.3 and Python 3 and
+# Requires installation of XCode 10.3 and go 1.19 and Python 3 and
 # python3 -m pip install certifi
 
 vm_name 'macos-kitty'

bypy/macos/__main__.py

@@ -13,16 +13,9 @@ import tempfile
 import zipfile
 
 from bypy.constants import PREFIX, PYTHON, SW, python_major_minor_version
-from bypy.freeze import (
-    extract_extension_modules, freeze_python, path_to_freeze_dir
-)
-from bypy.macos_sign import (
-    codesign, create_entitlements_file, make_certificate_useable, notarize_app,
-    verify_signature
-)
-from bypy.utils import (
-    current_dir, mkdtemp, py_compile, run_shell, timeit, walk
-)
+from bypy.freeze import extract_extension_modules, freeze_python, path_to_freeze_dir
+from bypy.macos_sign import codesign, create_entitlements_file, make_certificate_useable, notarize_app, verify_signature
+from bypy.utils import current_dir, mkdtemp, py_compile, run_shell, timeit, walk
 
 iv = globals()['init_env']
 kitty_constants = iv['kitty_constants']
@@ -113,6 +106,9 @@ def do_sign(app_dir):
             codesign(fw)
             items = set(os.listdir('.')) - fw
             codesign(expand_dirs(items))
+        # Sign kitten
+        with current_dir('MacOS'):
+            codesign('kitten')
 
     # Now sign the main app
     codesign(app_dir)
@@ -171,6 +167,7 @@ class Freeze(object):
         self.add_misc_libraries()
         self.freeze_python()
         self.add_ca_certs()
+        self.build_frozen_tools()
         if not self.dont_strip:
             self.strip_files()
         if not self.skip_tests:
@@ -369,6 +366,7 @@ class Freeze(object):
             iv['sanitize_source_folder'](join(self.python_stdlib, x))
         self.compile_py_modules()
         freeze_python(self.python_stdlib, pdir, self.obj_dir, ext_map, develop_mode_env_var='KITTY_DEVELOP_FROM', remove_pyc_files=True)
+        shutil.rmtree(self.python_stdlib)
         iv['build_frozen_launcher']([path_to_freeze_dir(), self.obj_dir])
         os.rename(join(dirname(self.contents_dir), 'bin', 'kitty'), join(self.contents_dir, 'MacOS', 'kitty'))
         shutil.rmtree(join(dirname(self.contents_dir), 'bin'))
@@ -377,6 +375,10 @@ class Freeze(object):
             if f.endswith('.so') or f.endswith('.dylib'):
                 self.fix_dependencies_in_lib(f)
 
+    @flush
+    def build_frozen_tools(self):
+        iv['build_frozen_tools'](join(self.contents_dir, 'MacOS', 'kitty'))
+
     @flush
     def add_site_packages(self):
         print('\nAdding site-packages')

bypy/rsync.conf

@@ -1 +1 @@
-to_vm_excludes '/build /dist /kitty/launcher/kitty /.build-cache /tags __pycache__ /*_commands.json *.so *.pyd *.pyc'
+to_vm_excludes '/build /dist /kitty/launcher/kitty* /.build-cache /tags __pycache__ /*_commands.json *.so *.pyd *.pyc *_generated.go'

bypy/sources.json

@@ -2,8 +2,8 @@
     {
         "name": "zlib",
         "unix": {
-            "filename": "zlib-1.2.11.tar.xz",
-            "hash": "sha256:4ff941449631ace0d4d203e3483be9dbc9da454084111f97ea0a2114e19bf066",
+            "filename": "zlib-1.2.13.tar.xz",
+            "hash": "sha256:d14c38e313afc35a9a8760dadf26042f51ea0f5d154b0630a31da0540107fb98",
             "urls": ["https://zlib.net/{filename}"]
         }
     },

count-lines-of-code

@@ -21,10 +21,17 @@ kitty/options/parse.py
 kitty/options/to-c-generated.h
 kittens/diff/options/types.py
 kittens/diff/options/parse.py
+tools/wcswidth/std.go
 '''
 
+ignored = []
+for line in subprocess.check_output(['git', 'status', '--ignored', '--porcelain']).decode().splitlines():
+    if line.startswith('!! '):
+        ignored.append(line[3:])
+files_to_exclude += '\n'.join(ignored)
+
 p = subprocess.Popen([
-    'cloc', '--exclude-list-file', '/dev/stdin', 'kitty', 'kittens'
+    'cloc', '--exclude-list-file', '/dev/stdin', 'kitty', 'kittens', 'tools',
 ], stdin=subprocess.PIPE)
 p.communicate(files_to_exclude.encode('utf-8'))
 raise SystemExit(p.wait())

docs/_static/custom.css

@@ -10,7 +10,7 @@
 }
 
 .sidebar-logo {
-    max-height: 128px;
+    height: 128px;
 }
 
 .major-features li {

docs/_templates/base.html

@@ -4,18 +4,14 @@
   {{ super() }}
 
   {%- if analytics_id %}
-      <script type="text/javascript">
-      var _gaq = _gaq || [];
-      _gaq.push(['_setAccount', '{{ analytics_id }}']);
-      _gaq.push(['_setDomainName', 'none']);
-      _gaq.push(['_setAllowLinker', true]);
-      _gaq.push(['_trackPageview']);
+  <!-- Global site tag (gtag.js) - Google Analytics -->
+    <script async src="https://www.googletagmanager.com/gtag/js?id={{ analytics_id }}"></script>
+    <script>
+        window.dataLayer = window.dataLayer || [];
+        function gtag(){dataLayer.push(arguments);}
+        gtag('js', new Date());
 
-      (function() {
-        var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
-        ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
-        var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
-      })();
+        gtag('config', '{{ analytics_id }}');
     </script>
   {% endif -%}
 

docs/basic.rst

@@ -27,6 +27,11 @@ Browse scrollback in less   :sc:`show_scrollback`
 Browse last cmd output      :sc:`show_last_command_output` (see :ref:`shell_integration`)
 =========================   =======================
 
+The scroll actions only take effect when the terminal is in the main screen.
+When the alternate screen is active (for example when using a full screen
+program like an editor) the key events are instead passed to program running in the
+terminal.
+
 Tabs
 ~~~~~~~~~~~
 
@@ -123,6 +128,7 @@ The full list of actions that can be mapped to key presses is available
 ==================================  =======================
 Action                              Shortcut
 ==================================  =======================
+Show this help                      :sc:`show_kitty_doc`
 Copy to clipboard                   :sc:`copy_to_clipboard` (also :kbd:`⌘+c` on macOS)
 Paste from clipboard                :sc:`paste_from_clipboard` (also :kbd:`⌘+v` on macOS)
 Paste from selection                :sc:`paste_from_selection`

docs/binary.rst

@@ -22,7 +22,8 @@ simply re-run the command.
 .. warning::
    **Do not** copy the kitty binary out of the installation folder. If you want
    to add it to your :envvar:`PATH`, create a symlink in :file:`~/.local/bin` or
-   :file:`/usr/bin` or wherever.
+   :file:`/usr/bin` or wherever. You should create a symlink for the :file:`kitten`
+   binary as well.
 
 
 Manually installing
@@ -46,9 +47,9 @@ particular desktop, but it should work for most major desktop environments.
 
 .. code-block:: sh
 
-    # Create a symbolic link to add kitty to PATH (assuming ~/.local/bin is in
+    # Create symbolic links to add kitty and kitten to PATH (assuming ~/.local/bin is in
     # your system-wide PATH)
-    ln -s ~/.local/kitty.app/bin/kitty ~/.local/bin/
+    ln -sf ~/.local/kitty.app/bin/kitty ~/.local/kitty.app/bin/kitten ~/.local/bin/
     # Place the kitty.desktop file somewhere it can be found by the OS
     cp ~/.local/kitty.app/share/applications/kitty.desktop ~/.local/share/applications/
     # If you want to open text files and images in kitty via your file manager also add the kitty-open.desktop file
@@ -85,7 +86,7 @@ Customizing the installation
 
   .. code-block:: sh
 
-     _kitty_install_cmd \\
+     _kitty_install_cmd \
          installer=nightly
 
   If you want to install it in parallel to the released kitty specify a
@@ -93,14 +94,14 @@ Customizing the installation
 
   .. code-block:: sh
 
-     _kitty_install_cmd \\
+     _kitty_install_cmd \
          installer=nightly dest=/some/other/location
 
 * You can specify a different install location, with ``dest``:
 
   .. code-block:: sh
 
-     _kitty_install_cmd \\
+     _kitty_install_cmd \
          dest=/some/other/location
 
 * You can tell the installer not to launch |kitty| after installing it with
@@ -108,14 +109,14 @@ Customizing the installation
 
   .. code-block:: sh
 
-     _kitty_install_cmd \\
+     _kitty_install_cmd \
          launch=n
 
 * You can use a previously downloaded dmg/tarball, with ``installer``:
 
   .. code-block:: sh
 
-     _kitty_install_cmd \\
+     _kitty_install_cmd \
          installer=/path/to/dmg or tarball
 
 

docs/build.rst

@@ -29,22 +29,24 @@ Dependencies
 
 Run-time dependencies:
 
-* ``python`` >= 3.6
+* ``python`` >= 3.8
 * ``harfbuzz`` >= 2.2.0
 * ``zlib``
 * ``libpng``
 * ``liblcms2``
 * ``librsync``
+* ``openssl``
 * ``freetype`` (not needed on macOS)
 * ``fontconfig`` (not needed on macOS)
 * ``libcanberra`` (not needed on macOS)
-* ``ImageMagick`` (optional, needed to use the ``kitty +kitten icat`` tool to display images in the terminal)
+* ``ImageMagick`` (optional, needed to display uncommon image formats in the terminal)
 * ``pygments`` (optional, needed for syntax highlighting in ``kitty +kitten diff``)
 
 
 Build-time dependencies:
 
 * ``gcc`` or ``clang``
+* ``go >= 1.20`` (see :file:`go.mod` for go packages used during building)
 * ``pkg-config``
 * For building on Linux in addition to the above dependencies you might also
   need to install the following packages, if they are not already installed by
@@ -82,14 +84,21 @@ You can run |kitty|, as::
 If that works, you can create a symlink to the launcher in :file:`~/bin` or some
 other directory on your PATH so that you can run |kitty| using just ``kitty``.
 
+To have the kitty documentation available locally, run::
+
+    python3 -m pip install -r docs/requirements.txt && make docs
+
 
 Building kitty.app on macOS from source
 -------------------------------------------
 
 Run::
 
+    python3 -m pip install -r docs/requirements.txt && make docs
     make app
 
+Building the docs needs to be done only once.
+
 This :file:`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.
@@ -152,7 +161,7 @@ While |kitty| does use Python, it is not a traditional Python package, so please
 do not install it in site-packages.
 Instead run::
 
-    python3 setup.py linux-package
+    make linux-package
 
 This will install |kitty| into the directory :file:`linux-package`. You can run
 |kitty| with :file:`linux-package/bin/kitty`. All the files needed to run kitty
@@ -175,8 +184,11 @@ You should probably split |kitty| into three packages:
 :code:`kitty`
     Installs the main program
 
-This allows users to install the terminfo and shell integration files on servers
-into which they ssh, without needing to install all of |kitty|.
+This allows users to install the terminfo and shell integration files on
+servers into which they ssh, without needing to install all of |kitty|. The
+shell integration files **must** still be present in
+:file:`lib/kitty/shell-integration` when installing the kitty main package as
+the kitty program expects to find them there.
 
 .. note::
    You need a couple of extra dependencies to build linux-package. :file:`tic`

docs/changelog.rst

@@ -16,6 +16,7 @@ The :doc:`ssh kitten <kittens/ssh>` is redesigned with powerful new features:
 
 * Automatic :ref:`shell_integration` on remote machines
 * Easily :ref:`clone local shell/editor config <real_world_ssh_kitten_config>` on remote machines
+* Easily :ref:`edit files in your local editor <edit_file>` on remote machines
 * Automatic :opt:`re-use of existing connections <kitten-ssh.share_connections>` to avoid connection setup latency
 
 
@@ -34,6 +35,310 @@ mouse anywhere in the current command to move the cursor there. See
 Detailed list of changes
 -------------------------------------
 
+0.27.1 [2023-02-07]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+- Fix :opt:`modify_font` not working for strikethrough position (:iss:`5946`)
+
+- Fix a regression causing the ``edit-in-kitty`` command not working if :file:`kitten` is not added
+  to PATH (:iss:`5956`)
+
+- icat kitten: Fix a regression that broke display of animated GIFs over SSH (:iss:`5958`)
+
+- Wayland GNOME: Fix for ibus not working when using XWayland (:iss:`5967`)
+
+- Fix regression in previous release that caused incorrect entries in terminfo for modifier+F3 key combinations (:pull:`5970`)
+
+- Bring back the deprecated and removed ``kitty +complete`` and delegate it to :program:`kitten` for backward compatibility (:pull:`5977`)
+
+- Bump the version of Go needed to build kitty to ``1.20`` so we can use the Go stdlib ecdh package for crypto.
+
+
+0.27.0 [2023-01-31]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+- A new statically compiled, standalone executable, ``kitten`` (written in Go)
+  that can be used on all UNIX-like servers for remote control (``kitten @``),
+  viewing images (``kitten icat``), manipulating the clipboard (``kitten clipboard``), etc.
+
+- :doc:`clipboard kitten </kittens/clipboard>`: Allow copying arbitrary data types to/from the clipboard, not just plain text
+
+- Speed up the ``kitty @`` executable by ~10x reducing the time for typical
+  remote control commands from ~50ms to ~5ms
+
+- icat kitten: Speed up by using POSIX shared memory when possible to transfer
+  image data to the terminal. Also support common image formats
+  GIF/PNG/JPEG/WEBP/TIFF/BMP out of the box without needing ImageMagick.
+
+- Option :opt:`show_hyperlink_targets` to show the target of terminal hyperlinks when hovering over them with the mouse (:pull:`5830`)
+
+- Keyboard protocol: Remove ``CSI R`` from the allowed encodings of the :kbd:`F3` key as it conflicts with the *Cursor Position Report* escape code (:disc:`5813`)
+
+- Allow using the cwd of the original process for :option:`launch --cwd` (:iss:`5672`)
+
+- Session files: Expand environment variables (:disc:`5917`)
+
+- Pass key events mapped to scroll actions to the program running in the terminal when the terminal is in alternate screen mode (:iss:`5839`)
+
+- Implement :ref:`edit-in-kitty <edit_file>` using the new ``kitten`` static executable (:iss:`5546`, :iss:`5630`)
+
+- Add an option :opt:`background_tint_gaps` to control background image tinting for window gaps (:iss:`5596`)
+
+- A new option :opt:`undercurl_style` to control the rendering of undercurls (:pull:`5883`)
+
+- Bash integration: Fix ``clone-in-kitty`` not working on bash >= 5.2 if environment variable values contain newlines or other special characters (:iss:`5629`)
+
+- A new :ac:`sleep` action useful in combine based mappings to make kitty sleep before executing the next action
+
+- Wayland GNOME: Workaround for latest mutter release breaking full screen for semi-transparent kitty windows (:iss:`5677`)
+
+- A new option :opt:`tab_title_max_length` to limit the length of tab (:iss:`5718`)
+
+- When drawing the tab bar have the default left and right margins drawn in a color matching the neighboring tab (:iss:`5719`)
+
+- When using the :code:`include` directive in :file:`kitty.conf` make the environment variable :envvar:`KITTY_OS` available for OS specific config
+
+- Wayland: Fix signal handling not working with some GPU drivers (:iss:`4636`)
+
+- Remote control: When matching windows allow using negative id numbers to match recently created windows (:iss:`5753`)
+
+- ZSH Integration: Bind :kbd:`alt+left` and :kbd:`alt+right` to move by word if not already bound. This mimics the default bindings in Terminal.app (:iss:`5793`)
+
+- macOS: Allow to customize :sc:`Hide <hide_macos_app>`, :sc:`Hide Others <hide_macos_other_apps>`, :sc:`Minimize <minimize_macos_window>`, and :sc:`Quit <quit>` global menu shortcuts. Note that :opt:`clear_all_shortcuts` will remove these shortcuts now (:iss:`948`)
+
+- When a multi-key sequence does not match any action, send all key events to the child program (:pull:`5841`)
+
+- broadcast kitten: Allow pressing a key to stop echoing of input into the broadcast window itself (:disc:`5868`)
+
+- When reporting unused activity in a window, ignore activity that occurs soon after a window resize (:iss:`5881`)
+
+- Fix using :opt:`cursor` = ``none`` not working on text that has reverse video (:iss:`5897`)
+
+- Fix ssh kitten not working on FreeBSD (:iss:`5928`)
+
+- macOS: Export kitty selected text to the system for use with services that accept it (patch by Sertaç Ö. Yıldız)
+
+
+0.26.5 [2022-11-07]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+- Splits layout: Add a new mappable action to move the active window to the screen edge (:iss:`5643`)
+
+- ssh kitten: Allow using absolute paths for the location of transferred data (:iss:`5607`)
+
+- Fix a regression in the previous release that caused a :opt:`resize_draw_strategy` of ``static`` to not work (:iss:`5601`)
+
+- Wayland KDE: Fix abort when pasting into Firefox (:iss:`5603`)
+
+- Wayland GNOME: Fix ghosting when using :opt:`background_tint` (:iss:`5605`)
+
+- Fix cursor position at x=0 changing to x=1 on resize (:iss:`5635`)
+
+- Wayland GNOME: Fix incorrect window size in some circumstances when switching between windows with window decorations disabled (:iss:`4802`)
+
+- Wayland: Fix high CPU usage when using some input methods (:pull:`5369`)
+
+- Remote control: When matching window by `state:focused` and no window currently has keyboard focus, match the window belonging to the OS window that was last focused (:iss:`5602`)
+
+
+0.26.4 [2022-10-17]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+- macOS: Allow changing the kitty icon by placing a custom icon in the kitty config folder (:pull:`5464`)
+
+- Allow centering the :opt:`background_image` (:iss:`5525`)
+
+- X11: Fix a regression in the previous release that caused pasting from GTK based applications to have extra newlines (:iss:`5528`)
+
+- Tab bar: Improve empty space management when some tabs have short titles, allocate the saved space to the active tab (:iss:`5548`)
+
+- Fix :opt:`background_tint` not applying to window margins and padding (:iss:`3933`)
+
+- Wayland: Fix background image scaling using tiled mode on high DPI screens
+
+- Wayland: Fix an abort when changing background colors with :opt:`wayland_titlebar_color` set to ``background`` (:iss:`5562`)
+
+- Update to Unicode 15.0 (:pull:`5542`)
+
+- GNOME Wayland: Fix a memory leak in gnome-shell when using client side decorations
+
+
+0.26.3 [2022-09-22]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+- Wayland: Mark windows in which a bell occurs as urgent on compositors that support the xdg-activation protocol
+
+- Allow passing null bytes through the system clipboard (:iss:`5483`)
+
+- ssh kitten: Fix :envvar:`KITTY_PUBLIC_KEY` not being encoded properly when transmitting (:iss:`5496`)
+
+- Sessions: Allow controlling which OS Window is active via the ``focus_os_window`` directive
+
+- Wayland: Fix for bug in NVIDIA drivers that prevents transparency working (:iss:`5479`)
+
+- Wayland: Fix for a bug that could cause kitty to become non-responsive when
+  using multiple OS windows in a single instance on some compositors (:iss:`5495`)
+
+- Wayland: Fix for a bug preventing kitty from starting on Hyprland when using a non-unit scale (:iss:`5467`)
+
+- Wayland: Generate a XDG_ACTIVATION_TOKEN when opening URLs or running programs in the background via the launch action
+
+- Fix a regression that caused kitty not to restore SIGPIPE after python nukes it when launching children. Affects bash which does not sanitize its signal mask. (:iss:`5500`)
+
+- Fix a use-after-free when handling fake mouse clicks and the action causes windows to be removed/re-allocated (:iss:`5506`)
+
+
+0.26.2 [2022-09-05]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+- Allow creating :code:`overlay-main` windows, which are treated as the active window unlike normal overlays (:iss:`5392`)
+
+- hints kitten: Allow using :doc:`launch` as the program to run, to open the result in a new kitty tab/window/etc. (:iss:`5462`)
+
+- hyperlinked_grep kitten: Allow control over which parts of ``rg`` output are hyperlinked (:pull:`5428`)
+
+- Fix regression in 0.26.0 that caused launching kitty without working STDIO handles to result in high CPU usage and prewarming failing (:iss:`5444`)
+
+- :doc:`/launch`: Allow setting the margin and padding for newly created windows (:iss:`5463`)
+
+- macOS: Fix regression in 0.26.0 that caused asking the user for a line of input such as for :ac:`set_tab_title` to not work (:iss:`5447`)
+
+- hints kitten: hyperlink matching: Fix hints occasionally matching text on subsequent line as part of hyperlink (:pull:`5450`)
+
+- Fix a regression in 0.26.0 that broke mapping of native keys whose key codes did not fit in 21 bits (:iss:`5452`)
+
+- Wayland: Fix remembering window size not accurate when client side decorations are present
+
+- Fix an issue where notification identifiers were not sanitized leading to
+  code execution if the user clicked on a notification popup from a malicious
+  source. Thanks to Carter Sande for discovering this vulnerability.
+
+
+0.26.1 [2022-08-30]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+- ssh kitten: Fix executable permission missing from kitty bootstrap script (:iss:`5438`)
+
+- Fix a regression in 0.26.0 that caused kitty to no longer set the ``LANG`` environment variable on macOS (:iss:`5439`)
+
+- Allow specifying a title when using the :ac:`set_tab_title` action (:iss:`5441`)
+
+
+0.26.0 [2022-08-29]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+- A new option :opt:`remote_control_password` to use fine grained permissions for what can be remote controlled (:disc:`5320`)
+
+- Reduce startup latency by ~30 milliseconds when running kittens via key bindings inside kitty (:iss:`5159`)
+
+- A new option :opt:`modify_font` to adjust various font metrics like underlines, cell sizes etc. (:pull:`5265`)
+
+- A new shortcut :sc:`show_kitty_doc` to display the kitty docs in a browser
+
+- Graphics protocol: Only delete temp files if they have the string
+  :code:`tty-graphics-protocol` in their file paths. This prevents deletion of arbitrary files in :file:`/tmp`.
+
+- Deprecate the ``adjust_baseline``, ``adjust_line_height`` and ``adjust_column_width`` options in favor of :opt:`modify_font`
+
+- Wayland: Fix a regression in the previous release that caused mouse cursor
+  animation and keyboard repeat to stop working when switching seats (:iss:`5188`)
+
+- Allow resizing windows created in session files (:pull:`5196`)
+
+- Fix horizontal wheel events not being reported to client programs when they grab the mouse (:iss:`2819`)
+
+- macOS: Remote control: Fix unable to launch a new OS window or background process when there is no OS window (:iss:`5210`)
+
+- macOS: Fix unable to open new tab or new window when there is no OS window (:iss:`5276`)
+
+- kitty @ set-colors: Fix changing inactive_tab_foreground not working (:iss:`5214`)
+
+- macOS: Fix a regression that caused switching keyboard input using Eisu and
+  Kana keys not working (:iss:`5232`)
+
+- Add a mappable action to toggle the mirrored setting for the tall and fat
+  layouts (:pull:`5344`)
+
+- Add a mappable action to switch between predefined bias values for the tall and fat
+  layouts (:pull:`5352`)
+
+- Wayland: Reduce flicker at startup by not using render frames immediately after a resize (:iss:`5235`)
+
+- Linux: Update cursor position after all key presses not just pre-edit text
+  changes (:iss:`5241`)
+
+- ssh kitten: Allow ssh kitten to work from inside tmux, provided the tmux
+  session inherits the correct KITTY env vars (:iss:`5227`)
+
+- ssh kitten: A new option :code:`--symlink-strategy` to control how symlinks
+  are copied to the remote machine (:iss:`5249`)
+
+- ssh kitten: Allow pressing :kbd:`Ctrl+C` to abort ssh before the connection is
+  completed (:iss:`5271`)
+
+- Bash integration: Fix declare not creating global variables in .bashrc (:iss:`5254`)
+
+- Bash integration: Fix the inherit_errexit option being set by shell integration (:iss:`5349`)
+
+- :command:`kitty @ scroll-window` allow scrolling by fractions of a screen
+  (:iss:`5294`)
+
+- remote files kitten: Fix working with files whose names have characters that
+  need to be quoted in shell scripts (:iss:`5313`)
+
+- Expand ~ in paths configured in :opt:`editor` and :opt:`exe_search_path` (:disc:`5298`)
+
+- Allow showing the working directory of the active window in tab titles
+  (:pull:`5314`)
+
+- ssh kitten: Allow completion of ssh options between the destination and command (:iss:`5322`)
+
+- macOS: Fix speaking selected text not working (:iss:`5357`)
+
+- Allow ignoring failure to close windows/tabs via rc commands (:disc:`5406`)
+
+- Fix hyperlinks not present when fetching text from the history buffer
+  (:iss:`5427`)
+
+
+0.25.2 [2022-06-07]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+- A new command :command:`edit-in-kitty` to :ref:`edit_file`
+
+- Allow getting the last non-empty command output easily via an action or
+  remote control (:pull:`4973`)
+
+- Fix a bug that caused :opt:`macos_colorspace` to always be ``default`` regardless of its actual value (:iss:`5129`)
+
+- diff kitten: A new option :opt:`kitten-diff.ignore_name` to exclude files and directories from being scanned (:pull:`5171`)
+
+- ssh kitten: Fix bash not being executed as a login shell since kitty 0.25.0 (:iss:`5130`)
+
+- macOS: When pasting text and the clipboard has a filesystem path, paste the
+  full path instead of the text, which is sometimes just the file name (:pull:`5142`)
+
+- macOS: Allow opening executables without a file extension with kitty as well
+  (:iss:`5160`)
+
+- Themes kitten: Add a tab to show user defined custom color themes separately
+  (:pull:`5150`)
+
+- Iosevka: Fix incorrect rendering when there is a combining char that does not
+  group with its neighbors (:iss:`5153`)
+
+- Weston: Fix client side decorations flickering on slow computers during
+  window resize (:iss:`5162`)
+
+- Remote control: Fix commands with large or asynchronous payloads like
+  :command:`kitty @ set-backround-image`, :command:`kitty @ set-window-logo`
+  and :command:`kitty @ select-window` not working correctly
+  when using a socket (:iss:`5165`)
+
+- hints kitten: Fix surrounding quotes/brackets and embedded carriage returns
+  not being removed when using line number processing (:iss:`5170`)
+
+
 0.25.1 [2022-05-26]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -648,7 +953,7 @@ Detailed list of changes
 0.21.2 [2021-06-28]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-- A new :opt:`adjust_baseline` option to adjust the vertical alignment of text
+- A new ``adjust_baseline`` option to adjust the vertical alignment of text
   inside a line (:pull:`3734`)
 
 - A new :opt:`url_excluded_characters` option to exclude additional characters
@@ -822,7 +1127,7 @@ Detailed list of changes
   scrollback buffer onto the screen. Useful, for example, to restore
   the screen after showing completions below the shell prompt.
 
-- A new remote control command :ref:`at_env` to change the default
+- A new remote control command :ref:`at-env` to change the default
   environment passed to newly created windows (:iss:`3529`)
 
 - Linux: Fix binary kitty builds not able to load fonts in WOFF2 format
@@ -847,7 +1152,7 @@ Detailed list of changes
   kitty window title bar
 
 - Fix reading :option:`kitty --session` from ``STDIN`` not working when the
-  :option:`kitty --detach` option is used (:iss:`3523`)
+  :code:`kitty --detach` option is used (:iss:`3523`)
 
 - Special case rendering of the few remaining Powerline box drawing chars
   (:iss:`3535`)
@@ -1405,6 +1710,7 @@ Detailed list of changes
 
 - Fix :option:`--title` not being applied at window creation time (:iss:`2570`)
 
+
 0.17.2 [2020-03-29]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -1589,6 +1895,7 @@ Detailed list of changes
 - When windows are semi-transparent and all contain graphics, correctly render
   them. (:iss:`2310`)
 
+
 0.15.1 [2019-12-21]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -1697,6 +2004,7 @@ Detailed list of changes
 
 - Use selection foreground color for underlines as well (:iss:`1982`)
 
+
 0.14.4 [2019-08-31]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -1990,7 +2298,7 @@ Detailed list of changes
 - Allow the user to control the resize debounce time via
   :opt:`resize_debounce_time`.
 
-- Remote control: Make the :ref:`at_set-font-size` command more capable.
+- Remote control: Make the :ref:`at-set-font-size` command more capable.
   It can now increment font size and reset it. It also only acts on the
   active top-level window, by default (:iss:`1581`)
 
@@ -2003,6 +2311,7 @@ Detailed list of changes
 - Mouse selection: When extending by word, fix extending selection to non-word
   characters not working well (:iss:`1616`)
 
+
 0.13.3 [2019-01-19]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -2096,6 +2405,7 @@ Detailed list of changes
 - Fix resizing window smaller and then restoring causing some wrapped lines to not
   be properly unwrapped (:iss:`1206`)
 
+
 0.13.0 [2018-12-05]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -2193,6 +2503,7 @@ Detailed list of changes
 - Fix hover detection of URLs not working when hovering over the first colon
   and slash characters in short URLs (:iss:`1201`)
 
+
 0.12.3 [2018-09-29]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -2269,6 +2580,7 @@ Detailed list of changes
 - Fix using :opt:`focus_follows_mouse` causing text selection with the
   mouse to malfunction when using multiple kitty windows (:iss:`1002`)
 
+
 0.12.1 [2018-09-08]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -2299,7 +2611,7 @@ Detailed list of changes
 
 - Fix a regression in 0.12.0 that broke dynamic resizing of layouts (:iss:`860`)
 
-- Wayland: Allow using the :option:`kitty --class` command line flag
+- Wayland: Allow using the :code:`kitty --class` command line flag
   to set the app id (:iss:`862`)
 
 - Add completion of the kitty command for the fish shell (:pull:`829`)
@@ -2312,6 +2624,7 @@ Detailed list of changes
 - macOS: Diff kitten: Fix syntax highlighting not working because of
   a bug in the 0.12.0 macOS package
 
+
 0.12.0 [2018-09-01]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -2342,7 +2655,7 @@ Detailed list of changes
   window is not the active window (:iss:`729`)
 
 - Remote control: Allow changing the current window layout with a new
-  :ref:`at_goto-layout` command (:iss:`845`)
+  :ref:`at-goto-layout` command (:iss:`845`)
 
 - Remote control: Allow matching windows by the environment variables of their
   child process as well
@@ -2822,6 +3135,7 @@ Detailed list of changes
 
 - Fix a crash when getting the contents of the scrollback buffer as text
 
+
 0.8.1 [2018-03-09]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -2899,6 +3213,7 @@ Detailed list of changes
 - Browsing the scrollback buffer now happens in an overlay window instead of a
   new window/tab.
 
+
 0.7.1 [2018-01-31]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

docs/clipboard.rst

@@ -0,0 +1,160 @@
+Copying all data types to the clipboard
+==============================================
+
+There already exists an escape code to allow terminal programs to
+read/write plain text data from the system clipboard, *OSC 52*.
+kitty introduces a more advanced protocol that supports:
+
+* Copy arbitrary data including images, rich text documents, etc.
+* Allow terminals to ask the user for permission to access the clipboard and
+  report permission denied
+
+The escape code is *OSC 5522*, an extension of *OSC 52*. The basic format
+of the escape code is::
+
+    <OSC>5522;metadata;payload<ST>
+
+Here, *metadata* is a colon separated list of key-value pairs and payload is
+base64 encoded data. :code:`OSC` is :code:`<ESC>[`.
+:code:`ST` is the string terminator, :code:`<ESC>\\`.
+
+Reading data from the system clipboard
+----------------------------------------
+
+To read data from the system clipboard, the escape code is::
+
+    <OSC>5522;type=read;<base 64 encoded space separated list of mime types to read><ST>
+
+For example, to read plain text and PNG data, the payload would be::
+
+    text/plain image/png
+
+encoded as base64. To read from the primary selection instead of the
+clipboard, add the key ``loc=primary`` to the metadata section.
+
+To get the list of MIME types available on the clipboard the payload must be
+just a period (``.``), encoded as base64.
+
+The terminal emulator will reply with a sequence of escape codes of the form::
+
+    <OSC>5522;type=read:status=OK<ST>
+    <OSC>5522;type=read:status=DATA:mime=<base 64 encoded mime type>;<base64 encoded data><ST>
+    <OSC>5522;type=read:status=DATA:mime=<base 64 encoded mime type>;<base64 encoded data><ST>
+    .
+    .
+    .
+    <OSC>5522;type=read:status=DONE<ST>
+
+Here, the ``status=DATA`` packets deliver the data (as base64 encoded bytes)
+associated with each MIME type. The terminal emulator should chunk up the data
+for an individual type. A recommended size for each chunk is 4096 bytes. All
+the chunks for a given type must be transmitted sequentially and only once they
+are done the chunks for the next type, if any, should be sent. The end of data
+is indicated by a ``status=DONE`` packet.
+
+If an error occurs, instead of the opening ``status=OK`` packet the terminal
+must send a ``status=ERRORCODE`` packet. The error code must be one of:
+
+``status=ENOSYS``
+    Sent if the requested clipboard type is not available. For example, primary
+    selection is not available on all systems and ``loc=primary`` was used.
+
+``status=EPERM``
+    Sent if permission to read from the clipboard was denied by the system or
+    the user.
+
+``status=EBUSY``
+    Sent if there is some temporary problem, such as multiple clients in a
+    multiplexer trying to access the clipboard simultaneously.
+
+Terminals should ask the user for permission before allowing a read request.
+However, if a read request only wishes to list the available data types on the
+clipboard, it should be allowed without a permission prompt. This is so that
+the user is not presented with a double permission prompt for reading the
+available MIME types and then reading the actual data.
+
+
+Writing data to the system clipboard
+----------------------------------------
+
+To write data to the system clipboard, the terminal programs sends the
+following sequence of packets::
+
+    <OSC>5522;type=write<ST>
+    <OSC>5522;type=wdata:mime=<base64 encoded mime type>;<base 64 encoded chunk of data for this type><ST>
+    <OSC>5522;type=wdata:mime=<base64 encoded mime type>;<base 64 encoded chunk of data for this type><ST>
+    .
+    .
+    .
+    <OSC>5522;type=wdata<ST>
+
+The final packet with no mime and no data indicates end of transmission. The
+data for every MIME type should be split into chunks of no more than 4096
+bytes. All the chunks for a given MIME type must be sent sequentially, before
+sending chunks for the next MIME type. After the transmission is complete, the
+terminal replies with a single packet indicating success::
+
+    <OSC>5522;type=write:status=DONE<ST>
+
+If an error occurs the terminal can, at any time, send an error packet of the
+form::
+
+    <OSC>5522;type=write:status=ERRORCODE<ST>
+
+Here ``ERRORCODE`` must be one of:
+
+``status=EIO``
+    An I/O error occurred while processing the data
+``status=EINVAL``
+    One of the packets was invalid, usually because of invalid base64 encoding.
+``status=ENOSYS``
+    The client asked to write to the primary selection with (``loc=primary``) and that is not
+    available on the system
+``status=EPERM``
+    Sent if permission to write to the clipboard was denied by the system or
+    the user.
+``status=EBUSY``
+    Sent if there is some temporary problem, such as multiple clients in a
+    multiplexer trying to access the clipboard simultaneously.
+
+Once an error occurs, the terminal must ignore all further OSC 5522 write related packets until it
+sees the start of a new write with a ``type=write`` packet.
+
+The client can send to the primary selection instead of the clipboard by adding
+``loc=primary`` to the initial ``type=write`` packet.
+
+Finally, clients have the ability to *alias* MIME types when sending data to
+the clipboard. To do that, the client must send a ``type=walias`` packet of the
+form::
+
+    <OSC>5522;type=walias;mime=<base64 encoded target MIME type>;<base64 encoded, space separated list of aliases><ST>
+
+The effect of an alias is that the system clipboard will make available all the
+aliased MIME types, with the same data as was transmitted for the target MIME
+type. This saves bandwidth, allowing the client to only transmit one copy of
+the data, but create multiple references to it in the system clipboard. Alias
+packets can be sent anytime after the initial write packet and before the end
+of data packet.
+
+
+Support for terminal multiplexers
+------------------------------------
+
+Since this protocol involves two way communication between the terminal
+emulator and the client program, multiplexers need a way to know which window
+to send responses from the terminal to. In order to make this possible, the
+metadata portion of this escape code includes an optional ``id`` field. If
+present the terminal emulator must send it back unchanged with every response.
+Valid ids must include only characters from the set: ``[a-zA-Z0-9-_+.]``. Any
+other characters must be stripped out from the id by the terminal emulator
+before retransmitting it.
+
+Note that when using a terminal multiplexer it is possible for two different
+programs to tread on each others clipboard requests. This is fundamentally
+unavoidable since the system clipboard is a single global shared resource.
+However, there is an additional complication where responses form this protocol
+could get lost if, for instance, multiple write requests are received
+simultaneously. It is up to well designed multiplexers to ensure that only a
+single request is in flight at a time. The multiplexer can abort requests by
+sending back the ``EBUSY`` error code indicating some other window is trying
+to access the clipboard.

docs/conf.py

@@ -13,14 +13,12 @@ import subprocess
 import sys
 import time
 from functools import partial
-from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple
+from typing import Any, Callable, Dict, Iterable, List, Tuple
 
 from docutils import nodes
 from docutils.parsers.rst.roles import set_classes
 from pygments.lexer import RegexLexer, bygroups  # type: ignore
-from pygments.token import (  # type: ignore
-    Comment, Keyword, Literal, Name, Number, String, Whitespace
-)
+from pygments.token import Comment, Keyword, Literal, Name, Number, String, Whitespace  # type: ignore
 from sphinx import addnodes, version_info
 from sphinx.util.logging import getLogger
 
@@ -85,7 +83,7 @@ master_doc = 'index'
 #
 # This is also used if you do content translation via gettext catalogs.
 # Usually you set "language" from the command line for these cases.
-language: Optional[str] = None
+language: str = 'en'
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
@@ -120,10 +118,23 @@ html_title = 'kitty'
 # Theme options are theme-specific and customize the look and feel of a theme
 # further.  For a list of options available for each theme, see the
 # documentation.
-#
+github_icon_path = 'M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36.09 2 .27 1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.013 8.013 0 0 0 16 8c0-4.42-3.58-8-8-8z'  # noqa
+
 html_theme_options: Dict[str, Any] = {
     'sidebar_hide_name': True,
     'navigation_with_keys': True,
+    'footer_icons': [
+        {
+            "name": "GitHub",
+            "url": "https://github.com/kovidgoyal/kitty",
+            "html": f"""
+                <svg stroke="currentColor" fill="currentColor" stroke-width="0" viewBox="0 0 16 16">
+                    <path fill-rule="evenodd" d="{github_icon_path}"></path>
+                </svg>
+            """,
+            "class": "",
+        },
+    ],
 }
 
 
@@ -202,10 +213,10 @@ def commit_role(
 
 # CLI docs {{{
 def write_cli_docs(all_kitten_names: Iterable[str]) -> None:
-    from kitty.cli import option_spec_as_rst
-    from kitty.launch import options_spec as launch_options_spec
     from kittens.ssh.copy import option_text
     from kittens.ssh.options.definition import copy_message
+    from kitty.cli import option_spec_as_rst
+    from kitty.launch import options_spec as launch_options_spec
     with open('generated/ssh-copy.rst', 'w') as f:
         f.write(option_spec_as_rst(
             appname='copy', ospec=option_text, heading_char='^',
@@ -236,12 +247,14 @@ if you specify a program-to-run you can use the special placeholder
         from kitty.rc.base import cli_params_for
         for cmd_name in sorted(all_command_names()):
             func = command_for_name(cmd_name)
-            p(f'.. _at_{func.name}:\n')
+            p(f'.. _at-{func.name}:\n')
             p('kitty @', func.name)
             p('-' * 120)
             p('.. program::', 'kitty @', func.name)
             p('\n\n' + as_rst(*cli_params_for(func)))
     from kittens.runner import get_kitten_cli_docs
+    from kitty.fast_data_types import wrapped_kitten_names
+
     for kitten in all_kitten_names:
         data = get_kitten_cli_docs(kitten)
         if data:
@@ -250,7 +263,11 @@ if you specify a program-to-run you can use the special placeholder
                 p('.. program::', 'kitty +kitten', kitten)
                 p('\nSource code for', kitten)
                 p('-' * 72)
-                p(f'\nThe source code for this kitten is `available on GitHub <https://github.com/kovidgoyal/kitty/tree/master/kittens/{kitten}>`_.')
+                if kitten in wrapped_kitten_names():
+                    scurl = f'https://github.com/kovidgoyal/kitty/tree/master/tools/cmd/{kitten}'
+                else:
+                    scurl = f'https://github.com/kovidgoyal/kitty/tree/master/kittens/{kitten}'
+                p(f'\nThe source code for this kitten is `available on GitHub <{scurl}>`_.')
                 p('\nCommand Line Interface')
                 p('-' * 72)
                 p('\n\n' + option_spec_as_rst(
@@ -261,10 +278,8 @@ if you specify a program-to-run you can use the special placeholder
 
 
 def write_remote_control_protocol_docs() -> None:  # {{{
-    from kitty.rc.base import (
-        RemoteCommand, all_command_names, command_for_name
-    )
-    field_pat = re.compile(r'\s*([a-zA-Z0-9_+]+)\s*:\s*(.+)')
+    from kitty.rc.base import RemoteCommand, all_command_names, command_for_name
+    field_pat = re.compile(r'\s*([^:]+?)\s*:\s*(.+)')
 
     def format_cmd(p: Callable[..., None], name: str, cmd: RemoteCommand) -> None:
         p(name)
@@ -276,7 +291,7 @@ def write_remote_control_protocol_docs() -> None:  # {{{
             if m is None:
                 p(line)
             else:
-                fields.append((m.group(1), m.group(2)))
+                fields.append((m.group(1).split('/')[0], m.group(2)))
         if fields:
             p('\nFields are:\n')
             for (name, desc) in fields:

docs/conf.rst

@@ -27,11 +27,13 @@ line.
 
 .. _include:
 
-You can include secondary config files via the :code:`include` directive.  If
+You can include secondary config files via the :code:`include` directive. If
 you use a relative path for :code:`include`, it is resolved with respect to the
 location of the current config file. Note that environment variables are
 expanded, so :code:`${USER}.conf` becomes :file:`name.conf` if
-:code:`USER=name`. Also, you can use :code:`globinclude` to include files
+:code:`USER=name`. A special environment variable :envvar:`KITTY_OS` is available,
+to detect the operating system. It is ``linux``, ``macos`` or ``bsd``.
+Also, you can use :code:`globinclude` to include files
 matching a shell glob pattern and :code:`envinclude` to include configuration
 from environment variables. For example::
 
@@ -66,6 +68,11 @@ Sample kitty.conf
    pre-existing :file:`kitty.conf`, then that will be used instead, delete it to
    see the sample file.
 
+A default configuration file can also be generated by running::
+
+    kitty +runpy 'from kitty.config import *; print(commented_out_default_config())'
+
+This will print the commented out default config file to :file:`STDOUT`.
 
 All mappable actions
 ------------------------

docs/desktop-notifications.rst

@@ -50,7 +50,8 @@ and the terminal emulator should hold off displaying it. A value of ``1`` means
 the notification is done, and should be displayed. You can specify the title or
 body multiple times and the terminal emulator will concatenate them, thereby
 allowing arbitrarily long text (terminal emulators are free to impose a sensible
-limit to avoid Denial-of-Service attacks).
+limit to avoid Denial-of-Service attacks). The size of the payload must be no
+longer than ``2048`` bytes, *before being encoded*.
 
 Both the ``title`` and ``body`` payloads must be either UTF-8 encoded plain
 text with no embedded escape codes, or UTF-8 text that is Base64 encoded, in

docs/extract-rst-targets.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+# License: GPLv3 Copyright: 2022, Kovid Goyal <kovid at kovidgoyal.net>
+
+import os
+import re
+from typing import Dict, Iterator
+
+tgt_pat = re.compile(r'^.. _(\S+?):$', re.MULTILINE)
+title_pat = re.compile('^(.+)\n[-=^#*]{5,}$', re.MULTILINE)
+
+
+def find_explicit_targets(text: str) -> Iterator[str]:
+    for m in tgt_pat.finditer(text):
+        yield m.group(1)
+
+
+def find_page_title(text: str) -> str:
+    for m in title_pat.finditer(text):
+        return m.group(1)
+    return ''
+
+
+def main() -> Dict[str, Dict[str, str]]:
+    refs = {}
+    docs = {}
+    base = os.path.dirname(os.path.abspath(__file__))
+    for dirpath, dirnames, filenames in os.walk(base):
+        if 'generated' in dirnames:
+            dirnames.remove('generated')
+        for f in filenames:
+            if f.endswith('.rst'):
+                with open(os.path.join(dirpath, f)) as stream:
+                    raw = stream.read()
+                href = os.path.relpath(stream.name, base).replace(os.sep, '/')
+                href = href.rpartition('.')[0] + '/'
+                docs[href.rstrip('/')] = find_page_title(raw)
+                first_line = raw.lstrip('\n').partition('\n')[0]
+                first_target_added = False
+                for explicit_target in find_explicit_targets(raw):
+                    # Shorten the reference link to the top of the page.
+                    # Note that anchor links should still be used in HTML docs
+                    # to allow jumping within the same page.
+                    if not first_target_added:
+                        first_target_added = True
+                        if first_line.startswith(f'.. _{explicit_target}:'):
+                            refs[explicit_target] = href
+                            continue
+                    refs[explicit_target] = href + f'#{explicit_target.replace("_", "-")}'
+    return {'ref': refs, 'doc': docs}
+
+
+if __name__ == '__main__':
+    import json
+    print(json.dumps(main(), indent=2))

docs/faq.rst

@@ -27,96 +27,145 @@ turned off for specific symbols using :opt:`narrow_symbols`.
 Using a color theme with a background color does not work well in vim?
 -----------------------------------------------------------------------
 
-First make sure you have not changed the :envvar:`TERM` environment variable, it
-should be ``xterm-kitty``. vim uses *background color erase* even if the
-terminfo file does not contain the ``bce`` capability. This is a bug in vim. You
-can work around it by adding the following to your vimrc::
+Sadly, vim has very poor out-of-the-box detection for modern terminal features.
+Furthermore, it `recently broke detection even more <https://github.com/vim/vim/issues/11729>`__.
+It kind of, but not really, supports terminfo, except it overrides it with its own hard-coded
+values when it feels like it. Worst of all, it has no ability to detect modern
+features not present in terminfo, at all, even security sensitive ones like
+bracketed paste.
 
+Thankfully, probably as a consequence of this lack of detection, vim allows users to
+configure these low level details. So, to make vim work well with any modern
+terminal, including kitty, add the following to your :file:`~/.vimrc`.
+
+.. code-block:: vim
+
+    " Mouse support
+    set mouse=a
+    set ttymouse=sgr
+    set balloonevalterm
+    " Styled and colored underline support
+    let &t_AU = "\e[58:5:%dm"
+    let &t_8u = "\e[58:2:%lu:%lu:%lum"
+    let &t_Us = "\e[4:2m"
+    let &t_Cs = "\e[4:3m"
+    let &t_ds = "\e[4:4m"
+    let &t_Ds = "\e[4:5m"
+    let &t_Ce = "\e[4:0m"
+    " Strikethrough
+    let &t_Ts = "\e[9m"
+    let &t_Te = "\e[29m"
+    " Truecolor support
+    let &t_8f = "\e[38:2:%lu:%lu:%lum"
+    let &t_8b = "\e[48:2:%lu:%lu:%lum"
+    let &t_RF = "\e]10;?\e\\"
+    let &t_RB = "\e]11;?\e\\"
+    " Bracketed paste
+    let &t_BE = "\e[?2004h"
+    let &t_BD = "\e[?2004l"
+    let &t_PS = "\e[200~"
+    let &t_PE = "\e[201~"
+    " Cursor control
+    let &t_RC = "\e[?12$p"
+    let &t_SH = "\e[%d q"
+    let &t_RS = "\eP$q q\e\\"
+    let &t_SI = "\e[5 q"
+    let &t_SR = "\e[3 q"
+    let &t_EI = "\e[1 q"
+    let &t_VS = "\e[?12l"
+    " Focus tracking
+    let &t_fe = "\e[?1004h"
+    let &t_fd = "\e[?1004l"
+    execute "set <FocusGained>=\<Esc>[I"
+    execute "set <FocusLost>=\<Esc>[O"
+    " Window title
+    let &t_ST = "\e[22;2t"
+    let &t_RT = "\e[23;2t"
+
+    " vim hardcodes background color erase even if the terminfo file does
+    " not contain bce. This causes incorrect background rendering when
+    " using a color theme with a background color in terminals such as
+    " kitty that do not support background color erase.
     let &t_ut=''
 
-See :doc:`here <deccara>` for why |kitty| does not support background color
-erase.
+These settings must be placed **before** setting the ``colorscheme``. It is
+also important that the value of the vim ``term`` variable is not changed
+after these settings.
 
+I get errors about the terminal being unknown or opening the terminal failing or functional keys like arrow keys don't work?
+-------------------------------------------------------------------------------------------------------------------------------
 
-I get errors about the terminal being unknown or opening the terminal failing when SSHing into a different computer?
------------------------------------------------------------------------------------------------------------------------
-
-This happens because the |kitty| terminfo files are not available on the server.
-You can ssh in using the following command which will automatically copy the
-terminfo files to the server::
+These issues all have the same root cause: the kitty terminfo files not being
+available. The most common way this happens is SSHing into a computer that does
+not have the kitty terminfo files. The simplest fix for that is running::
 
     kitty +kitten ssh myserver
 
+It will automatically copy over the terminfo files and also magically enable
+:doc:`shell integration </shell-integration>` on the remote machine.
+
 This :doc:`ssh kitten <kittens/ssh>` takes all the same command line arguments
 as :program:`ssh`, you can alias it to something small in your shell's rc files
 to avoid having to type it each time::
 
     alias s="kitty +kitten ssh"
 
-If the ssh kitten fails, use the following one-liner instead (it is slower as it
-needs to ssh into the server twice, but will work with most servers)::
+If this does not work, see :ref:`manual_terminfo_copy` for alternative ways to
+get the kitty terminfo files onto a remote computer.
 
-    infocmp -a xterm-kitty | ssh myserver tic -x -o \~/.terminfo /dev/stdin
+The next most common reason for this is if you are running commands as root
+using :program:`sudo` or :program:`su`. These programs often filter the
+:envvar:`TERMINFO` environment variable which is what points to the kitty
+terminfo files.
 
-If you are behind a proxy (like Balabit) that prevents this, or :program:`tic`
-comes with macOS that does not support reading from STDIN, you must redirect the
-first command to a file, copy that to the server and run :program:`tic`
-manually. If you connect to a server, embedded or Android system that doesn't
-have :program:`tic`, copy over your local file terminfo to the other system as
-:file:`~/.terminfo/x/xterm-kitty`.
+First, make sure the :envvar:`TERM` is set to ``xterm-kitty`` in the sudo
+environment. By default, it should be automatically copied over.
 
-Really, the correct solution for this is to convince the OpenSSH maintainers to
-have :program:`ssh` do this automatically, if possible, when connecting to a
-server, so that all terminals work transparently.
+If you are using a well maintained Linux distribution, it will have a
+``kitty-terminfo`` package that you can simply install to make the kitty
+terminfo files available system-wide. Then the problem will no longer occur.
 
-If the server is running FreeBSD, or another system that relies on termcap
-rather than terminfo, you will need to convert the terminfo file on your local
-machine by running (on local machine with |kitty|)::
-
-    infocmp -CrT0 xterm-kitty
-
-The output of this command is the termcap description, which should be appended
-to :file:`/usr/share/misc/termcap` on the remote server. Then run the following
-command to apply your change (on the server)::
-
-    cap_mkdb /usr/share/misc/termcap
-
-
-Keys such as arrow keys, backspace, delete, home/end, etc. do not work when using su or sudo?
--------------------------------------------------------------------------------------------------
-
-Make sure the :envvar:`TERM` environment variable, is ``xterm-kitty``.  And
-either the :envvar:`TERMINFO` environment variable points to a directory
-containing :file:`x/xterm-kitty` or that file is under :file:`~/.terminfo/x/`.
-
-For macOS, you may also need to put that file under :file:`~/.terminfo/78/`::
-
-    mkdir -p ~/.terminfo/{78,x}
-    ln -snf ../x/xterm-kitty ~/.terminfo/78/xterm-kitty
-    tic -x -o ~/.terminfo "$KITTY_INSTALLATION_DIR/terminfo/kitty.terminfo"
-
-Note that :program:`sudo` might remove :envvar:`TERMINFO`. Then setting it at
-the shell prompt can be too late, because command line editing may not be
-reinitialized. In that case you can either ask :program:`sudo` to set it or if
-that is not supported, insert an :program:`env` command before starting the
-shell, or, if not possible, after sudo start another shell providing the right
-terminfo path::
-
-    sudo … TERMINFO=$HOME/.terminfo bash -i
-    sudo … env TERMINFO=$HOME/.terminfo bash -i
-    TERMINFO=/home/ORIGINALUSER/.terminfo exec bash -i
-
-You can configure :program:`sudo` to preserve :envvar:`TERMINFO` by running
-``sudo visudo`` and adding the following line::
+Alternately, you can configure :program:`sudo` to preserve :envvar:`TERMINFO`
+by running ``sudo visudo`` and adding the following line::
 
     Defaults env_keep += "TERM TERMINFO"
 
+If none of these are suitable for you, you can run sudo as follows::
+
+    sudo TERMINFO="$TERMINFO" -s -H
+
+This will start a new root shell with the correct :envvar:`TERMINFO` value from your
+current environment copied over.
+
 If you have double width characters in your prompt, you may also need to
 explicitly set a UTF-8 locale, like::
 
     export LANG=en_US.UTF-8 LC_ALL=en_US.UTF-8
 
 
+I cannot use the key combination X in program Y?
+-------------------------------------------------------
+
+First, run::
+
+    kitty +kitten show_key -m kitty
+
+Press the key combination X. If the kitten reports the key press
+that means kitty is correctly sending the key press to terminal programs.
+You need to report the issue to the developer of the terminal program. Most
+likely they have not added support for :doc:`/keyboard-protocol`.
+
+If the kitten does not report it, it means that the key is bound to some action
+in kitty. You can unbind it in :file:`kitty.conf` with:
+
+.. code-block:: conf
+
+   map X no_op
+
+Here X is the keys you press on the keyboard. So for example
+:kbd:`ctrl+shift+1`.
+
+
 How do I change the colors in a running kitty instance?
 ------------------------------------------------------------
 
@@ -132,8 +181,8 @@ You can also define keyboard shortcuts to set colors, for example::
     map f1 set_colors --configured /path/to/some/config/file/colors.conf
 
 Or you can enable :doc:`remote control <remote-control>` for |kitty| and use
-:ref:`at_set-colors`. The shortcut mapping technique has the same syntax as the
-remote control command, for details, see :ref:`at_set-colors`.
+:ref:`at-set-colors`. The shortcut mapping technique has the same syntax as the
+remote control command, for details, see :ref:`at-set-colors`.
 
 To change colors when SSHing into a remote host, use the :opt:`color_scheme
 <kitten-ssh.color_scheme>` setting for the :doc:`ssh kitten <kittens/ssh>`.
@@ -205,13 +254,15 @@ fonts to be freely resizable, so it does not support bitmapped fonts.
 .. note::
    If you are trying to use a font patched with `Nerd Fonts
    <https://nerdfonts.com/>`__ symbols, don't do that as patching destroys
-   fonts. There is no need, simply install the standalone ``Symbols Nerd Font``
+   fonts. There is no need, simply install the standalone ``Symbols Nerd Font Mono``
    (the file :file:`NerdFontsSymbolsOnly.zip` from the `Nerd Fonts releases page
    <https://github.com/ryanoasis/nerd-fonts/releases>`__). kitty should pick up
    symbols from it automatically, and you can tell it to do so explicitly in
    case it doesn't with the :opt:`symbol_map` directive::
 
-        symbol_map U+23FB-U+23FE,U+2665,U+26A1,U+2B58,U+E000-U+E00A,U+E0A0-U+E0A3,U+E0B0-U+E0C8,U+E0CA,U+E0CC-U+E0D2,U+E0D4,U+E200-U+E2A9,U+E300-U+E3E3,U+E5FA-U+E62F,U+E700-U+E7C5,U+F000-U+F2E0,U+F300-U+F31C,U+F400-U+F4A9,U+F500-U+F8FF Symbols Nerd Font
+        # Nerd Fonts v2.2.2
+
+        symbol_map U+23FB-U+23FE,U+2665,U+26A1,U+2B58,U+E000-U+E00A,U+E0A0-U+E0A3,U+E0B0-U+E0C8,U+E0CA,U+E0CC-U+E0D2,U+E0D4,U+E200-U+E2A9,U+E300-U+E3E3,U+E5FA-U+E634,U+E700-U+E7C5,U+EA60-U+EBEB,U+F000-U+F2E0,U+F300-U+F32F,U+F400-U+F4A9,U+F500-U+F8FF Symbols Nerd Font Mono
 
    Those Unicode symbols beyond the ``E000-F8FF`` Unicode private use area are
    not included.
@@ -283,13 +334,40 @@ homepage:
    :target: https://github.com/igrmk/whiskers
    :width: 256
 
-On macOS you can change the icon by following the steps:
+.. image:: https://github.com/samholmes/whiskers/raw/main/whiskers.png
+   :target: https://github.com/samholmes/whiskers
+   :width: 256
+
+On macOS you can put :file:`kitty.app.icns` or :file:`kitty.app.png` in the
+:ref:`kitty configuration directory <confloc>`, and this icon will be applied
+automatically at startup. Unfortunately, Apple's Dock does not change its
+cached icon so the custom icon will revert when kitty is quit. Run the
+following to force the Dock to update its cached icons:
+
+.. code-block:: sh
+
+    rm /var/folders/*/*/*/com.apple.dock.iconcache; killall Dock
+
+If you prefer not to keep a custom icon in the kitty config folder, you can
+also set it with the following command:
+
+.. code-block:: sh
+
+    # Set kitty.icns as the icon for currently running kitty
+    kitty +runpy 'from kitty.fast_data_types import cocoa_set_app_icon; import sys; cocoa_set_app_icon(*sys.argv[1:]); print("OK")' kitty.icns
+
+    # Set the icon for app bundle specified by the path
+    kitty +runpy 'from kitty.fast_data_types import cocoa_set_app_icon; import sys; cocoa_set_app_icon(*sys.argv[1:]); print("OK")' /path/to/icon.png /Applications/kitty.app
+
+You can also change the icon manually by following the steps:
 
 #. Find :file:`kitty.app` in the Applications folder, select it and press :kbd:`⌘+I`
 #. Drag :file:`kitty.icns` onto the application icon in the kitty info pane
-#. Delete the icon cache and restart Dock::
+#. Delete the icon cache and restart Dock:
 
-    $ rm /var/folders/*/*/*/com.apple.dock.iconcache; killall Dock
+.. code-block:: sh
+
+    rm /var/folders/*/*/*/com.apple.dock.iconcache; killall Dock
 
 
 How do I map key presses in kitty to different keys in the terminal program?
@@ -308,7 +386,11 @@ the :sc:`send_text <send_text>` you can use the ``show_key`` kitten. Run::
 Then press the key you want to emulate. Note that this kitten will only show
 keys that actually reach the terminal program, in particular, keys mapped to
 actions in kitty will not be shown. To check those first map them to
-:ac:`no_op`.
+:ac:`no_op`. You can also start a kitty instance without any shortcuts to
+interfere::
+
+    kitty -o clear_all_shortcuts=yes kitty +kitten show_key
+
 
 How do I open a new window or tab with the same working directory as the current window?
 --------------------------------------------------------------------------------------------

docs/glossary.rst

@@ -30,9 +30,14 @@ Glossary
    overlay
       An *overlay window* is a :term:`kitty window <window>` that is placed on
       top of an existing kitty window, entirely covering it. Overlays are used
-      throught kitty, for example, to display the :ref:`the scrollback buffer <scrollback>`,
+      throughout kitty, for example, to display the :ref:`the scrollback buffer <scrollback>`,
       to display :doc:`hints </kittens/hints>`, for :doc:`unicode input
-      </kittens/unicode_input>` etc.
+      </kittens/unicode_input>` etc. Normal overlays are meant for short
+      duration popups and so are not considered the :italic:`active window`
+      when determining the current working directory or getting input text for
+      kittens, launch commands, etc. To create an overlay considered as a
+      :italic:`main window` use the :code:`overlay-main` argument to
+      :doc:`launch`.
 
    hyperlinks
       Terminals can have hyperlinks, just like the internet. In kitty you can
@@ -107,6 +112,11 @@ Variables that influence kitty behavior
    Set this to the directory path of the kitty source code and its Python code
    will be loaded from there. Only works with official binary builds.
 
+.. envvar:: KITTY_RC_PASSWORD
+
+   Set this to a pass phrase to use the ``kitty @`` remote control command with
+   :opt:`remote_control_password`.
+
 
 Variables that kitty sets when running child programs
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -116,53 +126,49 @@ Variables that kitty sets when running child programs
    This is only set on macOS. If the country and language from the macOS user
    settings form an invalid locale, it will be set to :code:`en_US.UTF-8`.
 
-
 .. envvar:: PATH
 
    kitty prepends itself to the PATH of its own environment to ensure the
    functions calling :program:`kitty` will work properly.
 
-
 .. envvar:: KITTY_WINDOW_ID
 
    An integer that is the id for the kitty :term:`window` the program is running in.
    Can be used with the :doc:`kitty remote control facility <remote-control>`.
 
-
 .. envvar:: KITTY_PID
 
    An integer that is the process id for the kitty process in which the program
    is running. Allows programs to tell kitty to reload its config by sending it
    the SIGUSR1 signal.
 
+.. envvar:: KITTY_PUBLIC_KEY
+
+   A public key that programs can use to communicate securely with kitty using
+   the remote control protocol. The format is: :code:`protocol:key data`.
 
 .. envvar:: WINDOWID
 
    The id for the :term:`OS Window <os_window>` the program is running in. Only available
    on platforms that have ids for their windows, such as X11 and macOS.
 
-
 .. envvar:: TERM
 
    The name of the terminal, defaults to ``xterm-kitty``. See :opt:`term`.
 
-
 .. envvar:: TERMINFO
 
    Path to a directory containing the kitty terminfo database.
 
-
 .. envvar:: KITTY_INSTALLATION_DIR
 
    Path to the kitty installation directory.
 
-
 .. envvar:: COLORTERM
 
    Set to the value ``truecolor`` to indicate that kitty supports 16 million
    colors.
 
-
 .. envvar:: KITTY_LISTEN_ON
 
    Set when the :doc:`remote control <remote-control>` facility is enabled and
@@ -170,46 +176,44 @@ Variables that kitty sets when running child programs
    Contains the path to the socket. Avoid the need to use :option:`kitty @ --to` when
    issuing remote control commands.
 
-
 .. envvar:: KITTY_PIPE_DATA
 
    Set to data describing the layout of the screen when running child
    programs using :option:`launch --stdin-source` with the contents of the
    screen/scrollback piped to them.
 
-
 .. envvar:: KITTY_CHILD_CMDLINE
 
    Set to the command line of the child process running in the kitty
    window when calling the notification callback program on terminal bell, see
    :opt:`command_on_bell`.
 
-
 .. envvar:: KITTY_COMMON_OPTS
 
    Set with the values of some common kitty options when running
    kittens, so kittens can use them without needing to load :file:`kitty.conf`.
 
-
 .. envvar:: KITTY_SHELL_INTEGRATION
 
    Set when enabling :ref:`shell_integration`. It is automatically removed by
    the shell integration scripts.
 
-
 .. envvar:: ZDOTDIR
 
    Set when enabling :ref:`shell_integration` with :program:`zsh`, allowing
    :program:`zsh` to automatically load the integration script.
 
-
 .. envvar:: XDG_DATA_DIRS
 
    Set when enabling :ref:`shell_integration` with :program:`fish`, allowing
    :program:`fish` to automatically load the integration script.
 
-
 .. envvar:: ENV
 
    Set when enabling :ref:`shell_integration` with :program:`bash`, allowing
    :program:`bash` to automatically load the integration script.
+
+.. envvar:: KITTY_OS
+
+   Set when using the include directive in kitty.conf. Can take values:
+   ``linux``, ``macos``, ``bsd``.

docs/graphics-protocol.rst

@@ -28,21 +28,22 @@ alpha-blending and text over graphics.
 Some programs and libraries that use the kitty graphics protocol:
 
 * `termpdf.py <https://github.com/dsanson/termpdf.py>`_ - a terminal PDF/DJVU/CBR viewer
-* `ranger <https://github.com/ranger/ranger>`_ - a terminal file manager, with
-  image previews, see this `PR <https://github.com/ranger/ranger/pull/1077>`_
+* `ranger <https://github.com/ranger/ranger>`_ - a terminal file manager, with image previews
 * :doc:`kitty-diff <kittens/diff>` - a side-by-side terminal diff program with support for images
-* `tpix <https://github.com/jesvedberg/tpix>` - a statically compiled binary that can be used to display images and easily installed on remote servers without root access
+* `tpix <https://github.com/jesvedberg/tpix>`_ - a statically compiled binary that can be used to display images and easily installed on remote servers without root access
+* `mpv <https://github.com/mpv-player/mpv/commit/874e28f4a41a916bb567a882063dd2589e9234e1>`_ - A video player that can play videos in the terminal
 * `pixcat <https://github.com/mirukana/pixcat>`_ - a third party CLI and python library that wraps the graphics protocol
 * `neofetch <https://github.com/dylanaraps/neofetch>`_ - A command line system
   information tool
 * `viu <https://github.com/atanunq/viu>`_ - a terminal image viewer
-* `glkitty <https://github.com/michaeljclark/glkitty>`_ - C library to draw OpenGL shaders in the terminal with a glgears demo
 * `ctx.graphics <https://ctx.graphics/>`_ - Library for drawing graphics
 * `timg <https://github.com/hzeller/timg>`_ - a terminal image and video viewer
 * `notcurses <https://github.com/dankamongmen/notcurses>`_ - C library for terminal graphics with bindings for C++, Rust and Python
 * `rasterm <https://github.com/BourgeoisBear/rasterm>`_  - Go library to display images in the terminal
 * `chafa <https://github.com/hpjansson/chafa>`_  - a terminal image viewer
 * `hologram.nvim <https://github.com/edluffy/hologram.nvim>`_  - view images inside nvim
+* `term-image <https://github.com/AnonymouX47/term-image>`_  - A Python library, CLI and TUI to display and browse images in the terminal
+* `glkitty <https://github.com/michaeljclark/glkitty>`_ - C library to draw OpenGL shaders in the terminal with a glgears demo
 
 Other terminals that have implemented the graphics protocol:
 
@@ -87,6 +88,17 @@ code to demonstrate its use
             'number of rows: {} number of columns: {}'
             'screen width: {} screen height: {}').format(*buf))
 
+.. tab:: Go
+
+    .. code-block:: go
+
+        import "golang.org/x/sys/unix"
+        fd, err := unix.Open(fd, unix.O_NOCTTY|unix.O_CLOEXEC|unix.O_NDELAY|unix.O_RDWR, 0666)
+        sz, err := unix.IoctlGetWinsize(fd, unix.TIOCGWINSZ)
+        fmt.Println("rows: %v columns: %v width: %v height %v", sz.Row, sz.Col, sz.Xpixel, sz.Ypixel)
+
+
+
 Note that some terminals return ``0`` for the width and height values. Such
 terminals should be modified to return the correct values.  Examples of
 terminals that return correct values: ``kitty, xterm``
@@ -100,47 +112,71 @@ kitty.
 A minimal example
 ------------------
 
-Some minimal python code to display PNG images in kitty, using the most basic
+Some minimal code to display PNG images in kitty, using the most basic
 features of the graphics protocol:
 
-.. code-block:: python
+.. tab:: Bash
 
-    import sys
-    from base64 import standard_b64encode
+    .. code-block:: sh
+
+        #!/bin/bash
+        transmit_png() {
+            data=$(base64 "$1")
+            data="${data//[[:space:]]}"
+            builtin local pos=0
+            builtin local chunk_size=4096
+            while [ $pos -lt ${#data} ]; do
+                builtin printf "\e_G"
+                [ $pos = "0" ] && printf "a=T,f=100,"
+                builtin local chunk="${data:$pos:$chunk_size}"
+                pos=$(($pos+$chunk_size))
+                [ $pos -lt ${#data} ] && builtin printf "m=1"
+                [ ${#chunk} -gt 0 ] && builtin printf ";%s" "${chunk}"
+                builtin printf "\e\\"
+            done
+        }
+
+        transmit_png "$1"
+
+.. tab:: Python
+
+    .. code-block:: python
+
+        #!/usr/bin/python
+        import sys
+        from base64 import standard_b64encode
+
+        def serialize_gr_command(**cmd):
+            payload = cmd.pop('payload', None)
+            cmd = ','.join(f'{k}={v}' for k, v in cmd.items())
+            ans = []
+            w = ans.append
+            w(b'\033_G'), w(cmd.encode('ascii'))
+            if payload:
+                w(b';')
+                w(payload)
+            w(b'\033\\')
+            return b''.join(ans)
+
+        def write_chunked(**cmd):
+            data = standard_b64encode(cmd.pop('data'))
+            while data:
+                chunk, data = data[:4096], data[4096:]
+                m = 1 if data else 0
+                sys.stdout.buffer.write(serialize_gr_command(payload=chunk, m=m,
+                                                            **cmd))
+                sys.stdout.flush()
+                cmd.clear()
+
+        with open(sys.argv[-1], 'rb') as f:
+            write_chunked(a='T', f=100, data=f.read())
 
 
-    def serialize_gr_command(**cmd):
-        payload = cmd.pop('payload', None)
-        cmd = ','.join(f'{k}={v}' for k, v in cmd.items())
-        ans = []
-        w = ans.append
-        w(b'\033_G'), w(cmd.encode('ascii'))
-        if payload:
-            w(b';')
-            w(payload)
-        w(b'\033\\')
-        return b''.join(ans)
-
-
-    def write_chunked(**cmd):
-        data = standard_b64encode(cmd.pop('data'))
-        while data:
-            chunk, data = data[:4096], data[4096:]
-            m = 1 if data else 0
-            sys.stdout.buffer.write(serialize_gr_command(payload=chunk, m=m,
-                                                        **cmd))
-            sys.stdout.flush()
-            cmd.clear()
-
-
-    with open(sys.argv[-1], 'rb') as f:
-        write_chunked(a='T', f=100, data=f.read())
-
-
-Save this script as :file:`png.py`, then you can use it to display any PNG
+Save this script as :file:`send-png`, then you can use it to display any PNG
 file in kitty as::
 
-   python png.py file.png
+    chmod +x send-png
+    ./send-png file.png
 
 
 The graphics escape code
@@ -236,7 +272,8 @@ Value of `t`          Meaning
                       the terminal emulator should only delete the file if it
                       is in a known temporary directory, such as :file:`/tmp`,
                       :file:`/dev/shm`, :file:`TMPDIR env var if present` and any platform
-                      specific temporary directories.
+                      specific temporary directories and the file has the
+                      string :code:`tty-graphics-protocol` in its full file path.
 ``s``                 A *shared memory object*, which on POSIX systems is a
                       `POSIX shared memory object <https://pubs.opengroup.org/onlinepubs/9699919799/functions/shm_open.html>`_
                       and on Windows is a
@@ -293,12 +330,13 @@ sequence of escape codes to the terminal emulator::
     <ESC>_Gm=0;<encoded pixel data last chunk><ESC>\
 
 Note that only the first escape code needs to have the full set of control
-codes such as width, height, format etc. Subsequent chunks **must** have
-only the ``m`` key. The client **must** finish sending all chunks for a single image
-before sending any other graphics related escape codes. Note that the cursor
-position used to display the image **must** be the position when the final chunk is
-received. Finally, terminals must not display anything, until the entire sequence is
-received and validated.
+codes such as width, height, format, etc. Subsequent chunks **must** have only
+the ``m`` and optionally ``q`` keys. When sending animation frame data, subsequent
+chunks **must** also specify the ``a=f`` key. The client **must** finish sending
+all chunks for a single image before sending any other graphics related escape
+codes. Note that the cursor position used to display the image **must** be the
+position when the final chunk is received. Finally, terminals must not display
+anything, until the entire sequence is received and validated.
 
 
 Querying support and available transmission mediums
@@ -378,7 +416,9 @@ id. To do so add the ``p`` key with a number between ``1`` and ``4294967295``.
 When you specify a placement id, it will be added to the acknowledgement code
 above. Every placement is uniquely identified by the pair of the ``image id``
 and the ``placement id``. If you specify a placement id for an image that does
-not have an id, it will be ignored. An example response::
+not have an id (i.e. has id=0), it will be ignored. In particular this means
+there can exist multiple images with ``image id=0, placement id=0``.
+An example response::
 
     <ESC>_Gi=<image id>,p=<placement id>;OK<ESC>\
 
@@ -415,7 +455,9 @@ they are semi-transparent. You can specify z-index values using the ``z`` key.
 Negative z-index values mean that the images will be drawn under the text. This
 allows rendering of text on top of images. Negative z-index values below
 INT32_MIN/2 (-1,073,741,824) will be drawn under cells with non-default background
-colors.
+colors. If two images with the same z-index overlap then the image with the
+lower id is considered to have the lower z-index. If the images have the same
+z-index and the same id, then the behavior is undefined.
 
 .. note:: After placing an image on the screen the cursor must be moved to the
    right by the number of cols in the image placement rectangle and down by the

docs/integrations.rst

@@ -47,6 +47,12 @@ graphics protocol.
 Another terminal file manager, with previews of file contents powered by kitty's
 graphics protocol.
 
+.. _tool_term_image:
+
+`term-image <https://github.com/AnonymouX47/term-image>`__
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Tool to browse images in a terminal using kitty's graphics protocol.
+
 .. _tool_koneko:
 
 `koneko <https://github.com/twenty5151/koneko>`_
@@ -74,6 +80,12 @@ base application that uses kitty's graphics protocol for images.
 A text mode WWW browser that supports kitty's graphics protocol to display
 images.
 
+.. _tool_mpv:
+
+`mpv <https://github.com/mpv-player/mpv/commit/874e28f4a41a916bb567a882063dd2589e9234e1>`_
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+A video player that can play videos in the terminal.
+
 .. _tool_timg:
 
 `timg <https://github.com/hzeller/timg>`_

docs/keyboard-protocol.rst

@@ -35,9 +35,13 @@ inside the kitty terminal to report key events.
 In addition to kitty, this protocol is also implemented in:
 
 * The `foot terminal <https://codeberg.org/dnkl/foot/issues/319>`__
+* The `WezTerm terminal <https://wezfurlong.org/wezterm/config/lua/config/enable_kitty_keyboard.html>`__
 * The `notcurses library
   <https://github.com/dankamongmen/notcurses/issues/2131>`__
-* The `neovim text editor <https://github.com/neovim/neovim/pull/18181>`__
+* The `crossterm library
+  <https://github.com/crossterm-rs/crossterm/pull/688>`__
+* The `Vim text editor <https://github.com/vim/vim/commit/63a2e360cca2c70ab0a85d14771d3259d4b3aafa>`__
+* The `Neovim text editor <https://github.com/neovim/neovim/pull/18181>`__
 * The `kakoune text editor <https://github.com/mawww/kakoune/issues/4103>`__
 * The `dte text editor <https://gitlab.com/craigbarnes/dte/-/issues/138>`__
 
@@ -57,14 +61,14 @@ without too many changes, do the following:
    that are easy to parse unambiguously.
 #. Emit the escape sequence ``CSI < u`` at application exit if using the main
    screen or just before leaving alternate screen mode if using the alternate screen,
-   to restore the previously used keyboard mode.
+   to restore whatever the keyboard mode was before step 1.
 
 Key events will all be delivered to your application either as plain UTF-8
 text, or using the following escape codes, for those keys that do not produce
 text (``CSI`` is the bytes ``0x1b 0x5b``)::
 
     CSI number ; modifiers [u~]
-    CSI 1; modifiers [ABCDEFHPQRS]
+    CSI 1; modifiers [ABCDEFHPQS]
     0x0d - for the Enter key
     0x7f or 0x08 - for Backspace
     0x09 - for Tab
@@ -79,7 +83,7 @@ The second form is used for a few functional keys, such as the :kbd:`Home`,
 :kbd:`End`, :kbd:`Arrow` keys and :kbd:`F1` ... :kbd:`F4`, they are enumerated in
 the :ref:`functional` table below.  Note that if no modifiers are present the
 parameters are omitted entirely giving an escape code of the form ``CSI
-[ABCDEFHPQRS]``.
+[ABCDEFHPQS]``.
 
 If you want support for more advanced features such as repeat and release
 events, alternate keys for shortcut matching et cetera, these can be turned on
@@ -310,7 +314,7 @@ With this flag turned on, all key events that do not generate text are
 represented in one of the following two forms::
 
     CSI number; modifier u
-    CSI 1; modifier [~ABCDEFHPQRS]
+    CSI 1; modifier [~ABCDEFHPQS]
 
 This makes it very easy to parse key events in an application. In particular,
 :kbd:`ctrl+c` will no longer generate the ``SIGINT`` signal, but instead be
@@ -401,7 +405,7 @@ Legacy functional keys
 These keys are encoded using three schemes::
 
     CSI number ; modifier ~
-    CSI 1 ; modifier {ABCDEFHPQRS}
+    CSI 1 ; modifier {ABCDEFHPQS}
     SS3 {ABCDEFHPQRS}
 
 In the above, if there are no modifiers, the modifier parameter is omitted.
@@ -529,7 +533,7 @@ compatibility reasons.
    "NUM_LOCK", "``57360 u``", "PRINT_SCREEN", "``57361 u``"
    "PAUSE", "``57362 u``", "MENU", "``57363 u``"
    "F1", "``1 P or 11 ~``", "F2", "``1 Q or 12 ~``"
-   "F3", "``1 R or 13 ~``", "F4", "``1 S or 14 ~``"
+   "F3", "``13 ~``", "F4", "``1 S or 14 ~``"
    "F5", "``15 ~``", "F6", "``17 ~``"
    "F7", "``18 ~``", "F8", "``19 ~``"
    "F9", "``20 ~``", "F10", "``21 ~``"
@@ -578,8 +582,14 @@ compatibility reasons.
 .. end functional key table
 .. }}}
 
-Note that the escape codes above of the form ``CSI 1 letter`` will omit the
-``1`` if there are no modifiers, since ``1`` is the default value.
+.. note::
+    The escape codes above of the form ``CSI 1 letter`` will omit the
+    ``1`` if there are no modifiers, since ``1`` is the default value.
+
+.. note::
+   The original version of this specification allowed F3 to be encoded as both
+   CSI R and CSI ~. However, CSI R conflicts with the Cursor Position Report,
+   so it was removed.
 
 .. _ctrl_mapping:
 
@@ -672,3 +682,31 @@ specification.
 * Handwaves that :kbd:`ctrl` *tends to* mask with ``0x1f``. In actual fact it
   does this only for some keys. The action of :kbd:`ctrl` is not specified and
   varies between terminals, historically because of different keyboard layouts.
+
+
+Why xterm's modifyOtherKeys should not be used
+---------------------------------------------------
+
+* Does not support release events
+
+* Does not fix the issue of :kbd:`Esc` key presses not being distinguishable from
+  escape codes.
+
+* Does not fix the issue of some keypresses generating identical bytes and thus
+  being indistinguishable
+
+* There is no robust way to query it or manage its state from a program running
+  in the terminal.
+
+* No support for shifted keys.
+
+* No support for alternate keyboard layouts.
+
+* No support for modifiers beyond the basic four.
+
+* No support for lock keys like Num lock and Caps lock.
+
+* Is completely unspecified. The most discussion of it available anywhere is
+  `here <https://invisible-island.net/xterm/modified-keys.html>`__
+  And it contains no specification of what numbers to assign to what function
+  keys beyond running a Perl script on an X11 system!!

docs/kittens/clipboard.rst

@@ -11,14 +11,46 @@ from the shell. It even works over SSH. Using it is as simple as::
 
     echo hooray | kitty +kitten clipboard
 
-All text received on :file:`stdin` is copied to the clipboard.
+All text received on :file:`STDIN` is copied to the clipboard.
 
-To get text from the clipboard you have to enable reading of the clipboard
-in :opt:`clipboard_control` in :file:`kitty.conf`. Once you do that, you can
-use::
+To get text from the clipboard::
 
     kitty +kitten clipboard --get-clipboard
 
+The text will be written to :file:`STDOUT`. Note that by default kitty asks for
+permission when a program attempts to read the clipboard. This can be
+controlled via :opt:`clipboard_control`.
+
+.. versionadded:: 0.27.0
+   Support for copying arbitrary data types
+
+The clipboard kitten can be used to send/receive
+more than just plain text from the system clipboard. You can transfer arbitrary
+data types. Best illustrated with some examples::
+
+    # Copy an image to the clipboard:
+    kitty +kitten clipboard picture.png
+
+    # Copy an image and some text to the clipboard:
+    kitty +kitten clipboard picture.jpg text.txt
+
+    # Copy text from STDIN and an image to the clipboard:
+    echo hello | kitty +kitten clipboard picture.png /dev/stdin
+
+    # Copy any raster image available on the clipboard to a PNG file:
+    kitty +kitten clipboard -g picture.png
+
+    # Copy an image to a file and text to STDOUT:
+    kitty +kitten clipboard -g picture.png /dev/stdout
+
+    # List the formats available on the system clipboard
+    kitty +kitten clipboard -g -m . /dev/stdout
+
+Normally, the kitten guesses MIME types based on the file names. To control the
+MIME types precisely, use the :option:`--mime <kitty +kitten clipboard --mime>` option.
+
+This kitten uses a new protocol developed by kitty to function, for details,
+see :doc:`/clipboard`.
 
 .. program:: kitty +kitten clipboard
 

docs/kittens/custom.rst

@@ -49,6 +49,24 @@ kittens. Look in the `kittens sub-directory
 code for those. Or see below for a list of :ref:`third-party kittens
 <external_kittens>`, that other kitty users have created.
 
+kitty API to use with kittens
+-------------------------------
+
+Kittens have full access to internal kitty APIs. However these are neither
+entirely stable nor documented. You can instead use the kitty
+:doc:`Remote control API </remote-control>`. Simply call
+:code:`boss.call_remote_control()`, with the same arguments you
+would pass to ``kitty @``. For example:
+
+.. code-block:: python
+
+    def handle_result(args: List[str], answer: str, target_window_id: int, boss: Boss) -> None:
+        # get the kitty window to which to send text
+        w = boss.window_id_map.get(target_window_id)
+        if w is not None:
+            boss.call_remote_control(w, ('send-text', 'hello world'))
+
+
 
 Passing arguments to kittens
 ------------------------------

docs/kittens/hyperlinked_grep.rst

@@ -17,12 +17,12 @@ following contents:
     # by the hyperlink_grep kitten and nothing else so far.
     protocol file
     fragment_matches [0-9]+
-    action launch --type=overlay vim +${FRAGMENT} ${FILE_PATH}
+    action launch --type=overlay --cwd=current vim +${FRAGMENT} ${FILE_PATH}
 
     # Open text files without fragments in the editor
     protocol file
     mime text/*
-    action launch --type=overlay ${EDITOR} ${FILE_PATH}
+    action launch --type=overlay --cwd=current ${EDITOR} ${FILE_PATH}
 
 Now, run a search with::
 
@@ -43,37 +43,19 @@ You can now run searches with::
 
     hg some-search-term
 
-If you want to enable completion, for the kitten, you can delegate completion
-to :program:`rg`. How to do that varies based on the shell:
-
-
-.. tab:: zsh
-
-    Instead of using an alias, create a simple wrapper script named
-    :program:`hg` somewhere in your :envvar:`PATH`:
-
-    .. code-block:: sh
-
-        #!/bin/sh
-        exec kitty +kitten hyperlinked_grep "$@"
-
-    Then, add the following to :file:`.zshrc`::
-
-        compdef _rg hg
-
-.. tab:: fish
-
-    You can combine both the aliasing/wrapping and pointing fish to ripgrep's
-    autocompletion with a fish wrapper function in your :file:`config.fish`
-    or :file:`~/.config/fish/functions/hg.fish`:
-
-    .. code-block:: fish
-
-        function hg --wraps rg; kitty +kitten hyperlinked_grep $argv; end
-
 To learn more about kitty's powerful framework for customizing URL click
 actions, see :doc:`here </open_actions>`.
 
+By default, this kitten adds hyperlinks for several parts of ripgrep output:
+the per-file header, match context lines, and match lines. You can control
+which items are linked with a :code:`--kitten hyperlink` flag. For example,
+:code:`--kitten hyperlink=matching_lines` will only add hyperlinks to the
+match lines. :code:`--kitten hyperlink=file_headers,context_lines` will link
+file headers and context lines but not match lines. :code:`--kitten
+hyperlink=none` will cause the command line to be passed to directly to
+:command:`rg` so no hyperlinking will be performed. :code:`--kitten hyperlink`
+may be specified multiple times.
+
 Hopefully, someday this functionality will make it into some `upstream grep
 <https://github.com/BurntSushi/ripgrep/issues/665>`__ program directly removing
 the need for this kitten.
@@ -83,3 +65,9 @@ the need for this kitten.
    While you can pass any of ripgrep's comand line options to the kitten and
    they will be forwarded to :program:`rg`, do not use options that change the
    output formatting as the kitten works by parsing the output from ripgrep.
+   The unsupported options are: :code:`--context-separator`,
+   :code:`--field-context-separator`, :code:`--field-match-separator`,
+   :code:`--json`, :code:`-I --no-filename`, :code:`-0 --null`,
+   :code:`--null-data`, :code:`--path-separator`. If you specify options via
+   configuration file, then any changes to the default output format will not be
+   supported, not just the ones listed.

docs/kittens/icat.rst

@@ -7,6 +7,7 @@ The ``icat`` kitten can be used to display arbitrary images in the |kitty|
 terminal. Using it is as simple as::
 
     kitty +kitten icat image.jpeg
+    kitten icat image.jpeg
 
 It supports all image types supported by `ImageMagick
 <https://www.imagemagick.org>`__. It even works over SSH. For details, see the
@@ -20,8 +21,9 @@ Then you can simply use ``icat image.png`` to view images.
 
 .. note::
 
-    `ImageMagick <https://www.imagemagick.org>`__ must be installed for icat
-    kitten to work.
+    `ImageMagick <https://www.imagemagick.org>`__ must be installed for the
+    full range of image types. Without it only PNG/JPG/GIF/BMP/TIFF/WEBP are
+    supported.
 
 .. note::
 
@@ -35,16 +37,15 @@ Then you can simply use ``icat image.png`` to view images.
 
 The ``icat`` kitten has various command line arguments to allow it to be used
 from inside other programs to display images. In particular, :option:`--place`,
-:option:`--detect-support`, :option:`--silent` and
-:option:`--print-window-size`.
+:option:`--detect-support` and :option:`--print-window-size`.
 
 If you are trying to integrate icat into a complex program like a file manager
 or editor, there are a few things to keep in mind. icat works by communicating
 over the TTY device, it both writes to and reads from the TTY. So it is
 imperative that while it is running the host program does not do any TTY I/O.
 Any key presses or other input from the user on the TTY device will be
-discarded. At a minimum, you should use the :option:`--silent` and
-:option:`--transfer-mode` command line arguments. To be really robust you should
+discarded. At a minimum, you should use the :option:`--transfer-mode`
+command line arguments. To be really robust you should
 consider writing proper support for the :doc:`kitty graphics protocol
 </graphics-protocol>` in the program instead. Nowadays there are many libraries
 that have support for it.

docs/kittens/remote_file.rst

@@ -22,6 +22,8 @@ transferred to the remote computer. Note that this happens without needing
 to install *any* special software on the server, beyond :program:`ls` that
 supports hyperlinks.
 
+.. seealso:: See the :ref:`edit-in-kitty <edit_file>` command
+
 .. seealso:: See the :doc:`transfer` kitten
 
 .. versionadded:: 0.19.0

docs/kittens/ssh.rst

@@ -143,6 +143,16 @@ transmitted instantly without any roundtrip delay.
    is something POSIX sh compliant, and use :code:`python` as the
    :opt:`interpreter <kitten-ssh.interpreter>` in :file:`ssh.conf`.
 
+
+.. note::
+
+   This may or may not work when using terminal multiplexers, depending on
+   whether they passthrough the escape codes and if the values of the
+   environment variables :envvar:`KITTY_PID` and :envvar:`KITTY_WINDOW_ID` are
+   correct in the current session (they can be wrong when connecting to a tmux
+   session running in a different window) and the ssh kitten is run in the
+   currently active multiplexer window.
+
 .. include:: /generated/conf-kitten-ssh.rst
 
 
@@ -152,3 +162,42 @@ The copy command
 --------------------
 
 .. include:: /generated/ssh-copy.rst
+
+
+.. _manual_terminfo_copy:
+
+Copying terminfo files manually
+-------------------------------------
+
+Sometimes, the ssh kitten can fail, or maybe you dont like to use it. In such
+cases, the terminfo files can be copied over manually to a server with the
+following one liner::
+
+    infocmp -a xterm-kitty | ssh myserver tic -x -o \~/.terminfo /dev/stdin
+
+If you are behind a proxy (like Balabit) that prevents this, or you are SSHing
+into macOS where the :program:`tic` does not support reading from :file:`STDIN`,
+you must redirect the first command to a file, copy that to the server and run :program:`tic`
+manually. If you connect to a server, embedded, or Android system that doesn't
+have :program:`tic`, copy over your local file terminfo to the other system as
+:file:`~/.terminfo/x/xterm-kitty`.
+
+If the server is running a relatively modern Linux distribution and you have
+root access to it, you could simply install the ``kitty-terminfo`` package on
+the server to make the terminfo files available.
+
+Really, the correct solution for this is to convince the OpenSSH maintainers to
+have :program:`ssh` do this automatically, if possible, when connecting to a
+server, so that all terminals work transparently.
+
+If the server is running FreeBSD, or another system that relies on termcap
+rather than terminfo, you will need to convert the terminfo file on your local
+machine by running (on local machine with |kitty|)::
+
+    infocmp -CrT0 xterm-kitty
+
+The output of this command is the termcap description, which should be appended
+to :file:`/usr/share/misc/termcap` on the remote server. Then run the following
+command to apply your change (on the server)::
+
+    cap_mkdb /usr/share/misc/termcap

docs/layouts.rst

@@ -68,11 +68,20 @@ for the options is::
     └──────────────┴───────────────┘
 
 In addition, you can map keys to increase or decrease the number of full-height
-windows, for example::
+windows, or toggle the mirrored setting, for example::
 
    map ctrl+[ layout_action decrease_num_full_size_windows
    map ctrl+] layout_action increase_num_full_size_windows
+   map ctrl+/ layout_action mirror toggle
+   map ctrl+y layout_action mirror true
+   map ctrl+n layout_action mirror false
 
+You can also map a key to change the bias by providing a list of percentages
+and it will rotate through the list as you press the key. If you only provide
+one number it'll toggle between that percentage and 50, for example::
+
+   map ctrl+. layout_action bias 50 62 70
+   map ctrl+, layout_action bias 62
 
 The Fat Layout
 ----------------
@@ -101,8 +110,7 @@ on the bottom of the screen instead of the top. The syntax for the options is::
     └─────────┴──────────┴─────────┘
 
 
-This layout also supports ``decrease_num_full_size_windows`` layout action like
-the *Tall* layout, shown above.
+This layout also supports the same layout actions as the *Tall* layout, shown above.
 
 
 The Grid Layout
@@ -159,6 +167,12 @@ define a few extra key bindings in :file:`kitty.conf`::
     map shift+right move_window right
     map shift+down move_window down
 
+    # Move the active window to the indicated screen edge
+    map ctrl+shift+up layout_action move_to_screen_edge top
+    map ctrl+shift+left layout_action move_to_screen_edge left
+    map ctrl+shift+right layout_action move_to_screen_edge right
+    map ctrl+shift+down layout_action move_to_screen_edge bottom
+
     # Switch focus to the neighboring window in the indicated direction
     map ctrl+left neighboring_window left
     map ctrl+right neighboring_window right

docs/open_actions.rst

@@ -64,6 +64,17 @@ some special variables, documented below:
 ``FRAGMENT``
     The fragment (unquoted), if any of the URL or the empty string.
 
+``URL_PATH``
+    The path, query and fragment portions of the URL, without any
+    unquoting.
+
+``EDITOR``
+    The terminal based text editor. The configured :opt:`editor` in
+    :file:`kitty.conf` is preferred.
+
+``SHELL``
+    The path to the shell. The configured :opt:`shell` in :file:`kitty.conf` is
+    preferred, without arguments.
 
 .. note::
    You can use the :opt:`action_alias` option just as in :file:`kitty.conf` to
@@ -99,7 +110,8 @@ lines. The various available criteria are:
     Useful if your system MIME database does not have definitions you need. This
     file is in the standard format of one definition per line, like:
     ``text/plain rst md``. Note that the MIME type for directories is
-    ``inode/directory``.
+    ``inode/directory``. MIME types are detected based on file extension, not
+    file contents.
 
 ``ext``
     A comma separated list of file extensions, for example: ``jpeg, tar.gz``
@@ -144,33 +156,7 @@ You can customize these actions by creating a :file:`launch-actions.conf` file
 in the :ref:`kitty config directory <confloc>`, just like the
 :file:`open-actions.conf` file above. For example:
 
-.. code:: conf
-
-    # Open script files based on their shebangs
-    protocol file
-    ext sh,command,tool
-    action launch --hold --type=os-window kitty +shebang $FILE_PATH {SHELL}
-
-    # Open shell specific script files
-    protocol file
-    ext fish,bash,zsh
-    action launch --hold --type=os-window kitty +shebang $FILE_PATH __ext__
-
-    # Open directories
-    protocol file
-    mime inode/directory
-    action launch --type=os-window --cwd $FILE_PATH
-
-    # Open text files without fragments in the editor
-    protocol file
-    mime text/*
-    action launch --type=os-window $EDITOR $FILE_PATH
-
-    # Open image files with icat
-    protocol file
-    mime image/*
-    action launch --type=os-window kitty +kitten icat --hold $FILE_PATH
-
-    # Open ssh URLs with ssh command
-    protocol ssh
-    action launch --type=os-window ssh $URL
+.. literalinclude:: ../kitty/open_actions.py
+   :language: conf
+   :start-at: # Open script files
+   :end-before: '''.splitlines()))

docs/overview.rst

@@ -85,7 +85,7 @@ Extending kitty
 ------------------
 
 kitty has a powerful framework for scripting. You can create small terminal
-programs called :doc:`kittens <kittens_intro>`. These can used to add features
+programs called :doc:`kittens <kittens_intro>`. These can be used to add features
 to kitty, for example, :doc:`editing remote files <kittens/remote_file>` or
 :doc:`inputting Unicode characters <kittens/unicode_input>`. They can also be
 used to create programs that leverage kitty's powerful features, for example,
@@ -127,7 +127,7 @@ Startup Sessions
 You can control the :term:`tabs <tab>`, :term:`kitty window <window>` layout,
 working directory, startup programs, etc. by creating a *session* file and using
 the :option:`kitty --session` command line flag or the :opt:`startup_session`
-option in :file:`kitty.conf`. For example:
+option in :file:`kitty.conf`. An example, showing all available commands:
 
 .. code-block:: session
 
@@ -154,21 +154,30 @@ option in :file:`kitty.conf`. For example:
     launch zsh
 
     # Create a new OS window
-    # Any definitions specifed before the first new_os_window will apply to first OS window.
+    # Any definitions specified before the first new_os_window will apply to first OS window.
     new_os_window
     # Set new window size to 80x24 cells
     os_window_size 80c 24c
     # Set the --class for the new OS window
     os_window_class mywindow
     launch sh
-    # Make the current window the active (focused) window
+    # Resize the current window (see the resize_window action for details)
+    resize_window wider 2
+    # Make the current window the active (focused) window in its tab
     focus
+    # Make the current OS Window the globally active window (not supported on Wayland)
+    focus_os_window
     launch emacs
 
 .. note::
     The :doc:`launch <launch>` command when used in a session file cannot create
     new OS windows, or tabs.
 
+.. note::
+   Environment variables of the for :code:`${NAME}` or :code:`$NAME` are
+   expanded in the session file, except in the *arguments* (not options) to the
+   launch command.
+
 
 Creating tabs/windows
 -------------------------------

docs/protocol-extensions.rst

@@ -32,3 +32,4 @@ please do so by opening issues in the `GitHub bug tracker
    unscroll
    color-stack
    deccara
+   clipboard

docs/rc_protocol.rst

@@ -7,13 +7,16 @@ form::
 
     <ESC>P@kitty-cmd<JSON object><ESC>\
 
-Where ``<ESC>`` is the byte ``0x1b``. The JSON object has the form::
+Where ``<ESC>`` is the byte ``0x1b``. The JSON object has the form:
+
+.. code-block:: json
 
     {
         "cmd": "command name",
-        "version": <kitty version>,
-        "no_response": <Optional Boolean>,
-        "payload": <Optional JSON object>,
+        "version": "<kitty version>",
+        "no_response": "<Optional Boolean>",
+        "kitty_window_id": "<Optional value of the KITTY_WINDOW_ID env var>",
+        "payload": "<Optional JSON object>"
     }
 
 The ``version`` above is an array of the form :code:`[0, 14, 2]`. If you are
@@ -38,4 +41,47 @@ with the following command line::
 
     echo -en '\eP@kitty-cmd{"cmd":"ls","version":[0,14,2]}\e\\' | socat - unix:/tmp/test | awk '{ print substr($0, 13, length($0) - 14) }' | jq -c '.data | fromjson' | jq .
 
+There is also the statically compiled stand-alone executable ``kitten``
+that can be used for this, available from the `kitty releases
+<https://github.com/kovidgoyal/kitty/releases>`__ page::
+
+    kitten @ --help
+
+.. _rc_crypto:
+
+Encrypted communication
+--------------------------
+
+.. versionadded:: 0.26.0
+
+When using the :opt:`remote_control_password` option communication to the
+terminal is encrypted to keep the password secure. A public key is used from
+the :envvar:`KITTY_PUBLIC_KEY` environment variable. Currently, only one
+encryption protocol is supported. The protocol number is present in
+:envvar:`KITTY_PUBLIC_KEY` as ``1``. The key data in this environment variable
+is :rfc:`Base-85 <1924>` encoded.  The algorithm used is `Elliptic Curve Diffie
+Helman <https://en.wikipedia.org/wiki/Elliptic-curve_Diffie–Hellman>`__ with
+the `X25519 curve <https://en.wikipedia.org/wiki/Curve25519>`__. A time based
+nonce is used to minimise replay attacks. The original JSON command has the
+fields: ``password`` and ``timestamp`` added. The timestamp is the number of
+nanoseconds since the epoch, excluding leap seconds. Commands with a timestamp
+more than 5 minutes from the current time are rejected. The command is then
+encrypted using AES-256-GCM in authenticated encryption mode, with a symmetric
+key that is derived from the ECDH key-pair by running the shared secret through
+SHA-256 hashing, once.  An IV of at least 96 bits of CSPRNG data is used. The
+tag for authenticated encryption **must** be at least 128 bits long.  The tag
+**must** authenticate only the value of the ``encrypted`` field. A new command
+is created and transmitted that contains the fields:
+
+.. code-block:: json
+
+    {
+        "version": "<kitty version>",
+        "iv": "base85 encoded IV",
+        "tag": "base85 encoded AEAD tag",
+        "pubkey": "base85 encoded ECDH public key of sender",
+        "encrypted": "The original command encrypted and base85 encoded"
+    }
+
+
 .. include:: generated/rc.rst

docs/remote-control.rst

@@ -17,8 +17,9 @@ Start by running |kitty| as::
 
     kitty -o allow_remote_control=yes -o enabled_layouts=tall
 
-In order for control to work, :opt:`allow_remote_control` must be enabled in
-:file:`kitty.conf`. Here we turn it on explicitly at the command line.
+In order for control to work, :opt:`allow_remote_control` or
+:opt:`remote_control_password` must be enabled in :file:`kitty.conf`. Here we
+turn it on explicitly at the command line.
 
 Now, in the new |kitty| window, enter the command::
 
@@ -35,12 +36,12 @@ This will make ``Hello, World`` show up in the window running the :program:`cat`
 program. The :option:`kitty @ send-text --match` option is very powerful, it
 allows selecting windows by their titles, the command line of the program
 running in the window, the working directory of the program running in the
-window, etc. See :ref:`kitty @ send-text --help <at_send-text>` for details.
+window, etc. See :ref:`kitty @ send-text --help <at-send-text>` for details.
 
 More usefully, you can pipe the output of a command running in one window to
 another window, for example::
 
-    ls | kitty @ send-text --match title:^Output --stdin
+    ls | kitty @ send-text --match 'title:^Output' --stdin
 
 This will show the output of :program:`ls` in the output window instead of the
 current window. You can use this technique to, for example, show the output of
@@ -49,7 +50,7 @@ are endless.
 
 You can even have things you type show up in a different window. Run::
 
-    kitty @ send-text --match title:^Output --stdin
+    kitty @ send-text --match 'title:^Output' --stdin
 
 And type some text, it will show up in the output window, instead of the current
 window. Type :kbd:`Ctrl+D` when you are ready to stop.
@@ -61,7 +62,7 @@ Now, let's open a new tab::
 This will open a new tab running the bash shell with the title "My Tab".
 We can change the title of the tab to "New Title" with::
 
-   kitty @ set-tab-title --match title:^My New Title
+   kitty @ set-tab-title --match 'title:^My' New Title
 
 Let's change the title of the current tab::
 
@@ -69,12 +70,12 @@ Let's change the title of the current tab::
 
 Now lets switch to the newly opened tab::
 
-   kitty @ focus-tab --match title:^New
+   kitty @ focus-tab --match 'title:^New'
 
 Similarly, to focus the previously opened output window (which will also switch
 back to the old tab, automatically)::
 
-   kitty @ focus-window --match title:^Output
+   kitty @ focus-window --match 'title:^Output'
 
 You can get a listing of available tabs and windows, by running::
 
@@ -92,11 +93,23 @@ As you can see, it is very easy to control |kitty| using the ``kitty @``
 messaging system. This tutorial touches only the surface of what is possible.
 See ``kitty @ --help`` for more details.
 
-Note that in the example's above, ``kitty @`` messaging works only when run
+In the example's above, ``kitty @`` messaging works only when run
 inside a |kitty| window, not anywhere. But, within a |kitty| window it even
 works over SSH. If you want to control |kitty| from programs/scripts not running
-inside a |kitty| window, you have to implement a couple of extra steps. First
-start |kitty| as::
+inside a |kitty| window, see the section on :ref:`using a socket for remote control <rc_via_socket>`
+below.
+
+
+Note that if all you want to do is run a single |kitty| "daemon" and have
+subsequent |kitty| invocations appear as new top-level windows, you can use the
+simpler :option:`kitty --single-instance` option, see ``kitty --help`` for that.
+
+
+.. _rc_via_socket:
+
+Remote control via a socket
+--------------------------------
+First, start |kitty| as::
 
     kitty -o allow_remote_control=yes --listen-on unix:/tmp/mykitty
 
@@ -108,11 +121,6 @@ command line argument to ``kitty @``. For example::
     kitty @ --to unix:/tmp/mykitty ls
 
 
-Note that if all you want to do is run a single |kitty| "daemon" and have
-subsequent |kitty| invocations appear as new top-level windows, you can use the
-simpler :option:`kitty --single-instance` option, see ``kitty --help`` for that.
-
-
 The builtin kitty shell
 --------------------------
 
@@ -147,6 +155,112 @@ other computers (for example, over SSH) or as other users.
    what programs you run in such windows, since they can effectively control
    kitty, as if you were running with :opt:`allow_remote_control` turned on.
 
+    You can further restrict what is allowed in these windows by using
+    :option:`kitty @ launch --remote-control-password`.
+
+
+Fine grained permissions for remote control
+----------------------------------------------
+
+.. versionadded:: 0.26.0
+
+The :opt:`allow_remote_control` option discussed so far is a blunt
+instrument, granting the ability to any program running on your computer
+or even on remote computers via SSH the ability to use remote control.
+
+You can instead define remote control passwords that can be used to grant
+different levels of control to different places. You can even write your
+own script to decide which remote control requests are allowed. This is
+done using the :opt:`remote_control_password` option in :file:`kitty.conf`.
+Set :opt:`allow_remote_control` to :code:`password` to use this feature.
+Let's see some examples:
+
+.. code-block:: conf
+
+   remote_control_password "control colors" get-colors set-colors
+
+Now, using this password, you can, in scripts run the command::
+
+    kitty @ --password="control colors" set-colors background=red
+
+Any script with access to the password can now change colors in kitty using
+remote control, but only that and nothing else. You can even supply the
+password via the :envvar:`KITTY_RC_PASSWORD` environment variable, or the
+file :file:`~/.config/kitty/rc-password` to avoid having to type it repeatedly.
+See :option:`kitty @ --password-file` and :option:`kitty @ --password-env`.
+
+The :opt:`remote_control_password` can be specified multiple times to create
+different passwords with different capabilities. Run the following to get a
+list of all action names::
+
+    kitty @ --help
+
+You can even use glob patterns to match action names, for example:
+
+.. code-block:: conf
+
+   remote_control_password "control colors" *-colors
+
+If no action names are specified, all actions are allowed.
+
+If ``kitty @`` is run with a password that is not present in
+:file:`kitty.conf`, then kitty will interactively prompt the user to allow or
+disallow the remote control request. The user can choose to allow or disallow
+either just that request or all requests using that password. The user's
+decision is remembered for the duration of that kitty instance.
+
+.. note::
+   For password based authentication to work over SSH, you must pass the
+   :envvar:`KITTY_PUBLIC_KEY` environment variable to the remote host. The
+   :doc:`ssh kitten <kittens/ssh>` does this for you automatically. When
+   using a password, :ref:`rc_crypto` is used to ensure the password
+   is kept secure. This does mean that using password based authentication
+   is slower as the entire command is encrypted before transmission. This
+   can be noticeable when using a command like ``kitty @ set-background-image``
+   which transmits large amounts of image data. Also, the clock on the remote
+   system must match (within a few minutes) the clock on the local system.
+   kitty uses a time based nonce to minimise the potential for replay attacks.
+
+.. _rc_custom_auth:
+
+Customizing authorization with your own program
+____________________________________________________________
+
+If the ability to control access by action names is not fine grained enough,
+you can define your own Python script to examine every remote control command
+and allow/disallow it. To do so create a file in the kitty configuration
+directory, :file:`~/.config/kitty/my_rc_auth.py` and add the following
+to :file:`kitty.conf`:
+
+.. code-block:: conf
+
+    remote_control_password "testing custom auth" my_rc_auth.py
+
+:file:`my_rc_auth.py` should define a :code:`is_cmd_allowed` function
+as shown below:
+
+.. code-block:: py
+
+    def is_cmd_allowed(pcmd, window, from_socket, extra_data):
+        cmd_name = pcmd['cmd']  # the name of the command
+        cmd_payload = pcmd['payload']  # the arguments to the command
+        # examine the cmd_name and cmd_payload and return True to allow
+        # the command or False to disallow it. Return None to have no
+        # effect on the command.
+
+        # The command payload will vary from command to command, see
+        # the rc protocol docs for details. Below is an example of
+        # restricting the launch command to allow only running the
+        # default shell.
+
+        if cmd_name != 'launch':
+            return None
+        if cmd_payload.get('args') or cmd_payload.get('env') or cmd_payload.get('copy_cmdline') or cmd_payload.get('copy_env'):
+            return False
+        # prints in this function go to the parent kitty process STDOUT
+        print('Allowing launch command:', cmd_payload)
+        return True
+
 
 .. _rc_mapping:
 
@@ -162,6 +276,12 @@ Then pressing the :kbd:`F1` key will set the active window margins to
 :code:`30`. The syntax for what follows :ac:`remote_control` is exactly the same
 as the syntax for what follows :code:`kitty @` above.
 
+If you wish to ignore errors from the command, prefix the command with an
+``!``. For example, the following will not return an error when no windows
+are matched::
+
+    map f1 remote_control !focus-window --match XXXXXX
+
 .. note:: You do not need :opt:`allow_remote_control` to use these mappings,
    as they are not actual remote programs, but are simply a way to resuse the
    remote control infrastructure via keybings.
@@ -184,7 +304,13 @@ The remote control protocol
 -----------------------------------------------
 
 If you wish to develop your own client to talk to |kitty|, you can use the
-:doc:`remote control protocol specification <rc_protocol>`.
+:doc:`remote control protocol specification <rc_protocol>`. Note that there
+is a statically compiled, standalone executable, ``kitten`` available that
+can be used as a remote control client on any UNIX like computer. This can be
+downloaded and used directly from the `kitty releases
+<https://github.com/kovidgoyal/kitty/releases>`__ page::
+
+    kitten @ --help
 
 
 .. _search_syntax:

docs/shell-integration.rst

@@ -33,13 +33,15 @@ Features
 * :ref:`clone_shell` with all environment variables and the working directory
   copied
 
+* :ref:`Edit files in new kitty windows <edit_file>` even over SSH
+
 * Glitch free window resizing even with complex prompts. Achieved by erasing
   the prompt on resize and allowing the shell to redraw it cleanly.
 
 * Sophisticated completion for the :program:`kitty` command in the shell.
 
 * When confirming a quit command if a window is sitting at a shell prompt,
-  it is optionally, not counted (see :opt:`confirm_os_window_close`)
+  it is not counted (for details, see :opt:`confirm_os_window_close`)
 
 
 Configuration
@@ -263,6 +265,33 @@ state (mainly CWD and env vars) and this state is transmitted to kitty and
 restored by the shell integration scripts in the cloned window.
 
 
+.. _edit_file:
+
+Edit files in new kitty windows even over SSH
+------------------------------------------------
+
+.. code-block:: sh
+
+   edit-in-kitty myfile.txt
+   edit-in-kitty --type tab --title "Editing My File" myfile.txt
+   # open myfile.txt at line 75 (works with vim, neovim, emacs, nano, micro)
+   edit-in-kitty +75 myfile.txt
+
+The :command:`edit-in-kitty` command allows you to seamlessly edit files
+in your default :opt:`editor` in new kitty windows. This works even over
+SSH (if you use the :doc:`ssh kitten <kittens/ssh>`), allowing you
+to easily edit remote files in your local editor with all its bells and
+whistles.
+
+The :command:`edit-in-kitty` command takes almost all the same arguments as the
+:doc:`launch <launch>` command, so you can open a new tab instead or a new OS
+window, etc. Not all arguments are supported, see the discussion in the
+:ref:`clone_shell` section above.
+
+In order to avoid remote code execution, kitty will only execute the configured
+editor and pass the file path to edit to it.
+
+
 .. _manual_shell_integration:
 
 Manual shell integration

gen-config.py

@@ -1,8 +1,9 @@
-#!/usr/bin/env python
+#!./kitty/launcher/kitty +launch
 # License: GPLv3 Copyright: 2021, Kovid Goyal <kovid at kovidgoyal.net>
 
 
 import re
+import subprocess
 from typing import List
 
 from kitty.conf.generate import write_output
@@ -11,14 +12,25 @@ from kitty.conf.generate import write_output
 def patch_color_list(path: str, colors: List[str], name: str, spc: str = '    ') -> None:
     with open(path, 'r+') as f:
         raw = f.read()
-        nraw = re.sub(
-            fr'(# {name}_COLORS_START).+?(\s+# {name}_COLORS_END)',
-            r'\1' + f'\n{spc}' + f'\n{spc}'.join(map(lambda x: f'{x!r},', sorted(colors))) + r'\2',
-            raw, flags=re.DOTALL | re.MULTILINE)
+        colors = sorted(colors)
+        if path.endswith('.go'):
+            spc = '\t'
+            nraw = re.sub(
+                fr'(// {name}_COLORS_START).+?(\s+// {name}_COLORS_END)',
+                r'\1' + f'\n{spc}' + f'\n{spc}'.join(map(lambda x: f'"{x}":true,', colors)) + r'\2',
+                raw, flags=re.DOTALL | re.MULTILINE)
+        else:
+            nraw = re.sub(
+                fr'(# {name}_COLORS_START).+?(\s+# {name}_COLORS_END)',
+                r'\1' + f'\n{spc}' + f'\n{spc}'.join(map(lambda x: f'{x!r},', colors)) + r'\2',
+                raw, flags=re.DOTALL | re.MULTILINE)
         if nraw != raw:
             f.seek(0)
             f.truncate()
             f.write(nraw)
+            f.flush()
+            if path.endswith('.go'):
+                subprocess.check_call(['gofmt', '-w', path])
 
 
 def main() -> None:
@@ -34,6 +46,7 @@ def main() -> None:
             elif opt.parser_func.__name__ in ('to_color', 'titlebar_color', 'macos_titlebar_color'):
                 all_colors.append(opt.name)
     patch_color_list('kitty/rc/set_colors.py', nullable_colors, 'NULLABLE')
+    patch_color_list('tools/cmd/at/set_colors.go', nullable_colors, 'NULLABLE')
     patch_color_list('kittens/themes/collection.py', all_colors, 'ALL', ' ' * 8)
 
     from kittens.diff.options.definition import definition as kd

gen-go-code.py

@@ -0,0 +1,607 @@
+#!./kitty/launcher/kitty +launch
+# License: GPLv3 Copyright: 2022, Kovid Goyal <kovid at kovidgoyal.net>
+
+import io
+import json
+import os
+import subprocess
+import sys
+from contextlib import contextmanager, suppress
+from functools import lru_cache
+from typing import Any, Dict, Iterator, List, Optional, Sequence, Set, Tuple, Union
+
+import kitty.constants as kc
+from kittens.tui.operations import Mode
+from kittens.tui.spinners import spinners
+from kitty.cli import (
+    CompletionSpec,
+    GoOption,
+    go_options_for_seq,
+    parse_option_spec,
+    serialize_as_go_string,
+)
+from kitty.guess_mime_type import text_mimes
+from kitty.key_encoding import config_mod_map
+from kitty.key_names import character_key_name_aliases, functional_key_name_aliases
+from kitty.options.types import Options
+from kitty.rc.base import RemoteCommand, all_command_names, command_for_name
+from kitty.remote_control import global_options_spec
+from kitty.rgb import color_names
+
+changed: List[str] = []
+
+
+# Utils {{{
+
+def serialize_go_dict(x: Union[Dict[str, int], Dict[int, str], Dict[int, int], Dict[str, str]]) -> str:
+    ans = []
+
+    def s(x: Union[int, str]) -> str:
+        if isinstance(x, int):
+            return str(x)
+        return f'"{serialize_as_go_string(x)}"'
+
+    for k, v in x.items():
+        ans.append(f'{s(k)}: {s(v)}')
+    return '{' + ', '.join(ans) + '}'
+
+
+def replace(template: str, **kw: str) -> str:
+    for k, v in kw.items():
+        template = template.replace(k, v)
+    return template
+# }}}
+
+
+# Completions {{{
+
+@lru_cache
+def kitten_cli_docs(kitten: str) -> Any:
+    from kittens.runner import get_kitten_cli_docs
+    return get_kitten_cli_docs(kitten)
+
+
+@lru_cache
+def go_options_for_kitten(kitten: str) -> Tuple[Sequence[GoOption], Optional[CompletionSpec]]:
+    kcd = kitten_cli_docs(kitten)
+    if kcd:
+        ospec = kcd['options']
+        return (tuple(go_options_for_seq(parse_option_spec(ospec())[0])), kcd.get('args_completion'))
+    return (), None
+
+
+def generate_kittens_completion() -> None:
+    from kittens.runner import all_kitten_names, get_kitten_wrapper_of
+    for kitten in sorted(all_kitten_names()):
+        kn = 'kitten_' + kitten
+        print(f'{kn} := plus_kitten.AddSubCommand(&cli.Command{{Name:"{kitten}", Group: "Kittens"}})')
+        wof = get_kitten_wrapper_of(kitten)
+        if wof:
+            print(f'{kn}.ArgCompleter = cli.CompletionForWrapper("{serialize_as_go_string(wof)}")')
+            print(f'{kn}.OnlyArgsAllowed = true')
+            continue
+        gopts, ac = go_options_for_kitten(kitten)
+        if gopts or ac:
+            for opt in gopts:
+                print(opt.as_option(kn))
+            if ac is not None:
+                print(''.join(ac.as_go_code(kn + '.ArgCompleter', ' = ')))
+        else:
+            print(f'{kn}.HelpText = ""')
+
+
+@lru_cache
+def clone_safe_launch_opts() -> Sequence[GoOption]:
+    from kitty.launch import clone_safe_opts, options_spec
+    ans = []
+    allowed = clone_safe_opts()
+    for o in go_options_for_seq(parse_option_spec(options_spec())[0]):
+        if o.obj_dict['name'] in allowed:
+            ans.append(o)
+    return tuple(ans)
+
+
+def completion_for_launch_wrappers(*names: str) -> None:
+    for o in clone_safe_launch_opts():
+        for name in names:
+            print(o.as_option(name))
+
+
+def generate_completions_for_kitty() -> None:
+    from kitty.config import option_names_for_completion
+    print('package completion\n')
+    print('import "kitty/tools/cli"')
+    print('import "kitty/tools/cmd/tool"')
+    print('import "kitty/tools/cmd/at"')
+    conf_names = ', '.join((f'"{serialize_as_go_string(x)}"' for x in option_names_for_completion()))
+    print('var kitty_option_names_for_completion = []string{' + conf_names + '}')
+
+    print('func kitty(root *cli.Command) {')
+
+    # The kitty exe
+    print('k := root.AddSubCommand(&cli.Command{'
+          'Name:"kitty", SubCommandIsOptional: true, ArgCompleter: cli.CompleteExecutableFirstArg, SubCommandMustBeFirst: true })')
+    print('kt := root.AddSubCommand(&cli.Command{Name:"kitten", SubCommandMustBeFirst: true })')
+    print('tool.KittyToolEntryPoints(kt)')
+    for opt in go_options_for_seq(parse_option_spec()[0]):
+        print(opt.as_option('k'))
+
+    # kitty +
+    print('plus := k.AddSubCommand(&cli.Command{Name:"+", Group:"Entry points", ShortDescription: "Various special purpose tools and kittens"})')
+
+    # kitty +launch
+    print('plus_launch := plus.AddSubCommand(&cli.Command{'
+          'Name:"launch", Group:"Entry points", ShortDescription: "Launch Python scripts", ArgCompleter: complete_plus_launch})')
+    print('k.AddClone("", plus_launch).Name = "+launch"')
+
+    # kitty +list-fonts
+    print('plus_list_fonts := plus.AddSubCommand(&cli.Command{'
+          'Name:"list-fonts", Group:"Entry points", ShortDescription: "List all available monospaced fonts"})')
+    print('k.AddClone("", plus_list_fonts).Name = "+list-fonts"')
+
+    # kitty +runpy
+    print('plus_runpy := plus.AddSubCommand(&cli.Command{'
+          'Name: "runpy", Group:"Entry points", ArgCompleter: complete_plus_runpy, ShortDescription: "Run Python code"})')
+    print('k.AddClone("", plus_runpy).Name = "+runpy"')
+
+    # kitty +open
+    print('plus_open := plus.AddSubCommand(&cli.Command{'
+          'Name:"open", Group:"Entry points", ArgCompleter: complete_plus_open, ShortDescription: "Open files and URLs"})')
+    print('for _, og := range k.OptionGroups { plus_open.OptionGroups = append(plus_open.OptionGroups, og.Clone(plus_open)) }')
+    print('k.AddClone("", plus_open).Name = "+open"')
+
+    # kitty +kitten
+    print('plus_kitten := plus.AddSubCommand(&cli.Command{Name:"kitten", Group:"Kittens", SubCommandMustBeFirst: true})')
+    generate_kittens_completion()
+    print('k.AddClone("", plus_kitten).Name = "+kitten"')
+
+    # @
+    print('at.EntryPoint(k)')
+
+    # clone-in-kitty, edit-in-kitty
+    print('cik := root.AddSubCommand(&cli.Command{Name:"clone-in-kitty"})')
+    completion_for_launch_wrappers('cik')
+
+    print('}')
+    print('func init() {')
+    print('cli.RegisterExeForCompletion(kitty)')
+    print('}')
+# }}}
+
+
+# rc command wrappers {{{
+json_field_types: Dict[str, str] = {
+    'bool': 'bool', 'str': 'escaped_string', 'list.str': '[]escaped_string', 'dict.str': 'map[escaped_string]escaped_string', 'float': 'float64', 'int': 'int',
+    'scroll_amount': 'any', 'spacing': 'any', 'colors': 'any',
+}
+
+
+def go_field_type(json_field_type: str) -> str:
+    q = json_field_types.get(json_field_type)
+    if q:
+        return q
+    if json_field_type.startswith('choices.'):
+        return 'string'
+    if '.' in json_field_type:
+        p, r = json_field_type.split('.', 1)
+        p = {'list': '[]', 'dict': 'map[string]'}[p]
+        return p + go_field_type(r)
+    raise TypeError(f'Unknown JSON field type: {json_field_type}')
+
+
+class JSONField:
+
+    def __init__(self, line: str) -> None:
+        field_def = line.split(':', 1)[0]
+        self.required = False
+        self.field, self.field_type = field_def.split('/', 1)
+        if self.field.endswith('+'):
+            self.required = True
+            self.field = self.field[:-1]
+        self.struct_field_name = self.field[0].upper() + self.field[1:]
+
+    def go_declaration(self) -> str:
+        return self.struct_field_name + ' ' + go_field_type(self.field_type) + f'`json:"{self.field},omitempty"`'
+
+
+def go_code_for_remote_command(name: str, cmd: RemoteCommand, template: str) -> str:
+    template = '\n' + template[len('//go:build exclude'):]
+    NO_RESPONSE_BASE = 'false'
+    af: List[str] = []
+    a = af.append
+    af.extend(cmd.args.as_go_completion_code('ans'))
+    od: List[str] = []
+    option_map: Dict[str, GoOption] = {}
+    for o in rc_command_options(name):
+        option_map[o.go_var_name] = o
+        a(o.as_option('ans'))
+        if o.go_var_name in ('NoResponse', 'ResponseTimeout'):
+            continue
+        od.append(o.struct_declaration())
+    jd: List[str] = []
+    json_fields = []
+    field_types: Dict[str, str] = {}
+    for line in cmd.protocol_spec.splitlines():
+        line = line.strip()
+        if ':' not in line:
+            continue
+        f = JSONField(line)
+        json_fields.append(f)
+        field_types[f.field] = f.field_type
+        jd.append(f.go_declaration())
+    jc: List[str] = []
+    handled_fields: Set[str] = set()
+    jc.extend(cmd.args.as_go_code(name, field_types, handled_fields))
+
+    unhandled = {}
+    used_options = set()
+    for field in json_fields:
+        oq = (cmd.field_to_option_map or {}).get(field.field, field.field)
+        oq = ''.join(x.capitalize() for x in oq.split('_'))
+        if oq in option_map:
+            o = option_map[oq]
+            used_options.add(oq)
+            if field.field_type == 'str':
+                jc.append(f'payload.{field.struct_field_name} = escaped_string(options_{name}.{o.go_var_name})')
+            elif field.field_type == 'list.str':
+                jc.append(f'payload.{field.struct_field_name} = escape_list_of_strings(options_{name}.{o.go_var_name})')
+            elif field.field_type == 'dict.str':
+                jc.append(f'payload.{field.struct_field_name} = escape_dict_of_strings(options_{name}.{o.go_var_name})')
+            else:
+                jc.append(f'payload.{field.struct_field_name} = options_{name}.{o.go_var_name}')
+        elif field.field in handled_fields:
+            pass
+        else:
+            unhandled[field.field] = field
+    for x in tuple(unhandled):
+        if x == 'match_window' and 'Match' in option_map and 'Match' not in used_options:
+            used_options.add('Match')
+            o = option_map['Match']
+            field = unhandled[x]
+            if field.field_type == 'str':
+                jc.append(f'payload.{field.struct_field_name} = escaped_string(options_{name}.{o.go_var_name})')
+            else:
+                jc.append(f'payload.{field.struct_field_name} = options_{name}.{o.go_var_name}')
+            del unhandled[x]
+    if unhandled:
+        raise SystemExit(f'Cant map fields: {", ".join(unhandled)} for cmd: {name}')
+    if name != 'send_text':
+        unused_options = set(option_map) - used_options - {'NoResponse', 'ResponseTimeout'}
+        if unused_options:
+            raise SystemExit(f'Unused options: {", ".join(unused_options)} for command: {name}')
+
+    argspec = cmd.args.spec
+    if argspec:
+        argspec = ' ' + argspec
+    ans = replace(
+        template,
+        CMD_NAME=name, __FILE__=__file__, CLI_NAME=name.replace('_', '-'),
+        SHORT_DESC=serialize_as_go_string(cmd.short_desc),
+        LONG_DESC=serialize_as_go_string(cmd.desc.strip()),
+        IS_ASYNC='true' if cmd.is_asynchronous else 'false',
+        NO_RESPONSE_BASE=NO_RESPONSE_BASE, ADD_FLAGS_CODE='\n'.join(af),
+        WAIT_TIMEOUT=str(cmd.response_timeout),
+        OPTIONS_DECLARATION_CODE='\n'.join(od),
+        JSON_DECLARATION_CODE='\n'.join(jd),
+        JSON_INIT_CODE='\n'.join(jc), ARGSPEC=argspec,
+        STRING_RESPONSE_IS_ERROR='true' if cmd.string_return_is_error else 'false',
+        STREAM_WANTED='true' if cmd.reads_streaming_data else 'false',
+    )
+    return ans
+# }}}
+
+
+# kittens {{{
+
+@lru_cache
+def wrapped_kittens() -> Sequence[str]:
+    with open('shell-integration/ssh/kitty') as f:
+        for line in f:
+            if line.startswith('    wrapped_kittens="'):
+                val = line.strip().partition('"')[2][:-1]
+                return tuple(sorted(filter(None, val.split())))
+    raise Exception('Failed to read wrapped kittens from kitty wrapper script')
+
+
+def kitten_clis() -> None:
+    for kitten in wrapped_kittens():
+        with replace_if_needed(f'tools/cmd/{kitten}/cli_generated.go'):
+            od = []
+            kcd = kitten_cli_docs(kitten)
+            has_underscore = '_' in kitten
+            print(f'package {kitten}')
+            print('import "kitty/tools/cli"')
+            print('func create_cmd(root *cli.Command, run_func func(*cli.Command, *Options, []string)(int, error)) {')
+            print('ans := root.AddSubCommand(&cli.Command{')
+            print(f'Name: "{kitten}",')
+            print(f'ShortDescription: "{serialize_as_go_string(kcd["short_desc"])}",')
+            if kcd['usage']:
+                print(f'Usage: "[options] {serialize_as_go_string(kcd["usage"])}",')
+            print(f'HelpText: "{serialize_as_go_string(kcd["help_text"])}",')
+            print('Run: func(cmd *cli.Command, args []string) (int, error) {')
+            print('opts := Options{}')
+            print('err := cmd.GetOptionValues(&opts)')
+            print('if err != nil { return 1, err }')
+            print('return run_func(cmd, &opts, args)},')
+            if has_underscore:
+                print('Hidden: true,')
+            print('})')
+            gopts, ac = go_options_for_kitten(kitten)
+            for opt in gopts:
+                print(opt.as_option('ans'))
+                od.append(opt.struct_declaration())
+            if ac is not None:
+                print(''.join(ac.as_go_code('ans.ArgCompleter', ' = ')))
+            if has_underscore:
+                print("clone := root.AddClone(ans.Group, ans)")
+                print('clone.Hidden = false')
+                print(f'clone.Name = "{serialize_as_go_string(kitten.replace("_", "-"))}"')
+            print('}')
+            print('type Options struct {')
+            print('\n'.join(od))
+            print('}')
+
+# }}}
+
+
+# Constants {{{
+
+def generate_spinners() -> str:
+    ans = ['package tui', 'import "time"', 'func NewSpinner(name string) *Spinner {', 'var ans *Spinner', 'switch name {']
+    a = ans.append
+    for name, spinner in spinners.items():
+        a(f'case "{serialize_as_go_string(name)}":')
+        a('ans = &Spinner{')
+        a(f'Name: "{serialize_as_go_string(name)}",')
+        a(f'interval: {spinner["interval"]},')
+        frames = ', '.join(f'"{serialize_as_go_string(x)}"' for x in spinner['frames'])
+        a(f'frames: []string{{{frames}}},')
+        a('}')
+    a('}')
+    a('if ans != nil {')
+    a('ans.interval *= time.Millisecond')
+    a('ans.current_frame = -1')
+    a('ans.last_change_at = time.Now().Add(-ans.interval)')
+    a('}')
+    a('return ans}')
+    return '\n'.join(ans)
+
+
+def generate_color_names() -> str:
+    return 'package style\n\nvar ColorNames = map[string]RGBA{' + '\n'.join(
+        f'\t"{name}": RGBA{{ Red:{val.red}, Green:{val.green}, Blue:{val.blue} }},'
+        for name, val in color_names.items()
+    ) + '\n}' + '\n\nvar ColorTable = [256]uint32{' + ', '.join(
+        f'{x}' for x in Options.color_table) + '}\n'
+
+
+def load_ref_map() -> Dict[str, Dict[str, str]]:
+    with open('kitty/docs_ref_map_generated.h') as f:
+        raw = f.read()
+    raw = raw.split('{', 1)[1].split('}', 1)[0]
+    data = json.loads(bytes(bytearray(json.loads(f'[{raw}]'))))
+    return data  # type: ignore
+
+
+def generate_constants() -> str:
+    ref_map = load_ref_map()
+    dp = ", ".join(map(lambda x: f'"{serialize_as_go_string(x)}"', kc.default_pager_for_help))
+    return f'''\
+package kitty
+
+type VersionType struct {{
+    Major, Minor, Patch int
+}}
+const VersionString string = "{kc.str_version}"
+const WebsiteBaseURL string = "{kc.website_base_url}"
+const VCSRevision string = ""
+const RC_ENCRYPTION_PROTOCOL_VERSION string = "{kc.RC_ENCRYPTION_PROTOCOL_VERSION}"
+const IsFrozenBuild bool = false
+const IsStandaloneBuild bool = false
+const HandleTermiosSignals = {Mode.HANDLE_TERMIOS_SIGNALS.value[0]}
+var Version VersionType = VersionType{{Major: {kc.version.major}, Minor: {kc.version.minor}, Patch: {kc.version.patch},}}
+var DefaultPager []string = []string{{ {dp} }}
+var FunctionalKeyNameAliases = map[string]string{serialize_go_dict(functional_key_name_aliases)}
+var CharacterKeyNameAliases = map[string]string{serialize_go_dict(character_key_name_aliases)}
+var ConfigModMap = map[string]uint16{serialize_go_dict(config_mod_map)}
+var RefMap = map[string]string{serialize_go_dict(ref_map['ref'])}
+var DocTitleMap = map[string]string{serialize_go_dict(ref_map['doc'])}
+'''  # }}}
+
+
+# Boilerplate {{{
+
+@contextmanager
+def replace_if_needed(path: str, show_diff: bool = False) -> Iterator[io.StringIO]:
+    buf = io.StringIO()
+    origb = sys.stdout
+    sys.stdout = buf
+    try:
+        yield buf
+    finally:
+        sys.stdout = origb
+    orig = ''
+    with suppress(FileNotFoundError), open(path, 'r') as f:
+        orig = f.read()
+    new = buf.getvalue()
+    new = f'// Code generated by {os.path.basename(__file__)}; DO NOT EDIT.\n\n' + new
+    if orig != new:
+        changed.append(path)
+        if show_diff:
+            with open(path + '.new', 'w') as f:
+                f.write(new)
+                subprocess.run(['diff', '-Naurp', path, f.name], stdout=open('/dev/tty', 'w'))
+                os.remove(f.name)
+        with open(path, 'w') as f:
+            f.write(new)
+
+
+@lru_cache(maxsize=256)
+def rc_command_options(name: str) -> Tuple[GoOption, ...]:
+    cmd = command_for_name(name)
+    return tuple(go_options_for_seq(parse_option_spec(cmd.options_spec or '\n\n')[0]))
+
+
+def update_at_commands() -> None:
+    with open('tools/cmd/at/template.go') as f:
+        template = f.read()
+    for name in all_command_names():
+        cmd = command_for_name(name)
+        code = go_code_for_remote_command(name, cmd, template)
+        dest = f'tools/cmd/at/cmd_{name}_generated.go'
+        with replace_if_needed(dest) as f:
+            f.write(code)
+    struct_def = []
+    opt_def = []
+    for o in go_options_for_seq(parse_option_spec(global_options_spec())[0]):
+        struct_def.append(o.struct_declaration())
+        opt_def.append(o.as_option(depth=1, group="Global options"))
+    sdef = '\n'.join(struct_def)
+    odef = '\n'.join(opt_def)
+    code = f'''
+package at
+import "kitty/tools/cli"
+type rc_global_options struct {{
+{sdef}
+}}
+var rc_global_opts rc_global_options
+
+func add_rc_global_opts(cmd *cli.Command) {{
+{odef}
+}}
+'''
+    with replace_if_needed('tools/cmd/at/global_opts_generated.go') as f:
+        f.write(code)
+
+
+def update_completion() -> None:
+    with replace_if_needed('tools/cmd/completion/kitty_generated.go'):
+        generate_completions_for_kitty()
+    with replace_if_needed('tools/cmd/edit_in_kitty/launch_generated.go'):
+        print('package edit_in_kitty')
+        print('import "kitty/tools/cli"')
+        print('func AddCloneSafeOpts(cmd *cli.Command) {')
+        completion_for_launch_wrappers('cmd')
+        print(''.join(CompletionSpec.from_string('type:file mime:text/* group:"Text files"').as_go_code('cmd.ArgCompleter', ' = ')))
+        print('}')
+
+
+def define_enum(package_name: str, type_name: str, items: str, underlying_type: str = 'uint') -> str:
+    actions = []
+    for x in items.splitlines():
+        x = x.strip()
+        if x:
+            actions.append(x)
+    ans = [f'package {package_name}', 'import "strconv"', f'type {type_name} {underlying_type}', 'const (']
+    stringer = [f'func (ac {type_name}) String() string ''{', 'switch(ac) {']
+    for i, ac in enumerate(actions):
+        stringer.append(f'case {ac}: return "{ac}"')
+        if i == 0:
+            ac = ac + f' {type_name} = iota'
+        ans.append(ac)
+    ans.append(')')
+    stringer.append('}\nreturn strconv.Itoa(int(ac)) }')
+    return '\n'.join(ans + stringer)
+
+
+def generate_readline_actions() -> str:
+    return define_enum('readline', 'Action', '''\
+        ActionNil
+
+        ActionBackspace
+        ActionDelete
+        ActionMoveToStartOfLine
+        ActionMoveToEndOfLine
+        ActionMoveToStartOfDocument
+        ActionMoveToEndOfDocument
+        ActionMoveToEndOfWord
+        ActionMoveToStartOfWord
+        ActionCursorLeft
+        ActionCursorRight
+        ActionEndInput
+        ActionAcceptInput
+        ActionCursorUp
+        ActionHistoryPreviousOrCursorUp
+        ActionCursorDown
+        ActionHistoryNextOrCursorDown
+        ActionHistoryNext
+        ActionHistoryPrevious
+        ActionHistoryFirst
+        ActionHistoryLast
+        ActionHistoryIncrementalSearchBackwards
+        ActionHistoryIncrementalSearchForwards
+        ActionTerminateHistorySearchAndApply
+        ActionTerminateHistorySearchAndRestore
+        ActionClearScreen
+        ActionAddText
+        ActionAbortCurrentLine
+
+        ActionStartKillActions
+        ActionKillToEndOfLine
+        ActionKillToStartOfLine
+        ActionKillNextWord
+        ActionKillPreviousWord
+        ActionKillPreviousSpaceDelimitedWord
+        ActionEndKillActions
+        ActionYank
+        ActionPopYank
+
+        ActionNumericArgumentDigit0
+        ActionNumericArgumentDigit1
+        ActionNumericArgumentDigit2
+        ActionNumericArgumentDigit3
+        ActionNumericArgumentDigit4
+        ActionNumericArgumentDigit5
+        ActionNumericArgumentDigit6
+        ActionNumericArgumentDigit7
+        ActionNumericArgumentDigit8
+        ActionNumericArgumentDigit9
+        ActionNumericArgumentDigitMinus
+
+        ActionCompleteForward
+        ActionCompleteBackward
+    ''')
+
+
+def generate_mimetypes() -> str:
+    import mimetypes
+    if not mimetypes.inited:
+        mimetypes.init()
+    ans = ['package utils', 'import "sync"', 'var only_once sync.Once', 'var builtin_types_map map[string]string',
+           'func set_builtins() {', 'builtin_types_map = map[string]string{',]
+    for k, v in mimetypes.types_map.items():
+        ans.append(f'  "{serialize_as_go_string(k)}": "{serialize_as_go_string(v)}",')
+    ans.append('}}')
+    return '\n'.join(ans)
+
+
+def generate_textual_mimetypes() -> str:
+    ans = ['package utils', 'var KnownTextualMimes = map[string]bool{',]
+    for k in text_mimes:
+        ans.append(f'  "{serialize_as_go_string(k)}": true,')
+    ans.append('}')
+    return '\n'.join(ans)
+
+
+def main() -> None:
+    with replace_if_needed('constants_generated.go') as f:
+        f.write(generate_constants())
+    with replace_if_needed('tools/utils/style/color-names_generated.go') as f:
+        f.write(generate_color_names())
+    with replace_if_needed('tools/tui/readline/actions_generated.go') as f:
+        f.write(generate_readline_actions())
+    with replace_if_needed('tools/tui/spinners_generated.go') as f:
+        f.write(generate_spinners())
+    with replace_if_needed('tools/utils/mimetypes_generated.go') as f:
+        f.write(generate_mimetypes())
+    with replace_if_needed('tools/utils/mimetypes_textual_generated.go') as f:
+        f.write(generate_textual_mimetypes())
+
+    update_completion()
+    update_at_commands()
+    kitten_clis()
+    print(json.dumps(changed, indent=2))
+
+
+if __name__ == '__main__':
+    main()  # }}}

gen-key-constants.py

@@ -2,8 +2,8 @@
 # License: GPLv3 Copyright: 2021, Kovid Goyal <kovid at kovidgoyal.net>
 
 import string
-from typing import Dict, List, Any
 from pprint import pformat
+from typing import Any, Dict, List, Union
 
 functional_key_defs = '''# {{{
 # kitty                     XKB                         macVK  macU
@@ -130,7 +130,7 @@ functional_encoding_overrides = {
 }
 different_trailer_functionals = {
     'up': 'A', 'down': 'B', 'right': 'C', 'left': 'D', 'kp_begin': 'E', 'end': 'F', 'home': 'H',
-    'f1': 'P', 'f2': 'Q', 'f3': 'R', 'f4': 'S', 'enter': 'u', 'tab': 'u',
+    'f1': 'P', 'f2': 'Q', 'f3': '~', 'f4': 'S', 'enter': 'u', 'tab': 'u',
     'backspace': 'u', 'escape': 'u'
 }
 
@@ -248,6 +248,19 @@ def serialize_dict(x: Dict[Any, Any]) -> str:
     return pformat(x, indent=4).replace('{', '{\n ', 1)
 
 
+def serialize_go_dict(x: Union[Dict[str, int], Dict[int, str], Dict[int, int]]) -> str:
+    ans = []
+
+    def s(x: Union[int, str]) -> str:
+        if isinstance(x, int):
+            return str(x)
+        return f'"{x}"'
+
+    for k, v in x.items():
+        ans.append(f'{s(k)}: {s(v)}')
+    return '{' + ', '.join(ans) + '}'
+
+
 def generate_glfw_header() -> None:
     lines = [
         'typedef enum {',
@@ -309,14 +322,20 @@ def generate_functional_table() -> None:
     patch_file('kitty/key_encoding.c', 'special numbers', '\n'.join(enc_lines))
     code_to_name = {v: k.upper() for k, v in name_to_code.items()}
     csi_map = {v: name_to_code[k] for k, v in functional_encoding_overrides.items()}
-    letter_trailer_codes = {
-        v: functional_encoding_overrides.get(k, name_to_code.get(k))
+    letter_trailer_codes: Dict[str, int] = {
+        v: functional_encoding_overrides.get(k, name_to_code.get(k, 0))
         for k, v in different_trailer_functionals.items() if v in 'ABCDEHFPQRSZ'}
     text = f'functional_key_number_to_name_map = {serialize_dict(code_to_name)}'
     text += f'\ncsi_number_to_functional_number_map = {serialize_dict(csi_map)}'
     text += f'\nletter_trailer_to_csi_number_map = {letter_trailer_codes!r}'
     text += f'\ntilde_trailers = {tilde_trailers!r}'
     patch_file('kitty/key_encoding.py', 'csi mapping', text, start_marker='# ', end_marker='')
+    text = f'var functional_key_number_to_name_map = map[int]string{serialize_go_dict(code_to_name)}\n'
+    text += f'\nvar csi_number_to_functional_number_map = map[int]int{serialize_go_dict(csi_map)}\n'
+    text += f'\nvar letter_trailer_to_csi_number_map = map[string]int{serialize_go_dict(letter_trailer_codes)}\n'
+    tt = ', '.join(f'{x}: true' for x in tilde_trailers)
+    text += '\nvar tilde_trailers = map[int]bool{' + f'{tt}' + '}\n'
+    patch_file('tools/tui/loop/key-encoding.go', 'csi mapping', text, start_marker='// ', end_marker='')
 
 
 def generate_legacy_text_key_maps() -> None:

gen-wcwidth.py

@@ -3,17 +3,26 @@
 
 import os
 import re
+import subprocess
 import sys
 from collections import defaultdict
 from contextlib import contextmanager
-from datetime import date
-from functools import partial
+from functools import lru_cache, partial
 from html.entities import html5
 from itertools import groupby
 from operator import itemgetter
 from typing import (
-    Callable, DefaultDict, Dict, FrozenSet, Generator, Iterable, List,
-    Optional, Set, Tuple, Union
+    Callable,
+    DefaultDict,
+    Dict,
+    FrozenSet,
+    Generator,
+    Iterable,
+    List,
+    Optional,
+    Set,
+    Tuple,
+    Union,
 )
 from urllib.request import urlopen
 
@@ -44,6 +53,15 @@ def get_data(fname: str, folder: str = 'UCD') -> Iterable[str]:
             yield line
 
 
+@lru_cache(maxsize=2)
+def unicode_version() -> Tuple[int, int, int]:
+    for line in get_data("ReadMe.txt"):
+        m = re.search(r'Version\s+(\d+)\.(\d+)\.(\d+)', line)
+        if m is not None:
+            return int(m.group(1)), int(m.group(2)), int(m.group(3))
+    raise ValueError('Could not find Unicode Version')
+
+
 # Map of class names to set of codepoints in class
 class_maps: Dict[str, Set[int]] = {}
 all_symbols: Set[int] = set()
@@ -254,9 +272,13 @@ def get_ranges(items: List[int]) -> Generator[Union[int, Tuple[int, int]], None,
             yield a, b
 
 
-def write_case(spec: Union[Tuple[int, ...], int], p: Callable[..., None]) -> None:
+def write_case(spec: Union[Tuple[int, ...], int], p: Callable[..., None], for_go: bool = False) -> None:
     if isinstance(spec, tuple):
-        p('\t\tcase 0x{:x} ... 0x{:x}:'.format(*spec))
+        if for_go:
+            v = ', '.join(f'0x{x:x}' for x in range(spec[0], spec[1] + 1))
+            p(f'\t\tcase {v}:')
+        else:
+            p('\t\tcase 0x{:x} ... 0x{:x}:'.format(*spec))
     else:
         p(f'\t\tcase 0x{spec:x}:')
 
@@ -265,8 +287,8 @@ def write_case(spec: Union[Tuple[int, ...], int], p: Callable[..., None]) -> Non
 def create_header(path: str, include_data_types: bool = True) -> Generator[Callable[..., None], None, None]:
     with open(path, 'w') as f:
         p = partial(print, file=f)
-        p('// unicode data, built from the unicode standard on:', date.today())
-        p('// see gen-wcwidth.py')
+        p('// Unicode data, built from the Unicode Standard', '.'.join(map(str, unicode_version())))
+        p(f'// Code generated by {os.path.basename(__file__)}, DO NOT EDIT.', end='\n\n')
         if path.endswith('.h'):
             p('#pragma once')
         if include_data_types:
@@ -476,7 +498,7 @@ def gen_names() -> None:
 
         # The trie
         p('typedef struct { uint32_t children_offset; uint32_t match_offset; } word_trie;\n')
-        all_trie_nodes: List['TrieNode'] = []  # noqa
+        all_trie_nodes: List['TrieNode'] = []
 
         class TrieNode:
 
@@ -524,45 +546,69 @@ def gen_names() -> None:
 
 def gen_wcwidth() -> None:
     seen: Set[int] = set()
+    non_printing = class_maps['Cc'] | class_maps['Cf'] | class_maps['Cs']
 
-    def add(p: Callable[..., None], comment: str, chars_: Union[Set[int], FrozenSet[int]], ret: int) -> None:
+    def add(p: Callable[..., None], comment: str, chars_: Union[Set[int], FrozenSet[int]], ret: int, for_go: bool = False) -> None:
         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)
+            write_case(spec, p, for_go)
             p(f'\t\t\treturn {ret};')
         p('\t\t// }}}\n')
 
-    with create_header('kitty/wcwidth-std.h') as p:
-        p('static inline int\nwcwidth_std(int32_t code) {')
-        p('\tif (LIKELY(0x20 <= code && code <= 0x7e)) return 1;')
-        p('\tswitch(code) {')
+    def add_all(p: Callable[..., None], for_go: bool = False) -> None:
+        seen.clear()
+        add(p, 'Flags', flag_codepoints, 2, for_go)
+        add(p, 'Marks', marks | {0}, 0, for_go)
+        add(p, 'Non-printing characters', non_printing, -1, for_go)
+        add(p, 'Private use', class_maps['Co'], -3, for_go)
+        add(p, 'Text Presentation', narrow_emoji, 1, for_go)
+        add(p, 'East Asian ambiguous width', ambiguous, -2, for_go)
+        add(p, 'East Asian double width', doublewidth, 2, for_go)
+        add(p, 'Emoji Presentation', wide_emoji, 2, for_go)
 
-        non_printing = class_maps['Cc'] | class_maps['Cf'] | class_maps['Cs']
-        add(p, 'Flags', flag_codepoints, 2)
-        add(p, 'Marks', marks | {0}, 0)
-        add(p, 'Non-printing characters', non_printing, -1)
-        add(p, 'Private use', class_maps['Co'], -3)
-        add(p, 'Text Presentation', narrow_emoji, 1)
-        add(p, 'East Asian ambiguous width', ambiguous, -2)
-        add(p, 'East Asian double width', doublewidth, 2)
-        add(p, 'Emoji Presentation', wide_emoji, 2)
+        add(p, 'Not assigned in the unicode character database', not_assigned, -4, for_go)
 
-        add(p, 'Not assigned in the unicode character database', not_assigned, -4)
-
-        p('\t\tdefault: return 1;')
+        p('\t\tdefault:\n\t\t\treturn 1;')
         p('\t}')
-        p('\treturn 1;\n}')
+        if for_go:
+            p('\t}')
+        else:
+            p('\treturn 1;\n}')
+
+    with create_header('kitty/wcwidth-std.h') as p, open('tools/wcswidth/std.go', 'w') as gof:
+        gop = partial(print, file=gof)
+        gop('package wcswidth\n\n')
+        gop('func Runewidth(code rune) int {')
+        p('static inline int\nwcwidth_std(int32_t code) {')
+        p('\tif (LIKELY(0x20 <= code && code <= 0x7e)) { return 1; }')
+        p('\tswitch(code) {')
+        gop('\tswitch(code) {')
+        add_all(p)
+        add_all(gop, True)
 
         p('static inline bool\nis_emoji_presentation_base(uint32_t code) {')
+        gop('func IsEmojiPresentationBase(code rune) bool {')
         p('\tswitch(code) {')
+        gop('\tswitch(code) {')
         for spec in get_ranges(list(emoji_presentation_bases)):
             write_case(spec, p)
+            write_case(spec, gop, for_go=True)
             p('\t\t\treturn true;')
+            gop('\t\t\treturn true;')
         p('\t\tdefault: return false;')
         p('\t}')
-        p('\treturn 1;\n}')
+        gop('\t\tdefault:\n\t\t\treturn false')
+        gop('\t}')
+        p('\treturn true;\n}')
+        gop('\n}')
+        uv = unicode_version()
+        p(f'#define UNICODE_MAJOR_VERSION {uv[0]}')
+        p(f'#define UNICODE_MINOR_VERSION {uv[1]}')
+        p(f'#define UNICODE_PATCH_VERSION {uv[2]}')
+        gop('var UnicodeDatabaseVersion [3]int = [3]int{' f'{uv[0]}, {uv[1]}, {uv[2]}' + '}')
+    subprocess.check_call(['gofmt', '-w', '-s', gof.name])
 
 
 parse_ucd()

glad/generate.py

@@ -8,7 +8,6 @@ import shlex
 import shutil
 import subprocess
 
-
 cmdline = (
     'glad --out-path {dest} --api gl:core=3.3 '
     ' --extensions GL_ARB_texture_storage,GL_ARB_copy_image,GL_ARB_multisample,GL_ARB_robustness,GL_KHR_debug '

glfw/cocoa_init.m

@@ -770,6 +770,11 @@ is_useful_apple_global_shortcut(int sc) {
     }
 }
 
+static bool
+is_apple_jis_layout_function_key(NSEvent *event) {
+    return [event keyCode] == 0x66 /* kVK_JIS_Eisu */ || [event keyCode] == 0x68 /* kVK_JIS_Kana */;
+}
+
 GLFWAPI GLFWapplicationshouldhandlereopenfun glfwSetApplicationShouldHandleReopen(GLFWapplicationshouldhandlereopenfun callback) {
     GLFWapplicationshouldhandlereopenfun previous = handle_reopen_callback;
     handle_reopen_callback = callback;
@@ -837,6 +842,14 @@ int _glfwPlatformInit(void)
                 last_keydown_shortcut_event.timestamp = [event timestamp];
                 return event;
             }
+            // check for JIS keyboard layout function keys
+            if (is_apple_jis_layout_function_key(event)) {
+                debug_key("keyDown triggerred JIS layout function key ignoring\n");
+                last_keydown_shortcut_event.virtual_key_code = [event keyCode];
+                last_keydown_shortcut_event.input_source_switch_modifiers = 0;
+                last_keydown_shortcut_event.timestamp = [event timestamp];
+                return event;
+            }
         }
         last_keydown_shortcut_event.virtual_key_code = 0xffff;
         NSWindow *kw = [NSApp keyWindow];
@@ -979,8 +992,6 @@ void _glfwPlatformTerminate(void)
         _glfw.ns.appleSettings = nil;
     }
 
-    free(_glfw.ns.clipboardString);
-
     _glfwTerminateNSGL();
     if (global_shortcuts != nil) { [global_shortcuts release]; global_shortcuts = nil; }
 

glfw/cocoa_platform.h

@@ -183,7 +183,6 @@ typedef struct _GLFWlibraryNS
 
     char                keyName[64];
     char                text[256];
-    char*               clipboardString;
     CGPoint             cascadePoint;
     // Where to place the cursor when re-enabled
     double              restoreCursorPosX, restoreCursorPosY;

glfw/cocoa_window.m

@@ -29,6 +29,9 @@
 #include "internal.h"
 #include "../kitty/monotonic.h"
 
+#include <Availability.h>
+#import <CoreServices/CoreServices.h>
+#import <UniformTypeIdentifiers/UniformTypeIdentifiers.h>
 #include <float.h>
 #include <string.h>
 
@@ -1540,6 +1543,102 @@ void _glfwPlatformUpdateIMEState(_GLFWwindow *w, const GLFWIMEUpdateEvent *ev) {
     debug_key("\n\tdoCommandBySelector: (%s)\n", [NSStringFromSelector(selector) UTF8String]);
 }
 
+- (BOOL)isAccessibilityElement
+{
+    return YES;
+}
+
+- (BOOL)isAccessibilitySelectorAllowed:(SEL)selector
+{
+    if (selector == @selector(accessibilityRole) || selector == @selector(accessibilitySelectedText)) return YES;
+    return NO;
+}
+
+#if (TARGET_OS_OSX && __MAC_OS_X_VERSION_MIN_REQUIRED >= 101400)
+
+- (NSAccessibilityRole)accessibilityRole
+{
+    return NSAccessibilityTextAreaRole;
+}
+
+#endif
+
+- (NSString *)accessibilitySelectedText
+{
+    NSString *text = nil;
+    if (_glfw.callbacks.get_current_selection) {
+        char *s = _glfw.callbacks.get_current_selection();
+        if (s) {
+            text = [NSString stringWithUTF8String:s];
+            free(s);
+        }
+    }
+    return text;
+}
+
+// <https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/SysServices/Articles/using.html>
+
+// Support services receiving "public.utf8-plain-text" and "NSStringPboardType"
+- (id)validRequestorForSendType:(NSString *)sendType returnType:(NSString *)returnType
+{
+    if (
+        (!sendType || [sendType isEqual:NSPasteboardTypeString] || [sendType isEqual:@"NSStringPboardType"]) &&
+        (!returnType || [returnType isEqual:NSPasteboardTypeString] || [returnType isEqual:@"NSStringPboardType"])
+    ) {
+        if (_glfw.callbacks.has_current_selection && _glfw.callbacks.has_current_selection()) return self;
+    }
+    return [super validRequestorForSendType:sendType returnType:returnType];
+}
+
+// Selected text as input to be sent to Services
+- (BOOL)writeSelectionToPasteboard:(NSPasteboard *)pboard types:(NSArray *)types
+{
+    if (!_glfw.callbacks.get_current_selection) return NO;
+    char *text = _glfw.callbacks.get_current_selection();
+    if (!text) return NO;
+    BOOL ans = NO;
+    if (text[0]) {
+        if ([types containsObject:NSPasteboardTypeString] == YES) {
+            [pboard declareTypes:@[NSPasteboardTypeString] owner:self];
+            ans = [pboard setString:@(text) forType:NSPasteboardTypeString];
+        } else if ([types containsObject:@"NSStringPboardType"] == YES) {
+            [pboard declareTypes:@[@"NSStringPboardType"] owner:self];
+            ans = [pboard setString:@(text) forType:@"NSStringPboardType"];
+        }
+        free(text);
+    }
+    return ans;
+}
+
+// Service output to be handled
+- (BOOL)readSelectionFromPasteboard:(NSPasteboard *)pboard
+{
+    NSString* text = nil;
+    NSArray *types = [pboard types];
+    if ([types containsObject:NSPasteboardTypeString] == YES) {
+        text = [pboard stringForType:NSPasteboardTypeString]; // public.utf8-plain-text
+    } else if ([types containsObject:@"NSStringPboardType"] == YES) {
+        text = [pboard stringForType:@"NSStringPboardType"]; // for older services (need re-encode?)
+    } else {
+        return NO;
+    }
+    if (text && [text length] > 0) {
+        // Terminal.app inserts the output, do the same
+        const char *utf8 = polymorphic_string_as_utf8(text);
+        if ([self hasMarkedText]) {
+            [self unmarkText];
+            debug_key("Clearing pre-edit because insertText called from readSelectionFromPasteboard\n");
+            GLFWkeyevent glfw_keyevent = {.ime_state = GLFW_IME_PREEDIT_CHANGED};
+            _glfwInputKeyboard(window, &glfw_keyevent);
+        }
+        debug_key("Sending text received in readSelectionFromPasteboard as key event\n");
+        GLFWkeyevent glfw_keyevent = {.text=utf8, .ime_state=GLFW_IME_COMMIT_TEXT};
+        _glfwInputKeyboard(window, &glfw_keyevent);
+        return YES;
+    }
+    return NO;
+}
+
 @end
 // }}}
 
@@ -2472,38 +2571,150 @@ bool _glfwPlatformToggleFullscreen(_GLFWwindow* w, unsigned int flags) {
     return made_fullscreen;
 }
 
-void _glfwPlatformSetClipboardString(const char* string)
-{
-    NSPasteboard* pasteboard = [NSPasteboard generalPasteboard];
-    [pasteboard declareTypes:@[NSPasteboardTypeString] owner:nil];
-    [pasteboard setString:@(string) forType:NSPasteboardTypeString];
+// Clipboard {{{
+
+#define UTI_ROUNDTRIP_PREFIX @"uti-is-typical-apple-nih."
+
+static NSString*
+mime_to_uti(const char *mime) {
+    if (strcmp(mime, "text/plain") == 0) return NSPasteboardTypeString;
+    if (@available(macOS 11.0, *)) {
+        UTType *t = [UTType typeWithMIMEType:@(mime)];  // auto-released
+        if (t != nil && !t.dynamic) return t.identifier;
+    }
+    return [NSString stringWithFormat:@"%@%s", UTI_ROUNDTRIP_PREFIX, mime];  // auto-released
 }
 
-const char* _glfwPlatformGetClipboardString(void)
-{
-    NSPasteboard* pasteboard = [NSPasteboard generalPasteboard];
-
-    if (![[pasteboard types] containsObject:NSPasteboardTypeString])
-    {
-        _glfwInputError(GLFW_FORMAT_UNAVAILABLE,
-                        "Cocoa: Failed to retrieve string from pasteboard");
-        return NULL;
+static const char*
+uti_to_mime(NSString *uti) {
+    if ([uti isEqualToString:NSPasteboardTypeString]) return "text/plain";
+    if ([uti hasPrefix:UTI_ROUNDTRIP_PREFIX]) return [[uti substringFromIndex:[UTI_ROUNDTRIP_PREFIX length]] UTF8String];
+    if (@available(macOS 11.0, *)) {
+        UTType *t = [UTType typeWithIdentifier:uti];  // auto-released
+        if (t.preferredMIMEType != nil) return [t.preferredMIMEType UTF8String];
     }
-
-    NSString* object = [pasteboard stringForType:NSPasteboardTypeString];
-    if (!object)
-    {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Cocoa: Failed to retrieve object from pasteboard");
-        return NULL;
-    }
-
-    free(_glfw.ns.clipboardString);
-    _glfw.ns.clipboardString = _glfw_strdup([object UTF8String]);
-
-    return _glfw.ns.clipboardString;
+    return "";
 }
 
+static void
+list_clipboard_mimetypes(GLFWclipboardwritedatafun write_data, void *object) {
+#define w(x) { if (ok) ok = write_data(object, x, strlen(x)); }
+    NSPasteboard* pasteboard = [NSPasteboard generalPasteboard];
+    NSDictionary* options = @{NSPasteboardURLReadingFileURLsOnlyKey:@YES};
+    BOOL has_file_urls = [pasteboard canReadObjectForClasses:@[[NSURL class]] options:options];
+    BOOL has_strings = [pasteboard canReadObjectForClasses:@[[NSString class]] options:nil];
+    /* NSLog(@"has_file_urls: %d has_strings: %d", has_file_urls, has_strings); */
+    bool ok = true;
+    if (has_strings) w("text/plain");
+    if (has_file_urls) w("text/local-path-list");
+    for (NSPasteboardItem * item in pasteboard.pasteboardItems) {
+        for (NSPasteboardType type in item.types) {
+            /* NSLog(@"%@", type); */
+            const char *mime = uti_to_mime(type);
+            if (mime && mime[0] && ![@(mime) hasPrefix:@"text/plain"]) {
+                /* NSLog(@"ut: %@ mt: %@ tags: %@", ut, ut.preferredMIMEType, ut.tags); */
+                w(mime);
+            }
+        }
+    }
+#undef w
+}
+
+static void
+get_text_plain(GLFWclipboardwritedatafun write_data, void *object) {
+    NSPasteboard* pasteboard = [NSPasteboard generalPasteboard];
+    NSDictionary* options = @{NSPasteboardURLReadingFileURLsOnlyKey:@YES};
+    NSArray* objs = [pasteboard readObjectsForClasses:@[[NSURL class], [NSString class]] options:options];
+    bool found = false;
+    if (objs) {
+        const NSUInteger count = [objs count];
+        if (count) {
+            NSMutableData *path_list = [NSMutableData dataWithCapacity:4096];  // auto-released
+            NSMutableData *text_list = [NSMutableData dataWithCapacity:4096];  // auto-released
+            for (NSUInteger i = 0;  i < count;  i++) {
+                id obj = objs[i];
+                if ([obj isKindOfClass:[NSURL class]]) {
+                    NSURL *url = (NSURL*)obj;
+                    if (url.fileURL && url.fileSystemRepresentation) {
+                        if ([path_list length] > 0) [path_list appendBytes:"\n" length:1];
+                        [path_list appendBytes:url.fileSystemRepresentation length:strlen(url.fileSystemRepresentation)];
+                    }
+                } else if ([obj isKindOfClass:[NSString class]]) {
+                    if ([text_list length] > 0) [text_list appendBytes:"\n" length:1];
+                    [text_list appendData:[obj dataUsingEncoding:NSUTF8StringEncoding]];
+                }
+            }
+            const NSMutableData *text = nil;
+            if (path_list.length > 0) text = path_list;
+            else if (text_list.length > 0) text = text_list;
+            if (text) {
+                found = true;
+                write_data(object, text.mutableBytes, text.length);
+            }
+        }
+    }
+    if (!found) _glfwInputError(GLFW_PLATFORM_ERROR, "Cocoa: Failed to retrieve text/plain from pasteboard");
+}
+
+void
+_glfwPlatformGetClipboard(GLFWClipboardType clipboard_type, const char* mime_type, GLFWclipboardwritedatafun write_data, void *object) {
+    if (clipboard_type != GLFW_CLIPBOARD) return;
+    if (mime_type == NULL) {
+        list_clipboard_mimetypes(write_data, object);
+        return;
+    }
+    if (strcmp(mime_type, "text/plain") == 0) {
+        get_text_plain(write_data, object);
+        return;
+    }
+    NSPasteboard* pasteboard = [NSPasteboard generalPasteboard];
+    /* NSLog(@"mime: %s uti: %@", mime_type, mime_to_uti(mime_type)); */
+    NSPasteboardType t = [pasteboard availableTypeFromArray:@[mime_to_uti(mime_type)]];
+    /* NSLog(@"available type: %@", t); */
+    if (t != nil) {
+        NSData *data = [pasteboard dataForType:t];  // auto-released
+        /* NSLog(@"data: %@", data); */
+        if (data != nil && data.length > 0) {
+            write_data(object, data.bytes, data.length);
+        }
+    }
+}
+
+static NSMutableData*
+get_clipboard_data(const _GLFWClipboardData *cd, const char *mime) {
+    NSMutableData *ans = [NSMutableData dataWithCapacity:8192];
+    if (ans == nil) return nil;
+    GLFWDataChunk chunk = cd->get_data(mime, NULL, cd->ctype);
+    void *iter = chunk.iter;
+    if (!iter) return ans;
+    while (true) {
+        chunk = cd->get_data(mime, iter, cd->ctype);
+        if (!chunk.sz) break;
+        [ans appendBytes:chunk.data length:chunk.sz];
+        if (chunk.free) chunk.free((void*)chunk.free_data);
+    }
+    cd->get_data(NULL, iter, cd->ctype);
+    return ans;
+}
+
+
+void
+_glfwPlatformSetClipboard(GLFWClipboardType t) {
+    if (t != GLFW_CLIPBOARD) return;
+    NSPasteboard* pasteboard = [NSPasteboard generalPasteboard];
+    NSMutableArray<NSPasteboardType> *ptypes = [NSMutableArray arrayWithCapacity:_glfw.clipboard.num_mime_types];  // auto-released
+    for (size_t i = 0; i < _glfw.clipboard.num_mime_types; i++) {
+        [ptypes addObject:mime_to_uti(_glfw.clipboard.mime_types[i])];
+    }
+    [pasteboard declareTypes:ptypes owner:nil];
+    for (size_t i = 0; i < _glfw.clipboard.num_mime_types; i++) {
+        NSMutableData *data = get_clipboard_data(&_glfw.clipboard, _glfw.clipboard.mime_types[i]);  // auto-released
+        /* NSLog(@"putting data: %@ for: %s with UTI: %@", data, _glfw.clipboard.mime_types[i], ptypes[i]); */
+        if (data != nil) [pasteboard setData:data forType:ptypes[i]];
+    }
+}
+// }}}
+
 EGLenum _glfwPlatformGetEGLPlatform(EGLint** attribs)
 {
     if (_glfw.egl.ANGLE_platform_angle)

glfw/context.c

@@ -396,15 +396,6 @@ bool _glfwRefreshContextAttribs(_GLFWwindow* window,
             window->context.release = GLFW_RELEASE_BEHAVIOR_FLUSH;
     }
 
-    // Clearing the front buffer to black to avoid garbage pixels left over from
-    // previous uses of our bit of VRAM
-    {
-        PFNGLCLEARPROC glClear = (PFNGLCLEARPROC)
-            window->context.getProcAddress("glClear");
-        glClear(GL_COLOR_BUFFER_BIT);
-        window->context.swapBuffers(window);
-    }
-
     glfwMakeContextCurrent((GLFWwindow*) previous);
     return true;
 }
@@ -487,6 +478,9 @@ GLFWAPI void glfwSwapBuffers(GLFWwindow* handle)
     }
 
     window->context.swapBuffers(window);
+#ifdef _GLFW_WAYLAND
+    _glfwWaylandAfterBufferSwap(window);
+#endif
 }
 
 GLFWAPI void glfwSwapInterval(int interval)

glfw/egl_context.c

@@ -326,6 +326,7 @@ bool _glfwInitEGL(void)
     glfw_dlsym(_glfw.egl.SwapBuffers, _glfw.egl.handle, "eglSwapBuffers");
     glfw_dlsym(_glfw.egl.SwapInterval, _glfw.egl.handle, "eglSwapInterval");
     glfw_dlsym(_glfw.egl.QueryString, _glfw.egl.handle, "eglQueryString");
+    glfw_dlsym(_glfw.egl.QuerySurface, _glfw.egl.handle, "eglQuerySurface");
     glfw_dlsym(_glfw.egl.GetProcAddress, _glfw.egl.handle, "eglGetProcAddress");
 
     if (!_glfw.egl.GetConfigAttrib ||
@@ -428,6 +429,8 @@ bool _glfwInitEGL(void)
         extensionSupportedEGL("EGL_KHR_get_all_proc_addresses");
     _glfw.egl.KHR_context_flush_control =
         extensionSupportedEGL("EGL_KHR_context_flush_control");
+    _glfw.egl.EXT_present_opaque =
+        extensionSupportedEGL("EGL_EXT_present_opaque");
 
     return true;
 }
@@ -598,6 +601,11 @@ bool _glfwCreateContextEGL(_GLFWwindow* window,
         if (_glfw.egl.KHR_gl_colorspace)
             setAttrib(EGL_GL_COLORSPACE_KHR, EGL_GL_COLORSPACE_SRGB_KHR);
     }
+    // Disabled because it prevents transparency from working on NVIDIA drivers under Wayland
+    // https://github.com/kovidgoyal/kitty/issues/5479
+    // We anyway dont use the alpha bits for anything.
+    /* if (_glfw.egl.EXT_present_opaque) */
+    /*     setAttrib(EGL_PRESENT_OPAQUE_EXT, !fbconfig->transparent); */
 
     setAttrib(EGL_NONE, EGL_NONE);
 

glfw/egl_context.h

@@ -132,6 +132,7 @@ typedef EGLBoolean (EGLAPIENTRY * PFN_eglMakeCurrent)(EGLDisplay,EGLSurface,EGLS
 typedef EGLBoolean (EGLAPIENTRY * PFN_eglSwapBuffers)(EGLDisplay,EGLSurface);
 typedef EGLBoolean (EGLAPIENTRY * PFN_eglSwapInterval)(EGLDisplay,EGLint);
 typedef const char* (EGLAPIENTRY * PFN_eglQueryString)(EGLDisplay,EGLint);
+typedef const char* (EGLAPIENTRY * PFN_eglQuerySurface)(EGLDisplay,EGLSurface,EGLint,EGLint*);
 typedef GLFWglproc (EGLAPIENTRY * PFN_eglGetProcAddress)(const char*);
 #define eglGetConfigAttrib _glfw.egl.GetConfigAttrib
 #define eglGetConfigs _glfw.egl.GetConfigs
@@ -149,6 +150,7 @@ typedef GLFWglproc (EGLAPIENTRY * PFN_eglGetProcAddress)(const char*);
 #define eglSwapBuffers _glfw.egl.SwapBuffers
 #define eglSwapInterval _glfw.egl.SwapInterval
 #define eglQueryString _glfw.egl.QueryString
+#define eglQuerySurface _glfw.egl.QuerySurface
 #define eglGetProcAddress _glfw.egl.GetProcAddress
 
 typedef EGLDisplay (EGLAPIENTRY * PFNEGLGETPLATFORMDISPLAYEXTPROC)(EGLenum,void*,const EGLint*);
@@ -160,11 +162,11 @@ typedef EGLSurface (EGLAPIENTRY * PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC)(EGLD
 //
 typedef struct _GLFWcontextEGL
 {
-   EGLConfig        config;
-   EGLContext       handle;
-   EGLSurface       surface;
+    EGLConfig        config;
+    EGLContext       handle;
+    EGLSurface       surface;
 
-   void*            client;
+    void*            client;
 
 } _GLFWcontextEGL;
 
@@ -186,6 +188,7 @@ typedef struct _GLFWlibraryEGL
     bool            EXT_platform_base;
     bool            EXT_platform_x11;
     bool            EXT_platform_wayland;
+    bool            EXT_present_opaque;
     bool            ANGLE_platform_angle;
     bool            ANGLE_platform_angle_opengl;
     bool            ANGLE_platform_angle_d3d;
@@ -210,6 +213,7 @@ typedef struct _GLFWlibraryEGL
     PFN_eglSwapBuffers          SwapBuffers;
     PFN_eglSwapInterval         SwapInterval;
     PFN_eglQueryString          QueryString;
+    PFN_eglQuerySurface         QuerySurface;
     PFN_eglGetProcAddress       GetProcAddress;
 
     PFNEGLGETPLATFORMDISPLAYEXTPROC GetPlatformDisplayEXT;

glfw/glfw.py

@@ -14,6 +14,10 @@ is_openbsd = 'openbsd' in _plat
 base = os.path.dirname(os.path.abspath(__file__))
 
 
+def null_func() -> None:
+    return None
+
+
 class CompileKey(NamedTuple):
     src: str
     dest: str
@@ -23,7 +27,7 @@ class Command(NamedTuple):
     desc: str
     cmd: Sequence[str]
     is_newer_func: Callable[[], bool]
-    on_success: Callable[[], None] = lambda: None
+    on_success: Callable[[], None] = null_func
     key: Optional[CompileKey] = None
     keyfile: Optional[str] = None
 
@@ -111,7 +115,7 @@ def init_env(
 
     elif module == 'cocoa':
         ans.cppflags.append('-DGL_SILENCE_DEPRECATION')
-        for f_ in 'Cocoa IOKit CoreFoundation CoreVideo'.split():
+        for f_ in 'Cocoa IOKit CoreFoundation CoreVideo UniformTypeIdentifiers'.split():
             ans.ldpaths.extend(('-framework', f_))
 
     elif module == 'wayland':
@@ -172,6 +176,8 @@ class Arg:
         while self.name.startswith('*'):
             self.name = self.name[1:]
             self.type = self.type + '*'
+        if '[' in self.name:
+            self.type += '[' + self.name.partition('[')[-1]
 
     def __repr__(self) -> str:
         return f'Arg({self.type}, {self.name})'
@@ -245,11 +251,15 @@ def generate_wrappers(glfw_header: str) -> None:
     const char* glfwGetPrimarySelectionString(GLFWwindow* window, void)
     int glfwGetNativeKeyForName(const char* key_name, int case_sensitive)
     void glfwRequestWaylandFrameEvent(GLFWwindow *handle, unsigned long long id, GLFWwaylandframecallbackfunc callback)
+    void glfwWaylandActivateWindow(GLFWwindow *handle, const char *activation_token)
+    void glfwWaylandRunWithActivationToken(GLFWwindow *handle, GLFWactivationcallback cb, void *cb_data)
     bool glfwWaylandSetTitlebarColor(GLFWwindow *handle, uint32_t color, bool use_system_color)
     unsigned long long glfwDBusUserNotify(const char *app_name, const char* icon, const char *summary, const char *body, \
 const char *action_text, int32_t timeout, GLFWDBusnotificationcreatedfun callback, void *data)
     void glfwDBusSetUserNotificationHandler(GLFWDBusnotificationactivatedfun handler)
     int glfwSetX11LaunchCommand(GLFWwindow *handle, char **argv, int argc)
+    void glfwSetX11WindowAsDock(int32_t x11_window_id)
+    void glfwSetX11WindowStrut(int32_t x11_window_id, uint32_t dimensions[12])
 '''.splitlines():
         if line:
             functions.append(Function(line.strip(), check_fail=False))

glfw/glfw3.h

@@ -512,6 +512,7 @@ typedef enum {
  *  GLFW_LOCK_KEY_MODS input mode is set.
  */
 #define GLFW_MOD_NUM_LOCK        0x0080
+#define GLFW_MOD_LAST            GLFW_MOD_NUM_LOCK
 #define GLFW_LOCK_MASK           (GLFW_MOD_NUM_LOCK | GLFW_MOD_CAPS_LOCK)
 
 /*! @} */
@@ -1715,7 +1716,22 @@ typedef void (* GLFWjoystickfun)(int,int);
 
 typedef void (* GLFWuserdatafun)(unsigned long long, void*);
 typedef void (* GLFWtickcallback)(void*);
+typedef void (* GLFWactivationcallback)(GLFWwindow *window, const char *token, void *data);
 typedef bool (* GLFWdrawtextfun)(GLFWwindow *window, const char *text, uint32_t fg, uint32_t bg, uint8_t *output_buf, size_t width, size_t height, float x_offset, float y_offset, size_t right_margin);
+typedef char* (* GLFWcurrentselectionfun)(void);
+typedef bool (* GLFWhascurrentselectionfun)(void);
+typedef void (* GLFWclipboarddatafreefun)(void* data);
+typedef struct GLFWDataChunk {
+    const char *data;
+    size_t sz;
+    GLFWclipboarddatafreefun free;
+    void *iter, *free_data;
+} GLFWDataChunk;
+typedef enum {
+    GLFW_CLIPBOARD, GLFW_PRIMARY_SELECTION
+} GLFWClipboardType;
+typedef GLFWDataChunk (* GLFWclipboarditerfun)(const char *mime_type, void *iter, GLFWClipboardType ctype);
+typedef bool (* GLFWclipboardwritedatafun)(void *object, const char *data, size_t sz);
 
 /*! @brief Video mode type.
  *
@@ -1873,6 +1889,8 @@ GLFWAPI unsigned long long glfwAddTimer(monotonic_t interval, bool repeats, GLFW
 GLFWAPI void glfwUpdateTimer(unsigned long long timer_id, monotonic_t interval, bool enabled);
 GLFWAPI void glfwRemoveTimer(unsigned long long);
 GLFWAPI GLFWdrawtextfun glfwSetDrawTextFunction(GLFWdrawtextfun function);
+GLFWAPI GLFWcurrentselectionfun glfwSetCurrentSelectionCallback(GLFWcurrentselectionfun callback);
+GLFWAPI GLFWhascurrentselectionfun glfwSetHasCurrentSelectionCallback(GLFWhascurrentselectionfun callback);
 
 /*! @brief Terminates the GLFW library.
  *
@@ -2768,6 +2786,7 @@ GLFWAPI void glfwWindowHintString(int hint, const char* value);
 GLFWAPI GLFWwindow* glfwCreateWindow(int width, int height, const char* title, GLFWmonitor* monitor, GLFWwindow* share);
 GLFWAPI bool glfwToggleFullscreen(GLFWwindow *window, unsigned int flags);
 GLFWAPI bool glfwIsFullscreen(GLFWwindow *window, unsigned int flags);
+GLFWAPI bool glfwAreSwapsAllowed(const GLFWwindow* window);
 
 /*! @brief Destroys the specified window and its context.
  *
@@ -5216,64 +5235,8 @@ GLFWAPI const char* glfwGetGamepadName(int jid);
  */
 GLFWAPI int glfwGetGamepadState(int jid, GLFWgamepadstate* state);
 
-/*! @brief Sets the clipboard to the specified string.
- *
- *  This function sets the system clipboard to the specified, UTF-8 encoded
- *  string.
- *
- *  @param[in] window Deprecated.  Any valid window or `NULL`.
- *  @param[in] string A UTF-8 encoded string.
- *
- *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
- *  GLFW_PLATFORM_ERROR.
- *
- *  @remark @wayland Clipboard is currently unimplemented.
- *
- *  @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 clipboard
- *  @sa @ref glfwGetClipboardString
- *
- *  @since Added in version 3.0.
- *
- *  @ingroup input
- */
-GLFWAPI void glfwSetClipboardString(GLFWwindow* window, const char* string);
-
-/*! @brief Returns the contents of the clipboard as a string.
- *
- *  This function returns the contents of the system clipboard, if it contains
- *  or is convertible to a UTF-8 encoded string.  If the clipboard is empty or
- *  if its contents cannot be converted, `NULL` is returned and a @ref
- *  GLFW_FORMAT_UNAVAILABLE error is generated.
- *
- *  @param[in] window Deprecated.  Any valid window or `NULL`.
- *  @return The contents of the clipboard as a UTF-8 encoded string, or `NULL`
- *  if an [error](@ref error_handling) occurred.
- *
- *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
- *  GLFW_PLATFORM_ERROR.
- *
- *  @remark @wayland Clipboard is currently unimplemented.
- *
- *  @pointer_lifetime The returned string is allocated and freed by GLFW.  You
- *  should not free it yourself.  It is valid until the next call to @ref
- *  glfwGetClipboardString or @ref glfwSetClipboardString, or until the library
- *  is terminated.
- *
- *  @thread_safety This function must only be called from the main thread.
- *
- *  @sa @ref clipboard
- *  @sa @ref glfwSetClipboardString
- *
- *  @since Added in version 3.0.
- *
- *  @ingroup input
- */
-GLFWAPI const char* glfwGetClipboardString(GLFWwindow* window);
+GLFWAPI void glfwSetClipboardDataTypes(GLFWClipboardType clipboard_type, const char* const *mime_types, size_t num_mime_types, GLFWclipboarditerfun get_iter);
+GLFWAPI void glfwGetClipboard(GLFWClipboardType clipboard_type, const char* mime_type, GLFWclipboardwritedatafun write_data, void *object);
 
 /*! @brief Returns the GLFW time.
  *

glfw/ibus_glfw.c

@@ -283,29 +283,35 @@ static const char*
 get_ibus_address_file_name(void) {
     const char *addr;
     static char ans[PATH_MAX];
+    static char display[64] = {0};
     addr = getenv("IBUS_ADDRESS");
     int offset = 0;
     if (addr && addr[0]) {
         memcpy(ans, addr, GLFW_MIN(strlen(addr), sizeof(ans)));
         return ans;
     }
-
-    const char *de = getenv("DISPLAY");
-    if (!de || !de[0]) de = ":0.0";
-    char *display = _glfw_strdup(de);
-    const char *host = display;
-    char *disp_num  = strrchr(display, ':');
-    char *screen_num = strrchr(display, '.');
-
-    if (!disp_num) {
-        _glfwInputError(GLFW_PLATFORM_ERROR, "Could not get IBUS address file name as DISPLAY env var has no colon");
-        free(display);
-        return NULL;
+    const char* disp_num = NULL;
+    const char *host = "unix";
+    // See https://github.com/ibus/ibus/commit/8ce25208c3f4adfd290a032c6aa739d2b7580eb1 for why we need this dance.
+    const char *de = getenv("WAYLAND_DISPLAY");
+    if (de) {
+        disp_num = de;
+    } else {
+        const char *de = getenv("DISPLAY");
+        if (!de || !de[0]) de = ":0.0";
+        strncpy(display, de, sizeof(display) - 1);
+        char *dnum = strrchr(display, ':');
+        if (!dnum) {
+            _glfwInputError(GLFW_PLATFORM_ERROR, "Could not get IBUS address file name as DISPLAY env var has no colon");
+            return NULL;
+        }
+        char *screen_num = strrchr(display, '.');
+        *dnum = 0;
+        dnum++;
+        if (screen_num) *screen_num = 0;
+        if (*display) host = display;
+        disp_num = dnum;
     }
-    *disp_num = 0;
-    disp_num++;
-    if (screen_num) *screen_num = 0;
-    if (!*host) host = "unix";
 
     memset(ans, 0, sizeof(ans));
     const char *conf_env = getenv("XDG_CONFIG_HOME");
@@ -315,7 +321,6 @@ get_ibus_address_file_name(void) {
         conf_env = getenv("HOME");
         if (!conf_env || !conf_env[0]) {
             _glfwInputError(GLFW_PLATFORM_ERROR, "Could not get IBUS address file name as no HOME env var is set");
-            free(display);
             return NULL;
         }
         offset = snprintf(ans, sizeof(ans), "%s/.config", conf_env);
@@ -323,7 +328,6 @@ get_ibus_address_file_name(void) {
     char *key = dbus_get_local_machine_id();
     snprintf(ans + offset, sizeof(ans) - offset, "/ibus/bus/%s-%s-%s", key, host, disp_num);
     dbus_free(key);
-    free(display);
     return ans;
 }
 
@@ -383,12 +387,12 @@ input_context_created(DBusMessage *msg, const char* errmsg, void *data) {
     enum Capabilities caps = IBUS_CAP_FOCUS | IBUS_CAP_PREEDIT_TEXT;
     if (!glfw_dbus_call_method_no_reply(ibus->conn, IBUS_SERVICE, ibus->input_ctx_path, IBUS_INPUT_INTERFACE, "SetCapabilities", DBUS_TYPE_UINT32, &caps, DBUS_TYPE_INVALID)) return;
     ibus->ok = true;
-    glfw_ibus_set_focused(ibus, false);
+    glfw_ibus_set_focused(ibus, _glfwFocusedWindow() != NULL);
     glfw_ibus_set_cursor_geometry(ibus, 0, 0, 0, 0);
     debug("Connected to IBUS daemon for IME input management\n");
 }
 
-bool
+static bool
 setup_connection(_GLFWIBUSData *ibus) {
     const char *client_name = "GLFW_Application";
     const char *address_file_name = get_ibus_address_file_name();

glfw/init.c

@@ -68,6 +68,8 @@ static void terminate(void)
     int i;
 
     memset(&_glfw.callbacks, 0, sizeof(_glfw.callbacks));
+    _glfw_free_clipboard_data(&_glfw.clipboard);
+    _glfw_free_clipboard_data(&_glfw.primary);
 
     while (_glfw.windowListHead)
         glfwDestroyWindow((GLFWwindow*) _glfw.windowListHead);
@@ -386,3 +388,17 @@ GLFWAPI GLFWdrawtextfun glfwSetDrawTextFunction(GLFWdrawtextfun cbfun)
     _GLFW_SWAP_POINTERS(_glfw.callbacks.draw_text, cbfun);
     return cbfun;
 }
+
+GLFWAPI GLFWcurrentselectionfun glfwSetCurrentSelectionCallback(GLFWcurrentselectionfun cbfun)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(_glfw.callbacks.get_current_selection, cbfun);
+    return cbfun;
+}
+
+GLFWAPI GLFWhascurrentselectionfun glfwSetHasCurrentSelectionCallback(GLFWhascurrentselectionfun cbfun)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(_glfw.callbacks.has_current_selection, cbfun);
+    return cbfun;
+}

glfw/input.c

@@ -1526,36 +1526,41 @@ GLFWAPI int glfwGetGamepadState(int jid, GLFWgamepadstate* state)
     return true;
 }
 
-GLFWAPI void glfwSetClipboardString(GLFWwindow* handle UNUSED, const char* string)
-{
-    assert(string != NULL);
+void _glfw_free_clipboard_data(_GLFWClipboardData *cd) {
+    if (cd->mime_types) {
+        for (size_t i = 0; i < cd->num_mime_types; i++) free((void*)cd->mime_types[i]);
+        free((void*)cd->mime_types);
+    }
+    memset(cd, 0, sizeof(cd[0]));
+}
 
+GLFWAPI void glfwGetClipboard(GLFWClipboardType clipboard_type, const char* mime_type, GLFWclipboardwritedatafun write_data, void *object) {
     _GLFW_REQUIRE_INIT();
-    _glfwPlatformSetClipboardString(string);
+    _glfwPlatformGetClipboard(clipboard_type, mime_type, write_data, object);
 }
 
-GLFWAPI const char* glfwGetClipboardString(GLFWwindow* handle UNUSED)
-{
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-    return _glfwPlatformGetClipboardString();
-}
-
-#if defined(_GLFW_X11) || defined(_GLFW_WAYLAND)
-GLFWAPI void glfwSetPrimarySelectionString(GLFWwindow* handle UNUSED, const char* string)
-{
-    assert(string != NULL);
-
+GLFWAPI void glfwSetClipboardDataTypes(GLFWClipboardType clipboard_type, const char* const *mime_types, size_t num_mime_types, GLFWclipboarditerfun get_data) {
+    assert(mime_types != NULL);
+    assert(get_data != NULL);
     _GLFW_REQUIRE_INIT();
-    _glfwPlatformSetPrimarySelectionString(string);
+    _GLFWClipboardData *cd = NULL;
+    switch(clipboard_type) {
+        case GLFW_CLIPBOARD: cd = &_glfw.clipboard; break;
+        case GLFW_PRIMARY_SELECTION: cd = &_glfw.primary; break;
+    }
+    _glfw_free_clipboard_data(cd);
+    cd->get_data = get_data;
+    cd->mime_types = calloc(num_mime_types, sizeof(char*));
+    cd->num_mime_types = 0;
+    cd->ctype = clipboard_type;
+    for (size_t i = 0; i < num_mime_types; i++) {
+        if (mime_types[i]) {
+            cd->mime_types[cd->num_mime_types++] = _glfw_strdup(mime_types[i]);
+        }
+    }
+    _glfwPlatformSetClipboard(clipboard_type);
 }
 
-GLFWAPI const char* glfwGetPrimarySelectionString(GLFWwindow* handle UNUSED)
-{
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-    return _glfwPlatformGetPrimarySelectionString();
-}
-#endif
-
 GLFWAPI monotonic_t glfwGetTime(void)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(0);

glfw/internal.h

@@ -34,6 +34,9 @@
 #endif
 
 #define arraysz(x) (sizeof(x)/sizeof(x[0]))
+#define MAX(x, y) __extension__ ({ \
+    __typeof__ (x) a = (x); __typeof__ (y) b = (y); \
+        a > b ? a : b;})
 
 #if defined(GLFW_INCLUDE_GLCOREARB) || \
     defined(GLFW_INCLUDE_ES1)       || \
@@ -52,6 +55,8 @@
 #define GLFW_INCLUDE_NONE
 #include "glfw3.h"
 
+#define EGL_PRESENT_OPAQUE_EXT 0x31df
+
 #define _GLFW_INSERT_FIRST      0
 #define _GLFW_INSERT_LAST       1
 
@@ -439,6 +444,11 @@ struct _GLFWwindow
     bool                rawMouseMotion;
 
     _GLFWcontext        context;
+#ifdef _GLFW_WAYLAND
+    bool                swaps_disallowed;
+#else
+    const bool                swaps_disallowed;
+#endif
 
     struct {
         GLFWwindowposfun        pos;
@@ -554,6 +564,13 @@ struct _GLFWmutex
     _GLFW_PLATFORM_MUTEX_STATE;
 };
 
+typedef struct _GLFWClipboardData {
+    const char** mime_types;
+    size_t num_mime_types;
+    GLFWclipboarditerfun get_data;
+    GLFWClipboardType ctype;
+} _GLFWClipboardData;
+
 // Library global data
 //
 struct _GLFWlibrary
@@ -568,6 +585,8 @@ struct _GLFWlibrary
         int             refreshRate;
     } hints;
 
+    _GLFWClipboardData primary, clipboard;
+
     _GLFWerror*         errorListHead;
     _GLFWcursor*        cursorListHead;
     _GLFWwindow*        windowListHead;
@@ -614,6 +633,8 @@ struct _GLFWlibrary
         GLFWjoystickfun joystick;
         GLFWapplicationclosefun application_close;
         GLFWdrawtextfun draw_text;
+        GLFWcurrentselectionfun get_current_selection;
+        GLFWhascurrentselectionfun has_current_selection;
     } callbacks;
 
 
@@ -666,12 +687,8 @@ void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode);
 bool _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp);
 void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp);
 
-void _glfwPlatformSetClipboardString(const char* string);
-const char* _glfwPlatformGetClipboardString(void);
-#if defined(_GLFW_X11) || defined(_GLFW_WAYLAND)
-void _glfwPlatformSetPrimarySelectionString(const char* string);
-const char* _glfwPlatformGetPrimarySelectionString(void);
-#endif
+void _glfwPlatformSetClipboard(GLFWClipboardType t);
+void _glfwPlatformGetClipboard(GLFWClipboardType clipboard_type, const char* mime_type, GLFWclipboardwritedatafun write_data, void *object);
 
 bool _glfwPlatformInitJoysticks(void);
 void _glfwPlatformTerminateJoysticks(void);
@@ -847,3 +864,5 @@ void _glfwPlatformUpdateTimer(unsigned long long timer_id, monotonic_t interval,
 void _glfwPlatformRemoveTimer(unsigned long long timer_id);
 
 char* _glfw_strdup(const char* source);
+
+void _glfw_free_clipboard_data(_GLFWClipboardData *cd);

glfw/linux_desktop_settings.c

@@ -83,8 +83,8 @@ process_settings_dict(DBusMessageIter *array_iter, void(process_setting)(const c
 
 HANDLER(process_desktop_settings)
     cursor_theme_changed = false;
-	DBusMessageIter root, array, item, settings;
-	dbus_message_iter_init(msg, &root);
+    DBusMessageIter root, array, item, settings;
+    dbus_message_iter_init(msg, &root);
 #define die(...) { _glfwInputError(GLFW_PLATFORM_ERROR, __VA_ARGS__); return; }
     if (dbus_message_iter_get_arg_type(&root) != DBUS_TYPE_ARRAY) die("Reply to request for desktop settings is not an array");
     dbus_message_iter_recurse(&root, &array);

glfw/source-info.json

@@ -77,7 +77,8 @@
       "unstable/idle-inhibit/idle-inhibit-unstable-v1.xml",
       "unstable/xdg-decoration/xdg-decoration-unstable-v1.xml",
       "unstable/primary-selection/primary-selection-unstable-v1.xml",
-      "unstable/text-input/text-input-unstable-v3.xml"
+      "unstable/text-input/text-input-unstable-v3.xml",
+      "staging/xdg-activation/xdg-activation-v1.xml"
     ],
     "sources": [
       "wl_init.c",

glfw/window.c

@@ -71,7 +71,7 @@ void _glfwInputWindowFocus(_GLFWwindow* window, bool focused)
         _glfw.focusedWindowId = window->id;
 }
 
-_GLFWwindow* _glfwFocusedWindow() {
+_GLFWwindow* _glfwFocusedWindow(void) {
     if (_glfw.focusedWindowId) {
         _GLFWwindow *w = _glfw.windowListHead;
         while (w) {
@@ -1067,6 +1067,10 @@ GLFWAPI bool glfwIsFullscreen(GLFWwindow* wh, unsigned int flags) {
     return _glfwPlatformIsFullscreen((_GLFWwindow*)wh, flags);
 }
 
+GLFWAPI bool glfwAreSwapsAllowed(const GLFWwindow* wh) {
+    return !(((_GLFWwindow*)wh)->swaps_disallowed);
+}
+
 GLFWAPI void glfwSetWindowUserPointer(GLFWwindow* handle, void* pointer)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;

glfw/wl_client_side_decorations.c

@@ -31,13 +31,13 @@ static void
 build_blur_kernel(kernel_type *blur_kernel, const size_t size, kernel_type sigma) {
     // 1D Normalized Gaussian
     const kernel_type half = size / (kernel_type)2;
-	kernel_type sum = 0;
-	for (size_t i = 0; i < size; i++) {
-		kernel_type f = (i - half);
-		blur_kernel[i] = (kernel_type)exp(- f * f / sigma);
-		sum += blur_kernel[i];
-	}
-	for (size_t i = 0; i < size; i++) blur_kernel[i] /= sum;
+    kernel_type sum = 0;
+    for (size_t i = 0; i < size; i++) {
+        kernel_type f = (i - half);
+        blur_kernel[i] = (kernel_type)exp(- f * f / sigma);
+        sum += blur_kernel[i];
+    }
+    for (size_t i = 0; i < size; i++) blur_kernel[i] /= sum;
 }
 
 static void
@@ -102,13 +102,34 @@ init_buffer_pair(_GLFWWaylandBufferPair *pair, size_t width, size_t height, unsi
     return 2 * pair->size_in_bytes;
 }
 
+static bool
+window_has_buffer(_GLFWwindow *window, struct wl_buffer *q) {
+#define Q(which) if (decs.which.buffer.a == q) { decs.which.buffer.a_needs_to_be_destroyed = false; return true; } if (decs.which.buffer.b == q) { decs.which.buffer.b_needs_to_be_destroyed = false; return true; }
+    Q(left); Q(top); Q(right); Q(bottom);
+#undef Q
+    return false;
+}
+
 static void
-alloc_buffer_pair(_GLFWWaylandBufferPair *pair, struct wl_shm_pool *pool, uint8_t *data, size_t *offset) {
+buffer_release_event(void *data, struct wl_buffer *buffer) {
+    wl_buffer_destroy(buffer);
+    _GLFWwindow *window = _glfwWindowForId((uintptr_t)data);
+    if (window && window_has_buffer(window, buffer)) decs.buffer_destroyed = true;
+}
+
+static struct wl_buffer_listener handle_buffer_events = {.release = buffer_release_event};
+
+static void
+alloc_buffer_pair(uintptr_t window_id, _GLFWWaylandBufferPair *pair, struct wl_shm_pool *pool, uint8_t *data, size_t *offset) {
     pair->data.a = data + *offset;
     pair->a = wl_shm_pool_create_buffer(pool, *offset, pair->width, pair->height, pair->stride, WL_SHM_FORMAT_ARGB8888);
+    pair->a_needs_to_be_destroyed = true;
+    wl_buffer_add_listener(pair->a, &handle_buffer_events, (void*)window_id);
     *offset += pair->size_in_bytes;
     pair->data.b = data + *offset;
     pair->b = wl_shm_pool_create_buffer(pool, *offset, pair->width, pair->height, pair->stride, WL_SHM_FORMAT_ARGB8888);
+    pair->b_needs_to_be_destroyed = true;
+    wl_buffer_add_listener(pair->b, &handle_buffer_events, (void*)window_id);
     *offset += pair->size_in_bytes;
     pair->front = pair->a; pair->back = pair->b;
     pair->data.front = pair->data.a; pair->data.back = pair->data.b;
@@ -287,7 +308,7 @@ create_shm_buffers(_GLFWwindow* window) {
     struct wl_shm_pool* pool = wl_shm_create_pool(_glfw.wl.shm, fd, decs.mapping.size);
     close(fd);
     size_t offset = 0;
-#define a(which) alloc_buffer_pair(&decs.which.buffer, pool, decs.mapping.data, &offset)
+#define a(which) alloc_buffer_pair(window->id, &decs.which.buffer, pool, decs.mapping.data, &offset)
     a(top); a(left); a(bottom); a(right);
 #undef a
     wl_shm_pool_destroy(pool);
@@ -313,8 +334,8 @@ free_csd_surfaces(_GLFWwindow *window) {
 static void
 free_csd_buffers(_GLFWwindow *window) {
 #define d(which) { \
-    if (decs.which.buffer.a) wl_buffer_destroy(decs.which.buffer.a); \
-    if (decs.which.buffer.b) wl_buffer_destroy(decs.which.buffer.b); \
+    if (decs.which.buffer.a_needs_to_be_destroyed && decs.which.buffer.a) wl_buffer_destroy(decs.which.buffer.a); \
+    if (decs.which.buffer.b_needs_to_be_destroyed && decs.which.buffer.b) wl_buffer_destroy(decs.which.buffer.b); \
     memset(&decs.which.buffer, 0, sizeof(_GLFWWaylandBufferPair)); \
 }
     d(left); d(top); d(right); d(bottom);
@@ -337,9 +358,10 @@ create_csd_surfaces(_GLFWwindow *window, _GLFWWaylandCSDEdge *s) {
 }
 
 #define damage_csd(which, xbuffer) \
-    wl_surface_attach(decs.which.surface, xbuffer, 0, 0); \
+    wl_surface_attach(decs.which.surface, (xbuffer), 0, 0); \
     wl_surface_damage(decs.which.surface, 0, 0, decs.which.buffer.width, decs.which.buffer.height); \
-    wl_surface_commit(decs.which.surface)
+    wl_surface_commit(decs.which.surface); \
+    if (decs.which.buffer.a == (xbuffer)) { decs.which.buffer.a_needs_to_be_destroyed = false; } else { decs.which.buffer.b_needs_to_be_destroyed = false; }
 
 bool
 ensure_csd_resources(_GLFWwindow *window) {
@@ -352,12 +374,14 @@ ensure_csd_resources(_GLFWwindow *window) {
         decs.for_window_state.scale != window->wl.scale ||
         !decs.mapping.data
     );
-    const bool needs_update = focus_changed || size_changed || !decs.left.surface;
-    debug("CSD: old.size: %dx%d new.size: %dx%d needs_update: %d size_changed: %d\n", decs.for_window_state.width, decs.for_window_state.height, window->wl.width, window->wl.height, needs_update, size_changed);
+    const bool needs_update = focus_changed || size_changed || !decs.left.surface || decs.buffer_destroyed;
+    debug("CSD: old.size: %dx%d new.size: %dx%d needs_update: %d size_changed: %d buffer_destroyed: %d\n",
+            decs.for_window_state.width, decs.for_window_state.height, window->wl.width, window->wl.height, needs_update, size_changed, decs.buffer_destroyed);
     if (!needs_update) return false;
-    if (size_changed) {
+    if (size_changed || decs.buffer_destroyed) {
         free_csd_buffers(window);
         if (!create_shm_buffers(window)) return false;
+        decs.buffer_destroyed = false;
     }
 
     int32_t x, y, scale = window->wl.scale < 1 ? 1 : window->wl.scale;
@@ -432,8 +456,5 @@ set_titlebar_color(_GLFWwindow *window, uint32_t color, bool use_system_color) {
         decs.use_custom_titlebar_color = use_custom_color;
         decs.titlebar_color = color;
     }
-    if (window->decorated && decs.top.surface) {
-        update_title_bar(window);
-        damage_csd(top, decs.top.buffer.front);
-    }
+    change_csd_title(window);
 }

glfw/wl_init.c

@@ -99,7 +99,7 @@ static void pointerHandleEnter(void* data UNUSED,
             return;
     }
     window->wl.decorations.focus = focus;
-    _glfw.wl.serial = serial;
+    _glfw.wl.serial = serial; _glfw.wl.input_serial = serial;
     _glfw.wl.pointerFocus = window;
 
     window->wl.hovered = true;
@@ -144,8 +144,12 @@ static void setCursor(GLFWCursorShape shape, _GLFWwindow* window)
     if (!image)
         return;
     if (image->width % scale || image->height % scale) {
-        _glfwInputError(GLFW_PLATFORM_ERROR, "WARNING: Cursor image size: %dx%d is not a multiple of window scale: %d. This will"
-                " cause some compositors such as GNOME to crash. See https://github.com/kovidgoyal/kitty/issues/4878", image->width, image->height, scale);
+        static uint32_t warned_width = 0, warned_height = 0;
+        if (warned_width != image->width || warned_height != image->height) {
+            _glfwInputError(GLFW_PLATFORM_ERROR, "WARNING: Cursor image size: %dx%d is not a multiple of window scale: %d. This will"
+                    " cause some compositors such as GNOME to crash. See https://github.com/kovidgoyal/kitty/issues/4878", image->width, image->height, scale);
+            warned_width = image->width; warned_height = image->height;
+        }
     }
 
     buffer = wl_cursor_image_get_buffer(image);
@@ -307,7 +311,7 @@ static void pointerHandleButton(void* data UNUSED,
     if (window->wl.decorations.focus != CENTRAL_WINDOW)
         return;
 
-    _glfw.wl.serial = serial;
+    _glfw.wl.serial = serial; _glfw.wl.input_serial = serial;
 
     /* Makes left, right and middle 0, 1 and 2. Overall order follows evdev
      * codes. */
@@ -459,7 +463,7 @@ static void keyboardHandleEnter(void* data UNUSED,
             return;
     }
 
-    _glfw.wl.serial = serial;
+    _glfw.wl.serial = serial; _glfw.wl.input_serial = serial;
     _glfw.wl.keyboardFocusId = window->id;
     _glfwInputWindowFocus(window, true);
     uint32_t* key;
@@ -512,7 +516,7 @@ static void keyboardHandleKey(void* data UNUSED,
         return;
     int action = state == WL_KEYBOARD_KEY_STATE_PRESSED ? GLFW_PRESS : GLFW_RELEASE;
 
-    _glfw.wl.serial = serial;
+    _glfw.wl.serial = serial; _glfw.wl.input_serial = serial;
     glfw_xkb_handle_key_event(window, &_glfw.wl.xkb, key, action);
 
     if (action == GLFW_PRESS && _glfw.wl.keyboardRepeatRate > 0 && glfw_xkb_should_repeat(&_glfw.wl.xkb, key))
@@ -535,7 +539,7 @@ static void keyboardHandleModifiers(void* data UNUSED,
                                     uint32_t modsLocked,
                                     uint32_t group)
 {
-    _glfw.wl.serial = serial;
+    _glfw.wl.serial = serial; _glfw.wl.input_serial = serial;
     glfw_xkb_update_modifiers(&_glfw.wl.xkb, modsDepressed, modsLatched, modsLocked, 0, 0, group);
 }
 
@@ -573,6 +577,7 @@ static void seatHandleCapabilities(void* data UNUSED,
     {
         wl_pointer_destroy(_glfw.wl.pointer);
         _glfw.wl.pointer = NULL;
+        if (_glfw.wl.cursorAnimationTimer) toggleTimer(&_glfw.wl.eventLoopData, _glfw.wl.cursorAnimationTimer, 0);
     }
 
     if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !_glfw.wl.keyboard)
@@ -584,6 +589,8 @@ static void seatHandleCapabilities(void* data UNUSED,
     {
         wl_keyboard_destroy(_glfw.wl.keyboard);
         _glfw.wl.keyboard = NULL;
+        _glfw.wl.keyboardFocusId = 0;
+        if (_glfw.wl.keyRepeatInfo.keyRepeatTimer) toggleTimer(&_glfw.wl.eventLoopData, _glfw.wl.keyRepeatInfo.keyRepeatTimer, 0);
     }
 }
 
@@ -712,6 +719,9 @@ static void registryHandleGlobal(void* data UNUSED,
             _glfwSetupWaylandPrimarySelectionDevice();
         }
     }
+    else if (strstr(interface, "xdg_activation_v1") != 0) {
+        _glfw.wl.xdg_activation_v1 = wl_registry_bind(registry, name, &xdg_activation_v1_interface, 1);
+    }
 
 }
 
@@ -875,6 +885,14 @@ int _glfwPlatformInit(void)
 
 void _glfwPlatformTerminate(void)
 {
+    if (_glfw.wl.activation_requests.array) {
+        for (size_t i=0; i < _glfw.wl.activation_requests.sz; i++) {
+            glfw_wl_xdg_activation_request *r = _glfw.wl.activation_requests.array + i;
+            if (r->callback) r->callback(NULL, NULL, r->callback_data);
+            xdg_activation_token_v1_destroy(r->token);
+        }
+        free(_glfw.wl.activation_requests.array);
+    }
     _glfwTerminateEGL();
     if (_glfw.wl.egl.handle)
     {
@@ -919,6 +937,8 @@ void _glfwPlatformTerminate(void)
         zwp_idle_inhibit_manager_v1_destroy(_glfw.wl.idleInhibitManager);
     if (_glfw.wl.dataSourceForClipboard)
         wl_data_source_destroy(_glfw.wl.dataSourceForClipboard);
+    if (_glfw.wl.dataSourceForPrimarySelection)
+        zwp_primary_selection_source_v1_destroy(_glfw.wl.dataSourceForPrimarySelection);
     for (size_t doi=0; doi < arraysz(_glfw.wl.dataOffers); doi++) {
         if (_glfw.wl.dataOffers[doi].id) {
             destroy_data_offer(&_glfw.wl.dataOffers[doi]);
@@ -932,6 +952,8 @@ void _glfwPlatformTerminate(void)
         zwp_primary_selection_device_v1_destroy(_glfw.wl.primarySelectionDevice);
     if (_glfw.wl.primarySelectionDeviceManager)
         zwp_primary_selection_device_manager_v1_destroy(_glfw.wl.primarySelectionDeviceManager);
+    if (_glfw.wl.xdg_activation_v1)
+        xdg_activation_v1_destroy(_glfw.wl.xdg_activation_v1);
     if (_glfw.wl.registry)
         wl_registry_destroy(_glfw.wl.registry);
     if (_glfw.wl.display)
@@ -940,10 +962,6 @@ void _glfwPlatformTerminate(void)
         wl_display_disconnect(_glfw.wl.display);
     }
     finalizePollData(&_glfw.wl.eventLoopData);
-    free(_glfw.wl.clipboardString); _glfw.wl.clipboardString = NULL;
-    free(_glfw.wl.primarySelectionString); _glfw.wl.primarySelectionString = NULL;
-    free(_glfw.wl.pasteString); _glfw.wl.pasteString = NULL;
-
 }
 
 const char* _glfwPlatformGetVersionString(void)

glfw/wl_platform.h

@@ -58,7 +58,9 @@ typedef VkBool32 (APIENTRY *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR
 #include "wayland-pointer-constraints-unstable-v1-client-protocol.h"
 #include "wayland-idle-inhibit-unstable-v1-client-protocol.h"
 #include "wayland-primary-selection-unstable-v1-client-protocol.h"
+#include "wayland-primary-selection-unstable-v1-client-protocol.h"
 #include "wl_text_input.h"
+#include "wayland-xdg-activation-v1-client-protocol.h"
 
 #define _glfw_dlopen(name) dlopen(name, RTLD_LAZY | RTLD_LOCAL)
 #define _glfw_dlclose(handle) dlclose(handle)
@@ -102,6 +104,7 @@ typedef struct _GLFWWaylandBufferPair {
     struct { uint8_t *a, *b, *front, *back; } data;
     bool has_pending_update;
     size_t size_in_bytes, width, height, stride;
+    bool a_needs_to_be_destroyed, b_needs_to_be_destroyed;
 } _GLFWWaylandBufferPair;
 
 typedef struct _GLFWWaylandCSDEdge {
@@ -116,14 +119,22 @@ typedef enum WaylandWindowState {
     TOPLEVEL_STATE_NONE = 0,
     TOPLEVEL_STATE_MAXIMIZED = 1,
     TOPLEVEL_STATE_FULLSCREEN = 2,
-	TOPLEVEL_STATE_RESIZING = 4,
-	TOPLEVEL_STATE_ACTIVATED = 8,
-	TOPLEVEL_STATE_TILED_LEFT = 16,
-	TOPLEVEL_STATE_TILED_RIGHT = 32,
-	TOPLEVEL_STATE_TILED_TOP = 64,
-	TOPLEVEL_STATE_TILED_BOTTOM = 128,
+    TOPLEVEL_STATE_RESIZING = 4,
+    TOPLEVEL_STATE_ACTIVATED = 8,
+    TOPLEVEL_STATE_TILED_LEFT = 16,
+    TOPLEVEL_STATE_TILED_RIGHT = 32,
+    TOPLEVEL_STATE_TILED_TOP = 64,
+    TOPLEVEL_STATE_TILED_BOTTOM = 128,
 } WaylandWindowState;
 
+typedef struct glfw_wl_xdg_activation_request {
+    GLFWid window_id;
+    GLFWactivationcallback callback;
+    void *callback_data;
+    uintptr_t request_id;
+    void *token;
+} glfw_wl_xdg_activation_request;
+
 
 static const WaylandWindowState TOPLEVEL_STATE_DOCKED = TOPLEVEL_STATE_MAXIMIZED | TOPLEVEL_STATE_FULLSCREEN | TOPLEVEL_STATE_TILED_TOP | TOPLEVEL_STATE_TILED_LEFT | TOPLEVEL_STATE_TILED_RIGHT | TOPLEVEL_STATE_TILED_BOTTOM;
 
@@ -141,6 +152,7 @@ typedef struct _GLFWwindowWayland
     bool                        hovered;
     bool                        transparent;
     struct wl_surface*          surface;
+    bool                        waiting_for_swap_to_commit;
     struct wl_egl_window*       native;
     struct wl_callback*         callback;
 
@@ -172,7 +184,7 @@ typedef struct _GLFWwindowWayland
     struct zwp_idle_inhibitor_v1*          idleInhibitor;
 
     struct {
-        bool serverSide;
+        bool serverSide, buffer_destroyed;
         _GLFWdecorationSideWayland focus;
         _GLFWWaylandCSDEdge top, left, right, bottom;
 
@@ -276,13 +288,14 @@ typedef struct _GLFWlibraryWayland
     struct zwp_primary_selection_device_manager_v1* primarySelectionDeviceManager;
     struct zwp_primary_selection_device_v1*    primarySelectionDevice;
     struct zwp_primary_selection_source_v1*    dataSourceForPrimarySelection;
+    struct xdg_activation_v1* xdg_activation_v1;
 
     int                         compositorVersion;
     int                         seatVersion;
 
     struct wl_surface*          cursorSurface;
     GLFWCursorShape             cursorPreviousShape;
-    uint32_t                    serial;
+    uint32_t                    serial, input_serial;
 
     int32_t                     keyboardRepeatRate;
     monotonic_t                 keyboardRepeatDelay;
@@ -316,12 +329,14 @@ typedef struct _GLFWlibraryWayland
         PFN_wl_egl_window_resize window_resize;
     } egl;
 
+    struct {
+        glfw_wl_xdg_activation_request *array;
+        size_t capacity, sz;
+    } activation_requests;
+
     EventLoopData eventLoopData;
-    char* pasteString;
-    char* clipboardString;
     size_t dataOffersCounter;
     _GLFWWaylandDataOffer dataOffers[8];
-    char* primarySelectionString;
 } _GLFWlibraryWayland;
 
 // Wayland-specific per-monitor data
@@ -355,6 +370,7 @@ typedef struct _GLFWcursorWayland
 
 
 void _glfwAddOutputWayland(uint32_t name, uint32_t version);
+void _glfwWaylandAfterBufferSwap(_GLFWwindow *window);
 void _glfwSetupWaylandDataDevice(void);
 void _glfwSetupWaylandPrimarySelectionDevice(void);
 void animateCursorImage(id_type timer_id, void *data);

glfw/wl_text_input.c

@@ -9,12 +9,15 @@
 #include "internal.h"
 #include "wayland-text-input-unstable-v3-client-protocol.h"
 #include <stdlib.h>
+#include <string.h>
 #define debug(...) if (_glfw.hints.init.debugKeyboard) printf(__VA_ARGS__);
 
 static struct zwp_text_input_v3*                  text_input;
 static struct zwp_text_input_manager_v3*          text_input_manager;
 static char *pending_pre_edit = NULL;
+static char *current_pre_edit = NULL;
 static char *pending_commit   = NULL;
+static int last_cursor_left = 0, last_cursor_top = 0, last_cursor_width = 0, last_cursor_height = 0;
 uint32_t commit_serial = 0;
 
 static void commit(void) {
@@ -87,15 +90,23 @@ static void
 text_input_done(void *data UNUSED, struct zwp_text_input_v3 *txt_input UNUSED, uint32_t serial) {
     debug("text-input: done event: serial: %u current_commit_serial: %u\n", serial, commit_serial);
     if (serial != commit_serial) {
-        _glfwInputError(GLFW_PLATFORM_ERROR, "Wayland: text_input_done serial mismatch, expected=%u got=%u\n", commit_serial, serial);
+        if (serial > commit_serial) _glfwInputError(GLFW_PLATFORM_ERROR, "Wayland: text_input_done serial mismatch, expected=%u got=%u\n", commit_serial, serial);
         return;
     }
-    if (pending_pre_edit) {
-        send_text(pending_pre_edit, GLFW_IME_PREEDIT_CHANGED);
+
+    if ((pending_pre_edit == NULL && current_pre_edit == NULL) ||
+        (pending_pre_edit && current_pre_edit && strcmp(pending_pre_edit, current_pre_edit) == 0)) {
         free(pending_pre_edit); pending_pre_edit = NULL;
     } else {
-        // Clear pre-edit text
-        send_text(NULL, GLFW_IME_WAYLAND_DONE_EVENT);
+        free(current_pre_edit);
+        current_pre_edit = pending_pre_edit;
+        pending_pre_edit = NULL;
+        if (current_pre_edit) {
+            send_text(current_pre_edit, GLFW_IME_PREEDIT_CHANGED);
+        } else {
+            // Clear pre-edit text
+            send_text(NULL, GLFW_IME_WAYLAND_DONE_EVENT);
+        }
     }
     if (pending_commit) {
         send_text(pending_commit, GLFW_IME_COMMIT_TEXT);
@@ -133,6 +144,7 @@ _glfwWaylandDestroyTextInput(void) {
     if (text_input_manager) zwp_text_input_manager_v3_destroy(text_input_manager);
     text_input = NULL; text_input_manager = NULL;
     free(pending_pre_edit); pending_pre_edit = NULL;
+    free(current_pre_edit); current_pre_edit = NULL;
     free(pending_commit); pending_commit = NULL;
 }
 
@@ -146,10 +158,11 @@ _glfwPlatformUpdateIMEState(_GLFWwindow *w, const GLFWIMEUpdateEvent *ev) {
                 zwp_text_input_v3_enable(text_input);
                 zwp_text_input_v3_set_content_type(text_input, ZWP_TEXT_INPUT_V3_CONTENT_HINT_NONE, ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_TERMINAL);
             } else {
-                if (pending_pre_edit) {
+                free(pending_pre_edit); pending_pre_edit = NULL;
+                if (current_pre_edit) {
                     // Clear pre-edit text
                     send_text(NULL, GLFW_IME_PREEDIT_CHANGED);
-                    free(pending_pre_edit); pending_pre_edit = NULL;
+                    free(current_pre_edit); current_pre_edit = NULL;
                 }
                 if (pending_commit) {
                     free(pending_commit); pending_commit = NULL;
@@ -161,9 +174,15 @@ _glfwPlatformUpdateIMEState(_GLFWwindow *w, const GLFWIMEUpdateEvent *ev) {
         case GLFW_IME_UPDATE_CURSOR_POSITION: {
             const int scale = w->wl.scale;
             const int left = ev->cursor.left / scale, top = ev->cursor.top / scale, width = ev->cursor.width / scale, height = ev->cursor.height / scale;
-            debug("\ntext-input: updating cursor position: left=%d top=%d width=%d height=%d\n", left, top, width, height);
-            zwp_text_input_v3_set_cursor_rectangle(text_input, left, top, width, height);
-            commit();
+            if (left != last_cursor_left || top != last_cursor_top || width != last_cursor_width || height != last_cursor_height) {
+                last_cursor_left = left;
+                last_cursor_top = top;
+                last_cursor_width = width;
+                last_cursor_height = height;
+                debug("\ntext-input: updating cursor position: left=%d top=%d width=%d height=%d\n", left, top, width, height);
+                zwp_text_input_v3_set_cursor_rectangle(text_input, left, top, width, height);
+                commit();
+            }
         }
             break;
     }

glfw/wl_window.c

@@ -44,6 +44,59 @@
 
 #define debug(...) if (_glfw.hints.init.debugRendering) fprintf(stderr, __VA_ARGS__);
 
+static void
+activation_token_done(void *data, struct xdg_activation_token_v1 *xdg_token, const char *token) {
+    for (size_t i = 0; i < _glfw.wl.activation_requests.sz; i++) {
+        glfw_wl_xdg_activation_request *r = _glfw.wl.activation_requests.array + i;
+        if (r->request_id == (uintptr_t)data) {
+            _GLFWwindow *window = _glfwWindowForId(r->window_id);
+            if (r->callback) r->callback((GLFWwindow*)window, token, r->callback_data);
+            remove_i_from_array(_glfw.wl.activation_requests.array, i, _glfw.wl.activation_requests.sz);
+            break;
+        }
+    }
+    xdg_activation_token_v1_destroy(xdg_token);
+}
+
+
+static const struct
+xdg_activation_token_v1_listener activation_token_listener = {
+    .done = &activation_token_done,
+};
+
+
+static bool
+get_activation_token(
+    _GLFWwindow *window, uint32_t serial, GLFWactivationcallback cb, void *cb_data
+) {
+#define fail(msg) { _glfwInputError(GLFW_PLATFORM_ERROR, msg); if (cb) cb((GLFWwindow*)window, NULL, cb_data); return false; }
+    if (_glfw.wl.xdg_activation_v1 == NULL) fail("Wayland: activation requests not supported by this Wayland compositor");
+    struct xdg_activation_token_v1 *token = xdg_activation_v1_get_activation_token(_glfw.wl.xdg_activation_v1);
+    if (token == NULL) fail("Wayland: failed to create activation request token");
+    if (_glfw.wl.activation_requests.capacity < _glfw.wl.activation_requests.sz + 1) {
+        _glfw.wl.activation_requests.capacity = MAX(64u, _glfw.wl.activation_requests.capacity * 2);
+        _glfw.wl.activation_requests.array = realloc(_glfw.wl.activation_requests.array, _glfw.wl.activation_requests.capacity * sizeof(_glfw.wl.activation_requests.array[0]));
+        if (!_glfw.wl.activation_requests.array) {
+            _glfw.wl.activation_requests.capacity = 0;
+            fail("Wayland: Out of memory while allocation activation request");
+        }
+    }
+    glfw_wl_xdg_activation_request *r = _glfw.wl.activation_requests.array + _glfw.wl.activation_requests.sz++;
+    memset(r, 0, sizeof(*r));
+    static uintptr_t rq = 0;
+    r->window_id = window->id;
+    r->callback = cb; r->callback_data = cb_data;
+    r->request_id = ++rq; r->token = token;
+    if (serial != 0)
+        xdg_activation_token_v1_set_serial(token, serial, _glfw.wl.seat);
+
+    xdg_activation_token_v1_set_surface(token, window->wl.surface);
+    xdg_activation_token_v1_add_listener(token, &activation_token_listener, (void*)r->request_id);
+    xdg_activation_token_v1_commit(token);
+    return true;
+#undef fail
+}
+
 static struct wl_buffer* createShmBuffer(const GLFWimage* image, bool is_opaque, bool init_data)
 {
     struct wl_shm_pool* pool;
@@ -198,8 +251,17 @@ static bool checkScaleChange(_GLFWwindow* window)
     return false;
 }
 
+static void
+commit_window_surface_if_safe(_GLFWwindow *window) {
+    // we only commit if the buffer attached to the surface is the correct size,
+    // which means that at least one frame is drawn after resizeFramebuffer()
+    if (!window->wl.waiting_for_swap_to_commit) {
+        wl_surface_commit(window->wl.surface);
+    }
+}
+
 // Makes the surface considered as XRGB instead of ARGB.
-static void setOpaqueRegion(_GLFWwindow* window)
+static void setOpaqueRegion(_GLFWwindow* window, bool commit_surface)
 {
     struct wl_region* region;
 
@@ -209,7 +271,7 @@ static void setOpaqueRegion(_GLFWwindow* window)
 
     wl_region_add(region, 0, 0, window->wl.width, window->wl.height);
     wl_surface_set_opaque_region(window->wl.surface, region);
-    wl_surface_commit(window->wl.surface);
+    if (commit_surface) commit_window_surface_if_safe(window);
     wl_region_destroy(region);
 }
 
@@ -221,10 +283,21 @@ resizeFramebuffer(_GLFWwindow* window) {
     int scaledHeight = window->wl.height * scale;
     debug("Resizing framebuffer to: %dx%d at scale: %d\n", window->wl.width, window->wl.height, scale);
     wl_egl_window_resize(window->wl.native, scaledWidth, scaledHeight, 0, 0);
-    if (!window->wl.transparent) setOpaqueRegion(window);
+    if (!window->wl.transparent) setOpaqueRegion(window, false);
+    window->wl.waiting_for_swap_to_commit = true;
     _glfwInputFramebufferSize(window, scaledWidth, scaledHeight);
 }
 
+void
+_glfwWaylandAfterBufferSwap(_GLFWwindow* window) {
+    if (window->wl.waiting_for_swap_to_commit) {
+        debug("Waiting for swap to commit: swap has happened\n");
+        window->wl.waiting_for_swap_to_commit = false;
+        // this is not really needed, since I think eglSwapBuffers() calls wl_surface_commit()
+        // but lets be safe. See https://gitlab.freedesktop.org/mesa/mesa/-/blob/main/src/egl/drivers/dri2/platform_wayland.c#L1510
+        wl_surface_commit(window->wl.surface);
+    }
+}
 
 static const char*
 clipboard_mime(void) {
@@ -368,9 +441,22 @@ static bool createSurface(_GLFWwindow* window,
 
     wl_surface_set_user_data(window->wl.surface, window);
 
-    window->wl.native = wl_egl_window_create(window->wl.surface,
-                                             wndconfig->width,
-                                             wndconfig->height);
+    // If we already have been notified of the primary monitor scale, assume
+    // the window will be created on it and so avoid a rescale roundtrip in the common
+    // case of the window being shown on the primary monitor or all monitors having the same scale.
+    // If you change this also change get_window_content_scale() in the kitty code.
+    GLFWmonitor* monitor = glfwGetPrimaryMonitor();
+    float xscale = 1.0, yscale = 1.0;
+    int scale = 1;
+    if (monitor) {
+        glfwGetMonitorContentScale(monitor, &xscale, &yscale);
+        // see wl_monitor.c xscale is always == yscale
+        if (xscale <= 0.0001 || xscale != xscale || xscale >= 24) xscale = 1.0;
+        if (xscale > 1) scale = (int)xscale;
+    }
+
+    debug("Creating window at size: %dx%d and scale %d\n", wndconfig->width, wndconfig->height, scale);
+    window->wl.native = wl_egl_window_create(window->wl.surface, wndconfig->width * scale, wndconfig->height * scale);
     if (!window->wl.native)
         return false;
 
@@ -378,11 +464,13 @@ static bool createSurface(_GLFWwindow* window,
     window->wl.height = wndconfig->height;
     window->wl.user_requested_content_size.width = wndconfig->width;
     window->wl.user_requested_content_size.height = wndconfig->height;
-    window->wl.scale = 1;
+
+    window->wl.scale = scale;
 
     if (!window->wl.transparent)
-        setOpaqueRegion(window);
+        setOpaqueRegion(window, false);
 
+    wl_surface_set_buffer_scale(window->wl.surface, scale);
     return true;
 }
 
@@ -488,6 +576,15 @@ static void xdgSurfaceHandleConfigure(void* data,
                                       struct xdg_surface* surface,
                                       uint32_t serial)
 {
+    // The poorly documented pattern Wayland requires is:
+    // 1) ack the configure,
+    // 2) set the window geometry
+    // 3) attach a new buffer of the correct size to the surface
+    // 4) only then commit the surface.
+    // buffer is attached only by eglSwapBuffers,
+    // so we set a flag to not commit the surface till the next swapbuffers. Note that
+    // wl_egl_window_resize() does not actually resize the buffer until the next draw call
+    // or buffer state query.
     _GLFWwindow* window = data;
     xdg_surface_ack_configure(surface, serial);
     if (window->wl.pending_state & PENDING_STATE_TOPLEVEL) {
@@ -495,12 +592,9 @@ static void xdgSurfaceHandleConfigure(void* data,
         int width = window->wl.pending.width;
         int height = window->wl.pending.height;
         if (!window->wl.surface_configured_once) {
+            window->swaps_disallowed = false;
+            window->wl.waiting_for_swap_to_commit = true;
             window->wl.surface_configured_once = true;
-            if (!width && !height && !new_states && !window->wl.decorations.serverSide && getenv("XAUTHORITY") && strstr(getenv("XAUTHORITY"), "mutter")) {
-                // https://github.com/kovidgoyal/kitty/issues/4802
-                debug("Ignoring first empty surface configure event on mutter.\n");
-                return;
-            }
         }
 
         if (new_states != window->wl.current.toplevel_states ||
@@ -523,12 +617,11 @@ static void xdgSurfaceHandleConfigure(void* data,
         window->wl.current.decoration_mode = mode;
     }
 
-    bool resized = false;
     if (window->wl.pending_state) {
         int width = window->wl.pending.width, height = window->wl.pending.height;
         set_csd_window_geometry(window, &width, &height);
-        resized = dispatchChangesAfterConfigure(window, width, height);
-        if (window->wl.decorations.serverSide) {
+        bool resized = dispatchChangesAfterConfigure(window, width, height);
+        if (window->wl.decorations.serverSide || window->monitor || window->wl.current.toplevel_states & TOPLEVEL_STATE_FULLSCREEN) {
             free_csd_surfaces(window);
         } else {
             ensure_csd_resources(window);
@@ -537,10 +630,7 @@ static void xdgSurfaceHandleConfigure(void* data,
     }
 
     inform_compositor_of_window_geometry(window, "configure");
-
-    // if a resize happened there will be a commit at the next render frame so
-    // dont commit here, GNOME doesnt like it and its not really needed anyway
-    if (!resized) wl_surface_commit(window->wl.surface);
+    commit_window_surface_if_safe(window);
     window->wl.pending_state = 0;
 }
 
@@ -784,6 +874,7 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
     initialize_csd_metrics(window);
     window->wl.transparent = fbconfig->transparent;
     strncpy(window->wl.appId, wndconfig->wl.appId, sizeof(window->wl.appId));
+    window->swaps_disallowed = true;
 
     if (!createSurface(window, wndconfig))
         return false;
@@ -939,7 +1030,7 @@ void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height)
         window->wl.width = w; window->wl.height = h;
         resizeFramebuffer(window);
         ensure_csd_resources(window);
-        wl_surface_commit(window->wl.surface);
+        commit_window_surface_if_safe(window);
         inform_compositor_of_window_geometry(window, "SetWindowSize");
     }
 }
@@ -956,7 +1047,7 @@ void _glfwPlatformSetWindowSizeLimits(_GLFWwindow* window,
             maxwidth = maxheight = 0;
         xdg_toplevel_set_min_size(window->wl.xdg.toplevel, minwidth, minheight);
         xdg_toplevel_set_max_size(window->wl.xdg.toplevel, maxwidth, maxheight);
-        wl_surface_commit(window->wl.surface);
+        commit_window_surface_if_safe(window);
     }
 }
 
@@ -993,7 +1084,7 @@ void _glfwPlatformGetWindowFrameSize(_GLFWwindow* window,
     if (window->decorated && !window->monitor && !window->wl.decorations.serverSide)
     {
         if (top)
-            *top = window->wl.decorations.metrics.top;
+            *top = window->wl.decorations.metrics.top - window->wl.decorations.metrics.visible_titlebar_height;
         if (left)
             *left = window->wl.decorations.metrics.width;
         if (right)
@@ -1062,38 +1153,51 @@ void _glfwPlatformHideWindow(_GLFWwindow* window)
         xdg_surface_destroy(window->wl.xdg.surface);
         window->wl.xdg.toplevel = NULL;
         window->wl.xdg.surface = NULL;
+        window->wl.surface_configured_once = false;
+        window->swaps_disallowed = true;
     }
     window->wl.visible = false;
 }
 
-void _glfwPlatformRequestWindowAttention(_GLFWwindow* window UNUSED)
-{
-    // TODO
-    static bool notified = false;
-    if (!notified) {
-        _glfwInputError(GLFW_FEATURE_UNIMPLEMENTED,
-                        "Wayland: Window attention request not implemented yet");
-        notified = true;
+static void
+request_attention(GLFWwindow *window, const char *token, void *data UNUSED) {
+    if (window && token && token[0]) xdg_activation_v1_activate(_glfw.wl.xdg_activation_v1, token, ((_GLFWwindow*)window)->wl.surface);
+}
+
+static bool
+has_activation_in_flight(_GLFWwindow* window, GLFWactivationcallback callback) {
+    for (size_t i = 0; i < _glfw.wl.activation_requests.sz; i++) {
+        glfw_wl_xdg_activation_request *r = _glfw.wl.activation_requests.array + i;
+        if (r->window_id == window->id && r->callback == callback) return true;
     }
+    return false;
+}
+
+void _glfwPlatformRequestWindowAttention(_GLFWwindow* window) {
+    if (!has_activation_in_flight(window, request_attention)) get_activation_token(window, 0, request_attention, NULL);
 }
 
 int _glfwPlatformWindowBell(_GLFWwindow* window UNUSED)
 {
     // TODO: Use an actual Wayland API to implement this when one becomes available
-    static char tty[L_ctermid + 1];
-    int fd = open(ctermid(tty), O_WRONLY | O_CLOEXEC);
-    if (fd > -1) {
-        int ret = write(fd, "\x07", 1) == 1 ? true : false;
-        close(fd);
-        return ret;
-    }
     return false;
 }
 
+static void
+focus_window(GLFWwindow *window, const char *token, void *data UNUSED) {
+    if (!window) return;
+    if (token && token[0]) xdg_activation_v1_activate(_glfw.wl.xdg_activation_v1, token, ((_GLFWwindow*)window)->wl.surface);
+    else {
+        _glfwInputError(GLFW_PLATFORM_ERROR, "Wayland: Window focus request via xdg-activation protocol was denied by the compositor. Use a better compositor.");
+    }
+}
+
 void _glfwPlatformFocusWindow(_GLFWwindow* window UNUSED)
 {
-    _glfwInputError(GLFW_FEATURE_UNAVAILABLE,
-                    "Wayland: The platform does not support setting the input focus");
+    // Attempt to focus the window by using the activation protocol, whether it works
+    // is entirely compositor dependent and as we all know Wayland and its ecosystem is
+    // the product of morons.
+    if (_glfw.wl.input_serial && !has_activation_in_flight(window, focus_window)) get_activation_token(window, _glfw.wl.input_serial, focus_window, NULL);
 }
 
 void _glfwPlatformSetWindowMonitor(_GLFWwindow* window,
@@ -1178,7 +1282,7 @@ void _glfwPlatformSetWindowMousePassthrough(_GLFWwindow* window, bool enabled)
     }
     else
         wl_surface_set_input_region(window->wl.surface, 0);
-    wl_surface_commit(window->wl.surface);
+    commit_window_surface_if_safe(window);
 }
 
 float _glfwPlatformGetWindowOpacity(_GLFWwindow* window UNUSED)
@@ -1242,7 +1346,7 @@ void _glfwPlatformSetCursorPos(_GLFWwindow* window, double x, double y)
         zwp_locked_pointer_v1_set_cursor_position_hint(
             window->wl.pointerLock.lockedPointer,
             wl_fixed_from_double(x), wl_fixed_from_double(y));
-        wl_surface_commit(window->wl.surface);
+        commit_window_surface_if_safe(window);
     }
 }
 
@@ -1440,53 +1544,68 @@ void _glfwPlatformSetCursor(_GLFWwindow* window, _GLFWcursor* cursor)
     }
 }
 
-static void send_text(char *text, int fd)
-{
-    if (text) {
-        size_t len = strlen(text), pos = 0;
-        monotonic_t start = glfwGetTime();
-        while (pos < len && glfwGetTime() - start < s_to_monotonic_t(2ll)) {
-            ssize_t ret = write(fd, text + pos, len - pos);
-            if (ret < 0) {
-                if (errno == EAGAIN || errno == EINTR) continue;
-                _glfwInputError(GLFW_PLATFORM_ERROR,
-                    "Wayland: Could not copy writing to destination fd failed with error: %s", strerror(errno));
-                break;
-            }
-            if (ret > 0) {
-                start = glfwGetTime();
-                pos += ret;
-            }
+static bool
+write_all(int fd, const char *data, size_t sz) {
+    monotonic_t start = glfwGetTime();
+    size_t pos = 0;
+    while (pos < sz && glfwGetTime() - start < s_to_monotonic_t(2ll)) {
+        ssize_t ret = write(fd, data + pos, sz - pos);
+        if (ret < 0) {
+            if (errno == EAGAIN || errno == EINTR) continue;
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                "Wayland: Could not copy writing to destination fd failed with error: %s", strerror(errno));
+            return false;
+        }
+        if (ret > 0) {
+            start = glfwGetTime();
+            pos += ret;
         }
     }
+    return pos >= sz;
+}
+
+static void
+send_clipboard_data(const _GLFWClipboardData *cd, const char *mime, int fd) {
+    if (strcmp(mime, "text/plain;charset=utf-8") == 0 || strcmp(mime, "UTF8_STRING") == 0 || strcmp(mime, "TEXT") == 0 || strcmp(mime, "STRING") == 0) mime = "text/plain";
+    GLFWDataChunk chunk = cd->get_data(mime, NULL, cd->ctype);
+    void *iter = chunk.iter;
+    if (!iter) return;
+    bool keep_going = true;
+    while (keep_going) {
+        chunk = cd->get_data(mime, iter, cd->ctype);
+        if (!chunk.sz) break;
+        if (!write_all(fd, chunk.data, chunk.sz)) keep_going = false;
+        if (chunk.free) chunk.free((void*)chunk.free_data);
+    }
+    cd->get_data(NULL, iter, cd->ctype);
+}
+
+static void _glfwSendClipboardText(void *data UNUSED, struct wl_data_source *data_source UNUSED, const char *mime_type, int fd) {
+    send_clipboard_data(&_glfw.clipboard, mime_type, fd);
     close(fd);
 }
 
-static void _glfwSendClipboardText(void *data UNUSED, struct wl_data_source *data_source UNUSED, const char *mime_type UNUSED, int fd) {
-    send_text(_glfw.wl.clipboardString, fd);
-}
-
 static void _glfwSendPrimarySelectionText(void *data UNUSED, struct zwp_primary_selection_source_v1 *primary_selection_source UNUSED,
-        const char *mime_type UNUSED, int fd) {
-    send_text(_glfw.wl.primarySelectionString, fd);
+        const char *mime_type, int fd) {
+    send_clipboard_data(&_glfw.primary, mime_type, fd);
+    close(fd);
 }
 
-static char* read_offer_string(int data_pipe, size_t *data_sz) {
+static void
+read_offer(int data_pipe, GLFWclipboardwritedatafun write_data, void *object) {
     wl_display_flush(_glfw.wl.display);
-    size_t capacity = 0;
-    char *buf = NULL;
-    *data_sz = 0;
     struct pollfd fds;
     fds.fd = data_pipe;
     fds.events = POLLIN;
     monotonic_t start = glfwGetTime();
 #define bail(...) { \
     _glfwInputError(GLFW_PLATFORM_ERROR, __VA_ARGS__); \
-    free(buf); buf = NULL; \
     close(data_pipe); \
-    return NULL; \
+    return; \
 }
 
+    char buf[8192];
+
     while (glfwGetTime() - start < s_to_monotonic_t(2ll)) {
         int ret = poll(&fds, 1, 2000);
         if (ret == -1) {
@@ -1496,34 +1615,65 @@ static char* read_offer_string(int data_pipe, size_t *data_sz) {
         if (!ret) {
             bail("Wayland: Failed to read clipboard data from pipe (timed out)");
         }
-        if (capacity <= *data_sz || capacity - *data_sz <= 64) {
-            capacity += 4096;
-            buf = realloc(buf, capacity);
-            if (!buf) {
-                bail("Wayland: Failed to allocate memory to read clipboard data");
-            }
-        }
-        ret = read(data_pipe, buf + *data_sz, capacity - *data_sz - 1);
+        ret = read(data_pipe, buf, sizeof(buf));
         if (ret == -1) {
             if (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK) continue;
             bail("Wayland: Failed to read clipboard data from pipe with error: %s", strerror(errno));
         }
-        if (ret == 0) { close(data_pipe); buf[*data_sz] = 0; return buf; }
-        *data_sz += ret;
+        if (ret == 0) { close(data_pipe); return; }
+        if (!write_data(object, buf, ret)) bail("Wayland: call to write_data() failed with data from data offer");
         start = glfwGetTime();
     }
     bail("Wayland: Failed to read clipboard data from pipe (timed out)");
 #undef bail
-
 }
 
-static char* read_primary_selection_offer(struct zwp_primary_selection_offer_v1 *primary_selection_offer, const char *mime) {
+
+typedef struct chunked_writer {
+    char *buf; size_t sz, cap;
+} chunked_writer;
+
+static bool
+write_chunk(void *object, const char *data, size_t sz) {
+    chunked_writer *cw = object;
+    if (cw->cap < cw->sz + sz) {
+        cw->cap = MAX(cw->cap * 2, cw->sz + 8*sz);
+        cw->buf = realloc(cw->buf, cw->cap * sizeof(cw->buf[0]));
+    }
+    memcpy(cw->buf + cw->sz, data, sz);
+    cw->sz += sz;
+    return true;
+}
+
+
+static char*
+read_offer_string(int data_pipe, size_t *sz) {
+    chunked_writer cw = {0};
+    read_offer(data_pipe, write_chunk, &cw);
+    if (cw.buf) {
+        *sz = cw.sz;
+        return cw.buf;
+    }
+    *sz = 0;
+    return NULL;
+}
+
+static void
+read_clipboard_data_offer(struct wl_data_offer *data_offer, const char *mime, GLFWclipboardwritedatafun write_data, void *object) {
     int pipefd[2];
-    if (pipe2(pipefd, O_CLOEXEC) != 0) return NULL;
+    if (pipe2(pipefd, O_CLOEXEC) != 0) return;
+    wl_data_offer_receive(data_offer, mime, pipefd[1]);
+    close(pipefd[1]);
+    read_offer(pipefd[0], write_data, object);
+}
+
+static void
+read_primary_selection_offer(struct zwp_primary_selection_offer_v1 *primary_selection_offer, const char *mime, GLFWclipboardwritedatafun write_data, void *object) {
+    int pipefd[2];
+    if (pipe2(pipefd, O_CLOEXEC) != 0) return;
     zwp_primary_selection_offer_v1_receive(primary_selection_offer, mime, pipefd[1]);
     close(pipefd[1]);
-    size_t sz = 0;
-    return read_offer_string(pipefd[0], &sz);
+    read_offer(pipefd[0], write_data, object);
 }
 
 static char* read_data_offer(struct wl_data_offer *data_offer, const char *mime, size_t *sz) {
@@ -1535,24 +1685,33 @@ static char* read_data_offer(struct wl_data_offer *data_offer, const char *mime,
 }
 
 static void data_source_canceled(void *data UNUSED, struct wl_data_source *wl_data_source) {
-    if (_glfw.wl.dataSourceForClipboard == wl_data_source)
+    if (_glfw.wl.dataSourceForClipboard == wl_data_source) {
         _glfw.wl.dataSourceForClipboard = NULL;
+        _glfw_free_clipboard_data(&_glfw.clipboard);
+    }
     wl_data_source_destroy(wl_data_source);
 }
 
 static void primary_selection_source_canceled(void *data UNUSED, struct zwp_primary_selection_source_v1 *primary_selection_source) {
-    if (_glfw.wl.dataSourceForPrimarySelection == primary_selection_source)
+    if (_glfw.wl.dataSourceForPrimarySelection == primary_selection_source) {
         _glfw.wl.dataSourceForPrimarySelection = NULL;
+        _glfw_free_clipboard_data(&_glfw.primary);
+    }
     zwp_primary_selection_source_v1_destroy(primary_selection_source);
 }
 
-static void data_source_target(void *data UNUSED, struct wl_data_source *wl_data_source UNUSED, const char* mime UNUSED) {
+// KWin aborts if we don't define these even though they are not used for copy/paste
+static void dummy_data_source_target(void* data UNUSED, struct wl_data_source* wl_data_source UNUSED, const char* mime_type UNUSED) {
+}
+
+static void dummy_data_source_action(void* data UNUSED, struct wl_data_source* wl_data_source UNUSED, uint dnd_action UNUSED) {
 }
 
 static const struct wl_data_source_listener data_source_listener = {
     .send = _glfwSendClipboardText,
     .cancelled = data_source_canceled,
-    .target = data_source_target,
+    .target = dummy_data_source_target,
+    .action = dummy_data_source_action,
 };
 
 static const struct zwp_primary_selection_source_v1_listener primary_selection_source_listener = {
@@ -1829,30 +1988,69 @@ static bool _glfwEnsureDataDevice(void) {
     return true;
 }
 
-void _glfwPlatformSetClipboardString(const char* string)
-{
-    if (!_glfwEnsureDataDevice()) return;
-    free(_glfw.wl.clipboardString);
-    _glfw.wl.clipboardString = _glfw_strdup(string);
-    if (_glfw.wl.dataSourceForClipboard)
-        wl_data_source_destroy(_glfw.wl.dataSourceForClipboard);
-    _glfw.wl.dataSourceForClipboard = wl_data_device_manager_create_data_source(_glfw.wl.dataDeviceManager);
-    if (!_glfw.wl.dataSourceForClipboard)
-    {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Wayland: Cannot copy failed to create data source");
-        return;
+typedef void(*add_offer_func)(void*, const char *mime);
+
+
+void
+_glfwPlatformSetClipboard(GLFWClipboardType t) {
+    _GLFWClipboardData *cd = NULL;
+    void *data_source;
+    add_offer_func f;
+    if (t == GLFW_CLIPBOARD) {
+        if (!_glfwEnsureDataDevice()) return;
+        cd = &_glfw.clipboard;
+        f = (add_offer_func)wl_data_source_offer;
+        if (_glfw.wl.dataSourceForClipboard) wl_data_source_destroy(_glfw.wl.dataSourceForClipboard);
+        _glfw.wl.dataSourceForClipboard = wl_data_device_manager_create_data_source(_glfw.wl.dataDeviceManager);
+        if (!_glfw.wl.dataSourceForClipboard)
+        {
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "Wayland: Cannot copy failed to create data source");
+            return;
+        }
+        wl_data_source_add_listener(_glfw.wl.dataSourceForClipboard, &data_source_listener, NULL);
+        data_source = _glfw.wl.dataSourceForClipboard;
+    } else {
+        if (!_glfw.wl.primarySelectionDevice) {
+            static bool warned_about_primary_selection_device = false;
+            if (!warned_about_primary_selection_device) {
+                _glfwInputError(GLFW_PLATFORM_ERROR,
+                                "Wayland: Cannot copy no primary selection device available");
+                warned_about_primary_selection_device = true;
+            }
+            return;
+        }
+        cd = &_glfw.primary;
+        f = (add_offer_func)zwp_primary_selection_source_v1_offer;
+        if (_glfw.wl.dataSourceForPrimarySelection) zwp_primary_selection_source_v1_destroy(_glfw.wl.dataSourceForPrimarySelection);
+        _glfw.wl.dataSourceForPrimarySelection = zwp_primary_selection_device_manager_v1_create_source(_glfw.wl.primarySelectionDeviceManager);
+        if (!_glfw.wl.dataSourceForPrimarySelection)
+        {
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "Wayland: Cannot copy failed to create primary selection source");
+            return;
+        }
+        zwp_primary_selection_source_v1_add_listener(_glfw.wl.dataSourceForPrimarySelection, &primary_selection_source_listener, NULL);
+        data_source = _glfw.wl.dataSourceForPrimarySelection;
+    }
+    f(data_source, clipboard_mime());
+    for (size_t i = 0; i < cd->num_mime_types; i++) {
+        if (strcmp(cd->mime_types[i], "text/plain") == 0) {
+            f(data_source, "TEXT");
+            f(data_source, "STRING");
+            f(data_source, "UTF8_STRING");
+            f(data_source, "text/plain;charset=utf-8");
+        }
+        f(data_source, cd->mime_types[i]);
     }
-    wl_data_source_add_listener(_glfw.wl.dataSourceForClipboard, &data_source_listener, NULL);
-    wl_data_source_offer(_glfw.wl.dataSourceForClipboard, clipboard_mime());
-    wl_data_source_offer(_glfw.wl.dataSourceForClipboard, "text/plain");
-    wl_data_source_offer(_glfw.wl.dataSourceForClipboard, "text/plain;charset=utf-8");
-    wl_data_source_offer(_glfw.wl.dataSourceForClipboard, "TEXT");
-    wl_data_source_offer(_glfw.wl.dataSourceForClipboard, "STRING");
-    wl_data_source_offer(_glfw.wl.dataSourceForClipboard, "UTF8_STRING");
     struct wl_callback *callback = wl_display_sync(_glfw.wl.display);
-    static const struct wl_callback_listener clipboard_copy_callback_listener = {.done = clipboard_copy_callback_done};
-    wl_callback_add_listener(callback, &clipboard_copy_callback_listener, _glfw.wl.dataSourceForClipboard);
+    if (t == GLFW_CLIPBOARD) {
+        static const struct wl_callback_listener clipboard_copy_callback_listener = {.done = clipboard_copy_callback_done};
+        wl_callback_add_listener(callback, &clipboard_copy_callback_listener, _glfw.wl.dataSourceForClipboard);
+    } else {
+        static const struct wl_callback_listener primary_selection_copy_callback_listener = {.done = primary_selection_copy_callback_done};
+        wl_callback_add_listener(callback, &primary_selection_copy_callback_listener, _glfw.wl.dataSourceForPrimarySelection);
+    }
 }
 
 static bool
@@ -1870,81 +2068,47 @@ plain_text_mime_for_offer(const _GLFWWaylandDataOffer *d) {
     A("text/plain");
     A("UTF8_STRING");
     A("STRING");
+    A("TEXT");
 #undef A
     return NULL;
 }
 
-const char* _glfwPlatformGetClipboardString(void)
-{
+void
+_glfwPlatformGetClipboard(GLFWClipboardType clipboard_type, const char* mime_type, GLFWclipboardwritedatafun write_data, void *object) {
+    _GLFWWaylandOfferType offer_type = clipboard_type == GLFW_PRIMARY_SELECTION ? PRIMARY_SELECTION : CLIPBOARD;
     for (size_t i = 0; i < arraysz(_glfw.wl.dataOffers); i++) {
         _GLFWWaylandDataOffer *d = _glfw.wl.dataOffers + i;
-        if (d->id && d->offer_type == CLIPBOARD) {
-            if (d->is_self_offer) return _glfw.wl.clipboardString;
-            const char *mime = plain_text_mime_for_offer(d);
-            if (mime) {
-                free(_glfw.wl.pasteString);
-                size_t sz = 0;
-                _glfw.wl.pasteString = read_data_offer(d->id, mime, &sz);
-                return _glfw.wl.pasteString;
+        if (d->id && d->offer_type == offer_type) {
+            if (d->is_self_offer) {
+                write_data(object, NULL, 1);
+                return;
             }
-        }
-    }
-    return NULL;
-}
-
-void _glfwPlatformSetPrimarySelectionString(const char* string)
-{
-    if (!_glfw.wl.primarySelectionDevice) {
-        static bool warned_about_primary_selection_device = false;
-        if (!warned_about_primary_selection_device) {
-            _glfwInputError(GLFW_PLATFORM_ERROR,
-                            "Wayland: Cannot copy no primary selection device available");
-            warned_about_primary_selection_device = true;
-        }
-        return;
-    }
-    if (_glfw.wl.primarySelectionString == string) return;
-    free(_glfw.wl.primarySelectionString);
-    _glfw.wl.primarySelectionString = _glfw_strdup(string);
-
-    if (_glfw.wl.dataSourceForPrimarySelection)
-        zwp_primary_selection_source_v1_destroy(_glfw.wl.dataSourceForPrimarySelection);
-    _glfw.wl.dataSourceForPrimarySelection = zwp_primary_selection_device_manager_v1_create_source(_glfw.wl.primarySelectionDeviceManager);
-    if (!_glfw.wl.dataSourceForPrimarySelection)
-    {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Wayland: Cannot copy failed to create primary selection source");
-        return;
-    }
-    zwp_primary_selection_source_v1_add_listener(_glfw.wl.dataSourceForPrimarySelection, &primary_selection_source_listener, NULL);
-    zwp_primary_selection_source_v1_offer(_glfw.wl.dataSourceForPrimarySelection, clipboard_mime());
-    zwp_primary_selection_source_v1_offer(_glfw.wl.dataSourceForPrimarySelection, "text/plain");
-    zwp_primary_selection_source_v1_offer(_glfw.wl.dataSourceForPrimarySelection, "text/plain;charset=utf-8");
-    zwp_primary_selection_source_v1_offer(_glfw.wl.dataSourceForPrimarySelection, "TEXT");
-    zwp_primary_selection_source_v1_offer(_glfw.wl.dataSourceForPrimarySelection, "STRING");
-    zwp_primary_selection_source_v1_offer(_glfw.wl.dataSourceForPrimarySelection, "UTF8_STRING");
-    struct wl_callback *callback = wl_display_sync(_glfw.wl.display);
-    static const struct wl_callback_listener primary_selection_copy_callback_listener = {.done = primary_selection_copy_callback_done};
-    wl_callback_add_listener(callback, &primary_selection_copy_callback_listener, _glfw.wl.dataSourceForPrimarySelection);
-}
-
-const char* _glfwPlatformGetPrimarySelectionString(void)
-{
-    if (_glfw.wl.dataSourceForPrimarySelection != NULL) return _glfw.wl.primarySelectionString;
-
-    for (size_t i = 0; i < arraysz(_glfw.wl.dataOffers); i++) {
-        _GLFWWaylandDataOffer *d = _glfw.wl.dataOffers + i;
-        if (d->id && d->is_primary && d->offer_type == PRIMARY_SELECTION) {
-            if (d->is_self_offer) return _glfw.wl.primarySelectionString;
-            const char *mime = plain_text_mime_for_offer(d);
-            if (mime) {
-                free(_glfw.wl.pasteString);
-                _glfw.wl.pasteString = read_primary_selection_offer(d->id, mime);
-                return _glfw.wl.pasteString;
+            if (mime_type == NULL) {
+                bool ok = true;
+                for (size_t o = 0; o < d->mimes_count; o++) {
+                    const char *q = d->mimes[o];
+                    if (strchr(d->mimes[0], '/')) {
+                        if (strcmp(q, clipboard_mime()) == 0) continue;
+                        if (strcmp(q, "text/plain;charset=utf-8") == 0) q = "text/plain";
+                    } else {
+                        if (strcmp(q, "UTF8_STRING") == 0 || strcmp(q, "STRING") == 0 || strcmp(q, "TEXT") == 0) q = "text/plain";
+                    }
+                    if (ok) ok = write_data(object, q, strlen(q));
+                }
+                return;
             }
+            if (strcmp(mime_type, "text/plain") == 0) {
+                mime_type = plain_text_mime_for_offer(d);
+                if (!mime_type) return;
+            }
+            if (d->is_primary) {
+                read_primary_selection_offer(d->id, mime_type, write_data, object);
+            } else {
+                read_clipboard_data_offer(d->id, mime_type, write_data, object);
+            }
+            break;
         }
     }
-    return NULL;
 }
 
 EGLenum _glfwPlatformGetEGLPlatform(EGLint** attribs UNUSED)
@@ -2066,6 +2230,18 @@ GLFWAPI struct wl_surface* glfwGetWaylandWindow(GLFWwindow* handle)
     return window->wl.surface;
 }
 
+GLFWAPI void glfwWaylandActivateWindow(GLFWwindow* handle, const char *activation_token) {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT();
+    if (activation_token && activation_token[0]) xdg_activation_v1_activate(_glfw.wl.xdg_activation_v1, activation_token, window->wl.surface);
+}
+
+GLFWAPI void glfwWaylandRunWithActivationToken(GLFWwindow *handle, GLFWactivationcallback cb, void *cb_data) {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT();
+    get_activation_token(window, _glfw.wl.input_serial, cb, cb_data);
+}
+
 GLFWAPI int glfwGetNativeKeyForName(const char* keyName, bool caseSensitive) {
     return glfw_xkb_keysym_from_name(keyName, caseSensitive);
 }
@@ -2074,12 +2250,19 @@ GLFWAPI void glfwRequestWaylandFrameEvent(GLFWwindow *handle, unsigned long long
     _GLFWwindow* window = (_GLFWwindow*) handle;
     static const struct wl_callback_listener frame_listener = { .done = frame_handle_redraw };
     if (window->wl.frameCallbackData.current_wl_callback) wl_callback_destroy(window->wl.frameCallbackData.current_wl_callback);
-    window->wl.frameCallbackData.id = id;
-    window->wl.frameCallbackData.callback = callback;
-    window->wl.frameCallbackData.current_wl_callback = wl_surface_frame(window->wl.surface);
-    if (window->wl.frameCallbackData.current_wl_callback) {
-        wl_callback_add_listener(window->wl.frameCallbackData.current_wl_callback, &frame_listener, window);
-        wl_surface_commit(window->wl.surface);
+    if (window->wl.waiting_for_swap_to_commit) {
+        callback(id);
+        window->wl.frameCallbackData.id = 0;
+        window->wl.frameCallbackData.callback = NULL;
+        window->wl.frameCallbackData.current_wl_callback = NULL;
+    } else {
+        window->wl.frameCallbackData.id = id;
+        window->wl.frameCallbackData.callback = callback;
+        window->wl.frameCallbackData.current_wl_callback = wl_surface_frame(window->wl.surface);
+        if (window->wl.frameCallbackData.current_wl_callback) {
+            wl_callback_add_listener(window->wl.frameCallbackData.current_wl_callback, &frame_listener, window);
+            commit_window_surface_if_safe(window);
+        }
     }
 }
 

glfw/x11_init.c

@@ -137,6 +137,8 @@ static void detectEWMH(void)
         getAtomIfSupported(supportedAtoms, atomCount, "_NET_WM_WINDOW_TYPE");
     _glfw.x11.NET_WM_WINDOW_TYPE_NORMAL =
         getAtomIfSupported(supportedAtoms, atomCount, "_NET_WM_WINDOW_TYPE_NORMAL");
+    _glfw.x11.NET_WM_WINDOW_TYPE_DOCK =
+        getAtomIfSupported(supportedAtoms, atomCount, "_NET_WM_WINDOW_TYPE_DOCK");
     _glfw.x11.NET_WORKAREA =
         getAtomIfSupported(supportedAtoms, atomCount, "_NET_WORKAREA");
     _glfw.x11.NET_CURRENT_DESKTOP =
@@ -147,6 +149,8 @@ static void detectEWMH(void)
         getAtomIfSupported(supportedAtoms, atomCount, "_NET_FRAME_EXTENTS");
     _glfw.x11.NET_REQUEST_FRAME_EXTENTS =
         getAtomIfSupported(supportedAtoms, atomCount, "_NET_REQUEST_FRAME_EXTENTS");
+    _glfw.x11.NET_WM_STRUT_PARTIAL =
+        getAtomIfSupported(supportedAtoms, atomCount, "_NET_WM_STRUT_PARTIAL");
 
     XFree(supportedAtoms);
 }
@@ -680,8 +684,14 @@ void _glfwPlatformTerminate(void)
 
     glfw_xkb_release(&_glfw.x11.xkb);
     glfw_dbus_terminate(&_glfw.x11.dbus);
-    free(_glfw.x11.primarySelectionString);
-    free(_glfw.x11.clipboardString);
+    if (_glfw.x11.mime_atoms.array) {
+        for (size_t i = 0; i < _glfw.x11.mime_atoms.sz; i++) {
+            free((void*)_glfw.x11.mime_atoms.array[i].mime);
+        }
+        free(_glfw.x11.mime_atoms.array);
+    }
+    if (_glfw.x11.clipboard_atoms.array) { free(_glfw.x11.clipboard_atoms.array); }
+    if (_glfw.x11.primary_atoms.array) { free(_glfw.x11.primary_atoms.array); }
 
     if (_glfw.x11.display)
     {

glfw/x11_platform.h

@@ -207,6 +207,16 @@ typedef struct _GLFWwindowX11
 
 } _GLFWwindowX11;
 
+typedef struct MimeAtom {
+        Atom atom;
+        const char* mime;
+} MimeAtom;
+
+typedef struct AtomArray {
+    MimeAtom *array;
+    size_t sz, capacity;
+} AtomArray;
+
 // X11-specific global data
 //
 typedef struct _GLFWlibraryX11
@@ -225,10 +235,6 @@ typedef struct _GLFWlibraryX11
     XContext        context;
     // Most recent error code received by X error handler
     int             errorCode;
-    // Primary selection string (while the primary selection is owned)
-    char*           primarySelectionString;
-    // Clipboard string (while the selection is owned)
-    char*           clipboardString;
     // Where to place the cursor when re-enabled
     double          restoreCursorPosX, restoreCursorPosY;
     // The window whose disabled cursor mode is active
@@ -247,6 +253,7 @@ typedef struct _GLFWlibraryX11
     Atom            NET_WM_PING;
     Atom            NET_WM_WINDOW_TYPE;
     Atom            NET_WM_WINDOW_TYPE_NORMAL;
+    Atom            NET_WM_WINDOW_TYPE_DOCK;
     Atom            NET_WM_STATE;
     Atom            NET_WM_STATE_ABOVE;
     Atom            NET_WM_STATE_FULLSCREEN;
@@ -262,6 +269,7 @@ typedef struct _GLFWlibraryX11
     Atom            NET_ACTIVE_WINDOW;
     Atom            NET_FRAME_EXTENTS;
     Atom            NET_REQUEST_FRAME_EXTENTS;
+    Atom            NET_WM_STRUT_PARTIAL;
     Atom            MOTIF_WM_HINTS;
 
     // Xdnd (drag and drop) atoms
@@ -291,6 +299,8 @@ typedef struct _GLFWlibraryX11
 
     // XRM database atom
     Atom            RESOURCE_MANAGER;
+    // Atoms for MIME types
+    AtomArray mime_atoms, clipboard_atoms, primary_atoms;
 
     struct {
         bool        available;

glfw/x11_window.c

@@ -716,19 +716,60 @@ static bool createNativeWindow(_GLFWwindow* window,
     return true;
 }
 
+static size_t
+get_clipboard_data(const _GLFWClipboardData *cd, const char *mime, char **data) {
+    *data = NULL;
+    GLFWDataChunk chunk = cd->get_data(mime, NULL, cd->ctype);
+    char *buf = NULL;
+    size_t sz = 0, cap = 0;
+    void *iter = chunk.iter;
+    if (!iter) return 0;
+    while (true) {
+        chunk = cd->get_data(mime, iter, cd->ctype);
+        if (!chunk.sz) break;
+        if (cap < sz + chunk.sz) {
+            cap = MAX(cap * 2, sz + 4 * chunk.sz);
+            buf = realloc(buf, cap * sizeof(buf[0]));
+        }
+        memcpy(buf + sz, chunk.data, chunk.sz);
+        sz += chunk.sz;
+        if (chunk.free) chunk.free((void*)chunk.free_data);
+    }
+    *data = buf;
+    cd->get_data(NULL, iter, cd->ctype);
+    return sz;
+}
+
+static void
+get_atom_names(const Atom *atoms, int count, char **atom_names) {
+    _glfwGrabErrorHandlerX11();
+    XGetAtomNames(_glfw.x11.display, (Atom*)atoms, count, atom_names);
+    _glfwReleaseErrorHandlerX11();
+    if (_glfw.x11.errorCode != Success) {
+        for (int i = 0; i < count; i++) {
+            _glfwGrabErrorHandlerX11();
+            atom_names[i] = XGetAtomName(_glfw.x11.display, atoms[i]);
+            _glfwReleaseErrorHandlerX11();
+            if (_glfw.x11.errorCode != Success) atom_names[i] = NULL;
+        }
+    }
+}
+
+
 // Set the specified property to the selection converted to the requested target
 //
 static Atom writeTargetToProperty(const XSelectionRequestEvent* request)
 {
-    int i;
-    char* selectionString = NULL;
-    const Atom formats[] = { _glfw.x11.UTF8_STRING, XA_STRING };
-    const int formatCount = sizeof(formats) / sizeof(formats[0]);
+    const AtomArray *aa;
+    const _GLFWClipboardData *cd;
 
-    if (request->selection == _glfw.x11.PRIMARY)
-        selectionString = _glfw.x11.primarySelectionString;
-    else
-        selectionString = _glfw.x11.clipboardString;
+    if (request->selection == _glfw.x11.PRIMARY) {
+        aa = &_glfw.x11.primary_atoms;
+        cd = &_glfw.primary;
+    } else {
+        aa = &_glfw.x11.clipboard_atoms;
+        cd = &_glfw.clipboard;
+    }
 
     if (request->property == None)
     {
@@ -741,11 +782,10 @@ static Atom writeTargetToProperty(const XSelectionRequestEvent* request)
     {
         // The list of supported targets was requested
 
-        const Atom targets[] = { _glfw.x11.TARGETS,
-                                 _glfw.x11.MULTIPLE,
-                                 _glfw.x11.UTF8_STRING,
-                                 XA_STRING };
-
+        Atom *targets = calloc(aa->sz + 2, sizeof(Atom));
+        targets[0] = _glfw.x11.TARGETS;
+        targets[1] = _glfw.x11.MULTIPLE;
+        for (size_t i = 0; i < aa->sz; i++) targets[i+2] = aa->array[i].atom;
         XChangeProperty(_glfw.x11.display,
                         request->requestor,
                         request->property,
@@ -753,8 +793,8 @@ static Atom writeTargetToProperty(const XSelectionRequestEvent* request)
                         32,
                         PropModeReplace,
                         (unsigned char*) targets,
-                        sizeof(targets) / sizeof(targets[0]));
-
+                        aa->sz + 2);
+        free(targets);
         return request->property;
     }
 
@@ -763,7 +803,7 @@ static Atom writeTargetToProperty(const XSelectionRequestEvent* request)
         // Multiple conversions were requested
 
         Atom* targets;
-        unsigned long i, count;
+        size_t i, j, count;
 
         count = _glfwGetWindowPropertyX11(request->requestor,
                                           request->property,
@@ -772,24 +812,25 @@ static Atom writeTargetToProperty(const XSelectionRequestEvent* request)
 
         for (i = 0;  i < count;  i += 2)
         {
-            int j;
-
-            for (j = 0;  j < formatCount;  j++)
+            for (j = 0;  j < aa->sz;  j++)
             {
-                if (targets[i] == formats[j])
+                if (targets[i] == aa->array[j].atom)
                     break;
             }
 
-            if (j < formatCount)
+            if (j < aa->sz)
             {
-                if (selectionString) XChangeProperty(_glfw.x11.display,
+                char *data = NULL; size_t sz = get_clipboard_data(cd, aa->array[j].mime, &data);
+
+                if (data) XChangeProperty(_glfw.x11.display,
                                 request->requestor,
                                 targets[i + 1],
                                 targets[i],
                                 8,
                                 PropModeReplace,
-                                (unsigned char *) selectionString,
-                                strlen(selectionString));
+                                (unsigned char *) data,
+                                sz);
+                free(data);
             }
             else
                 targets[i + 1] = None;
@@ -828,20 +869,22 @@ static Atom writeTargetToProperty(const XSelectionRequestEvent* request)
 
     // Conversion to a data target was requested
 
-    for (i = 0;  i < formatCount;  i++)
+    for (size_t i = 0;  i < aa->sz;  i++)
     {
-        if (request->target == formats[i])
+        if (request->target == aa->array[i].atom)
         {
             // The requested target is one we support
 
-            if (selectionString) XChangeProperty(_glfw.x11.display,
+            char *data = NULL; size_t sz = get_clipboard_data(cd, aa->array[i].mime, &data);
+            if (data) XChangeProperty(_glfw.x11.display,
                             request->requestor,
                             request->property,
                             request->target,
                             8,
                             PropModeReplace,
-                            (unsigned char *) selectionString,
-                            strlen(selectionString));
+                            (unsigned char *) data,
+                            sz);
+            free(data);
 
             return request->property;
         }
@@ -856,13 +899,11 @@ static void handleSelectionClear(XEvent* event)
 {
     if (event->xselectionclear.selection == _glfw.x11.PRIMARY)
     {
-        free(_glfw.x11.primarySelectionString);
-        _glfw.x11.primarySelectionString = NULL;
+        _glfw_free_clipboard_data(&_glfw.primary);
     }
     else
     {
-        free(_glfw.x11.clipboardString);
-        _glfw.x11.clipboardString = NULL;
+        _glfw_free_clipboard_data(&_glfw.clipboard);
     }
 }
 
@@ -881,34 +922,21 @@ static void handleSelectionRequest(XEvent* event)
     XSendEvent(_glfw.x11.display, request->requestor, False, 0, &reply);
 }
 
-static const char* getSelectionString(Atom selection)
+static void
+getSelectionString(Atom selection, Atom *targets, size_t num_targets, GLFWclipboardwritedatafun write_data, void *object, bool report_not_found)
 {
-    char** selectionString = NULL;
-    const Atom targets[] = { _glfw.x11.UTF8_STRING, XA_STRING };
-    const size_t targetCount = sizeof(targets) / sizeof(targets[0]);
-
-    if (selection == _glfw.x11.PRIMARY)
-        selectionString = &_glfw.x11.primarySelectionString;
-    else
-        selectionString = &_glfw.x11.clipboardString;
-
-    if (XGetSelectionOwner(_glfw.x11.display, selection) ==
-        _glfw.x11.helperWindowHandle)
-    {
-        // Instead of doing a large number of X round-trips just to put this
-        // string into a window property and then read it back, just return it
-        return *selectionString;
+#define XFREE(x) { if (x) XFree(x); x = NULL; }
+    if (XGetSelectionOwner(_glfw.x11.display, selection) == _glfw.x11.helperWindowHandle) {
+        write_data(object, NULL, 1);
+        return;
     }
-
-    free(*selectionString);
-    *selectionString = NULL;
-
-    for (size_t i = 0;  i < targetCount;  i++)
+    bool found = false;
+    for (size_t i = 0; !found && i < num_targets; i++)
     {
-        char* data;
-        Atom actualType;
-        int actualFormat;
-        unsigned long itemCount, bytesAfter;
+        char* data = NULL;
+        Atom actualType = None;
+        int actualFormat = 0;
+        unsigned long itemCount = 0, bytesAfter = 0;
         monotonic_t start = glfwGetTime();
         XEvent notification, dummy;
 
@@ -925,8 +953,7 @@ static const char* getSelectionString(Atom selection)
                                        &notification))
         {
             monotonic_t time = glfwGetTime();
-            if (time - start > s_to_monotonic_t(2ll))
-                return "";
+            if (time - start > s_to_monotonic_t(2ll)) return;
             waitForX11Event(s_to_monotonic_t(2ll) - (time - start));
         }
 
@@ -953,9 +980,6 @@ static const char* getSelectionString(Atom selection)
 
         if (actualType == _glfw.x11.INCR)
         {
-            size_t size = 1;
-            char* string = NULL;
-
             for (;;)
             {
                 start = glfwGetTime();
@@ -966,13 +990,12 @@ static const char* getSelectionString(Atom selection)
                 {
                     monotonic_t time = glfwGetTime();
                     if (time - start > s_to_monotonic_t(2ll)) {
-                        free(string);
-                        return "";
+                        return;
                     }
                     waitForX11Event(s_to_monotonic_t(2ll) - (time - start));
                 }
 
-                XFree(data);
+                XFREE(data);
                 XGetWindowProperty(_glfw.x11.display,
                                    notification.xselection.requestor,
                                    notification.xselection.property,
@@ -988,47 +1011,41 @@ static const char* getSelectionString(Atom selection)
 
                 if (itemCount)
                 {
-                    size += itemCount;
-                    string = realloc(string, size);
-                    string[size - itemCount - 1] = '\0';
-                    strcat(string, data);
-                }
-
-                if (!itemCount)
-                {
-                    if (targets[i] == XA_STRING)
-                    {
-                        *selectionString = convertLatin1toUTF8(string);
-                        free(string);
+                    const char *string = data;
+                    if (targets[i] == XA_STRING) {
+                        string = convertLatin1toUTF8(data);
+                        itemCount = strlen(string);
                     }
-                    else
-                        *selectionString = string;
+                    bool ok = write_data(object, string, itemCount);
+                    if (string != data) free((void*)string);
+                    if (!ok) { XFREE(data); break; }
+                } else { found = true; break; }
 
-                    break;
-                }
             }
         }
         else if (actualType == targets[i])
         {
-            if (targets[i] == XA_STRING)
-                *selectionString = convertLatin1toUTF8(data);
-            else
-                *selectionString = _glfw_strdup(data);
+            if (targets[i] == XA_STRING) {
+                const char *string = convertLatin1toUTF8(data);
+                write_data(object, string, strlen(string)); free((void*)string);
+            } else write_data(object, data, itemCount);
+            found = true;
+        }
+        else if (actualType == XA_ATOM && targets[i] == _glfw.x11.TARGETS) {
+            found = true;
+            write_data(object, data, sizeof(Atom) * itemCount);
         }
 
-        XFree(data);
+        XFREE(data);
 
-        if (*selectionString)
-            break;
     }
 
-    if (!*selectionString)
+    if (!found && report_not_found)
     {
         _glfwInputError(GLFW_FORMAT_UNAVAILABLE,
-                        "X11: Failed to convert selection to string");
+                        "X11: Failed to convert selection to data from clipboard");
     }
-
-    return *selectionString;
+#undef XFREE
 }
 
 // Make the specified window and its video mode active on its monitor
@@ -1098,21 +1115,6 @@ static void onConfigChange(void)
     }
 }
 
-static void
-get_atom_names(Atom *atoms, int count, char **atom_names) {
-    _glfwGrabErrorHandlerX11();
-    XGetAtomNames(_glfw.x11.display, atoms, count, atom_names);
-    _glfwReleaseErrorHandlerX11();
-    if (_glfw.x11.errorCode != Success) {
-        for (int i = 0; i < count; i++) {
-            _glfwGrabErrorHandlerX11();
-            atom_names[i] = XGetAtomName(_glfw.x11.display, atoms[i]);
-            _glfwReleaseErrorHandlerX11();
-            if (_glfw.x11.errorCode != Success) atom_names[i] = NULL;
-        }
-    }
-}
-
 // Process the specified X event
 //
 static void processEvent(XEvent *event)
@@ -2849,51 +2851,120 @@ void _glfwPlatformSetCursor(_GLFWwindow* window, _GLFWcursor* cursor UNUSED)
     }
 }
 
-void _glfwPlatformSetClipboardString(const char* string)
-{
-    char* copy = _glfw_strdup(string);
-    free(_glfw.x11.clipboardString);
-    _glfw.x11.clipboardString = copy;
+static MimeAtom atom_for_mime(const char *mime) {
+    for (size_t i = 0; i < _glfw.x11.mime_atoms.sz; i++) {
+        MimeAtom ma = _glfw.x11.mime_atoms.array[i];
+        if (strcmp(ma.mime, mime) == 0) {
+            return ma;
+        }
+    }
+    MimeAtom ma = {.mime=_glfw_strdup(mime), .atom=XInternAtom(_glfw.x11.display, mime, 0)};
+    if (_glfw.x11.mime_atoms.capacity < _glfw.x11.mime_atoms.sz + 1) {
+        _glfw.x11.mime_atoms.capacity += 32;
+        _glfw.x11.mime_atoms.array = realloc(_glfw.x11.mime_atoms.array, _glfw.x11.mime_atoms.capacity * sizeof(_glfw.x11.mime_atoms.array[0]));
+    }
+    _glfw.x11.mime_atoms.array[_glfw.x11.mime_atoms.sz++] = ma;
+    return ma;
+}
 
-    XSetSelectionOwner(_glfw.x11.display,
-                       _glfw.x11.CLIPBOARD,
-                       _glfw.x11.helperWindowHandle,
-                       CurrentTime);
-
-    if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.CLIPBOARD) !=
-        _glfw.x11.helperWindowHandle)
-    {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "X11: Failed to become owner of clipboard selection");
+void _glfwPlatformSetClipboard(GLFWClipboardType t) {
+    Atom which = None;
+    _GLFWClipboardData *cd = NULL;
+    AtomArray *aa = NULL;
+    switch (t) {
+        case GLFW_CLIPBOARD: which = _glfw.x11.CLIPBOARD; cd = &_glfw.clipboard; aa = &_glfw.x11.clipboard_atoms; break;
+        case GLFW_PRIMARY_SELECTION: which = _glfw.x11.PRIMARY; cd = &_glfw.primary; aa = &_glfw.x11.primary_atoms; break;
+    }
+    XSetSelectionOwner(_glfw.x11.display, which, _glfw.x11.helperWindowHandle, CurrentTime);
+    if (XGetSelectionOwner(_glfw.x11.display, which) != _glfw.x11.helperWindowHandle) {
+        _glfwInputError(GLFW_PLATFORM_ERROR, "X11: Failed to become owner of clipboard selection");
+    }
+    if (aa->capacity < cd->num_mime_types + 32) {
+        aa->capacity = cd->num_mime_types + 32;
+        aa->array = reallocarray(aa->array, aa->capacity, sizeof(aa->array[0]));
+    }
+    aa->sz = 0;
+    for (size_t i = 0; i < cd->num_mime_types; i++) {
+        MimeAtom *a = aa->array + aa->sz++;
+        *a = atom_for_mime(cd->mime_types[i]);
+        if (strcmp(cd->mime_types[i], "text/plain") == 0) {
+            a = aa->array + aa->sz++;
+            a->atom = _glfw.x11.UTF8_STRING;
+            a->mime = "text/plain";
+        }
     }
 }
 
-const char* _glfwPlatformGetClipboardString(void)
-{
-    return getSelectionString(_glfw.x11.CLIPBOARD);
+typedef struct chunked_writer {
+    char *buf; size_t sz, cap;
+    bool is_self_offer;
+} chunked_writer;
+
+static bool
+write_chunk(void *object, const char *data, size_t sz) {
+    chunked_writer *cw = object;
+    if (data) {
+        if (cw->cap < cw->sz + sz) {
+            cw->cap = MAX(cw->cap * 2, cw->sz + 8*sz);
+            cw->buf = realloc(cw->buf, cw->cap * sizeof(cw->buf[0]));
+        }
+        memcpy(cw->buf + cw->sz, data, sz);
+        cw->sz += sz;
+    } else if (sz == 1) cw->is_self_offer = true;
+    return true;
 }
 
-void _glfwPlatformSetPrimarySelectionString(const char* string)
-{
-    free(_glfw.x11.primarySelectionString);
-    _glfw.x11.primarySelectionString = _glfw_strdup(string);
-
-    XSetSelectionOwner(_glfw.x11.display,
-                       _glfw.x11.PRIMARY,
-                       _glfw.x11.helperWindowHandle,
-                       CurrentTime);
-
-    if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.PRIMARY) !=
-        _glfw.x11.helperWindowHandle)
-    {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "X11: Failed to become owner of primary selection");
+static void
+get_available_mime_types(Atom which_clipboard, GLFWclipboardwritedatafun write_data, void *object) {
+    chunked_writer cw = {0};
+    getSelectionString(which_clipboard, &_glfw.x11.TARGETS, 1, write_chunk, &cw, false);
+    if (cw.is_self_offer) {
+        write_data(object, NULL, 1);
+        return;
+    }
+    size_t count = 0;
+    bool ok = true;
+    if (cw.buf) {
+        Atom *atoms = (Atom*)cw.buf;
+        count = cw.sz / sizeof(Atom);
+        char **names = calloc(count, sizeof(char*));
+        get_atom_names(atoms, count, names);
+        for (size_t i = 0; i < count; i++) {
+            if (strchr(names[i], '/')) {
+                if (ok) ok = write_data(object, names[i], strlen(names[i]));
+            } else {
+                if (atoms[i] == _glfw.x11.UTF8_STRING || atoms[i] == XA_STRING) {
+                    if (ok) ok = write_data(object, "text/plain", strlen("text/plain"));
+                }
+            }
+            XFree(names[i]);
+        }
+        free(cw.buf);
+        free(names);
     }
 }
 
-const char* _glfwPlatformGetPrimarySelectionString(void)
-{
-    return getSelectionString(_glfw.x11.PRIMARY);
+void
+_glfwPlatformGetClipboard(GLFWClipboardType clipboard_type, const char* mime_type, GLFWclipboardwritedatafun write_data, void *object) {
+    Atom atoms[4], which = clipboard_type == GLFW_PRIMARY_SELECTION ? _glfw.x11.PRIMARY : _glfw.x11.CLIPBOARD;
+    if (mime_type == NULL) {
+        get_available_mime_types(which, write_data, object);
+        return;
+    }
+    size_t count = 0;
+    if (strcmp(mime_type, "text/plain") == 0) {
+        // UTF8_STRING is what xclip uses by default, and there are people out there that expect to be able to paste from it with a single read operation. See https://github.com/kovidgoyal/kitty/issues/5842
+        // Also ancient versions of GNOME use DOS line endings even for text/plain;charset=utf-8. See https://github.com/kovidgoyal/kitty/issues/5528#issuecomment-1325348218
+        atoms[count++] = _glfw.x11.UTF8_STRING;
+        // we need to do this because GTK/GNOME is moronic they convert text/plain to DOS line endings, see
+        // https://gitlab.gnome.org/GNOME/gtk/-/issues/2307
+        atoms[count++] = atom_for_mime("text/plain;charset=utf-8").atom;
+        atoms[count++] = atom_for_mime("text/plain").atom;
+        atoms[count++] = XA_STRING;
+    } else {
+        atoms[count++] = atom_for_mime(mime_type).atom;
+    }
+    getSelectionString(which, atoms, count, write_data, object, true);
 }
 
 EGLenum _glfwPlatformGetEGLPlatform(EGLint** attribs)
@@ -3134,3 +3205,18 @@ GLFWAPI int glfwSetX11LaunchCommand(GLFWwindow *handle, char **argv, int argc)
     _GLFWwindow* window = (_GLFWwindow*) handle;
     return XSetCommand(_glfw.x11.display, window->x11.handle, argv, argc);
 }
+
+GLFWAPI void glfwSetX11WindowAsDock(int32_t x11_window_id) {
+    _GLFW_REQUIRE_INIT();
+    Atom type = _glfw.x11.NET_WM_WINDOW_TYPE_DOCK;
+    XChangeProperty(_glfw.x11.display, x11_window_id,
+                    _glfw.x11.NET_WM_WINDOW_TYPE, XA_ATOM, 32,
+                    PropModeReplace, (unsigned char*) &type, 1);
+}
+
+GLFWAPI void glfwSetX11WindowStrut(int32_t x11_window_id, uint32_t dimensions[12]) {
+    _GLFW_REQUIRE_INIT();
+    XChangeProperty(_glfw.x11.display, x11_window_id,
+                    _glfw.x11.NET_WM_STRUT_PARTIAL, XA_CARDINAL, 32,
+                    PropModeReplace, (unsigned char*) dimensions, 12);
+}

go.mod

@@ -0,0 +1,17 @@
+module kitty
+
+go 1.20
+
+require (
+	github.com/ALTree/bigfloat v0.0.0-20220102081255-38c8b72a9924
+	github.com/disintegration/imaging v1.6.2
+	github.com/google/go-cmp v0.5.8
+	github.com/google/uuid v1.3.0
+	github.com/jamesruan/go-rfc1924 v0.0.0-20170108144916-2767ca7c638f
+	github.com/seancfoley/ipaddress-go v1.5.3
+	golang.org/x/exp v0.0.0-20230202163644-54bba9f4231b
+	golang.org/x/image v0.3.0
+	golang.org/x/sys v0.4.0
+)
+
+require github.com/seancfoley/bintree v1.2.1 // indirect

go.sum

@@ -0,0 +1,45 @@
+github.com/ALTree/bigfloat v0.0.0-20220102081255-38c8b72a9924 h1:DG4UyTVIujioxwJc8Zj8Nabz1L1wTgQ/xNBSQDfdP3I=
+github.com/ALTree/bigfloat v0.0.0-20220102081255-38c8b72a9924/go.mod h1:+NaH2gLeY6RPBPPQf4aRotPPStg+eXc8f9ZaE4vRfD4=
+github.com/disintegration/imaging v1.6.2 h1:w1LecBlG2Lnp8B3jk5zSuNqd7b4DXhcjwek1ei82L+c=
+github.com/disintegration/imaging v1.6.2/go.mod h1:44/5580QXChDfwIclfc/PCwrr44amcmDAg8hxG0Ewe4=
+github.com/google/go-cmp v0.5.8 h1:e6P7q2lk1O+qJJb4BtCQXlK8vWEO8V1ZeuEdJNOqZyg=
+github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
+github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/jamesruan/go-rfc1924 v0.0.0-20170108144916-2767ca7c638f h1:Ko4+g6K16vSyUrtd/pPXuQnWsiHe5BYptEtTxfwYwCc=
+github.com/jamesruan/go-rfc1924 v0.0.0-20170108144916-2767ca7c638f/go.mod h1:eHzfhOKbTGJEGPSdMHzU6jft192tHHt2Bu2vIZArvC0=
+github.com/seancfoley/bintree v1.2.1 h1:Z/iNjRKkXnn0CTW7jDQYtjW5fz2GH1yWvOTJ4MrMvdo=
+github.com/seancfoley/bintree v1.2.1/go.mod h1:hIUabL8OFYyFVTQ6azeajbopogQc2l5C/hiXMcemWNU=
+github.com/seancfoley/ipaddress-go v1.5.3 h1:fLnn4nsatd2rp3IJsVWriXv5gXn2Qiy8uxjxe4iZtTg=
+github.com/seancfoley/ipaddress-go v1.5.3/go.mod h1:fpvVPC+Jso+YEhNcNiww8HQmBgKP8T4T6BTp1SLxxIo=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/exp v0.0.0-20230202163644-54bba9f4231b h1:EqBVA+nNsObCwQoBEHy4wLU0pi7i8a4AL3pbItPdPkE=
+golang.org/x/exp v0.0.0-20230202163644-54bba9f4231b/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc=
+golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
+golang.org/x/image v0.3.0 h1:HTDXbdK9bjfSWkPzDJIw89W8CAtfFGduujWs33NLLsg=
+golang.org/x/image v0.3.0/go.mod h1:fXd9211C/0VTlYuAcOhW8dY/RtEJqODXOWBDpmYBf+A=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.4.0 h1:Zr2JFtRQNX3BCZ8YtxRE9hNJYC8J6I1MVbMg6owUp18=
+golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.6.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

kittens/ask/main.py

@@ -2,25 +2,35 @@
 # License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
 
 import os
+import re
 import sys
 from contextlib import suppress
 from typing import (
-    TYPE_CHECKING, Callable, Dict, List, NamedTuple, Optional, Tuple
+    TYPE_CHECKING,
+    Callable,
+    Dict,
+    Iterator,
+    List,
+    NamedTuple,
+    Optional,
+    Tuple,
 )
 
 from kitty.cli import parse_args
 from kitty.cli_stub import AskCLIOptions
 from kitty.constants import cache_dir
 from kitty.fast_data_types import truncate_point_for_length, wcswidth
+from kitty.types import run_once
 from kitty.typing import BossType, KeyEventType, TypedDict
 from kitty.utils import ScreenSize
 
 from ..tui.handler import Handler, result_handler
-from ..tui.loop import Loop, MouseEvent
+from ..tui.loop import Loop, MouseEvent, debug
 from ..tui.operations import MouseTracking, alternate_screen, styled
 
 if TYPE_CHECKING:
     import readline
+    debug
 else:
     readline = None
 
@@ -108,6 +118,15 @@ The default choice is selected when the user presses the :kbd:`Enter` key.
 --prompt -p
 default="> "
 The prompt to use when inputting a line of text or a password.
+
+
+--unhide-key
+default=u
+The key to be pressed to unhide hidden text
+
+
+--hidden-text-placeholder
+The text in the message to be replaced by hidden text. The hidden text is read via STDIN.
 '''
 
 
@@ -147,14 +166,17 @@ def extra_for(width: int, screen_width: int) -> int:
 
 class Password(Handler):
 
-    def __init__(self, cli_opts: AskCLIOptions, prompt: str) -> None:
+    def __init__(self, cli_opts: AskCLIOptions, prompt: str, is_password: bool = True, initial_text: str = '') -> None:
         self.cli_opts = cli_opts
         self.prompt = prompt
+        self.initial_text = initial_text
         from kittens.tui.line_edit import LineEdit
-        self.line_edit = LineEdit(is_password=True)
+        self.line_edit = LineEdit(is_password=is_password)
 
     def initialize(self) -> None:
         self.cmd.set_cursor_shape('beam')
+        if self.initial_text:
+            self.line_edit.on_text(self.initial_text, True)
         self.draw_screen()
 
     @Handler.atomic_update
@@ -194,10 +216,11 @@ class Password(Handler):
         return ''
 
 
-class Choose(Handler):
+class Choose(Handler):  # {{{
     mouse_tracking = MouseTracking.buttons_only
 
     def __init__(self, cli_opts: AskCLIOptions) -> None:
+        self.prefix_style_pat = re.compile(r'(?:\x1b\[[^m]*?m)+')
         self.cli_opts = cli_opts
         self.choices: Dict[str, Choice] = {}
         self.clickable_ranges: Dict[str, List[Range]] = {}
@@ -219,6 +242,18 @@ class Choose(Handler):
         self.response_on_accept = cli_opts.default or ''
         if cli_opts.type in ('yesno', 'choices') and self.response_on_accept not in self.allowed:
             self.response_on_accept = 'y' if cli_opts.type == 'yesno' else tuple(self.choices.keys())[0]
+        self.message = cli_opts.message
+        self.hidden_text_start_pos = self.hidden_text_end_pos = -1
+        self.hidden_text = ''
+        self.replacement_text = t = f'Press {styled(self.cli_opts.unhide_key, fg="green")} or click to show'
+        self.replacement_range = Range(-1, -1, -1)
+        if self.message and self.cli_opts.hidden_text_placeholder:
+            self.hidden_text_start_pos = self.message.find(self.cli_opts.hidden_text_placeholder)
+            if self.hidden_text_start_pos > -1:
+                self.hidden_text = sys.stdin.read().rstrip()
+                self.hidden_text_end_pos = self.hidden_text_start_pos + len(t)
+                suffix = self.message[self.hidden_text_start_pos + len(self.cli_opts.hidden_text_placeholder):]
+                self.message = self.message[:self.hidden_text_start_pos] + t + suffix
 
     def initialize(self) -> None:
         self.cmd.set_cursor_visible(False)
@@ -227,24 +262,35 @@ class Choose(Handler):
     def finalize(self) -> None:
         self.cmd.set_cursor_visible(True)
 
-    def draw_long_text(self, text: str) -> int:
-        y = 0
+    def draw_long_text(self, text: str) -> Iterator[str]:
+        if not text:
+            yield ''
+            return
         width = self.screen_size.cols - 2
+        m = self.prefix_style_pat.match(text)
+        prefix = m.group() if m else ''
         while text:
             t, text = truncate_at_space(text, width)
             t = t.strip()
-            self.print(' ' * extra_for(wcswidth(t), width), styled(t, bold=True), sep='')
-            y += 1
-        return y
+            yield ' ' * extra_for(wcswidth(t), width) + styled(prefix + t, bold=True)
 
     @Handler.atomic_update
     def draw_screen(self) -> None:
         self.cmd.clear_screen()
-        y = max(0, self.screen_size.rows // 2 - 2)
+        msg_lines: List[str] = []
+        if self.message:
+            for line in self.message.splitlines():
+                msg_lines.extend(self.draw_long_text(line))
+        y = self.screen_size.rows - len(msg_lines)
+        y = max(0, (y // 2) - 2)
         self.print(end='\r\n'*y)
-        if self.cli_opts.message:
-            for line in self.cli_opts.message.splitlines():
-                y += self.draw_long_text(line)
+        for line in msg_lines:
+            if self.replacement_text in line:
+                idx = line.find(self.replacement_text)
+                x = wcswidth(line[:idx])
+                self.replacement_range = Range(x, x + wcswidth(self.replacement_text), y)
+            self.print(line)
+            y += 1
         if self.screen_size.rows > 2:
             self.print()
             y += 1
@@ -259,7 +305,8 @@ class Choose(Handler):
         current_line_length = 0
         current_line: List[Tuple[str, str]] = []
         lines: List[List[Tuple[str, str]]] = []
-        sep, sep_sz = '  ', 2
+        sep = '  '
+        sep_sz = len(sep) + 2  # for the borders
 
         for choice in choices:
             self.clickable_ranges[choice.letter] = []
@@ -272,7 +319,7 @@ class Choose(Handler):
                 current_line = []
                 current_line_length = 0
             current_line.append((choice.letter, text))
-            current_line_length += sz
+            current_line_length += sz + sep_sz
         if current_line:
             lines.append(current_line)
 
@@ -311,10 +358,12 @@ class Choose(Handler):
             self.print(' ' * offset, line, sep='', end='' if is_last else '\r\n')
             y += 1
 
+        self.cmd.set_line_wrapping(False)
         for boxed_line in lines:
             print_line(top, *boxed_line)
             print_line(middle, *boxed_line)
             print_line(bottom, *boxed_line, is_last=boxed_line is lines[-1])
+        self.cmd.set_line_wrapping(True)
 
     def draw_choice(self, y: int) -> None:
         if y + 3 <= self.screen_size.rows:
@@ -370,6 +419,14 @@ class Choose(Handler):
             self.quit_loop(0)
         elif self.cli_opts.type == 'yesno':
             self.on_interrupt()
+        elif self.hidden_text and text == self.cli_opts.unhide_key:
+            self.unhide()
+
+    def unhide(self) -> None:
+        if self.hidden_text and self.message:
+            self.message = self.message[:self.hidden_text_start_pos] + self.hidden_text + self.message[self.hidden_text_end_pos:]
+            self.hidden_text = ''
+            self.draw_screen()
 
     def on_key(self, key_event: KeyEventType) -> None:
         if key_event.matches('esc'):
@@ -385,6 +442,8 @@ class Choose(Handler):
                     self.response = letter
                     self.quit_loop(0)
                     return
+        if self.hidden_text and self.replacement_range.has_point(ev.cell_x, ev.cell_y):
+            self.unhide()
 
     def on_resize(self, screen_size: ScreenSize) -> None:
         self.screen_size = screen_size
@@ -393,6 +452,18 @@ class Choose(Handler):
     def on_interrupt(self) -> None:
         self.quit_loop(1)
     on_eot = on_interrupt
+# }}}
+
+
+@run_once
+def init_readline() -> None:
+    import readline
+    with suppress(OSError):
+        readline.read_init_file()
+    if 'libedit' in readline.__doc__:
+        readline.parse_and_bind("bind ^I rl_complete")
+    else:
+        readline.parse_and_bind('tab: complete')
 
 
 def main(args: List[str]) -> Response:
@@ -402,7 +473,7 @@ def main(args: List[str]) -> Response:
     global readline
     msg = 'Ask the user for input'
     try:
-        cli_opts, items = parse_args(args[1:], option_text, '', msg, 'kitty ask', result_class=AskCLIOptions)
+        cli_opts, items = parse_args(args[1:], option_text, '', msg, 'kitty +kitten ask', result_class=AskCLIOptions)
     except SystemExit as e:
         if e.code != 0:
             print(e.args[0])
@@ -424,17 +495,22 @@ def main(args: List[str]) -> Response:
         loop.loop(phandler)
         return {'items': items, 'response': phandler.response}
 
-    import readline as rl
-    readline = rl
-    from kitty.shell import init_readline
-    init_readline()
-    response = None
+    # we do this file descriptor dance to get readline to work even when STDOUT
+    # is redirected
+    orig_stdout = os.dup(sys.stdout.fileno())
+    try:
+        with open(os.ctermid(), 'r') as tty:
+            os.dup2(tty.fileno(), sys.stdin.fileno())
+        with open(os.ctermid(), 'w') as tty:
+            os.dup2(tty.fileno(), sys.stdout.fileno())
+        import readline as rl
+        readline = rl
+        init_readline()
+        response = None
 
-    with alternate_screen(), HistoryCompleter(cli_opts.name):
-        if cli_opts.message:
-            print(styled(cli_opts.message, bold=True))
-
-        with suppress(KeyboardInterrupt, EOFError):
+        with alternate_screen(), HistoryCompleter(cli_opts.name), suppress(KeyboardInterrupt, EOFError):
+            if cli_opts.message:
+                print(styled(cli_opts.message, bold=True))
             if cli_opts.default:
                 def prefill_text() -> None:
                     readline.insert_text(cli_opts.default or '')
@@ -444,6 +520,10 @@ def main(args: List[str]) -> Response:
                 readline.set_pre_input_hook()
             else:
                 response = input(prompt)
+        sys.stdout.flush()
+        os.dup2(orig_stdout, sys.stdout.fileno())
+    finally:
+        os.close(orig_stdout)
     return {'items': items, 'response': response}
 
 
@@ -457,4 +537,5 @@ def handle_result(args: List[str], data: Response, target_window_id: int, boss:
 if __name__ == '__main__':
     ans = main(sys.argv)
     if ans:
-        print(ans)
+        import json
+        print(json.dumps(ans))

kittens/broadcast/main.py

@@ -31,6 +31,7 @@ class Broadcast(Handler):
 
     def __init__(self, opts: BroadcastCLIOptions, initial_strings: List[str]) -> None:
         self.opts = opts
+        self.hide_input = False
         self.initial_strings = initial_strings
         self.payload = {'exclude_active': True, 'data': '', 'match': opts.match, 'match_tab': opts.match_tab, 'session_id': uuid4()}
         self.line_edit = LineEdit()
@@ -40,7 +41,7 @@ class Broadcast(Handler):
 
     def initialize(self) -> None:
         self.write_broadcast_session()
-        self.print('Type the text to broadcast below, press', styled('Ctrl+Esc', fg='yellow'), 'to quit:')
+        self.print('Type the text to broadcast below, press', styled(self.opts.end_session, fg='yellow'), 'to quit:')
         for x in self.initial_strings:
             self.write_broadcast_text(x)
         self.write(SAVE_CURSOR)
@@ -56,7 +57,8 @@ class Broadcast(Handler):
 
     def on_text(self, text: str, in_bracketed_paste: bool = False) -> None:
         self.write_broadcast_text(text)
-        self.line_edit.on_text(text, in_bracketed_paste)
+        if not self.hide_input:
+            self.line_edit.on_text(text, in_bracketed_paste)
         self.commit_line()
 
     def on_interrupt(self) -> None:
@@ -68,22 +70,33 @@ class Broadcast(Handler):
         self.write_broadcast_text('\x04')
 
     def on_key(self, key_event: KeyEventType) -> None:
-        if self.line_edit.on_key(key_event):
+        if key_event.matches(self.opts.hide_input_toggle):
+            self.hide_input ^= True
+            self.cmd.set_cursor_visible(not self.hide_input)
+            if self.hide_input:
+                self.end_line()
+                self.print('Input hidden, press', styled(self.opts.hide_input_toggle, fg='yellow'), 'to unhide:')
+                self.end_line()
+            return
+        if key_event.matches(self.opts.end_session):
+            self.quit_loop(0)
+            return
+        if not self.hide_input and self.line_edit.on_key(key_event):
             self.commit_line()
         if key_event.matches('enter'):
             self.write_broadcast_text('\r')
-            self.print('')
-            self.line_edit.clear()
-            self.write(SAVE_CURSOR)
-            return
-        if key_event.matches('ctrl+esc'):
-            self.quit_loop(0)
+            self.end_line()
             return
 
         ek = encode_key_event(key_event)
         ek = standard_b64encode(ek.encode('utf-8')).decode('ascii')
         self.write_broadcast_data('kitty-key:' + ek)
 
+    def end_line(self) -> None:
+        self.print('')
+        self.line_edit.clear()
+        self.write(SAVE_CURSOR)
+
     def write_broadcast_text(self, text: str) -> None:
         self.write_broadcast_data('base64:' + standard_b64encode(text.encode('utf-8')).decode('ascii'))
 
@@ -98,7 +111,19 @@ class Broadcast(Handler):
         self.write(session_command(self.payload, start))
 
 
-OPTIONS = (MATCH_WINDOW_OPTION + '\n\n' + MATCH_TAB_OPTION.replace('--match -m', '--match-tab -t')).format
+OPTIONS = ('''
+--hide-input-toggle
+default=Ctrl+Alt+Esc
+Key to press that will toggle hiding of the input in the broadcast window itself.
+Useful while typing a password, prevents the password from being visible on the screen.
+
+
+--end-session
+default=Ctrl+Esc
+Key to press to end the broadcast session.
+
+
+''' + MATCH_WINDOW_OPTION + '\n\n' + MATCH_TAB_OPTION.replace('--match -m', '--match-tab -t')).format
 help_text = 'Broadcast typed text to kitty windows. By default text is sent to all windows, unless one of the matching options is specified'
 usage = '[initial text to send ...]'
 

kittens/choose/main.c

@@ -231,11 +231,11 @@ static PyMethodDef module_methods[] = {
 };
 
 static struct PyModuleDef module = {
-   .m_base = PyModuleDef_HEAD_INIT,
-   .m_name = "subseq_matcher",   /* name of module */
-   .m_doc = NULL,
-   .m_size = -1,
-   .m_methods = module_methods
+    .m_base = PyModuleDef_HEAD_INIT,
+    .m_name = "subseq_matcher",   /* name of module */
+    .m_doc = NULL,
+    .m_size = -1,
+    .m_methods = module_methods
 };
 
 EXPORTED PyMODINIT_FUNC

kittens/choose/subseq_matcher.pyi

@@ -1,6 +1,5 @@
 from typing import List, Optional, Tuple
 
-
 def match(
     lines: List[bytes], levels: Tuple[str, str, str], needle: str,
     output_positions: bool, limit: int, num_threads: int, mark_before: str,

kittens/clipboard/main.py

@@ -1,115 +1,91 @@
 #!/usr/bin/env python3
 # License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
 
-import os
 import sys
-from typing import List, NoReturn, Optional
-
-from kitty.cli import parse_args
-from kitty.cli_stub import ClipboardCLIOptions
-
-from ..tui.handler import Handler
-from ..tui.loop import Loop
-
-
-class Clipboard(Handler):
-
-    def __init__(self, data_to_send: Optional[bytes], args: ClipboardCLIOptions):
-        self.args = args
-        self.clipboard_contents: Optional[str] = None
-        self.data_to_send = data_to_send
-        self.quit_on_write = False
-
-    def initialize(self) -> None:
-        if self.data_to_send is not None:
-            self.cmd.write_to_clipboard(self.data_to_send, self.args.use_primary)
-        if not self.args.get_clipboard:
-            if self.args.wait_for_completion:
-                # ask kitty for the TN terminfo capability and
-                # only quit after a response is received
-                self.print('\x1bP+q544e\x1b\\', end='')
-                self.print('Waiting for completion...')
-                return
-            self.quit_on_write = True
-            return
-        self.cmd.request_from_clipboard(self.args.use_primary)
-
-    def on_writing_finished(self) -> None:
-        if self.quit_on_write:
-            self.quit_loop(0)
-
-    def on_clipboard_response(self, text: str, from_primary: bool = False) -> None:
-        self.clipboard_contents = text
-        self.quit_loop(0)
-
-    def on_capability_response(self, name: str, val: str) -> None:
-        self.quit_loop(0)
-
-    def on_interrupt(self) -> None:
-        self.quit_loop(1)
-
-    def on_eot(self) -> None:
-        self.quit_loop(1)
-
 
 OPTIONS = r'''
---get-clipboard
-default=False
+--get-clipboard -g
 type=bool-set
 Output the current contents of the clipboard to STDOUT. Note that by default
 kitty will prompt for permission to access the clipboard. Can be controlled
 by :opt:`clipboard_control`.
 
 
---use-primary
-default=False
+--use-primary -p
 type=bool-set
 Use the primary selection rather than the clipboard on systems that support it,
-such as X11.
+such as Linux.
+
+
+--mime -m
+type=list
+The mimetype of the specified file. Useful when the auto-detected mimetype is
+likely to be incorrect or the filename has no extension and therefore no mimetype
+can be detected. If more than one file is specified, this option should be specified multiple
+times, once for each specified file. When copying data from the clipboard, you can use wildcards
+to match MIME types. For example: :code:`--mime 'text/*'` will match any textual MIME type
+available on the clipboard, usually the first matching MIME type is copied. The special MIME
+type :code:`.` will return the list of available MIME types currently on the system clipboard.
+
+
+--alias -a
+type=list
+Specify aliases for MIME types. Aliased MIME types are considered equivalent.
+When copying to clipboard both the original and alias are made available on the
+clipboard. When copying from clipboard if the original is not found, the alias
+is used, as a fallback. Can be specified multiple times to create multiple
+aliases. For example: :code:`--alias text/plain=text/x-rst` makes :code:`text/plain` an alias
+of :code:`text/rst`. Aliases are not used in filter mode. An alias for
+:code:`text/plain` is automatically created if :code:`text/plain` is not present in the input data, but some
+other :code:`text/*` MIME is present.
 
 
 --wait-for-completion
-default=False
 type=bool-set
 Wait till the copy to clipboard is complete before exiting. Useful if running
-the kitten in a dedicated, ephemeral window.
+the kitten in a dedicated, ephemeral window. Only needed in filter mode.
 '''.format
 help_text = '''\
 Read or write to the system clipboard.
 
-To set the clipboard text, pipe in the new text on STDIN. Use the
-:option:`--get-clipboard` option to output the current clipboard contents to
-:file:`stdout`. Note that reading the clipboard will cause a permission
+This kitten operates most simply in :italic:`filter mode`.
+To set the clipboard text, pipe in the new text on :file:`STDIN`. Use the
+:option:`--get-clipboard` option to output the current clipboard text content to
+:file:`STDOUT`. Note that copying from the clipboard will cause a permission
 popup, see :opt:`clipboard_control` for details.
+
+For more control, specify filename arguments. Then, different MIME types can be copied to/from
+the clipboard. Some examples:
+
+.. code:: sh
+
+    # Copy an image to the clipboard:
+    kitty +kitten clipboard picture.png
+
+    # Copy an image and some text to the clipboard:
+    kitty +kitten clipboard picture.jpg text.txt
+
+    # Copy text from STDIN and an image to the clipboard:
+    echo hello | kitty +kitten clipboard picture.png /dev/stdin
+
+    # Copy any raster image available on the clipboard to a PNG file:
+    kitty +kitten clipboard -g picture.png
+
+    # Copy an image to a file and text to STDOUT:
+    kitty +kitten clipboard -g picture.png /dev/stdout
+
+    # List the formats available on the system clipboard
+    kitty +kitten clipboard -g -m . /dev/stdout
 '''
 
-usage = ''
-
-
-def main(args: List[str]) -> NoReturn:
-    cli_opts, items = parse_args(args[1:], OPTIONS, usage, help_text, 'kitty +kitten clipboard', result_class=ClipboardCLIOptions)
-    if items:
-        raise SystemExit('Unrecognized extra command line arguments')
-    data: Optional[bytes] = None
-    if not sys.stdin.isatty():
-        data = sys.stdin.buffer.read()
-        try:
-            sys.stdin = open(os.ctermid())
-        except FileNotFoundError:
-            raise SystemExit('Not connected to a controlling terminal device, no /dev/tty')
-    loop = Loop()
-    handler = Clipboard(data, cli_opts)
-    loop.loop(handler)
-    if loop.return_code == 0 and handler.clipboard_contents:
-        sys.stdout.write(handler.clipboard_contents)
-        sys.stdout.flush()
-    raise SystemExit(loop.return_code)
-
-
+usage = '[files to copy to/from]'
 if __name__ == '__main__':
-    main(sys.argv)
+    raise SystemExit('This should be run as kitten clipboard')
 elif __name__ == '__doc__':
+    from kitty.cli import CompletionSpec
     cd = sys.cli_docs  # type: ignore
     cd['usage'] = usage
     cd['options'] = OPTIONS
     cd['help_text'] = help_text
+    cd['short_desc'] = 'Copy/paste with the system clipboard, even over SSH'
+    cd['args_completion'] = CompletionSpec.from_string('type:file mime:* group:Files')

kittens/diff/collect.py

@@ -2,15 +2,17 @@
 # License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
 
 import os
-import re
 from contextlib import suppress
+from fnmatch import fnmatch
 from functools import lru_cache
 from hashlib import md5
+from typing import TYPE_CHECKING, Dict, Iterator, List, Optional, Sequence, Set, Tuple, Union
+
 from kitty.guess_mime_type import guess_type
-from typing import TYPE_CHECKING, Dict, List, Set, Optional, Iterator, Tuple, Union
+from kitty.utils import control_codes_pat
 
 if TYPE_CHECKING:
-    from .highlight import DiffHighlight  # noqa
+    from .highlight import DiffHighlight
 
 
 path_name_map: Dict[str, str] = {}
@@ -37,6 +39,8 @@ class Segment:
 
 class Collection:
 
+    ignore_names: Tuple[str, ...] = ()
+
     def __init__(self) -> None:
         self.changes: Dict[str, str] = {}
         self.renames: Dict[str, str] = {}
@@ -105,22 +109,34 @@ def resolve_remote_name(path: str, default: str) -> str:
     return default
 
 
+def allowed_items(items: Sequence[str], ignore_patterns: Sequence[str]) -> Iterator[str]:
+    for name in items:
+        for pat in ignore_patterns:
+            if fnmatch(name, pat):
+                break
+        else:
+            yield name
+
+
+def walk(base: str, names: Set[str], pmap: Dict[str, str], ignore_names: Tuple[str, ...]) -> None:
+    for dirpath, dirnames, filenames in os.walk(base):
+        dirnames[:] = allowed_items(dirnames, ignore_names)
+        for filename in allowed_items(filenames, ignore_names):
+            path = os.path.abspath(os.path.join(dirpath, filename))
+            path_name_map[path] = name = os.path.relpath(path, base)
+            names.add(name)
+            pmap[name] = path
+
+
 def collect_files(collection: Collection, left: str, right: str) -> None:
     left_names: Set[str] = set()
     right_names: Set[str] = set()
     left_path_map: Dict[str, str] = {}
     right_path_map: Dict[str, str] = {}
 
-    def walk(base: str, names: Set[str], pmap: Dict[str, str]) -> None:
-        for dirpath, dirnames, filenames in os.walk(base):
-            for filename in filenames:
-                path = os.path.abspath(os.path.join(dirpath, filename))
-                path_name_map[path] = name = os.path.relpath(path, base)
-                names.add(name)
-                pmap[name] = path
+    walk(left, left_names, left_path_map, collection.ignore_names)
+    walk(right, right_names, right_path_map, collection.ignore_names)
 
-    walk(left, left_names, left_path_map)
-    walk(right, right_names, right_path_map)
     common_names = left_names & right_names
     changed_names = {n for n in common_names if data_for_path(left_path_map[n]) != data_for_path(right_path_map[n])}
     for n in changed_names:
@@ -143,12 +159,9 @@ def collect_files(collection: Collection, left: str, right: str) -> None:
         collection.add_add(right_path_map[name])
 
 
-sanitize_pat = re.compile('[\x00-\x09\x0b-\x1f\x7f\x80-\x9f]')
-
-
 def sanitize(text: str) -> str:
     ntext = text.replace('\r\n', '⏎\n')
-    return sanitize_pat.sub('░', ntext)
+    return control_codes_pat().sub('░', ntext)
 
 
 @lru_cache(maxsize=1024)

kittens/diff/config.py

@@ -5,13 +5,13 @@ import os
 from typing import Any, Dict, Iterable, Optional
 
 from kitty.cli_stub import DiffCLIOptions
-from kitty.conf.utils import (
-    load_config as _load_config, parse_config_base, resolve_config
-)
+from kitty.conf.utils import load_config as _load_config
+from kitty.conf.utils import parse_config_base, resolve_config
 from kitty.constants import config_dir
 from kitty.rgb import color_as_sgr
 
-from .options.types import Options as DiffOptions, defaults
+from .options.types import Options as DiffOptions
+from .options.types import defaults
 
 formats: Dict[str, str] = {
     'title': '',
@@ -41,9 +41,7 @@ defconf = os.path.join(config_dir, 'diff.conf')
 
 
 def load_config(*paths: str, overrides: Optional[Iterable[str]] = None) -> DiffOptions:
-    from .options.parse import (
-        create_result_dict, merge_result_dicts, parse_conf_item
-    )
+    from .options.parse import create_result_dict, merge_result_dicts, parse_conf_item
 
     def parse_config(lines: Iterable[str]) -> Dict[str, Any]:
         ans: Dict[str, Any] = create_result_dict()

kittens/diff/diff_speedup.pyi

@@ -2,7 +2,6 @@ from typing import List, Optional, Tuple
 
 from .collect import Segment
 
-
 def split_with_highlights(
     line: str, truncate_points: List[int], fg_highlights: List[Segment],
     bg_highlight: Optional[Segment]

kittens/diff/highlight.py

@@ -5,9 +5,7 @@ import concurrent
 import os
 import re
 from concurrent.futures import ProcessPoolExecutor
-from typing import (
-    IO, Dict, Iterable, Iterator, List, Optional, Tuple, Union, cast
-)
+from typing import IO, Dict, Iterable, Iterator, List, Optional, Tuple, Union, cast
 
 from pygments import highlight  # type: ignore
 from pygments.formatter import Formatter  # type: ignore

kittens/diff/main.py

@@ -14,16 +14,24 @@ from enum import Enum, auto
 from functools import partial
 from gettext import gettext as _
 from typing import (
-    Any, DefaultDict, Dict, Iterable, Iterator, List, Optional, Tuple, Union
+    Any,
+    DefaultDict,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    Tuple,
+    Union,
 )
 
-from kitty.cli import CONFIG_HELP, parse_args
+from kitty.cli import CONFIG_HELP, CompletionSpec, parse_args
 from kitty.cli_stub import DiffCLIOptions
 from kitty.conf.utils import KeyAction
 from kitty.constants import appname
 from kitty.fast_data_types import wcswidth
 from kitty.key_encoding import EventType, KeyEvent
-from kitty.utils import ScreenSize
+from kitty.utils import ScreenSize, extract_all_from_tarfile_safely
 
 from ..tui.handler import Handler
 from ..tui.images import ImageManager, Placement
@@ -32,21 +40,33 @@ from ..tui.loop import Loop
 from ..tui.operations import styled
 from . import global_data
 from .collect import (
-    Collection, add_remote_dir, create_collection, data_for_path,
-    lines_for_path, sanitize, set_highlight_data
+    Collection,
+    add_remote_dir,
+    create_collection,
+    data_for_path,
+    lines_for_path,
+    sanitize,
+    set_highlight_data,
 )
 from .config import init_config
 from .options.types import Options as DiffOptions
 from .patch import Differ, Patch, set_diff_command, worker_processes
 from .render import (
-    ImagePlacement, ImageSupportWarning, Line, LineRef, Reference, render_diff
+    ImagePlacement,
+    ImageSupportWarning,
+    Line,
+    LineRef,
+    Reference,
+    render_diff,
 )
 from .search import BadRegex, Search
 
 try:
     from .highlight import (
-        DiffHighlight, get_highlight_processes, highlight_collection,
-        initialize_highlighter
+        DiffHighlight,
+        get_highlight_processes,
+        highlight_collection,
+        initialize_highlighter,
     )
     has_highlighter = True
     DiffHighlight
@@ -229,8 +249,8 @@ class DiffHandler(Handler):
         self.diff_lines: Tuple[Line, ...] = tuple(render_diff(self.collection, self.diff_map, self.args, self.screen_size.cols, self.image_manager))
         self.margin_size = render_diff.margin_size
         self.ref_path_map: DefaultDict[str, List[Tuple[int, Reference]]] = defaultdict(list)
-        for i, l in enumerate(self.diff_lines):
-            self.ref_path_map[l.ref.path].append((i, l.ref))
+        for i, dl in enumerate(self.diff_lines):
+            self.ref_path_map[dl.ref.path].append((i, dl.ref))
         self.max_scroll_pos = len(self.diff_lines) - self.num_lines
         if self.current_search is not None:
             self.current_search(self.diff_lines, self.margin_size, self.screen_size.cols)
@@ -319,7 +339,7 @@ class DiffHandler(Handler):
             fg=self.opts.foreground, bg=self.opts.background,
             cursor=self.opts.foreground, select_fg=self.opts.select_fg,
             select_bg=self.opts.select_bg)
-        self.cmd.set_cursor_shape('bar')
+        self.cmd.set_cursor_shape('beam')
 
     def finalize(self) -> None:
         self.cmd.set_default_colors()
@@ -577,6 +597,7 @@ number set in :file:`diff.conf`.
 
 --config
 type=list
+completion=type:file ext:conf group:"Config files" kwds:none,NONE
 {config_help}
 
 
@@ -629,7 +650,7 @@ def get_ssh_file(hostname: str, rpath: str) -> str:
         raise SystemExit(p.returncode)
     with tarfile.open(fileobj=io.BytesIO(raw), mode='r:') as tf:
         members = tf.getmembers()
-        tf.extractall(tdir)
+        extract_all_from_tarfile_safely(tf, tdir)
         if len(members) == 1:
             for root, dirs, files in os.walk(tdir):
                 if files:
@@ -655,6 +676,7 @@ def main(args: List[str]) -> None:
     opts = init_config(cli_opts)
     set_diff_command(opts.diff_cmd)
     lines_for_path.replace_tab_by = opts.replace_tab_by
+    Collection.ignore_names = tuple(opts.ignore_name)
     left, right = map(get_remote_file, (left, right))
     if os.path.isdir(left) != os.path.isdir(right):
         raise SystemExit('The items to be diffed should both be either directories or files. Comparing a directory to a file is not valid.')
@@ -686,6 +708,7 @@ elif __name__ == '__doc__':
     cd['usage'] = usage
     cd['options'] = OPTIONS
     cd['help_text'] = help_text
+    cd['args_completion'] = CompletionSpec.from_string('type:file mime:text/* mime:image/* group:"Text and image files"')
 elif __name__ == '__conf__':
     from .options.definition import definition
     sys.options_definition = definition  # type: ignore

kittens/diff/options/definition.py

@@ -6,7 +6,6 @@
 
 from kitty.conf.types import Action, Definition
 
-
 definition = Definition(
     'kittens.diff',
     Action('map', 'parse_map', {'key_definitions': 'kitty.conf.utils.KittensKeyMap'}, ['kitty.types.ParsedShortcut', 'kitty.conf.utils.KeyAction']),
@@ -47,6 +46,21 @@ opt('replace_tab_by', '\\x20\\x20\\x20\\x20',
     option_type='python_string',
     long_text='The string to replace tabs with. Default is to use four spaces.'
     )
+
+opt('+ignore_name', '',
+    option_type='store_multiple',
+    add_to_default=False,
+    long_text='''
+A glob pattern that is matched against only the filename of files and directories. Matching
+files and directories are ignored when scanning the filesystem to look for files to diff.
+Can be specified multiple times to use multiple patterns. For example::
+
+    ignore_name .git
+    ignore_name *~
+    ignore_name *.pyc
+''',
+    )
+
 egr()  # }}}
 
 # colors {{{

kittens/diff/options/parse.py

@@ -1,7 +1,8 @@
 # generated by gen-config.py DO NOT edit
 
+# isort: skip_file
 import typing
-from kittens.diff.options.utils import parse_map, syntax_aliases
+from kittens.diff.options.utils import parse_map, store_multiple, syntax_aliases
 from kitty.conf.utils import merge_dicts, positive_int, python_string, to_color, to_color_or_none
 
 
@@ -37,6 +38,10 @@ class Parser:
     def hunk_margin_bg(self, val: str, ans: typing.Dict[str, typing.Any]) -> None:
         ans['hunk_margin_bg'] = to_color(val)
 
+    def ignore_name(self, val: str, ans: typing.Dict[str, typing.Any]) -> None:
+        for k, v in store_multiple(val, ans["ignore_name"]):
+            ans["ignore_name"][k] = v
+
     def margin_bg(self, val: str, ans: typing.Dict[str, typing.Any]) -> None:
         ans['margin_bg'] = to_color(val)
 
@@ -89,6 +94,7 @@ class Parser:
 
 def create_result_dict() -> typing.Dict[str, typing.Any]:
     return {
+        'ignore_name': {},
         'map': [],
     }
 

kittens/diff/options/types.py

@@ -1,5 +1,6 @@
 # generated by gen-config.py DO NOT edit
 
+# isort: skip_file
 import typing
 from kitty.conf.utils import KeyAction, KittensKeyMap
 import kitty.conf.utils
@@ -20,6 +21,7 @@ option_names = (  # {{{
  'highlight_removed_bg',
  'hunk_bg',
  'hunk_margin_bg',
+ 'ignore_name',
  'map',
  'margin_bg',
  'margin_fg',
@@ -64,6 +66,7 @@ class Options:
     syntax_aliases: typing.Dict[str, str] = {'pyj': 'py', 'pyi': 'py', 'recipe': 'py'}
     title_bg: Color = Color(255, 255, 255)
     title_fg: Color = Color(0, 0, 0)
+    ignore_name: typing.Dict[str, str] = {}
     map: typing.List[typing.Tuple[kitty.types.ParsedShortcut, kitty.conf.utils.KeyAction]] = []
     key_definitions: KittensKeyMap = {}
     config_paths: typing.Tuple[str, ...] = ()
@@ -116,55 +119,56 @@ class Options:
 
 
 defaults = Options()
+defaults.ignore_name = {}
 defaults.map = [
     # quit
-    (ParsedShortcut(mods=0, key_name='q'), KeyAction('quit')),  # noqa
+    (ParsedShortcut(mods=0, key_name='q'), KeyAction('quit')), 
     # quit
-    (ParsedShortcut(mods=0, key_name='ESCAPE'), KeyAction('quit')),  # noqa
+    (ParsedShortcut(mods=0, key_name='ESCAPE'), KeyAction('quit')), 
     # scroll_down
-    (ParsedShortcut(mods=0, key_name='j'), KeyAction('scroll_by', (1,))),  # noqa
+    (ParsedShortcut(mods=0, key_name='j'), KeyAction('scroll_by', (1,))), 
     # scroll_down
-    (ParsedShortcut(mods=0, key_name='DOWN'), KeyAction('scroll_by', (1,))),  # noqa
+    (ParsedShortcut(mods=0, key_name='DOWN'), KeyAction('scroll_by', (1,))), 
     # scroll_up
-    (ParsedShortcut(mods=0, key_name='k'), KeyAction('scroll_by', (-1,))),  # noqa
+    (ParsedShortcut(mods=0, key_name='k'), KeyAction('scroll_by', (-1,))), 
     # scroll_up
-    (ParsedShortcut(mods=0, key_name='UP'), KeyAction('scroll_by', (-1,))),  # noqa
+    (ParsedShortcut(mods=0, key_name='UP'), KeyAction('scroll_by', (-1,))), 
     # scroll_top
-    (ParsedShortcut(mods=0, key_name='HOME'), KeyAction('scroll_to', ('start',))),  # noqa
+    (ParsedShortcut(mods=0, key_name='HOME'), KeyAction('scroll_to', ('start',))), 
     # scroll_bottom
-    (ParsedShortcut(mods=0, key_name='END'), KeyAction('scroll_to', ('end',))),  # noqa
+    (ParsedShortcut(mods=0, key_name='END'), KeyAction('scroll_to', ('end',))), 
     # scroll_page_down
-    (ParsedShortcut(mods=0, key_name='PAGE_DOWN'), KeyAction('scroll_to', ('next-page',))),  # noqa
+    (ParsedShortcut(mods=0, key_name='PAGE_DOWN'), KeyAction('scroll_to', ('next-page',))), 
     # scroll_page_down
-    (ParsedShortcut(mods=0, key_name=' '), KeyAction('scroll_to', ('next-page',))),  # noqa
+    (ParsedShortcut(mods=0, key_name=' '), KeyAction('scroll_to', ('next-page',))), 
     # scroll_page_up
-    (ParsedShortcut(mods=0, key_name='PAGE_UP'), KeyAction('scroll_to', ('prev-page',))),  # noqa
+    (ParsedShortcut(mods=0, key_name='PAGE_UP'), KeyAction('scroll_to', ('prev-page',))), 
     # next_change
-    (ParsedShortcut(mods=0, key_name='n'), KeyAction('scroll_to', ('next-change',))),  # noqa
+    (ParsedShortcut(mods=0, key_name='n'), KeyAction('scroll_to', ('next-change',))), 
     # prev_change
-    (ParsedShortcut(mods=0, key_name='p'), KeyAction('scroll_to', ('prev-change',))),  # noqa
+    (ParsedShortcut(mods=0, key_name='p'), KeyAction('scroll_to', ('prev-change',))), 
     # all_context
-    (ParsedShortcut(mods=0, key_name='a'), KeyAction('change_context', ('all',))),  # noqa
+    (ParsedShortcut(mods=0, key_name='a'), KeyAction('change_context', ('all',))), 
     # default_context
-    (ParsedShortcut(mods=0, key_name='='), KeyAction('change_context', ('default',))),  # noqa
+    (ParsedShortcut(mods=0, key_name='='), KeyAction('change_context', ('default',))), 
     # increase_context
-    (ParsedShortcut(mods=0, key_name='+'), KeyAction('change_context', (5,))),  # noqa
+    (ParsedShortcut(mods=0, key_name='+'), KeyAction('change_context', (5,))), 
     # decrease_context
-    (ParsedShortcut(mods=0, key_name='-'), KeyAction('change_context', (-5,))),  # noqa
+    (ParsedShortcut(mods=0, key_name='-'), KeyAction('change_context', (-5,))), 
     # search_forward
-    (ParsedShortcut(mods=0, key_name='/'), KeyAction('start_search', (True, False))),  # noqa
+    (ParsedShortcut(mods=0, key_name='/'), KeyAction('start_search', (True, False))), 
     # search_backward
-    (ParsedShortcut(mods=0, key_name='?'), KeyAction('start_search', (True, True))),  # noqa
+    (ParsedShortcut(mods=0, key_name='?'), KeyAction('start_search', (True, True))), 
     # next_match
-    (ParsedShortcut(mods=0, key_name='.'), KeyAction('scroll_to', ('next-match',))),  # noqa
+    (ParsedShortcut(mods=0, key_name='.'), KeyAction('scroll_to', ('next-match',))), 
     # next_match
-    (ParsedShortcut(mods=0, key_name='>'), KeyAction('scroll_to', ('next-match',))),  # noqa
+    (ParsedShortcut(mods=0, key_name='>'), KeyAction('scroll_to', ('next-match',))), 
     # prev_match
-    (ParsedShortcut(mods=0, key_name=','), KeyAction('scroll_to', ('prev-match',))),  # noqa
+    (ParsedShortcut(mods=0, key_name=','), KeyAction('scroll_to', ('prev-match',))), 
     # prev_match
-    (ParsedShortcut(mods=0, key_name='<'), KeyAction('scroll_to', ('prev-match',))),  # noqa
+    (ParsedShortcut(mods=0, key_name='<'), KeyAction('scroll_to', ('prev-match',))), 
     # search_forward_simple
-    (ParsedShortcut(mods=0, key_name='f'), KeyAction('start_search', (False, False))),  # noqa
+    (ParsedShortcut(mods=0, key_name='f'), KeyAction('start_search', (False, False))), 
     # search_backward_simple
-    (ParsedShortcut(mods=0, key_name='b'), KeyAction('start_search', (False, True))),  # noqa
+    (ParsedShortcut(mods=0, key_name='b'), KeyAction('start_search', (False, True))), 
 ]

kittens/diff/options/utils.py

@@ -3,11 +3,9 @@
 # License: GPLv3 Copyright: 2021, Kovid Goyal <kovid at kovidgoyal.net>
 
 
-from typing import Any, Dict, Iterable, Tuple, Union
+from typing import Any, Container, Dict, Iterable, Tuple, Union
 
-from kitty.conf.utils import (
-    KeyFuncWrapper, KittensKeyDefinition, parse_kittens_key
-)
+from kitty.conf.utils import KeyFuncWrapper, KittensKeyDefinition, parse_kittens_key
 
 ReturnType = Tuple[str, Any]
 func_with_args = KeyFuncWrapper[ReturnType]()
@@ -58,6 +56,12 @@ def syntax_aliases(raw: str) -> Dict[str, str]:
     return ans
 
 
+def store_multiple(val: str, current_val: Container[str]) -> Iterable[Tuple[str, str]]:
+    val = val.strip()
+    if val not in current_val:
+        yield val, val
+
+
 def parse_map(val: str) -> Iterable[KittensKeyDefinition]:
     x = parse_kittens_key(val, func_with_args.args_funcs)
     if x is not None:

kittens/diff/render.py

@@ -13,10 +13,7 @@ from kitty.types import run_once
 from kitty.utils import ScreenSize
 
 from ..tui.images import ImageManager, can_display_images
-from .collect import (
-    Collection, Segment, data_for_path, highlights_for_path, is_image,
-    lines_for_path, path_name_map, sanitize
-)
+from .collect import Collection, Segment, data_for_path, highlights_for_path, is_image, lines_for_path, path_name_map, sanitize
 from .config import formats
 from .diff_speedup import split_with_highlights as _split_with_highlights
 from .patch import Chunk, Hunk, Patch

kittens/diff/search.py

@@ -5,9 +5,9 @@ import re
 from typing import TYPE_CHECKING, Callable, Dict, Iterable, List, Tuple
 
 from kitty.fast_data_types import wcswidth
-from .options.types import Options as DiffOptions
 
 from ..tui.operations import styled
+from .options.types import Options as DiffOptions
 
 if TYPE_CHECKING:
     from .render import Line

kittens/diff/speedup.c

@@ -187,11 +187,11 @@ static PyMethodDef module_methods[] = {
 };
 
 static struct PyModuleDef module = {
-   .m_base = PyModuleDef_HEAD_INIT,
-   .m_name = "diff_speedup",   /* name of module */
-   .m_doc = NULL,
-   .m_size = -1,
-   .m_methods = module_methods
+    .m_base = PyModuleDef_HEAD_INIT,
+    .m_name = "diff_speedup",   /* name of module */
+    .m_doc = NULL,
+    .m_size = -1,
+    .m_methods = module_methods
 };
 
 EXPORTED PyMODINIT_FUNC

kittens/hints/main.py

@@ -8,21 +8,16 @@ import sys
 from functools import lru_cache
 from gettext import gettext as _
 from itertools import repeat
-from typing import (
-    Any, Callable, Dict, Generator, Iterable, List, Optional, Pattern,
-    Sequence, Set, Tuple, Type, cast
-)
+from typing import Any, Callable, Dict, Generator, Iterable, Iterator, List, Optional, Pattern, Sequence, Set, Tuple, Type, cast
 
 from kitty.cli import parse_args
 from kitty.cli_stub import HintsCLIOptions
+from kitty.clipboard import set_clipboard_string, set_primary_selection
 from kitty.constants import website_url
-from kitty.fast_data_types import get_options, set_clipboard_string
+from kitty.fast_data_types import get_options, wcswidth
 from kitty.key_encoding import KeyEvent
 from kitty.typing import BossType, KittyCommonOpts
-from kitty.utils import (
-    ScreenSize, kitty_ansi_sanitizer_pat, resolve_custom_file,
-    screen_size_function, set_primary_selection
-)
+from kitty.utils import ScreenSize, kitty_ansi_sanitizer_pat, resolve_custom_file, screen_size_function
 
 from ..tui.handler import Handler, result_handler
 from ..tui.loop import Loop
@@ -44,6 +39,7 @@ DEFAULT_HINT_ALPHABET = string.digits + string.ascii_lowercase
 DEFAULT_REGEX = r'(?m)^\s*(.+)\s*$'
 FILE_EXTENSION = r'\.(?:[a-zA-Z0-9]{2,7}|[ahcmo])(?!\.)'
 PATH_REGEX = fr'(?:\S*?/[\r\S]+)|(?:\S[\r\S]*{FILE_EXTENSION})\b'
+DEFAULT_LINENUM_REGEX = fr'(?P<path>{PATH_REGEX}):(?P<line>\d+)'
 
 
 class Mark:
@@ -64,6 +60,10 @@ class Mark:
         self.is_hyperlink = is_hyperlink
         self.group_id = group_id
 
+    def __repr__(self) -> str:
+        return (f'Mark(index={self.index!r}, start={self.start!r}, end={self.end!r},'
+                f' text={self.text!r}, groupdict={self.groupdict!r}, is_hyperlink={self.is_hyperlink!r}, group_id={self.group_id!r})')
+
 
 @lru_cache(maxsize=2048)
 def encode_hint(num: int, alphabet: str) -> str:
@@ -225,14 +225,14 @@ class Hints(Handler):
         self.write(self.current_text)
 
 
-def regex_finditer(pat: 'Pattern[str]', minimum_match_length: int, text: str) -> Generator[Tuple[int, int, Dict[str, str]], None, None]:
+def regex_finditer(pat: 'Pattern[str]', minimum_match_length: int, text: str) -> Iterator[Tuple[int, int, 're.Match[str]']]:
     has_named_groups = bool(pat.groupindex)
     for m in pat.finditer(text):
         s, e = m.span(0 if has_named_groups else pat.groups)
         while e > s + 1 and text[e-1] == '\0':
             e -= 1
         if e - s >= minimum_match_length:
-            yield s, e, m.groupdict()
+            yield s, e, m
 
 
 closing_bracket_map = {'(': ')', '[': ']', '{': '}', '<': '>', '*': '*', '"': '"', "'": "'", "“": "”", "‘": "’"}
@@ -318,16 +318,22 @@ def ip(text: str, s: int, e: int) -> Tuple[int, int]:
     return s, e
 
 
-def mark(pattern: str, post_processors: Iterable[PostprocessorFunc], text: str, args: HintsCLIOptions) -> Generator[Mark, None, None]:
+def mark(pattern: str, post_processors: Iterable[PostprocessorFunc], text: str, args: HintsCLIOptions) -> Iterator[Mark]:
     pat = re.compile(pattern)
-    for idx, (s, e, groupdict) in enumerate(regex_finditer(pat, args.minimum_match_length, text)):
+    sanitize_pat = re.compile('[\r\n\0]')
+    for idx, (s, e, match_object) in enumerate(regex_finditer(pat, args.minimum_match_length, text)):
         try:
             for func in post_processors:
                 s, e = func(text, s, e)
         except InvalidMatch:
             continue
-
-        mark_text = re.sub('[\r\n\0]', '', text[s:e])
+        groupdict = match_object.groupdict()
+        for group_name in groupdict:
+            group_idx = pat.groupindex[group_name]
+            gs, ge = match_object.span(group_idx)
+            gs, ge = max(gs, s), min(ge, e)
+            groupdict[group_name] = sanitize_pat.sub('', text[gs:ge])
+        mark_text = sanitize_pat.sub('', text[s:e])
         yield Mark(idx, s, e, mark_text, groupdict)
 
 
@@ -400,7 +406,10 @@ def convert_text(text: str, cols: int) -> str:
             appended = False
             for line in full_line.split('\r'):
                 if line:
-                    lines.append(line.ljust(cols, '\0'))
+                    line_sz = wcswidth(line)
+                    if line_sz < cols:
+                        line += '\0' * (cols - line_sz)
+                    lines.append(line)
                     lines.append('\r')
                     appended = True
             if appended:
@@ -420,7 +429,7 @@ def parse_input(text: str) -> str:
 def linenum_marks(text: str, args: HintsCLIOptions, Mark: Type[Mark], extra_cli_args: Sequence[str], *a: Any) -> Generator[Mark, None, None]:
     regex = args.regex
     if regex == DEFAULT_REGEX:
-        regex = fr'(?P<path>{PATH_REGEX}):(?P<line>\d+)'
+        regex = DEFAULT_LINENUM_REGEX
     yield from mark(regex, [brackets, quotes], text, args)
 
 
@@ -525,12 +534,27 @@ OPTIONS = r'''
 --program
 type=list
 What program to use to open matched text. Defaults to the default open program
-for the operating system. Use a value of :code:`-` to paste the match into the
-terminal window instead. A value of :code:`@` will copy the match to the
-clipboard. A value of :code:`*` will copy the match to the primary selection
-(on systems that support primary selections). A value of :code:`default` will
-run the default open program. Can be specified multiple times to run multiple
-programs.
+for the operating system. Various special values are supported:
+
+:code:`-`
+    paste the match into the terminal window.
+
+:code:`@`
+    copy the match to the clipboard
+
+:code:`*`
+    copy the match to the primary selection (on systems that support primary selections)
+
+:code:`default`
+    run the default open program.
+
+:code:`launch`
+    run :doc:`/launch` to open the program in a new kitty tab, window, overlay, etc.
+    For example::
+
+        --program "launch --type=tab vim"
+
+Can be specified multiple times to run multiple programs.
 
 
 --type
@@ -699,18 +723,14 @@ def main(args: List[str]) -> Optional[Dict[str, Any]]:
 
 
 def linenum_process_result(data: Dict[str, Any]) -> Tuple[str, int]:
-    pat = re.compile(r':(\d+)$')
-    for m, g in zip(data['match'], data['groupdicts']):
-        if m:
-            path, line = g['path'], g['line']
-            # look for trailers on path of the for :number
-            while True:
-                m = pat.search(path)
-                if m is None:
-                    break
-                line = m.group(1)
-                path = path[:-len(m.group())]
-
+    lnum_pat = re.compile(r'(:\d+)$')
+    for match, g in zip(data['match'], data['groupdicts']):
+        path, line = g['path'], g['line']
+        if path and line:
+            m = lnum_pat.search(path)
+            if m is not None:
+                line = m.group(1)[1:]
+                path = path.rpartition(':')[0]
             return os.path.expanduser(path), int(line)
     return '', -1
 
@@ -796,6 +816,7 @@ def handle_result(args: List[str], data: Dict[str, Any], target_window_id: int,
         elif program == '*':
             set_primary_selection(joined_text())
         else:
+            from kitty.conf.utils import to_cmdline
             cwd = data['cwd']
             program = get_options().open_url_with if program == 'default' else program
             if text_type == 'hyperlink':
@@ -804,12 +825,20 @@ def handle_result(args: List[str], data: Dict[str, Any], target_window_id: int,
                     if w is not None:
                         w.open_url(m, hyperlink_id=1, cwd=cwd)
             else:
+                launch_args = []
+                if isinstance(program, str) and program.startswith('launch '):
+                    launch_args = to_cmdline(program)
+                    launch_args.insert(1, '--cwd=' + cwd)
                 for m, groupdict in zip(matches, groupdicts):
                     if groupdict:
                         m = []
                         for k, v in groupdict.items():
                             m.append('{}={}'.format(k, v or ''))
-                    boss.open_url(m, program, cwd=cwd)
+                    if launch_args:
+                        w = boss.window_id_map.get(target_window_id)
+                        boss.call_remote_control(active_window=w, args=tuple(launch_args + ([m] if isinstance(m, str) else m)))
+                    else:
+                        boss.open_url(m, program, cwd=cwd)
 
 
 if __name__ == '__main__':

kittens/hints/url_regex.py

@@ -1,3 +1,3 @@
 # generated by gen-wcwidth.py, do not edit
 
-url_delimiters = '\x00-\x09\x0b-\x0c\x0e-\x20\x7f-\xa0\xad\u0600-\u0605\u061c\u06dd\u070f\u0890-\u0891\u08e2\u1680\u180e\u2000-\u200f\u2028-\u202f\u205f-\u2064\u2066-\u206f\u3000\ud800-\uf8ff\ufeff\ufff9-\ufffb\U000110bd\U000110cd\U00013430-\U00013438\U0001bca0-\U0001bca3\U0001d173-\U0001d17a\U000e0001\U000e0020-\U000e007f\U000f0000-\U000ffffd\U00100000-\U0010fffd'  # noqa
+url_delimiters = '\x00-\x09\x0b-\x0c\x0e-\x20\x7f-\xa0\xad\u0600-\u0605\u061c\u06dd\u070f\u0890-\u0891\u08e2\u1680\u180e\u2000-\u200f\u2028-\u202f\u205f-\u2064\u2066-\u206f\u3000\ud800-\uf8ff\ufeff\ufff9-\ufffb\U000110bd\U000110cd\U00013430-\U0001343f\U0001bca0-\U0001bca3\U0001d173-\U0001d17a\U000e0001\U000e0020-\U000e007f\U000f0000-\U000ffffd\U00100000-\U0010fffd'  # noqa

kittens/hyperlinked_grep/main.py

@@ -1,15 +1,17 @@
 #!/usr/bin/env python
 # License: GPLv3 Copyright: 2020, Kovid Goyal <kovid at kovidgoyal.net>
 
+import argparse
 import os
 import re
 import signal
-import socket
 import subprocess
 import sys
-from typing import Callable, cast
+from typing import Callable, List, cast
 from urllib.parse import quote_from_bytes
 
+from kitty.utils import get_hostname
+
 
 def write_hyperlink(write: Callable[[bytes], None], url: bytes, line: bytes, frag: bytes = b'') -> None:
     text = b'\033]8;;' + url
@@ -19,8 +21,93 @@ def write_hyperlink(write: Callable[[bytes], None], url: bytes, line: bytes, fra
     write(text)
 
 
+def parse_options(argv: List[str]) -> argparse.Namespace:
+    p = argparse.ArgumentParser(add_help=False)
+    p.add_argument('--context-separator', default='--')
+    p.add_argument('-c', '--count', action='store_true')
+    p.add_argument('--count-matches', action='store_true')
+    p.add_argument('--field-context-separator', default='-')
+    p.add_argument('--field-match-separator', default='-')
+    p.add_argument('--files', action='store_true')
+    p.add_argument('-l', '--files-with-matches', action='store_true')
+    p.add_argument('--files-without-match', action='store_true')
+    p.add_argument('-h', '--help', action='store_true')
+    p.add_argument('--json', action='store_true')
+    p.add_argument('-I', '--no-filename', action='store_true')
+    p.add_argument('--no-heading', action='store_true')
+    p.add_argument('-N', '--no-line-number', action='store_true')
+    p.add_argument('-0', '--null', action='store_true')
+    p.add_argument('--null-data', action='store_true')
+    p.add_argument('--path-separator', default=os.path.sep)
+    p.add_argument('--stats', action='store_true')
+    p.add_argument('--type-list', action='store_true')
+    p.add_argument('-V', '--version', action='store_true')
+    p.add_argument('--vimgrep', action='store_true')
+    p.add_argument(
+        '-p', '--pretty',
+        default=sys.stdout.isatty(),
+        action='store_true',
+    )
+    p.add_argument('--kitten', action='append', default=[])
+    args, _ = p.parse_known_args(argv)
+    return args
+
+
 def main() -> None:
-    if not sys.stdout.isatty() and '--pretty' not in sys.argv and '-p' not in sys.argv:
+    i = 1
+    args = parse_options(sys.argv[1:])
+    all_link_options = {'matching_lines', 'context_lines', 'file_headers'}
+    link_options = set()
+    delegate_to_rg = False
+
+    for raw in args.kitten:
+        p, _, s = raw.partition('=')
+        if p != 'hyperlink':
+            raise SystemExit(f'Unknown argument for --kitten: {raw}')
+        for option in s.split(','):
+            if option == 'all':
+                link_options.update(all_link_options)
+                delegate_to_rg = False
+            elif option == 'none':
+                delegate_to_rg = True
+                link_options.clear()
+            elif option not in all_link_options:
+                a = ', '.join(sorted(all_link_options))
+                raise SystemExit(f"hyperlink option must be one of all, none, {a}, not '{option}'")
+            else:
+                link_options.add(option)
+                delegate_to_rg = False
+
+    while i < len(sys.argv):
+        if sys.argv[i] == '--kitten':
+            del sys.argv[i:i+2]
+        elif sys.argv[i].startswith('--kitten='):
+            del sys.argv[i]
+        else:
+            i += 1
+    if not link_options:  # Default to linking everything if no options given
+        link_options.update(all_link_options)
+    link_file_headers = 'file_headers' in link_options
+    link_context_lines = 'context_lines' in link_options
+    link_matching_lines = 'matching_lines' in link_options
+
+    if any((
+        args.context_separator != '--',
+        args.field_context_separator != '-',
+        args.field_match_separator != '-',
+        args.help,
+        args.json,
+        args.no_filename,
+        args.null,
+        args.null_data,
+        args.path_separator != os.path.sep,
+        args.type_list,
+        args.version,
+        not args.pretty,
+    )):
+        delegate_to_rg = True
+
+    if delegate_to_rg:
         os.execlp('rg', 'rg', *sys.argv[1:])
     cmdline = ['rg', '--pretty', '--with-filename'] + sys.argv[1:]
     try:
@@ -28,13 +115,22 @@ def main() -> None:
     except FileNotFoundError:
         raise SystemExit('Could not find the rg executable in your PATH. Is ripgrep installed?')
     assert p.stdout is not None
+
     write: Callable[[bytes], None] = cast(Callable[[bytes], None], sys.stdout.buffer.write)
     sgr_pat = re.compile(br'\x1b\[.*?m')
     osc_pat = re.compile(b'\x1b\\].*?\x1b\\\\')
-    num_pat = re.compile(br'^(\d+)[:-]')
+    num_pat = re.compile(br'^(\d+)([:-])')
+    path_with_count_pat = re.compile(br'(.*?)(:\d+)')
+    path_with_linenum_pat = re.compile(br'^(.*?):(\d+):')
+    stats_pat = re.compile(br'^\d+ matches$')
+    vimgrep_pat = re.compile(br'^(.*?):(\d+):(\d+):')
 
+    in_stats = False
     in_result: bytes = b''
-    hostname = socket.gethostname().encode('utf-8')
+    hostname = get_hostname().encode('utf-8')
+
+    def get_quoted_url(file_path: bytes) -> bytes:
+        return b'file://' + hostname + quote_from_bytes(os.path.abspath(file_path)).encode('utf-8')
 
     try:
         for line in p.stdout:
@@ -43,20 +139,43 @@ def main() -> None:
             if not clean_line:
                 in_result = b''
                 write(b'\n')
-                continue
-            if in_result:
-                m = num_pat.match(clean_line)
-                if m is not None:
-                    write_hyperlink(write, in_result, line, frag=m.group(1))
-                else:
-                    write(line)
+            elif in_stats:
+                write(line)
+            elif in_result:
+                if not args.no_line_number:
+                    m = num_pat.match(clean_line)
+                    if m is not None:
+                        is_match_line = m.group(2) == b':'
+                        if (is_match_line and link_matching_lines) or (not is_match_line and link_context_lines):
+                            write_hyperlink(write, in_result, line, frag=m.group(1))
+                            continue
+                write(line)
             else:
                 if line.strip():
-                    path = quote_from_bytes(os.path.abspath(clean_line)).encode('utf-8')
-                    in_result = b'file://' + hostname + path
-                    write_hyperlink(write, in_result, line)
-                else:
-                    write(line)
+                    # The option priority should be consistent with ripgrep here.
+                    if args.stats and not in_stats and stats_pat.match(clean_line):
+                        in_stats = True
+                    elif args.count or args.count_matches:
+                        m = path_with_count_pat.match(clean_line)
+                        if m is not None and link_file_headers:
+                            write_hyperlink(write, get_quoted_url(m.group(1)), line)
+                            continue
+                    elif args.files or args.files_with_matches or args.files_without_match:
+                        if link_file_headers:
+                            write_hyperlink(write, get_quoted_url(clean_line), line)
+                            continue
+                    elif args.vimgrep or args.no_heading:
+                        # When the vimgrep option is present, it will take precedence.
+                        m = vimgrep_pat.match(clean_line) if args.vimgrep else path_with_linenum_pat.match(clean_line)
+                        if m is not None and (link_file_headers or link_matching_lines):
+                            write_hyperlink(write, get_quoted_url(m.group(1)), line, frag=m.group(2))
+                            continue
+                    else:
+                        in_result = get_quoted_url(clean_line)
+                        if link_file_headers:
+                            write_hyperlink(write, in_result, line)
+                            continue
+                write(line)
     except KeyboardInterrupt:
         p.send_signal(signal.SIGINT)
     except (EOFError, BrokenPipeError):
@@ -68,3 +187,6 @@ def main() -> None:
 
 if __name__ == '__main__':
     main()
+elif __name__ == '__wrapper_of__':
+    cd = sys.cli_docs  # type: ignore
+    cd['wrapper_of'] = 'rg'

kittens/icat/main.py

@@ -1,38 +1,6 @@
 #!/usr/bin/env python3
 # License: GPL v3 Copyright: 2017, Kovid Goyal <kovid at kovidgoyal.net>
 
-import contextlib
-import os
-import re
-import signal
-import socket
-import sys
-import zlib
-from base64 import standard_b64encode
-from math import ceil
-from tempfile import NamedTemporaryFile
-from typing import (
-    Dict, Generator, List, NamedTuple, Optional, Pattern, Tuple, Union
-)
-
-from kitty.cli import parse_args
-from kitty.cli_stub import IcatCLIOptions
-from kitty.constants import appname
-from kitty.guess_mime_type import guess_type
-from kitty.rgb import to_color
-from kitty.types import run_once
-from kitty.typing import GRT_f, GRT_t
-from kitty.utils import (
-    TTYIO, ScreenSize, ScreenSizeGetter, screen_size_function
-)
-
-from ..tui.images import (
-    ConvertFailed, Dispose, GraphicsCommand, NoImageMagick, OpenFailed,
-    OutdatedImageMagick, RenderedImage, fsenc, identify,
-    render_as_single_image, render_image
-)
-from ..tui.operations import clear_images_on_screen, raw_mode
-
 OPTIONS = '''\
 --align
 type=choices
@@ -46,7 +14,10 @@ Choose where on the screen to display the image. The image will be scaled to fit
 into the specified rectangle. The syntax for specifying rectangles is
 <:italic:`width`>x<:italic:`height`>@<:italic:`left`>x<:italic:`top`>.
 All measurements are in cells (i.e. cursor positions) with the origin
-:italic:`(0, 0)` at the top-left corner of the screen.
+:italic:`(0, 0)` at the top-left corner of the screen. Note that the :option:`--align`
+option will horizontally align the image within this rectangle. By default, the image
+is horizontally centered within the rectangle. Using place will cause the cursor to
+be positioned at the top left corner of the image, instead of on the line after the image.
 
 
 --scale-up
@@ -76,13 +47,14 @@ Remove all images currently displayed on the screen.
 
 --transfer-mode
 type=choices
-choices=detect,file,stream
+choices=detect,file,stream,memory
 default=detect
 Which mechanism to use to transfer images to the terminal. The default is to
-auto-detect. :italic:`file` means to use a temporary file and :italic:`stream`
-means to send the data via terminal escape codes. Note that if you use the
-:italic:`file` transfer mode and you are connecting over a remote session then
-image display will not work.
+auto-detect. :italic:`file` means to use a temporary file, :italic:`memory` means
+to use shared memory, :italic:`stream` means to send the data via terminal
+escape codes. Note that if you use the :italic:`file` or :italic:`memory` transfer
+modes and you are connecting over a remote session then image display will not
+work.
 
 
 --detect-support
@@ -117,7 +89,17 @@ not a terminal, but you can turn it off or on explicitly, if needed.
 
 --silent
 type=bool-set
-Do not print out anything to STDOUT during operation.
+Not used, present for legacy compatibility.
+
+
+--engine
+type=choices
+choices=auto,builtin,magick
+default=auto
+The engine used for decoding and processing of images. The default is to use
+the most appropriate engine.  The :code:`builtin` engine uses Go's native
+imaging libraries. The :code:`magick` engine uses ImageMagick which requires
+it to be installed on the system.
 
 
 --z-index -z
@@ -140,306 +122,6 @@ type=bool-set
 Wait for a key press before exiting after displaying the images.
 '''
 
-
-screen_size: Optional[ScreenSizeGetter] = None
-can_transfer_with_files = False
-
-
-def get_screen_size_function() -> ScreenSizeGetter:
-    global screen_size
-    if screen_size is None:
-        screen_size = screen_size_function()
-    return screen_size
-
-
-def get_screen_size() -> ScreenSize:
-    screen_size = get_screen_size_function()
-    return screen_size()
-
-
-@run_once
-def options_spec() -> str:
-    return OPTIONS.format(appname=f'{appname}-icat')
-
-
-def write_gr_cmd(cmd: GraphicsCommand, payload: Optional[bytes] = None) -> None:
-    sys.stdout.buffer.write(cmd.serialize(payload or b''))
-    sys.stdout.flush()
-
-
-def calculate_in_cell_x_offset(width: int, cell_width: int, align: str) -> int:
-    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: GraphicsCommand, width: int, height: int, align: str) -> None:
-    ss = get_screen_size()
-    cw = int(ss.width / ss.cols)
-    num_of_cells_needed = int(ceil(width / cw))
-    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
-    elif align == 'right':
-        extra_cells = (ss.cols - num_of_cells_needed)
-    if extra_cells:
-        sys.stdout.buffer.write(b' ' * extra_cells)
-
-
-def set_cursor_for_place(place: 'Place', cmd: GraphicsCommand, width: int, height: int, align: str) -> None:
-    x = place.left + 1
-    ss = get_screen_size()
-    cw = int(ss.width / ss.cols)
-    num_of_cells_needed = int(ceil(width / cw))
-    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
-    elif align == 'right':
-        extra_cells = place.width - num_of_cells_needed
-    sys.stdout.buffer.write(f'\033[{place.top + 1};{x + extra_cells}H'.encode('ascii'))
-
-
-def write_chunked(cmd: GraphicsCommand, data: bytes) -> None:
-    cmd = cmd.clone()
-    if cmd.f != 100:
-        data = zlib.compress(data)
-        cmd.o = 'z'
-    data = standard_b64encode(data)
-    ac = cmd.a
-    quiet = cmd.q
-    while data:
-        chunk, data = data[:4096], data[4096:]
-        cmd.m = 1 if data else 0
-        write_gr_cmd(cmd, chunk)
-        cmd.clear()
-        cmd.a = ac
-        cmd.q = quiet
-
-
-def show(
-    outfile: str,
-    width: int, height: int, zindex: int,
-    fmt: 'GRT_f',
-    transmit_mode: 'GRT_t' = 't',
-    align: str = 'center',
-    place: Optional['Place'] = None,
-    use_number: int = 0
-) -> None:
-    cmd = GraphicsCommand()
-    cmd.a = 'T'
-    cmd.f = fmt
-    cmd.s = width
-    cmd.v = height
-    cmd.z = zindex
-    if use_number:
-        cmd.I = use_number  # noqa
-        cmd.q = 2
-    if place:
-        set_cursor_for_place(place, cmd, width, height, align)
-    else:
-        set_cursor(cmd, width, height, align)
-    if can_transfer_with_files:
-        cmd.t = transmit_mode
-        write_gr_cmd(cmd, standard_b64encode(os.path.abspath(outfile).encode(fsenc)))
-    else:
-        with open(outfile, 'rb') as f:
-            data = f.read()
-        if transmit_mode == 't':
-            os.unlink(outfile)
-        if fmt == 100:
-            cmd.S = len(data)
-        write_chunked(cmd, data)
-
-
-def show_frames(frame_data: RenderedImage, use_number: int, loops: int) -> None:
-    transmit_cmd = GraphicsCommand()
-    transmit_cmd.a = 'f'
-    transmit_cmd.I = use_number  # noqa
-    transmit_cmd.q = 2
-    if can_transfer_with_files:
-        transmit_cmd.t = 't'
-    transmit_cmd.f = 24 if frame_data.mode == 'rgb' else 32
-
-    def control(frame_number: int = 0, loops: Optional[int] = None, gap: Optional[int] = 0, animation_control: int = 0) -> None:
-        cmd = GraphicsCommand()
-        cmd.a = 'a'
-        cmd.I = use_number  # noqa
-        cmd.r = frame_number
-        if loops is not None:
-            cmd.v = loops + 1
-        if gap is not None:
-            cmd.z = gap if gap > 0 else -1
-        if animation_control:
-            cmd.s = animation_control
-        write_gr_cmd(cmd)
-
-    anchor_frame = 0
-
-    for frame in frame_data.frames:
-        frame_number = frame.index + 1
-        if frame.dispose < Dispose.previous:
-            anchor_frame = frame_number
-        if frame_number == 1:
-            control(frame_number, gap=frame.gap, loops=None if loops < 1 else loops)
-            continue
-        if frame.dispose is Dispose.previous:
-            if anchor_frame != frame_number:
-                transmit_cmd.c = anchor_frame
-        else:
-            transmit_cmd.c = (frame_number - 1) if frame.needs_blend else 0
-        transmit_cmd.s = frame.width
-        transmit_cmd.v = frame.height
-        transmit_cmd.x = frame.canvas_x
-        transmit_cmd.y = frame.canvas_y
-        transmit_cmd.z = frame.gap if frame.gap > 0 else -1
-        if can_transfer_with_files:
-            write_gr_cmd(transmit_cmd, standard_b64encode(os.path.abspath(frame.path).encode(fsenc)))
-        else:
-            with open(frame.path, 'rb') as f:
-                data = f.read()
-            write_chunked(transmit_cmd, data)
-        if frame_number == 2:
-            control(animation_control=2)
-    control(animation_control=3)
-
-
-def parse_z_index(val: str) -> int:
-    origin = 0
-    if val.startswith('--'):
-        val = val[1:]
-        origin = -1073741824
-    return origin + int(val)
-
-
-class ParsedOpts:
-
-    place: Optional['Place'] = None
-    z_index: int = 0
-    remove_alpha: str = ''
-    flip: bool = False
-    flop: bool = False
-
-
-def process(path: str, args: IcatCLIOptions, parsed_opts: ParsedOpts, is_tempfile: bool) -> bool:
-    m = identify(path)
-    ss = get_screen_size()
-    available_width = parsed_opts.place.width * (ss.width // ss.cols) if parsed_opts.place else ss.width
-    available_height = parsed_opts.place.height * (ss.height // ss.rows) if parsed_opts.place else 10 * m.height
-    needs_scaling = m.width > available_width or m.height > available_height
-    needs_scaling = needs_scaling or args.scale_up
-    needs_conversion = needs_scaling or bool(parsed_opts.remove_alpha) or parsed_opts.flip or parsed_opts.flop
-    file_removed = False
-    use_number = 0
-    if m.fmt == 'png' and not needs_conversion:
-        outfile = path
-        transmit_mode: 'GRT_t' = 't' if is_tempfile else 'f'
-        fmt: 'GRT_f' = 100
-        width, height = m.width, m.height
-        file_removed = transmit_mode == 't'
-    else:
-        fmt = 24 if m.mode == 'rgb' else 32
-        transmit_mode = 't'
-        if len(m) == 1 or args.loop == 0:
-            outfile, width, height = render_as_single_image(
-                path, m, available_width, available_height, args.scale_up,
-                remove_alpha=parsed_opts.remove_alpha, flip=parsed_opts.flip, flop=parsed_opts.flop)
-        else:
-            import struct
-            use_number = max(1, struct.unpack('@I', os.urandom(4))[0])
-            with NamedTemporaryFile() as f:
-                prefix = f.name
-            frame_data = render_image(
-                path, prefix, m, available_width, available_height, args.scale_up,
-                remove_alpha=parsed_opts.remove_alpha, flip=parsed_opts.flip, flop=parsed_opts.flop)
-            outfile, width, height = frame_data.frames[0].path, frame_data.width, frame_data.height
-    show(
-        outfile, width, height, parsed_opts.z_index, fmt, transmit_mode,
-        align=args.align, place=parsed_opts.place, use_number=use_number
-    )
-    if use_number:
-        show_frames(frame_data, use_number, args.loop)
-        if not can_transfer_with_files:
-            for fr in frame_data.frames:
-                with contextlib.suppress(FileNotFoundError):
-                    os.unlink(fr.path)
-    if not args.place:
-        print()  # ensure cursor is on a new line
-    return file_removed
-
-
-def scan(d: str) -> Generator[Tuple[str, str], None, None]:
-    for dirpath, dirnames, filenames in os.walk(d):
-        for f in filenames:
-            mt = guess_type(f)
-            if mt and mt.startswith('image/'):
-                yield os.path.join(dirpath, f), mt
-
-
-def detect_support(wait_for: float = 10, silent: bool = False) -> bool:
-    global can_transfer_with_files
-    if not silent:
-        print(f'Checking for graphics ({wait_for}s max. wait)...', end='\r')
-    sys.stdout.flush()
-    try:
-        received = b''
-        responses: Dict[int, bool] = {}
-
-        def parse_responses() -> None:
-            for m in re.finditer(b'\033_Gi=([1|2]);(.+?)\033\\\\', received):
-                iid = m.group(1)
-                if iid in (b'1', b'2'):
-                    iid_ = int(iid.decode('ascii'))
-                    if iid_ not in responses:
-                        responses[iid_] = m.group(2) == b'OK'
-
-        def more_needed(data: bytes) -> bool:
-            nonlocal received
-            received += data
-            parse_responses()
-            return 1 not in responses or 2 not in responses
-
-        with NamedTemporaryFile() as f:
-            f.write(b'abcd')
-            f.flush()
-            gc = GraphicsCommand()
-            gc.a = 'q'
-            gc.s = gc.v = gc.i = 1
-            write_gr_cmd(gc, standard_b64encode(b'abcd'))
-            gc.t = 'f'
-            gc.i = 2
-            write_gr_cmd(gc, standard_b64encode(f.name.encode(fsenc)))
-            with TTYIO() as io:
-                io.recv(more_needed, timeout=wait_for)
-    finally:
-        if not silent:
-            sys.stdout.buffer.write(b'\033[J'), sys.stdout.flush()
-    can_transfer_with_files = bool(responses.get(2))
-    return responses.get(1, False)
-
-
-class Place(NamedTuple):
-    width: int
-    height: int
-    left: int
-    top: int
-
-
-def parse_place(raw: str) -> Optional[Place]:
-    if raw:
-        area, pos = raw.split('@', 1)
-        w, h = map(int, area.split('x'))
-        l, t = map(int, pos.split('x'))
-        return Place(w, h, l, t)
-    return None
-
-
 help_text = (
         'A cat like utility to display images in the terminal.'
         ' You can specify multiple image files and/or directories.'
@@ -451,174 +133,15 @@ help_text = (
 usage = 'image-file-or-url-or-directory ...'
 
 
-@contextlib.contextmanager
-def socket_timeout(seconds: int) -> Generator[None, None, None]:
-    old = socket.getdefaulttimeout()
-    socket.setdefaulttimeout(seconds)
-    try:
-        yield
-    finally:
-        socket.setdefaulttimeout(old)
-
-
-def process_single_item(
-    item: Union[bytes, str],
-    args: IcatCLIOptions,
-    parsed_opts: ParsedOpts,
-    url_pat: Optional['Pattern[str]'] = None,
-    maybe_dir: bool = True
-) -> None:
-    is_tempfile = False
-    file_removed = False
-    try:
-        if isinstance(item, bytes):
-            with NamedTemporaryFile(prefix='stdin-image-data-', delete=False) as tf:
-                tf.write(item)
-            item = tf.name
-            is_tempfile = True
-        if url_pat is not None and url_pat.match(item) is not None:
-            from urllib.request import urlretrieve
-            with NamedTemporaryFile(prefix='url-image-data-', delete=False) as tf:
-                try:
-                    with socket_timeout(30):
-                        urlretrieve(item, filename=tf.name)
-                except Exception as e:
-                    raise SystemExit(f'Failed to download image at URL: {item} with error: {e}')
-                item = tf.name
-            is_tempfile = True
-            file_removed = process(item, args, parsed_opts, is_tempfile)
-        elif item.lower().startswith('file://'):
-            from urllib.parse import urlparse
-            from urllib.request import url2pathname
-            pitem = urlparse(item)
-            if os.sep == '\\':
-                item = pitem.netloc + pitem.path
-            else:
-                item = pitem.path
-            item = url2pathname(item)
-            file_removed = process(item, args, parsed_opts, is_tempfile)
-        else:
-            if maybe_dir and os.path.isdir(item):
-                for (x, mt) in scan(item):
-                    process_single_item(x, args, parsed_opts, url_pat=None, maybe_dir=False)
-            else:
-                file_removed = process(item, args, parsed_opts, is_tempfile)
-    finally:
-        if is_tempfile and not file_removed:
-            os.remove(item)
-
-
-def main(args: List[str] = sys.argv) -> None:
-    global can_transfer_with_files
-    cli_opts, items_ = parse_args(args[1:], options_spec, usage, help_text, f'{appname} +kitten icat', result_class=IcatCLIOptions)
-    items: List[Union[str, bytes]] = list(items_)
-
-    if cli_opts.print_window_size:
-        screen_size_function.cache_clear()
-        with open(os.ctermid()) as tty:
-            try:
-                fd = tty.fileno()
-            except AttributeError:
-                # use default value for fd if ctermid is not available
-                fd = None
-            ss = screen_size_function(fd)()
-        print(f'{ss.width}x{ss.height}', end='')
-        raise SystemExit(0)
-
-    if not sys.stdout.isatty():
-        sys.stdout = open(os.ctermid(), 'w')
-    stdin_data = None
-    if cli_opts.stdin == 'yes' or (cli_opts.stdin == 'detect' and sys.stdin is not None and not sys.stdin.isatty()):
-        stdin_data = sys.stdin.buffer.read()
-        if stdin_data:
-            items.insert(0, stdin_data)
-        sys.stdin.close()
-        sys.stdin = open(os.ctermid())
-
-    screen_size = get_screen_size_function()
-    signal.signal(signal.SIGWINCH, lambda signum, frame: setattr(screen_size, 'changed', True))
-    if screen_size().width == 0:
-        if cli_opts.detect_support:
-            raise SystemExit(1)
-        raise SystemExit(
-            'Terminal does not support reporting screen sizes via the TIOCGWINSZ ioctl'
-        )
-    parsed_opts = ParsedOpts()
-    if cli_opts.place:
-        try:
-            parsed_opts.place = parse_place(cli_opts.place)
-        except Exception:
-            raise SystemExit(f'Not a valid place specification: {cli_opts.place}')
-
-    try:
-        parsed_opts.z_index = parse_z_index(cli_opts.z_index)
-    except Exception:
-        raise SystemExit(f'Not a valid z-index specification: {cli_opts.z_index}')
-    if cli_opts.background != 'none':
-        ra = to_color(cli_opts.background)
-        if ra is None:
-            raise SystemExit(f'Not a valid color specification: {cli_opts.background}')
-        parsed_opts.remove_alpha = ra.as_sharp
-    parsed_opts.flip = cli_opts.mirror in ('both', 'vertical')
-    parsed_opts.flop = cli_opts.mirror in ('both', 'horizontal')
-
-    if cli_opts.detect_support:
-        if not detect_support(wait_for=cli_opts.detection_timeout, silent=True):
-            raise SystemExit(1)
-        print('file' if can_transfer_with_files else 'stream', end='', file=sys.stderr)
-        return
-    if cli_opts.transfer_mode == 'detect':
-        if not detect_support(wait_for=cli_opts.detection_timeout, silent=cli_opts.silent):
-            raise SystemExit('This terminal emulator does not support the graphics protocol, use a terminal emulator such as kitty that does support it')
-    else:
-        can_transfer_with_files = cli_opts.transfer_mode == 'file'
-    errors = []
-    if cli_opts.clear:
-        sys.stdout.write(clear_images_on_screen(delete_data=True))
-        if not items:
-            return
-    if not items:
-        raise SystemExit('You must specify at least one file to cat')
-    if parsed_opts.place:
-        if len(items) > 1 or (isinstance(items[0], str) and os.path.isdir(items[0])):
-            raise SystemExit(f'The --place option can only be used with a single image, not {items}')
-        sys.stdout.buffer.write(b'\0337')  # save cursor
-    url_pat = re.compile(r'(?:https?|ftp)://', flags=re.I)
-
-    def hold_if_needed(exit_code_or_msg: Union[int, str]) -> None:
-        if cli_opts.hold:
-            if isinstance(exit_code_or_msg, str):
-                print(exit_code_or_msg, file=sys.stderr, flush=True)
-                exit_code_or_msg = 1
-            with open(os.ctermid()) as tty, raw_mode(tty.fileno()):
-                tty.buffer.read(1)
-        raise SystemExit(exit_code_or_msg)
-
-    for item in items:
-        try:
-            process_single_item(item, cli_opts, parsed_opts, url_pat)
-        except NoImageMagick as e:
-            hold_if_needed(str(e))
-        except OutdatedImageMagick as e:
-            print(e.detailed_error, file=sys.stderr)
-            hold_if_needed(str(e))
-        except ConvertFailed as e:
-            hold_if_needed(str(e))
-        except OpenFailed as e:
-            errors.append(e)
-    if parsed_opts.place:
-        sys.stdout.buffer.write(b'\0338')  # restore cursor
-    if errors:
-        for err in errors:
-            print(err, file=sys.stderr)
-    hold_if_needed(1 if errors else 0)
-    raise SystemExit()
-
-
 if __name__ == '__main__':
-    main()
+    raise SystemExit('This should be run as kitten icat')
 elif __name__ == '__doc__':
+    import sys
+
+    from kitty.cli import CompletionSpec
     cd = sys.cli_docs  # type: ignore
     cd['usage'] = usage
-    cd['options'] = options_spec
+    cd['options'] = lambda: OPTIONS.format()
     cd['help_text'] = help_text
+    cd['short_desc'] = 'Display images in the terminal'
+    cd['args_completion'] = CompletionSpec.from_string('type:file mime:image/* group:Images')

kittens/panel/main.py

@@ -2,14 +2,13 @@
 # License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
 
 import os
-import shutil
-import subprocess
 import sys
 from typing import Any, Callable, Dict, List, Tuple
 
 from kitty.cli import parse_args
 from kitty.cli_stub import PanelCLIOptions
 from kitty.constants import appname, is_macos
+from kitty.fast_data_types import make_x11_window_a_dock_window
 from kitty.os_window_size import WindowSizeData
 
 OPTIONS = r'''
@@ -65,14 +64,7 @@ def parse_panel_args(args: List[str]) -> Tuple[PanelCLIOptions, List[str]]:
     return parse_args(args, OPTIONS, usage, help_text, 'kitty +kitten panel', result_class=PanelCLIOptions)
 
 
-def call_xprop(*cmd: str, silent: bool = False) -> None:
-    cmd_ = ['xprop'] + list(cmd)
-    try:
-        cp = subprocess.run(cmd_, stdout=subprocess.DEVNULL if silent else None)
-    except FileNotFoundError:
-        raise SystemExit('You must have the xprop program installed')
-    if cp.returncode != 0:
-        raise SystemExit(cp.returncode)
+Strut = Tuple[int, int, int, int, int, int, int, int, int, int, int, int]
 
 
 def create_strut(
@@ -80,43 +72,33 @@ def create_strut(
     left: int = 0, right: int = 0, top: int = 0, bottom: int = 0, left_start_y: int = 0, left_end_y: int = 0,
     right_start_y: int = 0, right_end_y: int = 0, top_start_x: int = 0, top_end_x: int = 0,
     bottom_start_x: int = 0, bottom_end_x: int = 0
-) -> None:
-    call_xprop(
-            '-id',
-            str(int(win_id)), '-format', '_NET_WM_STRUT_PARTIAL', '32cccccccccccc',
-            '-set', '_NET_WM_STRUT_PARTIAL',
-            f'{left},{right},{top},{bottom},'
-            f'{left_start_y},{left_end_y},{right_start_y},{right_end_y},'
-            f'{top_start_x},{top_end_x},{bottom_start_x},{bottom_end_x}'
-    )
+) -> Strut:
+    return left, right, top, bottom, left_start_y, left_end_y, right_start_y, right_end_y, top_start_x, top_end_x, bottom_start_x, bottom_end_x
 
 
-def create_top_strut(win_id: int, width: int, height: int) -> None:
-    create_strut(win_id, top=height, top_end_x=width)
+def create_top_strut(win_id: int, width: int, height: int) -> Strut:
+    return create_strut(win_id, top=height, top_end_x=width)
 
 
-def create_bottom_strut(win_id: int, width: int, height: int) -> None:
-    create_strut(win_id, bottom=height, bottom_end_x=width)
+def create_bottom_strut(win_id: int, width: int, height: int) -> Strut:
+    return create_strut(win_id, bottom=height, bottom_end_x=width)
 
 
-def create_left_strut(win_id: int, width: int, height: int) -> None:
-    create_strut(win_id, left=width, left_end_y=height)
+def create_left_strut(win_id: int, width: int, height: int) -> Strut:
+    return create_strut(win_id, left=width, left_end_y=height)
 
 
-def create_right_strut(win_id: int, width: int, height: int) -> None:
-    create_strut(win_id, right=width, right_end_y=height)
+def create_right_strut(win_id: int, width: int, height: int) -> Strut:
+    return create_strut(win_id, right=width, right_end_y=height)
 
 
 window_width = window_height = 0
 
 
 def setup_x11_window(win_id: int) -> None:
-    call_xprop(
-            '-id', str(win_id), '-format', '_NET_WM_WINDOW_TYPE', '32a',
-            '-set', '_NET_WM_WINDOW_TYPE', '_NET_WM_WINDOW_TYPE_DOCK'
-    )
     func = globals()[f'create_{args.edge}_strut']
-    func(win_id, window_width, window_height)
+    strut = func(win_id, window_width, window_height)
+    make_x11_window_a_dock_window(win_id, strut)
 
 
 def initial_window_size_func(opts: WindowSizeData, cached_values: Dict[str, Any]) -> Callable[[int, int, float, float, float, float], Tuple[int, int]]:
@@ -140,8 +122,6 @@ def main(sys_args: List[str]) -> None:
     global args
     if is_macos or not os.environ.get('DISPLAY'):
         raise SystemExit('Currently the panel kitten is supported only on X11 desktops')
-    if not shutil.which('xprop'):
-        raise SystemExit('The xprop program is required for the panel kitten')
     args, items = parse_panel_args(sys_args[1:])
     if not items:
         raise SystemExit('You must specify the program to run')
@@ -154,7 +134,8 @@ def main(sys_args: List[str]) -> None:
     for override in args.override:
         sys.argv.extend(('--override', override))
     sys.argv.extend(items)
-    from kitty.main import main as real_main, run_app
+    from kitty.main import main as real_main
+    from kitty.main import run_app
     run_app.cached_values_name = 'panel'
     run_app.first_window_callback = setup_x11_window
     run_app.initial_window_size_func = initial_window_size_func

kittens/query_terminal/main.py

@@ -5,7 +5,7 @@ import re
 import sys
 from binascii import hexlify, unhexlify
 from contextlib import suppress
-from typing import Dict, Iterable, List, Type, Optional
+from typing import Dict, Iterable, List, Optional, Type
 
 from kitty.cli import parse_args
 from kitty.cli_stub import QueryTerminalCLIOptions

kittens/remote_file/main.py

@@ -16,17 +16,12 @@ from kitty.cli import parse_args
 from kitty.cli_stub import RemoteFileCLIOptions
 from kitty.constants import cache_dir
 from kitty.typing import BossType
-from kitty.utils import (
-    SSHConnectionData, command_for_open, get_editor, open_cmd
-)
+from kitty.utils import SSHConnectionData, command_for_open, get_editor, open_cmd
 
 from ..tui.handler import result_handler
-from ..tui.operations import (
-    faint, raw_mode, reset_terminal, styled
-)
+from ..tui.operations import faint, raw_mode, reset_terminal, styled
 from ..tui.utils import get_key_press
 
-
 is_ssh_kitten_sentinel = '!#*&$#($ssh-kitten)(##$'
 
 
@@ -206,7 +201,7 @@ class ControlMaster:
         show_error(msg)
 
     def download(self) -> bool:
-        cmdline = self.batch_cmd_prefix + [self.conn_data.hostname, 'cat', self.remote_path]
+        cmdline = self.batch_cmd_prefix + [self.conn_data.hostname, 'cat', shlex.quote(self.remote_path)]
         with open(self.dest, 'wb') as f:
             cp = subprocess.run(cmdline, stdout=f, stderr=subprocess.PIPE, stdin=subprocess.DEVNULL)
             if cp.returncode != 0:
@@ -216,7 +211,7 @@ class ControlMaster:
 
     def upload(self, suppress_output: bool = True) -> bool:
         cmd_prefix = self.cmd_prefix if suppress_output else self.batch_cmd_prefix
-        cmd = cmd_prefix + [self.conn_data.hostname, 'cat', '>', self.remote_path]
+        cmd = cmd_prefix + [self.conn_data.hostname, 'cat', '>', shlex.quote(self.remote_path)]
         if not suppress_output:
             print(shlex.join(cmd))
         with open(self.dest, 'rb') as f:
@@ -234,9 +229,9 @@ Result = Optional[str]
 
 
 def main(args: List[str]) -> Result:
-    msg = 'Ask the user what to do with the remote file'
+    msg = 'Ask the user what to do with the remote file. For internal use by kitty, do not run it directly.'
     try:
-        cli_opts, items = parse_args(args[1:], option_text, '', msg, 'kitty remote_file', result_class=RemoteFileCLIOptions)
+        cli_opts, items = parse_args(args[1:], option_text, '', msg, 'kitty +kitten remote_file', result_class=RemoteFileCLIOptions)
     except SystemExit as e:
         if e.code != 0:
             print(e.args[0])
@@ -273,9 +268,9 @@ def save_as(conn_data: SSHConnectionData, remote_path: str, cli_opts: RemoteFile
     )
     print('Relative paths will be resolved from:', styled(os.getcwd(), fg_intense=True, bold=True))
     print()
-    from ..tui.path_completer import PathCompleter
+    from ..tui.path_completer import get_path
     try:
-        dest = PathCompleter().input()
+        dest = get_path()
     except (KeyboardInterrupt, EOFError):
         return
     if dest: