version 0.14.1

Upstream commit:
0b01d850ed

.circleci/config.yml

@@ -0,0 +1,94 @@
+version: 2
+
+jobs:
+
+  lin-sys:
+    docker:
+        - image: kovidgoyal/kitty-test:latest
+    steps:
+        - checkout
+        - run: if grep -Inr '\s$' kitty kitty_tests kittens docs *.py *.asciidoc *.rst .gitattributes .gitignore; then echo Trailing whitespace found, aborting.; exit 1; fi
+        - run: python3 -m flake8 --count .
+        - run: python3 setup.py build --debug --verbose
+        - run: python3 test.py
+        - run: make FAIL_WARN=-W man
+        - run: make FAIL_WARN=-W html
+        - run: python3 setup.py linux-package
+
+  lin-35:
+    docker:
+        - image: kovidgoyal/kitty-test:latest
+    environment:
+        CC: gcc
+        CFLAGS: -funsigned-char
+        LD_LIBRARY_PATH: /opt/py3.5/lib
+        ASAN_OPTIONS: leak_check_at_exit=0
+    steps:
+        - checkout
+        - run: /opt/py3.5/bin/python3 setup.py build --debug --verbose --sanitize
+        - run: ./asan-launcher test.py
+
+  lin-37:
+    docker:
+        - image: kovidgoyal/kitty-test:latest
+    environment:
+        CC: clang
+        LD_LIBRARY_PATH: /opt/py3.7/lib
+        ASAN_OPTIONS: leak_check_at_exit=0
+    steps:
+        - checkout
+        - run: /opt/py3.7/bin/python3 setup.py build --debug --verbose --sanitize
+        - run: ./asan-launcher test.py
+
+  lin-bundle:
+    docker:
+        - image: kovidgoyal/kitty-test:latest
+    environment:
+        ASAN_OPTIONS: leak_check_at_exit=0
+    steps:
+        - checkout
+        - run: echo "export LD_LIBRARY_PATH=$SW/lib" >> $BASH_ENV
+        - run: echo "export PKG_CONFIG_PATH=$SW/lib/pkgconfig" >> $BASH_ENV
+        - run: $SW/bin/python3 setup.py build --debug --verbose
+        - run: $SW/bin/python3 test.py
+
+  mac-bundle:
+      macos:
+          xcode: "10.1.0"
+      environment:
+          LC_ALL: en_US.UTF-8
+          LANG: en_US.UTF-8
+          SW: /Users/Shared/buildbot/sw/sw
+      steps:
+          - checkout
+          - run: mkdir -p $SW
+          - run: curl https://download.calibre-ebook.com/travis/kitty/osx.tar.xz | tar xJ -C $SW
+          - run: echo "export PATH=$SW/bin:$PATH" >> $BASH_ENV
+          - run: python3 setup.py build --debug --verbose
+          - run: python3 test.py
+
+  mac-brew:
+      macos:
+          xcode: "10.1.0"
+      environment:
+          LC_ALL: en_US.UTF-8
+          LANG: en_US.UTF-8
+      steps:
+          - checkout
+          - run: brew bundle
+          - run: python3 logo/make.py
+          - run: python3 setup.py build --debug --verbose
+          - run: python3 test.py
+          - run: python3 setup.py macos-bundle
+
+
+workflows:
+    version: 2
+    all_jobs:
+        jobs:
+            - mac-bundle
+            - lin-sys
+            - lin-35
+            - lin-37
+            - lin-bundle
+            - mac-brew

.circleci/images/Dockerfile

@@ -0,0 +1,55 @@
+# When changing this file, go to
+# https://cloud.docker.com/repository/docker/kovidgoyal/kitty-test/builds and
+# click the "Trigger" button under Automated builds to rebuild 
+FROM ubuntu:latest
+
+# make Apt non-interactive
+ENV DEBIAN_FRONTEND=noninteractive
+RUN echo 'APT::Get::Assume-Yes "true";' > /etc/apt/apt.conf.d/90circleci \
+  && echo 'DPkg::Options "--force-confnew";' >> /etc/apt/apt.conf.d/90circleci \
+  && echo 'Acquire::Languages "none";' >> /etc/apt/apt.conf.d/90circleci 
+
+# System setup
+RUN apt-get update && mkdir -p /usr/share/man/man1 && apt-get install -y python3-flake8 python3-pip python3-pil clang git apt locales sudo openssh-client ca-certificates tar gzip parallel net-tools netcat unzip zip bzip2 gnupg curl wget build-essential apt-utils
+
+# Setup circleci user
+RUN groupadd --gid 3434 circleci \
+  && useradd --uid 3434 --gid circleci --shell /bin/bash --create-home circleci \
+  && echo 'circleci ALL=NOPASSWD: ALL' >> /etc/sudoers.d/50-circleci \
+  && echo 'Defaults    env_keep += "DEBIAN_FRONTEND"' >> /etc/sudoers.d/env_keep \
+  && echo 'Defaults    env_keep += "SW"' >> /etc/sudoers.d/env_keep \
+  && echo 'Defaults    env_keep += "LANG"' >> /etc/sudoers.d/env_keep
+
+# Set timezone to UTC by default
+RUN ln -sf /usr/share/zoneinfo/Etc/UTC /etc/localtime
+
+# Use unicode
+RUN locale-gen en_US.UTF-8 || true
+ENV LANG=en_US.UTF-8
+
+# Deps needed for building python
+RUN apt-get install -y libreadline-dev zlib1g-dev libssl-dev libbz2-dev libsqlite3-dev libffi-dev
+
+# kitty deps
+RUN apt-get install -y libgl1-mesa-dev libxi-dev libxrandr-dev libxinerama-dev libxcursor-dev libxcb-xkb-dev libdbus-1-dev libxkbcommon-dev libharfbuzz-dev libpng-dev libfontconfig-dev libpython3-dev libxkbcommon-x11-dev python3-pygments
+
+# Needed to build kitty docs
+RUN pip3 install sphinx
+
+# Install multiple pythons
+ADD install-python.py /tmp/install-python.py
+RUN python3 /tmp/install-python.py py3.5 https://www.python.org/ftp/python/3.5.6/Python-3.5.6.tar.xz
+RUN python3 /tmp/install-python.py py3.7 https://www.python.org/ftp/python/3.7.2/Python-3.7.2.tar.xz
+
+# Install kitty bundle
+ENV SW=/home/circleci/sw
+RUN python3 /tmp/install-python.py bundle https://download.calibre-ebook.com/travis/kitty/linux-64.tar.xz
+RUN echo SW=$SW >> /etc/environment
+
+# Clean unused files
+RUN apt-get clean -y
+
+USER circleci
+
+LABEL com.circleci.preserve-entrypoint=true
+ENTRYPOINT sleep 2h

.circleci/images/install-python.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+# vim:fileencoding=utf-8
+# License: GPLv3 Copyright: 2019, Kovid Goyal <kovid at kovidgoyal.net>
+
+import io
+import os
+import shlex
+import shutil
+import subprocess
+import sys
+import tarfile
+from urllib.request import urlopen
+
+PY, URL = sys.argv[1], sys.argv[2]
+if PY == 'bundle':
+    SW = os.environ['SW']
+    os.mkdir(SW)
+    os.chdir(SW)
+else:
+    os.chdir('/usr/src')
+
+
+def run(cmd):
+    cmd = shlex.split(cmd)
+    p = subprocess.Popen(cmd)
+    if p.wait() != 0:
+        raise SystemExit(p.returncode)
+
+
+with urlopen(URL) as f:
+    data = f.read()
+
+with tarfile.open(fileobj=io.BytesIO(data), mode='r:xz') as tf:
+    tf.extractall()
+
+
+def replace_in_file(path, src, dest):
+    with open(path, 'r+') as f:
+        n = f.read().replace(src, dest)
+        f.seek(0), f.truncate()
+        f.write(n)
+
+
+if PY == 'bundle':
+    replaced = 0
+    for dirpath, dirnames, filenames in os.walk(SW):
+        for f in filenames:
+            if f.endswith('.pc') or (f.endswith('.py') and f.startswith('_sysconfig')):
+                replace_in_file(os.path.join(dirpath, f), '/sw/sw', SW)
+                replaced += 1
+    if replaced < 2:
+        raise SystemExit('Failed to replace path to SW in bundle')
+else:
+    src = os.path.abspath(tuple(os.listdir('.'))[0])
+    os.chdir(src)
+    run(f'./configure --prefix=/opt/{PY} --enable-shared --with-system-expat --without-ensurepip')
+    run(f'make -j {os.cpu_count()}')
+    run('make install')
+    os.chdir('/')
+    shutil.rmtree(src)

.gitignore

@@ -9,6 +9,7 @@ logo/*.iconset
 compile_commands.json
 glad/out
 asan-launcher
+asan-launcher.dSYM
 kitty-profile
 dev
 __pycache__

.travis.yml

@@ -1,170 +0,0 @@
-git:
-    depth: false
-matrix:
-    fast_finish: true
-    include:
-        - os: linux
-          dist: trusty
-          group: beta
-          language: python
-          sudo: false
-          env: USE_BUNDLE=1 SW=$HOME/sw PKG_CONFIG_PATH=$SW/lib/pkgconfig LD_LIBRARY_PATH=$SW/lib PYTHON=$SW/bin/python3
-          addons:
-            apt:
-              packages:
-                - libxi-dev
-                - libxrandr-dev
-                - libxinerama-dev
-                - libxcursor-dev
-                - libxcb-xkb-dev
-                - libdbus-1-dev
-
-        - os: linux
-          dist: trusty
-          group: beta
-          sudo: false
-          env:
-            - CC=gcc CFLAGS=-funsigned-char SANITIZE_ARG=--sanitize
-          language: python
-          python: "3.5"
-          addons:
-            apt:
-              packages:
-                - libfontconfig1-dev
-                - libharfbuzz-dev
-                - libxi-dev
-                - libxrandr-dev
-                - libxinerama-dev
-                - libxcursor-dev
-                - libxcb-xkb-dev
-                - libpng-dev
-                - libdbus-1-dev
-                - python3-pil
-
-        - os: linux
-          dist: trusty
-          group: beta
-          sudo: false
-          env:
-            - CC=clang SANITIZE_ARG=--sanitize
-          language: python
-          python: "3.5"
-          addons:
-            apt:
-              packages:
-                - libfontconfig1-dev
-                - libharfbuzz-dev
-                - libxi-dev
-                - libxrandr-dev
-                - libxinerama-dev
-                - libxcursor-dev
-                - libxcb-xkb-dev
-                - libpng-dev
-                - libdbus-1-dev
-                - python3-pil
-
-        - os: linux
-          dist: trusty
-          group: beta
-          sudo: false
-          env:
-            - RUN_FLAKE=1 BUILD_PKG=linux-package
-          language: python
-          python: "3.6"
-          addons:
-            apt:
-              packages:
-                - libfontconfig1-dev
-                - libharfbuzz-dev
-                - libxi-dev
-                - libxrandr-dev
-                - libxinerama-dev
-                - libxcursor-dev
-                - libxcb-xkb-dev
-                - libpng-dev
-                - libdbus-1-dev
-                - python3-pil
-                - clang
-        - os: osx
-          language: generic
-          env: SWBASE=/Users/Shared/buildbot/sw SW=$SWBASE/sw PATH=$SW/bin:$PATH
-
-        - os: osx
-          language: generic
-          env: USE_BREW=1 BUILD_PKG=osx-bundle
-
-env:
-    global:
-        - PYTHON=python3
-        - PKG_CONFIG_PATH=$HOME/harfbuzz/lib/pkgconfig:$PKG_CONFIG_PATH
-        - LD_LIBRARY_PATH=$HOME/harfbuzz/lib:$LD_LIBRARY_PATH
-        - ASAN_OPTIONS=leak_check_at_exit=0
-
-install: |
-    set -e
-    if [[ "$RUN_FLAKE" == "1" ]]; then pip install flake8; fi
-    if [[ "$TRAVIS_OS_NAME" == 'osx' ]]; then
-        if [[ "$USE_BREW" == "1" ]]; then
-            brew update;
-            brew upgrade python;
-            brew install harfbuzz --without-graphite2 --without-icu4c --without-freetype;
-            brew install imagemagick
-            brew install optipng
-            brew install librsvg
-            logo/make.py
-        else
-            mkdir -p $SW;
-            curl https://download.calibre-ebook.com/travis/kitty/osx.tar.xz | tar xJ -C $SW;
-        fi
-    else
-        if [[ "$USE_BUNDLE" == "1" ]]; then
-            mkdir -p $SW;
-            curl https://download.calibre-ebook.com/travis/kitty/linux-64.tar.xz | tar xJ -C $SW;
-            find $SW -type f -name '*.pc' -exec sed -i "s,/sw/sw,$SW,g" {} \;;
-            find $SW -type f -name '_sysconfig*.py' -exec sed -i "s,/sw/sw,$SW,g" {} \;;
-        else
-            pushd /tmp
-            wget --no-check-certificate http://xkbcommon.org/download/libxkbcommon-0.6.1.tar.xz
-            tar xf libxkbcommon-0.6.1.tar.xz
-            cd libxkbcommon-0.6.1
-            ./configure --prefix=$HOME/harfbuzz --disable-dependency-tracking --disable-static
-            make -j2
-            make install
-            wget https://github.com/behdad/harfbuzz/releases/download/1.6.3/harfbuzz-1.6.3.tar.bz2
-            tar xf harfbuzz-1.6.3.tar.bz2
-            cd harfbuzz-1.6.3
-            ./configure --prefix=$HOME/harfbuzz --disable-dependency-tracking --disable-static --with-glib=no --with-gobject=no --with-cairo=no --with-fontconfig=no --with-icu=no --with-directwrite=no --with-freetype=yes
-            make -j2
-            make install
-            cd ..
-            popd
-        fi
-        if [[ "$BUILD_PKG" == "linux-package" ]]; then
-            pip install sphinx
-        fi
-    fi
-    pkg-config --cflags harfbuzz
-    if [[ "$TRAVIS_OS_NAME" != 'osx' ]]; then
-        PLIB=$(ldd `which python` | grep libpython | cut -d ' ' -f 3)
-        export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:`dirname $PLIB`
-    fi
-    set +e
-
-before_script:
-    - echo LD_LIBRARY_PATH=$LD_LIBRARY_PATH PKG_CONFIG_PATH=$PKG_CONFIG_PATH
-    - $PYTHON setup.py build --debug --verbose $SANITIZE_ARG;
-
-script: |
-    set -e
-
-    if grep -Inr '\s$' kitty kitty_tests kittens docs *.py *.asciidoc *.rst .gitattributes .gitignore; then echo Trailing whitespace found, aborting.; exit 1; fi
-
-    if [[ -z "$SANITIZE_ARG" ]]; then $PYTHON test.py; else ./asan-launcher test.py; fi
-
-    if [[ "$RUN_FLAKE" == "1" ]]; then flake8 --count .; fi
-
-    if [[ "$BUILD_PKG" == "linux-package" ]]; then make FAIL_WARN=-W man && make FAIL_WARN=-W html; fi
-
-    if [[ ! -z "$BUILD_PKG" ]]; then $PYTHON setup.py $BUILD_PKG; fi
-
-    set +e

Brewfile

@@ -0,0 +1,6 @@
+brew 'pkg-config'
+brew 'imagemagick'
+brew 'optipng'
+brew 'librsvg'
+brew 'harfbuzz'
+brew 'python'

LICENSE

@@ -1,7 +1,7 @@
                     GNU GENERAL PUBLIC LICENSE
                        Version 3, 29 June 2007
 
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 
@@ -645,7 +645,7 @@ the "copyright" line and a pointer to where the full notice is found.
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 Also add information on how to contact you by electronic and paper mail.
 
@@ -664,11 +664,11 @@ might be different; for a GUI interface, you would use an "about box".
   You should also get your employer (if you work as a programmer) or school,
 if any, to sign a "copyright disclaimer" for the program, if necessary.
 For more information on this, and how to apply and follow the GNU GPL, see
-<http://www.gnu.org/licenses/>.
+<https://www.gnu.org/licenses/>.
 
   The GNU General Public License does not permit incorporating your program
 into proprietary programs.  If your program is a subroutine library, you
 may consider it more useful to permit linking proprietary applications with
 the library.  If this is what you want to do, use the GNU Lesser General
 Public License instead of this License.  But first, please read
-<http://www.gnu.org/philosophy/why-not-lgpl.html>.
+<https://www.gnu.org/philosophy/why-not-lgpl.html>.

Makefile

@@ -18,6 +18,9 @@ clean:
 debug:
 	python3 setup.py build $(VVAL) --debug
 
+debug-event-loop:
+	python3 setup.py build $(VVAL) --debug --extra-logging=event-loop
+
 # Build with the ASAN and UBSAN sanitizers
 asan:
 	python3 setup.py build $(VVAL) --debug --sanitize

README.asciidoc

@@ -2,4 +2,4 @@
 
 See https://sw.kovidgoyal.net/kitty
 
-image::https://travis-ci.org/kovidgoyal/kitty.svg?branch=master[Build status, link=https://travis-ci.org/kovidgoyal/kitty]
+image:https://circleci.com/gh/kovidgoyal/kitty.svg?style=svg["Build status", link="https://circleci.com/gh/kovidgoyal/kitty"]

__main__.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # vim:fileencoding=utf-8
 # License: GPL v3 Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
 
@@ -88,7 +88,7 @@ def setup_openssl_environment():
     # Workaround for Linux distros that have still failed to get their heads
     # out of their asses and implement a common location for SSL certificates.
     # It's not that hard people, there exists a wonderful tool called the symlink
-    # See http://www.mobileread.com/forums/showthread.php?t=256095
+    # See https://www.mobileread.com/forums/showthread.php?t=256095
     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'

asan-launcher.c

@@ -1,5 +1,5 @@
 /*
- * linux-launcher.c
+ * asan-launcher.c
  * Copyright (C) 2017 Kovid Goyal <kovid at kovidgoyal.net>
  *
  * Distributed under terms of the GPL3 license.

build-terminfo

@@ -1,24 +1,48 @@
 #!/usr/bin/env python3
+# vim:fileencoding=utf-8
+# License: GPL v3 Copyright: 2019, Kovid Goyal <kovid at kovidgoyal.net>
 
+import glob
 import os
-import sys
+import re
 import shutil
 import subprocess
+import sys
+import tempfile
 
-base = os.path.dirname(os.path.abspath(__file__))
-os.chdir(base)
-sys.path.insert(0, base)
 
-from kitty.terminfo import generate_terminfo  # noqa
+def compile_terminfo(base):
+    with tempfile.TemporaryDirectory() as tdir:
+        proc = subprocess.run(['tic', '-x', '-o' + tdir, 'terminfo/kitty.terminfo'], check=True, stderr=subprocess.PIPE)
+        regex = '^"terminfo/kitty.terminfo", line [0-9]+, col [0-9]+, terminal \'xterm-kitty\': older tic versions may treat the description field as an alias$'
+        for error in proc.stderr.decode('utf-8').splitlines():
+            if not re.match(regex, error):
+                print(error, file=sys.stderr)
+        tfiles = glob.glob(os.path.join(tdir, '*', 'xterm-kitty'))
+        if not tfiles:
+            raise SystemExit('tic failed to output the compiled kitty terminfo file')
 
-with open('terminfo/kitty.terminfo', 'w') as f:
-    f.write(generate_terminfo())
+        tfile = tfiles[0]
+        directory, xterm_kitty = os.path.split(tfile)
+        _, directory = os.path.split(directory)
+        odir = os.path.join(base, directory)
+        os.makedirs(odir, exist_ok=True)
+        ofile = os.path.join(odir, xterm_kitty)
+        shutil.move(tfile, ofile)
 
-os.environ['TERMINFO'] = os.path.join(base, 'terminfo')
-subprocess.check_call(['tic', '-x', 'terminfo/kitty.terminfo'])
-# On OS X tic puts the compiled database into a different directory
-try:
-    os.mkdir('terminfo/78')
-except FileExistsError:
-    pass
-shutil.copy2('terminfo/x/xterm-kitty', 'terminfo/78')
+
+def generate_terminfo():
+    base = os.path.dirname(os.path.abspath(__file__))
+    os.chdir(base)
+    sys.path.insert(0, base)
+
+    from kitty.terminfo import generate_terminfo
+
+    with open('terminfo/kitty.terminfo', 'w') as f:
+        f.write(generate_terminfo())
+
+    compile_terminfo(os.path.join(base, 'terminfo'))
+
+
+if __name__ == '__main__':
+    generate_terminfo()

docs/Makefile

@@ -2,8 +2,8 @@
 #
 
 # You can set these variables from the command line.
-SPHINXOPTS    = -T $(FAIL_WARN)
-SPHINXBUILD   = python3 .. +launch :sphinx-build
+SPHINXOPTS    = -j auto -T $(FAIL_WARN)
+SPHINXBUILD   = sphinx-build
 SPHINXPROJ    = kitty
 SOURCEDIR     = .
 BUILDDIR      = _build

docs/_templates/layout.html

@@ -1,13 +1,6 @@
 {% extends "!layout.html" %}
 
 {%- block extrahead %}
-<!-- Google Analytics -->
-<script>
-window.ga=window.ga||function(){(ga.q=ga.q||[]).push(arguments)};ga.l=+new Date;
-ga('create', 'UA-20736318-2', 'auto');
-ga('send', 'pageview');
-</script>
-<script async="async" src='https://www.google-analytics.com/analytics.js'></script>
-<!-- End Google Analytics -->
+<!-- kitty analytics placeholder -->
   {{ super() }}
 {% endblock %}

docs/build.rst

@@ -1,9 +1,9 @@
 Building kitty from source
 ==============================
 
-.. image:: https://travis-ci.org/kovidgoyal/kitty.svg?branch=master
+.. image:: https://circleci.com/gh/kovidgoyal/kitty.svg?style=svg
   :alt: Build status
-  :target: https://travis-ci.org/kovidgoyal/kitty
+  :target: https://circleci.com/gh/kovidgoyal/kitty
 
 
 |kitty| is designed to run from source, for easy hackability. Make sure
@@ -28,7 +28,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`` and ``libxkbcommon-x11-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
@@ -107,7 +107,7 @@ without needing to install all of |kitty|.
         development package of :file:`ncurses`. Also, if you are building from
         a git checkout instead of the released source code tarball, you will
         need :file:`sphinx-build` from the `Sphinx documentation generator
-        <http://www.sphinx-doc.org/>`_.
+        <https://www.sphinx-doc.org/>`_.
 
 This applies to creating packages for |kitty| for macOS package managers such as
 brew or MacPorts as well.

docs/changelog.rst

@@ -2,6 +2,367 @@ Changelog
 ==============
 
 |kitty| is a feature full, cross-platform, *fast*, GPU based terminal emulator.
+To update |kitty|, :doc:`follow the instructions <binary>`.
+
+0.14.1 [2019-05-29]
+---------------------
+
+- Add an option :opt:`command_on_bell` to run an arbitrary command when
+  a bell occurs (:iss:`1660`)
+
+- Add a shortcut to toggle maximized window state :sc:`toggle_maximized`
+
+- Add support for the underscore key found in some keyboard layouts
+  (:iss:`1639`)
+
+- Fix a missing newline when using the pipe command between the
+  scrollback and screen contents (:iss:`1642`)
+
+- Fix colors not being preserved when using the pipe command with
+  the pager history buffer (:pull:`1657`)
+
+- macOS: Fix a regression that could cause rendering of a kitty window
+  to occasionally freeze in certain situations, such as moving it between
+  monitors or transitioning from/to fullscreen (:iss:`1641`)
+
+- macOS: Fix a regression that caused :kbd:`cmd+v` to double up in the dvorak
+  keyboard layout (:iss:`1652`)
+
+- When resizing and only a single window is present in the current layout,
+  use that window's background color to fill in the blank areas.
+
+- Linux: Automatically increase cell height if the font being used is broken
+  and draws the underscore outside the bounding box (:iss:`690`)
+
+- Wayland: Fix maximizing the window on a compositor that does not provide
+  server side window decorations, such a GNOME or Weston not working
+  (:iss:`1662`)
+
+
+0.14.0 [2019-05-24]
+---------------------
+
+- macOS: The default behavior of the Option key has changed. It now generates
+  unicode characters rather than acting as the :kbd:`Alt` modifier. See
+  :opt:`macos_option_as_alt`.
+
+- Support for an arbitrary number of internal clipboard buffers to copy/paste
+  from, see (:ref:`cpbuf`)
+
+- Allow using the new private internal clipboard buffers with the
+  :opt:`copy_on_select` option (:iss:`1390`)
+
+- macOS: Allow opening new kitty tabs/top-level windows from Finder
+  (:pull:`1350`)
+
+- Add an option :opt:`disable_ligatures` to disable
+  multi-character ligatures under the cursor to make editing easier
+  or disable them completely (:iss:`461`)
+
+- Allow creating new OS windows in session files (:iss:`1514`)
+
+- Allow setting OS window size in session files
+
+- Add an option :opt:`tab_switch_strategy` to control which
+  tab becomes active when the current tab is closed (:pull:`1524`)
+
+- Allow specifying a value of ``none`` for the :opt:`selection_foreground`
+  which will cause kitty to not change text color in selections (:iss:`1358`)
+
+- Make live resizing of OS windows smoother and add an option
+  :opt:`resize_draw_strategy` to control what is drawn while a
+  resize is in progress.
+
+- macOS: Improve handling of IME extended input. Compose characters
+  are now highlighted and the IME panel moves along with the text
+  (:pull:`1586`). Also fixes handling of delete key in Chinese IME
+  (:iss:`1461`)
+
+- When a window is closed, switch focus to the previously active window (if
+  any) instead of picking the previous window in the layout (:iss:`1450`)
+
+- icat kitten: Add support for displaying images at http(s) URLs (:iss:`1340`)
+
+- A new option :opt:`strip_trailing_spaces` to optionally remove trailing
+  spaces from lines when copying to clipboard.
+
+- A new option :opt:`tab_bar_min_tabs` to control how many tabs must be
+  present before the tab-bar is shown (:iss:`1382`)
+
+- Automatically check for new releases and notify when an update is available,
+  via the system notification facilities. Can be controlled by
+  :opt:`update_check_interval` (:iss:`1342`)
+
+- macOS: Fix :kbd:`cmd+period` key not working (:iss:`1318`)
+
+- macOS: Add an option :opt:`macos_show_window_title_in_menubar` to not
+  show the current window title in the menu-bar (:iss:`1066`)
+
+- macOS: Workaround for cocoa bug that could cause the mouse cursor to become
+  hidden in other applications in rare circumstances (:iss:`1218`)
+
+- macOS: Allow assigning only the left or right :kbd:`Option` key to work as the
+  :kbd:`Alt` key. See :opt:`macos_option_as_alt` for details (:iss:`1022`)
+
+- Fix using remote control to set cursor text color causing errors when
+  creating new windows (:iss:`1326`)
+
+- Fix window title for minimized windows not being updated (:iss:`1332`)
+
+- macOS: Fix using multi-key sequences to input text ignoring the
+  first few key presses if the sequence is aborted (:iss:`1311`)
+
+- macOS: Add a number of common macOS keyboard shortcuts
+
+- macOS: Reduce energy consumption by not rendering occluded windows
+
+- Fix scrollback pager history not being cleared when clearing the
+  main scrollback buffer (:iss:`1387`)
+
+- macOS: When closing a top-level window only switch focus to the previous kitty
+  window if it is on the same workspace (:iss:`1379`)
+
+- macOS: Fix :opt:`sync_to_monitor` not working on Mojave.
+
+- macOS: Use the system cursor blink interval by default
+  :opt:`cursor_blink_interval`.
+
+- Wayland: Use the kitty Wayland backend by default. Can be switched back
+  to using XWayland by setting the environment variable:
+  ``KITTY_DISABLE_WAYLAND=1``
+
+- Add a ``no-append`` setting to :opt:`clipboard_control` to disable
+  the kitty copy concatenation protocol extension for OSC 52.
+
+- Update to using the Unicode 12 standard
+
+- Unicode input kitten: Allow using the arrow keys in code mode to go to next
+  and previous unicode symbol.
+
+- macOS: Fix specifying initial window size in cells not working correctly on
+  Retina screens (:iss:`1444`)
+
+- Fix a regression in version 0.13.0 that caused background colors of space
+  characters after private use unicode characters to not be respected
+  (:iss:`1455`)
+
+- Only update the selected text to clipboard when the selection is finished,
+  not continuously as it is updated. (:iss:`1460`)
+
+- Allow setting :opt:`active_border_color` to ``none`` to not draw a border
+  around the active window (:iss:`805`)
+
+- Use negative values for :opt:`mouse_hide_wait` to hide the mouse cursor
+  immediately when pressing a key (:iss:`1534`)
+
+- When encountering errors in :file:`kitty.conf` report them to the user
+  instead of failing to start.
+
+- Allow the user to control the resize debounce time via
+  :opt:`resize_debounce_time`.
+
+- Remote control: Make the :ref:`at_set-font-size` command more capable.
+  It can now increment font size and reset it. It also only acts on the
+  active top-level window, by default (:iss:`1581`)
+
+- When launching child processes set the :code:`PWD` environment variable
+  (:iss:`1595`)
+
+- X11: use the window manager's native full-screen implementation when
+  making windows full-screen (:iss:`1605`)
+
+- Mouse selection: When extending by word, fix extending selection to non-word
+  characters not working well (:iss:`1616`)
+
+0.13.3 [2019-01-19]
+------------------------------
+
+- icat kitten: Add a ``--stdin`` option to control if image data is read from
+  STDIN (:iss:`1308`)
+
+- hints kitten: Start hints numbering at one instead of zero by default. Added
+  an option ``--hints-offset`` to control it. (:iss:`1289`)
+
+- Fix a regression in the previous release that broke using ``background`` for
+  :opt:`cursor_text_color` (:iss:`1288`)
+
+- macOS: Fix dragging kitty window tabs in traditional full screen mode causing
+  crashes (:iss:`1296`)
+
+- macOS: Ensure that when running from a bundle, the bundle kitty exe is
+  preferred over any kitty in PATH (:iss:`1280`)
+
+- macOS: Fix a regression that broke mapping of :kbd:`ctrl+tab` (:iss:`1304`)
+
+- Add a list of user-created kittens to the docs
+
+- Fix a regression that broke changing mouse wheel scroll direction with
+  negative :opt:`wheel_scroll_multiplier` values in full-screen applications
+  like vim (:iss:`1299`)
+
+- Fix :opt:`background_opacity` not working with pure white backgrounds
+  (:iss:`1285`)
+
+- macOS: Fix "New OS Window" dock action not working when kitty is not focused
+  (:iss:`1312`)
+
+- macOS: Add aliases for close window and new tab actions that conform to common
+  Apple shortcuts for these actions (:iss:`1313`)
+
+- macOS: Fix some kittens causing 100% CPU usage
+
+
+0.13.2 [2019-01-04]
+------------------------------
+
+- Add a new option :opt:`tab_title_template` to control how tab titles
+  are formatted. In particular the template can be used to display
+  the tab number next to the title (:iss:`1223`)
+
+- Report the current foreground processes as well as the original child process,
+  when using `kitty @ ls`
+
+- Use the current working directory of the foreground process for the
+  `*_with_cwd` actions that open a new window with the current working
+  directory.
+
+- Add a new ``copy_or_interrupt`` action that can be mapped to kbd:`ctrl+c`. It
+  will copy if there is a selection and interrupt otherwise (:iss:`1286`)
+
+- Fix setting :opt:`background_opacity` causing window margins/padding to be slightly
+  different shade from background (:iss:`1221`)
+
+- Handle keyboards with a "+" key (:iss:`1224`)
+
+- Fix Private use Unicode area characters followed by spaces at the end of text
+  not being rendered correctly (:iss:`1210`)
+
+- macOS: Add an entry to the dock menu to open a new OS window (:iss:`1242`)
+
+- macOS: Fix scrolling very slowly with wheel mice not working (:iss:`1238`)
+
+- Fix changing :opt:`cursor_text_color` via remote control not working
+  (:iss:`1229`)
+
+- Add an action to resize windows that can be mapped to shortcuts in :file:`kitty.conf`
+  (:pull:`1245`)
+
+- Fix using the ``new_tab !neighbor`` action changing the order of the
+  non-neighboring tabs (:iss:`1256`)
+
+- macOS: Fix momentum scrolling continuing when changing the active window/tab
+  (:iss:`1267`)
+
+
+0.13.1 [2018-12-06]
+------------------------------
+
+- Fix passing input via the pipe action to a program without a window not
+  working.
+
+- Linux: Fix a regression in the previous release that caused automatic
+  selection of bold/italic fonts when using aliases such as "monospace" to not
+  work (:iss:`1209`)
+
+- Fix resizing window smaller and then restoring causing some wrapped lines to not
+  be properly unwrapped (:iss:`1206`)
+
+0.13.0 [2018-12-05]
+------------------------------
+
+- Add an option :opt:`scrollback_pager_history_size` to tell kitty to store
+  extended scrollback to use when viewing the scrollback buffer in a pager
+  (:iss:`970`)
+
+- Modify the kittens sub-system to allow creating custom kittens without any
+  user interface. This is useful for creating more complex actions that can
+  be bound to key presses in :file:`kitty.conf`. See
+  doc:`kittens/custom`. (:iss:`870`)
+
+- Add a new ``nth_window`` action that can be used to go to the nth window and
+  also previously active windows, using negative numbers. Similarly,
+  ``goto_tab`` now accepts negative numbers to go to previously active tabs
+  (:iss:`1040`)
+
+- Allow hiding the tab bar completely, by setting :opt:`tab_bar_style` to
+  ``hidden``. (:iss:`1014`)
+
+- Allow private use unicode characters to stretch over more than a single
+  neighboring space (:pull:`1036`)
+
+- Add a new :opt:`touch_scroll_multiplier` option to modify the amount
+  scrolled by high precision scrolling devices such as touchpads (:pull:`1129`)
+
+- icat kitten: Implement reading image data from STDIN, if STDIN is not
+  connected to a terminal (:iss:`1130`)
+
+- hints kitten: Insert trailing spaces after matches when using the
+  ``--multiple`` option. Also add a separate ``--add-trailing-space``
+  option to control this behavior (:pull:`1132`)
+
+- Fix the ``*_with_cwd`` actions using the cwd of the overlay window rather
+  than the underlying window's cwd (:iss:`1045`)
+
+- Fix incorrect key repeat rate on wayland (:pull:`1055`)
+
+- macOS: Fix drag and drop of files not working on Mojave (:iss:`1058`)
+
+- macOS: Fix IME input for East Asian languages (:iss:`910`)
+
+- macOS: Fix rendering frames-per-second very low when processing
+  large amounts of input in small chunks (:pull:`1082`)
+
+- macOS: Fix incorrect text sizes calculated when using an external display
+  that is set to mirror the main display (:iss:`1056`)
+
+- macOS: Use the system default double click interval (:pull:`1090`)
+
+- macOS: Fix touch scrolling sensitivity low on retina screens (:iss:`1112`)
+
+- Linux: Fix incorrect rendering of some fonts when hinting is disabled at
+  small sizes (:iss:`1173`)
+
+- Linux: Fix match rules used as aliases in Fontconfig configuration not being
+  respected (:iss:`1085`)
+
+- Linux: Fix a crash when using the GNU Unifont as a fallback font
+  (:iss:`1087`)
+
+- Wayland: Fix copying from hidden kitty windows hanging (:iss:`1051`)
+
+- Wayland: Add support for the primary selection protocol
+  implemented by some compositors (:pull:`1095`)
+
+- Fix expansion of env vars not working in the :opt:`env` directive
+  (:iss:`1075`)
+
+- Fix :opt:`mouse_hide_wait` only taking effect after an event such as cursor
+  blink or key press (:iss:`1073`)
+
+- Fix the ``set_background_opacity`` action not working correctly
+  (:pull:`1147`)
+
+- Fix second cell of emoji created using variation selectors not having
+  the same attributes as the first cell (:iss:`1109`)
+
+- Fix focusing neighboring windows in the grid layout with less than 4 windows
+  not working (:iss:`1115`)
+
+- Fix :kbd:`ctrl+shift+special` key not working in normal and application keyboard
+  modes (:iss:`1114`)
+
+- Add a terminfo entry for full keyboard mode.
+
+- Fix incorrect text-antialiasing when using very low background opacity
+  (:iss:`1005`)
+
+- When double or triple clicking ignore clicks if they are "far" from each
+  other (:iss:`1093`)
+
+- Follow xterm's behavior for the menu key (:iss:`597`)
+
+- Fix hover detection of URLs not working when hovering over the first colon
+  and slash characters in short URLs (:iss:`1201`)
 
 0.12.3 [2018-09-29]
 ------------------------------
@@ -142,6 +503,9 @@ Changelog
 - Add an option :opt:`env` to set environment variables in child processes
   from kitty.conf
 
+- Add an action to the ``clear_terminal`` function to scroll the screen
+  contents into the scrollback buffer (:iss:`1113`)
+
 - Implement high precision scrolling with the trackpad on platforms such as
   macOS and Wayland that implement it. (:pull:`819`)
 
@@ -351,7 +715,7 @@ Changelog
 
 - Add a config option (:opt:`editor`) to set the EDITOR kitty uses (:iss:`580`)
 
-- Add a config option (:opt:`x11_hide_window_decorations`) to hide window
+- Add a config option (``x11_hide_window_decorations``) to hide window
   decorations under X11/Wayland (:iss:`607`)
 
 - Add an option to @set-window-title to make the title change non-permanent

docs/conf.py

@@ -1,15 +1,18 @@
+#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 #
 # Configuration file for the Sphinx documentation builder.
 #
 # This file does only contain a selection of the most common options. For a
 # full list see the documentation:
-# http://www.sphinx-doc.org/en/master/config
+# https://www.sphinx-doc.org/en/master/config
 
+import importlib
 import os
 import re
 import subprocess
 import sys
+import time
 from functools import partial
 
 from docutils import nodes
@@ -19,15 +22,19 @@ from pygments.token import (
     Comment, Keyword, Literal, Name, Number, String, Whitespace
 )
 from sphinx import addnodes
+from sphinx.environment.adapters.toctree import TocTree
 from sphinx.util.logging import getLogger
 
-from kitty.constants import str_version
+kitty_src = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if kitty_src not in sys.path:
+    sys.path.insert(0, kitty_src)
+str_version = importlib.import_module('kitty.constants').str_version
 
 # config {{{
 # -- Project information -----------------------------------------------------
 
 project = 'kitty'
-copyright = '2018, Kovid Goyal'
+copyright = time.strftime('%Y, Kovid Goyal')
 author = 'Kovid Goyal'
 building_man_pages = 'man' in sys.argv
 
@@ -175,7 +182,7 @@ texinfo_documents = [
 # }}}
 
 
-# GitHub linking inlne roles {{{
+# GitHub linking inline roles {{{
 
 def num_role(which, name, rawtext, text, lineno, inliner, options={}, content=[]):
     ' Link to a github issue '
@@ -214,7 +221,8 @@ def commit_role(name, rawtext, text, lineno, inliner, options={}, content=[]):
 
 # Sidebar ToC {{{
 def create_toc(app, pagename):
-    toctree = app.env.get_toc_for(pagename, app.builder)
+    tt = TocTree(app.env)
+    toctree = tt.get_toc_for(pagename, app.builder)
     if toctree is not None:
         subtree = toctree[toctree.first_child_matching_class(nodes.list_item)]
         bl = subtree.first_child_matching_class(nodes.bullet_list)

docs/conf.rst

@@ -20,6 +20,10 @@ You can also display the current configuration by running ``kitty
 :option:`kitty --config` option or use the ``KITTY_CONFIG_DIRECTORY``
 environment variable. See the :option:`kitty --config` option for full details.
 
+Comments can be added to the config file as lines starting with the ``#``
+character. This works only if the ``#`` character is the first character
+in the line.
+
 You can include secondary config files via the :code:`include` directive.  If
 you use a relative path for include, it is resolved with respect to the
 location of the current config file. Note that environment variables are

docs/faq.rst

@@ -6,7 +6,7 @@ Frequently Asked Questions
 .. contents::
 
 Some special symbols are rendered small/truncated in kitty?
------------------------------------------------------------------
+-----------------------------------------------------------
 
 The number of cells a unicode character takes up are controlled by the unicode
 standard.  All characters are rendered in a single cell unless the unicode
@@ -48,25 +48,61 @@ terminfo files to the server::
     kitty +kitten ssh myserver
 
 If for some reason that does not work (typically because the server is using a
-a non POSIX compliant shell), you can use the following one-liner instead (it
+non POSIX compliant shell), you can use the following one-liner instead (it
 is slower as it needs to ssh into the server twice, but will work with most
 servers)::
 
     infocmp xterm-kitty | ssh myserver tic -x -o \~/.terminfo /dev/stdin
 
+If you are behind a proxy (like Balabit) that prevents this, you must redirect the
+1st command to a file, copy that to the server and run ``tic`` manually.  If you
+connect to a server, embedded or Android system that doesn't have ``tic``, copy over
+your local file terminfo to the other system as :file:`~/.terminfo/x/xterm-kitty`.
+
 Really, the correct solution for this is to convince the OpenSSH maintainers to
-have ssh do this automatically when connecting to a server, so that all
-terminals work transparently.
+have ssh do this automatically, if possible, when connecting to a server, so that
+all terminals work transparently.
+
+
+Keys such as arrow keys, backspace, delete, home/end, etc. do not work when using su or sudo?
+-------------------------------------------------------------------------------------------------
+
+Make sure the TERM environment variable, is ``xterm-kitty``.  And either the
+TERMINFO environment variable points to a directory containing :file:`x/xterm-kitty`
+or that file is under :file:`~/.terminfo/x/`.
+
+Note that ``sudo`` might remove TERMINFO.  Then setting it at the shell prompt can
+be too late, because command line editing may not be reinitialized.  In that case
+you can either ask ``sudo`` to set it or if that is not supported, insert an ``env``
+command before starting the shell, or, if not possible, after sudo start another
+Shell providing the right terminfo path::
+
+    sudo … TERMINFO=$HOME/.terminfo bash -i
+    sudo … env TERMINFO=$HOME/.terminfo bash -i
+    TERMINFO=/home/ORIGINALUSER/.terminfo exec bash -i
+
+You can configure sudo to preserve TERMINFO by running ``sudo
+visudo`` and adding the following line::
+
+    Defaults env_keep += "TERM TERMINFO"
+
+If you have double width characters in your prompt, you may also need to
+explicitly set a UTF-8 locale, like::
+
+    export LANG=en_US.UTF-8 LC_ALL=en_US.UTF-8
 
 
 How do I change the colors in a running kitty instance?
 ------------------------------------------------------------
 
 You can either use the
-`OSC terminal escape codes <http://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-Operating-System-Commands>`_
+`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`.
 
+A list of pre-made color themes for kitty is available at:
+`kitty-themes <https://github.com/dexpota/kitty-themes>`_
+
 
 How do I specify command line options for kitty on macOS?
 ---------------------------------------------------------------

docs/graphics-protocol.rst

@@ -75,6 +75,47 @@ You can also use the *CSI t* escape code to get the screen size. Send
 ``<ESC>[4;<height>;<width>t`` where *height* and *width* are the window size in
 pixels. This escape code is supported in many terminals, not just kitty.
 
+A minimal example
+------------------
+
+Some minimal python code to display PNG images in kitty, using the most basic
+features of the graphics protocol:
+
+.. code-block:: python
+
+   import sys
+   from base64 import standard_b64encode
+
+   def serialize_gr_command(cmd, payload=None):
+      cmd = ','.join('{}={}'.format(k, v) for k, v in cmd.items())
+      ans = []
+      w = ans.append
+      w(b'\033_G'), w(cmd.encode('ascii'))
+      if payload:
+         w(b';')
+         w(payload)
+      w(b'\033\\')
+      return b''.join(ans)
+
+   def write_chunked(cmd, data):
+      data = standard_b64encode(data)
+      while data:
+         chunk, data = data[:4096], data[4096:]
+         m = 1 if data else 0
+         cmd['m'] = m
+         sys.stdout.buffer.write(serialize_gr_command(cmd, chunk))
+         sys.stdout.flush()
+         cmd.clear()
+
+   write_chunked({'a': 'T', 'f': 100}, open(sys.argv[-1], 'rb').read())
+
+
+Save this script as :file:`png.py`, then you can use it to display any PNG
+file in kitty as::
+
+   python png.py file.png
+
+
 The graphics escape code
 ---------------------------
 
@@ -160,7 +201,11 @@ Value of `t`          Meaning
 ==================    ============
 ``d``                 Direct (the data is transmitted within the escape code itself)
 ``f``                 A simple file
-``t``                 A temporary file, the terminal emulator will delete the file after reading the pixel data
+``t``                 A temporary file, the terminal emulator will delete the file after reading the pixel data. For security reasons
+                      the terminal emulator should only delete the file if it
+                      is in a known temporary directory, such as :file:`/tmp`,
+                      :file:`/dev/shm`, :file:`TMPDIR env var if present` and any platform
+                      specific temporary directories.
 ``s``                 A `POSIX shared memory object <http://man7.org/linux/man-pages/man7/shm_overview.7.html>`_.
                       The terminal emulator will delete it after reading the pixel data
 ==================    ============

docs/index.rst

@@ -36,6 +36,8 @@ kitty - the fast, featureful, GPU based terminal emulator
       separate window using arbitrary programs of your choice. This is useful for
       browsing the history comfortably in a pager or editor.
 
+    * Has :ref:`multiple copy/paste buffers <cpbuf>`, like vim.
+
 
 .. figure:: screenshots/screenshot.png
     :alt: Screenshot, showing three programs in the 'Tall' layout
@@ -54,15 +56,18 @@ Pre-built binaries of |kitty| are available for both macOS and Linux.
 See the :doc:`binary install instructions </binary>`. You can also
 :doc:`build from source </build>`.
 
-If you are on Linux, you can also use your distribution's |kitty| package.
+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>`_,
+`Ubuntu <https://launchpad.net/ubuntu/+source/kitty>`_,
 `Debian <https://packages.debian.org/buster/kitty>`_,
 `openSUSE <https://build.opensuse.org/package/show/X11:terminals/kitty>`_,
 `Arch Linux <https://www.archlinux.org/packages/community/x86_64/kitty/>`_,
-`NixOS <https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/misc/kitty/default.nix>`_,
 `Gentoo <https://packages.gentoo.org/packages/x11-terms/kitty>`_,
 `Fedora <https://copr.fedorainfracloud.org/coprs/gagbo/kitty-latest/>`_,
-`Void Linux <https://github.com/void-linux/void-packages/blob/master/srcpkgs/kitty/template>`_.
+`Void Linux <https://github.com/void-linux/void-packages/blob/master/srcpkgs/kitty/template>`_,
+and `Solus <https://dev.getsol.us/source/kitty/>`_.
 
 See :doc:`Configuring kitty <conf>` for help on configuring |kitty| and
 :doc:`Invocation <invocation>` for the command line arguments |kitty| supports.
@@ -90,7 +95,7 @@ formatting, etc. It even extends existing text formatting escape codes,
 to add support for features not available elsewhere, such as colored and
 styled (curly) underlines. One of the design goals of |kitty| is to be
 easily extensible so that new features can be added in the future with
-relatively less effort.
+relatively little effort.
 
 Tabs and Windows
 -------------------
@@ -108,12 +113,12 @@ Scrolling
 ========================    =======================
 Action                      Shortcut
 ========================    =======================
-Scroll line up              :sc:`scroll_line_up`
-Scroll line down            :sc:`scroll_line_down`
-Scroll page up              :sc:`scroll_page_up`
-Scroll page down            :sc:`scroll_page_down`
-Scroll to top               :sc:`scroll_home`
-Scroll to bottom            :sc:`scroll_end`
+Scroll line up              :sc:`scroll_line_up` (also :kbd:`⌥+⌘+⇞` and :kbd:`⌘+↑` on macOS)
+Scroll line down            :sc:`scroll_line_down` (also :kbd:`⌥+⌘+⇟` and :kbd:`⌘+↓` on macOS)
+Scroll page up              :sc:`scroll_page_up` (also :kbd:`⌘+⇞` on macOS)
+Scroll page down            :sc:`scroll_page_down` (also :kbd:`⌘+⇟` on macOS)
+Scroll to top               :sc:`scroll_home` (also :kbd:`⌘+↖` on macOS)
+Scroll to bottom            :sc:`scroll_end` (also :kbd:`⌘+↘` on macOS)
 ========================    =======================
 
 Tabs
@@ -122,14 +127,14 @@ Tabs
 ========================    =======================
 Action                      Shortcut
 ========================    =======================
-New tab                     :sc:`new_tab`
-Close tab                   :sc:`close_tab`
-Next tab                    :sc:`next_tab` (also :kbd:`control+tab` on macOS)
-Previous tab                :sc:`previous_tab` (also :kbd:`control+shift+tab` on macOS)
+New tab                     :sc:`new_tab` (also :kbd:`⌘+t` on macOS)
+Close tab                   :sc:`close_tab` (also :kbd:`⌘+w` on macOS)
+Next tab                    :sc:`next_tab` (also :kbd:`^+⇥` and :kbd:`⇧+⌘+]` on macOS)
+Previous tab                :sc:`previous_tab` (also :kbd:`⇧+^+⇥` and :kbd:`⇧+⌘+[` on macOS)
 Next layout                 :sc:`next_layout`
 Move tab forward            :sc:`move_tab_forward`
 Move tab backward           :sc:`move_tab_backward`
-Set tab title               :sc:`set_tab_title`
+Set tab title               :sc:`set_tab_title` (also :kbd:`⇧+⌘+i` on macOS)
 ========================    =======================
 
 
@@ -139,15 +144,16 @@ Windows
 ========================    =======================
 Action                      Shortcut
 ========================    =======================
-New window                  :sc:`new_window`
+New window                  :sc:`new_window` (also :kbd:`⌘+↩` on macOS)
 New OS window               :sc:`new_os_window` (also :kbd:`⌘+n` on macOS)
-Close window                :sc:`close_window`
+Close window                :sc:`close_window` (also :kbd:`⇧+⌘+d` on macOS)
 Next window                 :sc:`next_window`
 Previous window             :sc:`previous_window`
 Move window forward         :sc:`move_window_forward`
 Move window backward        :sc:`move_window_backward`
 Move window to top          :sc:`move_window_to_top`
 Focus specific window       :sc:`first_window`, :sc:`second_window` ... :sc:`tenth_window`
+                            (also :kbd:`⌘+1`, :kbd:`⌘+2` ... :kbd:`⌘+9` on macOS)
                             (clockwise from the top-left)
 ========================    =======================
 
@@ -160,6 +166,13 @@ windows and move windows around (similar to window movement in vim)::
    map shift+down move_window up
    ...
 
+You can also define a shortcut to switch to the previously active window::
+
+   map ctrl+p nth_window -1
+
+``nth_window`` will focus the nth window for positive numbers and the
+previously active windows for negative numbers.
+
 
 Other keyboard shortcuts
 ----------------------------------
@@ -170,11 +183,11 @@ Action                              Shortcut
 Copy to clipboard                   :sc:`copy_to_clipboard` (also :kbd:`⌘+c` on macOS)
 Paste from clipboard                :sc:`paste_from_clipboard` (also :kbd:`⌘+v` on macOS)
 Paste from selection                :sc:`paste_from_selection`
-Increase font size                  :sc:`increase_font_size`
-Decrease font size                  :sc:`decrease_font_size`
-Restore font size                   :sc:`reset_font_size`
-Toggle fullscreen                   :sc:`toggle_fullscreen` (also :kbd:`^⌘+f` on macOS)
-on
+Increase font size                  :sc:`increase_font_size` (also :kbd:`⌘++` on macOS)
+Decrease font size                  :sc:`decrease_font_size` (also :kbd:`⌘+-` on macOS)
+Restore font size                   :sc:`reset_font_size` (also :kbd:`⌘+0` on macOS)
+Toggle fullscreen                   :sc:`toggle_fullscreen` (also :kbd:`^+⌘+f` on macOS)
+Toggle maximized                    :sc:`toggle_maximized`
 Input unicode character             :sc:`input_unicode_character`
 Click URL using the keyboard        :sc:`open_url`
 Reset the terminal                  :sc:`reset_terminal`
@@ -209,13 +222,26 @@ You can switch between layouts using the :sc:`next_layout` key combination. You
 also create shortcuts to select particular layouts, and choose which layouts
 you want to enable/disable, see :ref:`conf-kitty-shortcuts.layout` for examples.
 
-You can resize windows inside layouts. Press :sc:`start_resizing_window` to
+You can resize windows inside layouts. Press :sc:`start_resizing_window` (also :kbd:`⌘+r` on macOS) to
 enter resizing mode and follow the on-screen instructions.  In a given window
 layout only some operations may be possible for a particular window. For
 example, in the Tall layout you can make the first window wider/narrower, but
 not taller/shorter. Note that what you are resizing is actually not a window,
 but a row/column in the layout, all windows in that row/column will be resized.
 
+You can also define shortcuts in :file:`kitty.conf` to make the active window
+wider, narrower, taller, or shorter by mapping to the ``resize_window``
+action, for example::
+
+   map ctrl+left resize_window narrower
+   map ctrl+right resize_window wider
+   map ctrl+up resize_window taller
+   map ctrl+down resize_window shorter 3
+
+The ``resize_window`` action has a second, optional argument to control
+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::
@@ -320,6 +346,12 @@ For example:
     # Set the current layout
     layout stack
     launch zsh
+
+    # Create a new OS window
+    new_os_window
+    # set new window size to 80x25 cells
+    os_window_size 80c 25c
+    launch sh
     # Make the current window the active (focused) window
     focus
     launch emacs
@@ -328,11 +360,14 @@ For example:
 Mouse features
 -------------------
 
-* You can also hold down :kbd:`ctrl+shift` and click on a URL to open it in a browser.
-* You can double click to select a word and triple click to select a line.
-* You can right click to extend a previous selection
+* You can hold down :kbd:`ctrl+shift` and click on a URL to open it in a browser.
+* You can double click to select a word and then drag to select more words.
+* You can triple click to select a line and then drag to select more lines.
+* You can right click to extend a previous selection.
 * You can hold down :kbd:`ctrl+alt` and drag with the mouse to select in
-  columns
+  columns.
+* Selecting text automatically copies it to the primary clipboard (on
+  platforms with a primary clipboard).
 
 
 Font control
@@ -370,6 +405,26 @@ arbitrary, command running in a new window, tab or overlay, for example::
 Would open the scrollback buffer in a new window when you press the :kbd:`F1`
 key. See :sc:`show_scrollback` for details.
 
+If you wish to store very large amounts of scrollback to view using the piping or
+:sc:`show_scrollback` features, you can use the :opt:`scrollback_pager_history_size`
+option.
+
+.. _cpbuf:
+
+Multiple copy/paste buffers
+-----------------------------
+
+In addition to being able to copy/paste from the system clipboard, in |kitty| you
+can also setup an arbitrary number of copy paste buffers. To do so, simply add
+something like the following to your :file:`kitty.conf`::
+
+   map f1 copy_to_buffer a
+   map f2 paste_from_buffer a
+
+This will allow you to press :kbd:`F1` to copy the current selection to an
+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.
 
 Frequently Asked Questions
 ---------------------------------

docs/installer.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # vim:fileencoding=utf-8
 # License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
 
@@ -72,7 +72,10 @@ class Reporter:  # {{{
 def get_latest_release_data():
     print('Checking for latest release on GitHub...')
     req = urllib.Request('https://api.github.com/repos/kovidgoyal/kitty/releases/latest', headers={'Accept': 'application/vnd.github.v3+json'})
-    res = urllib.urlopen(req).read().decode('utf-8')
+    try:
+        res = urllib.urlopen(req).read().decode('utf-8')
+    except Exception as err:
+        raise SystemExit('Failed to contact {} with error: {}'.format(req.get_full_url(), err))
     data = json.loads(res)
     html_url = data['html_url'].replace('/tag/', '/download/').rstrip('/')
     for asset in data.get('assets', ()):

docs/kittens/custom.rst

@@ -43,6 +43,8 @@ Now in :file:`kitty.conf` add the lines::
 Start kitty and press :kbd:`ctrl+k` and you should see the kitten running.
 The best way to develop your own kittens is to modify one of the built in
 kittens. Look in the kittens sub-directory of the kitty source code for those.
+Or see below for a list of :ref:`third-party kittens <external_kittens>`,
+that other kitty users have created.
 
 
 Passing arguments to kittens
@@ -68,7 +70,14 @@ function, telling kitty what kind of input your kitten would like. For example:
 
 .. code-block:: py
 
-   def handle_result(...):
+   # in main, STDIN is for the kitten process and will contain
+   # the contents of the screen
+   def main(args):
+      return sys.stdin.read()
+
+   # in handle_result, STDIN is for the kitty process itself, rather
+   # than the kitten process and should not be read from.
+   def handle_result(args, stdin_data, target_window_id, boss):
       pass
 
    handle_result.type_of_input = 'text'
@@ -78,3 +87,60 @@ This will send the plain text of the active window to the kitten's
 instead. If you want line wrap markers as well, use ``screen-ansi``
 or just ``screen``. For the scrollback buffer as well, use
 ``history``, ``ansi-history`` or ``screen-history``.
+
+
+Using kittens to script kitty, without any terminal UI
+-----------------------------------------------------------
+
+If you would like your kitten to script kitty, without bothering to write a
+terminal program, you can tell the kittens system to run the
+``handle_result()`` function without first running the ``main()`` function.
+
+For example, here is a kitten that "zooms/unzooms" the current terminal window
+by switching to the stack layout or back to the previous layout.
+
+Create a file in the kitty config folder, :file:`~/.config/kitty/zoom_toggle.py`
+
+.. code-block:: py
+
+   def main(args):
+      pass
+
+   def handle_result(args, answer, target_window_id, boss):
+      tab = boss.active_tab
+      if tab is not None:
+         if tab.current_layout.name == 'stack':
+            tab.last_used_layout()
+         else:
+            tab.goto_layout('stack')
+
+   handle_result.no_ui = True
+
+
+Now in kitty.conf add::
+
+   map f11 kitten zoom_toggle.py
+
+Pressing :kbd:`F11` will now act as a zoom toggle function. You can get even
+more fancy, switching the kitty OS window to fullscreen as well as changing the
+layout, by simply adding the line::
+
+    boss.toggle_fullscreen()
+
+
+to the ``handle_result()`` function, above.
+
+.. _external_kittens:
+
+Kittens created by kitty users
+---------------------------------------------
+
+`vim-kitty-navigator <https://github.com/knubie/vim-kitty-navigator>`_
+   Allows you to navigate seamlessly between vim and kitty splits using a consistent set of hotkeys.
+
+`smart-scroll <https://github.com/yurikhan/kitty-smart-scroll>`_
+   Makes the kitty scroll bindings work in full screen applications
+
+`insert password <https://github.com/kovidgoyal/kitty/issues/1222>`_
+   Insert a password from a CLI password manager, taking care to only do it at
+   a password prompt.

docs/kittens/unicode-input.rst

@@ -15,6 +15,8 @@ In :guilabel:`Code` mode, you enter a unicode character by typing in the hex cod
 character and pressing enter, for example, type in ``2716`` and press enter to get
 ✖. You can also choose a character from the list of recently used characters by
 typing a leading period and then the two character index and pressing Enter.
+The up and down arrow keys can be used to choose the previous and next unicode
+symbol respectively.
 
 In :guilabel:`Name` mode you instead type words from the character name and use the arrow
 keys/tab to select the character from the displayed matches. You can also type

docs/pipe.rst

@@ -0,0 +1,88 @@
+Working with the screen and history buffer contents
+======================================================
+
+
+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
+can be displayed in a kitty window or overlay.
+
+For example, the following in :file:`kitty.conf` will open the scrollback
+buffer in less in an overlay window, when you press :kbd:`F1`::
+
+    map f1 pipe @ansi overlay less +G -R
+
+The syntax of the ``pipe`` function is::
+
+   pipe <input placeholder> <destination window type> <command line to run>
+
+
+The piping environment
+--------------------------
+
+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.
+
+You can choose where to run the pipe program:
+
+``overlay``
+   An overlay window over the current kitty window
+
+``window``
+   A new kitty window
+
+``os_window``
+   A new top-level window
+
+``tab``
+   A new window in a new tab
+
+``none``
+   Run it in the background
+
+
+Input placeholders
+--------------------
+
+There are various different kinds of placeholders
+
+``@text``
+   Plain text, current screen + scrollback buffer
+
+``@ansi``
+   Text with formatting, current screen + scrollback buffer
+
+``@screen``
+   Plain text, only current screen
+
+``@ansi_screen``
+   Text with formatting, only current screen
+
+``@alternate``
+   Plain text, secondary screen. The secondary screen is the screen not currently displayed. For
+   example if you run a fullscreen terminal application, the secondary screen will
+   be the screen you return to when quitting the application.
+
+``@ansi_alternate``
+   Text with formatting, secondary screen.
+
+``@alternate_scrollback``
+   Plain text, secondary screen + scrollback, if any.
+
+``@ansi_alternate_scrollback``
+   Text with formatting, secondary screen + scrollback, if any.
+
+``none``
+   No input
+
+
+You can also add the suffix ``_wrap`` to the placeholder, in which case kitty
+will insert the carriage return at every line wrap location (where long lines
+are wrapped at screen edges). This is useful if you want to pipe to program
+that wants to duplicate the screen layout of the screen.

docs/protocol-extensions.rst

@@ -6,7 +6,7 @@ These are typically in the form of new or re-purposed escape codes. While these
 extensions are currently |kitty| specific, it would be nice to get some of them
 adopted more broadly, to push the state of terminal emulators forward.
 
-The goal of these extensions is to be as small an unobtrusive as possible,
+The goal of these extensions is to be as small and unobtrusive as possible,
 while filling in some gaps in the existing xterm protocol. In particular, one
 of the goals of this specification is explicitly not to "re-imagine" the tty.
 The tty should remain what it is -- a device for efficiently processing text
@@ -51,6 +51,9 @@ To reset the underline color (also previously reserved and unused)::
 
     <ESC>[59m
 
+The underline color must remain the same under reverse video, if it has a
+color, if not, it should follow the foreground color.
+
 To detect support for this feature in a terminal emulator, query the terminfo database
 for the ``Su`` boolean capability.
 
@@ -133,6 +136,10 @@ Alt -- ``0x2``, Control -- ``0x4`` and Super -- ``0x8``.  ``<key>`` is a number
 (encoded in base85) corresponding to the key pressed. The key name to number
 mapping is defined in :doc:`this table <key-encoding>`.
 
+Client programs must ignore events for keys they do not know. The mapping in
+the above table is stable and will never change, however, new codes might be
+added to it in the future, for new keys.
+
 For example::
 
     <ESC>_KpGp<ESC>\  is  <Ctrl>+<Alt>+x (press)
@@ -141,6 +148,12 @@ For example::
 This encoding means each key event is represented by 8 or 9 printable ascii
 only bytes, for maximum robustness.
 
+To see the full mode in action, run::
+
+   kitty +kitten key_demo
+
+Support for this mode is indicated by the ``fullkbd`` boolean capability
+in the terminfo database, in case querying for it via DECQRM is inconvenient.
 
 .. _ext_styles:
 
@@ -158,7 +171,7 @@ The motivation for this extension is the various problems with the existing
 solution for erasing to background color, namely the *background color erase
 (bce)* capability. See
 `this discussion <https://github.com/kovidgoyal/kitty/issues/160#issuecomment-346470545>`_
-and `this FAQ <http://invisible-island.net/ncurses/ncurses.faq.html#bce_mismatches>`_
+and `this FAQ <https://invisible-island.net/ncurses/ncurses.faq.html#bce_mismatches>`_
 for a summary of problems with *bce*.
 
 For example, to set the background color to blue in a
@@ -206,3 +219,7 @@ first, for example::
     <ESC>]52;c;!<ESC>\
 
 Here ``!`` is not valid base64 encoded text, so it clears the clipboard.
+
+In case you're using software that can't be easily adapted to this
+protocol extension, it can be disabled by specifying ``no-append`` to the
+:opt:`clipboard_control` setting.

gen-apc-parsers.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # vim:fileencoding=utf-8
 # License: GPLv3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
 

gen-wcwidth.py

@@ -3,6 +3,7 @@
 # License: GPL v3 Copyright: 2017, Kovid Goyal <kovid at kovidgoyal.net>
 
 import os
+import re
 import sys
 from collections import defaultdict
 from contextlib import contextmanager
@@ -87,6 +88,11 @@ def parse_ucd():
             if category.startswith('M'):
                 marks.add(codepoint)
 
+    # Some common synonyms
+    word_search_map['bee'] |= word_search_map['honeybee']
+    word_search_map['lambda'] |= word_search_map['lamda']
+    word_search_map['lamda'] |= word_search_map['lambda']
+
 
 def split_two(line):
     spec, rest = line.split(';', 1)
@@ -276,7 +282,8 @@ def gen_ucd():
         p('combining_type mark_for_codepoint(char_type c) {')
         rmap = codepoint_to_mark_map(p, mark_map)
         p('}\n')
-        if rmap[0xfe0e] != 1281:
+        expected = int(re.search(r'^#define VS15 (\d+)', open('kitty/unicode-data.h').read(), re.M).group(1))
+        if rmap[0xfe0e] != expected:
             raise ValueError('The mark for 0xfe0e has changed, you have to update VS15 to {} and VS16 to {} in unicode-data.h'.format(
                 rmap[0xfe0e], rmap[0xfe0f]
             ))
@@ -360,16 +367,15 @@ def gen_names():
         root = TrieNode()
         all_trie_nodes.append(root)
 
-        def add_word(word_idx):
-            word = word_map[word_idx]
+        def add_word(word_idx, word):
             parent = root
             for letter in map(ord, word):
                 idx = parent.add_letter(letter)
                 parent = all_trie_nodes[idx]
             parent.match_offset = offsets_array[word_idx]
 
-        for i in range(len(word_map)):
-            add_word(i)
+        for i, word in enumerate(word_map):
+            add_word(i, word)
         children_array = [0]
         for node in all_trie_nodes:
             if node.children:

glfw/backend_utils.c

@@ -21,16 +21,16 @@
 #endif
 
 static inline double
-monotonic() {
+monotonic(void) {
     struct timespec ts = {0};
 #ifdef CLOCK_HIGHRES
-	clock_gettime(CLOCK_HIGHRES, &ts);
+    clock_gettime(CLOCK_HIGHRES, &ts);
 #elif CLOCK_MONOTONIC_RAW
-	clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
+    clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
 #else
-	clock_gettime(CLOCK_MONOTONIC, &ts);
+    clock_gettime(CLOCK_MONOTONIC, &ts);
 #endif
-	return (((double)ts.tv_nsec) / 1e9) + (double)ts.tv_sec;
+    return (((double)ts.tv_nsec) / 1e9) + (double)ts.tv_sec;
 }
 
 void
@@ -55,6 +55,7 @@ addWatch(EventLoopData *eld, const char* name, int fd, int events, int enabled,
     w->fd = fd; w->events = events; w->enabled = enabled;
     w->callback = cb;
     w->callback_data = cb_data;
+    w->free = NULL;
     w->id = ++watch_counter;
     update_fds(eld);
     return w->id;
@@ -64,6 +65,10 @@ addWatch(EventLoopData *eld, const char* name, int fd, int events, int enabled,
     for (nfds_t i = 0; i < eld->which##_count; i++) { \
         if (eld->which[i].id == item_id) { \
             eld->which##_count--; \
+            if (eld->which[i].callback_data && eld->which[i].free) { \
+                eld->which[i].free(eld->which[i].id, eld->which[i].callback_data); \
+                eld->which[i].callback_data = NULL; eld->which[i].free = NULL; \
+            } \
             if (i < eld->which##_count) { \
                 memmove(eld->which + i, eld->which + i + 1, sizeof(eld->which[0]) * (eld->which##_count - i)); \
             } \
@@ -102,7 +107,7 @@ update_timers(EventLoopData *eld) {
 }
 
 id_type
-addTimer(EventLoopData *eld, const char *name, double interval, int enabled, timer_callback_func cb, void *cb_data) {
+addTimer(EventLoopData *eld, const char *name, double 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;
@@ -111,11 +116,13 @@ addTimer(EventLoopData *eld, const char *name, double interval, int enabled, tim
     t->interval = interval;
     t->name = name;
     t->trigger_at = enabled ? monotonic() + interval : DBL_MAX;
+    t->repeats = repeats;
     t->callback = cb;
     t->callback_data = cb_data;
+    t->free = free;
     t->id = ++timer_counter;
     update_timers(eld);
-    return t->id;
+    return timer_counter;
 }
 
 void
@@ -123,6 +130,14 @@ removeTimer(EventLoopData *eld, id_type timer_id) {
     removeX(timers, timer_id, update_timers);
 }
 
+void
+removeAllTimers(EventLoopData *eld) {
+    for (nfds_t i = 0; i < eld->timers_count; i++) {
+        if (eld->timers[i].free && eld->timers[i].callback_data) eld->timers[i].free(eld->timers[i].id, eld->timers[i].callback_data);
+    }
+    eld->timers_count = 0;
+}
+
 void
 toggleTimer(EventLoopData *eld, id_type timer_id, int enabled) {
     for (nfds_t i = 0; i < eld->timers_count; i++) {
@@ -182,7 +197,7 @@ dispatchEvents(EventLoopData *eld) {
 unsigned
 dispatchTimers(EventLoopData *eld) {
     if (!eld->timers_count || eld->timers[0].trigger_at == DBL_MAX) return 0;
-    static struct { timer_callback_func func; id_type id; void* data; } dispatches[sizeof(eld->timers)/sizeof(eld->timers[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();
     for (nfds_t i = 0; i < eld->timers_count && eld->timers[i].trigger_at <= now; i++) {
@@ -190,11 +205,15 @@ dispatchTimers(EventLoopData *eld) {
         dispatches[num_dispatches].func = eld->timers[i].callback;
         dispatches[num_dispatches].id = eld->timers[i].id;
         dispatches[num_dispatches].data = eld->timers[i].callback_data;
+        dispatches[num_dispatches].repeats = eld->timers[i].repeats;
         num_dispatches++;
     }
     // we dispatch separately so that the callbacks can modify timers
     for (unsigned i = 0; i < num_dispatches; i++) {
         dispatches[i].func(dispatches[i].id, dispatches[i].data);
+        if (!dispatches[i].repeats) {
+            removeTimer(eld, dispatches[i].id);
+        }
     }
     if (num_dispatches) update_timers(eld);
     return num_dispatches;

glfw/backend_utils.h

@@ -27,15 +27,18 @@
 #pragma once
 #include <poll.h>
 #include <unistd.h>
+#include <stdbool.h>
 
 typedef unsigned long long id_type;
 typedef void(*watch_callback_func)(int, int, void*);
 typedef void(*timer_callback_func)(id_type, void*);
+typedef void (* GLFWuserdatafreefun)(id_type, void*);
 
 typedef struct {
     int fd, events, enabled, ready;
     watch_callback_func callback;
     void *callback_data;
+    GLFWuserdatafreefun free;
     id_type id;
     const char *name;
 } Watch;
@@ -45,7 +48,9 @@ typedef struct {
     double interval, trigger_at;
     timer_callback_func callback;
     void *callback_data;
+    GLFWuserdatafreefun free;
     const char *name;
+    bool repeats;
 } Timer;
 
 
@@ -61,8 +66,9 @@ typedef struct {
 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, timer_callback_func cb, void *cb_data);
+id_type addTimer(EventLoopData *eld, const char *name, double 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);

glfw/cocoa_init.m

@@ -27,7 +27,6 @@
 #include "internal.h"
 #include <sys/param.h> // For MAXPATHLEN
 
-
 // Change to our application bundle's resources directory, if present
 //
 static void changeToResourcesDirectory(void)
@@ -274,33 +273,110 @@ static GLFWbool initializeTIS(void)
     return updateUnicodeDataNS();
 }
 
-@interface GLFWLayoutListener : NSObject
+@interface GLFWHelper : NSObject
 @end
 
-@implementation GLFWLayoutListener
+@implementation GLFWHelper
 
 - (void)selectedKeyboardInputSourceChanged:(NSObject* )object
 {
     updateUnicodeDataNS();
 }
 
+- (void)doNothing:(id)object
+{
+}
+
+@end  // GLFWHelper
+
+@interface GLFWApplication : NSApplication
+- (void)tick_callback;
+- (void)render_frame_received:(id)displayIDAsID;
 @end
 
+@implementation GLFWApplication
+- (void)tick_callback
+{
+    _glfwDispatchTickCallback();
+}
+
+- (void)render_frame_received:(id)displayIDAsID
+{
+    CGDirectDisplayID displayID = [(NSNumber*)displayIDAsID unsignedIntValue];
+    _glfwDispatchRenderFrame(displayID);
+}
+@end
 
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW platform API                      //////
 //////////////////////////////////////////////////////////////////////////
 
+static inline bool
+is_ctrl_tab(NSEvent *event, NSEventModifierFlags modifierFlags) {
+    if (modifierFlags == NSEventModifierFlagControl || modifierFlags == (
+                NSEventModifierFlagControl | NSEventModifierFlagShift)) {
+        if ([event.charactersIgnoringModifiers isEqualToString:@"\t"]) return true;
+    }
+    return false;
+}
+
+static inline bool
+is_cmd_period(NSEvent *event, NSEventModifierFlags modifierFlags) {
+    if (modifierFlags != NSEventModifierFlagCommand) return false;
+    if ([event.charactersIgnoringModifiers isEqualToString:@"."]) return true;
+    return false;
+}
+
 int _glfwPlatformInit(void)
 {
-    _glfw.ns.autoreleasePool = [[NSAutoreleasePool alloc] init];
+    @autoreleasepool {
+    _glfw.ns.helper = [[GLFWHelper alloc] init];
 
+    [NSThread detachNewThreadSelector:@selector(doNothing:)
+                             toTarget:_glfw.ns.helper
+                           withObject:nil];
+
+    [GLFWApplication sharedApplication];
+
+    NSEvent* (^keydown_block)(NSEvent*) = ^ NSEvent* (NSEvent* event)
+    {
+        NSEventModifierFlags modifierFlags = [event modifierFlags] & NSEventModifierFlagDeviceIndependentFlagsMask;
+        if (is_ctrl_tab(event, modifierFlags) || is_cmd_period(event, modifierFlags)) {
+            // Cocoa swallows Ctrl+Tab to cycle between views
+            [[NSApp keyWindow].contentView keyDown:event];
+        }
+
+        return event;
+    };
+
+    NSEvent* (^keyup_block)(NSEvent*) = ^ NSEvent* (NSEvent* event)
+    {
+        NSEventModifierFlags modifierFlags = [event modifierFlags] & NSEventModifierFlagDeviceIndependentFlagsMask;
+        if (modifierFlags & NSEventModifierFlagCommand) {
+            // From http://cocoadev.com/index.pl?GameKeyboardHandlingAlmost
+            // This works around an AppKit bug, where key up events while holding
+            // down the command key don't get sent to the key window.
+            [[NSApp keyWindow] sendEvent:event];
+        }
+        if (is_ctrl_tab(event, modifierFlags) || is_cmd_period(event, modifierFlags)) {
+            // Cocoa swallows Ctrl+Tab to cycle between views
+            [[NSApp keyWindow].contentView keyUp:event];
+        }
+
+        return event;
+    };
+
+    _glfw.ns.keyUpMonitor =
+        [NSEvent addLocalMonitorForEventsMatchingMask:NSEventMaskKeyUp
+                                              handler:keyup_block];
+    _glfw.ns.keyDownMonitor =
+        [NSEvent addLocalMonitorForEventsMatchingMask:NSEventMaskKeyDown
+                                              handler:keydown_block];
     if (_glfw.hints.init.ns.chdir)
         changeToResourcesDirectory();
 
-    _glfw.ns.listener = [[GLFWLayoutListener alloc] init];
     [[NSNotificationCenter defaultCenter]
-        addObserver:_glfw.ns.listener
+        addObserver:_glfw.ns.helper
            selector:@selector(selectedKeyboardInputSourceChanged:)
                name:NSTextInputContextKeyboardSelectionDidChangeNotification
              object:nil];
@@ -316,15 +392,25 @@ int _glfwPlatformInit(void)
     if (!initializeTIS())
         return GLFW_FALSE;
 
+    _glfw.ns.displayLinks.lock = [NSLock new];
     _glfwInitTimerNS();
     _glfwInitJoysticksNS();
 
     _glfwPollMonitorsNS();
+    }
     return GLFW_TRUE;
 }
 
 void _glfwPlatformTerminate(void)
 {
+    @autoreleasepool {
+
+    if (_glfw.ns.displayLinks.lock) {
+        _glfwClearDisplayLinks();
+        [_glfw.ns.displayLinks.lock release];
+        _glfw.ns.displayLinks.lock = nil;
+    }
+
     if (_glfw.ns.inputSource)
     {
         CFRelease(_glfw.ns.inputSource);
@@ -345,32 +431,142 @@ void _glfwPlatformTerminate(void)
         _glfw.ns.delegate = nil;
     }
 
-    if (_glfw.ns.listener)
+    if (_glfw.ns.helper)
     {
         [[NSNotificationCenter defaultCenter]
-            removeObserver:_glfw.ns.listener
+            removeObserver:_glfw.ns.helper
                       name:NSTextInputContextKeyboardSelectionDidChangeNotification
                     object:nil];
         [[NSNotificationCenter defaultCenter]
-            removeObserver:_glfw.ns.listener];
-        [_glfw.ns.listener release];
-        _glfw.ns.listener = nil;
+            removeObserver:_glfw.ns.helper];
+        [_glfw.ns.helper release];
+        _glfw.ns.helper = nil;
     }
+    if (_glfw.ns.keyUpMonitor)
+        [NSEvent removeMonitor:_glfw.ns.keyUpMonitor];
+    if (_glfw.ns.keyDownMonitor)
+        [NSEvent removeMonitor:_glfw.ns.keyDownMonitor];
 
     free(_glfw.ns.clipboardString);
 
     _glfwTerminateNSGL();
     _glfwTerminateJoysticksNS();
-
-    [_glfw.ns.autoreleasePool release];
-    _glfw.ns.autoreleasePool = nil;
+    }
 }
 
 const char* _glfwPlatformGetVersionString(void)
 {
-    return _GLFW_VERSION_NUMBER " Cocoa NSGL"
+    return _GLFW_VERSION_NUMBER " Cocoa NSGL EGL OSMesa"
 #if defined(_GLFW_BUILD_DLL)
         " dynamic"
 #endif
         ;
 }
+
+static GLFWtickcallback tick_callback = NULL;
+static void* tick_callback_data = NULL;
+static bool tick_callback_requested = false;
+
+
+void _glfwDispatchTickCallback() {
+    if (tick_callback) {
+        tick_callback_requested = false;
+        tick_callback(tick_callback_data);
+    }
+}
+
+void _glfwPlatformRequestTickCallback() {
+    if (!tick_callback_requested) {
+        tick_callback_requested = true;
+        [NSApp performSelectorOnMainThread:@selector(tick_callback) withObject:nil waitUntilDone:NO];
+    }
+}
+
+void _glfwPlatformStopMainLoop(void) {
+    tick_callback = NULL;
+    [NSApp stop:nil];
+    _glfwPlatformPostEmptyEvent();
+}
+
+void _glfwPlatformRunMainLoop(GLFWtickcallback callback, void* data) {
+    tick_callback = callback;
+    tick_callback_data = data;
+    [NSApp run];
+}
+
+
+typedef struct {
+    NSTimer *os_timer;
+    unsigned long long id;
+    bool repeats;
+    double interval;
+    GLFWuserdatafun callback;
+    void *callback_data;
+    GLFWuserdatafun free_callback_data;
+} Timer;
+
+static Timer timers[128] = {{0}};
+static size_t num_timers = 0;
+
+static inline void
+remove_timer_at(size_t idx) {
+    if (idx < num_timers) {
+        Timer *t = timers + idx;
+        if (t->os_timer) { [t->os_timer invalidate]; t->os_timer = NULL; }
+        if (t->callback_data && t->free_callback_data) { t->free_callback_data(t->id, t->callback_data); t->callback_data = NULL; }
+        num_timers--;
+        if (idx < num_timers) {
+            memmove(timers + idx, timers + idx + 1, sizeof(timers[0]) * (num_timers - idx));
+        }
+    }
+}
+
+static void schedule_timer(Timer *t) {
+    t->os_timer = [NSTimer scheduledTimerWithTimeInterval: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);
+                if (!timers[i].repeats) remove_timer_at(i);
+                break;
+            }
+        }
+    }];
+}
+
+unsigned long long _glfwPlatformAddTimer(double 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");
+        return 0;
+    }
+    Timer *t = timers + num_timers++;
+    t->id = ++timer_counter;
+    t->repeats = repeats;
+    t->interval = interval;
+    t->callback = callback;
+    t->callback_data = callback_data;
+    t->free_callback_data = free_callback;
+    schedule_timer(t);
+    return timer_counter;
+}
+
+void _glfwPlatformRemoveTimer(unsigned long long timer_id) {
+    for (size_t i = 0; i < num_timers; i++) {
+        if (timers[i].id == timer_id) {
+            remove_timer_at(i);
+            break;
+        }
+    }
+}
+
+void _glfwPlatformUpdateTimer(unsigned long long timer_id, double interval, GLFWbool enabled) {
+    for (size_t i = 0; i < num_timers; i++) {
+        if (timers[i].id == timer_id) {
+            Timer *t = timers + i;
+            if (t->os_timer) { [t->os_timer invalidate]; t->os_timer = NULL; }
+            t->interval = interval;
+            if (enabled) schedule_timer(t);
+            break;
+        }
+    }
+}

glfw/cocoa_joystick.m

@@ -220,9 +220,18 @@ static void matchCallback(void* context,
                 case kHIDUsage_GD_Hatswitch:
                     target = hats;
                     break;
+                case kHIDUsage_GD_DPadUp:
+                case kHIDUsage_GD_DPadRight:
+                case kHIDUsage_GD_DPadDown:
+                case kHIDUsage_GD_DPadLeft:
+                case kHIDUsage_GD_SystemMainMenu:
+                case kHIDUsage_GD_Select:
+                case kHIDUsage_GD_Start:
+                    target = buttons;
+                    break;
             }
         }
-        else if (page == kHIDPage_Button)
+        else if (page == kHIDPage_Button || page == kHIDPage_Consumer)
             target = buttons;
 
         if (target)
@@ -397,12 +406,12 @@ int _glfwPlatformPollJoystick(_GLFWjoystick* js, int mode)
             if (raw > axis->maximum)
                 axis->maximum = raw;
 
-            const long delta = axis->maximum - axis->minimum;
-            if (delta == 0)
+            const long size = axis->maximum - axis->minimum;
+            if (size == 0)
                 _glfwInputJoystickAxis(js, (int) i, 0.f);
             else
             {
-                const float value = (2.f * (raw - axis->minimum) / delta) - 1.f;
+                const float value = (2.f * (raw - axis->minimum) / size) - 1.f;
                 _glfwInputJoystickAxis(js, (int) i, value);
             }
         }
@@ -417,7 +426,8 @@ int _glfwPlatformPollJoystick(_GLFWjoystick* js, int mode)
             _GLFWjoyelementNS* button = (_GLFWjoyelementNS*)
                 CFArrayGetValueAtIndex(js->ns.buttons, i);
             const char value = getElementValue(js, button) - button->minimum;
-            _glfwInputJoystickButton(js, (int) i, value);
+            const int state = (value > 0) ? GLFW_PRESS : GLFW_RELEASE;
+            _glfwInputJoystickButton(js, (int) i, state);
         }
 
         for (i = 0;  i < CFArrayGetCount(js->ns.hats);  i++)
@@ -454,9 +464,8 @@ void _glfwPlatformUpdateGamepadGUID(char* guid)
         (strncmp(guid + 20, "000000000000", 12) == 0))
     {
         char original[33];
-        strcpy(original, guid);
+        strncpy(original, guid, sizeof(original) - 1);
         sprintf(guid, "03000000%.4s0000%.4s000000000000",
                 original, original + 16);
     }
 }
-

glfw/cocoa_monitor.m

@@ -29,6 +29,7 @@
 
 #include <stdlib.h>
 #include <limits.h>
+#include <math.h>
 
 #include <IOKit/graphics/IOGraphicsLib.h>
 #include <CoreVideo/CVBase.h>
@@ -148,7 +149,7 @@ static GLFWvidmode vidmodeFromCGDisplayMode(CGDisplayModeRef mode,
     GLFWvidmode result;
     result.width = (int) CGDisplayModeGetWidth(mode);
     result.height = (int) CGDisplayModeGetHeight(mode);
-    result.refreshRate = (int) CGDisplayModeGetRefreshRate(mode);
+    result.refreshRate = (int) round(CGDisplayModeGetRefreshRate(mode));
 
     if (result.refreshRate == 0)
     {
@@ -212,11 +213,91 @@ static void endFadeReservation(CGDisplayFadeReservationToken token)
     }
 }
 
+// Finds and caches the NSScreen corresponding to the specified monitor
+//
+GLFWbool refreshMonitorScreen(_GLFWmonitor* monitor)
+{
+    if (monitor->ns.screen)
+        return GLFW_TRUE;
+
+     for (NSScreen* screen in [NSScreen screens])
+    {
+        NSNumber* displayID = [screen deviceDescription][@"NSScreenNumber"];
+
+        // HACK: Compare unit numbers instead of display IDs to work around
+        //       display replacement on machines with automatic graphics
+        //       switching
+        if (monitor->ns.unitNumber == CGDisplayUnitNumber([displayID unsignedIntValue]))
+        {
+            monitor->ns.screen = screen;
+            return GLFW_TRUE;
+        }
+    }
+
+     _glfwInputError(GLFW_PLATFORM_ERROR, "Cocoa: Failed to find a screen for monitor");
+    return GLFW_FALSE;
+}
 
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
 
+void _glfwClearDisplayLinks() {
+    [_glfw.ns.displayLinks.lock lock];
+    for (size_t i = 0; i < _glfw.ns.displayLinks.count; i++) {
+        if (_glfw.ns.displayLinks.entries[i].displayLinkStarted) {
+            CVDisplayLinkStop(_glfw.ns.displayLinks.entries[i].displayLink);
+            _glfw.ns.displayLinks.entries[i].displayLinkStarted = GLFW_FALSE;
+        }
+        if (_glfw.ns.displayLinks.entries[i].displayLink) {
+            CVDisplayLinkRelease(_glfw.ns.displayLinks.entries[i].displayLink);
+            _glfw.ns.displayLinks.entries[i].displayLink = nil;
+        }
+    }
+    _glfw.ns.displayLinks.count = 0;
+    [_glfw.ns.displayLinks.lock unlock];
+}
+
+static CVReturn displayLinkCallback(
+        CVDisplayLinkRef displayLink,
+        const CVTimeStamp* now, const CVTimeStamp* outputTime,
+        CVOptionFlags flagsIn, CVOptionFlags* flagsOut, void* userInfo)
+{
+    CGDirectDisplayID displayID = (CGDirectDisplayID)userInfo;
+    [_glfw.ns.displayLinks.lock lock];
+    GLFWbool notify = GLFW_FALSE;
+    for (size_t i = 0; i < _glfw.ns.displayLinks.count; i++) {
+        if (_glfw.ns.displayLinks.entries[i].displayID == displayID) {
+            if (_glfw.ns.displayLinks.entries[i].renderFrameRequested) {
+                notify = GLFW_TRUE;
+                _glfw.ns.displayLinks.entries[i].renderFrameRequested = GLFW_FALSE;
+            }
+            break;
+        }
+    }
+    [_glfw.ns.displayLinks.lock unlock];
+    if (notify) {
+        NSNumber *arg = [NSNumber numberWithUnsignedInt:displayID];
+        [NSApp performSelectorOnMainThread:@selector(render_frame_received:) withObject:arg waitUntilDone:NO];
+        [arg release];
+    }
+    return kCVReturnSuccess;
+}
+
+static inline void createDisplayLink(CGDirectDisplayID displayID) {
+    [_glfw.ns.displayLinks.lock lock];
+    if (_glfw.ns.displayLinks.count >= sizeof(_glfw.ns.displayLinks.entries)/sizeof(_glfw.ns.displayLinks.entries[0]) - 1) return;
+    for (size_t i = 0; i < _glfw.ns.displayLinks.count; i++) {
+        if (_glfw.ns.displayLinks.entries[i].displayID == displayID) return;
+    }
+    _GLFWDisplayLinkNS *entry = &_glfw.ns.displayLinks.entries[_glfw.ns.displayLinks.count++];
+    memset(entry, 0, sizeof(_GLFWDisplayLinkNS));
+    entry->displayID = displayID;
+    CVDisplayLinkCreateWithCGDisplay(displayID, &entry->displayLink);
+    CVDisplayLinkSetOutputCallback(entry->displayLink, &displayLinkCallback, (void*)(uintptr_t)displayID);
+    [_glfw.ns.displayLinks.lock unlock];
+}
+
 // Poll for changes in the set of connected monitors
 //
 void _glfwPollMonitorsNS(void)
@@ -228,6 +309,7 @@ void _glfwPollMonitorsNS(void)
     CGGetOnlineDisplayList(0, NULL, &displayCount);
     displays = calloc(displayCount, sizeof(CGDirectDisplayID));
     CGGetOnlineDisplayList(displayCount, displays, &displayCount);
+    _glfwClearDisplayLinks();
 
     for (i = 0;  i < _glfw.monitorCount;  i++)
         _glfw.monitors[i]->ns.screen = nil;
@@ -269,6 +351,7 @@ void _glfwPollMonitorsNS(void)
         monitor = _glfwAllocMonitor(name, size.width, size.height);
         monitor->ns.displayID  = displays[i];
         monitor->ns.unitNumber = unitNumber;
+        createDisplayLink(monitor->ns.displayID);
 
         free(name);
 
@@ -283,6 +366,7 @@ void _glfwPollMonitorsNS(void)
 
     free(disconnected);
     free(displays);
+    _glfwRestartDisplayLinks();
 }
 
 // Change the current video mode
@@ -372,35 +456,8 @@ void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
 void _glfwPlatformGetMonitorContentScale(_GLFWmonitor* monitor,
                                          float* xscale, float* yscale)
 {
-    if (!monitor->ns.screen)
-    {
-        NSUInteger i;
-        NSArray* screens = [NSScreen screens];
-
-        for (i = 0;  i < [screens count];  i++)
-        {
-            NSScreen* screen = [screens objectAtIndex:i];
-            NSNumber* displayID =
-                [[screen deviceDescription] objectForKey:@"NSScreenNumber"];
-
-            // HACK: Compare unit numbers instead of display IDs to work around
-            //       display replacement on machines with automatic graphics
-            //       switching
-            if (monitor->ns.unitNumber ==
-                CGDisplayUnitNumber([displayID unsignedIntValue]))
-            {
-                monitor->ns.screen = screen;
-                break;
-            }
-        }
-
-        if (i == [screens count])
-        {
-            _glfwInputError(GLFW_PLATFORM_ERROR,
-                            "Cocoa: Failed to find a screen for monitor");
-            return;
-        }
-    }
+    if (!refreshMonitorScreen(monitor))
+        return;
 
     const NSRect points = [monitor->ns.screen frame];
     const NSRect pixels = [monitor->ns.screen convertRectToBacking:points];
@@ -411,6 +468,24 @@ void _glfwPlatformGetMonitorContentScale(_GLFWmonitor* monitor,
         *yscale = (float) (pixels.size.height / points.size.height);
 }
 
+void _glfwPlatformGetMonitorWorkarea(_GLFWmonitor* monitor, int* xpos, int* ypos, int *width, int *height)
+{
+    if (!refreshMonitorScreen(monitor))
+        return;
+
+    const NSRect frameRect = [monitor->ns.screen visibleFrame];
+
+    if (xpos)
+        *xpos = frameRect.origin.x;
+    if (ypos)
+        *ypos = _glfwTransformYNS(frameRect.origin.y + frameRect.size.height - 1);
+    if (width)
+        *width = frameRect.size.width;
+    if (height)
+        *height = frameRect.size.height;
+
+}
+
 GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* count)
 {
     CFArrayRef modes;
@@ -467,7 +542,7 @@ void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode *mode)
     CVDisplayLinkRelease(link);
 }
 
-void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
+GLFWbool _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
 {
     uint32_t i, size = CGDisplayGammaTableCapacity(monitor->ns.displayID);
     CGGammaValue* values = calloc(size * 3, sizeof(CGGammaValue));
@@ -489,6 +564,7 @@ void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
     }
 
     free(values);
+    return GLFW_TRUE;
 }
 
 void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
@@ -523,4 +599,3 @@ GLFWAPI CGDirectDisplayID glfwGetCocoaMonitor(GLFWmonitor* handle)
     _GLFW_REQUIRE_INIT_OR_RETURN(kCGNullDirectDisplay);
     return monitor->ns.displayID;
 }
-

glfw/cocoa_platform.h

@@ -27,19 +27,46 @@
 #include <stdint.h>
 #include <dlfcn.h>
 
-#if defined(__OBJC__)
-#import <Carbon/Carbon.h>
-#import <Cocoa/Cocoa.h>
-#else
 #include <Carbon/Carbon.h>
-#include <ApplicationServices/ApplicationServices.h>
+#if defined(__OBJC__)
+#import <Cocoa/Cocoa.h>
+#import <CoreVideo/CoreVideo.h>
+#else
 typedef void* id;
+typedef void* CVDisplayLinkRef;
 #endif
 
+#if MAC_OS_X_VERSION_MAX_ALLOWED < 101200
+ #define NSBitmapFormatAlphaNonpremultiplied NSAlphaNonpremultipliedBitmapFormat
+ #define NSEventMaskAny NSAnyEventMask
+ #define NSEventMaskKeyUp NSKeyUpMask
+ #define NSEventModifierFlagCapsLock NSAlphaShiftKeyMask
+ #define NSEventModifierFlagCommand NSCommandKeyMask
+ #define NSEventModifierFlagControl NSControlKeyMask
+ #define NSEventModifierFlagDeviceIndependentFlagsMask NSDeviceIndependentModifierFlagsMask
+ #define NSEventModifierFlagOption NSAlternateKeyMask
+ #define NSEventModifierFlagShift NSShiftKeyMask
+ #define NSEventTypeApplicationDefined NSApplicationDefined
+ #define NSWindowStyleMaskBorderless NSBorderlessWindowMask
+ #define NSWindowStyleMaskClosable NSClosableWindowMask
+ #define NSWindowStyleMaskMiniaturizable NSMiniaturizableWindowMask
+ #define NSWindowStyleMaskResizable NSResizableWindowMask
+ #define NSWindowStyleMaskTitled NSTitledWindowMask
+#endif
+
+#if (MAC_OS_X_VERSION_MAX_ALLOWED < 101400)
+ #define NSPasteboardTypeFileURL NSFilenamesPboardType
+ #define NSBitmapFormatAlphaNonpremultiplied NSAlphaNonpremultipliedBitmapFormat
+ #define NSPasteboardTypeString NSStringPboardType
+ #define NSOpenGLContextParameterSurfaceOpacity NSOpenGLCPSurfaceOpacity
+#endif
+
+
 typedef VkFlags VkMacOSSurfaceCreateFlagsMVK;
-typedef int (* GLFWcocoatextinputfilterfun)(int,int,int);
+typedef int (* GLFWcocoatextinputfilterfun)(int,int,unsigned int, unsigned long);
 typedef int (* GLFWapplicationshouldhandlereopenfun)(int);
 typedef int (* GLFWcocoatogglefullscreenfun)(GLFWwindow*);
+typedef void (* GLFWcocoarenderframefun)(GLFWwindow*);
 
 typedef struct VkMacOSSurfaceCreateInfoMVK
 {
@@ -90,6 +117,7 @@ typedef struct _GLFWwindowNS
     id              layer;
 
     GLFWbool        maximized;
+    GLFWbool        retina;
 
     // Cached window properties to filter out duplicate events
     int             width, height;
@@ -107,20 +135,32 @@ typedef struct _GLFWwindowNS
     GLFWcocoatogglefullscreenfun toggleFullscreenCallback;
     // Dead key state
     UInt32 deadKeyState;
+    // Whether a render frame has been requested for this window
+    GLFWbool renderFrameRequested;
+    GLFWcocoarenderframefun renderFrameCallback;
 } _GLFWwindowNS;
 
+typedef struct _GLFWDisplayLinkNS
+{
+    CVDisplayLinkRef displayLink;
+    CGDirectDisplayID displayID;
+    GLFWbool displayLinkStarted;
+    GLFWbool renderFrameRequested;
+} _GLFWDisplayLinkNS;
+
 // Cocoa-specific global data
 //
 typedef struct _GLFWlibraryNS
 {
     CGEventSourceRef    eventSource;
     id                  delegate;
-    id                  autoreleasePool;
     GLFWbool            cursorHidden;
     TISInputSourceRef   inputSource;
     IOHIDManagerRef     hidManager;
     id                  unicodeData;
-    id                  listener;
+    id                  helper;
+    id                  keyUpMonitor;
+    id                  keyDownMonitor;
 
     char                keyName[64];
     char                text[256];
@@ -141,6 +181,12 @@ typedef struct _GLFWlibraryNS
         CFStringRef     kPropertyUnicodeKeyLayoutData;
     } tis;
 
+    struct {
+        _GLFWDisplayLinkNS entries[256];
+        size_t count;
+        id lock;
+    } displayLinks;
+
 } _GLFWlibraryNS;
 
 // Cocoa-specific per-monitor data
@@ -176,3 +222,9 @@ void _glfwInitTimerNS(void);
 void _glfwPollMonitorsNS(void);
 void _glfwSetVideoModeNS(_GLFWmonitor* monitor, const GLFWvidmode* desired);
 void _glfwRestoreVideoModeNS(_GLFWmonitor* monitor);
+float _glfwTransformYNS(float y);
+void _glfwClearDisplayLinks(void);
+void _glfwRestartDisplayLinks(void);
+void _glfwCocoaPostEmptyEvent(short subtype, long data1, bool at_start);
+void _glfwDispatchTickCallback(void);
+void _glfwDispatchRenderFrame(CGDirectDisplayID);

glfw/context.c

@@ -358,7 +358,7 @@ GLFWbool _glfwRefreshContextAttribs(_GLFWwindow* window,
     window->context.source = ctxconfig->source;
     window->context.client = GLFW_OPENGL_API;
 
-    previous = _glfwPlatformGetTls(&_glfw.contextSlot);;
+    previous = _glfwPlatformGetTls(&_glfw.contextSlot);
     glfwMakeContextCurrent((GLFWwindow*) window);
 
     window->context.GetIntegerv = (PFNGLGETINTEGERVPROC)
@@ -755,4 +755,3 @@ GLFWAPI GLFWglproc glfwGetProcAddress(const char* procname)
 
     return window->context.getProcAddress(procname);
 }
-

glfw/dbus_glfw.c

@@ -43,6 +43,7 @@ report_error(DBusError *err, const char *fmt, ...) {
 }
 
 static _GLFWDBUSData *dbus_data = NULL;
+static DBusConnection *session_bus = NULL;
 
 GLFWbool
 glfw_dbus_init(_GLFWDBUSData *dbus, EventLoopData *eld) {
@@ -108,7 +109,7 @@ 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;
     if (interval < 0) return FALSE;
-    id_type timer_id = addTimer(dbus_data->eld, data, interval, enabled, on_dbus_timer_ready, timeout);
+    id_type timer_id = addTimer(dbus_data->eld, data, interval, enabled, true, on_dbus_timer_ready, timeout, NULL);
     if (!timer_id) return FALSE;
     id_type *idp = malloc(sizeof(id_type));
     if (!idp) {
@@ -171,12 +172,21 @@ glfw_dbus_dispatch(DBusConnection *conn) {
     while(dbus_connection_dispatch(conn) == DBUS_DISPATCH_DATA_REMAINS);
 }
 
+void
+glfw_dbus_session_bus_dispatch() {
+    if (session_bus) glfw_dbus_dispatch(session_bus);
+}
+
 void
 glfw_dbus_terminate(_GLFWDBUSData *dbus) {
     if (dbus_data) {
         dbus_data->eld = NULL;
         dbus_data = NULL;
     }
+    if (session_bus) {
+        dbus_connection_unref(session_bus);
+        session_bus = NULL;
+    }
 }
 
 void
@@ -223,34 +233,43 @@ method_reply_received(DBusPendingCall *pending, void *user_data) {
     }
 }
 
+GLFWbool
+call_method_with_msg(DBusConnection *conn, DBusMessage *msg, int timeout, dbus_pending_callback callback, void *user_data) {
+    GLFWbool retval = GLFW_FALSE;
+#define REPORT(errs) _glfwInputError(GLFW_PLATFORM_ERROR, "Failed to call DBUS method: node=%s path=%s interface=%s method=%s, with error: %s", dbus_message_get_destination(msg), dbus_message_get_path(msg), dbus_message_get_interface(msg), dbus_message_get_member(msg), errs)
+    if (callback) {
+        DBusPendingCall *pending = NULL;
+        if (dbus_connection_send_with_reply(conn, msg, &pending, timeout)) {
+            MethodResponse *res = malloc(sizeof(MethodResponse));
+            if (!res) return GLFW_FALSE;
+            res->callback = callback;
+            res->user_data = user_data;
+            dbus_pending_call_set_notify(pending, method_reply_received, res, free);
+            retval = GLFW_TRUE;
+        } else {
+            REPORT("out of memory");
+        }
+    } else {
+        if (dbus_connection_send(conn, msg, NULL)) {
+            retval = GLFW_TRUE;
+        } else {
+            REPORT("out of memory");
+        }
+    }
+    return retval;
+#undef REPORT
+}
+
 static GLFWbool
 call_method(DBusConnection *conn, const char *node, const char *path, const char *interface, const char *method, int timeout, dbus_pending_callback callback, void *user_data, va_list ap) {
     if (!conn) return GLFW_FALSE;
     DBusMessage *msg = dbus_message_new_method_call(node, path, interface, method);
     if (!msg) return GLFW_FALSE;
     GLFWbool retval = GLFW_FALSE;
-    MethodResponse *res = malloc(sizeof(MethodResponse));
-    if (!res) { dbus_message_unref(msg); return GLFW_FALSE; }
-    res->callback = callback;
-    res->user_data = user_data;
 
     int firstarg = va_arg(ap, int);
     if ((firstarg == DBUS_TYPE_INVALID) || dbus_message_append_args_valist(msg, firstarg, ap)) {
-        if (callback) {
-            DBusPendingCall *pending = NULL;
-            if (dbus_connection_send_with_reply(conn, msg, &pending, timeout)) {
-                dbus_pending_call_set_notify(pending, method_reply_received, res, free);
-                retval = GLFW_TRUE;
-            } else {
-                _glfwInputError(GLFW_PLATFORM_ERROR, "Failed to call DBUS method: %s on node: %s and interface: %s out of memory", method, node, interface);
-            }
-        } else {
-            if (dbus_connection_send(conn, msg, NULL)) {
-                retval = GLFW_TRUE;
-            } else {
-                _glfwInputError(GLFW_PLATFORM_ERROR, "Failed to call DBUS method: %s on node: %s and interface: %s out of memory", method, node, interface);
-            }
-        }
+        retval = call_method_with_msg(conn, msg, timeout, callback, user_data);
     } else {
         _glfwInputError(GLFW_PLATFORM_ERROR, "Failed to call DBUS method: %s on node: %s and interface: %s could not add arguments", method, node, interface);
     }
@@ -293,3 +312,38 @@ glfw_dbus_match_signal(DBusMessage *msg, const char *interface, ...) {
     va_end(ap);
     return ans;
 }
+
+static void
+glfw_dbus_connect_to_session_bus(void) {
+    DBusError error;
+    dbus_error_init(&error);
+    if (session_bus) {
+        dbus_connection_unref(session_bus);
+    }
+    session_bus = dbus_bus_get(DBUS_BUS_SESSION, &error);
+    if (dbus_error_is_set(&error)) {
+        report_error(&error, "Failed to connect to DBUS session bus");
+        session_bus = NULL;
+        return;
+    }
+    static const char *name = "session-bus";
+    if (!dbus_connection_set_watch_functions(session_bus, add_dbus_watch, remove_dbus_watch, toggle_dbus_watch, (void*)name, NULL)) {
+        _glfwInputError(GLFW_PLATFORM_ERROR, "Failed to set DBUS watches on connection to: %s", name);
+        dbus_connection_close(session_bus);
+        dbus_connection_unref(session_bus);
+        return;
+    }
+    if (!dbus_connection_set_timeout_functions(session_bus, add_dbus_timeout, remove_dbus_timeout, toggle_dbus_timeout, (void*)name, NULL)) {
+        _glfwInputError(GLFW_PLATFORM_ERROR, "Failed to set DBUS timeout functions on connection to: %s", name);
+        dbus_connection_close(session_bus);
+        dbus_connection_unref(session_bus);
+        return;
+    }
+
+}
+
+DBusConnection *
+glfw_dbus_session_bus() {
+    if (!session_bus) glfw_dbus_connect_to_session_bus();
+    return session_bus;
+}

glfw/dbus_glfw.h

@@ -42,9 +42,13 @@ void glfw_dbus_terminate(_GLFWDBUSData *dbus);
 DBusConnection* glfw_dbus_connect_to(const char *path, const char* err_msg, const char* name, GLFWbool register_on_bus);
 void glfw_dbus_close_connection(DBusConnection *conn);
 GLFWbool
+call_method_with_msg(DBusConnection *conn, DBusMessage *msg, int timeout, dbus_pending_callback callback, void *user_data);
+GLFWbool
 glfw_dbus_call_method_no_reply(DBusConnection *conn, const char *node, const char *path, const char *interface, const char *method, ...);
 GLFWbool
 glfw_dbus_call_method_with_reply(DBusConnection *conn, const char *node, const char *path, const char *interface, const char *method, int timeout_ms, dbus_pending_callback callback, void *user_data, ...);
 void glfw_dbus_dispatch(DBusConnection *);
+void glfw_dbus_session_bus_dispatch(void);
 GLFWbool glfw_dbus_get_args(DBusMessage *msg, const char *failmsg, ...);
 int glfw_dbus_match_signal(DBusMessage *msg, const char *interface, ...);
+DBusConnection* glfw_dbus_session_bus(void);

glfw/egl_context.c

@@ -612,6 +612,15 @@ GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
 
     window->context.egl.config = config;
 
+    EGLint a = EGL_MIN_SWAP_INTERVAL;
+    if (!eglGetConfigAttrib(_glfw.egl.display, config, a, &a)) {
+        _glfwInputError(GLFW_VERSION_UNAVAILABLE, "EGL: could not check for non-blocking buffer swap with error: %s", getEGLErrorString(eglGetError()));
+    } else {
+        if (a > 0) {
+            _glfwInputError(GLFW_VERSION_UNAVAILABLE, "EGL: non-blocking swap buffers not available, minimum swap interval is: %d", a);
+        }
+    }
+
     // Load the appropriate client library
     if (!_glfw.egl.KHR_get_all_proc_addresses)
     {
@@ -783,4 +792,3 @@ GLFWAPI EGLSurface glfwGetEGLSurface(GLFWwindow* handle)
 
     return window->context.egl.surface;
 }
-

glfw/egl_context.h

@@ -43,34 +43,30 @@ typedef Window EGLNativeWindowType;
  #define EGLAPIENTRY
 typedef struct wl_display* EGLNativeDisplayType;
 typedef struct wl_egl_window* EGLNativeWindowType;
-#elif defined(_GLFW_MIR)
- #define EGLAPIENTRY
-typedef MirEGLNativeDisplayType EGLNativeDisplayType;
-typedef MirEGLNativeWindowType EGLNativeWindowType;
 #else
  #error "No supported EGL platform selected"
 #endif
 
-#define EGL_SUCCESS	0x3000
-#define EGL_NOT_INITIALIZED	0x3001
+#define EGL_SUCCESS 0x3000
+#define EGL_NOT_INITIALIZED 0x3001
 #define EGL_BAD_ACCESS 0x3002
 #define EGL_BAD_ALLOC 0x3003
 #define EGL_BAD_ATTRIBUTE 0x3004
 #define EGL_BAD_CONFIG 0x3005
-#define EGL_BAD_CONTEXT	0x3006
-#define EGL_BAD_CURRENT_SURFACE	0x3007
-#define EGL_BAD_DISPLAY	0x3008
+#define EGL_BAD_CONTEXT 0x3006
+#define EGL_BAD_CURRENT_SURFACE 0x3007
+#define EGL_BAD_DISPLAY 0x3008
 #define EGL_BAD_MATCH 0x3009
 #define EGL_BAD_NATIVE_PIXMAP 0x300a
 #define EGL_BAD_NATIVE_WINDOW 0x300b
 #define EGL_BAD_PARAMETER 0x300c
-#define EGL_BAD_SURFACE	0x300d
+#define EGL_BAD_SURFACE 0x300d
 #define EGL_CONTEXT_LOST 0x300e
 #define EGL_COLOR_BUFFER_TYPE 0x303f
 #define EGL_RGB_BUFFER 0x308e
 #define EGL_SURFACE_TYPE 0x3033
 #define EGL_WINDOW_BIT 0x0004
-#define EGL_RENDERABLE_TYPE	0x3040
+#define EGL_RENDERABLE_TYPE 0x3040
 #define EGL_OPENGL_ES_BIT 0x0001
 #define EGL_OPENGL_ES2_BIT 0x0004
 #define EGL_OPENGL_BIT 0x0008
@@ -80,7 +76,7 @@ typedef MirEGLNativeWindowType EGLNativeWindowType;
 #define EGL_RED_SIZE 0x3024
 #define EGL_DEPTH_SIZE 0x3025
 #define EGL_STENCIL_SIZE 0x3026
-#define EGL_SAMPLES	0x3031
+#define EGL_SAMPLES 0x3031
 #define EGL_OPENGL_ES_API 0x30a0
 #define EGL_OPENGL_API 0x30a2
 #define EGL_NONE 0x3038
@@ -91,6 +87,8 @@ typedef MirEGLNativeWindowType EGLNativeWindowType;
 #define EGL_NO_DISPLAY ((EGLDisplay) 0)
 #define EGL_NO_CONTEXT ((EGLContext) 0)
 #define EGL_DEFAULT_DISPLAY ((EGLNativeDisplayType) 0)
+#define EGL_MIN_SWAP_INTERVAL             0x303B
+#define EGL_MAX_SWAP_INTERVAL             0x303C
 
 #define EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR 0x00000002
 #define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR 0x00000001
@@ -216,4 +214,3 @@ GLFWbool _glfwChooseVisualEGL(const _GLFWwndconfig* wndconfig,
                               const _GLFWfbconfig* fbconfig,
                               Visual** visual, int* depth);
 #endif /*_GLFW_X11*/
-

glfw/glfw.py

@@ -1,11 +1,10 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # vim:fileencoding=utf-8
 # License: GPL v3 Copyright: 2017, Kovid Goyal <kovid at kovidgoyal.net>
 
 import json
 import os
 import re
-import shutil
 import sys
 
 _plat = sys.platform.lower()
@@ -22,7 +21,7 @@ def wayland_protocol_file_name(base, ext='c'):
     return 'wayland-{}-client-protocol.{}'.format(base, ext)
 
 
-def init_env(env, pkg_config, at_least_version, module='x11'):
+def init_env(env, pkg_config, at_least_version, test_compile, module='x11'):
     ans = env.copy()
     ans.cflags = [
         x for x in ans.cflags
@@ -32,10 +31,11 @@ def init_env(env, pkg_config, at_least_version, module='x11'):
         ans.cflags.append('-pthread')
         ans.ldpaths.append('-pthread')
     ans.cflags.append('-fpic')
-    ans.cflags.append('-D_GLFW_' + module.upper())
-    ans.cflags.append('-D_GLFW_BUILD_DLL')
+    ans.cppflags.append('-D_GLFW_' + module.upper())
+    ans.cppflags.append('-D_GLFW_BUILD_DLL')
 
     if is_macos:
+        ans.cppflags.append('-DGL_SILENCE_DEPRECATION')
         ans.ldpaths.extend(
             "-framework Cocoa -framework IOKit -framework CoreFoundation -framework CoreVideo".
             split()
@@ -76,6 +76,14 @@ def init_env(env, pkg_config, at_least_version, module='x11'):
         for dep in 'wayland-egl wayland-client wayland-cursor xkbcommon dbus-1'.split():
             ans.cflags.extend(pkg_config(dep, '--cflags-only-I'))
             ans.ldpaths.extend(pkg_config(dep, '--libs'))
+        has_memfd_create = test_compile(env.cc, '-Werror', src='''#define _GNU_SOURCE
+    #include <unistd.h>
+    #include <sys/syscall.h>
+    int main(void) {
+        return syscall(__NR_memfd_create, "test", 0);
+    }''')
+        if has_memfd_create:
+            ans.cppflags.append('-DHAS_MEMFD_CREATE')
 
     return ans
 
@@ -94,40 +102,6 @@ def build_wayland_protocols(env, run_tool, emphasis, newer, dest_dir):
                          desc='Generating {} ...'.format(emphasis(os.path.basename(dest))))
 
 
-def collect_source_information():
-    raw = open('src/CMakeLists.txt').read()
-    mraw = open('CMakeLists.txt').read()
-
-    def extract_sources(group, start_pos=0):
-        for which in 'HEADERS SOURCES'.split():
-            yield which.lower(), list(filter(
-                lambda x: x[0] not in '"$',
-                re.search(
-                    r'{0}_{1}\s+([^)]+?)[)]'.format(group, which),
-                    raw[start_pos:]
-                ).group(1).strip().split()
-            ))
-
-    wayland_protocols = re.search(r'WaylandProtocols\s+(\S+)\s+', mraw).group(1)
-    wayland_protocols = list(map(int, wayland_protocols.split('.')))
-    ans = {
-        'common': dict(extract_sources('common')),
-        'wayland_protocols': wayland_protocols,
-    }
-    for group in 'cocoa win32 x11 wayland osmesa'.split():
-        m = re.search('_GLFW_' + group.upper(), raw)
-        ans[group] = dict(extract_sources('glfw', m.start()))
-        if group in ('x11', 'wayland'):
-            for joystick in ('linux', 'null'):
-                ans[group]['headers'].append('{}_joystick.h'.format(joystick))
-                ans[group]['sources'].append('{}_joystick.c'.format(joystick))
-        if group == 'wayland':
-            ans[group]['protocols'] = p = []
-            for m in re.finditer(r'WAYLAND_PROTOCOLS_PKGDATADIR\}/(.+?)"?$', raw, flags=re.M):
-                p.append(m.group(1))
-    return ans
-
-
 class Arg:
 
     def __init__(self, decl):
@@ -160,6 +134,8 @@ class Function:
             if a == 'void':
                 continue
             self.args.append(Arg(a))
+        if not self.args:
+            self.args = [Arg('void v')]
 
     def declaration(self):
         return 'typedef {restype} (*{name}_func)({args});\n{name}_func {name}_impl;\n#define {name} {name}_impl'.format(
@@ -179,7 +155,7 @@ class Function:
         return ans
 
 
-def generate_wrappers(glfw_header, glfw_native_header):
+def generate_wrappers(glfw_header):
     src = open(glfw_header).read()
     functions = []
     first = None
@@ -198,11 +174,16 @@ def generate_wrappers(glfw_header, glfw_native_header):
     GLFWcocoatogglefullscreenfun glfwSetCocoaToggleFullscreenIntercept(GLFWwindow *window, GLFWcocoatogglefullscreenfun callback)
     GLFWapplicationshouldhandlereopenfun glfwSetApplicationShouldHandleReopen(GLFWapplicationshouldhandlereopenfun callback)
     void glfwGetCocoaKeyEquivalent(int glfw_key, int glfw_mods, void* cocoa_key, void* cocoa_mods)
+    void glfwCocoaRequestRenderFrame(GLFWwindow *w, GLFWcocoarenderframefun callback)
     void* glfwGetX11Display(void)
     int32_t glfwGetX11Window(GLFWwindow* window)
-    void glfwSetX11SelectionString(const char* string)
-    const char* glfwGetX11SelectionString(void)
+    void glfwSetPrimarySelectionString(GLFWwindow* window, const char* string)
+    const char* glfwGetPrimarySelectionString(GLFWwindow* window, void)
     int glfwGetXKBScancode(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)
+    void glfwDBusSetUserNotificationHandler(GLFWDBusnotificationactivatedfun handler)
 '''.splitlines():
         if line:
             functions.append(Function(line.strip(), check_fail=False))
@@ -218,10 +199,13 @@ def generate_wrappers(glfw_header, glfw_native_header):
 
 {}
 
-typedef int (* GLFWcocoatextinputfilterfun)(int,int,unsigned int);
+typedef int (* GLFWcocoatextinputfilterfun)(int,int,unsigned int,unsigned long);
 typedef int (* GLFWapplicationshouldhandlereopenfun)(int);
 typedef int (* 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*);
 {}
 
 const char* load_glfw(const char* path);
@@ -251,7 +235,7 @@ load_glfw(const char* path) {
 }
 
 void
-unload_glfw() {
+unload_glfw(void) {
     if (handle) { dlclose(handle); handle = NULL; }
 }
 '''.replace('LOAD', '\n\n    '.join(f.load() for f in functions))
@@ -259,53 +243,9 @@ unload_glfw() {
         f.write(code)
 
 
-def from_glfw(glfw_dir):
-    os.chdir(glfw_dir)
-    sinfo = collect_source_information()
-    files_to_copy = set()
-    for x in sinfo.values():
-        if isinstance(x, dict):
-            headers, sources = x['headers'], x['sources']
-            for name in headers + sources:
-                files_to_copy.add(os.path.abspath(os.path.join('src', name)))
-    glfw_header = os.path.abspath('include/GLFW/glfw3.h')
-    glfw_native_header = os.path.abspath('include/GLFW/glfw3native.h')
-    os.chdir(base)
-    for x in os.listdir('.'):
-        if x.rpartition('.') in ('c', 'h'):
-            os.unlink(x)
-    for src in files_to_copy:
-        shutil.copy2(src, '.')
-    shutil.copy2(glfw_header, '.')
-    json.dump(
-        sinfo,
-        open('source-info.json', 'w'),
-        indent=2,
-        ensure_ascii=False,
-        sort_keys=True
-    )
-    generate_wrappers(glfw_header, glfw_native_header)
-
-
-def to_glfw(glfw_dir):
-    src = base
-    for x in os.listdir(src):
-        if x in ('glfw.py', 'glfw3.h', '__pycache__', 'source-info.json') or x.startswith('wayland-'):
-            continue
-        xp = os.path.join(src, x)
-        shutil.copyfile(xp, os.path.join(glfw_dir, 'src', x))
-    shutil.copyfile(os.path.join(src, 'glfw3.h'), os.path.join(glfw_dir, 'include/GLFW/glfw3.h'))
-
-
 def main():
-    glfw_dir = os.path.abspath(os.path.join(base, '../../glfw'))
-    q = sys.argv[1].lower().replace('_', '-')
-    if q == 'from-glfw':
-        from_glfw(glfw_dir)
-    elif q == 'to-glfw':
-        to_glfw(glfw_dir)
-    else:
-        raise SystemExit('First argument must be one of to-glfw or from-glfw')
+    os.chdir(os.path.dirname(os.path.abspath(__file__)))
+    generate_wrappers('glfw3.h')
 
 
 if __name__ == '__main__':

glfw/glfw3.h

@@ -133,6 +133,8 @@ extern "C" {
  */
 #include <stdint.h>
 
+#include <stdbool.h>
+
 /* Include the chosen OpenGL or OpenGL ES headers.
  */
 #if defined(GLFW_INCLUDE_ES1)
@@ -277,14 +279,14 @@ extern "C" {
  *  semantic sugar for the number 1.  You can also use `1` or `true` or `_True`
  *  or `GL_TRUE` or whatever you want.
  */
-#define GLFW_TRUE                   1
+#define GLFW_TRUE                   true
 /*! @brief Zero.
  *
  *  Zero.  Seriously.  You don't _need_ to use this symbol in your code.  It's
  *  semantic sugar for the number 0.  You can also use `0` or `false` or
  *  `_False` or `GL_FALSE` or whatever you want.
  */
-#define GLFW_FALSE                  0
+#define GLFW_FALSE                  false
 /*! @} */
 
 /*! @name Key and button actions
@@ -407,6 +409,8 @@ extern "C" {
 #define GLFW_KEY_GRAVE_ACCENT       96  /* ` */
 #define GLFW_KEY_WORLD_1            161 /* non-US #1 */
 #define GLFW_KEY_WORLD_2            162 /* non-US #2 */
+#define GLFW_KEY_PLUS               163
+#define GLFW_KEY_UNDERSCORE         164
 
 /* Function keys */
 #define GLFW_KEY_ESCAPE             256
@@ -825,7 +829,11 @@ extern "C" {
  *  [window attribute](@ref GLFW_FOCUS_ON_SHOW_attrib).
  */
 #define GLFW_FOCUS_ON_SHOW          0x0002000C
-
+/*! @brief Occlusion window attribute
+ *
+ *  Occlusion [window attribute](@ref GLFW_OCCLUDED_attrib).
+ */
+#define GLFW_OCCLUDED               0x0002000D
 /*! @brief Framebuffer bit depth hint.
  *
  *  Framebuffer bit depth [hint](@ref GLFW_RED_BITS).
@@ -1025,36 +1033,19 @@ extern "C" {
  *  @ingroup input
  *  @{ */
 
-/*! @brief The regular arrow cursor shape.
- *
- *  The regular arrow cursor.
- */
-#define GLFW_ARROW_CURSOR           0x00036001
-/*! @brief The text input I-beam cursor shape.
- *
- *  The text input I-beam cursor shape.
- */
-#define GLFW_IBEAM_CURSOR           0x00036002
-/*! @brief The crosshair shape.
- *
- *  The crosshair shape.
- */
-#define GLFW_CROSSHAIR_CURSOR       0x00036003
-/*! @brief The hand shape.
- *
- *  The hand shape.
- */
-#define GLFW_HAND_CURSOR            0x00036004
-/*! @brief The horizontal resize arrow shape.
- *
- *  The horizontal resize arrow shape.
- */
-#define GLFW_HRESIZE_CURSOR         0x00036005
-/*! @brief The vertical resize arrow shape.
- *
- *  The vertical resize arrow shape.
- */
-#define GLFW_VRESIZE_CURSOR         0x00036006
+typedef enum {
+    GLFW_ARROW_CURSOR,
+    GLFW_IBEAM_CURSOR,
+    GLFW_CROSSHAIR_CURSOR,
+    GLFW_HAND_CURSOR,
+    GLFW_HRESIZE_CURSOR,
+    GLFW_VRESIZE_CURSOR,
+    GLFW_NW_RESIZE_CURSOR,
+    GLFW_NE_RESIZE_CURSOR,
+    GLFW_SW_RESIZE_CURSOR,
+    GLFW_SE_RESIZE_CURSOR,
+    GLFW_INVALID_CURSOR
+} GLFWCursorShape;
 /*! @} */
 
 #define GLFW_CONNECTED              0x00040001
@@ -1163,9 +1154,9 @@ typedef void (* GLFWerrorfun)(int,const char*);
  *
  *  @param[in] window The window that was moved.
  *  @param[in] xpos The new x-coordinate, in screen coordinates, of the
- *  upper-left corner of the client area of the window.
+ *  upper-left corner of the content area of the window.
  *  @param[in] ypos The new y-coordinate, in screen coordinates, of the
- *  upper-left corner of the client area of the window.
+ *  upper-left corner of the content area of the window.
  *
  *  @sa @ref window_pos
  *  @sa @ref glfwSetWindowPosCallback
@@ -1243,6 +1234,24 @@ typedef void (* GLFWwindowrefreshfun)(GLFWwindow*);
  */
 typedef void (* GLFWwindowfocusfun)(GLFWwindow*,int);
 
+/*! @brief The function signature for window occlusion callbacks.
+ *
+ *  This is the function signature for window occlusion callback functions.
+ *
+ *  @param[in] window The window whose occlusion state changed.
+ *  @param[in] occluded `GLFW_TRUE` if the window was occluded, or `GLFW_FALSE`
+ *  if the window is no longer occluded.
+ *
+ *  @sa @ref window_occlusion
+ *  @sa @ref glfwSetWindowOcclusionCallback
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup window
+ */
+typedef void (* GLFWwindowocclusionfun)(GLFWwindow*, bool);
+
+
 /*! @brief The function signature for window iconify/restore callbacks.
  *
  *  This is the function signature for window iconify/restore callback
@@ -1342,9 +1351,9 @@ typedef void (* GLFWmousebuttonfun)(GLFWwindow*,int,int,int);
  *
  *  @param[in] window The window that received the event.
  *  @param[in] xpos The new cursor x-coordinate, relative to the left edge of
- *  the client area.
+ *  the content area.
  *  @param[in] ypos The new cursor y-coordinate, relative to the top edge of the
- *  client area.
+ *  content area.
  *
  *  @sa @ref cursor_pos
  *  @sa @ref glfwSetCursorPosCallback
@@ -1379,7 +1388,13 @@ typedef void (* GLFWcursorenterfun)(GLFWwindow*,int);
  *  @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.
+ *  @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) & 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
+ *  scrolling cancelled and value 6 if scrolling may begin soon.
  *
  *  @sa @ref scrolling
  *  @sa @ref glfwSetScrollCallback
@@ -1443,6 +1458,8 @@ typedef void (* GLFWkeyboardfun)(GLFWwindow*, int, int, int, int, const char*, i
  */
 typedef void (* GLFWdropfun)(GLFWwindow*,int,const char**);
 
+typedef void (* GLFWliveresizefun)(GLFWwindow*, bool);
+
 /*! @brief The function signature for monitor configuration callbacks.
  *
  *  This is the function signature for monitor configuration callback functions.
@@ -1478,6 +1495,9 @@ typedef void (* GLFWmonitorfun)(GLFWmonitor*,int);
  */
 typedef void (* GLFWjoystickfun)(int,int);
 
+typedef void (* GLFWuserdatafun)(unsigned long long, void*);
+typedef void (* GLFWtickcallback)(void*);
+
 /*! @brief Video mode type.
  *
  *  This describes a single video mode.
@@ -1624,6 +1644,12 @@ typedef struct GLFWgamepadstate
  *  @ingroup init
  */
 GLFWAPI int glfwInit(void);
+GLFWAPI void glfwRunMainLoop(GLFWtickcallback callback, void *callback_data);
+GLFWAPI void glfwStopMainLoop(void);
+GLFWAPI void glfwRequestTickCallback(void);
+GLFWAPI unsigned long long glfwAddTimer(double interval, bool repeats, GLFWuserdatafun callback, void * callback_data, GLFWuserdatafun free_callback);
+GLFWAPI void glfwUpdateTimer(unsigned long long timer_id, double interval, bool enabled);
+GLFWAPI void glfwRemoveTimer(unsigned long long);
 
 /*! @brief Terminates the GLFW library.
  *
@@ -1895,6 +1921,35 @@ GLFWAPI GLFWmonitor* glfwGetPrimaryMonitor(void);
  */
 GLFWAPI void glfwGetMonitorPos(GLFWmonitor* monitor, int* xpos, int* ypos);
 
+/*! @brief Returns the work area of the monitor.
+ *
+ *  This function returns the position, in screen coordinates, of the upper-left
+ *  corner of the specified monitor alongwith the work area size in screen co-ordinates.
+ *  The work area is defined as the area of the monitor not occluded by the operating
+ *  system chrome (task bar, global menubar, etc.).
+ *
+ *  Any or all of the position and size arguments may be `NULL`.  If an error occurs, all
+ *  non-`NULL` position and size arguments will be set to zero.
+ *
+ *  @param[in] monitor The monitor to query.
+ *  @param[out] xpos Where to store the monitor x-coordinate, or `NULL`.
+ *  @param[out] ypos Where to store the monitor y-coordinate, or `NULL`.
+ *  @param[out] width Where to store the monitor width, or `NULL`.
+*  @param[out] height Where to store the monitor height, or `NULL`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref monitor_workarea
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup monitor
+ */
+GLFWAPI void glfwGetMonitorWorkarea(GLFWmonitor* monitor, int* xpos, int* ypos, int *width, int *height);
+
 /*! @brief Returns the physical size of the monitor.
  *
  *  This function returns the size, in millimetres, of the display area of the
@@ -2121,9 +2176,9 @@ GLFWAPI const GLFWvidmode* glfwGetVideoMode(GLFWmonitor* monitor);
 
 /*! @brief Generates a gamma ramp and sets it for the specified monitor.
  *
- *  This function generates a 256-element gamma ramp from the specified exponent
- *  and then calls @ref glfwSetGammaRamp with it.  The value must be a finite
- *  number greater than zero.
+ *  This function generates an appropriately sized gamma ramp from the
+ *  specified exponent and then calls @ref glfwSetGammaRamp with it.  The value
+ *  must be a finite number greater than zero.
  *
  *  The software controlled gamma ramp is applied _in addition_ to the hardware
  *  gamma correction, which today is usually an approximation of sRGB gamma.
@@ -2202,8 +2257,8 @@ GLFWAPI const GLFWgammaramp* glfwGetGammaRamp(GLFWmonitor* monitor);
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
  *  GLFW_PLATFORM_ERROR.
  *
- *  @remark Gamma ramp sizes other than 256 are not supported by all platforms
- *  or graphics hardware.
+ *  @remark The size of the specified gamma ramp should match the size of the
+ *  current ramp for that monitor.
  *
  *  @remark @win32 The gamma ramp size must be 256.
  *
@@ -2443,11 +2498,13 @@ GLFWAPI void glfwWindowHintString(int hint, const char* value);
  *  GLFW_X11_CLASS_NAME and @ref GLFW_X11_INSTANCE_NAME window hints to override
  *  this.
  *
- *  @remark @wayland The window frame is currently very simple, only allowing
- *  window resize or move.  A compositor can still emit close, maximize or
- *  fullscreen events, using for example a keybind mechanism.  Additionally,
- *  the wp_viewporter protocol is required for this feature, otherwise the
- *  window will not be decorated.
+ *  @remark @wayland Compositors should implement the xdg-decoration protocol
+ *  for GLFW to decorate the window properly.  If this protocol isn't
+ *  supported, or if the compositor prefers client-side decorations, a very
+ *  simple fallback frame will be drawn using the wp_viewporter protocol.  A
+ *  compositor can still emit close, maximize or fullscreen events, using for
+ *  instance a keybind mechanism.  If neither of these protocols is supported,
+ *  the window won't be decorated.
  *
  *  @remark @wayland A full screen window will not attempt to change the mode,
  *  no matter what the requested size or refresh rate.
@@ -2465,6 +2522,7 @@ GLFWAPI void glfwWindowHintString(int hint, const char* value);
  *  @ingroup window
  */
 GLFWAPI GLFWwindow* glfwCreateWindow(int width, int height, const char* title, GLFWmonitor* monitor, GLFWwindow* share);
+GLFWAPI bool glfwToggleFullscreen(GLFWwindow *window, unsigned int flags);
 
 /*! @brief Destroys the specified window and its context.
  *
@@ -2609,19 +2667,19 @@ GLFWAPI void glfwSetWindowTitle(GLFWwindow* window, const char* title);
  */
 GLFWAPI void glfwSetWindowIcon(GLFWwindow* window, int count, const GLFWimage* images);
 
-/*! @brief Retrieves the position of the client area of the specified window.
+/*! @brief Retrieves the position of the content area of the specified window.
  *
  *  This function retrieves the position, in screen coordinates, of the
- *  upper-left corner of the client area of the specified window.
+ *  upper-left corner of the content area of the specified window.
  *
  *  Any or all of the position arguments may be `NULL`.  If an error occurs, all
  *  non-`NULL` position arguments will be set to zero.
  *
  *  @param[in] window The window to query.
  *  @param[out] xpos Where to store the x-coordinate of the upper-left corner of
- *  the client area, or `NULL`.
+ *  the content area, or `NULL`.
  *  @param[out] ypos Where to store the y-coordinate of the upper-left corner of
- *  the client area, or `NULL`.
+ *  the content area, or `NULL`.
  *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
  *  GLFW_PLATFORM_ERROR.
@@ -2641,10 +2699,10 @@ GLFWAPI void glfwSetWindowIcon(GLFWwindow* window, int count, const GLFWimage* i
  */
 GLFWAPI void glfwGetWindowPos(GLFWwindow* window, int* xpos, int* ypos);
 
-/*! @brief Sets the position of the client area of the specified window.
+/*! @brief Sets the position of the content area of the specified window.
  *
  *  This function sets the position, in screen coordinates, of the upper-left
- *  corner of the client area of the specified windowed mode window.  If the
+ *  corner of the content area of the specified windowed mode window.  If the
  *  window is a full screen window, this function does nothing.
  *
  *  __Do not use this function__ to move an already visible window unless you
@@ -2654,8 +2712,8 @@ GLFWAPI void glfwGetWindowPos(GLFWwindow* window, int* xpos, int* ypos);
  *  cannot and should not override these limits.
  *
  *  @param[in] window The window to query.
- *  @param[in] xpos The x-coordinate of the upper-left corner of the client area.
- *  @param[in] ypos The y-coordinate of the upper-left corner of the client area.
+ *  @param[in] xpos The x-coordinate of the upper-left corner of the content area.
+ *  @param[in] ypos The y-coordinate of the upper-left corner of the content area.
  *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
  *  GLFW_PLATFORM_ERROR.
@@ -2676,9 +2734,9 @@ GLFWAPI void glfwGetWindowPos(GLFWwindow* window, int* xpos, int* ypos);
  */
 GLFWAPI void glfwSetWindowPos(GLFWwindow* window, int xpos, int ypos);
 
-/*! @brief Retrieves the size of the client area of the specified window.
+/*! @brief Retrieves the size of the content area of the specified window.
  *
- *  This function retrieves the size, in screen coordinates, of the client area
+ *  This function retrieves the size, in screen coordinates, of the content area
  *  of the specified window.  If you wish to retrieve the size of the
  *  framebuffer of the window in pixels, see @ref glfwGetFramebufferSize.
  *
@@ -2687,9 +2745,9 @@ GLFWAPI void glfwSetWindowPos(GLFWwindow* window, int xpos, int ypos);
  *
  *  @param[in] window The window whose size to retrieve.
  *  @param[out] width Where to store the width, in screen coordinates, of the
- *  client area, or `NULL`.
+ *  content area, or `NULL`.
  *  @param[out] height Where to store the height, in screen coordinates, of the
- *  client area, or `NULL`.
+ *  content area, or `NULL`.
  *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
  *  GLFW_PLATFORM_ERROR.
@@ -2708,7 +2766,7 @@ GLFWAPI void glfwGetWindowSize(GLFWwindow* window, int* width, int* height);
 
 /*! @brief Sets the size limits of the specified window.
  *
- *  This function sets the size limits of the client area of the specified
+ *  This function sets the size limits of the content area of the specified
  *  window.  If the window is full screen, the size limits only take effect
  *  once it is made windowed.  If the window is not resizable, this function
  *  does nothing.
@@ -2723,11 +2781,11 @@ GLFWAPI void glfwGetWindowSize(GLFWwindow* window, int* width, int* height);
  *  @param[in] minwidth The minimum width, in screen coordinates, of the client
  *  area, or `GLFW_DONT_CARE`.
  *  @param[in] minheight The minimum height, in screen coordinates, of the
- *  client area, or `GLFW_DONT_CARE`.
+ *  content area, or `GLFW_DONT_CARE`.
  *  @param[in] maxwidth The maximum width, in screen coordinates, of the client
  *  area, or `GLFW_DONT_CARE`.
  *  @param[in] maxheight The maximum height, in screen coordinates, of the
- *  client area, or `GLFW_DONT_CARE`.
+ *  content area, or `GLFW_DONT_CARE`.
  *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
  *  GLFW_INVALID_VALUE and @ref GLFW_PLATFORM_ERROR.
@@ -2751,7 +2809,7 @@ GLFWAPI void glfwSetWindowSizeLimits(GLFWwindow* window, int minwidth, int minhe
 
 /*! @brief Sets the aspect ratio of the specified window.
  *
- *  This function sets the required aspect ratio of the client area of the
+ *  This function sets the required aspect ratio of the content area of the
  *  specified window.  If the window is full screen, the aspect ratio only takes
  *  effect once it is made windowed.  If the window is not resizable, this
  *  function does nothing.
@@ -2792,9 +2850,9 @@ GLFWAPI void glfwSetWindowSizeLimits(GLFWwindow* window, int minwidth, int minhe
  */
 GLFWAPI void glfwSetWindowAspectRatio(GLFWwindow* window, int numer, int denom);
 
-/*! @brief Sets the size of the client area of the specified window.
+/*! @brief Sets the size of the content area of the specified window.
  *
- *  This function sets the size, in screen coordinates, of the client area of
+ *  This function sets the size, in screen coordinates, of the content area of
  *  the specified window.
  *
  *  For full screen windows, this function updates the resolution of its desired
@@ -2810,9 +2868,9 @@ GLFWAPI void glfwSetWindowAspectRatio(GLFWwindow* window, int numer, int denom);
  *
  *  @param[in] window The window to resize.
  *  @param[in] width The desired width, in screen coordinates, of the window
- *  client area.
+ *  content area.
  *  @param[in] height The desired height, in screen coordinates, of the window
- *  client area.
+ *  content area.
  *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
  *  GLFW_PLATFORM_ERROR.
@@ -2930,6 +2988,32 @@ GLFWAPI void glfwGetWindowFrameSize(GLFWwindow* window, int* left, int* top, int
  */
 GLFWAPI void glfwGetWindowContentScale(GLFWwindow* window, float* xscale, float* yscale);
 
+/*! @brief Returns the double click time interval.
+ *
+ *  This function returns the maximum time between clicks to count as a
+ *  double click.
+ *
+ *  The double click interval is a positive finite number greater than zero,
+ *  where zero means that no click is ever recognized as a double click. If the
+ *  system does not support a double click interval, this function always returns one half.
+ *
+ *  @return The double click interval.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref double_click
+ *  @sa @ref click_interval
+ *  @sa @ref double_click_interval
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup window
+ */
+GLFWAPI double glfwGetDoubleClickInterval(GLFWwindow* window);
+
 /*! @brief Returns the opacity of the whole window.
  *
  *  This function returns the opacity of the window, including any decorations.
@@ -3000,9 +3084,8 @@ GLFWAPI void glfwSetWindowOpacity(GLFWwindow* window, float opacity);
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
  *  GLFW_PLATFORM_ERROR.
  *
- *  @remark @wayland There is no concept of iconification in wl_shell, this
- *  function will emit @ref GLFW_PLATFORM_ERROR when using this deprecated
- *  protocol.
+ *  @remark @wayland Once a window is iconified it cannot be restored
+ *  except by the compositor, this is a design decision of xdg-shell.
  *
  *  @thread_safety This function must only be called from the main thread.
  *
@@ -3239,7 +3322,7 @@ GLFWAPI GLFWmonitor* glfwGetWindowMonitor(GLFWwindow* window);
  *  The window position is ignored when setting a monitor.
  *
  *  When the monitor is `NULL`, the position, width and height are used to
- *  place the window client area.  The refresh rate is ignored when no monitor
+ *  place the window content area.  The refresh rate is ignored when no monitor
  *  is specified.
  *
  *  If you only wish to update the resolution of a full screen window or the
@@ -3252,10 +3335,10 @@ GLFWAPI GLFWmonitor* glfwGetWindowMonitor(GLFWwindow* window);
  *  @param[in] window The window whose monitor, size or video mode to set.
  *  @param[in] monitor The desired monitor, or `NULL` to set windowed mode.
  *  @param[in] xpos The desired x-coordinate of the upper-left corner of the
- *  client area.
+ *  content area.
  *  @param[in] ypos The desired y-coordinate of the upper-left corner of the
- *  client area.
- *  @param[in] width The desired with, in screen coordinates, of the client area
+ *  content area.
+ *  @param[in] width The desired with, in screen coordinates, of the content area
  *  or video mode.
  *  @param[in] height The desired height, in screen coordinates, of the client
  *  area or video mode.
@@ -3407,7 +3490,7 @@ GLFWAPI void* glfwGetWindowUserPointer(GLFWwindow* window);
  *
  *  This function sets the position callback of the specified window, which is
  *  called when the window is moved.  The callback is provided with the
- *  position, in screen coordinates, of the upper-left corner of the client area
+ *  position, in screen coordinates, of the upper-left corner of the content area
  *  of the window.
  *
  *  @param[in] window The window whose callback to set.
@@ -3435,7 +3518,7 @@ GLFWAPI GLFWwindowposfun glfwSetWindowPosCallback(GLFWwindow* window, GLFWwindow
  *
  *  This function sets the size callback of the specified window, which is
  *  called when the window is resized.  The callback is provided with the size,
- *  in screen coordinates, of the client area of the window.
+ *  in screen coordinates, of the content area of the window.
  *
  *  @param[in] window The window whose callback to set.
  *  @param[in] cbfun The new callback, or `NULL` to remove the currently set
@@ -3492,7 +3575,7 @@ GLFWAPI GLFWwindowclosefun glfwSetWindowCloseCallback(GLFWwindow* window, GLFWwi
 /*! @brief Sets the refresh callback for the specified window.
  *
  *  This function sets the refresh callback of the specified window, which is
- *  called when the client area of the window needs to be redrawn, for example
+ *  called when the content area of the window needs to be redrawn, for example
  *  if the window has been exposed after having been covered by another window.
  *
  *  On compositing window systems such as Aero, Compiz, Aqua or Wayland, where
@@ -3546,6 +3629,31 @@ GLFWAPI GLFWwindowrefreshfun glfwSetWindowRefreshCallback(GLFWwindow* window, GL
  */
 GLFWAPI GLFWwindowfocusfun glfwSetWindowFocusCallback(GLFWwindow* window, GLFWwindowfocusfun cbfun);
 
+/*! @brief Sets the occlusion callback for the specified window.
+ *
+ *  This function sets the occlusion callback of the specified window, which is
+ *  called when the window becomes (fully) occluded by other windows or when (a
+ *  part of) the window becomes visible again because an overlapping window is
+ *  moved away.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] cbfun The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_occlusion
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup window
+ */
+GLFWAPI GLFWwindowocclusionfun glfwSetWindowOcclusionCallback(GLFWwindow* window, GLFWwindowocclusionfun cbfun);
+
 /*! @brief Sets the iconify callback for the specified window.
  *
  *  This function sets the iconification callback of the specified window, which
@@ -3559,9 +3667,6 @@ GLFWAPI GLFWwindowfocusfun glfwSetWindowFocusCallback(GLFWwindow* window, GLFWwi
  *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
  *
- *  @remark @wayland The wl_shell protocol has no concept of iconification,
- *  this callback will never be called when using this deprecated protocol.
- *
  *  @thread_safety This function must only be called from the main thread.
  *
  *  @sa @ref window_iconify
@@ -3642,152 +3747,11 @@ GLFWAPI GLFWframebuffersizefun glfwSetFramebufferSizeCallback(GLFWwindow* window
  */
 GLFWAPI GLFWwindowcontentscalefun glfwSetWindowContentScaleCallback(GLFWwindow* window, GLFWwindowcontentscalefun cbfun);
 
-/*! @brief Processes all pending events.
- *
- *  This function processes only those events that are already in the event
- *  queue and then returns immediately.  Processing events will cause the window
- *  and input callbacks associated with those events to be called.
- *
- *  On some platforms, a window move, resize or menu operation will cause event
- *  processing to block.  This is due to how event processing is designed on
- *  those platforms.  You can use the
- *  [window refresh callback](@ref window_refresh) to redraw the contents of
- *  your window when necessary during such operations.
- *
- *  Do not assume that callbacks you set will _only_ be called in response to
- *  event processing functions like this one.  While it is necessary to poll for
- *  events, window systems that require GLFW to register callbacks of its own
- *  can pass events to GLFW in response to many window system function calls.
- *  GLFW will pass those events on to the application callbacks before
- *  returning.
- *
- *  Event processing is not required for joystick input to work.
- *
- *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
- *  GLFW_PLATFORM_ERROR.
- *
- *  @reentrancy This function must not be called from a callback.
- *
- *  @thread_safety This function must only be called from the main thread.
- *
- *  @sa @ref events
- *  @sa @ref glfwWaitEvents
- *  @sa @ref glfwWaitEventsTimeout
- *
- *  @since Added in version 1.0.
- *
- *  @ingroup window
- */
-GLFWAPI void glfwPollEvents(void);
-
-/*! @brief Waits until events are queued and processes them.
- *
- *  This function puts the calling thread to sleep until at least one event is
- *  available in the event queue.  Once one or more events are available,
- *  it behaves exactly like @ref glfwPollEvents, i.e. the events in the queue
- *  are processed and the function then returns immediately.  Processing events
- *  will cause the window and input callbacks associated with those events to be
- *  called.
- *
- *  Since not all events are associated with callbacks, this function may return
- *  without a callback having been called even if you are monitoring all
- *  callbacks.
- *
- *  On some platforms, a window move, resize or menu operation will cause event
- *  processing to block.  This is due to how event processing is designed on
- *  those platforms.  You can use the
- *  [window refresh callback](@ref window_refresh) to redraw the contents of
- *  your window when necessary during such operations.
- *
- *  Do not assume that callbacks you set will _only_ be called in response to
- *  event processing functions like this one.  While it is necessary to poll for
- *  events, window systems that require GLFW to register callbacks of its own
- *  can pass events to GLFW in response to many window system function calls.
- *  GLFW will pass those events on to the application callbacks before
- *  returning.
- *
- *  If no windows exist, this function returns immediately.  For synchronization
- *  of threads in applications that do not create windows, use your threading
- *  library of choice.
- *
- *  Event processing is not required for joystick input to work.
- *
- *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
- *  GLFW_PLATFORM_ERROR.
- *
- *  @reentrancy This function must not be called from a callback.
- *
- *  @thread_safety This function must only be called from the main thread.
- *
- *  @sa @ref events
- *  @sa @ref glfwPollEvents
- *  @sa @ref glfwWaitEventsTimeout
- *
- *  @since Added in version 2.5.
- *
- *  @ingroup window
- */
-GLFWAPI void glfwWaitEvents(void);
-
-/*! @brief Waits with timeout until events are queued and processes them.
- *
- *  This function puts the calling thread to sleep until at least one event is
- *  available in the event queue, or until the specified timeout is reached.  If
- *  one or more events are available, it behaves exactly like @ref
- *  glfwPollEvents, i.e. the events in the queue are processed and the function
- *  then returns immediately.  Processing events will cause the window and input
- *  callbacks associated with those events to be called.
- *
- *  The timeout value must be a positive finite number.
- *
- *  Since not all events are associated with callbacks, this function may return
- *  without a callback having been called even if you are monitoring all
- *  callbacks.
- *
- *  On some platforms, a window move, resize or menu operation will cause event
- *  processing to block.  This is due to how event processing is designed on
- *  those platforms.  You can use the
- *  [window refresh callback](@ref window_refresh) to redraw the contents of
- *  your window when necessary during such operations.
- *
- *  Do not assume that callbacks you set will _only_ be called in response to
- *  event processing functions like this one.  While it is necessary to poll for
- *  events, window systems that require GLFW to register callbacks of its own
- *  can pass events to GLFW in response to many window system function calls.
- *  GLFW will pass those events on to the application callbacks before
- *  returning.
- *
- *  If no windows exist, this function returns immediately.  For synchronization
- *  of threads in applications that do not create windows, use your threading
- *  library of choice.
- *
- *  Event processing is not required for joystick input to work.
- *
- *  @param[in] timeout The maximum amount of time, in seconds, to wait.
- *
- *  @reentrancy This function must not be called from a callback.
- *
- *  @thread_safety This function must only be called from the main thread.
- *
- *  @sa @ref events
- *  @sa @ref glfwPollEvents
- *  @sa @ref glfwWaitEvents
- *
- *  @since Added in version 3.2.
- *
- *  @ingroup window
- */
-GLFWAPI void glfwWaitEventsTimeout(double timeout);
-
 /*! @brief Posts an empty event to the event queue.
  *
  *  This function posts an empty event from the current thread to the event
  *  queue, causing @ref glfwWaitEvents or @ref glfwWaitEventsTimeout to return.
  *
- *  If no windows exist, this function returns immediately.  For synchronization
- *  of threads in applications that do not create windows, use your threading
- *  library of choice.
- *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
  *  GLFW_PLATFORM_ERROR.
  *
@@ -4039,11 +4003,11 @@ GLFWAPI int glfwGetKey(GLFWwindow* window, int key);
  */
 GLFWAPI int glfwGetMouseButton(GLFWwindow* window, int button);
 
-/*! @brief Retrieves the position of the cursor relative to the client area of
+/*! @brief Retrieves the position of the cursor relative to the content area of
  *  the window.
  *
  *  This function returns the position of the cursor, in screen coordinates,
- *  relative to the upper-left corner of the client area of the specified
+ *  relative to the upper-left corner of the content area of the specified
  *  window.
  *
  *  If the cursor is disabled (with `GLFW_CURSOR_DISABLED`) then the cursor
@@ -4059,9 +4023,9 @@ GLFWAPI int glfwGetMouseButton(GLFWwindow* window, int button);
  *
  *  @param[in] window The desired window.
  *  @param[out] xpos Where to store the cursor x-coordinate, relative to the
- *  left edge of the client area, or `NULL`.
+ *  left edge of the content area, or `NULL`.
  *  @param[out] ypos Where to store the cursor y-coordinate, relative to the to
- *  top edge of the client area, or `NULL`.
+ *  top edge of the content area, or `NULL`.
  *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
  *  GLFW_PLATFORM_ERROR.
@@ -4077,11 +4041,11 @@ GLFWAPI int glfwGetMouseButton(GLFWwindow* window, int button);
  */
 GLFWAPI void glfwGetCursorPos(GLFWwindow* window, double* xpos, double* ypos);
 
-/*! @brief Sets the position of the cursor, relative to the client area of the
+/*! @brief Sets the position of the cursor, relative to the content area of the
  *  window.
  *
  *  This function sets the position, in screen coordinates, of the cursor
- *  relative to the upper-left corner of the client area of the specified
+ *  relative to the upper-left corner of the content area of the specified
  *  window.  The window must have input focus.  If the window does not have
  *  input focus when this function is called, it fails silently.
  *
@@ -4096,9 +4060,9 @@ GLFWAPI void glfwGetCursorPos(GLFWwindow* window, double* xpos, double* ypos);
  *
  *  @param[in] window The desired window.
  *  @param[in] xpos The desired x-coordinate, relative to the left edge of the
- *  client area.
+ *  content area.
  *  @param[in] ypos The desired y-coordinate, relative to the top edge of the
- *  client area.
+ *  content area.
  *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
  *  GLFW_PLATFORM_ERROR.
@@ -4177,7 +4141,7 @@ GLFWAPI GLFWcursor* glfwCreateCursor(const GLFWimage* image, int xhot, int yhot,
  *
  *  @ingroup input
  */
-GLFWAPI GLFWcursor* glfwCreateStandardCursor(int shape);
+GLFWAPI GLFWcursor* glfwCreateStandardCursor(GLFWCursorShape shape);
 
 /*! @brief Destroys a cursor.
  *
@@ -4209,7 +4173,7 @@ GLFWAPI void glfwDestroyCursor(GLFWcursor* cursor);
 /*! @brief Sets the cursor for the window.
  *
  *  This function sets the cursor image to be used when the cursor is over the
- *  client area of the specified window.  The set cursor will only be visible
+ *  content area of the specified window.  The set cursor will only be visible
  *  when the [cursor mode](@ref cursor_mode) of the window is
  *  `GLFW_CURSOR_NORMAL`.
  *
@@ -4291,7 +4255,7 @@ GLFWAPI GLFWmousebuttonfun glfwSetMouseButtonCallback(GLFWwindow* window, GLFWmo
  *  This function sets the cursor position callback of the specified window,
  *  which is called when the cursor is moved.  The callback is provided with the
  *  position, in screen coordinates, relative to the upper-left corner of the
- *  client area of the window.
+ *  content area of the window.
  *
  *  @param[in] window The window whose callback to set.
  *  @param[in] cbfun The new callback, or `NULL` to remove the currently set
@@ -4314,7 +4278,7 @@ GLFWAPI GLFWcursorposfun glfwSetCursorPosCallback(GLFWwindow* window, GLFWcursor
 /*! @brief Sets the cursor enter/exit callback.
  *
  *  This function sets the cursor boundary crossing callback of the specified
- *  window, which is called when the cursor enters or leaves the client area of
+ *  window, which is called when the cursor enters or leaves the content area of
  *  the window.
  *
  *  @param[in] window The window whose callback to set.
@@ -4391,6 +4355,7 @@ GLFWAPI GLFWscrollfun glfwSetScrollCallback(GLFWwindow* window, GLFWscrollfun cb
  *  @ingroup input
  */
 GLFWAPI GLFWdropfun glfwSetDropCallback(GLFWwindow* window, GLFWdropfun cbfun);
+GLFWAPI GLFWliveresizefun glfwSetLiveResizeCallback(GLFWwindow* window, GLFWliveresizefun cbfun);
 
 /*! @brief Returns whether the specified joystick is present.
  *

glfw/glx_context.c

@@ -226,8 +226,6 @@ static GLFWglproc getProcAddressGLX(const char* procname)
         return _glfw_dlsym(_glfw.glx.handle, procname);
 }
 
-// Destroy the OpenGL context
-//
 static void destroyContextGLX(_GLFWwindow* window)
 {
     if (window->context.glx.window)
@@ -695,4 +693,3 @@ GLFWAPI GLXWindow glfwGetGLXWindow(GLFWwindow* handle)
 
     return window->context.glx.window;
 }
-

glfw/glx_context.h

@@ -29,11 +29,11 @@
 #define GLX_RGBA_BIT 0x00000001
 #define GLX_WINDOW_BIT 0x00000001
 #define GLX_DRAWABLE_TYPE 0x8010
-#define GLX_RENDER_TYPE	0x8011
+#define GLX_RENDER_TYPE 0x8011
 #define GLX_RGBA_TYPE 0x8014
 #define GLX_DOUBLEBUFFER 5
 #define GLX_STEREO 6
-#define GLX_AUX_BUFFERS	7
+#define GLX_AUX_BUFFERS 7
 #define GLX_RED_SIZE 8
 #define GLX_GREEN_SIZE 9
 #define GLX_BLUE_SIZE 10
@@ -42,7 +42,7 @@
 #define GLX_STENCIL_SIZE 13
 #define GLX_ACCUM_RED_SIZE 14
 #define GLX_ACCUM_GREEN_SIZE 15
-#define GLX_ACCUM_BLUE_SIZE	16
+#define GLX_ACCUM_BLUE_SIZE 16
 #define GLX_ACCUM_ALPHA_SIZE 17
 #define GLX_SAMPLES 0x186a1
 #define GLX_VISUAL_ID 0x800b

glfw/ibus_glfw.c

@@ -56,7 +56,7 @@ test_env_var(const char *name, const char *val) {
     return (q && strcmp(q, val) == 0) ? GLFW_TRUE : GLFW_FALSE;
 }
 
-static inline GLFWbool
+static inline size_t
 MIN(size_t a, size_t b) {
     return a < b ? a : b;
 }

glfw/init.c

@@ -193,6 +193,20 @@ void _glfwInputError(int code, const char* format, ...)
         _glfwErrorCallback(code, description);
 }
 
+void
+_glfwDebug(const char *format, ...) {
+    if (format)
+    {
+        va_list vl;
+
+        fprintf(stderr, "[%.4f] ", glfwGetTime());
+        va_start(vl, format);
+        vfprintf(stderr, format, vl);
+        va_end(vl);
+        fprintf(stderr, "\n");
+    }
+
+}
 
 //////////////////////////////////////////////////////////////////////////
 //////                        GLFW public API                       //////
@@ -320,3 +334,34 @@ GLFWAPI GLFWerrorfun glfwSetErrorCallback(GLFWerrorfun cbfun)
     _GLFW_SWAP_POINTERS(_glfwErrorCallback, cbfun);
     return cbfun;
 }
+
+
+GLFWAPI void glfwRunMainLoop(GLFWtickcallback callback, void *data)
+{
+    _GLFW_REQUIRE_INIT();
+    _glfwPlatformRunMainLoop(callback, data);
+}
+
+GLFWAPI void glfwRequestTickCallback(void) {
+    _glfwPlatformRequestTickCallback();
+}
+
+GLFWAPI void glfwStopMainLoop(void) {
+    _GLFW_REQUIRE_INIT();
+    _glfwPlatformStopMainLoop();
+}
+
+GLFWAPI unsigned long long glfwAddTimer(
+        double 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) {
+    _glfwPlatformUpdateTimer(timer_id, interval, enabled);
+}
+
+GLFWAPI void glfwRemoveTimer(unsigned long long timer_id) {
+    _glfwPlatformRemoveTimer(timer_id);
+}

glfw/input.c

@@ -312,7 +312,7 @@ void _glfwInputMouseClick(_GLFWwindow* window, int button, int action, int mods)
 }
 
 // Notifies shared code of a cursor motion event
-// The position is specified in client-area relative screen coordinates
+// The position is specified in content area relative screen coordinates
 //
 void _glfwInputCursorPos(_GLFWwindow* window, double xpos, double ypos)
 {
@@ -415,7 +415,7 @@ _GLFWjoystick* _glfwAllocJoystick(const char* name,
     js->buttonCount = buttonCount;
     js->hatCount    = hatCount;
 
-    strcpy(js->guid, guid);
+    strncpy(js->guid, guid, sizeof(js->guid) - 1);
     js->mapping = findValidMapping(js);
 
     return js;
@@ -487,6 +487,8 @@ const char* _glfwGetKeyName(int key)
         case GLFW_KEY_SLASH:        return "SLASH";
         case GLFW_KEY_WORLD_1:      return "WORLD 1";
         case GLFW_KEY_WORLD_2:      return "WORLD 2";
+        case GLFW_KEY_PLUS:         return "PLUS";
+        case GLFW_KEY_UNDERSCORE:   return "UNDERSCORE";
 
         // Function keys
         case GLFW_KEY_ESCAPE:       return "ESCAPE";
@@ -564,6 +566,15 @@ const char* _glfwGetKeyName(int key)
     }
 }
 
+// Center the cursor in the middle of the content area of the specified window
+//
+void _glfwCenterCursorInContentArea(_GLFWwindow* window)
+{
+    int width, height;
+    _glfwPlatformGetWindowSize(window, &width, &height);
+    _glfwPlatformSetCursorPos(window, width / 2.0, height / 2.0);
+}
+
 //////////////////////////////////////////////////////////////////////////
 //////                        GLFW public API                       //////
 //////////////////////////////////////////////////////////////////////////
@@ -821,20 +832,15 @@ GLFWAPI GLFWcursor* glfwCreateCursor(const GLFWimage* image, int xhot, int yhot,
     return (GLFWcursor*) cursor;
 }
 
-GLFWAPI GLFWcursor* glfwCreateStandardCursor(int shape)
+GLFWAPI GLFWcursor* glfwCreateStandardCursor(GLFWCursorShape shape)
 {
     _GLFWcursor* cursor;
 
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
-    if (shape != GLFW_ARROW_CURSOR &&
-        shape != GLFW_IBEAM_CURSOR &&
-        shape != GLFW_CROSSHAIR_CURSOR &&
-        shape != GLFW_HAND_CURSOR &&
-        shape != GLFW_HRESIZE_CURSOR &&
-        shape != GLFW_VRESIZE_CURSOR)
+    if (shape >= GLFW_INVALID_CURSOR)
     {
-        _glfwInputError(GLFW_INVALID_ENUM, "Invalid standard cursor 0x%08X", shape);
+        _glfwInputError(GLFW_INVALID_ENUM, "Invalid standard cursor: %d", shape);
         return NULL;
     }
 
@@ -914,7 +920,7 @@ GLFWAPI void glfwUpdateIMEState(GLFWwindow* handle, int which, int a, int b, int
     assert(window != NULL);
 
     _GLFW_REQUIRE_INIT();
-#if defined(_GLFW_X11) || defined(_GLFW_WAYLAND)
+#if defined(_GLFW_X11) || defined(_GLFW_WAYLAND) || defined(_GLFW_COCOA)
     _glfwPlatformUpdateIMEState(window, which, a, b, c, d);
 #else
     (void)window; (void)which; (void)a; (void)b; (void)c; (void)d;
@@ -1375,6 +1381,22 @@ GLFWAPI const char* glfwGetClipboardString(GLFWwindow* handle)
     return _glfwPlatformGetClipboardString();
 }
 
+#if defined(_GLFW_X11) || defined(_GLFW_WAYLAND)
+GLFWAPI void glfwSetPrimarySelectionString(GLFWwindow* handle, const char* string)
+{
+    assert(string != NULL);
+
+    _GLFW_REQUIRE_INIT();
+    _glfwPlatformSetPrimarySelectionString(string);
+}
+
+GLFWAPI const char* glfwGetPrimarySelectionString(GLFWwindow* handle)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    return _glfwPlatformGetPrimarySelectionString();
+}
+#endif
+
 GLFWAPI double glfwGetTime(void)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(0.0);

glfw/internal.h

@@ -60,7 +60,7 @@
 
 #define _GLFW_MESSAGE_SIZE      1024
 
-typedef int GLFWbool;
+typedef bool GLFWbool;
 typedef unsigned long long GLFWid;
 
 typedef struct _GLFWerror       _GLFWerror;
@@ -87,8 +87,8 @@ typedef GLFWglproc (* _GLFWgetprocaddressfun)(const char*);
 typedef void (* _GLFWdestroycontextfun)(_GLFWwindow*);
 
 #define GL_VERSION 0x1f02
-#define GL_NONE	0
-#define GL_COLOR_BUFFER_BIT	0x00004000
+#define GL_NONE 0
+#define GL_COLOR_BUFFER_BIT 0x00004000
 #define GL_UNSIGNED_BYTE 0x1401
 #define GL_EXTENSIONS 0x1f03
 #define GL_NUM_EXTENSIONS 0x821d
@@ -105,7 +105,7 @@ typedef void (* _GLFWdestroycontextfun)(_GLFWwindow*);
 #define GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH 0x82fc
 #define GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR 0x00000008
 
-typedef int	GLint;
+typedef int GLint;
 typedef unsigned int GLuint;
 typedef unsigned int GLenum;
 typedef unsigned int GLbitfield;
@@ -129,7 +129,6 @@ typedef enum VkStructureType
     VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,
     VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000,
     VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
-    VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000,
     VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
     VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000,
     VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
@@ -191,8 +190,6 @@ typedef void (APIENTRY * PFN_vkVoidFunction)(void);
  #include "x11_platform.h"
 #elif defined(_GLFW_WAYLAND)
  #include "wl_platform.h"
-#elif defined(_GLFW_MIR)
- #include "mir_platform.h"
 #elif defined(_GLFW_OSMESA)
  #include "null_platform.h"
 #else
@@ -411,6 +408,7 @@ struct _GLFWwindow
         GLFWwindowclosefun      close;
         GLFWwindowrefreshfun    refresh;
         GLFWwindowfocusfun      focus;
+        GLFWwindowocclusionfun  occlusion;
         GLFWwindowiconifyfun    iconify;
         GLFWwindowmaximizefun   maximize;
         GLFWframebuffersizefun  fbsize;
@@ -421,6 +419,7 @@ struct _GLFWwindow
         GLFWscrollfun           scroll;
         GLFWkeyboardfun         keyboard;
         GLFWdropfun             drop;
+        GLFWliveresizefun       liveResize;
     } callbacks;
 
     // This is defined in the window API's platform.h
@@ -571,8 +570,6 @@ struct _GLFWlibrary
         GLFWbool        KHR_xcb_surface;
 #elif defined(_GLFW_WAYLAND)
         GLFWbool        KHR_wayland_surface;
-#elif defined(_GLFW_MIR)
-        GLFWbool        KHR_mir_surface;
 #endif
     } vk;
 
@@ -611,7 +608,7 @@ void _glfwPlatformSetCursorPos(_GLFWwindow* window, double xpos, double ypos);
 void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode);
 int _glfwPlatformCreateCursor(_GLFWcursor* cursor,
                               const GLFWimage* image, int xhot, int yhot, int count);
-int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, int shape);
+int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, GLFWCursorShape shape);
 void _glfwPlatformDestroyCursor(_GLFWcursor* cursor);
 void _glfwPlatformSetCursor(_GLFWwindow* window, _GLFWcursor* cursor);
 
@@ -622,13 +619,18 @@ void _glfwPlatformFreeMonitor(_GLFWmonitor* monitor);
 void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos);
 void _glfwPlatformGetMonitorContentScale(_GLFWmonitor* monitor,
                                          float* xscale, float* yscale);
+void _glfwPlatformGetMonitorWorkarea(_GLFWmonitor* monitor, int* xpos, int* ypos, int *width, int *height);
 GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* count);
 void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode);
-void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp);
+GLFWbool _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp);
 void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp);
 
 void _glfwPlatformSetClipboardString(const char* string);
 const char* _glfwPlatformGetClipboardString(void);
+#if defined(_GLFW_X11) || defined(_GLFW_WAYLAND)
+void _glfwPlatformSetPrimarySelectionString(const char* string);
+const char* _glfwPlatformGetPrimarySelectionString(void);
+#endif
 
 int _glfwPlatformPollJoystick(_GLFWjoystick* js, int mode);
 void _glfwPlatformUpdateGamepadGUID(char* guid);
@@ -653,11 +655,13 @@ void _glfwPlatformSetWindowSizeLimits(_GLFWwindow* window,
                                       int maxwidth, int maxheight);
 void _glfwPlatformSetWindowAspectRatio(_GLFWwindow* window, int numer, int denom);
 void _glfwPlatformGetFramebufferSize(_GLFWwindow* window, int* width, int* height);
+void _glfwInputLiveResize(_GLFWwindow* window, bool started);
 void _glfwPlatformGetWindowFrameSize(_GLFWwindow* window,
                                      int* left, int* top,
                                      int* right, int* bottom);
 void _glfwPlatformGetWindowContentScale(_GLFWwindow* window,
                                         float* xscale, float* yscale);
+double _glfwPlatformGetDoubleClickInterval(_GLFWwindow* window);
 void _glfwPlatformIconifyWindow(_GLFWwindow* window);
 void _glfwPlatformRestoreWindow(_GLFWwindow* window);
 void _glfwPlatformMaximizeWindow(_GLFWwindow* window);
@@ -669,7 +673,9 @@ void _glfwPlatformFocusWindow(_GLFWwindow* window);
 void _glfwPlatformSetWindowMonitor(_GLFWwindow* window, _GLFWmonitor* monitor,
                                    int xpos, int ypos, int width, int height,
                                    int refreshRate);
+bool _glfwPlatformToggleFullscreen(_GLFWwindow *w, unsigned int flags);
 int _glfwPlatformWindowFocused(_GLFWwindow* window);
+int _glfwPlatformWindowOccluded(_GLFWwindow* window);
 int _glfwPlatformWindowIconified(_GLFWwindow* window);
 int _glfwPlatformWindowVisible(_GLFWwindow* window);
 int _glfwPlatformWindowMaximized(_GLFWwindow* window);
@@ -712,6 +718,7 @@ void _glfwPlatformUnlockMutex(_GLFWmutex* mutex);
 //////////////////////////////////////////////////////////////////////////
 
 void _glfwInputWindowFocus(_GLFWwindow* window, GLFWbool focused);
+void _glfwInputWindowOcclusion(_GLFWwindow* window, GLFWbool occluded);
 void _glfwInputWindowPos(_GLFWwindow* window, int xpos, int ypos);
 void _glfwInputWindowSize(_GLFWwindow* window, int width, int height);
 void _glfwInputFramebufferSize(_GLFWwindow* window, int width, int height);
@@ -737,13 +744,21 @@ void _glfwInputJoystickHat(_GLFWjoystick* js, int hat, char value);
 void _glfwInputMonitor(_GLFWmonitor* monitor, int action, int placement);
 void _glfwInputMonitorWindow(_GLFWmonitor* monitor, _GLFWwindow* window);
 
-#if defined(__GNUC__)
+#if defined(__GNUC__) || defined(__clang__)
 void _glfwInputError(int code, const char* format, ...)
     __attribute__((format(printf, 2, 3)));
+void _glfwDebug(const char* format, ...)
+    __attribute__((format(printf, 1, 2)));
 #else
 void _glfwInputError(int code, const char* format, ...);
+void _glfwDebug(const char* format, ...);
 #endif
 
+#ifdef DEBUG_EVENT_LOOP
+#define EVDBG(...) _glfwDebug(__VA_ARGS__)
+#else
+#define EVDBG(...)
+#endif
 
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW internal API                      //////
@@ -773,11 +788,18 @@ _GLFWjoystick* _glfwAllocJoystick(const char* name,
                                   int hatCount);
 void _glfwFreeJoystick(_GLFWjoystick* js);
 const char* _glfwGetKeyName(int key);
+void _glfwCenterCursorInContentArea(_GLFWwindow* window);
 
 GLFWbool _glfwInitVulkan(int mode);
 void _glfwTerminateVulkan(void);
 const char* _glfwGetVulkanResultString(VkResult result);
-_GLFWwindow* _glfwFocusedWindow();
+_GLFWwindow* _glfwFocusedWindow(void);
 _GLFWwindow* _glfwWindowForId(GLFWid id);
+void _glfwPlatformRunMainLoop(GLFWtickcallback, void*);
+void _glfwPlatformRequestTickCallback(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, GLFWbool enabled);
+void _glfwPlatformRemoveTimer(unsigned long long timer_id);
 
 char* _glfw_strdup(const char* source);

glfw/linux_joystick.c

@@ -228,7 +228,7 @@ static GLFWbool openJoystickDevice(const char* path)
         return GLFW_FALSE;
     }
 
-    strncpy(linjs.path, path, sizeof(linjs.path));
+    strncpy(linjs.path, path, sizeof(linjs.path) - 1);
     memcpy(&js->linjs, &linjs, sizeof(linjs));
 
     pollAbsState(js);
@@ -431,4 +431,3 @@ int _glfwPlatformPollJoystick(_GLFWjoystick* js, int mode)
 void _glfwPlatformUpdateGamepadGUID(char* guid)
 {
 }
-

glfw/linux_notify.c

@@ -0,0 +1,106 @@
+/*
+ * linux_notify.c
+ * Copyright (C) 2019 Kovid Goyal <kovid at kovidgoyal.net>
+ *
+ * Distributed under terms of the GPL3 license.
+ */
+
+#include "internal.h"
+#include "linux_notify.h"
+#include <stdlib.h>
+
+#define NOTIFICATIONS_SERVICE  "org.freedesktop.Notifications"
+#define NOTIFICATIONS_PATH "/org/freedesktop/Notifications"
+#define NOTIFICATIONS_IFACE "org.freedesktop.Notifications"
+
+static notification_id_type notification_id = 0;
+
+typedef struct {
+    notification_id_type next_id;
+    GLFWDBusnotificationcreatedfun callback;
+    void *data;
+} NotificationCreatedData;
+
+static GLFWDBusnotificationactivatedfun activated_handler = NULL;
+
+void
+glfw_dbus_set_user_notification_activated_handler(GLFWDBusnotificationactivatedfun handler) {
+    activated_handler = handler;
+}
+
+void
+notification_created(DBusMessage *msg, const char* errmsg, void *data) {
+    if (errmsg) {
+        _glfwInputError(GLFW_PLATFORM_ERROR, "Notify: Failed to create notification error: %s", errmsg);
+        if (data) free(data);
+        return;
+    }
+    uint32_t notification_id;
+    if (!glfw_dbus_get_args(msg, "Failed to get Notification uid", DBUS_TYPE_UINT32, &notification_id, DBUS_TYPE_INVALID)) return;
+    NotificationCreatedData *ncd = (NotificationCreatedData*)data;
+    if (ncd->callback) ncd->callback(ncd->next_id, notification_id, ncd->data);
+    if (data) free(data);
+}
+
+static DBusHandlerResult
+message_handler(DBusConnection *conn, DBusMessage *msg, void *user_data) {
+    (void)(user_data);
+    /* printf("session_bus message_handler invoked interface: %s member: %s\n", dbus_message_get_interface(msg), dbus_message_get_member(msg)); */
+    if (dbus_message_is_signal(msg, NOTIFICATIONS_IFACE, "ActionInvoked")) {
+        uint32_t notification_id;
+        const char *action;
+        if (glfw_dbus_get_args(msg, "Failed to get args from ActionInvoked notification signal",
+                    DBUS_TYPE_UINT32, &notification_id, DBUS_TYPE_STRING, &action, DBUS_TYPE_INVALID)) {
+            if (activated_handler) {
+                activated_handler(notification_id, action);
+                return DBUS_HANDLER_RESULT_HANDLED;
+            }
+        }
+
+    }
+    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
+notification_id_type
+glfw_dbus_send_user_notification(const char *app_name, const char* icon, const char *summary, const char *body, const char* action_name, int32_t timeout, GLFWDBusnotificationcreatedfun callback, void *user_data) {
+    DBusConnection *session_bus = glfw_dbus_session_bus();
+    static DBusConnection *added_signal_match = NULL;
+    if (!session_bus) return 0;
+    if (added_signal_match != session_bus) {
+        dbus_bus_add_match(session_bus, "type='signal',interface='" NOTIFICATIONS_IFACE "',member='ActionInvoked'", NULL);
+        dbus_connection_add_filter(session_bus, message_handler, NULL, NULL);
+        added_signal_match = session_bus;
+    }
+    NotificationCreatedData *data = malloc(sizeof(NotificationCreatedData));
+    if (!data) return 0;
+    data->next_id = ++notification_id;
+    data->callback = callback; data->data = user_data;
+    if (!data->next_id) data->next_id = ++notification_id;
+    uint32_t replaces_id = 0;
+
+    DBusMessage *msg = dbus_message_new_method_call(NOTIFICATIONS_SERVICE, NOTIFICATIONS_PATH, NOTIFICATIONS_IFACE, "Notify");
+    if (!msg) { free(data); return 0; }
+    DBusMessageIter args, array;
+    dbus_message_iter_init_append(msg, &args);
+#define OOMMSG { free(data); data = NULL; dbus_message_unref(msg); _glfwInputError(GLFW_PLATFORM_ERROR, "%s", "Out of memory allocating DBUS message for notification\n"); return 0; }
+#define APPEND(type, val) { if (!dbus_message_iter_append_basic(&args, type, val)) OOMMSG }
+    APPEND(DBUS_TYPE_STRING, &app_name)
+    APPEND(DBUS_TYPE_UINT32, &replaces_id)
+    APPEND(DBUS_TYPE_STRING, &icon)
+    APPEND(DBUS_TYPE_STRING, &summary)
+    APPEND(DBUS_TYPE_STRING, &body)
+    if (!dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY, "s", &array)) OOMMSG;
+    if (action_name) {
+        static const char* default_action = "default";
+        dbus_message_iter_append_basic(&array, DBUS_TYPE_STRING, &default_action);
+        dbus_message_iter_append_basic(&array, DBUS_TYPE_STRING, &action_name);
+    }
+    if (!dbus_message_iter_close_container(&args, &array)) OOMMSG;
+    if (!dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY, "{sv}", &array)) OOMMSG;
+    if (!dbus_message_iter_close_container(&args, &array)) OOMMSG;
+    APPEND(DBUS_TYPE_INT32, &timeout)
+#undef OOMMSG
+#undef APPEND
+    if (!call_method_with_msg(session_bus, msg, 5000, notification_created, data)) return 0;
+    return data->next_id;
+}

glfw/linux_notify.h

@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2019 Kovid Goyal <kovid at kovidgoyal.net>
+ *
+ * Distributed under terms of the GPL3 license.
+ */
+
+#pragma once
+
+
+#include "dbus_glfw.h"
+#include "internal.h"
+
+typedef unsigned long long notification_id_type;
+typedef void (*GLFWDBusnotificationcreatedfun)(notification_id_type, uint32_t, void*);
+typedef void (*GLFWDBusnotificationactivatedfun)(uint32_t, const char*);
+notification_id_type
+glfw_dbus_send_user_notification(const char *app_name, const char* icon, const char *summary, const char *body, const char *action_name, int32_t timeout, GLFWDBusnotificationcreatedfun, void*);
+void
+glfw_dbus_set_user_notification_activated_handler(GLFWDBusnotificationactivatedfun handler);

glfw/main_loop.h

@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2019 Kovid Goyal <kovid at kovidgoyal.net>
+ *
+ * Distributed under terms of the GPL3 license.
+ */
+
+#pragma once
+
+#include "internal.h"
+
+#ifndef GLFW_LOOP_BACKEND
+#define GLFW_LOOP_BACKEND x11
+#endif
+
+static GLFWbool keep_going = GLFW_FALSE;
+
+void _glfwPlatformRequestTickCallback() {
+}
+
+void _glfwPlatformStopMainLoop(void) {
+    if (keep_going) {
+        keep_going = GLFW_FALSE;
+        _glfwPlatformPostEmptyEvent();
+    }
+}
+
+void _glfwPlatformRunMainLoop(GLFWtickcallback tick_callback, void* data) {
+    keep_going = GLFW_TRUE;
+    while(keep_going) {
+        _glfwPlatformWaitEvents();
+		EVDBG("loop tick");
+        tick_callback(data);
+    }
+}
+
+unsigned long long _glfwPlatformAddTimer(double 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);
+}
+
+void _glfwPlatformRemoveTimer(unsigned long long timer_id) {
+    removeTimer(&_glfw.GLFW_LOOP_BACKEND.eventLoopData, timer_id);
+}
+
+void _glfwPlatformUpdateTimer(unsigned long long timer_id, double interval, GLFWbool enabled) {
+    changeTimerInterval(&_glfw.GLFW_LOOP_BACKEND.eventLoopData, timer_id, interval);
+    toggleTimer(&_glfw.GLFW_LOOP_BACKEND.eventLoopData, timer_id, enabled);
+}

glfw/memfd.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2018 Kovid Goyal <kovid at kovidgoyal.net>
+ *
+ * Distributed under terms of the GPL3 license.
+ */
+
+#pragma once
+
+#ifdef HAS_MEMFD_CREATE
+
+#include <unistd.h>
+#include <sys/syscall.h>
+static inline int memfd_create(const char *name, unsigned int flags) {
+    return syscall(__NR_memfd_create, name, flags);
+}
+
+#ifndef F_LINUX_SPECIFIC_BASE
+#define F_LINUX_SPECIFIC_BASE 1024
+#endif
+
+#ifndef F_ADD_SEALS
+#define F_ADD_SEALS (F_LINUX_SPECIFIC_BASE + 9)
+#define F_GET_SEALS (F_LINUX_SPECIFIC_BASE + 10)
+
+#define F_SEAL_SEAL     0x0001  /* prevent further seals from being set */
+#define F_SEAL_SHRINK   0x0002  /* prevent file from shrinking */
+#define F_SEAL_GROW     0x0004  /* prevent file from growing */
+#define F_SEAL_WRITE    0x0008  /* prevent writes */
+#endif
+
+#ifndef MFD_CLOEXEC
+#define MFD_CLOEXEC     0x0001U
+#define MFD_ALLOW_SEALING 0x0002U
+#endif
+
+#else
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+static inline int
+createTmpfileCloexec(char* tmpname)
+{
+    int fd;
+
+    fd = mkostemp(tmpname, O_CLOEXEC);
+    if (fd >= 0)
+        unlink(tmpname);
+
+    return fd;
+}
+
+#endif

glfw/monitor.c

@@ -330,6 +330,25 @@ GLFWAPI void glfwGetMonitorPos(GLFWmonitor* handle, int* xpos, int* ypos)
     _glfwPlatformGetMonitorPos(monitor, xpos, ypos);
 }
 
+GLFWAPI void glfwGetMonitorWorkarea(GLFWmonitor* handle, int* xpos, int* ypos, int* width, int* height)
+{
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+    assert(monitor != NULL);
+
+    if (xpos)
+        *xpos = 0;
+    if (ypos)
+        *ypos = 0;
+    if (width)
+        *width = 0;
+    if (height)
+        *height = 0;
+
+    _GLFW_REQUIRE_INIT();
+
+    _glfwPlatformGetMonitorWorkarea(monitor, xpos, ypos, width, height);
+}
+
 GLFWAPI void glfwGetMonitorPhysicalSize(GLFWmonitor* handle, int* widthMM, int* heightMM)
 {
     _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
@@ -427,11 +446,11 @@ GLFWAPI const GLFWvidmode* glfwGetVideoMode(GLFWmonitor* handle)
 
 GLFWAPI void glfwSetGamma(GLFWmonitor* handle, float gamma)
 {
-    int i;
-    unsigned short values[256];
+    unsigned int i;
+    unsigned short* values;
     GLFWgammaramp ramp;
+    const GLFWgammaramp* original;
     assert(handle != NULL);
-    assert(gamma == gamma);
     assert(gamma >= 0.f);
     assert(gamma <= FLT_MAX);
 
@@ -442,13 +461,18 @@ GLFWAPI void glfwSetGamma(GLFWmonitor* handle, float gamma)
         _glfwInputError(GLFW_INVALID_VALUE, "Invalid gamma value %f", gamma);
         return;
     }
+    original = glfwGetGammaRamp(handle);
+    if (!original)
+        return;
 
-    for (i = 0;  i < 256;  i++)
+    values = calloc(original->size, sizeof(unsigned short));
+
+    for (i = 0;  i < original->size;  i++)
     {
         float value;
 
         // Calculate intensity
-        value = i / 255.f;
+        value = i / (float) (original->size - 1);
         // Apply gamma curve
         value = powf(value, 1.f / gamma) * 65535.f + 0.5f;
 
@@ -462,9 +486,10 @@ GLFWAPI void glfwSetGamma(GLFWmonitor* handle, float gamma)
     ramp.red = values;
     ramp.green = values;
     ramp.blue = values;
-    ramp.size = 256;
+    ramp.size = original->size;
 
     glfwSetGammaRamp(handle, &ramp);
+    free(values);
 }
 
 GLFWAPI const GLFWgammaramp* glfwGetGammaRamp(GLFWmonitor* handle)
@@ -475,7 +500,8 @@ GLFWAPI const GLFWgammaramp* glfwGetGammaRamp(GLFWmonitor* handle)
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
     _glfwFreeGammaArrays(&monitor->currentRamp);
-    _glfwPlatformGetGammaRamp(monitor, &monitor->currentRamp);
+    if (!_glfwPlatformGetGammaRamp(monitor, &monitor->currentRamp))
+        return NULL;
 
     return &monitor->currentRamp;
 }
@@ -501,8 +527,10 @@ GLFWAPI void glfwSetGammaRamp(GLFWmonitor* handle, const GLFWgammaramp* ramp)
     _GLFW_REQUIRE_INIT();
 
     if (!monitor->originalRamp.size)
-        _glfwPlatformGetGammaRamp(monitor, &monitor->originalRamp);
+    {
+        if (!_glfwPlatformGetGammaRamp(monitor, &monitor->originalRamp))
+            return;
+    }
 
     _glfwPlatformSetGammaRamp(monitor, ramp);
 }
-

glfw/nsgl_context.h

@@ -33,7 +33,7 @@
 typedef struct _GLFWcontextNSGL
 {
     id           pixelFormat;
-    id	         object;
+    id           object;
 
 } _GLFWcontextNSGL;
 

glfw/nsgl_context.m

@@ -45,11 +45,10 @@ static void swapBuffersNSGL(_GLFWwindow* window)
 
 static void swapIntervalNSGL(int interval)
 {
-    _GLFWwindow* window = _glfwPlatformGetTls(&_glfw.contextSlot);
-
-    GLint sync = interval;
-    [window->context.nsgl.object setValues:&sync
-                              forParameter:NSOpenGLCPSwapInterval];
+    // As of Mojave this does not work so we use CVDisplayLink instead
+    (void)(interval);
+    _glfwInputError(GLFW_API_UNAVAILABLE,
+                    "NSGL: Swap intervals do not work on macOS");
 }
 
 static int extensionSupportedNSGL(const char* extension)
@@ -72,8 +71,6 @@ static GLFWglproc getProcAddressNSGL(const char* procname)
     return symbol;
 }
 
-// Destroy the OpenGL context
-//
 static void destroyContextNSGL(_GLFWwindow* window)
 {
     [window->context.nsgl.pixelFormat release];
@@ -135,12 +132,6 @@ GLFWbool _glfwCreateContextNSGL(_GLFWwindow* window,
             return GLFW_FALSE;
         }
 
-        if (!ctxconfig->forward || ctxconfig->profile != GLFW_OPENGL_CORE_PROFILE)
-        {
-            _glfwInputError(GLFW_VERSION_UNAVAILABLE,
-                            "NSGL: The targeted version of macOS only supports forward-compatible core profile contexts for OpenGL 3.2 and above");
-            return GLFW_FALSE;
-        }
     }
 
     // Context robustness modes (GL_KHR_robustness) are not yet supported by
@@ -175,9 +166,7 @@ GLFWbool _glfwCreateContextNSGL(_GLFWwindow* window,
         //       Info.plist for unbundled applications
         // HACK: This assumes that NSOpenGLPixelFormat will remain
         //       a straightforward wrapper of its CGL counterpart
-#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1080
         addAttrib(kCGLPFASupportsAutomaticGraphicsSwitching);
-#endif /*MAC_OS_X_VERSION_MAX_ALLOWED*/
     }
 
 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 101000
@@ -299,9 +288,16 @@ GLFWbool _glfwCreateContextNSGL(_GLFWwindow* window,
     if (fbconfig->transparent)
     {
         GLint opaque = 0;
-        [window->context.nsgl.object setValues:&opaque forParameter:NSOpenGLCPSurfaceOpacity];
+        [window->context.nsgl.object setValues:&opaque forParameter:NSOpenGLContextParameterSurfaceOpacity];
     }
 
+    if (window->ns.retina)
+        [window->ns.view setWantsBestResolutionOpenGLSurface:YES];
+
+    GLint interval = 0;
+    [window->context.nsgl.object setValues:&interval
+                              forParameter:NSOpenGLContextParameterSwapInterval];
+
     [window->context.nsgl.object setView:window->ns.view];
 
     window->context.makeCurrent = makeContextCurrentNSGL;
@@ -332,4 +328,3 @@ GLFWAPI id glfwGetNSGLContext(GLFWwindow* handle)
 
     return window->context.nsgl.object;
 }
-

glfw/null_monitor.c

@@ -49,6 +49,10 @@ void _glfwPlatformGetMonitorContentScale(_GLFWmonitor* monitor,
         *yscale = 1.f;
 }
 
+void _glfwPlatformGetMonitorWorkarea(_GLFWmonitor* monitor, int* xpos, int* ypos, int *width, int *height)
+{
+}
+
 GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* found)
 {
     return NULL;
@@ -58,11 +62,11 @@ void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode)
 {
 }
 
-void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
+GLFWbool _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
 {
+    return GLFW_FALSE;
 }
 
 void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
 {
 }
-

glfw/null_window.c

@@ -148,6 +148,11 @@ void _glfwPlatformGetWindowContentScale(_GLFWwindow* window,
         *yscale = 1.f;
 }
 
+double _glfwPlatformGetDoubleClickInterval(_GLFWwindow* window)
+{
+    return 0.5;
+}
+
 void _glfwPlatformIconifyWindow(_GLFWwindow* window)
 {
 }
@@ -227,6 +232,11 @@ int _glfwPlatformWindowFocused(_GLFWwindow* window)
     return GLFW_FALSE;
 }
 
+int _glfwPlatformWindowOccluded(_GLFWwindow* window)
+{
+    return GLFW_FALSE;
+}
+
 int _glfwPlatformWindowIconified(_GLFWwindow* window)
 {
     return GLFW_FALSE;

glfw/osmesa_context.c

@@ -240,7 +240,7 @@ GLFWbool _glfwCreateContextOSMesa(_GLFWwindow* window,
         if (ctxconfig->forward)
         {
             _glfwInputError(GLFW_VERSION_UNAVAILABLE,
-                            "OSMesa: Foward-compatible contexts not supported");
+                            "OSMesa: Forward-compatible contexts not supported");
             return GLFW_FALSE;
         }
 
@@ -367,4 +367,3 @@ GLFWAPI OSMesaContext glfwGetOSMesaContext(GLFWwindow* handle)
 
     return window->context.osmesa.handle;
 }
-

glfw/source-info.json

@@ -64,14 +64,18 @@
       "egl_context.h",
       "osmesa_context.h",
       "linux_joystick.h",
-      "null_joystick.h"
+      "null_joystick.h",
+      "linux_notify.h",
+      "main_loop.h"
     ],
     "protocols": [
       "stable/xdg-shell/xdg-shell.xml",
       "stable/viewporter/viewporter.xml",
       "unstable/relative-pointer/relative-pointer-unstable-v1.xml",
       "unstable/pointer-constraints/pointer-constraints-unstable-v1.xml",
-      "unstable/idle-inhibit/idle-inhibit-unstable-v1.xml"
+      "unstable/idle-inhibit/idle-inhibit-unstable-v1.xml",
+      "unstable/xdg-decoration/xdg-decoration-unstable-v1.xml",
+      "unstable/primary-selection/primary-selection-unstable-v1.xml"
     ],
     "sources": [
       "wl_init.c",
@@ -86,12 +90,13 @@
       "osmesa_context.c",
       "backend_utils.c",
       "linux_joystick.c",
-      "null_joystick.c"
+      "null_joystick.c",
+      "linux_notify.c"
     ]
   },
   "wayland_protocols": [
     1,
-    12
+    17
   ],
   "win32": {
     "headers": [
@@ -126,7 +131,9 @@
       "egl_context.h",
       "osmesa_context.h",
       "linux_joystick.h",
-      "null_joystick.h"
+      "null_joystick.h",
+      "linux_notify.h",
+      "main_loop.h"
     ],
     "sources": [
       "x11_init.c",
@@ -142,7 +149,8 @@
       "osmesa_context.c",
       "backend_utils.c",
       "linux_joystick.c",
-      "null_joystick.c"
+      "null_joystick.c",
+      "linux_notify.c"
     ]
   }
-}
+}

glfw/vulkan.c

@@ -136,9 +136,6 @@ GLFWbool _glfwInitVulkan(int mode)
 #elif defined(_GLFW_WAYLAND)
         else if (strcmp(ep[i].extensionName, "VK_KHR_wayland_surface") == 0)
             _glfw.vk.KHR_wayland_surface = GLFW_TRUE;
-#elif defined(_GLFW_MIR)
-        else if (strcmp(ep[i].extensionName, "VK_KHR_mir_surface") == 0)
-            _glfw.vk.KHR_mir_surface = GLFW_TRUE;
 #endif
     }
 
@@ -326,4 +323,3 @@ GLFWAPI VkResult glfwCreateWindowSurface(VkInstance instance,
 
     return _glfwPlatformCreateWindowSurface(instance, window, allocator, surface);
 }
-

glfw/wgl_context.c

@@ -389,7 +389,7 @@ GLFWbool _glfwInitWGL(void)
     // NOTE: This code will accept the Microsoft GDI ICD; accelerated context
     //       creation failure occurs during manual pixel format enumeration
 
-    dc = GetDC(_glfw.win32.helperWindowHandle);;
+    dc = GetDC(_glfw.win32.helperWindowHandle);
 
     ZeroMemory(&pfd, sizeof(pfd));
     pfd.nSize = sizeof(pfd);
@@ -741,4 +741,3 @@ GLFWAPI HGLRC glfwGetWGLContext(GLFWwindow* handle)
 
     return window->context.wgl.handle;
 }
-

glfw/win32_init.c

@@ -1,627 +0,0 @@
-//========================================================================
-// GLFW 3.3 Win32 - www.glfw.org
-//------------------------------------------------------------------------
-// Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-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.
-//
-//========================================================================
-
-#include "internal.h"
-
-#include <stdlib.h>
-#include <malloc.h>
-
-static const GUID _glfw_GUID_DEVINTERFACE_HID =
-    {0x4d1e55b2,0xf16f,0x11cf,{0x88,0xcb,0x00,0x11,0x11,0x00,0x00,0x30}};
-
-#define GUID_DEVINTERFACE_HID _glfw_GUID_DEVINTERFACE_HID
-
-#if defined(_GLFW_USE_HYBRID_HPG) || defined(_GLFW_USE_OPTIMUS_HPG)
-
-// Executables (but not DLLs) exporting this symbol with this value will be
-// automatically directed to the high-performance GPU on Nvidia Optimus systems
-// with up-to-date drivers
-//
-__declspec(dllexport) DWORD NvOptimusEnablement = 1;
-
-// Executables (but not DLLs) exporting this symbol with this value will be
-// automatically directed to the high-performance GPU on AMD PowerXpress systems
-// with up-to-date drivers
-//
-__declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1;
-
-#endif // _GLFW_USE_HYBRID_HPG
-
-#if defined(_GLFW_BUILD_DLL)
-
-// GLFW DLL entry point
-//
-BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved)
-{
-    return TRUE;
-}
-
-#endif // _GLFW_BUILD_DLL
-
-// Load necessary libraries (DLLs)
-//
-static GLFWbool loadLibraries(void)
-{
-    _glfw.win32.winmm.instance = LoadLibraryA("winmm.dll");
-    if (!_glfw.win32.winmm.instance)
-    {
-        _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
-                             "Win32: Failed to load winmm.dll");
-        return GLFW_FALSE;
-    }
-
-    _glfw.win32.winmm.GetTime = (PFN_timeGetTime)
-        GetProcAddress(_glfw.win32.winmm.instance, "timeGetTime");
-
-    _glfw.win32.user32.instance = LoadLibraryA("user32.dll");
-    if (!_glfw.win32.user32.instance)
-    {
-        _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
-                             "Win32: Failed to load user32.dll");
-        return GLFW_FALSE;
-    }
-
-    _glfw.win32.user32.SetProcessDPIAware_ = (PFN_SetProcessDPIAware)
-        GetProcAddress(_glfw.win32.user32.instance, "SetProcessDPIAware");
-    _glfw.win32.user32.ChangeWindowMessageFilterEx_ = (PFN_ChangeWindowMessageFilterEx)
-        GetProcAddress(_glfw.win32.user32.instance, "ChangeWindowMessageFilterEx");
-    _glfw.win32.user32.EnableNonClientDpiScaling_ = (PFN_EnableNonClientDpiScaling)
-        GetProcAddress(_glfw.win32.user32.instance, "EnableNonClientDpiScaling");
-    _glfw.win32.user32.SetProcessDpiAwarenessContext_ = (PFN_SetProcessDpiAwarenessContext)
-        GetProcAddress(_glfw.win32.user32.instance, "SetProcessDpiAwarenessContext");
-    _glfw.win32.user32.GetDpiForWindow_ = (PFN_GetDpiForWindow)
-        GetProcAddress(_glfw.win32.user32.instance, "GetDpiForWindow");
-    _glfw.win32.user32.AdjustWindowRectExForDpi_ = (PFN_AdjustWindowRectExForDpi)
-        GetProcAddress(_glfw.win32.user32.instance, "AdjustWindowRectExForDpi");
-
-    _glfw.win32.dinput8.instance = LoadLibraryA("dinput8.dll");
-    if (_glfw.win32.dinput8.instance)
-    {
-        _glfw.win32.dinput8.Create = (PFN_DirectInput8Create)
-            GetProcAddress(_glfw.win32.dinput8.instance, "DirectInput8Create");
-    }
-
-    {
-        int i;
-        const char* names[] =
-        {
-            "xinput1_4.dll",
-            "xinput1_3.dll",
-            "xinput9_1_0.dll",
-            "xinput1_2.dll",
-            "xinput1_1.dll",
-            NULL
-        };
-
-        for (i = 0;  names[i];  i++)
-        {
-            _glfw.win32.xinput.instance = LoadLibraryA(names[i]);
-            if (_glfw.win32.xinput.instance)
-            {
-                _glfw.win32.xinput.GetCapabilities = (PFN_XInputGetCapabilities)
-                    GetProcAddress(_glfw.win32.xinput.instance, "XInputGetCapabilities");
-                _glfw.win32.xinput.GetState = (PFN_XInputGetState)
-                    GetProcAddress(_glfw.win32.xinput.instance, "XInputGetState");
-
-                break;
-            }
-        }
-    }
-
-    _glfw.win32.dwmapi.instance = LoadLibraryA("dwmapi.dll");
-    if (_glfw.win32.dwmapi.instance)
-    {
-        _glfw.win32.dwmapi.IsCompositionEnabled = (PFN_DwmIsCompositionEnabled)
-            GetProcAddress(_glfw.win32.dwmapi.instance, "DwmIsCompositionEnabled");
-        _glfw.win32.dwmapi.Flush = (PFN_DwmFlush)
-            GetProcAddress(_glfw.win32.dwmapi.instance, "DwmFlush");
-        _glfw.win32.dwmapi.EnableBlurBehindWindow = (PFN_DwmEnableBlurBehindWindow)
-            GetProcAddress(_glfw.win32.dwmapi.instance, "DwmEnableBlurBehindWindow");
-    }
-
-    _glfw.win32.shcore.instance = LoadLibraryA("shcore.dll");
-    if (_glfw.win32.shcore.instance)
-    {
-        _glfw.win32.shcore.SetProcessDpiAwareness_ = (PFN_SetProcessDpiAwareness)
-            GetProcAddress(_glfw.win32.shcore.instance, "SetProcessDpiAwareness");
-        _glfw.win32.shcore.GetDpiForMonitor_ = (PFN_GetDpiForMonitor)
-            GetProcAddress(_glfw.win32.shcore.instance, "GetDpiForMonitor");
-    }
-
-    _glfw.win32.ntdll.instance = LoadLibraryA("ntdll.dll");
-    if (_glfw.win32.ntdll.instance)
-    {
-        _glfw.win32.ntdll.RtlVerifyVersionInfo_ = (PFN_RtlVerifyVersionInfo)
-            GetProcAddress(_glfw.win32.ntdll.instance, "RtlVerifyVersionInfo");
-    }
-
-    return GLFW_TRUE;
-}
-
-// Unload used libraries (DLLs)
-//
-static void freeLibraries(void)
-{
-    if (_glfw.win32.xinput.instance)
-        FreeLibrary(_glfw.win32.xinput.instance);
-
-    if (_glfw.win32.dinput8.instance)
-        FreeLibrary(_glfw.win32.dinput8.instance);
-
-    if (_glfw.win32.winmm.instance)
-        FreeLibrary(_glfw.win32.winmm.instance);
-
-    if (_glfw.win32.user32.instance)
-        FreeLibrary(_glfw.win32.user32.instance);
-
-    if (_glfw.win32.dwmapi.instance)
-        FreeLibrary(_glfw.win32.dwmapi.instance);
-
-    if (_glfw.win32.shcore.instance)
-        FreeLibrary(_glfw.win32.shcore.instance);
-
-    if (_glfw.win32.ntdll.instance)
-        FreeLibrary(_glfw.win32.ntdll.instance);
-}
-
-// Create key code translation tables
-//
-static void createKeyTables(void)
-{
-    int scancode;
-
-    memset(_glfw.win32.keycodes, -1, sizeof(_glfw.win32.keycodes));
-    memset(_glfw.win32.scancodes, -1, sizeof(_glfw.win32.scancodes));
-
-    _glfw.win32.keycodes[0x00B] = GLFW_KEY_0;
-    _glfw.win32.keycodes[0x002] = GLFW_KEY_1;
-    _glfw.win32.keycodes[0x003] = GLFW_KEY_2;
-    _glfw.win32.keycodes[0x004] = GLFW_KEY_3;
-    _glfw.win32.keycodes[0x005] = GLFW_KEY_4;
-    _glfw.win32.keycodes[0x006] = GLFW_KEY_5;
-    _glfw.win32.keycodes[0x007] = GLFW_KEY_6;
-    _glfw.win32.keycodes[0x008] = GLFW_KEY_7;
-    _glfw.win32.keycodes[0x009] = GLFW_KEY_8;
-    _glfw.win32.keycodes[0x00A] = GLFW_KEY_9;
-    _glfw.win32.keycodes[0x01E] = GLFW_KEY_A;
-    _glfw.win32.keycodes[0x030] = GLFW_KEY_B;
-    _glfw.win32.keycodes[0x02E] = GLFW_KEY_C;
-    _glfw.win32.keycodes[0x020] = GLFW_KEY_D;
-    _glfw.win32.keycodes[0x012] = GLFW_KEY_E;
-    _glfw.win32.keycodes[0x021] = GLFW_KEY_F;
-    _glfw.win32.keycodes[0x022] = GLFW_KEY_G;
-    _glfw.win32.keycodes[0x023] = GLFW_KEY_H;
-    _glfw.win32.keycodes[0x017] = GLFW_KEY_I;
-    _glfw.win32.keycodes[0x024] = GLFW_KEY_J;
-    _glfw.win32.keycodes[0x025] = GLFW_KEY_K;
-    _glfw.win32.keycodes[0x026] = GLFW_KEY_L;
-    _glfw.win32.keycodes[0x032] = GLFW_KEY_M;
-    _glfw.win32.keycodes[0x031] = GLFW_KEY_N;
-    _glfw.win32.keycodes[0x018] = GLFW_KEY_O;
-    _glfw.win32.keycodes[0x019] = GLFW_KEY_P;
-    _glfw.win32.keycodes[0x010] = GLFW_KEY_Q;
-    _glfw.win32.keycodes[0x013] = GLFW_KEY_R;
-    _glfw.win32.keycodes[0x01F] = GLFW_KEY_S;
-    _glfw.win32.keycodes[0x014] = GLFW_KEY_T;
-    _glfw.win32.keycodes[0x016] = GLFW_KEY_U;
-    _glfw.win32.keycodes[0x02F] = GLFW_KEY_V;
-    _glfw.win32.keycodes[0x011] = GLFW_KEY_W;
-    _glfw.win32.keycodes[0x02D] = GLFW_KEY_X;
-    _glfw.win32.keycodes[0x015] = GLFW_KEY_Y;
-    _glfw.win32.keycodes[0x02C] = GLFW_KEY_Z;
-
-    _glfw.win32.keycodes[0x028] = GLFW_KEY_APOSTROPHE;
-    _glfw.win32.keycodes[0x02B] = GLFW_KEY_BACKSLASH;
-    _glfw.win32.keycodes[0x033] = GLFW_KEY_COMMA;
-    _glfw.win32.keycodes[0x00D] = GLFW_KEY_EQUAL;
-    _glfw.win32.keycodes[0x029] = GLFW_KEY_GRAVE_ACCENT;
-    _glfw.win32.keycodes[0x01A] = GLFW_KEY_LEFT_BRACKET;
-    _glfw.win32.keycodes[0x00C] = GLFW_KEY_MINUS;
-    _glfw.win32.keycodes[0x034] = GLFW_KEY_PERIOD;
-    _glfw.win32.keycodes[0x01B] = GLFW_KEY_RIGHT_BRACKET;
-    _glfw.win32.keycodes[0x027] = GLFW_KEY_SEMICOLON;
-    _glfw.win32.keycodes[0x035] = GLFW_KEY_SLASH;
-    _glfw.win32.keycodes[0x056] = GLFW_KEY_WORLD_2;
-
-    _glfw.win32.keycodes[0x00E] = GLFW_KEY_BACKSPACE;
-    _glfw.win32.keycodes[0x153] = GLFW_KEY_DELETE;
-    _glfw.win32.keycodes[0x14F] = GLFW_KEY_END;
-    _glfw.win32.keycodes[0x01C] = GLFW_KEY_ENTER;
-    _glfw.win32.keycodes[0x001] = GLFW_KEY_ESCAPE;
-    _glfw.win32.keycodes[0x147] = GLFW_KEY_HOME;
-    _glfw.win32.keycodes[0x152] = GLFW_KEY_INSERT;
-    _glfw.win32.keycodes[0x15D] = GLFW_KEY_MENU;
-    _glfw.win32.keycodes[0x151] = GLFW_KEY_PAGE_DOWN;
-    _glfw.win32.keycodes[0x149] = GLFW_KEY_PAGE_UP;
-    _glfw.win32.keycodes[0x045] = GLFW_KEY_PAUSE;
-    _glfw.win32.keycodes[0x146] = GLFW_KEY_PAUSE;
-    _glfw.win32.keycodes[0x039] = GLFW_KEY_SPACE;
-    _glfw.win32.keycodes[0x00F] = GLFW_KEY_TAB;
-    _glfw.win32.keycodes[0x03A] = GLFW_KEY_CAPS_LOCK;
-    _glfw.win32.keycodes[0x145] = GLFW_KEY_NUM_LOCK;
-    _glfw.win32.keycodes[0x046] = GLFW_KEY_SCROLL_LOCK;
-    _glfw.win32.keycodes[0x03B] = GLFW_KEY_F1;
-    _glfw.win32.keycodes[0x03C] = GLFW_KEY_F2;
-    _glfw.win32.keycodes[0x03D] = GLFW_KEY_F3;
-    _glfw.win32.keycodes[0x03E] = GLFW_KEY_F4;
-    _glfw.win32.keycodes[0x03F] = GLFW_KEY_F5;
-    _glfw.win32.keycodes[0x040] = GLFW_KEY_F6;
-    _glfw.win32.keycodes[0x041] = GLFW_KEY_F7;
-    _glfw.win32.keycodes[0x042] = GLFW_KEY_F8;
-    _glfw.win32.keycodes[0x043] = GLFW_KEY_F9;
-    _glfw.win32.keycodes[0x044] = GLFW_KEY_F10;
-    _glfw.win32.keycodes[0x057] = GLFW_KEY_F11;
-    _glfw.win32.keycodes[0x058] = GLFW_KEY_F12;
-    _glfw.win32.keycodes[0x064] = GLFW_KEY_F13;
-    _glfw.win32.keycodes[0x065] = GLFW_KEY_F14;
-    _glfw.win32.keycodes[0x066] = GLFW_KEY_F15;
-    _glfw.win32.keycodes[0x067] = GLFW_KEY_F16;
-    _glfw.win32.keycodes[0x068] = GLFW_KEY_F17;
-    _glfw.win32.keycodes[0x069] = GLFW_KEY_F18;
-    _glfw.win32.keycodes[0x06A] = GLFW_KEY_F19;
-    _glfw.win32.keycodes[0x06B] = GLFW_KEY_F20;
-    _glfw.win32.keycodes[0x06C] = GLFW_KEY_F21;
-    _glfw.win32.keycodes[0x06D] = GLFW_KEY_F22;
-    _glfw.win32.keycodes[0x06E] = GLFW_KEY_F23;
-    _glfw.win32.keycodes[0x076] = GLFW_KEY_F24;
-    _glfw.win32.keycodes[0x038] = GLFW_KEY_LEFT_ALT;
-    _glfw.win32.keycodes[0x01D] = GLFW_KEY_LEFT_CONTROL;
-    _glfw.win32.keycodes[0x02A] = GLFW_KEY_LEFT_SHIFT;
-    _glfw.win32.keycodes[0x15B] = GLFW_KEY_LEFT_SUPER;
-    _glfw.win32.keycodes[0x137] = GLFW_KEY_PRINT_SCREEN;
-    _glfw.win32.keycodes[0x138] = GLFW_KEY_RIGHT_ALT;
-    _glfw.win32.keycodes[0x11D] = GLFW_KEY_RIGHT_CONTROL;
-    _glfw.win32.keycodes[0x036] = GLFW_KEY_RIGHT_SHIFT;
-    _glfw.win32.keycodes[0x15C] = GLFW_KEY_RIGHT_SUPER;
-    _glfw.win32.keycodes[0x150] = GLFW_KEY_DOWN;
-    _glfw.win32.keycodes[0x14B] = GLFW_KEY_LEFT;
-    _glfw.win32.keycodes[0x14D] = GLFW_KEY_RIGHT;
-    _glfw.win32.keycodes[0x148] = GLFW_KEY_UP;
-
-    _glfw.win32.keycodes[0x052] = GLFW_KEY_KP_0;
-    _glfw.win32.keycodes[0x04F] = GLFW_KEY_KP_1;
-    _glfw.win32.keycodes[0x050] = GLFW_KEY_KP_2;
-    _glfw.win32.keycodes[0x051] = GLFW_KEY_KP_3;
-    _glfw.win32.keycodes[0x04B] = GLFW_KEY_KP_4;
-    _glfw.win32.keycodes[0x04C] = GLFW_KEY_KP_5;
-    _glfw.win32.keycodes[0x04D] = GLFW_KEY_KP_6;
-    _glfw.win32.keycodes[0x047] = GLFW_KEY_KP_7;
-    _glfw.win32.keycodes[0x048] = GLFW_KEY_KP_8;
-    _glfw.win32.keycodes[0x049] = GLFW_KEY_KP_9;
-    _glfw.win32.keycodes[0x04E] = GLFW_KEY_KP_ADD;
-    _glfw.win32.keycodes[0x053] = GLFW_KEY_KP_DECIMAL;
-    _glfw.win32.keycodes[0x135] = GLFW_KEY_KP_DIVIDE;
-    _glfw.win32.keycodes[0x11C] = GLFW_KEY_KP_ENTER;
-    _glfw.win32.keycodes[0x059] = GLFW_KEY_KP_EQUAL;
-    _glfw.win32.keycodes[0x037] = GLFW_KEY_KP_MULTIPLY;
-    _glfw.win32.keycodes[0x04A] = GLFW_KEY_KP_SUBTRACT;
-
-    for (scancode = 0;  scancode < 512;  scancode++)
-    {
-        if (_glfw.win32.keycodes[scancode] > 0)
-            _glfw.win32.scancodes[_glfw.win32.keycodes[scancode]] = scancode;
-    }
-}
-
-// Creates a dummy window for behind-the-scenes work
-//
-static HWND createHelperWindow(void)
-{
-    MSG msg;
-    HWND window = CreateWindowExW(WS_EX_OVERLAPPEDWINDOW,
-                                  _GLFW_WNDCLASSNAME,
-                                  L"GLFW message window",
-                                  WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
-                                  0, 0, 1, 1,
-                                  NULL, NULL,
-                                  GetModuleHandleW(NULL),
-                                  NULL);
-    if (!window)
-    {
-        _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
-                             "Win32: Failed to create helper window");
-        return NULL;
-    }
-
-    // HACK: The command to the first ShowWindow call is ignored if the parent
-    //       process passed along a STARTUPINFO, so clear that with a no-op call
-    ShowWindow(window, SW_HIDE);
-
-    // Register for HID device notifications
-    {
-        DEV_BROADCAST_DEVICEINTERFACE_W dbi;
-        ZeroMemory(&dbi, sizeof(dbi));
-        dbi.dbcc_size = sizeof(dbi);
-        dbi.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
-        dbi.dbcc_classguid = GUID_DEVINTERFACE_HID;
-
-        _glfw.win32.deviceNotificationHandle =
-            RegisterDeviceNotificationW(window,
-                                        (DEV_BROADCAST_HDR*) &dbi,
-                                        DEVICE_NOTIFY_WINDOW_HANDLE);
-    }
-
-    while (PeekMessageW(&msg, _glfw.win32.helperWindowHandle, 0, 0, PM_REMOVE))
-    {
-        TranslateMessage(&msg);
-        DispatchMessageW(&msg);
-    }
-
-   return window;
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-//////                       GLFW internal API                      //////
-//////////////////////////////////////////////////////////////////////////
-
-// Returns a wide string version of the specified UTF-8 string
-//
-WCHAR* _glfwCreateWideStringFromUTF8Win32(const char* source)
-{
-    WCHAR* target;
-    int count;
-
-    count = MultiByteToWideChar(CP_UTF8, 0, source, -1, NULL, 0);
-    if (!count)
-    {
-        _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
-                             "Win32: Failed to convert string from UTF-8");
-        return NULL;
-    }
-
-    target = calloc(count, sizeof(WCHAR));
-
-    if (!MultiByteToWideChar(CP_UTF8, 0, source, -1, target, count))
-    {
-        _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
-                             "Win32: Failed to convert string from UTF-8");
-        free(target);
-        return NULL;
-    }
-
-    return target;
-}
-
-// Returns a UTF-8 string version of the specified wide string
-//
-char* _glfwCreateUTF8FromWideStringWin32(const WCHAR* source)
-{
-    char* target;
-    int size;
-
-    size = WideCharToMultiByte(CP_UTF8, 0, source, -1, NULL, 0, NULL, NULL);
-    if (!size)
-    {
-        _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
-                             "Win32: Failed to convert string to UTF-8");
-        return NULL;
-    }
-
-    target = calloc(size, 1);
-
-    if (!WideCharToMultiByte(CP_UTF8, 0, source, -1, target, size, NULL, NULL))
-    {
-        _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
-                             "Win32: Failed to convert string to UTF-8");
-        free(target);
-        return NULL;
-    }
-
-    return target;
-}
-
-// Reports the specified error, appending information about the last Win32 error
-//
-void _glfwInputErrorWin32(int error, const char* description)
-{
-    WCHAR buffer[_GLFW_MESSAGE_SIZE] = L"";
-    char message[_GLFW_MESSAGE_SIZE] = "";
-
-    FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM |
-                       FORMAT_MESSAGE_IGNORE_INSERTS |
-                       FORMAT_MESSAGE_MAX_WIDTH_MASK,
-                   NULL,
-                   GetLastError() & 0xffff,
-                   MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-                   buffer,
-                   sizeof(buffer),
-                   NULL);
-    WideCharToMultiByte(CP_UTF8, 0, buffer, -1, message, sizeof(message), NULL, NULL);
-
-    _glfwInputError(error, "%s: %s", description, message);
-}
-
-// Updates key names according to the current keyboard layout
-//
-void _glfwUpdateKeyNamesWin32(void)
-{
-    int key;
-    BYTE state[256] = {0};
-
-    memset(_glfw.win32.keynames, 0, sizeof(_glfw.win32.keynames));
-
-    for (key = GLFW_KEY_SPACE;  key <= GLFW_KEY_LAST;  key++)
-    {
-        UINT vk;
-        int scancode, length;
-        WCHAR chars[16];
-
-        scancode = _glfw.win32.scancodes[key];
-        if (scancode == -1)
-            continue;
-
-        if (key >= GLFW_KEY_KP_0 && key <= GLFW_KEY_KP_ADD)
-        {
-            const UINT vks[] = {
-                VK_NUMPAD0,  VK_NUMPAD1,  VK_NUMPAD2, VK_NUMPAD3,
-                VK_NUMPAD4,  VK_NUMPAD5,  VK_NUMPAD6, VK_NUMPAD7,
-                VK_NUMPAD8,  VK_NUMPAD9,  VK_DECIMAL, VK_DIVIDE,
-                VK_MULTIPLY, VK_SUBTRACT, VK_ADD
-            };
-
-            vk = vks[key - GLFW_KEY_KP_0];
-        }
-        else
-            vk = MapVirtualKey(scancode, MAPVK_VSC_TO_VK);
-
-        length = ToUnicode(vk, scancode, state,
-                           chars, sizeof(chars) / sizeof(WCHAR),
-                           0);
-
-        if (length == -1)
-        {
-            length = ToUnicode(vk, scancode, state,
-                               chars, sizeof(chars) / sizeof(WCHAR),
-                               0);
-        }
-
-        if (length < 1)
-            continue;
-
-        WideCharToMultiByte(CP_UTF8, 0, chars, 1,
-                            _glfw.win32.keynames[key],
-                            sizeof(_glfw.win32.keynames[key]),
-                            NULL, NULL);
-    }
-}
-
-// Replacement for IsWindowsVersionOrGreater as MinGW lacks versionhelpers.h
-//
-BOOL _glfwIsWindowsVersionOrGreaterWin32(WORD major, WORD minor, WORD sp)
-{
-    OSVERSIONINFOEXW osvi = { sizeof(osvi), major, minor, 0, 0, {0}, sp };
-    DWORD mask = VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR;
-    ULONGLONG cond = VerSetConditionMask(0, VER_MAJORVERSION, VER_GREATER_EQUAL);
-    cond = VerSetConditionMask(cond, VER_MINORVERSION, VER_GREATER_EQUAL);
-    cond = VerSetConditionMask(cond, VER_SERVICEPACKMAJOR, VER_GREATER_EQUAL);
-    // HACK: Use RtlVerifyVersionInfo instead of VerifyVersionInfoW as the
-    //       latter lies unless the user knew to embedd a non-default manifest
-    //       announcing support for Windows 10 via supportedOS GUID
-    return RtlVerifyVersionInfo(&osvi, mask, cond) == 0;
-}
-
-// Checks whether we are on at least the specified build of Windows 10
-//
-BOOL _glfwIsWindows10BuildOrGreaterWin32(WORD build)
-{
-    OSVERSIONINFOEXW osvi = { sizeof(osvi), 10, 0, build };
-    DWORD mask = VER_MAJORVERSION | VER_MINORVERSION | VER_BUILDNUMBER;
-    ULONGLONG cond = VerSetConditionMask(0, VER_MAJORVERSION, VER_GREATER_EQUAL);
-    cond = VerSetConditionMask(cond, VER_MINORVERSION, VER_GREATER_EQUAL);
-    cond = VerSetConditionMask(cond, VER_BUILDNUMBER, VER_GREATER_EQUAL);
-    // HACK: Use RtlVerifyVersionInfo instead of VerifyVersionInfoW as the
-    //       latter lies unless the user knew to embedd a non-default manifest
-    //       announcing support for Windows 10 via supportedOS GUID
-    return RtlVerifyVersionInfo(&osvi, mask, cond) == 0;
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-//////                       GLFW platform API                      //////
-//////////////////////////////////////////////////////////////////////////
-
-int _glfwPlatformInit(void)
-{
-    // To make SetForegroundWindow work as we want, we need to fiddle
-    // with the FOREGROUNDLOCKTIMEOUT system setting (we do this as early
-    // as possible in the hope of still being the foreground process)
-    SystemParametersInfoW(SPI_GETFOREGROUNDLOCKTIMEOUT, 0,
-                          &_glfw.win32.foregroundLockTimeout, 0);
-    SystemParametersInfoW(SPI_SETFOREGROUNDLOCKTIMEOUT, 0, UIntToPtr(0),
-                          SPIF_SENDCHANGE);
-
-    if (!loadLibraries())
-        return GLFW_FALSE;
-
-    createKeyTables();
-    _glfwUpdateKeyNamesWin32();
-
-    if (_glfwIsWindows10CreatorsUpdateOrGreaterWin32())
-        SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
-    else if (IsWindows8Point1OrGreater())
-        SetProcessDpiAwareness(PROCESS_PER_MONITOR_DPI_AWARE);
-    else if (IsWindowsVistaOrGreater())
-        SetProcessDPIAware();
-
-    if (!_glfwRegisterWindowClassWin32())
-        return GLFW_FALSE;
-
-    _glfw.win32.helperWindowHandle = createHelperWindow();
-    if (!_glfw.win32.helperWindowHandle)
-        return GLFW_FALSE;
-
-    _glfwInitTimerWin32();
-    _glfwInitJoysticksWin32();
-
-    _glfwPollMonitorsWin32();
-    return GLFW_TRUE;
-}
-
-void _glfwPlatformTerminate(void)
-{
-    if (_glfw.win32.deviceNotificationHandle)
-        UnregisterDeviceNotification(_glfw.win32.deviceNotificationHandle);
-
-    if (_glfw.win32.helperWindowHandle)
-        DestroyWindow(_glfw.win32.helperWindowHandle);
-
-    _glfwUnregisterWindowClassWin32();
-
-    // Restore previous foreground lock timeout system setting
-    SystemParametersInfoW(SPI_SETFOREGROUNDLOCKTIMEOUT, 0,
-                          UIntToPtr(_glfw.win32.foregroundLockTimeout),
-                          SPIF_SENDCHANGE);
-
-    free(_glfw.win32.clipboardString);
-    free(_glfw.win32.rawInput);
-
-    _glfwTerminateWGL();
-    _glfwTerminateEGL();
-
-    _glfwTerminateJoysticksWin32();
-
-    freeLibraries();
-}
-
-const char* _glfwPlatformGetVersionString(void)
-{
-    return _GLFW_VERSION_NUMBER " Win32 WGL EGL"
-#if defined(__MINGW32__)
-        " MinGW"
-#elif defined(_MSC_VER)
-        " VisualC"
-#endif
-#if defined(_GLFW_USE_HYBRID_HPG) || defined(_GLFW_USE_OPTIMUS_HPG)
-        " hybrid-GPU"
-#endif
-#if defined(_GLFW_BUILD_DLL)
-        " DLL"
-#endif
-        ;
-}
-

glfw/win32_joystick.c

@@ -1,751 +0,0 @@
-//========================================================================
-// GLFW 3.3 Win32 - www.glfw.org
-//------------------------------------------------------------------------
-// Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-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.
-//
-//========================================================================
-
-#include "internal.h"
-
-#include <stdio.h>
-#include <math.h>
-
-#define _GLFW_TYPE_AXIS     0
-#define _GLFW_TYPE_SLIDER   1
-#define _GLFW_TYPE_BUTTON   2
-#define _GLFW_TYPE_POV      3
-
-// Data produced with DirectInput device object enumeration
-//
-typedef struct _GLFWobjenumWin32
-{
-    IDirectInputDevice8W*   device;
-    _GLFWjoyobjectWin32*    objects;
-    int                     objectCount;
-    int                     axisCount;
-    int                     sliderCount;
-    int                     buttonCount;
-    int                     povCount;
-} _GLFWobjenumWin32;
-
-// Define local copies of the necessary GUIDs
-//
-static const GUID _glfw_IID_IDirectInput8W =
-    {0xbf798031,0x483a,0x4da2,{0xaa,0x99,0x5d,0x64,0xed,0x36,0x97,0x00}};
-static const GUID _glfw_GUID_XAxis =
-    {0xa36d02e0,0xc9f3,0x11cf,{0xbf,0xc7,0x44,0x45,0x53,0x54,0x00,0x00}};
-static const GUID _glfw_GUID_YAxis =
-    {0xa36d02e1,0xc9f3,0x11cf,{0xbf,0xc7,0x44,0x45,0x53,0x54,0x00,0x00}};
-static const GUID _glfw_GUID_ZAxis =
-    {0xa36d02e2,0xc9f3,0x11cf,{0xbf,0xc7,0x44,0x45,0x53,0x54,0x00,0x00}};
-static const GUID _glfw_GUID_RxAxis =
-    {0xa36d02f4,0xc9f3,0x11cf,{0xbf,0xc7,0x44,0x45,0x53,0x54,0x00,0x00}};
-static const GUID _glfw_GUID_RyAxis =
-    {0xa36d02f5,0xc9f3,0x11cf,{0xbf,0xc7,0x44,0x45,0x53,0x54,0x00,0x00}};
-static const GUID _glfw_GUID_RzAxis =
-    {0xa36d02e3,0xc9f3,0x11cf,{0xbf,0xc7,0x44,0x45,0x53,0x54,0x00,0x00}};
-static const GUID _glfw_GUID_Slider =
-    {0xa36d02e4,0xc9f3,0x11cf,{0xbf,0xc7,0x44,0x45,0x53,0x54,0x00,0x00}};
-static const GUID _glfw_GUID_POV =
-    {0xa36d02f2,0xc9f3,0x11cf,{0xbf,0xc7,0x44,0x45,0x53,0x54,0x00,0x00}};
-
-#define IID_IDirectInput8W _glfw_IID_IDirectInput8W
-#define GUID_XAxis _glfw_GUID_XAxis
-#define GUID_YAxis _glfw_GUID_YAxis
-#define GUID_ZAxis _glfw_GUID_ZAxis
-#define GUID_RxAxis _glfw_GUID_RxAxis
-#define GUID_RyAxis _glfw_GUID_RyAxis
-#define GUID_RzAxis _glfw_GUID_RzAxis
-#define GUID_Slider _glfw_GUID_Slider
-#define GUID_POV _glfw_GUID_POV
-
-// Object data array for our clone of c_dfDIJoystick
-// Generated with https://github.com/elmindreda/c_dfDIJoystick2
-//
-static DIOBJECTDATAFORMAT _glfwObjectDataFormats[] =
-{
-    { &GUID_XAxis,DIJOFS_X,DIDFT_AXIS|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,DIDOI_ASPECTPOSITION },
-    { &GUID_YAxis,DIJOFS_Y,DIDFT_AXIS|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,DIDOI_ASPECTPOSITION },
-    { &GUID_ZAxis,DIJOFS_Z,DIDFT_AXIS|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,DIDOI_ASPECTPOSITION },
-    { &GUID_RxAxis,DIJOFS_RX,DIDFT_AXIS|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,DIDOI_ASPECTPOSITION },
-    { &GUID_RyAxis,DIJOFS_RY,DIDFT_AXIS|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,DIDOI_ASPECTPOSITION },
-    { &GUID_RzAxis,DIJOFS_RZ,DIDFT_AXIS|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,DIDOI_ASPECTPOSITION },
-    { &GUID_Slider,DIJOFS_SLIDER(0),DIDFT_AXIS|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,DIDOI_ASPECTPOSITION },
-    { &GUID_Slider,DIJOFS_SLIDER(1),DIDFT_AXIS|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,DIDOI_ASPECTPOSITION },
-    { &GUID_POV,DIJOFS_POV(0),DIDFT_POV|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { &GUID_POV,DIJOFS_POV(1),DIDFT_POV|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { &GUID_POV,DIJOFS_POV(2),DIDFT_POV|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { &GUID_POV,DIJOFS_POV(3),DIDFT_POV|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(0),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(1),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(2),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(3),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(4),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(5),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(6),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(7),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(8),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(9),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(10),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(11),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(12),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(13),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(14),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(15),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(16),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(17),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(18),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(19),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(20),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(21),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(22),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(23),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(24),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(25),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(26),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(27),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(28),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(29),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(30),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-    { NULL,DIJOFS_BUTTON(31),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
-};
-
-// Our clone of c_dfDIJoystick
-//
-static const DIDATAFORMAT _glfwDataFormat =
-{
-    sizeof(DIDATAFORMAT),
-    sizeof(DIOBJECTDATAFORMAT),
-    DIDFT_ABSAXIS,
-    sizeof(DIJOYSTATE),
-    sizeof(_glfwObjectDataFormats) / sizeof(DIOBJECTDATAFORMAT),
-    _glfwObjectDataFormats
-};
-
-// Returns a description fitting the specified XInput capabilities
-//
-static const char* getDeviceDescription(const XINPUT_CAPABILITIES* xic)
-{
-    switch (xic->SubType)
-    {
-        case XINPUT_DEVSUBTYPE_WHEEL:
-            return "XInput Wheel";
-        case XINPUT_DEVSUBTYPE_ARCADE_STICK:
-            return "XInput Arcade Stick";
-        case XINPUT_DEVSUBTYPE_FLIGHT_STICK:
-            return "XInput Flight Stick";
-        case XINPUT_DEVSUBTYPE_DANCE_PAD:
-            return "XInput Dance Pad";
-        case XINPUT_DEVSUBTYPE_GUITAR:
-            return "XInput Guitar";
-        case XINPUT_DEVSUBTYPE_DRUM_KIT:
-            return "XInput Drum Kit";
-        case XINPUT_DEVSUBTYPE_GAMEPAD:
-        {
-            if (xic->Flags & XINPUT_CAPS_WIRELESS)
-                return "Wireless Xbox Controller";
-            else
-                return "Xbox Controller";
-        }
-    }
-
-    return "Unknown XInput Device";
-}
-
-// Lexically compare device objects
-//
-static int compareJoystickObjects(const void* first, const void* second)
-{
-    const _GLFWjoyobjectWin32* fo = first;
-    const _GLFWjoyobjectWin32* so = second;
-
-    if (fo->type != so->type)
-        return fo->type - so->type;
-
-    return fo->offset - so->offset;
-}
-
-// Checks whether the specified device supports XInput
-// Technique from FDInputJoystickManager::IsXInputDeviceFast in ZDoom
-//
-static GLFWbool supportsXInput(const GUID* guid)
-{
-    UINT i, count = 0;
-    RAWINPUTDEVICELIST* ridl;
-    GLFWbool result = GLFW_FALSE;
-
-    if (GetRawInputDeviceList(NULL, &count, sizeof(RAWINPUTDEVICELIST)) != 0)
-        return GLFW_FALSE;
-
-    ridl = calloc(count, sizeof(RAWINPUTDEVICELIST));
-
-    if (GetRawInputDeviceList(ridl, &count, sizeof(RAWINPUTDEVICELIST)) == (UINT) -1)
-    {
-        free(ridl);
-        return GLFW_FALSE;
-    }
-
-    for (i = 0;  i < count;  i++)
-    {
-        RID_DEVICE_INFO rdi;
-        char name[256];
-        UINT size;
-
-        if (ridl[i].dwType != RIM_TYPEHID)
-            continue;
-
-        ZeroMemory(&rdi, sizeof(rdi));
-        rdi.cbSize = sizeof(rdi);
-        size = sizeof(rdi);
-
-        if ((INT) GetRawInputDeviceInfoA(ridl[i].hDevice,
-                                         RIDI_DEVICEINFO,
-                                         &rdi, &size) == -1)
-        {
-            continue;
-        }
-
-        if (MAKELONG(rdi.hid.dwVendorId, rdi.hid.dwProductId) != (LONG) guid->Data1)
-            continue;
-
-        memset(name, 0, sizeof(name));
-        size = sizeof(name);
-
-        if ((INT) GetRawInputDeviceInfoA(ridl[i].hDevice,
-                                         RIDI_DEVICENAME,
-                                         name, &size) == -1)
-        {
-            break;
-        }
-
-        name[sizeof(name) - 1] = '\0';
-        if (strstr(name, "IG_"))
-        {
-            result = GLFW_TRUE;
-            break;
-        }
-    }
-
-    free(ridl);
-    return result;
-}
-
-// Frees all resources associated with the specified joystick
-//
-static void closeJoystick(_GLFWjoystick* js)
-{
-    if (js->win32.device)
-    {
-        IDirectInputDevice8_Unacquire(js->win32.device);
-        IDirectInputDevice8_Release(js->win32.device);
-    }
-
-    _glfwFreeJoystick(js);
-    _glfwInputJoystick(js, GLFW_DISCONNECTED);
-}
-
-// DirectInput device object enumeration callback
-// Insights gleaned from SDL
-//
-static BOOL CALLBACK deviceObjectCallback(const DIDEVICEOBJECTINSTANCEW* doi,
-                                          void* user)
-{
-    _GLFWobjenumWin32* data = user;
-    _GLFWjoyobjectWin32* object = data->objects + data->objectCount;
-
-    if (DIDFT_GETTYPE(doi->dwType) & DIDFT_AXIS)
-    {
-        DIPROPRANGE dipr;
-
-        if (memcmp(&doi->guidType, &GUID_Slider, sizeof(GUID)) == 0)
-            object->offset = DIJOFS_SLIDER(data->sliderCount);
-        else if (memcmp(&doi->guidType, &GUID_XAxis, sizeof(GUID)) == 0)
-            object->offset = DIJOFS_X;
-        else if (memcmp(&doi->guidType, &GUID_YAxis, sizeof(GUID)) == 0)
-            object->offset = DIJOFS_Y;
-        else if (memcmp(&doi->guidType, &GUID_ZAxis, sizeof(GUID)) == 0)
-            object->offset = DIJOFS_Z;
-        else if (memcmp(&doi->guidType, &GUID_RxAxis, sizeof(GUID)) == 0)
-            object->offset = DIJOFS_RX;
-        else if (memcmp(&doi->guidType, &GUID_RyAxis, sizeof(GUID)) == 0)
-            object->offset = DIJOFS_RY;
-        else if (memcmp(&doi->guidType, &GUID_RzAxis, sizeof(GUID)) == 0)
-            object->offset = DIJOFS_RZ;
-        else
-            return DIENUM_CONTINUE;
-
-        ZeroMemory(&dipr, sizeof(dipr));
-        dipr.diph.dwSize = sizeof(dipr);
-        dipr.diph.dwHeaderSize = sizeof(dipr.diph);
-        dipr.diph.dwObj = doi->dwType;
-        dipr.diph.dwHow = DIPH_BYID;
-        dipr.lMin = -32768;
-        dipr.lMax =  32767;
-
-        if (FAILED(IDirectInputDevice8_SetProperty(data->device,
-                                                   DIPROP_RANGE,
-                                                   &dipr.diph)))
-        {
-            return DIENUM_CONTINUE;
-        }
-
-        if (memcmp(&doi->guidType, &GUID_Slider, sizeof(GUID)) == 0)
-        {
-            object->type = _GLFW_TYPE_SLIDER;
-            data->sliderCount++;
-        }
-        else
-        {
-            object->type = _GLFW_TYPE_AXIS;
-            data->axisCount++;
-        }
-    }
-    else if (DIDFT_GETTYPE(doi->dwType) & DIDFT_BUTTON)
-    {
-        object->offset = DIJOFS_BUTTON(data->buttonCount);
-        object->type = _GLFW_TYPE_BUTTON;
-        data->buttonCount++;
-    }
-    else if (DIDFT_GETTYPE(doi->dwType) & DIDFT_POV)
-    {
-        object->offset = DIJOFS_POV(data->povCount);
-        object->type = _GLFW_TYPE_POV;
-        data->povCount++;
-    }
-
-    data->objectCount++;
-    return DIENUM_CONTINUE;
-}
-
-// DirectInput device enumeration callback
-//
-static BOOL CALLBACK deviceCallback(const DIDEVICEINSTANCE* di, void* user)
-{
-    int jid = 0;
-    DIDEVCAPS dc;
-    DIPROPDWORD dipd;
-    IDirectInputDevice8* device;
-    _GLFWobjenumWin32 data;
-    _GLFWjoystick* js;
-    char guid[33];
-    char name[256];
-
-    for (jid = 0;  jid <= GLFW_JOYSTICK_LAST;  jid++)
-    {
-        _GLFWjoystick* js = _glfw.joysticks + jid;
-        if (js->present)
-        {
-            if (memcmp(&js->win32.guid, &di->guidInstance, sizeof(GUID)) == 0)
-                return DIENUM_CONTINUE;
-        }
-    }
-
-    if (supportsXInput(&di->guidProduct))
-        return DIENUM_CONTINUE;
-
-    if (FAILED(IDirectInput8_CreateDevice(_glfw.win32.dinput8.api,
-                                          &di->guidInstance,
-                                          &device,
-                                          NULL)))
-    {
-        _glfwInputError(GLFW_PLATFORM_ERROR, "Win32: Failed to create device");
-        return DIENUM_CONTINUE;
-    }
-
-    if (FAILED(IDirectInputDevice8_SetDataFormat(device, &_glfwDataFormat)))
-    {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Win32: Failed to set device data format");
-
-        IDirectInputDevice8_Release(device);
-        return DIENUM_CONTINUE;
-    }
-
-    ZeroMemory(&dc, sizeof(dc));
-    dc.dwSize = sizeof(dc);
-
-    if (FAILED(IDirectInputDevice8_GetCapabilities(device, &dc)))
-    {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Win32: Failed to query device capabilities");
-
-        IDirectInputDevice8_Release(device);
-        return DIENUM_CONTINUE;
-    }
-
-    ZeroMemory(&dipd, sizeof(dipd));
-    dipd.diph.dwSize = sizeof(dipd);
-    dipd.diph.dwHeaderSize = sizeof(dipd.diph);
-    dipd.diph.dwHow = DIPH_DEVICE;
-    dipd.dwData = DIPROPAXISMODE_ABS;
-
-    if (FAILED(IDirectInputDevice8_SetProperty(device,
-                                               DIPROP_AXISMODE,
-                                               &dipd.diph)))
-    {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Win32: Failed to set device axis mode");
-
-        IDirectInputDevice8_Release(device);
-        return DIENUM_CONTINUE;
-    }
-
-    memset(&data, 0, sizeof(data));
-    data.device = device;
-    data.objects = calloc(dc.dwAxes + dc.dwButtons + dc.dwPOVs,
-                          sizeof(_GLFWjoyobjectWin32));
-
-    if (FAILED(IDirectInputDevice8_EnumObjects(device,
-                                               deviceObjectCallback,
-                                               &data,
-                                               DIDFT_AXIS | DIDFT_BUTTON | DIDFT_POV)))
-    {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Win32: Failed to enumerate device objects");
-
-        IDirectInputDevice8_Release(device);
-        free(data.objects);
-        return DIENUM_CONTINUE;
-    }
-
-    qsort(data.objects, data.objectCount,
-          sizeof(_GLFWjoyobjectWin32),
-          compareJoystickObjects);
-
-    if (!WideCharToMultiByte(CP_UTF8, 0,
-                             di->tszInstanceName, -1,
-                             name, sizeof(name),
-                             NULL, NULL))
-    {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Win32: Failed to convert joystick name to UTF-8");
-
-        IDirectInputDevice8_Release(device);
-        free(data.objects);
-        return DIENUM_STOP;
-    }
-
-    // Generate a joystick GUID that matches the SDL 2.0.5+ one
-    if (memcmp(&di->guidProduct.Data4[2], "PIDVID", 6) == 0)
-    {
-        sprintf(guid, "03000000%02x%02x0000%02x%02x000000000000",
-                (uint8_t) di->guidProduct.Data1,
-                (uint8_t) (di->guidProduct.Data1 >> 8),
-                (uint8_t) (di->guidProduct.Data1 >> 16),
-                (uint8_t) (di->guidProduct.Data1 >> 24));
-    }
-    else
-    {
-        sprintf(guid, "05000000%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x00",
-                name[0], name[1], name[2], name[3],
-                name[4], name[5], name[6], name[7],
-                name[8], name[9], name[10]);
-    }
-
-    js = _glfwAllocJoystick(name, guid,
-                            data.axisCount + data.sliderCount,
-                            data.buttonCount,
-                            data.povCount);
-    if (!js)
-    {
-        IDirectInputDevice8_Release(device);
-        free(data.objects);
-        return DIENUM_STOP;
-    }
-
-    js->win32.device = device;
-    js->win32.guid = di->guidInstance;
-    js->win32.objects = data.objects;
-    js->win32.objectCount = data.objectCount;
-
-    _glfwInputJoystick(js, GLFW_CONNECTED);
-    return DIENUM_CONTINUE;
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-//////                       GLFW internal API                      //////
-//////////////////////////////////////////////////////////////////////////
-
-// Initialize joystick interface
-//
-void _glfwInitJoysticksWin32(void)
-{
-    if (_glfw.win32.dinput8.instance)
-    {
-        if (FAILED(DirectInput8Create(GetModuleHandle(NULL),
-                                      DIRECTINPUT_VERSION,
-                                      &IID_IDirectInput8W,
-                                      (void**) &_glfw.win32.dinput8.api,
-                                      NULL)))
-        {
-            _glfwInputError(GLFW_PLATFORM_ERROR,
-                            "Win32: Failed to create interface");
-        }
-    }
-
-    _glfwDetectJoystickConnectionWin32();
-}
-
-// Close all opened joystick handles
-//
-void _glfwTerminateJoysticksWin32(void)
-{
-    int jid;
-
-    for (jid = GLFW_JOYSTICK_1;  jid <= GLFW_JOYSTICK_LAST;  jid++)
-        closeJoystick(_glfw.joysticks + jid);
-
-    if (_glfw.win32.dinput8.api)
-        IDirectInput8_Release(_glfw.win32.dinput8.api);
-}
-
-// Checks for new joysticks after DBT_DEVICEARRIVAL
-//
-void _glfwDetectJoystickConnectionWin32(void)
-{
-    if (_glfw.win32.xinput.instance)
-    {
-        DWORD index;
-
-        for (index = 0;  index < XUSER_MAX_COUNT;  index++)
-        {
-            int jid;
-            char guid[33];
-            XINPUT_CAPABILITIES xic;
-            _GLFWjoystick* js;
-
-            for (jid = 0;  jid <= GLFW_JOYSTICK_LAST;  jid++)
-            {
-                if (_glfw.joysticks[jid].present &&
-                    _glfw.joysticks[jid].win32.device == NULL &&
-                    _glfw.joysticks[jid].win32.index == index)
-                {
-                    break;
-                }
-            }
-
-            if (jid <= GLFW_JOYSTICK_LAST)
-                continue;
-
-            if (XInputGetCapabilities(index, 0, &xic) != ERROR_SUCCESS)
-                continue;
-
-            // Generate a joystick GUID that matches the SDL 2.0.5+ one
-            sprintf(guid, "78696e707574%02x000000000000000000",
-                    xic.SubType & 0xff);
-
-            js = _glfwAllocJoystick(getDeviceDescription(&xic), guid, 6, 10, 1);
-            if (!js)
-                continue;
-
-            js->win32.index = index;
-
-            _glfwInputJoystick(js, GLFW_CONNECTED);
-        }
-    }
-
-    if (_glfw.win32.dinput8.api)
-    {
-        if (FAILED(IDirectInput8_EnumDevices(_glfw.win32.dinput8.api,
-                                             DI8DEVCLASS_GAMECTRL,
-                                             deviceCallback,
-                                             NULL,
-                                             DIEDFL_ALLDEVICES)))
-        {
-            _glfwInputError(GLFW_PLATFORM_ERROR,
-                            "Failed to enumerate DirectInput8 devices");
-            return;
-        }
-    }
-}
-
-// Checks for joystick disconnection after DBT_DEVICEREMOVECOMPLETE
-//
-void _glfwDetectJoystickDisconnectionWin32(void)
-{
-    int jid;
-
-    for (jid = 0;  jid <= GLFW_JOYSTICK_LAST;  jid++)
-    {
-        _GLFWjoystick* js = _glfw.joysticks + jid;
-        if (js->present)
-            _glfwPlatformPollJoystick(js, _GLFW_POLL_PRESENCE);
-    }
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-//////                       GLFW platform API                      //////
-//////////////////////////////////////////////////////////////////////////
-
-int _glfwPlatformPollJoystick(_GLFWjoystick* js, int mode)
-{
-    if (js->win32.device)
-    {
-        int i, ai = 0, bi = 0, pi = 0;
-        HRESULT result;
-        DIJOYSTATE state;
-
-        IDirectInputDevice8_Poll(js->win32.device);
-        result = IDirectInputDevice8_GetDeviceState(js->win32.device,
-                                                    sizeof(state),
-                                                    &state);
-        if (result == DIERR_NOTACQUIRED || result == DIERR_INPUTLOST)
-        {
-            IDirectInputDevice8_Acquire(js->win32.device);
-            IDirectInputDevice8_Poll(js->win32.device);
-            result = IDirectInputDevice8_GetDeviceState(js->win32.device,
-                                                        sizeof(state),
-                                                        &state);
-        }
-
-        if (FAILED(result))
-        {
-            closeJoystick(js);
-            return GLFW_FALSE;
-        }
-
-        if (mode == _GLFW_POLL_PRESENCE)
-            return GLFW_TRUE;
-
-        for (i = 0;  i < js->win32.objectCount;  i++)
-        {
-            const void* data = (char*) &state + js->win32.objects[i].offset;
-
-            switch (js->win32.objects[i].type)
-            {
-                case _GLFW_TYPE_AXIS:
-                case _GLFW_TYPE_SLIDER:
-                {
-                    const float value = (*((LONG*) data) + 0.5f) / 32767.5f;
-                    _glfwInputJoystickAxis(js, ai, value);
-                    ai++;
-                    break;
-                }
-
-                case _GLFW_TYPE_BUTTON:
-                {
-                    const char value = (*((BYTE*) data) & 0x80) != 0;
-                    _glfwInputJoystickButton(js, bi, value);
-                    bi++;
-                    break;
-                }
-
-                case _GLFW_TYPE_POV:
-                {
-                    const int states[9] =
-                    {
-                        GLFW_HAT_UP,
-                        GLFW_HAT_RIGHT_UP,
-                        GLFW_HAT_RIGHT,
-                        GLFW_HAT_RIGHT_DOWN,
-                        GLFW_HAT_DOWN,
-                        GLFW_HAT_LEFT_DOWN,
-                        GLFW_HAT_LEFT,
-                        GLFW_HAT_LEFT_UP,
-                        GLFW_HAT_CENTERED
-                    };
-
-                    // Screams of horror are appropriate at this point
-                    int state = LOWORD(*(DWORD*) data) / (45 * DI_DEGREES);
-                    if (state < 0 || state > 8)
-                        state = 8;
-
-                    _glfwInputJoystickHat(js, pi, states[state]);
-                    pi++;
-                    break;
-                }
-            }
-        }
-    }
-    else
-    {
-        int i, dpad = 0;
-        DWORD result;
-        XINPUT_STATE xis;
-        const WORD buttons[10] =
-        {
-            XINPUT_GAMEPAD_A,
-            XINPUT_GAMEPAD_B,
-            XINPUT_GAMEPAD_X,
-            XINPUT_GAMEPAD_Y,
-            XINPUT_GAMEPAD_LEFT_SHOULDER,
-            XINPUT_GAMEPAD_RIGHT_SHOULDER,
-            XINPUT_GAMEPAD_BACK,
-            XINPUT_GAMEPAD_START,
-            XINPUT_GAMEPAD_LEFT_THUMB,
-            XINPUT_GAMEPAD_RIGHT_THUMB
-        };
-
-        result = XInputGetState(js->win32.index, &xis);
-        if (result != ERROR_SUCCESS)
-        {
-            if (result == ERROR_DEVICE_NOT_CONNECTED)
-                closeJoystick(js);
-
-            return GLFW_FALSE;
-        }
-
-        if (mode == _GLFW_POLL_PRESENCE)
-            return GLFW_TRUE;
-
-        _glfwInputJoystickAxis(js, 0, (xis.Gamepad.sThumbLX + 0.5f) / 32767.5f);
-        _glfwInputJoystickAxis(js, 1, -(xis.Gamepad.sThumbLY + 0.5f) / 32767.5f);
-        _glfwInputJoystickAxis(js, 2, (xis.Gamepad.sThumbRX + 0.5f) / 32767.5f);
-        _glfwInputJoystickAxis(js, 3, -(xis.Gamepad.sThumbRY + 0.5f) / 32767.5f);
-        _glfwInputJoystickAxis(js, 4, xis.Gamepad.bLeftTrigger / 127.5f - 1.f);
-        _glfwInputJoystickAxis(js, 5, xis.Gamepad.bRightTrigger / 127.5f - 1.f);
-
-        for (i = 0;  i < 10;  i++)
-        {
-            const char value = (xis.Gamepad.wButtons & buttons[i]) ? 1 : 0;
-            _glfwInputJoystickButton(js, i, value);
-        }
-
-        if (xis.Gamepad.wButtons & XINPUT_GAMEPAD_DPAD_UP)
-            dpad |= GLFW_HAT_UP;
-        if (xis.Gamepad.wButtons & XINPUT_GAMEPAD_DPAD_RIGHT)
-            dpad |= GLFW_HAT_RIGHT;
-        if (xis.Gamepad.wButtons & XINPUT_GAMEPAD_DPAD_DOWN)
-            dpad |= GLFW_HAT_DOWN;
-        if (xis.Gamepad.wButtons & XINPUT_GAMEPAD_DPAD_LEFT)
-            dpad |= GLFW_HAT_LEFT;
-
-        _glfwInputJoystickHat(js, 0, dpad);
-    }
-
-    return GLFW_TRUE;
-}
-
-void _glfwPlatformUpdateGamepadGUID(char* guid)
-{
-    if (strcmp(guid + 20, "504944564944") == 0)
-    {
-        char original[33];
-        strcpy(original, guid);
-        sprintf(guid, "03000000%.4s0000%.4s000000000000",
-                original, original + 4);
-    }
-}
-

glfw/win32_joystick.h

@@ -1,56 +0,0 @@
-//========================================================================
-// GLFW 3.3 Win32 - www.glfw.org
-//------------------------------------------------------------------------
-// Copyright (c) 2006-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.
-//
-//========================================================================
-
-#define _GLFW_PLATFORM_JOYSTICK_STATE         _GLFWjoystickWin32 win32
-#define _GLFW_PLATFORM_LIBRARY_JOYSTICK_STATE int dummy
-
-#define _GLFW_PLATFORM_MAPPING_NAME "Windows"
-
-// Joystick element (axis, button or slider)
-//
-typedef struct _GLFWjoyobjectWin32
-{
-    int                     offset;
-    int                     type;
-} _GLFWjoyobjectWin32;
-
-// Win32-specific per-joystick data
-//
-typedef struct _GLFWjoystickWin32
-{
-    _GLFWjoyobjectWin32*    objects;
-    int                     objectCount;
-    IDirectInputDevice8W*   device;
-    DWORD                   index;
-    GUID                    guid;
-} _GLFWjoystickWin32;
-
-
-void _glfwInitJoysticksWin32(void);
-void _glfwTerminateJoysticksWin32(void);
-void _glfwDetectJoystickConnectionWin32(void);
-void _glfwDetectJoystickDisconnectionWin32(void);
-

glfw/win32_monitor.c

@@ -1,513 +0,0 @@
-//========================================================================
-// GLFW 3.3 Win32 - www.glfw.org
-//------------------------------------------------------------------------
-// Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-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.
-//
-//========================================================================
-
-#include "internal.h"
-
-#include <stdlib.h>
-#include <string.h>
-#include <limits.h>
-#include <malloc.h>
-
-
-// Callback for EnumDisplayMonitors in createMonitor
-//
-static BOOL CALLBACK monitorCallback(HMONITOR handle,
-                                     HDC dc,
-                                     RECT* rect,
-                                     LPARAM data)
-{
-    MONITORINFOEXW mi;
-    ZeroMemory(&mi, sizeof(mi));
-    mi.cbSize = sizeof(mi);
-
-    if (GetMonitorInfoW(handle, (MONITORINFO*) &mi))
-    {
-        _GLFWmonitor* monitor = (_GLFWmonitor*) data;
-        if (wcscmp(mi.szDevice, monitor->win32.adapterName) == 0)
-            monitor->win32.handle = handle;
-    }
-
-    return TRUE;
-}
-
-// Create monitor from an adapter and (optionally) a display
-//
-static _GLFWmonitor* createMonitor(DISPLAY_DEVICEW* adapter,
-                                   DISPLAY_DEVICEW* display)
-{
-    _GLFWmonitor* monitor;
-    int widthMM, heightMM;
-    char* name;
-    HDC dc;
-    DEVMODEW dm;
-    RECT rect;
-
-    if (display)
-        name = _glfwCreateUTF8FromWideStringWin32(display->DeviceString);
-    else
-        name = _glfwCreateUTF8FromWideStringWin32(adapter->DeviceString);
-    if (!name)
-        return NULL;
-
-    ZeroMemory(&dm, sizeof(dm));
-    dm.dmSize = sizeof(dm);
-    EnumDisplaySettingsW(adapter->DeviceName, ENUM_CURRENT_SETTINGS, &dm);
-
-    dc = CreateDCW(L"DISPLAY", adapter->DeviceName, NULL, NULL);
-
-    if (IsWindows8Point1OrGreater())
-    {
-        widthMM  = GetDeviceCaps(dc, HORZSIZE);
-        heightMM = GetDeviceCaps(dc, VERTSIZE);
-    }
-    else
-    {
-        widthMM  = (int) (dm.dmPelsWidth * 25.4f / GetDeviceCaps(dc, LOGPIXELSX));
-        heightMM = (int) (dm.dmPelsHeight * 25.4f / GetDeviceCaps(dc, LOGPIXELSY));
-    }
-
-    DeleteDC(dc);
-
-    monitor = _glfwAllocMonitor(name, widthMM, heightMM);
-    free(name);
-
-    if (adapter->StateFlags & DISPLAY_DEVICE_MODESPRUNED)
-        monitor->win32.modesPruned = GLFW_TRUE;
-
-    wcscpy(monitor->win32.adapterName, adapter->DeviceName);
-    WideCharToMultiByte(CP_UTF8, 0,
-                        adapter->DeviceName, -1,
-                        monitor->win32.publicAdapterName,
-                        sizeof(monitor->win32.publicAdapterName),
-                        NULL, NULL);
-
-    if (display)
-    {
-        wcscpy(monitor->win32.displayName, display->DeviceName);
-        WideCharToMultiByte(CP_UTF8, 0,
-                            display->DeviceName, -1,
-                            monitor->win32.publicDisplayName,
-                            sizeof(monitor->win32.publicDisplayName),
-                            NULL, NULL);
-    }
-
-    rect.left   = dm.dmPosition.x;
-    rect.top    = dm.dmPosition.y;
-    rect.right  = dm.dmPosition.x + dm.dmPelsWidth;
-    rect.bottom = dm.dmPosition.y + dm.dmPelsHeight;
-
-    EnumDisplayMonitors(NULL, &rect, monitorCallback, (LPARAM) monitor);
-    return monitor;
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-//////                       GLFW internal API                      //////
-//////////////////////////////////////////////////////////////////////////
-
-// Poll for changes in the set of connected monitors
-//
-void _glfwPollMonitorsWin32(void)
-{
-    int i, disconnectedCount;
-    _GLFWmonitor** disconnected = NULL;
-    DWORD adapterIndex, displayIndex;
-    DISPLAY_DEVICEW adapter, display;
-    _GLFWmonitor* monitor;
-
-    disconnectedCount = _glfw.monitorCount;
-    if (disconnectedCount)
-    {
-        disconnected = calloc(_glfw.monitorCount, sizeof(_GLFWmonitor*));
-        memcpy(disconnected,
-               _glfw.monitors,
-               _glfw.monitorCount * sizeof(_GLFWmonitor*));
-    }
-
-    for (adapterIndex = 0;  ;  adapterIndex++)
-    {
-        int type = _GLFW_INSERT_LAST;
-
-        ZeroMemory(&adapter, sizeof(adapter));
-        adapter.cb = sizeof(adapter);
-
-        if (!EnumDisplayDevicesW(NULL, adapterIndex, &adapter, 0))
-            break;
-
-        if (!(adapter.StateFlags & DISPLAY_DEVICE_ACTIVE))
-            continue;
-
-        if (adapter.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE)
-            type = _GLFW_INSERT_FIRST;
-
-        for (displayIndex = 0;  ;  displayIndex++)
-        {
-            ZeroMemory(&display, sizeof(display));
-            display.cb = sizeof(display);
-
-            if (!EnumDisplayDevicesW(adapter.DeviceName, displayIndex, &display, 0))
-                break;
-
-            if (!(display.StateFlags & DISPLAY_DEVICE_ACTIVE))
-                continue;
-
-            for (i = 0;  i < disconnectedCount;  i++)
-            {
-                if (disconnected[i] &&
-                    wcscmp(disconnected[i]->win32.displayName,
-                           display.DeviceName) == 0)
-                {
-                    disconnected[i] = NULL;
-                    break;
-                }
-            }
-
-            if (i < disconnectedCount)
-                continue;
-
-            monitor = createMonitor(&adapter, &display);
-            if (!monitor)
-            {
-                free(disconnected);
-                return;
-            }
-
-            _glfwInputMonitor(monitor, GLFW_CONNECTED, type);
-
-            type = _GLFW_INSERT_LAST;
-        }
-
-        // HACK: If an active adapter does not have any display devices
-        //       (as sometimes happens), add it directly as a monitor
-        if (displayIndex == 0)
-        {
-            for (i = 0;  i < disconnectedCount;  i++)
-            {
-                if (disconnected[i] &&
-                    wcscmp(disconnected[i]->win32.adapterName,
-                           adapter.DeviceName) == 0)
-                {
-                    disconnected[i] = NULL;
-                    break;
-                }
-            }
-
-            if (i < disconnectedCount)
-                continue;
-
-            monitor = createMonitor(&adapter, NULL);
-            if (!monitor)
-            {
-                free(disconnected);
-                return;
-            }
-
-            _glfwInputMonitor(monitor, GLFW_CONNECTED, type);
-        }
-    }
-
-    for (i = 0;  i < disconnectedCount;  i++)
-    {
-        if (disconnected[i])
-            _glfwInputMonitor(disconnected[i], GLFW_DISCONNECTED, 0);
-    }
-
-    free(disconnected);
-}
-
-// Change the current video mode
-//
-void _glfwSetVideoModeWin32(_GLFWmonitor* monitor, const GLFWvidmode* desired)
-{
-    GLFWvidmode current;
-    const GLFWvidmode* best;
-    DEVMODEW dm;
-    LONG result;
-
-    best = _glfwChooseVideoMode(monitor, desired);
-    _glfwPlatformGetVideoMode(monitor, &current);
-    if (_glfwCompareVideoModes(&current, best) == 0)
-        return;
-
-    ZeroMemory(&dm, sizeof(dm));
-    dm.dmSize = sizeof(dm);
-    dm.dmFields           = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL |
-                            DM_DISPLAYFREQUENCY;
-    dm.dmPelsWidth        = best->width;
-    dm.dmPelsHeight       = best->height;
-    dm.dmBitsPerPel       = best->redBits + best->greenBits + best->blueBits;
-    dm.dmDisplayFrequency = best->refreshRate;
-
-    if (dm.dmBitsPerPel < 15 || dm.dmBitsPerPel >= 24)
-        dm.dmBitsPerPel = 32;
-
-    result = ChangeDisplaySettingsExW(monitor->win32.adapterName,
-                                      &dm,
-                                      NULL,
-                                      CDS_FULLSCREEN,
-                                      NULL);
-    if (result == DISP_CHANGE_SUCCESSFUL)
-        monitor->win32.modeChanged = GLFW_TRUE;
-    else
-    {
-        const char* description = "Unknown error";
-
-        if (result == DISP_CHANGE_BADDUALVIEW)
-            description = "The system uses DualView";
-        else if (result == DISP_CHANGE_BADFLAGS)
-            description = "Invalid flags";
-        else if (result == DISP_CHANGE_BADMODE)
-            description = "Graphics mode not supported";
-        else if (result == DISP_CHANGE_BADPARAM)
-            description = "Invalid parameter";
-        else if (result == DISP_CHANGE_FAILED)
-            description = "Graphics mode failed";
-        else if (result == DISP_CHANGE_NOTUPDATED)
-            description = "Failed to write to registry";
-        else if (result == DISP_CHANGE_RESTART)
-            description = "Computer restart required";
-
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Win32: Failed to set video mode: %s",
-                        description);
-    }
-}
-
-// Restore the previously saved (original) video mode
-//
-void _glfwRestoreVideoModeWin32(_GLFWmonitor* monitor)
-{
-    if (monitor->win32.modeChanged)
-    {
-        ChangeDisplaySettingsExW(monitor->win32.adapterName,
-                                 NULL, NULL, CDS_FULLSCREEN, NULL);
-        monitor->win32.modeChanged = GLFW_FALSE;
-    }
-}
-
-void _glfwGetMonitorContentScaleWin32(HMONITOR handle, float* xscale, float* yscale)
-{
-    UINT xdpi, ydpi;
-
-    if (IsWindows8Point1OrGreater())
-        GetDpiForMonitor(handle, MDT_EFFECTIVE_DPI, &xdpi, &ydpi);
-    else
-    {
-        const HDC dc = GetDC(NULL);
-        xdpi = GetDeviceCaps(dc, LOGPIXELSX);
-        ydpi = GetDeviceCaps(dc, LOGPIXELSY);
-        ReleaseDC(NULL, dc);
-    }
-
-    if (xscale)
-        *xscale = xdpi / (float) USER_DEFAULT_SCREEN_DPI;
-    if (yscale)
-        *yscale = ydpi / (float) USER_DEFAULT_SCREEN_DPI;
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-//////                       GLFW platform API                      //////
-//////////////////////////////////////////////////////////////////////////
-
-void _glfwPlatformFreeMonitor(_GLFWmonitor* monitor)
-{
-}
-
-void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
-{
-    DEVMODEW dm;
-    ZeroMemory(&dm, sizeof(dm));
-    dm.dmSize = sizeof(dm);
-
-    EnumDisplaySettingsExW(monitor->win32.adapterName,
-                           ENUM_CURRENT_SETTINGS,
-                           &dm,
-                           EDS_ROTATEDMODE);
-
-    if (xpos)
-        *xpos = dm.dmPosition.x;
-    if (ypos)
-        *ypos = dm.dmPosition.y;
-}
-
-void _glfwPlatformGetMonitorContentScale(_GLFWmonitor* monitor,
-                                         float* xscale, float* yscale)
-{
-    _glfwGetMonitorContentScaleWin32(monitor->win32.handle, xscale, yscale);
-}
-
-GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* count)
-{
-    int modeIndex = 0, size = 0;
-    GLFWvidmode* result = NULL;
-
-    *count = 0;
-
-    for (;;)
-    {
-        int i;
-        GLFWvidmode mode;
-        DEVMODEW dm;
-
-        ZeroMemory(&dm, sizeof(dm));
-        dm.dmSize = sizeof(dm);
-
-        if (!EnumDisplaySettingsW(monitor->win32.adapterName, modeIndex, &dm))
-            break;
-
-        modeIndex++;
-
-        // Skip modes with less than 15 BPP
-        if (dm.dmBitsPerPel < 15)
-            continue;
-
-        mode.width  = dm.dmPelsWidth;
-        mode.height = dm.dmPelsHeight;
-        mode.refreshRate = dm.dmDisplayFrequency;
-        _glfwSplitBPP(dm.dmBitsPerPel,
-                      &mode.redBits,
-                      &mode.greenBits,
-                      &mode.blueBits);
-
-        for (i = 0;  i < *count;  i++)
-        {
-            if (_glfwCompareVideoModes(result + i, &mode) == 0)
-                break;
-        }
-
-        // Skip duplicate modes
-        if (i < *count)
-            continue;
-
-        if (monitor->win32.modesPruned)
-        {
-            // Skip modes not supported by the connected displays
-            if (ChangeDisplaySettingsExW(monitor->win32.adapterName,
-                                         &dm,
-                                         NULL,
-                                         CDS_TEST,
-                                         NULL) != DISP_CHANGE_SUCCESSFUL)
-            {
-                continue;
-            }
-        }
-
-        if (*count == size)
-        {
-            size += 128;
-            result = (GLFWvidmode*) realloc(result, size * sizeof(GLFWvidmode));
-        }
-
-        (*count)++;
-        result[*count - 1] = mode;
-    }
-
-    if (!*count)
-    {
-        // HACK: Report the current mode if no valid modes were found
-        result = calloc(1, sizeof(GLFWvidmode));
-        _glfwPlatformGetVideoMode(monitor, result);
-        *count = 1;
-    }
-
-    return result;
-}
-
-void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode)
-{
-    DEVMODEW dm;
-    ZeroMemory(&dm, sizeof(dm));
-    dm.dmSize = sizeof(dm);
-
-    EnumDisplaySettingsW(monitor->win32.adapterName, ENUM_CURRENT_SETTINGS, &dm);
-
-    mode->width  = dm.dmPelsWidth;
-    mode->height = dm.dmPelsHeight;
-    mode->refreshRate = dm.dmDisplayFrequency;
-    _glfwSplitBPP(dm.dmBitsPerPel,
-                  &mode->redBits,
-                  &mode->greenBits,
-                  &mode->blueBits);
-}
-
-void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
-{
-    HDC dc;
-    WORD values[768];
-
-    dc = CreateDCW(L"DISPLAY", monitor->win32.adapterName, NULL, NULL);
-    GetDeviceGammaRamp(dc, values);
-    DeleteDC(dc);
-
-    _glfwAllocGammaArrays(ramp, 256);
-
-    memcpy(ramp->red,   values +   0, 256 * sizeof(unsigned short));
-    memcpy(ramp->green, values + 256, 256 * sizeof(unsigned short));
-    memcpy(ramp->blue,  values + 512, 256 * sizeof(unsigned short));
-}
-
-void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
-{
-    HDC dc;
-    WORD values[768];
-
-    if (ramp->size != 256)
-    {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Win32: Gamma ramp size must be 256");
-        return;
-    }
-
-    memcpy(values +   0, ramp->red,   256 * sizeof(unsigned short));
-    memcpy(values + 256, ramp->green, 256 * sizeof(unsigned short));
-    memcpy(values + 512, ramp->blue,  256 * sizeof(unsigned short));
-
-    dc = CreateDCW(L"DISPLAY", monitor->win32.adapterName, NULL, NULL);
-    SetDeviceGammaRamp(dc, values);
-    DeleteDC(dc);
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-//////                        GLFW native API                       //////
-//////////////////////////////////////////////////////////////////////////
-
-GLFWAPI const char* glfwGetWin32Adapter(GLFWmonitor* handle)
-{
-    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-    return monitor->win32.publicAdapterName;
-}
-
-GLFWAPI const char* glfwGetWin32Monitor(GLFWmonitor* handle)
-{
-    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-    return monitor->win32.publicDisplayName;
-}
-

glfw/win32_platform.h

@@ -1,449 +0,0 @@
-//========================================================================
-// GLFW 3.3 Win32 - www.glfw.org
-//------------------------------------------------------------------------
-// Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-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.
-//
-//========================================================================
-
-// We don't need all the fancy stuff
-#ifndef NOMINMAX
- #define NOMINMAX
-#endif
-
-#ifndef VC_EXTRALEAN
- #define VC_EXTRALEAN
-#endif
-
-#ifndef WIN32_LEAN_AND_MEAN
- #define WIN32_LEAN_AND_MEAN
-#endif
-
-// This is a workaround for the fact that glfw3.h needs to export APIENTRY (for
-// example to allow applications to correctly declare a GL_ARB_debug_output
-// callback) but windows.h assumes no one will define APIENTRY before it does
-#undef APIENTRY
-
-// GLFW on Windows is Unicode only and does not work in MBCS mode
-#ifndef UNICODE
- #define UNICODE
-#endif
-
-// GLFW requires Windows XP or later
-#if WINVER < 0x0501
- #undef WINVER
- #define WINVER 0x0501
-#endif
-#if _WIN32_WINNT < 0x0501
- #undef _WIN32_WINNT
- #define _WIN32_WINNT 0x0501
-#endif
-
-// GLFW uses DirectInput8 interfaces
-#define DIRECTINPUT_VERSION 0x0800
-
-#include <wctype.h>
-#include <windows.h>
-#include <dinput.h>
-#include <xinput.h>
-#include <dbt.h>
-
-// HACK: Define macros that some windows.h variants don't
-#ifndef WM_MOUSEHWHEEL
- #define WM_MOUSEHWHEEL 0x020E
-#endif
-#ifndef WM_DWMCOMPOSITIONCHANGED
- #define WM_DWMCOMPOSITIONCHANGED 0x031E
-#endif
-#ifndef WM_COPYGLOBALDATA
- #define WM_COPYGLOBALDATA 0x0049
-#endif
-#ifndef WM_UNICHAR
- #define WM_UNICHAR 0x0109
-#endif
-#ifndef UNICODE_NOCHAR
- #define UNICODE_NOCHAR 0xFFFF
-#endif
-#ifndef WM_DPICHANGED
- #define WM_DPICHANGED 0x02E0
-#endif
-#ifndef GET_XBUTTON_WPARAM
- #define GET_XBUTTON_WPARAM(w) (HIWORD(w))
-#endif
-#ifndef EDS_ROTATEDMODE
- #define EDS_ROTATEDMODE 0x00000004
-#endif
-#ifndef DISPLAY_DEVICE_ACTIVE
- #define DISPLAY_DEVICE_ACTIVE 0x00000001
-#endif
-#ifndef _WIN32_WINNT_WINBLUE
- #define _WIN32_WINNT_WINBLUE 0x0602
-#endif
-#ifndef WM_GETDPISCALEDSIZE
- #define WM_GETDPISCALEDSIZE 0x02e4
-#endif
-#ifndef USER_DEFAULT_SCREEN_DPI
- #define USER_DEFAULT_SCREEN_DPI 96
-#endif
-
-#if WINVER < 0x0601
-typedef struct
-{
-    DWORD cbSize;
-    DWORD ExtStatus;
-} CHANGEFILTERSTRUCT;
-#ifndef MSGFLT_ALLOW
- #define MSGFLT_ALLOW 1
-#endif
-#endif /*Windows 7*/
-
-#if WINVER < 0x0600
-#define DWM_BB_ENABLE 0x00000001
-#define DWM_BB_BLURREGION 0x00000002
-typedef struct
-{
-    DWORD dwFlags;
-    BOOL fEnable;
-    HRGN hRgnBlur;
-    BOOL fTransitionOnMaximized;
-} DWM_BLURBEHIND;
-#else
- #include <dwmapi.h>
-#endif /*Windows Vista*/
-
-#ifndef DPI_ENUMS_DECLARED
-typedef enum
-{
-    PROCESS_DPI_UNAWARE = 0,
-    PROCESS_SYSTEM_DPI_AWARE = 1,
-    PROCESS_PER_MONITOR_DPI_AWARE = 2
-} PROCESS_DPI_AWARENESS;
-typedef enum
-{
-    MDT_EFFECTIVE_DPI = 0,
-    MDT_ANGULAR_DPI = 1,
-    MDT_RAW_DPI = 2,
-    MDT_DEFAULT = MDT_EFFECTIVE_DPI
-} MONITOR_DPI_TYPE;
-#endif /*DPI_ENUMS_DECLARED*/
-
-#ifndef DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2
-DECLARE_HANDLE(DPI_AWARENESS_CONTEXT);
-#define DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2 ((DPI_AWARENESS_CONTEXT) -4)
-#endif /*DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2*/
-
-// HACK: Define versionhelpers.h functions manually as MinGW lacks the header
-#define IsWindowsXPOrGreater()                                 \
-    _glfwIsWindowsVersionOrGreaterWin32(HIBYTE(_WIN32_WINNT_WINXP),   \
-                                        LOBYTE(_WIN32_WINNT_WINXP), 0)
-#define IsWindowsVistaOrGreater()                                     \
-    _glfwIsWindowsVersionOrGreaterWin32(HIBYTE(_WIN32_WINNT_VISTA),   \
-                                        LOBYTE(_WIN32_WINNT_VISTA), 0)
-#define IsWindows7OrGreater()                                         \
-    _glfwIsWindowsVersionOrGreaterWin32(HIBYTE(_WIN32_WINNT_WIN7),    \
-                                        LOBYTE(_WIN32_WINNT_WIN7), 0)
-#define IsWindows8OrGreater()                                         \
-    _glfwIsWindowsVersionOrGreaterWin32(HIBYTE(_WIN32_WINNT_WIN8),    \
-                                        LOBYTE(_WIN32_WINNT_WIN8), 0)
-#define IsWindows8Point1OrGreater()                                   \
-    _glfwIsWindowsVersionOrGreaterWin32(HIBYTE(_WIN32_WINNT_WINBLUE), \
-                                        LOBYTE(_WIN32_WINNT_WINBLUE), 0)
-
-#define _glfwIsWindows10AnniversaryUpdateOrGreaterWin32() \
-    _glfwIsWindows10BuildOrGreaterWin32(14393)
-#define _glfwIsWindows10CreatorsUpdateOrGreaterWin32() \
-    _glfwIsWindows10BuildOrGreaterWin32(15063)
-
-// HACK: Define macros that some xinput.h variants don't
-#ifndef XINPUT_CAPS_WIRELESS
- #define XINPUT_CAPS_WIRELESS 0x0002
-#endif
-#ifndef XINPUT_DEVSUBTYPE_WHEEL
- #define XINPUT_DEVSUBTYPE_WHEEL 0x02
-#endif
-#ifndef XINPUT_DEVSUBTYPE_ARCADE_STICK
- #define XINPUT_DEVSUBTYPE_ARCADE_STICK 0x03
-#endif
-#ifndef XINPUT_DEVSUBTYPE_FLIGHT_STICK
- #define XINPUT_DEVSUBTYPE_FLIGHT_STICK 0x04
-#endif
-#ifndef XINPUT_DEVSUBTYPE_DANCE_PAD
- #define XINPUT_DEVSUBTYPE_DANCE_PAD 0x05
-#endif
-#ifndef XINPUT_DEVSUBTYPE_GUITAR
- #define XINPUT_DEVSUBTYPE_GUITAR 0x06
-#endif
-#ifndef XINPUT_DEVSUBTYPE_DRUM_KIT
- #define XINPUT_DEVSUBTYPE_DRUM_KIT 0x08
-#endif
-#ifndef XINPUT_DEVSUBTYPE_ARCADE_PAD
- #define XINPUT_DEVSUBTYPE_ARCADE_PAD 0x13
-#endif
-#ifndef XUSER_MAX_COUNT
- #define XUSER_MAX_COUNT 4
-#endif
-
-// HACK: Define macros that some dinput.h variants don't
-#ifndef DIDFT_OPTIONAL
- #define DIDFT_OPTIONAL	0x80000000
-#endif
-
-// winmm.dll function pointer typedefs
-typedef DWORD (WINAPI * PFN_timeGetTime)(void);
-#define timeGetTime _glfw.win32.winmm.GetTime
-
-// xinput.dll function pointer typedefs
-typedef DWORD (WINAPI * PFN_XInputGetCapabilities)(DWORD,DWORD,XINPUT_CAPABILITIES*);
-typedef DWORD (WINAPI * PFN_XInputGetState)(DWORD,XINPUT_STATE*);
-#define XInputGetCapabilities _glfw.win32.xinput.GetCapabilities
-#define XInputGetState _glfw.win32.xinput.GetState
-
-// dinput8.dll function pointer typedefs
-typedef HRESULT (WINAPI * PFN_DirectInput8Create)(HINSTANCE,DWORD,REFIID,LPVOID*,LPUNKNOWN);
-#define DirectInput8Create _glfw.win32.dinput8.Create
-
-// user32.dll function pointer typedefs
-typedef BOOL (WINAPI * PFN_SetProcessDPIAware)(void);
-typedef BOOL (WINAPI * PFN_ChangeWindowMessageFilterEx)(HWND,UINT,DWORD,CHANGEFILTERSTRUCT*);
-typedef BOOL (WINAPI * PFN_EnableNonClientDpiScaling)(HWND);
-typedef BOOL (WINAPI * PFN_SetProcessDpiAwarenessContext)(DPI_AWARENESS_CONTEXT);
-typedef UINT (WINAPI * PFN_GetDpiForWindow)(HWND);
-typedef BOOL (WINAPI * PFN_AdjustWindowRectExForDpi)(LPRECT,DWORD,BOOL,DWORD,UINT);
-#define SetProcessDPIAware _glfw.win32.user32.SetProcessDPIAware_
-#define ChangeWindowMessageFilterEx _glfw.win32.user32.ChangeWindowMessageFilterEx_
-#define EnableNonClientDpiScaling _glfw.win32.user32.EnableNonClientDpiScaling_
-#define SetProcessDpiAwarenessContext _glfw.win32.user32.SetProcessDpiAwarenessContext_
-#define GetDpiForWindow _glfw.win32.user32.GetDpiForWindow_
-#define AdjustWindowRectExForDpi _glfw.win32.user32.AdjustWindowRectExForDpi_
-
-// dwmapi.dll function pointer typedefs
-typedef HRESULT (WINAPI * PFN_DwmIsCompositionEnabled)(BOOL*);
-typedef HRESULT (WINAPI * PFN_DwmFlush)(VOID);
-typedef HRESULT(WINAPI * PFN_DwmEnableBlurBehindWindow)(HWND,const DWM_BLURBEHIND*);
-#define DwmIsCompositionEnabled _glfw.win32.dwmapi.IsCompositionEnabled
-#define DwmFlush _glfw.win32.dwmapi.Flush
-#define DwmEnableBlurBehindWindow _glfw.win32.dwmapi.EnableBlurBehindWindow
-
-// shcore.dll function pointer typedefs
-typedef HRESULT (WINAPI * PFN_SetProcessDpiAwareness)(PROCESS_DPI_AWARENESS);
-typedef HRESULT (WINAPI * PFN_GetDpiForMonitor)(HMONITOR,MONITOR_DPI_TYPE,UINT*,UINT*);
-#define SetProcessDpiAwareness _glfw.win32.shcore.SetProcessDpiAwareness_
-#define GetDpiForMonitor _glfw.win32.shcore.GetDpiForMonitor_
-
-// ntdll.dll function pointer typedefs
-typedef LONG (WINAPI * PFN_RtlVerifyVersionInfo)(OSVERSIONINFOEXW*,ULONG,ULONGLONG);
-#define RtlVerifyVersionInfo _glfw.win32.ntdll.RtlVerifyVersionInfo_
-
-typedef VkFlags VkWin32SurfaceCreateFlagsKHR;
-
-typedef struct VkWin32SurfaceCreateInfoKHR
-{
-    VkStructureType                 sType;
-    const void*                     pNext;
-    VkWin32SurfaceCreateFlagsKHR    flags;
-    HINSTANCE                       hinstance;
-    HWND                            hwnd;
-} VkWin32SurfaceCreateInfoKHR;
-
-typedef VkResult (APIENTRY *PFN_vkCreateWin32SurfaceKHR)(VkInstance,const VkWin32SurfaceCreateInfoKHR*,const VkAllocationCallbacks*,VkSurfaceKHR*);
-typedef VkBool32 (APIENTRY *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice,uint32_t);
-
-#include "win32_joystick.h"
-#include "wgl_context.h"
-#include "egl_context.h"
-#include "osmesa_context.h"
-
-#if !defined(_GLFW_WNDCLASSNAME)
- #define _GLFW_WNDCLASSNAME L"GLFW30"
-#endif
-
-#define _glfw_dlopen(name) LoadLibraryA(name)
-#define _glfw_dlclose(handle) FreeLibrary((HMODULE) handle)
-#define _glfw_dlsym(handle, name) GetProcAddress((HMODULE) handle, name)
-
-#define _GLFW_EGL_NATIVE_WINDOW  ((EGLNativeWindowType) window->win32.handle)
-#define _GLFW_EGL_NATIVE_DISPLAY EGL_DEFAULT_DISPLAY
-
-#define _GLFW_PLATFORM_WINDOW_STATE         _GLFWwindowWin32  win32
-#define _GLFW_PLATFORM_LIBRARY_WINDOW_STATE _GLFWlibraryWin32 win32
-#define _GLFW_PLATFORM_LIBRARY_TIMER_STATE  _GLFWtimerWin32   win32
-#define _GLFW_PLATFORM_MONITOR_STATE        _GLFWmonitorWin32 win32
-#define _GLFW_PLATFORM_CURSOR_STATE         _GLFWcursorWin32  win32
-#define _GLFW_PLATFORM_TLS_STATE            _GLFWtlsWin32     win32
-#define _GLFW_PLATFORM_MUTEX_STATE          _GLFWmutexWin32   win32
-
-
-// Win32-specific per-window data
-//
-typedef struct _GLFWwindowWin32
-{
-    HWND                handle;
-    HICON               bigIcon;
-    HICON               smallIcon;
-
-    GLFWbool            cursorTracked;
-    GLFWbool            frameAction;
-    GLFWbool            iconified;
-    GLFWbool            maximized;
-    // Whether to enable framebuffer transparency on DWM
-    GLFWbool            transparent;
-    GLFWbool            scaleToMonitor;
-
-    // The last received cursor position, regardless of source
-    int                 lastCursorPosX, lastCursorPosY;
-
-} _GLFWwindowWin32;
-
-// Win32-specific global data
-//
-typedef struct _GLFWlibraryWin32
-{
-    HWND                helperWindowHandle;
-    HDEVNOTIFY          deviceNotificationHandle;
-    DWORD               foregroundLockTimeout;
-    int                 acquiredMonitorCount;
-    char*               clipboardString;
-    short int           keycodes[512];
-    short int           scancodes[GLFW_KEY_LAST + 1];
-    char                keynames[GLFW_KEY_LAST + 1][5];
-    // Where to place the cursor when re-enabled
-    double              restoreCursorPosX, restoreCursorPosY;
-    // The window whose disabled cursor mode is active
-    _GLFWwindow*        disabledCursorWindow;
-    RAWINPUT*           rawInput;
-    int                 rawInputSize;
-    UINT                mouseTrailSize;
-
-    struct {
-        HINSTANCE                       instance;
-        PFN_timeGetTime                 GetTime;
-    } winmm;
-
-    struct {
-        HINSTANCE                       instance;
-        PFN_DirectInput8Create          Create;
-        IDirectInput8W*                 api;
-    } dinput8;
-
-    struct {
-        HINSTANCE                       instance;
-        PFN_XInputGetCapabilities       GetCapabilities;
-        PFN_XInputGetState              GetState;
-    } xinput;
-
-    struct {
-        HINSTANCE                       instance;
-        PFN_SetProcessDPIAware          SetProcessDPIAware_;
-        PFN_ChangeWindowMessageFilterEx ChangeWindowMessageFilterEx_;
-        PFN_EnableNonClientDpiScaling   EnableNonClientDpiScaling_;
-        PFN_SetProcessDpiAwarenessContext SetProcessDpiAwarenessContext_;
-        PFN_GetDpiForWindow             GetDpiForWindow_;
-        PFN_AdjustWindowRectExForDpi    AdjustWindowRectExForDpi_;
-    } user32;
-
-    struct {
-        HINSTANCE                       instance;
-        PFN_DwmIsCompositionEnabled     IsCompositionEnabled;
-        PFN_DwmFlush                    Flush;
-        PFN_DwmEnableBlurBehindWindow   EnableBlurBehindWindow;
-    } dwmapi;
-
-    struct {
-        HINSTANCE                       instance;
-        PFN_SetProcessDpiAwareness      SetProcessDpiAwareness_;
-        PFN_GetDpiForMonitor            GetDpiForMonitor_;
-    } shcore;
-
-    struct {
-        HINSTANCE                       instance;
-        PFN_RtlVerifyVersionInfo        RtlVerifyVersionInfo_;
-    } ntdll;
-
-} _GLFWlibraryWin32;
-
-// Win32-specific per-monitor data
-//
-typedef struct _GLFWmonitorWin32
-{
-    HMONITOR            handle;
-    // This size matches the static size of DISPLAY_DEVICE.DeviceName
-    WCHAR               adapterName[32];
-    WCHAR               displayName[32];
-    char                publicAdapterName[32];
-    char                publicDisplayName[32];
-    GLFWbool            modesPruned;
-    GLFWbool            modeChanged;
-
-} _GLFWmonitorWin32;
-
-// Win32-specific per-cursor data
-//
-typedef struct _GLFWcursorWin32
-{
-    HCURSOR             handle;
-
-} _GLFWcursorWin32;
-
-// Win32-specific global timer data
-//
-typedef struct _GLFWtimerWin32
-{
-    GLFWbool            hasPC;
-    uint64_t            frequency;
-
-} _GLFWtimerWin32;
-
-// Win32-specific thread local storage data
-//
-typedef struct _GLFWtlsWin32
-{
-    GLFWbool            allocated;
-    DWORD               index;
-
-} _GLFWtlsWin32;
-
-// Win32-specific mutex data
-//
-typedef struct _GLFWmutexWin32
-{
-    GLFWbool            allocated;
-    CRITICAL_SECTION    section;
-
-} _GLFWmutexWin32;
-
-
-GLFWbool _glfwRegisterWindowClassWin32(void);
-void _glfwUnregisterWindowClassWin32(void);
-
-WCHAR* _glfwCreateWideStringFromUTF8Win32(const char* source);
-char* _glfwCreateUTF8FromWideStringWin32(const WCHAR* source);
-BOOL _glfwIsWindowsVersionOrGreaterWin32(WORD major, WORD minor, WORD sp);
-BOOL _glfwIsWindows10BuildOrGreaterWin32(WORD build);
-void _glfwInputErrorWin32(int error, const char* description);
-void _glfwUpdateKeyNamesWin32(void);
-
-void _glfwInitTimerWin32(void);
-
-void _glfwPollMonitorsWin32(void);
-void _glfwSetVideoModeWin32(_GLFWmonitor* monitor, const GLFWvidmode* desired);
-void _glfwRestoreVideoModeWin32(_GLFWmonitor* monitor);
-void _glfwGetMonitorContentScaleWin32(HMONITOR handle, float* xscale, float* yscale);

glfw/win32_thread.c

@@ -1,97 +0,0 @@
-//========================================================================
-// GLFW 3.3 Win32 - www.glfw.org
-//------------------------------------------------------------------------
-// Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-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.
-//
-//========================================================================
-
-#include "internal.h"
-
-#include <assert.h>
-
-
-//////////////////////////////////////////////////////////////////////////
-//////                       GLFW platform API                      //////
-//////////////////////////////////////////////////////////////////////////
-
-GLFWbool _glfwPlatformCreateTls(_GLFWtls* tls)
-{
-    assert(tls->win32.allocated == GLFW_FALSE);
-
-    tls->win32.index = TlsAlloc();
-    if (tls->win32.index == TLS_OUT_OF_INDEXES)
-    {
-        _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
-                             "Win32: Failed to allocate TLS index");
-        return GLFW_FALSE;
-    }
-
-    tls->win32.allocated = GLFW_TRUE;
-    return GLFW_TRUE;
-}
-
-void _glfwPlatformDestroyTls(_GLFWtls* tls)
-{
-    if (tls->win32.allocated)
-        TlsFree(tls->win32.index);
-    memset(tls, 0, sizeof(_GLFWtls));
-}
-
-void* _glfwPlatformGetTls(_GLFWtls* tls)
-{
-    assert(tls->win32.allocated == GLFW_TRUE);
-    return TlsGetValue(tls->win32.index);
-}
-
-void _glfwPlatformSetTls(_GLFWtls* tls, void* value)
-{
-    assert(tls->win32.allocated == GLFW_TRUE);
-    TlsSetValue(tls->win32.index, value);
-}
-
-GLFWbool _glfwPlatformCreateMutex(_GLFWmutex* mutex)
-{
-    assert(mutex->win32.allocated == GLFW_FALSE);
-    InitializeCriticalSection(&mutex->win32.section);
-    return mutex->win32.allocated = GLFW_TRUE;
-}
-
-void _glfwPlatformDestroyMutex(_GLFWmutex* mutex)
-{
-    if (mutex->win32.allocated)
-        DeleteCriticalSection(&mutex->win32.section);
-    memset(mutex, 0, sizeof(_GLFWmutex));
-}
-
-void _glfwPlatformLockMutex(_GLFWmutex* mutex)
-{
-    assert(mutex->win32.allocated == GLFW_TRUE);
-    EnterCriticalSection(&mutex->win32.section);
-}
-
-void _glfwPlatformUnlockMutex(_GLFWmutex* mutex)
-{
-    assert(mutex->win32.allocated == GLFW_TRUE);
-    LeaveCriticalSection(&mutex->win32.section);
-}
-

glfw/win32_time.c

@@ -1,74 +0,0 @@
-//========================================================================
-// GLFW 3.3 Win32 - www.glfw.org
-//------------------------------------------------------------------------
-// Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-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.
-//
-//========================================================================
-
-#include "internal.h"
-
-
-//////////////////////////////////////////////////////////////////////////
-//////                       GLFW internal API                      //////
-//////////////////////////////////////////////////////////////////////////
-
-// Initialise timer
-//
-void _glfwInitTimerWin32(void)
-{
-    uint64_t frequency;
-
-    if (QueryPerformanceFrequency((LARGE_INTEGER*) &frequency))
-    {
-        _glfw.timer.win32.hasPC = GLFW_TRUE;
-        _glfw.timer.win32.frequency = frequency;
-    }
-    else
-    {
-        _glfw.timer.win32.hasPC = GLFW_FALSE;
-        _glfw.timer.win32.frequency = 1000;
-    }
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-//////                       GLFW platform API                      //////
-//////////////////////////////////////////////////////////////////////////
-
-uint64_t _glfwPlatformGetTimerValue(void)
-{
-    if (_glfw.timer.win32.hasPC)
-    {
-        uint64_t value;
-        QueryPerformanceCounter((LARGE_INTEGER*) &value);
-        return value;
-    }
-    else
-        return (uint64_t) timeGetTime();
-}
-
-uint64_t _glfwPlatformGetTimerFrequency(void)
-{
-    return _glfw.timer.win32.frequency;
-}
-

glfw/window.c

@@ -88,8 +88,16 @@ _GLFWwindow* _glfwWindowForId(GLFWid id) {
     return NULL;
 }
 
+// Notifies shared code that a window's occlusion state has changed
+//
+void _glfwInputWindowOcclusion(_GLFWwindow* window, GLFWbool occluded)
+{
+    if (window->callbacks.occlusion)
+        window->callbacks.occlusion((GLFWwindow*) window, occluded);
+}
+
 // Notifies shared code that a window has moved
-// The position is specified in client-area relative screen coordinates
+// The position is specified in content area relative screen coordinates
 //
 void _glfwInputWindowPos(_GLFWwindow* window, int x, int y)
 {
@@ -131,6 +139,14 @@ void _glfwInputFramebufferSize(_GLFWwindow* window, int width, int height)
         window->callbacks.fbsize((GLFWwindow*) window, width, height);
 }
 
+// Notifies shared code that a window live resize is in progress
+//
+void _glfwInputLiveResize(_GLFWwindow* window, bool started)
+{
+    if (window && window->callbacks.liveResize)
+        window->callbacks.liveResize((GLFWwindow*) window, started);
+}
+
 // Notifies shared code that a window content scale has changed
 // The scale is specified as the ratio between the current and default DPI
 //
@@ -254,19 +270,17 @@ GLFWAPI GLFWwindow* glfwCreateWindow(int width, int height,
     if (window->monitor)
     {
         if (wndconfig.centerCursor)
-        {
-            int width, height;
-            _glfwPlatformGetWindowSize(window, &width, &height);
-            _glfwPlatformSetCursorPos(window, width / 2.0, height / 2.0);
-        }
+            _glfwCenterCursorInContentArea(window);
     }
     else
     {
         if (wndconfig.visible)
         {
             _glfwPlatformShowWindow(window);
+#ifndef _GLFW_WAYLAND
             if (wndconfig.focused)
                 _glfwPlatformFocusWindow(window);
+#endif
         }
     }
 
@@ -721,6 +735,15 @@ GLFWAPI void glfwGetWindowContentScale(GLFWwindow* handle,
     _glfwPlatformGetWindowContentScale(window, xscale, yscale);
 }
 
+GLFWAPI double glfwGetDoubleClickInterval(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(0.5f);
+    return _glfwPlatformGetDoubleClickInterval(window);
+}
+
 GLFWAPI float glfwGetWindowOpacity(GLFWwindow* handle)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
@@ -792,8 +815,10 @@ GLFWAPI void glfwShowWindow(GLFWwindow* handle)
 
     _glfwPlatformShowWindow(window);
 
+#ifndef _GLFW_WAYLAND
     if (window->focusOnShow)
         _glfwPlatformFocusWindow(window);
+#endif
 }
 
 GLFWAPI void glfwRequestWindowAttention(GLFWwindow* handle)
@@ -862,6 +887,8 @@ GLFWAPI int glfwGetWindowAttrib(GLFWwindow* handle, int attrib)
             return window->focusOnShow;
         case GLFW_TRANSPARENT_FRAMEBUFFER:
             return _glfwPlatformFramebufferTransparent(window);
+        case GLFW_OCCLUDED:
+            return _glfwPlatformWindowOccluded(window);
         case GLFW_RESIZABLE:
             return window->resizable;
         case GLFW_DECORATED:
@@ -990,6 +1017,12 @@ GLFWAPI void glfwSetWindowMonitor(GLFWwindow* wh,
                                   refreshRate);
 }
 
+GLFWAPI bool glfwToggleFullscreen(GLFWwindow* wh, unsigned int flags) {
+    _GLFWwindow* window = (_GLFWwindow*) wh;
+    if (window) return _glfwPlatformToggleFullscreen(window, flags);
+    return false;
+}
+
 GLFWAPI void glfwSetWindowUserPointer(GLFWwindow* handle, void* pointer)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
@@ -1063,6 +1096,17 @@ GLFWAPI GLFWwindowfocusfun glfwSetWindowFocusCallback(GLFWwindow* handle,
     return cbfun;
 }
 
+GLFWAPI GLFWwindowocclusionfun glfwSetWindowOcclusionCallback(GLFWwindow* handle,
+                                                              GLFWwindowocclusionfun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.occlusion, cbfun);
+    return cbfun;
+}
+
 GLFWAPI GLFWwindowiconifyfun glfwSetWindowIconifyCallback(GLFWwindow* handle,
                                                           GLFWwindowiconifyfun cbfun)
 {
@@ -1096,6 +1140,17 @@ GLFWAPI GLFWframebuffersizefun glfwSetFramebufferSizeCallback(GLFWwindow* handle
     return cbfun;
 }
 
+GLFWAPI GLFWliveresizefun glfwSetLiveResizeCallback(GLFWwindow* handle,
+                                                              GLFWliveresizefun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.liveResize, cbfun);
+    return cbfun;
+}
+
 GLFWAPI GLFWwindowcontentscalefun glfwSetWindowContentScaleCallback(GLFWwindow* handle,
                                                                     GLFWwindowcontentscalefun cbfun)
 {
@@ -1107,44 +1162,9 @@ GLFWAPI GLFWwindowcontentscalefun glfwSetWindowContentScaleCallback(GLFWwindow*
     return cbfun;
 }
 
-GLFWAPI void glfwPollEvents(void)
-{
-    _GLFW_REQUIRE_INIT();
-    _glfwPlatformPollEvents();
-}
-
-GLFWAPI void glfwWaitEvents(void)
-{
-    _GLFW_REQUIRE_INIT();
-
-    if (!_glfw.windowListHead)
-        return;
-
-    _glfwPlatformWaitEvents();
-}
-
-GLFWAPI void glfwWaitEventsTimeout(double timeout)
-{
-    _GLFW_REQUIRE_INIT();
-    assert(timeout == timeout);
-    assert(timeout >= 0.0);
-    assert(timeout <= DBL_MAX);
-
-    if (timeout != timeout || timeout < 0.0 || timeout > DBL_MAX)
-    {
-        _glfwInputError(GLFW_INVALID_VALUE, "Invalid time %f", timeout);
-        return;
-    }
-
-    _glfwPlatformWaitEventsTimeout(timeout);
-}
-
 GLFWAPI void glfwPostEmptyEvent(void)
 {
     _GLFW_REQUIRE_INIT();
 
-    if (!_glfw.windowListHead)
-        return;
-
     _glfwPlatformPostEmptyEvent();
 }

glfw/wl_init.c

@@ -29,6 +29,8 @@
 #include "backend_utils.h"
 
 #include <assert.h>
+#include <errno.h>
+#include <limits.h>
 #include <linux/input.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -124,21 +126,15 @@ static void pointerHandleLeave(void* data,
     _glfwInputCursorEnter(window, GLFW_FALSE);
 }
 
-static void setCursor(const char* name)
+static void setCursor(GLFWCursorShape shape)
 {
     struct wl_buffer* buffer;
     struct wl_cursor* cursor;
     struct wl_cursor_image* image;
     struct wl_surface* surface = _glfw.wl.cursorSurface;
 
-    cursor = wl_cursor_theme_get_cursor(_glfw.wl.cursorTheme,
-                                        name);
-    if (!cursor)
-    {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Wayland: Standard cursor not found");
-        return;
-    }
+    cursor = _glfwLoadCursor(shape);
+    if (!cursor) return;
     // TODO: handle animated cursors too.
     image = cursor->images[0];
 
@@ -165,7 +161,7 @@ static void pointerHandleMotion(void* data,
                                 wl_fixed_t sy)
 {
     _GLFWwindow* window = _glfw.wl.pointerFocus;
-    const char* cursorName = NULL;
+    GLFWCursorShape cursorShape = GLFW_ARROW_CURSOR;
 
     if (!window)
         return;
@@ -187,34 +183,34 @@ static void pointerHandleMotion(void* data,
             return;
         case topDecoration:
             if (window->wl.cursorPosY < _GLFW_DECORATION_WIDTH)
-                cursorName = "n-resize";
+                cursorShape = GLFW_VRESIZE_CURSOR;
             else
-                cursorName = "left_ptr";
+                cursorShape = GLFW_ARROW_CURSOR;
             break;
         case leftDecoration:
             if (window->wl.cursorPosY < _GLFW_DECORATION_WIDTH)
-                cursorName = "nw-resize";
+                cursorShape = GLFW_NW_RESIZE_CURSOR;
             else
-                cursorName = "w-resize";
+                cursorShape = GLFW_HRESIZE_CURSOR;
             break;
         case rightDecoration:
             if (window->wl.cursorPosY < _GLFW_DECORATION_WIDTH)
-                cursorName = "ne-resize";
+                cursorShape = GLFW_NE_RESIZE_CURSOR;
             else
-                cursorName = "e-resize";
+                cursorShape = GLFW_HRESIZE_CURSOR;
             break;
         case bottomDecoration:
             if (window->wl.cursorPosX < _GLFW_DECORATION_WIDTH)
-                cursorName = "sw-resize";
+                cursorShape = GLFW_SW_RESIZE_CURSOR;
             else if (window->wl.cursorPosX > window->wl.width + _GLFW_DECORATION_WIDTH)
-                cursorName = "se-resize";
+                cursorShape = GLFW_SE_RESIZE_CURSOR;
             else
-                cursorName = "s-resize";
+                cursorShape = GLFW_VRESIZE_CURSOR;
             break;
         default:
             assert(0);
     }
-    setCursor(cursorName);
+    setCursor(cursorShape);
 }
 
 static void pointerHandleButton(void* data,
@@ -227,8 +223,7 @@ static void pointerHandleButton(void* data,
     _GLFWwindow* window = _glfw.wl.pointerFocus;
     int glfwButton;
 
-    // Both xdg-shell and wl_shell use the same values.
-    uint32_t edges = WL_SHELL_SURFACE_RESIZE_NONE;
+    uint32_t edges = XDG_TOPLEVEL_RESIZE_EDGE_NONE;
 
     if (!window)
         return;
@@ -240,46 +235,40 @@ static void pointerHandleButton(void* data,
                 break;
             case topDecoration:
                 if (window->wl.cursorPosY < _GLFW_DECORATION_WIDTH)
-                    edges = WL_SHELL_SURFACE_RESIZE_TOP;
+                    edges = XDG_TOPLEVEL_RESIZE_EDGE_TOP;
                 else
                 {
                     if (window->wl.xdg.toplevel)
                         xdg_toplevel_move(window->wl.xdg.toplevel, _glfw.wl.seat, serial);
-                    else
-                        wl_shell_surface_move(window->wl.shellSurface, _glfw.wl.seat, serial);
                 }
                 break;
             case leftDecoration:
                 if (window->wl.cursorPosY < _GLFW_DECORATION_WIDTH)
-                    edges = WL_SHELL_SURFACE_RESIZE_TOP_LEFT;
+                    edges = XDG_TOPLEVEL_RESIZE_EDGE_TOP_LEFT;
                 else
-                    edges = WL_SHELL_SURFACE_RESIZE_LEFT;
+                    edges = XDG_TOPLEVEL_RESIZE_EDGE_LEFT;
                 break;
             case rightDecoration:
                 if (window->wl.cursorPosY < _GLFW_DECORATION_WIDTH)
-                    edges = WL_SHELL_SURFACE_RESIZE_TOP_RIGHT;
+                    edges = XDG_TOPLEVEL_RESIZE_EDGE_TOP_RIGHT;
                 else
-                    edges = WL_SHELL_SURFACE_RESIZE_RIGHT;
+                    edges = XDG_TOPLEVEL_RESIZE_EDGE_RIGHT;
                 break;
             case bottomDecoration:
                 if (window->wl.cursorPosX < _GLFW_DECORATION_WIDTH)
-                    edges = WL_SHELL_SURFACE_RESIZE_BOTTOM_LEFT;
+                    edges = XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_LEFT;
                 else if (window->wl.cursorPosX > window->wl.width + _GLFW_DECORATION_WIDTH)
-                    edges = WL_SHELL_SURFACE_RESIZE_BOTTOM_RIGHT;
+                    edges = XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_RIGHT;
                 else
-                    edges = WL_SHELL_SURFACE_RESIZE_BOTTOM;
+                    edges = XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM;
                 break;
             default:
                 assert(0);
         }
-        if (edges != WL_SHELL_SURFACE_RESIZE_NONE)
+        if (edges != XDG_TOPLEVEL_RESIZE_EDGE_NONE)
         {
-            if (window->wl.xdg.toplevel)
-                xdg_toplevel_resize(window->wl.xdg.toplevel, _glfw.wl.seat,
-                                    serial, edges);
-            else
-                wl_shell_surface_resize(window->wl.shellSurface, _glfw.wl.seat,
-                                        serial, edges);
+            xdg_toplevel_resize(window->wl.xdg.toplevel, _glfw.wl.seat,
+                                serial, edges);
         }
     }
     else if (button == BTN_RIGHT)
@@ -407,7 +396,7 @@ static void
 dispatchPendingKeyRepeats(id_type timer_id, void *data) {
     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, ((double)_glfw.wl.keyboardRepeatRate) / 1000.0);
+    changeTimerInterval(&_glfw.wl.eventLoopData, _glfw.wl.keyRepeatInfo.keyRepeatTimer, (1.0 / (double)_glfw.wl.keyboardRepeatRate));
     toggleTimer(&_glfw.wl.eventLoopData, _glfw.wl.keyRepeatInfo.keyRepeatTimer, 1);
 }
 
@@ -542,11 +531,6 @@ static void registryHandleGlobal(void* data,
         _glfw.wl.shm =
             wl_registry_bind(registry, name, &wl_shm_interface, 1);
     }
-    else if (strcmp(interface, "wl_shell") == 0)
-    {
-        _glfw.wl.shell =
-            wl_registry_bind(registry, name, &wl_shell_interface, 1);
-    }
     else if (strcmp(interface, "wl_output") == 0)
     {
         _glfwAddOutputWayland(name, version);
@@ -561,8 +545,11 @@ static void registryHandleGlobal(void* data,
                                  _glfw.wl.seatVersion);
             wl_seat_add_listener(_glfw.wl.seat, &seatListener, NULL);
         }
-        if (_glfw.wl.seat && _glfw.wl.dataDeviceManager && !_glfw.wl.dataDevice) {
-            _glfwSetupWaylandDataDevice();
+        if (_glfw.wl.seat) {
+            if (_glfw.wl.dataDeviceManager && !_glfw.wl.dataDevice) _glfwSetupWaylandDataDevice();
+            if (_glfw.wl.primarySelectionDeviceManager && !_glfw.wl.primarySelectionDevice) {
+                _glfwSetupWaylandPrimarySelectionDevice();
+            }
         }
     }
     else if (strcmp(interface, "xdg_wm_base") == 0)
@@ -571,6 +558,12 @@ static void registryHandleGlobal(void* data,
             wl_registry_bind(registry, name, &xdg_wm_base_interface, 1);
         xdg_wm_base_add_listener(_glfw.wl.wmBase, &wmBaseListener, NULL);
     }
+    else if (strcmp(interface, "zxdg_decoration_manager_v1") == 0)
+    {
+        _glfw.wl.decorationManager =
+        wl_registry_bind(registry, name,
+            &zxdg_decoration_manager_v1_interface, 1);
+    }
     else if (strcmp(interface, "wp_viewporter") == 0)
     {
         _glfw.wl.viewporter =
@@ -607,6 +600,17 @@ static void registryHandleGlobal(void* data,
             _glfwSetupWaylandDataDevice();
         }
     }
+    else if (strcmp(interface, "zwp_primary_selection_device_manager_v1") == 0 ||
+        strcmp(interface, "gtk_primary_selection_device_manager") == 0)
+    {
+        _glfw.wl.primarySelectionDeviceManager =
+            wl_registry_bind(registry, name,
+                             &zwp_primary_selection_device_manager_v1_interface,
+                             1);
+        if (_glfw.wl.seat && _glfw.wl.primarySelectionDeviceManager && !_glfw.wl.primarySelectionDevice) {
+            _glfwSetupWaylandPrimarySelectionDevice();
+        }
+    }
 
 }
 
@@ -689,8 +693,8 @@ int _glfwPlatformInit(void)
     }
     initPollData(&_glfw.wl.eventLoopData, _glfw.wl.eventLoopData.wakeupFds[0], wl_display_get_fd(_glfw.wl.display));
     glfw_dbus_init(&_glfw.wl.dbus, &_glfw.wl.eventLoopData);
-    _glfw.wl.keyRepeatInfo.keyRepeatTimer = addTimer(&_glfw.wl.eventLoopData, "wayland-key-repeat", 0.5, 0, dispatchPendingKeyRepeats, NULL);
-    _glfw.wl.cursorAnimationTimer = addTimer(&_glfw.wl.eventLoopData, "wayland-cursor-animation", 0.5, 0, animateCursorImage, NULL);
+    _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.registry = wl_display_get_registry(_glfw.wl.display);
     wl_registry_add_listener(_glfw.wl.registry, &registryListener, NULL);
@@ -711,10 +715,26 @@ int _glfwPlatformInit(void)
 #endif
 
     _glfwInitTimerPOSIX();
-
-    if (_glfw.wl.pointer && _glfw.wl.shm)
+    if (!_glfw.wl.wmBase)
     {
-        _glfw.wl.cursorTheme = wl_cursor_theme_load(NULL, 32, _glfw.wl.shm);
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Wayland: Failed to find xdg-shell in your compositor");
+        return GLFW_FALSE;
+    }
+
+    if (_glfw.wl.shm)
+    {
+        const char *cursorTheme = getenv("XCURSOR_THEME"), *cursorSizeStr = getenv("XCURSOR_SIZE");
+        char *cursorSizeEnd;
+        int cursorSize = 32;
+        if (cursorSizeStr)
+        {
+            errno = 0;
+            long cursorSizeLong = strtol(cursorSizeStr, &cursorSizeEnd, 10);
+            if (!*cursorSizeEnd && !errno && cursorSizeLong > 0 && cursorSizeLong <= INT_MAX)
+                cursorSize = (int)cursorSizeLong;
+        }
+        _glfw.wl.cursorTheme = wl_cursor_theme_load(cursorTheme, cursorSize, _glfw.wl.shm);
         if (!_glfw.wl.cursorTheme)
         {
             _glfwInputError(GLFW_PLATFORM_ERROR,
@@ -759,10 +779,10 @@ void _glfwPlatformTerminate(void)
         wl_compositor_destroy(_glfw.wl.compositor);
     if (_glfw.wl.shm)
         wl_shm_destroy(_glfw.wl.shm);
-    if (_glfw.wl.shell)
-        wl_shell_destroy(_glfw.wl.shell);
     if (_glfw.wl.viewporter)
         wp_viewporter_destroy(_glfw.wl.viewporter);
+    if (_glfw.wl.decorationManager)
+        zxdg_decoration_manager_v1_destroy(_glfw.wl.decorationManager);
     if (_glfw.wl.wmBase)
         xdg_wm_base_destroy(_glfw.wl.wmBase);
     if (_glfw.wl.pointer)
@@ -788,6 +808,10 @@ void _glfwPlatformTerminate(void)
         wl_data_device_destroy(_glfw.wl.dataDevice);
     if (_glfw.wl.dataDeviceManager)
         wl_data_device_manager_destroy(_glfw.wl.dataDeviceManager);
+    if (_glfw.wl.primarySelectionDevice)
+        zwp_primary_selection_device_v1_destroy(_glfw.wl.primarySelectionDevice);
+    if (_glfw.wl.primarySelectionDeviceManager)
+        zwp_primary_selection_device_manager_v1_destroy(_glfw.wl.primarySelectionDeviceManager);
     if (_glfw.wl.registry)
         wl_registry_destroy(_glfw.wl.registry);
     if (_glfw.wl.display)
@@ -797,13 +821,14 @@ void _glfwPlatformTerminate(void)
     }
     closeFds(_glfw.wl.eventLoopData.wakeupFds, sizeof(_glfw.wl.eventLoopData.wakeupFds)/sizeof(_glfw.wl.eventLoopData.wakeupFds[0]));
     free(_glfw.wl.clipboardString); _glfw.wl.clipboardString = NULL;
-    free(_glfw.wl.clipboardSourceString); _glfw.wl.clipboardSourceString = NULL;
+    free(_glfw.wl.primarySelectionString); _glfw.wl.primarySelectionString = NULL;
+    free(_glfw.wl.pasteString); _glfw.wl.pasteString = NULL;
 
 }
 
 const char* _glfwPlatformGetVersionString(void)
 {
-    return _GLFW_VERSION_NUMBER " Wayland EGL"
+    return _GLFW_VERSION_NUMBER " Wayland EGL OSMesa"
 #if defined(_POSIX_TIMERS) && defined(_POSIX_MONOTONIC_CLOCK)
         " clock_gettime"
 #else
@@ -815,3 +840,6 @@ const char* _glfwPlatformGetVersionString(void)
 #endif
         ;
 }
+
+#define GLFW_LOOP_BACKEND wl
+#include "main_loop.h"

glfw/wl_monitor.c

@@ -30,18 +30,19 @@
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
+#include <math.h>
 
 
-static void geometry(void* data,
-                     struct wl_output* output,
-                     int32_t x,
-                     int32_t y,
-                     int32_t physicalWidth,
-                     int32_t physicalHeight,
-                     int32_t subpixel,
-                     const char* make,
-                     const char* model,
-                     int32_t transform)
+static void outputHandleGeometry(void* data,
+                                struct wl_output* output,
+                                int32_t x,
+                                int32_t y,
+                                int32_t physicalWidth,
+                                int32_t physicalHeight,
+                                int32_t subpixel,
+                                const char* make,
+                                const char* model,
+                                int32_t transform)
 {
     struct _GLFWmonitor *monitor = data;
     char name[1024];
@@ -55,12 +56,12 @@ static void geometry(void* data,
     monitor->name = _glfw_strdup(name);
 }
 
-static void mode(void* data,
-                 struct wl_output* output,
-                 uint32_t flags,
-                 int32_t width,
-                 int32_t height,
-                 int32_t refresh)
+static void outputHandleMode(void* data,
+                            struct wl_output* output,
+                            uint32_t flags,
+                            int32_t width,
+                            int32_t height,
+                            int32_t refresh)
 {
     struct _GLFWmonitor *monitor = data;
     GLFWvidmode mode;
@@ -70,7 +71,7 @@ static void mode(void* data,
     mode.redBits = 8;
     mode.greenBits = 8;
     mode.blueBits = 8;
-    mode.refreshRate = refresh / 1000;
+    mode.refreshRate = (int)round(refresh / 1000.0);
 
     monitor->modeCount++;
     monitor->modes =
@@ -81,27 +82,27 @@ static void mode(void* data,
         monitor->wl.currentMode = monitor->modeCount - 1;
 }
 
-static void done(void* data, struct wl_output* output)
+static void outputHandleDone(void* data, struct wl_output* output)
 {
     struct _GLFWmonitor *monitor = data;
 
     _glfwInputMonitor(monitor, GLFW_CONNECTED, _GLFW_INSERT_LAST);
 }
 
-static void scale(void* data,
-                  struct wl_output* output,
-                  int32_t factor)
+static void outputHandleScale(void* data,
+                            struct wl_output* output,
+                            int32_t factor)
 {
     struct _GLFWmonitor *monitor = data;
-
-    monitor->wl.scale = factor;
+    if (factor > 0 && factor < 24)
+        monitor->wl.scale = factor;
 }
 
 static const struct wl_output_listener outputListener = {
-    geometry,
-    mode,
-    done,
-    scale,
+    outputHandleGeometry,
+    outputHandleMode,
+    outputHandleDone,
+    outputHandleScale,
 };
 
 
@@ -169,6 +170,18 @@ void _glfwPlatformGetMonitorContentScale(_GLFWmonitor* monitor,
         *yscale = (float) monitor->wl.scale;
 }
 
+void _glfwPlatformGetMonitorWorkarea(_GLFWmonitor* monitor, int* xpos, int* ypos, int *width, int *height)
+{
+    if (xpos)
+        *xpos = monitor->wl.x;
+    if (ypos)
+        *ypos = monitor->wl.y;
+    if (width)
+        *width = monitor->modes[monitor->wl.currentMode].width;
+    if (height)
+        *height = monitor->modes[monitor->wl.currentMode].height;
+}
+
 GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* found)
 {
     *found = monitor->modeCount;
@@ -180,18 +193,17 @@ void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode)
     *mode = monitor->modes[monitor->wl.currentMode];
 }
 
-void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
+GLFWbool _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
 {
-    // TODO
     _glfwInputError(GLFW_PLATFORM_ERROR,
-                    "Wayland: Gamma ramp getting not supported yet");
+                    "Wayland: Gamma ramp access is not available");
+    return GLFW_FALSE;
 }
 
 void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
 {
-    // TODO
     _glfwInputError(GLFW_PLATFORM_ERROR,
-                    "Wayland: Gamma ramp setting not supported yet");
+                    "Wayland: Gamma ramp access is not available");
 }
 
 
@@ -205,4 +217,3 @@ GLFWAPI struct wl_output* glfwGetWaylandMonitor(GLFWmonitor* handle)
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     return monitor->wl.output;
 }
-

glfw/wl_platform.h

@@ -56,9 +56,11 @@ typedef VkBool32 (APIENTRY *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR
 
 #include "wayland-xdg-shell-client-protocol.h"
 #include "wayland-viewporter-client-protocol.h"
+#include "wayland-xdg-decoration-unstable-v1-client-protocol.h"
 #include "wayland-relative-pointer-unstable-v1-client-protocol.h"
 #include "wayland-pointer-constraints-unstable-v1-client-protocol.h"
 #include "wayland-idle-inhibit-unstable-v1-client-protocol.h"
+#include "wayland-primary-selection-unstable-v1-client-protocol.h"
 
 #define _glfw_dlopen(name) dlopen(name, RTLD_LAZY | RTLD_LOCAL)
 #define _glfw_dlclose(handle) dlclose(handle)
@@ -137,12 +139,12 @@ typedef struct _GLFWwindowWayland
     GLFWbool                    transparent;
     struct wl_surface*          surface;
     struct wl_egl_window*       native;
-    struct wl_shell_surface*    shellSurface;
     struct wl_callback*         callback;
 
     struct {
         struct xdg_surface*     surface;
         struct xdg_toplevel*    toplevel;
+        struct zxdg_toplevel_decoration_v1* decoration;
     } xdg;
 
     _GLFWcursor*                currentCursor;
@@ -165,22 +167,37 @@ typedef struct _GLFWwindowWayland
 
     struct zwp_idle_inhibitor_v1*          idleInhibitor;
 
-    // This is a hack to prevent auto-iconification on creation.
-    GLFWbool                    justCreated;
+    GLFWbool                    fullscreened;
 
     struct {
+        GLFWbool                           serverSide;
         struct wl_buffer*                  buffer;
         _GLFWdecorationWayland             top, left, right, bottom;
         int                                focus;
     } decorations;
 
+    struct {
+        unsigned long long id;
+        void(*callback)(unsigned long long id);
+        struct wl_callback *current_wl_callback;
+    } frameCallbackData;
+
+
 } _GLFWwindowWayland;
 
+typedef enum _GLFWWaylandOfferType
+{
+    EXPIRED,
+    CLIPBOARD,
+    DRAG_AND_DROP,
+    PRIMARY_SELECTION
+}_GLFWWaylandOfferType ;
+
 typedef struct _GLFWWaylandDataOffer
 {
     struct wl_data_offer *id;
     const char *mime;
-    int offer_type;
+    _GLFWWaylandOfferType offer_type;
     size_t idx;
     int is_self_offer;
     int has_uri_list;
@@ -189,6 +206,17 @@ typedef struct _GLFWWaylandDataOffer
     struct wl_surface *surface;
 } _GLFWWaylandDataOffer;
 
+typedef struct _GLFWWaylandPrimaryOffer
+{
+    struct zwp_primary_selection_offer_v1 *id;
+    const char *mime;
+    _GLFWWaylandOfferType offer_type;
+    size_t idx;
+    int is_self_offer;
+    int has_uri_list;
+    struct wl_surface *surface;
+} _GLFWWaylandPrimaryOffer;
+
 // Wayland-specific global data
 //
 typedef struct _GLFWlibraryWayland
@@ -197,12 +225,12 @@ typedef struct _GLFWlibraryWayland
     struct wl_registry*         registry;
     struct wl_compositor*       compositor;
     struct wl_subcompositor*    subcompositor;
-    struct wl_shell*            shell;
     struct wl_shm*              shm;
     struct wl_seat*             seat;
     struct wl_pointer*          pointer;
     struct wl_keyboard*         keyboard;
     struct xdg_wm_base*         wmBase;
+    struct zxdg_decoration_manager_v1*      decorationManager;
     struct wp_viewporter*       viewporter;
     struct zwp_relative_pointer_manager_v1* relativePointerManager;
     struct zwp_pointer_constraints_v1*      pointerConstraints;
@@ -210,6 +238,9 @@ typedef struct _GLFWlibraryWayland
     struct wl_data_device_manager*          dataDeviceManager;
     struct wl_data_device*                  dataDevice;
     struct wl_data_source*                  dataSourceForClipboard;
+    struct zwp_primary_selection_device_manager_v1* primarySelectionDeviceManager;
+    struct zwp_primary_selection_device_v1*    primarySelectionDevice;
+    struct zwp_primary_selection_source_v1*    dataSourceForPrimarySelection;
 
     int                         compositorVersion;
     int                         seatVersion;
@@ -250,11 +281,13 @@ typedef struct _GLFWlibraryWayland
     } egl;
 
     EventLoopData eventLoopData;
+    char* pasteString;
     char* clipboardString;
-    char* clipboardSourceString;
-    struct wl_data_offer* clipboardSourceOffer;
     size_t dataOffersCounter;
     _GLFWWaylandDataOffer dataOffers[8];
+    char* primarySelectionString;
+    size_t primarySelectionOffersCounter;
+    _GLFWWaylandPrimaryOffer primarySelectionOffers[8];
 } _GLFWlibraryWayland;
 
 // Wayland-specific per-monitor data
@@ -284,5 +317,7 @@ typedef struct _GLFWcursorWayland
 
 
 void _glfwAddOutputWayland(uint32_t name, uint32_t version);
-void _glfwSetupWaylandDataDevice();
+void _glfwSetupWaylandDataDevice(void);
+void _glfwSetupWaylandPrimarySelectionDevice(void);
 void animateCursorImage(id_type timer_id, void *data);
+struct wl_cursor* _glfwLoadCursor(GLFWCursorShape);

glfw/x11_init.c

@@ -137,6 +137,10 @@ static void detectEWMH(void)
         getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_WINDOW_TYPE");
     _glfw.x11.NET_WM_WINDOW_TYPE_NORMAL =
         getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_WINDOW_TYPE_NORMAL");
+    _glfw.x11.NET_WORKAREA =
+        getSupportedAtom(supportedAtoms, atomCount, "_NET_WORKAREA");
+    _glfw.x11.NET_CURRENT_DESKTOP =
+        getSupportedAtom(supportedAtoms, atomCount, "_NET_CURRENT_DESKTOP");
     _glfw.x11.NET_ACTIVE_WINDOW =
         getSupportedAtom(supportedAtoms, atomCount, "_NET_ACTIVE_WINDOW");
     _glfw.x11.NET_FRAME_EXTENTS =
@@ -675,6 +679,7 @@ int _glfwPlatformInit(void)
 
 void _glfwPlatformTerminate(void)
 {
+    removeAllTimers(&_glfw.x11.eventLoopData);
     if (_glfw.x11.helperWindowHandle)
     {
         if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.CLIPBOARD) ==
@@ -754,7 +759,7 @@ void _glfwPlatformTerminate(void)
 
 const char* _glfwPlatformGetVersionString(void)
 {
-    return _GLFW_VERSION_NUMBER " X11 GLX EGL"
+    return _GLFW_VERSION_NUMBER " X11 GLX EGL OSMesa"
 #if defined(_POSIX_TIMERS) && defined(_POSIX_MONOTONIC_CLOCK)
         " clock_gettime"
 #else
@@ -768,3 +773,5 @@ const char* _glfwPlatformGetVersionString(void)
 #endif
         ;
 }
+
+#include "main_loop.h"

glfw/x11_monitor.c

@@ -30,6 +30,7 @@
 #include <limits.h>
 #include <stdlib.h>
 #include <string.h>
+#include <math.h>
 
 
 // Check whether the display mode should be included in enumeration
@@ -44,7 +45,7 @@ static GLFWbool modeIsGood(const XRRModeInfo* mi)
 static int calculateRefreshRate(const XRRModeInfo* mi)
 {
     if (mi->hTotal && mi->vTotal)
-        return (int) ((double) mi->dotClock / ((double) mi->hTotal * (double) mi->vTotal));
+        return (int) round((double) mi->dotClock / ((double) mi->hTotal * (double) mi->vTotal));
     else
         return 0;
 }
@@ -348,6 +349,100 @@ void _glfwPlatformGetMonitorContentScale(_GLFWmonitor* monitor,
         *yscale = _glfw.x11.contentScaleY;
 }
 
+void _glfwPlatformGetMonitorWorkarea(_GLFWmonitor* monitor, int* xpos, int* ypos, int *width, int *height)
+{
+    int areaX = 0, areaY = 0, areaWidth = 0, areaHeight = 0;
+
+    if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
+    {
+        XRRScreenResources* sr;
+        XRRCrtcInfo* ci;
+
+        sr = XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
+        ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
+
+        areaX = ci->x;
+        areaY = ci->y;
+
+        const XRRModeInfo* mi = getModeInfo(sr, ci->mode);
+
+        if (ci->rotation == RR_Rotate_90 || ci->rotation == RR_Rotate_270)
+        {
+            areaWidth  = mi->height;
+            areaHeight = mi->width;
+        }
+        else
+        {
+            areaWidth  = mi->width;
+            areaHeight = mi->height;
+        }
+
+        XRRFreeCrtcInfo(ci);
+        XRRFreeScreenResources(sr);
+    }
+    else
+    {
+        areaWidth  = DisplayWidth(_glfw.x11.display, _glfw.x11.screen);
+        areaHeight = DisplayHeight(_glfw.x11.display, _glfw.x11.screen);
+    }
+
+    if (_glfw.x11.NET_WORKAREA && _glfw.x11.NET_CURRENT_DESKTOP)
+    {
+        Atom* extents = NULL;
+        Atom* desktop = NULL;
+        const unsigned long extentCount =
+            _glfwGetWindowPropertyX11(_glfw.x11.root,
+                                      _glfw.x11.NET_WORKAREA,
+                                      XA_CARDINAL,
+                                      (unsigned char**) &extents);
+
+        if (_glfwGetWindowPropertyX11(_glfw.x11.root,
+                                      _glfw.x11.NET_CURRENT_DESKTOP,
+                                      XA_CARDINAL,
+                                      (unsigned char**) &desktop) > 0)
+        {
+            if (extentCount >= 4 && *desktop < extentCount / 4)
+            {
+                const int globalX = extents[*desktop * 4 + 0];
+                const int globalY = extents[*desktop * 4 + 1];
+                const int globalWidth  = extents[*desktop * 4 + 2];
+                const int globalHeight = extents[*desktop * 4 + 3];
+
+                if (areaX < globalX)
+                {
+                    areaWidth -= globalX - areaX;
+                    areaX = globalX;
+                }
+
+                if (areaY < globalY)
+                {
+                    areaHeight -= globalY - areaY;
+                    areaY = globalY;
+                }
+
+                if (areaX + areaWidth > globalX + globalWidth)
+                    areaWidth = globalX - areaX + globalWidth;
+                if (areaY + areaHeight > globalY + globalHeight)
+                    areaHeight = globalY - areaY + globalHeight;
+            }
+        }
+
+        if (extents)
+            XFree(extents);
+        if (desktop)
+            XFree(desktop);
+    }
+
+    if (xpos)
+        *xpos = areaX;
+    if (ypos)
+        *ypos = areaY;
+    if (width)
+        *width = areaWidth;
+    if (height)
+        *height = areaHeight;
+}
+
 GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* count)
 {
     GLFWvidmode* result;
@@ -433,7 +528,7 @@ void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode)
     }
 }
 
-void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
+GLFWbool _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
 {
     if (_glfw.x11.randr.available && !_glfw.x11.randr.gammaBroken)
     {
@@ -449,6 +544,7 @@ void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
         memcpy(ramp->blue,  gamma->blue,  size * sizeof(unsigned short));
 
         XRRFreeGamma(gamma);
+        return GLFW_TRUE;
     }
     else if (_glfw.x11.vidmode.available)
     {
@@ -460,6 +556,13 @@ void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
         XF86VidModeGetGammaRamp(_glfw.x11.display,
                                 _glfw.x11.screen,
                                 ramp->size, ramp->red, ramp->green, ramp->blue);
+        return GLFW_TRUE;
+    }
+    else
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "X11: Gamma ramp access not supported by server");
+        return GLFW_FALSE;
     }
 }
 
@@ -492,6 +595,10 @@ void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
                                 (unsigned short*) ramp->green,
                                 (unsigned short*) ramp->blue);
     }
+    else {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "X11: Gamma ramp access not supported by server");
+    }
 }
 
 

glfw/x11_platform.h

@@ -182,7 +182,6 @@ typedef struct _GLFWwindowX11
     Colormap        colormap;
     Window          handle;
 
-    GLFWbool        overrideRedirect;
     GLFWbool        iconified;
     GLFWbool        maximized;
 
@@ -198,9 +197,6 @@ typedef struct _GLFWwindowX11
     // The last position the cursor was warped to by GLFW
     int             warpCursorPosX, warpCursorPosY;
 
-    // The time of the last KeyPress event
-    Time            lastKeyTime;
-
 } _GLFWwindowX11;
 
 // X11-specific global data
@@ -251,6 +247,8 @@ typedef struct _GLFWlibraryX11
     Atom            NET_WM_FULLSCREEN_MONITORS;
     Atom            NET_WM_WINDOW_OPACITY;
     Atom            NET_WM_CM_Sx;
+    Atom            NET_WORKAREA;
+    Atom            NET_CURRENT_DESKTOP;
     Atom            NET_ACTIVE_WINDOW;
     Atom            NET_FRAME_EXTENTS;
     Atom            NET_REQUEST_FRAME_EXTENTS;

glfw/x11_window.c

@@ -28,6 +28,7 @@
 #define _GNU_SOURCE
 #include "internal.h"
 #include "backend_utils.h"
+#include "linux_notify.h"
 
 #include <X11/cursorfont.h>
 #include <X11/Xmd.h>
@@ -54,13 +55,21 @@
 // This avoids blocking other threads via the per-display Xlib lock that also
 // covers GLX functions
 //
-GLFWbool _glfwDispatchX11Events(void);
+static unsigned _glfwDispatchX11Events(void);
 
 static void
 handleEvents(double timeout) {
+    EVDBG("starting handleEvents(%.2f)", timeout);
     int display_read_ok = pollForEvents(&_glfw.x11.eventLoopData, timeout);
-    if (display_read_ok) _glfwDispatchX11Events();
+    EVDBG("display_read_ok: %d", display_read_ok);
+    if (display_read_ok) {
+        unsigned dispatched = _glfwDispatchX11Events();
+        (void)dispatched;
+        EVDBG("dispatched %u X11 events", dispatched);
+    }
     glfw_ibus_dispatch(&_glfw.x11.xkb.ibus);
+    glfw_dbus_session_bus_dispatch();
+    EVDBG("other dispatch done");
 }
 
 static GLFWbool
@@ -256,6 +265,76 @@ static void updateNormalHints(_GLFWwindow* window, int width, int height)
     XFree(hints);
 }
 
+static inline bool
+is_window_fullscreen(_GLFWwindow* window)
+{
+    Atom* states;
+    unsigned long i;
+    GLFWbool ans = GLFW_FALSE;
+    if (!_glfw.x11.NET_WM_STATE || !_glfw.x11.NET_WM_STATE_FULLSCREEN)
+        return ans;
+    const unsigned long count =
+        _glfwGetWindowPropertyX11(window->x11.handle,
+                                  _glfw.x11.NET_WM_STATE,
+                                  XA_ATOM,
+                                  (unsigned char**) &states);
+
+    for (i = 0;  i < count;  i++)
+    {
+        if (states[i] == _glfw.x11.NET_WM_STATE_FULLSCREEN)
+        {
+            ans = GLFW_TRUE;
+            break;
+        }
+    }
+
+    if (states)
+        XFree(states);
+
+    return ans;
+}
+
+static inline void
+set_fullscreen(_GLFWwindow *window, bool on) {
+    if (_glfw.x11.NET_WM_STATE && _glfw.x11.NET_WM_STATE_FULLSCREEN) {
+        sendEventToWM(window,
+                _glfw.x11.NET_WM_STATE,
+                on ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE,
+                _glfw.x11.NET_WM_STATE_FULLSCREEN,
+                0, 1, 0);
+        // Enable compositor bypass
+        if (!window->x11.transparent)
+        {
+            if (on) {
+                const unsigned long value = 1;
+
+                XChangeProperty(_glfw.x11.display,  window->x11.handle,
+                                _glfw.x11.NET_WM_BYPASS_COMPOSITOR, XA_CARDINAL, 32,
+                                PropModeReplace, (unsigned char*) &value, 1);
+            } else {
+                XDeleteProperty(_glfw.x11.display, window->x11.handle,
+                                _glfw.x11.NET_WM_BYPASS_COMPOSITOR);
+            }
+        }
+
+    } else {
+        static bool warned = false;
+        if (!warned) {
+            warned = true;
+            _glfwInputErrorX11(GLFW_PLATFORM_ERROR,
+                               "X11: Failed to toggle fullscreen, the window manager does not support it");
+        }
+    }
+}
+
+bool
+_glfwPlatformToggleFullscreen(_GLFWwindow *window, unsigned int flags) {
+    (void) flags;
+    bool already_fullscreen = is_window_fullscreen(window);
+    set_fullscreen(window, !already_fullscreen);
+    return !already_fullscreen;
+}
+
 // Updates the full screen status of the window
 //
 static void updateWindowMode(_GLFWwindow* window)
@@ -274,43 +353,8 @@ static void updateWindowMode(_GLFWwindow* window)
                           0);
         }
 
-        if (_glfw.x11.NET_WM_STATE && _glfw.x11.NET_WM_STATE_FULLSCREEN)
-        {
-            sendEventToWM(window,
-                          _glfw.x11.NET_WM_STATE,
-                          _NET_WM_STATE_ADD,
-                          _glfw.x11.NET_WM_STATE_FULLSCREEN,
-                          0, 1, 0);
-        }
-        else
-        {
-            // This is the butcher's way of removing window decorations
-            // Setting the override-redirect attribute on a window makes the
-            // window manager ignore the window completely (ICCCM, section 4)
-            // The good thing is that this makes undecorated full screen windows
-            // easy to do; the bad thing is that we have to do everything
-            // manually and some things (like iconify/restore) won't work at
-            // all, as those are tasks usually performed by the window manager
+        set_fullscreen(window, true);
 
-            XSetWindowAttributes attributes;
-            attributes.override_redirect = True;
-            XChangeWindowAttributes(_glfw.x11.display,
-                                    window->x11.handle,
-                                    CWOverrideRedirect,
-                                    &attributes);
-
-            window->x11.overrideRedirect = GLFW_TRUE;
-        }
-
-        // Enable compositor bypass
-        if (!window->x11.transparent)
-        {
-            const unsigned long value = 1;
-
-            XChangeProperty(_glfw.x11.display,  window->x11.handle,
-                            _glfw.x11.NET_WM_BYPASS_COMPOSITOR, XA_CARDINAL, 32,
-                            PropModeReplace, (unsigned char*) &value, 1);
-        }
     }
     else
     {
@@ -321,32 +365,8 @@ static void updateWindowMode(_GLFWwindow* window)
                             _glfw.x11.NET_WM_FULLSCREEN_MONITORS);
         }
 
-        if (_glfw.x11.NET_WM_STATE && _glfw.x11.NET_WM_STATE_FULLSCREEN)
-        {
-            sendEventToWM(window,
-                          _glfw.x11.NET_WM_STATE,
-                          _NET_WM_STATE_REMOVE,
-                          _glfw.x11.NET_WM_STATE_FULLSCREEN,
-                          0, 1, 0);
-        }
-        else
-        {
-            XSetWindowAttributes attributes;
-            attributes.override_redirect = False;
-            XChangeWindowAttributes(_glfw.x11.display,
-                                    window->x11.handle,
-                                    CWOverrideRedirect,
-                                    &attributes);
+        set_fullscreen(window, false);
 
-            window->x11.overrideRedirect = GLFW_FALSE;
-        }
-
-        // Disable compositor bypass
-        if (!window->x11.transparent)
-        {
-            XDeleteProperty(_glfw.x11.display, window->x11.handle,
-                            _glfw.x11.NET_WM_BYPASS_COMPOSITOR);
-        }
     }
 }
 
@@ -401,15 +421,6 @@ static char* convertLatin1toUTF8(const char* source)
     return target;
 }
 
-// Centers the cursor over the window client area
-//
-static void centerCursor(_GLFWwindow* window)
-{
-    int width, height;
-    _glfwPlatformGetWindowSize(window, &width, &height);
-    _glfwPlatformSetCursorPos(window, width / 2.0, height / 2.0);
-}
-
 // Updates the cursor image according to its cursor mode
 //
 static void updateCursorImage(_GLFWwindow* window)
@@ -453,7 +464,7 @@ static void disableCursor(_GLFWwindow* window)
                               &_glfw.x11.restoreCursorPosX,
                               &_glfw.x11.restoreCursorPosY);
     updateCursorImage(window);
-    centerCursor(window);
+    _glfwCenterCursorInContentArea(window);
     XGrabPointer(_glfw.x11.display, window->x11.handle, True,
                  ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
                  GrabModeAsync, GrabModeAsync,
@@ -873,6 +884,7 @@ static const char* getSelectionString(Atom selection)
         Atom actualType;
         int actualFormat;
         unsigned long itemCount, bytesAfter;
+        double start = glfwGetTime();
         XEvent notification, dummy;
 
         XConvertSelection(_glfw.x11.display,
@@ -887,7 +899,10 @@ static const char* getSelectionString(Atom selection)
                                        SelectionNotify,
                                        &notification))
         {
-            waitForX11Event(-1);
+            double time = glfwGetTime();
+            if (time - start > 2)
+                return "";
+            waitForX11Event(2.0 - (time - start));
         }
 
         if (notification.xselection.property == None)
@@ -918,12 +933,16 @@ static const char* getSelectionString(Atom selection)
 
             for (;;)
             {
+                start = glfwGetTime();
                 while (!XCheckIfEvent(_glfw.x11.display,
                                       &dummy,
                                       isSelPropNewValueNotify,
                                       (XPointer) &notification))
                 {
-                    waitForX11Event(-1);
+                    double time = glfwGetTime();
+                    if (time - start > 2)
+                        return "";
+                    waitForX11Event(2.0 - (time - start));
                 }
 
                 XFree(data);
@@ -1008,19 +1027,6 @@ static void acquireMonitor(_GLFWwindow* window)
 
     _glfwSetVideoModeX11(window->monitor, &window->videoMode);
 
-    if (window->x11.overrideRedirect)
-    {
-        int xpos, ypos;
-        GLFWvidmode mode;
-
-        // Manually position the window over its monitor
-        _glfwPlatformGetMonitorPos(window->monitor, &xpos, &ypos);
-        _glfwPlatformGetVideoMode(window->monitor, &mode);
-
-        XMoveResizeWindow(_glfw.x11.display, window->x11.handle,
-                          xpos, ypos, mode.width, mode.height);
-    }
-
     _glfwInputMonitorWindow(window->monitor, window);
 }
 
@@ -1047,7 +1053,7 @@ static void releaseMonitor(_GLFWwindow* window)
     }
 }
 
-static void onConfigChange()
+static void onConfigChange(void)
 {
     float xscale, yscale;
     _glfwGetSystemContentScaleX11(&xscale, &yscale, GLFW_TRUE);
@@ -1070,7 +1076,8 @@ static void onConfigChange()
 static void processEvent(XEvent *event)
 {
     _GLFWwindow* window = NULL;
-    Bool filtered = False;
+    static GLFWbool keymap_dirty = GLFW_FALSE;
+#define UPDATE_KEYMAP_IF_NEEDED if (keymap_dirty) { keymap_dirty = GLFW_FALSE; glfw_xkb_compile_keymap(&_glfw.x11.xkb, NULL); }
 
     if (_glfw.x11.randr.available)
     {
@@ -1146,11 +1153,12 @@ static void processEvent(XEvent *event)
                 /* fallthrough */
             case XkbMapNotify:
             {
-                glfw_xkb_compile_keymap(&_glfw.x11.xkb, NULL);
+                keymap_dirty = GLFW_TRUE;
                 return;
             }
             case XkbStateNotify:
             {
+                UPDATE_KEYMAP_IF_NEEDED;
                 XkbStateNotifyEvent *state_event = (XkbStateNotifyEvent*)kb_event;
                 glfw_xkb_update_modifiers(
                         &_glfw.x11.xkb, state_event->base_mods, state_event->latched_mods,
@@ -1175,12 +1183,14 @@ static void processEvent(XEvent *event)
     {
         case KeyPress:
         {
+            UPDATE_KEYMAP_IF_NEEDED;
             glfw_xkb_handle_key_event(window, &_glfw.x11.xkb, event->xkey.keycode, GLFW_PRESS);
             return;
         }
 
         case KeyRelease:
         {
+            UPDATE_KEYMAP_IF_NEEDED;
             if (!_glfw.x11.xkb.detectable)
             {
                 // HACK: Key repeat events will arrive as KeyRelease/KeyPress
@@ -1291,12 +1301,20 @@ static void processEvent(XEvent *event)
 
         case EnterNotify:
         {
+            // XEnterWindowEvent is XCrossingEvent
+            const int x = event->xcrossing.x;
+            const int y = event->xcrossing.y;
+
             // HACK: This is a workaround for WMs (KWM, Fluxbox) that otherwise
             //       ignore the defined cursor for hidden cursor mode
             if (window->cursorMode == GLFW_CURSOR_HIDDEN)
                 updateCursorImage(window);
 
             _glfwInputCursorEnter(window, GLFW_TRUE);
+            _glfwInputCursorPos(window, x, y);
+
+            window->x11.lastCursorPosX = x;
+            window->x11.lastCursorPosY = y;
             return;
         }
 
@@ -1359,7 +1377,7 @@ static void processEvent(XEvent *event)
             if (event->xconfigure.x != window->x11.xpos ||
                 event->xconfigure.y != window->x11.ypos)
             {
-                if (window->x11.overrideRedirect || event->xany.send_event)
+                if (event->xany.send_event)
                 {
                     _glfwInputWindowPos(window,
                                         event->xconfigure.x,
@@ -1377,9 +1395,6 @@ static void processEvent(XEvent *event)
         {
             // Custom client message, probably from the window manager
 
-            if (filtered)
-                return;
-
             if (event->xclient.message_type == None)
                 return;
 
@@ -1669,6 +1684,7 @@ static void processEvent(XEvent *event)
         case DestroyNotify:
             return;
     }
+#undef UPDATE_KEYMAP_IF_NEEDED
 }
 
 
@@ -2100,32 +2116,19 @@ void _glfwPlatformGetWindowContentScale(_GLFWwindow* window,
         *yscale = _glfw.x11.contentScaleY;
 }
 
+double _glfwPlatformGetDoubleClickInterval(_GLFWwindow* window)
+{
+    return 0.5;
+}
+
 void _glfwPlatformIconifyWindow(_GLFWwindow* window)
 {
-    if (window->x11.overrideRedirect)
-    {
-        // Override-redirect windows cannot be iconified or restored, as those
-        // tasks are performed by the window manager
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "X11: Iconification of full screen windows requires a WM that supports EWMH full screen");
-        return;
-    }
-
     XIconifyWindow(_glfw.x11.display, window->x11.handle, _glfw.x11.screen);
     XFlush(_glfw.x11.display);
 }
 
 void _glfwPlatformRestoreWindow(_GLFWwindow* window)
 {
-    if (window->x11.overrideRedirect)
-    {
-        // Override-redirect windows cannot be iconified or restored, as those
-        // tasks are performed by the window manager
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "X11: Iconification of full screen windows requires a WM that supports EWMH full screen");
-        return;
-    }
-
     if (_glfwPlatformWindowIconified(window))
     {
         XMapWindow(_glfw.x11.display, window->x11.handle);
@@ -2223,10 +2226,14 @@ void _glfwPlatformSetWindowMonitor(_GLFWwindow* window,
         }
         else
         {
+            if (!window->resizable)
+                updateNormalHints(window, width, height);
+
             XMoveResizeWindow(_glfw.x11.display, window->x11.handle,
                               xpos, ypos, width, height);
         }
 
+        XFlush(_glfw.x11.display);
         return;
     }
 
@@ -2235,16 +2242,20 @@ void _glfwPlatformSetWindowMonitor(_GLFWwindow* window,
 
     _glfwInputWindowMonitor(window, monitor);
     updateNormalHints(window, width, height);
-    updateWindowMode(window);
 
     if (window->monitor)
     {
-        XMapRaised(_glfw.x11.display, window->x11.handle);
-        if (waitForVisibilityNotify(window))
-            acquireMonitor(window);
+       if (!_glfwPlatformWindowVisible(window))
+       {
+           XMapRaised(_glfw.x11.display, window->x11.handle);
+           waitForVisibilityNotify(window);
+       }
+       updateWindowMode(window);
+       acquireMonitor(window);
     }
     else
     {
+        updateWindowMode(window);
         XMoveResizeWindow(_glfw.x11.display, window->x11.handle,
                           xpos, ypos, width, height);
     }
@@ -2261,6 +2272,11 @@ int _glfwPlatformWindowFocused(_GLFWwindow* window)
     return window->x11.handle == focused;
 }
 
+int _glfwPlatformWindowOccluded(_GLFWwindow* window)
+{
+    return GLFW_FALSE;
+}
+
 int _glfwPlatformWindowIconified(_GLFWwindow* window)
 {
     return getWindowState(window) == IconicState;
@@ -2278,6 +2294,10 @@ int _glfwPlatformWindowMaximized(_GLFWwindow* window)
     Atom* states;
     unsigned long i;
     GLFWbool maximized = GLFW_FALSE;
+    if (!_glfw.x11.NET_WM_STATE ||
+            !_glfw.x11.NET_WM_STATE_MAXIMIZED_VERT ||
+            !_glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ)
+        return maximized;
     const unsigned long count =
         _glfwGetWindowPropertyX11(window->x11.handle,
                                   _glfw.x11.NET_WM_STATE,
@@ -2464,23 +2484,29 @@ void _glfwPlatformSetWindowOpacity(_GLFWwindow* window, float opacity)
                     PropModeReplace, (unsigned char*) &value, 1);
 }
 
-GLFWbool
+static inline unsigned
+dispatch_x11_queued_events(void) {
+    unsigned dispatched = 0;
+    while (XQLength(_glfw.x11.display) > 0)
+    {
+        XEvent event;
+        XNextEvent(_glfw.x11.display, &event);
+        processEvent(&event);
+        dispatched += 1;
+    }
+    return dispatched;
+}
+
+static unsigned
 _glfwDispatchX11Events(void) {
     _GLFWwindow* window;
-    GLFWbool dispatched = GLFW_FALSE;
+    unsigned dispatched = 0;
 
 #if defined(__linux__)
     _glfwDetectJoystickConnectionLinux();
 #endif
     XPending(_glfw.x11.display);
-
-    while (XQLength(_glfw.x11.display))
-    {
-        XEvent event;
-        XNextEvent(_glfw.x11.display, &event);
-        processEvent(&event);
-        dispatched = GLFW_TRUE;
-    }
+    dispatched += dispatch_x11_queued_events();
 
     window = _glfw.x11.disabledCursorWindow;
     if (window)
@@ -2498,6 +2524,8 @@ _glfwDispatchX11Events(void) {
     }
 
     XFlush(_glfw.x11.display);
+    // XFlush can cause events to be queued
+    dispatched += dispatch_x11_queued_events();
     return dispatched;
 }
 
@@ -2521,16 +2549,6 @@ void _glfwPlatformWaitEventsTimeout(double timeout)
 
 void _glfwPlatformPostEmptyEvent(void)
 {
-    XEvent event;
-
-    memset(&event, 0, sizeof(event));
-    event.type = ClientMessage;
-    event.xclient.window = _glfw.x11.helperWindowHandle;
-    event.xclient.format = 32; // Data is 32-bit longs
-    event.xclient.message_type = _glfw.x11.NULL_;
-
-    XSendEvent(_glfw.x11.display, _glfw.x11.helperWindowHandle, False, 0, &event);
-    XFlush(_glfw.x11.display);
     while (write(_glfw.x11.eventLoopData.wakeupFds[1], "w", 1) < 0 && errno == EINTR);
 }
 
@@ -2599,24 +2617,25 @@ int _glfwPlatformCreateCursor(_GLFWcursor* cursor,
     return GLFW_TRUE;
 }
 
-int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, int shape)
+int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, GLFWCursorShape shape)
 {
     int native = 0;
-
-    if (shape == GLFW_ARROW_CURSOR)
-        native = XC_left_ptr;
-    else if (shape == GLFW_IBEAM_CURSOR)
-        native = XC_xterm;
-    else if (shape == GLFW_CROSSHAIR_CURSOR)
-        native = XC_crosshair;
-    else if (shape == GLFW_HAND_CURSOR)
-        native = XC_hand1;
-    else if (shape == GLFW_HRESIZE_CURSOR)
-        native = XC_sb_h_double_arrow;
-    else if (shape == GLFW_VRESIZE_CURSOR)
-        native = XC_sb_v_double_arrow;
-    else
-        return GLFW_FALSE;
+#define C(name, val) case name: native = val; break;
+    switch(shape) {
+        C(GLFW_ARROW_CURSOR, XC_arrow);
+        C(GLFW_IBEAM_CURSOR, XC_xterm);
+        C(GLFW_CROSSHAIR_CURSOR, XC_crosshair);
+        C(GLFW_HAND_CURSOR, XC_hand2);
+        C(GLFW_HRESIZE_CURSOR, XC_sb_h_double_arrow);
+        C(GLFW_VRESIZE_CURSOR, XC_sb_v_double_arrow);
+        C(GLFW_NW_RESIZE_CURSOR, XC_top_left_corner);
+        C(GLFW_NE_RESIZE_CURSOR, XC_top_right_corner);
+        C(GLFW_SW_RESIZE_CURSOR, XC_bottom_left_corner);
+        C(GLFW_SE_RESIZE_CURSOR, XC_bottom_right_corner);
+        case GLFW_INVALID_CURSOR:
+            return GLFW_FALSE;
+    }
+#undef C
 
     cursor->x11.handle = XCreateFontCursor(_glfw.x11.display, native);
     if (!cursor->x11.handle)
@@ -2667,6 +2686,29 @@ const char* _glfwPlatformGetClipboardString(void)
     return getSelectionString(_glfw.x11.CLIPBOARD);
 }
 
+void _glfwPlatformSetPrimarySelectionString(const char* string)
+{
+    free(_glfw.x11.primarySelectionString);
+    _glfw.x11.primarySelectionString = _glfw_strdup(string);
+
+    XSetSelectionOwner(_glfw.x11.display,
+                       _glfw.x11.PRIMARY,
+                       _glfw.x11.helperWindowHandle,
+                       CurrentTime);
+
+    if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.PRIMARY) !=
+        _glfw.x11.helperWindowHandle)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "X11: Failed to become owner of primary selection");
+    }
+}
+
+const char* _glfwPlatformGetPrimarySelectionString(void)
+{
+    return getSelectionString(_glfw.x11.PRIMARY);
+}
+
 void _glfwPlatformGetRequiredInstanceExtensions(char** extensions)
 {
     if (!_glfw.vk.KHR_surface)
@@ -2838,32 +2880,14 @@ GLFWAPI Window glfwGetX11Window(GLFWwindow* handle)
     return window->x11.handle;
 }
 
-GLFWAPI void glfwSetX11SelectionString(const char* string)
-{
-    _GLFW_REQUIRE_INIT();
-
-    free(_glfw.x11.primarySelectionString);
-    _glfw.x11.primarySelectionString = _glfw_strdup(string);
-
-    XSetSelectionOwner(_glfw.x11.display,
-                       _glfw.x11.PRIMARY,
-                       _glfw.x11.helperWindowHandle,
-                       CurrentTime);
-
-    if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.PRIMARY) !=
-        _glfw.x11.helperWindowHandle)
-    {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "X11: Failed to become owner of primary selection");
-    }
-}
-
-GLFWAPI const char* glfwGetX11SelectionString(void)
-{
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-    return getSelectionString(_glfw.x11.PRIMARY);
-}
-
 GLFWAPI int glfwGetXKBScancode(const char* keyName, GLFWbool caseSensitive) {
     return glfw_xkb_keysym_from_name(keyName, caseSensitive);
 }
+
+GLFWAPI unsigned long long glfwDBusUserNotify(const char *app_name, const char* icon, const char *summary, const char *body, const char *action_name, int32_t timeout, GLFWDBusnotificationcreatedfun callback, void *data) {
+    return glfw_dbus_send_user_notification(app_name, icon, summary, body, action_name, timeout, callback, data);
+}
+
+GLFWAPI void glfwDBusSetUserNotificationHandler(GLFWDBusnotificationactivatedfun handler) {
+    glfw_dbus_set_user_notification_activated_handler(handler);
+}

glfw/xkb_glfw.c

@@ -46,6 +46,8 @@
         S(bracketleft, LEFT_BRACKET); \
         S(backslash, BACKSLASH); \
         S(bracketright, RIGHT_BRACKET); \
+        S(plus, PLUS); \
+        S(underscore, UNDERSCORE); \
         S(grave, GRAVE_ACCENT); \
         S(Escape, ESCAPE); \
         S(Return, ENTER); \
@@ -255,6 +257,7 @@ load_compose_tables(_GLFWXKBData *xkb) {
     if (!xkb->states.composeState) {
         _glfwInputError(GLFW_PLATFORM_ERROR, "Failed to create XKB compose state");
     }
+    xkb_compose_table_unref(compose_table);
 }
 
 GLFWbool

kittens/ask/main.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # vim:fileencoding=utf-8
 # License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
 

kittens/choose/choose-data-types.h

@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2017 Kovid Goyal <kovid at kovidgoyal.net>
+ *
+ * Distributed under terms of the GPL3 license.
+ */
+
+#pragma once
+#include "data-types.h"
+#if defined(_MSC_VER)
+#define ISWINDOWS
+#define STDCALL __stdcall
+#ifndef ssize_t
+#include <BaseTsd.h>
+typedef SSIZE_T ssize_t;
+#ifndef SSIZE_MAX
+#if defined(_WIN64)
+    #define SSIZE_MAX _I64_MAX
+#else
+    #define SSIZE_MAX LONG_MAX
+#endif
+#endif
+#endif
+#else
+#define STDCALL
+#endif
+
+#include "vector.h"
+
+typedef uint8_t len_t;
+typedef uint32_t text_t;
+
+#define LEN_MAX UINT8_MAX
+#define UTF8_ACCEPT 0
+#define UTF8_REJECT 1
+#define IS_LOWERCASE(x) (x) >= 'a' && (x) <= 'z'
+#define IS_UPPERCASE(x) (x) >= 'A' && (x) <= 'Z'
+#define LOWERCASE(x) ((IS_UPPERCASE(x)) ? (x) + 32 : (x))
+#define arraysz(x) (sizeof(x)/sizeof(x[0]))
+
+typedef struct {
+    text_t* src;
+    ssize_t src_sz;
+    len_t haystack_len;
+    len_t *positions;
+    double score;
+    ssize_t idx;
+} Candidate;
+
+typedef struct {
+    Candidate *haystack;
+    size_t haystack_count;
+    text_t level1[LEN_MAX], level2[LEN_MAX], level3[LEN_MAX], needle[LEN_MAX];
+    len_t level1_len, level2_len, level3_len, needle_len;
+    size_t haystack_size;
+    text_t *output;
+    size_t output_sz, output_pos;
+    int oom;
+} GlobalData;
+
+typedef struct {
+    bool output_positions;
+    size_t limit;
+    int num_threads;
+    text_t mark_before[128], mark_after[128], delimiter[128];
+    size_t mark_before_sz, mark_after_sz, delimiter_sz;
+} Options;
+
+VECTOR_OF(len_t, Positions)
+VECTOR_OF(text_t, Chars)
+VECTOR_OF(Candidate, Candidates)
+
+
+void output_results(GlobalData *, Candidate *haystack, size_t count, Options *opts, len_t needle_len);
+void* alloc_workspace(len_t max_haystack_len, GlobalData*);
+void* free_workspace(void *v);
+double score_item(void *v, text_t *haystack, len_t haystack_len, len_t *match_positions);
+unsigned int encode_codepoint(text_t ch, char* dest);
+size_t unescape(const char *src, char *dest, size_t destlen);
+int cpu_count(void);
+void* alloc_threads(size_t num_threads);
+#ifdef ISWINDOWS
+bool start_thread(void* threads, size_t i, unsigned int (STDCALL *start_routine) (void *), void *arg);
+ssize_t getdelim(char **lineptr, size_t *n, int delim, FILE *stream);
+#else
+bool start_thread(void* threads, size_t i, void *(*start_routine) (void *), void *arg);
+#endif
+void wait_for_thread(void *threads, size_t i);
+void free_threads(void *threads);

kittens/choose/main.c

@@ -0,0 +1,244 @@
+/*
+ * main.c
+ * Copyright (C) 2017 Kovid Goyal <kovid at kovidgoyal.net>
+ *
+ * Distributed under terms of the GPL3 license.
+ */
+
+#include "choose-data-types.h"
+#include "charsets.h"
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <fcntl.h>
+#ifndef ISWINDOWS
+#include <unistd.h>
+#endif
+
+typedef struct {
+    size_t start, count;
+    void *workspace;
+    len_t max_haystack_len;
+    bool started;
+    GlobalData *global;
+} JobData;
+
+
+static unsigned int STDCALL
+run_scoring(JobData *job_data) {
+    GlobalData *global = job_data->global;
+    for (size_t i = job_data->start; i < job_data->start + job_data->count; i++) {
+        global->haystack[i].score = score_item(job_data->workspace, global->haystack[i].src, global->haystack[i].haystack_len, global->haystack[i].positions);
+    }
+    return 0;
+}
+
+static void*
+run_scoring_pthreads(void *job_data) {
+    run_scoring((JobData*)job_data);
+    return NULL;
+}
+#ifdef ISWINDOWS
+#define START_FUNC run_scoring
+#else
+#define START_FUNC run_scoring_pthreads
+#endif
+
+static JobData*
+create_job(size_t i, size_t blocksz, GlobalData *global) {
+    JobData *ans = (JobData*)calloc(1, sizeof(JobData));
+    if (ans == NULL) return NULL;
+    ans->start = i * blocksz;
+    if (ans->start >= global->haystack_count) ans->count = 0;
+    else ans->count = global->haystack_count - ans->start;
+    ans->max_haystack_len = 0;
+    for (size_t i = ans->start; i < ans->start + ans->count; i++) ans->max_haystack_len = MAX(ans->max_haystack_len, global->haystack[i].haystack_len);
+    if (ans->count > 0) {
+        ans->workspace = alloc_workspace(ans->max_haystack_len, global);
+        if (!ans->workspace) { free(ans); return NULL; }
+    }
+    ans->global = global;
+    return ans;
+}
+
+static JobData*
+free_job(JobData *job) {
+    if (job) {
+        if (job->workspace) free_workspace(job->workspace);
+        free(job);
+    }
+    return NULL;
+}
+
+
+static int
+run_threaded(int num_threads_asked, GlobalData *global) {
+    int ret = 0;
+    size_t i, blocksz;
+    size_t num_threads = MAX(1, num_threads_asked > 0 ? num_threads_asked : cpu_count());
+    if (global->haystack_size < 10000) num_threads = 1;
+    /* printf("num_threads: %lu asked: %d sysconf: %ld\n", num_threads, num_threads_asked, sysconf(_SC_NPROCESSORS_ONLN)); */
+
+    void *threads = alloc_threads(num_threads);
+    JobData **job_data = calloc(num_threads, sizeof(JobData*));
+    if (threads == NULL || job_data == NULL) { ret = 1; goto end; }
+
+    blocksz = global->haystack_count / num_threads + global->haystack_count % num_threads;
+
+    for (i = 0; i < num_threads; i++) {
+        job_data[i] = create_job(i, blocksz, global);
+        if (job_data[i] == NULL) { ret = 1; goto end; }
+    }
+
+    if (num_threads == 1) {
+        run_scoring(job_data[0]);
+    } else {
+        for (i = 0; i < num_threads; i++) {
+            job_data[i]->started = false;
+            if (job_data[i]->count > 0) {
+                if (!start_thread(threads, i, START_FUNC, job_data[i])) ret = 1;
+                else job_data[i]->started = true;
+            }
+        }
+    }
+
+end:
+    if (num_threads > 1 && job_data) {
+        for (i = 0; i < num_threads; i++) {
+            if (job_data[i] && job_data[i]->started) wait_for_thread(threads, i);
+        }
+    }
+    for (i = 0; i < num_threads; i++) job_data[i] = free_job(job_data[i]);
+    free(job_data);
+    free_threads(threads);
+    return ret;
+}
+
+
+static int
+run_search(Options *opts, GlobalData *global, const char * const *lines, const size_t* sizes, size_t num_lines) {
+    const char *linebuf = NULL;
+    size_t idx = 0;
+    ssize_t sz = 0;
+    int ret = 0;
+    Candidates candidates = {0};
+    Chars chars = {0};
+
+    ALLOC_VEC(text_t, chars, 8192 * 20);
+    if (chars.data == NULL) return 1;
+    ALLOC_VEC(Candidate, candidates, 8192);
+    if (candidates.data == NULL) { FREE_VEC(chars) return 1; }
+
+    for (size_t i = 0; i < num_lines; i++) {
+        sz = sizes[i];
+        linebuf = lines[i];
+        if (sz > 0) {
+            ENSURE_SPACE(text_t, chars, sz);
+            ENSURE_SPACE(Candidate, candidates, 1);
+            sz = decode_utf8_string(linebuf, sz, &(NEXT(chars)));
+            NEXT(candidates).src_sz = sz;
+            NEXT(candidates).haystack_len = (len_t)(MIN(LEN_MAX, sz));
+            global->haystack_size += NEXT(candidates).haystack_len;
+            NEXT(candidates).idx = idx++;
+            INC(candidates, 1); INC(chars, sz);
+        }
+    }
+
+    // Prepare the haystack allocating space for positions arrays and settings
+    // up the src pointers to point to the correct locations
+    Candidate *haystack = &ITEM(candidates, 0);
+    len_t *positions = (len_t*)calloc(SIZE(candidates), sizeof(len_t) * global->needle_len);
+    if (positions) {
+        text_t *cdata = &ITEM(chars, 0);
+        for (size_t i = 0, off = 0; i < SIZE(candidates); i++) {
+            haystack[i].positions = positions + (i * global->needle_len);
+            haystack[i].src = cdata + off;
+            off += haystack[i].src_sz;
+        }
+        global->haystack = haystack;
+        global->haystack_count = SIZE(candidates);
+        ret = run_threaded(opts->num_threads, global);
+        if (ret == 0) output_results(global, haystack, SIZE(candidates), opts, global->needle_len);
+        else { REPORT_OOM; }
+    } else { ret = 1; REPORT_OOM; }
+
+    FREE_VEC(chars); free(positions); FREE_VEC(candidates);
+    return ret;
+}
+
+static size_t
+copy_unicode_object(PyObject *src, text_t *dest, size_t dest_sz) {
+    PyUnicode_READY(src);
+    int kind = PyUnicode_KIND(src);
+    void *data = PyUnicode_DATA(src);
+    size_t len = PyUnicode_GetLength(src);
+    for (size_t i = 0; i < len && i < dest_sz; i++) {
+        dest[i] = PyUnicode_READ(kind, data, i);
+    }
+    return len;
+}
+
+static PyObject*
+match(PyObject *self, PyObject *args) {
+    (void)(self);
+    int output_positions;
+    unsigned long limit;
+    PyObject *lines, *levels, *needle, *mark_before, *mark_after, *delimiter;
+    Options opts = {0};
+    GlobalData global = {0};
+    if (!PyArg_ParseTuple(args, "O!O!UpkiUUU",
+            &PyList_Type, &lines, &PyTuple_Type, &levels, &needle,
+            &output_positions, &limit, &opts.num_threads,
+            &mark_before, &mark_after, &delimiter
+    )) return NULL;
+    opts.output_positions = output_positions ? true : false;
+    opts.limit = limit;
+    global.level1_len = copy_unicode_object(PyTuple_GET_ITEM(levels, 0), global.level1, arraysz(global.level1));
+    global.level2_len = copy_unicode_object(PyTuple_GET_ITEM(levels, 1), global.level2, arraysz(global.level2));
+    global.level3_len = copy_unicode_object(PyTuple_GET_ITEM(levels, 2), global.level3, arraysz(global.level3));
+    global.needle_len = copy_unicode_object(needle, global.needle, arraysz(global.needle));
+    opts.mark_before_sz = copy_unicode_object(mark_before, opts.mark_before, arraysz(opts.mark_before));
+    opts.mark_after_sz = copy_unicode_object(mark_after, opts.mark_after, arraysz(opts.mark_after));
+    opts.delimiter_sz = copy_unicode_object(delimiter, opts.delimiter, arraysz(opts.delimiter));
+    size_t num_lines = PyList_GET_SIZE(lines);
+    char **clines = malloc(sizeof(char*) * num_lines);
+    if (!clines) { return PyErr_NoMemory(); }
+    size_t *sizes = malloc(sizeof(size_t) * num_lines);
+    if (!sizes) { free(clines); clines = NULL; return PyErr_NoMemory(); }
+    for (size_t i = 0; i < num_lines; i++) {
+        clines[i] = PyBytes_AS_STRING(PyList_GET_ITEM(lines, i));
+        sizes[i] = PyBytes_GET_SIZE(PyList_GET_ITEM(lines, i));
+    }
+    Py_BEGIN_ALLOW_THREADS;
+    run_search(&opts, &global, (const char* const *)clines, sizes, num_lines);
+    Py_END_ALLOW_THREADS;
+    free(clines); free(sizes);
+    if (global.oom) { free(global.output); return PyErr_NoMemory(); }
+    if (global.output) {
+        PyObject *ans = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, global.output, global.output_pos);
+        free(global.output);
+        return ans;
+    }
+    Py_RETURN_NONE;
+}
+
+static PyMethodDef module_methods[] = {
+    {"match", match, METH_VARARGS, ""},
+    {NULL, NULL, 0, NULL}        /* Sentinel */
+};
+
+static struct PyModuleDef module = {
+   .m_base = PyModuleDef_HEAD_INIT,
+   .m_name = "subseq_matcher",   /* name of module */
+   .m_doc = NULL,
+   .m_size = -1,
+   .m_methods = module_methods
+};
+
+EXPORTED PyMODINIT_FUNC
+PyInit_subseq_matcher(void) {
+    return PyModule_Create(&module);
+}

kittens/choose/main.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+# vim:fileencoding=utf-8
+# License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
+
+import sys
+
+
+from ..tui.handler import Handler
+from ..tui.loop import Loop
+
+from . import subseq_matcher
+
+
+def match(
+    input_data,
+    query,
+    threads=0,
+    positions=False,
+    level1='/',
+    level2='-_0123456789',
+    level3='.',
+    limit=0,
+    mark_before='',
+    mark_after='',
+    delimiter='\n'
+):
+    if isinstance(input_data, str):
+        input_data = input_data.encode('utf-8')
+    if isinstance(input_data, bytes):
+        input_data = input_data.split(delimiter.encode('utf-8'))
+    else:
+        input_data = [x.encode('utf-8') if isinstance(x, str) else x for x in input_data]
+    query = query.lower()
+    level1 = level1.lower()
+    level2 = level2.lower()
+    level3 = level3.lower()
+    data = subseq_matcher.match(
+        input_data, (level1, level2, level3), query,
+        positions, limit, threads,
+        mark_before, mark_after, delimiter)
+    if data is None:
+        return []
+    return list(filter(None, data.split(delimiter or '\n')))
+
+
+class ChooseHandler(Handler):
+
+    def initialize(self):
+        pass
+
+    def on_text(self, text, in_bracketed_paste=False):
+        pass
+
+    def on_key(self, key_event):
+        pass
+
+    def on_interrupt(self):
+        self.quit_loop(1)
+
+    def on_eot(self):
+        self.quit_loop(1)
+
+
+def main(args):
+    loop = Loop()
+    handler = ChooseHandler()
+    loop.loop(handler)
+    raise SystemExit(loop.return_code)
+
+
+if __name__ == '__main__':
+    main(sys.argv)

kittens/choose/output.c

@@ -0,0 +1,105 @@
+/*
+ * output.c
+ * Copyright (C) 2017 Kovid Goyal <kovid at kovidgoyal.net>
+ *
+ * Distributed under terms of the GPL3 license.
+ */
+
+#include "choose-data-types.h"
+#include <string.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <stdio.h>
+#ifdef ISWINDOWS
+#include <io.h>
+#define STDOUT_FILENO 1
+static inline ssize_t ms_write(int fd, const void* buf, size_t count) { return _write(fd, buf, (unsigned int)count); }
+#define write ms_write
+#else
+#include <unistd.h>
+#endif
+#include <errno.h>
+
+
+#define FIELD(x, which) (((Candidate*)(x))->which)
+
+static inline bool
+ensure_space(GlobalData *global, size_t sz) {
+    if (global->output_sz < sz + global->output_pos) {
+        size_t before = global->output_sz;
+        global->output_sz += MAX(sz, (64 * 1024));
+        global->output = realloc(global->output, sizeof(text_t) * global->output_sz);
+        if (!global->output) {
+            global->output_sz = before;
+            return false;
+        }
+    }
+    return true;
+}
+
+static inline void
+output_text(GlobalData *global, const text_t *data, size_t sz) {
+    if (ensure_space(global, sz)) {
+        memcpy(global->output + global->output_pos, data, sizeof(text_t) * sz);
+        global->output_pos += sz;
+    }
+}
+
+static int
+cmpscore(const void *a, const void *b) {
+    double sa = FIELD(a, score), sb = FIELD(b, score);
+    // Sort descending
+    return (sa > sb) ? -1 : ((sa == sb) ? ((int)FIELD(a, idx) - (int)FIELD(b, idx)) : 1);
+}
+
+static void
+output_with_marks(GlobalData *global, Options *opts, text_t *src, size_t src_sz, len_t *positions, len_t poslen) {
+    size_t pos, i = 0;
+    for (pos = 0; pos < poslen; pos++, i++) {
+        output_text(global, src + i, MIN(src_sz, positions[pos]) - i);
+        i = positions[pos];
+        if (i < src_sz) {
+            if (opts->mark_before_sz > 0) output_text(global, opts->mark_before, opts->mark_before_sz);
+            output_text(global, src + i, 1);
+            if (opts->mark_after_sz > 0) output_text(global, opts->mark_after, opts->mark_after_sz);
+        }
+    }
+    i = positions[poslen - 1];
+    if (i + 1 < src_sz) output_text(global, src + i + 1, src_sz - i - 1);
+}
+
+static void
+output_positions(GlobalData *global, len_t *positions, len_t num) {
+    wchar_t buf[128];
+    for (len_t i = 0; i < num; i++) {
+        int num = swprintf(buf, sizeof(buf)/sizeof(buf[0]), L"%u", positions[i]);
+        if (num > 0 && ensure_space(global, num + 1)) {
+            for (int i = 0; i < num; i++) global->output[global->output_pos++] = buf[i];
+            global->output[global->output_pos++] = (i == num - 1) ? ',' : ':';
+        }
+    }
+}
+
+
+static void
+output_result(GlobalData *global, Candidate *c, Options *opts, len_t needle_len) {
+    if (opts->output_positions) output_positions(global, c->positions, needle_len);
+    if (opts->mark_before_sz > 0 || opts->mark_after_sz > 0) {
+        output_with_marks(global, opts, c->src, c->src_sz, c->positions, needle_len);
+    } else {
+        output_text(global, c->src, c->src_sz);
+    }
+    output_text(global, opts->delimiter, opts->delimiter_sz);
+}
+
+
+void
+output_results(GlobalData *global, Candidate *haystack, size_t count, Options *opts, len_t needle_len) {
+    Candidate *c;
+    qsort(haystack, count, sizeof(*haystack), cmpscore);
+    size_t left = opts->limit > 0 ? opts->limit : count;
+    for (size_t i = 0; i < left; i++) {
+        c = haystack + i;
+        if (c->score > 0) output_result(global, c, opts, needle_len);
+    }
+}

kittens/choose/score.c

@@ -0,0 +1,182 @@
+/*
+ * score.c
+ * Copyright (C) 2017 Kovid Goyal <kovid at kovidgoyal.net>
+ *
+ * Distributed under terms of the GPL3 license.
+ */
+
+#include "choose-data-types.h"
+#include <stdlib.h>
+#include <string.h>
+#include <float.h>
+#include <stdio.h>
+
+typedef struct {
+    len_t *positions_buf;  // buffer to store positions for every char in needle
+    len_t **positions;  // Array of pointers into positions_buf
+    len_t *positions_count; // Array of counts for positions
+    len_t needle_len;  // Length of the needle
+    len_t max_haystack_len;  // Max length of a string in the haystack
+    len_t haystack_len; // Length of the current string in the haystack
+    len_t *address; // Array of offsets into the positions array
+    double max_score_per_char;
+    uint8_t *level_factors;  // Array of score factors for every character in the current haystack that matches a character in the needle
+    text_t *level1, *level2, *level3;  // The characters in the levels
+    len_t level1_len, level2_len, level3_len;
+    text_t *needle;  // The current needle
+    text_t *haystack; //The current haystack
+} WorkSpace;
+
+void*
+alloc_workspace(len_t max_haystack_len, GlobalData *global) {
+    WorkSpace *ans = calloc(1, sizeof(WorkSpace));
+    if (ans == NULL) return NULL;
+    ans->positions_buf = (len_t*) calloc(global->needle_len, sizeof(len_t) * max_haystack_len);
+    ans->positions = (len_t**)calloc(global->needle_len, sizeof(len_t*));
+    ans->positions_count = (len_t*)calloc(2*global->needle_len, sizeof(len_t));
+    ans->level_factors = (uint8_t*)calloc(max_haystack_len, sizeof(uint8_t));
+    if (ans->positions == NULL || ans->positions_buf == NULL || ans->positions_count == NULL || ans->level_factors == NULL) { free_workspace(ans); return NULL; }
+    ans->needle = global->needle;
+    ans->needle_len = global->needle_len;
+    ans->max_haystack_len = max_haystack_len;
+    ans->level1 = global->level1; ans->level2 = global->level2; ans->level3 = global->level3;
+    ans->level1_len = global->level1_len; ans->level2_len = global->level2_len; ans->level3_len = global->level3_len;
+    ans->address = ans->positions_count + sizeof(len_t) * global->needle_len;
+    for (len_t i = 0; i < global->needle_len; i++) ans->positions[i] = ans->positions_buf + i * max_haystack_len;
+    return ans;
+}
+
+#define NUKE(x) free(x); x = NULL;
+
+void*
+free_workspace(void *v) {
+    WorkSpace *w = (WorkSpace*)v;
+    NUKE(w->positions_buf);
+    NUKE(w->positions);
+    NUKE(w->positions_count);
+    NUKE(w->level_factors);
+    free(w);
+    return NULL;
+}
+
+static inline bool
+has_char(text_t *text, len_t sz, text_t ch) {
+    for(len_t i = 0; i < sz; i++) {
+        if(text[i] == ch) return true;
+    }
+    return false;
+}
+
+static inline uint8_t
+level_factor_for(text_t current, text_t last, WorkSpace *w) {
+    text_t lch = LOWERCASE(last);
+    if (has_char(w->level1, w->level1_len, lch)) return 90;
+    if (has_char(w->level2, w->level2_len, lch)) return 80;
+    if (IS_LOWERCASE(last) && IS_UPPERCASE(current)) return 80; // CamelCase
+    if (has_char(w->level3, w->level3_len, lch)) return 70;
+    return 0;
+}
+
+static void
+init_workspace(WorkSpace *w, text_t *haystack, len_t haystack_len) {
+    // Calculate the positions and level_factors arrays for the specified haystack
+    bool level_factor_calculated = false;
+    memset(w->positions_count, 0, sizeof(*(w->positions_count)) * 2 * w->needle_len);
+    memset(w->level_factors, 0, sizeof(*(w->level_factors)) * w->max_haystack_len);
+    for (len_t i = 0; i < haystack_len; i++) {
+        level_factor_calculated = false;
+        for (len_t j = 0; j < w->needle_len; j++) {
+            if (w->needle[j] == LOWERCASE(haystack[i])) {
+                if (!level_factor_calculated) {
+                    level_factor_calculated = true;
+                    w->level_factors[i] = i > 0 ? level_factor_for(haystack[i], haystack[i-1], w) : 0;
+                }
+                w->positions[j][w->positions_count[j]++] = i;
+            }
+        }
+    }
+    w->haystack = haystack;
+    w->haystack_len = haystack_len;
+    w->max_score_per_char = (1.0 / haystack_len + 1.0 / w->needle_len) / 2.0;
+}
+
+
+static inline bool
+has_atleast_one_match(WorkSpace *w) {
+    int p = -1;
+    bool found;
+    for (len_t i = 0; i < w->needle_len; i++) {
+        if (w->positions_count[i] == 0) return false;  // All characters of the needle are not present in the haystack
+        found = false;
+        for (len_t j = 0; j < w->positions_count[i]; j++) {
+            if (w->positions[i][j] > p) { p = w->positions[i][j]; found = true; break; }
+        }
+        if (!found) return false; // Characters of needle not present in sequence in haystack
+    }
+    return true;
+}
+
+#define POSITION(x) w->positions[x][w->address[x]]
+
+static inline bool
+increment_address(WorkSpace *w) {
+    len_t pos = w->needle_len - 1;
+    while(true) {
+        w->address[pos]++;
+        if (w->address[pos] < w->positions_count[pos]) return true;
+        if (pos == 0) break;
+        w->address[pos--] = 0;
+    }
+    return false;
+}
+
+static inline bool
+address_is_monotonic(WorkSpace *w) {
+    // Check if the character positions pointed to by the current address are monotonic
+    for (len_t i = 1; i < w->needle_len; i++) {
+        if (POSITION(i) <= POSITION(i-1)) return false;
+    }
+    return true;
+}
+
+static inline double
+calc_score(WorkSpace *w) {
+    double ans = 0;
+    len_t distance, pos;
+    for (len_t i = 0; i < w->needle_len; i++) {
+        pos = POSITION(i);
+        if (i == 0) distance = pos < LEN_MAX ? pos + 1 : LEN_MAX;
+        else {
+            distance = pos - POSITION(i-1);
+            if (distance < 2) {
+                ans += w->max_score_per_char; // consecutive characters
+                continue;
+            }
+        }
+        if (w->level_factors[pos]) ans += (100 * w->max_score_per_char) / w->level_factors[pos];  // at a special location
+        else ans += (0.75 * w->max_score_per_char) / distance;
+    }
+    return ans;
+}
+
+static double
+process_item(WorkSpace *w, len_t *match_positions) {
+    double highscore = 0, score;
+    do {
+        if (!address_is_monotonic(w)) continue;
+        score = calc_score(w);
+        if (score > highscore) {
+            highscore = score;
+            for (len_t i = 0; i < w->needle_len; i++) match_positions[i] = POSITION(i);
+        }
+    } while(increment_address(w));
+    return highscore;
+}
+
+double
+score_item(void *v, text_t *haystack, len_t haystack_len, len_t *match_positions) {
+    WorkSpace *w = (WorkSpace*)v;
+    init_workspace(w, haystack, haystack_len);
+    if (!has_atleast_one_match(w)) return 0;
+    return process_item(w, match_positions);
+}

kittens/choose/unix_compat.c

@@ -0,0 +1,50 @@
+/*
+ * unix_compat.c
+ * Copyright (C) 2017 Kovid Goyal <kovid at kovidgoyal.net>
+ *
+ * Distributed under terms of the GPL3 license.
+ */
+
+#include "choose-data-types.h"
+#include <unistd.h>
+#include <pthread.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#ifdef __APPLE__
+#ifndef _SC_NPROCESSORS_ONLN
+#define _SC_NPROCESSORS_ONLN 58
+#endif
+#endif
+
+int
+cpu_count() {
+    return sysconf(_SC_NPROCESSORS_ONLN);
+}
+
+
+void*
+alloc_threads(size_t num_threads) {
+    return calloc(num_threads, sizeof(pthread_t));
+}
+
+bool
+start_thread(void* threads, size_t i, void *(*start_routine) (void *), void *arg) {
+    int rc;
+    if ((rc = pthread_create(((pthread_t*)threads) + i, NULL, start_routine, arg))) {
+        fprintf(stderr, "Failed to create thread, with error: %s\n", strerror(rc));
+        return false;
+    }
+    return true;
+}
+
+void
+wait_for_thread(void *threads, size_t i) {
+    pthread_join(((pthread_t*)(threads))[i], NULL);
+}
+
+void
+free_threads(void *threads) {
+    free(threads);
+}

kittens/choose/vector.h

@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2017 Kovid Goyal <kovid at kovidgoyal.net>
+ *
+ * Distributed under terms of the GPL3 license.
+ */
+
+#pragma once
+
+#include "data-types.h"
+
+#define REPORT_OOM global->oom = 1;
+
+#define VECTOR_OF(TYPE, NAME) typedef struct { \
+    TYPE *data; \
+    size_t size; \
+    size_t capacity; \
+} NAME;
+
+#define ALLOC_VEC(TYPE, vec, cap) \
+    vec.size = 0; vec.capacity = cap; \
+    vec.data = (TYPE*)malloc(vec.capacity * sizeof(TYPE)); \
+    if (vec.data == NULL) { REPORT_OOM; }
+
+#define FREE_VEC(vec) \
+    if (vec.data) { free(vec.data); vec.data = NULL; } \
+    vec.size = 0; vec.capacity = 0;
+
+#define ENSURE_SPACE(TYPE, vec, amt) \
+    if (vec.size + amt >= vec.capacity) { \
+        vec.capacity = MAX(vec.capacity * 2, vec.size + amt); \
+        vec.data = (TYPE*)realloc(vec.data, sizeof(TYPE) * vec.capacity); \
+        if (vec.data == NULL) { REPORT_OOM; ret = 1; break; }  \
+    }
+
+#define NEXT(vec) (vec.data[vec.size])
+
+#define INC(vec, amt) vec.size += amt;
+
+#define SIZE(vec) (vec.size)
+
+#define ITEM(vec, n) (vec.data[n])

kittens/choose/windows_compat.c

@@ -0,0 +1,107 @@
+/*
+ * windows_compat.c
+ * Copyright (C) 2017 Kovid Goyal <kovid at kovidgoyal.net>
+ *
+ * Distributed under terms of the GPL3 license.
+ */
+
+#include "choose-data-types.h"
+
+#include <windows.h>
+#include <process.h>
+#include <stdio.h>
+#include <errno.h>
+
+int
+cpu_count() {
+    SYSTEM_INFO sysinfo;
+    GetSystemInfo(&sysinfo);
+    return sysinfo.dwNumberOfProcessors;
+}
+
+void*
+alloc_threads(size_t num_threads) {
+    return calloc(num_threads, sizeof(uintptr_t));
+}
+
+bool
+start_thread(void* vt, size_t i, unsigned int (STDCALL *start_routine) (void *), void *arg) {
+    uintptr_t *threads = (uintptr_t*)vt;
+    errno = 0;
+    threads[i] = _beginthreadex(NULL, 0, start_routine, arg, 0, NULL);
+    if (threads[i] == 0) {
+        perror("Failed to create thread, with error");
+        return false;
+    }
+    return true;
+}
+
+void
+wait_for_thread(void *vt, size_t i) {
+    uintptr_t *threads = vt;
+    WaitForSingleObject((HANDLE)threads[i], INFINITE);
+    CloseHandle((HANDLE)threads[i]);
+    threads[i] = 0;
+}
+
+void
+free_threads(void *threads) {
+    free(threads);
+}
+
+ssize_t
+getdelim(char **lineptr, size_t *n, int delim, FILE *stream) {
+    char c, *cur_pos, *new_lineptr;
+    size_t new_lineptr_len;
+
+    if (lineptr == NULL || n == NULL || stream == NULL) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    if (*lineptr == NULL) {
+        *n = 8192; /* init len */
+        if ((*lineptr = (char *)malloc(*n)) == NULL) {
+            errno = ENOMEM;
+            return -1;
+        }
+    }
+
+    cur_pos = *lineptr;
+    for (;;) {
+        c = getc(stream);
+
+        if (ferror(stream) || (c == EOF && cur_pos == *lineptr))
+            return -1;
+
+        if (c == EOF)
+            break;
+
+        if ((*lineptr + *n - cur_pos) < 2) {
+            if (SSIZE_MAX / 2 < *n) {
+#ifdef EOVERFLOW
+                errno = EOVERFLOW;
+#else
+                errno = ERANGE; /* no EOVERFLOW defined */
+#endif
+                return -1;
+            }
+            new_lineptr_len = *n * 2;
+
+            if ((new_lineptr = (char *)realloc(*lineptr, new_lineptr_len)) == NULL) {
+                errno = ENOMEM;
+                return -1;
+            }
+            *lineptr = new_lineptr;
+            *n = new_lineptr_len;
+        }
+
+        *cur_pos++ = c;
+
+        if (c == delim)
+            break;
+    }
+
+    *cur_pos = '\0';
+    return (ssize_t)(cur_pos - *lineptr);
+}

kittens/clipboard/main.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # vim:fileencoding=utf-8
 # License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
 

kittens/diff/collect.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # vim:fileencoding=utf-8
 # License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
 

kittens/diff/config.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # vim:fileencoding=utf-8
 # License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
 

kittens/diff/config_data.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # vim:fileencoding=utf-8
 # License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
 
@@ -85,7 +85,7 @@ c('hunk_bg', '#f1f8ff')
 
 c('search_bg', '#444', long_text=_('Highlighting'))
 c('search_fg', 'white')
-c('select_bg', '#B4D5FE')
+c('select_bg', '#b4d5fe')
 c('select_fg', 'black')
 
 g('shortcuts')

kittens/diff/highlight.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # vim:fileencoding=utf-8
 # License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
 

kittens/diff/main.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # vim:fileencoding=utf-8
 # License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
 
@@ -208,7 +208,7 @@ class DiffHandler(Handler):
                 break
 
         if num is not None:
-            self.scroll_pos = min(num, self.max_scroll_pos)
+            self.scroll_pos = max(0, min(num, self.max_scroll_pos))
 
     @property
     def num_lines(self):

kittens/diff/patch.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # vim:fileencoding=utf-8
 # License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
 
@@ -18,7 +18,7 @@ worker_processes = []
 
 
 def find_differ():
-    if shutil.which('git'):
+    if shutil.which('git') and subprocess.Popen(['git', '--help'], stderr=subprocess.DEVNULL, stdout=subprocess.DEVNULL).wait() == 0:
         return GIT_DIFF
     if shutil.which('diff'):
         return DIFF_DIFF

kittens/diff/render.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # vim:fileencoding=utf-8
 # License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
 

kittens/diff/search.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # vim:fileencoding=utf-8
 # License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
 

kittens/hints/main.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # vim:fileencoding=utf-8
 # License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
 
@@ -84,9 +84,17 @@ class Hints(Handler):
         self.args = args
         self.window_title = _('Choose URL') if args.type == 'url' else _('Choose text')
         self.multiple = args.multiple
+        self.match_suffix = self.get_match_suffix(args)
         self.chosen = []
         self.reset()
 
+    def get_match_suffix(self, args):
+        if args.add_trailing_space == 'always':
+            return ' '
+        if args.add_trailing_space == 'never':
+            return ''
+        return ' ' if args.multiple else ''
+
     def reset(self):
         self.current_input = ''
         self.current_text = None
@@ -112,7 +120,7 @@ class Hints(Handler):
                 if encode_hint(idx).startswith(self.current_input)
             ]
             if len(matches) == 1:
-                self.chosen.append(matches[0].text)
+                self.chosen.append(matches[0].text + self.match_suffix)
                 if self.multiple:
                     self.ignore_mark_indices.add(matches[0].index)
                     self.reset()
@@ -130,7 +138,7 @@ class Hints(Handler):
         elif key_event is enter_key and self.current_input:
             try:
                 idx = decode_hint(self.current_input)
-                self.chosen.append(self.index_map[idx].text)
+                self.chosen.append(self.index_map[idx].text + self.match_suffix)
                 self.ignore_mark_indices.add(idx)
             except Exception:
                 self.current_input = ''
@@ -307,8 +315,9 @@ def run(args, text):
             return
 
         largest_index = all_marks[-1].index
+        offset = max(0, args.hints_offset)
         for m in all_marks:
-            m.index = largest_index - m.index
+            m.index = largest_index - m.index + offset
         index_map = {m.index: m for m in all_marks}
     except Exception:
         import traceback
@@ -363,6 +372,20 @@ The minimum number of characters to consider a match.
 type=bool-set
 Select multiple matches and perform the action on all of them together at the end.
 In this mode, press :kbd:`Esc` to finish selecting.
+
+
+--add-trailing-space
+default=auto
+choices=auto,always,never
+Add trailing space after matched text. Defaults to auto, which adds the space
+when used together with --multiple.
+
+
+--hints-offset
+default=1
+type=int
+The offset (from zero) at which to start hint numbering. Note that only numbers
+greater than or equal to zero are respected.
 '''.format(','.join(sorted(URL_PREFIXES))).format
 help_text = 'Select text from the screen using the keyboard. Defaults to searching for URLs.'
 usage = ''