version 0.16.0

Fixes #1526

.gitattributes

@@ -3,11 +3,11 @@ kitty/emoji.h linguist-generated=true
 kitty/keys.h linguist-generated=true
 kitty/charsets.c linguist-generated=true
 kitty/key_encoding.py linguist-generated=true
-kitty/unicode-data.c
+kitty/unicode-data.c linguist-generated=true
 kitty/rgb.py linguist-generated=true
 kitty/gl-wrapper.* linguist-generated=true
-kitty/khrplatform.h linguist-generated=true
 kitty/glfw-wrapper.* linguist-generated=true
+kitty/parse-graphics-command.h linguist-generated=true
 glfw/*.c linguist-vendored=true
 glfw/*.h linguist-vendored=true
 kittens/unicode_input/names.h linguist-generated=true

README.asciidoc

@@ -1,5 +1,5 @@
 = kitty - the fast, featureful, GPU based, terminal emulator
 
-See https://sw.kovidgoyal.net/kitty
+See https://sw.kovidgoyal.net/kitty/
 
 image:https://circleci.com/gh/kovidgoyal/kitty.svg?style=svg["Build status", link="https://circleci.com/gh/kovidgoyal/kitty"]

__main__.py

@@ -92,8 +92,10 @@ def setup_openssl_environment():
     if 'SSL_CERT_FILE' not in os.environ and 'SSL_CERT_DIR' not in os.environ:
         if os.access('/etc/pki/tls/certs/ca-bundle.crt', os.R_OK):
             os.environ['SSL_CERT_FILE'] = '/etc/pki/tls/certs/ca-bundle.crt'
+            sys.kitty_ssl_env_var = 'SSL_CERT_FILE'
         elif os.path.isdir('/etc/ssl/certs'):
             os.environ['SSL_CERT_DIR'] = '/etc/ssl/certs'
+            sys.kitty_ssl_env_var = 'SSL_CERT_DIR'
 
 
 def main():

count-lines-of-code

@@ -1,2 +1,27 @@
-#!/usr/bin/env bash
-cloc --exclude-list-file <(echo -e 'kitty/wcwidth-std.h\nkitty/glfw.c\nkitty/keys.h\nkitty/charsets.c\nkitty/unicode-data.c\nkitty/key_encoding.py\nkitty/rgb.py\nkitty/gl.h\nkitty/gl-wrapper.h\nkitty/gl-wrapper.c\nkitty/khrplatform.h\nkitty/glfw-wrapper.h\nkitty/glfw-wrapper.c\nkitty/emoji.h\nkittens/unicode_input/names.h') kitty kittens
+#!/usr/bin/env python
+
+import subprocess
+
+files_to_exclude = '''\
+kitty/wcwidth-std.h
+kitty/glfw.c
+kitty/keys.h
+kitty/charsets.c
+kitty/unicode-data.c
+kitty/key_encoding.py
+kitty/rgb.py
+kitty/gl.h
+kitty/gl-wrapper.h
+kitty/gl-wrapper.c
+kitty/glfw-wrapper.h
+kitty/glfw-wrapper.c
+kitty/emoji.h
+kittens/unicode_input/names.h
+kitty/parse-graphics-command.h
+'''
+
+p = subprocess.Popen([
+    'cloc', '--exclude-list-file', '/dev/stdin', 'kitty', 'kittens'
+], stdin=subprocess.PIPE)
+p.communicate(files_to_exclude.encode('utf-8'))
+raise SystemExit(p.wait())

docs/_static/custom.css

@@ -78,6 +78,8 @@ body div.document {
 div.sphinxsidebar {
     font-size: inherit;
     line-height: inherit;
+    max-height: 100%;
+    overflow-y: auto;
 }
 
 #sidebartoc li {

docs/build.rst

@@ -29,7 +29,7 @@ Build-time dependencies:
     * gcc or clang
     * pkg-config
     * For building on Linux in addition to the above dependencies you might also need to install the ``-dev`` packages for:
-      ``libdbus-1-dev``, ``libxcursor-dev``, ``libxrandr-dev``, ``libxi-dev``, ``libxinerama-dev``, ``libgl1-mesa-dev``, ``libxkbcommon-x11-dev``, ``libfontconfig-dev``, ``libcanberra-dev`` and ``libpython-dev``.
+      ``libdbus-1-dev``, ``libxcursor-dev``, ``libxrandr-dev``, ``libxi-dev``, ``libxinerama-dev``, ``libgl1-mesa-dev``, ``libxkbcommon-x11-dev``, ``libfontconfig-dev``, and ``libpython-dev``,
       if they are not already installed by your distro.
 
 Install and run from source

docs/changelog.rst

@@ -4,6 +4,138 @@ Changelog
 |kitty| is a feature full, cross-platform, *fast*, GPU based terminal emulator.
 To update |kitty|, :doc:`follow the instructions <binary>`.
 
+0.16.0 [2020-01-28]
+--------------------
+
+- A new :doc:`marks` feature that allows highlighting and scrolling to arbitrary
+  text in the terminal window.
+
+- hints kitten: Allow pressing :sc:`goto_file_line` to quickly open
+  the selected file at the selected line in vim or a configurable editor (:iss:`2268`)
+
+- Allow having more than one full height window in the :code:`tall` layout
+  (:iss:`2276`)
+
+- Allow choosing OpenType features for individual fonts via the
+  :opt:`font_features` option. (:pull:`2248`)
+
+- Wayland: Fix a freeze in rare circumstances when having multiple OS Windows
+  (:iss:`2307` and :iss:`1722`)
+
+- Wayland: Fix window titles being set to very long strings on the order of 8KB
+  causing a crash (:iss:`1526`)
+
+- Add an option :opt:`force_ltr` to turn off the display of text in RTL scripts
+  in right-to-left order (:pull:`2293`)
+
+- Allow opening new tabs/windows before the current tab/window as well as after
+  it with the :option:`launch --location` option.
+
+- Add a :opt:`resize_in_steps` option that can be used to resize the OS window
+  in steps as large as character cells (:pull:`2131`)
+
+- When triple-click+dragging to select multiple lines, extend the selection
+  of the first line to match the rest on the left (:pull:`2284`)
+
+- macOS: Add a :code:`titlebar-only` setting to
+  :opt:`hide_window_decorations` to only hide the title bar (:pull:`2286`)
+
+- Fix a segfault when using :option:`kitty --debug-config` with maps (:iss:`2270`)
+
+- ``goto_tab`` now maps numbers larger than the last tab to the last tab
+  (:iss:`2291`)
+
+- Fix URL detection not working for urls of the form scheme:///url
+  (:iss:`2292`)
+
+- When windows are semi-transparent and all contain graphics, correctly render
+  them. (:iss:`2310`)
+
+0.15.1 [2019-12-21]
+--------------------
+
+- Fix a crash/incorrect rendering when detaching a window in some circumstances
+  (:iss:`2173`)
+
+- hints kitten: Add an option :option:`kitty +kitten hints --ascending` to
+  control if the hints numbers increase or decrease from top to bottom
+
+- Fix :opt:`background_opacity` incorrectly applying to selected text and
+  reverse video text (:iss:`2177`)
+
+- Add a new option :opt:`tab_bar_background` to specify a different color
+  for the tab bar (:iss:`2198`)
+
+- Add a new option :opt:`active_tab_title_template` to specify a different
+  template for active tab titles (:iss:`2198`)
+
+- Fix lines at the edge of the window at certain windows sizes when drawing
+  images on a transparent window (:iss:`2079`)
+
+- Fix window not being rendered for the first time until some input has been
+  received from child process (:iss:`2216`)
+
+
+0.15.0 [2019-11-27]
+--------------------
+
+- Add a new action :ref:`detach_window <detach_window>` that can be used to move the current
+  window into a different tab (:iss:`1310`)
+
+- Add a new action :doc:`launch <launch>` that unifies launching of processes
+  in new kitty windows/tabs.
+
+- Add a new style ``powerline`` for tab bar rendering, see :opt:`tab_bar_style` (:pull:`2021`)
+
+- Allow changing colors by mapping a keyboard shortcut to read a kitty config
+  file with color definitions. See the :doc:`FAQ <faq>` for details
+  (:iss:`2083`)
+
+- hints kitten: Allow completely customizing the matching and actions performed
+  by the kitten using your own script (:iss:`2124`)
+
+- Wayland: Fix key repeat not being stopped when focus leaves window. This is
+  expected behavior on Wayland, apparently (:iss:`2014`)
+
+- When drawing unicode symbols that are followed by spaces, use multiple cells
+  to avoid resized or cut-off glyphs (:iss:`1452`)
+
+- diff kitten: Allow diffing remote files easily via ssh (:iss:`727`)
+
+- unicode input kitten: Add an option :option:`kitty +kitten unicode_input
+  --emoji-variation` to control the presentation variant of selected emojis
+  (:iss:`2139`)
+
+- Add specialised rendering for a few more box powerline and unicode symbols
+  (:pull:`2074` and :pull:`2021`)
+
+- Add a new socket only mode for :opt:`allow_remote_control`. This makes
+  it possible for programs running on the local machine to control kitty
+  but not programs running over ssh.
+
+- hints kitten: Allow using named groups in the regular expression. The named
+  groups are passed to the invoked program for further processing.
+
+- Fix a regression in 0.14.5 that caused rendering of private use glyphs
+  with and without spaces to be identical (:iss:`2117`)
+
+- Wayland: Fix incorrect scale used when first creating an OS window
+  (:iss:`2133`)
+
+- macOS: Disable mouse hiding by default as getting it to work robustly
+  on Cocoa is too much effort (:iss:`2158`)
+
+
+0.14.6 [2019-09-25]
+---------------------
+
+- macOS: Fix a regression in the previous release that caused a crash when
+  pressing a unprintable key, such as the POWER key (:iss:`1997`)
+
+- Fix a regression in the previous release that caused kitty to not always
+  respond to DPI changes (:pull:`1999`)
+
+
 0.14.5 [2019-09-23]
 ---------------------
 

docs/conf.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
+# vim:fileencoding=utf-8
 #
 # Configuration file for the Sphinx documentation builder.
 #
@@ -243,7 +243,17 @@ def add_html_context(app, pagename, templatename, context, *args):
 
 # CLI docs {{{
 def write_cli_docs(all_kitten_names):
+    from kitty.launch import options_spec as launch_options_spec
     from kitty.cli import option_spec_as_rst
+    with open('generated/launch.rst', 'w') as f:
+        f.write(option_spec_as_rst(
+            appname='launch', ospec=launch_options_spec, heading_char='_',
+            message='''\
+Launch an arbitrary program in a new kitty window/tab. Note that
+if you specify a program-to-run you can use the special placeholder
+:code:`@selection` which will be replaced by the current selection.
+'''
+        ))
     with open('generated/cli-kitty.rst', 'w') as f:
         f.write(option_spec_as_rst(appname='kitty').replace(
             'kitty --to', 'kitty @ --to'))

docs/faq.rst

@@ -109,8 +109,13 @@ How do I change the colors in a running kitty instance?
 
 You can either use the
 `OSC terminal escape codes <https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-Operating-System-Commands>`_
-to set colors or you can enable :doc:`remote control <remote-control>`
-for |kitty| and use :ref:`at_set-colors`.
+to set colors or you can 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`.
 
 A list of pre-made color themes for kitty is available at:
 `kitty-themes <https://github.com/dexpota/kitty-themes>`_
@@ -184,6 +189,11 @@ following :file:`~/.config/fontconfig/fonts.conf`::
     </match>
     </fontconfig>
 
+After creating (or modifying) this file, you may need to run the following
+command to rebuild your fontconfig cache::
+
+    fc-cache -r
+
 Then, the font will be available in ``kitty list-fonts``.
 
 

docs/graphics-protocol.rst

@@ -334,7 +334,9 @@ Finally, you can specify the image *z-index*, i.e. the vertical stacking order.
 placed in the same location with different z-index values will be blended if
 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.
+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.
 
 Deleting images
 ---------------------
@@ -417,7 +419,7 @@ Key      Value                 Default    Description
 ``Y``    Positive integer      ``0``      The y-offset within the first cell at which to start displaying the image
 ``c``    Positive integer      ``0``      The number of columns to display the image over
 ``r``    Positive integer      ``0``      The number of rows to display the image over
-``z``    Integer               ``0``      The *z-index* vertical stacking order of the image
+``z``    32-bit integer        ``0``      The *z-index* vertical stacking order of the image
 **Keys for deleting images**
 -----------------------------------------------------------
 ``d``    Single character.     ``a``      What to delete.

docs/index.rst

@@ -53,13 +53,13 @@ Quickstart
 --------------
 
 Pre-built binaries of |kitty| are available for both macOS and Linux.
-See the :doc:`binary install instructions </binary>`. You can also
+See the :doc:`binary install instructions </binary>`. You can
 :doc:`build from source </build>`.
 
 You can also use your favorite package manager to install the |kitty| package.
 |kitty| packages are available for:
 `macOS with Homebrew (Cask) <https://formulae.brew.sh/cask/kitty>`_,
-`macOS and Linux with Nix <https://nixos.org/nixos/packages.html#kitty>`_,
+`macOS and Linux with Nix <https://nixos.org/nixos/packages.html?channel=nixpkgs-unstable&query=kitty>`_,
 `Ubuntu <https://launchpad.net/ubuntu/+source/kitty>`_,
 `Debian <https://packages.debian.org/buster/kitty>`_,
 `openSUSE <https://build.opensuse.org/package/show/X11:terminals/kitty>`_,
@@ -173,6 +173,19 @@ You can also define a shortcut to switch to the previously active window::
 ``nth_window`` will focus the nth window for positive numbers and the
 previously active windows for negative numbers.
 
+.. _detach_window:
+
+You can define shortcuts to detach the current window and
+move it to another tab or another OS window::
+
+    map ctrl+f2 detach_window         # moves the window into a new OS window
+    map ctrl+f3 detach_window new-tab # moves the window into a new Tab
+    map ctrl+f4 detach_window ask     # asks which tab to move the window into
+
+Similarly, you can detach the current tab, with::
+
+    map ctrl+f2 detach_tab         # moves the tab into a new OS window
+    map ctrl+f4 detach_tab ask     # asks which OS Window to move the tab into
 
 Other keyboard shortcuts
 ----------------------------------
@@ -211,11 +224,11 @@ using the :sc:`new_window` key combination.
 
 Currently, there are five layouts available,
 
-* **Stack** -- Only a single maximized window is shown at a time
-* **Tall** -- One window is shown full height on the left, the rest of the windows are shown one below the other on the right
-* **Fat** -- One window is shown full width on the top, the rest of the windows are shown side-by-side on the bottom
+* **Fat** -- One (or optionally more) windows are shown full width on the top, the rest of the windows are shown side-by-side on the bottom
 * **Grid** -- All windows are shown in a grid
 * **Horizontal** -- All windows are shown side-by-side
+* **Stack** -- Only a single maximized window is shown at a time
+* **Tall** -- One (or optionally more) windows are shown full height on the left, the rest of the windows are shown one below the other on the right
 * **Vertical** -- All windows are shown one below the other
 
 You can switch between layouts using the :sc:`next_layout` key combination. You can
@@ -243,13 +256,15 @@ the resizing increment (a positive integer that defaults to 1).
 
 
 Some layouts take options to control their behavior. For example, the ``fat``
-and ``tall`` layouts accept the ``bias`` option to control how the available
-space is split up. To specify the option, in :opt:`kitty.conf <enabled_layouts>` use::
+and ``tall`` layouts accept the ``bias`` and ``full_size`` options to control
+how the available space is split up.
+To specify the option, in :opt:`kitty.conf <enabled_layouts>` use::
 
-    enabled_layouts tall:bias=70
+    enabled_layouts tall:bias=70;full_size=2
 
-This will make the tall window occupy ``70%`` of available width. ``bias`` can be
-any number between 10 and 90.
+This will have ``2`` instead of a single tall window, that occupy ``70%``
+instead of ``50%`` of available width. ``bias`` can be any number between 10
+and 90.
 
 Writing a new layout only requires about a hundred lines of code, so if there
 is some layout you want, take a look at `layout.py
@@ -402,7 +417,7 @@ comfortably within the pager.
 Additionally, you can pipe the contents of the scrollback buffer to an
 arbitrary, command running in a new window, tab or overlay, for example::
 
-   map f1 pipe @ansi window less +G -R
+   map f1 launch --stdin-source=@screen_scrollback --stdin-add-formatting less +G -R
 
 Would open the scrollback buffer in a new window when you press the :kbd:`F1`
 key. See :sc:`show_scrollback` for details.
@@ -428,6 +443,14 @@ internal buffer named ``a`` and :kbd:`F2` to paste from that buffer. The buffer
 names are arbitrary strings, so you can define as many such buffers as you
 need.
 
+Marks
+-------------
+
+kitty has the ability to mark text on the screen based on regular expressions.
+This can be useful to highlight words or phrases when browsing output from long
+running programs or similar. To learn how this feature works, see :doc:`marks`.
+
+
 Frequently Asked Questions
 ---------------------------------
 
@@ -478,7 +501,8 @@ completions happens after the call to :file:`compinit`.
 fish
 ~~~~~~~~
 
-Add the following to your :file:`~/.config/fish/config.fish`
+For versions of fish earlier than 3.0.0, add the following to your
+:file:`~/.config/fish/config.fish`. Later versions source completions by default.
 
 .. code-block:: sh
 

docs/kittens/custom.rst

@@ -128,7 +128,27 @@ layout, by simply adding the line::
     boss.toggle_fullscreen()
 
 
-to the ``handle_result()`` function, above.
+To the ``handle_result()`` function, above.
+
+
+Debugging kittens
+--------------------
+
+The part of the kitten that runs in ``main()`` is just a normal program and
+the output of print statements will be visible in the kitten window. Or
+alternately, you can use::
+
+    from kittens.tui.loop import debug
+    debug('whatever')
+
+The ``debug()`` function is just like ``print()`` except that the output
+will appear in the ``STDOUT`` of the kitty process inside which the kitten is
+running.
+
+The ``handle_result()`` part of the kitten runs inside the kitty process.
+The output of print statements will go to the ``STDOUT`` of the kitty process.
+So if you run kitty from another kitty instance, the output will be visible
+in the first kitty instance.
 
 .. _external_kittens:
 

docs/kittens/hints.rst

@@ -18,11 +18,71 @@ select anything that looks like a path or filename and then insert it into the
 terminal, very useful for picking files from the output of a ``git`` or ``ls`` command and
 adding them to the command line for the next command.
 
+You can also press :sc:`goto_file_line` to select anything that looks
+like a path or filename followed by a colon and a line number and open
+the file in vim at the specified line number. The patterns and editor
+to be used can be modified using options passed to the kitten. For example::
+
+    map ctrl+g kitten hints --type=linenum --linenum-action=tab nvim +{line} +{path}
+
+will open the selected file in a new tab inside neovim when you press
+:kbd:`ctrl+g`.
+
 The hints kitten is very powerful to see more detailed help on its various
 options and modes of operation, see below. You can use these options to
 create mappings in :file:`kitty.conf` to select various different text
 snippets. See :sc:`insert_selected_path` for examples.
 
+Completely customizing the matching and actions of the kitten
+---------------------------------------------------------------
+
+The hints kitten supports writing simple python scripts that can be used to
+completely customize how it finds matches and what happens when a match is
+selected. This allows the hints kitten to provide the user interface, while
+you can provide the logic for finding matches and performing actions on them.
+This is best illustrated with an example. Create the file
+:file:`custom-hints.py` in the kitty config directory with the following
+contents:
+
+.. code-block:: python
+
+    import re
+
+    def mark(text, args, Mark, extra_cli_args, *a):
+        # This function is responsible for finding all
+        # matching text. extra_cli_args are any extra arguments
+        # passed on the command line when invoking the kitten.
+        # We mark all individual word for potential selection
+        for idx, m in enumerate(re.finditer(r'\w+', text)):
+            start, end = m.span()
+            mark_text = text[start:end].replace('\n', '').replace('\0', '')
+            # The empty dictionary below will be available as groupdicts
+            # in handle_result() and can contain arbitrary data.
+            yield Mark(idx, start, end, mark_text, {})
+
+
+    def handle_result(args, data, target_window_id, boss, extra_cli_args, *a):
+        # This function is responsible for performing some
+        # action on the selected text.
+        # matches is a list of the selected entries and groupdicts contains
+        # the arbitrary data associated with each entry in mark() above
+        matches, groupdicts = [], []
+        for m, g in zip(data['match'], data['groupdicts']):
+            if m:
+                matches.append(m), groupdicts.append(g)
+        for word, match_data in zip(matches, groupdicts):
+            # Lookup the word in a dictionary, the open_url function
+            # will open the provided url in the system browser
+            boss.open_url(f'https://www.google.com/search?q=define:{word}')
+
+Now run kitty with::
+
+    kitty -o 'map f1 kitten hints --customize-processing custom-hints.py'
+
+When you press the :kbd:`F1` key you will be able to select a word to
+look it up in the Google dictionary.
+
+
 Command Line Interface
 -------------------------
 

docs/kittens/unicode-input.rst

@@ -22,3 +22,8 @@ In :guilabel:`Name` mode you instead type words from the character name and use
 keys/tab to select the character from the displayed matches. You can also type
 a leading period and the index for the match if you don't like to use arrow
 keys.
+
+Command Line Interface
+-------------------------
+
+.. include:: ../generated/cli-kitten-unicode_input.rst

docs/launch.rst

@@ -0,0 +1,56 @@
+Launching programs in new windows/tabs
+========================================
+
+.. program:: launch
+
+
+|kitty| has a :code:`launch` action that can be used to run arbitrary programs
+in news windows/tabs. It can be mapped to user defined shortcuts in kitty.conf.
+It is very powerful and allows sending the contents of
+the current window to the launched program, as well as many other options.
+
+In the simplest form, you can use it to open a new kitty window running the
+shell, as shown below::
+
+    map f1 launch
+
+To run a different program simply pass the command line as arguments to
+launch::
+
+    map f1 launch vim path/to/some/file
+
+
+To open a new window with the same working directory as the currently
+active window::
+
+    map f1 launch --cwd=current
+
+To open the new window in a new tab::
+
+    map f1 launch --type=tab
+
+To pass the contents of the current screen and scrollback to the started process::
+
+    map f1 launch --stdin-source=@screen_scrollback less
+
+There are many more powerful options, refer to the complete list below.
+
+The piping environment
+--------------------------
+
+When using :option:`launch --stdin-source`, the program to which the data is
+piped has a special environment variable declared, ``KITTY_PIPE_DATA`` whose
+contents are::
+
+   KITTY_PIPE_DATA={scrolled_by}:{cursor_x},{cursor_y}:{lines},{columns}
+
+where ``scrolled_by`` is the number of lines kitty is currently scrolled by,
+``cursor_(x|y)`` is the position of the cursor on the screen with ``(1,1)``
+being the top left corner and ``{lines},{columns}`` being the number of rows
+and columns of the screen.
+
+
+Syntax reference
+------------------
+
+.. include:: /generated/launch.rst

docs/marks.rst

@@ -0,0 +1,122 @@
+Marks
+=================
+
+
+kitty has the ability to mark text on the screen based on regular expressions.
+This can be useful to highlight words or phrases when browsing output from long
+running programs or similar. Lets start with a few examples:
+
+Suppose we want to be able to highlight the word ERROR in the current window.
+Add the following to :file:`kitty.conf`::
+
+    map f1 toggle_marker text 1 ERROR
+
+Now when you press :kbd:`F1` all instances of the word :code:`ERROR` will be
+highlighted. To turn off the highlighting, press :kbd:`F1` again.
+If you want to make it case-insensitive, use::
+
+    map f1 toggle_marker itext 1 ERROR
+
+To make it match only complete words, use::
+
+    map f1 toggle_marker regex 1 \bERROR\b
+
+Suppose you want to highlight both :code:`ERROR` and :code:`WARNING`, case
+insensitively::
+
+    map f1 toggle_marker iregex 1 \bERROR\b 2 \bWARNING\b
+
+kitty supports up to 3 mark groups (the numbers in the commands above). You
+can control the colors used for these groups in :file:`kitty.conf` with::
+
+    mark1_foreground red
+    mark1_background gray
+    mark2_foreground green
+    ...
+
+
+.. note::
+    For performance reasons, matching is done per line only, and only when that line is
+    altered in any way. So you cannot match text that stretches across multiple
+    lines.
+
+
+Creating markers dynamically
+---------------------------------
+
+If you want to create markers dynamically rather than pre-defining them in
+:file:`kitty.conf` you can do so as follows::
+
+    map f1 create_marker
+    map f2 remove_marker
+
+Then pressing :kbd:`F1` will allow you to enter the marker definition and set
+it and pressing :kbd:`F2` will remove the marker.
+
+You can also use the facilities for :doc:`remote-control` to dynamically
+add/remove markers.
+
+
+Scrolling to marks
+--------------------
+
+kitty has an action to scroll to the next line that contains a mark. You can
+use it by mapping it to some shortcut in :file:`kitty.conf`::
+
+    map ctrl+p scroll_to_mark prev
+    map ctrl+n scroll_to_mark next
+
+Then pressing :kbd:`ctrl+p` will scroll to the first line in the scrollback
+buffer above the current top line that contains a mark. Pressing :kbd:`ctrl+n`
+will scroll to show the first line below the current last line that contains
+a mark. If you wish to jump to a mark of a specific type, you can add that to
+the mapping::
+
+    map ctrl+1 scroll_to_mark prev 1
+
+Which will scroll only to marks of type 1.
+
+
+The full syntax for creating marks
+-------------------------------------
+
+The syntax of the :code:`toggle_marker` command is::
+
+    toggle_marker <marker-type> <specification>
+
+Here :code:`marker-type` is one of:
+
+    * :code:`text` - simple substring matching
+    * :code:`itext` - case-insensitive substring matching
+    * :code:`regex` - A python regular expression
+    * :code:`iregex` - A case-insensitive python regular expression
+    * :code:`function` - An arbitrary function defined in a python file, see
+      :ref:`marker_funcs`.
+
+.. _marker_funcs:
+
+Arbitrary marker functions
+-----------------------------
+
+You can create your own marker functions. Create a python file named
+:file:`mymarker.py` and in it create a :code:`marker` function. This
+function receives the text of the line as input and must yield three numbers,
+the starting character position, the ending character position and the mark
+group (1-3). For example:
+
+.. code-block::
+
+    def marker(text):
+        # Function to highlight the letter X
+        for i, ch in enumerate(text):
+            if ch.lower() == 'x':
+                yield i, i, 3
+
+
+Save this file somewhere and in :file:`kitty.conf`, use::
+
+    map f1 toggle_marker function /path/to/mymarker.py
+
+If you save the file in the kitty config directory, you can use::
+
+    map f1 toggle_marker function mymarker.py

docs/pipe.rst

@@ -1,6 +1,9 @@
 Working with the screen and history buffer contents
 ======================================================
 
+.. warning::
+    The pipe action has been deprecated in favor of the
+    :doc:`launch <launch>` action which is more powerful.
 
 You can pipe the contents of the current screen and history buffer as
 :file:`STDIN` to an arbitrary program using the ``pipe`` function. The program
@@ -56,6 +59,9 @@ Input placeholders
 
 There are various different kinds of placeholders
 
+``@selection``
+   Plain text, currently selected text
+
 ``@text``
    Plain text, current screen + scrollback buffer
 

docs/remote-control.rst

@@ -126,7 +126,7 @@ If you do not want to allow all programs running in |kitty| to control it, you c
 enable remote control for only some |kitty| windows. Simply create a shortcut
 such as::
 
-    map ctrl+k new_window @ some_program
+    map ctrl+k launch --allow-remote-control some_program
 
 Then programs running in windows created with that shortcut can use ``kitty @``
 to control kitty. Note that any program with the right level of permissions can

gen-wcwidth.py

@@ -43,6 +43,7 @@ def get_data(fname, folder='UCD'):
 
 # Map of class names to set of codepoints in class
 class_maps = {}
+all_symbols = set()
 name_map = {}
 word_search_map = defaultdict(set)
 zwj = 0x200d
@@ -89,6 +90,8 @@ def parse_ucd():
             not_assigned.discard(codepoint)
             if category.startswith('M'):
                 marks.add(codepoint)
+            elif category.startswith('S'):
+                all_symbols.add(codepoint)
 
     # Some common synonyms
     word_search_map['bee'] |= word_search_map['honeybee']
@@ -194,6 +197,7 @@ def gen_emoji():
         p('\t\tdefault: return false;')
         p('\t}')
         p('\treturn false;\n}')
+
         p('static inline bool\nis_emoji_modifier(char_type code) {')
         p('\tswitch(code) {')
         for spec in get_ranges(list(emoji_categories['Emoji_Modifier'])):
@@ -203,6 +207,15 @@ def gen_emoji():
         p('\t}')
         p('\treturn false;\n}')
 
+        p('static inline bool\nis_symbol(char_type code) {')
+        p('\tswitch(code) {')
+        for spec in get_ranges(list(all_symbols)):
+            write_case(spec, p)
+            p('\t\t\treturn true;')
+        p('\t\tdefault: return false;')
+        p('\t}')
+        p('\treturn false;\n}')
+
 
 def category_test(name, p, classes, comment, static=False, extra_chars=frozenset(), exclude=frozenset()):
     static = 'static inline ' if static else ''

glfw/backend_utils.c

@@ -22,19 +22,6 @@
 #define ppoll pollts
 #endif
 
-static inline double
-monotonic(void) {
-    struct timespec ts = {0};
-#ifdef CLOCK_HIGHRES
-    clock_gettime(CLOCK_HIGHRES, &ts);
-#elif CLOCK_MONOTONIC_RAW
-    clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
-#else
-    clock_gettime(CLOCK_MONOTONIC, &ts);
-#endif
-    return (((double)ts.tv_nsec) / 1e9) + (double)ts.tv_sec;
-}
-
 void
 update_fds(EventLoopData *eld) {
     for (nfds_t i = 0; i < eld->watches_count; i++) {
@@ -109,7 +96,7 @@ update_timers(EventLoopData *eld) {
 }
 
 id_type
-addTimer(EventLoopData *eld, const char *name, double interval, int enabled, bool repeats, timer_callback_func cb, void *cb_data, GLFWuserdatafreefun free) {
+addTimer(EventLoopData *eld, const char *name, monotonic_t interval, int enabled, bool repeats, timer_callback_func cb, void *cb_data, GLFWuserdatafreefun free) {
     if (eld->timers_count >= sizeof(eld->timers)/sizeof(eld->timers[0])) {
         _glfwInputError(GLFW_PLATFORM_ERROR, "Too many timers added");
         return 0;
@@ -117,7 +104,7 @@ addTimer(EventLoopData *eld, const char *name, double interval, int enabled, boo
     Timer *t = eld->timers + eld->timers_count++;
     t->interval = interval;
     t->name = name;
-    t->trigger_at = enabled ? monotonic() + interval : DBL_MAX;
+    t->trigger_at = enabled ? monotonic() + interval : MONOTONIC_T_MAX;
     t->repeats = repeats;
     t->callback = cb;
     t->callback_data = cb_data;
@@ -144,7 +131,7 @@ void
 toggleTimer(EventLoopData *eld, id_type timer_id, int enabled) {
     for (nfds_t i = 0; i < eld->timers_count; i++) {
         if (eld->timers[i].id == timer_id) {
-            double trigger_at = enabled ? (monotonic() + eld->timers[i].interval) : DBL_MAX;
+            monotonic_t trigger_at = enabled ? (monotonic() + eld->timers[i].interval) : MONOTONIC_T_MAX;
             if (trigger_at != eld->timers[i].trigger_at) {
                 eld->timers[i].trigger_at = trigger_at;
                 update_timers(eld);
@@ -155,7 +142,7 @@ toggleTimer(EventLoopData *eld, id_type timer_id, int enabled) {
 }
 
 void
-changeTimerInterval(EventLoopData *eld, id_type timer_id, double interval) {
+changeTimerInterval(EventLoopData *eld, id_type timer_id, monotonic_t interval) {
     for (nfds_t i = 0; i < eld->timers_count; i++) {
         if (eld->timers[i].id == timer_id) {
             eld->timers[i].interval = interval;
@@ -165,22 +152,28 @@ changeTimerInterval(EventLoopData *eld, id_type timer_id, double interval) {
 }
 
 
-double
-prepareForPoll(EventLoopData *eld, double timeout) {
+monotonic_t
+prepareForPoll(EventLoopData *eld, monotonic_t timeout) {
     for (nfds_t i = 0; i < eld->watches_count; i++) eld->fds[i].revents = 0;
-    if (!eld->timers_count || eld->timers[0].trigger_at == DBL_MAX) return timeout;
-    double now = monotonic(), next_repeat_at = eld->timers[0].trigger_at;
+    if (!eld->timers_count || eld->timers[0].trigger_at == MONOTONIC_T_MAX) return timeout;
+    monotonic_t now = monotonic(), next_repeat_at = eld->timers[0].trigger_at;
     if (timeout < 0 || now + timeout > next_repeat_at) {
         timeout = next_repeat_at <= now ? 0 : next_repeat_at - now;
     }
     return timeout;
 }
 
+static inline struct timespec
+calc_time(monotonic_t nsec) {
+    struct timespec result;
+    result.tv_sec  = nsec / (1000LL * 1000LL * 1000LL);
+    result.tv_nsec = nsec % (1000LL * 1000LL * 1000LL);
+    return result;
+}
+
 int
-pollWithTimeout(struct pollfd *fds, nfds_t nfds, double timeout) {
-    const long seconds = (long) timeout;
-    const long nanoseconds = (long) ((timeout - seconds) * 1e9);
-    struct timespec tv = { seconds, nanoseconds };
+pollWithTimeout(struct pollfd *fds, nfds_t nfds, monotonic_t timeout) {
+    struct timespec tv = calc_time(timeout);
     return ppoll(fds, nfds, &tv, NULL);
 }
 
@@ -198,10 +191,10 @@ dispatchEvents(EventLoopData *eld) {
 
 unsigned
 dispatchTimers(EventLoopData *eld) {
-    if (!eld->timers_count || eld->timers[0].trigger_at == DBL_MAX) return 0;
+    if (!eld->timers_count || eld->timers[0].trigger_at == MONOTONIC_T_MAX) return 0;
     static struct { timer_callback_func func; id_type id; void* data; bool repeats; } dispatches[sizeof(eld->timers)/sizeof(eld->timers[0])];
     unsigned num_dispatches = 0;
-    double now = monotonic();
+    monotonic_t now = monotonic();
     for (nfds_t i = 0; i < eld->timers_count && eld->timers[i].trigger_at <= now; i++) {
         eld->timers[i].trigger_at = now + eld->timers[i].interval;
         dispatches[num_dispatches].func = eld->timers[i].callback;
@@ -299,12 +292,12 @@ finalizePollData(EventLoopData *eld) {
 }
 
 int
-pollForEvents(EventLoopData *eld, double timeout) {
+pollForEvents(EventLoopData *eld, monotonic_t timeout, watch_callback_func display_callback) {
     int read_ok = 0;
     timeout = prepareForPoll(eld, timeout);
-    EVDBG("pollForEvents final timeout: %.3f", timeout);
+    EVDBG("pollForEvents final timeout: %.3f", monotonic_t_to_s_double(timeout));
     int result;
-    double end_time = monotonic() + timeout;
+    monotonic_t end_time = monotonic() + timeout;
     eld->wakeup_fd_ready = false;
 
     while(1) {
@@ -312,6 +305,7 @@ pollForEvents(EventLoopData *eld, double timeout) {
             errno = 0;
             result = pollWithTimeout(eld->fds, eld->watches_count, timeout);
             int saved_errno = errno;
+            if (display_callback) display_callback(result, eld->fds[0].revents && eld->watches[0].events, NULL);
             dispatchTimers(eld);
             if (result > 0) {
                 dispatchEvents(eld);
@@ -326,6 +320,7 @@ pollForEvents(EventLoopData *eld, double timeout) {
             errno = 0;
             result = poll(eld->fds, eld->watches_count, -1);
             int saved_errno = errno;
+            if (display_callback) display_callback(result, eld->fds[0].revents && eld->watches[0].events, NULL);
             dispatchTimers(eld);
             if (result > 0) {
                 dispatchEvents(eld);

glfw/backend_utils.h

@@ -25,6 +25,7 @@
 //========================================================================
 
 #pragma once
+#include "../kitty/monotonic.h"
 #include <poll.h>
 #include <unistd.h>
 #include <stdbool.h>
@@ -55,7 +56,7 @@ typedef struct {
 
 typedef struct {
     id_type id;
-    double interval, trigger_at;
+    monotonic_t interval, trigger_at;
     timer_callback_func callback;
     void *callback_data;
     GLFWuserdatafreefun free;
@@ -82,14 +83,14 @@ void check_for_wakeup_events(EventLoopData *eld);
 id_type addWatch(EventLoopData *eld, const char *name, int fd, int events, int enabled, watch_callback_func cb, void *cb_data);
 void removeWatch(EventLoopData *eld, id_type watch_id);
 void toggleWatch(EventLoopData *eld, id_type watch_id, int enabled);
-id_type addTimer(EventLoopData *eld, const char *name, double interval, int enabled, bool repeats, timer_callback_func cb, void *cb_data, GLFWuserdatafreefun free);
+id_type addTimer(EventLoopData *eld, const char *name, monotonic_t interval, int enabled, bool repeats, timer_callback_func cb, void *cb_data, GLFWuserdatafreefun free);
 void removeTimer(EventLoopData *eld, id_type timer_id);
 void removeAllTimers(EventLoopData *eld);
 void toggleTimer(EventLoopData *eld, id_type timer_id, int enabled);
-void changeTimerInterval(EventLoopData *eld, id_type timer_id, double interval);
-double prepareForPoll(EventLoopData *eld, double timeout);
-int pollWithTimeout(struct pollfd *fds, nfds_t nfds, double timeout);
-int pollForEvents(EventLoopData *eld, double timeout);
+void changeTimerInterval(EventLoopData *eld, id_type timer_id, monotonic_t interval);
+monotonic_t prepareForPoll(EventLoopData *eld, monotonic_t timeout);
+int pollWithTimeout(struct pollfd *fds, nfds_t nfds, monotonic_t timeout);
+int pollForEvents(EventLoopData *eld, monotonic_t timeout, watch_callback_func);
 unsigned dispatchTimers(EventLoopData *eld);
 void finalizePollData(EventLoopData *eld);
 bool initPollData(EventLoopData *eld, int display_fd);

glfw/cocoa_init.m

@@ -27,9 +27,13 @@
 //========================================================================
 
 #include "internal.h"
+#include "../kitty/monotonic.h"
 #include <sys/param.h> // For MAXPATHLEN
 #include <pthread.h>
 
+// Needed for _NSGetProgname
+#include <crt_externs.h>
+
 // Change to our application bundle's resources directory, if present
 //
 static void changeToResourcesDirectory(void)
@@ -66,14 +70,119 @@ static void changeToResourcesDirectory(void)
     chdir(resourcesPath);
 }
 
+// Set up the menu bar (manually)
+// This is nasty, nasty stuff -- calls to undocumented semi-private APIs that
+// could go away at any moment, lots of stuff that really should be
+// localize(d|able), etc.  Add a nib to save us this horror.
+//
+static void createMenuBar(void)
+{
+    size_t i;
+    NSString* appName = nil;
+    NSDictionary* bundleInfo = [[NSBundle mainBundle] infoDictionary];
+    NSString* nameKeys[] =
+    {
+        @"CFBundleDisplayName",
+        @"CFBundleName",
+        @"CFBundleExecutable",
+    };
+
+    // Try to figure out what the calling application is called
+
+    for (i = 0;  i < sizeof(nameKeys) / sizeof(nameKeys[0]);  i++)
+    {
+        id name = bundleInfo[nameKeys[i]];
+        if (name &&
+            [name isKindOfClass:[NSString class]] &&
+            ![name isEqualToString:@""])
+        {
+            appName = name;
+            break;
+        }
+    }
+
+    if (!appName)
+    {
+        char** progname = _NSGetProgname();
+        if (progname && *progname)
+            appName = @(*progname);
+        else
+            appName = @"GLFW Application";
+    }
+
+    NSMenu* bar = [[NSMenu alloc] init];
+    [NSApp setMainMenu:bar];
+
+    NSMenuItem* appMenuItem =
+        [bar addItemWithTitle:@"" action:NULL keyEquivalent:@""];
+    NSMenu* appMenu = [[NSMenu alloc] init];
+    [appMenuItem setSubmenu:appMenu];
+
+    [appMenu addItemWithTitle:[NSString stringWithFormat:@"About %@", appName]
+                       action:@selector(orderFrontStandardAboutPanel:)
+                keyEquivalent:@""];
+    [appMenu addItem:[NSMenuItem separatorItem]];
+    NSMenu* servicesMenu = [[NSMenu alloc] init];
+    [NSApp setServicesMenu:servicesMenu];
+    [[appMenu addItemWithTitle:@"Services"
+                       action:NULL
+                keyEquivalent:@""] setSubmenu:servicesMenu];
+    [servicesMenu release];
+    [appMenu addItem:[NSMenuItem separatorItem]];
+    [appMenu addItemWithTitle:[NSString stringWithFormat:@"Hide %@", appName]
+                       action:@selector(hide:)
+                keyEquivalent:@"h"];
+    [[appMenu addItemWithTitle:@"Hide Others"
+                       action:@selector(hideOtherApplications:)
+                keyEquivalent:@"h"]
+        setKeyEquivalentModifierMask:NSEventModifierFlagOption | NSEventModifierFlagCommand];
+    [appMenu addItemWithTitle:@"Show All"
+                       action:@selector(unhideAllApplications:)
+                keyEquivalent:@""];
+    [appMenu addItem:[NSMenuItem separatorItem]];
+    [appMenu addItemWithTitle:[NSString stringWithFormat:@"Quit %@", appName]
+                       action:@selector(terminate:)
+                keyEquivalent:@"q"];
+
+    NSMenuItem* windowMenuItem =
+        [bar addItemWithTitle:@"" action:NULL keyEquivalent:@""];
+    [bar release];
+    NSMenu* windowMenu = [[NSMenu alloc] initWithTitle:@"Window"];
+    [NSApp setWindowsMenu:windowMenu];
+    [windowMenuItem setSubmenu:windowMenu];
+
+    [windowMenu addItemWithTitle:@"Minimize"
+                          action:@selector(performMiniaturize:)
+                   keyEquivalent:@"m"];
+    [windowMenu addItemWithTitle:@"Zoom"
+                          action:@selector(performZoom:)
+                   keyEquivalent:@""];
+    [windowMenu addItem:[NSMenuItem separatorItem]];
+    [windowMenu addItemWithTitle:@"Bring All to Front"
+                          action:@selector(arrangeInFront:)
+                   keyEquivalent:@""];
+
+    // TODO: Make this appear at the bottom of the menu (for consistency)
+    [windowMenu addItem:[NSMenuItem separatorItem]];
+    [[windowMenu addItemWithTitle:@"Enter Full Screen"
+                           action:@selector(toggleFullScreen:)
+                    keyEquivalent:@"f"]
+     setKeyEquivalentModifierMask:NSEventModifierFlagControl | NSEventModifierFlagCommand];
+
+    // Prior to Snow Leopard, we need to use this oddly-named semi-private API
+    // to get the application menu working properly.
+    SEL setAppleMenuSelector = NSSelectorFromString(@"setAppleMenu:");
+    [NSApp performSelector:setAppleMenuSelector withObject:appMenu];
+}
+
 // Create key code translation tables
 //
 static void createKeyTables(void)
 {
-    int scancode;
+    int keycode;
 
     memset(_glfw.ns.keycodes, -1, sizeof(_glfw.ns.keycodes));
-    memset(_glfw.ns.scancodes, -1, sizeof(_glfw.ns.scancodes));
+    memset(_glfw.ns.key_to_keycode, -1, sizeof(_glfw.ns.key_to_keycode));
 
     _glfw.ns.keycodes[0x1D] = GLFW_KEY_0;
     _glfw.ns.keycodes[0x12] = GLFW_KEY_1;
@@ -190,11 +299,11 @@ static void createKeyTables(void)
     _glfw.ns.keycodes[0x43] = GLFW_KEY_KP_MULTIPLY;
     _glfw.ns.keycodes[0x4E] = GLFW_KEY_KP_SUBTRACT;
 
-    for (scancode = 0;  scancode < 256;  scancode++)
+    for (keycode = 0; keycode < 256; keycode++)
     {
         // Store the reverse translation for faster key name lookup
-        if (_glfw.ns.keycodes[scancode] >= 0)
-            _glfw.ns.scancodes[_glfw.ns.keycodes[scancode]] = scancode;
+        if (_glfw.ns.keycodes[keycode] >= 0)
+            _glfw.ns.key_to_keycode[_glfw.ns.keycodes[keycode]] = keycode;
     }
 }
 
@@ -276,6 +385,17 @@ static bool initializeTIS(void)
     return updateUnicodeDataNS();
 }
 
+static void
+display_reconfigured(CGDirectDisplayID display UNUSED, CGDisplayChangeSummaryFlags flags, void *userInfo UNUSED)
+{
+    if (flags & kCGDisplayBeginConfigurationFlag) {
+        return;
+    }
+    if (flags & kCGDisplaySetModeFlag) {
+        // GPU possibly changed
+    }
+}
+
 @interface GLFWHelper : NSObject
 @end
 
@@ -294,6 +414,102 @@ static bool initializeTIS(void)
 
 @end // GLFWHelper
 
+// Delegate for application related notifications {{{
+
+@interface GLFWApplicationDelegate : NSObject <NSApplicationDelegate>
+@end
+
+@implementation GLFWApplicationDelegate
+
+- (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)sender
+{
+    (void)sender;
+    _GLFWwindow* window;
+
+    for (window = _glfw.windowListHead;  window;  window = window->next)
+        _glfwInputWindowCloseRequest(window);
+
+    return NSTerminateCancel;
+}
+
+static GLFWapplicationshouldhandlereopenfun handle_reopen_callback = NULL;
+
+- (BOOL)applicationShouldHandleReopen:(NSApplication *)sender hasVisibleWindows:(BOOL)flag
+{
+    (void)sender;
+    if (!handle_reopen_callback) return YES;
+    if (handle_reopen_callback(flag)) return YES;
+    return NO;
+}
+
+- (void)applicationDidChangeScreenParameters:(NSNotification *) notification
+{
+    (void)notification;
+    _GLFWwindow* window;
+
+    for (window = _glfw.windowListHead;  window;  window = window->next)
+    {
+        if (window->context.client != GLFW_NO_API)
+            [window->context.nsgl.object update];
+    }
+
+    _glfwPollMonitorsNS();
+}
+
+static GLFWapplicationwillfinishlaunchingfun finish_launching_callback = NULL;
+
+- (void)applicationWillFinishLaunching:(NSNotification *)notification
+{
+    (void)notification;
+    if (_glfw.hints.init.ns.menubar)
+    {
+        // In case we are unbundled, make us a proper UI application
+        [NSApp setActivationPolicy:NSApplicationActivationPolicyRegular];
+
+        // Menu bar setup must go between sharedApplication and finishLaunching
+        // in order to properly emulate the behavior of NSApplicationMain
+
+        if ([[NSBundle mainBundle] pathForResource:@"MainMenu" ofType:@"nib"])
+        {
+            [[NSBundle mainBundle] loadNibNamed:@"MainMenu"
+                                          owner:NSApp
+                                topLevelObjects:&_glfw.ns.nibObjects];
+        }
+        else
+            createMenuBar();
+    }
+    if (finish_launching_callback)
+        finish_launching_callback();
+}
+
+- (void)applicationDidFinishLaunching:(NSNotification *)notification
+{
+    (void)notification;
+    [NSApp stop:nil];
+
+    CGDisplayRegisterReconfigurationCallback(display_reconfigured, NULL);
+    _glfwCocoaPostEmptyEvent();
+}
+
+- (void)applicationWillTerminate:(NSNotification *)aNotification
+{
+    (void)aNotification;
+    CGDisplayRemoveReconfigurationCallback(display_reconfigured, NULL);
+}
+
+- (void)applicationDidHide:(NSNotification *)notification
+{
+    (void)notification;
+    int i;
+
+    for (i = 0;  i < _glfw.monitorCount;  i++)
+        _glfwRestoreVideoModeNS(_glfw.monitors[i]);
+}
+
+@end // GLFWApplicationDelegate
+// }}}
+
+
 @interface GLFWApplication : NSApplication
 - (void)tick_callback;
 - (void)render_frame_received:(id)displayIDAsID;
@@ -313,6 +529,32 @@ static bool initializeTIS(void)
 @end
 
 
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+void* _glfwLoadLocalVulkanLoaderNS(void)
+{
+    CFBundleRef bundle = CFBundleGetMainBundle();
+    if (!bundle)
+        return NULL;
+
+    CFURLRef url =
+        CFBundleCopyAuxiliaryExecutableURL(bundle, CFSTR("libvulkan.1.dylib"));
+    if (!url)
+        return NULL;
+
+    char path[PATH_MAX];
+    void* handle = NULL;
+
+    if (CFURLGetFileSystemRepresentation(url, true, (UInt8*) path, sizeof(path) - 1))
+        handle = _glfw_dlopen(path);
+
+    CFRelease(url);
+    return handle;
+}
+
+
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW platform API                      //////
 //////////////////////////////////////////////////////////////////////////
@@ -335,6 +577,18 @@ is_cmd_period(NSEvent *event, NSEventModifierFlags modifierFlags) {
     return false;
 }
 
+GLFWAPI GLFWapplicationshouldhandlereopenfun glfwSetApplicationShouldHandleReopen(GLFWapplicationshouldhandlereopenfun callback) {
+    GLFWapplicationshouldhandlereopenfun previous = handle_reopen_callback;
+    handle_reopen_callback = callback;
+    return previous;
+}
+
+GLFWAPI GLFWapplicationwillfinishlaunchingfun glfwSetApplicationWillFinishLaunching(GLFWapplicationwillfinishlaunchingfun callback) {
+    GLFWapplicationwillfinishlaunchingfun previous = finish_launching_callback;
+    finish_launching_callback = callback;
+    return previous;
+}
+
 int _glfwPlatformInit(void)
 {
     @autoreleasepool {
@@ -345,8 +599,21 @@ int _glfwPlatformInit(void)
                              toTarget:_glfw.ns.helper
                            withObject:nil];
 
+    if (NSApp)
+        _glfw.ns.finishedLaunching = true;
+
     [GLFWApplication sharedApplication];
 
+    _glfw.ns.delegate = [[GLFWApplicationDelegate alloc] init];
+    if (_glfw.ns.delegate == nil)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Cocoa: Failed to create application delegate");
+        return false;
+    }
+
+    [NSApp setDelegate:_glfw.ns.delegate];
+
     NSEvent* (^keydown_block)(NSEvent*) = ^ NSEvent* (NSEvent* event)
     {
         NSEventModifierFlags modifierFlags = [event modifierFlags] & NSEventModifierFlagDeviceIndependentFlagsMask;
@@ -385,6 +652,10 @@ int _glfwPlatformInit(void)
     if (_glfw.hints.init.ns.chdir)
         changeToResourcesDirectory();
 
+    // Press and Hold prevents some keys from emitting repeated characters
+    NSDictionary* defaults = @{@"ApplePressAndHoldEnabled":@NO};
+    [[NSUserDefaults standardUserDefaults] registerDefaults:defaults];
+
     [[NSNotificationCenter defaultCenter]
         addObserver:_glfw.ns.helper
            selector:@selector(selectedKeyboardInputSourceChanged:)
@@ -402,7 +673,6 @@ int _glfwPlatformInit(void)
     if (!initializeTIS())
         return false;
 
-    _glfwInitTimerNS();
     _glfwInitJoysticksNS();
 
     _glfwPollMonitorsNS();
@@ -531,7 +801,7 @@ typedef struct {
     NSTimer *os_timer;
     unsigned long long id;
     bool repeats;
-    double interval;
+    monotonic_t interval;
     GLFWuserdatafun callback;
     void *callback_data;
     GLFWuserdatafun free_callback_data;
@@ -551,7 +821,7 @@ remove_timer_at(size_t idx) {
 }
 
 static void schedule_timer(Timer *t) {
-    t->os_timer = [NSTimer scheduledTimerWithTimeInterval:t->interval repeats:(t->repeats ? YES: NO) block:^(NSTimer *os_timer) {
+    t->os_timer = [NSTimer scheduledTimerWithTimeInterval:monotonic_t_to_s_double(t->interval) repeats:(t->repeats ? YES: NO) block:^(NSTimer *os_timer) {
         for (size_t i = 0; i < num_timers; i++) {
             if (timers[i].os_timer == os_timer) {
                 timers[i].callback(timers[i].id, timers[i].callback_data);
@@ -562,7 +832,7 @@ static void schedule_timer(Timer *t) {
     }];
 }
 
-unsigned long long _glfwPlatformAddTimer(double interval, bool repeats, GLFWuserdatafun callback, void *callback_data, GLFWuserdatafun free_callback) {
+unsigned long long _glfwPlatformAddTimer(monotonic_t interval, bool repeats, GLFWuserdatafun callback, void *callback_data, GLFWuserdatafun free_callback) {
     static unsigned long long timer_counter = 0;
     if (num_timers >= sizeof(timers)/sizeof(timers[0]) - 1) {
         _glfwInputError(GLFW_PLATFORM_ERROR, "Too many timers added");
@@ -588,7 +858,7 @@ void _glfwPlatformRemoveTimer(unsigned long long timer_id) {
     }
 }
 
-void _glfwPlatformUpdateTimer(unsigned long long timer_id, double interval, bool enabled) {
+void _glfwPlatformUpdateTimer(unsigned long long timer_id, monotonic_t interval, bool enabled) {
     for (size_t i = 0; i < num_timers; i++) {
         if (timers[i].id == timer_id) {
             Timer *t = timers + i;

glfw/cocoa_monitor.m

@@ -146,7 +146,7 @@ static bool modeIsGood(CGDisplayModeRef mode)
 // Convert Core Graphics display mode to GLFW video mode
 //
 static GLFWvidmode vidmodeFromCGDisplayMode(CGDisplayModeRef mode,
-                                            CVDisplayLinkRef link)
+                                            double fallbackRefreshRate)
 {
     GLFWvidmode result;
     result.width = (int) CGDisplayModeGetWidth(mode);
@@ -154,11 +154,7 @@ static GLFWvidmode vidmodeFromCGDisplayMode(CGDisplayModeRef mode,
     result.refreshRate = (int) round(CGDisplayModeGetRefreshRate(mode));
 
     if (result.refreshRate == 0)
-    {
-        const CVTime time = CVDisplayLinkGetNominalOutputVideoRefreshPeriod(link);
-        if (!(time.flags & kCVTimeIsIndefinite))
-            result.refreshRate = (int) (time.timeScale / (double) time.timeValue);
-    }
+        result.refreshRate = (int) round(fallbackRefreshRate);
 
 #if MAC_OS_X_VERSION_MAX_ALLOWED <= 101100
     CFStringRef format = CGDisplayModeCopyPixelEncoding(mode);
@@ -240,6 +236,30 @@ static bool refreshMonitorScreen(_GLFWmonitor* monitor)
     return false;
 }
 
+// Returns a fallback refresh rate for when Core Graphics says it is zero
+//
+static double getFallbackRefreshRate(_GLFWmonitor* monitor)
+{
+    CGDisplayModeRef mode = CGDisplayCopyDisplayMode(monitor->ns.displayID);
+    double refreshRate = CGDisplayModeGetRefreshRate(mode);
+    CGDisplayModeRelease(mode);
+
+    if (refreshRate == 0.0)
+    {
+        CVDisplayLinkRef link = NULL;
+        CVDisplayLinkCreateWithCGDisplay(monitor->ns.displayID, &link);
+
+        const CVTime time = CVDisplayLinkGetNominalOutputVideoRefreshPeriod(link);
+        if (!(time.flags & kCVTimeIsIndefinite))
+            refreshRate = (int) (time.timeScale / (double) time.timeValue);
+
+        CVDisplayLinkRelease(link);
+    }
+
+    return refreshRate;
+}
+
+
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
@@ -328,9 +348,10 @@ void _glfwPollMonitorsNS(void)
         if (!name)
             name = _glfw_strdup("Unknown");
 
-        _GLFWmonitor* monitor = _glfwAllocMonitor(name, size.width, size.height);
+        _GLFWmonitor* monitor = _glfwAllocMonitor(name, (int)size.width, (int)size.height);
         monitor->ns.displayID  = displays[i];
         monitor->ns.unitNumber = unitNumber;
+        monitor->ns.fallbackRefreshRate = getFallbackRefreshRate(monitor);
         createDisplayLink(monitor->ns.displayID);
 
         free(name);
@@ -354,14 +375,12 @@ void _glfwPollMonitorsNS(void)
 void _glfwSetVideoModeNS(_GLFWmonitor* monitor, const GLFWvidmode* desired)
 {
     GLFWvidmode current;
-    const GLFWvidmode* best = _glfwChooseVideoMode(monitor, desired);
     _glfwPlatformGetVideoMode(monitor, &current);
+
+    const GLFWvidmode* best = _glfwChooseVideoMode(monitor, desired);
     if (_glfwCompareVideoModes(&current, best) == 0)
         return;
 
-    CVDisplayLinkRef link;
-    CVDisplayLinkCreateWithCGDisplay(monitor->ns.displayID, &link);
-
     CFArrayRef modes = CGDisplayCopyAllDisplayModes(monitor->ns.displayID, NULL);
     const CFIndex count = CFArrayGetCount(modes);
     CGDisplayModeRef native = NULL;
@@ -372,7 +391,8 @@ void _glfwSetVideoModeNS(_GLFWmonitor* monitor, const GLFWvidmode* desired)
         if (!modeIsGood(dm))
             continue;
 
-        const GLFWvidmode mode = vidmodeFromCGDisplayMode(dm, link);
+        const GLFWvidmode mode =
+            vidmodeFromCGDisplayMode(dm, monitor->ns.fallbackRefreshRate);
         if (_glfwCompareVideoModes(best, &mode) == 0)
         {
             native = dm;
@@ -391,7 +411,6 @@ void _glfwSetVideoModeNS(_GLFWmonitor* monitor, const GLFWvidmode* desired)
     }
 
     CFRelease(modes);
-    CVDisplayLinkRelease(link);
 }
 
 // Restore the previously saved (original) video mode
@@ -454,13 +473,13 @@ void _glfwPlatformGetMonitorWorkarea(_GLFWmonitor* monitor,
     const NSRect frameRect = [monitor->ns.screen visibleFrame];
 
     if (xpos)
-        *xpos = frameRect.origin.x;
+        *xpos = (int)frameRect.origin.x;
     if (ypos)
-        *ypos = _glfwTransformYNS(frameRect.origin.y + frameRect.size.height - 1);
+        *ypos = (int)_glfwTransformYNS(frameRect.origin.y + frameRect.size.height - 1);
     if (width)
-        *width = frameRect.size.width;
+        *width = (int)frameRect.size.width;
     if (height)
-        *height = frameRect.size.height;
+        *height = (int)frameRect.size.height;
 
 }
 
@@ -468,9 +487,6 @@ GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* count)
 {
     *count = 0;
 
-    CVDisplayLinkRef link;
-    CVDisplayLinkCreateWithCGDisplay(monitor->ns.displayID, &link);
-
     CFArrayRef modes = CGDisplayCopyAllDisplayModes(monitor->ns.displayID, NULL);
     const CFIndex found = CFArrayGetCount(modes);
     GLFWvidmode* result = calloc(found, sizeof(GLFWvidmode));
@@ -481,7 +497,8 @@ GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* count)
         if (!modeIsGood(dm))
             continue;
 
-        const GLFWvidmode mode = vidmodeFromCGDisplayMode(dm, link);
+        const GLFWvidmode mode =
+            vidmodeFromCGDisplayMode(dm, monitor->ns.fallbackRefreshRate);
 
         for (CFIndex j = 0;  j < *count;  j++)
         {
@@ -498,21 +515,14 @@ GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* count)
     }
 
     CFRelease(modes);
-    CVDisplayLinkRelease(link);
     return result;
 }
 
 void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode *mode)
 {
-    CVDisplayLinkRef link;
-
-    CVDisplayLinkCreateWithCGDisplay(monitor->ns.displayID, &link);
-
     CGDisplayModeRef native = CGDisplayCopyDisplayMode(monitor->ns.displayID);
-    *mode = vidmodeFromCGDisplayMode(native, link);
+    *mode = vidmodeFromCGDisplayMode(native, monitor->ns.fallbackRefreshRate);
     CGDisplayModeRelease(native);
-
-    CVDisplayLinkRelease(link);
 }
 
 bool _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)

glfw/cocoa_platform.h

@@ -36,6 +36,9 @@ typedef void* id;
 typedef void* CVDisplayLinkRef;
 #endif
 
+// NOTE: Many Cocoa enum values have been renamed and we need to build across
+//       SDK versions where one is unavailable or the other deprecated
+//       We use the newer names in code and these macros to handle compatibility
 #if MAC_OS_X_VERSION_MAX_ALLOWED < 101200
  #define NSBitmapFormatAlphaNonpremultiplied NSAlphaNonpremultipliedBitmapFormat
  #define NSEventMaskAny NSAnyEventMask
@@ -62,12 +65,15 @@ typedef void* CVDisplayLinkRef;
 #endif
 
 
-typedef VkFlags VkMacOSSurfaceCreateFlagsMVK;
 typedef int (* GLFWcocoatextinputfilterfun)(int,int,unsigned int, unsigned long);
-typedef int (* GLFWapplicationshouldhandlereopenfun)(int);
-typedef int (* GLFWcocoatogglefullscreenfun)(GLFWwindow*);
+typedef bool (* GLFWapplicationshouldhandlereopenfun)(int);
+typedef void (* GLFWapplicationwillfinishlaunchingfun)(void);
+typedef bool (* GLFWcocoatogglefullscreenfun)(GLFWwindow*);
 typedef void (* GLFWcocoarenderframefun)(GLFWwindow*);
 
+typedef VkFlags VkMacOSSurfaceCreateFlagsMVK;
+typedef VkFlags VkMetalSurfaceCreateFlagsEXT;
+
 typedef struct VkMacOSSurfaceCreateInfoMVK
 {
     VkStructureType                 sType;
@@ -76,7 +82,16 @@ typedef struct VkMacOSSurfaceCreateInfoMVK
     const void*                     pView;
 } VkMacOSSurfaceCreateInfoMVK;
 
+typedef struct VkMetalSurfaceCreateInfoEXT
+{
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkMetalSurfaceCreateFlagsEXT    flags;
+    const void*                     pLayer;
+} VkMetalSurfaceCreateInfoEXT;
+
 typedef VkResult (APIENTRY *PFN_vkCreateMacOSSurfaceMVK)(VkInstance,const VkMacOSSurfaceCreateInfoMVK*,const VkAllocationCallbacks*,VkSurfaceKHR*);
+typedef VkResult (APIENTRY *PFN_vkCreateMetalSurfaceEXT)(VkInstance,const VkMetalSurfaceCreateInfoEXT*,const VkAllocationCallbacks*,VkSurfaceKHR*);
 
 #include "posix_thread.h"
 #include "cocoa_joystick.h"
@@ -144,7 +159,7 @@ typedef struct _GLFWDisplayLinkNS
 {
     CVDisplayLinkRef displayLink;
     CGDirectDisplayID displayID;
-    double lastRenderFrameRequestedAt;
+    monotonic_t lastRenderFrameRequestedAt;
 } _GLFWDisplayLinkNS;
 
 // Cocoa-specific global data
@@ -153,6 +168,7 @@ typedef struct _GLFWlibraryNS
 {
     CGEventSourceRef    eventSource;
     id                  delegate;
+    bool                finishedLaunching;
     bool                cursorHidden;
     TISInputSourceRef   inputSource;
     IOHIDManagerRef     hidManager;
@@ -160,11 +176,12 @@ typedef struct _GLFWlibraryNS
     id                  helper;
     id                  keyUpMonitor;
     id                  keyDownMonitor;
+    id                  nibObjects;
 
     char                keyName[64];
     char                text[256];
     short int           keycodes[256];
-    short int           scancodes[GLFW_KEY_LAST + 1];
+    short int           key_to_keycode[GLFW_KEY_LAST + 1];
     char*               clipboardString;
     CGPoint             cascadePoint;
     // Where to place the cursor when re-enabled
@@ -195,6 +212,7 @@ typedef struct _GLFWmonitorNS
     CGDisplayModeRef    previousMode;
     uint32_t            unitNumber;
     id                  screen;
+    double              fallbackRefreshRate;
 
 } _GLFWmonitorNS;
 
@@ -215,14 +233,14 @@ typedef struct _GLFWtimerNS
 } _GLFWtimerNS;
 
 
-void _glfwInitTimerNS(void);
-
 void _glfwPollMonitorsNS(void);
 void _glfwSetVideoModeNS(_GLFWmonitor* monitor, const GLFWvidmode* desired);
 void _glfwRestoreVideoModeNS(_GLFWmonitor* monitor);
 
 float _glfwTransformYNS(float y);
 
+void* _glfwLoadLocalVulkanLoaderNS(void);
+
 void _glfwClearDisplayLinks(void);
 void _glfwRestartDisplayLinks(void);
 void _glfwDispatchTickCallback(void);

glfw/cocoa_time.c

@@ -1,62 +0,0 @@
-//========================================================================
-// GLFW 3.4 macOS - www.glfw.org
-//------------------------------------------------------------------------
-// Copyright (c) 2009-2016 Camilla Löwy <elmindreda@glfw.org>
-//
-// This software is provided 'as-is', without any express or implied
-// warranty. In no event will the authors be held liable for any damages
-// arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it
-// freely, subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented; you must not
-//    claim that you wrote the original software. If you use this software
-//    in a product, an acknowledgment in the product documentation would
-//    be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such, and must not
-//    be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source
-//    distribution.
-//
-//========================================================================
-// It is fine to use C99 in this file because it will not be built with VS
-//========================================================================
-
-#include "internal.h"
-
-#include <mach/mach_time.h>
-
-
-//////////////////////////////////////////////////////////////////////////
-//////                       GLFW internal API                      //////
-//////////////////////////////////////////////////////////////////////////
-
-// Initialise timer
-//
-void _glfwInitTimerNS(void)
-{
-    mach_timebase_info_data_t info;
-    mach_timebase_info(&info);
-
-    _glfw.timer.ns.frequency = (info.denom * 1e9) / info.numer;
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-//////                       GLFW platform API                      //////
-//////////////////////////////////////////////////////////////////////////
-
-uint64_t _glfwPlatformGetTimerValue(void)
-{
-    return mach_absolute_time();
-}
-
-uint64_t _glfwPlatformGetTimerFrequency(void)
-{
-    return _glfw.timer.ns.frequency;
-}
-

glfw/dbus_glfw.c

@@ -27,6 +27,7 @@
 
 #include "internal.h"
 #include "dbus_glfw.h"
+#include "../kitty/monotonic.h"
 #include <stdlib.h>
 #include <string.h>
 
@@ -107,7 +108,7 @@ on_dbus_timer_ready(id_type timer_id UNUSED, void *data) {
 static dbus_bool_t
 add_dbus_timeout(DBusTimeout *timeout, void *data) {
     int enabled = dbus_timeout_get_enabled(timeout) ? 1 : 0;
-    double interval = ((double)dbus_timeout_get_interval(timeout)) / 1000.0;
+    monotonic_t interval = ms_to_monotonic_t(dbus_timeout_get_interval(timeout));
     if (interval < 0) return FALSE;
     id_type timer_id = addTimer(dbus_data->eld, data, interval, enabled, true, on_dbus_timer_ready, timeout, NULL);
     if (!timer_id) return FALSE;

glfw/egl_context.c

@@ -123,23 +123,24 @@ static bool chooseEGLConfig(const _GLFWctxconfig* ctxconfig,
             continue;
 
 #if defined(_GLFW_X11)
-        XVisualInfo vi = {0};
-
-        // Only consider EGLConfigs with associated Visuals
-        vi.visualid = getEGLConfigAttrib(n, EGL_NATIVE_VISUAL_ID);
-        if (!vi.visualid)
-            continue;
-
-        if (desired->transparent)
         {
-            int count;
-            XVisualInfo* vis = XGetVisualInfo(_glfw.x11.display,
-                                              VisualIDMask, &vi,
-                                              &count);
-            if (vis)
+            XVisualInfo vi = {0};
+
+            // Only consider EGLConfigs with associated Visuals
+            vi.visualid = getEGLConfigAttrib(n, EGL_NATIVE_VISUAL_ID);
+            if (!vi.visualid)
+                continue;
+
+            if (desired->transparent)
             {
-                u->transparent = _glfwIsVisualTransparentX11(vis[0].visual);
-                XFree(vis);
+                int count;
+                XVisualInfo* vis =
+                    XGetVisualInfo(_glfw.x11.display, VisualIDMask, &vi, &count);
+                if (vis)
+                {
+                    u->transparent = _glfwIsVisualTransparentX11(vis[0].visual);
+                    XFree(vis);
+                }
             }
         }
 #endif // _GLFW_X11

glfw/glfw.py

@@ -165,13 +165,14 @@ def generate_wrappers(glfw_header):
     GLFWcocoatextinputfilterfun glfwSetCocoaTextInputFilter(GLFWwindow* window, GLFWcocoatextinputfilterfun callback)
     GLFWcocoatogglefullscreenfun glfwSetCocoaToggleFullscreenIntercept(GLFWwindow *window, GLFWcocoatogglefullscreenfun callback)
     GLFWapplicationshouldhandlereopenfun glfwSetApplicationShouldHandleReopen(GLFWapplicationshouldhandlereopenfun callback)
-    void glfwGetCocoaKeyEquivalent(int glfw_key, int glfw_mods, void* cocoa_key, void* cocoa_mods)
+    GLFWapplicationwillfinishlaunchingfun glfwSetApplicationWillFinishLaunching(GLFWapplicationwillfinishlaunchingfun callback)
+    void glfwGetCocoaKeyEquivalent(int glfw_key, int glfw_mods, char* cocoa_key, size_t key_sz, int* cocoa_mods)
     void glfwCocoaRequestRenderFrame(GLFWwindow *w, GLFWcocoarenderframefun callback)
     void* glfwGetX11Display(void)
     int32_t glfwGetX11Window(GLFWwindow* window)
     void glfwSetPrimarySelectionString(GLFWwindow* window, const char* string)
     const char* glfwGetPrimarySelectionString(GLFWwindow* window, void)
-    int glfwGetXKBScancode(const char* key_name, int case_sensitive)
+    int glfwGetNativeKeyForName(const char* key_name, int case_sensitive)
     void glfwRequestWaylandFrameEvent(GLFWwindow *handle, unsigned long long id, GLFWwaylandframecallbackfunc callback)
     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)
@@ -185,15 +186,23 @@ const char *action_text, int32_t timeout, GLFWDBusnotificationcreatedfun callbac
     p = src.find('*/', p)
     preamble = src[p + 2:first]
     header = '''\
+//
+// THIS FILE IS GENERATED BY glfw.py
+//
+// SAVE YOURSELF SOME TIME, DO NOT MANUALLY EDIT
+//
+
 #pragma once
 #include <stddef.h>
 #include <stdint.h>
+#include "monotonic.h"
 
 {}
 
 typedef int (* GLFWcocoatextinputfilterfun)(int,int,unsigned int,unsigned long);
-typedef int (* GLFWapplicationshouldhandlereopenfun)(int);
-typedef int (* GLFWcocoatogglefullscreenfun)(GLFWwindow*);
+typedef bool (* GLFWapplicationshouldhandlereopenfun)(int);
+typedef void (* GLFWapplicationwillfinishlaunchingfun)(void);
+typedef bool (* GLFWcocoatogglefullscreenfun)(GLFWwindow*);
 typedef void (* GLFWcocoarenderframefun)(GLFWwindow*);
 typedef void (*GLFWwaylandframecallbackfunc)(unsigned long long id);
 typedef void (*GLFWDBusnotificationcreatedfun)(unsigned long long, uint32_t, void*);

glfw/ibus_glfw.c

@@ -107,10 +107,14 @@ get_ibus_text_from_message(DBusMessage *msg) {
 }
 
 static inline void
-send_text(const char *text, int state) {
+send_text(const char *text, int ime_state) {
     _GLFWwindow *w = _glfwFocusedWindow();
     if (w && w->callbacks.keyboard) {
-        w->callbacks.keyboard((GLFWwindow*) w, GLFW_KEY_UNKNOWN, 0, GLFW_PRESS, 0, text, state);
+        GLFWkeyevent fake_ev;
+        _glfwInitializeKeyEvent(&fake_ev, GLFW_KEY_UNKNOWN, 0, GLFW_PRESS, 0);
+        fake_ev.text = text;
+        fake_ev.ime_state = ime_state;
+        w->callbacks.keyboard((GLFWwindow*) w, &fake_ev);
     }
 }
 
@@ -393,31 +397,36 @@ ibus_key_state(unsigned int glfw_modifiers, int action) {
 void
 key_event_processed(DBusMessage *msg, const char* errmsg, void *data) {
     uint32_t handled = 0;
-    KeyEvent *ev = (KeyEvent*)data;
-    bool is_release = ev->action == GLFW_RELEASE;
+    _GLFWIBUSKeyEvent *ev = (_GLFWIBUSKeyEvent*)data;
+    // Restore key's text from the text embedded in the structure.
+    ev->glfw_ev.text = ev->__embedded_text;
+    bool is_release = ev->glfw_ev.action == GLFW_RELEASE;
     bool failed = false;
     if (errmsg) {
         _glfwInputError(GLFW_PLATFORM_ERROR, "IBUS: Failed to process key with error: %s", errmsg);
         failed = true;
     } else {
         glfw_dbus_get_args(msg, "Failed to get IBUS handled key from reply", DBUS_TYPE_BOOLEAN, &handled, DBUS_TYPE_INVALID);
-        debug("IBUS processed scancode: 0x%x release: %d handled: %u\n", ev->keycode, is_release, handled);
+        debug("IBUS processed native_key: 0x%x release: %d handled: %u\n", ev->glfw_ev.native_key, is_release, handled);
     }
     glfw_xkb_key_from_ime(ev, handled ? true : false, failed);
     free(ev);
 }
 
 bool
-ibus_process_key(const KeyEvent *ev_, _GLFWIBUSData *ibus) {
+ibus_process_key(const _GLFWIBUSKeyEvent *ev_, _GLFWIBUSData *ibus) {
     if (!check_connection(ibus)) return false;
-    KeyEvent *ev = malloc(sizeof(KeyEvent));
+    _GLFWIBUSKeyEvent *ev = calloc(1, sizeof(_GLFWIBUSKeyEvent));
     if (!ev) return false;
-    memcpy(ev, ev_, sizeof(KeyEvent));
-    uint32_t state = ibus_key_state(ev->glfw_modifiers, ev->action);
+    memcpy(ev, ev_, sizeof(_GLFWIBUSKeyEvent));
+    // Put the key's text in a field IN the structure, for proper serialization.
+    if (ev->glfw_ev.text) strncpy(ev->__embedded_text, ev->glfw_ev.text, sizeof(ev->__embedded_text) - 1);
+    ev->glfw_ev.text = NULL;
+    uint32_t state = ibus_key_state(ev->glfw_ev.mods, ev->glfw_ev.action);
     if (!glfw_dbus_call_method_with_reply(
             ibus->conn, IBUS_SERVICE, ibus->input_ctx_path, IBUS_INPUT_INTERFACE, "ProcessKeyEvent",
             3000, key_event_processed, ev,
-            DBUS_TYPE_UINT32, &ev->ibus_sym, DBUS_TYPE_UINT32, &ev->ibus_keycode, DBUS_TYPE_UINT32,
+            DBUS_TYPE_UINT32, &ev->ibus_keysym, DBUS_TYPE_UINT32, &ev->ibus_keycode, DBUS_TYPE_UINT32,
             &state, DBUS_TYPE_INVALID)) {
         free(ev);
         return false;

glfw/ibus_glfw.h

@@ -27,6 +27,7 @@
 
 #pragma once
 
+#include "internal.h"
 #include "dbus_glfw.h"
 #include <xkbcommon/xkbcommon.h>
 
@@ -38,18 +39,16 @@ typedef struct {
 } _GLFWIBUSData;
 
 typedef struct {
-    xkb_keycode_t keycode, ibus_keycode;
-    xkb_keysym_t keysym, ibus_sym;
-    unsigned int glfw_modifiers;
-    int action;
+    xkb_keycode_t ibus_keycode;
+    xkb_keysym_t ibus_keysym;
     GLFWid window_id;
-    int glfw_keycode;
-    char text[64];
-} KeyEvent;
+    GLFWkeyevent glfw_ev;
+    char __embedded_text[64];
+} _GLFWIBUSKeyEvent;
 
 void glfw_connect_to_ibus(_GLFWIBUSData *ibus);
 void glfw_ibus_terminate(_GLFWIBUSData *ibus);
 void glfw_ibus_set_focused(_GLFWIBUSData *ibus, bool focused);
 void glfw_ibus_dispatch(_GLFWIBUSData *ibus);
-bool ibus_process_key(const KeyEvent *ev_, _GLFWIBUSData *ibus);
+bool ibus_process_key(const _GLFWIBUSKeyEvent *ev_, _GLFWIBUSData *ibus);
 void glfw_ibus_set_cursor_geometry(_GLFWIBUSData *ibus, int x, int y, int w, int h);

glfw/init.c

@@ -201,7 +201,7 @@ _glfwDebug(const char *format, ...) {
     {
         va_list vl;
 
-        fprintf(stderr, "[%.4f] ", glfwGetTime());
+        fprintf(stderr, "[%.4f] ", monotonic_t_to_s_double(glfwGetTime()));
         va_start(vl, format);
         vfprintf(stderr, format, vl);
         va_end(vl);
@@ -214,10 +214,11 @@ _glfwDebug(const char *format, ...) {
 //////                        GLFW public API                       //////
 //////////////////////////////////////////////////////////////////////////
 
-GLFWAPI int glfwInit(void)
+GLFWAPI int glfwInit(monotonic_t start_time)
 {
     if (_glfw.initialized)
         return true;
+    monotonic_start_time = start_time;
 
     memset(&_glfw, 0, sizeof(_glfw));
     _glfw.hints.init = _glfwInitHints;
@@ -239,7 +240,6 @@ GLFWAPI int glfwInit(void)
     _glfwPlatformSetTls(&_glfw.errorSlot, &_glfwMainThreadError);
 
     _glfw.initialized = true;
-    _glfw.timer.offset = _glfwPlatformGetTimerValue();
 
     glfwDefaultWindowHints();
 
@@ -350,13 +350,13 @@ GLFWAPI void glfwStopMainLoop(void) {
 }
 
 GLFWAPI unsigned long long glfwAddTimer(
-        double interval, bool repeats, GLFWuserdatafun callback,
+        monotonic_t interval, bool repeats, GLFWuserdatafun callback,
         void *callback_data, GLFWuserdatafun free_callback)
 {
     return _glfwPlatformAddTimer(interval, repeats, callback, callback_data, free_callback);
 }
 
-GLFWAPI void glfwUpdateTimer(unsigned long long timer_id, double interval, bool enabled) {
+GLFWAPI void glfwUpdateTimer(unsigned long long timer_id, monotonic_t interval, bool enabled) {
     _glfwPlatformUpdateTimer(timer_id, interval, enabled);
 }
 

glfw/input.c

@@ -28,6 +28,7 @@
 //========================================================================
 
 #include "internal.h"
+#include "../kitty/monotonic.h"
 
 #include <assert.h>
 #include <float.h>
@@ -256,33 +257,44 @@ static bool parseMapping(_GLFWmapping* mapping, const char* string)
 //////                         GLFW event API                       //////
 //////////////////////////////////////////////////////////////////////////
 
+void _glfwInitializeKeyEvent(GLFWkeyevent *ev, int key, int native_key, int action, int mods)
+{
+    ev->key = key;
+    ev->native_key = native_key;
+    ev->action = action;
+    ev->mods = mods;
+    ev->text = NULL;
+    ev->ime_state = 0;
+}
+
 // Notifies shared code of a physical key event
 //
-void _glfwInputKeyboard(_GLFWwindow* window, int key, int scancode, int action, int mods, const char* text, int state)
+void _glfwInputKeyboard(_GLFWwindow* window, GLFWkeyevent* ev)
 {
-    if (key >= 0 && key <= GLFW_KEY_LAST)
+    if (ev->key >= 0 && ev->key <= GLFW_KEY_LAST)
     {
         bool repeated = false;
 
-        if (action == GLFW_RELEASE && window->keys[key] == GLFW_RELEASE)
+        if (ev->action == GLFW_RELEASE && window->keys[ev->key] == GLFW_RELEASE)
             return;
 
-        if (action == GLFW_PRESS && window->keys[key] == GLFW_PRESS)
+        if (ev->action == GLFW_PRESS && window->keys[ev->key] == GLFW_PRESS)
             repeated = true;
 
-        if (action == GLFW_RELEASE && window->stickyKeys)
-            window->keys[key] = _GLFW_STICK;
+        if (ev->action == GLFW_RELEASE && window->stickyKeys)
+            window->keys[ev->key] = _GLFW_STICK;
         else
-            window->keys[key] = (char) action;
+            window->keys[ev->key] = (char) ev->action;
 
         if (repeated)
-            action = GLFW_REPEAT;
+            ev->action = GLFW_REPEAT;
     }
 
 
+    // FIXME: will need to update ev->virtual_mods here too?
     if (window->callbacks.keyboard) {
-        if (!window->lockKeyMods) mods &= ~(GLFW_MOD_CAPS_LOCK | GLFW_MOD_NUM_LOCK);
-        window->callbacks.keyboard((GLFWwindow*) window, key, scancode, action, mods, text, state);
+        if (!window->lockKeyMods) ev->mods &= ~(GLFW_MOD_CAPS_LOCK | GLFW_MOD_NUM_LOCK);
+        window->callbacks.keyboard((GLFWwindow*) window, ev);
     }
 }
 
@@ -498,6 +510,7 @@ const char* _glfwGetKeyName(int key)
         case GLFW_KEY_LEFT_BRACKET:       return "LEFT_BRACKET";
         case GLFW_KEY_BACKSLASH:          return "BACKSLASH";
         case GLFW_KEY_RIGHT_BRACKET:      return "RIGHT_BRACKET";
+        case GLFW_KEY_CIRCUMFLEX:         return "CIRCUMFLEX";
         case GLFW_KEY_UNDERSCORE:         return "UNDERSCORE";
         case GLFW_KEY_GRAVE_ACCENT:       return "GRAVE_ACCENT";
         case GLFW_KEY_WORLD_1:            return "WORLD_1";
@@ -744,7 +757,7 @@ GLFWAPI void glfwSetInputMode(GLFWwindow* handle, int mode, int value)
         _glfwInputError(GLFW_INVALID_ENUM, "Invalid input mode 0x%08X", mode);
 }
 
-GLFWAPI const char* glfwGetKeyName(int key, int scancode)
+GLFWAPI const char* glfwGetKeyName(int key, int native_key)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
@@ -757,13 +770,13 @@ GLFWAPI const char* glfwGetKeyName(int key, int scancode)
             return NULL;
         }
 
-        scancode = _glfwPlatformGetKeyScancode(key);
+        native_key = _glfwPlatformGetNativeKeyForKey(key);
     }
 
-    return _glfwPlatformGetScancodeName(scancode);
+    return _glfwPlatformGetNativeKeyName(native_key);
 }
 
-GLFWAPI int glfwGetKeyScancode(int key)
+GLFWAPI int glfwGetNativeKeyForKey(int key)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(-1);
 
@@ -773,7 +786,7 @@ GLFWAPI int glfwGetKeyScancode(int key)
         return GLFW_RELEASE;
     }
 
-    return _glfwPlatformGetKeyScancode(key);
+    return _glfwPlatformGetNativeKeyForKey(key);
 }
 
 GLFWAPI int glfwGetKey(GLFWwindow* handle, int key)
@@ -1466,35 +1479,8 @@ GLFWAPI const char* glfwGetPrimarySelectionString(GLFWwindow* handle UNUSED)
 }
 #endif
 
-GLFWAPI double glfwGetTime(void)
-{
-    _GLFW_REQUIRE_INIT_OR_RETURN(0.0);
-    return (double) (_glfwPlatformGetTimerValue() - _glfw.timer.offset) /
-        _glfwPlatformGetTimerFrequency();
-}
-
-GLFWAPI void glfwSetTime(double time)
-{
-    _GLFW_REQUIRE_INIT();
-
-    if (time != time || time < 0.0 || time > 18446744073.0)
-    {
-        _glfwInputError(GLFW_INVALID_VALUE, "Invalid time %f", time);
-        return;
-    }
-
-    _glfw.timer.offset = _glfwPlatformGetTimerValue() -
-        (uint64_t) (time * _glfwPlatformGetTimerFrequency());
-}
-
-GLFWAPI uint64_t glfwGetTimerValue(void)
+GLFWAPI monotonic_t glfwGetTime(void)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(0);
-    return _glfwPlatformGetTimerValue();
-}
-
-GLFWAPI uint64_t glfwGetTimerFrequency(void)
-{
-    _GLFW_REQUIRE_INIT_OR_RETURN(0);
-    return _glfwPlatformGetTimerFrequency();
+    return monotonic();
 }

glfw/internal.h

@@ -27,6 +27,8 @@
 
 #pragma once
 
+#include "../kitty/monotonic.h"
+
 #if defined(_GLFW_USE_CONFIG_H)
  #include "glfw_config.h"
 #endif
@@ -130,6 +132,7 @@ typedef enum VkStructureType
     VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
     VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
     VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000,
+    VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT = 1000217000,
     VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
 } VkStructureType;
 
@@ -416,6 +419,7 @@ struct _GLFWwindow
     int                 minwidth, minheight;
     int                 maxwidth, maxheight;
     int                 numer, denom;
+    int                 widthincr, heightincr;
 
     bool                stickyKeys;
     bool                stickyMouseButtons;
@@ -572,12 +576,6 @@ struct _GLFWlibrary
     _GLFWtls            contextSlot;
     _GLFWmutex          errorLock;
 
-    struct {
-        uint64_t        offset;
-        // This is defined in the platform's time.h
-        _GLFW_PLATFORM_LIBRARY_TIMER_STATE;
-    } timer;
-
     struct {
         bool            available;
         void*           handle;
@@ -591,6 +589,7 @@ struct _GLFWlibrary
         bool            KHR_win32_surface;
 #elif defined(_GLFW_COCOA)
         bool            MVK_macos_surface;
+        bool            EXT_metal_surface;
 #elif defined(_GLFW_X11)
         bool            KHR_xlib_surface;
         bool            KHR_xcb_surface;
@@ -638,8 +637,8 @@ int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, GLFWCursorShape shape
 void _glfwPlatformDestroyCursor(_GLFWcursor* cursor);
 void _glfwPlatformSetCursor(_GLFWwindow* window, _GLFWcursor* cursor);
 
-const char* _glfwPlatformGetScancodeName(int scancode);
-int _glfwPlatformGetKeyScancode(int key);
+const char* _glfwPlatformGetNativeKeyName(int native_key);
+int _glfwPlatformGetNativeKeyForKey(int key);
 
 void _glfwPlatformFreeMonitor(_GLFWmonitor* monitor);
 void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos);
@@ -661,9 +660,6 @@ const char* _glfwPlatformGetPrimarySelectionString(void);
 int _glfwPlatformPollJoystick(_GLFWjoystick* js, int mode);
 void _glfwPlatformUpdateGamepadGUID(char* guid);
 
-uint64_t _glfwPlatformGetTimerValue(void);
-uint64_t _glfwPlatformGetTimerFrequency(void);
-
 int _glfwPlatformCreateWindow(_GLFWwindow* window,
                               const _GLFWwndconfig* wndconfig,
                               const _GLFWctxconfig* ctxconfig,
@@ -680,6 +676,7 @@ void _glfwPlatformSetWindowSizeLimits(_GLFWwindow* window,
                                       int minwidth, int minheight,
                                       int maxwidth, int maxheight);
 void _glfwPlatformSetWindowAspectRatio(_GLFWwindow* window, int numer, int denom);
+void _glfwPlatformSetWindowSizeIncrements(_GLFWwindow* window, int widthincr, int heightincr);
 void _glfwPlatformGetFramebufferSize(_GLFWwindow* window, int* width, int* height);
 void _glfwInputLiveResize(_GLFWwindow* window, bool started);
 void _glfwPlatformGetWindowFrameSize(_GLFWwindow* window,
@@ -687,7 +684,7 @@ void _glfwPlatformGetWindowFrameSize(_GLFWwindow* window,
                                      int* right, int* bottom);
 void _glfwPlatformGetWindowContentScale(_GLFWwindow* window,
                                         float* xscale, float* yscale);
-double _glfwPlatformGetDoubleClickInterval(_GLFWwindow* window);
+monotonic_t _glfwPlatformGetDoubleClickInterval(_GLFWwindow* window);
 void _glfwPlatformIconifyWindow(_GLFWwindow* window);
 void _glfwPlatformRestoreWindow(_GLFWwindow* window);
 void _glfwPlatformMaximizeWindow(_GLFWwindow* window);
@@ -716,7 +713,7 @@ void _glfwPlatformUpdateIMEState(_GLFWwindow *w, int which, int a, int b, int c,
 
 void _glfwPlatformPollEvents(void);
 void _glfwPlatformWaitEvents(void);
-void _glfwPlatformWaitEventsTimeout(double timeout);
+void _glfwPlatformWaitEventsTimeout(monotonic_t timeout);
 void _glfwPlatformPostEmptyEvent(void);
 
 void _glfwPlatformGetRequiredInstanceExtensions(char** extensions);
@@ -756,7 +753,8 @@ void _glfwInputWindowDamage(_GLFWwindow* window);
 void _glfwInputWindowCloseRequest(_GLFWwindow* window);
 void _glfwInputWindowMonitor(_GLFWwindow* window, _GLFWmonitor* monitor);
 
-void _glfwInputKeyboard(_GLFWwindow* window, int key, int scancode, int action, int mods, const char* text, int state);
+void _glfwInitializeKeyEvent(GLFWkeyevent *ev, int key, int native_key, int action, int mods);
+void _glfwInputKeyboard(_GLFWwindow *window, GLFWkeyevent *ev);
 void _glfwInputScroll(_GLFWwindow* window, double xoffset, double yoffset, int flags);
 void _glfwInputMouseClick(_GLFWwindow* window, int button, int action, int mods);
 void _glfwInputCursorPos(_GLFWwindow* window, double xpos, double ypos);
@@ -823,8 +821,8 @@ _GLFWwindow* _glfwFocusedWindow(void);
 _GLFWwindow* _glfwWindowForId(GLFWid id);
 void _glfwPlatformRunMainLoop(GLFWtickcallback, void*);
 void _glfwPlatformStopMainLoop(void);
-unsigned long long _glfwPlatformAddTimer(double interval, bool repeats, GLFWuserdatafun callback, void *callback_data, GLFWuserdatafun free_callback);
-void _glfwPlatformUpdateTimer(unsigned long long timer_id, double interval, bool enabled);
+unsigned long long _glfwPlatformAddTimer(monotonic_t interval, bool repeats, GLFWuserdatafun callback, void *callback_data, GLFWuserdatafun free_callback);
+void _glfwPlatformUpdateTimer(unsigned long long timer_id, monotonic_t interval, bool enabled);
 void _glfwPlatformRemoveTimer(unsigned long long timer_id);
 
 char* _glfw_strdup(const char* source);

glfw/linux_joystick.c

@@ -222,7 +222,8 @@ static bool openJoystickDevice(const char* path)
         }
     }
 
-    _GLFWjoystick* js = _glfwAllocJoystick(name, guid, axisCount, buttonCount, hatCount);
+    _GLFWjoystick* js =
+        _glfwAllocJoystick(name, guid, axisCount, buttonCount, hatCount);
     if (!js)
     {
         close(linjs.fd);

glfw/main_loop.h

@@ -7,6 +7,7 @@
 #pragma once
 
 #include "internal.h"
+#include "../kitty/monotonic.h"
 
 #ifndef GLFW_LOOP_BACKEND
 #define GLFW_LOOP_BACKEND x11
@@ -36,7 +37,7 @@ void _glfwPlatformRunMainLoop(GLFWtickcallback tick_callback, void* data) {
     EVDBG("main loop exiting");
 }
 
-unsigned long long _glfwPlatformAddTimer(double interval, bool repeats, GLFWuserdatafreefun callback, void *callback_data, GLFWuserdatafreefun free_callback) {
+unsigned long long _glfwPlatformAddTimer(monotonic_t interval, bool repeats, GLFWuserdatafreefun callback, void *callback_data, GLFWuserdatafreefun free_callback) {
     return addTimer(&_glfw.GLFW_LOOP_BACKEND.eventLoopData, "user timer", interval, 1, repeats, callback, callback_data, free_callback);
 }
 
@@ -44,7 +45,7 @@ void _glfwPlatformRemoveTimer(unsigned long long timer_id) {
     removeTimer(&_glfw.GLFW_LOOP_BACKEND.eventLoopData, timer_id);
 }
 
-void _glfwPlatformUpdateTimer(unsigned long long timer_id, double interval, bool enabled) {
+void _glfwPlatformUpdateTimer(unsigned long long timer_id, monotonic_t interval, bool enabled) {
     changeTimerInterval(&_glfw.GLFW_LOOP_BACKEND.eventLoopData, timer_id, interval);
     toggleTimer(&_glfw.GLFW_LOOP_BACKEND.eventLoopData, timer_id, enabled);
 }

glfw/monotonic.c

@@ -0,0 +1,10 @@
+/*
+ * monotonic.c
+ * Copyright (C) 2019 Kovid Goyal <kovid at kovidgoyal.net>
+ *
+ * Distributed under terms of the GPL3 license.
+ */
+
+#define _POSIX_C_SOURCE 200809L
+#define MONOTONIC_IMPLEMENTATION
+#include "../kitty/monotonic.h"

glfw/nsgl_context.h

@@ -32,8 +32,8 @@
 //
 typedef struct _GLFWcontextNSGL
 {
-    id           pixelFormat;
-    id           object;
+    id                pixelFormat;
+    id                object;
 
 } _GLFWcontextNSGL;
 

glfw/nsgl_context.m

@@ -271,7 +271,7 @@ bool _glfwCreateContextNSGL(_GLFWwindow* window,
         return false;
     }
 
-    NSOpenGLContext* share = NULL;
+    NSOpenGLContext* share = nil;
 
     if (ctxconfig->share)
         share = ctxconfig->share->context.nsgl.object;
@@ -293,8 +293,7 @@ bool _glfwCreateContextNSGL(_GLFWwindow* window,
                                   forParameter:NSOpenGLContextParameterSurfaceOpacity];
     }
 
-    if (window->ns.retina)
-        [window->ns.view setWantsBestResolutionOpenGLSurface:YES];
+    [window->ns.view setWantsBestResolutionOpenGLSurface:window->ns.retina];
 
     GLint interval = 0;
     [window->context.nsgl.object setValues:&interval
@@ -325,7 +324,7 @@ GLFWAPI id glfwGetNSGLContext(GLFWwindow* handle)
     if (window->context.client == GLFW_NO_API)
     {
         _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
-        return NULL;
+        return nil;
     }
 
     return window->context.nsgl.object;

glfw/null_init.c

@@ -36,7 +36,6 @@
 
 int _glfwPlatformInit(void)
 {
-    _glfwInitTimerPOSIX();
     return true;
 }
 
@@ -49,4 +48,3 @@ const char* _glfwPlatformGetVersionString(void)
 {
     return _GLFW_VERSION_NUMBER " null OSMesa";
 }
-

glfw/null_window.c

@@ -28,6 +28,7 @@
 //========================================================================
 
 #include "internal.h"
+#include "../kitty/monotonic.h"
 
 
 static int createNativeWindow(_GLFWwindow* window,
@@ -127,6 +128,10 @@ void _glfwPlatformSetWindowAspectRatio(_GLFWwindow* window UNUSED, int n UNUSED,
 {
 }
 
+void _glfwPlatformSetWindowSizeIncrements(_GLFWwindow* window UNUSED, int widthincr UNUSED, int heightincr UNUSED)
+{
+}
+
 void _glfwPlatformGetFramebufferSize(_GLFWwindow* window, int* width, int* height)
 {
     if (width)
@@ -150,9 +155,9 @@ void _glfwPlatformGetWindowContentScale(_GLFWwindow* window UNUSED,
         *yscale = 1.f;
 }
 
-double _glfwPlatformGetDoubleClickInterval(_GLFWwindow* window UNUSED)
+monotonic_t _glfwPlatformGetDoubleClickInterval(_GLFWwindow* window UNUSED)
 {
-    return 0.5;
+    return ms_to_monotonic_t(500ll);
 }
 
 void _glfwPlatformIconifyWindow(_GLFWwindow* window UNUSED)
@@ -257,7 +262,7 @@ void _glfwPlatformWaitEvents(void)
 {
 }
 
-void _glfwPlatformWaitEventsTimeout(double timeout UNUSED)
+void _glfwPlatformWaitEventsTimeout(monotonic_t timeout UNUSED)
 {
 }
 
@@ -306,12 +311,12 @@ const char* _glfwPlatformGetClipboardString(void)
     return NULL;
 }
 
-const char* _glfwPlatformGetScancodeName(int scancode UNUSED)
+const char* _glfwPlatformGetNativeKeyName(int native_key UNUSED)
 {
     return "";
 }
 
-int _glfwPlatformGetKeyScancode(int key UNUSED)
+int _glfwPlatformGetNativeKeyForKey(int key UNUSED)
 {
     return -1;
 }

glfw/posix_time.c

@@ -1,87 +0,0 @@
-//========================================================================
-// GLFW 3.4 POSIX - www.glfw.org
-//------------------------------------------------------------------------
-// Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2017 Camilla Löwy <elmindreda@glfw.org>
-//
-// This software is provided 'as-is', without any express or implied
-// warranty. In no event will the authors be held liable for any damages
-// arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it
-// freely, subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented; you must not
-//    claim that you wrote the original software. If you use this software
-//    in a product, an acknowledgment in the product documentation would
-//    be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such, and must not
-//    be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source
-//    distribution.
-//
-//========================================================================
-// It is fine to use C99 in this file because it will not be built with VS
-//========================================================================
-
-#include "internal.h"
-
-#include <sys/time.h>
-#include <time.h>
-
-
-//////////////////////////////////////////////////////////////////////////
-//////                       GLFW internal API                      //////
-//////////////////////////////////////////////////////////////////////////
-
-// Initialise timer
-//
-void _glfwInitTimerPOSIX(void)
-{
-#if defined(CLOCK_MONOTONIC)
-    struct timespec ts;
-
-    if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0)
-    {
-        _glfw.timer.posix.monotonic = true;
-        _glfw.timer.posix.frequency = 1000000000;
-    }
-    else
-#endif
-    {
-        _glfw.timer.posix.monotonic = false;
-        _glfw.timer.posix.frequency = 1000000;
-    }
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-//////                       GLFW platform API                      //////
-//////////////////////////////////////////////////////////////////////////
-
-uint64_t _glfwPlatformGetTimerValue(void)
-{
-#if defined(CLOCK_MONOTONIC)
-    if (_glfw.timer.posix.monotonic)
-    {
-        struct timespec ts;
-        clock_gettime(CLOCK_MONOTONIC, &ts);
-        return (uint64_t) ts.tv_sec * (uint64_t) 1000000000 + (uint64_t) ts.tv_nsec;
-    }
-    else
-#endif
-    {
-        struct timeval tv;
-        gettimeofday(&tv, NULL);
-        return (uint64_t) tv.tv_sec * (uint64_t) 1000000 + (uint64_t) tv.tv_usec;
-    }
-}
-
-uint64_t _glfwPlatformGetTimerFrequency(void)
-{
-    return _glfw.timer.posix.frequency;
-}
-

glfw/posix_time.h

@@ -1,44 +0,0 @@
-//========================================================================
-// GLFW 3.4 POSIX - www.glfw.org
-//------------------------------------------------------------------------
-// Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2017 Camilla Löwy <elmindreda@glfw.org>
-//
-// This software is provided 'as-is', without any express or implied
-// warranty. In no event will the authors be held liable for any damages
-// arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it
-// freely, subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented; you must not
-//    claim that you wrote the original software. If you use this software
-//    in a product, an acknowledgment in the product documentation would
-//    be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such, and must not
-//    be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source
-//    distribution.
-//
-//========================================================================
-
-#define _GLFW_PLATFORM_LIBRARY_TIMER_STATE _GLFWtimerPOSIX posix
-
-#include <stdint.h>
-
-
-// POSIX-specific global timer data
-//
-typedef struct _GLFWtimerPOSIX
-{
-    bool        monotonic;
-    uint64_t    frequency;
-
-} _GLFWtimerPOSIX;
-
-
-void _glfwInitTimerPOSIX(void);
-

glfw/source-info.json

@@ -13,7 +13,6 @@
       "cocoa_joystick.m",
       "cocoa_monitor.m",
       "cocoa_window.m",
-      "cocoa_time.c",
       "posix_thread.c",
       "nsgl_context.m",
       "egl_context.c",
@@ -31,6 +30,7 @@
       "input.c",
       "monitor.c",
       "vulkan.c",
+      "monotonic.c",
       "window.c"
     ]
   },
@@ -38,7 +38,6 @@
     "headers": [
       "null_platform.h",
       "null_joystick.h",
-      "posix_time.h",
       "posix_thread.h",
       "osmesa_context.h"
     ],
@@ -47,7 +46,6 @@
       "null_monitor.c",
       "null_window.c",
       "null_joystick.c",
-      "posix_time.c",
       "posix_thread.c",
       "osmesa_context.c"
     ]
@@ -55,7 +53,6 @@
   "wayland": {
     "headers": [
       "wl_platform.h",
-      "posix_time.h",
       "posix_thread.h",
       "xkb_glfw.h",
       "dbus_glfw.h",
@@ -81,7 +78,6 @@
       "wl_init.c",
       "wl_monitor.c",
       "wl_window.c",
-      "posix_time.c",
       "posix_thread.c",
       "xkb_glfw.c",
       "dbus_glfw.c",
@@ -125,7 +121,6 @@
       "dbus_glfw.h",
       "ibus_glfw.h",
       "backend_utils.h",
-      "posix_time.h",
       "posix_thread.h",
       "glx_context.h",
       "egl_context.h",
@@ -142,7 +137,6 @@
       "xkb_glfw.c",
       "dbus_glfw.c",
       "ibus_glfw.c",
-      "posix_time.c",
       "posix_thread.c",
       "glx_context.c",
       "egl_context.c",

glfw/vulkan.c

@@ -57,6 +57,8 @@ bool _glfwInitVulkan(int mode)
     _glfw.vk.handle = _glfw_dlopen("vulkan-1.dll");
 #elif defined(_GLFW_COCOA)
     _glfw.vk.handle = _glfw_dlopen("libvulkan.1.dylib");
+    if (!_glfw.vk.handle)
+        _glfw.vk.handle = _glfwLoadLocalVulkanLoaderNS();
 #else
     _glfw.vk.handle = _glfw_dlopen("libvulkan.so.1");
 #endif
@@ -130,6 +132,8 @@ bool _glfwInitVulkan(int mode)
 #elif defined(_GLFW_COCOA)
         else if (strcmp(ep[i].extensionName, "VK_MVK_macos_surface") == 0)
             _glfw.vk.MVK_macos_surface = true;
+        else if (strcmp(ep[i].extensionName, "VK_EXT_metal_surface") == 0)
+            _glfw.vk.EXT_metal_surface = true;
 #elif defined(_GLFW_X11)
         else if (strcmp(ep[i].extensionName, "VK_KHR_xlib_surface") == 0)
             _glfw.vk.KHR_xlib_surface = true;

glfw/window.c

@@ -29,6 +29,7 @@
 //========================================================================
 
 #include "internal.h"
+#include "../kitty/monotonic.h"
 
 #include <assert.h>
 #include <string.h>
@@ -56,8 +57,10 @@ void _glfwInputWindowFocus(_GLFWwindow* window, bool focused)
         {
             if (window->keys[key] == GLFW_PRESS)
             {
-                const int scancode = _glfwPlatformGetKeyScancode(key);
-                _glfwInputKeyboard(window, key, scancode, GLFW_RELEASE, 0, "", 0);
+                const int native_key = _glfwPlatformGetNativeKeyForKey(key);
+                GLFWkeyevent ev;
+                _glfwInitializeKeyEvent(&ev, key, native_key, GLFW_RELEASE, 0);
+                _glfwInputKeyboard(window, &ev);
             }
         }
 
@@ -251,6 +254,8 @@ GLFWAPI GLFWwindow* glfwCreateWindow(int width, int height,
     window->maxheight   = GLFW_DONT_CARE;
     window->numer       = GLFW_DONT_CARE;
     window->denom       = GLFW_DONT_CARE;
+    window->widthincr   = GLFW_DONT_CARE;
+    window->heightincr  = GLFW_DONT_CARE;
 
     // Open the actual window and create its context
     if (!_glfwPlatformCreateWindow(window, &wndconfig, &ctxconfig, &fbconfig))
@@ -687,6 +692,20 @@ GLFWAPI void glfwSetWindowAspectRatio(GLFWwindow* handle, int numer, int denom)
     _glfwPlatformSetWindowAspectRatio(window, numer, denom);
 }
 
+GLFWAPI void glfwSetWindowSizeIncrements(GLFWwindow* handle, int widthincr, int heightincr)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+    assert(widthincr >= 0);
+    assert(heightincr >= 0);
+
+    _GLFW_REQUIRE_INIT();
+
+    window->widthincr  = widthincr;
+    window->heightincr = heightincr;
+    _glfwPlatformSetWindowSizeIncrements(window, window->widthincr, window->heightincr);
+}
+
 GLFWAPI void glfwGetFramebufferSize(GLFWwindow* handle, int* width, int* height)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
@@ -736,12 +755,12 @@ GLFWAPI void glfwGetWindowContentScale(GLFWwindow* handle,
     _glfwPlatformGetWindowContentScale(window, xscale, yscale);
 }
 
-GLFWAPI double glfwGetDoubleClickInterval(GLFWwindow* handle)
+GLFWAPI monotonic_t glfwGetDoubleClickInterval(GLFWwindow* handle)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
-    _GLFW_REQUIRE_INIT_OR_RETURN(0.5f);
+    _GLFW_REQUIRE_INIT_OR_RETURN(ms_to_monotonic_t(500ll));
     return _glfwPlatformGetDoubleClickInterval(window);
 }
 

glfw/wl_init.c

@@ -29,6 +29,7 @@
 #define _GNU_SOURCE
 #include "internal.h"
 #include "backend_utils.h"
+#include "../kitty/monotonic.h"
 
 #include <assert.h>
 #include <errno.h>
@@ -136,6 +137,7 @@ static void pointerHandleLeave(void* data UNUSED,
     _glfw.wl.pointerSerial = serial;
     _glfw.wl.pointerFocus = NULL;
     _glfwInputCursorEnter(window, false);
+    _glfw.wl.cursorPreviousShape = GLFW_INVALID_CURSOR;
 }
 
 static void setCursor(GLFWCursorShape shape)
@@ -164,6 +166,7 @@ static void setCursor(GLFWCursorShape shape)
     wl_surface_damage(surface, 0, 0,
                       image->width, image->height);
     wl_surface_commit(surface);
+    _glfw.wl.cursorPreviousShape = shape;
 }
 
 static void pointerHandleMotion(void* data UNUSED,
@@ -174,43 +177,46 @@ static void pointerHandleMotion(void* data UNUSED,
 {
     _GLFWwindow* window = _glfw.wl.pointerFocus;
     GLFWCursorShape cursorShape = GLFW_ARROW_CURSOR;
+    double x, y;
 
     if (!window)
         return;
 
     if (window->cursorMode == GLFW_CURSOR_DISABLED)
         return;
-    window->wl.cursorPosX = wl_fixed_to_double(sx);
-    window->wl.cursorPosY = wl_fixed_to_double(sy);
+    x = wl_fixed_to_double(sx);
+    y = wl_fixed_to_double(sy);
 
     switch (window->wl.decorations.focus)
     {
         case mainWindow:
-            _glfwInputCursorPos(window,
-                                window->wl.cursorPosX, window->wl.cursorPosY);
+            window->wl.cursorPosX = x;
+            window->wl.cursorPosY = y;
+            _glfwInputCursorPos(window, x, y);
+            _glfw.wl.cursorPreviousShape = GLFW_INVALID_CURSOR;
             return;
         case topDecoration:
-            if (window->wl.cursorPosY < _GLFW_DECORATION_WIDTH)
+            if (y < _GLFW_DECORATION_WIDTH)
                 cursorShape = GLFW_VRESIZE_CURSOR;
             else
                 cursorShape = GLFW_ARROW_CURSOR;
             break;
         case leftDecoration:
-            if (window->wl.cursorPosY < _GLFW_DECORATION_WIDTH)
+            if (y < _GLFW_DECORATION_WIDTH)
                 cursorShape = GLFW_NW_RESIZE_CURSOR;
             else
                 cursorShape = GLFW_HRESIZE_CURSOR;
             break;
         case rightDecoration:
-            if (window->wl.cursorPosY < _GLFW_DECORATION_WIDTH)
+            if (y < _GLFW_DECORATION_WIDTH)
                 cursorShape = GLFW_NE_RESIZE_CURSOR;
             else
                 cursorShape = GLFW_HRESIZE_CURSOR;
             break;
         case bottomDecoration:
-            if (window->wl.cursorPosX < _GLFW_DECORATION_WIDTH)
+            if (x < _GLFW_DECORATION_WIDTH)
                 cursorShape = GLFW_SW_RESIZE_CURSOR;
-            else if (window->wl.cursorPosX > window->wl.width + _GLFW_DECORATION_WIDTH)
+            else if (x > window->wl.width + _GLFW_DECORATION_WIDTH)
                 cursorShape = GLFW_SE_RESIZE_CURSOR;
             else
                 cursorShape = GLFW_VRESIZE_CURSOR;
@@ -218,7 +224,8 @@ static void pointerHandleMotion(void* data UNUSED,
         default:
             assert(0);
     }
-    setCursor(cursorShape);
+    if (_glfw.wl.cursorPreviousShape != cursorShape)
+        setCursor(cursorShape);
 }
 
 static void pointerHandleButton(void* data UNUSED,
@@ -284,8 +291,8 @@ static void pointerHandleButton(void* data UNUSED,
         {
             xdg_toplevel_show_window_menu(window->wl.xdg.toplevel,
                                           _glfw.wl.seat, serial,
-                                          window->wl.cursorPosX,
-                                          window->wl.cursorPosY);
+                                          (int32_t)window->wl.cursorPosX,
+                                          (int32_t)window->wl.cursorPosY);
             return;
         }
     }
@@ -367,7 +374,7 @@ static void keyboardHandleEnter(void* data UNUSED,
                                 struct wl_keyboard* keyboard UNUSED,
                                 uint32_t serial UNUSED,
                                 struct wl_surface* surface,
-                                struct wl_array* keys UNUSED)
+                                struct wl_array* keys)
 {
     // Happens in the case we just destroyed the surface.
     if (!surface)
@@ -383,6 +390,15 @@ static void keyboardHandleEnter(void* data UNUSED,
 
     _glfw.wl.keyboardFocus = window;
     _glfwInputWindowFocus(window, true);
+    uint32_t* key;
+    if (keys && _glfw.wl.keyRepeatInfo.key) {
+        wl_array_for_each(key, keys) {
+            if (*key == _glfw.wl.keyRepeatInfo.key) {
+                toggleTimer(&_glfw.wl.eventLoopData, _glfw.wl.keyRepeatInfo.keyRepeatTimer, 1);
+                break;
+            }
+        }
+    }
 }
 
 static void keyboardHandleLeave(void* data UNUSED,
@@ -397,13 +413,14 @@ static void keyboardHandleLeave(void* data UNUSED,
 
     _glfw.wl.keyboardFocus = NULL;
     _glfwInputWindowFocus(window, false);
+    toggleTimer(&_glfw.wl.eventLoopData, _glfw.wl.keyRepeatInfo.keyRepeatTimer, 0);
 }
 
 static void
 dispatchPendingKeyRepeats(id_type timer_id UNUSED, void *data UNUSED) {
     if (_glfw.wl.keyRepeatInfo.keyboardFocus != _glfw.wl.keyboardFocus || _glfw.wl.keyboardRepeatRate == 0) return;
     glfw_xkb_handle_key_event(_glfw.wl.keyRepeatInfo.keyboardFocus, &_glfw.wl.xkb, _glfw.wl.keyRepeatInfo.key, GLFW_REPEAT);
-    changeTimerInterval(&_glfw.wl.eventLoopData, _glfw.wl.keyRepeatInfo.keyRepeatTimer, (1.0 / (double)_glfw.wl.keyboardRepeatRate));
+    changeTimerInterval(&_glfw.wl.eventLoopData, _glfw.wl.keyRepeatInfo.keyRepeatTimer, (s_to_monotonic_t(1ll) / (monotonic_t)_glfw.wl.keyboardRepeatRate));
     toggleTimer(&_glfw.wl.eventLoopData, _glfw.wl.keyRepeatInfo.keyRepeatTimer, 1);
 }
 
@@ -421,6 +438,7 @@ static void keyboardHandleKey(void* data UNUSED,
     int action = state == WL_KEYBOARD_KEY_STATE_PRESSED ? GLFW_PRESS : GLFW_RELEASE;
     glfw_xkb_handle_key_event(window, &_glfw.wl.xkb, key, action);
     bool repeatable = false;
+    _glfw.wl.keyRepeatInfo.key = 0;
 
     if (action == GLFW_PRESS && _glfw.wl.keyboardRepeatRate > 0 && glfw_xkb_should_repeat(&_glfw.wl.xkb, key))
     {
@@ -429,7 +447,7 @@ static void keyboardHandleKey(void* data UNUSED,
         _glfw.wl.keyRepeatInfo.keyboardFocus = window;
     }
     if (repeatable) {
-        changeTimerInterval(&_glfw.wl.eventLoopData, _glfw.wl.keyRepeatInfo.keyRepeatTimer, (double)(_glfw.wl.keyboardRepeatDelay) / 1000.0);
+        changeTimerInterval(&_glfw.wl.eventLoopData, _glfw.wl.keyRepeatInfo.keyRepeatTimer, _glfw.wl.keyboardRepeatDelay);
     }
     toggleTimer(&_glfw.wl.eventLoopData, _glfw.wl.keyRepeatInfo.keyRepeatTimer, repeatable ? 1 : 0);
 }
@@ -454,7 +472,7 @@ static void keyboardHandleRepeatInfo(void* data UNUSED,
         return;
 
     _glfw.wl.keyboardRepeatRate = rate;
-    _glfw.wl.keyboardRepeatDelay = delay;
+    _glfw.wl.keyboardRepeatDelay = ms_to_monotonic_t(delay);
 }
 
 static const struct wl_keyboard_listener keyboardListener = {
@@ -607,8 +625,7 @@ static void registryHandleGlobal(void* data UNUSED,
             _glfwSetupWaylandDataDevice();
         }
     }
-    else if (strcmp(interface, "zwp_primary_selection_device_manager_v1") == 0 ||
-        strcmp(interface, "gtk_primary_selection_device_manager") == 0)
+    else if (strcmp(interface, "zwp_primary_selection_device_manager_v1") == 0)
     {
         _glfw.wl.primarySelectionDeviceManager =
             wl_registry_bind(registry, name,
@@ -728,8 +745,8 @@ int _glfwPlatformInit(void)
                         "Wayland: Failed to initialize event loop data");
     }
     glfw_dbus_init(&_glfw.wl.dbus, &_glfw.wl.eventLoopData);
-    _glfw.wl.keyRepeatInfo.keyRepeatTimer = addTimer(&_glfw.wl.eventLoopData, "wayland-key-repeat", 0.5, 0, true, dispatchPendingKeyRepeats, NULL, NULL);
-    _glfw.wl.cursorAnimationTimer = addTimer(&_glfw.wl.eventLoopData, "wayland-cursor-animation", 0.5, 0, true, animateCursorImage, NULL, NULL);
+    _glfw.wl.keyRepeatInfo.keyRepeatTimer = addTimer(&_glfw.wl.eventLoopData, "wayland-key-repeat", ms_to_monotonic_t(500ll), 0, true, dispatchPendingKeyRepeats, NULL, NULL);
+    _glfw.wl.cursorAnimationTimer = addTimer(&_glfw.wl.eventLoopData, "wayland-cursor-animation", ms_to_monotonic_t(500ll), 0, true, animateCursorImage, NULL, NULL);
 
     _glfw.wl.registry = wl_display_get_registry(_glfw.wl.display);
     wl_registry_add_listener(_glfw.wl.registry, &registryListener, NULL);
@@ -749,7 +766,6 @@ int _glfwPlatformInit(void)
     }
 #endif
 
-    _glfwInitTimerPOSIX();
     if (!_glfw.wl.wmBase)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,

glfw/wl_platform.h

@@ -43,7 +43,6 @@ typedef VkResult (APIENTRY *PFN_vkCreateWaylandSurfaceKHR)(VkInstance,const VkWa
 typedef VkBool32 (APIENTRY *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice,uint32_t,struct wl_display*);
 
 #include "posix_thread.h"
-#include "posix_time.h"
 #ifdef __linux__
 #include "linux_joystick.h"
 #else
@@ -156,6 +155,7 @@ typedef struct _GLFWwindowWayland
     // We need to track the monitors the window spans on to calculate the
     // optimal scaling factor.
     int                         scale;
+    bool                        initial_scale_notified;
     _GLFWmonitor**              monitors;
     int                         monitorsCount;
     int                         monitorsSize;
@@ -247,10 +247,11 @@ typedef struct _GLFWlibraryWayland
 
     struct wl_cursor_theme*     cursorTheme;
     struct wl_surface*          cursorSurface;
+    GLFWCursorShape             cursorPreviousShape;
     uint32_t                    pointerSerial;
 
     int32_t                     keyboardRepeatRate;
-    int32_t                     keyboardRepeatDelay;
+    monotonic_t                 keyboardRepeatDelay;
     struct {
         uint32_t                key;
         id_type                 keyRepeatTimer;

glfw/wl_window.c

@@ -32,6 +32,7 @@
 #include "backend_utils.h"
 #include "memfd.h"
 #include "linux_notify.h"
+#include "../kitty/monotonic.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -54,13 +55,18 @@ static bool checkScaleChange(_GLFWwindow* window)
     if (_glfw.wl.compositorVersion < 3)
         return false;
 
-    // Get the scale factor from the highest scale monitor.
+    // Get the scale factor from the highest scale monitor that this window is on
     for (i = 0; i < window->wl.monitorsCount; ++i)
     {
         monitorScale = window->wl.monitors[i]->wl.scale;
         if (scale < monitorScale)
             scale = monitorScale;
     }
+    if (window->wl.monitorsCount < 1 && _glfw.monitorCount > 0) {
+        // The window has not yet been assigned to any monitors, use the primary monitor
+        _GLFWmonitor *m = _glfw.monitors[0];
+        if (m && m->wl.scale > scale) scale = m->wl.scale;
+    }
 
     // Only change the framebuffer size if the scale changed.
     if (scale != window->wl.scale)
@@ -69,6 +75,10 @@ static bool checkScaleChange(_GLFWwindow* window)
         wl_surface_set_buffer_scale(window->wl.surface, scale);
         return true;
     }
+    if (window->wl.monitorsCount > 0 && !window->wl.initial_scale_notified) {
+        window->wl.initial_scale_notified = true;
+        return true;
+    }
     return false;
 }
 
@@ -241,8 +251,8 @@ static struct wl_buffer* createShmBuffer(const GLFWimage* image)
     if (fd < 0)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Wayland: Creating a buffer file for %d B failed: %%m",
-                        length);
+                        "Wayland: Creating a buffer file for %d B failed: %s",
+                        length, strerror(errno));
         return NULL;
     }
 
@@ -250,7 +260,7 @@ static struct wl_buffer* createShmBuffer(const GLFWimage* image)
     if (data == MAP_FAILED)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Wayland: mmap failed: %%m");
+                        "Wayland: mmap failed: %s", strerror(errno));
         close(fd);
         return NULL;
     }
@@ -545,9 +555,9 @@ static void xdgToplevelHandleConfigure(void* data,
                 aspectRatio = (float)width / (float)height;
                 targetRatio = (float)window->numer / (float)window->denom;
                 if (aspectRatio < targetRatio)
-                    height = width / targetRatio;
+                    height = (int32_t)((float)width / targetRatio);
                 else if (aspectRatio > targetRatio)
-                    width = height * targetRatio;
+                    width = (int32_t)((float)height * targetRatio);
             }
         }
     }
@@ -684,7 +694,7 @@ setCursorImage(_GLFWcursorWayland* cursorWayland)
         image = cursorWayland->cursor->images[cursorWayland->currentImage];
         buffer = wl_cursor_image_get_buffer(image);
         if (image->delay) {
-            changeTimerInterval(&_glfw.wl.eventLoopData, _glfw.wl.cursorAnimationTimer, ((double)image->delay) / 1000.0);
+            changeTimerInterval(&_glfw.wl.eventLoopData, _glfw.wl.cursorAnimationTimer, ms_to_monotonic_t(image->delay));
             toggleTimer(&_glfw.wl.eventLoopData, _glfw.wl.cursorAnimationTimer, 1);
         } else {
             toggleTimer(&_glfw.wl.eventLoopData, _glfw.wl.cursorAnimationTimer, 0);
@@ -745,24 +755,23 @@ abortOnFatalError(int last_error) {
 }
 
 static void
-handleEvents(double timeout)
+wayland_read_events(int poll_result, int events, void *data UNUSED) {
+    EVDBG("wayland_read_events poll_result: %d events: %d", poll_result, events);
+    if (poll_result > 0 && events) wl_display_read_events(_glfw.wl.display);
+    else wl_display_cancel_read(_glfw.wl.display);
+}
+
+static void
+handleEvents(monotonic_t timeout)
 {
     struct wl_display* display = _glfw.wl.display;
     errno = 0;
-    EVDBG("starting handleEvents(%.2f)", timeout);
+    EVDBG("starting handleEvents(%.2f)", monotonic_t_to_s_double(timeout));
 
     while (wl_display_prepare_read(display) != 0) {
-        while(1) {
-            errno = 0;
-            int num_dispatched = wl_display_dispatch_pending(display);
-            if (num_dispatched < 0) {
-                if (errno == EAGAIN) continue;
-                int last_error = wl_display_get_error(display);
-                if (last_error) abortOnFatalError(last_error);
-                wl_display_cancel_read(display);
-                return;
-            }
-            break;
+        if (wl_display_dispatch_pending(display) == -1) {
+            abortOnFatalError(errno);
+            return;
         }
     }
 
@@ -772,23 +781,22 @@ handleEvents(double timeout)
     errno = 0;
     if (wl_display_flush(display) < 0 && errno != EAGAIN)
     {
-        abortOnFatalError(errno);
         wl_display_cancel_read(display);
+        abortOnFatalError(errno);
         return;
     }
 
-    bool display_read_ok = pollForEvents(&_glfw.wl.eventLoopData, timeout);
+    // we pass in wayland_read_events to ensure that the above wl_display_prepare_read call
+    // is followed by either wl_display_cancel_read or wl_display_read_events
+    // before any events/timers are dispatched. This allows other wayland functions
+    // to be called in the event/timer handlers without causing a deadlock
+    bool display_read_ok = pollForEvents(&_glfw.wl.eventLoopData, timeout, wayland_read_events);
     EVDBG("display_read_ok: %d", display_read_ok);
     if (display_read_ok) {
-        wl_display_read_events(display);
         int num = wl_display_dispatch_pending(display);
         (void)num;
         EVDBG("dispatched %d Wayland events", num);
     }
-    else
-    {
-        wl_display_cancel_read(display);
-    }
     glfw_ibus_dispatch(&_glfw.wl.xkb.ibus);
     glfw_dbus_session_bus_dispatch();
     EVDBG("other dispatch done");
@@ -950,8 +958,13 @@ void _glfwPlatformSetWindowTitle(_GLFWwindow* window, const char* title)
     if (window->wl.title)
         free(window->wl.title);
     window->wl.title = _glfw_strdup(title);
+    // Wayland cannot handle requests larger than ~8200 bytes. Sending
+    // on causes an abort(). Since titles this large are meaningless anyway
+    // ensure they do not happen. One should really truncate ensuring valid UTF-8
+    // but I cant be bothered.
+    if (title && strnlen(title, 2048) >= 2048) window->wl.title[2048] = 0;
     if (window->wl.xdg.toplevel)
-        xdg_toplevel_set_title(window->wl.xdg.toplevel, title);
+        xdg_toplevel_set_title(window->wl.xdg.toplevel, window->wl.title);
 }
 
 void _glfwPlatformSetWindowIcon(_GLFWwindow* window UNUSED,
@@ -1018,6 +1031,13 @@ void _glfwPlatformSetWindowAspectRatio(_GLFWwindow* window UNUSED,
     // The actual limits are checked in the xdg_toplevel::configure handler.
 }
 
+void _glfwPlatformSetWindowSizeIncrements(_GLFWwindow* window UNUSED,
+                                          int widthincr UNUSED, int heightincr UNUSED)
+{
+    // TODO: find out how to trigger a resize.
+    // The actual limits are checked in the xdg_toplevel::configure handler.
+}
+
 void _glfwPlatformGetFramebufferSize(_GLFWwindow* window,
                                      int* width, int* height)
 {
@@ -1052,9 +1072,9 @@ void _glfwPlatformGetWindowContentScale(_GLFWwindow* window,
         *yscale = (float) window->wl.scale;
 }
 
-double _glfwPlatformGetDoubleClickInterval(_GLFWwindow* window UNUSED)
+monotonic_t _glfwPlatformGetDoubleClickInterval(_GLFWwindow* window UNUSED)
 {
-    return 0.5;
+    return ms_to_monotonic_t(500ll);
 }
 
 void _glfwPlatformIconifyWindow(_GLFWwindow* window)
@@ -1227,11 +1247,11 @@ void _glfwPlatformPollEvents(void)
 
 void _glfwPlatformWaitEvents(void)
 {
-    double timeout = wl_display_dispatch_pending(_glfw.wl.display) > 0 ? 0 : -1;
+    monotonic_t timeout = wl_display_dispatch_pending(_glfw.wl.display) > 0 ? 0 : -1;
     handleEvents(timeout);
 }
 
-void _glfwPlatformWaitEventsTimeout(double timeout)
+void _glfwPlatformWaitEventsTimeout(monotonic_t timeout)
 {
     if (wl_display_dispatch_pending(_glfw.wl.display) > 0) timeout = 0;
     handleEvents(timeout);
@@ -1268,12 +1288,12 @@ void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode UNUSED)
     _glfwPlatformSetCursor(window, window->wl.currentCursor);
 }
 
-const char* _glfwPlatformGetScancodeName(int scancode)
+const char* _glfwPlatformGetNativeKeyName(int native_key)
 {
-    return glfw_xkb_keysym_name(scancode);
+    return glfw_xkb_keysym_name(native_key);
 }
 
-int _glfwPlatformGetKeyScancode(int key)
+int _glfwPlatformGetNativeKeyForKey(int key)
 {
     return glfw_xkb_sym_for_key(key);
 }
@@ -1462,8 +1482,8 @@ static void send_text(char *text, int fd)
 {
     if (text) {
         size_t len = strlen(text), pos = 0;
-        double start = glfwGetTime();
-        while (pos < len && glfwGetTime() - start < 2.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;
@@ -1496,7 +1516,7 @@ static char* read_offer_string(int data_pipe) {
     struct pollfd fds;
     fds.fd = data_pipe;
     fds.events = POLLIN;
-    double start = glfwGetTime();
+    monotonic_t start = glfwGetTime();
 #define bail(...) { \
     _glfwInputError(GLFW_PLATFORM_ERROR, __VA_ARGS__); \
     free(buf); buf = NULL; \
@@ -1504,7 +1524,7 @@ static char* read_offer_string(int data_pipe) {
     return NULL; \
 }
 
-    while (glfwGetTime() - start < 2) {
+    while (glfwGetTime() - start < s_to_monotonic_t(2ll)) {
         int ret = poll(&fds, 1, 2000);
         if (ret == -1) {
             if (errno == EINTR) continue;
@@ -2031,7 +2051,7 @@ GLFWAPI struct wl_surface* glfwGetWaylandWindow(GLFWwindow* handle)
     return window->wl.surface;
 }
 
-GLFWAPI int glfwGetXKBScancode(const char* keyName, bool caseSensitive) {
+GLFWAPI int glfwGetNativeKeyForName(const char* keyName, bool caseSensitive) {
     return glfw_xkb_keysym_from_name(keyName, caseSensitive);
 }
 

glfw/x11_init.c

@@ -433,12 +433,10 @@ static bool initExtensions(void)
 //
 void _glfwGetSystemContentScaleX11(float* xscale, float* yscale, bool bypass_cache)
 {
-    // NOTE: Default to the display-wide DPI as we don't currently have a policy
-    //       for which monitor a window is considered to be on
-    float xdpi = DisplayWidth(_glfw.x11.display, _glfw.x11.screen) *
-        25.4f / DisplayWidthMM(_glfw.x11.display, _glfw.x11.screen);
-    float ydpi = DisplayHeight(_glfw.x11.display, _glfw.x11.screen) *
-        25.4f / DisplayHeightMM(_glfw.x11.display, _glfw.x11.screen);
+    // Start by assuming the default X11 DPI
+    // NOTE: Some desktop environments (KDE) may remove the Xft.dpi field when it
+    //       would be set to 96, so assume that is the case if we cannot find it
+    float xdpi = 96.f, ydpi = 96.f;
 
     // NOTE: Basing the scale on Xft.dpi where available should provide the most
     //       consistent user experience (matches Qt, Gtk, etc), although not
@@ -468,7 +466,7 @@ void _glfwGetSystemContentScaleX11(float* xscale, float* yscale, bool bypass_cac
             if (XrmGetResource(db, "Xft.dpi", "Xft.Dpi", &type, &value))
             {
                 if (type && strcmp(type, "String") == 0)
-                    xdpi = ydpi = atof(value.addr);
+                    xdpi = ydpi = (float)atof(value.addr);
             }
 
             XrmDestroyDatabase(db);
@@ -637,8 +635,6 @@ int _glfwPlatformInit(void)
     }
 #endif
 
-    _glfwInitTimerPOSIX();
-
     _glfwPollMonitorsX11();
     return true;
 }

glfw/x11_monitor.c

@@ -166,6 +166,16 @@ void _glfwPollMonitorsX11(void)
                 heightMM = oi->mm_height;
             }
 
+            if (widthMM <= 0 || heightMM <= 0)
+            {
+                // HACK: If RandR does not provide a physical size, assume the
+                //       X11 default 96 DPI and calcuate from the CRTC viewport
+                // NOTE: These members are affected by rotation, unlike the mode
+                //       info and output info members
+                widthMM  = (int) (ci->width * 25.4f / 96.f);
+                heightMM = (int) (ci->height * 25.4f / 96.f);
+            }
+
             _GLFWmonitor* monitor = _glfwAllocMonitor(oi->name, widthMM, heightMM);
             monitor->x11.output = sr->outputs[i];
             monitor->x11.crtc   = oi->crtc;

glfw/x11_platform.h

@@ -152,7 +152,6 @@ typedef VkResult (APIENTRY *PFN_vkCreateXcbSurfaceKHR)(VkInstance,const VkXcbSur
 typedef VkBool32 (APIENTRY *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice,uint32_t,xcb_connection_t*,xcb_visualid_t);
 
 #include "posix_thread.h"
-#include "posix_time.h"
 #include "glx_context.h"
 #include "egl_context.h"
 #include "osmesa_context.h"
@@ -181,6 +180,7 @@ typedef struct _GLFWwindowX11
 {
     Colormap        colormap;
     Window          handle;
+    Window          parent;
 
     bool            iconified;
     bool            maximized;

glfw/x11_window.c

@@ -31,6 +31,7 @@
 #include "internal.h"
 #include "backend_utils.h"
 #include "linux_notify.h"
+#include "../kitty/monotonic.h"
 
 #include <X11/cursorfont.h>
 #include <X11/Xmd.h>
@@ -51,6 +52,10 @@
 #define Button6            6
 #define Button7            7
 
+// Motif WM hints flags
+#define MWM_HINTS_DECORATIONS   2
+#define MWM_DECOR_ALL           1
+
 #define _GLFW_XDND_VERSION 5
 
 
@@ -61,9 +66,9 @@
 static unsigned _glfwDispatchX11Events(void);
 
 static void
-handleEvents(double timeout) {
-    EVDBG("starting handleEvents(%.2f)", timeout);
-    int display_read_ok = pollForEvents(&_glfw.x11.eventLoopData, timeout);
+handleEvents(monotonic_t timeout) {
+    EVDBG("starting handleEvents(%.2f)", monotonic_t_to_s_double(timeout));
+    int display_read_ok = pollForEvents(&_glfw.x11.eventLoopData, timeout, NULL);
     EVDBG("display_read_ok: %d", display_read_ok);
     if (display_read_ok) {
         unsigned dispatched = _glfwDispatchX11Events();
@@ -77,9 +82,9 @@ handleEvents(double timeout) {
 }
 
 static bool
-waitForX11Event(double timeout) {
+waitForX11Event(monotonic_t timeout) {
     // returns true if there is X11 data waiting to be read, does not run watches and timers
-    double end_time = glfwGetTime() + timeout;
+    monotonic_t end_time = glfwGetTime() + timeout;
     while(true) {
         if (timeout >= 0) {
             const int result = pollWithTimeout(_glfw.x11.eventLoopData.fds, 1, timeout);
@@ -109,7 +114,7 @@ static bool waitForVisibilityNotify(_GLFWwindow* window)
                                    VisibilityNotify,
                                    &dummy))
     {
-        if (!waitForX11Event(0.1))
+        if (!waitForX11Event(ms_to_monotonic_t(100ll)))
             return false;
     }
 
@@ -250,6 +255,14 @@ static void updateNormalHints(_GLFWwindow* window, int width, int height)
                 hints->min_aspect.x = hints->max_aspect.x = window->numer;
                 hints->min_aspect.y = hints->max_aspect.y = window->denom;
             }
+
+            if (window->widthincr != GLFW_DONT_CARE &&
+                window->heightincr != GLFW_DONT_CARE)
+            {
+                hints->flags |= PResizeInc;
+                hints->width_inc = window->widthincr;
+                hints->height_inc = window->heightincr;
+            }
         }
         else
         {
@@ -508,8 +521,8 @@ static bool createNativeWindow(_GLFWwindow* window,
 
     if (wndconfig->scaleToMonitor)
     {
-        width *= _glfw.x11.contentScaleX;
-        height *= _glfw.x11.contentScaleY;
+        width *= (int)_glfw.x11.contentScaleX;
+        height *= (int)_glfw.x11.contentScaleY;
     }
 
     // Create a colormap based on the visual used by the current context
@@ -520,46 +533,41 @@ static bool createNativeWindow(_GLFWwindow* window,
 
     window->x11.transparent = _glfwIsVisualTransparentX11(visual);
 
-    // Create the actual window
+    XSetWindowAttributes wa = { 0 };
+    wa.colormap = window->x11.colormap;
+    wa.event_mask = StructureNotifyMask | KeyPressMask | KeyReleaseMask |
+                    PointerMotionMask | ButtonPressMask | ButtonReleaseMask |
+                    ExposureMask | FocusChangeMask | VisibilityChangeMask |
+                    EnterWindowMask | LeaveWindowMask | PropertyChangeMask;
+
+    _glfwGrabErrorHandlerX11();
+
+    window->x11.parent = _glfw.x11.root;
+    window->x11.handle = XCreateWindow(_glfw.x11.display,
+                                       _glfw.x11.root,
+                                       0, 0,   // Position
+                                       width, height,
+                                       0,      // Border width
+                                       depth,  // Color depth
+                                       InputOutput,
+                                       visual,
+                                       CWBorderPixel | CWColormap | CWEventMask,
+                                       &wa);
+
+    _glfwReleaseErrorHandlerX11();
+
+    if (!window->x11.handle)
     {
-        XSetWindowAttributes wa;
-        const unsigned long wamask = CWBorderPixel | CWColormap | CWEventMask;
-
-        wa.colormap = window->x11.colormap;
-        wa.border_pixel = 0;
-        wa.event_mask = StructureNotifyMask | KeyPressMask | KeyReleaseMask |
-                        PointerMotionMask | ButtonPressMask | ButtonReleaseMask |
-                        ExposureMask | FocusChangeMask | VisibilityChangeMask |
-                        EnterWindowMask | LeaveWindowMask | PropertyChangeMask;
-
-        _glfwGrabErrorHandlerX11();
-
-        window->x11.handle = XCreateWindow(_glfw.x11.display,
-                                           _glfw.x11.root,
-                                           0, 0,
-                                           width, height,
-                                           0,      // Border width
-                                           depth,  // Color depth
-                                           InputOutput,
-                                           visual,
-                                           wamask,
-                                           &wa);
-
-        _glfwReleaseErrorHandlerX11();
-
-        if (!window->x11.handle)
-        {
-            _glfwInputErrorX11(GLFW_PLATFORM_ERROR,
-                               "X11: Failed to create window");
-            return false;
-        }
-
-        XSaveContext(_glfw.x11.display,
-                     window->x11.handle,
-                     _glfw.x11.context,
-                     (XPointer) window);
+        _glfwInputErrorX11(GLFW_PLATFORM_ERROR,
+                           "X11: Failed to create window");
+        return false;
     }
 
+    XSaveContext(_glfw.x11.display,
+                 window->x11.handle,
+                 _glfw.x11.context,
+                 (XPointer) window);
+
     if (!wndconfig->decorated)
         _glfwPlatformSetWindowDecorated(window, false);
 
@@ -589,7 +597,7 @@ static bool createNativeWindow(_GLFWwindow* window,
         {
             XChangeProperty(_glfw.x11.display, window->x11.handle,
                             _glfw.x11.NET_WM_STATE, XA_ATOM, 32,
-                            PropModeReplace, (unsigned char*) &states, count);
+                            PropModeReplace, (unsigned char*) states, count);
         }
     }
 
@@ -880,7 +888,7 @@ static const char* getSelectionString(Atom selection)
         Atom actualType;
         int actualFormat;
         unsigned long itemCount, bytesAfter;
-        double start = glfwGetTime();
+        monotonic_t start = glfwGetTime();
         XEvent notification, dummy;
 
         XConvertSelection(_glfw.x11.display,
@@ -895,10 +903,10 @@ static const char* getSelectionString(Atom selection)
                                        SelectionNotify,
                                        &notification))
         {
-            double time = glfwGetTime();
-            if (time - start > 2)
+            monotonic_t time = glfwGetTime();
+            if (time - start > s_to_monotonic_t(2ll))
                 return "";
-            waitForX11Event(2.0 - (time - start));
+            waitForX11Event(s_to_monotonic_t(2ll) - (time - start));
         }
 
         if (notification.xselection.property == None)
@@ -935,10 +943,10 @@ static const char* getSelectionString(Atom selection)
                                       isSelPropNewValueNotify,
                                       (XPointer) &notification))
                 {
-                    double time = glfwGetTime();
-                    if (time - start > 2)
+                    monotonic_t time = glfwGetTime();
+                    if (time - start > s_to_monotonic_t(2ll))
                         return "";
-                    waitForX11Event(2.0 - (time - start));
+                    waitForX11Event(s_to_monotonic_t(2ll) - (time - start));
                 }
 
                 XFree(data);
@@ -1177,6 +1185,12 @@ static void processEvent(XEvent *event)
 
     switch (event->type)
     {
+        case ReparentNotify:
+        {
+            window->x11.parent = event->xreparent.parent;
+            return;
+        }
+
         case KeyPress:
         {
             UPDATE_KEYMAP_IF_NEEDED;
@@ -1370,18 +1384,28 @@ static void processEvent(XEvent *event)
                 window->x11.height = event->xconfigure.height;
             }
 
-            if (event->xconfigure.x != window->x11.xpos ||
-                event->xconfigure.y != window->x11.ypos)
-            {
-                if (event->xany.send_event)
-                {
-                    _glfwInputWindowPos(window,
-                                        event->xconfigure.x,
-                                        event->xconfigure.y);
+            int xpos = event->xconfigure.x;
+            int ypos = event->xconfigure.y;
 
-                    window->x11.xpos = event->xconfigure.x;
-                    window->x11.ypos = event->xconfigure.y;
-                }
+            // NOTE: ConfigureNotify events from the server are in local
+            //       coordinates, so if we are reparented we need to translate
+            //       the position into root (screen) coordinates
+            if (!event->xany.send_event && window->x11.parent != _glfw.x11.root)
+            {
+                Window dummy;
+                XTranslateCoordinates(_glfw.x11.display,
+                                      window->x11.parent,
+                                      _glfw.x11.root,
+                                      xpos, ypos,
+                                      &xpos, &ypos,
+                                      &dummy);
+            }
+
+            if (xpos != window->x11.xpos || ypos != window->x11.ypos)
+            {
+                _glfwInputWindowPos(window, xpos, ypos);
+                window->x11.xpos = xpos;
+                window->x11.ypos = ypos;
             }
 
             return;
@@ -2029,6 +2053,14 @@ void _glfwPlatformSetWindowAspectRatio(_GLFWwindow* window, int numer UNUSED, in
     XFlush(_glfw.x11.display);
 }
 
+void _glfwPlatformSetWindowSizeIncrements(_GLFWwindow* window, int widthincr UNUSED, int heightincr UNUSED)
+{
+    int width, height;
+    _glfwPlatformGetWindowSize(window, &width, &height);
+    updateNormalHints(window, width, height);
+    XFlush(_glfw.x11.display);
+}
+
 void _glfwPlatformGetFramebufferSize(_GLFWwindow* window, int* width, int* height)
 {
     _glfwPlatformGetWindowSize(window, width, height);
@@ -2066,7 +2098,7 @@ void _glfwPlatformGetWindowFrameSize(_GLFWwindow* window,
                               isFrameExtentsEvent,
                               (XPointer) window))
         {
-            if (!waitForX11Event(0.5))
+            if (!waitForX11Event(ms_to_monotonic_t(500ll)))
             {
                 _glfwInputError(GLFW_PLATFORM_ERROR,
                                 "X11: The window manager has a broken _NET_REQUEST_FRAME_EXTENTS implementation; please report this issue");
@@ -2103,9 +2135,9 @@ void _glfwPlatformGetWindowContentScale(_GLFWwindow* window UNUSED,
         *yscale = _glfw.x11.contentScaleY;
 }
 
-double _glfwPlatformGetDoubleClickInterval(_GLFWwindow* window UNUSED)
+monotonic_t _glfwPlatformGetDoubleClickInterval(_GLFWwindow* window UNUSED)
 {
-    return 0.5;
+    return ms_to_monotonic_t(500ll);
 }
 
 void _glfwPlatformIconifyWindow(_GLFWwindow* window)
@@ -2141,18 +2173,67 @@ void _glfwPlatformRestoreWindow(_GLFWwindow* window)
 
 void _glfwPlatformMaximizeWindow(_GLFWwindow* window)
 {
-    if (_glfw.x11.NET_WM_STATE &&
-        _glfw.x11.NET_WM_STATE_MAXIMIZED_VERT &&
-        _glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ)
+    if (!_glfw.x11.NET_WM_STATE ||
+        !_glfw.x11.NET_WM_STATE_MAXIMIZED_VERT ||
+        !_glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ)
+    {
+        return;
+    }
+
+    if (_glfwPlatformWindowVisible(window))
     {
         sendEventToWM(window,
-                      _glfw.x11.NET_WM_STATE,
-                      _NET_WM_STATE_ADD,
-                      _glfw.x11.NET_WM_STATE_MAXIMIZED_VERT,
-                      _glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ,
-                      1, 0);
-        XFlush(_glfw.x11.display);
+                    _glfw.x11.NET_WM_STATE,
+                    _NET_WM_STATE_ADD,
+                    _glfw.x11.NET_WM_STATE_MAXIMIZED_VERT,
+                    _glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ,
+                    1, 0);
     }
+    else
+    {
+        Atom* states = NULL;
+        unsigned long count =
+            _glfwGetWindowPropertyX11(window->x11.handle,
+                                      _glfw.x11.NET_WM_STATE,
+                                      XA_ATOM,
+                                      (unsigned char**) &states);
+
+        // NOTE: We don't check for failure as this property may not exist yet
+        //       and that's fine (and we'll create it implicitly with append)
+
+        Atom missing[2] =
+        {
+            _glfw.x11.NET_WM_STATE_MAXIMIZED_VERT,
+            _glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ
+        };
+        unsigned long missingCount = 2;
+
+        for (unsigned long i = 0;  i < count;  i++)
+        {
+            for (unsigned long j = 0;  j < missingCount;  j++)
+            {
+                if (states[i] == missing[j])
+                {
+                    missing[j] = missing[missingCount - 1];
+                    missingCount--;
+                }
+            }
+        }
+
+        if (states)
+            XFree(states);
+
+        if (!missingCount)
+            return;
+
+        XChangeProperty(_glfw.x11.display, window->x11.handle,
+                        _glfw.x11.NET_WM_STATE, XA_ATOM, 32,
+                        PropModeAppend,
+                        (unsigned char*) missing,
+                        missingCount);
+    }
+
+    XFlush(_glfw.x11.display);
 }
 
 void _glfwPlatformShowWindow(_GLFWwindow* window)
@@ -2172,6 +2253,9 @@ void _glfwPlatformHideWindow(_GLFWwindow* window)
 
 void _glfwPlatformRequestWindowAttention(_GLFWwindow* window)
 {
+    if (!_glfw.x11.NET_WM_STATE || !_glfw.x11.NET_WM_STATE_DEMANDS_ATTENTION)
+        return;
+
     sendEventToWM(window,
                   _glfw.x11.NET_WM_STATE,
                   _NET_WM_STATE_ADD,
@@ -2188,7 +2272,7 @@ void _glfwPlatformFocusWindow(_GLFWwindow* window)
 {
     if (_glfw.x11.NET_ACTIVE_WINDOW)
         sendEventToWM(window, _glfw.x11.NET_ACTIVE_WINDOW, 1, 0, 0, 0, 0);
-    else
+    else if (_glfwPlatformWindowVisible(window))
     {
         XRaiseWindow(_glfw.x11.display, window->x11.handle);
         XSetInputFocus(_glfw.x11.display, window->x11.handle,
@@ -2350,33 +2434,24 @@ void _glfwPlatformSetWindowResizable(_GLFWwindow* window, bool enabled UNUSED)
 
 void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, bool enabled)
 {
-    if (enabled)
+    struct
     {
-        XDeleteProperty(_glfw.x11.display,
-                        window->x11.handle,
-                        _glfw.x11.MOTIF_WM_HINTS);
-    }
-    else
-    {
-        struct
-        {
-            unsigned long flags;
-            unsigned long functions;
-            unsigned long decorations;
-            long input_mode;
-            unsigned long status;
-        } hints;
+        unsigned long flags;
+        unsigned long functions;
+        unsigned long decorations;
+        long input_mode;
+        unsigned long status;
+    } hints = {0};
 
-        hints.flags = 2;       // Set decorations
-        hints.decorations = 0; // No decorations
+    hints.flags = MWM_HINTS_DECORATIONS;
+    hints.decorations = enabled ? MWM_DECOR_ALL : 0;
 
-        XChangeProperty(_glfw.x11.display, window->x11.handle,
-                        _glfw.x11.MOTIF_WM_HINTS,
-                        _glfw.x11.MOTIF_WM_HINTS, 32,
-                        PropModeReplace,
-                        (unsigned char*) &hints,
-                        sizeof(hints) / sizeof(long));
-    }
+    XChangeProperty(_glfw.x11.display, window->x11.handle,
+                    _glfw.x11.MOTIF_WM_HINTS,
+                    _glfw.x11.MOTIF_WM_HINTS, 32,
+                    PropModeReplace,
+                    (unsigned char*) &hints,
+                    sizeof(hints) / sizeof(long));
 }
 
 void _glfwPlatformSetWindowFloating(_GLFWwindow* window, bool enabled)
@@ -2386,7 +2461,7 @@ void _glfwPlatformSetWindowFloating(_GLFWwindow* window, bool enabled)
 
     if (_glfwPlatformWindowVisible(window))
     {
-        const Atom action = enabled ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
+        const long action = enabled ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
         sendEventToWM(window,
                       _glfw.x11.NET_WM_STATE,
                       action,
@@ -2395,15 +2470,16 @@ void _glfwPlatformSetWindowFloating(_GLFWwindow* window, bool enabled)
     }
     else
     {
-        Atom* states;
+        Atom* states = NULL;
         unsigned long i, count;
 
         count = _glfwGetWindowPropertyX11(window->x11.handle,
                                           _glfw.x11.NET_WM_STATE,
                                           XA_ATOM,
                                           (unsigned char**) &states);
-        if (!states)
-            return;
+
+        // NOTE: We don't check for failure as this property may not exist yet
+        //       and that's fine (and we'll create it implicitly with append)
 
         if (enabled)
         {
@@ -2413,32 +2489,36 @@ void _glfwPlatformSetWindowFloating(_GLFWwindow* window, bool enabled)
                     break;
             }
 
-            if (i == count)
-            {
-                XChangeProperty(_glfw.x11.display, window->x11.handle,
-                                _glfw.x11.NET_WM_STATE, XA_ATOM, 32,
-                                PropModeAppend,
-                                (unsigned char*) &_glfw.x11.NET_WM_STATE_ABOVE,
-                                1);
-            }
+            if (i < count)
+                return;
+
+            XChangeProperty(_glfw.x11.display, window->x11.handle,
+                            _glfw.x11.NET_WM_STATE, XA_ATOM, 32,
+                            PropModeAppend,
+                            (unsigned char*) &_glfw.x11.NET_WM_STATE_ABOVE,
+                            1);
         }
-        else
+        else if (states)
         {
             for (i = 0;  i < count;  i++)
             {
                 if (states[i] == _glfw.x11.NET_WM_STATE_ABOVE)
-                {
-                    states[i] = states[count - 1];
-                    count--;
-                }
+                    break;
             }
 
+            if (i == count)
+                return;
+
+            states[i] = states[count - 1];
+            count--;
+
             XChangeProperty(_glfw.x11.display, window->x11.handle,
                             _glfw.x11.NET_WM_STATE, XA_ATOM, 32,
-                            PropModeReplace, (unsigned char*) &states, count);
+                            PropModeReplace, (unsigned char*) states, count);
         }
 
-        XFree(states);
+        if (states)
+            XFree(states);
     }
 
     XFlush(_glfw.x11.display);
@@ -2527,11 +2607,11 @@ void _glfwPlatformPollEvents(void)
 
 void _glfwPlatformWaitEvents(void)
 {
-    double timeout = _glfwDispatchX11Events() ? 0 : -1;
+    monotonic_t timeout = _glfwDispatchX11Events() ? 0 : -1;
     handleEvents(timeout);
 }
 
-void _glfwPlatformWaitEventsTimeout(double timeout)
+void _glfwPlatformWaitEventsTimeout(monotonic_t timeout)
 {
     if (_glfwDispatchX11Events()) timeout = 0;
     handleEvents(timeout);
@@ -2585,13 +2665,13 @@ void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode)
     XFlush(_glfw.x11.display);
 }
 
-const char* _glfwPlatformGetScancodeName(int scancode)
+const char* _glfwPlatformGetNativeKeyName(int native_key)
 {
 
-    return glfw_xkb_keysym_name(scancode);
+    return glfw_xkb_keysym_name(native_key);
 }
 
-int _glfwPlatformGetKeyScancode(int key)
+int _glfwPlatformGetNativeKeyForKey(int key)
 {
     return glfw_xkb_sym_for_key(key);
 }
@@ -2870,7 +2950,7 @@ GLFWAPI Window glfwGetX11Window(GLFWwindow* handle)
     return window->x11.handle;
 }
 
-GLFWAPI int glfwGetXKBScancode(const char* keyName, bool caseSensitive) {
+GLFWAPI int glfwGetNativeKeyForName(const char* keyName, bool caseSensitive) {
     return glfw_xkb_keysym_from_name(keyName, caseSensitive);
 }
 

glfw/xkb_glfw.c

@@ -61,6 +61,7 @@ START_ALLOW_CASE_RANGE
         S(bracketleft, LEFT_BRACKET); \
         S(backslash, BACKSLASH); \
         S(bracketright, RIGHT_BRACKET); \
+        S(asciicircum, CIRCUMFLEX); \
         S(underscore, UNDERSCORE); \
         S(grave, GRAVE_ACCENT); \
         R(a, z, A, Z); \
@@ -437,24 +438,22 @@ glfw_xkb_update_modifiers(_GLFWXKBData *xkb, xkb_mod_mask_t depressed, xkb_mod_m
 }
 
 bool
-glfw_xkb_should_repeat(_GLFWXKBData *xkb, xkb_keycode_t scancode) {
+glfw_xkb_should_repeat(_GLFWXKBData *xkb, xkb_keycode_t keycode) {
 #ifdef _GLFW_WAYLAND
-    scancode += 8;
+    keycode += 8;
 #endif
-    return xkb_keymap_key_repeats(xkb->keymap, scancode);
+    return xkb_keymap_key_repeats(xkb->keymap, keycode);
 }
 
 
-static KeyEvent key_event = {0};
-
 static inline xkb_keysym_t
-compose_symbol(struct xkb_compose_state *composeState, xkb_keysym_t sym, int *compose_completed) {
+compose_symbol(struct xkb_compose_state *composeState, xkb_keysym_t sym, int *compose_completed, char *key_text, int n) {
     *compose_completed = 0;
     if (sym == XKB_KEY_NoSymbol || !composeState) return sym;
     if (xkb_compose_state_feed(composeState, sym) != XKB_COMPOSE_FEED_ACCEPTED) return sym;
     switch (xkb_compose_state_get_status(composeState)) {
         case XKB_COMPOSE_COMPOSED:
-            xkb_compose_state_get_utf8(composeState, key_event.text, sizeof(key_event.text));
+            xkb_compose_state_get_utf8(composeState, key_text, n);
             *compose_completed = 1;
             return xkb_compose_state_get_one_sym(composeState);
         case XKB_COMPOSE_COMPOSING:
@@ -534,11 +533,14 @@ glfw_xkb_update_ime_state(_GLFWwindow *w, _GLFWXKBData *xkb, int which, int a, i
 }
 
 void
-glfw_xkb_key_from_ime(KeyEvent *ev, bool handled_by_ime, bool failed) {
+glfw_xkb_key_from_ime(_GLFWIBUSKeyEvent *ev, bool handled_by_ime, bool failed) {
     _GLFWwindow *window = _glfwWindowForId(ev->window_id);
     if (failed && window && window->callbacks.keyboard) {
         // notify application to remove any existing pre-edit text
-        window->callbacks.keyboard((GLFWwindow*) window, GLFW_KEY_UNKNOWN, 0, GLFW_PRESS, 0, "", 1);
+        GLFWkeyevent fake_ev;
+        _glfwInitializeKeyEvent(&fake_ev, GLFW_KEY_UNKNOWN, 0, GLFW_PRESS, 0);
+        fake_ev.ime_state = 1;
+        window->callbacks.keyboard((GLFWwindow*) window, &fake_ev);
     }
     static xkb_keycode_t last_handled_press_keycode = 0;
     // We filter out release events that correspond to the last press event
@@ -547,53 +549,58 @@ glfw_xkb_key_from_ime(KeyEvent *ev, bool handled_by_ime, bool failed) {
     // you'd need to implement a ring buffer to store pending key presses.
     xkb_keycode_t prev_handled_press = last_handled_press_keycode;
     last_handled_press_keycode = 0;
-    bool is_release = ev->action == GLFW_RELEASE;
-    debug("From IBUS: scancode: 0x%x name: %s is_release: %d\n", ev->keycode, glfw_xkb_keysym_name(ev->keysym), is_release);
-    if (window && !handled_by_ime && !(is_release && ev->keycode == prev_handled_press)) {
+    bool is_release = ev->glfw_ev.action == GLFW_RELEASE;
+    debug("From IBUS: native_key: 0x%x name: %s is_release: %d\n", ev->glfw_ev.native_key, glfw_xkb_keysym_name(ev->glfw_ev.key), is_release);
+    if (window && !handled_by_ime && !(is_release && ev->glfw_ev.native_key == (int) prev_handled_press)) {
         debug("↳ to application: glfw_keycode: 0x%x (%s) keysym: 0x%x (%s) action: %s %s text: %s\n",
-            ev->glfw_keycode, _glfwGetKeyName(ev->glfw_keycode), ev->keysym, glfw_xkb_keysym_name(ev->keysym),
-            (ev->action == GLFW_RELEASE ? "RELEASE" : (ev->action == GLFW_PRESS ? "PRESS" : "REPEAT")),
-            format_mods(ev->glfw_modifiers), ev->text
+            ev->glfw_ev.native_key, _glfwGetKeyName(ev->glfw_ev.native_key), ev->glfw_ev.key, glfw_xkb_keysym_name(ev->glfw_ev.key),
+            (ev->glfw_ev.action == GLFW_RELEASE ? "RELEASE" : (ev->glfw_ev.action == GLFW_PRESS ? "PRESS" : "REPEAT")),
+            format_mods(ev->glfw_ev.mods), ev->glfw_ev.text
         );
-        _glfwInputKeyboard(window, ev->glfw_keycode, ev->keysym, ev->action, ev->glfw_modifiers, ev->text, 0);
+
+        ev->glfw_ev.ime_state = 0;
+        _glfwInputKeyboard(window, &ev->glfw_ev);
     } else debug("↳ discarded\n");
-    if (!is_release && handled_by_ime) last_handled_press_keycode = ev->keycode;
+    if (!is_release && handled_by_ime)
+      last_handled_press_keycode = ev->glfw_ev.native_key;
 }
 
 void
-glfw_xkb_handle_key_event(_GLFWwindow *window, _GLFWXKBData *xkb, xkb_keycode_t scancode, int action) {
+glfw_xkb_handle_key_event(_GLFWwindow *window, _GLFWXKBData *xkb, xkb_keycode_t xkb_keycode, int action) {
+    static char key_text[64] = {0};
     const xkb_keysym_t *syms, *clean_syms, *default_syms;
-    xkb_keysym_t glfw_sym;
-    xkb_keycode_t code_for_sym = scancode;
-    key_event.ibus_keycode = scancode;
+    xkb_keysym_t xkb_sym;
+    xkb_keycode_t code_for_sym = xkb_keycode, ibus_keycode = xkb_keycode;
+    GLFWkeyevent glfw_ev;
+    _glfwInitializeKeyEvent(&glfw_ev, GLFW_KEY_UNKNOWN, 0, GLFW_PRESS, 0); // init with default values
 #ifdef _GLFW_WAYLAND
     code_for_sym += 8;
 #else
-    key_event.ibus_keycode -= 8;
+    ibus_keycode -= 8;
 #endif
-    debug("%s scancode: 0x%x ", action == GLFW_RELEASE ? "Release" : "Press", scancode);
+    debug("%s xkb_keycode: 0x%x ", action == GLFW_RELEASE ? "Release" : "Press", xkb_keycode);
     XKBStateGroup *sg = &xkb->states;
     int num_syms = xkb_state_key_get_syms(sg->state, code_for_sym, &syms);
     int num_clean_syms = xkb_state_key_get_syms(sg->clean_state, code_for_sym, &clean_syms);
-    key_event.text[0] = 0;
+    key_text[0] = 0;
     // According to the documentation of xkb_compose_state_feed it does not
     // support multi-sym events, so we ignore them
     if (num_syms != 1 || num_clean_syms != 1) {
         debug("num_syms: %d num_clean_syms: %d ignoring event\n", num_syms, num_clean_syms);
         return;
     }
-    glfw_sym = clean_syms[0];
+    xkb_sym = clean_syms[0];
     debug("clean_sym: %s ", glfw_xkb_keysym_name(clean_syms[0]));
     if (action == GLFW_PRESS || action == GLFW_REPEAT) {
         const char *text_type = "composed_text";
         int compose_completed;
-        glfw_sym = compose_symbol(sg->composeState, syms[0], &compose_completed);
-        if (glfw_sym == XKB_KEY_NoSymbol && !compose_completed) {
+        xkb_sym = compose_symbol(sg->composeState, syms[0], &compose_completed, key_text, sizeof(key_text));
+        if (xkb_sym == XKB_KEY_NoSymbol && !compose_completed) {
             debug("compose not complete, ignoring.\n");
             return;
         }
-        debug("composed_sym: %s ", glfw_xkb_keysym_name(glfw_sym));
-        if (glfw_sym == syms[0]) { // composed sym is the same as non-composed sym
+        debug("composed_sym: %s ", glfw_xkb_keysym_name(xkb_sym));
+        if (xkb_sym == syms[0]) { // composed sym is the same as non-composed sym
             // Only use the clean_sym if no mods other than the mods we report
             // are active (for example if ISO_Shift_Level_* mods are active
             // they are not reported by GLFW so the key should be the shifted
@@ -601,37 +608,58 @@ glfw_xkb_handle_key_event(_GLFWwindow *window, _GLFWXKBData *xkb, xkb_keycode_t
             xkb_mod_mask_t consumed_unknown_mods = xkb_state_key_get_consumed_mods(sg->state, code_for_sym) & sg->activeUnknownModifiers;
             if (sg->activeUnknownModifiers) debug("%s", format_xkb_mods(xkb, "active_unknown_mods", sg->activeUnknownModifiers));
             if (consumed_unknown_mods) { debug("%s", format_xkb_mods(xkb, "consumed_unknown_mods", consumed_unknown_mods)); }
-            else glfw_sym = clean_syms[0];
+            else xkb_sym = clean_syms[0];
             // xkb returns text even if alt and/or super are pressed
-            if ( ((GLFW_MOD_CONTROL | GLFW_MOD_ALT | GLFW_MOD_SUPER) & sg->modifiers) == 0) xkb_state_key_get_utf8(sg->state, code_for_sym, key_event.text, sizeof(key_event.text));
+            if ( ((GLFW_MOD_CONTROL | GLFW_MOD_ALT | GLFW_MOD_SUPER) & sg->modifiers) == 0) {
+              xkb_state_key_get_utf8(sg->state, code_for_sym, key_text, sizeof(key_text));
+            }
             text_type = "text";
         }
-        if ((1 <= key_event.text[0] && key_event.text[0] <= 31) || key_event.text[0] == 127) key_event.text[0] = 0;  // don't send text for ascii control codes
-        if (key_event.text[0]) { debug("%s: %s ", text_type, key_event.text); }
+        if ((1 <= key_text[0] && key_text[0] <= 31) || key_text[0] == 127) {
+          key_text[0] = 0;  // don't send text for ascii control codes
+        }
+        if (key_text[0]) { debug("%s: %s ", text_type, key_text); }
     }
-    int glfw_keycode = glfw_key_for_sym(glfw_sym);
+    int glfw_sym = glfw_key_for_sym(xkb_sym);
     bool is_fallback = false;
-    if (glfw_keycode == GLFW_KEY_UNKNOWN && !key_event.text[0]) {
+    if (glfw_sym == GLFW_KEY_UNKNOWN && !key_text[0]) {
         int num_default_syms = xkb_state_key_get_syms(sg->default_state, code_for_sym, &default_syms);
         if (num_default_syms > 0) {
-            glfw_sym = default_syms[0];
-            glfw_keycode = glfw_key_for_sym(glfw_sym);
+            xkb_sym = default_syms[0];
+            glfw_sym = glfw_key_for_sym(xkb_sym);
             is_fallback = true;
         }
     }
     debug(
         "%s%s: %d (%s) xkb_key: %d (%s)\n",
         format_mods(sg->modifiers),
-        is_fallback ? "glfw_fallback_key" : "glfw_key", glfw_keycode, _glfwGetKeyName(glfw_keycode),
-        glfw_sym, glfw_xkb_keysym_name(glfw_sym)
+        is_fallback ? "glfw_fallback_key" : "glfw_key", glfw_sym, _glfwGetKeyName(glfw_sym),
+        xkb_sym, glfw_xkb_keysym_name(xkb_sym)
     );
-    key_event.action = action; key_event.glfw_modifiers = sg->modifiers;
-    key_event.keycode = scancode; key_event.keysym = glfw_sym;
-    key_event.window_id = window->id; key_event.glfw_keycode = glfw_keycode;
-    key_event.ibus_sym = syms[0];
-    if (ibus_process_key(&key_event, &xkb->ibus)) {
-        debug("↳ to IBUS: keycode: 0x%x keysym: 0x%x (%s) %s\n", key_event.ibus_keycode, key_event.ibus_sym, glfw_xkb_keysym_name(key_event.ibus_sym), format_mods(key_event.glfw_modifiers));
+
+    // NOTE: On linux, the reported native key identifier is the XKB keysym value.
+    // Do not confuse `native_key` with `xkb_keycode` (the native keycode reported for the
+    // glfw event VS the X internal code for a key).
+    //
+    // We use the XKB keysym instead of the X keycode to be able to go back-and-forth between
+    // the GLFW keysym and the XKB keysym when needed, which is not possible using the X keycode,
+    // because of the lost information when resolving the keycode to the keysym, like consumed
+    // mods.
+    glfw_ev.native_key = xkb_sym;
+
+    glfw_ev.action = action;
+    glfw_ev.key = glfw_sym;
+    glfw_ev.mods = sg->modifiers;
+    glfw_ev.text = key_text;
+
+    _GLFWIBUSKeyEvent ibus_ev;
+    ibus_ev.glfw_ev = glfw_ev;
+    ibus_ev.ibus_keycode = ibus_keycode;
+    ibus_ev.window_id = window->id;
+    ibus_ev.ibus_keysym = syms[0];
+    if (ibus_process_key(&ibus_ev, &xkb->ibus)) {
+        debug("↳ to IBUS: keycode: 0x%x keysym: 0x%x (%s) %s\n", ibus_ev.ibus_keycode, ibus_ev.ibus_keysym, glfw_xkb_keysym_name(ibus_ev.ibus_keysym), format_mods(ibus_ev.glfw_ev.mods));
     } else {
-        _glfwInputKeyboard(window, glfw_keycode, glfw_sym, action, sg->modifiers, key_event.text, 0);
+        _glfwInputKeyboard(window, &glfw_ev);
     }
 }

glfw/xkb_glfw.h

@@ -87,10 +87,10 @@ void glfw_xkb_release(_GLFWXKBData *xkb);
 bool glfw_xkb_create_context(_GLFWXKBData *xkb);
 bool glfw_xkb_compile_keymap(_GLFWXKBData *xkb, const char *map_str);
 void glfw_xkb_update_modifiers(_GLFWXKBData *xkb, xkb_mod_mask_t depressed, xkb_mod_mask_t latched, xkb_mod_mask_t locked, xkb_layout_index_t base_group, xkb_layout_index_t latched_group, xkb_layout_index_t locked_group);
-bool glfw_xkb_should_repeat(_GLFWXKBData *xkb, xkb_keycode_t scancode);
+bool glfw_xkb_should_repeat(_GLFWXKBData *xkb, xkb_keycode_t keycode);
 const char* glfw_xkb_keysym_name(xkb_keysym_t sym);
 xkb_keysym_t glfw_xkb_sym_for_key(int key);
-void glfw_xkb_handle_key_event(_GLFWwindow *window, _GLFWXKBData *xkb, xkb_keycode_t scancode, int action);
+void glfw_xkb_handle_key_event(_GLFWwindow *window, _GLFWXKBData *xkb, xkb_keycode_t keycode, int action);
 int glfw_xkb_keysym_from_name(const char *name, bool case_sensitive);
 void glfw_xkb_update_ime_state(_GLFWwindow *w, _GLFWXKBData *xkb, int which, int a, int b, int c, int d);
-void glfw_xkb_key_from_ime(KeyEvent *ev, bool handled_by_ime, bool failed);
+void glfw_xkb_key_from_ime(_GLFWIBUSKeyEvent *ev, bool handled_by_ime, bool failed);

kittens/diff/main.py

@@ -2,14 +2,17 @@
 # vim:fileencoding=utf-8
 # License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
 
+import atexit
 import os
 import signal
+import subprocess
 import sys
+import tempfile
 import warnings
 from collections import defaultdict
+from contextlib import suppress
 from functools import partial
 from gettext import gettext as _
-from contextlib import suppress
 
 from kitty.cli import CONFIG_HELP, parse_args
 from kitty.constants import appname
@@ -506,7 +509,7 @@ def showwarning(message, category, filename, lineno, file=None, line=None):
 
 
 showwarning.warnings = []
-help_text = 'Show a side-by-side diff of the specified files/directories'
+help_text = 'Show a side-by-side diff of the specified files/directories. You can also use ssh:hostname:remote-file-path to diff remote files.'
 usage = 'file_or_directory_left file_or_directory_right'
 
 
@@ -516,6 +519,20 @@ def terminate_processes(processes):
             os.kill(pid, signal.SIGKILL)
 
 
+def get_remote_file(path):
+    if path.startswith('ssh:'):
+        parts = path.split(':', 2)
+        if len(parts) == 3:
+            hostname, rpath = parts[1:]
+            with tempfile.NamedTemporaryFile(suffix='-' + os.path.basename(rpath), prefix='remote:', delete=False) as tf:
+                atexit.register(os.remove, tf.name)
+                p = subprocess.Popen(['ssh', hostname, 'cat', rpath], stdout=tf)
+                if p.wait() != 0:
+                    raise SystemExit(p.returncode)
+                return tf.name
+    return path
+
+
 def main(args):
     warnings.showwarning = showwarning
     args, items = parse_args(args[1:], OPTIONS, usage, help_text, 'kitty +kitten diff')
@@ -528,6 +545,7 @@ def main(args):
     opts = init_config(args)
     set_diff_command(opts.diff_cmd)
     lines_for_path.replace_tab_by = opts.replace_tab_by
+    left, right = map(get_remote_file, (left, right))
     for f in left, right:
         if not os.path.exists(f):
             raise SystemExit('{} does not exist'.format(f))

kittens/hints/main.py

@@ -21,16 +21,18 @@ from ..tui.operations import faint, styled
 
 URL_PREFIXES = 'http https file ftp'.split()
 DEFAULT_HINT_ALPHABET = string.digits + string.ascii_lowercase
+DEFAULT_REGEX = r'(?m)^\s*(.+)\s*$'
 screen_size = screen_size_function()
 
 
 class Mark:
 
-    __slots__ = ('index', 'start', 'end', 'text')
+    __slots__ = ('index', 'start', 'end', 'text', 'groupdict')
 
-    def __init__(self, index, start, end, text):
+    def __init__(self, index, start, end, text, groupdict):
         self.index, self.start, self.end = index, start, end
         self.text = text
+        self.groupdict = groupdict
 
 
 @lru_cache(maxsize=2048)
@@ -94,6 +96,14 @@ class Hints(Handler):
         self.chosen = []
         self.reset()
 
+    @property
+    def text_matches(self):
+        return [m.text + self.match_suffix for m in self.chosen]
+
+    @property
+    def groupdicts(self):
+        return [m.groupdict for m in self.chosen]
+
     def get_match_suffix(self, args):
         if args.add_trailing_space == 'always':
             return ' '
@@ -126,7 +136,7 @@ class Hints(Handler):
                 if encode_hint(idx, self.alphabet).startswith(self.current_input)
             ]
             if len(matches) == 1:
-                self.chosen.append(matches[0].text + self.match_suffix)
+                self.chosen.append(matches[0])
                 if self.multiple:
                     self.ignore_mark_indices.add(matches[0].index)
                     self.reset()
@@ -144,7 +154,7 @@ class Hints(Handler):
         elif key_event is enter_key and self.current_input:
             try:
                 idx = decode_hint(self.current_input, self.alphabet)
-                self.chosen.append(self.index_map[idx].text + self.match_suffix)
+                self.chosen.append(self.index_map[idx])
                 self.ignore_mark_indices.add(idx)
             except Exception:
                 self.current_input = ''
@@ -176,12 +186,13 @@ class Hints(Handler):
 
 
 def regex_finditer(pat, minimum_match_length, text):
+    has_named_groups = bool(pat.groupindex)
     for m in pat.finditer(text):
-        s, e = m.span(pat.groups)
+        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
+            yield s, e, m.groupdict()
 
 
 closing_bracket_map = {'(': ')', '[': ']', '{': '}', '<': '>', '*': '*', '"': '"', "'": "'"}
@@ -240,21 +251,23 @@ def quotes(text, s, e):
 
 def mark(pattern, post_processors, text, args):
     pat = re.compile(pattern)
-    for idx, (s, e) in enumerate(regex_finditer(pat, args.minimum_match_length, text)):
+    for idx, (s, e, groupdict) in enumerate(regex_finditer(pat, args.minimum_match_length, text)):
         for func in post_processors:
             s, e = func(text, s, e)
         mark_text = text[s:e].replace('\n', '').replace('\0', '')
-        yield Mark(idx, s, e, mark_text)
+        yield Mark(idx, s, e, mark_text, groupdict)
 
 
-def run_loop(args, text, all_marks, index_map):
+def run_loop(args, text, all_marks, index_map, extra_cli_args=()):
     loop = Loop()
     handler = Hints(text, all_marks, index_map, args)
     loop.loop(handler)
     if handler.chosen and loop.return_code == 0:
-        return {'match': handler.chosen, 'programs': args.program,
-                'multiple_joiner': args.multiple_joiner,
-                'type': args.type}
+        return {
+            'match': handler.text_matches, 'programs': args.program,
+            'multiple_joiner': args.multiple_joiner, 'customize_processing': args.customize_processing,
+            'type': args.type, 'groupdicts': handler.groupdicts, 'extra_cli_args': extra_cli_args, 'linenum_action': args.linenum_action
+        }
     raise SystemExit(loop.return_code)
 
 
@@ -311,11 +324,44 @@ def parse_input(text):
     return convert_text(text, cols)
 
 
-def run(args, text):
+def linenum_marks(text, args, Mark, extra_cli_args, *a):
+    regex = args.regex
+    if regex == DEFAULT_REGEX:
+        regex = r'(?P<path>(?:\S*/\S+)|(?:\S+[.][a-zA-Z0-9]{2,7})):(?P<line>\d+)'
+    yield from mark(regex, [brackets, quotes], text, args)
+
+
+def load_custom_processor(customize_processing):
+    if customize_processing.startswith('::import::'):
+        import importlib
+        m = importlib.import_module(customize_processing[len('::import::'):])
+        return {k: getattr(m, k) for k in dir(m)}
+    if customize_processing == '::linenum::':
+        return {'mark': linenum_marks, 'handle_result': linenum_handle_result}
+    from kitty.constants import config_dir
+    customize_processing = os.path.expandvars(os.path.expanduser(customize_processing))
+    if os.path.isabs(customize_processing):
+        custom_path = customize_processing
+    else:
+        custom_path = os.path.join(config_dir, customize_processing)
+    import runpy
+    return runpy.run_path(custom_path, run_name='__main__')
+
+
+def run(args, text, extra_cli_args=()):
     try:
-        pattern, post_processors = functions_for(args)
         text = parse_input(text)
-        all_marks = tuple(mark(pattern, post_processors, text, args))
+        pattern, post_processors = functions_for(args)
+        if args.type == 'linenum':
+            args.customize_processing = '::linenum::'
+        if args.customize_processing:
+            m = load_custom_processor(args.customize_processing)
+            if 'mark' in m:
+                all_marks = tuple(m['mark'](text, args, Mark, extra_cli_args))
+            else:
+                all_marks = tuple(mark(pattern, post_processors, text, args))
+        else:
+            all_marks = tuple(mark(pattern, post_processors, text, args))
         if not all_marks:
             input(_('No {} found, press Enter to quit.').format(
                 'URLs' if args.type == 'url' else 'matches'
@@ -325,7 +371,10 @@ def run(args, text):
         largest_index = all_marks[-1].index
         offset = max(0, args.hints_offset)
         for m in all_marks:
-            m.index = largest_index - m.index + offset
+            if args.ascending:
+                m.index += offset
+            else:
+                m.index = largest_index - m.index + offset
         index_map = {m.index: m for m in all_marks}
     except Exception:
         import traceback
@@ -333,7 +382,7 @@ def run(args, text):
         input('Press Enter to quit.')
         raise SystemExit(1)
 
-    return run_loop(args, text, all_marks, index_map)
+    return run_loop(args, text, all_marks, index_map, extra_cli_args)
 
 
 # CLI {{{
@@ -349,22 +398,41 @@ multiple times to run multiple programs.
 
 --type
 default=url
-choices=url,regex,path,line,hash,word
-The type of text to search for.
+choices=url,regex,path,line,hash,word,linenum
+The type of text to search for. A value of :code:`linenum` looks for error messages
+using the pattern specified with :option:`--regex`, which must have the named groups,
+path and line. If not specified, will look for :code:`path:line`.
+The :option:`--linenum-action` option controls what to do with the selected error message.
 
 
 --regex
-default=(?m)^\s*(.+)\s*$
+default={default_regex}
 The regular expression to use when :option:`kitty +kitten hints --type`=regex.
-The regular expression is in python syntax. If you specify a group in
+The regular expression is in python syntax. If you specify a numbered group in
 the regular expression only the group will be matched. This allow you to match
 text ignoring a prefix/suffix, as needed. The default expression matches lines.
 To match text over multiple lines you should prefix the regular expression with
 :code:`(?ms)`, which turns on MULTILINE and DOTALL modes for the regex engine.
+If you specify named groups and a :option:`kitty +kitten hints --program` then
+the program will be passed arguments corresponding to each named group of
+the form key=value.
+
+
+--linenum-action
+default=self
+type=choice
+choices=self,window,tab,os_window,background
+The action to perform on the matched errors. The actual action is whatever
+arguments are provided to the kitten, for example:
+:code:`kitty + kitten hints --type=linenum vim +{line} {path}`
+will open the matched path at the matched line number in vim. This option
+controls where the action is executed: :code:`self` means the current window,
+:code:`window` a new kitty window, :code:`tab` a new tab, :code:`os_window`
+a new OS window and :code:`background` run in the background.
 
 
 --url-prefixes
-default={0}
+default={url_prefixes}
 Comma separated list of recognized URL prefixes.
 
 
@@ -418,7 +486,22 @@ unless you specify the hints offset as zero the first match will be highlighted
 the second character you specify.
 
 
-'''.format(','.join(sorted(URL_PREFIXES))).format
+--ascending
+type=bool-set
+Have the hints increase from top to bottom instead of decreasing from top to bottom.
+
+
+--customize-processing
+Name of a python file in the kitty config directory which will be imported to provide
+custom implementations for pattern finding and performing actions
+on selected matches. See https://sw.kovidgoyal.net/kitty/kittens/hints.html
+for details. You can also specify absolute paths to load the script from elsewhere.
+
+
+'''.format(
+    default_regex=DEFAULT_REGEX, url_prefixes=','.join(sorted(URL_PREFIXES)),
+    line='{{line}}', path='{{path}}'
+).format
 help_text = 'Select text from the screen using the keyboard. Defaults to searching for URLs.'
 usage = ''
 
@@ -444,15 +527,50 @@ def main(args):
             print(e.args[0], file=sys.stderr)
             input(_('Press Enter to quit'))
         return
-    if items:
+    if items and not (args.customize_processing or args.type == 'linenum'):
         print('Extra command line arguments present: {}'.format(' '.join(items)), file=sys.stderr)
         input(_('Press Enter to quit'))
-    return run(args, text)
+    return run(args, text, items)
+
+
+def linenum_handle_result(args, data, target_window_id, boss, extra_cli_args, *a):
+    for m, g in zip(data['match'], data['groupdicts']):
+        if m:
+            path, line = g['path'], g['line']
+            path = path.split(':')[-1]
+            line = int(line)
+            break
+    else:
+        return
+
+    cmd = [x.format(path=path, line=line) for x in extra_cli_args or ('vim', '+{line}', '{path}')]
+    w = boss.window_id_map.get(target_window_id)
+    action = data['linenum_action']
+
+    if action == 'self':
+        if w is not None:
+            import shlex
+            w.paste_bytes(shlex.join(cmd) + '\r')
+    elif action == 'background':
+        import subprocess
+        subprocess.Popen(cmd)
+    else:
+        getattr(boss, {
+            'window': 'new_window_with_cwd', 'tab': 'new_tab_with_cwd', 'os_window': 'new_os_window_with_cwd'
+            }[action])(*cmd)
 
 
 def handle_result(args, data, target_window_id, boss):
+    if data['customize_processing']:
+        m = load_custom_processor(data['customize_processing'])
+        if 'handle_result' in m:
+            return m['handle_result'](args, data, target_window_id, boss, data['extra_cli_args'])
+
     programs = data['programs'] or ('default',)
-    matches = tuple(filter(None, data['match']))
+    matches, groupdicts = [], []
+    for m, g in zip(data['match'], data['groupdicts']):
+        if m:
+            matches.append(m), groupdicts.append(g)
     joiner = data['multiple_joiner']
     try:
         is_int = int(joiner)
@@ -489,7 +607,11 @@ def handle_result(args, data, target_window_id, boss):
             if w is not None:
                 cwd = w.cwd_of_child
             program = None if program == 'default' else program
-            for m in matches:
+            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)
 
 

kittens/icat/main.py

@@ -22,7 +22,6 @@ from ..tui.images import (
 )
 from ..tui.operations import clear_images_on_screen, serialize_gr_command
 
-screen_size = None
 OPTIONS = '''\
 --align
 type=choices
@@ -94,9 +93,31 @@ but you can turn it off or on explicitly, if needed.
 --silent
 type=bool-set
 Do not print out anything to stdout during operation.
+
+
+--z-index -z
+default=0
+Z-index of the image. When negative, text will be displayed on top of the image. Use
+a double minus for values under the threshold for drawing images under cell background
+colors. For example, --1 evaluates as -1,073,741,825.
 '''
 
 
+screen_size = None
+
+
+def get_screen_size_function():
+    global screen_size
+    if screen_size is None:
+        screen_size = screen_size_function()
+    return screen_size
+
+
+def get_screen_size():
+    screen_size = get_screen_size_function()
+    return screen_size()
+
+
 def options_spec():
     if not hasattr(options_spec, 'ans'):
         options_spec.ans = OPTIONS.format(
@@ -122,7 +143,7 @@ def calculate_in_cell_x_offset(width, cell_width, align):
 
 
 def set_cursor(cmd, width, height, align):
-    ss = screen_size()
+    ss = get_screen_size()
     cw = int(ss.width / ss.cols)
     num_of_cells_needed = int(ceil(width / cw))
     if num_of_cells_needed > ss.cols:
@@ -143,7 +164,7 @@ def set_cursor(cmd, width, height, align):
 
 def set_cursor_for_place(place, cmd, width, height, align):
     x = place.left + 1
-    ss = screen_size()
+    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)
@@ -168,8 +189,8 @@ def write_chunked(cmd, data):
         cmd.clear()
 
 
-def show(outfile, width, height, fmt, transmit_mode='t', align='center', place=None):
-    cmd = {'a': 'T', 'f': fmt, 's': width, 'v': height}
+def show(outfile, width, height, zindex, fmt, transmit_mode='t', align='center', place=None):
+    cmd = {'a': 'T', 'f': fmt, 's': width, 'v': height, 'z': zindex}
     if place:
         set_cursor_for_place(place, cmd, width, height, align)
     else:
@@ -187,9 +208,17 @@ def show(outfile, width, height, fmt, transmit_mode='t', align='center', place=N
         write_chunked(cmd, data)
 
 
+def parse_z_index(val):
+    origin = 0
+    if val.startswith('--'):
+        val = val[1:]
+        origin = -1073741824
+    return origin + int(val)
+
+
 def process(path, args, is_tempfile):
     m = identify(path)
-    ss = screen_size()
+    ss = get_screen_size()
     available_width = args.place.width * (ss.width / ss.cols) if args.place else ss.width
     available_height = args.place.height * (ss.height / ss.rows) if args.place else 10 * m.height
     needs_scaling = m.width > available_width or m.height > available_height
@@ -205,7 +234,7 @@ def process(path, args, is_tempfile):
         fmt = 24 if m.mode == 'rgb' else 32
         transmit_mode = 't'
         outfile, width, height = convert(path, m, available_width, available_height, args.scale_up)
-    show(outfile, width, height, fmt, transmit_mode, align=args.align, place=args.place)
+    show(outfile, width, height, args.z_index, fmt, transmit_mode, align=args.align, place=args.place)
     if not args.place:
         print()  # ensure cursor is on a new line
     return file_removed
@@ -314,7 +343,6 @@ def process_single_item(item, args, url_pat=None, maybe_dir=True):
 
 
 def main(args=sys.argv):
-    global screen_size
     args, items = parse_args(args[1:], options_spec, usage, help_text, '{} +kitten icat'.format(appname))
 
     if args.print_window_size:
@@ -334,7 +362,7 @@ def main(args=sys.argv):
         sys.stdin.close()
         sys.stdin = open(os.ctermid(), 'r')
 
-    screen_size = screen_size_function()
+    screen_size = get_screen_size_function()
     signal.signal(signal.SIGWINCH, lambda signum, frame: setattr(screen_size, 'changed', True))
     if screen_size().width == 0:
         if args.detect_support:
@@ -347,6 +375,11 @@ def main(args=sys.argv):
     except Exception:
         raise SystemExit('Not a valid place specification: {}'.format(args.place))
 
+    try:
+        args.z_index = parse_z_index(args.z_index)
+    except Exception:
+        raise SystemExit('Not a valid z-index specification: {}'.format(args.z_index))
+
     if args.detect_support:
         if not detect_support(wait_for=args.detection_timeout, silent=True):
             raise SystemExit(1)

kittens/panel/main.py

@@ -130,8 +130,8 @@ def main(sys_args):
     if not items:
         raise SystemExit('You must specify the program to run')
     sys.argv = ['kitty']
-    if args.config:
-        sys.argv.append('--config={}'.format(args.config))
+    for config in args.config:
+        sys.argv.append('--config={}'.format(config))
     for override in args.override:
         sys.argv.append('--override={}'.format(override))
     sys.argv.extend(items)

kittens/show_error/main.py

@@ -4,6 +4,7 @@
 
 import os
 import sys
+from contextlib import suppress
 
 from kitty.cli import parse_args
 
@@ -30,9 +31,8 @@ def real_main(args):
 
 def main(args):
     try:
-        real_main(args)
-    except KeyboardInterrupt:
-        pass
+        with suppress(KeyboardInterrupt):
+            real_main(args)
     except Exception:
         import traceback
         traceback.print_exc()

kittens/ssh/main.py

@@ -76,6 +76,9 @@ def parse_ssh_args(args):
                 if arg in boolean_ssh_args:
                     ssh_args.append(arg)
                     continue
+                if arg.startswith('-p') and arg[2:].isdigit():
+                    ssh_args.append(arg)
+                    continue
                 if arg in other_ssh_args:
                     if i != len(all_args) - 1:
                         raise SystemExit('Option {} cannot occur in the middle'.format(arg))

kittens/unicode_input/main.py

@@ -5,25 +5,27 @@
 import os
 import string
 import subprocess
+import sys
+from contextlib import suppress
 from functools import lru_cache
 from gettext import gettext as _
-from contextlib import suppress
 
+from kitty.cli import parse_args
 from kitty.config import cached_values_for
 from kitty.constants import config_dir
-from kitty.utils import get_editor
-from kitty.fast_data_types import wcswidth
+from kitty.fast_data_types import wcswidth, is_emoji_presentation_base
 from kitty.key_encoding import (
     DOWN, ESCAPE, F1, F2, F3, F4, F12, LEFT, RELEASE, RIGHT, SHIFT, TAB, UP,
     enter_key
 )
+from kitty.utils import get_editor
 
-from ..tui.line_edit import LineEdit
 from ..tui.handler import Handler
+from ..tui.line_edit import LineEdit
 from ..tui.loop import Loop
 from ..tui.operations import (
-    clear_screen, colored, cursor, faint, set_line_wrapping,
-    set_window_title, sgr, styled
+    clear_screen, colored, cursor, faint, set_line_wrapping, set_window_title,
+    sgr, styled
 )
 
 HEX, NAME, EMOTICONS, FAVORITES = 'HEX', 'NAME', 'EMOTICONS', 'FAVORITES'
@@ -131,7 +133,8 @@ def decode_hint(x):
 
 class Table:
 
-    def __init__(self):
+    def __init__(self, emoji_variation):
+        self.emoji_variation = emoji_variation
         self.layout_dirty = True
         self.last_rows = self.last_cols = -1
         self.codepoints = []
@@ -161,7 +164,10 @@ class Table:
         self.layout_dirty = False
 
         def safe_chr(codepoint):
-            return chr(codepoint).encode('utf-8', 'replace').decode('utf-8')
+            ans = chr(codepoint).encode('utf-8', 'replace').decode('utf-8')
+            if self.emoji_variation and is_emoji_presentation_base(codepoint):
+                ans += self.emoji_variation
+            return ans
 
         if self.mode is NAME:
             def as_parts(i, codepoint):
@@ -248,8 +254,13 @@ def is_index(w):
 
 class UnicodeInput(Handler):
 
-    def __init__(self, cached_values):
+    def __init__(self, cached_values, emoji_variation='none'):
         self.cached_values = cached_values
+        self.emoji_variation = ''
+        if emoji_variation == 'text':
+            self.emoji_variation = '\ufe0e'
+        elif emoji_variation == 'graphic':
+            self.emoji_variation = '\ufe0f'
         self.line_edit = LineEdit()
         self.recent = list(self.cached_values.get('recent', DEFAULT_SET))
         self.current_char = None
@@ -257,9 +268,17 @@ class UnicodeInput(Handler):
         self.last_updated_code_point_at = None
         self.choice_line = ''
         self.mode = globals().get(cached_values.get('mode', 'HEX'), 'HEX')
-        self.table = Table()
+        self.table = Table(self.emoji_variation)
         self.update_prompt()
 
+    @property
+    def resolved_current_char(self):
+        ans = self.current_char
+        if ans:
+            if self.emoji_variation and is_emoji_presentation_base(ord(ans[0])):
+                ans += self.emoji_variation
+        return ans
+
     def update_codepoints(self):
         codepoints = None
         if self.mode is HEX:
@@ -320,8 +339,10 @@ class UnicodeInput(Handler):
             self.choice_line = ''
         else:
             c, color = self.current_char, 'green'
+            if self.emoji_variation and is_emoji_presentation_base(ord(c[0])):
+                c += self.emoji_variation
             self.choice_line = _('Chosen:') + ' {} U+{} {}'.format(
-                colored(c, 'green'), hex(ord(c))[2:], faint(styled(name(c) or '', italic=True)))
+                colored(c, 'green'), hex(ord(c[0]))[2:], faint(styled(name(c) or '', italic=True)))
         self.prompt = self.prompt_template.format(colored(c, color))
 
     def init_terminal_state(self):
@@ -475,17 +496,43 @@ class UnicodeInput(Handler):
         self.refresh()
 
 
+help_text = 'Input a unicode character'
+usage = ''
+OPTIONS = '''
+--emoji-variation
+type=choices
+default=none
+choices=none,graphic,text
+Whether to use the textual or the graphical form for emoji. By default the
+default form specified in the unicode standard for the symbol is used.
+
+
+'''.format
+
+
+def parse_unicode_input_args(args):
+    return parse_args(args, OPTIONS, usage, help_text, 'kitty +kitten unicode_input')
+
+
 def main(args):
+    try:
+        args, items = parse_unicode_input_args(args[1:])
+    except SystemExit as e:
+        if e.code != 0:
+            print(e.args[0], file=sys.stderr)
+            input(_('Press Enter to quit'))
+        return
+
     loop = Loop()
     with cached_values_for('unicode-input') as cached_values:
-        handler = UnicodeInput(cached_values)
+        handler = UnicodeInput(cached_values, args.emoji_variation)
         loop.loop(handler)
         if handler.current_char and loop.return_code == 0:
             with suppress(Exception):
                 handler.recent.remove(ord(handler.current_char))
             recent = [ord(handler.current_char)] + handler.recent
             cached_values['recent'] = recent[:len(DEFAULT_SET)]
-            return handler.current_char
+            return handler.resolved_current_char
     if loop.return_code != 0:
         raise SystemExit(loop.return_code)
 
@@ -497,10 +544,10 @@ def handle_result(args, current_char, target_window_id, boss):
 
 
 if __name__ == '__main__':
-    import sys
-    if '-h' in sys.argv or '--help' in sys.argv:
-        print('Choose a unicode character to input into the terminal')
-        raise SystemExit(0)
     ans = main(sys.argv)
     if ans:
         print(ans)
+elif __name__ == '__doc__':
+    sys.cli_docs['usage'] = usage
+    sys.cli_docs['options'] = OPTIONS
+    sys.cli_docs['help_text'] = help_text

kittens/unicode_input/names.h

@@ -1,4 +1,4 @@
-// unicode data, built from the unicode standard on: 2019-08-02
+// unicode data, built from the unicode standard on: 2019-10-01
 // see gen-wcwidth.py
 #pragma once
 #include "data-types.h"

kitty/blit_fragment.glsl

@@ -7,5 +7,4 @@ out vec4 color;
 
 void main() {
     color = texture(image, texcoord);
-    color = vec4(color.rgb, color.a);
 }

kitty/boss.py

@@ -23,10 +23,10 @@ from .constants import (
 from .fast_data_types import (
     ChildMonitor, background_opacity_of, change_background_opacity,
     change_os_window_state, create_os_window, current_os_window,
-    destroy_global_data, get_clipboard_string, global_font_size,
-    mark_os_window_for_close, os_window_font_size, patch_global_colors,
-    safe_pipe, set_clipboard_string, set_in_sequence_mode, thread_write,
-    toggle_fullscreen, toggle_maximized
+    destroy_global_data, focus_os_window, get_clipboard_string,
+    global_font_size, mark_os_window_for_close, os_window_font_size,
+    patch_global_colors, safe_pipe, set_clipboard_string, set_in_sequence_mode,
+    thread_write, toggle_fullscreen, toggle_maximized
 )
 from .keys import get_shortcut, shortcut_matches
 from .layout import set_layout_options
@@ -58,9 +58,9 @@ def data_for_at(w, arg, add_wrap_markers=False):
 
     if arg == '@selection':
         return w.text_for_selection()
-    if arg == '@ansi':
+    if arg in ('@ansi', '@ansi_screen_scrollback'):
         return as_text(as_ansi=True, add_history=True)
-    if arg == '@text':
+    if arg in ('@text', '@screen_scrollback'):
         return as_text(add_history=True)
     if arg == '@screen':
         return as_text()
@@ -121,7 +121,7 @@ class Boss:
         talk_fd = getattr(single_instance, 'socket', None)
         talk_fd = -1 if talk_fd is None else talk_fd.fileno()
         listen_fd = -1
-        if opts.allow_remote_control and args.listen_on:
+        if args.listen_on and (opts.allow_remote_control in ('y', 'socket-only')):
             listen_fd = listen_on(args.listen_on)
         self.child_monitor = ChildMonitor(
             self.on_child_death,
@@ -146,9 +146,9 @@ class Boss:
             from .fast_data_types import cocoa_set_notification_activated_callback
             cocoa_set_notification_activated_callback(self.notification_activated)
 
-    def add_os_window(self, startup_session, os_window_id=None, wclass=None, wname=None, opts_for_size=None, startup_id=None):
+    def add_os_window(self, startup_session=None, os_window_id=None, wclass=None, wname=None, opts_for_size=None, startup_id=None):
         if os_window_id is None:
-            opts_for_size = opts_for_size or startup_session.os_window_size or self.opts
+            opts_for_size = opts_for_size or getattr(startup_session, 'os_window_size', None) or self.opts
             cls = wclass or self.args.cls or appname
             with startup_notification_handler(do_notify=startup_id is not None, startup_id=startup_id) as pre_show_callback:
                 os_window_id = create_os_window(
@@ -235,7 +235,7 @@ class Boss:
                 if tab:
                     yield tab
 
-    def set_active_window(self, window):
+    def set_active_window(self, window, switch_os_window_if_needed=False):
         for os_window_id, tm in self.os_window_map.items():
             for tab in tm:
                 for w in tab:
@@ -243,6 +243,8 @@ class Boss:
                         if tab is not self.active_tab:
                             tm.set_active_tab(tab)
                         tab.set_active_window(w)
+                        if switch_os_window_if_needed and current_os_window() != os_window_id:
+                            focus_os_window(os_window_id, True)
                         return os_window_id
 
     def _new_os_window(self, args, cwd_from=None):
@@ -276,9 +278,9 @@ class Boss:
         self.child_monitor.add_child(window.id, window.child.pid, window.child.child_fd, window.screen)
         self.window_id_map[window.id] = window
 
-    def _handle_remote_command(self, cmd, window=None):
+    def _handle_remote_command(self, cmd, window=None, from_peer=False):
         response = None
-        if self.opts.allow_remote_control or getattr(window, 'allow_remote_control', False):
+        if self.opts.allow_remote_control == 'y' or from_peer or getattr(window, 'allow_remote_control', False):
             try:
                 response = handle_cmd(self, window, cmd)
             except Exception as err:
@@ -287,7 +289,7 @@ class Boss:
                 if not getattr(err, 'hide_traceback', False):
                     response['tb'] = traceback.format_exc()
         else:
-            response = {'ok': False, 'error': 'Remote control is disabled. Add allow_remote_control yes to your kitty.conf'}
+            response = {'ok': False, 'error': 'Remote control is disabled. Add allow_remote_control to your kitty.conf'}
         return response
 
     def peer_message_received(self, msg):
@@ -295,7 +297,7 @@ class Boss:
         cmd_prefix = '\x1bP@kitty-cmd'
         if msg.startswith(cmd_prefix):
             cmd = msg[len(cmd_prefix):-2]
-            response = self._handle_remote_command(cmd)
+            response = self._handle_remote_command(cmd, from_peer=True)
             if response is not None:
                 response = (cmd_prefix + json.dumps(response) + '\x1b\\').encode('utf-8')
             return response
@@ -321,6 +323,16 @@ class Boss:
             if window is not None:
                 window.send_cmd_response(response)
 
+    def _cleanup_tab_after_window_removal(self, src_tab):
+        if len(src_tab) < 1:
+            tm = src_tab.tab_manager_ref()
+            if tm is not None:
+                tm.remove(src_tab)
+                src_tab.destroy()
+                if len(tm) == 0:
+                    if not self.shutting_down:
+                        mark_os_window_for_close(src_tab.os_window_id)
+
     def on_child_death(self, window_id):
         window = self.window_id_map.pop(window_id, None)
         if window is None:
@@ -334,20 +346,22 @@ class Boss:
         os_window_id = window.os_window_id
         window.destroy()
         tm = self.os_window_map.get(os_window_id)
-        if tm is None:
-            return
-        for tab in tm:
-            if window in tab:
-                break
-        else:
-            return
-        tab.remove_window(window)
-        if len(tab) == 0:
-            tm.remove(tab)
-            tab.destroy()
-            if len(tm) == 0:
-                if not self.shutting_down:
-                    mark_os_window_for_close(os_window_id)
+        tab = None
+        if tm is not None:
+            for q in tm:
+                if window in q:
+                    tab = q
+                    break
+        if tab is not None:
+            tab.remove_window(window)
+            self._cleanup_tab_after_window_removal(tab)
+        if window.action_on_removal:
+            try:
+                window.action_on_removal(window)
+            except Exception:
+                import traceback
+                traceback.print_exc()
+        window.action_on_close = window.action_on_removal = None
 
     def close_window(self, window=None):
         if window is None:
@@ -512,27 +526,27 @@ class Boss:
         if t is not None:
             return t.active_window
 
-    def dispatch_special_key(self, key, scancode, action, mods):
+    def dispatch_special_key(self, key, native_key, action, mods):
         # Handles shortcuts, return True if the key was consumed
-        key_action = get_shortcut(self.keymap, mods, key, scancode)
+        key_action = get_shortcut(self.keymap, mods, key, native_key)
         if key_action is None:
-            sequences = get_shortcut(self.opts.sequence_map, mods, key, scancode)
+            sequences = get_shortcut(self.opts.sequence_map, mods, key, native_key)
             if sequences:
                 self.pending_sequences = sequences
                 set_in_sequence_mode(True)
                 return True
         else:
-            self.current_key_press_info = key, scancode, action, mods
+            self.current_key_press_info = key, native_key, action, mods
             return self.dispatch_action(key_action)
 
-    def process_sequence(self, key, scancode, action, mods):
+    def process_sequence(self, key, native_key, action, mods):
         if not self.pending_sequences:
             set_in_sequence_mode(False)
 
         remaining = {}
         matched_action = None
         for seq, key_action in self.pending_sequences.items():
-            if shortcut_matches(seq[0], mods, key, scancode):
+            if shortcut_matches(seq[0], mods, key, native_key):
                 seq = seq[1:]
                 if seq:
                     remaining[seq] = key_action
@@ -643,7 +657,7 @@ class Boss:
         with suppress(Exception):
             s.connect(address)
             s.sendall(b'c')
-            with suppress(EnvironmentError):
+            with suppress(OSError):
                 s.shutdown(socket.SHUT_RDWR)
             s.close()
 
@@ -670,7 +684,7 @@ class Boss:
             output += str(s.linebuf.line(i))
         return output
 
-    def _run_kitten(self, kitten, args=(), input_data=None, window=None):
+    def _run_kitten(self, kitten, args=(), input_data=None, window=None, custom_callback=None, action_on_removal=None):
         orig_args, args = list(args), list(args)
         from kittens.runner import create_kitten_handler
         end_kitten = create_kitten_handler(kitten, orig_args)
@@ -719,7 +733,10 @@ class Boss:
                 ),
                 copy_colors_from=w
             )
-            overlay_window.action_on_close = partial(self.on_kitten_finish, w.id, end_kitten)
+            wid = w.id
+            overlay_window.action_on_close = partial(self.on_kitten_finish, wid, custom_callback or end_kitten)
+            if action_on_removal is not None:
+                overlay_window.action_on_removal = lambda *a: action_on_removal(wid, self)
             return overlay_window
 
     def kitten(self, kitten, *args):
@@ -744,9 +761,6 @@ class Boss:
             args = ['--name=tab-title', '--message', _('Enter the new title for this tab below.'), 'do_set_tab_title', str(tab.id)]
             self._run_kitten('ask', args)
 
-    def show_error(self, title, msg):
-        self._run_kitten('show_error', args=['--title', title], input_data=msg)
-
     def do_set_tab_title(self, title, tab_id):
         tm = self.active_tab_manager
         if tm is not None and title:
@@ -756,6 +770,32 @@ class Boss:
                     tab.set_title(title)
                     break
 
+    def show_error(self, title, msg):
+        self._run_kitten('show_error', args=['--title', title], input_data=msg)
+
+    def create_marker(self):
+        w = self.active_window
+        if w:
+            spec = None
+
+            def done(data, target_window_id, self):
+                nonlocal spec
+                spec = data['response']
+
+            def done2(target_window_id, self):
+                w = self.window_id_map.get(target_window_id)
+                if w is not None and spec:
+                    try:
+                        w.set_marker(spec)
+                    except Exception as err:
+                        self.show_error(_('Invalid marker specification'), str(err))
+
+            self._run_kitten('ask', [
+                '--name=create-marker', '--message',
+                _('Create marker, for example:\ntext 1 ERROR\nSee https://sw.kovidgoyal.net/kitty/marks.html\n')
+                ],
+                custom_callback=done, action_on_removal=done2)
+
     def kitty_shell(self, window_type):
         cmd = ['@', kitty_exe(), '@']
         if window_type == 'tab':
@@ -881,6 +921,9 @@ class Boss:
                 stdin = stdin.encode('utf-8')
         return env, stdin
 
+    def data_for_at(self, which, window=None, add_wrap_markers=False):
+        return data_for_at(window or self.active_window, which, add_wrap_markers=add_wrap_markers)
+
     def special_window_for_cmd(self, cmd, window=None, stdin=None, cwd_from=None, as_overlay=False):
         w = window or self.active_window
         env, stdin = self.process_stdin_source(w, stdin)
@@ -894,6 +937,25 @@ class Boss:
         overlay_for = w.id if as_overlay and w.overlay_for is None else None
         return SpecialWindow(cmd, stdin, cwd_from=cwd_from, overlay_for=overlay_for, env=env)
 
+    def run_background_process(self, cmd, cwd=None, env=None, stdin=None, cwd_from=None):
+        import subprocess
+        if cwd_from:
+            with suppress(Exception):
+                cwd = cwd_of_process(cwd_from)
+
+        if stdin:
+            r, w = safe_pipe(False)
+            try:
+                subprocess.Popen(cmd, env=env, stdin=r, cwd=cwd)
+            except Exception:
+                os.close(w)
+            else:
+                thread_write(w, stdin)
+            finally:
+                os.close(r)
+        else:
+            subprocess.Popen(cmd, env=env, cwd=cwd)
+
     def pipe(self, source, dest, exe, *args):
         cmd = [exe] + list(args)
         window = self.active_window
@@ -919,24 +981,8 @@ class Boss:
                 func = set_clipboard_string if dest == 'clipboard' else set_primary_selection
                 func(stdin)
         else:
-            import subprocess
             env, stdin = self.process_stdin_source(stdin=source, window=window)
-            cwd = None
-            if cwd_from:
-                with suppress(Exception):
-                    cwd = cwd_of_process(cwd_from)
-            if stdin:
-                r, w = safe_pipe(False)
-                try:
-                    subprocess.Popen(cmd, env=env, stdin=r, cwd=cwd)
-                except Exception:
-                    os.close(w)
-                else:
-                    thread_write(w, stdin)
-                finally:
-                    os.close(r)
-            else:
-                subprocess.Popen(cmd, env=env, cwd=cwd)
+            self.run_background_process(cmd, cwd_from=cwd_from, stdin=stdin, env=env)
 
     def args_to_special_window(self, args, cwd_from=None):
         args = list(args)
@@ -991,14 +1037,20 @@ class Boss:
     def _new_window(self, args, cwd_from=None):
         tab = self.active_tab
         if tab is not None:
+            allow_remote_control = False
             location = None
             if args and args[0].startswith('!'):
                 location = args[0][1:].lower()
                 args = args[1:]
+            if args and args[0] == '@':
+                args = args[1:]
+                allow_remote_control = True
             if args:
-                return tab.new_special_window(self.args_to_special_window(args, cwd_from=cwd_from), location=location)
+                return tab.new_special_window(
+                    self.args_to_special_window(args, cwd_from=cwd_from),
+                    location=location, allow_remote_control=allow_remote_control)
             else:
-                return tab.new_window(cwd_from=cwd_from, location=location)
+                return tab.new_window(cwd_from=cwd_from, location=location, allow_remote_control=allow_remote_control)
 
     def new_window(self, *args):
         self._new_window(args)
@@ -1010,6 +1062,11 @@ class Boss:
         cwd_from = w.child.pid_for_cwd if w is not None else None
         self._new_window(args, cwd_from=cwd_from)
 
+    def launch(self, *args):
+        from kitty.launch import parse_launch_args, launch
+        opts, args = parse_launch_args(args)
+        launch(self, opts, args)
+
     def move_tab_forward(self):
         tm = self.active_tab_manager
         if tm is not None:
@@ -1096,3 +1153,144 @@ class Boss:
 
         msg = '\n'.join(map(format_bad_line, bad_lines)).rstrip()
         self.show_error(_('Errors in kitty.conf'), msg)
+
+    def set_colors(self, *args):
+        from .cmds import parse_subcommand_cli, cmd_set_colors, set_colors
+        opts, items = parse_subcommand_cli(cmd_set_colors, ['set-colors'] + list(args))
+        payload = cmd_set_colors(None, opts, items)
+        set_colors(self, self.active_window, payload)
+
+    def _move_window_to(self, window=None, target_tab_id=None, target_os_window_id=None):
+        window = window or self.active_window
+        if not window:
+            return
+        src_tab = self.tab_for_window(window)
+        if src_tab is None:
+            return
+        if target_os_window_id == 'new':
+            target_os_window_id = self.add_os_window()
+            tm = self.os_window_map[target_os_window_id]
+            target_tab = tm.new_tab(empty_tab=True)
+        else:
+            target_os_window_id = target_os_window_id or current_os_window()
+            if target_tab_id == 'new':
+                tm = self.os_window_map[target_os_window_id]
+                target_tab = tm.new_tab(empty_tab=True)
+            else:
+                for tab in self.all_tabs:
+                    if tab.id == target_tab_id:
+                        target_tab = tab
+                        target_os_window_id = tab.os_window_id
+                        break
+                else:
+                    return
+
+        underlaid_window, overlaid_window = src_tab.detach_window(window)
+        if underlaid_window:
+            target_tab.attach_window(underlaid_window)
+        if overlaid_window:
+            target_tab.attach_window(overlaid_window)
+        self._cleanup_tab_after_window_removal(src_tab)
+        target_tab.make_active()
+
+    def _move_tab_to(self, tab=None, target_os_window_id=None):
+        tab = tab or self.active_tab
+        if tab is None:
+            return
+        if target_os_window_id is None:
+            target_os_window_id = self.add_os_window()
+        tm = self.os_window_map[target_os_window_id]
+        target_tab = tm.new_tab(empty_tab=True)
+        target_tab.take_over_from(tab)
+        self._cleanup_tab_after_window_removal(tab)
+        target_tab.make_active()
+
+    def detach_window(self, *args):
+        if not args or args[0] == 'new':
+            return self._move_window_to(target_os_window_id='new')
+        if args[0] == 'new-tab':
+            return self._move_window_to(target_tab_id='new')
+        lines = [
+            'Choose a tab to move the window to',
+            ''
+        ]
+        fmt = ': {1}'
+        tab_id_map = {}
+        current_tab = self.active_tab
+        for i, tab in enumerate(self.all_tabs):
+            if tab is not current_tab:
+                tab_id_map[len(tab_id_map)] = tab.id
+                lines.append(fmt.format(i + 1, tab.title))
+        new_idx = len(tab_id_map) + 1
+        tab_id_map[new_idx - 1] = 'new'
+        lines.append(fmt.format(new_idx, 'New tab'))
+        new_idx = len(tab_id_map) + 1
+        tab_id_map[new_idx - 1] = None
+        lines.append(fmt.format(new_idx, 'New OS Window'))
+
+        def done(data, target_window_id, self):
+            done.tab_id = tab_id_map[int(data['groupdicts'][0]['index'])]
+
+        def done2(target_window_id, self):
+            if not hasattr(done, 'tab_id'):
+                return
+            tab_id = done.tab_id
+            target_window = None
+            for w in self.all_windows:
+                if w.id == target_window_id:
+                    target_window = w
+                    break
+            if tab_id is None:
+                self._move_window_to(window=target_window, target_os_window_id='new')
+            else:
+                self._move_window_to(window=target_window, target_tab_id=tab_id)
+
+        self._run_kitten(
+            'hints', args=(
+                '--ascending', '--customize-processing=::import::kitty.choose_entry',
+                r'--regex=(?m)^:\s+.+$',
+            ), input_data='\r\n'.join(lines).encode('utf-8'), custom_callback=done, action_on_removal=done2
+        )
+
+    def detach_tab(self, *args):
+        if not args or args[0] == 'new':
+            return self._move_tab_to()
+
+        lines = [
+            'Choose an OS window to move the tab to',
+            ''
+        ]
+        fmt = ': {1}'
+        os_window_id_map = {}
+        current_os_window = getattr(self.active_tab, 'os_window_id', 0)
+        for i, osw in enumerate(self.os_window_map):
+            tm = self.os_window_map[osw]
+            if current_os_window != osw and tm.active_tab and tm.active_tab:
+                os_window_id_map[len(os_window_id_map)] = osw
+                lines.append(fmt.format(i + 1, tm.active_tab.title))
+        new_idx = len(os_window_id_map) + 1
+        os_window_id_map[new_idx - 1] = None
+        lines.append(fmt.format(new_idx, 'New OS Window'))
+
+        def done(data, target_window_id, self):
+            done.os_window_id = os_window_id_map[int(data['groupdicts'][0]['index'])]
+
+        def done2(target_window_id, self):
+            if not hasattr(done, 'os_window_id'):
+                return
+            os_window_id = done.os_window_id
+            target_tab = self.active_tab
+            for w in self.all_windows:
+                if w.id == target_window_id:
+                    target_tab = w.tabref()
+                    break
+            if target_tab and target_tab.os_window_id == os_window_id:
+                return
+            self._move_tab_to(tab=target_tab, target_os_window_id=os_window_id)
+
+        self._run_kitten(
+            'hints', args=(
+                '--ascending', '--customize-processing=::import::kitty.choose_entry',
+                r'--regex=(?m)^:\s+.+$',
+            ), input_data='\r\n'.join(lines).encode('utf-8'), custom_callback=done, action_on_removal=done2
+        )

kitty/cell_fragment.glsl

@@ -12,6 +12,7 @@
 
 #ifdef NEEDS_BACKROUND
 in vec3 background;
+in float draw_bg;
 #if defined(TRANSPARENT) || defined(SPECIAL)
 in float bg_alpha;
 #endif
@@ -76,11 +77,13 @@ vec4 blend_onto_opaque_premul(vec3 over, float over_alpha, vec3 under) {
  *
  *    2a) Opaque bg with images under text
  *        There are multiple passes, each pass is blended onto the previous using the opaque blend func (alpha, 1- alpha):
- *        1) Draw only the background -- expected output is color with alpha 1
- *        2) Draw the images that are supposed to be below text. This happens in the graphics shader
- *        3) Draw the special cells (selection/cursor). Output is same as from step 1, with bg_alpha 1 for special cells and 0 otherwise
- *        4) Draw the foreground -- expected output is color with alpha which is blended using the opaque blend func
- *        5) Draw the images that are supposed to be above text again in the graphics shader
+ *        1) Draw background for all cells
+ *        2) Draw the images that are supposed to be below both the background and text, if any. This happens in the graphics shader
+ *        3) Draw the background of cells that don't have the default background if any images were drawn in 2 above
+          4) Draw the images that are supposed to be below text but not background, again in graphics shader.
+ *        5) Draw the special cells (selection/cursor). Output is same as from step 1, with bg_alpha 1 for special cells and 0 otherwise
+ *        6) Draw the foreground -- expected output is color with alpha which is blended using the opaque blend func
+ *        7) Draw the images that are supposed to be above text again in the graphics shader
  *
  *    2b) Transparent bg with images
  *        First everything is rendered into a framebuffer, and then the framebauffer is blended onto
@@ -126,10 +129,10 @@ void main() {
 #endif
 
 #ifdef BACKGROUND
-#ifdef TRANSPARENT
+#if defined(TRANSPARENT)
     final_color = vec4(background.rgb * bg_alpha, bg_alpha);
 #else
-    final_color = vec4(background.rgb, 1.0f);
+    final_color = vec4(background.rgb, draw_bg);
 #endif
 #endif
 

kitty/cell_vertex.glsl

@@ -5,7 +5,10 @@
 #define REVERSE_SHIFT {REVERSE_SHIFT}
 #define STRIKE_SHIFT {STRIKE_SHIFT}
 #define DIM_SHIFT {DIM_SHIFT}
+#define MARK_SHIFT {MARK_SHIFT}
+#define MARK_MASK {MARK_MASK}
 #define USE_SELECTION_FG
+#define NUM_COLORS 256
 
 // Inputs {{{
 layout(std140) uniform CellRenderData {
@@ -16,8 +19,11 @@ layout(std140) uniform CellRenderData {
     uint xnum, ynum, cursor_fg_sprite_idx;
     float cursor_x, cursor_y, cursor_w;
 
-    uint color_table[256];
+    uint color_table[NUM_COLORS + MARK_MASK + MARK_MASK + 2];
 };
+#ifdef BACKGROUND
+uniform uint draw_bg_bitfield;
+#endif
 
 // Have to use fixed locations here as all variants of the cell program share the same VAO
 layout(location=0) in uvec3 colors;
@@ -45,6 +51,7 @@ const uvec2 cell_pos_map[] = uvec2[4](
 
 #ifdef NEEDS_BACKROUND
 out vec3 background;
+out float draw_bg;
 #if defined(TRANSPARENT) || defined(SPECIAL)
 out float bg_alpha;
 #endif
@@ -151,13 +158,18 @@ void main() {
     // set cell color indices {{{
     uvec2 default_colors = uvec2(default_fg, default_bg);
     uint text_attrs = sprite_coords[3];
-    uint is_inverted = ((text_attrs >> REVERSE_SHIFT) & ONE) + inverted;
+    uint is_reversed = ((text_attrs >> REVERSE_SHIFT) & ONE);
+    uint is_inverted = is_reversed + inverted;
     int fg_index = fg_index_map[is_inverted];
     int bg_index = 1 - fg_index;
     float cell_has_cursor = is_cursor(c, r);
     float is_block_cursor = step(float(cursor_fg_sprite_idx), 0.5);
     float cell_has_block_cursor = cell_has_cursor * is_block_cursor;
-    vec3 bg = to_color(colors[bg_index], default_colors[bg_index]);
+    int mark = int(text_attrs >> MARK_SHIFT) & MARK_MASK;
+    uint has_mark = uint(step(1, float(mark)));
+    uint bg_as_uint = resolve_color(colors[bg_index], default_colors[bg_index]);
+    bg_as_uint = has_mark * color_table[NUM_COLORS + mark] + (ONE - has_mark) * bg_as_uint;
+    vec3 bg = color_to_vec(bg_as_uint);
     // }}}
 
     // Foreground {{{
@@ -168,12 +180,13 @@ void main() {
     colored_sprite = float((sprite_coords.z & COLOR_MASK) >> 14);
 
     // Foreground
-    uint resolved_fg = resolve_color(colors[fg_index], default_colors[fg_index]);
-    foreground = color_to_vec(resolved_fg);
+    uint fg_as_uint = resolve_color(colors[fg_index], default_colors[fg_index]);
+    fg_as_uint = has_mark * color_table[NUM_COLORS + MARK_MASK + 1 + mark] + (ONE - has_mark) * fg_as_uint;
+    foreground = color_to_vec(fg_as_uint);
     float has_dim = float((text_attrs >> DIM_SHIFT) & ONE);
     effective_text_alpha = inactive_text_alpha * mix(1.0, dim_opacity, has_dim);
     float in_url = float((is_selected & TWO) >> 1);
-    decoration_fg = choose_color(in_url, color_to_vec(url_color), to_color(colors[2], resolved_fg));
+    decoration_fg = choose_color(in_url, color_to_vec(url_color), to_color(colors[2], fg_as_uint));
 #ifdef USE_SELECTION_FG
     // Selection
     vec3 selection_color = color_to_vec(highlight_fg);
@@ -195,26 +208,39 @@ void main() {
 
     // Background {{{
 #ifdef NEEDS_BACKROUND
+    float cell_has_non_default_bg = step(1, float(abs(bg_as_uint - default_colors[bg_index])));
+    draw_bg = 1;
 
 #if defined(BACKGROUND)
     background = bg;
+    // draw_bg_bitfield has bit 0 set to draw default bg cells and bit 1 set to draw non-default bg cells
+    uint draw_bg_mask = uint(2 * cell_has_non_default_bg + (1 - cell_has_non_default_bg));
+    draw_bg = step(1, float(draw_bg_bitfield & draw_bg_mask));
 #endif
 
-#if defined(TRANSPARENT) && !defined(SPECIAL)
-    // If the background color is default, set its opacity to background_opacity, otherwise it should be opaque
-    bg_alpha = step(0.5, float(colors[bg_index] & BYTE_MASK));
-    // Cursor must not be affected by background_opacity
-    bg_alpha = mix(bg_alpha, 1.0, cell_has_block_cursor);
+#ifdef TRANSPARENT
+    // Set bg_alpha to background_opacity on cells that have the default background color
+    // Which means they must not have a block cursor or a selection or reverse video
+    // On other cells it should be 1. For the SPECIAL program it should be 1 on cells with
+    // selections/block cursor and 0 everywhere else.
+    float is_special_cell = cell_has_block_cursor + float(is_selected & ONE);
+#ifndef SPECIAL
+    is_special_cell += cell_has_non_default_bg + float(is_reversed);
+#endif
+    bg_alpha = step(0.5, is_special_cell);
+#ifndef SPECIAL
     bg_alpha = bg_alpha + (1.0f - bg_alpha) * background_opacity;
+    bg_alpha *= draw_bg;
+#endif
 #endif
 
 #if defined(SPECIAL) || defined(SIMPLE)
     // Selection and cursor
     bg = choose_color(float(is_selected & ONE), color_to_vec(highlight_bg), bg);
     background = choose_color(cell_has_block_cursor, color_to_vec(cursor_color), bg);
-#ifdef SPECIAL
-    // bg_alpha should be 1 if cursor/selection otherwise 0
-    bg_alpha = mix(0.0, 1.0, step(0.5, float(is_selected & ONE) + cell_has_block_cursor));
+#if !defined(TRANSPARENT) && defined(SPECIAL)
+    float is_special_cell = cell_has_block_cursor + float(is_selected & ONE);
+    bg_alpha = step(0.5, is_special_cell);
 #endif
 #endif
 

kitty/child-monitor.c

@@ -11,6 +11,7 @@
 #include "screen.h"
 #include "fonts.h"
 #include "charsets.h"
+#include "monotonic.h"
 #include <termios.h>
 #include <unistd.h>
 #include <float.h>
@@ -34,7 +35,7 @@ extern PyTypeObject Screen_Type;
 #endif
 #define USE_RENDER_FRAMES (global_state.has_render_frames && OPT(sync_to_monitor))
 
-static void (*parse_func)(Screen*, PyObject*, double);
+static void (*parse_func)(Screen*, PyObject*, monotonic_t);
 
 typedef struct {
     char *data;
@@ -108,12 +109,12 @@ static size_t reaped_pids_count = 0;
 #define INCREF_CHILD(x) XREF_CHILD(x, Py_INCREF)
 #define DECREF_CHILD(x) XREF_CHILD(x, Py_DECREF)
 
-// The max time (in secs) to wait for events from the window system
+// The max time to wait for events from the window system
 // before ticking over the main loop. Negative values mean wait forever.
-static double maximum_wait = -1.0;
+static monotonic_t maximum_wait = -1;
 
 static inline void
-set_maximum_wait(double val) {
+set_maximum_wait(monotonic_t val) {
     if (val >= 0 && (val < maximum_wait || maximum_wait < 0)) maximum_wait = val;
 }
 
@@ -296,11 +297,11 @@ shutdown_monitor(ChildMonitor *self, PyObject *a UNUSED) {
 }
 
 static inline bool
-do_parse(ChildMonitor *self, Screen *screen, double now) {
+do_parse(ChildMonitor *self, Screen *screen, monotonic_t now) {
     bool input_read = false;
     screen_mutex(lock, read);
     if (screen->read_buf_sz || screen->pending_mode.used) {
-        double time_since_new_input = now - screen->new_input_at;
+        monotonic_t time_since_new_input = now - screen->new_input_at;
         if (time_since_new_input >= OPT(input_delay)) {
             bool read_buf_full = screen->read_buf_sz >= READ_BUF_SZ;
             input_read = true;
@@ -308,7 +309,7 @@ do_parse(ChildMonitor *self, Screen *screen, double now) {
             if (read_buf_full) wakeup_io_loop(self, false);  // Ensure the read fd has POLLIN set
             screen->new_input_at = 0;
             if (screen->pending_mode.activated_at) {
-                double time_since_pending = MAX(0, now - screen->pending_mode.activated_at);
+                monotonic_t time_since_pending = MAX(0, now - screen->pending_mode.activated_at);
                 set_maximum_wait(screen->pending_mode.wait_time - time_since_pending);
             }
         } else set_maximum_wait(OPT(input_delay) - time_since_new_input);
@@ -322,7 +323,7 @@ parse_input(ChildMonitor *self) {
     // Parse all available input that was read in the I/O thread.
     size_t count = 0, remove_count = 0;
     bool input_read = false;
-    double now = monotonic();
+    monotonic_t now = monotonic();
     PyObject *msg = NULL;
     children_mutex(lock);
     while (remove_queue_count) {
@@ -485,22 +486,22 @@ pyset_iutf8(ChildMonitor *self, PyObject *args) {
 extern void cocoa_update_menu_bar_title(PyObject*);
 
 static inline void
-collect_cursor_info(CursorRenderInfo *ans, Window *w, double now, OSWindow *os_window) {
+collect_cursor_info(CursorRenderInfo *ans, Window *w, monotonic_t now, OSWindow *os_window) {
     ScreenRenderData *rd = &w->render_data;
     Cursor *cursor = rd->screen->cursor;
     ans->x = cursor->x; ans->y = cursor->y;
     ans->is_visible = false;
     if (rd->screen->scrolled_by || !screen_is_cursor_visible(rd->screen)) return;
-    double time_since_start_blink = now - os_window->cursor_blink_zero_time;
+    monotonic_t time_since_start_blink = now - os_window->cursor_blink_zero_time;
     bool cursor_blinking = OPT(cursor_blink_interval) > 0 && os_window->is_focused && (OPT(cursor_stop_blinking_after) == 0 || time_since_start_blink <= OPT(cursor_stop_blinking_after));
     bool do_draw_cursor = true;
     if (cursor_blinking) {
-        int t = (int)(time_since_start_blink * 1000);
-        int d = (int)(OPT(cursor_blink_interval) * 1000);
+        int t = monotonic_t_to_ms(time_since_start_blink);
+        int d = monotonic_t_to_ms(OPT(cursor_blink_interval));
         int n = t / d;
         do_draw_cursor = n % 2 == 0 ? true : false;
-        double bucket = (n + 1) * d;
-        double delay = (bucket / 1000.0) - time_since_start_blink;
+        monotonic_t bucket = ms_to_monotonic_t((n + 1) * d);
+        monotonic_t delay = bucket - time_since_start_blink;
         set_maximum_wait(delay);
     }
     if (!do_draw_cursor) { ans->is_visible = false; return; }
@@ -526,7 +527,7 @@ update_window_title(Window *w, OSWindow *os_window) {
 }
 
 static inline bool
-prepare_to_render_os_window(OSWindow *os_window, double now, unsigned int *active_window_id, color_type *active_window_bg, unsigned int *num_visible_windows, bool *all_windows_have_same_bg) {
+prepare_to_render_os_window(OSWindow *os_window, monotonic_t now, unsigned int *active_window_id, color_type *active_window_bg, unsigned int *num_visible_windows, bool *all_windows_have_same_bg) {
 #define TD os_window->tab_bar_render_data
     bool needs_render = os_window->needs_render;
     os_window->needs_render = false;
@@ -555,10 +556,10 @@ prepare_to_render_os_window(OSWindow *os_window, double now, unsigned int *activ
             if (*num_visible_windows == 1) first_window_bg = window_bg;
             if (first_window_bg != window_bg) all_windows_have_same_bg = false;
             if (w->last_drag_scroll_at > 0) {
-                if (now - w->last_drag_scroll_at >= 0.02) {
+                if (now - w->last_drag_scroll_at >= ms_to_monotonic_t(20ll)) {
                     if (drag_scroll(w, os_window)) {
                         w->last_drag_scroll_at = now;
-                        set_maximum_wait(0.02);
+                        set_maximum_wait(ms_to_monotonic_t(20ll));
                         needs_render = true;
                     } else w->last_drag_scroll_at = 0;
                 } else set_maximum_wait(now - w->last_drag_scroll_at);
@@ -579,7 +580,7 @@ prepare_to_render_os_window(OSWindow *os_window, double now, unsigned int *activ
 }
 
 static inline void
-render_os_window(OSWindow *os_window, double now, unsigned int active_window_id, color_type active_window_bg, unsigned int num_visible_windows, bool all_windows_have_same_bg) {
+render_os_window(OSWindow *os_window, monotonic_t now, unsigned int active_window_id, color_type active_window_bg, unsigned int num_visible_windows, bool all_windows_have_same_bg) {
     // ensure all pixels are cleared to background color at least once in every buffer
     if (os_window->clear_count++ < 3) blank_os_window(os_window);
     Tab *tab = os_window->tabs + os_window->active_tab;
@@ -587,8 +588,8 @@ render_os_window(OSWindow *os_window, double now, unsigned int active_window_id,
     bool static_live_resize_in_progress = os_window->live_resize.in_progress && OPT(resize_draw_strategy) == RESIZE_DRAW_STATIC;
     float x_ratio = 1, y_ratio = 1;
     if (static_live_resize_in_progress) {
-        x_ratio = os_window->viewport_width / (double) os_window->live_resize.width;
-        y_ratio = os_window->viewport_height / (double) os_window->live_resize.height;
+        x_ratio = (float) os_window->viewport_width / (float) os_window->live_resize.width;
+        y_ratio = (float) os_window->viewport_height / (float) os_window->live_resize.height;
     }
     if (!static_live_resize_in_progress) {
         draw_borders(br->vao_idx, br->num_border_rects, br->rect_buf, br->is_dirty, os_window->viewport_width, os_window->viewport_height, active_window_bg, num_visible_windows, all_windows_have_same_bg, os_window);
@@ -601,7 +602,7 @@ render_os_window(OSWindow *os_window, double now, unsigned int active_window_id,
             bool is_active_window = i == tab->active_window;
             draw_cells(WD.vao_idx, WD.gvao_idx, WD.xstart, WD.ystart, WD.dx * x_ratio, WD.dy * y_ratio, WD.screen, os_window, is_active_window, true);
             if (WD.screen->start_visual_bell_at != 0) {
-                double bell_left = OPT(visual_bell_duration) - (now - WD.screen->start_visual_bell_at);
+                monotonic_t bell_left = OPT(visual_bell_duration) - (now - WD.screen->start_visual_bell_at);
                 set_maximum_wait(bell_left);
             }
             w->cursor_visible_at_last_render = WD.screen->cursor_render_info.is_visible; w->last_cursor_x = WD.screen->cursor_render_info.x; w->last_cursor_y = WD.screen->cursor_render_info.y; w->last_cursor_shape = WD.screen->cursor_render_info.shape;
@@ -632,23 +633,23 @@ draw_resizing_text(OSWindow *w) {
     snprintf(text, sizeof(text), "%u x %u cells", width / w->fonts_data->cell_width, height / w->fonts_data->cell_height);
     StringCanvas rendered = render_simple_text(w->fonts_data, text);
     if (rendered.canvas) {
-        draw_centered_alpha_mask(w->gvao_idx, width, height, rendered.width, rendered.height, rendered.canvas);
+        draw_centered_alpha_mask(w, width, height, rendered.width, rendered.height, rendered.canvas);
         free(rendered.canvas);
     }
 }
 
 static inline bool
-no_render_frame_received_recently(OSWindow *w, double now, double max_wait) {
+no_render_frame_received_recently(OSWindow *w, monotonic_t now, monotonic_t max_wait) {
     bool ans = now - w->last_render_frame_received_at > max_wait;
-    if (ans) log_error("No render frame received in %f seconds, re-requesting at: %f", max_wait, now);
+    if (ans) log_error("No render frame received in %.2f seconds, re-requesting at: %f", monotonic_t_to_s_double(max_wait), monotonic_t_to_s_double(now));
     return ans;
 }
 
 static inline void
-render(double now, bool input_read) {
+render(monotonic_t now, bool input_read) {
     EVDBG("input_read: %d", input_read);
-    static double last_render_at = -DBL_MAX;
-    double time_since_last_render = now - last_render_at;
+    static monotonic_t last_render_at = MONOTONIC_T_MIN;
+    monotonic_t time_since_last_render = last_render_at == MONOTONIC_T_MIN ? OPT(repaint_delay) : now - last_render_at;
     if (!input_read && time_since_last_render < OPT(repaint_delay)) {
         set_maximum_wait(OPT(repaint_delay) - time_since_last_render);
         return;
@@ -662,7 +663,7 @@ render(double now, bool input_read) {
             continue;
         }
         if (USE_RENDER_FRAMES && w->render_state != RENDER_FRAME_READY) {
-            if (w->render_state == RENDER_FRAME_NOT_REQUESTED || no_render_frame_received_recently(w, now, 0.25)) request_frame_render(w);
+            if (w->render_state == RENDER_FRAME_NOT_REQUESTED || no_render_frame_received_recently(w, now, ms_to_monotonic_t(250ll))) request_frame_render(w);
             continue;
         }
         make_os_window_context_current(w);
@@ -806,7 +807,7 @@ add_python_timer(PyObject *self UNUSED, PyObject *args) {
     double interval;
     int repeats = 1;
     if (!PyArg_ParseTuple(args, "Od|p", &callback, &interval, &repeats)) return NULL;
-    unsigned long long timer_id = add_main_loop_timer(interval, repeats ? true: false, python_timer_callback, callback, python_timer_cleanup);
+    unsigned long long timer_id = add_main_loop_timer(s_double_to_monotonic_t(interval), repeats ? true: false, python_timer_callback, callback, python_timer_cleanup);
     Py_INCREF(callback);
     return Py_BuildValue("K", timer_id);
 }
@@ -821,7 +822,7 @@ remove_python_timer(PyObject *self UNUSED, PyObject *args) {
 
 
 static inline void
-process_pending_resizes(double now) {
+process_pending_resizes(monotonic_t now) {
     global_state.has_pending_resizes = false;
     for (size_t i = 0; i < global_state.num_os_windows; i++) {
         OSWindow *w = global_state.os_windows + i;
@@ -830,11 +831,11 @@ process_pending_resizes(double now) {
             if (w->live_resize.from_os_notification) {
                 if (w->live_resize.os_says_resize_complete || (now - w->live_resize.last_resize_event_at) > 1) update_viewport = true;
             } else {
-                double debounce_time = OPT(resize_debounce_time);
+                monotonic_t debounce_time = OPT(resize_debounce_time);
                 // if more than one resize event has occurred, wait at least 0.2 secs
                 // before repainting, to avoid rapid transitions between the cells banner
                 // and the normal screen
-                if (w->live_resize.num_of_resize_events > 1 && OPT(resize_draw_strategy) == RESIZE_DRAW_SIZE) debounce_time = MAX(0.2, debounce_time);
+                if (w->live_resize.num_of_resize_events > 1 && OPT(resize_draw_strategy) == RESIZE_DRAW_SIZE) debounce_time = MAX(ms_to_monotonic_t(200ll), debounce_time);
                 if (now - w->live_resize.last_resize_event_at >= debounce_time) update_viewport = true;
                 else {
                     global_state.has_pending_resizes = true;
@@ -915,10 +916,14 @@ process_global_state(void *data) {
     ChildMonitor *self = data;
     maximum_wait = -1;
     bool state_check_timer_enabled = false;
+    bool input_read = false;
 
-    double now = monotonic();
-    if (global_state.has_pending_resizes) process_pending_resizes(now);
-    bool input_read = parse_input(self);
+    monotonic_t now = monotonic();
+    if (global_state.has_pending_resizes) {
+        process_pending_resizes(now);
+        input_read = true;
+    }
+    if (parse_input(self)) input_read = true;
     render(now, input_read);
 #ifdef __APPLE__
         if (cocoa_pending_actions) {
@@ -1167,7 +1172,7 @@ io_loop(void *data) {
     size_t i;
     int ret;
     bool has_more, data_received, has_pending_wakeups = false;
-    double last_main_loop_wakeup_at = -1, now = -1;
+    monotonic_t last_main_loop_wakeup_at = -1, now = -1;
     Screen *screen;
     ChildMonitor *self = (ChildMonitor*)data;
     set_thread_name("KittyChildMon");
@@ -1188,8 +1193,8 @@ io_loop(void *data) {
         }
         if (has_pending_wakeups) {
             now = monotonic();
-            double time_delta = OPT(input_delay) - (now - last_main_loop_wakeup_at);
-            if (time_delta >= 0) ret = poll(fds, self->count + EXTRA_FDS, (int)ceil(1000 * time_delta));
+            monotonic_t time_delta = OPT(input_delay) - (now - last_main_loop_wakeup_at);
+            if (time_delta >= 0) ret = poll(fds, self->count + EXTRA_FDS, monotonic_t_to_ms(time_delta));
             else ret = 0;
         } else {
             ret = poll(fds, self->count + EXTRA_FDS, -1);

kitty/child.py

@@ -4,9 +4,9 @@
 
 import fcntl
 import os
+import sys
 from collections import defaultdict
-from contextlib import contextmanager
-from contextlib import suppress
+from contextlib import contextmanager, suppress
 
 import kitty.fast_data_types as fast_data_types
 
@@ -51,7 +51,7 @@ else:
             try:
                 with open('/proc/' + x + '/stat', 'rb') as f:
                     raw = f.read().decode('utf-8')
-            except EnvironmentError:
+            except OSError:
                 continue
             try:
                 q = int(raw.split(' ', 5)[4])
@@ -125,15 +125,24 @@ def remove_blocking(fd):
     os.set_blocking(fd, False)
 
 
+def process_env():
+    ans = os.environ
+    ssl_env_var = getattr(sys, 'kitty_ssl_env_var', None)
+    if ssl_env_var is not None:
+        ans = ans.copy()
+        ans.pop(ssl_env_var, None)
+    return ans
+
+
 def default_env():
     try:
         return default_env.env
     except AttributeError:
-        return os.environ
+        return process_env()
 
 
 def set_default_env(val=None):
-    env = os.environ.copy()
+    env = process_env().copy()
     if val:
         env.update(val)
     default_env.env = env
@@ -151,12 +160,8 @@ class Child:
     child_fd = pid = None
     forked = False
 
-    def __init__(self, argv, cwd, opts, stdin=None, env=None, cwd_from=None):
-        self.allow_remote_control = False
-        if argv and argv[0] == '@':
-            self.allow_remote_control = True
-            if len(argv) > 1:
-                argv = argv[1:]
+    def __init__(self, argv, cwd, opts, stdin=None, env=None, cwd_from=None, allow_remote_control=False):
+        self.allow_remote_control = allow_remote_control
         self.argv = argv
         if cwd_from is not None:
             try:
@@ -262,6 +267,13 @@ class Child:
         except Exception:
             return list(self.argv)
 
+    @property
+    def foreground_cmdline(self):
+        try:
+            return cmdline_of_process(self.pid_for_cwd) or self.cmdline
+        except Exception:
+            return self.cmdline
+
     @property
     def environ(self):
         try:
@@ -287,3 +299,14 @@ class Child:
     def foreground_cwd(self):
         with suppress(Exception):
             return cwd_of_process(self.pid_for_cwd) or None
+
+    @property
+    def foreground_environ(self):
+        try:
+            return environ_of_process(self.pid_for_cwd)
+        except Exception:
+            try:
+                return environ_of_process(self.pid)
+            except Exception:
+                pass
+        return {}

kitty/choose_entry.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python
+# vim:fileencoding=utf-8
+# License: GPLv3 Copyright: 2019, Kovid Goyal <kovid at kovidgoyal.net>
+
+import re
+
+
+def mark(text, args, Mark, extra_cli_args, *a):
+    for idx, m in enumerate(re.finditer(args.regex, text)):
+        start, end = m.span()
+        mark_text = text[start:end].replace('\n', '').replace('\0', '')
+        yield Mark(idx, start, end, mark_text, {'index': idx})

kitty/cli.py

@@ -223,9 +223,9 @@ def get_defaults_from_seq(seq):
 default_msg = ('''\
 Run the :italic:`{appname}` terminal emulator. You can also specify the :italic:`program`
 to run inside :italic:`{appname}` as normal arguments following the :italic:`options`.
-For example: {appname} /bin/sh
+For example: {appname} sh -c "echo hello, world. Press ENTER to quit; read"
 
-For comprehensive documentation for kitty, please see: https://sw.kovidgoyal.net/kitty''').format(appname=appname)
+For comprehensive documentation for kitty, please see: https://sw.kovidgoyal.net/kitty/''').format(appname=appname)
 
 
 def print_help_for_seq(seq, usage, message, appname):
@@ -233,7 +233,7 @@ def print_help_for_seq(seq, usage, message, appname):
     screen_size = screen_size_function()
     try:
         linesz = min(screen_size().cols, 76)
-    except EnvironmentError:
+    except OSError:
         linesz = 76
     blocks = []
     a = blocks.append
@@ -423,8 +423,8 @@ class Options:
 class Namespace:
 
     def __init__(self, kwargs):
-        for name in kwargs:
-            setattr(self, name, kwargs[name])
+        for name, val in kwargs.items():
+            setattr(self, name, val)
 
 
 def parse_cmdline(oc, disabled, args=None):

kitty/cmds.py

@@ -7,10 +7,16 @@ import os
 import sys
 from contextlib import suppress
 
-from .cli import parse_args, parse_option_spec, get_defaults_from_seq
+from .cli import (
+    Namespace, get_defaults_from_seq, parse_args, parse_option_spec
+)
 from .config import parse_config, parse_send_text_bytes
 from .constants import appname
 from .fast_data_types import focus_os_window
+from .launch import (
+    launch as do_launch, options_spec as launch_options_spec,
+    parse_launch_args
+)
 from .tabs import SpecialWindow
 from .utils import natsort_ints
 
@@ -375,6 +381,176 @@ def set_tab_title(boss, window, payload):
 # }}}
 
 
+# create_marker {{{
+@cmd(
+    'Create a marker that highlights specified text',
+    'Create a marker which can highlight text in the specified window. For example: '
+    'create_marker text 1 ERROR. For full details see: https://sw.kovidgoyal.net/kitty/marks.html',
+    options_spec=MATCH_WINDOW_OPTION + '''\n
+--self
+type=bool-set
+If specified apply marker to the window this command is run in, rather than the active window.
+''',
+    argspec='MARKER SPECIFICATION'
+)
+def cmd_create_marker(global_opts, opts, args):
+    '''
+    match: Which window to detach
+    self: Boolean indicating whether to detach the window the command is run in
+    marker_spec: A list or arguments that define the marker specification, for example: ['text', '1', 'ERROR']
+    '''
+    from .config import parse_marker_spec
+    if len(args) < 2:
+        raise ValueError('Invalid marker specification: {}'.format(' '.join(args)))
+    parse_marker_spec(args[0], args[1:])
+    return {'match': opts.match, 'self': opts.self, 'marker_spec': args}
+
+
+def create_marker(boss, window, payload):
+    pg = cmd_create_marker.payload_get
+    match = pg(payload, 'match')
+    if match:
+        windows = tuple(boss.match_windows(match))
+        if not windows:
+            raise MatchError(match)
+    else:
+        windows = [window if window and pg(payload, 'self') else boss.active_window]
+    args = pg(payload, 'marker_spec')
+
+    for window in windows:
+        window.set_marker(args)
+
+# }}}
+
+
+# remove_marker {{{
+@cmd(
+    'Remove the currently set marker, if any.',
+    options_spec=MATCH_WINDOW_OPTION + '''\n
+--self
+type=bool-set
+If specified apply marker to the window this command is run in, rather than the active window.
+''',
+    argspec=''
+)
+def cmd_remove_marker(global_opts, opts, args):
+    '''
+    match: Which window to detach
+    self: Boolean indicating whether to detach the window the command is run in
+    '''
+    return {'match': opts.match, 'self': opts.self}
+
+
+def remove_marker(boss, window, payload):
+    pg = cmd_create_marker.payload_get
+    match = pg(payload, 'match')
+    if match:
+        windows = tuple(boss.match_windows(match))
+        if not windows:
+            raise MatchError(match)
+    else:
+        windows = [window if window and pg(payload, 'self') else boss.active_window]
+
+    for window in windows:
+        window.remove_marker()
+
+# }}}
+
+
+# detach_window {{{
+@cmd(
+    'Detach a window and place it in a different/new tab',
+    'Detach the specified window and either move it into a new tab, a new OS window'
+    ' or add it to the specified tab. Use the special value :code:`new` for --target-tab'
+    ' to move to a new tab. If no target tab is specified the window is moved to a new OS window.',
+    options_spec=MATCH_WINDOW_OPTION + '\n\n' + MATCH_TAB_OPTION.replace('--match -m', '--target-tab -t') + '''\n
+--self
+type=bool-set
+If specified detach the window this command is run in, rather than the active window.
+''',
+    argspec=''
+)
+def cmd_detach_window(global_opts, opts, args):
+    '''
+    match: Which window to detach
+    target: Which tab to move the detached window to
+    self: Boolean indicating whether to detach the window the command is run in
+    '''
+    return {'match': opts.match, 'target': opts.target_tab, 'self': opts.self}
+
+
+def detach_window(boss, window, payload):
+    pg = cmd_detach_window.payload_get
+    match = pg(payload, 'match')
+    if match:
+        windows = tuple(boss.match_windows(match))
+        if not windows:
+            raise MatchError(match)
+    else:
+        windows = [window if window and pg(payload, 'self') else boss.active_window]
+    match = pg(payload, 'target_tab')
+    kwargs = {}
+    if match:
+        if match == 'new':
+            kwargs['target_tab_id'] = 'new'
+        else:
+            tabs = tuple(boss.match_tabs(match))
+            if not tabs:
+                raise MatchError(match, 'tabs')
+            kwargs['target_tab_id'] = tabs[0].id
+    if not kwargs:
+        kwargs['target_os_window_id'] = 'new'
+
+    for window in windows:
+        boss._move_window_to(window=window, **kwargs)
+
+# }}}
+
+
+# detach_tab {{{
+@cmd(
+    'Detach a tab and place it in a different/new OS Window',
+    'Detach the specified tab and either move it into a new OS window'
+    ' or add it to the OS Window containing the tab specified by --target-tab',
+    options_spec=MATCH_TAB_OPTION + '\n\n' + MATCH_TAB_OPTION.replace('--match -m', '--target-tab -t') + '''\n
+--self
+type=bool-set
+If specified detach the tab this command is run in, rather than the active tab.
+''',
+    argspec=''
+)
+def cmd_detach_tab(global_opts, opts, args):
+    '''
+    match: Which tab to detach
+    target: Which OS Window to move the detached tab to
+    self: Boolean indicating whether to detach the tab the command is run in
+    '''
+    return {'match': opts.match, 'target': opts.target_tab, 'self': opts.self}
+
+
+def detach_tab(boss, window, payload):
+    pg = cmd_detach_tab.payload_get
+    match = pg(payload, 'match')
+    if match:
+        tabs = tuple(boss.match_tabs(match))
+        if not tabs:
+            raise MatchError(match)
+    else:
+        tabs = [window.tabref() if pg(payload, 'self') and window and window.tabref() else boss.active_tab]
+    match = pg(payload, 'target_tab')
+    kwargs = {}
+    if match:
+        targets = tuple(boss.match_tabs(match))
+        if not targets:
+            raise MatchError(match, 'tabs')
+        kwargs['target_os_window_id'] = targets[0].os_window_id
+
+    for tab in tabs:
+        boss._move_tab_to(tab=tab, **kwargs)
+
+# }}}
+
+
 # goto_layout {{{
 @cmd(
     'Set the window layout',
@@ -675,6 +851,77 @@ def new_window(boss, window, payload):
 # }}}
 
 
+# launch {{{
+@cmd(
+    'Run an arbitrary process in a new window/tab',
+    ' Prints out the id of the newly opened window. Any command line arguments'
+    ' are assumed to be the command line used to run in the new window, if none'
+    ' are provided, the default shell is run. For example:'
+    ' :italic:`kitty @ launch --title Email mutt`.',
+    options_spec=MATCH_TAB_OPTION + '\n\n' + '''\
+--no-response
+type=bool-set
+Do not print out the id of the newly created window.
+
+
+--self
+type=bool-set
+If specified the tab containing the window this command is run in is used
+instead of the active tab
+    ''' + '\n\n' + launch_options_spec().replace(':option:`launch', ':option:`kitty @ launch'),
+    argspec='[CMD ...]'
+)
+def cmd_launch(global_opts, opts, args):
+    '''
+    args+: The command line to run in the new window, as a list, use an empty list to run the default shell
+    match: The tab to open the new window in
+    window_title: Title for the new window
+    cwd: Working directory for the new window
+    env: List of environment varibles of the form NAME=VALUE
+    tab_title: Title for the new tab
+    type: The type of window to open
+    keep_focus: Boolean indicating whether the current window should retain focus or not
+    copy_colors: Boolean indicating whether to copy the colors from the current window
+    copy_cmdline: Boolean indicating whether to copy the cmdline from the current window
+    copy_env: Boolean indicating whether to copy the environ from the current window
+    location: Where in the tab to open the new window
+    allow_remote_control: Boolean indicating whether to allow remote control from the new window
+    stdin_source: Where to get stdin for thew process from
+    stdin_add_formatting: Boolean indicating whether to add formatting codes to stdin
+    stdin_add_line_wrap_markers: Boolean indicating whether to add line wrap markers to stdin
+    no_response: Boolean indicating whether to send back the window id
+    marker: Specification for marker for new window, for example: "text 1 ERROR"
+    '''
+    if opts.no_response:
+        global_opts.no_command_response = True
+    ans = {'args': args or []}
+    for attr, val in opts.__dict__.items():
+        ans[attr] = val
+    return ans
+
+
+def launch(boss, window, payload):
+    pg = cmd_launch.payload_get
+    default_opts = parse_launch_args()[0]
+    opts = {}
+    for key, default_value in default_opts.__dict__.items():
+        opts[key] = payload.get(key, default_value)
+    opts = Namespace(opts)
+    match = pg(payload, 'match')
+    if match:
+        tabs = tuple(boss.match_tabs(match))
+        if not tabs:
+            raise MatchError(match, 'tabs')
+    else:
+        tabs = [boss.active_tab]
+        if pg(payload, 'self') and window and window.tabref():
+            tabs = [window.tabref()]
+    tab = tabs[0]
+    w = do_launch(boss, opts, pg(payload, 'args') or None, target_tab=tab)
+    return None if pg(payload, 'no_response') else str(getattr(w, 'id', 0))
+# }}}
+
+
 # focus_window {{{
 @cmd(
     'Focus the specified window',
@@ -882,7 +1129,7 @@ this option, any color arguments are ignored and --configured and --all are impl
 def cmd_set_colors(global_opts, opts, args):
     '''
     colors+: An object mapping names to colors as 24-bit RGB integers
-    cursor_text_color: A 24-bit clor for text under the cursor
+    cursor_text_color: A 24-bit color for text under the cursor
     match_window: Window to change colors in
     match_tab: Tab to change colors in
     all: Boolean indicating change colors everywhere or not

kitty/cocoa_window.m

@@ -7,6 +7,7 @@
 
 
 #include "state.h"
+#include "monotonic.h"
 #include <Cocoa/Cocoa.h>
 
 #include <AvailabilityMacros.h>
@@ -72,16 +73,21 @@ find_app_name(void) {
 
 @implementation GlobalMenuTarget
 
-- (void) show_preferences              : (id)sender {
+- (void)show_preferences:(id)sender {
     (void)sender;
     set_cocoa_pending_action(PREFERENCES_WINDOW, NULL);
 }
 
-- (void) new_os_window              : (id)sender {
+- (void)new_os_window:(id)sender {
     (void)sender;
     set_cocoa_pending_action(NEW_OS_WINDOW, NULL);
 }
 
+- (void)open_kitty_website_url:(id)sender {
+    (void)sender;
+    [[NSWorkspace sharedWorkspace] openURL:[NSURL URLWithString:@"https://sw.kovidgoyal.net/kitty/"]];
+}
+
 
 + (GlobalMenuTarget *) shared_instance
 {
@@ -96,7 +102,7 @@ find_app_name(void) {
 
 @end
 
-static unichar new_window_key = 0;
+static char new_window_key[32] = {0};
 static NSEventModifierFlags new_window_mods = 0;
 
 static PyObject*
@@ -104,9 +110,9 @@ cocoa_set_new_window_trigger(PyObject *self UNUSED, PyObject *args) {
     int mods, key;
     if (!PyArg_ParseTuple(args, "ii", &mods, &key)) return NULL;
     int nwm;
-    get_cocoa_key_equivalent(key, mods, &new_window_key, &nwm);
+    get_cocoa_key_equivalent(key, mods, new_window_key, sizeof(new_window_key), &nwm);
     new_window_mods = nwm;
-    if (new_window_key) Py_RETURN_TRUE;
+    if (new_window_key[0]) Py_RETURN_TRUE;
     Py_RETURN_FALSE;
 }
 
@@ -117,10 +123,10 @@ get_dock_menu(id self UNUSED, SEL _cmd UNUSED, NSApplication *sender UNUSED) {
     if (!dockMenu) {
         GlobalMenuTarget *global_menu_target = [GlobalMenuTarget shared_instance];
         dockMenu = [[NSMenu alloc] init];
-        NSMenuItem *newWindowItem = [dockMenu addItemWithTitle:@"New OS window"
-                            action:@selector(new_os_window:)
-                            keyEquivalent:@""];
-        [newWindowItem setTarget:global_menu_target];
+        [[dockMenu addItemWithTitle:@"New OS window"
+                             action:@selector(new_os_window:)
+                      keyEquivalent:@""]
+                          setTarget:global_menu_target];
     }
     return dockMenu;
 }
@@ -231,41 +237,41 @@ cocoa_send_notification(PyObject *self UNUSED, PyObject *args) {
 // global menu {{{
 void
 cocoa_create_global_menu(void) {
-    @autoreleasepool {
-
     NSString* app_name = find_app_name();
     NSMenu* bar = [[NSMenu alloc] init];
     GlobalMenuTarget *global_menu_target = [GlobalMenuTarget shared_instance];
     [NSApp setMainMenu:bar];
 
     NSMenuItem* appMenuItem =
-        [bar addItemWithTitle:@"" action:NULL keyEquivalent:@""];
+        [bar addItemWithTitle:@""
+                       action:NULL
+                keyEquivalent:@""];
     NSMenu* appMenu = [[NSMenu alloc] init];
     [appMenuItem setSubmenu:appMenu];
 
     [appMenu addItemWithTitle:[NSString stringWithFormat:@"About %@", app_name]
                        action:@selector(orderFrontStandardAboutPanel:)
-                       keyEquivalent:@""];
+                keyEquivalent:@""];
     [appMenu addItem:[NSMenuItem separatorItem]];
-    NSMenuItem* preferences_menu_item = [[NSMenuItem alloc] initWithTitle:@"Preferences..." action:@selector(show_preferences:) keyEquivalent:@","], *new_os_window_menu_item = NULL;
-    [preferences_menu_item setTarget:global_menu_target];
-    [appMenu addItem:preferences_menu_item];
-    if (new_window_key) {
-        NSString *s = [NSString stringWithCharacters:&new_window_key length:1];
-        new_os_window_menu_item = [[NSMenuItem alloc] initWithTitle:@"New OS window" action:@selector(new_os_window:) keyEquivalent:s];
-        [new_os_window_menu_item setKeyEquivalentModifierMask:new_window_mods];
-        [new_os_window_menu_item setTarget:global_menu_target];
-        [appMenu addItem:new_os_window_menu_item];
-        [s release];
-    }
+    [[appMenu addItemWithTitle:@"Preferences..."
+                       action:@selector(show_preferences:)
+                keyEquivalent:@","]
+                    setTarget:global_menu_target];
+
+    NSMenuItem* new_os_window_menu_item =
+        [appMenu addItemWithTitle:@"New OS window"
+                           action:@selector(new_os_window:)
+                    keyEquivalent:@(new_window_key)];
+    [new_os_window_menu_item setKeyEquivalentModifierMask:new_window_mods];
+    [new_os_window_menu_item setTarget:global_menu_target];
 
 
     [appMenu addItemWithTitle:[NSString stringWithFormat:@"Hide %@", app_name]
                        action:@selector(hide:)
                 keyEquivalent:@"h"];
     [[appMenu addItemWithTitle:@"Hide Others"
-                       action:@selector(hideOtherApplications:)
-                keyEquivalent:@"h"]
+                        action:@selector(hideOtherApplications:)
+                 keyEquivalent:@"h"]
         setKeyEquivalentModifierMask:NSEventModifierFlagOption | NSEventModifierFlagCommand];
     [appMenu addItemWithTitle:@"Show All"
                        action:@selector(unhideAllApplications:)
@@ -275,19 +281,21 @@ cocoa_create_global_menu(void) {
     NSMenu* servicesMenu = [[NSMenu alloc] init];
     [NSApp setServicesMenu:servicesMenu];
     [[appMenu addItemWithTitle:@"Services"
-                       action:NULL
-                keyEquivalent:@""] setSubmenu:servicesMenu];
+                        action:NULL
+                 keyEquivalent:@""] setSubmenu:servicesMenu];
     [servicesMenu release];
 
     [appMenu addItem:[NSMenuItem separatorItem]];
 
     [appMenu addItemWithTitle:[NSString stringWithFormat:@"Quit %@", app_name]
                        action:@selector(terminate:)
-                       keyEquivalent:@"q"];
+                keyEquivalent:@"q"];
     [appMenu release];
 
     NSMenuItem* windowMenuItem =
-        [bar addItemWithTitle:@"" action:NULL keyEquivalent:@""];
+        [bar addItemWithTitle:@""
+                       action:NULL
+                keyEquivalent:@""];
     NSMenu* windowMenu = [[NSMenu alloc] initWithTitle:@"Window"];
     [windowMenuItem setSubmenu:windowMenu];
 
@@ -309,28 +317,34 @@ cocoa_create_global_menu(void) {
      setKeyEquivalentModifierMask:NSEventModifierFlagControl | NSEventModifierFlagCommand];
     [NSApp setWindowsMenu:windowMenu];
     [windowMenu release];
-    [preferences_menu_item release];
-    if (new_os_window_menu_item) {
-        [new_os_window_menu_item release];
-    }
+
+    NSMenuItem* helpMenuItem =
+        [bar addItemWithTitle:@"Help"
+                       action:NULL
+                keyEquivalent:@""];
+    NSMenu* helpMenu = [[NSMenu alloc] initWithTitle:@"Help"];
+    [helpMenuItem setSubmenu:helpMenu];
+    [[helpMenu addItemWithTitle:[NSString stringWithFormat:@"Visit %@ website", app_name]
+                         action:@selector(open_kitty_website_url:)
+                  keyEquivalent:@"?"]
+                      setTarget:global_menu_target];
+    [helpMenu release];
 
     [bar release];
 
     class_addMethod(
-            object_getClass([NSApp delegate]),
-            @selector(applicationDockMenu:),
-            (IMP)get_dock_menu,
-            "@@:@");
+        object_getClass([NSApp delegate]),
+        @selector(applicationDockMenu:),
+        (IMP)get_dock_menu,
+        "@@:@");
 
 
     [NSApp setServicesProvider:[[[ServiceProvider alloc] init] autorelease]];
-
-    } // autoreleasepool
 }
 
 void
 cocoa_update_menu_bar_title(PyObject *pytitle) {
-    NSString *title = [[NSString alloc] initWithUTF8String:PyUnicode_AsUTF8(pytitle)];
+    NSString *title = @(PyUnicode_AsUTF8(pytitle));
     NSMenu *bar = [NSApp mainMenu];
     if (title_menu != NULL) {
         [bar removeItem:title_menu];
@@ -339,7 +353,6 @@ cocoa_update_menu_bar_title(PyObject *pytitle) {
     NSMenu *m = [[NSMenu alloc] initWithTitle:[NSString stringWithFormat:@" :: %@", title]];
     [title_menu setSubmenu:m];
     [m release];
-    [title release];
 } // }}}
 
 bool
@@ -367,7 +380,7 @@ cocoa_make_window_resizable(void *w, bool resizable) {
 bool
 cocoa_alt_option_key_pressed(NSUInteger flags) {
     NSUInteger q = (OPT(macos_option_as_alt) == 1) ? NSRightAlternateKeyMask : NSLeftAlternateKeyMask;
-    return ((q & flags) == q) ? true : false;
+    return (q & flags) == q;
 }
 
 void
@@ -411,7 +424,7 @@ cocoa_get_lang(PyObject UNUSED *self) {
     } // autoreleasepool
 }
 
-double
+monotonic_t
 cocoa_cursor_blink_interval(void) {
     @autoreleasepool {
 
@@ -420,12 +433,12 @@ cocoa_cursor_blink_interval(void) {
     double off_period_ms = [defaults doubleForKey:@"NSTextInsertionPointBlinkPeriodOff"];
     double period_ms = [defaults doubleForKey:@"NSTextInsertionPointBlinkPeriod"];
     double max_value = 60 * 1000.0, ans = -1.0;
-    if (on_period_ms || off_period_ms) {
+    if (on_period_ms != 0. || off_period_ms != 0.) {
         ans = on_period_ms + off_period_ms;
-    } else if (period_ms) {
+    } else if (period_ms != 0.) {
         ans = period_ms;
     }
-    return ans > max_value ? 0.0 : ans;
+    return ans > max_value ? 0ll : ms_double_to_monotonic_t(ans);
 
     } // autoreleasepool
 }
@@ -473,7 +486,6 @@ cleanup() {
     dockMenu = nil;
     if (notification_activated_callback) Py_DECREF(notification_activated_callback);
     notification_activated_callback = NULL;
-
     } // autoreleasepool
 }
 
@@ -488,6 +500,30 @@ cocoa_hide_window_title(void *w)
     } // autoreleasepool
 }
 
+void
+cocoa_hide_titlebar(void *w)
+{
+    @autoreleasepool {
+
+    cocoa_hide_window_title(w);
+
+    NSWindow *window = (NSWindow*)w;
+    NSButton *button;
+
+    button = [window standardWindowButton: NSWindowCloseButton];
+    if (button) button.hidden = true;
+    button = [window standardWindowButton: NSWindowMiniaturizeButton];
+    if (button) button.hidden = true;
+    button = [window standardWindowButton: NSWindowZoomButton];
+    if (button) button.hidden = true;
+
+    [window setTitlebarAppearsTransparent:YES];
+    [window setStyleMask:
+        [window styleMask] | NSWindowStyleMaskFullSizeContentView];
+
+    } // autoreleasepool
+}
+
 static PyMethodDef module_methods[] = {
     {"cocoa_get_lang", (PyCFunction)cocoa_get_lang, METH_NOARGS, ""},
     {"cocoa_set_new_window_trigger", (PyCFunction)cocoa_set_new_window_trigger, METH_VARARGS, ""},

kitty/colors.c

@@ -6,7 +6,7 @@
  */
 
 #define EXTRA_INIT if (PyModule_AddFunctions(module, module_methods) != 0) return false;
-#include "data-types.h"
+#include "state.h"
 #include <structmember.h>
 
 PyTypeObject ColorProfile_Type;
@@ -69,6 +69,9 @@ new(PyTypeObject *type, PyObject UNUSED *args, PyObject UNUSED *kwds) {
         init_FG_BG_table();
         memcpy(self->color_table, FG_BG_256, sizeof(FG_BG_256));
         memcpy(self->orig_color_table, FG_BG_256, sizeof(FG_BG_256));
+#define S(which) self->mark_foregrounds[which] = OPT(mark##which##_foreground); self->mark_backgrounds[which] = OPT(mark##which##_background)
+        S(1); S(2); S(3);
+#undef S
         self->dirty = true;
     }
     return (PyObject*) self;
@@ -107,6 +110,32 @@ copy_color_profile(ColorProfile *dest, ColorProfile *src) {
     dest->dirty = true;
 }
 
+static inline void
+patch_color_table(const char *key, PyObject *profiles, PyObject *spec, size_t which, int change_configured) {
+    PyObject *v = PyDict_GetItemString(spec, key);
+    if (v) {
+        color_type color = PyLong_AsUnsignedLong(v);
+        for (Py_ssize_t j = 0; j < PyTuple_GET_SIZE(profiles); j++) {
+            ColorProfile *self = (ColorProfile*)PyTuple_GET_ITEM(profiles, j);
+            self->color_table[which] = color;
+            if (change_configured) self->orig_color_table[which] = color;
+            self->dirty = true;
+        }
+    }
+
+}
+
+#define patch_mark_color(key, profiles, spec, array, i) { \
+    PyObject *v = PyDict_GetItemString(spec, key); \
+    if (v) { \
+        color_type color = PyLong_AsUnsignedLong(v); \
+        for (Py_ssize_t j = 0; j < PyTuple_GET_SIZE(profiles); j++) { \
+            ColorProfile *self = (ColorProfile*)PyTuple_GET_ITEM(profiles, j); \
+            self->array[i] = color; \
+            self->dirty = true; \
+} } }
+
+
 static PyObject*
 patch_color_profiles(PyObject *module UNUSED, PyObject *args) {
     PyObject *spec, *profiles, *v; ColorProfile *self; int change_configured; PyObject *cursor_text_color;
@@ -114,16 +143,12 @@ patch_color_profiles(PyObject *module UNUSED, PyObject *args) {
     char key[32] = {0};
     for (size_t i = 0; i < arraysz(FG_BG_256); i++) {
         snprintf(key, sizeof(key) - 1, "color%zu", i);
-        v = PyDict_GetItemString(spec, key);
-        if (v) {
-            color_type color = PyLong_AsUnsignedLong(v);
-            for (Py_ssize_t j = 0; j < PyTuple_GET_SIZE(profiles); j++) {
-                self = (ColorProfile*)PyTuple_GET_ITEM(profiles, j);
-                self->color_table[i] = color;
-                if (change_configured) self->orig_color_table[i] = color;
-                self->dirty = true;
-            }
-        }
+        patch_color_table(key, profiles, spec, i, change_configured);
+    }
+    for (size_t i = 1; i <= MARK_MASK; i++) {
+#define S(which, i) snprintf(key, sizeof(key) - 1, "mark%zu_" #which, i); patch_mark_color(key, profiles, spec, mark_##which##s, i)
+    S(background, i); S(foreground, i);
+#undef S
     }
 #define S(config_name, profile_name) { \
     v = PyDict_GetItemString(spec, #config_name); \
@@ -282,8 +307,13 @@ void
 copy_color_table_to_buffer(ColorProfile *self, color_type *buf, int offset, size_t stride) {
     size_t i;
     stride = MAX(1u, stride);
-    for (i = 0, buf = buf + offset; i < sizeof(self->color_table)/sizeof(self->color_table[0]); i++, buf += stride) {
-        *buf = self->color_table[i];
+    for (i = 0, buf = buf + offset; i < arraysz(self->color_table); i++, buf += stride) *buf = self->color_table[i];
+    // Copy the mark colors
+    for (i = 0; i < arraysz(self->mark_backgrounds); i++) {
+        *buf = self->mark_backgrounds[i]; buf += stride;
+    }
+    for (i = 0; i < arraysz(self->mark_foregrounds); i++) {
+        *buf = self->mark_foregrounds[i]; buf += stride;
     }
     self->dirty = false;
 }

kitty/complete.py

@@ -16,7 +16,7 @@ from .shell import options_for_cmd
 To add completion for a new shell, you need to:
 
 1) Add an entry to completion scripts for your shell, this is
-a simple function that call's kitty's completion code and passes the
+a simple function that calls kitty's completion code and passes the
 results to the shell's completion system. This can be output by
 `kitty +complete setup shell_name` and its output goes into
 your shell's rc file.

kitty/conf/utils.py

@@ -80,7 +80,7 @@ def parse_line(line, type_map, special_handling, ans, all_keys, base_path_for_in
                 _parse(include, type_map, special_handling, ans, all_keys)
         except FileNotFoundError:
             log_error('Could not find included config file: {}, ignoring'.format(val))
-        except EnvironmentError:
+        except OSError:
             log_error('Could not read from included config file: {}, ignoring'.format(val))
         return
     if all_keys is not None and key not in all_keys:

kitty/config.py

@@ -50,7 +50,8 @@ func_with_args, args_funcs = key_func()
 
 @func_with_args(
     'pass_selection_to_program', 'new_window', 'new_tab', 'new_os_window',
-    'new_window_with_cwd', 'new_tab_with_cwd', 'new_os_window_with_cwd'
+    'new_window_with_cwd', 'new_tab_with_cwd', 'new_os_window_with_cwd',
+    'launch'
     )
 def shlex_parse(func, rest):
     return func, to_cmdline(rest)
@@ -92,6 +93,20 @@ def goto_tab_parse(func, rest):
     return func, args
 
 
+@func_with_args('detach_window')
+def detach_window_parse(func, rest):
+    if rest not in ('new', 'new-tab', 'ask'):
+        rest = 'new'
+    return func, (rest,)
+
+
+@func_with_args('detach_tab')
+def detach_tab_parse(func, rest):
+    if rest not in ('new', 'ask'):
+        rest = 'new'
+    return func, (rest,)
+
+
 @func_with_args('set_background_opacity', 'goto_layout', 'kitty_shell')
 def simple_parse(func, rest):
     return func, [rest]
@@ -193,6 +208,15 @@ def pipe(func, rest):
     return func, rest
 
 
+@func_with_args('set_colors')
+def set_colors(func, rest):
+    import shlex
+    rest = shlex.split(rest)
+    if len(rest) < 1:
+        log_error('Too few arguments to set_colors function')
+    return func, rest
+
+
 @func_with_args('nth_window')
 def nth_window(func, rest):
     try:
@@ -217,6 +241,58 @@ def disable_ligatures_in(func, rest):
     return func, [where, strategy]
 
 
+def parse_marker_spec(ftype, parts):
+    flags = re.UNICODE
+    if ftype in ('text', 'itext', 'regex', 'iregex'):
+        if ftype.startswith('i'):
+            flags |= re.IGNORECASE
+        if not parts or len(parts) % 2 != 0:
+            raise ValueError('No color specified in marker: {}'.format(' '.join(parts)))
+        ans = []
+        for i in range(0, len(parts), 2):
+            try:
+                color = max(1, min(int(parts[i]), 3))
+            except Exception:
+                raise ValueError('color {} in marker specification is not an integer'.format(parts[i]))
+            spec = parts[i + 1]
+            if 'regex' not in ftype:
+                spec = re.escape(spec)
+            ans.append((color, spec))
+        ftype = 'regex'
+        spec = tuple(ans)
+    elif ftype == 'function':
+        spec = ' '.join(parts)
+    else:
+        raise ValueError('Unknown marker type: {}'.format(ftype))
+    return ftype, spec, flags
+
+
+@func_with_args('toggle_marker')
+def toggle_marker(func, rest):
+    parts = rest.split(maxsplit=1)
+    if len(parts) != 2:
+        raise ValueError('{} if not a valid marker specification'.format(rest))
+    ftype, spec = parts
+    parts = spec.split()
+    return func, list(parse_marker_spec(ftype, parts))
+
+
+@func_with_args('scroll_to_mark')
+def scroll_to_mark(func, rest):
+    parts = rest.split()
+    if not parts or not rest:
+        return func, [True, 0]
+    if len(parts) == 1:
+        q = parts[0].lower()
+        if q in ('prev', 'previous', 'next'):
+            return func, [q != 'next', 0]
+        try:
+            return func, [True, max(0, min(int(q), 3))]
+        except Exception:
+            raise ValueError('{} is not a valid scroll_to_mark destination'.format(rest))
+    return func, [parts[0] != 'next', max(0, min(int(parts[1]), 3))]
+
+
 def parse_key_action(action):
     parts = action.strip().split(maxsplit=1)
     func = parts[0]
@@ -227,8 +303,8 @@ def parse_key_action(action):
     if parser is not None:
         try:
             func, args = parser(func, rest)
-        except Exception:
-            log_error('Ignoring invalid key action: {}'.format(action))
+        except Exception as err:
+            log_error('Ignoring invalid key action: {} with err: {}'.format(action, err))
         else:
             return KeyAction(func, args)
 
@@ -386,6 +462,33 @@ def handle_symbol_map(key, val, ans):
     ans['symbol_map'].update(parse_symbol_map(val))
 
 
+class FontFeature(str):
+
+    def __new__(cls, name, parsed):
+        ans = str.__new__(cls, name)
+        ans.parsed = parsed
+        return ans
+
+
+@special_handler
+def handle_font_features(key, val, ans):
+    if val != 'none':
+        parts = val.split()
+        if len(parts) < 2:
+            log_error("Ignoring invalid font_features {}".format(val))
+        else:
+            features = []
+            for feat in parts[1:]:
+                try:
+                    parsed = defines.parse_font_feature(feat)
+                except ValueError:
+                    log_error('Ignoring invalid font feature: {}'.format(feat))
+                else:
+                    features.append(FontFeature(feat, parsed))
+            if features:
+                ans['font_features'][parts[0]] = tuple(features)
+
+
 @special_handler
 def handle_kitten_alias(key, val, ans):
     parts = val.split(maxsplit=2)
@@ -471,7 +574,7 @@ def option_names_for_completion():
 
 
 def parse_config(lines, check_keys=True, accumulate_bad_lines=None):
-    ans = {'symbol_map': {}, 'keymap': {}, 'sequence_map': {}, 'key_definitions': [], 'env': {}, 'kitten_aliases': {}}
+    ans = {'symbol_map': {}, 'keymap': {}, 'sequence_map': {}, 'key_definitions': [], 'env': {}, 'kitten_aliases': {}, 'font_features': {}}
     parse_config_base(
         lines,
         defaults,

kitty/config_data.py

@@ -144,7 +144,8 @@ For example::
             _('Tab management'), '',
             _('''\
 You can also create shortcuts to go to specific tabs, with 1 being the first
-tab, 2 the second tab and -1 being the previously active tab::
+tab, 2 the second tab and -1 being the previously active tab, and any number
+larger than the last tab being the last tab::
 
     map ctrl+alt+1 goto_tab 1
     map ctrl+alt+2 goto_tab 2
@@ -223,6 +224,23 @@ def to_font_size(x):
 
 o('font_size', 11.0, long_text=_('Font size (in pts)'), option_type=to_font_size)
 
+o('force_ltr', False, long_text=_("""
+kitty does not support BIDI (bidirectional text), however, for RTL scripts,
+words are automatically displayed in RTL. That is
+to say, in an RTL script, the words "HELLO WORLD" display in kitty as "WORLD
+HELLO", and if you try to select a substring of an RTL-shaped string, you will
+get the character that would be there had the the string been LTR. For example,
+assuming the Hebrew word ירושלים, selecting the character that on the screen
+appears to be ם actually writes into the selection buffer the character י.
+
+kitty's default behavior is useful in conjunction with a filter to reverse the
+word order, however, if you wish to manipulate RTL glyphs, it can be very
+challenging to work with, so this option is provided to turn it off.
+Furthermore, this option can be used with the command line program
+:link:`GNU FriBidi <https://github.com/fribidi/fribidi#executable>` to get BIDI
+support, because it will force kitty to always treat the text as LTR, which
+FriBidi expects for terminals."""))
+
 
 def adjust_line_height(x):
     if x.endswith('%'):
@@ -276,6 +294,51 @@ or by defining shortcuts for it in kitty.conf, for example::
     map alt+1 disable_ligatures_in active always
     map alt+2 disable_ligatures_in all never
     map alt+3 disable_ligatures_in tab cursor
+
+'''))
+
+o('font_features', 'none', long_text=_('''
+Choose exactly which OpenType features to enable or disable. This is useful as
+some fonts might have features worthwhile in a terminal. For example, Fira
+Code Retina includes a discretionary feature, :code:`zero`, which in that font
+changes the appearance of the zero (0), to make it more easily distinguishable
+from Ø. Fira Code Retina also includes other discretionary features known as
+Stylistic Sets which have the tags :code:`ss01` through :code:`ss20`.
+
+Note that this code is indexed by PostScript name, and not the font
+family. This allows you to define very precise feature settings; e.g. you can
+disable a feature in the italic font but not in the regular font.
+
+To get the PostScript name for a font, use :code:`kitty + list-fonts --psnames`::
+
+    $ kitty + list-fonts --psnames | grep Fira
+    Fira Code
+    Fira Code Bold (FiraCode-Bold)
+    Fira Code Light (FiraCode-Light)
+    Fira Code Medium (FiraCode-Medium)
+    Fira Code Regular (FiraCode-Regular)
+    Fira Code Retina (FiraCode-Retina)
+
+The part in brackets is the PostScript name.
+
+Enable alternate zero and oldstyle numerals::
+
+    font_features FiraCode-Retina +zero +onum
+
+Enable only alternate zero::
+
+    font_features FiraCode-Retina +zero
+
+Disable the normal ligatures, but keep the :code:`calt` feature which (in this
+font) breaks up monotony::
+
+    font_features TT2020StyleB-Regular -liga +calt
+
+In conjunction with :opt:`force_ltr`, you may want to disable Arabic shaping
+entirely, and only look at their isolated forms if they show up in a document.
+You can do this with e.g.::
+
+    font_features UnifontMedium +isol -medi -fina -init
 '''))
 
 
@@ -393,10 +456,13 @@ Use negative numbers to change scroll direction.'''))
 
 g('mouse')  # {{{
 
-o('mouse_hide_wait', 3.0, option_type=float, long_text=_('''
+o('mouse_hide_wait', 0.0 if is_macos else 3.0, option_type=float, long_text=_('''
 Hide mouse cursor after the specified number of seconds
 of the mouse not being used. Set to zero to disable mouse cursor hiding.
-Set to a negative value to hide the mouse cursor immediately when typing text.'''))
+Set to a negative value to hide the mouse cursor immediately when typing text.
+Disabled by default on macOS as getting it to work robustly with
+the ever-changing sea of bugs that is Cocoa is too much effort.
+'''))
 
 o('url_color', '#0087bd', option_type=to_color, long_text=_('''
 The color and style for highlighting URLs on mouse-over.
@@ -476,6 +542,7 @@ moving the mouse around'''))
 
 o('pointer_shape_when_grabbed', 'arrow', option_type=choices('arrow', 'beam', 'hand'), long_text=('''
 The shape of the mouse pointer when the program running in the terminal grabs the mouse.
+Valid values are: :code:`arrow`, :code:`beam` and :code:`hand`
 '''))
 
 # }}}
@@ -565,7 +632,8 @@ def to_layout_names(raw):
 o('enabled_layouts', '*', option_type=to_layout_names, long_text=_('''
 The enabled window layouts. A comma separated list of layout names. The special
 value :code:`all` means all layouts. The first listed layout will be used as the
-startup layout. For a list of available layouts, see the :ref:`layouts`.
+startup layout. Default configuration is all layouts in alphabetical order.
+For a list of available layouts, see the :ref:`layouts`.
 '''))
 
 o('window_resize_step_cells', 2, option_type=positive_int, long_text=_('''
@@ -619,8 +687,18 @@ Fade the text in inactive windows by the specified amount (a number between
 zero and one, with zero being fully faded).
 '''))
 
-o('hide_window_decorations', False, long_text=_('''
-Hide the window decorations (title-bar and window borders).
+
+def hide_window_decorations(x):
+    if x == 'titlebar-only':
+        return 0b10
+    if to_bool(x):
+        return 0b01
+    return 0b00
+
+
+o('hide_window_decorations', 'no', option_type=hide_window_decorations, long_text=_('''
+Hide the window decorations (title-bar and window borders) with :code:`yes`.
+On macOS, :code:`titlebar-only` can be used to only hide the titlebar.
 Whether this works and exactly what effect it has depends on the
 window manager/operating system.
 '''))
@@ -645,6 +723,13 @@ A value of :code:`blank` means draw a blank window.
 A value of :code:`size` means show the window size in cells.
 '''))
 
+o('resize_in_steps', False, long_text=_('''
+Resize the OS window in steps as large as the cells, instead of with the usual pixel accuracy.
+Combined with an :opt:`initial_window_width` and :opt:`initial_window_height` in number of cells,
+this option can be used to keep the margins as small as possible when resizing the OS window.
+Note that this does not currently work on Wayland.
+'''))
+
 # }}}
 
 g('tabbar')   # {{{
@@ -679,10 +764,10 @@ Which edge to show the tab bar on, top or bottom'''))
 o('tab_bar_margin_width', 0.0, option_type=positive_float, long_text=_('''
 The margin to the left and right of the tab bar (in pts)'''))
 
-o('tab_bar_style', 'fade', option_type=choices('fade', 'separator', 'hidden'), long_text=_('''
-The tab bar style, can be one of: :code:`fade`, :code:`separator` or :code:`hidden`. In the fade style,
-each tab's edges fade into the background color, in the separator style, tabs are
-separated by a configurable separator.
+o('tab_bar_style', 'fade', option_type=choices('fade', 'separator', 'powerline', 'hidden'), long_text=_('''
+The tab bar style, can be one of: :code:`fade`, :code:`separator`, :code:`powerline`, or :code:`hidden`.
+In the fade style, each tab's edges fade into the background color, in the separator style, tabs are
+separated by a configurable separator, and the powerline shows the tabs as a continuous line.
 '''))
 
 o('tab_bar_min_tabs', 2, option_type=lambda x: max(1, positive_int(x)), long_text=_('''
@@ -712,12 +797,20 @@ entries to this list.
 o('tab_separator', '"{}"'.format(default_tab_separator), option_type=tab_separator, long_text=_('''
 The separator between tabs in the tab bar when using :code:`separator` as the :opt:`tab_bar_style`.'''))
 
+
+def active_tab_title_template(x):
+    return None if x == 'none' else x
+
+
 o('tab_title_template', '{title}', long_text=_('''
 A template to render the tab title. The default just renders
 the title. If you wish to include the tab-index as well,
 use something like: :code:`{index}: {title}`. Useful
 if you have shortcuts mapped for :code:`goto_tab N`.
 '''))
+o('active_tab_title_template', 'none', option_type=active_tab_title_template, long_text=_('''
+Template to use for active tabs, if not specified falls back
+to :opt:`tab_title_template`.'''))
 
 o('active_tab_foreground', '#000', option_type=to_color, long_text=_('''
 Tab bar colors and styles'''))
@@ -726,6 +819,8 @@ o('active_tab_font_style', 'bold-italic', option_type=tab_font_style)
 o('inactive_tab_foreground', '#444', option_type=to_color)
 o('inactive_tab_background', '#999', option_type=to_color)
 o('inactive_tab_font_style', 'normal', option_type=tab_font_style)
+o('tab_bar_background', 'none', option_type=to_color_or_none, long_text=_('''
+Background color for the tab bar. Defaults to using the terminal background color.'''))
 
 # }}}
 
@@ -797,6 +892,12 @@ o('color14', '#14ffff', option_type=to_color)
 o('color7', '#dddddd', long_text=_('white'), option_type=to_color)
 o('color15', '#ffffff', option_type=to_color)
 
+o('mark1_foreground', 'black', long_text=_('Color for marks of type 1'), option_type=to_color)
+o('mark1_background', '#98d3cb', long_text=_('Color for marks of type 1 (light steel blue)'), option_type=to_color)
+o('mark2_foreground', 'black', long_text=_('Color for marks of type 2'), option_type=to_color)
+o('mark2_background', '#f2dcd3', long_text=_('Color for marks of type 1 (beige)'), option_type=to_color)
+o('mark3_foreground', 'black', long_text=_('Color for marks of type 3'), option_type=to_color)
+o('mark3_background', '#f274bc', long_text=_('Color for marks of type 1 (violet)'), option_type=to_color)
 dfctl = defines.default_color_table()
 for i in range(16, 256):
     o('color{}'.format(i), color_as_sharp(color_from_int(dfctl[i])), option_type=to_color, add_to_docs=False)
@@ -812,9 +913,9 @@ ensure that the shell starts in interactive mode and reads its startup rc files.
 
 o('editor', '.', long_text=_('''
 The console editor to use when editing the kitty config file or similar tasks.
-A value of . means to use the environment variable EDITOR. Note that this
-environment variable has to be set not just in your shell startup scripts but
-system-wide, otherwise kitty will not see it.
+A value of . means to use the environment variables VISUAL and EDITOR in that
+order. Note that this environment variable has to be set not just in your shell
+startup scripts but system-wide, otherwise kitty will not see it.
 '''))
 
 o('close_on_child_death', False, long_text=_('''
@@ -826,11 +927,23 @@ Note that setting it to yes means that any background processes still using the
 terminal can fail silently because their stdout/stderr/stdin no longer work.
 '''))
 
-o('allow_remote_control', False, long_text=_('''
+
+def allow_remote_control(x):
+    if x != 'socket-only':
+        x = 'y' if to_bool(x) else 'n'
+    return x
+
+
+o('allow_remote_control', 'no', option_type=allow_remote_control, long_text=_('''
 Allow other programs to control kitty. If you turn this on other programs can
-control all aspects of kitty, including sending text to kitty windows,
-opening new windows, closing windows, reading the content of windows, etc.
-Note that this even works over ssh connections.
+control all aspects of kitty, including sending text to kitty windows, opening
+new windows, closing windows, reading the content of windows, etc.  Note that
+this even works over ssh connections. You can chose to either allow any program
+running within kitty to control it, with :code:`yes` or only programs that
+connect to the socket specified with the :option:`kitty --listen-on` command
+line option, if you use the value :code:`socket-only`. The latter is useful if
+you want to prevent programs running on a remote computer over ssh from
+controlling kitty.
 '''))
 
 o(
@@ -1061,13 +1174,13 @@ if is_macos:
 k('show_scrollback', 'kitty_mod+h', 'show_scrollback', _('Browse scrollback buffer in less'), long_text=_('''
 
 You can pipe the contents of the current screen + history buffer as
-:file:`STDIN` to an arbitrary program using the ``pipe`` function. For example,
+:file:`STDIN` to an arbitrary program using the ``launch`` function. For example,
 the following opens the scrollback buffer in less in an overlay window::
 
-    map f1 pipe @ansi overlay less +G -R
+    map f1 launch --stdin-source=@screen_scrollback --stdin-add-formatting --type=overlay less +G -R
 
 For more details on piping screen and buffer contents to external programs,
-see :doc:`pipe`.
+see :doc:`launch`.
 '''))
 
 
@@ -1077,30 +1190,33 @@ g('shortcuts.window')  # {{{
 k('new_window', 'kitty_mod+enter', 'new_window', _(''), long_text=_('''
 You can open a new window running an arbitrary program, for example::
 
-    map kitty_mod+y      new_window mutt
+    map kitty_mod+y      launch mutt
 
 You can open a new window with the current working directory set to the
 working directory of the current window using::
 
-    map ctrl+alt+enter    new_window_with_cwd
+    map ctrl+alt+enter    launch --cwd=current
 
 You can open a new window that is allowed to control kitty via
 the kitty remote control facility by prefixing the command line with @.
 Any programs running in that window will be allowed to control kitty.
 For example::
 
-    map ctrl+enter new_window @ some_program
+    map ctrl+enter launch --allow-remote-control some_program
 
 You can open a new window next to the currently active window or as the first window,
 with::
 
-    map ctrl+n new_window !neighbor some_program
-    map ctrl+f new_window !first some_program
+    map ctrl+n launch --location=neighbor some_program
+    map ctrl+f launch --location=first some_program
 
+For more details, see :doc:`launch`.
 '''))
 if is_macos:
     k('new_window', 'cmd+enter', 'new_window', _('New window'), add_to_docs=False)
-k('new_os_window', 'kitty_mod+n', 'new_os_window', _('New OS window'))
+k('new_os_window', 'kitty_mod+n', 'new_os_window', _('New OS window'), _(
+    'Works like new_window above, except that it opens a top level OS kitty window.'
+    ' In particular you can use new_os_window_with_cwd to open a window with the current working directory.'))
 if is_macos:
     k('new_os_window', 'cmd+n', 'new_os_window', _('New OS window'), add_to_docs=False)
 k('close_window', 'kitty_mod+w', 'close_window', _('Close window'))
@@ -1199,6 +1315,11 @@ k('insert_selected_hash', 'kitty_mod+p>h', 'kitten hints --type hash --program -
 Select something that looks like a hash and insert it into the terminal.
 Useful with git, which uses sha1 hashes to identify commits'''))
 
+k('goto_file_line', 'kitty_mod+p>n', 'kitten hints --type linenum', _('Open the selected file at the selected line'), long_text=_('''
+Select something that looks like :code:`filename:linenum` and open it in vim at
+the specified line number.'''))
+
+
 # }}}
 
 g('shortcuts.misc')  # {{{

kitty/constants.py

@@ -5,11 +5,12 @@
 import os
 import pwd
 import sys
+import errno
 from collections import namedtuple
 from contextlib import suppress
 
 appname = 'kitty'
-version = (0, 14, 5)
+version = (0, 16, 0)
 str_version = '.'.join(map(str, version))
 _plat = sys.platform.lower()
 is_macos = 'darwin' in _plat
@@ -25,7 +26,7 @@ def kitty_exe():
     if ans is None:
         rpath = sys._xoptions.get('bundle_exe_dir')
         if not rpath:
-            items = os.environ['PATH'].split(os.pathsep)
+            items = filter(None, os.environ.get('PATH', '').split(os.pathsep))
             seen = set()
             for candidate in items:
                 if candidate not in seen:
@@ -49,22 +50,15 @@ def _get_config_dir():
     locations.append(os.path.expanduser('~/.config'))
     if is_macos:
         locations.append(os.path.expanduser('~/Library/Preferences'))
-    if 'XDG_CONFIG_DIRS' in os.environ:
-        for loc in os.environ['XDG_CONFIG_DIRS'].split(os.pathsep):
-            locations.append(os.path.abspath(os.path.expanduser(loc)))
+    for loc in filter(None, os.environ.get('XDG_CONFIG_DIRS', '').split(os.pathsep)):
+        locations.append(os.path.abspath(os.path.expanduser(loc)))
     for loc in locations:
         if loc:
             q = os.path.join(loc, appname)
             if os.access(q, os.W_OK) and os.path.exists(os.path.join(q, 'kitty.conf')):
                 return q
 
-    candidate = os.path.abspath(os.path.expanduser(os.environ.get('XDG_CONFIG_HOME') or '~/.config'))
-    ans = os.path.join(candidate, appname)
-    try:
-        os.makedirs(ans, exist_ok=True)
-    except FileExistsError:
-        raise SystemExit('A file {} already exists. It must be a directory, not a file.'.format(ans))
-    except PermissionError:
+    def make_tmp_conf():
         import tempfile
         import atexit
         ans = tempfile.mkdtemp(prefix='kitty-conf-')
@@ -74,6 +68,19 @@ def _get_config_dir():
             with suppress(Exception):
                 shutil.rmtree(ans)
         atexit.register(cleanup)
+
+    candidate = os.path.abspath(os.path.expanduser(os.environ.get('XDG_CONFIG_HOME') or '~/.config'))
+    ans = os.path.join(candidate, appname)
+    try:
+        os.makedirs(ans, exist_ok=True)
+    except FileExistsError:
+        raise SystemExit('A file {} already exists. It must be a directory, not a file.'.format(ans))
+    except PermissionError:
+        make_tmp_conf()
+    except OSError as err:
+        if err.errno != errno.EROFS:  # Error other than read-only file system
+            raise
+        make_tmp_conf()
     return ans
 
 

kitty/core_text.m

@@ -278,7 +278,7 @@ get_glyph_width(PyObject *s, glyph_index g) {
     CGGlyph gg = g;
     CGRect bounds;
     CTFontGetBoundingRectsForGlyphs(self->ct_font, kCTFontOrientationHorizontal, &gg, &bounds, 1);
-    return bounds.size.width;
+    return (int)ceil(bounds.size.width);
 }
 
 static inline float
@@ -326,7 +326,7 @@ cell_metrics(PyObject *s, unsigned int* cell_width, unsigned int* cell_height, u
         }
     }
     *cell_width = MAX(1u, width);
-    *underline_position = floor(self->ascent - self->underline_position + 0.5);
+    *underline_position = (unsigned int)floor(self->ascent - self->underline_position + 0.5);
     *underline_thickness = (unsigned int)ceil(MAX(0.1, self->underline_thickness));
     *baseline = (unsigned int)self->ascent;
     // float line_height = MAX(1, floor(self->ascent + self->descent + MAX(0, self->leading) + 0.5));
@@ -457,11 +457,12 @@ render_simple_text_impl(PyObject *s, const char *text, unsigned int baseline) {
     CTFontGetGlyphsForCharacters(font, chars, glyphs, num_chars);
     CTFontGetAdvancesForGlyphs(font, kCTFontOrientationDefault, glyphs, advances, num_chars);
     CGRect bounding_box = CTFontGetBoundingRectsForGlyphs(font, kCTFontOrientationDefault, glyphs, boxes, num_chars);
-    StringCanvas ans = { .width = 0, .height = 2 * bounding_box.size.height };
-    for (size_t i = 0, y = 0; i < num_chars; i++) {
-        positions[i] = CGPointMake(ans.width, y);
-        ans.width += advances[i].width; y += advances[i].height;
+    CGFloat x = 0, y = 0;
+    for (size_t i = 0; i < num_chars; i++) {
+        positions[i] = CGPointMake(x, y);
+        x += advances[i].width; y += advances[i].height;
     }
+    StringCanvas ans = { .width = (size_t)ceil(x), .height = (size_t)(2 * bounding_box.size.height) };
     ensure_render_space(ans.width, ans.height);
     render_glyphs(font, ans.width, ans.height, baseline, num_chars);
     ans.canvas = malloc(ans.width * ans.height);

kitty/data-types.c

@@ -22,31 +22,10 @@
 #ifdef WITH_PROFILER
 #include <gperftools/profiler.h>
 #endif
-
-/* To millisecond (10^-3) */
-#define SEC_TO_MS 1000
-
-/* To microseconds (10^-6) */
-#define MS_TO_US 1000
-#define SEC_TO_US (SEC_TO_MS * MS_TO_US)
-
-/* To nanoseconds (10^-9) */
-#define US_TO_NS 1000
-#define MS_TO_NS (MS_TO_US * US_TO_NS)
-#define SEC_TO_NS (SEC_TO_MS * MS_TO_NS)
-
-/* Conversion from nanoseconds */
-#define NS_TO_MS (1000 * 1000)
-#define NS_TO_US (1000)
+#include "monotonic.h"
 
 #ifdef __APPLE__
 #include <libproc.h>
-#include <mach/mach_time.h>
-static mach_timebase_info_data_t timebase = {0};
-
-static inline double monotonic_(void) {
-    return ((double)(mach_absolute_time() * timebase.numer) / timebase.denom)/SEC_TO_NS;
-}
 
 static PyObject*
 user_cache_dir() {
@@ -73,33 +52,15 @@ process_group_map() {
     free(buf);
     return ans;
 }
-
-#else
-#include <time.h>
-static inline double monotonic_(void) {
-    struct timespec ts = {0};
-#ifdef CLOCK_HIGHRES
-    clock_gettime(CLOCK_HIGHRES, &ts);
-#elif CLOCK_MONOTONIC_RAW
-    clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
-#else
-    clock_gettime(CLOCK_MONOTONIC, &ts);
 #endif
-    return (((double)ts.tv_nsec) / SEC_TO_NS) + (double)ts.tv_sec;
-}
-#endif
-
-static double start_time = 0;
-
-double monotonic() { return monotonic_() - start_time; }
 
 static PyObject*
 redirect_std_streams(PyObject UNUSED *self, PyObject *args) {
     char *devnull = NULL;
     if (!PyArg_ParseTuple(args, "s", &devnull)) return NULL;
-    if (freopen(devnull, "r", stdin) == NULL) return PyErr_SetFromErrno(PyExc_EnvironmentError);
-    if (freopen(devnull, "w", stdout) == NULL) return PyErr_SetFromErrno(PyExc_EnvironmentError);
-    if (freopen(devnull, "w", stderr) == NULL)  return PyErr_SetFromErrno(PyExc_EnvironmentError);
+    if (freopen(devnull, "r", stdin) == NULL) return PyErr_SetFromErrno(PyExc_OSError);
+    if (freopen(devnull, "w", stdout) == NULL) return PyErr_SetFromErrno(PyExc_OSError);
+    if (freopen(devnull, "w", stderr) == NULL)  return PyErr_SetFromErrno(PyExc_OSError);
     Py_RETURN_NONE;
 }
 
@@ -148,7 +109,7 @@ open_tty(PyObject *self UNUSED, PyObject *args) {
     if (!read_with_timeout) flags |= O_NONBLOCK;
     static char ctty[L_ctermid+1];
     int fd = open(ctermid(ctty), flags);
-    if (fd == -1) { PyErr_SetFromErrno(PyExc_OSError); return NULL; }
+    if (fd == -1) { PyErr_Format(PyExc_OSError, "Failed to open controlling terminal: %s (identified with ctermid()) with error: %s", ctty, strerror(errno)); return NULL; }
     struct termios *termios_p = calloc(1, sizeof(struct termios));
     if (!termios_p) return PyErr_NoMemory();
     if (tcgetattr(fd, termios_p) != 0) { free(termios_p); PyErr_SetFromErrno(PyExc_OSError); return NULL; }
@@ -253,10 +214,7 @@ PyInit_fast_data_types(void) {
 
     m = PyModule_Create(&module);
     if (m == NULL) return NULL;
-#ifdef __APPLE__
-    mach_timebase_info(&timebase);
-#endif
-    start_time = monotonic_();
+    init_monotonic();
 
     if (m != NULL) {
         if (!init_logging(m)) return NULL;
@@ -293,6 +251,8 @@ PyInit_fast_data_types(void) {
         PyModule_AddIntConstant(m, "STRIKETHROUGH", STRIKE_SHIFT);
         PyModule_AddIntConstant(m, "DIM", DIM_SHIFT);
         PyModule_AddIntConstant(m, "DECORATION", DECORATION_SHIFT);
+        PyModule_AddIntConstant(m, "MARK", MARK_SHIFT);
+        PyModule_AddIntConstant(m, "MARK_MASK", MARK_MASK);
         PyModule_AddStringMacro(m, ERROR_PREFIX);
 #ifdef KITTY_VCS_REV
         PyModule_AddStringMacro(m, KITTY_VCS_REV);

kitty/data-types.h

@@ -13,6 +13,7 @@
 #include <stdbool.h>
 #include <poll.h>
 #include <pthread.h>
+#include "glfw-wrapper.h"
 // Required minimum OpenGL version
 #define OPENGL_REQUIRED_VERSION_MAJOR 3
 #define OPENGL_REQUIRED_VERSION_MINOR 3
@@ -57,7 +58,7 @@ typedef enum { NONE, MENUBAR, WINDOW, ALL } WindowTitleIn;
 
 #define MAX_CHILDREN 512
 #define BLANK_CHAR 0
-#define ATTRS_MASK_WITHOUT_WIDTH 0xFFC
+#define ATTRS_MASK_WITHOUT_WIDTH 0xFFFC
 #define WIDTH_MASK  3
 #define DECORATION_SHIFT  2
 #define DECORATION_MASK 3
@@ -67,6 +68,9 @@ typedef enum { NONE, MENUBAR, WINDOW, ALL } WindowTitleIn;
 #define REVERSE_SHIFT 6
 #define STRIKE_SHIFT 7
 #define DIM_SHIFT 8
+#define MARK_SHIFT 9
+#define ATTRS_MASK_WITHOUT_MARK 0xf9ff
+#define MARK_MASK 3
 #define COL_MASK 0xFFFFFFFF
 #define UTF8_ACCEPT 0
 #define UTF8_REJECT 1
@@ -140,6 +144,7 @@ typedef enum { NONE, MENUBAR, WINDOW, ALL } WindowTitleIn;
 #define END_ALLOW_UNUSED_RESULT _Pragma("GCC diagnostic pop")
 #endif
 
+
 typedef struct {
     uint32_t left, top, right, bottom;
 } Region;
@@ -230,6 +235,7 @@ typedef struct {
     DynamicColor dynamic_color_stack[10];
     size_t dynamic_color_stack_idx;
     DynamicColor configured, overridden;
+    color_type mark_foregrounds[MARK_MASK+1], mark_backgrounds[MARK_MASK+1];
 } ColorProfile;
 
 typedef struct {
@@ -291,7 +297,6 @@ void apply_sgr_to_cells(GPUCell *first_cell, unsigned int cell_count, unsigned i
 const char* cell_as_sgr(const GPUCell *, const GPUCell *);
 const char* cursor_as_sgr(const Cursor *);
 
-double monotonic(void);
 PyObject* cm_thread_write(PyObject *self, PyObject *args);
 bool schedule_write_to_child(unsigned long id, unsigned int num, ...);
 bool set_iutf8(int, bool);
@@ -309,7 +314,7 @@ void focus_in_event(void);
 void scroll_event(double, double, int);
 void fake_scroll(int, bool);
 void set_special_key_combo(int glfw_key, int mods, bool is_native);
-void on_key_input(int key, int scancode, int action, int mods, const char*, int);
+void on_key_input(GLFWkeyevent *ev);
 void request_window_attention(id_type, bool);
 #ifndef __APPLE__
 void play_canberra_sound(const char *which_sound, const char *event_id);

kitty/desktop.c

@@ -7,7 +7,6 @@
 
 #include "data-types.h"
 #include <dlfcn.h>
-#include <canberra.h>
 
 #define FUNC(name, restype, ...) typedef restype (*name##_func)(__VA_ARGS__); static name##_func name = NULL
 #define LOAD_FUNC(handle, name) {\
@@ -90,15 +89,56 @@ static PyMethodDef module_methods[] = {
     {NULL, NULL, 0, NULL}        /* Sentinel */
 };
 
-static ca_context *canberra_ctx = NULL;
+static void* libcanberra_handle = NULL;
+static void *canberra_ctx = NULL;
+FUNC(ca_context_create, int, void**);
+FUNC(ca_context_destroy, int, void*);
+typedef int (*ca_context_play_func)(void*, uint32_t, ...); static ca_context_play_func ca_context_play = NULL;
+
+static PyObject*
+load_libcanberra_functions(void) {
+    LOAD_FUNC(libcanberra_handle, ca_context_create);
+    LOAD_FUNC(libcanberra_handle, ca_context_play);
+    LOAD_FUNC(libcanberra_handle, ca_context_destroy);
+    return NULL;
+}
+
+static void
+load_libcanberra(void) {
+    static const char* libname = "libcanberra.so";
+    // some installs are missing the .so symlink, so try the full name
+    static const char* libname2 = "libcanberra.so.0";
+    static const char* libname3 = "libcanberra.so.0.2.5";
+    static bool done = false;
+    if (done) return;
+    done = true;
+    libcanberra_handle = dlopen(libname, RTLD_LAZY);
+    if (libcanberra_handle == NULL) libcanberra_handle = dlopen(libname2, RTLD_LAZY);
+    if (libcanberra_handle == NULL) libcanberra_handle = dlopen(libname3, RTLD_LAZY);
+    if (libcanberra_handle == NULL) {
+        fprintf(stderr, "Failed to load %s, cannot play beep sound, with error: %s\n", libname, dlerror());
+        return;
+    }
+    load_libcanberra_functions();
+    if (PyErr_Occurred()) {
+        PyErr_Print();
+        dlclose(libcanberra_handle); libcanberra_handle = NULL;
+    }
+    if (ca_context_create(&canberra_ctx) != 0) {
+        fprintf(stderr, "Failed to create libcanberra context, cannot play beep sound\n");
+        ca_context_destroy(canberra_ctx); canberra_ctx = NULL;
+        dlclose(libcanberra_handle); libcanberra_handle = NULL;
+    }
+}
 
 void
 play_canberra_sound(const char *which_sound, const char *event_id) {
-    if (canberra_ctx == NULL) ca_context_create(&canberra_ctx);
+    load_libcanberra();
+    if (libcanberra_handle == NULL || canberra_ctx == NULL) return;
     ca_context_play(
         canberra_ctx, 0,
-        CA_PROP_EVENT_ID, which_sound,
-        CA_PROP_EVENT_DESCRIPTION, event_id,
+        "event.id", which_sound,
+        "event.description", event_id,
         NULL
     );
 }
@@ -109,6 +149,7 @@ finalize(void) {
     libsn_handle = NULL;
     if (canberra_ctx) ca_context_destroy(canberra_ctx);
     canberra_ctx = NULL;
+    if (libcanberra_handle) dlclose(libcanberra_handle);
 }
 
 bool

kitty/emoji.h

@@ -1,4 +1,4 @@
-// unicode data, built from the unicode standard on: 2019-08-02
+// unicode data, built from the unicode standard on: 2019-10-01
 // see gen-wcwidth.py
 #pragma once
 #include "data-types.h"
@@ -187,5 +187,464 @@ is_emoji_modifier(char_type code) {
 	}
 	return false;
 }
+static inline bool
+is_symbol(char_type code) {
+	switch(code) {
+		case 0x24:
+			return true;
+		case 0x2b:
+			return true;
+		case 0x3c ... 0x3e:
+			return true;
+		case 0x5e:
+			return true;
+		case 0x60:
+			return true;
+		case 0x7c:
+			return true;
+		case 0x7e:
+			return true;
+		case 0xa2 ... 0xa6:
+			return true;
+		case 0xa8 ... 0xa9:
+			return true;
+		case 0xac:
+			return true;
+		case 0xae ... 0xb1:
+			return true;
+		case 0xb4:
+			return true;
+		case 0xb8:
+			return true;
+		case 0xd7:
+			return true;
+		case 0xf7:
+			return true;
+		case 0x2c2 ... 0x2c5:
+			return true;
+		case 0x2d2 ... 0x2df:
+			return true;
+		case 0x2e5 ... 0x2eb:
+			return true;
+		case 0x2ed:
+			return true;
+		case 0x2ef ... 0x2ff:
+			return true;
+		case 0x375:
+			return true;
+		case 0x384 ... 0x385:
+			return true;
+		case 0x3f6:
+			return true;
+		case 0x482:
+			return true;
+		case 0x58d ... 0x58f:
+			return true;
+		case 0x606 ... 0x608:
+			return true;
+		case 0x60b:
+			return true;
+		case 0x60e ... 0x60f:
+			return true;
+		case 0x6de:
+			return true;
+		case 0x6e9:
+			return true;
+		case 0x6fd ... 0x6fe:
+			return true;
+		case 0x7f6:
+			return true;
+		case 0x7fe ... 0x7ff:
+			return true;
+		case 0x9f2 ... 0x9f3:
+			return true;
+		case 0x9fa ... 0x9fb:
+			return true;
+		case 0xaf1:
+			return true;
+		case 0xb70:
+			return true;
+		case 0xbf3 ... 0xbfa:
+			return true;
+		case 0xc7f:
+			return true;
+		case 0xd4f:
+			return true;
+		case 0xd79:
+			return true;
+		case 0xe3f:
+			return true;
+		case 0xf01 ... 0xf03:
+			return true;
+		case 0xf13:
+			return true;
+		case 0xf15 ... 0xf17:
+			return true;
+		case 0xf1a ... 0xf1f:
+			return true;
+		case 0xf34:
+			return true;
+		case 0xf36:
+			return true;
+		case 0xf38:
+			return true;
+		case 0xfbe ... 0xfc5:
+			return true;
+		case 0xfc7 ... 0xfcc:
+			return true;
+		case 0xfce ... 0xfcf:
+			return true;
+		case 0xfd5 ... 0xfd8:
+			return true;
+		case 0x109e ... 0x109f:
+			return true;
+		case 0x1390 ... 0x1399:
+			return true;
+		case 0x166d:
+			return true;
+		case 0x17db:
+			return true;
+		case 0x1940:
+			return true;
+		case 0x19de ... 0x19ff:
+			return true;
+		case 0x1b61 ... 0x1b6a:
+			return true;
+		case 0x1b74 ... 0x1b7c:
+			return true;
+		case 0x1fbd:
+			return true;
+		case 0x1fbf ... 0x1fc1:
+			return true;
+		case 0x1fcd ... 0x1fcf:
+			return true;
+		case 0x1fdd ... 0x1fdf:
+			return true;
+		case 0x1fed ... 0x1fef:
+			return true;
+		case 0x1ffd ... 0x1ffe:
+			return true;
+		case 0x2044:
+			return true;
+		case 0x2052:
+			return true;
+		case 0x207a ... 0x207c:
+			return true;
+		case 0x208a ... 0x208c:
+			return true;
+		case 0x20a0 ... 0x20bf:
+			return true;
+		case 0x2100 ... 0x2101:
+			return true;
+		case 0x2103 ... 0x2106:
+			return true;
+		case 0x2108 ... 0x2109:
+			return true;
+		case 0x2114:
+			return true;
+		case 0x2116 ... 0x2118:
+			return true;
+		case 0x211e ... 0x2123:
+			return true;
+		case 0x2125:
+			return true;
+		case 0x2127:
+			return true;
+		case 0x2129:
+			return true;
+		case 0x212e:
+			return true;
+		case 0x213a ... 0x213b:
+			return true;
+		case 0x2140 ... 0x2144:
+			return true;
+		case 0x214a ... 0x214d:
+			return true;
+		case 0x214f:
+			return true;
+		case 0x218a ... 0x218b:
+			return true;
+		case 0x2190 ... 0x2307:
+			return true;
+		case 0x230c ... 0x2328:
+			return true;
+		case 0x232b ... 0x2426:
+			return true;
+		case 0x2440 ... 0x244a:
+			return true;
+		case 0x249c ... 0x24e9:
+			return true;
+		case 0x2500 ... 0x2767:
+			return true;
+		case 0x2794 ... 0x27c4:
+			return true;
+		case 0x27c7 ... 0x27e5:
+			return true;
+		case 0x27f0 ... 0x2982:
+			return true;
+		case 0x2999 ... 0x29d7:
+			return true;
+		case 0x29dc ... 0x29fb:
+			return true;
+		case 0x29fe ... 0x2b73:
+			return true;
+		case 0x2b76 ... 0x2b95:
+			return true;
+		case 0x2b98 ... 0x2bff:
+			return true;
+		case 0x2ce5 ... 0x2cea:
+			return true;
+		case 0x2e80 ... 0x2e99:
+			return true;
+		case 0x2e9b ... 0x2ef3:
+			return true;
+		case 0x2f00 ... 0x2fd5:
+			return true;
+		case 0x2ff0 ... 0x2ffb:
+			return true;
+		case 0x3004:
+			return true;
+		case 0x3012 ... 0x3013:
+			return true;
+		case 0x3020:
+			return true;
+		case 0x3036 ... 0x3037:
+			return true;
+		case 0x303e ... 0x303f:
+			return true;
+		case 0x309b ... 0x309c:
+			return true;
+		case 0x3190 ... 0x3191:
+			return true;
+		case 0x3196 ... 0x319f:
+			return true;
+		case 0x31c0 ... 0x31e3:
+			return true;
+		case 0x3200 ... 0x321e:
+			return true;
+		case 0x322a ... 0x3247:
+			return true;
+		case 0x3250:
+			return true;
+		case 0x3260 ... 0x327f:
+			return true;
+		case 0x328a ... 0x32b0:
+			return true;
+		case 0x32c0 ... 0x33ff:
+			return true;
+		case 0x4dc0 ... 0x4dff:
+			return true;
+		case 0xa490 ... 0xa4c6:
+			return true;
+		case 0xa700 ... 0xa716:
+			return true;
+		case 0xa720 ... 0xa721:
+			return true;
+		case 0xa789 ... 0xa78a:
+			return true;
+		case 0xa828 ... 0xa82b:
+			return true;
+		case 0xa836 ... 0xa839:
+			return true;
+		case 0xaa77 ... 0xaa79:
+			return true;
+		case 0xab5b:
+			return true;
+		case 0xfb29:
+			return true;
+		case 0xfbb2 ... 0xfbc1:
+			return true;
+		case 0xfdfc ... 0xfdfd:
+			return true;
+		case 0xfe62:
+			return true;
+		case 0xfe64 ... 0xfe66:
+			return true;
+		case 0xfe69:
+			return true;
+		case 0xff04:
+			return true;
+		case 0xff0b:
+			return true;
+		case 0xff1c ... 0xff1e:
+			return true;
+		case 0xff3e:
+			return true;
+		case 0xff40:
+			return true;
+		case 0xff5c:
+			return true;
+		case 0xff5e:
+			return true;
+		case 0xffe0 ... 0xffe6:
+			return true;
+		case 0xffe8 ... 0xffee:
+			return true;
+		case 0xfffc ... 0xfffd:
+			return true;
+		case 0x10137 ... 0x1013f:
+			return true;
+		case 0x10179 ... 0x10189:
+			return true;
+		case 0x1018c ... 0x1018e:
+			return true;
+		case 0x10190 ... 0x1019b:
+			return true;
+		case 0x101a0:
+			return true;
+		case 0x101d0 ... 0x101fc:
+			return true;
+		case 0x10877 ... 0x10878:
+			return true;
+		case 0x10ac8:
+			return true;
+		case 0x1173f:
+			return true;
+		case 0x11fd5 ... 0x11ff1:
+			return true;
+		case 0x16b3c ... 0x16b3f:
+			return true;
+		case 0x16b45:
+			return true;
+		case 0x1bc9c:
+			return true;
+		case 0x1d000 ... 0x1d0f5:
+			return true;
+		case 0x1d100 ... 0x1d126:
+			return true;
+		case 0x1d129 ... 0x1d164:
+			return true;
+		case 0x1d16a ... 0x1d16c:
+			return true;
+		case 0x1d183 ... 0x1d184:
+			return true;
+		case 0x1d18c ... 0x1d1a9:
+			return true;
+		case 0x1d1ae ... 0x1d1e8:
+			return true;
+		case 0x1d200 ... 0x1d241:
+			return true;
+		case 0x1d245:
+			return true;
+		case 0x1d300 ... 0x1d356:
+			return true;
+		case 0x1d6c1:
+			return true;
+		case 0x1d6db:
+			return true;
+		case 0x1d6fb:
+			return true;
+		case 0x1d715:
+			return true;
+		case 0x1d735:
+			return true;
+		case 0x1d74f:
+			return true;
+		case 0x1d76f:
+			return true;
+		case 0x1d789:
+			return true;
+		case 0x1d7a9:
+			return true;
+		case 0x1d7c3:
+			return true;
+		case 0x1d800 ... 0x1d9ff:
+			return true;
+		case 0x1da37 ... 0x1da3a:
+			return true;
+		case 0x1da6d ... 0x1da74:
+			return true;
+		case 0x1da76 ... 0x1da83:
+			return true;
+		case 0x1da85 ... 0x1da86:
+			return true;
+		case 0x1e14f:
+			return true;
+		case 0x1e2ff:
+			return true;
+		case 0x1ecac:
+			return true;
+		case 0x1ecb0:
+			return true;
+		case 0x1ed2e:
+			return true;
+		case 0x1eef0 ... 0x1eef1:
+			return true;
+		case 0x1f000 ... 0x1f02b:
+			return true;
+		case 0x1f030 ... 0x1f093:
+			return true;
+		case 0x1f0a0 ... 0x1f0ae:
+			return true;
+		case 0x1f0b1 ... 0x1f0bf:
+			return true;
+		case 0x1f0c1 ... 0x1f0cf:
+			return true;
+		case 0x1f0d1 ... 0x1f0f5:
+			return true;
+		case 0x1f110 ... 0x1f16c:
+			return true;
+		case 0x1f170 ... 0x1f1ac:
+			return true;
+		case 0x1f1e6 ... 0x1f202:
+			return true;
+		case 0x1f210 ... 0x1f23b:
+			return true;
+		case 0x1f240 ... 0x1f248:
+			return true;
+		case 0x1f250 ... 0x1f251:
+			return true;
+		case 0x1f260 ... 0x1f265:
+			return true;
+		case 0x1f300 ... 0x1f6d5:
+			return true;
+		case 0x1f6e0 ... 0x1f6ec:
+			return true;
+		case 0x1f6f0 ... 0x1f6fa:
+			return true;
+		case 0x1f700 ... 0x1f773:
+			return true;
+		case 0x1f780 ... 0x1f7d8:
+			return true;
+		case 0x1f7e0 ... 0x1f7eb:
+			return true;
+		case 0x1f800 ... 0x1f80b:
+			return true;
+		case 0x1f810 ... 0x1f847:
+			return true;
+		case 0x1f850 ... 0x1f859:
+			return true;
+		case 0x1f860 ... 0x1f887:
+			return true;
+		case 0x1f890 ... 0x1f8ad:
+			return true;
+		case 0x1f900 ... 0x1f90b:
+			return true;
+		case 0x1f90d ... 0x1f971:
+			return true;
+		case 0x1f973 ... 0x1f976:
+			return true;
+		case 0x1f97a ... 0x1f9a2:
+			return true;
+		case 0x1f9a5 ... 0x1f9aa:
+			return true;
+		case 0x1f9ae ... 0x1f9ca:
+			return true;
+		case 0x1f9cd ... 0x1fa53:
+			return true;
+		case 0x1fa60 ... 0x1fa6d:
+			return true;
+		case 0x1fa70 ... 0x1fa73:
+			return true;
+		case 0x1fa78 ... 0x1fa7a:
+			return true;
+		case 0x1fa80 ... 0x1fa82:
+			return true;
+		case 0x1fa90 ... 0x1fa95:
+			return true;
+		default: return false;
+	}
+	return false;
+}
 
 END_ALLOW_CASE_RANGE

kitty/fonts.c

@@ -62,6 +62,7 @@ static hb_feature_t hb_features[3] = {{0}};
 static char_type shape_buffer[4096] = {0};
 static size_t max_texture_size = 1024, max_array_len = 1024;
 typedef enum { LIGA_FEATURE, DLIG_FEATURE, CALT_FEATURE } HBFeature;
+static PyObject* font_feature_settings = NULL;
 
 typedef struct {
     char_type left, right;
@@ -71,14 +72,12 @@ typedef struct {
 static SymbolMap *symbol_maps = NULL;
 static size_t num_symbol_maps = 0;
 
-
-
 typedef struct {
     PyObject *face;
     // Map glyphs to sprite map co-ords
     SpritePosition sprite_map[1024];
-    hb_feature_t hb_features[8];
-    size_t num_hb_features;
+    hb_feature_t* ffs_hb_features;
+    size_t num_ffs_hb_features;
     SpecialGlyphCache special_glyph_cache[SPECIAL_GLYPH_CACHE_SIZE];
     bool bold, italic, emoji_presentation;
 } Font;
@@ -348,27 +347,47 @@ desc_to_face(PyObject *desc, FONTS_DATA_HANDLE fg) {
     return ans;
 }
 
-static inline void
-copy_hb_feature(Font *f, HBFeature which) {
-    memcpy(f->hb_features + f->num_hb_features++, hb_features + which, sizeof(hb_features[0]));
-}
-
 static inline bool
 init_font(Font *f, PyObject *face, bool bold, bool italic, bool emoji_presentation) {
     f->face = face; Py_INCREF(f->face);
     f->bold = bold; f->italic = italic; f->emoji_presentation = emoji_presentation;
-    f->num_hb_features = 0;
+    f->num_ffs_hb_features = 0;
     const char *psname = postscript_name_for_face(face);
-    if (strstr(psname, "NimbusMonoPS-") == psname) {
-        copy_hb_feature(f, LIGA_FEATURE); copy_hb_feature(f, DLIG_FEATURE);
+    if (font_feature_settings != NULL){
+        PyObject* o = PyDict_GetItemString(font_feature_settings, psname);
+        if (o != NULL && PyTuple_Check(o)) {
+            Py_ssize_t len = PyTuple_GET_SIZE(o);
+            if (len > 0) {
+                f->num_ffs_hb_features = len + 1;
+                f->ffs_hb_features = calloc(f->num_ffs_hb_features, sizeof(hb_feature_t));
+                if (!f->ffs_hb_features) return false;
+                for (Py_ssize_t i = 0; i < len; i++) {
+                    PyObject* parsed = PyObject_GetAttrString(PyTuple_GET_ITEM(o, i), "parsed");
+                    if (parsed) {
+                        memcpy(f->ffs_hb_features + i, PyBytes_AS_STRING(parsed), sizeof(hb_feature_t));
+                        Py_DECREF(parsed);
+                    }
+                }
+                memcpy(f->ffs_hb_features + len, &hb_features[CALT_FEATURE], sizeof(hb_feature_t));
+            }
+        }
+    }
+    if (!f->num_ffs_hb_features) {
+        f->ffs_hb_features = calloc(4, sizeof(hb_feature_t));
+        if (!f->ffs_hb_features) return false;
+        if (strstr(psname, "NimbusMonoPS-") == psname) {
+            memcpy(f->ffs_hb_features + f->num_ffs_hb_features++, &hb_features[LIGA_FEATURE], sizeof(hb_feature_t));
+            memcpy(f->ffs_hb_features + f->num_ffs_hb_features++, &hb_features[DLIG_FEATURE], sizeof(hb_feature_t));
+        }
+        memcpy(f->ffs_hb_features + f->num_ffs_hb_features++, &hb_features[CALT_FEATURE], sizeof(hb_feature_t));
     }
-    copy_hb_feature(f, CALT_FEATURE);
     return true;
 }
 
 static inline void
 del_font(Font *f) {
     Py_CLEAR(f->face);
+    free(f->ffs_hb_features); f->ffs_hb_features = NULL;
     free_maps(f);
     f->bold = false; f->italic = false;
 }
@@ -409,9 +428,9 @@ calc_cell_metrics(FontGroup *fg) {
     unsigned int before_cell_height = cell_height;
     int cw = cell_width, ch = cell_height;
     if (OPT(adjust_line_height_px) != 0) ch += OPT(adjust_line_height_px);
-    if (OPT(adjust_line_height_frac) != 0.f) ch *= OPT(adjust_line_height_frac);
+    if (OPT(adjust_line_height_frac) != 0.f) ch = (int)(ch * OPT(adjust_line_height_frac));
     if (OPT(adjust_column_width_px != 0)) cw += OPT(adjust_column_width_px);
-    if (OPT(adjust_column_width_frac) != 0.f) cw *= OPT(adjust_column_width_frac);
+    if (OPT(adjust_column_width_frac) != 0.f) cw = (int)(cw * OPT(adjust_column_width_frac));
 #define MAX_DIM 1000
 #define MIN_WIDTH 2
 #define MIN_HEIGHT 4
@@ -543,8 +562,18 @@ in_symbol_maps(FontGroup *fg, char_type ch) {
 }
 
 
-static ssize_t
-font_for_cell(FontGroup *fg, CPUCell *cpu_cell, GPUCell *gpu_cell) {
+// Decides which 'font' to use for a given cell.
+//
+// Possible results:
+// - NO_FONT
+// - MISSING_FONT
+// - BLANK_FONT
+// - BOX_FONT
+// - an index in the fonts list
+static inline ssize_t
+font_for_cell(FontGroup *fg, CPUCell *cpu_cell, GPUCell *gpu_cell, bool *is_fallback_font, bool *is_emoji_presentation) {
+    *is_fallback_font = false;
+    *is_emoji_presentation = false;
 START_ALLOW_CASE_RANGE
     ssize_t ans;
     switch(cpu_cell->ch) {
@@ -552,12 +581,14 @@ START_ALLOW_CASE_RANGE
         case ' ':
         case '\t':
             return BLANK_FONT;
-        case 0x2500 ... 0x2570:
+        case 0x2500 ... 0x2573:
         case 0x2574 ... 0x259f:
-        case 0xe0b0:
-        case 0xe0b2:
-        case 0xe0b4:
+        case 0xe0b0 ... 0xe0b4:
         case 0xe0b6:
+        case 0xe0b8: // 
+        case 0xe0ba: //   
+        case 0xe0bc: // 
+        case 0xe0be: //   
             return BOX_FONT;
         default:
             ans = in_symbol_maps(fg, cpu_cell->ch);
@@ -573,7 +604,9 @@ START_ALLOW_CASE_RANGE
                     ans = fg->bi_font_idx; break;
             }
             if (ans < 0) ans = fg->medium_font_idx;
-            if (!has_emoji_presentation(cpu_cell, gpu_cell) && has_cell_text(fg->fonts + ans, cpu_cell)) return ans;
+            *is_emoji_presentation = has_emoji_presentation(cpu_cell, gpu_cell);
+            if (!*is_emoji_presentation && has_cell_text(fg->fonts + ans, cpu_cell)) return ans;
+            *is_fallback_font = true;
             return fallback_font(fg, cpu_cell, gpu_cell);
     }
 END_ALLOW_CASE_RANGE
@@ -584,20 +617,15 @@ set_sprite(GPUCell *cell, sprite_index x, sprite_index y, sprite_index z) {
     cell->sprite_x = x; cell->sprite_y = y; cell->sprite_z = z;
 }
 
+// Gives a unique (arbitrary) id to a box glyph
 static inline glyph_index
 box_glyph_id(char_type ch) {
 START_ALLOW_CASE_RANGE
     switch(ch) {
         case 0x2500 ... 0x259f:
-            return ch - 0x2500;
-        case 0xe0b0:
-            return 0xfa;
-        case 0xe0b2:
-            return 0xfb;
-        case 0xe0b4:
-            return 0xfc;
-        case 0xe0b6:
-            return 0xfd;
+            return ch - 0x2500; // IDs from 0x00 to 0x9f
+        case 0xe0b0 ... 0xe0d4:
+            return 0xa0 + ch - 0xe0b0; // IDs from 0xa0 to 0xc4
         default:
             return 0xff;
     }
@@ -661,6 +689,7 @@ load_hb_buffer(CPUCell *first_cpu_cell, GPUCell *first_gpu_cell, index_type num_
         hb_buffer_add_utf32(harfbuzz_buffer, shape_buffer, num, 0, num);
     }
     hb_buffer_guess_segment_properties(harfbuzz_buffer);
+    if (OPT(force_ltr)) hb_buffer_set_direction(harfbuzz_buffer, HB_DIRECTION_LTR);
 }
 
 
@@ -682,7 +711,7 @@ static inline void
 render_group(FontGroup *fg, unsigned int num_cells, unsigned int num_glyphs, CPUCell *cpu_cells, GPUCell *gpu_cells, hb_glyph_info_t *info, hb_glyph_position_t *positions, Font *font, glyph_index glyph, ExtraGlyphs *extra_glyphs, bool center_glyph) {
     static SpritePosition* sprite_position[16];
     int error = 0;
-    num_cells = MIN(sizeof(sprite_position)/sizeof(sprite_position[0]), num_cells);
+    num_cells = MIN(arraysz(sprite_position), num_cells);
     for (unsigned int i = 0; i < num_cells; i++) {
         sprite_position[i] = sprite_position_for(fg, font, glyph, extra_glyphs, (uint8_t)i, &error);
         if (error != 0) { sprite_map_set_error(error); PyErr_Print(); return; }
@@ -717,7 +746,7 @@ typedef struct {
 
 typedef struct {
     unsigned int first_glyph_idx, first_cell_idx, num_glyphs, num_cells;
-    bool has_special_glyph;
+    bool has_special_glyph, is_space_ligature;
 } Group;
 
 typedef struct {
@@ -767,7 +796,9 @@ shape(CPUCell *first_cpu_cell, GPUCell *first_gpu_cell, index_type num_cells, hb
     group_state.last_gpu_cell = first_gpu_cell + (num_cells ? num_cells - 1 : 0);
     load_hb_buffer(first_cpu_cell, first_gpu_cell, num_cells);
 
-    hb_shape(font, harfbuzz_buffer, fobj->hb_features, fobj->num_hb_features - (disable_ligature ? 0 : 1));
+    size_t num_features = fobj->num_ffs_hb_features;
+    if (num_features && !disable_ligature) num_features--;  // the last feature is always -calt
+    hb_shape(font, harfbuzz_buffer, fobj->ffs_hb_features, num_features);
 
     unsigned int info_length, positions_length;
     group_state.info = hb_buffer_get_glyph_infos(harfbuzz_buffer, &info_length);
@@ -955,13 +986,11 @@ merge_groups_for_pua_space_ligature(void) {
     while (G(group_idx) > 0) {
         Group *g = G(groups), *g1 = G(groups) + 1;
         g->num_cells += g1->num_cells;
-        // We dont want the space glyphs rendered because some stupid
-        // fonts like PowerLine dont have a space glyph
-        // https://github.com/kovidgoyal/kitty/issues/1225
-        /* g->num_glyphs += g1->num_glyphs; */
-        /* g->num_glyphs = MIN(g->num_glyphs, MAX_NUM_EXTRA_GLYPHS + 1); */
+        g->num_glyphs += g1->num_glyphs;
+        g->num_glyphs = MIN(g->num_glyphs, MAX_NUM_EXTRA_GLYPHS + 1);
         G(group_idx)--;
     }
+    G(groups)->is_space_ligature = true;
 }
 
 static inline void
@@ -995,7 +1024,11 @@ render_groups(FontGroup *fg, Font *font, bool center_glyph) {
         int last = -1;
         for (i = 1; i < MIN(arraysz(ed.data) + 1, group->num_glyphs); i++) { last = i - 1; ed.data[last] = G(info)[group->first_glyph_idx + i].codepoint; }
         if ((size_t)(last + 1) < arraysz(ed.data)) ed.data[last + 1] = 0;
-        render_group(fg, group->num_cells, group->num_glyphs, G(first_cpu_cell) + group->first_cell_idx, G(first_gpu_cell) + group->first_cell_idx, G(info) + group->first_glyph_idx, G(positions) + group->first_glyph_idx, font, primary, &ed, center_glyph);
+        // We dont want to render the spaces in a space ligature because
+        // there exist stupid fonts like Powerline that have no space glyph,
+        // so special case it: https://github.com/kovidgoyal/kitty/issues/1225
+        unsigned int num_glyphs = group->is_space_ligature ? 1 : group->num_glyphs;
+        render_group(fg, group->num_cells, num_glyphs, G(first_cpu_cell) + group->first_cell_idx, G(first_gpu_cell) + group->first_cell_idx, G(info) + group->first_glyph_idx, G(positions) + group->first_glyph_idx, font, primary, &ed, center_glyph);
         idx++;
     }
 }
@@ -1016,8 +1049,6 @@ test_shape(PyObject UNUSED *self, PyObject *args) {
         if (face == NULL) return NULL;
         font = calloc(1, sizeof(Font));
         font->face = face;
-        font->hb_features[0] = hb_features[CALT_FEATURE];
-        font->num_hb_features = 1;
     } else {
         FontGroup *fg = font_groups;
         font = fg->fonts + fg->medium_font_idx;
@@ -1048,7 +1079,7 @@ render_run(FontGroup *fg, CPUCell *first_cpu_cell, GPUCell *first_gpu_cell, inde
         default:
             shape_run(first_cpu_cell, first_gpu_cell, num_cells, &fg->fonts[font_idx], disable_ligature_strategy == DISABLE_LIGATURES_ALWAYS);
             if (pua_space_ligature) merge_groups_for_pua_space_ligature();
-            else if (cursor_offset > -1) {
+            else if (cursor_offset > -1) { // false if DISABLE_LIGATURES_NEVER
                 index_type left, right;
                 split_run_at_offset(cursor_offset, &left, &right);
                 if (right > left) {
@@ -1096,18 +1127,20 @@ render_line(FONTS_DATA_HANDLE fg_, Line *line, index_type lnum, Cursor *cursor,
         if (prev_width == 2) { prev_width = 0; continue; }
         CPUCell *cpu_cell = line->cpu_cells + i;
         GPUCell *gpu_cell = line->gpu_cells + i;
-        ssize_t cell_font_idx = font_for_cell(fg, cpu_cell, gpu_cell);
+        bool is_fallback_font, is_emoji_presentation;
+        ssize_t cell_font_idx = font_for_cell(fg, cpu_cell, gpu_cell, &is_fallback_font, &is_emoji_presentation);
 
-        if (is_private_use(cpu_cell->ch)
-                && cell_font_idx != BOX_FONT
-                && cell_font_idx != MISSING_FONT) {
+        if (
+                cell_font_idx != MISSING_FONT &&
+                ((is_fallback_font && !is_emoji_presentation && is_symbol(cpu_cell->ch)) || (cell_font_idx != BOX_FONT && is_private_use(cpu_cell->ch)))
+        ) {
             unsigned int desired_cells = 1;
             if (cell_font_idx > 0) {
                 Font *font = (fg->fonts + cell_font_idx);
                 glyph_index glyph_id = glyph_id_for_codepoint(font->face, cpu_cell->ch);
 
                 int width = get_glyph_width(font->face, glyph_id);
-                desired_cells = ceilf((float)width / fg->cell_width);
+                desired_cells = (unsigned int)ceilf((float)width / fg->cell_width);
             }
 
             unsigned int num_spaces = 0;
@@ -1170,12 +1203,12 @@ DescriptorIndices descriptor_indices = {0};
 static PyObject*
 set_font_data(PyObject UNUSED *m, PyObject *args) {
     PyObject *sm;
-    Py_CLEAR(box_drawing_function); Py_CLEAR(prerender_function); Py_CLEAR(descriptor_for_idx);
-    if (!PyArg_ParseTuple(args, "OOOIIIIO!d",
+    Py_CLEAR(box_drawing_function); Py_CLEAR(prerender_function); Py_CLEAR(descriptor_for_idx); Py_CLEAR(font_feature_settings);
+    if (!PyArg_ParseTuple(args, "OOOIIIIO!dO",
                 &box_drawing_function, &prerender_function, &descriptor_for_idx,
                 &descriptor_indices.bold, &descriptor_indices.italic, &descriptor_indices.bi, &descriptor_indices.num_symbol_fonts,
-                &PyTuple_Type, &sm, &global_state.font_sz_in_pts)) return NULL;
-    Py_INCREF(box_drawing_function); Py_INCREF(prerender_function); Py_INCREF(descriptor_for_idx);
+                &PyTuple_Type, &sm, &global_state.font_sz_in_pts, &font_feature_settings)) return NULL;
+    Py_INCREF(box_drawing_function); Py_INCREF(prerender_function); Py_INCREF(descriptor_for_idx); Py_INCREF(font_feature_settings);
     free_font_groups();
     clear_symbol_maps();
     num_symbol_maps = PyTuple_GET_SIZE(sm);
@@ -1277,6 +1310,7 @@ finalize(void) {
     Py_CLEAR(box_drawing_function);
     Py_CLEAR(prerender_function);
     Py_CLEAR(descriptor_for_idx);
+    Py_CLEAR(font_feature_settings);
     free_font_groups();
     if (harfbuzz_buffer) { hb_buffer_destroy(harfbuzz_buffer); harfbuzz_buffer = NULL; }
     free(group_state.groups); group_state.groups = NULL; group_state.groups_capacity = 0;
@@ -1422,9 +1456,26 @@ free_font_data(PyObject *self UNUSED, PyObject *args UNUSED) {
     Py_RETURN_NONE;
 }
 
+static PyObject*
+parse_font_feature(PyObject *self UNUSED, PyObject *feature) {
+    if (!PyUnicode_Check(feature)) {
+        PyErr_SetString(PyExc_TypeError, "feature must be a unicode object");
+        return NULL;
+    }
+    PyObject *ans = PyBytes_FromStringAndSize(NULL, sizeof(hb_feature_t));
+    if (!ans) return NULL;
+    if (!hb_feature_from_string(PyUnicode_AsUTF8(feature), -1, (hb_feature_t*)PyBytes_AS_STRING(ans))) {
+        Py_CLEAR(ans);
+        PyErr_Format(PyExc_ValueError, "%U is not a valid font feature", feature);
+        return NULL;
+    }
+    return ans;
+}
+
 static PyMethodDef module_methods[] = {
     METHODB(set_font_data, METH_VARARGS),
     METHODB(free_font_data, METH_NOARGS),
+    METHODB(parse_font_feature, METH_O),
     METHODB(create_test_font_group, METH_VARARGS),
     METHODB(sprite_map_set_layout, METH_VARARGS),
     METHODB(test_sprite_position_for, METH_VARARGS),

kitty/fonts/box_drawing.py

@@ -2,6 +2,11 @@
 # vim:fileencoding=utf-8
 # License: GPL v3 Copyright: 2017, Kovid Goyal <kovid at kovidgoyal.net>
 
+#
+# NOTE: to add a new glyph, add an entry to the `box_chars` dict, then update
+# the functions `font_for_cell` and `box_glyph_id` in `kitty/fonts.c`.
+#
+
 import math
 from functools import partial as p
 from itertools import repeat
@@ -172,6 +177,117 @@ def triangle(buf, width, height, left=True):
     fill_region(buf, width, height, xlimits)
 
 
+def corner_triangle(buf, width, height, corner):
+    if corner == 'top-right' or corner == 'bottom-left':
+        diagonal_y = line_equation(0, 0, width - 1, height - 1)
+        if corner == 'top-right':
+            xlimits = [(0, diagonal_y(x)) for x in range(width)]
+        elif corner == 'bottom-left':
+            xlimits = [(diagonal_y(x), height - 1) for x in range(width)]
+    else:
+        diagonal_y = line_equation(width - 1, 0, 0, height - 1)
+        if corner == 'top-left':
+            xlimits = [(0, diagonal_y(x)) for x in range(width)]
+        elif corner == 'bottom-right':
+            xlimits = [(diagonal_y(x), height - 1) for x in range(width)]
+    fill_region(buf, width, height, xlimits)
+
+
+def antialiased_1px_line(buf, width, height, p1, p2):
+    # Draw an antialiased line using the Wu algorithm
+    x1, y1 = p1
+    x2, y2 = p2
+    dx, dy = x2 - x1, y2 - y1
+    off_limit = height * width
+    steep = abs(dx) < abs(dy)
+
+    if steep:
+        x1, y1, x2, y2, dx, dy = y1, x1, y2, x2, dy, dx
+
+        def p(x, y):
+            return y, x
+    else:
+        def p(x, y):
+            return x, y
+
+    if x2 < x1:
+        x1, x2, y1, y2 = x2, x1, y2, y1
+
+    def fpart(x):
+        return x - int(x)
+
+    def rfpart(x):
+        return 1 - fpart(x)
+
+    def putpixel(p, alpha):
+        x, y = p
+        off = int(x + y * width)
+        if 0 <= off < off_limit:
+            buf[off] = int(min(buf[off] + (alpha * 255), 255))
+
+    def draw_endpoint(pt):
+        x, y = pt
+        xend = round(x)
+        yend = y + grad * (xend - x)
+        xgap = rfpart(x + 0.5)
+        px, py = int(xend), int(yend)
+        putpixel(p(px, py), rfpart(yend) * xgap)
+        putpixel(p(px, py+1), fpart(yend) * xgap)
+        return px
+
+    grad = dy/dx
+    intery = y1 + rfpart(x1) * grad
+
+    xstart = draw_endpoint(p(*p1))
+    xend = draw_endpoint(p(*p2))
+
+    if xstart > xend:
+        xstart, xend = xend, xstart
+    xstart += 1
+
+    for x in range(xstart, xend):
+        y = int(intery)
+        putpixel(p(x, y), rfpart(intery))
+        putpixel(p(x, y+1), fpart(intery))
+        intery += grad
+
+
+def antialiased_line(buf, width, height, p1, p2, level=1):
+    th = thickness(level)
+    if th < 2:
+        return antialiased_1px_line(buf, width, height, p1, p2)
+    (x1, y1), (x2, y2) = p1, p2
+    dh = th // 2
+    items = range(-dh, dh + (th % 2))
+    for delta in items:
+        antialiased_1px_line(buf, width, height, (x1, y1 + delta), (x2, y2 + delta))
+
+
+def cross_line(buf, width, height, left=True, level=1):
+    if left:
+        p1, p2 = (0, 0), (width - 1, height - 1)
+    else:
+        p1, p2 = (width - 1, 0), (0, height - 1)
+    antialiased_line(buf, width, height, p1, p2, level=level)
+
+
+def half_cross_line(buf, width, height, which='tl', level=1):
+    my = (height - 1) // 2
+    if which == 'tl':
+        p1 = 0, 0
+        p2 = width - 1, my
+    elif which == 'bl':
+        p2 = 0, height - 1
+        p1 = width - 1, my
+    elif which == 'tr':
+        p1 = width - 1, 0
+        p2 = 0, my
+    else:
+        p2 = width - 1, height - 1
+        p1 = 0, my
+    antialiased_line(buf, width, height, p1, p2, level=level)
+
+
 def cubic_bezier(start, end, c1, c2):
 
     def bezier_eq(p0, p1, p2, p3):
@@ -459,6 +575,12 @@ box_chars = {
     '': [p(triangle, left=False)],
     '': [D],
     '': [p(D, left=False)],
+    '': [p(half_cross_line, which='tl'), p(half_cross_line, which='bl')],
+    '': [p(half_cross_line, which='tr'), p(half_cross_line, which='br')],
+    '': [p(corner_triangle, corner='bottom-left')],
+    '': [p(corner_triangle, corner='bottom-right')],
+    '': [p(corner_triangle, corner='top-left')],
+    '': [p(corner_triangle, corner='top-right')],
     '═': [dhline],
     '║': [dvline],
     '╞': [vline, p(half_dhline, which='right')],
@@ -472,6 +594,9 @@ box_chars = {
     '╣': [p(inner_corner, which='tl'), p(inner_corner, which='bl'), p(dvline, only='right')],
     '╦': [p(inner_corner, which='bl'), p(inner_corner, which='br'), p(dhline, only='top')],
     '╩': [p(inner_corner, which='tl'), p(inner_corner, which='tr'), p(dhline, only='bottom')],
+    '╱': [p(cross_line, left=False)],
+    '╲': [cross_line],
+    '╳': [cross_line, p(cross_line, left=False)],
     '▀': [p(vblock, frac=1/2)],
     '▁': [p(vblock, frac=1/8, gravity='bottom')],
     '▂': [p(vblock, frac=1/4, gravity='bottom')],
@@ -551,60 +676,60 @@ def render_missing_glyph(buf, width, height):
 
 
 def test_char(ch, sz=48):
-    # kitty +runpy "from kitty.fonts.box_drawing import test_char; import sys; test_char('XXX')"
+    # kitty +runpy "from kitty.fonts.box_drawing import test_char; test_char('XXX')"
     from .render import display_bitmap, setup_for_testing
     from kitty.fast_data_types import concat_cells, set_send_sprite_to_gpu
-    width, height = setup_for_testing('monospace', sz)[1:]
-    buf = bytearray(width * height)
-    try:
-        render_box_char(ch, buf, width, height)
+    with setup_for_testing('monospace', sz) as (_, width, height):
+        buf = bytearray(width * height)
+        try:
+            render_box_char(ch, buf, width, height)
 
-        def join_cells(*cells):
-            cells = tuple(bytes(x) for x in cells)
-            return concat_cells(width, height, False, cells)
+            def join_cells(*cells):
+                cells = tuple(bytes(x) for x in cells)
+                return concat_cells(width, height, False, cells)
 
-        rgb_data = join_cells(buf)
-        display_bitmap(rgb_data, width, height)
-        print()
-    finally:
-        set_send_sprite_to_gpu(None)
+            rgb_data = join_cells(buf)
+            display_bitmap(rgb_data, width, height)
+            print()
+        finally:
+            set_send_sprite_to_gpu(None)
 
 
 def test_drawing(sz=48, family='monospace'):
     from .render import display_bitmap, setup_for_testing
     from kitty.fast_data_types import concat_cells, set_send_sprite_to_gpu
 
-    width, height = setup_for_testing(family, sz)[1:]
-    space = bytearray(width * height)
+    with setup_for_testing(family, sz) as (_, width, height):
+        space = bytearray(width * height)
 
-    def join_cells(cells):
-        cells = tuple(bytes(x) for x in cells)
-        return concat_cells(width, height, False, cells)
+        def join_cells(cells):
+            cells = tuple(bytes(x) for x in cells)
+            return concat_cells(width, height, False, cells)
 
-    def render_chr(ch):
-        if ch in box_chars:
-            cell = bytearray(len(space))
-            render_box_char(ch, cell, width, height)
-            return cell
-        return space
+        def render_chr(ch):
+            if ch in box_chars:
+                cell = bytearray(len(space))
+                render_box_char(ch, cell, width, height)
+                return cell
+            return space
 
-    pos = 0x2500
-    rows = []
-    space_row = join_cells(repeat(space, 32))
+        pos = 0x2500
+        rows = []
+        space_row = join_cells(repeat(space, 32))
 
-    try:
-        for r in range(10):
-            row = []
-            for i in range(16):
-                row.append(render_chr(chr(pos)))
-                row.append(space)
-                pos += 1
-            rows.append(join_cells(row))
-            rows.append(space_row)
-        rgb_data = b''.join(rows)
-        width *= 32
-        height *= len(rows)
-        assert len(rgb_data) == width * height * 4, '{} != {}'.format(len(rgb_data), width * height * 4)
-        display_bitmap(rgb_data, width, height)
-    finally:
-        set_send_sprite_to_gpu(None)
+        try:
+            for r in range(10):
+                row = []
+                for i in range(16):
+                    row.append(render_chr(chr(pos)))
+                    row.append(space)
+                    pos += 1
+                rows.append(join_cells(row))
+                rows.append(space_row)
+            rgb_data = b''.join(rows)
+            width *= 32
+            height *= len(rows)
+            assert len(rgb_data) == width * height * 4, '{} != {}'.format(len(rgb_data), width * height * 4)
+            display_bitmap(rgb_data, width, height)
+        finally:
+            set_send_sprite_to_gpu(None)

kitty/fonts/core_text.py

@@ -38,7 +38,7 @@ def list_fonts():
         if f:
             fn = (f + ' ' + (fd['style'] or '')).strip()
             is_mono = bool(fd['monospace'])
-            yield {'family': f, 'full_name': fn, 'is_monospace': is_mono}
+            yield {'family': f, 'full_name': fn, 'postscript_name': fd['postscript_name'] or '', 'is_monospace': is_mono}
 
 
 def find_best_match(family, bold=False, italic=False):

kitty/fonts/fontconfig.py

@@ -45,7 +45,7 @@ def list_fonts():
         if f:
             fn = fd.get('full_name') or (f + ' ' + fd.get('style', '')).strip()
             is_mono = fd.get('spacing') in ('MONO', 'DUAL')
-            yield {'family': f, 'full_name': fn, 'is_monospace': is_mono}
+            yield {'family': f, 'full_name': fn, 'postscript_name': fd.get('postscript_name', ''), 'is_monospace': is_mono}
 
 
 def family_name_to_key(family):

kitty/fonts/list.py

@@ -20,6 +20,7 @@ def create_family_groups(monospaced=True):
 
 
 def main(argv):
+    psnames = '--psnames' in argv
     isatty = sys.stdout.isatty()
     groups = create_family_groups()
     for k in sorted(groups, key=lambda x: x.lower()):
@@ -31,5 +32,7 @@ def main(argv):
             p = f['full_name']
             if isatty:
                 p = '\033[3m' + p + '\033[m'
+            if psnames:
+                p += ' ({})'.format(f['postscript_name'])
             print('   ', p)
         print()

kitty/fonts/render.py

@@ -25,8 +25,29 @@ else:
 current_faces = None
 
 
+def coalesce_symbol_maps(maps):
+    if not maps:
+        return maps
+    items = tuple((k, maps[k]) for k in sorted(maps))
+    ans = [items[0]]
+
+    def merge(prev_item, item):
+        s, e = item[0]
+        pe = prev_item[0][1]
+        ans[-1] = ((prev_item[0][0], max(pe, e)), prev_item[1])
+
+    for item in items[1:]:
+        current_item = ans[-1]
+        if current_item[1] != item[1] or item[0][0] > current_item[0][1] + 1:
+            ans.append(item)
+        else:
+            merge(current_item, item)
+
+    return dict(ans)
+
+
 def create_symbol_map(opts):
-    val = opts.symbol_map
+    val = coalesce_symbol_maps(opts.symbol_map)
     family_map = {}
     count = 0
     for family in val.values():
@@ -82,7 +103,7 @@ def set_font_family(opts=None, override_font_size=None, debug_font_matching=Fals
     set_font_data(
         render_box_drawing, prerender_function, descriptor_for_idx,
         indices['bold'], indices['italic'], indices['bi'], num_symbol_fonts,
-        sm, sz
+        sm, sz, opts.font_features
     )
 
 

kitty/freetype.c

@@ -77,12 +77,12 @@ static FT_Library  library;
 
 static inline int
 font_units_to_pixels_y(Face *self, int x) {
-    return ceil((double)FT_MulFix(x, self->face->size->metrics.y_scale) / 64.0);
+    return (int)ceil((double)FT_MulFix(x, self->face->size->metrics.y_scale) / 64.0);
 }
 
 static inline int
 font_units_to_pixels_x(Face *self, int x) {
-    return ceil((double)FT_MulFix(x, self->face->size->metrics.x_scale) / 64.0);
+    return (int)ceil((double)FT_MulFix(x, self->face->size->metrics.x_scale) / 64.0);
 }
 
 
@@ -140,7 +140,7 @@ set_font_size(Face *self, FT_F26Dot6 char_width, FT_F26Dot6 char_height, FT_UInt
     if (!error) {
         unsigned int ch = calc_cell_height(self, false);
         if (desired_height && ch != desired_height) {
-            FT_F26Dot6 h = floor((double)char_height * (double)desired_height / (double) ch);
+            FT_F26Dot6 h = (FT_F26Dot6)floor((double)char_height * (double)desired_height / (double) ch);
             return set_font_size(self, 0, h, xdpi, ydpi, 0, cell_height);
         }
         self->char_width = char_width; self->char_height = char_height; self->xdpi = xdpi; self->ydpi = ydpi;
@@ -160,8 +160,8 @@ set_font_size(Face *self, FT_F26Dot6 char_width, FT_F26Dot6 char_height, FT_UInt
             int32_t min_diff = INT32_MAX;
             if (desired_height == 0) desired_height = cell_height;
             if (desired_height == 0) {
-                desired_height = ceil(((double)char_height / 64.) * (double)ydpi / 72.);
-                desired_height += ceil(0.2 * desired_height);
+                desired_height = (unsigned int)ceil(((double)char_height / 64.) * (double)ydpi / 72.);
+                desired_height += (unsigned int)ceil(0.2 * desired_height);
             }
             FT_Int strike_index = -1;
             for (FT_Int i = 0; i < self->face->num_fixed_sizes; i++) {
@@ -190,7 +190,7 @@ set_size_for_face(PyObject *s, unsigned int desired_height, bool force, FONTS_DA
     FT_F26Dot6 w = (FT_F26Dot6)(ceil(fg->font_sz_in_pts * 64.0));
     FT_UInt xdpi = (FT_UInt)fg->logical_dpi_x, ydpi = (FT_UInt)fg->logical_dpi_y;
     if (!force && (self->char_width == w && self->char_height == w && self->xdpi == xdpi && self->ydpi == ydpi)) return true;
-    ((Face*)self)->size_in_pts = fg->font_sz_in_pts;
+    ((Face*)self)->size_in_pts = (float)fg->font_sz_in_pts;
     return set_font_size(self, w, w, xdpi, ydpi, desired_height, fg->cell_height);
 }
 
@@ -438,7 +438,7 @@ downsample_bitmap(ProcessedBitmap *bm, unsigned int width, unsigned int cell_hei
     // better with bi-cubic or lanczos, but at these small sizes I don't think
     // it matters
     float ratio = MAX((float)bm->width / width, (float)bm->rows / cell_height);
-    int factor = ceilf(ratio);
+    int factor = (int)ceilf(ratio);
     uint8_t *dest = calloc(4, width * cell_height);
     if (dest == NULL) fatal("Out of memory");
     uint8_t *d = dest;
@@ -499,8 +499,8 @@ render_color_bitmap(Face *self, int glyph_id, ProcessedBitmap *ans, unsigned int
     ans->rows = bitmap->rows;
     ans->pixel_mode = bitmap->pixel_mode;
     if (ans->width > num_cells * cell_width + 2) downsample_bitmap(ans, num_cells * cell_width, cell_height);
-    ans->bitmap_top = (float)self->face->glyph->bitmap_top / ans->factor;
-    ans->bitmap_left = (float)self->face->glyph->bitmap_left / ans->factor;
+    ans->bitmap_top = (int)((float)self->face->glyph->bitmap_top / ans->factor);
+    ans->bitmap_left = (int)((float)self->face->glyph->bitmap_left / ans->factor);
     detect_right_edge(ans);
     return true;
 }

kitty/gl-wrapper.h

@@ -1,5 +1,5 @@
 /**
- * Loader generated by glad 2.0.0-beta on Sun Jul  7 20:35:06 2019
+ * Loader generated by glad 2.0.0-beta on Fri Dec 20 14:59:05 2019
  *
  * Generator: C/C++
  * Specification: gl
@@ -9,19 +9,19 @@
  *  - gl:core=3.3
  *
  * Options:
+ *  - ALIAS = False
+ *  - DEBUG = True
+ *  - HEADER_ONLY = True
+ *  - LOADER = False
+ *  - MX = False
  *  - MX_GLOBAL = False
  *  - ON_DEMAND = False
- *  - LOADER = False
- *  - ALIAS = False
- *  - HEADER_ONLY = True
- *  - DEBUG = True
- *  - MX = False
  *
  * Commandline:
- *    --api='gl:core=3.3' --extensions='GL_ARB_copy_image,GL_ARB_multisample,GL_ARB_robustness,GL_ARB_texture_storage,GL_KHR_debug' c --header-only --debug
+ *    --api='gl:core=3.3' --extensions='GL_ARB_copy_image,GL_ARB_multisample,GL_ARB_robustness,GL_ARB_texture_storage,GL_KHR_debug' c --debug --header-only
  *
  * Online:
- *    http://glad.sh/#api=gl%3Acore%3D3.3&extensions=GL_ARB_copy_image%2CGL_ARB_multisample%2CGL_ARB_robustness%2CGL_ARB_texture_storage%2CGL_KHR_debug&generator=c&options=HEADER_ONLY%2CDEBUG
+ *    http://glad.sh/#api=gl%3Acore%3D3.3&extensions=GL_ARB_copy_image%2CGL_ARB_multisample%2CGL_ARB_robustness%2CGL_ARB_texture_storage%2CGL_KHR_debug&generator=c&options=DEBUG%2CHEADER_ONLY
  *
  */
 #ifndef GLAD_GL_H_
@@ -31,8 +31,8 @@
 #endif
 #define __gl_h_ 1
 #define GLAD_GL
-#define GLAD_OPTION_GL_HEADER_ONLY
 #define GLAD_OPTION_GL_DEBUG
+#define GLAD_OPTION_GL_HEADER_ONLY
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -1324,13 +1324,13 @@ typedef khronos_uint64_t GLuint64EXT;
 typedef struct __GLsync *GLsync;
 struct _cl_context;
 struct _cl_event;
-typedef void ( *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);
-typedef void ( *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);
-typedef void ( *GLDEBUGPROCKHR)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);
-typedef void ( *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,void *userParam);
+typedef void (GLAD_API_PTR *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);
+typedef void (GLAD_API_PTR *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);
+typedef void (GLAD_API_PTR *GLDEBUGPROCKHR)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);
+typedef void (GLAD_API_PTR *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,void *userParam);
 typedef unsigned short GLhalfNV;
 typedef GLintptr GLvdpauSurfaceNV;
-typedef void ( *GLVULKANPROCNV)(void);
+typedef void (GLAD_API_PTR *GLVULKANPROCNV)(void);
 #define GL_VERSION_1_0 1
 GLAD_API_CALL int GLAD_GL_VERSION_1_0;
 #define GL_VERSION_1_1 1
@@ -1522,7 +1522,7 @@ typedef void (GLAD_API_PTR *PFNGLGETSHADERSOURCEPROC)(GLuint shader, GLsizei buf
 typedef void (GLAD_API_PTR *PFNGLGETSHADERIVPROC)(GLuint shader, GLenum pname, GLint * params);
 typedef const GLubyte * (GLAD_API_PTR *PFNGLGETSTRINGPROC)(GLenum name);
 typedef const GLubyte * (GLAD_API_PTR *PFNGLGETSTRINGIPROC)(GLenum name, GLuint index);
-typedef void (GLAD_API_PTR *PFNGLGETSYNCIVPROC)(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei * length, GLint * values);
+typedef void (GLAD_API_PTR *PFNGLGETSYNCIVPROC)(GLsync sync, GLenum pname, GLsizei count, GLsizei * length, GLint * values);
 typedef void (GLAD_API_PTR *PFNGLGETTEXIMAGEPROC)(GLenum target, GLint level, GLenum format, GLenum type, void * pixels);
 typedef void (GLAD_API_PTR *PFNGLGETTEXLEVELPARAMETERFVPROC)(GLenum target, GLint level, GLenum pname, GLfloat * params);
 typedef void (GLAD_API_PTR *PFNGLGETTEXLEVELPARAMETERIVPROC)(GLenum target, GLint level, GLenum pname, GLint * params);
@@ -4037,10 +4037,10 @@ static const GLubyte * GLAD_API_PTR glad_debug_impl_glGetStringi(GLenum name, GL
 }
 PFNGLGETSTRINGIPROC glad_debug_glGetStringi = glad_debug_impl_glGetStringi;
 PFNGLGETSYNCIVPROC glad_glGetSynciv = NULL;
-static void GLAD_API_PTR glad_debug_impl_glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei * length, GLint * values) {
-    _pre_call_gl_callback("glGetSynciv", (GLADapiproc) glad_glGetSynciv, 5, sync, pname, bufSize, length, values);
-    glad_glGetSynciv(sync, pname, bufSize, length, values);
-    _post_call_gl_callback(NULL, "glGetSynciv", (GLADapiproc) glad_glGetSynciv, 5, sync, pname, bufSize, length, values);
+static void GLAD_API_PTR glad_debug_impl_glGetSynciv(GLsync sync, GLenum pname, GLsizei count, GLsizei * length, GLint * values) {
+    _pre_call_gl_callback("glGetSynciv", (GLADapiproc) glad_glGetSynciv, 5, sync, pname, count, length, values);
+    glad_glGetSynciv(sync, pname, count, length, values);
+    _post_call_gl_callback(NULL, "glGetSynciv", (GLADapiproc) glad_glGetSynciv, 5, sync, pname, count, length, values);
 }
 PFNGLGETSYNCIVPROC glad_debug_glGetSynciv = glad_debug_impl_glGetSynciv;
 PFNGLGETTEXIMAGEPROC glad_glGetTexImage = NULL;

kitty/gl.c

@@ -81,6 +81,11 @@ free_texture(GLuint *tex_id) {
     *tex_id = 0;
 }
 
+void
+free_framebuffer(GLuint *fb_id) {
+    glDeleteFramebuffers(1, fb_id);
+    *fb_id = 0;
+}
 
 // }}}
 
@@ -126,6 +131,12 @@ init_uniforms(int program) {
     }
 }
 
+GLint
+get_uniform_location(int program, const char *name) {
+    Program *p = programs + program;
+    return glGetUniformLocation(p->id, name);
+}
+
 GLint
 get_uniform_information(int program, const char *name, GLenum information_type) {
     GLint q; GLuint t;

kitty/gl.h

@@ -35,12 +35,14 @@ typedef struct {
 void gl_init(void);
 void update_surface_size(int w, int h, GLuint offscreen_texture_id);
 void free_texture(GLuint *tex_id);
+void free_framebuffer(GLuint *fb_id);
 void remove_vao(ssize_t vao_idx);
 void init_uniforms(int program);
 GLuint program_id(int program);
 Program* program_ptr(int program);
 GLuint block_index(int program, const char *name);
 GLint block_size(int program, GLuint block_index);
+GLint get_uniform_location(int program, const char *name);
 GLint get_uniform_information(int program, const char *name, GLenum information_type);
 GLint attrib_location(int program, const char *name);
 ssize_t create_vao(void);

kitty/glfw-wrapper.c

@@ -140,6 +140,9 @@ load_glfw(const char* path) {
     *(void **) (&glfwSetWindowAspectRatio_impl) = dlsym(handle, "glfwSetWindowAspectRatio");
     if (glfwSetWindowAspectRatio_impl == NULL) fail("Failed to load glfw function glfwSetWindowAspectRatio with error: %s", dlerror());
 
+    *(void **) (&glfwSetWindowSizeIncrements_impl) = dlsym(handle, "glfwSetWindowSizeIncrements");
+    if (glfwSetWindowSizeIncrements_impl == NULL) fail("Failed to load glfw function glfwSetWindowSizeIncrements with error: %s", dlerror());
+
     *(void **) (&glfwSetWindowSize_impl) = dlsym(handle, "glfwSetWindowSize");
     if (glfwSetWindowSize_impl == NULL) fail("Failed to load glfw function glfwSetWindowSize with error: %s", dlerror());
 
@@ -245,8 +248,8 @@ load_glfw(const char* path) {
     *(void **) (&glfwGetKeyName_impl) = dlsym(handle, "glfwGetKeyName");
     if (glfwGetKeyName_impl == NULL) fail("Failed to load glfw function glfwGetKeyName with error: %s", dlerror());
 
-    *(void **) (&glfwGetKeyScancode_impl) = dlsym(handle, "glfwGetKeyScancode");
-    if (glfwGetKeyScancode_impl == NULL) fail("Failed to load glfw function glfwGetKeyScancode with error: %s", dlerror());
+    *(void **) (&glfwGetNativeKeyForKey_impl) = dlsym(handle, "glfwGetNativeKeyForKey");
+    if (glfwGetNativeKeyForKey_impl == NULL) fail("Failed to load glfw function glfwGetNativeKeyForKey with error: %s", dlerror());
 
     *(void **) (&glfwGetKey_impl) = dlsym(handle, "glfwGetKey");
     if (glfwGetKey_impl == NULL) fail("Failed to load glfw function glfwGetKey with error: %s", dlerror());
@@ -344,15 +347,6 @@ load_glfw(const char* path) {
     *(void **) (&glfwGetTime_impl) = dlsym(handle, "glfwGetTime");
     if (glfwGetTime_impl == NULL) fail("Failed to load glfw function glfwGetTime with error: %s", dlerror());
 
-    *(void **) (&glfwSetTime_impl) = dlsym(handle, "glfwSetTime");
-    if (glfwSetTime_impl == NULL) fail("Failed to load glfw function glfwSetTime with error: %s", dlerror());
-
-    *(void **) (&glfwGetTimerValue_impl) = dlsym(handle, "glfwGetTimerValue");
-    if (glfwGetTimerValue_impl == NULL) fail("Failed to load glfw function glfwGetTimerValue with error: %s", dlerror());
-
-    *(void **) (&glfwGetTimerFrequency_impl) = dlsym(handle, "glfwGetTimerFrequency");
-    if (glfwGetTimerFrequency_impl == NULL) fail("Failed to load glfw function glfwGetTimerFrequency with error: %s", dlerror());
-
     *(void **) (&glfwMakeContextCurrent_impl) = dlsym(handle, "glfwMakeContextCurrent");
     if (glfwMakeContextCurrent_impl == NULL) fail("Failed to load glfw function glfwMakeContextCurrent with error: %s", dlerror());
 
@@ -389,6 +383,8 @@ load_glfw(const char* path) {
 
     *(void **) (&glfwSetApplicationShouldHandleReopen_impl) = dlsym(handle, "glfwSetApplicationShouldHandleReopen");
 
+    *(void **) (&glfwSetApplicationWillFinishLaunching_impl) = dlsym(handle, "glfwSetApplicationWillFinishLaunching");
+
     *(void **) (&glfwGetCocoaKeyEquivalent_impl) = dlsym(handle, "glfwGetCocoaKeyEquivalent");
 
     *(void **) (&glfwCocoaRequestRenderFrame_impl) = dlsym(handle, "glfwCocoaRequestRenderFrame");
@@ -401,7 +397,7 @@ load_glfw(const char* path) {
 
     *(void **) (&glfwGetPrimarySelectionString_impl) = dlsym(handle, "glfwGetPrimarySelectionString");
 
-    *(void **) (&glfwGetXKBScancode_impl) = dlsym(handle, "glfwGetXKBScancode");
+    *(void **) (&glfwGetNativeKeyForName_impl) = dlsym(handle, "glfwGetNativeKeyForName");
 
     *(void **) (&glfwRequestWaylandFrameEvent_impl) = dlsym(handle, "glfwRequestWaylandFrameEvent");
 

kitty/glfw-wrapper.h

@@ -1,6 +1,13 @@
+//
+// THIS FILE IS GENERATED BY glfw.py
+//
+// SAVE YOURSELF SOME TIME, DO NOT MANUALLY EDIT
+//
+
 #pragma once
 #include <stddef.h>
 #include <stdint.h>
+#include "monotonic.h"
 
 
 
@@ -18,7 +25,7 @@
  *  backward-compatible.
  *  @ingroup init
  */
-#define GLFW_VERSION_MINOR          3
+#define GLFW_VERSION_MINOR          4
 /*! @brief The revision number of the GLFW library.
  *
  *  This is incremented when a bug fix release is made that does not contain any
@@ -54,6 +61,7 @@
 /*! @} */
 
 /*! @defgroup hat_state Joystick hat states
+ *  @brief Joystick hat states.
  *
  *  See [joystick hat input](@ref joystick_hat) for how these are used.
  *
@@ -157,6 +165,7 @@
 #define GLFW_KEY_LEFT_BRACKET       91  /* [ */
 #define GLFW_KEY_BACKSLASH          92  /* \ */
 #define GLFW_KEY_RIGHT_BRACKET      93  /* ] */
+#define GLFW_KEY_CIRCUMFLEX         94  /* ^ */
 #define GLFW_KEY_UNDERSCORE         95  /* _ */
 #define GLFW_KEY_GRAVE_ACCENT       96  /* ` */
 #define GLFW_KEY_WORLD_1            161 /* non-US #1 */
@@ -725,74 +734,87 @@
 #define GLFW_CLIENT_API             0x00022001
 /*! @brief Context client API major version hint and attribute.
  *
- *  Context client API major version [hint](@ref GLFW_CLIENT_API_hint) and
- *  [attribute](@ref GLFW_CLIENT_API_attrib).
+ *  Context client API major version [hint](@ref GLFW_CONTEXT_VERSION_MAJOR_hint)
+ *  and [attribute](@ref GLFW_CONTEXT_VERSION_MAJOR_attrib).
  */
 #define GLFW_CONTEXT_VERSION_MAJOR  0x00022002
 /*! @brief Context client API minor version hint and attribute.
  *
- *  Context client API minor version [hint](@ref GLFW_CLIENT_API_hint) and
- *  [attribute](@ref GLFW_CLIENT_API_attrib).
+ *  Context client API minor version [hint](@ref GLFW_CONTEXT_VERSION_MINOR_hint)
+ *  and [attribute](@ref GLFW_CONTEXT_VERSION_MINOR_attrib).
  */
 #define GLFW_CONTEXT_VERSION_MINOR  0x00022003
 /*! @brief Context client API revision number hint and attribute.
  *
- *  Context client API revision number [hint](@ref GLFW_CLIENT_API_hint) and
- *  [attribute](@ref GLFW_CLIENT_API_attrib).
+ *  Context client API revision number
+ *  [attribute](@ref GLFW_CONTEXT_REVISION_attrib).
  */
 #define GLFW_CONTEXT_REVISION       0x00022004
 /*! @brief Context robustness hint and attribute.
  *
- *  Context client API revision number [hint](@ref GLFW_CLIENT_API_hint) and
- *  [attribute](@ref GLFW_CLIENT_API_attrib).
+ *  Context client API revision number [hint](@ref GLFW_CONTEXT_ROBUSTNESS_hint)
+ *  and [attribute](@ref GLFW_CONTEXT_ROBUSTNESS_attrib).
  */
 #define GLFW_CONTEXT_ROBUSTNESS     0x00022005
 /*! @brief OpenGL forward-compatibility hint and attribute.
  *
- *  OpenGL forward-compatibility [hint](@ref GLFW_CLIENT_API_hint) and
- *  [attribute](@ref GLFW_CLIENT_API_attrib).
+ *  OpenGL forward-compatibility [hint](@ref GLFW_OPENGL_FORWARD_COMPAT_hint)
+ *  and [attribute](@ref GLFW_OPENGL_FORWARD_COMPAT_attrib).
  */
 #define GLFW_OPENGL_FORWARD_COMPAT  0x00022006
 /*! @brief OpenGL debug context hint and attribute.
  *
- *  OpenGL debug context [hint](@ref GLFW_CLIENT_API_hint) and
- *  [attribute](@ref GLFW_CLIENT_API_attrib).
+ *  OpenGL debug context [hint](@ref GLFW_OPENGL_DEBUG_CONTEXT_hint) and
+ *  [attribute](@ref GLFW_OPENGL_DEBUG_CONTEXT_attrib).
  */
 #define GLFW_OPENGL_DEBUG_CONTEXT   0x00022007
 /*! @brief OpenGL profile hint and attribute.
  *
- *  OpenGL profile [hint](@ref GLFW_CLIENT_API_hint) and
- *  [attribute](@ref GLFW_CLIENT_API_attrib).
+ *  OpenGL profile [hint](@ref GLFW_OPENGL_PROFILE_hint) and
+ *  [attribute](@ref GLFW_OPENGL_PROFILE_attrib).
  */
 #define GLFW_OPENGL_PROFILE         0x00022008
 /*! @brief Context flush-on-release hint and attribute.
  *
- *  Context flush-on-release [hint](@ref GLFW_CLIENT_API_hint) and
- *  [attribute](@ref GLFW_CLIENT_API_attrib).
+ *  Context flush-on-release [hint](@ref GLFW_CONTEXT_RELEASE_BEHAVIOR_hint) and
+ *  [attribute](@ref GLFW_CONTEXT_RELEASE_BEHAVIOR_attrib).
  */
 #define GLFW_CONTEXT_RELEASE_BEHAVIOR 0x00022009
 /*! @brief Context error suppression hint and attribute.
  *
- *  Context error suppression [hint](@ref GLFW_CLIENT_API_hint) and
- *  [attribute](@ref GLFW_CLIENT_API_attrib).
+ *  Context error suppression [hint](@ref GLFW_CONTEXT_NO_ERROR_hint) and
+ *  [attribute](@ref GLFW_CONTEXT_NO_ERROR_attrib).
  */
 #define GLFW_CONTEXT_NO_ERROR       0x0002200A
 /*! @brief Context creation API hint and attribute.
  *
- *  Context creation API [hint](@ref GLFW_CLIENT_API_hint) and
- *  [attribute](@ref GLFW_CLIENT_API_attrib).
+ *  Context creation API [hint](@ref GLFW_CONTEXT_CREATION_API_hint) and
+ *  [attribute](@ref GLFW_CONTEXT_CREATION_API_attrib).
  */
 #define GLFW_CONTEXT_CREATION_API   0x0002200B
 /*! @brief Window content area scaling window
  *  [window hint](@ref GLFW_SCALE_TO_MONITOR).
  */
 #define GLFW_SCALE_TO_MONITOR       0x0002200C
-
+/*! @brief macOS specific
+ *  [window hint](@ref GLFW_COCOA_RETINA_FRAMEBUFFER_hint).
+ */
 #define GLFW_COCOA_RETINA_FRAMEBUFFER 0x00023001
+/*! @brief macOS specific
+ *  [window hint](@ref GLFW_COCOA_FRAME_NAME_hint).
+ */
 #define GLFW_COCOA_FRAME_NAME         0x00023002
+/*! @brief macOS specific
+ *  [window hint](@ref GLFW_COCOA_GRAPHICS_SWITCHING_hint).
+ */
 #define GLFW_COCOA_GRAPHICS_SWITCHING 0x00023003
-
+/*! @brief X11 specific
+ *  [window hint](@ref GLFW_X11_CLASS_NAME_hint).
+ */
 #define GLFW_X11_CLASS_NAME         0x00024001
+/*! @brief X11 specific
+ *  [window hint](@ref GLFW_X11_CLASS_NAME_hint).
+ */
 #define GLFW_X11_INSTANCE_NAME      0x00024002
 
 #define GLFW_WAYLAND_APP_ID         0x00025001
@@ -855,11 +877,22 @@ typedef enum {
 
 /*! @addtogroup init
  *  @{ */
+/*! @brief Joystick hat buttons init hint.
+ *
+ *  Joystick hat buttons [init hint](@ref GLFW_JOYSTICK_HAT_BUTTONS).
+ */
 #define GLFW_JOYSTICK_HAT_BUTTONS   0x00050001
 #define GLFW_DEBUG_KEYBOARD         0x00050002
 #define GLFW_ENABLE_JOYSTICKS       0x00050003
-
+/*! @brief macOS specific init hint.
+ *
+ *  macOS specific [init hint](@ref GLFW_COCOA_CHDIR_RESOURCES_hint).
+ */
 #define GLFW_COCOA_CHDIR_RESOURCES  0x00051001
+/*! @brief macOS specific init hint.
+ *
+ *  macOS specific [init hint](@ref GLFW_COCOA_MENUBAR_hint).
+ */
 #define GLFW_COCOA_MENUBAR          0x00051002
 /*! @} */
 
@@ -930,17 +963,48 @@ typedef struct GLFWwindow GLFWwindow;
  *
  *  @since Added in version 3.1.
  *
- *  @ingroup cursor
+ *  @ingroup input
  */
 typedef struct GLFWcursor GLFWcursor;
 
-/*! @brief The function signature for error callbacks.
+typedef struct GLFWkeyevent
+{
+    // The [keyboard key](@ref keys) that was pressed or released.
+    int key;
+
+    // The platform-specific identifier of the key.
+    int native_key;
+
+    // The event action. Either `GLFW_PRESS`, `GLFW_RELEASE` or `GLFW_REPEAT`.
+    int action;
+
+    // Bit field describing which [modifier keys](@ref mods) were held down.
+    int mods;
+
+    // UTF-8 encoded text generated by this key event or empty string or NULL
+    const char *text;
+
+    // Used for Input Method events. Zero for normal key events.
+    //   A value of 1 means the pre-edit text for the input event has been changed.
+    //   A value of 2 means the text should be committed.
+    int ime_state;
+} GLFWkeyevent;
+
+/*! @brief The function pointer type for error callbacks.
  *
- *  This is the function signature for error callback functions.
+ *  This is the function pointer type for error callbacks.  An error callback
+ *  function has the following signature:
+ *  @code
+ *  void callback_name(int error_code, const char* description)
+ *  @endcode
  *
- *  @param[in] error An [error code](@ref errors).
+ *  @param[in] error_code An [error code](@ref errors).  Future releases may add
+ *  more error codes.
  *  @param[in] description A UTF-8 encoded string describing the error.
  *
+ *  @pointer_lifetime The error description string is valid until the callback
+ *  function returns.
+ *
  *  @sa @ref error_handling
  *  @sa @ref glfwSetErrorCallback
  *
@@ -950,9 +1014,13 @@ typedef struct GLFWcursor GLFWcursor;
  */
 typedef void (* GLFWerrorfun)(int,const char*);
 
-/*! @brief The function signature for window position callbacks.
+/*! @brief The function pointer type for window position callbacks.
  *
- *  This is the function signature for window position callback functions.
+ *  This is the function pointer type for window position callbacks.  A window
+ *  position callback function has the following signature:
+ *  @code
+ *  void callback_name(GLFWwindow* window, int xpos, int ypos)
+ *  @endcode
  *
  *  @param[in] window The window that was moved.
  *  @param[in] xpos The new x-coordinate, in screen coordinates, of the
@@ -969,9 +1037,13 @@ typedef void (* GLFWerrorfun)(int,const char*);
  */
 typedef void (* GLFWwindowposfun)(GLFWwindow*,int,int);
 
-/*! @brief The function signature for window resize callbacks.
+/*! @brief The function pointer type for window size callbacks.
  *
- *  This is the function signature for window size callback functions.
+ *  This is the function pointer type for window size callbacks.  A window size
+ *  callback function has the following signature:
+ *  @code
+ *  void callback_name(GLFWwindow* window, int width, int height)
+ *  @endcode
  *
  *  @param[in] window The window that was resized.
  *  @param[in] width The new width, in screen coordinates, of the window.
@@ -987,9 +1059,13 @@ typedef void (* GLFWwindowposfun)(GLFWwindow*,int,int);
  */
 typedef void (* GLFWwindowsizefun)(GLFWwindow*,int,int);
 
-/*! @brief The function signature for window close callbacks.
+/*! @brief The function pointer type for window close callbacks.
  *
- *  This is the function signature for window close callback functions.
+ *  This is the function pointer type for window close callbacks.  A window
+ *  close callback function has the following signature:
+ *  @code
+ *  void function_name(GLFWwindow* window)
+ *  @endcode
  *
  *  @param[in] window The window that the user attempted to close.
  *
@@ -1003,9 +1079,13 @@ typedef void (* GLFWwindowsizefun)(GLFWwindow*,int,int);
  */
 typedef void (* GLFWwindowclosefun)(GLFWwindow*);
 
-/*! @brief The function signature for window content refresh callbacks.
+/*! @brief The function pointer type for window content refresh callbacks.
  *
- *  This is the function signature for window refresh callback functions.
+ *  This is the function pointer type for window content refresh callbacks.
+ *  A window content refresh callback function has the following signature:
+ *  @code
+ *  void function_name(GLFWwindow* window);
+ *  @endcode
  *
  *  @param[in] window The window whose content needs to be refreshed.
  *
@@ -1019,9 +1099,13 @@ typedef void (* GLFWwindowclosefun)(GLFWwindow*);
  */
 typedef void (* GLFWwindowrefreshfun)(GLFWwindow*);
 
-/*! @brief The function signature for window focus/defocus callbacks.
+/*! @brief The function pointer type for window focus callbacks.
  *
- *  This is the function signature for window focus callback functions.
+ *  This is the function pointer type for window focus callbacks.  A window
+ *  focus callback function has the following signature:
+ *  @code
+ *  void function_name(GLFWwindow* window, int focused)
+ *  @endcode
  *
  *  @param[in] window The window that gained or lost input focus.
  *  @param[in] focused `true` if the window was given input focus, or
@@ -1054,10 +1138,13 @@ typedef void (* GLFWwindowfocusfun)(GLFWwindow*,int);
 typedef void (* GLFWwindowocclusionfun)(GLFWwindow*, bool);
 
 
-/*! @brief The function signature for window iconify/restore callbacks.
+/*! @brief The function pointer type for window iconify callbacks.
  *
- *  This is the function signature for window iconify/restore callback
- *  functions.
+ *  This is the function pointer type for window iconify callbacks.  A window
+ *  iconify callback function has the following signature:
+ *  @code
+ *  void function_name(GLFWwindow* window, int iconified)
+ *  @endcode
  *
  *  @param[in] window The window that was iconified or restored.
  *  @param[in] iconified `true` if the window was iconified, or
@@ -1072,10 +1159,13 @@ typedef void (* GLFWwindowocclusionfun)(GLFWwindow*, bool);
  */
 typedef void (* GLFWwindowiconifyfun)(GLFWwindow*,int);
 
-/*! @brief The function signature for window maximize/restore callbacks.
+/*! @brief The function pointer type for window maximize callbacks.
  *
- *  This is the function signature for window maximize/restore callback
- *  functions.
+ *  This is the function pointer type for window maximize callbacks.  A window
+ *  maximize callback function has the following signature:
+ *  @code
+ *  void function_name(GLFWwindow* window, int maximized)
+ *  @endcode
  *
  *  @param[in] window The window that was maximized or restored.
  *  @param[in] iconified `true` if the window was maximized, or
@@ -1090,10 +1180,13 @@ typedef void (* GLFWwindowiconifyfun)(GLFWwindow*,int);
  */
 typedef void (* GLFWwindowmaximizefun)(GLFWwindow*,int);
 
-/*! @brief The function signature for framebuffer resize callbacks.
+/*! @brief The function pointer type for framebuffer size callbacks.
  *
- *  This is the function signature for framebuffer resize callback
- *  functions.
+ *  This is the function pointer type for framebuffer size callbacks.
+ *  A framebuffer size callback function has the following signature:
+ *  @code
+ *  void function_name(GLFWwindow* window, int width, int height)
+ *  @endcode
  *
  *  @param[in] window The window whose framebuffer was resized.
  *  @param[in] width The new width, in pixels, of the framebuffer.
@@ -1108,10 +1201,13 @@ typedef void (* GLFWwindowmaximizefun)(GLFWwindow*,int);
  */
 typedef void (* GLFWframebuffersizefun)(GLFWwindow*,int,int);
 
-/*! @brief The function signature for window content scale callbacks.
+/*! @brief The function pointer type for window content scale callbacks.
  *
- *  This is the function signature for window content scale callback
- *  functions.
+ *  This is the function pointer type for window content scale callbacks.
+ *  A window content scale callback function has the following signature:
+ *  @code
+ *  void function_name(GLFWwindow* window, float xscale, float yscale)
+ *  @endcode
  *
  *  @param[in] window The window whose content scale changed.
  *  @param[in] xscale The new x-axis content scale of the window.
@@ -1126,14 +1222,19 @@ typedef void (* GLFWframebuffersizefun)(GLFWwindow*,int,int);
  */
 typedef void (* GLFWwindowcontentscalefun)(GLFWwindow*,float,float);
 
-/*! @brief The function signature for mouse button callbacks.
+/*! @brief The function pointer type for mouse button callbacks.
  *
- *  This is the function signature for mouse button callback functions.
+ *  This is the function pointer type for mouse button callback functions.
+ *  A mouse button callback function has the following signature:
+ *  @code
+ *  void function_name(GLFWwindow* window, int button, int action, int mods)
+ *  @endcode
  *
  *  @param[in] window The window that received the event.
  *  @param[in] button The [mouse button](@ref buttons) that was pressed or
  *  released.
- *  @param[in] action One of `GLFW_PRESS` or `GLFW_RELEASE`.
+ *  @param[in] action One of `GLFW_PRESS` or `GLFW_RELEASE`.  Future releases
+ *  may add more actions.
  *  @param[in] mods Bit field describing which [modifier keys](@ref mods) were
  *  held down.
  *
@@ -1147,9 +1248,13 @@ typedef void (* GLFWwindowcontentscalefun)(GLFWwindow*,float,float);
  */
 typedef void (* GLFWmousebuttonfun)(GLFWwindow*,int,int,int);
 
-/*! @brief The function signature for cursor position callbacks.
+/*! @brief The function pointer type for cursor position callbacks.
  *
- *  This is the function signature for cursor position callback functions.
+ *  This is the function pointer type for cursor position callbacks.  A cursor
+ *  position callback function has the following signature:
+ *  @code
+ *  void function_name(GLFWwindow* window, double xpos, double ypos);
+ *  @endcode
  *
  *  @param[in] window The window that received the event.
  *  @param[in] xpos The new cursor x-coordinate, relative to the left edge of
@@ -1166,12 +1271,16 @@ typedef void (* GLFWmousebuttonfun)(GLFWwindow*,int,int,int);
  */
 typedef void (* GLFWcursorposfun)(GLFWwindow*,double,double);
 
-/*! @brief The function signature for cursor enter/leave callbacks.
+/*! @brief The function pointer type for cursor enter/leave callbacks.
  *
- *  This is the function signature for cursor enter/leave callback functions.
+ *  This is the function pointer type for cursor enter/leave callbacks.
+ *  A cursor enter/leave callback function has the following signature:
+ *  @code
+ *  void function_name(GLFWwindow* window, int entered)
+ *  @endcode
  *
  *  @param[in] window The window that received the event.
- *  @param[in] entered `true` if the cursor entered the window's client
+ *  @param[in] entered `true` if the cursor entered the window's content
  *  area, or `false` if it left it.
  *
  *  @sa @ref cursor_enter
@@ -1183,16 +1292,20 @@ typedef void (* GLFWcursorposfun)(GLFWwindow*,double,double);
  */
 typedef void (* GLFWcursorenterfun)(GLFWwindow*,int);
 
-/*! @brief The function signature for scroll callbacks.
+/*! @brief The function pointer type for scroll callbacks.
  *
- *  This is the function signature for scroll callback functions.
+ *  This is the function pointer type for scroll callbacks.  A scroll callback
+ *  function has the following signature:
+ *  @code
+ *  void function_name(GLFWwindow* window, double xoffset, double yoffset)
+ *  @endcode
  *
  *  @param[in] window The window that received the event.
  *  @param[in] xoffset The scroll offset along the x-axis.
  *  @param[in] yoffset The scroll offset along the y-axis.
  *  @param[in] flags A bit-mask providing extra data about the event.
- *  flags & 1 will be true if and only if the offset values are "high-precision".
- *  Typically pixel values. Otherwise the offset values are number of lines.
+ *  flags & 1 will be true if and only if the offset values are "high-precision",
+ *  typically pixel values. Otherwise the offset values are number of lines.
  *  (flags >> 1) & 7 will have value 1 for the start of momentum scrolling,
  *  value 2 for stationary momentum scrolling, value 3 for momentum scrolling
  *  in progress, value 4 for momentum scrolling ended, value 5 for momentum
@@ -1208,9 +1321,13 @@ typedef void (* GLFWcursorenterfun)(GLFWwindow*,int);
  */
 typedef void (* GLFWscrollfun)(GLFWwindow*,double,double,int);
 
-/*! @brief The function signature for key callbacks.
+/*! @brief The function pointer type for key callbacks.
  *
- *  This is the function signature for key callback functions.
+ *  This is the function pointer type for key callbacks.  A keyboard
+ *  key callback function has the following signature:
+ *  @code
+ *  void function_name(GLFWwindow* window, int key, int native_key, int action, int mods)
+ *  @endcode
  *  The semantics of this function are that the key that is interacted with on the
  *  keyboard is reported, and the text, if any generated by the key is reported.
  *  So, for example, if on a US-ASCII keyboard the user presses Shift+= GLFW
@@ -1219,15 +1336,8 @@ typedef void (* GLFWscrollfun)(GLFWwindow*,double,double,int);
  *  the "s" key will generate text "o" and GLFW_KEY_O.
  *
  *  @param[in] window The window that received the event.
- *  @param[in] key The [keyboard key](@ref keys) that was pressed or released.
- *  @param[in] scancode The system-specific scancode of the key.
- *  @param[in] action `GLFW_PRESS`, `GLFW_RELEASE` or `GLFW_REPEAT`.
- *  @param[in] mods Bit field describing which [modifier keys](@ref mods) were
- *  held down.
- *  @param[in] text UTF-8 encoded text generated by this key event or empty string.
- *  @param[in] Used for Input Method events. Zero for normal key events.
- *      A value of 1 means the pre-edit text for the input event has been changed.
- *      A value of 2 means the text should be committed.
+ *  @param[in] ev The key event, see GLFWkeyevent. The data in this event is only valid for
+ *  the lifetime of the callback.
  *
  *  @note On X11/Wayland if a modifier other than the modifiers GLFW reports
  *  (ctrl/shift/alt/super) is used, GLFW will report the shifted key rather
@@ -1241,16 +1351,23 @@ typedef void (* GLFWscrollfun)(GLFWwindow*,double,double,int);
  *
  *  @ingroup input
  */
-typedef void (* GLFWkeyboardfun)(GLFWwindow*, int, int, int, int, const char*, int);
+typedef void (* GLFWkeyboardfun)(GLFWwindow*, GLFWkeyevent*);
 
-/*! @brief The function signature for file drop callbacks.
+/*! @brief The function pointer type for path drop callbacks.
  *
- *  This is the function signature for file drop callbacks.
+ *  This is the function pointer type for path drop callbacks.  A path drop
+ *  callback function has the following signature:
+ *  @code
+ *  void function_name(GLFWwindow* window, int path_count, const char* paths[])
+ *  @endcode
  *
  *  @param[in] window The window that received the event.
- *  @param[in] count The number of dropped files.
+ *  @param[in] path_count The number of dropped paths.
  *  @param[in] paths The UTF-8 encoded file and/or directory path names.
  *
+ *  @pointer_lifetime The path array and its strings are valid until the
+ *  callback function returns.
+ *
  *  @sa @ref path_drop
  *  @sa @ref glfwSetDropCallback
  *
@@ -1258,17 +1375,21 @@ typedef void (* GLFWkeyboardfun)(GLFWwindow*, int, int, int, int, const char*, i
  *
  *  @ingroup input
  */
-typedef void (* GLFWdropfun)(GLFWwindow*,int,const char**);
+typedef void (* GLFWdropfun)(GLFWwindow*,int,const char*[]);
 
 typedef void (* GLFWliveresizefun)(GLFWwindow*, bool);
 
-/*! @brief The function signature for monitor configuration callbacks.
+/*! @brief The function pointer type for monitor configuration callbacks.
  *
- *  This is the function signature for monitor configuration callback functions.
+ *  This is the function pointer type for monitor configuration callbacks.
+ *  A monitor callback function has the following signature:
+ *  @code
+ *  void function_name(GLFWmonitor* monitor, int event)
+ *  @endcode
  *
  *  @param[in] monitor The monitor that was connected or disconnected.
- *  @param[in] event One of `GLFW_CONNECTED` or `GLFW_DISCONNECTED`.  Remaining
- *  values reserved for future use.
+ *  @param[in] event One of `GLFW_CONNECTED` or `GLFW_DISCONNECTED`.  Future
+ *  releases may add more events.
  *
  *  @sa @ref monitor_event
  *  @sa @ref glfwSetMonitorCallback
@@ -1279,14 +1400,17 @@ typedef void (* GLFWliveresizefun)(GLFWwindow*, bool);
  */
 typedef void (* GLFWmonitorfun)(GLFWmonitor*,int);
 
-/*! @brief The function signature for joystick configuration callbacks.
+/*! @brief The function pointer type for joystick configuration callbacks.
  *
- *  This is the function signature for joystick configuration callback
- *  functions.
+ *  This is the function pointer type for joystick configuration callbacks.
+ *  A joystick configuration callback function has the following signature:
+ *  @code
+ *  void function_name(int jid, int event)
+ *  @endcode
  *
  *  @param[in] jid The joystick that was connected or disconnected.
- *  @param[in] event One of `GLFW_CONNECTED` or `GLFW_DISCONNECTED`.  Remaining
- *  values reserved for future use.
+ *  @param[in] event One of `GLFW_CONNECTED` or `GLFW_DISCONNECTED`.  Future
+ *  releases may add more events.
  *
  *  @sa @ref joystick_event
  *  @sa @ref glfwSetJoystickCallback
@@ -1373,6 +1497,8 @@ typedef struct GLFWgammaramp
  *
  *  @since Added in version 2.1.
  *  @glfw3 Removed format and bytes-per-pixel members.
+ *
+ *  @ingroup window
  */
 typedef struct GLFWimage
 {
@@ -1395,6 +1521,8 @@ typedef struct GLFWimage
  *  @sa @ref glfwGetGamepadState
  *
  *  @since Added in version 3.3.
+ *
+ *  @ingroup input
  */
 typedef struct GLFWgamepadstate
 {
@@ -1448,13 +1576,14 @@ typedef struct GLFWgamepadstate
 
 
 typedef int (* GLFWcocoatextinputfilterfun)(int,int,unsigned int,unsigned long);
-typedef int (* GLFWapplicationshouldhandlereopenfun)(int);
-typedef int (* GLFWcocoatogglefullscreenfun)(GLFWwindow*);
+typedef bool (* GLFWapplicationshouldhandlereopenfun)(int);
+typedef void (* GLFWapplicationwillfinishlaunchingfun)(void);
+typedef bool (* GLFWcocoatogglefullscreenfun)(GLFWwindow*);
 typedef void (* GLFWcocoarenderframefun)(GLFWwindow*);
 typedef void (*GLFWwaylandframecallbackfunc)(unsigned long long id);
 typedef void (*GLFWDBusnotificationcreatedfun)(unsigned long long, uint32_t, void*);
 typedef void (*GLFWDBusnotificationactivatedfun)(uint32_t, const char*);
-typedef int (*glfwInit_func)(void);
+typedef int (*glfwInit_func)(monotonic_t);
 glfwInit_func glfwInit_impl;
 #define glfwInit glfwInit_impl
 
@@ -1466,11 +1595,11 @@ typedef void (*glfwStopMainLoop_func)(void);
 glfwStopMainLoop_func glfwStopMainLoop_impl;
 #define glfwStopMainLoop glfwStopMainLoop_impl
 
-typedef unsigned long long (*glfwAddTimer_func)(double, bool, GLFWuserdatafun, void *, GLFWuserdatafun);
+typedef unsigned long long (*glfwAddTimer_func)(monotonic_t, bool, GLFWuserdatafun, void *, GLFWuserdatafun);
 glfwAddTimer_func glfwAddTimer_impl;
 #define glfwAddTimer glfwAddTimer_impl
 
-typedef void (*glfwUpdateTimer_func)(unsigned long long, double, bool);
+typedef void (*glfwUpdateTimer_func)(unsigned long long, monotonic_t, bool);
 glfwUpdateTimer_func glfwUpdateTimer_impl;
 #define glfwUpdateTimer glfwUpdateTimer_impl
 
@@ -1622,6 +1751,10 @@ typedef void (*glfwSetWindowAspectRatio_func)(GLFWwindow*, int, int);
 glfwSetWindowAspectRatio_func glfwSetWindowAspectRatio_impl;
 #define glfwSetWindowAspectRatio glfwSetWindowAspectRatio_impl
 
+typedef void (*glfwSetWindowSizeIncrements_func)(GLFWwindow*, int, int);
+glfwSetWindowSizeIncrements_func glfwSetWindowSizeIncrements_impl;
+#define glfwSetWindowSizeIncrements glfwSetWindowSizeIncrements_impl
+
 typedef void (*glfwSetWindowSize_func)(GLFWwindow*, int, int);
 glfwSetWindowSize_func glfwSetWindowSize_impl;
 #define glfwSetWindowSize glfwSetWindowSize_impl
@@ -1638,7 +1771,7 @@ typedef void (*glfwGetWindowContentScale_func)(GLFWwindow*, float*, float*);
 glfwGetWindowContentScale_func glfwGetWindowContentScale_impl;
 #define glfwGetWindowContentScale glfwGetWindowContentScale_impl
 
-typedef double (*glfwGetDoubleClickInterval_func)(GLFWwindow*);
+typedef monotonic_t (*glfwGetDoubleClickInterval_func)(GLFWwindow*);
 glfwGetDoubleClickInterval_func glfwGetDoubleClickInterval_impl;
 #define glfwGetDoubleClickInterval glfwGetDoubleClickInterval_impl
 
@@ -1762,9 +1895,9 @@ typedef const char* (*glfwGetKeyName_func)(int, int);
 glfwGetKeyName_func glfwGetKeyName_impl;
 #define glfwGetKeyName glfwGetKeyName_impl
 
-typedef int (*glfwGetKeyScancode_func)(int);
-glfwGetKeyScancode_func glfwGetKeyScancode_impl;
-#define glfwGetKeyScancode glfwGetKeyScancode_impl
+typedef int (*glfwGetNativeKeyForKey_func)(int);
+glfwGetNativeKeyForKey_func glfwGetNativeKeyForKey_impl;
+#define glfwGetNativeKeyForKey glfwGetNativeKeyForKey_impl
 
 typedef int (*glfwGetKey_func)(GLFWwindow*, int);
 glfwGetKey_func glfwGetKey_impl;
@@ -1890,22 +2023,10 @@ typedef const char* (*glfwGetClipboardString_func)(GLFWwindow*);
 glfwGetClipboardString_func glfwGetClipboardString_impl;
 #define glfwGetClipboardString glfwGetClipboardString_impl
 
-typedef double (*glfwGetTime_func)(void);
+typedef monotonic_t (*glfwGetTime_func)(void);
 glfwGetTime_func glfwGetTime_impl;
 #define glfwGetTime glfwGetTime_impl
 
-typedef void (*glfwSetTime_func)(double);
-glfwSetTime_func glfwSetTime_impl;
-#define glfwSetTime glfwSetTime_impl
-
-typedef uint64_t (*glfwGetTimerValue_func)(void);
-glfwGetTimerValue_func glfwGetTimerValue_impl;
-#define glfwGetTimerValue glfwGetTimerValue_impl
-
-typedef uint64_t (*glfwGetTimerFrequency_func)(void);
-glfwGetTimerFrequency_func glfwGetTimerFrequency_impl;
-#define glfwGetTimerFrequency glfwGetTimerFrequency_impl
-
 typedef void (*glfwMakeContextCurrent_func)(GLFWwindow*);
 glfwMakeContextCurrent_func glfwMakeContextCurrent_impl;
 #define glfwMakeContextCurrent glfwMakeContextCurrent_impl
@@ -1962,7 +2083,11 @@ typedef GLFWapplicationshouldhandlereopenfun (*glfwSetApplicationShouldHandleReo
 glfwSetApplicationShouldHandleReopen_func glfwSetApplicationShouldHandleReopen_impl;
 #define glfwSetApplicationShouldHandleReopen glfwSetApplicationShouldHandleReopen_impl
 
-typedef void (*glfwGetCocoaKeyEquivalent_func)(int, int, void*, void*);
+typedef GLFWapplicationwillfinishlaunchingfun (*glfwSetApplicationWillFinishLaunching_func)(GLFWapplicationwillfinishlaunchingfun);
+glfwSetApplicationWillFinishLaunching_func glfwSetApplicationWillFinishLaunching_impl;
+#define glfwSetApplicationWillFinishLaunching glfwSetApplicationWillFinishLaunching_impl
+
+typedef void (*glfwGetCocoaKeyEquivalent_func)(int, int, char*, size_t, int*);
 glfwGetCocoaKeyEquivalent_func glfwGetCocoaKeyEquivalent_impl;
 #define glfwGetCocoaKeyEquivalent glfwGetCocoaKeyEquivalent_impl
 
@@ -1986,9 +2111,9 @@ typedef const char* (*glfwGetPrimarySelectionString_func)(GLFWwindow*);
 glfwGetPrimarySelectionString_func glfwGetPrimarySelectionString_impl;
 #define glfwGetPrimarySelectionString glfwGetPrimarySelectionString_impl
 
-typedef int (*glfwGetXKBScancode_func)(const char*, int);
-glfwGetXKBScancode_func glfwGetXKBScancode_impl;
-#define glfwGetXKBScancode glfwGetXKBScancode_impl
+typedef int (*glfwGetNativeKeyForName_func)(const char*, int);
+glfwGetNativeKeyForName_func glfwGetNativeKeyForName_impl;
+#define glfwGetNativeKeyForName glfwGetNativeKeyForName_impl
 
 typedef void (*glfwRequestWaylandFrameEvent_func)(GLFWwindow*, unsigned long long, GLFWwaylandframecallbackfunc);
 glfwRequestWaylandFrameEvent_func glfwRequestWaylandFrameEvent_impl;

kitty/glfw.c

@@ -7,17 +7,19 @@
 #include "state.h"
 #include "glfw_tests.h"
 #include "fonts.h"
+#include "monotonic.h"
 #include <structmember.h>
 #include "glfw-wrapper.h"
 extern bool cocoa_make_window_resizable(void *w, bool);
 extern void cocoa_focus_window(void *w);
 extern void cocoa_create_global_menu(void);
 extern void cocoa_hide_window_title(void *w);
+extern void cocoa_hide_titlebar(void *w);
 extern void cocoa_set_activation_policy(bool);
 extern void cocoa_set_titlebar_color(void *w, color_type color);
 extern bool cocoa_alt_option_key_pressed(unsigned long);
 extern size_t cocoa_get_workspace_ids(void *w, size_t *workspace_ids, size_t array_sz);
-extern double cocoa_cursor_blink_interval(void);
+extern monotonic_t cocoa_cursor_blink_interval(void);
 
 
 #if GLFW_KEY_LAST >= MAX_KEY_COUNT
@@ -41,7 +43,10 @@ update_os_window_viewport(OSWindow *window, bool notify_boss) {
     int w, h, fw, fh;
     glfwGetFramebufferSize(window->handle, &fw, &fh);
     glfwGetWindowSize(window->handle, &w, &h);
-    if (fw == window->viewport_width && fh == window->viewport_height && w == window->window_width && h == window->window_height) {
+    double xdpi = window->logical_dpi_x, ydpi = window->logical_dpi_y;
+    set_os_window_dpi(window);
+
+    if (fw == window->viewport_width && fh == window->viewport_height && w == window->window_width && h == window->window_height && xdpi == window->logical_dpi_x && ydpi == window->logical_dpi_y) {
         return; // no change, ignore
     }
     if (w <= 0 || h <= 0 || fw / w > 5 || fh / h > 5 || fw < min_width || fh < min_height || fw < w || fh < h) {
@@ -62,8 +67,6 @@ update_os_window_viewport(OSWindow *window, bool notify_boss) {
     double xr = window->viewport_x_ratio, yr = window->viewport_y_ratio;
     window->viewport_x_ratio = w > 0 ? (double)window->viewport_width / (double)w : xr;
     window->viewport_y_ratio = h > 0 ? (double)window->viewport_height / (double)h : yr;
-    double xdpi = window->logical_dpi_x, ydpi = window->logical_dpi_y;
-    set_os_window_dpi(window);
     bool dpi_changed = (xr != 0.0 && xr != window->viewport_x_ratio) || (yr != 0.0 && yr != window->viewport_y_ratio) || (xdpi != window->logical_dpi_x) || (ydpi != window->logical_dpi_y);
 
     window->viewport_size_dirty = true;
@@ -82,7 +85,7 @@ log_event(const char *format, ...) {
     {
         va_list vl;
 
-        fprintf(stderr, "[%.4f] ", glfwGetTime());
+        fprintf(stderr, "[%.4f] ", monotonic_t_to_s_double(glfwGetTime()));
         va_start(vl, format);
         vfprintf(stderr, format, vl);
         va_end(vl);
@@ -230,14 +233,14 @@ refresh_callback(GLFWwindow *w) {
 static int mods_at_last_key_or_button_event = 0;
 
 static void
-key_callback(GLFWwindow *w, int key, int scancode, int action, int mods, const char* text, int state) {
+key_callback(GLFWwindow *w, GLFWkeyevent *ev) {
     if (!set_callback_window(w)) return;
-    mods_at_last_key_or_button_event = mods;
+    mods_at_last_key_or_button_event = ev->mods;
     global_state.callback_os_window->cursor_blink_zero_time = monotonic();
-    if (key >= 0 && key <= GLFW_KEY_LAST) {
-        global_state.callback_os_window->is_key_pressed[key] = action == GLFW_RELEASE ? false : true;
+    if (ev->key >= 0 && ev->key <= GLFW_KEY_LAST) {
+        global_state.callback_os_window->is_key_pressed[ev->key] = ev->action == GLFW_RELEASE ? false : true;
     }
-    if (is_window_ready_for_callbacks()) on_key_input(key, scancode, action, mods, text, state);
+    if (is_window_ready_for_callbacks()) on_key_input(ev);
     global_state.callback_os_window = NULL;
     request_tick_callback();
 }
@@ -247,7 +250,7 @@ cursor_enter_callback(GLFWwindow *w, int entered) {
     if (!set_callback_window(w)) return;
     if (entered) {
         show_mouse_cursor(w);
-        double now = monotonic();
+        monotonic_t now = monotonic();
         global_state.callback_os_window->last_mouse_activity_at = now;
         if (is_window_ready_for_callbacks()) enter_event();
         request_tick_callback();
@@ -260,7 +263,7 @@ mouse_button_callback(GLFWwindow *w, int button, int action, int mods) {
     if (!set_callback_window(w)) return;
     show_mouse_cursor(w);
     mods_at_last_key_or_button_event = mods;
-    double now = monotonic();
+    monotonic_t now = monotonic();
     global_state.callback_os_window->last_mouse_activity_at = now;
     if (button >= 0 && (unsigned int)button < arraysz(global_state.callback_os_window->mouse_button_pressed)) {
         global_state.callback_os_window->mouse_button_pressed[button] = action == GLFW_PRESS ? true : false;
@@ -274,7 +277,7 @@ static void
 cursor_pos_callback(GLFWwindow *w, double x, double y) {
     if (!set_callback_window(w)) return;
     show_mouse_cursor(w);
-    double now = monotonic();
+    monotonic_t now = monotonic();
     global_state.callback_os_window->last_mouse_activity_at = now;
     global_state.callback_os_window->cursor_blink_zero_time = now;
     global_state.callback_os_window->mouse_x = x * global_state.callback_os_window->viewport_x_ratio;
@@ -288,7 +291,7 @@ static void
 scroll_callback(GLFWwindow *w, double xoffset, double yoffset, int flags) {
     if (!set_callback_window(w)) return;
     show_mouse_cursor(w);
-    double now = monotonic();
+    monotonic_t now = monotonic();
     global_state.callback_os_window->last_mouse_activity_at = now;
     if (is_window_ready_for_callbacks()) scroll_event(xoffset, yoffset, flags);
     request_tick_callback();
@@ -307,7 +310,7 @@ window_focus_callback(GLFWwindow *w, int focused) {
         focus_in_event();
         global_state.callback_os_window->last_focused_counter = ++focus_counter;
     }
-    double now = monotonic();
+    monotonic_t now = monotonic();
     global_state.callback_os_window->last_mouse_activity_at = now;
     global_state.callback_os_window->cursor_blink_zero_time = now;
     if (is_window_ready_for_callbacks()) {
@@ -449,7 +452,7 @@ toggle_maximized_for_os_window(OSWindow *w) {
 
 #ifdef __APPLE__
 static int
-filter_option(int key UNUSED, int mods, unsigned int scancode UNUSED, unsigned long flags) {
+filter_option(int key UNUSED, int mods, unsigned int native_key UNUSED, unsigned long flags) {
     if ((mods == GLFW_MOD_ALT) || (mods == (GLFW_MOD_ALT | GLFW_MOD_SHIFT))) {
         if (OPT(macos_option_as_alt) == 3) return 1;
         if (cocoa_alt_option_key_pressed(flags)) return 1;
@@ -459,20 +462,19 @@ filter_option(int key UNUSED, int mods, unsigned int scancode UNUSED, unsigned l
 
 static GLFWwindow *application_quit_canary = NULL;
 
-static int
+static bool
 on_application_reopen(int has_visible_windows) {
     if (has_visible_windows) return true;
     set_cocoa_pending_action(NEW_OS_WINDOW, NULL);
-    // Without unjam wait_for_events() blocks until the next event
     return false;
 }
 
-static int
+static bool
 intercept_cocoa_fullscreen(GLFWwindow *w) {
-    if (!OPT(macos_traditional_fullscreen) || !set_callback_window(w)) return 0;
+    if (!OPT(macos_traditional_fullscreen) || !set_callback_window(w)) return false;
     toggle_fullscreen_for_os_window(global_state.callback_os_window);
     global_state.callback_os_window = NULL;
-    return 1;
+    return true;
 }
 #endif
 
@@ -512,11 +514,12 @@ create_os_window(PyObject UNUSED *self, PyObject *args) {
         // We don't use depth and stencil buffers
         glfwWindowHint(GLFW_DEPTH_BITS, 0);
         glfwWindowHint(GLFW_STENCIL_BITS, 0);
+        if (OPT(hide_window_decorations) & 1) glfwWindowHint(GLFW_DECORATED, false);
 #ifdef __APPLE__
         cocoa_set_activation_policy(OPT(macos_hide_from_tasks));
         glfwWindowHint(GLFW_COCOA_GRAPHICS_SWITCHING, true);
         glfwSetApplicationShouldHandleReopen(on_application_reopen);
-        if (OPT(hide_window_decorations)) glfwWindowHint(GLFW_DECORATED, false);
+        glfwSetApplicationWillFinishLaunching(cocoa_create_global_menu);
 #endif
 
     }
@@ -525,7 +528,6 @@ create_os_window(PyObject UNUSED *self, PyObject *args) {
     glfwWindowHintString(GLFW_X11_INSTANCE_NAME, wm_class_name);
     glfwWindowHintString(GLFW_X11_CLASS_NAME, wm_class_class);
     glfwWindowHintString(GLFW_WAYLAND_APP_ID, wm_class_class);
-    if (OPT(hide_window_decorations)) glfwWindowHint(GLFW_DECORATED, false);
 #endif
 
     if (global_state.num_os_windows >= MAX_CHILDREN) {
@@ -547,8 +549,13 @@ create_os_window(PyObject UNUSED *self, PyObject *args) {
     if (!common_context) common_context = application_quit_canary;
 #endif
 
-    GLFWwindow *temp_window = glfwCreateWindow(640, 480, "temp", NULL, common_context);
-    if (temp_window == NULL) { fatal("Failed to create GLFW temp window! This usually happens because of old/broken OpenGL drivers. kitty requires working OpenGL 3.3 drivers."); }
+    GLFWwindow *temp_window = NULL;
+    if (!global_state.is_wayland) {
+        // On Wayland windows dont get a content scale until they receive an enterEvent anyway
+        // which wont happen until the event loop ticks, so using a temp window is useless.
+        temp_window = glfwCreateWindow(640, 480, "temp", NULL, common_context);
+        if (temp_window == NULL) { fatal("Failed to create GLFW temp window! This usually happens because of old/broken OpenGL drivers. kitty requires working OpenGL 3.3 drivers."); }
+    }
     float xscale, yscale;
     double xdpi, ydpi;
     get_window_content_scale(temp_window, &xscale, &yscale, &xdpi, &ydpi);
@@ -563,8 +570,8 @@ create_os_window(PyObject UNUSED *self, PyObject *args) {
     // is no startup notification in Wayland anyway. It amazes me that anyone
     // uses Wayland as anything other than a butt for jokes.
     if (global_state.is_wayland) glfwWindowHint(GLFW_VISIBLE, true);
-    GLFWwindow *glfw_window = glfwCreateWindow(width, height, title, NULL, temp_window);
-    glfwDestroyWindow(temp_window); temp_window = NULL;
+    GLFWwindow *glfw_window = glfwCreateWindow(width, height, title, NULL, temp_window ? temp_window : common_context);
+    if (temp_window) { glfwDestroyWindow(temp_window); temp_window = NULL; }
     if (glfw_window == NULL) { PyErr_SetString(PyExc_ValueError, "Failed to create GLFWwindow"); return NULL; }
     glfwMakeContextCurrent(glfw_window);
     if (is_first_window) {
@@ -589,9 +596,6 @@ create_os_window(PyObject UNUSED *self, PyObject *args) {
         PyObject *ret = PyObject_CallFunction(load_programs, "O", is_semi_transparent ? Py_True : Py_False);
         if (ret == NULL) return NULL;
         Py_DECREF(ret);
-#ifdef __APPLE__
-        cocoa_create_global_menu();
-#endif
 #define CC(dest, shape) {\
     if (!dest##_cursor) { \
         dest##_cursor = glfwCreateStandardCursor(GLFW_##shape##_CURSOR); \
@@ -601,10 +605,10 @@ create_os_window(PyObject UNUSED *self, PyObject *args) {
 #undef CC
         if (OPT(click_interval) < 0) OPT(click_interval) = glfwGetDoubleClickInterval(glfw_window);
         if (OPT(cursor_blink_interval) < 0) {
-            OPT(cursor_blink_interval) = 0.5;
+            OPT(cursor_blink_interval) = ms_to_monotonic_t(500ll);
 #ifdef __APPLE__
-            double cbi = cocoa_cursor_blink_interval();
-            if (cbi >= 0) OPT(cursor_blink_interval) = cbi / 2000.0;
+            monotonic_t cbi = cocoa_cursor_blink_interval();
+            if (cbi >= 0) OPT(cursor_blink_interval) = cbi / 2;
 #endif
         }
         is_first_window = false;
@@ -621,6 +625,7 @@ create_os_window(PyObject UNUSED *self, PyObject *args) {
     w->fonts_data = fonts_data;
     w->shown_once = true;
     w->last_focused_counter = ++focus_counter;
+    if (OPT(resize_in_steps)) os_window_update_size_increments(w);
 #ifdef __APPLE__
     if (OPT(macos_option_as_alt)) glfwSetCocoaTextInputFilter(glfw_window, filter_option);
     glfwSetCocoaToggleFullscreenIntercept(glfw_window, intercept_cocoa_fullscreen);
@@ -648,13 +653,15 @@ create_os_window(PyObject UNUSED *self, PyObject *args) {
     glfwSetDropCallback(glfw_window, drop_callback);
 #ifdef __APPLE__
     if (glfwGetCocoaWindow) {
-        if (!(OPT(macos_show_window_title_in) & WINDOW)) {
+        if (OPT(hide_window_decorations) & 2) {
+            cocoa_hide_titlebar(glfwGetCocoaWindow(glfw_window));
+        } else if (!(OPT(macos_show_window_title_in) & WINDOW)) {
             cocoa_hide_window_title(glfwGetCocoaWindow(glfw_window));
         }
         cocoa_make_window_resizable(glfwGetCocoaWindow(glfw_window), OPT(macos_window_resizable));
     } else log_error("Failed to load glfwGetCocoaWindow");
 #endif
-    double now = monotonic();
+    monotonic_t now = monotonic();
     w->is_focused = true;
     w->cursor_blink_zero_time = now;
     w->last_mouse_activity_at = now;
@@ -669,6 +676,12 @@ create_os_window(PyObject UNUSED *self, PyObject *args) {
     return PyLong_FromUnsignedLongLong(w->id);
 }
 
+void
+os_window_update_size_increments(OSWindow *window) {
+    if (window->handle && window->fonts_data) glfwSetWindowSizeIncrements(
+            window->handle, window->fonts_data->cell_width, window->fonts_data->cell_height);
+}
+
 #ifdef __APPLE__
 static inline bool
 window_in_same_cocoa_workspace(void *w, size_t *source_workspaces, size_t source_workspace_count) {
@@ -790,7 +803,7 @@ glfw_init(PyObject UNUSED *self, PyObject *args) {
         glfwDBusSetUserNotificationHandler(dbus_user_notification_activated);
     }
 #endif
-    PyObject *ans = glfwInit() ? Py_True: Py_False;
+    PyObject *ans = glfwInit(monotonic_start_time) ? Py_True: Py_False;
     if (ans == Py_True) {
         OSWindow w = {0};
         set_os_window_dpi(&w);
@@ -814,8 +827,8 @@ get_physical_dpi(GLFWmonitor *m) {
     if (width == 0 || height == 0) { PyErr_SetString(PyExc_ValueError, "Failed to get primary monitor size"); return NULL; }
     const GLFWvidmode *vm = glfwGetVideoMode(m);
     if (vm == NULL) { PyErr_SetString(PyExc_ValueError, "Failed to get video mode for monitor"); return NULL; }
-    float dpix = vm->width / (width / 25.4);
-    float dpiy = vm->height / (height / 25.4);
+    float dpix = (float)(vm->width / (width / 25.4));
+    float dpiy = (float)(vm->height / (height / 25.4));
     return Py_BuildValue("ff", dpix, dpiy);
 }
 
@@ -828,9 +841,12 @@ glfw_get_physical_dpi(PYNOARG) {
 
 static PyObject*
 glfw_get_key_name(PyObject UNUSED *self, PyObject *args) {
-    int key, scancode;
-    if (!PyArg_ParseTuple(args, "ii", &key, &scancode)) return NULL;
-    return Py_BuildValue("s", glfwGetKeyName(key, scancode));
+    int key, native_key;
+    if (!PyArg_ParseTuple(args, "ii", &key, &native_key)) return NULL;
+    if (!glfwGetKeyName) {
+        return PyUnicode_FromFormat("key: %d native_key: %d", key, native_key);
+    }
+    return Py_BuildValue("z", glfwGetKeyName(key, native_key));
 }
 
 static PyObject*
@@ -853,9 +869,9 @@ get_clipboard_string(PYNOARG) {
 
 void
 ring_audio_bell(OSWindow *w UNUSED) {
-    static double last_bell_at = -1;
-    double now = monotonic();
-    if (now - last_bell_at <= 0.1) return;
+    static monotonic_t last_bell_at = -1;
+    monotonic_t now = monotonic();
+    if (now - last_bell_at <= ms_to_monotonic_t(100ll)) return;
     last_bell_at = now;
 #ifdef __APPLE__
     if (w->handle) {
@@ -1075,8 +1091,8 @@ set_custom_cursor(PyObject *self UNUSED, PyObject *args) {
 
 #ifdef __APPLE__
 void
-get_cocoa_key_equivalent(int key, int mods, unsigned short *cocoa_key, int *cocoa_mods) {
-    glfwGetCocoaKeyEquivalent(key, mods, cocoa_key, cocoa_mods);
+get_cocoa_key_equivalent(int key, int mods, char *cocoa_key, size_t key_sz, int *cocoa_mods) {
+    glfwGetCocoaKeyEquivalent(key, mods, cocoa_key, key_sz, cocoa_mods);
 }
 
 static void
@@ -1138,12 +1154,12 @@ dbus_send_notification(PyObject *self UNUSED, PyObject *args) {
 #endif
 
 id_type
-add_main_loop_timer(double interval, bool repeats, timer_callback_fun callback, void *callback_data, timer_callback_fun free_callback) {
+add_main_loop_timer(monotonic_t interval, bool repeats, timer_callback_fun callback, void *callback_data, timer_callback_fun free_callback) {
     return glfwAddTimer(interval, repeats, callback, callback_data, free_callback);
 }
 
 void
-update_main_loop_timer(id_type timer_id, double interval, bool enabled) {
+update_main_loop_timer(id_type timer_id, monotonic_t interval, bool enabled) {
     glfwUpdateTimer(timer_id, interval, enabled);
 }
 
@@ -1292,6 +1308,7 @@ init_glfw(PyObject *m) {
     ADDC(GLFW_KEY_LEFT_BRACKET);
     ADDC(GLFW_KEY_BACKSLASH);
     ADDC(GLFW_KEY_RIGHT_BRACKET);
+    ADDC(GLFW_KEY_CIRCUMFLEX);
     ADDC(GLFW_KEY_UNDERSCORE);
     ADDC(GLFW_KEY_GRAVE_ACCENT);
     ADDC(GLFW_KEY_WORLD_1);

kitty/glfw_tests.c

@@ -31,9 +31,9 @@ static void* empty_thread_main(void* data UNUSED)
     return 0;
 }
 
-static void key_callback(GLFWwindow *w UNUSED, int key, int scancode UNUSED, int action, int mods UNUSED, const char* text UNUSED, int state UNUSED)
+static void key_callback(GLFWwindow *w UNUSED, GLFWkeyevent *ev)
 {
-    if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS) {
+    if (ev->key == GLFW_KEY_ESCAPE && ev->action == GLFW_PRESS) {
         glfwSetWindowShouldClose(w, true);
         wakeup_main_loop();
     }

kitty/graphics.c

@@ -121,7 +121,7 @@ trim_predicate(Image *img) {
 
 static int
 oldest_last(const void* a, const void *b) {
-    double ans = ((Image*)(b))->atime - ((Image*)(a))->atime;
+    monotonic_t ans = ((Image*)(b))->atime - ((Image*)(a))->atime;
     return ans < 0 ? -1 : (ans == 0 ? 0 : 1);
 }
 
@@ -544,7 +544,9 @@ grman_update_layers(GraphicsManager *self, unsigned int scrolled_by, float scree
     if (!self->layers_dirty) return false;
     self->layers_dirty = false;
     size_t i, j;
-    self->num_of_negative_refs = 0; self->num_of_positive_refs = 0;
+    self->num_of_below_refs = 0;
+    self->num_of_negative_refs = 0;
+    self->num_of_positive_refs = 0;
     Image *img; ImageRef *ref;
     ImageRect r;
     float screen_width = dx * num_cols, screen_height = dy * num_rows;
@@ -565,7 +567,12 @@ grman_update_layers(GraphicsManager *self, unsigned int scrolled_by, float scree
         if (ref->num_cols > 0) r.right = screen_left + (ref->start_column + (int32_t)ref->num_cols) * dx;
         else r.right = r.left + screen_width * (float)ref->src_width / screen_width_px;
 
-        if (ref->z_index < 0) self->num_of_negative_refs++; else self->num_of_positive_refs++;
+        if (ref->z_index < ((int32_t)INT32_MIN/2))
+            self->num_of_below_refs++;
+        else if (ref->z_index < 0)
+            self->num_of_negative_refs++;
+        else
+            self->num_of_positive_refs++;
         ensure_space_for(self, render_data, ImageRenderData, self->count + 1, capacity, 64, true);
         ImageRenderData *rd = self->render_data + self->count;
         zero_at_ptr(rd);