version 0.14.2

All python scripts start with `#!/usr/bin/env python3` so I did the same
for a bash script.

.circleci/config.yml

@@ -13,7 +13,7 @@ jobs:
         - run: python3 test.py
         - run: make FAIL_WARN=-W man
         - run: make FAIL_WARN=-W html
-        - run: python3 setup.py linux-package
+        - run: python3 setup.py linux-package --update-check-interval=0
 
   lin-35:
     docker:

count-lines-of-code

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

docs/build.rst

@@ -111,3 +111,9 @@ without needing to install all of |kitty|.
 
 This applies to creating packages for |kitty| for macOS package managers such as
 brew or MacPorts as well.
+
+
+.. note::
+        |kitty| has its own update check mechanism, if you would like to turn
+        it off for your package, use
+        ``python3 setup.py linux-package --update-check-interval=0``

docs/changelog.rst

@@ -4,6 +4,83 @@ Changelog
 |kitty| is a feature full, cross-platform, *fast*, GPU based terminal emulator.
 To update |kitty|, :doc:`follow the instructions <binary>`.
 
+0.14.2 [2019-06-09]
+---------------------
+
+- Add an option :opt:`placement_strategy` to control how the cell area is
+  aligned inside the window when the window size is not an exact multiple
+  of the cell size (:pull:`1670`)
+
+- hints kitten: Add a :option:`kitty +kitten hints --multiple-joiner` option to
+  control how multiple selections are serialized when copying to clipboard
+  or inserting into the terminal. You can have them on separate lines,
+  separated by arbitrary characters, or even serialized as JSON (:iss:`1665`)
+
+- macOS: Fix a regression in the previous release that broke using
+  :kbd:`ctrl+shift+tab` (:iss:`1671`)
+
+- panel kitten: Fix the contents of the panel kitten not being positioned
+  correctly on the vertical axis
+
+- icat kitten: Fix a regression that broke passing directories to icat
+  (:iss:`1683`)
+
+- clipboard kitten: Add a :option:`kitty +kitten clipboard --wait-for-completion`
+  option to have the kitten wait till copying to clipboard is complete
+  (:iss:`1693`)
+
+- Allow using the :doc:`pipe <pipe>` command to send screen and scrollback
+  contents directly to the clipboard (:iss:`1693`)
+
+- Linux: Disable the Wayland backend on GNOME by default as GNOME has no
+  support for server side decorations. Can be controlled by
+  :opt:`linux_display_server`.
+
+- Add an option to control the default :opt:`update_check_interval` when
+  building kitty packages
+
+- Wayland: Fix resizing the window on a compositor that does not provide
+  server side window decorations, such a GNOME or Weston not working
+  correctly (:iss:`1659`)
+
+- Wayland: Fix crash when enabling disabling monitors on sway (:iss:`1696`)
+
+
+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]
 ---------------------
 

docs/conf.py

@@ -1,3 +1,4 @@
+#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 #
 # Configuration file for the Sphinx documentation builder.
@@ -11,6 +12,7 @@ import os
 import re
 import subprocess
 import sys
+import time
 from functools import partial
 
 from docutils import nodes
@@ -32,7 +34,7 @@ str_version = importlib.import_module('kitty.constants').str_version
 # -- Project information -----------------------------------------------------
 
 project = 'kitty'
-copyright = '2018, Kovid Goyal'
+copyright = time.strftime('%Y, Kovid Goyal')
 author = 'Kovid Goyal'
 building_man_pages = 'man' in sys.argv
 

docs/index.rst

@@ -60,6 +60,7 @@ 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/>`_,
@@ -186,6 +187,7 @@ Increase font size                  :sc:`increase_font_size` (also :kbd:`⌘++`
 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`

docs/pipe.rst

@@ -43,6 +43,10 @@ You can choose where to run the pipe program:
 ``tab``
    A new window in a new tab
 
+``clipboard, primary``
+   Copy the text directly to the clipboard. In this case the specified program
+   is not run, so use some dummy program name for it.
+
 ``none``
    Run it in the background
 

gen-apc-parsers.py

@@ -93,7 +93,7 @@ def generate(function_name, callback_name, report_name, keymap, command_class, i
     report_cmd = cmd_for_report(report_name, keymap, type_map, payload_allowed)
     if payload_allowed:
         payload_after_value = "case ';': state = PAYLOAD; break;"
-        payload = payload = ', PAYLOAD'
+        payload = ', PAYLOAD'
         parr = 'static uint8_t payload[4096];'
         payload_case = f'''
             case PAYLOAD: {{

glfw/cocoa_init.m

@@ -197,7 +197,7 @@ static void createKeyTables(void)
 
 // Retrieve Unicode data for the current keyboard layout
 //
-static GLFWbool updateUnicodeDataNS(void)
+static bool updateUnicodeDataNS(void)
 {
     if (_glfw.ns.inputSource)
     {
@@ -214,7 +214,7 @@ static GLFWbool updateUnicodeDataNS(void)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "Cocoa: Failed to retrieve keyboard layout input source");
-        return GLFW_FALSE;
+        return false;
     }
 
     _glfw.ns.unicodeData =
@@ -224,15 +224,15 @@ static GLFWbool updateUnicodeDataNS(void)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "Cocoa: Failed to retrieve keyboard layout Unicode data");
-        return GLFW_FALSE;
+        return false;
     }
 
-    return GLFW_TRUE;
+    return true;
 }
 
 // Load HIToolbox.framework and the TIS symbols we need from it
 //
-static GLFWbool initializeTIS(void)
+static bool initializeTIS(void)
 {
     // This works only because Cocoa has already loaded it properly
     _glfw.ns.tis.bundle =
@@ -241,7 +241,7 @@ static GLFWbool initializeTIS(void)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "Cocoa: Failed to load HIToolbox.framework");
-        return GLFW_FALSE;
+        return false;
     }
 
     CFStringRef* kPropertyUnicodeKeyLayoutData =
@@ -264,7 +264,7 @@ static GLFWbool initializeTIS(void)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "Cocoa: Failed to load TIS API symbols");
-        return GLFW_FALSE;
+        return false;
     }
 
     _glfw.ns.tis.kPropertyUnicodeKeyLayoutData =
@@ -313,13 +313,20 @@ static GLFWbool initializeTIS(void)
 
 static inline bool
 is_ctrl_tab(NSEvent *event, NSEventModifierFlags modifierFlags) {
-    return event.keyCode == kVK_Tab && (modifierFlags == NSEventModifierFlagControl || modifierFlags == (
-                NSEventModifierFlagControl | NSEventModifierFlagShift));
+    if (
+            (modifierFlags == NSEventModifierFlagControl &&
+                [event.charactersIgnoringModifiers isEqualToString:@"\t"]) ||
+            (modifierFlags == (NSEventModifierFlagControl | NSEventModifierFlagShift) &&
+                [event.charactersIgnoringModifiers isEqualToString:@"\x19"])
+       ) return true;
+    return false;
 }
 
 static inline bool
 is_cmd_period(NSEvent *event, NSEventModifierFlags modifierFlags) {
-    return event.keyCode == kVK_ANSI_Period && modifierFlags == NSEventModifierFlagCommand;
+    if (modifierFlags != NSEventModifierFlagCommand) return false;
+    if ([event.charactersIgnoringModifiers isEqualToString:@"."]) return true;
+    return false;
 }
 
 int _glfwPlatformInit(void)
@@ -380,12 +387,12 @@ int _glfwPlatformInit(void)
 
     _glfw.ns.eventSource = CGEventSourceCreate(kCGEventSourceStateHIDSystemState);
     if (!_glfw.ns.eventSource)
-        return GLFW_FALSE;
+        return false;
 
     CGEventSourceSetLocalEventsSuppressionInterval(_glfw.ns.eventSource, 0.0);
 
     if (!initializeTIS())
-        return GLFW_FALSE;
+        return false;
 
     _glfw.ns.displayLinks.lock = [NSLock new];
     _glfwInitTimerNS();
@@ -393,7 +400,7 @@ int _glfwPlatformInit(void)
 
     _glfwPollMonitorsNS();
     }
-    return GLFW_TRUE;
+    return true;
 }
 
 void _glfwPlatformTerminate(void)
@@ -509,10 +516,7 @@ remove_timer_at(size_t idx) {
         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));
-        }
+        remove_i_from_array(timers, idx, num_timers);
     }
 }
 
@@ -554,7 +558,7 @@ void _glfwPlatformRemoveTimer(unsigned long long timer_id) {
     }
 }
 
-void _glfwPlatformUpdateTimer(unsigned long long timer_id, double interval, GLFWbool enabled) {
+void _glfwPlatformUpdateTimer(unsigned long long timer_id, double interval, bool enabled) {
     for (size_t i = 0; i < num_timers; i++) {
         if (timers[i].id == timer_id) {
             Timer *t = timers + i;

glfw/cocoa_monitor.m

@@ -116,16 +116,16 @@ static char* getDisplayName(CGDirectDisplayID displayID)
 
 // Check whether the display mode should be included in enumeration
 //
-static GLFWbool modeIsGood(CGDisplayModeRef mode)
+static bool modeIsGood(CGDisplayModeRef mode)
 {
     uint32_t flags = CGDisplayModeGetIOFlags(mode);
 
     if (!(flags & kDisplayModeValidFlag) || !(flags & kDisplayModeSafeFlag))
-        return GLFW_FALSE;
+        return false;
     if (flags & kDisplayModeInterlacedFlag)
-        return GLFW_FALSE;
+        return false;
     if (flags & kDisplayModeStretchedFlag)
-        return GLFW_FALSE;
+        return false;
 
 #if MAC_OS_X_VERSION_MAX_ALLOWED <= 101100
     CFStringRef format = CGDisplayModeCopyPixelEncoding(mode);
@@ -133,12 +133,12 @@ static GLFWbool modeIsGood(CGDisplayModeRef mode)
         CFStringCompare(format, CFSTR(IO32BitDirectPixels), 0))
     {
         CFRelease(format);
-        return GLFW_FALSE;
+        return false;
     }
 
     CFRelease(format);
 #endif /* MAC_OS_X_VERSION_MAX_ALLOWED */
-    return GLFW_TRUE;
+    return true;
 }
 
 // Convert Core Graphics display mode to GLFW video mode
@@ -215,12 +215,12 @@ static void endFadeReservation(CGDisplayFadeReservationToken token)
 
 // Finds and caches the NSScreen corresponding to the specified monitor
 //
-GLFWbool refreshMonitorScreen(_GLFWmonitor* monitor)
+bool refreshMonitorScreen(_GLFWmonitor* monitor)
 {
     if (monitor->ns.screen)
-        return GLFW_TRUE;
+        return true;
 
-     for (NSScreen* screen in [NSScreen screens])
+    for (NSScreen* screen in [NSScreen screens])
     {
         NSNumber* displayID = [screen deviceDescription][@"NSScreenNumber"];
 
@@ -230,12 +230,12 @@ GLFWbool refreshMonitorScreen(_GLFWmonitor* monitor)
         if (monitor->ns.unitNumber == CGDisplayUnitNumber([displayID unsignedIntValue]))
         {
             monitor->ns.screen = screen;
-            return GLFW_TRUE;
+            return true;
         }
     }
 
-     _glfwInputError(GLFW_PLATFORM_ERROR, "Cocoa: Failed to find a screen for monitor");
-    return GLFW_FALSE;
+    _glfwInputError(GLFW_PLATFORM_ERROR, "Cocoa: Failed to find a screen for monitor");
+    return false;
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -247,7 +247,7 @@ void _glfwClearDisplayLinks() {
     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;
+            _glfw.ns.displayLinks.entries[i].displayLinkStarted = false;
         }
         if (_glfw.ns.displayLinks.entries[i].displayLink) {
             CVDisplayLinkRelease(_glfw.ns.displayLinks.entries[i].displayLink);
@@ -265,12 +265,12 @@ static CVReturn displayLinkCallback(
 {
     CGDirectDisplayID displayID = (CGDirectDisplayID)userInfo;
     [_glfw.ns.displayLinks.lock lock];
-    GLFWbool notify = GLFW_FALSE;
+    bool notify = 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;
+                notify = true;
+                _glfw.ns.displayLinks.entries[i].renderFrameRequested = false;
             }
             break;
         }
@@ -366,6 +366,7 @@ void _glfwPollMonitorsNS(void)
 
     free(disconnected);
     free(displays);
+    _glfwRestartDisplayLinks();
 }
 
 // Change the current video mode
@@ -541,7 +542,7 @@ void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode *mode)
     CVDisplayLinkRelease(link);
 }
 
-GLFWbool _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
+bool _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
 {
     uint32_t i, size = CGDisplayGammaTableCapacity(monitor->ns.displayID);
     CGGammaValue* values = calloc(size * 3, sizeof(CGGammaValue));
@@ -563,7 +564,7 @@ GLFWbool _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
     }
 
     free(values);
-    return GLFW_TRUE;
+    return true;
 }
 
 void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)

glfw/cocoa_platform.h

@@ -116,8 +116,8 @@ typedef struct _GLFWwindowNS
     id              view;
     id              layer;
 
-    GLFWbool        maximized;
-    GLFWbool        retina;
+    bool        maximized;
+    bool        retina;
 
     // Cached window properties to filter out duplicate events
     int             width, height;
@@ -136,7 +136,7 @@ typedef struct _GLFWwindowNS
     // Dead key state
     UInt32 deadKeyState;
     // Whether a render frame has been requested for this window
-    GLFWbool renderFrameRequested;
+    bool renderFrameRequested;
     GLFWcocoarenderframefun renderFrameCallback;
 } _GLFWwindowNS;
 
@@ -144,8 +144,8 @@ typedef struct _GLFWDisplayLinkNS
 {
     CVDisplayLinkRef displayLink;
     CGDirectDisplayID displayID;
-    GLFWbool displayLinkStarted;
-    GLFWbool renderFrameRequested;
+    bool displayLinkStarted;
+    bool renderFrameRequested;
 } _GLFWDisplayLinkNS;
 
 // Cocoa-specific global data
@@ -154,7 +154,7 @@ typedef struct _GLFWlibraryNS
 {
     CGEventSourceRef    eventSource;
     id                  delegate;
-    GLFWbool            cursorHidden;
+    bool            cursorHidden;
     TISInputSourceRef   inputSource;
     IOHIDManagerRef     hidManager;
     id                  unicodeData;
@@ -224,6 +224,7 @@ 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/cocoa_window.m

@@ -53,9 +53,54 @@ static NSUInteger getStyleMask(_GLFWwindow* window)
     return styleMask;
 }
 
+
+CGDirectDisplayID displayIDForWindow(_GLFWwindow *w) {
+    NSWindow *nw = w->ns.object;
+    NSDictionary *dict = [nw.screen deviceDescription];
+    NSNumber *displayIDns = [dict objectForKey:@"NSScreenNumber"];
+    if (displayIDns) return [displayIDns unsignedIntValue];
+    return (CGDirectDisplayID)-1;
+}
+
+
+static inline void
+requestRenderFrame(_GLFWwindow *w, GLFWcocoarenderframefun callback) {
+    if (!callback) {
+        w->ns.renderFrameRequested = false;
+        w->ns.renderFrameCallback = NULL;
+        return;
+    }
+    w->ns.renderFrameCallback = callback;
+    w->ns.renderFrameRequested = true;
+    CGDirectDisplayID displayID = displayIDForWindow(w);
+    [_glfw.ns.displayLinks.lock lock];
+    for (size_t i = 0; i < _glfw.ns.displayLinks.count; i++) {
+        _GLFWDisplayLinkNS *dl = &_glfw.ns.displayLinks.entries[i];
+        if (dl->displayID == displayID) {
+            dl->renderFrameRequested = true;
+            if (!dl->displayLinkStarted) {
+                CVDisplayLinkStart(dl->displayLink);
+                dl->displayLinkStarted = true;
+            }
+            break;
+        }
+    }
+    [_glfw.ns.displayLinks.lock unlock];
+}
+
+void
+_glfwRestartDisplayLinks(void) {
+    _GLFWwindow* window;
+    for (window = _glfw.windowListHead;  window;  window = window->next) {
+        if (window->ns.renderFrameRequested && window->ns.renderFrameCallback) {
+            requestRenderFrame(window, window->ns.renderFrameCallback);
+        }
+    }
+}
+
 // Returns whether the cursor is in the content area of the specified window
 //
-static GLFWbool cursorInContentArea(_GLFWwindow* window)
+static bool cursorInContentArea(_GLFWwindow* window)
 {
     const NSPoint pos = [window->ns.object mouseLocationOutsideOfEventStream];
     return [window->ns.view mouse:pos inRect:[window->ns.view frame]];
@@ -68,7 +113,7 @@ static void hideCursor(_GLFWwindow* window)
     if (!_glfw.ns.cursorHidden)
     {
         [NSCursor hide];
-        _glfw.ns.cursorHidden = GLFW_TRUE;
+        _glfw.ns.cursorHidden = true;
     }
 }
 
@@ -79,7 +124,7 @@ static void showCursor(_GLFWwindow* window)
     if (_glfw.ns.cursorHidden)
     {
         [NSCursor unhide];
-        _glfw.ns.cursorHidden = GLFW_FALSE;
+        _glfw.ns.cursorHidden = false;
     }
 }
 
@@ -218,7 +263,7 @@ safe_name_for_scancode(unsigned int scancode) {
 
 // Translates a macOS keycode to a GLFW keycode
 //
-static int translateKey(unsigned int key, GLFWbool apply_keymap)
+static int translateKey(unsigned int key, bool apply_keymap)
 {
     if (apply_keymap) {
         // Look for the effective key name after applying any keyboard layouts/mappings
@@ -272,6 +317,7 @@ static int translateKey(unsigned int key, GLFWbool apply_keymap)
                 K('[', LEFT_BRACKET);
                 K(']', RIGHT_BRACKET);
                 K('+', PLUS);
+                K('_', UNDERSCORE);
                 K('`', GRAVE_ACCENT);
                 K('\\', BACKSLASH);
 #undef K
@@ -416,7 +462,7 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
     if (window->monitor)
         releaseMonitor(window);
 
-    _glfwInputWindowIconify(window, GLFW_TRUE);
+    _glfwInputWindowIconify(window, true);
 }
 
 - (void)windowDidDeminiaturize:(NSNotification *)notification
@@ -424,7 +470,7 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
     if (window->monitor)
         acquireMonitor(window);
 
-    _glfwInputWindowIconify(window, GLFW_FALSE);
+    _glfwInputWindowIconify(window, false);
 }
 
 - (void)windowDidBecomeKey:(NSNotification *)notification
@@ -432,7 +478,7 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
     if (_glfw.ns.disabledCursorWindow == window)
         _glfwCenterCursorInContentArea(window);
 
-    _glfwInputWindowFocus(window, GLFW_TRUE);
+    _glfwInputWindowFocus(window, true);
     updateCursorMode(window);
     if (window->cursorMode == GLFW_CURSOR_HIDDEN) hideCursor(window);
     if (_glfw.ns.disabledCursorWindow != window && cursorInContentArea(window))
@@ -449,9 +495,19 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
         _glfwPlatformIconifyWindow(window);
     showCursor(window);
 
-    _glfwInputWindowFocus(window, GLFW_FALSE);
+    _glfwInputWindowFocus(window, false);
 }
 
+- (void)windowDidChangeScreen:(NSNotification *)notification
+{
+    if (window->ns.renderFrameRequested && window->ns.renderFrameCallback) {
+        // Ensure that if the window changed its monitor, CVDisplayLink
+        // is running for the new monitor
+        requestRenderFrame(window, window->ns.renderFrameCallback);
+    }
+}
+
+
 @end
 
 
@@ -591,7 +647,6 @@ static GLFWapplicationshouldhandlereopenfun handle_reopen_callback = NULL;
     _glfwInputLiveResize(window, false);
 }
 
-
 - (BOOL)wantsUpdateLayer
 {
     return YES;
@@ -711,12 +766,12 @@ static GLFWapplicationshouldhandlereopenfun handle_reopen_callback = NULL;
 
 - (void)mouseExited:(NSEvent *)event
 {
-    _glfwInputCursorEnter(window, GLFW_FALSE);
+    _glfwInputCursorEnter(window, false);
 }
 
 - (void)mouseEntered:(NSEvent *)event
 {
-    _glfwInputCursorEnter(window, GLFW_TRUE);
+    _glfwInputCursorEnter(window, true);
 }
 
 - (void)viewDidChangeBackingProperties
@@ -805,7 +860,7 @@ convert_utf16_to_utf8(UniChar *src, UniCharCount src_length, char *dest, size_t
     CFRelease(string);
 }
 
-static inline GLFWbool
+static inline bool
 is_ascii_control_char(char x) {
     return x == 0 || (1 <= x && x <= 31) || x == 127;
 }
@@ -815,8 +870,8 @@ is_ascii_control_char(char x) {
     const unsigned int scancode = [event keyCode];
     const NSUInteger flags = [event modifierFlags];
     const int mods = translateFlags(flags);
-    const int key = translateKey(scancode, GLFW_TRUE);
-    const GLFWbool process_text = !window->ns.textInputFilterCallback || window->ns.textInputFilterCallback(key, mods, scancode, flags) != 1;
+    const int key = translateKey(scancode, true);
+    const bool process_text = !window->ns.textInputFilterCallback || window->ns.textInputFilterCallback(key, mods, scancode, flags) != 1;
     const bool previous_has_marked_text = [self hasMarkedText];
     [self unmarkText];
     _glfw.ns.text[0] = 0;
@@ -844,11 +899,13 @@ is_ascii_control_char(char x) {
                     &char_count,
                     text
                     ) != noErr) {
-            debug_key(@"UCKeyTranslate failed for scancode: 0x%x (%s) %s\n", scancode, safe_name_for_scancode(scancode), format_mods(mods));
+            debug_key(@"UCKeyTranslate failed for scancode: 0x%x (%s) %s\n",
+                    scancode, safe_name_for_scancode(scancode), format_mods(mods));
             window->ns.deadKeyState = 0;
             return;
         }
-        debug_key(@"scancode: 0x%x (%s) %schar_count: %lu deadKeyState: %u ", scancode, safe_name_for_scancode(scancode), format_mods(mods), char_count, window->ns.deadKeyState);
+        debug_key(@"scancode: 0x%x (%s) %schar_count: %lu deadKeyState: %u repeat: %d",
+                scancode, safe_name_for_scancode(scancode), format_mods(mods), char_count, window->ns.deadKeyState, event.ARepeat);
         if (process_text) {
             // this will call insertText which will fill up _glfw.ns.text
             [self interpretKeyEvents:[NSArray arrayWithObject:event]];
@@ -869,9 +926,8 @@ is_ascii_control_char(char x) {
         }
     }
     if (is_ascii_control_char(_glfw.ns.text[0])) _glfw.ns.text[0] = 0;  // don't send text for ascii control codes
-    debug_key(@"text: %s glfw_key: %s\n",
-            format_text(_glfw.ns.text), _glfwGetKeyName(key));
-    debug_key(@"marked text: %@", markedText);
+    debug_key(@"text: %s glfw_key: %s marked_text: %@\n",
+            format_text(_glfw.ns.text), _glfwGetKeyName(key), markedText);
     if (!window->ns.deadKeyState) {
         if ([self hasMarkedText]) {
             _glfwInputKeyboard(window, key, scancode, GLFW_PRESS, mods,
@@ -893,7 +949,7 @@ is_ascii_control_char(char x) {
     int action;
     const unsigned int modifierFlags =
         [event modifierFlags] & NSEventModifierFlagDeviceIndependentFlagsMask;
-    const int key = translateKey([event keyCode], GLFW_FALSE);
+    const int key = translateKey([event keyCode], false);
     const int mods = translateFlags(modifierFlags);
     const NSUInteger keyFlag = translateKeyToModifierFlag(key);
 
@@ -912,7 +968,7 @@ is_ascii_control_char(char x) {
 
 - (void)keyUp:(NSEvent *)event
 {
-    const int key = translateKey([event keyCode], GLFW_TRUE);
+    const int key = translateKey([event keyCode], true);
     const int mods = translateFlags([event modifierFlags]);
     _glfwInputKeyboard(window, key, [event keyCode], GLFW_RELEASE, mods, "", 0);
 }
@@ -1229,10 +1285,10 @@ static void createMenuBar(void)
 
 // Initialize the Cocoa Application Kit
 //
-static GLFWbool initializeAppKit(void)
+static bool initializeAppKit(void)
 {
     if (_glfw.ns.delegate)
-        return GLFW_TRUE;
+        return true;
 
     // There can only be one application delegate, but we allocate it the
     // first time a window is created to keep all window code in this file
@@ -1241,7 +1297,7 @@ static GLFWbool initializeAppKit(void)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "Cocoa: Failed to create application delegate");
-        return GLFW_FALSE;
+        return false;
     }
     [NSApp setDelegate:_glfw.ns.delegate];
 
@@ -1268,12 +1324,12 @@ static GLFWbool initializeAppKit(void)
 
     [[NSUserDefaults standardUserDefaults] registerDefaults:defaults];
 
-    return GLFW_TRUE;
+    return true;
 }
 
 // Create the Cocoa window
 //
-static GLFWbool createNativeWindow(_GLFWwindow* window,
+static bool createNativeWindow(_GLFWwindow* window,
                                    const _GLFWwndconfig* wndconfig,
                                    const _GLFWfbconfig* fbconfig)
 {
@@ -1282,7 +1338,7 @@ static GLFWbool createNativeWindow(_GLFWwindow* window,
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "Cocoa: Failed to create window delegate");
-        return GLFW_FALSE;
+        return false;
     }
 
     NSRect contentRect;
@@ -1309,7 +1365,7 @@ static GLFWbool createNativeWindow(_GLFWwindow* window,
     if (window->ns.object == nil)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR, "Cocoa: Failed to create window");
-        return GLFW_FALSE;
+        return false;
     }
 
     if (window->monitor)
@@ -1360,7 +1416,7 @@ static GLFWbool createNativeWindow(_GLFWwindow* window,
     _glfwPlatformGetWindowSize(window, &window->ns.width, &window->ns.height);
     _glfwPlatformGetFramebufferSize(window, &window->ns.fbWidth, &window->ns.fbHeight);
 
-    return GLFW_TRUE;
+    return true;
 }
 
 
@@ -1375,33 +1431,33 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
 {
     window->ns.deadKeyState = 0;
     if (!initializeAppKit())
-        return GLFW_FALSE;
+        return false;
 
     if (!createNativeWindow(window, wndconfig, fbconfig))
-        return GLFW_FALSE;
+        return false;
 
     if (ctxconfig->client != GLFW_NO_API)
     {
         if (ctxconfig->source == GLFW_NATIVE_CONTEXT_API)
         {
             if (!_glfwInitNSGL())
-                return GLFW_FALSE;
+                return false;
             if (!_glfwCreateContextNSGL(window, ctxconfig, fbconfig))
-                return GLFW_FALSE;
+                return false;
         }
         else if (ctxconfig->source == GLFW_EGL_CONTEXT_API)
         {
             if (!_glfwInitEGL())
-                return GLFW_FALSE;
+                return false;
             if (!_glfwCreateContextEGL(window, ctxconfig, fbconfig))
-                return GLFW_FALSE;
+                return false;
         }
         else if (ctxconfig->source == GLFW_OSMESA_CONTEXT_API)
         {
             if (!_glfwInitOSMesa())
-                return GLFW_FALSE;
+                return false;
             if (!_glfwCreateContextOSMesa(window, ctxconfig, fbconfig))
-                return GLFW_FALSE;
+                return false;
         }
     }
 
@@ -1412,7 +1468,7 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
         acquireMonitor(window);
     }
 
-    return GLFW_TRUE;
+    return true;
 }
 
 void _glfwPlatformDestroyWindow(_GLFWwindow* window)
@@ -1601,7 +1657,7 @@ void _glfwPlatformRequestWindowAttention(_GLFWwindow* window)
 int _glfwPlatformWindowBell(_GLFWwindow* window)
 {
     NSBeep();
-    return GLFW_TRUE;
+    return true;
 }
 
 void _glfwPlatformFocusWindow(_GLFWwindow* window)
@@ -1732,7 +1788,7 @@ int _glfwPlatformWindowHovered(_GLFWwindow* window)
     if ([NSWindow windowNumberAtPoint:point belowWindowWithWindowNumber:0] !=
         [window->ns.object windowNumber])
     {
-        return GLFW_FALSE;
+        return false;
     }
 
     return NSMouseInRect(point,
@@ -1744,18 +1800,18 @@ int _glfwPlatformFramebufferTransparent(_GLFWwindow* window)
     return ![window->ns.object isOpaque] && ![window->ns.view isOpaque];
 }
 
-void _glfwPlatformSetWindowResizable(_GLFWwindow* window, GLFWbool enabled)
+void _glfwPlatformSetWindowResizable(_GLFWwindow* window, bool enabled)
 {
     [window->ns.object setStyleMask:getStyleMask(window)];
 }
 
-void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, GLFWbool enabled)
+void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, bool enabled)
 {
     [window->ns.object setStyleMask:getStyleMask(window)];
     [window->ns.object makeFirstResponder:window->ns.view];
 }
 
-void _glfwPlatformSetWindowFloating(_GLFWwindow* window, GLFWbool enabled)
+void _glfwPlatformSetWindowFloating(_GLFWwindow* window, bool enabled)
 {
     if (enabled)
         [window->ns.object setLevel:NSFloatingWindowLevel];
@@ -1773,51 +1829,18 @@ void _glfwPlatformSetWindowOpacity(_GLFWwindow* window, float opacity)
     [window->ns.object setAlphaValue:opacity];
 }
 
-CGDirectDisplayID displayIDForWindow(_GLFWwindow *w) {
-    NSWindow *nw = w->ns.object;
-    NSDictionary *dict = [nw.screen deviceDescription];
-    NSNumber *displayIDns = [dict objectForKey:@"NSScreenNumber"];
-    if (displayIDns) return [displayIDns unsignedIntValue];
-    return (CGDirectDisplayID)-1;
-}
-
 void
 _glfwDispatchRenderFrame(CGDirectDisplayID displayID) {
     _GLFWwindow *w = _glfw.windowListHead;
     while (w) {
         if (w->ns.renderFrameRequested && displayID == displayIDForWindow(w)) {
-            w->ns.renderFrameRequested = GLFW_FALSE;
+            w->ns.renderFrameRequested = false;
             w->ns.renderFrameCallback((GLFWwindow*)w);
         }
         w = w->next;
     }
 }
 
-static inline void
-requestRenderFrame(_GLFWwindow *w, GLFWcocoarenderframefun callback) {
-    if (!callback) {
-        w->ns.renderFrameRequested = GLFW_FALSE;
-        w->ns.renderFrameCallback = NULL;
-        return;
-    }
-    w->ns.renderFrameCallback = callback;
-    w->ns.renderFrameRequested = GLFW_TRUE;
-    CGDirectDisplayID displayID = displayIDForWindow(w);
-    [_glfw.ns.displayLinks.lock lock];
-    for (size_t i = 0; i < _glfw.ns.displayLinks.count; i++) {
-        _GLFWDisplayLinkNS *dl = &_glfw.ns.displayLinks.entries[i];
-        if (dl->displayID == displayID) {
-            dl->renderFrameRequested = GLFW_TRUE;
-            if (!dl->displayLinkStarted) {
-                CVDisplayLinkStart(dl->displayLink);
-                dl->displayLinkStarted = GLFW_TRUE;
-            }
-            break;
-        }
-    }
-    [_glfw.ns.displayLinks.lock unlock];
-}
-
 void _glfwCocoaPostEmptyEvent(short subtype, long data1, bool at_start)
 {
     @autoreleasepool {
@@ -1925,7 +1948,7 @@ int _glfwPlatformCreateCursor(_GLFWcursor* cursor,
 
     native = [[NSImage alloc] initWithSize:NSMakeSize(image->width, image->height)];
     if (native == nil)
-        return GLFW_FALSE;
+        return false;
 
     for (int i = 0; i < count; i++) {
         const GLFWimage *src = image + i;
@@ -1942,7 +1965,7 @@ int _glfwPlatformCreateCursor(_GLFWcursor* cursor,
                         bytesPerRow:src->width * 4
                         bitsPerPixel:32];
         if (rep == nil)
-            return GLFW_FALSE;
+            return false;
 
         memcpy([rep bitmapData], src->pixels, src->width * src->height * 4);
         [native addRepresentation:rep];
@@ -1953,8 +1976,8 @@ int _glfwPlatformCreateCursor(_GLFWcursor* cursor,
                                                 hotSpot:NSMakePoint(xhot, yhot)];
     [native release];
     if (cursor->ns.object == nil)
-        return GLFW_FALSE;
-    return GLFW_TRUE;
+        return false;
+    return true;
 }
 
 int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, GLFWCursorShape shape)
@@ -1973,7 +1996,7 @@ int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, GLFWCursorShape shape
         U(GLFW_SW_RESIZE_CURSOR, _windowResizeNorthEastSouthWestCursor);
         U(GLFW_SE_RESIZE_CURSOR, _windowResizeNorthWestSouthEastCursor);
         case GLFW_INVALID_CURSOR:
-            return GLFW_FALSE;
+            return false;
     }
 #undef C
 #undef U
@@ -1982,11 +2005,11 @@ int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, GLFWCursorShape shape
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "Cocoa: Failed to retrieve standard cursor");
-        return GLFW_FALSE;
+        return false;
     }
 
     [cursor->ns.object retain];
-    return GLFW_TRUE;
+    return true;
 }
 
 void _glfwPlatformDestroyCursor(_GLFWcursor* cursor)
@@ -2070,7 +2093,7 @@ int _glfwPlatformGetPhysicalDevicePresentationSupport(VkInstance instance,
                                                       VkPhysicalDevice device,
                                                       uint32_t queuefamily)
 {
-    return GLFW_TRUE;
+    return true;
 }
 
 VkResult _glfwPlatformCreateWindowSurface(VkInstance instance,
@@ -2234,6 +2257,7 @@ GLFWAPI void glfwGetCocoaKeyEquivalent(int glfw_key, int glfw_mods, unsigned sho
         K('[', LEFT_BRACKET);
         K(']', RIGHT_BRACKET);
         K('+', PLUS);
+        K('_', UNDERSCORE);
         K('`', GRAVE_ACCENT);
         K('\\', BACKSLASH);
 

glfw/context.c

@@ -44,7 +44,7 @@
 // exists and whether all relevant options have supported and non-conflicting
 // values
 //
-GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
+bool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
 {
     if (ctxconfig->share)
     {
@@ -52,7 +52,7 @@ GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
             ctxconfig->share->context.client == GLFW_NO_API)
         {
             _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
-            return GLFW_FALSE;
+            return false;
         }
     }
 
@@ -63,7 +63,7 @@ GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
         _glfwInputError(GLFW_INVALID_ENUM,
                         "Invalid context creation API 0x%08X",
                         ctxconfig->source);
-        return GLFW_FALSE;
+        return false;
     }
 
     if (ctxconfig->client != GLFW_NO_API &&
@@ -73,7 +73,7 @@ GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
         _glfwInputError(GLFW_INVALID_ENUM,
                         "Invalid client API 0x%08X",
                         ctxconfig->client);
-        return GLFW_FALSE;
+        return false;
     }
 
     if (ctxconfig->client == GLFW_OPENGL_API)
@@ -92,7 +92,7 @@ GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
             _glfwInputError(GLFW_INVALID_VALUE,
                             "Invalid OpenGL version %i.%i",
                             ctxconfig->major, ctxconfig->minor);
-            return GLFW_FALSE;
+            return false;
         }
 
         if (ctxconfig->profile)
@@ -103,7 +103,7 @@ GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
                 _glfwInputError(GLFW_INVALID_ENUM,
                                 "Invalid OpenGL profile 0x%08X",
                                 ctxconfig->profile);
-                return GLFW_FALSE;
+                return false;
             }
 
             if (ctxconfig->major <= 2 ||
@@ -114,7 +114,7 @@ GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
 
                 _glfwInputError(GLFW_INVALID_VALUE,
                                 "Context profiles are only defined for OpenGL version 3.2 and above");
-                return GLFW_FALSE;
+                return false;
             }
         }
 
@@ -123,7 +123,7 @@ GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
             // Forward-compatible contexts are only defined for OpenGL version 3.0 and above
             _glfwInputError(GLFW_INVALID_VALUE,
                             "Forward-compatibility is only defined for OpenGL version 3.0 and above");
-            return GLFW_FALSE;
+            return false;
         }
     }
     else if (ctxconfig->client == GLFW_OPENGL_ES_API)
@@ -140,7 +140,7 @@ GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
             _glfwInputError(GLFW_INVALID_VALUE,
                             "Invalid OpenGL ES version %i.%i",
                             ctxconfig->major, ctxconfig->minor);
-            return GLFW_FALSE;
+            return false;
         }
     }
 
@@ -152,7 +152,7 @@ GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
             _glfwInputError(GLFW_INVALID_ENUM,
                             "Invalid context robustness mode 0x%08X",
                             ctxconfig->robustness);
-            return GLFW_FALSE;
+            return false;
         }
     }
 
@@ -164,11 +164,11 @@ GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
             _glfwInputError(GLFW_INVALID_ENUM,
                             "Invalid context release behavior 0x%08X",
                             ctxconfig->release);
-            return GLFW_FALSE;
+            return false;
         }
     }
 
-    return GLFW_TRUE;
+    return true;
 }
 
 // Chooses the framebuffer config that best matches the desired one
@@ -341,7 +341,7 @@ const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired,
 
 // Retrieves the attributes of the current context
 //
-GLFWbool _glfwRefreshContextAttribs(_GLFWwindow* window,
+bool _glfwRefreshContextAttribs(_GLFWwindow* window,
                                     const _GLFWctxconfig* ctxconfig)
 {
     int i;
@@ -369,7 +369,7 @@ GLFWbool _glfwRefreshContextAttribs(_GLFWwindow* window,
     {
         _glfwInputError(GLFW_PLATFORM_ERROR, "Entry point retrieval is broken");
         glfwMakeContextCurrent((GLFWwindow*) previous);
-        return GLFW_FALSE;
+        return false;
     }
 
     version = (const char*) window->context.GetString(GL_VERSION);
@@ -387,7 +387,7 @@ GLFWbool _glfwRefreshContextAttribs(_GLFWwindow* window,
         }
 
         glfwMakeContextCurrent((GLFWwindow*) previous);
-        return GLFW_FALSE;
+        return false;
     }
 
     for (i = 0;  prefixes[i];  i++)
@@ -419,7 +419,7 @@ GLFWbool _glfwRefreshContextAttribs(_GLFWwindow* window,
         }
 
         glfwMakeContextCurrent((GLFWwindow*) previous);
-        return GLFW_FALSE;
+        return false;
     }
 
     if (window->context.major < ctxconfig->major ||
@@ -449,7 +449,7 @@ GLFWbool _glfwRefreshContextAttribs(_GLFWwindow* window,
         }
 
         glfwMakeContextCurrent((GLFWwindow*) previous);
-        return GLFW_FALSE;
+        return false;
     }
 
     if (window->context.major >= 3)
@@ -465,7 +465,7 @@ GLFWbool _glfwRefreshContextAttribs(_GLFWwindow* window,
             _glfwInputError(GLFW_PLATFORM_ERROR,
                             "Entry point retrieval is broken");
             glfwMakeContextCurrent((GLFWwindow*) previous);
-            return GLFW_FALSE;
+            return false;
         }
     }
 
@@ -478,21 +478,21 @@ GLFWbool _glfwRefreshContextAttribs(_GLFWwindow* window,
             window->context.GetIntegerv(GL_CONTEXT_FLAGS, &flags);
 
             if (flags & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT)
-                window->context.forward = GLFW_TRUE;
+                window->context.forward = true;
 
             if (flags & GL_CONTEXT_FLAG_DEBUG_BIT)
-                window->context.debug = GLFW_TRUE;
+                window->context.debug = true;
             else if (glfwExtensionSupported("GL_ARB_debug_output") &&
                      ctxconfig->debug)
             {
                 // HACK: This is a workaround for older drivers (pre KHR_debug)
                 //       not setting the debug bit in the context flags for
                 //       debug contexts
-                window->context.debug = GLFW_TRUE;
+                window->context.debug = true;
             }
 
             if (flags & GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR)
-                window->context.noerror = GLFW_TRUE;
+                window->context.noerror = true;
         }
 
         // Read back OpenGL context profile (OpenGL 3.2 and above)
@@ -572,12 +572,12 @@ GLFWbool _glfwRefreshContextAttribs(_GLFWwindow* window,
     }
 
     glfwMakeContextCurrent((GLFWwindow*) previous);
-    return GLFW_TRUE;
+    return true;
 }
 
 // Searches an extension string for the specified extension
 //
-GLFWbool _glfwStringInExtensionString(const char* string, const char* extensions)
+bool _glfwStringInExtensionString(const char* string, const char* extensions)
 {
     const char* start = extensions;
 
@@ -588,7 +588,7 @@ GLFWbool _glfwStringInExtensionString(const char* string, const char* extensions
 
         where = strstr(start, string);
         if (!where)
-            return GLFW_FALSE;
+            return false;
 
         terminator = where + strlen(string);
         if (where == start || *(where - 1) == ' ')
@@ -600,7 +600,7 @@ GLFWbool _glfwStringInExtensionString(const char* string, const char* extensions
         start = terminator;
     }
 
-    return GLFW_TRUE;
+    return true;
 }
 
 
@@ -677,20 +677,20 @@ GLFWAPI int glfwExtensionSupported(const char* extension)
     _GLFWwindow* window;
     assert(extension != NULL);
 
-    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
+    _GLFW_REQUIRE_INIT_OR_RETURN(false);
 
     window = _glfwPlatformGetTls(&_glfw.contextSlot);
     if (!window)
     {
         _glfwInputError(GLFW_NO_CURRENT_CONTEXT,
                         "Cannot query extension without a current OpenGL or OpenGL ES context");
-        return GLFW_FALSE;
+        return false;
     }
 
     if (*extension == '\0')
     {
         _glfwInputError(GLFW_INVALID_VALUE, "Extension name cannot be an empty string");
-        return GLFW_FALSE;
+        return false;
     }
 
     if (window->context.major >= 3)
@@ -710,11 +710,11 @@ GLFWAPI int glfwExtensionSupported(const char* extension)
             {
                 _glfwInputError(GLFW_PLATFORM_ERROR,
                                 "Extension string retrieval is broken");
-                return GLFW_FALSE;
+                return false;
             }
 
             if (strcmp(en, extension) == 0)
-                return GLFW_TRUE;
+                return true;
         }
     }
     else
@@ -727,11 +727,11 @@ GLFWAPI int glfwExtensionSupported(const char* extension)
         {
             _glfwInputError(GLFW_PLATFORM_ERROR,
                             "Extension string retrieval is broken");
-            return GLFW_FALSE;
+            return false;
         }
 
         if (_glfwStringInExtensionString(extension, extensions))
-            return GLFW_TRUE;
+            return true;
     }
 
     // Check if extension is in the platform-specific string

glfw/dbus_glfw.c

@@ -45,11 +45,11 @@ report_error(DBusError *err, const char *fmt, ...) {
 static _GLFWDBUSData *dbus_data = NULL;
 static DBusConnection *session_bus = NULL;
 
-GLFWbool
+bool
 glfw_dbus_init(_GLFWDBUSData *dbus, EventLoopData *eld) {
     dbus->eld = eld;
     dbus_data = dbus;
-    return GLFW_TRUE;
+    return true;
 }
 
 static void
@@ -136,7 +136,7 @@ toggle_dbus_timeout(DBusTimeout *timeout, void *data) {
 
 
 DBusConnection*
-glfw_dbus_connect_to(const char *path, const char* err_msg, const char *name, GLFWbool register_on_bus) {
+glfw_dbus_connect_to(const char *path, const char* err_msg, const char *name, bool register_on_bus) {
     DBusError err;
     dbus_error_init(&err);
     DBusConnection *ans = dbus_connection_open_private(path, &err);
@@ -195,14 +195,14 @@ glfw_dbus_close_connection(DBusConnection *conn) {
     dbus_connection_unref(conn);
 }
 
-GLFWbool
+bool
 glfw_dbus_get_args(DBusMessage *msg, const char *failmsg, ...) {
     DBusError err;
     dbus_error_init(&err);
     va_list ap;
     va_start(ap, failmsg);
     int firstarg = va_arg(ap, int);
-    GLFWbool ret = dbus_message_get_args_valist(msg, &err, firstarg, ap) ? GLFW_TRUE : GLFW_FALSE;
+    bool ret = dbus_message_get_args_valist(msg, &err, firstarg, ap) ? true : false;
     va_end(ap);
     if (!ret) report_error(&err, failmsg);
     return ret;
@@ -233,25 +233,25 @@ method_reply_received(DBusPendingCall *pending, void *user_data) {
     }
 }
 
-GLFWbool
+bool
 call_method_with_msg(DBusConnection *conn, DBusMessage *msg, int timeout, dbus_pending_callback callback, void *user_data) {
-    GLFWbool retval = GLFW_FALSE;
+    bool retval = 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;
+            if (!res) return false;
             res->callback = callback;
             res->user_data = user_data;
             dbus_pending_call_set_notify(pending, method_reply_received, res, free);
-            retval = GLFW_TRUE;
+            retval = true;
         } else {
             REPORT("out of memory");
         }
     } else {
         if (dbus_connection_send(conn, msg, NULL)) {
-            retval = GLFW_TRUE;
+            retval = true;
         } else {
             REPORT("out of memory");
         }
@@ -260,12 +260,12 @@ call_method_with_msg(DBusConnection *conn, DBusMessage *msg, int timeout, dbus_p
 #undef REPORT
 }
 
-static GLFWbool
+static bool
 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;
+    if (!conn) return false;
     DBusMessage *msg = dbus_message_new_method_call(node, path, interface, method);
-    if (!msg) return GLFW_FALSE;
-    GLFWbool retval = GLFW_FALSE;
+    if (!msg) return false;
+    bool retval = false;
 
     int firstarg = va_arg(ap, int);
     if ((firstarg == DBUS_TYPE_INVALID) || dbus_message_append_args_valist(msg, firstarg, ap)) {
@@ -278,9 +278,9 @@ call_method(DBusConnection *conn, const char *node, const char *path, const char
     return retval;
 }
 
-GLFWbool
+bool
 glfw_dbus_call_method_with_reply(DBusConnection *conn, const char *node, const char *path, const char *interface, const char *method, int timeout, dbus_pending_callback callback, void* user_data, ...) {
-    GLFWbool retval;
+    bool retval;
     va_list ap;
     va_start(ap, user_data);
     retval = call_method(conn, node, path, interface, method, timeout, callback, user_data, ap);
@@ -288,9 +288,9 @@ glfw_dbus_call_method_with_reply(DBusConnection *conn, const char *node, const c
     return retval;
 }
 
-GLFWbool
+bool
 glfw_dbus_call_method_no_reply(DBusConnection *conn, const char *node, const char *path, const char *interface, const char *method, ...) {
-    GLFWbool retval;
+    bool retval;
     va_list ap;
     va_start(ap, method);
     retval = call_method(conn, node, path, interface, method, DBUS_TIMEOUT_USE_DEFAULT, NULL, NULL, ap);

glfw/dbus_glfw.h

@@ -37,18 +37,18 @@ typedef struct {
 } _GLFWDBUSData;
 
 
-GLFWbool glfw_dbus_init(_GLFWDBUSData *dbus, EventLoopData *eld);
+bool glfw_dbus_init(_GLFWDBUSData *dbus, EventLoopData *eld);
 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);
+DBusConnection* glfw_dbus_connect_to(const char *path, const char* err_msg, const char* name, bool register_on_bus);
 void glfw_dbus_close_connection(DBusConnection *conn);
-GLFWbool
+bool
 call_method_with_msg(DBusConnection *conn, DBusMessage *msg, int timeout, dbus_pending_callback callback, void *user_data);
-GLFWbool
+bool
 glfw_dbus_call_method_no_reply(DBusConnection *conn, const char *node, const char *path, const char *interface, const char *method, ...);
-GLFWbool
+bool
 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, ...);
+bool 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

@@ -85,7 +85,7 @@ static int getEGLConfigAttrib(EGLConfig config, int attrib)
 
 // Return the EGLConfig most closely matching the specified hints
 //
-static GLFWbool chooseEGLConfig(const _GLFWctxconfig* ctxconfig,
+static bool chooseEGLConfig(const _GLFWctxconfig* ctxconfig,
                                 const _GLFWfbconfig* desired,
                                 EGLConfig* result)
 {
@@ -98,7 +98,7 @@ static GLFWbool chooseEGLConfig(const _GLFWctxconfig* ctxconfig,
     if (!nativeCount)
     {
         _glfwInputError(GLFW_API_UNAVAILABLE, "EGL: No EGLConfigs returned");
-        return GLFW_FALSE;
+        return false;
     }
 
     nativeConfigs = calloc(nativeCount, sizeof(EGLConfig));
@@ -170,7 +170,7 @@ static GLFWbool chooseEGLConfig(const _GLFWctxconfig* ctxconfig,
         u->stencilBits = getEGLConfigAttrib(n, EGL_STENCIL_SIZE);
 
         u->samples = getEGLConfigAttrib(n, EGL_SAMPLES);
-        u->doublebuffer = GLFW_TRUE;
+        u->doublebuffer = true;
 
         u->handle = (uintptr_t) n;
         usableCount++;
@@ -241,10 +241,10 @@ static int extensionSupportedEGL(const char* extension)
     if (extensions)
     {
         if (_glfwStringInExtensionString(extension, extensions))
-            return GLFW_TRUE;
+            return true;
     }
 
-    return GLFW_FALSE;
+    return false;
 }
 
 static GLFWglproc getProcAddressEGL(const char* procname)
@@ -297,7 +297,7 @@ static void destroyContextEGL(_GLFWwindow* window)
 
 // Initialize EGL
 //
-GLFWbool _glfwInitEGL(void)
+bool _glfwInitEGL(void)
 {
     int i;
     const char* sonames[] =
@@ -318,7 +318,7 @@ GLFWbool _glfwInitEGL(void)
     };
 
     if (_glfw.egl.handle)
-        return GLFW_TRUE;
+        return true;
 
     for (i = 0;  sonames[i];  i++)
     {
@@ -330,7 +330,7 @@ GLFWbool _glfwInitEGL(void)
     if (!_glfw.egl.handle)
     {
         _glfwInputError(GLFW_API_UNAVAILABLE, "EGL: Library not found");
-        return GLFW_FALSE;
+        return false;
     }
 
     _glfw.egl.prefix = (strncmp(sonames[i], "lib", 3) == 0);
@@ -389,7 +389,7 @@ GLFWbool _glfwInitEGL(void)
                         "EGL: Failed to load required entry points");
 
         _glfwTerminateEGL();
-        return GLFW_FALSE;
+        return false;
     }
 
     _glfw.egl.display = eglGetDisplay(_GLFW_EGL_NATIVE_DISPLAY);
@@ -400,7 +400,7 @@ GLFWbool _glfwInitEGL(void)
                         getEGLErrorString(eglGetError()));
 
         _glfwTerminateEGL();
-        return GLFW_FALSE;
+        return false;
     }
 
     if (!eglInitialize(_glfw.egl.display, &_glfw.egl.major, &_glfw.egl.minor))
@@ -410,7 +410,7 @@ GLFWbool _glfwInitEGL(void)
                         getEGLErrorString(eglGetError()));
 
         _glfwTerminateEGL();
-        return GLFW_FALSE;
+        return false;
     }
 
     _glfw.egl.KHR_create_context =
@@ -424,7 +424,7 @@ GLFWbool _glfwInitEGL(void)
     _glfw.egl.KHR_context_flush_control =
         extensionSupportedEGL("EGL_KHR_context_flush_control");
 
-    return GLFW_TRUE;
+    return true;
 }
 
 // Terminate EGL
@@ -453,7 +453,7 @@ void _glfwTerminateEGL(void)
 
 // Create the OpenGL or OpenGL ES context
 //
-GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
+bool _glfwCreateContextEGL(_GLFWwindow* window,
                                const _GLFWctxconfig* ctxconfig,
                                const _GLFWfbconfig* fbconfig)
 {
@@ -465,7 +465,7 @@ GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
     if (!_glfw.egl.display)
     {
         _glfwInputError(GLFW_API_UNAVAILABLE, "EGL: API not available");
-        return GLFW_FALSE;
+        return false;
     }
 
     if (ctxconfig->share)
@@ -475,7 +475,7 @@ GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
     {
         _glfwInputError(GLFW_FORMAT_UNAVAILABLE,
                         "EGL: Failed to find a suitable EGLConfig");
-        return GLFW_FALSE;
+        return false;
     }
 
     if (ctxconfig->client == GLFW_OPENGL_ES_API)
@@ -485,7 +485,7 @@ GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
             _glfwInputError(GLFW_API_UNAVAILABLE,
                             "EGL: Failed to bind OpenGL ES: %s",
                             getEGLErrorString(eglGetError()));
-            return GLFW_FALSE;
+            return false;
         }
     }
     else
@@ -495,7 +495,7 @@ GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
             _glfwInputError(GLFW_API_UNAVAILABLE,
                             "EGL: Failed to bind OpenGL: %s",
                             getEGLErrorString(eglGetError()));
-            return GLFW_FALSE;
+            return false;
         }
     }
 
@@ -536,7 +536,7 @@ GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
         if (ctxconfig->noerror)
         {
             if (_glfw.egl.KHR_create_context_no_error)
-                setAttrib(EGL_CONTEXT_OPENGL_NO_ERROR_KHR, GLFW_TRUE);
+                setAttrib(EGL_CONTEXT_OPENGL_NO_ERROR_KHR, true);
         }
 
         if (ctxconfig->major != 1 || ctxconfig->minor != 0)
@@ -581,7 +581,7 @@ GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
         _glfwInputError(GLFW_VERSION_UNAVAILABLE,
                         "EGL: Failed to create context: %s",
                         getEGLErrorString(eglGetError()));
-        return GLFW_FALSE;
+        return false;
     }
 
     // Set up attributes for surface creation
@@ -607,7 +607,7 @@ GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "EGL: Failed to create window surface: %s",
                         getEGLErrorString(eglGetError()));
-        return GLFW_FALSE;
+        return false;
     }
 
     window->context.egl.config = config;
@@ -695,7 +695,7 @@ GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
         {
             _glfwInputError(GLFW_API_UNAVAILABLE,
                             "EGL: Failed to load client library");
-            return GLFW_FALSE;
+            return false;
         }
     }
 
@@ -706,7 +706,7 @@ GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
     window->context.getProcAddress = getProcAddressEGL;
     window->context.destroy = destroyContextEGL;
 
-    return GLFW_TRUE;
+    return true;
 }
 
 #undef setAttrib
@@ -714,7 +714,7 @@ GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
 // Returns the Visual and depth of the chosen EGLConfig
 //
 #if defined(_GLFW_X11)
-GLFWbool _glfwChooseVisualEGL(const _GLFWwndconfig* wndconfig,
+bool _glfwChooseVisualEGL(const _GLFWwndconfig* wndconfig,
                               const _GLFWctxconfig* ctxconfig,
                               const _GLFWfbconfig* fbconfig,
                               Visual** visual, int* depth)
@@ -729,7 +729,7 @@ GLFWbool _glfwChooseVisualEGL(const _GLFWwndconfig* wndconfig,
     {
         _glfwInputError(GLFW_FORMAT_UNAVAILABLE,
                         "EGL: Failed to find a suitable EGLConfig");
-        return GLFW_FALSE;
+        return false;
     }
 
     eglGetConfigAttrib(_glfw.egl.display, native,
@@ -743,14 +743,14 @@ GLFWbool _glfwChooseVisualEGL(const _GLFWwndconfig* wndconfig,
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "EGL: Failed to retrieve Visual for EGLConfig");
-        return GLFW_FALSE;
+        return false;
     }
 
     *visual = result->visual;
     *depth = result->depth;
 
     XFree(result);
-    return GLFW_TRUE;
+    return true;
 }
 #endif // _GLFW_X11
 

glfw/egl_context.h

@@ -173,13 +173,13 @@ typedef struct _GLFWlibraryEGL
 {
     EGLDisplay      display;
     EGLint          major, minor;
-    GLFWbool        prefix;
+    bool        prefix;
 
-    GLFWbool        KHR_create_context;
-    GLFWbool        KHR_create_context_no_error;
-    GLFWbool        KHR_gl_colorspace;
-    GLFWbool        KHR_get_all_proc_addresses;
-    GLFWbool        KHR_context_flush_control;
+    bool        KHR_create_context;
+    bool        KHR_create_context_no_error;
+    bool        KHR_gl_colorspace;
+    bool        KHR_get_all_proc_addresses;
+    bool        KHR_context_flush_control;
 
     void*           handle;
 
@@ -203,13 +203,13 @@ typedef struct _GLFWlibraryEGL
 } _GLFWlibraryEGL;
 
 
-GLFWbool _glfwInitEGL(void);
+bool _glfwInitEGL(void);
 void _glfwTerminateEGL(void);
-GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
+bool _glfwCreateContextEGL(_GLFWwindow* window,
                                const _GLFWctxconfig* ctxconfig,
                                const _GLFWfbconfig* fbconfig);
 #if defined(_GLFW_X11)
-GLFWbool _glfwChooseVisualEGL(const _GLFWwndconfig* wndconfig,
+bool _glfwChooseVisualEGL(const _GLFWwndconfig* wndconfig,
                               const _GLFWctxconfig* ctxconfig,
                               const _GLFWfbconfig* fbconfig,
                               Visual** visual, int* depth);

glfw/glfw3.h

@@ -271,24 +271,6 @@ extern "C" {
 #define GLFW_VERSION_REVISION       0
 /*! @} */
 
-/*! @name Boolean values
- *  @{ */
-/*! @brief One.
- *
- *  One.  Seriously.  You don't _need_ to use this symbol in your code.  It's
- *  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                   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                  false
-/*! @} */
-
 /*! @name Key and button actions
  *  @{ */
 /*! @brief The key or mouse button was released.
@@ -410,6 +392,7 @@ extern "C" {
 #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
@@ -1221,8 +1204,8 @@ typedef void (* GLFWwindowrefreshfun)(GLFWwindow*);
  *  This is the function signature for window focus callback functions.
  *
  *  @param[in] window The window that gained or lost input focus.
- *  @param[in] focused `GLFW_TRUE` if the window was given input focus, or
- *  `GLFW_FALSE` if it lost it.
+ *  @param[in] focused `true` if the window was given input focus, or
+ *  `false` if it lost it.
  *
  *  @sa @ref window_focus
  *  @sa @ref glfwSetWindowFocusCallback
@@ -1238,7 +1221,7 @@ typedef void (* GLFWwindowfocusfun)(GLFWwindow*,int);
  *  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`
+ *  @param[in] occluded `true` if the window was occluded, or `false`
  *  if the window is no longer occluded.
  *
  *  @sa @ref window_occlusion
@@ -1257,8 +1240,8 @@ typedef void (* GLFWwindowocclusionfun)(GLFWwindow*, bool);
  *  functions.
  *
  *  @param[in] window The window that was iconified or restored.
- *  @param[in] iconified `GLFW_TRUE` if the window was iconified, or
- *  `GLFW_FALSE` if it was restored.
+ *  @param[in] iconified `true` if the window was iconified, or
+ *  `false` if it was restored.
  *
  *  @sa @ref window_iconify
  *  @sa @ref glfwSetWindowIconifyCallback
@@ -1275,8 +1258,8 @@ typedef void (* GLFWwindowiconifyfun)(GLFWwindow*,int);
  *  functions.
  *
  *  @param[in] window The window that was maximized or restored.
- *  @param[in] iconified `GLFW_TRUE` if the window was maximized, or
- *  `GLFW_FALSE` if it was restored.
+ *  @param[in] iconified `true` if the window was maximized, or
+ *  `false` if it was restored.
  *
  *  @sa @ref window_maximize
  *  @sa glfwSetWindowMaximizeCallback
@@ -1368,8 +1351,8 @@ typedef void (* GLFWcursorposfun)(GLFWwindow*,double,double);
  *  This is the function signature for cursor enter/leave callback functions.
  *
  *  @param[in] window The window that received the event.
- *  @param[in] entered `GLFW_TRUE` if the cursor entered the window's client
- *  area, or `GLFW_FALSE` if it left it.
+ *  @param[in] entered `true` if the cursor entered the window's client
+ *  area, or `false` if it left it.
  *
  *  @sa @ref cursor_enter
  *  @sa @ref glfwSetCursorEnterCallback
@@ -1621,9 +1604,9 @@ typedef struct GLFWgamepadstate
  *  succeeds, you should call @ref glfwTerminate before the application exits.
  *
  *  Additional calls to this function after successful initialization but before
- *  termination will return `GLFW_TRUE` immediately.
+ *  termination will return `true` immediately.
  *
- *  @return `GLFW_TRUE` if successful, or `GLFW_FALSE` if an
+ *  @return `true` if successful, or `false` if an
  *  [error](@ref error_handling) occurred.
  *
  *  @errors Possible errors include @ref GLFW_PLATFORM_ERROR.
@@ -2471,7 +2454,7 @@ GLFWAPI void glfwWindowHintString(int hint, const char* value);
  *  @remark @macos On OS X 10.10 and later the window frame will not be rendered
  *  at full resolution on Retina displays unless the
  *  [GLFW_COCOA_RETINA_FRAMEBUFFER](@ref GLFW_COCOA_RETINA_FRAMEBUFFER_hint)
- *  hint is `GLFW_TRUE` and the `NSHighResolutionCapable` key is enabled in the
+ *  hint is `true` and the `NSHighResolutionCapable` key is enabled in the
  *  application bundle's `Info.plist`.  For more information, see
  *  [High Resolution Guidelines for OS X](https://developer.apple.com/library/mac/documentation/GraphicsAnimation/Conceptual/HighResolutionOSX/Explained/Explained.html)
  *  in the Mac Developer Library.  The GLFW test and example programs use
@@ -3272,7 +3255,7 @@ GLFWAPI void glfwRequestWindowAttention(GLFWwindow* window);
  *  supported. Currently (macOS, Windows, X11 and Wayland).
  *
  *  @param[in] window The window with which the bell is associated.
- *  @return GLFW_TRUE if the bell succeeded otherwise GLFW_FALSE
+ *  @return true if the bell succeeded otherwise false
  *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
  *  GLFW_PLATFORM_ERROR.
@@ -3422,7 +3405,7 @@ GLFWAPI int glfwGetWindowAttrib(GLFWwindow* window, int attrib);
  *
  *  @param[in] window The window to set the attribute for.
  *  @param[in] attrib A supported window attribute.
- *  @param[in] value `GLFW_TRUE` or `GLFW_FALSE`.
+ *  @param[in] value `true` or `false`.
  *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
  *  GLFW_INVALID_ENUM, @ref GLFW_INVALID_VALUE and @ref GLFW_PLATFORM_ERROR.
@@ -3804,23 +3787,23 @@ GLFWAPI int glfwGetInputMode(GLFWwindow* window, int mode);
  *    and unlimited cursor movement.  This is useful for implementing for
  *    example 3D camera controls.
  *
- *  If the mode is `GLFW_STICKY_KEYS`, the value must be either `GLFW_TRUE` to
- *  enable sticky keys, or `GLFW_FALSE` to disable it.  If sticky keys are
+ *  If the mode is `GLFW_STICKY_KEYS`, the value must be either `true` to
+ *  enable sticky keys, or `false` to disable it.  If sticky keys are
  *  enabled, a key press will ensure that @ref glfwGetKey returns `GLFW_PRESS`
  *  the next time it is called even if the key had been released before the
  *  call.  This is useful when you are only interested in whether keys have been
  *  pressed but not when or in which order.
  *
  *  If the mode is `GLFW_STICKY_MOUSE_BUTTONS`, the value must be either
- *  `GLFW_TRUE` to enable sticky mouse buttons, or `GLFW_FALSE` to disable it.
+ *  `true` to enable sticky mouse buttons, or `false` to disable it.
  *  If sticky mouse buttons are enabled, a mouse button press will ensure that
  *  @ref glfwGetMouseButton returns `GLFW_PRESS` the next time it is called even
  *  if the mouse button had been released before the call.  This is useful when
  *  you are only interested in whether mouse buttons have been pressed but not
  *  when or in which order.
  *
- *  If the mode is `GLFW_LOCK_KEY_MODS`, the value must be either `GLFW_TRUE` to
- *  enable lock key modifier bits, or `GLFW_FALSE` to disable them.  If enabled,
+ *  If the mode is `GLFW_LOCK_KEY_MODS`, the value must be either `true` to
+ *  enable lock key modifier bits, or `false` to disable them.  If enabled,
  *  callbacks that receive modifier bits will also have the @ref
  *  GLFW_MOD_CAPS_LOCK bit set when the event was generated with Caps Lock on,
  *  and the @ref GLFW_MOD_NUM_LOCK bit when Num Lock was on.
@@ -4365,7 +4348,7 @@ GLFWAPI GLFWliveresizefun glfwSetLiveResizeCallback(GLFWwindow* window, GLFWlive
  *  work.
  *
  *  @param[in] jid The [joystick](@ref joysticks) to query.
- *  @return `GLFW_TRUE` if the joystick is present, or `GLFW_FALSE` otherwise.
+ *  @return `true` if the joystick is present, or `false` otherwise.
  *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
  *  GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR.
@@ -4639,13 +4622,13 @@ GLFWAPI void* glfwGetJoystickUserPointer(int jid);
  *  a gamepad mapping.
  *
  *  If the specified joystick is present but does not have a gamepad mapping
- *  this function will return `GLFW_FALSE` but will not generate an error.  Call
+ *  this function will return `false` but will not generate an error.  Call
  *  @ref glfwJoystickPresent to check if a joystick is present regardless of
  *  whether it has a mapping.
  *
  *  @param[in] jid The [joystick](@ref joysticks) to query.
- *  @return `GLFW_TRUE` if a joystick is both present and has a gamepad mapping,
- *  or `GLFW_FALSE` otherwise.
+ *  @return `true` if a joystick is both present and has a gamepad mapping,
+ *  or `false` otherwise.
  *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
  *  GLFW_INVALID_ENUM.
@@ -4706,7 +4689,7 @@ GLFWAPI GLFWjoystickfun glfwSetJoystickCallback(GLFWjoystickfun cbfun);
  *  default.
  *
  *  @param[in] string The string containing the gamepad mappings.
- *  @return `GLFW_TRUE` if successful, or `GLFW_FALSE` if an
+ *  @return `true` if successful, or `false` if an
  *  [error](@ref error_handling) occurred.
  *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
@@ -4760,7 +4743,7 @@ GLFWAPI const char* glfwGetGamepadName(int jid);
  *  an Xbox-like gamepad.
  *
  *  If the specified joystick is not present or does not have a gamepad mapping
- *  this function will return `GLFW_FALSE` but will not generate an error.  Call
+ *  this function will return `false` but will not generate an error.  Call
  *  @ref glfwJoystickPresent to check whether it is present regardless of
  *  whether it has a mapping.
  *
@@ -4773,7 +4756,7 @@ GLFWAPI const char* glfwGetGamepadName(int jid);
  *
  *  @param[in] jid The [joystick](@ref joysticks) to query.
  *  @param[out] state The gamepad input state of the joystick.
- *  @return `GLFW_TRUE` if successful, or `GLFW_FALSE` if no joystick is
+ *  @return `true` if successful, or `false` if no joystick is
  *  connected, it has no gamepad mapping or an [error](@ref error_handling)
  *  occurred.
  *
@@ -5106,7 +5089,7 @@ GLFWAPI void glfwSwapInterval(int interval);
  *  and `vkEnumerateDeviceExtensionProperties` instead.
  *
  *  @param[in] extension The ASCII encoded name of the extension.
- *  @return `GLFW_TRUE` if the extension is available, or `GLFW_FALSE`
+ *  @return `true` if the extension is available, or `false`
  *  otherwise.
  *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
@@ -5179,7 +5162,7 @@ GLFWAPI GLFWglproc glfwGetProcAddress(const char* procname);
  *  and @ref glfwGetPhysicalDevicePresentationSupport to check whether a queue
  *  family of a physical device supports image presentation.
  *
- *  @return `GLFW_TRUE` if Vulkan is minimally available, or `GLFW_FALSE`
+ *  @return `true` if Vulkan is minimally available, or `false`
  *  otherwise.
  *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
@@ -5291,7 +5274,7 @@ GLFWAPI GLFWvkproc glfwGetInstanceProcAddress(VkInstance instance, const char* p
  *
  *  If Vulkan or the required window surface creation instance extensions are
  *  not available on the machine, or if the specified instance was not created
- *  with the required extensions, this function returns `GLFW_FALSE` and
+ *  with the required extensions, this function returns `false` and
  *  generates a @ref GLFW_API_UNAVAILABLE error.  Call @ref glfwVulkanSupported
  *  to check whether Vulkan is at least minimally available and @ref
  *  glfwGetRequiredInstanceExtensions to check what instance extensions are
@@ -5300,13 +5283,13 @@ GLFWAPI GLFWvkproc glfwGetInstanceProcAddress(VkInstance instance, const char* p
  *  @param[in] instance The instance that the physical device belongs to.
  *  @param[in] device The physical device that the queue family belongs to.
  *  @param[in] queuefamily The index of the queue family to query.
- *  @return `GLFW_TRUE` if the queue family supports presentation, or
- *  `GLFW_FALSE` otherwise.
+ *  @return `true` if the queue family supports presentation, or
+ *  `false` otherwise.
  *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
  *  GLFW_API_UNAVAILABLE and @ref GLFW_PLATFORM_ERROR.
  *
- *  @remark @macos This function currently always returns `GLFW_TRUE`, as the
+ *  @remark @macos This function currently always returns `true`, as the
  *  `VK_MVK_macos_surface` extension does not provide
  *  a `vkGetPhysicalDevice*PresentationSupport` type function.
  *

glfw/glx_context.c

@@ -47,7 +47,7 @@ static int getGLXFBConfigAttrib(GLXFBConfig fbconfig, int attrib)
 
 // Return the GLXFBConfig most closely matching the specified hints
 //
-static GLFWbool chooseGLXFBConfig(const _GLFWfbconfig* desired,
+static bool chooseGLXFBConfig(const _GLFWfbconfig* desired,
                                   GLXFBConfig* result)
 {
     GLXFBConfig* nativeConfigs;
@@ -55,20 +55,20 @@ static GLFWbool chooseGLXFBConfig(const _GLFWfbconfig* desired,
     const _GLFWfbconfig* closest;
     int i, nativeCount, usableCount;
     const char* vendor;
-    GLFWbool trustWindowBit = GLFW_TRUE;
+    bool trustWindowBit = true;
 
     // HACK: This is a (hopefully temporary) workaround for Chromium
     //       (VirtualBox GL) not setting the window bit on any GLXFBConfigs
     vendor = glXGetClientString(_glfw.x11.display, GLX_VENDOR);
     if (vendor && strcmp(vendor, "Chromium") == 0)
-        trustWindowBit = GLFW_FALSE;
+        trustWindowBit = false;
 
     nativeConfigs =
         glXGetFBConfigs(_glfw.x11.display, _glfw.x11.screen, &nativeCount);
     if (!nativeConfigs || !nativeCount)
     {
         _glfwInputError(GLFW_API_UNAVAILABLE, "GLX: No GLXFBConfigs returned");
-        return GLFW_FALSE;
+        return false;
     }
 
     usableConfigs = calloc(nativeCount, sizeof(_GLFWfbconfig));
@@ -116,9 +116,9 @@ static GLFWbool chooseGLXFBConfig(const _GLFWfbconfig* desired,
         u->auxBuffers = getGLXFBConfigAttrib(n, GLX_AUX_BUFFERS);
 
         if (getGLXFBConfigAttrib(n, GLX_STEREO))
-            u->stereo = GLFW_TRUE;
+            u->stereo = true;
         if (getGLXFBConfigAttrib(n, GLX_DOUBLEBUFFER))
-            u->doublebuffer = GLFW_TRUE;
+            u->doublebuffer = true;
 
         if (_glfw.glx.ARB_multisample)
             u->samples = getGLXFBConfigAttrib(n, GLX_SAMPLES);
@@ -210,10 +210,10 @@ static int extensionSupportedGLX(const char* extension)
     if (extensions)
     {
         if (_glfwStringInExtensionString(extension, extensions))
-            return GLFW_TRUE;
+            return true;
     }
 
-    return GLFW_FALSE;
+    return false;
 }
 
 static GLFWglproc getProcAddressGLX(const char* procname)
@@ -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)
@@ -250,7 +248,7 @@ static void destroyContextGLX(_GLFWwindow* window)
 
 // Initialize GLX
 //
-GLFWbool _glfwInitGLX(void)
+bool _glfwInitGLX(void)
 {
     int i;
     const char* sonames[] =
@@ -267,7 +265,7 @@ GLFWbool _glfwInitGLX(void)
     };
 
     if (_glfw.glx.handle)
-        return GLFW_TRUE;
+        return true;
 
     for (i = 0;  sonames[i];  i++)
     {
@@ -279,7 +277,7 @@ GLFWbool _glfwInitGLX(void)
     if (!_glfw.glx.handle)
     {
         _glfwInputError(GLFW_API_UNAVAILABLE, "GLX: Failed to load GLX");
-        return GLFW_FALSE;
+        return false;
     }
 
     _glfw.glx.GetFBConfigs =
@@ -331,7 +329,7 @@ GLFWbool _glfwInitGLX(void)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "GLX: Failed to load required entry points");
-        return GLFW_FALSE;
+        return false;
     }
 
     if (!glXQueryExtension(_glfw.x11.display,
@@ -339,21 +337,21 @@ GLFWbool _glfwInitGLX(void)
                            &_glfw.glx.eventBase))
     {
         _glfwInputError(GLFW_API_UNAVAILABLE, "GLX: GLX extension not found");
-        return GLFW_FALSE;
+        return false;
     }
 
     if (!glXQueryVersion(_glfw.x11.display, &_glfw.glx.major, &_glfw.glx.minor))
     {
         _glfwInputError(GLFW_API_UNAVAILABLE,
                         "GLX: Failed to query GLX version");
-        return GLFW_FALSE;
+        return false;
     }
 
     if (_glfw.glx.major == 1 && _glfw.glx.minor < 3)
     {
         _glfwInputError(GLFW_API_UNAVAILABLE,
                         "GLX: GLX version 1.3 is required");
-        return GLFW_FALSE;
+        return false;
     }
 
     if (extensionSupportedGLX("GLX_EXT_swap_control"))
@@ -362,7 +360,7 @@ GLFWbool _glfwInitGLX(void)
             getProcAddressGLX("glXSwapIntervalEXT");
 
         if (_glfw.glx.SwapIntervalEXT)
-            _glfw.glx.EXT_swap_control = GLFW_TRUE;
+            _glfw.glx.EXT_swap_control = true;
     }
 
     if (extensionSupportedGLX("GLX_SGI_swap_control"))
@@ -371,7 +369,7 @@ GLFWbool _glfwInitGLX(void)
             getProcAddressGLX("glXSwapIntervalSGI");
 
         if (_glfw.glx.SwapIntervalSGI)
-            _glfw.glx.SGI_swap_control = GLFW_TRUE;
+            _glfw.glx.SGI_swap_control = true;
     }
 
     if (extensionSupportedGLX("GLX_MESA_swap_control"))
@@ -380,17 +378,17 @@ GLFWbool _glfwInitGLX(void)
             getProcAddressGLX("glXSwapIntervalMESA");
 
         if (_glfw.glx.SwapIntervalMESA)
-            _glfw.glx.MESA_swap_control = GLFW_TRUE;
+            _glfw.glx.MESA_swap_control = true;
     }
 
     if (extensionSupportedGLX("GLX_ARB_multisample"))
-        _glfw.glx.ARB_multisample = GLFW_TRUE;
+        _glfw.glx.ARB_multisample = true;
 
     if (extensionSupportedGLX("GLX_ARB_framebuffer_sRGB"))
-        _glfw.glx.ARB_framebuffer_sRGB = GLFW_TRUE;
+        _glfw.glx.ARB_framebuffer_sRGB = true;
 
     if (extensionSupportedGLX("GLX_EXT_framebuffer_sRGB"))
-        _glfw.glx.EXT_framebuffer_sRGB = GLFW_TRUE;
+        _glfw.glx.EXT_framebuffer_sRGB = true;
 
     if (extensionSupportedGLX("GLX_ARB_create_context"))
     {
@@ -398,25 +396,25 @@ GLFWbool _glfwInitGLX(void)
             getProcAddressGLX("glXCreateContextAttribsARB");
 
         if (_glfw.glx.CreateContextAttribsARB)
-            _glfw.glx.ARB_create_context = GLFW_TRUE;
+            _glfw.glx.ARB_create_context = true;
     }
 
     if (extensionSupportedGLX("GLX_ARB_create_context_robustness"))
-        _glfw.glx.ARB_create_context_robustness = GLFW_TRUE;
+        _glfw.glx.ARB_create_context_robustness = true;
 
     if (extensionSupportedGLX("GLX_ARB_create_context_profile"))
-        _glfw.glx.ARB_create_context_profile = GLFW_TRUE;
+        _glfw.glx.ARB_create_context_profile = true;
 
     if (extensionSupportedGLX("GLX_EXT_create_context_es2_profile"))
-        _glfw.glx.EXT_create_context_es2_profile = GLFW_TRUE;
+        _glfw.glx.EXT_create_context_es2_profile = true;
 
     if (extensionSupportedGLX("GLX_ARB_create_context_no_error"))
-        _glfw.glx.ARB_create_context_no_error = GLFW_TRUE;
+        _glfw.glx.ARB_create_context_no_error = true;
 
     if (extensionSupportedGLX("GLX_ARB_context_flush_control"))
-        _glfw.glx.ARB_context_flush_control = GLFW_TRUE;
+        _glfw.glx.ARB_context_flush_control = true;
 
-    return GLFW_TRUE;
+    return true;
 }
 
 // Terminate GLX
@@ -442,7 +440,7 @@ void _glfwTerminateGLX(void)
 
 // Create the OpenGL or OpenGL ES context
 //
-GLFWbool _glfwCreateContextGLX(_GLFWwindow* window,
+bool _glfwCreateContextGLX(_GLFWwindow* window,
                                const _GLFWctxconfig* ctxconfig,
                                const _GLFWfbconfig* fbconfig)
 {
@@ -457,7 +455,7 @@ GLFWbool _glfwCreateContextGLX(_GLFWwindow* window,
     {
         _glfwInputError(GLFW_FORMAT_UNAVAILABLE,
                         "GLX: Failed to find a suitable GLXFBConfig");
-        return GLFW_FALSE;
+        return false;
     }
 
     if (ctxconfig->client == GLFW_OPENGL_ES_API)
@@ -468,7 +466,7 @@ GLFWbool _glfwCreateContextGLX(_GLFWwindow* window,
         {
             _glfwInputError(GLFW_API_UNAVAILABLE,
                             "GLX: OpenGL ES requested but GLX_EXT_create_context_es2_profile is unavailable");
-            return GLFW_FALSE;
+            return false;
         }
     }
 
@@ -478,7 +476,7 @@ GLFWbool _glfwCreateContextGLX(_GLFWwindow* window,
         {
             _glfwInputError(GLFW_VERSION_UNAVAILABLE,
                             "GLX: Forward compatibility requested but GLX_ARB_create_context_profile is unavailable");
-            return GLFW_FALSE;
+            return false;
         }
     }
 
@@ -489,7 +487,7 @@ GLFWbool _glfwCreateContextGLX(_GLFWwindow* window,
         {
             _glfwInputError(GLFW_VERSION_UNAVAILABLE,
                             "GLX: An OpenGL profile requested but GLX_ARB_create_context_profile is unavailable");
-            return GLFW_FALSE;
+            return false;
         }
     }
 
@@ -554,7 +552,7 @@ GLFWbool _glfwCreateContextGLX(_GLFWwindow* window,
         if (ctxconfig->noerror)
         {
             if (_glfw.glx.ARB_create_context_no_error)
-                setAttrib(GLX_CONTEXT_OPENGL_NO_ERROR_ARB, GLFW_TRUE);
+                setAttrib(GLX_CONTEXT_OPENGL_NO_ERROR_ARB, true);
         }
 
         // NOTE: Only request an explicitly versioned context when necessary, as
@@ -590,7 +588,7 @@ GLFWbool _glfwCreateContextGLX(_GLFWwindow* window,
             if (_glfw.x11.errorCode == _glfw.glx.errorBase + GLXBadProfileARB &&
                 ctxconfig->client == GLFW_OPENGL_API &&
                 ctxconfig->profile == GLFW_OPENGL_ANY_PROFILE &&
-                ctxconfig->forward == GLFW_FALSE)
+                ctxconfig->forward == false)
             {
                 window->context.glx.handle =
                     createLegacyContextGLX(window, native, share);
@@ -608,7 +606,7 @@ GLFWbool _glfwCreateContextGLX(_GLFWwindow* window,
     if (!window->context.glx.handle)
     {
         _glfwInputErrorX11(GLFW_VERSION_UNAVAILABLE, "GLX: Failed to create context");
-        return GLFW_FALSE;
+        return false;
     }
 
     window->context.glx.window =
@@ -616,7 +614,7 @@ GLFWbool _glfwCreateContextGLX(_GLFWwindow* window,
     if (!window->context.glx.window)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR, "GLX: Failed to create window");
-        return GLFW_FALSE;
+        return false;
     }
 
     window->context.makeCurrent = makeContextCurrentGLX;
@@ -626,14 +624,14 @@ GLFWbool _glfwCreateContextGLX(_GLFWwindow* window,
     window->context.getProcAddress = getProcAddressGLX;
     window->context.destroy = destroyContextGLX;
 
-    return GLFW_TRUE;
+    return true;
 }
 
 #undef setAttrib
 
 // Returns the Visual and depth of the chosen GLXFBConfig
 //
-GLFWbool _glfwChooseVisualGLX(const _GLFWwndconfig* wndconfig,
+bool _glfwChooseVisualGLX(const _GLFWwndconfig* wndconfig,
                               const _GLFWctxconfig* ctxconfig,
                               const _GLFWfbconfig* fbconfig,
                               Visual** visual, int* depth)
@@ -645,7 +643,7 @@ GLFWbool _glfwChooseVisualGLX(const _GLFWwndconfig* wndconfig,
     {
         _glfwInputError(GLFW_FORMAT_UNAVAILABLE,
                         "GLX: Failed to find a suitable GLXFBConfig");
-        return GLFW_FALSE;
+        return false;
     }
 
     result = glXGetVisualFromFBConfig(_glfw.x11.display, native);
@@ -653,14 +651,14 @@ GLFWbool _glfwChooseVisualGLX(const _GLFWwndconfig* wndconfig,
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "GLX: Failed to retrieve Visual for GLXFBConfig");
-        return GLFW_FALSE;
+        return false;
     }
 
     *visual = result->visual;
     *depth  = result->depth;
 
     XFree(result);
-    return GLFW_TRUE;
+    return true;
 }
 
 
@@ -695,4 +693,3 @@ GLFWAPI GLXWindow glfwGetGLXWindow(GLFWwindow* handle)
 
     return window->context.glx.window;
 }
-

glfw/glx_context.h

@@ -153,28 +153,28 @@ typedef struct _GLFWlibraryGLX
     PFNGLXSWAPINTERVALEXTPROC           SwapIntervalEXT;
     PFNGLXSWAPINTERVALMESAPROC          SwapIntervalMESA;
     PFNGLXCREATECONTEXTATTRIBSARBPROC   CreateContextAttribsARB;
-    GLFWbool        SGI_swap_control;
-    GLFWbool        EXT_swap_control;
-    GLFWbool        MESA_swap_control;
-    GLFWbool        ARB_multisample;
-    GLFWbool        ARB_framebuffer_sRGB;
-    GLFWbool        EXT_framebuffer_sRGB;
-    GLFWbool        ARB_create_context;
-    GLFWbool        ARB_create_context_profile;
-    GLFWbool        ARB_create_context_robustness;
-    GLFWbool        EXT_create_context_es2_profile;
-    GLFWbool        ARB_create_context_no_error;
-    GLFWbool        ARB_context_flush_control;
+    bool        SGI_swap_control;
+    bool        EXT_swap_control;
+    bool        MESA_swap_control;
+    bool        ARB_multisample;
+    bool        ARB_framebuffer_sRGB;
+    bool        EXT_framebuffer_sRGB;
+    bool        ARB_create_context;
+    bool        ARB_create_context_profile;
+    bool        ARB_create_context_robustness;
+    bool        EXT_create_context_es2_profile;
+    bool        ARB_create_context_no_error;
+    bool        ARB_context_flush_control;
 
 } _GLFWlibraryGLX;
 
-GLFWbool _glfwInitGLX(void);
+bool _glfwInitGLX(void);
 void _glfwTerminateGLX(void);
-GLFWbool _glfwCreateContextGLX(_GLFWwindow* window,
+bool _glfwCreateContextGLX(_GLFWwindow* window,
                                const _GLFWctxconfig* ctxconfig,
                                const _GLFWfbconfig* fbconfig);
 void _glfwDestroyContextGLX(_GLFWwindow* window);
-GLFWbool _glfwChooseVisualGLX(const _GLFWwndconfig* wndconfig,
+bool _glfwChooseVisualGLX(const _GLFWwndconfig* wndconfig,
                               const _GLFWctxconfig* ctxconfig,
                               const _GLFWfbconfig* fbconfig,
                               Visual** visual, int* depth);

glfw/ibus_glfw.c

@@ -50,10 +50,10 @@ enum Capabilities {
 };
 
 
-static inline GLFWbool
+static inline bool
 test_env_var(const char *name, const char *val) {
     const char *q = getenv(name);
-    return (q && strcmp(q, val) == 0) ? GLFW_TRUE : GLFW_FALSE;
+    return (q && strcmp(q, val) == 0) ? true : false;
 }
 
 static inline size_t
@@ -193,39 +193,39 @@ get_ibus_address_file_name(void) {
 }
 
 
-static inline GLFWbool
+static inline bool
 read_ibus_address(_GLFWIBUSData *ibus) {
     static char buf[1024];
     struct stat s;
     FILE *addr_file = fopen(ibus->address_file_name, "r");
     if (!addr_file) {
         _glfwInputError(GLFW_PLATFORM_ERROR, "Failed to open IBUS address file: %s with error: %s", ibus->address_file_name, strerror(errno));
-        return GLFW_FALSE;
+        return false;
     }
     int stat_result = fstat(fileno(addr_file), &s);
-    GLFWbool found = GLFW_FALSE;
+    bool found = false;
     while (fgets(buf, sizeof(buf), addr_file)) {
         if (strncmp(buf, "IBUS_ADDRESS=", sizeof("IBUS_ADDRESS=")-1) == 0) {
             size_t sz = strlen(buf);
             if (buf[sz-1] == '\n') buf[sz-1] = 0;
             if (buf[sz-2] == '\r') buf[sz-2] = 0;
-            found = GLFW_TRUE;
+            found = true;
             break;
         }
     }
     fclose(addr_file); addr_file = NULL;
     if (stat_result != 0) {
         _glfwInputError(GLFW_PLATFORM_ERROR, "Failed to stat IBUS address file: %s with error: %s", ibus->address_file_name, strerror(errno));
-        return GLFW_FALSE;
+        return false;
     }
     ibus->address_file_mtime = s.st_mtime;
     if (found) {
         free((void*)ibus->address);
         ibus->address = _glfw_strdup(buf + sizeof("IBUS_ADDRESS=") - 1);
-        return GLFW_TRUE;
+        return true;
     }
     _glfwInputError(GLFW_PLATFORM_ERROR, "Could not find IBUS_ADDRESS in %s", ibus->address_file_name);
-    return GLFW_FALSE;
+    return false;
 }
 
 void
@@ -245,35 +245,35 @@ input_context_created(DBusMessage *msg, const char* errmsg, void *data) {
     dbus_connection_try_register_object_path(ibus->conn, ibus->input_ctx_path, &ibus_vtable, ibus, NULL);
     enum Capabilities caps = IBUS_CAP_FOCUS | IBUS_CAP_PREEDIT_TEXT;
     if (!glfw_dbus_call_method_no_reply(ibus->conn, IBUS_SERVICE, ibus->input_ctx_path, IBUS_INPUT_INTERFACE, "SetCapabilities", DBUS_TYPE_UINT32, &caps, DBUS_TYPE_INVALID)) return;
-    ibus->ok = GLFW_TRUE;
-    glfw_ibus_set_focused(ibus, GLFW_FALSE);
+    ibus->ok = true;
+    glfw_ibus_set_focused(ibus, false);
     glfw_ibus_set_cursor_geometry(ibus, 0, 0, 0, 0);
     debug("Connected to IBUS daemon for IME input management\n");
 }
 
-GLFWbool
+bool
 setup_connection(_GLFWIBUSData *ibus) {
     const char *client_name = "GLFW_Application";
     const char *address_file_name = get_ibus_address_file_name();
-    ibus->ok = GLFW_FALSE;
-    if (!address_file_name) return GLFW_FALSE;
+    ibus->ok = false;
+    if (!address_file_name) return false;
     free((void*)ibus->address_file_name);
     ibus->address_file_name = _glfw_strdup(address_file_name);
-    if (!read_ibus_address(ibus)) return GLFW_FALSE;
+    if (!read_ibus_address(ibus)) return false;
     if (ibus->conn) {
         glfw_dbus_close_connection(ibus->conn);
         ibus->conn = NULL;
     }
     debug("Connecting to IBUS daemon @ %s for IME input management\n", ibus->address);
-    ibus->conn = glfw_dbus_connect_to(ibus->address, "Failed to connect to the IBUS daemon, with error", "ibus", GLFW_FALSE);
-    if (!ibus->conn) return GLFW_FALSE;
+    ibus->conn = glfw_dbus_connect_to(ibus->address, "Failed to connect to the IBUS daemon, with error", "ibus", false);
+    if (!ibus->conn) return false;
     free((void*)ibus->input_ctx_path); ibus->input_ctx_path = NULL;
     if (!glfw_dbus_call_method_with_reply(
             ibus->conn, IBUS_SERVICE, IBUS_PATH, IBUS_INTERFACE, "CreateInputContext", DBUS_TIMEOUT_USE_DEFAULT, input_context_created, ibus,
             DBUS_TYPE_STRING, &client_name, DBUS_TYPE_INVALID)) {
-        return GLFW_FALSE;
+        return false;
     }
-    return GLFW_TRUE;
+    return true;
 }
 
 
@@ -281,7 +281,7 @@ void
 glfw_connect_to_ibus(_GLFWIBUSData *ibus) {
     if (ibus->inited) return;
     if (!test_env_var("GLFW_IM_MODULE", "ibus")) return;
-    ibus->inited = GLFW_TRUE;
+    ibus->inited = true;
     setup_connection(ibus);
 }
 
@@ -297,21 +297,21 @@ glfw_ibus_terminate(_GLFWIBUSData *ibus) {
     F(address_file_name);
 #undef F
 
-    ibus->ok = GLFW_FALSE;
+    ibus->ok = false;
 }
 
-static GLFWbool
+static bool
 check_connection(_GLFWIBUSData *ibus) {
-    if (!ibus->inited) return GLFW_FALSE;
+    if (!ibus->inited) return false;
     if (ibus->conn && dbus_connection_get_is_connected(ibus->conn)) {
         return ibus->ok;
     }
     struct stat s;
     if (stat(ibus->address_file_name, &s) != 0 || s.st_mtime != ibus->address_file_mtime) {
-        if (!read_ibus_address(ibus)) return GLFW_FALSE;
+        if (!read_ibus_address(ibus)) return false;
         setup_connection(ibus);
     }
-    return GLFW_FALSE;
+    return false;
 }
 
 
@@ -329,7 +329,7 @@ simple_message(_GLFWIBUSData *ibus, const char *method) {
 }
 
 void
-glfw_ibus_set_focused(_GLFWIBUSData *ibus, GLFWbool focused) {
+glfw_ibus_set_focused(_GLFWIBUSData *ibus, bool focused) {
     simple_message(ibus, focused ? "FocusIn" : "FocusOut");
 }
 
@@ -394,24 +394,24 @@ void
 key_event_processed(DBusMessage *msg, const char* errmsg, void *data) {
     uint32_t handled = 0;
     KeyEvent *ev = (KeyEvent*)data;
-    GLFWbool is_release = ev->action == GLFW_RELEASE;
-    GLFWbool failed = GLFW_FALSE;
+    bool is_release = ev->action == GLFW_RELEASE;
+    bool failed = false;
     if (errmsg) {
         _glfwInputError(GLFW_PLATFORM_ERROR, "IBUS: Failed to process key with error: %s", errmsg);
-        failed = GLFW_TRUE;
+        failed = true;
     } else {
         glfw_dbus_get_args(msg, "Failed to get IBUS handled key from reply", DBUS_TYPE_BOOLEAN, &handled, DBUS_TYPE_INVALID);
         debug("IBUS processed scancode: 0x%x release: %d handled: %u\n", ev->keycode, is_release, handled);
     }
-    glfw_xkb_key_from_ime(ev, handled ? GLFW_TRUE : GLFW_FALSE, failed);
+    glfw_xkb_key_from_ime(ev, handled ? true : false, failed);
     free(ev);
 }
 
-GLFWbool
+bool
 ibus_process_key(const KeyEvent *ev_, _GLFWIBUSData *ibus) {
-    if (!check_connection(ibus)) return GLFW_FALSE;
+    if (!check_connection(ibus)) return false;
     KeyEvent *ev = malloc(sizeof(KeyEvent));
-    if (!ev) return GLFW_FALSE;
+    if (!ev) return false;
     memcpy(ev, ev_, sizeof(KeyEvent));
     uint32_t state = ibus_key_state(ev->glfw_modifiers, ev->action);
     if (!glfw_dbus_call_method_with_reply(
@@ -420,7 +420,7 @@ ibus_process_key(const KeyEvent *ev_, _GLFWIBUSData *ibus) {
             DBUS_TYPE_UINT32, &ev->ibus_sym, DBUS_TYPE_UINT32, &ev->ibus_keycode, DBUS_TYPE_UINT32,
             &state, DBUS_TYPE_INVALID)) {
         free(ev);
-        return GLFW_FALSE;
+        return false;
     }
-    return GLFW_TRUE;
+    return true;
 }

glfw/ibus_glfw.h

@@ -31,7 +31,7 @@
 #include <xkbcommon/xkbcommon.h>
 
 typedef struct {
-    GLFWbool ok, inited;
+    bool ok, inited;
     time_t address_file_mtime;
     DBusConnection *conn;
     const char *input_ctx_path, *address_file_name, *address;
@@ -49,7 +49,7 @@ typedef struct {
 
 void glfw_connect_to_ibus(_GLFWIBUSData *ibus);
 void glfw_ibus_terminate(_GLFWIBUSData *ibus);
-void glfw_ibus_set_focused(_GLFWIBUSData *ibus, GLFWbool focused);
+void glfw_ibus_set_focused(_GLFWIBUSData *ibus, bool focused);
 void glfw_ibus_dispatch(_GLFWIBUSData *ibus);
-GLFWbool ibus_process_key(const KeyEvent *ev_, _GLFWIBUSData *ibus);
+bool ibus_process_key(const KeyEvent *ev_, _GLFWIBUSData *ibus);
 void glfw_ibus_set_cursor_geometry(_GLFWIBUSData *ibus, int x, int y, int w, int h);

glfw/init.c

@@ -41,7 +41,7 @@
 
 // Global state shared between compilation units of GLFW
 //
-_GLFWlibrary _glfw = { GLFW_FALSE };
+_GLFWlibrary _glfw = { false };
 
 // These are outside of _glfw so they can be used before initialization and
 // after termination
@@ -50,12 +50,12 @@ static _GLFWerror _glfwMainThreadError;
 static GLFWerrorfun _glfwErrorCallback;
 static _GLFWinitconfig _glfwInitHints =
 {
-    GLFW_TRUE,      // hat buttons
-    GLFW_FALSE,     // debug keyboard
-    GLFW_TRUE,      // enable joystick
+    true,      // hat buttons
+    false,     // debug keyboard
+    true,      // enable joystick
     {
-        GLFW_TRUE,  // macOS menu bar
-        GLFW_TRUE   // macOS bundle chdir
+        true,  // macOS menu bar
+        true   // macOS bundle chdir
     }
 };
 
@@ -92,7 +92,7 @@ static void terminate(void)
     _glfwTerminateVulkan();
     _glfwPlatformTerminate();
 
-    _glfw.initialized = GLFW_FALSE;
+    _glfw.initialized = false;
 
     while (_glfw.errorListHead)
     {
@@ -215,7 +215,7 @@ _glfwDebug(const char *format, ...) {
 GLFWAPI int glfwInit(void)
 {
     if (_glfw.initialized)
-        return GLFW_TRUE;
+        return true;
 
     memset(&_glfw, 0, sizeof(_glfw));
     _glfw.hints.init = _glfwInitHints;
@@ -223,7 +223,7 @@ GLFWAPI int glfwInit(void)
     if (!_glfwPlatformInit())
     {
         terminate();
-        return GLFW_FALSE;
+        return false;
     }
 
     if (!_glfwPlatformCreateMutex(&_glfw.errorLock) ||
@@ -231,12 +231,12 @@ GLFWAPI int glfwInit(void)
         !_glfwPlatformCreateTls(&_glfw.contextSlot))
     {
         terminate();
-        return GLFW_FALSE;
+        return false;
     }
 
     _glfwPlatformSetTls(&_glfw.errorSlot, &_glfwMainThreadError);
 
-    _glfw.initialized = GLFW_TRUE;
+    _glfw.initialized = true;
     _glfw.timer.offset = _glfwPlatformGetTimerValue();
 
     glfwDefaultWindowHints();
@@ -249,12 +249,12 @@ GLFWAPI int glfwInit(void)
             if (!glfwUpdateGamepadMappings(_glfwDefaultMappings[i]))
             {
                 terminate();
-                return GLFW_FALSE;
+                return false;
             }
         }
     }
 
-    return GLFW_TRUE;
+    return true;
 }
 
 GLFWAPI void glfwTerminate(void)

glfw/input.c

@@ -58,17 +58,17 @@ static _GLFWmapping* findMapping(const char* guid)
 
 // Checks whether a gamepad mapping element is present in the hardware
 //
-static GLFWbool isValidElementForJoystick(const _GLFWmapelement* e,
+static bool isValidElementForJoystick(const _GLFWmapelement* e,
                                           const _GLFWjoystick* js)
 {
     if (e->type == _GLFW_JOYSTICK_HATBIT && (e->index >> 4) >= js->hatCount)
-        return GLFW_FALSE;
+        return false;
     else if (e->type == _GLFW_JOYSTICK_BUTTON && e->index >= js->buttonCount)
-        return GLFW_FALSE;
+        return false;
     else if (e->type == _GLFW_JOYSTICK_AXIS && e->index >= js->axisCount)
-        return GLFW_FALSE;
+        return false;
 
-    return GLFW_TRUE;
+    return true;
 }
 
 // Finds a mapping based on joystick GUID and verifies element indices
@@ -110,7 +110,7 @@ static _GLFWmapping* findValidMapping(const _GLFWjoystick* js)
 
 // Parses an SDL_GameControllerDB line and adds it to the mapping list
 //
-static GLFWbool parseMapping(_GLFWmapping* mapping, const char* string)
+static bool parseMapping(_GLFWmapping* mapping, const char* string)
 {
     const char* c = string;
     size_t i, length;
@@ -148,7 +148,7 @@ static GLFWbool parseMapping(_GLFWmapping* mapping, const char* string)
     if (length != 32 || c[length] != ',')
     {
         _glfwInputError(GLFW_INVALID_VALUE, NULL);
-        return GLFW_FALSE;
+        return false;
     }
 
     memcpy(mapping->guid, c, length);
@@ -158,7 +158,7 @@ static GLFWbool parseMapping(_GLFWmapping* mapping, const char* string)
     if (length >= sizeof(mapping->name) || c[length] != ',')
     {
         _glfwInputError(GLFW_INVALID_VALUE, NULL);
-        return GLFW_FALSE;
+        return false;
     }
 
     memcpy(mapping->name, c, length);
@@ -168,7 +168,7 @@ static GLFWbool parseMapping(_GLFWmapping* mapping, const char* string)
     {
         // TODO: Implement output modifiers
         if (*c == '+' || *c == '-')
-            return GLFW_FALSE;
+            return false;
 
         for (i = 0;  i < sizeof(fields) / sizeof(fields[0]);  i++)
         {
@@ -229,7 +229,7 @@ static GLFWbool parseMapping(_GLFWmapping* mapping, const char* string)
             {
                 length = strlen(_GLFW_PLATFORM_MAPPING_NAME);
                 if (strncmp(c, _GLFW_PLATFORM_MAPPING_NAME, length) != 0)
-                    return GLFW_FALSE;
+                    return false;
             }
 
             break;
@@ -246,7 +246,7 @@ static GLFWbool parseMapping(_GLFWmapping* mapping, const char* string)
     }
 
     _glfwPlatformUpdateGamepadGUID(mapping->guid);
-    return GLFW_TRUE;
+    return true;
 }
 
 
@@ -260,13 +260,13 @@ void _glfwInputKeyboard(_GLFWwindow* window, int key, int scancode, int action,
 {
     if (key >= 0 && key <= GLFW_KEY_LAST)
     {
-        GLFWbool repeated = GLFW_FALSE;
+        bool repeated = false;
 
         if (action == GLFW_RELEASE && window->keys[key] == GLFW_RELEASE)
             return;
 
         if (action == GLFW_PRESS && window->keys[key] == GLFW_PRESS)
-            repeated = GLFW_TRUE;
+            repeated = true;
 
         if (action == GLFW_RELEASE && window->stickyKeys)
             window->keys[key] = _GLFW_STICK;
@@ -328,7 +328,7 @@ void _glfwInputCursorPos(_GLFWwindow* window, double xpos, double ypos)
 
 // Notifies shared code of a cursor enter/leave event
 //
-void _glfwInputCursorEnter(_GLFWwindow* window, GLFWbool entered)
+void _glfwInputCursorEnter(_GLFWwindow* window, bool entered)
 {
     if (window->callbacks.cursorEnter)
         window->callbacks.cursorEnter((GLFWwindow*) window, entered);
@@ -406,7 +406,7 @@ _GLFWjoystick* _glfwAllocJoystick(const char* name,
         return NULL;
 
     js = _glfw.joysticks + jid;
-    js->present     = GLFW_TRUE;
+    js->present     = true;
     js->name        = _glfw_strdup(name);
     js->axes        = calloc(axisCount, sizeof(float));
     js->buttons     = calloc(buttonCount + hatCount * 4, 1);
@@ -488,6 +488,7 @@ const char* _glfwGetKeyName(int key)
         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";
@@ -632,7 +633,7 @@ GLFWAPI void glfwSetInputMode(GLFWwindow* handle, int mode, int value)
     }
     else if (mode == GLFW_STICKY_KEYS)
     {
-        value = value ? GLFW_TRUE : GLFW_FALSE;
+        value = value ? true : false;
         if (window->stickyKeys == value)
             return;
 
@@ -652,7 +653,7 @@ GLFWAPI void glfwSetInputMode(GLFWwindow* handle, int mode, int value)
     }
     else if (mode == GLFW_STICKY_MOUSE_BUTTONS)
     {
-        value = value ? GLFW_TRUE : GLFW_FALSE;
+        value = value ? true : false;
         if (window->stickyMouseButtons == value)
             return;
 
@@ -671,7 +672,7 @@ GLFWAPI void glfwSetInputMode(GLFWwindow* handle, int mode, int value)
         window->stickyMouseButtons = value;
     }
     else if (mode == GLFW_LOCK_KEY_MODS)
-        window->lockKeyMods = value ? GLFW_TRUE : GLFW_FALSE;
+        window->lockKeyMods = value ? true : false;
     else
         _glfwInputError(GLFW_INVALID_ENUM, "Invalid input mode 0x%08X", mode);
 }
@@ -987,17 +988,17 @@ GLFWAPI int glfwJoystickPresent(int jid)
     assert(jid >= GLFW_JOYSTICK_1);
     assert(jid <= GLFW_JOYSTICK_LAST);
 
-    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
+    _GLFW_REQUIRE_INIT_OR_RETURN(false);
 
     if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
     {
         _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick ID %i", jid);
-        return GLFW_FALSE;
+        return false;
     }
 
     js = _glfw.joysticks + jid;
     if (!js->present)
-        return GLFW_FALSE;
+        return false;
 
     return _glfwPlatformPollJoystick(js, _GLFW_POLL_PRESENCE);
 }
@@ -1189,7 +1190,7 @@ GLFWAPI int glfwUpdateGamepadMappings(const char* string)
 
     assert(string != NULL);
 
-    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
+    _GLFW_REQUIRE_INIT_OR_RETURN(false);
 
     while (*c)
     {
@@ -1239,7 +1240,7 @@ GLFWAPI int glfwUpdateGamepadMappings(const char* string)
             js->mapping = findValidMapping(js);
     }
 
-    return GLFW_TRUE;
+    return true;
 }
 
 GLFWAPI int glfwJoystickIsGamepad(int jid)
@@ -1249,20 +1250,20 @@ GLFWAPI int glfwJoystickIsGamepad(int jid)
     assert(jid >= GLFW_JOYSTICK_1);
     assert(jid <= GLFW_JOYSTICK_LAST);
 
-    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
+    _GLFW_REQUIRE_INIT_OR_RETURN(false);
 
     if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
     {
         _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick ID %i", jid);
-        return GLFW_FALSE;
+        return false;
     }
 
     js = _glfw.joysticks + jid;
     if (!js->present)
-        return GLFW_FALSE;
+        return false;
 
     if (!_glfwPlatformPollJoystick(js, _GLFW_POLL_PRESENCE))
-        return GLFW_FALSE;
+        return false;
 
     return js->mapping != NULL;
 }
@@ -1306,23 +1307,23 @@ GLFWAPI int glfwGetGamepadState(int jid, GLFWgamepadstate* state)
 
     memset(state, 0, sizeof(GLFWgamepadstate));
 
-    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
+    _GLFW_REQUIRE_INIT_OR_RETURN(false);
 
     if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
     {
         _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick ID %i", jid);
-        return GLFW_FALSE;
+        return false;
     }
 
     js = _glfw.joysticks + jid;
     if (!js->present)
-        return GLFW_FALSE;
+        return false;
 
     if (!_glfwPlatformPollJoystick(js, _GLFW_POLL_ALL))
-        return GLFW_FALSE;
+        return false;
 
     if (!js->mapping)
-        return GLFW_FALSE;
+        return false;
 
     for (i = 0;  i <= GLFW_GAMEPAD_BUTTON_LAST;  i++)
     {
@@ -1363,7 +1364,7 @@ GLFWAPI int glfwGetGamepadState(int jid, GLFWgamepadstate* state)
             state->axes[i] = (float) js->buttons[e->index];
     }
 
-    return GLFW_TRUE;
+    return true;
 }
 
 GLFWAPI void glfwSetClipboardString(GLFWwindow* handle, const char* string)

glfw/internal.h

@@ -60,7 +60,6 @@
 
 #define _GLFW_MESSAGE_SIZE      1024
 
-typedef bool GLFWbool;
 typedef unsigned long long GLFWid;
 
 typedef struct _GLFWerror       _GLFWerror;
@@ -196,6 +195,13 @@ typedef void (APIENTRY * PFN_vkVoidFunction)(void);
  #error "No supported window creation API selected"
 #endif
 
+#define remove_i_from_array(array, i, count) { \
+    (count)--; \
+    if ((i) < (count)) { \
+        memmove((array) + (i), (array) + (i) + 1, sizeof((array)[0]) * ((count) - (i))); \
+    }}
+
+
 // Constructs a version number string from the public header macros
 #define _GLFW_CONCAT_VERSION(m, n, r) #m "." #n "." #r
 #define _GLFW_MAKE_VERSION(m, n, r) _GLFW_CONCAT_VERSION(m, n, r)
@@ -241,12 +247,12 @@ struct _GLFWerror
 //
 struct _GLFWinitconfig
 {
-    GLFWbool      hatButtons;
-    GLFWbool      debugKeyboard;
-    GLFWbool      enableJoysticks;
+    bool      hatButtons;
+    bool      debugKeyboard;
+    bool      enableJoysticks;
     struct {
-        GLFWbool  menubar;
-        GLFWbool  chdir;
+        bool  menubar;
+        bool  chdir;
     } ns;
 };
 
@@ -261,18 +267,18 @@ struct _GLFWwndconfig
     int           width;
     int           height;
     const char*   title;
-    GLFWbool      resizable;
-    GLFWbool      visible;
-    GLFWbool      decorated;
-    GLFWbool      focused;
-    GLFWbool      autoIconify;
-    GLFWbool      floating;
-    GLFWbool      maximized;
-    GLFWbool      centerCursor;
-    GLFWbool      focusOnShow;
-    GLFWbool      scaleToMonitor;
+    bool      resizable;
+    bool      visible;
+    bool      decorated;
+    bool      focused;
+    bool      autoIconify;
+    bool      floating;
+    bool      maximized;
+    bool      centerCursor;
+    bool      focusOnShow;
+    bool      scaleToMonitor;
     struct {
-        GLFWbool  retina;
+        bool  retina;
         char      frameName[256];
     } ns;
     struct {
@@ -296,15 +302,15 @@ struct _GLFWctxconfig
     int           source;
     int           major;
     int           minor;
-    GLFWbool      forward;
-    GLFWbool      debug;
-    GLFWbool      noerror;
+    bool      forward;
+    bool      debug;
+    bool      noerror;
     int           profile;
     int           robustness;
     int           release;
     _GLFWwindow*  share;
     struct {
-        GLFWbool  offline;
+        bool  offline;
     } nsgl;
 };
 
@@ -329,11 +335,11 @@ struct _GLFWfbconfig
     int         accumBlueBits;
     int         accumAlphaBits;
     int         auxBuffers;
-    GLFWbool    stereo;
+    bool    stereo;
     int         samples;
-    GLFWbool    sRGB;
-    GLFWbool    doublebuffer;
-    GLFWbool    transparent;
+    bool    sRGB;
+    bool    doublebuffer;
+    bool    transparent;
     uintptr_t   handle;
 };
 
@@ -344,7 +350,7 @@ struct _GLFWcontext
     int                 client;
     int                 source;
     int                 major, minor, revision;
-    GLFWbool            forward, debug, noerror;
+    bool            forward, debug, noerror;
     int                 profile;
     int                 robustness;
     int                 release;
@@ -375,12 +381,12 @@ struct _GLFWwindow
     struct _GLFWwindow* next;
 
     // Window settings and state
-    GLFWbool            resizable;
-    GLFWbool            decorated;
-    GLFWbool            autoIconify;
-    GLFWbool            floating;
-    GLFWbool            focusOnShow;
-    GLFWbool            shouldClose;
+    bool            resizable;
+    bool            decorated;
+    bool            autoIconify;
+    bool            floating;
+    bool            focusOnShow;
+    bool            shouldClose;
     void*               userPointer;
     GLFWid              id;
     GLFWvidmode         videoMode;
@@ -391,9 +397,9 @@ struct _GLFWwindow
     int                 maxwidth, maxheight;
     int                 numer, denom;
 
-    GLFWbool            stickyKeys;
-    GLFWbool            stickyMouseButtons;
-    GLFWbool            lockKeyMods;
+    bool            stickyKeys;
+    bool            stickyMouseButtons;
+    bool            lockKeyMods;
     int                 cursorMode;
     char                mouseButtons[GLFW_MOUSE_BUTTON_LAST + 1];
     char                keys[GLFW_KEY_LAST + 1];
@@ -484,7 +490,7 @@ struct _GLFWmapping
 //
 struct _GLFWjoystick
 {
-    GLFWbool        present;
+    bool        present;
     float*          axes;
     int             axisCount;
     unsigned char*  buttons;
@@ -520,7 +526,7 @@ struct _GLFWmutex
 //
 struct _GLFWlibrary
 {
-    GLFWbool            initialized;
+    bool            initialized;
 
     struct {
         _GLFWinitconfig init;
@@ -553,23 +559,23 @@ struct _GLFWlibrary
     } timer;
 
     struct {
-        GLFWbool        available;
+        bool        available;
         void*           handle;
         char*           extensions[2];
 #if !defined(_GLFW_VULKAN_STATIC)
         PFN_vkEnumerateInstanceExtensionProperties EnumerateInstanceExtensionProperties;
         PFN_vkGetInstanceProcAddr GetInstanceProcAddr;
 #endif
-        GLFWbool        KHR_surface;
+        bool        KHR_surface;
 #if defined(_GLFW_WIN32)
-        GLFWbool        KHR_win32_surface;
+        bool        KHR_win32_surface;
 #elif defined(_GLFW_COCOA)
-        GLFWbool        MVK_macos_surface;
+        bool        MVK_macos_surface;
 #elif defined(_GLFW_X11)
-        GLFWbool        KHR_xlib_surface;
-        GLFWbool        KHR_xcb_surface;
+        bool        KHR_xlib_surface;
+        bool        KHR_xcb_surface;
 #elif defined(_GLFW_WAYLAND)
-        GLFWbool        KHR_wayland_surface;
+        bool        KHR_wayland_surface;
 #endif
     } vk;
 
@@ -622,7 +628,7 @@ void _glfwPlatformGetMonitorContentScale(_GLFWmonitor* monitor,
 void _glfwPlatformGetMonitorWorkarea(_GLFWmonitor* monitor, int* xpos, int* ypos, int *width, int *height);
 GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* count);
 void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode);
-GLFWbool _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp);
+bool _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp);
 void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp);
 
 void _glfwPlatformSetClipboardString(const char* string);
@@ -682,9 +688,9 @@ int _glfwPlatformWindowMaximized(_GLFWwindow* window);
 int _glfwPlatformWindowHovered(_GLFWwindow* window);
 int _glfwPlatformFramebufferTransparent(_GLFWwindow* window);
 float _glfwPlatformGetWindowOpacity(_GLFWwindow* window);
-void _glfwPlatformSetWindowResizable(_GLFWwindow* window, GLFWbool enabled);
-void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, GLFWbool enabled);
-void _glfwPlatformSetWindowFloating(_GLFWwindow* window, GLFWbool enabled);
+void _glfwPlatformSetWindowResizable(_GLFWwindow* window, bool enabled);
+void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, bool enabled);
+void _glfwPlatformSetWindowFloating(_GLFWwindow* window, bool enabled);
 void _glfwPlatformSetWindowOpacity(_GLFWwindow* window, float opacity);
 void _glfwPlatformUpdateIMEState(_GLFWwindow *w, int which, int a, int b, int c, int d);
 
@@ -702,12 +708,12 @@ VkResult _glfwPlatformCreateWindowSurface(VkInstance instance,
                                           const VkAllocationCallbacks* allocator,
                                           VkSurfaceKHR* surface);
 
-GLFWbool _glfwPlatformCreateTls(_GLFWtls* tls);
+bool _glfwPlatformCreateTls(_GLFWtls* tls);
 void _glfwPlatformDestroyTls(_GLFWtls* tls);
 void* _glfwPlatformGetTls(_GLFWtls* tls);
 void _glfwPlatformSetTls(_GLFWtls* tls, void* value);
 
-GLFWbool _glfwPlatformCreateMutex(_GLFWmutex* mutex);
+bool _glfwPlatformCreateMutex(_GLFWmutex* mutex);
 void _glfwPlatformDestroyMutex(_GLFWmutex* mutex);
 void _glfwPlatformLockMutex(_GLFWmutex* mutex);
 void _glfwPlatformUnlockMutex(_GLFWmutex* mutex);
@@ -717,15 +723,15 @@ void _glfwPlatformUnlockMutex(_GLFWmutex* mutex);
 //////                         GLFW event API                       //////
 //////////////////////////////////////////////////////////////////////////
 
-void _glfwInputWindowFocus(_GLFWwindow* window, GLFWbool focused);
-void _glfwInputWindowOcclusion(_GLFWwindow* window, GLFWbool occluded);
+void _glfwInputWindowFocus(_GLFWwindow* window, bool focused);
+void _glfwInputWindowOcclusion(_GLFWwindow* window, bool 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);
 void _glfwInputWindowContentScale(_GLFWwindow* window,
                                   float xscale, float yscale);
-void _glfwInputWindowIconify(_GLFWwindow* window, GLFWbool iconified);
-void _glfwInputWindowMaximize(_GLFWwindow* window, GLFWbool maximized);
+void _glfwInputWindowIconify(_GLFWwindow* window, bool iconified);
+void _glfwInputWindowMaximize(_GLFWwindow* window, bool maximized);
 void _glfwInputWindowDamage(_GLFWwindow* window);
 void _glfwInputWindowCloseRequest(_GLFWwindow* window);
 void _glfwInputWindowMonitor(_GLFWwindow* window, _GLFWmonitor* monitor);
@@ -734,7 +740,7 @@ void _glfwInputKeyboard(_GLFWwindow* window, int key, int scancode, int action,
 void _glfwInputScroll(_GLFWwindow* window, double xoffset, double yoffset, int flags);
 void _glfwInputMouseClick(_GLFWwindow* window, int button, int action, int mods);
 void _glfwInputCursorPos(_GLFWwindow* window, double xpos, double ypos);
-void _glfwInputCursorEnter(_GLFWwindow* window, GLFWbool entered);
+void _glfwInputCursorEnter(_GLFWwindow* window, bool entered);
 void _glfwInputDrop(_GLFWwindow* window, int count, const char** names);
 void _glfwInputJoystick(_GLFWjoystick* js, int event);
 void _glfwInputJoystickAxis(_GLFWjoystick* js, int axis, float value);
@@ -764,13 +770,13 @@ void _glfwDebug(const char* format, ...);
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
 
-GLFWbool _glfwStringInExtensionString(const char* string, const char* extensions);
+bool _glfwStringInExtensionString(const char* string, const char* extensions);
 const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired,
                                          const _GLFWfbconfig* alternatives,
                                          unsigned int count);
-GLFWbool _glfwRefreshContextAttribs(_GLFWwindow* window,
+bool _glfwRefreshContextAttribs(_GLFWwindow* window,
                                     const _GLFWctxconfig* ctxconfig);
-GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig);
+bool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig);
 
 const GLFWvidmode* _glfwChooseVideoMode(_GLFWmonitor* monitor,
                                         const GLFWvidmode* desired);
@@ -790,7 +796,7 @@ void _glfwFreeJoystick(_GLFWjoystick* js);
 const char* _glfwGetKeyName(int key);
 void _glfwCenterCursorInContentArea(_GLFWwindow* window);
 
-GLFWbool _glfwInitVulkan(int mode);
+bool _glfwInitVulkan(int mode);
 void _glfwTerminateVulkan(void);
 const char* _glfwGetVulkanResultString(VkResult result);
 _GLFWwindow* _glfwFocusedWindow(void);
@@ -799,7 +805,7 @@ 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 _glfwPlatformUpdateTimer(unsigned long long timer_id, double interval, bool enabled);
 void _glfwPlatformRemoveTimer(unsigned long long timer_id);
 
 char* _glfw_strdup(const char* source);

glfw/linux_joystick.c

@@ -124,7 +124,7 @@ static void pollAbsState(_GLFWjoystick* js)
 
 // Attempt to open the specified joystick device
 //
-static GLFWbool openJoystickDevice(const char* path)
+static bool openJoystickDevice(const char* path)
 {
     int jid, code;
     char name[256] = "";
@@ -142,12 +142,12 @@ static GLFWbool openJoystickDevice(const char* path)
         if (!_glfw.joysticks[jid].present)
             continue;
         if (strcmp(_glfw.joysticks[jid].linjs.path, path) == 0)
-            return GLFW_FALSE;
+            return false;
     }
 
     linjs.fd = open(path, O_RDONLY | O_NONBLOCK);
     if (linjs.fd == -1)
-        return GLFW_FALSE;
+        return false;
 
     if (ioctl(linjs.fd, EVIOCGBIT(0, sizeof(evBits)), evBits) < 0 ||
         ioctl(linjs.fd, EVIOCGBIT(EV_KEY, sizeof(keyBits)), keyBits) < 0 ||
@@ -158,14 +158,14 @@ static GLFWbool openJoystickDevice(const char* path)
                         "Linux: Failed to query input device: %s",
                         strerror(errno));
         close(linjs.fd);
-        return GLFW_FALSE;
+        return false;
     }
 
     // Ensure this device supports the events expected of a joystick
     if (!isBitSet(EV_KEY, evBits) || !isBitSet(EV_ABS, evBits))
     {
         close(linjs.fd);
-        return GLFW_FALSE;
+        return false;
     }
 
     if (ioctl(linjs.fd, EVIOCGNAME(sizeof(name)), name) < 0)
@@ -225,7 +225,7 @@ static GLFWbool openJoystickDevice(const char* path)
     if (!js)
     {
         close(linjs.fd);
-        return GLFW_FALSE;
+        return false;
     }
 
     strncpy(linjs.path, path, sizeof(linjs.path) - 1);
@@ -234,7 +234,7 @@ static GLFWbool openJoystickDevice(const char* path)
     pollAbsState(js);
 
     _glfwInputJoystick(js, GLFW_CONNECTED);
-    return GLFW_TRUE;
+    return true;
 }
 
 #undef isBitSet
@@ -264,7 +264,7 @@ static int compareJoysticks(const void* fp, const void* sp)
 
 // Initialize joystick interface
 //
-GLFWbool _glfwInitJoysticksLinux(void)
+bool _glfwInitJoysticksLinux(void)
 {
     DIR* dir;
     int count = 0;
@@ -286,7 +286,7 @@ GLFWbool _glfwInitJoysticksLinux(void)
     if (regcomp(&_glfw.linjs.regex, "^event[0-9]\\+$", 0) != 0)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR, "Linux: Failed to compile regex");
-        return GLFW_FALSE;
+        return false;
     }
 
     dir = opendir(dirname);
@@ -315,7 +315,7 @@ GLFWbool _glfwInitJoysticksLinux(void)
     // Continue with no joysticks if enumeration fails
 
     qsort(_glfw.joysticks, count, sizeof(_GLFWjoystick), compareJoysticks);
-    return GLFW_TRUE;
+    return true;
 }
 
 // Close all opened joystick handles
@@ -408,10 +408,10 @@ int _glfwPlatformPollJoystick(_GLFWjoystick* js, int mode)
         if (e.type == EV_SYN)
         {
             if (e.code == SYN_DROPPED)
-                _glfw.linjs.dropped = GLFW_TRUE;
+                _glfw.linjs.dropped = true;
             else if (e.code == SYN_REPORT)
             {
-                _glfw.linjs.dropped = GLFW_FALSE;
+                _glfw.linjs.dropped = false;
                 pollAbsState(js);
             }
         }

glfw/linux_joystick.h

@@ -52,11 +52,11 @@ typedef struct _GLFWlibraryLinux
     int                     inotify;
     int                     watch;
     regex_t                 regex;
-    GLFWbool                dropped;
+    bool                dropped;
 } _GLFWlibraryLinux;
 
 
-GLFWbool _glfwInitJoysticksLinux(void);
+bool _glfwInitJoysticksLinux(void);
 void _glfwTerminateJoysticksLinux(void);
 void _glfwDetectJoystickConnectionLinux(void);
 

glfw/main_loop.h

@@ -12,20 +12,20 @@
 #define GLFW_LOOP_BACKEND x11
 #endif
 
-static GLFWbool keep_going = GLFW_FALSE;
+static bool keep_going = false;
 
 void _glfwPlatformRequestTickCallback() {
 }
 
 void _glfwPlatformStopMainLoop(void) {
     if (keep_going) {
-        keep_going = GLFW_FALSE;
+        keep_going = false;
         _glfwPlatformPostEmptyEvent();
     }
 }
 
 void _glfwPlatformRunMainLoop(GLFWtickcallback tick_callback, void* data) {
-    keep_going = GLFW_TRUE;
+    keep_going = true;
     while(keep_going) {
         _glfwPlatformWaitEvents();
 		EVDBG("loop tick");
@@ -41,7 +41,7 @@ void _glfwPlatformRemoveTimer(unsigned long long timer_id) {
     removeTimer(&_glfw.GLFW_LOOP_BACKEND.eventLoopData, timer_id);
 }
 
-void _glfwPlatformUpdateTimer(unsigned long long timer_id, double interval, GLFWbool enabled) {
+void _glfwPlatformUpdateTimer(unsigned long long timer_id, double interval, bool enabled) {
     changeTimerInterval(&_glfw.GLFW_LOOP_BACKEND.eventLoopData, timer_id, interval);
     toggleTimer(&_glfw.GLFW_LOOP_BACKEND.eventLoopData, timer_id, enabled);
 }

glfw/monitor.c

@@ -60,17 +60,17 @@ static int compareVideoModes(const void* fp, const void* sp)
 
 // Retrieves the available modes for the specified monitor
 //
-static GLFWbool refreshVideoModes(_GLFWmonitor* monitor)
+static bool refreshVideoModes(_GLFWmonitor* monitor)
 {
     int modeCount;
     GLFWvidmode* modes;
 
     if (monitor->modes)
-        return GLFW_TRUE;
+        return true;
 
     modes = _glfwPlatformGetVideoModes(monitor, &modeCount);
     if (!modes)
-        return GLFW_FALSE;
+        return false;
 
     qsort(modes, modeCount, sizeof(GLFWvidmode), compareVideoModes);
 
@@ -78,7 +78,7 @@ static GLFWbool refreshVideoModes(_GLFWmonitor* monitor)
     monitor->modes = modes;
     monitor->modeCount = modeCount;
 
-    return GLFW_TRUE;
+    return true;
 }
 
 
@@ -127,10 +127,7 @@ void _glfwInputMonitor(_GLFWmonitor* monitor, int action, int placement)
         {
             if (_glfw.monitors[i] == monitor)
             {
-                _glfw.monitorCount--;
-                memmove(_glfw.monitors + i,
-                        _glfw.monitors + i + 1,
-                        (_glfw.monitorCount - i) * sizeof(_GLFWmonitor*));
+                remove_i_from_array(_glfw.monitors, i, _glfw.monitorCount);
                 break;
             }
         }

glfw/nsgl_context.h

@@ -47,9 +47,9 @@ typedef struct _GLFWlibraryNSGL
 } _GLFWlibraryNSGL;
 
 
-GLFWbool _glfwInitNSGL(void);
+bool _glfwInitNSGL(void);
 void _glfwTerminateNSGL(void);
-GLFWbool _glfwCreateContextNSGL(_GLFWwindow* window,
+bool _glfwCreateContextNSGL(_GLFWwindow* window,
                                 const _GLFWctxconfig* ctxconfig,
                                 const _GLFWfbconfig* fbconfig);
 void _glfwDestroyContextNSGL(_GLFWwindow* window);

glfw/nsgl_context.m

@@ -54,7 +54,7 @@ static void swapIntervalNSGL(int interval)
 static int extensionSupportedNSGL(const char* extension)
 {
     // There are no NSGL extensions
-    return GLFW_FALSE;
+    return false;
 }
 
 static GLFWglproc getProcAddressNSGL(const char* procname)
@@ -71,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];
@@ -89,10 +87,10 @@ static void destroyContextNSGL(_GLFWwindow* window)
 
 // Initialize OpenGL support
 //
-GLFWbool _glfwInitNSGL(void)
+bool _glfwInitNSGL(void)
 {
     if (_glfw.nsgl.framework)
-        return GLFW_TRUE;
+        return true;
 
     _glfw.nsgl.framework =
         CFBundleGetBundleWithIdentifier(CFSTR("com.apple.opengl"));
@@ -100,10 +98,10 @@ GLFWbool _glfwInitNSGL(void)
     {
         _glfwInputError(GLFW_API_UNAVAILABLE,
                         "NSGL: Failed to locate OpenGL framework");
-        return GLFW_FALSE;
+        return false;
     }
 
-    return GLFW_TRUE;
+    return true;
 }
 
 // Terminate OpenGL support
@@ -114,7 +112,7 @@ void _glfwTerminateNSGL(void)
 
 // Create the OpenGL context
 //
-GLFWbool _glfwCreateContextNSGL(_GLFWwindow* window,
+bool _glfwCreateContextNSGL(_GLFWwindow* window,
                                 const _GLFWctxconfig* ctxconfig,
                                 const _GLFWfbconfig* fbconfig)
 {
@@ -122,7 +120,7 @@ GLFWbool _glfwCreateContextNSGL(_GLFWwindow* window,
     {
         _glfwInputError(GLFW_API_UNAVAILABLE,
                         "NSGL: OpenGL ES is not available on macOS");
-        return GLFW_FALSE;
+        return false;
     }
 
     if (ctxconfig->major > 2)
@@ -131,15 +129,9 @@ GLFWbool _glfwCreateContextNSGL(_GLFWwindow* window,
         {
             _glfwInputError(GLFW_VERSION_UNAVAILABLE,
                             "NSGL: The targeted version of macOS does not support OpenGL 3.0 or 3.1 but may support 3.2 and above");
-            return GLFW_FALSE;
+            return 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
@@ -239,7 +231,7 @@ GLFWbool _glfwCreateContextNSGL(_GLFWwindow* window,
 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 101200
         _glfwInputError(GLFW_FORMAT_UNAVAILABLE,
                         "NSGL: Stereo rendering is deprecated");
-        return GLFW_FALSE;
+        return false;
 #else
         addAttrib(NSOpenGLPFAStereo);
 #endif
@@ -275,7 +267,7 @@ GLFWbool _glfwCreateContextNSGL(_GLFWwindow* window,
     {
         _glfwInputError(GLFW_FORMAT_UNAVAILABLE,
                         "NSGL: Failed to find a suitable pixel format");
-        return GLFW_FALSE;
+        return false;
     }
 
     NSOpenGLContext* share = NULL;
@@ -290,7 +282,7 @@ GLFWbool _glfwCreateContextNSGL(_GLFWwindow* window,
     {
         _glfwInputError(GLFW_VERSION_UNAVAILABLE,
                         "NSGL: Failed to create OpenGL context");
-        return GLFW_FALSE;
+        return false;
     }
 
     if (fbconfig->transparent)
@@ -315,7 +307,7 @@ GLFWbool _glfwCreateContextNSGL(_GLFWwindow* window,
     window->context.getProcAddress = getProcAddressNSGL;
     window->context.destroy = destroyContextNSGL;
 
-    return GLFW_TRUE;
+    return true;
 }
 
 

glfw/null_init.c

@@ -35,7 +35,7 @@
 int _glfwPlatformInit(void)
 {
     _glfwInitTimerPOSIX();
-    return GLFW_TRUE;
+    return true;
 }
 
 void _glfwPlatformTerminate(void)

glfw/null_joystick.c

@@ -33,7 +33,7 @@
 
 int _glfwPlatformPollJoystick(_GLFWjoystick* js, int mode)
 {
-    return GLFW_FALSE;
+    return false;
 }
 
 void _glfwPlatformUpdateGamepadGUID(char* guid)

glfw/null_monitor.c

@@ -62,9 +62,9 @@ void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode)
 {
 }
 
-GLFWbool _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
+bool _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
 {
-    return GLFW_FALSE;
+    return false;
 }
 
 void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)

glfw/null_window.c

@@ -34,7 +34,7 @@ static int createNativeWindow(_GLFWwindow* window,
     window->null.width = wndconfig->width;
     window->null.height = wndconfig->height;
 
-    return GLFW_TRUE;
+    return true;
 }
 
 
@@ -48,7 +48,7 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
                               const _GLFWfbconfig* fbconfig)
 {
     if (!createNativeWindow(window, wndconfig))
-        return GLFW_FALSE;
+        return false;
 
     if (ctxconfig->client != GLFW_NO_API)
     {
@@ -56,18 +56,18 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
             ctxconfig->source == GLFW_OSMESA_CONTEXT_API)
         {
             if (!_glfwInitOSMesa())
-                return GLFW_FALSE;
+                return false;
             if (!_glfwCreateContextOSMesa(window, ctxconfig, fbconfig))
-                return GLFW_FALSE;
+                return false;
         }
         else
         {
             _glfwInputError(GLFW_API_UNAVAILABLE, "Null: EGL not available");
-            return GLFW_FALSE;
+            return false;
         }
     }
 
-    return GLFW_TRUE;
+    return true;
 }
 
 void _glfwPlatformDestroyWindow(_GLFWwindow* window)
@@ -167,28 +167,28 @@ void _glfwPlatformMaximizeWindow(_GLFWwindow* window)
 
 int _glfwPlatformWindowMaximized(_GLFWwindow* window)
 {
-    return GLFW_FALSE;
+    return false;
 }
 
 int _glfwPlatformWindowHovered(_GLFWwindow* window)
 {
-    return GLFW_FALSE;
+    return false;
 }
 
 int _glfwPlatformFramebufferTransparent(_GLFWwindow* window)
 {
-    return GLFW_FALSE;
+    return false;
 }
 
-void _glfwPlatformSetWindowResizable(_GLFWwindow* window, GLFWbool enabled)
+void _glfwPlatformSetWindowResizable(_GLFWwindow* window, bool enabled)
 {
 }
 
-void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, GLFWbool enabled)
+void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, bool enabled)
 {
 }
 
-void _glfwPlatformSetWindowFloating(_GLFWwindow* window, GLFWbool enabled)
+void _glfwPlatformSetWindowFloating(_GLFWwindow* window, bool enabled)
 {
 }
 
@@ -212,7 +212,7 @@ void _glfwPlatformRequestWindowAttention(_GLFWwindow* window)
 
 int _glfwPlatformWindowBell(_GLFWwindow* window)
 {
-    return GLFW_FALSE;
+    return false;
 }
 
 void _glfwPlatformUnhideWindow(_GLFWwindow* window)
@@ -229,22 +229,22 @@ void _glfwPlatformFocusWindow(_GLFWwindow* window)
 
 int _glfwPlatformWindowFocused(_GLFWwindow* window)
 {
-    return GLFW_FALSE;
+    return false;
 }
 
 int _glfwPlatformWindowOccluded(_GLFWwindow* window)
 {
-    return GLFW_FALSE;
+    return false;
 }
 
 int _glfwPlatformWindowIconified(_GLFWwindow* window)
 {
-    return GLFW_FALSE;
+    return false;
 }
 
 int _glfwPlatformWindowVisible(_GLFWwindow* window)
 {
-    return GLFW_FALSE;
+    return false;
 }
 
 void _glfwPlatformPollEvents(void)
@@ -279,12 +279,12 @@ int _glfwPlatformCreateCursor(_GLFWcursor* cursor,
                               const GLFWimage* image,
                               int xhot, int yhot, int count)
 {
-    return GLFW_TRUE;
+    return true;
 }
 
 int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, int shape)
 {
-    return GLFW_TRUE;
+    return true;
 }
 
 void _glfwPlatformDestroyCursor(_GLFWcursor* cursor)
@@ -322,7 +322,7 @@ int _glfwPlatformGetPhysicalDevicePresentationSupport(VkInstance instance,
                                                       VkPhysicalDevice device,
                                                       uint32_t queuefamily)
 {
-    return GLFW_FALSE;
+    return false;
 }
 
 VkResult _glfwPlatformCreateWindowSurface(VkInstance instance,

glfw/osmesa_context.c

@@ -100,7 +100,7 @@ static void swapIntervalOSMesa(int interval)
 static int extensionSupportedOSMesa(const char* extension)
 {
     // OSMesa does not have extensions
-    return GLFW_FALSE;
+    return false;
 }
 
 
@@ -108,7 +108,7 @@ static int extensionSupportedOSMesa(const char* extension)
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
 
-GLFWbool _glfwInitOSMesa(void)
+bool _glfwInitOSMesa(void)
 {
     int i;
     const char* sonames[] =
@@ -130,7 +130,7 @@ GLFWbool _glfwInitOSMesa(void)
     };
 
     if (_glfw.osmesa.handle)
-        return GLFW_TRUE;
+        return true;
 
     for (i = 0;  sonames[i];  i++)
     {
@@ -142,7 +142,7 @@ GLFWbool _glfwInitOSMesa(void)
     if (!_glfw.osmesa.handle)
     {
         _glfwInputError(GLFW_API_UNAVAILABLE, "OSMesa: Library not found");
-        return GLFW_FALSE;
+        return false;
     }
 
     _glfw.osmesa.CreateContextExt = (PFN_OSMesaCreateContextExt)
@@ -171,10 +171,10 @@ GLFWbool _glfwInitOSMesa(void)
                         "OSMesa: Failed to load required entry points");
 
         _glfwTerminateOSMesa();
-        return GLFW_FALSE;
+        return false;
     }
 
-    return GLFW_TRUE;
+    return true;
 }
 
 void _glfwTerminateOSMesa(void)
@@ -193,7 +193,7 @@ void _glfwTerminateOSMesa(void)
     attribs[index++] = v; \
 }
 
-GLFWbool _glfwCreateContextOSMesa(_GLFWwindow* window,
+bool _glfwCreateContextOSMesa(_GLFWwindow* window,
                                   const _GLFWctxconfig* ctxconfig,
                                   const _GLFWfbconfig* fbconfig)
 {
@@ -207,7 +207,7 @@ GLFWbool _glfwCreateContextOSMesa(_GLFWwindow* window,
     {
         _glfwInputError(GLFW_API_UNAVAILABLE,
                         "OSMesa: OpenGL ES is not available on OSMesa");
-        return GLFW_FALSE;
+        return false;
     }
 
     if (ctxconfig->share)
@@ -241,7 +241,7 @@ GLFWbool _glfwCreateContextOSMesa(_GLFWwindow* window,
         {
             _glfwInputError(GLFW_VERSION_UNAVAILABLE,
                             "OSMesa: Forward-compatible contexts not supported");
-            return GLFW_FALSE;
+            return false;
         }
 
         setAttrib(0, 0);
@@ -255,7 +255,7 @@ GLFWbool _glfwCreateContextOSMesa(_GLFWwindow* window,
         {
             _glfwInputError(GLFW_VERSION_UNAVAILABLE,
                             "OSMesa: OpenGL profiles unavailable");
-            return GLFW_FALSE;
+            return false;
         }
 
         window->context.osmesa.handle =
@@ -270,7 +270,7 @@ GLFWbool _glfwCreateContextOSMesa(_GLFWwindow* window,
     {
         _glfwInputError(GLFW_VERSION_UNAVAILABLE,
                         "OSMesa: Failed to create context");
-        return GLFW_FALSE;
+        return false;
     }
 
     window->context.makeCurrent = makeContextCurrentOSMesa;
@@ -280,7 +280,7 @@ GLFWbool _glfwCreateContextOSMesa(_GLFWwindow* window,
     window->context.getProcAddress = getProcAddressOSMesa;
     window->context.destroy = destroyContextOSMesa;
 
-    return GLFW_TRUE;
+    return true;
 }
 
 #undef setAttrib
@@ -298,7 +298,7 @@ GLFWAPI int glfwGetOSMesaColorBuffer(GLFWwindow* handle, int* width,
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
-    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
+    _GLFW_REQUIRE_INIT_OR_RETURN(false);
 
     if (!OSMesaGetColorBuffer(window->context.osmesa.handle,
                               &mesaWidth, &mesaHeight,
@@ -306,7 +306,7 @@ GLFWAPI int glfwGetOSMesaColorBuffer(GLFWwindow* handle, int* width,
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "OSMesa: Failed to retrieve color buffer");
-        return GLFW_FALSE;
+        return false;
     }
 
     if (width)
@@ -318,7 +318,7 @@ GLFWAPI int glfwGetOSMesaColorBuffer(GLFWwindow* handle, int* width,
     if (buffer)
         *buffer = mesaBuffer;
 
-    return GLFW_TRUE;
+    return true;
 }
 
 GLFWAPI int glfwGetOSMesaDepthBuffer(GLFWwindow* handle,
@@ -331,7 +331,7 @@ GLFWAPI int glfwGetOSMesaDepthBuffer(GLFWwindow* handle,
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
-    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
+    _GLFW_REQUIRE_INIT_OR_RETURN(false);
 
     if (!OSMesaGetDepthBuffer(window->context.osmesa.handle,
                               &mesaWidth, &mesaHeight,
@@ -339,7 +339,7 @@ GLFWAPI int glfwGetOSMesaDepthBuffer(GLFWwindow* handle,
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "OSMesa: Failed to retrieve depth buffer");
-        return GLFW_FALSE;
+        return false;
     }
 
     if (width)
@@ -351,7 +351,7 @@ GLFWAPI int glfwGetOSMesaDepthBuffer(GLFWwindow* handle,
     if (buffer)
         *buffer = mesaBuffer;
 
-    return GLFW_TRUE;
+    return true;
 }
 
 GLFWAPI OSMesaContext glfwGetOSMesaContext(GLFWwindow* handle)

glfw/osmesa_context.h

@@ -86,9 +86,9 @@ typedef struct _GLFWlibraryOSMesa
 } _GLFWlibraryOSMesa;
 
 
-GLFWbool _glfwInitOSMesa(void);
+bool _glfwInitOSMesa(void);
 void _glfwTerminateOSMesa(void);
-GLFWbool _glfwCreateContextOSMesa(_GLFWwindow* window,
+bool _glfwCreateContextOSMesa(_GLFWwindow* window,
                                   const _GLFWctxconfig* ctxconfig,
                                   const _GLFWfbconfig* fbconfig);
 

glfw/posix_thread.c

@@ -35,19 +35,19 @@
 //////                       GLFW platform API                      //////
 //////////////////////////////////////////////////////////////////////////
 
-GLFWbool _glfwPlatformCreateTls(_GLFWtls* tls)
+bool _glfwPlatformCreateTls(_GLFWtls* tls)
 {
-    assert(tls->posix.allocated == GLFW_FALSE);
+    assert(tls->posix.allocated == false);
 
     if (pthread_key_create(&tls->posix.key, NULL) != 0)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "POSIX: Failed to create context TLS");
-        return GLFW_FALSE;
+        return false;
     }
 
-    tls->posix.allocated = GLFW_TRUE;
-    return GLFW_TRUE;
+    tls->posix.allocated = true;
+    return true;
 }
 
 void _glfwPlatformDestroyTls(_GLFWtls* tls)
@@ -59,27 +59,27 @@ void _glfwPlatformDestroyTls(_GLFWtls* tls)
 
 void* _glfwPlatformGetTls(_GLFWtls* tls)
 {
-    assert(tls->posix.allocated == GLFW_TRUE);
+    assert(tls->posix.allocated == true);
     return pthread_getspecific(tls->posix.key);
 }
 
 void _glfwPlatformSetTls(_GLFWtls* tls, void* value)
 {
-    assert(tls->posix.allocated == GLFW_TRUE);
+    assert(tls->posix.allocated == true);
     pthread_setspecific(tls->posix.key, value);
 }
 
-GLFWbool _glfwPlatformCreateMutex(_GLFWmutex* mutex)
+bool _glfwPlatformCreateMutex(_GLFWmutex* mutex)
 {
-    assert(mutex->posix.allocated == GLFW_FALSE);
+    assert(mutex->posix.allocated == false);
 
     if (pthread_mutex_init(&mutex->posix.handle, NULL) != 0)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR, "POSIX: Failed to create mutex");
-        return GLFW_FALSE;
+        return false;
     }
 
-    return mutex->posix.allocated = GLFW_TRUE;
+    return mutex->posix.allocated = true;
 }
 
 void _glfwPlatformDestroyMutex(_GLFWmutex* mutex)
@@ -91,13 +91,13 @@ void _glfwPlatformDestroyMutex(_GLFWmutex* mutex)
 
 void _glfwPlatformLockMutex(_GLFWmutex* mutex)
 {
-    assert(mutex->posix.allocated == GLFW_TRUE);
+    assert(mutex->posix.allocated == true);
     pthread_mutex_lock(&mutex->posix.handle);
 }
 
 void _glfwPlatformUnlockMutex(_GLFWmutex* mutex)
 {
-    assert(mutex->posix.allocated == GLFW_TRUE);
+    assert(mutex->posix.allocated == true);
     pthread_mutex_unlock(&mutex->posix.handle);
 }
 

glfw/posix_thread.h

@@ -35,7 +35,7 @@
 //
 typedef struct _GLFWtlsPOSIX
 {
-    GLFWbool        allocated;
+    bool        allocated;
     pthread_key_t   key;
 
 } _GLFWtlsPOSIX;
@@ -44,7 +44,7 @@ typedef struct _GLFWtlsPOSIX
 //
 typedef struct _GLFWmutexPOSIX
 {
-    GLFWbool        allocated;
+    bool        allocated;
     pthread_mutex_t handle;
 
 } _GLFWmutexPOSIX;

glfw/posix_time.c

@@ -44,13 +44,13 @@ void _glfwInitTimerPOSIX(void)
 
     if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0)
     {
-        _glfw.timer.posix.monotonic = GLFW_TRUE;
+        _glfw.timer.posix.monotonic = true;
         _glfw.timer.posix.frequency = 1000000000;
     }
     else
 #endif
     {
-        _glfw.timer.posix.monotonic = GLFW_FALSE;
+        _glfw.timer.posix.monotonic = false;
         _glfw.timer.posix.frequency = 1000000;
     }
 }

glfw/posix_time.h

@@ -34,7 +34,7 @@
 //
 typedef struct _GLFWtimerPOSIX
 {
-    GLFWbool    monotonic;
+    bool    monotonic;
     uint64_t    frequency;
 
 } _GLFWtimerPOSIX;

glfw/vulkan.c

@@ -39,14 +39,14 @@
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
 
-GLFWbool _glfwInitVulkan(int mode)
+bool _glfwInitVulkan(int mode)
 {
     VkResult err;
     VkExtensionProperties* ep;
     uint32_t i, count;
 
     if (_glfw.vk.available)
-        return GLFW_TRUE;
+        return true;
 
 #if !defined(_GLFW_VULKAN_STATIC)
 #if defined(_GLFW_VULKAN_LIBRARY)
@@ -63,7 +63,7 @@ GLFWbool _glfwInitVulkan(int mode)
         if (mode == _GLFW_REQUIRE_LOADER)
             _glfwInputError(GLFW_API_UNAVAILABLE, "Vulkan: Loader not found");
 
-        return GLFW_FALSE;
+        return false;
     }
 
     _glfw.vk.GetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)
@@ -74,7 +74,7 @@ GLFWbool _glfwInitVulkan(int mode)
                         "Vulkan: Loader does not export vkGetInstanceProcAddr");
 
         _glfwTerminateVulkan();
-        return GLFW_FALSE;
+        return false;
     }
 
     _glfw.vk.EnumerateInstanceExtensionProperties = (PFN_vkEnumerateInstanceExtensionProperties)
@@ -85,7 +85,7 @@ GLFWbool _glfwInitVulkan(int mode)
                         "Vulkan: Failed to retrieve vkEnumerateInstanceExtensionProperties");
 
         _glfwTerminateVulkan();
-        return GLFW_FALSE;
+        return false;
     }
 #endif // _GLFW_VULKAN_STATIC
 
@@ -101,7 +101,7 @@ GLFWbool _glfwInitVulkan(int mode)
         }
 
         _glfwTerminateVulkan();
-        return GLFW_FALSE;
+        return false;
     }
 
     ep = calloc(count, sizeof(VkExtensionProperties));
@@ -115,37 +115,37 @@ GLFWbool _glfwInitVulkan(int mode)
 
         free(ep);
         _glfwTerminateVulkan();
-        return GLFW_FALSE;
+        return false;
     }
 
     for (i = 0;  i < count;  i++)
     {
         if (strcmp(ep[i].extensionName, "VK_KHR_surface") == 0)
-            _glfw.vk.KHR_surface = GLFW_TRUE;
+            _glfw.vk.KHR_surface = true;
 #if defined(_GLFW_WIN32)
         else if (strcmp(ep[i].extensionName, "VK_KHR_win32_surface") == 0)
-            _glfw.vk.KHR_win32_surface = GLFW_TRUE;
+            _glfw.vk.KHR_win32_surface = true;
 #elif defined(_GLFW_COCOA)
         else if (strcmp(ep[i].extensionName, "VK_MVK_macos_surface") == 0)
-            _glfw.vk.MVK_macos_surface = GLFW_TRUE;
+            _glfw.vk.MVK_macos_surface = true;
 #elif defined(_GLFW_X11)
         else if (strcmp(ep[i].extensionName, "VK_KHR_xlib_surface") == 0)
-            _glfw.vk.KHR_xlib_surface = GLFW_TRUE;
+            _glfw.vk.KHR_xlib_surface = true;
         else if (strcmp(ep[i].extensionName, "VK_KHR_xcb_surface") == 0)
-            _glfw.vk.KHR_xcb_surface = GLFW_TRUE;
+            _glfw.vk.KHR_xcb_surface = true;
 #elif defined(_GLFW_WAYLAND)
         else if (strcmp(ep[i].extensionName, "VK_KHR_wayland_surface") == 0)
-            _glfw.vk.KHR_wayland_surface = GLFW_TRUE;
+            _glfw.vk.KHR_wayland_surface = true;
 #endif
     }
 
     free(ep);
 
-    _glfw.vk.available = GLFW_TRUE;
+    _glfw.vk.available = true;
 
     _glfwPlatformGetRequiredInstanceExtensions(_glfw.vk.extensions);
 
-    return GLFW_TRUE;
+    return true;
 }
 
 void _glfwTerminateVulkan(void)
@@ -218,7 +218,7 @@ const char* _glfwGetVulkanResultString(VkResult result)
 
 GLFWAPI int glfwVulkanSupported(void)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
+    _GLFW_REQUIRE_INIT_OR_RETURN(false);
     return _glfwInitVulkan(_GLFW_FIND_LOADER);
 }
 
@@ -273,16 +273,16 @@ GLFWAPI int glfwGetPhysicalDevicePresentationSupport(VkInstance instance,
     assert(instance != VK_NULL_HANDLE);
     assert(device != VK_NULL_HANDLE);
 
-    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
+    _GLFW_REQUIRE_INIT_OR_RETURN(false);
 
     if (!_glfwInitVulkan(_GLFW_REQUIRE_LOADER))
-        return GLFW_FALSE;
+        return false;
 
     if (!_glfw.vk.extensions[0])
     {
         _glfwInputError(GLFW_API_UNAVAILABLE,
                         "Vulkan: Window surface creation extensions not found");
-        return GLFW_FALSE;
+        return false;
     }
 
     return _glfwPlatformGetPhysicalDevicePresentationSupport(instance,

glfw/wgl_context.c

@@ -122,9 +122,9 @@ static int choosePixelFormat(_GLFWwindow* window,
             u->auxBuffers = getPixelFormatAttrib(window, n, WGL_AUX_BUFFERS_ARB);
 
             if (getPixelFormatAttrib(window, n, WGL_STEREO_ARB))
-                u->stereo = GLFW_TRUE;
+                u->stereo = true;
             if (getPixelFormatAttrib(window, n, WGL_DOUBLE_BUFFER_ARB))
-                u->doublebuffer = GLFW_TRUE;
+                u->doublebuffer = true;
 
             if (_glfw.wgl.ARB_multisample)
                 u->samples = getPixelFormatAttrib(window, n, WGL_SAMPLES_ARB);
@@ -135,7 +135,7 @@ static int choosePixelFormat(_GLFWwindow* window,
                     _glfw.wgl.EXT_framebuffer_sRGB)
                 {
                     if (getPixelFormatAttrib(window, n, WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB))
-                        u->sRGB = GLFW_TRUE;
+                        u->sRGB = true;
                 }
             }
             else
@@ -145,7 +145,7 @@ static int choosePixelFormat(_GLFWwindow* window,
                     if (getPixelFormatAttrib(window, n, WGL_COLORSPACE_EXT) ==
                         WGL_COLORSPACE_SRGB_EXT)
                     {
-                        u->sRGB = GLFW_TRUE;
+                        u->sRGB = true;
                     }
                 }
             }
@@ -195,9 +195,9 @@ static int choosePixelFormat(_GLFWwindow* window,
             u->auxBuffers = pfd.cAuxBuffers;
 
             if (pfd.dwFlags & PFD_STEREO)
-                u->stereo = GLFW_TRUE;
+                u->stereo = true;
             if (pfd.dwFlags & PFD_DOUBLEBUFFER)
-                u->doublebuffer = GLFW_TRUE;
+                u->doublebuffer = true;
         }
 
         u->handle = n;
@@ -308,7 +308,7 @@ static int extensionSupportedWGL(const char* extension)
         if (extensions)
         {
             if (_glfwStringInExtensionString(extension, extensions))
-                return GLFW_TRUE;
+                return true;
         }
     }
 
@@ -318,11 +318,11 @@ static int extensionSupportedWGL(const char* extension)
         if (extensions)
         {
             if (_glfwStringInExtensionString(extension, extensions))
-                return GLFW_TRUE;
+                return true;
         }
     }
 
-    return GLFW_FALSE;
+    return false;
 }
 
 static GLFWglproc getProcAddressWGL(const char* procname)
@@ -352,21 +352,21 @@ static void destroyContextWGL(_GLFWwindow* window)
 
 // Initialize WGL
 //
-GLFWbool _glfwInitWGL(void)
+bool _glfwInitWGL(void)
 {
     PIXELFORMATDESCRIPTOR pfd;
     HGLRC prc, rc;
     HDC pdc, dc;
 
     if (_glfw.wgl.instance)
-        return GLFW_TRUE;
+        return true;
 
     _glfw.wgl.instance = LoadLibraryA("opengl32.dll");
     if (!_glfw.wgl.instance)
     {
         _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
                              "WGL: Failed to load opengl32.dll");
-        return GLFW_FALSE;
+        return false;
     }
 
     _glfw.wgl.CreateContext = (PFN_wglCreateContext)
@@ -402,7 +402,7 @@ GLFWbool _glfwInitWGL(void)
     {
         _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
                              "WGL: Failed to set pixel format for dummy context");
-        return GLFW_FALSE;
+        return false;
     }
 
     rc = wglCreateContext(dc);
@@ -410,7 +410,7 @@ GLFWbool _glfwInitWGL(void)
     {
         _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
                              "WGL: Failed to create dummy context");
-        return GLFW_FALSE;
+        return false;
     }
 
     pdc = wglGetCurrentDC();
@@ -422,7 +422,7 @@ GLFWbool _glfwInitWGL(void)
                              "WGL: Failed to make dummy context current");
         wglMakeCurrent(pdc, prc);
         wglDeleteContext(rc);
-        return GLFW_FALSE;
+        return false;
     }
 
     // NOTE: Functions must be loaded first as they're needed to retrieve the
@@ -467,7 +467,7 @@ GLFWbool _glfwInitWGL(void)
 
     wglMakeCurrent(pdc, prc);
     wglDeleteContext(rc);
-    return GLFW_TRUE;
+    return true;
 }
 
 // Terminate WGL
@@ -487,7 +487,7 @@ void _glfwTerminateWGL(void)
 
 // Create the OpenGL or OpenGL ES context
 //
-GLFWbool _glfwCreateContextWGL(_GLFWwindow* window,
+bool _glfwCreateContextWGL(_GLFWwindow* window,
                                const _GLFWctxconfig* ctxconfig,
                                const _GLFWfbconfig* fbconfig)
 {
@@ -504,26 +504,26 @@ GLFWbool _glfwCreateContextWGL(_GLFWwindow* window,
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "WGL: Failed to retrieve DC for window");
-        return GLFW_FALSE;
+        return false;
     }
 
     pixelFormat = choosePixelFormat(window, ctxconfig, fbconfig);
     if (!pixelFormat)
-        return GLFW_FALSE;
+        return false;
 
     if (!DescribePixelFormat(window->context.wgl.dc,
                              pixelFormat, sizeof(pfd), &pfd))
     {
         _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
                              "WGL: Failed to retrieve PFD for selected pixel format");
-        return GLFW_FALSE;
+        return false;
     }
 
     if (!SetPixelFormat(window->context.wgl.dc, pixelFormat, &pfd))
     {
         _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
                              "WGL: Failed to set selected pixel format");
-        return GLFW_FALSE;
+        return false;
     }
 
     if (ctxconfig->client == GLFW_OPENGL_API)
@@ -534,7 +534,7 @@ GLFWbool _glfwCreateContextWGL(_GLFWwindow* window,
             {
                 _glfwInputError(GLFW_VERSION_UNAVAILABLE,
                                 "WGL: A forward compatible OpenGL context requested but WGL_ARB_create_context is unavailable");
-                return GLFW_FALSE;
+                return false;
             }
         }
 
@@ -544,7 +544,7 @@ GLFWbool _glfwCreateContextWGL(_GLFWwindow* window,
             {
                 _glfwInputError(GLFW_VERSION_UNAVAILABLE,
                                 "WGL: OpenGL profile requested but WGL_ARB_create_context_profile is unavailable");
-                return GLFW_FALSE;
+                return false;
             }
         }
     }
@@ -556,7 +556,7 @@ GLFWbool _glfwCreateContextWGL(_GLFWwindow* window,
         {
             _glfwInputError(GLFW_API_UNAVAILABLE,
                             "WGL: OpenGL ES requested but WGL_ARB_create_context_es2_profile is unavailable");
-            return GLFW_FALSE;
+            return false;
         }
     }
 
@@ -619,7 +619,7 @@ GLFWbool _glfwCreateContextWGL(_GLFWwindow* window,
         if (ctxconfig->noerror)
         {
             if (_glfw.wgl.ARB_create_context_no_error)
-                setAttrib(WGL_CONTEXT_OPENGL_NO_ERROR_ARB, GLFW_TRUE);
+                setAttrib(WGL_CONTEXT_OPENGL_NO_ERROR_ARB, true);
         }
 
         // NOTE: Only request an explicitly versioned context when necessary, as
@@ -687,7 +687,7 @@ GLFWbool _glfwCreateContextWGL(_GLFWwindow* window,
                 }
             }
 
-            return GLFW_FALSE;
+            return false;
         }
     }
     else
@@ -697,7 +697,7 @@ GLFWbool _glfwCreateContextWGL(_GLFWwindow* window,
         {
             _glfwInputErrorWin32(GLFW_VERSION_UNAVAILABLE,
                                  "WGL: Failed to create OpenGL context");
-            return GLFW_FALSE;
+            return false;
         }
 
         if (share)
@@ -706,7 +706,7 @@ GLFWbool _glfwCreateContextWGL(_GLFWwindow* window,
             {
                 _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
                                      "WGL: Failed to enable sharing with specified OpenGL context");
-                return GLFW_FALSE;
+                return false;
             }
         }
     }
@@ -718,7 +718,7 @@ GLFWbool _glfwCreateContextWGL(_GLFWwindow* window,
     window->context.getProcAddress = getProcAddressWGL;
     window->context.destroy = destroyContextWGL;
 
-    return GLFW_TRUE;
+    return true;
 }
 
 #undef setAttrib

glfw/wgl_context.h

@@ -135,25 +135,25 @@ typedef struct _GLFWlibraryWGL
     PFNWGLGETEXTENSIONSSTRINGEXTPROC    GetExtensionsStringEXT;
     PFNWGLGETEXTENSIONSSTRINGARBPROC    GetExtensionsStringARB;
     PFNWGLCREATECONTEXTATTRIBSARBPROC   CreateContextAttribsARB;
-    GLFWbool                            EXT_swap_control;
-    GLFWbool                            EXT_colorspace;
-    GLFWbool                            ARB_multisample;
-    GLFWbool                            ARB_framebuffer_sRGB;
-    GLFWbool                            EXT_framebuffer_sRGB;
-    GLFWbool                            ARB_pixel_format;
-    GLFWbool                            ARB_create_context;
-    GLFWbool                            ARB_create_context_profile;
-    GLFWbool                            EXT_create_context_es2_profile;
-    GLFWbool                            ARB_create_context_robustness;
-    GLFWbool                            ARB_create_context_no_error;
-    GLFWbool                            ARB_context_flush_control;
+    bool                            EXT_swap_control;
+    bool                            EXT_colorspace;
+    bool                            ARB_multisample;
+    bool                            ARB_framebuffer_sRGB;
+    bool                            EXT_framebuffer_sRGB;
+    bool                            ARB_pixel_format;
+    bool                            ARB_create_context;
+    bool                            ARB_create_context_profile;
+    bool                            EXT_create_context_es2_profile;
+    bool                            ARB_create_context_robustness;
+    bool                            ARB_create_context_no_error;
+    bool                            ARB_context_flush_control;
 
 } _GLFWlibraryWGL;
 
 
-GLFWbool _glfwInitWGL(void);
+bool _glfwInitWGL(void);
 void _glfwTerminateWGL(void);
-GLFWbool _glfwCreateContextWGL(_GLFWwindow* window,
+bool _glfwCreateContextWGL(_GLFWwindow* window,
                                const _GLFWctxconfig* ctxconfig,
                                const _GLFWfbconfig* fbconfig);
 

glfw/window.c

@@ -40,7 +40,7 @@
 
 // Notifies shared code that a window has lost or received input focus
 //
-void _glfwInputWindowFocus(_GLFWwindow* window, GLFWbool focused)
+void _glfwInputWindowFocus(_GLFWwindow* window, bool focused)
 {
     if (window->callbacks.focus)
         window->callbacks.focus((GLFWwindow*) window, focused);
@@ -90,7 +90,7 @@ _GLFWwindow* _glfwWindowForId(GLFWid id) {
 
 // Notifies shared code that a window's occlusion state has changed
 //
-void _glfwInputWindowOcclusion(_GLFWwindow* window, GLFWbool occluded)
+void _glfwInputWindowOcclusion(_GLFWwindow* window, bool occluded)
 {
     if (window->callbacks.occlusion)
         window->callbacks.occlusion((GLFWwindow*) window, occluded);
@@ -116,7 +116,7 @@ void _glfwInputWindowSize(_GLFWwindow* window, int width, int height)
 
 // Notifies shared code that a window has been iconified or restored
 //
-void _glfwInputWindowIconify(_GLFWwindow* window, GLFWbool iconified)
+void _glfwInputWindowIconify(_GLFWwindow* window, bool iconified)
 {
     if (window->callbacks.iconify)
         window->callbacks.iconify((GLFWwindow*) window, iconified);
@@ -124,7 +124,7 @@ void _glfwInputWindowIconify(_GLFWwindow* window, GLFWbool iconified)
 
 // Notifies shared code that a window has been maximized or restored
 //
-void _glfwInputWindowMaximize(_GLFWwindow* window, GLFWbool maximized)
+void _glfwInputWindowMaximize(_GLFWwindow* window, bool maximized)
 {
     if (window->callbacks.maximize)
         window->callbacks.maximize((GLFWwindow*) window, maximized);
@@ -168,7 +168,7 @@ void _glfwInputWindowDamage(_GLFWwindow* window)
 //
 void _glfwInputWindowCloseRequest(_GLFWwindow* window)
 {
-    window->shouldClose = GLFW_TRUE;
+    window->shouldClose = true;
 
     if (window->callbacks.close)
         window->callbacks.close((GLFWwindow*) window);
@@ -300,13 +300,13 @@ void glfwDefaultWindowHints(void)
 
     // The default is a focused, visible, resizable window with decorations
     memset(&_glfw.hints.window, 0, sizeof(_glfw.hints.window));
-    _glfw.hints.window.resizable    = GLFW_TRUE;
-    _glfw.hints.window.visible      = GLFW_TRUE;
-    _glfw.hints.window.decorated    = GLFW_TRUE;
-    _glfw.hints.window.focused      = GLFW_TRUE;
-    _glfw.hints.window.autoIconify  = GLFW_TRUE;
-    _glfw.hints.window.centerCursor = GLFW_TRUE;
-    _glfw.hints.window.focusOnShow  = GLFW_TRUE;
+    _glfw.hints.window.resizable    = true;
+    _glfw.hints.window.visible      = true;
+    _glfw.hints.window.decorated    = true;
+    _glfw.hints.window.focused      = true;
+    _glfw.hints.window.autoIconify  = true;
+    _glfw.hints.window.centerCursor = true;
+    _glfw.hints.window.focusOnShow  = true;
 
     // The default is 24 bits of color, 24 bits of depth and 8 bits of stencil,
     // double buffered
@@ -317,13 +317,13 @@ void glfwDefaultWindowHints(void)
     _glfw.hints.framebuffer.alphaBits    = 8;
     _glfw.hints.framebuffer.depthBits    = 24;
     _glfw.hints.framebuffer.stencilBits  = 8;
-    _glfw.hints.framebuffer.doublebuffer = GLFW_TRUE;
+    _glfw.hints.framebuffer.doublebuffer = true;
 
     // The default is to select the highest available refresh rate
     _glfw.hints.refreshRate = GLFW_DONT_CARE;
 
     // The default is to use full Retina resolution framebuffers
-    _glfw.hints.window.ns.retina = GLFW_TRUE;
+    _glfw.hints.window.ns.retina = true;
 }
 
 GLFWAPI void glfwWindowHint(int hint, int value)
@@ -366,55 +366,55 @@ GLFWAPI void glfwWindowHint(int hint, int value)
             _glfw.hints.framebuffer.auxBuffers = value;
             return;
         case GLFW_STEREO:
-            _glfw.hints.framebuffer.stereo = value ? GLFW_TRUE : GLFW_FALSE;
+            _glfw.hints.framebuffer.stereo = value ? true : false;
             return;
         case GLFW_DOUBLEBUFFER:
-            _glfw.hints.framebuffer.doublebuffer = value ? GLFW_TRUE : GLFW_FALSE;
+            _glfw.hints.framebuffer.doublebuffer = value ? true : false;
             return;
         case GLFW_TRANSPARENT_FRAMEBUFFER:
-            _glfw.hints.framebuffer.transparent = value ? GLFW_TRUE : GLFW_FALSE;
+            _glfw.hints.framebuffer.transparent = value ? true : false;
             return;
         case GLFW_SAMPLES:
             _glfw.hints.framebuffer.samples = value;
             return;
         case GLFW_SRGB_CAPABLE:
-            _glfw.hints.framebuffer.sRGB = value ? GLFW_TRUE : GLFW_FALSE;
+            _glfw.hints.framebuffer.sRGB = value ? true : false;
             return;
         case GLFW_RESIZABLE:
-            _glfw.hints.window.resizable = value ? GLFW_TRUE : GLFW_FALSE;
+            _glfw.hints.window.resizable = value ? true : false;
             return;
         case GLFW_DECORATED:
-            _glfw.hints.window.decorated = value ? GLFW_TRUE : GLFW_FALSE;
+            _glfw.hints.window.decorated = value ? true : false;
             return;
         case GLFW_FOCUSED:
-            _glfw.hints.window.focused = value ? GLFW_TRUE : GLFW_FALSE;
+            _glfw.hints.window.focused = value ? true : false;
             return;
         case GLFW_AUTO_ICONIFY:
-            _glfw.hints.window.autoIconify = value ? GLFW_TRUE : GLFW_FALSE;
+            _glfw.hints.window.autoIconify = value ? true : false;
             return;
         case GLFW_FLOATING:
-            _glfw.hints.window.floating = value ? GLFW_TRUE : GLFW_FALSE;
+            _glfw.hints.window.floating = value ? true : false;
             return;
         case GLFW_MAXIMIZED:
-            _glfw.hints.window.maximized = value ? GLFW_TRUE : GLFW_FALSE;
+            _glfw.hints.window.maximized = value ? true : false;
             return;
         case GLFW_VISIBLE:
-            _glfw.hints.window.visible = value ? GLFW_TRUE : GLFW_FALSE;
+            _glfw.hints.window.visible = value ? true : false;
             return;
         case GLFW_COCOA_RETINA_FRAMEBUFFER:
-            _glfw.hints.window.ns.retina = value ? GLFW_TRUE : GLFW_FALSE;
+            _glfw.hints.window.ns.retina = value ? true : false;
             return;
         case GLFW_COCOA_GRAPHICS_SWITCHING:
-            _glfw.hints.context.nsgl.offline = value ? GLFW_TRUE : GLFW_FALSE;
+            _glfw.hints.context.nsgl.offline = value ? true : false;
             return;
         case GLFW_SCALE_TO_MONITOR:
-            _glfw.hints.window.scaleToMonitor = value ? GLFW_TRUE : GLFW_FALSE;
+            _glfw.hints.window.scaleToMonitor = value ? true : false;
             return;
         case GLFW_CENTER_CURSOR:
-            _glfw.hints.window.centerCursor = value ? GLFW_TRUE : GLFW_FALSE;
+            _glfw.hints.window.centerCursor = value ? true : false;
             return;
         case GLFW_FOCUS_ON_SHOW:
-            _glfw.hints.window.focusOnShow = value ? GLFW_TRUE : GLFW_FALSE;
+            _glfw.hints.window.focusOnShow = value ? true : false;
             return;
         case GLFW_CLIENT_API:
             _glfw.hints.context.client = value;
@@ -432,13 +432,13 @@ GLFWAPI void glfwWindowHint(int hint, int value)
             _glfw.hints.context.robustness = value;
             return;
         case GLFW_OPENGL_FORWARD_COMPAT:
-            _glfw.hints.context.forward = value ? GLFW_TRUE : GLFW_FALSE;
+            _glfw.hints.context.forward = value ? true : false;
             return;
         case GLFW_OPENGL_DEBUG_CONTEXT:
-            _glfw.hints.context.debug = value ? GLFW_TRUE : GLFW_FALSE;
+            _glfw.hints.context.debug = value ? true : false;
             return;
         case GLFW_CONTEXT_NO_ERROR:
-            _glfw.hints.context.noerror = value ? GLFW_TRUE : GLFW_FALSE;
+            _glfw.hints.context.noerror = value ? true : false;
             return;
         case GLFW_OPENGL_PROFILE:
             _glfw.hints.context.profile = value;
@@ -836,7 +836,7 @@ GLFWAPI int glfwWindowBell(GLFWwindow* handle)
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
-    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
+    _GLFW_REQUIRE_INIT_OR_RETURN(false);
 
     return _glfwPlatformWindowBell(window);
 }
@@ -932,7 +932,7 @@ GLFWAPI void glfwSetWindowAttrib(GLFWwindow* handle, int attrib, int value)
 
     _GLFW_REQUIRE_INIT();
 
-    value = value ? GLFW_TRUE : GLFW_FALSE;
+    value = value ? true : false;
 
     if (attrib == GLFW_AUTO_ICONIFY)
         window->autoIconify = value;

glfw/wl_init.c

@@ -103,10 +103,10 @@ static void pointerHandleEnter(void* data,
     _glfw.wl.pointerSerial = serial;
     _glfw.wl.pointerFocus = window;
 
-    window->wl.hovered = GLFW_TRUE;
+    window->wl.hovered = true;
 
     _glfwPlatformSetCursor(window, window->wl.currentCursor);
-    _glfwInputCursorEnter(window, GLFW_TRUE);
+    _glfwInputCursorEnter(window, true);
 }
 
 static void pointerHandleLeave(void* data,
@@ -119,11 +119,11 @@ static void pointerHandleLeave(void* data,
     if (!window)
         return;
 
-    window->wl.hovered = GLFW_FALSE;
+    window->wl.hovered = false;
 
     _glfw.wl.pointerSerial = serial;
     _glfw.wl.pointerFocus = NULL;
-    _glfwInputCursorEnter(window, GLFW_FALSE);
+    _glfwInputCursorEnter(window, false);
 }
 
 static void setCursor(GLFWCursorShape shape)
@@ -168,18 +168,13 @@ static void pointerHandleMotion(void* data,
 
     if (window->cursorMode == GLFW_CURSOR_DISABLED)
         return;
-    else
-    {
-        window->wl.cursorPosX = wl_fixed_to_double(sx);
-        window->wl.cursorPosY = wl_fixed_to_double(sy);
-    }
+    window->wl.cursorPosX = wl_fixed_to_double(sx);
+    window->wl.cursorPosY = wl_fixed_to_double(sy);
 
     switch (window->wl.decorations.focus)
     {
         case mainWindow:
-            _glfwInputCursorPos(window,
-                                wl_fixed_to_double(sx),
-                                wl_fixed_to_double(sy));
+            _glfwInputCursorPos(window, window->wl.cursorPosX, window->wl.cursorPosY);
             return;
         case topDecoration:
             if (window->wl.cursorPosY < _GLFW_DECORATION_WIDTH)
@@ -375,7 +370,7 @@ static void keyboardHandleEnter(void* data,
     }
 
     _glfw.wl.keyboardFocus = window;
-    _glfwInputWindowFocus(window, GLFW_TRUE);
+    _glfwInputWindowFocus(window, true);
 }
 
 static void keyboardHandleLeave(void* data,
@@ -389,7 +384,7 @@ static void keyboardHandleLeave(void* data,
         return;
 
     _glfw.wl.keyboardFocus = NULL;
-    _glfwInputWindowFocus(window, GLFW_FALSE);
+    _glfwInputWindowFocus(window, false);
 }
 
 static void
@@ -413,12 +408,12 @@ static void keyboardHandleKey(void* data,
         return;
     int action = state == WL_KEYBOARD_KEY_STATE_PRESSED ? GLFW_PRESS : GLFW_RELEASE;
     glfw_xkb_handle_key_event(window, &_glfw.wl.xkb, key, action);
-    GLFWbool repeatable = GLFW_FALSE;
+    bool repeatable = false;
 
     if (action == GLFW_PRESS && _glfw.wl.keyboardRepeatRate > 0 && glfw_xkb_should_repeat(&_glfw.wl.xkb, key))
     {
         _glfw.wl.keyRepeatInfo.key = key;
-        repeatable = GLFW_TRUE;
+        repeatable = true;
         _glfw.wl.keyRepeatInfo.keyboardFocus = window;
     }
     if (repeatable) {
@@ -618,14 +613,20 @@ static void registryHandleGlobalRemove(void *data,
                                        struct wl_registry *registry,
                                        uint32_t name)
 {
-    int i;
     _GLFWmonitor* monitor;
 
-    for (i = 0; i < _glfw.monitorCount; ++i)
+    for (int i = 0; i < _glfw.monitorCount; ++i)
     {
         monitor = _glfw.monitors[i];
         if (monitor->wl.name == name)
         {
+            for (_GLFWwindow *window = _glfw.windowListHead;  window;  window = window->next) {
+                for (int m = window->wl.monitorsCount - 1; m >= 0; m--) {
+                    if (window->wl.monitors[m] == monitor) {
+                        remove_i_from_array(window->wl.monitors, m, window->wl.monitorsCount);
+                    }
+                }
+            }
             _glfwInputMonitor(monitor, GLFW_DISCONNECTED, 0);
             return;
         }
@@ -639,6 +640,39 @@ static const struct wl_registry_listener registryListener = {
 };
 
 
+
+static void registry_handle_global(void* data,
+                                 struct wl_registry* registry,
+                                 uint32_t name,
+                                 const char* interface,
+                                 uint32_t version) {
+    if (strcmp(interface, "zxdg_decoration_manager_v1") == 0) {
+        bool *has_ssd = (bool*)data;
+        if (has_ssd) *has_ssd = true;
+    }
+}
+
+static void registry_handle_global_remove(void *data,
+                                       struct wl_registry *registry,
+                                       uint32_t name) {}
+GLFWAPI const char*
+glfwWaylandCheckForServerSideDecorations(void) {
+    struct wl_display *display = wl_display_connect(NULL);
+    if (!display) return "ERR: Failed to connect to Wayland display";
+    static const struct wl_registry_listener rl = {
+        registry_handle_global, registry_handle_global_remove
+    };
+    struct wl_registry *registry = wl_display_get_registry(display);
+    bool has_ssd = false;
+    wl_registry_add_listener(registry, &rl, &has_ssd);
+    wl_display_roundtrip(display);
+
+    wl_registry_destroy(registry);
+    wl_display_flush(display);
+    wl_display_flush(display);
+    return has_ssd ? "YES" : "NO";
+}
+
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW platform API                      //////
 //////////////////////////////////////////////////////////////////////////
@@ -649,7 +683,7 @@ int _glfwPlatformInit(void)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                 "Wayland: failed to create self pipe");
-        return GLFW_FALSE;
+        return false;
     }
 
     _glfw.wl.cursor.handle = _glfw_dlopen("libwayland-cursor.so.0");
@@ -657,7 +691,7 @@ int _glfwPlatformInit(void)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "Wayland: Failed to open libwayland-cursor");
-        return GLFW_FALSE;
+        return false;
     }
 
     _glfw.wl.cursor.theme_load = (PFN_wl_cursor_theme_load)
@@ -674,7 +708,7 @@ int _glfwPlatformInit(void)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "Wayland: Failed to open libwayland-egl");
-        return GLFW_FALSE;
+        return false;
     }
 
     _glfw.wl.egl.window_create = (PFN_wl_egl_window_create)
@@ -689,7 +723,7 @@ int _glfwPlatformInit(void)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "Wayland: Failed to connect to display");
-        return GLFW_FALSE;
+        return false;
     }
     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);
@@ -699,7 +733,7 @@ int _glfwPlatformInit(void)
     _glfw.wl.registry = wl_display_get_registry(_glfw.wl.display);
     wl_registry_add_listener(_glfw.wl.registry, &registryListener, NULL);
 
-    if (!glfw_xkb_create_context(&_glfw.wl.xkb)) return GLFW_FALSE;
+    if (!glfw_xkb_create_context(&_glfw.wl.xkb)) return false;
 
     // Sync so we got all registry objects
     wl_display_roundtrip(_glfw.wl.display);
@@ -710,7 +744,7 @@ int _glfwPlatformInit(void)
 #ifdef __linux__
     if (_glfw.hints.init.enableJoysticks) {
         if (!_glfwInitJoysticksLinux())
-            return GLFW_FALSE;
+            return false;
     }
 #endif
 
@@ -719,7 +753,7 @@ int _glfwPlatformInit(void)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "Wayland: Failed to find xdg-shell in your compositor");
-        return GLFW_FALSE;
+        return false;
     }
 
     if (_glfw.wl.shm)
@@ -739,13 +773,13 @@ int _glfwPlatformInit(void)
         {
             _glfwInputError(GLFW_PLATFORM_ERROR,
                             "Wayland: Unable to load default cursor theme");
-            return GLFW_FALSE;
+            return false;
         }
         _glfw.wl.cursorSurface =
             wl_compositor_create_surface(_glfw.wl.compositor);
     }
 
-    return GLFW_TRUE;
+    return true;
 }
 
 void _glfwPlatformTerminate(void)

glfw/wl_monitor.c

@@ -85,6 +85,9 @@ static void outputHandleMode(void* data,
 static void outputHandleDone(void* data, struct wl_output* output)
 {
     struct _GLFWmonitor *monitor = data;
+    for (int i = 0; i < _glfw.monitorCount; i++) {
+        if (_glfw.monitors[i] == monitor) return;
+    }
 
     _glfwInputMonitor(monitor, GLFW_CONNECTED, _GLFW_INSERT_LAST);
 }
@@ -193,11 +196,11 @@ void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode)
     *mode = monitor->modes[monitor->wl.currentMode];
 }
 
-GLFWbool _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
+bool _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
 {
     _glfwInputError(GLFW_PLATFORM_ERROR,
                     "Wayland: Gamma ramp access is not available");
-    return GLFW_FALSE;
+    return false;
 }
 
 void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)

glfw/wl_platform.h

@@ -133,10 +133,10 @@ typedef struct _GLFWdecorationWayland
 typedef struct _GLFWwindowWayland
 {
     int                         width, height;
-    GLFWbool                    visible;
-    GLFWbool                    maximized;
-    GLFWbool                    hovered;
-    GLFWbool                    transparent;
+    bool                    visible;
+    bool                    maximized;
+    bool                    hovered;
+    bool                    transparent;
     struct wl_surface*          surface;
     struct wl_egl_window*       native;
     struct wl_callback*         callback;
@@ -167,10 +167,10 @@ typedef struct _GLFWwindowWayland
 
     struct zwp_idle_inhibitor_v1*          idleInhibitor;
 
-    GLFWbool                    fullscreened;
+    bool                    fullscreened;
 
     struct {
-        GLFWbool                           serverSide;
+        bool                           serverSide;
         struct wl_buffer*                  buffer;
         _GLFWdecorationWayland             top, left, right, bottom;
         int                                focus;

glfw/wl_window.c

@@ -42,7 +42,7 @@
 #define URI_LIST_MIME "text/uri-list"
 
 
-static GLFWbool checkScaleChange(_GLFWwindow* window)
+static bool checkScaleChange(_GLFWwindow* window)
 {
     int scale = 1;
     int i;
@@ -50,7 +50,7 @@ static GLFWbool checkScaleChange(_GLFWwindow* window)
 
     // Check if we will be able to set the buffer scale or not.
     if (_glfw.wl.compositorVersion < 3)
-        return GLFW_FALSE;
+        return false;
 
     // Get the scale factor from the highest scale monitor.
     for (i = 0; i < window->wl.monitorsCount; ++i)
@@ -65,9 +65,9 @@ static GLFWbool checkScaleChange(_GLFWwindow* window)
     {
         window->wl.scale = scale;
         wl_surface_set_buffer_scale(window->wl.surface, scale);
-        return GLFW_TRUE;
+        return true;
     }
-    return GLFW_FALSE;
+    return false;
 }
 
 // Makes the surface considered as XRGB instead of ARGB.
@@ -137,8 +137,8 @@ clipboard_mime(void) {
 static void dispatchChangesAfterConfigure(_GLFWwindow *window, int32_t width, int32_t height) {
     if (width <= 0) width = window->wl.width;
     if (height <= 0) height = window->wl.height;
-    GLFWbool size_changed = width != window->wl.width || height != window->wl.height;
-    GLFWbool scale_changed = checkScaleChange(window);
+    bool size_changed = width != window->wl.width || height != window->wl.height;
+    bool scale_changed = checkScaleChange(window);
 
     if (size_changed) {
         _glfwInputWindowSize(window, width, height);
@@ -281,7 +281,7 @@ static struct wl_buffer* createShmBuffer(const GLFWimage* image)
 
 static void createDecoration(_GLFWdecorationWayland* decoration,
                              struct wl_surface* parent,
-                             struct wl_buffer* buffer, GLFWbool opaque,
+                             struct wl_buffer* buffer, bool opaque,
                              int x, int y,
                              int width, int height)
 {
@@ -313,7 +313,7 @@ static void createDecorations(_GLFWwindow* window)
 {
     unsigned char data[] = { 224, 224, 224, 255 };
     const GLFWimage image = { 1, 1, data };
-    GLFWbool opaque = (data[3] == 255);
+    bool opaque = (data[3] == 255);
 
     if (!_glfw.wl.viewporter || !window->decorated || window->wl.decorations.serverSide)
         return;
@@ -405,13 +405,13 @@ static void handleLeave(void *data,
 {
     _GLFWwindow* window = data;
     _GLFWmonitor* monitor = wl_output_get_user_data(output);
-    GLFWbool found;
+    bool found;
     int i;
 
-    for (i = 0, found = GLFW_FALSE; i < window->wl.monitorsCount - 1; ++i)
+    for (i = 0, found = false; i < window->wl.monitorsCount - 1; ++i)
     {
         if (monitor == window->wl.monitors[i])
-            found = GLFW_TRUE;
+            found = true;
         if (found)
             window->wl.monitors[i] = window->wl.monitors[i + 1];
     }
@@ -428,7 +428,7 @@ static const struct wl_surface_listener surfaceListener = {
     handleLeave
 };
 
-static void setIdleInhibitor(_GLFWwindow* window, GLFWbool enable)
+static void setIdleInhibitor(_GLFWwindow* window, bool enable)
 {
     if (enable && !window->wl.idleInhibitor && _glfw.wl.idleInhibitManager)
     {
@@ -446,12 +446,12 @@ static void setIdleInhibitor(_GLFWwindow* window, GLFWbool enable)
     }
 }
 
-static GLFWbool createSurface(_GLFWwindow* window,
+static bool createSurface(_GLFWwindow* window,
                               const _GLFWwndconfig* wndconfig)
 {
     window->wl.surface = wl_compositor_create_surface(_glfw.wl.compositor);
     if (!window->wl.surface)
-        return GLFW_FALSE;
+        return false;
 
     wl_surface_add_listener(window->wl.surface,
                             &surfaceListener,
@@ -463,7 +463,7 @@ static GLFWbool createSurface(_GLFWwindow* window,
                                              wndconfig->width,
                                              wndconfig->height);
     if (!window->wl.native)
-        return GLFW_FALSE;
+        return false;
 
     window->wl.width = wndconfig->width;
     window->wl.height = wndconfig->height;
@@ -472,7 +472,7 @@ static GLFWbool createSurface(_GLFWwindow* window,
     if (!window->wl.transparent)
         setOpaqueRegion(window);
 
-    return GLFW_TRUE;
+    return true;
 }
 
 static void
@@ -513,24 +513,24 @@ static void xdgToplevelHandleConfigure(void* data,
     float aspectRatio;
     float targetRatio;
     uint32_t* state;
-    GLFWbool maximized = GLFW_FALSE;
-    GLFWbool fullscreen = GLFW_FALSE;
-    GLFWbool activated = GLFW_FALSE;
+    bool maximized = false;
+    bool fullscreen = false;
+    bool activated = false;
 
     wl_array_for_each(state, states)
     {
         switch (*state)
         {
             case XDG_TOPLEVEL_STATE_MAXIMIZED:
-                maximized = GLFW_TRUE;
+                maximized = true;
                 break;
             case XDG_TOPLEVEL_STATE_FULLSCREEN:
-                fullscreen = GLFW_TRUE;
+                fullscreen = true;
                 break;
             case XDG_TOPLEVEL_STATE_RESIZING:
                 break;
             case XDG_TOPLEVEL_STATE_ACTIVATED:
-                activated = GLFW_TRUE;
+                activated = true;
                 break;
         }
     }
@@ -551,6 +551,12 @@ static void xdgToplevelHandleConfigure(void* data,
         }
     }
     window->wl.fullscreened = fullscreen;
+    if (!fullscreen) {
+        if (window->decorated && !window->wl.decorations.serverSide && window->wl.decorations.buffer) {
+            width -= _GLFW_DECORATION_HORIZONTAL;
+            height -= _GLFW_DECORATION_VERTICAL;
+        }
+    }
     dispatchChangesAfterConfigure(window, width, height);
     _glfwInputWindowFocus(window, activated);
 }
@@ -594,12 +600,12 @@ static void setXdgDecorations(_GLFWwindow* window)
     }
     else
     {
-        window->wl.decorations.serverSide = GLFW_FALSE;
+        window->wl.decorations.serverSide = false;
         createDecorations(window);
     }
 }
 
-static GLFWbool createXdgSurface(_GLFWwindow* window)
+static bool createXdgSurface(_GLFWwindow* window)
 {
     window->wl.xdg.surface = xdg_wm_base_get_xdg_surface(_glfw.wl.wmBase,
                                                          window->wl.surface);
@@ -607,7 +613,7 @@ static GLFWbool createXdgSurface(_GLFWwindow* window)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "Wayland: xdg-surface creation failed");
-        return GLFW_FALSE;
+        return false;
     }
 
     xdg_surface_add_listener(window->wl.xdg.surface,
@@ -619,7 +625,7 @@ static GLFWbool createXdgSurface(_GLFWwindow* window)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "Wayland: xdg-toplevel creation failed");
-        return GLFW_FALSE;
+        return false;
     }
 
     xdg_toplevel_add_listener(window->wl.xdg.toplevel,
@@ -640,17 +646,17 @@ static GLFWbool createXdgSurface(_GLFWwindow* window)
     {
         xdg_toplevel_set_fullscreen(window->wl.xdg.toplevel,
                                     window->monitor->wl.output);
-        setIdleInhibitor(window, GLFW_TRUE);
+        setIdleInhibitor(window, true);
     }
     else if (window->wl.maximized)
     {
         xdg_toplevel_set_maximized(window->wl.xdg.toplevel);
-        setIdleInhibitor(window, GLFW_FALSE);
+        setIdleInhibitor(window, false);
         setXdgDecorations(window);
     }
     else
     {
-        setIdleInhibitor(window, GLFW_FALSE);
+        setIdleInhibitor(window, false);
         setXdgDecorations(window);
     }
     if (strlen(window->wl.appId))
@@ -659,7 +665,7 @@ static GLFWbool createXdgSurface(_GLFWwindow* window)
     wl_surface_commit(window->wl.surface);
     wl_display_roundtrip(_glfw.wl.display);
 
-    return GLFW_TRUE;
+    return true;
 }
 
 static void
@@ -767,7 +773,7 @@ handleEvents(double timeout)
         return;
     }
 
-    GLFWbool display_read_ok = pollForEvents(&_glfw.wl.eventLoopData, timeout);
+    bool display_read_ok = pollForEvents(&_glfw.wl.eventLoopData, timeout);
     if (display_read_ok) {
         wl_display_read_events(display);
         wl_display_dispatch_pending(display);
@@ -795,13 +801,13 @@ try_cursor_names(int arg_count, ...) {
 
 struct wl_cursor* _glfwLoadCursor(GLFWCursorShape shape)
 {
-    static GLFWbool warnings[GLFW_INVALID_CURSOR] = {0};
+    static bool warnings[GLFW_INVALID_CURSOR] = {0};
 #define NUMARGS(...)  (sizeof((const char*[]){__VA_ARGS__})/sizeof(const char*))
 #define C(name, ...) case name: { \
     ans = try_cursor_names(NUMARGS(__VA_ARGS__), __VA_ARGS__); \
     if (!ans && !warnings[name]) {\
         _glfwInputError(GLFW_PLATFORM_ERROR, "Wayland: Could not find standard cursor: %s", #name); \
-        warnings[name] = GLFW_TRUE; \
+        warnings[name] = true; \
     } \
     break; }
 
@@ -839,7 +845,7 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
     strncpy(window->wl.appId, wndconfig->wl.appId, sizeof(window->wl.appId));
 
     if (!createSurface(window, wndconfig))
-        return GLFW_FALSE;
+        return false;
 
     if (ctxconfig->client != GLFW_NO_API)
     {
@@ -847,16 +853,16 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
             ctxconfig->source == GLFW_NATIVE_CONTEXT_API)
         {
             if (!_glfwInitEGL())
-                return GLFW_FALSE;
+                return false;
             if (!_glfwCreateContextEGL(window, ctxconfig, fbconfig))
-                return GLFW_FALSE;
+                return false;
         }
         else if (ctxconfig->source == GLFW_OSMESA_CONTEXT_API)
         {
             if (!_glfwInitOSMesa())
-                return GLFW_FALSE;
+                return false;
             if (!_glfwCreateContextOSMesa(window, ctxconfig, fbconfig))
-                return GLFW_FALSE;
+                return false;
         }
     }
 
@@ -866,15 +872,15 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
     if (wndconfig->visible)
     {
         if (!createXdgSurface(window))
-            return GLFW_FALSE;
+            return false;
 
-        window->wl.visible = GLFW_TRUE;
+        window->wl.visible = true;
     }
     else
     {
         window->wl.xdg.surface = NULL;
         window->wl.xdg.toplevel = NULL;
-        window->wl.visible = GLFW_FALSE;
+        window->wl.visible = false;
     }
 
     window->wl.currentCursor = NULL;
@@ -883,7 +889,7 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
     window->wl.monitorsCount = 0;
     window->wl.monitorsSize = 1;
 
-    return GLFW_TRUE;
+    return true;
 }
 
 void _glfwPlatformDestroyWindow(_GLFWwindow* window)
@@ -891,12 +897,12 @@ void _glfwPlatformDestroyWindow(_GLFWwindow* window)
     if (window == _glfw.wl.pointerFocus)
     {
         _glfw.wl.pointerFocus = NULL;
-        _glfwInputCursorEnter(window, GLFW_FALSE);
+        _glfwInputCursorEnter(window, false);
     }
     if (window == _glfw.wl.keyboardFocus)
     {
         _glfw.wl.keyboardFocus = NULL;
-        _glfwInputWindowFocus(window, GLFW_FALSE);
+        _glfwInputWindowFocus(window, false);
     }
 
     if (window->wl.idleInhibitor)
@@ -1057,7 +1063,7 @@ void _glfwPlatformRestoreWindow(_GLFWwindow* window)
         // minimized, so there is nothing to do in this case.
     }
     _glfwInputWindowMonitor(window, NULL);
-    window->wl.maximized = GLFW_FALSE;
+    window->wl.maximized = false;
 }
 
 void _glfwPlatformMaximizeWindow(_GLFWwindow* window)
@@ -1066,7 +1072,7 @@ void _glfwPlatformMaximizeWindow(_GLFWwindow* window)
     {
         xdg_toplevel_set_maximized(window->wl.xdg.toplevel);
     }
-    window->wl.maximized = GLFW_TRUE;
+    window->wl.maximized = true;
 }
 
 void _glfwPlatformShowWindow(_GLFWwindow* window)
@@ -1074,7 +1080,7 @@ void _glfwPlatformShowWindow(_GLFWwindow* window)
     if (!window->wl.visible)
     {
         createXdgSurface(window);
-        window->wl.visible = GLFW_TRUE;
+        window->wl.visible = true;
     }
 }
 
@@ -1087,17 +1093,17 @@ void _glfwPlatformHideWindow(_GLFWwindow* window)
         window->wl.xdg.toplevel = NULL;
         window->wl.xdg.surface = NULL;
     }
-    window->wl.visible = GLFW_FALSE;
+    window->wl.visible = false;
 }
 
 void _glfwPlatformRequestWindowAttention(_GLFWwindow* window)
 {
     // TODO
-    static GLFWbool notified = GLFW_FALSE;
+    static bool notified = false;
     if (!notified) {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "Wayland: Window attention request not implemented yet");
-        notified = GLFW_TRUE;
+        notified = true;
     }
 }
 
@@ -1107,11 +1113,11 @@ int _glfwPlatformWindowBell(_GLFWwindow* window)
     static char tty[L_ctermid + 1];
     int fd = open(ctermid(tty), O_WRONLY | O_CLOEXEC);
     if (fd > -1) {
-        int ret = write(fd, "\x07", 1) == 1 ? GLFW_TRUE : GLFW_FALSE;
+        int ret = write(fd, "\x07", 1) == 1 ? true : false;
         close(fd);
         return ret;
     }
-    return GLFW_FALSE;
+    return false;
 }
 
 void _glfwPlatformFocusWindow(_GLFWwindow* window)
@@ -1137,14 +1143,14 @@ int _glfwPlatformWindowFocused(_GLFWwindow* window)
 
 int _glfwPlatformWindowOccluded(_GLFWwindow* window)
 {
-    return GLFW_FALSE;
+    return false;
 }
 
 int _glfwPlatformWindowIconified(_GLFWwindow* window)
 {
     // xdg-shell doesn’t give any way to request whether a surface is
     // iconified.
-    return GLFW_FALSE;
+    return false;
 }
 
 int _glfwPlatformWindowVisible(_GLFWwindow* window)
@@ -1167,14 +1173,14 @@ int _glfwPlatformFramebufferTransparent(_GLFWwindow* window)
     return window->wl.transparent;
 }
 
-void _glfwPlatformSetWindowResizable(_GLFWwindow* window, GLFWbool enabled)
+void _glfwPlatformSetWindowResizable(_GLFWwindow* window, bool enabled)
 {
     // TODO
     _glfwInputError(GLFW_PLATFORM_ERROR,
                     "Wayland: Window attribute setting not implemented yet");
 }
 
-void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, GLFWbool enabled)
+void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, bool enabled)
 {
     if (!window->monitor)
     {
@@ -1185,7 +1191,7 @@ void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, GLFWbool enabled)
     }
 }
 
-void _glfwPlatformSetWindowFloating(_GLFWwindow* window, GLFWbool enabled)
+void _glfwPlatformSetWindowFloating(_GLFWwindow* window, bool enabled)
 {
     // TODO
     _glfwInputError(GLFW_PLATFORM_ERROR,
@@ -1232,7 +1238,7 @@ void _glfwPlatformGetCursorPos(_GLFWwindow* window, double* xpos, double* ypos)
         *ypos = window->wl.cursorPosY;
 }
 
-static GLFWbool isPointerLocked(_GLFWwindow* window);
+static bool isPointerLocked(_GLFWwindow* window);
 
 void _glfwPlatformSetCursorPos(_GLFWwindow* window, double x, double y)
 {
@@ -1266,12 +1272,12 @@ int _glfwPlatformCreateCursor(_GLFWcursor* cursor,
 {
     cursor->wl.buffer = createShmBuffer(image);
     if (!cursor->wl.buffer)
-        return GLFW_FALSE;
+        return false;
     cursor->wl.width = image->width;
     cursor->wl.height = image->height;
     cursor->wl.xhot = xhot;
     cursor->wl.yhot = yhot;
-    return GLFW_TRUE;
+    return true;
 }
 
 int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, GLFWCursorShape shape)
@@ -1279,10 +1285,10 @@ int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, GLFWCursorShape shape
     struct wl_cursor* standardCursor;
 
     standardCursor = _glfwLoadCursor(shape);
-    if (!standardCursor) return GLFW_FALSE;
+    if (!standardCursor) return false;
     cursor->wl.cursor = standardCursor;
     cursor->wl.currentImage = 0;
-    return GLFW_TRUE;
+    return true;
 }
 
 void _glfwPlatformDestroyCursor(_GLFWcursor* cursor)
@@ -1387,7 +1393,7 @@ static void lockPointer(_GLFWwindow* window)
                           NULL, 0, 0);
 }
 
-static GLFWbool isPointerLocked(_GLFWwindow* window)
+static bool isPointerLocked(_GLFWwindow* window)
 {
     return window->wl.pointerLock.lockedPointer != NULL;
 }
@@ -1799,12 +1805,12 @@ void _glfwSetupWaylandPrimarySelectionDevice() {
     if (_glfw.wl.primarySelectionDevice) zwp_primary_selection_device_v1_add_listener(_glfw.wl.primarySelectionDevice, &primary_selection_device_listener, NULL);
 }
 
-static inline GLFWbool _glfwEnsureDataDevice(void) {
+static inline bool _glfwEnsureDataDevice(void) {
     if (!_glfw.wl.dataDeviceManager)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "Wayland: Cannot use clipboard, data device manager is not ready");
-        return GLFW_FALSE;
+        return false;
     }
 
     if (!_glfw.wl.dataDevice)
@@ -1813,16 +1819,16 @@ static inline GLFWbool _glfwEnsureDataDevice(void) {
         {
             _glfwInputError(GLFW_PLATFORM_ERROR,
                             "Wayland: Cannot use clipboard, seat is not ready");
-            return GLFW_FALSE;
+            return false;
         }
         if (!_glfw.wl.dataDevice)
         {
             _glfwInputError(GLFW_PLATFORM_ERROR,
                     "Wayland: Cannot use clipboard, failed to create data device");
-            return GLFW_FALSE;
+            return false;
         }
     }
-    return GLFW_TRUE;
+    return true;
 }
 
 void _glfwPlatformSetClipboardString(const char* string)
@@ -1867,11 +1873,11 @@ const char* _glfwPlatformGetClipboardString(void)
 void _glfwPlatformSetPrimarySelectionString(const char* string)
 {
     if (!_glfw.wl.primarySelectionDevice) {
-        static GLFWbool warned_about_primary_selection_device = GLFW_FALSE;
+        static bool warned_about_primary_selection_device = false;
         if (!warned_about_primary_selection_device) {
             _glfwInputError(GLFW_PLATFORM_ERROR,
                             "Wayland: Cannot copy no primary selection device available");
-            warned_about_primary_selection_device = GLFW_TRUE;
+            warned_about_primary_selection_device = true;
         }
         return;
     }
@@ -2012,7 +2018,7 @@ GLFWAPI struct wl_surface* glfwGetWaylandWindow(GLFWwindow* handle)
     return window->wl.surface;
 }
 
-GLFWAPI int glfwGetXKBScancode(const char* keyName, GLFWbool caseSensitive) {
+GLFWAPI int glfwGetXKBScancode(const char* keyName, bool caseSensitive) {
     return glfw_xkb_keysym_from_name(keyName, caseSensitive);
 }
 

glfw/x11_init.c

@@ -154,7 +154,7 @@ static void detectEWMH(void)
 
 // Look for and initialize supported X11 extensions
 //
-static GLFWbool initExtensions(void)
+static bool initExtensions(void)
 {
     _glfw.x11.vidmode.handle = _glfw_dlopen("libXxf86vm.so.1");
     if (_glfw.x11.vidmode.handle)
@@ -199,7 +199,7 @@ static GLFWbool initExtensions(void)
                                &_glfw.x11.xi.major,
                                &_glfw.x11.xi.minor) == Success)
             {
-                _glfw.x11.xi.available = GLFW_TRUE;
+                _glfw.x11.xi.available = true;
             }
         }
     }
@@ -258,7 +258,7 @@ static GLFWbool initExtensions(void)
             {
                 // The GLFW RandR path requires at least version 1.3
                 if (_glfw.x11.randr.major > 1 || _glfw.x11.randr.minor >= 3)
-                    _glfw.x11.randr.available = GLFW_TRUE;
+                    _glfw.x11.randr.available = true;
             }
             else
             {
@@ -277,14 +277,14 @@ static GLFWbool initExtensions(void)
         {
             // This is likely an older Nvidia driver with broken gamma support
             // Flag it as useless and fall back to xf86vm gamma, if available
-            _glfw.x11.randr.gammaBroken = GLFW_TRUE;
+            _glfw.x11.randr.gammaBroken = true;
         }
 
         if (!sr->ncrtc)
         {
             // A system without CRTCs is likely a system with broken RandR
             // Disable the RandR monitor path and fall back to core functions
-            _glfw.x11.randr.monitorBroken = GLFW_TRUE;
+            _glfw.x11.randr.monitorBroken = true;
         }
 
         XRRFreeScreenResources(sr);
@@ -330,7 +330,7 @@ static GLFWbool initExtensions(void)
                                    &_glfw.x11.xinerama.minor))
         {
             if (XineramaIsActive(_glfw.x11.display))
-                _glfw.x11.xinerama.available = GLFW_TRUE;
+                _glfw.x11.xinerama.available = true;
         }
     }
 
@@ -356,7 +356,7 @@ static GLFWbool initExtensions(void)
                                     &_glfw.x11.xrender.major,
                                     &_glfw.x11.xrender.minor))
             {
-                _glfw.x11.xrender.available = GLFW_TRUE;
+                _glfw.x11.xrender.available = true;
             }
         }
     }
@@ -373,19 +373,19 @@ static GLFWbool initExtensions(void)
     if (!_glfw.x11.xkb.available)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR, "X11: Failed to load Xkb extension");
-        return GLFW_FALSE;
+        return false;
     }
     Bool supported;
     if (XkbSetDetectableAutoRepeat(_glfw.x11.display, True, &supported))
     {
         if (supported)
-            _glfw.x11.xkb.detectable = GLFW_TRUE;
+            _glfw.x11.xkb.detectable = true;
     }
 
-    if (!glfw_xkb_set_x11_events_mask()) return GLFW_FALSE;
-    if (!glfw_xkb_create_context(&_glfw.x11.xkb)) return GLFW_FALSE;
-    if (!glfw_xkb_update_x11_keyboard_id(&_glfw.x11.xkb)) return GLFW_FALSE;
-    if (!glfw_xkb_compile_keymap(&_glfw.x11.xkb, NULL)) return GLFW_FALSE;
+    if (!glfw_xkb_set_x11_events_mask()) return false;
+    if (!glfw_xkb_create_context(&_glfw.x11.xkb)) return false;
+    if (!glfw_xkb_update_x11_keyboard_id(&_glfw.x11.xkb)) return false;
+    if (!glfw_xkb_compile_keymap(&_glfw.x11.xkb, NULL)) return false;
 
     // Detect whether an EWMH-conformant window manager is running
     detectEWMH();
@@ -457,12 +457,12 @@ static GLFWbool initExtensions(void)
         _glfw.x11.NET_WM_CM_Sx = XInternAtom(_glfw.x11.display, name, False);
     }
 
-    return GLFW_TRUE;
+    return true;
 }
 
 // Retrieve system content scale via folklore heuristics
 //
-void _glfwGetSystemContentScaleX11(float* xscale, float* yscale, GLFWbool bypass_cache)
+void _glfwGetSystemContentScaleX11(float* xscale, float* yscale, bool bypass_cache)
 {
     // NOTE: Default to the display-wide DPI as we don't currently have a policy
     //       for which monitor a window is considered to be on
@@ -624,7 +624,7 @@ int _glfwPlatformInit(void)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                 "X11: failed to create self pipe");
-        return GLFW_FALSE;
+        return false;
     }
 
     _glfw.x11.display = XOpenDisplay(NULL);
@@ -642,7 +642,7 @@ int _glfwPlatformInit(void)
                             "X11: The DISPLAY environment variable is missing");
         }
 
-        return GLFW_FALSE;
+        return false;
     }
 
     initPollData(&_glfw.x11.eventLoopData, _glfw.x11.eventLoopData.wakeupFds[0], ConnectionNumber(_glfw.x11.display));
@@ -654,10 +654,10 @@ int _glfwPlatformInit(void)
     _glfw.x11.RESOURCE_MANAGER = XInternAtom(_glfw.x11.display, "RESOURCE_MANAGER", True);
     XSelectInput(_glfw.x11.display, _glfw.x11.root, PropertyChangeMask);
 
-    _glfwGetSystemContentScaleX11(&_glfw.x11.contentScaleX, &_glfw.x11.contentScaleY, GLFW_FALSE);
+    _glfwGetSystemContentScaleX11(&_glfw.x11.contentScaleX, &_glfw.x11.contentScaleY, false);
 
     if (!initExtensions())
-        return GLFW_FALSE;
+        return false;
 
     _glfw.x11.helperWindowHandle = createHelperWindow();
     _glfw.x11.hiddenCursorHandle = createHiddenCursor();
@@ -665,7 +665,7 @@ int _glfwPlatformInit(void)
 #if defined(__linux__)
     if (_glfw.hints.init.enableJoysticks) {
         if (!_glfwInitJoysticksLinux())
-            return GLFW_FALSE;
+            return false;
         if (_glfw.linjs.inotify > 0)
             addWatch(&_glfw.x11.eventLoopData, "joystick", _glfw.linjs.inotify, POLLIN, 1, NULL, NULL);
     }
@@ -674,7 +674,7 @@ int _glfwPlatformInit(void)
     _glfwInitTimerPOSIX();
 
     _glfwPollMonitorsX11();
-    return GLFW_TRUE;
+    return true;
 }
 
 void _glfwPlatformTerminate(void)

glfw/x11_monitor.c

@@ -35,7 +35,7 @@
 
 // Check whether the display mode should be included in enumeration
 //
-static GLFWbool modeIsGood(const XRRModeInfo* mi)
+static bool modeIsGood(const XRRModeInfo* mi)
 {
     return (mi->modeFlags & RR_Interlace) == 0;
 }
@@ -528,7 +528,7 @@ void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode)
     }
 }
 
-GLFWbool _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
+bool _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
 {
     if (_glfw.x11.randr.available && !_glfw.x11.randr.gammaBroken)
     {
@@ -544,7 +544,7 @@ GLFWbool _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
         memcpy(ramp->blue,  gamma->blue,  size * sizeof(unsigned short));
 
         XRRFreeGamma(gamma);
-        return GLFW_TRUE;
+        return true;
     }
     else if (_glfw.x11.vidmode.available)
     {
@@ -556,13 +556,13 @@ GLFWbool _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
         XF86VidModeGetGammaRamp(_glfw.x11.display,
                                 _glfw.x11.screen,
                                 ramp->size, ramp->red, ramp->green, ramp->blue);
-        return GLFW_TRUE;
+        return true;
     }
     else
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "X11: Gamma ramp access not supported by server");
-        return GLFW_FALSE;
+        return false;
     }
 }
 

glfw/x11_platform.h

@@ -182,11 +182,11 @@ typedef struct _GLFWwindowX11
     Colormap        colormap;
     Window          handle;
 
-    GLFWbool        iconified;
-    GLFWbool        maximized;
+    bool        iconified;
+    bool        maximized;
 
     // Whether the visual supports framebuffer transparency
-    GLFWbool        transparent;
+    bool        transparent;
 
     // Cached position and size used to filter out duplicate events
     int             width, height;
@@ -284,14 +284,14 @@ typedef struct _GLFWlibraryX11
     Atom            RESOURCE_MANAGER;
 
     struct {
-        GLFWbool    available;
+        bool    available;
         void*       handle;
         int         eventBase;
         int         errorBase;
         int         major;
         int         minor;
-        GLFWbool    gammaBroken;
-        GLFWbool    monitorBroken;
+        bool    gammaBroken;
+        bool    monitorBroken;
         PFN_XRRAllocGamma AllocGamma;
         PFN_XRRFreeCrtcInfo FreeCrtcInfo;
         PFN_XRRFreeGamma FreeGamma;
@@ -336,7 +336,7 @@ typedef struct _GLFWlibraryX11
     } xcursor;
 
     struct {
-        GLFWbool    available;
+        bool    available;
         void*       handle;
         int         major;
         int         minor;
@@ -346,7 +346,7 @@ typedef struct _GLFWlibraryX11
     } xinerama;
 
     struct {
-        GLFWbool    available;
+        bool    available;
         void*       handle;
         int         eventBase;
         int         errorBase;
@@ -357,7 +357,7 @@ typedef struct _GLFWlibraryX11
     } vidmode;
 
     struct {
-        GLFWbool    available;
+        bool    available;
         void*       handle;
         int         majorOpcode;
         int         eventBase;
@@ -369,7 +369,7 @@ typedef struct _GLFWlibraryX11
     } xi;
 
     struct {
-        GLFWbool    available;
+        bool    available;
         void*       handle;
         int         major;
         int         minor;
@@ -416,11 +416,11 @@ unsigned long _glfwGetWindowPropertyX11(Window window,
                                         Atom property,
                                         Atom type,
                                         unsigned char** value);
-GLFWbool _glfwIsVisualTransparentX11(Visual* visual);
+bool _glfwIsVisualTransparentX11(Visual* visual);
 
 void _glfwGrabErrorHandlerX11(void);
 void _glfwReleaseErrorHandlerX11(void);
 void _glfwInputErrorX11(int error, const char* message);
 
-void _glfwGetSystemContentScaleX11(float* xscale, float* yscale, GLFWbool bypass_cache);
+void _glfwGetSystemContentScaleX11(float* xscale, float* yscale, bool bypass_cache);
 void _glfwPushSelectionToManagerX11(void);

glfw/x11_window.c

@@ -72,23 +72,23 @@ handleEvents(double timeout) {
     EVDBG("other dispatch done");
 }
 
-static GLFWbool
+static bool
 waitForX11Event(double timeout) {
     // returns true iff there is X11 data waiting to be read, does not run watches and timers
     double end_time = glfwGetTime() + timeout;
-    while(GLFW_TRUE) {
+    while(true) {
         if (timeout >= 0) {
             const int result = pollWithTimeout(_glfw.x11.eventLoopData.fds, 1, timeout);
-            if (result > 0) return GLFW_TRUE;
+            if (result > 0) return true;
             timeout = end_time - glfwGetTime();
-            if (timeout <= 0) return GLFW_FALSE;
+            if (timeout <= 0) return false;
             if (result < 0 && (errno == EINTR || errno == EAGAIN)) continue;
-            return GLFW_FALSE;
+            return false;
         } else {
             const int result = poll(_glfw.x11.eventLoopData.fds, 1, -1);
-            if (result > 0) return GLFW_TRUE;
+            if (result > 0) return true;
             if (result < 0 && (errno == EINTR || errno == EAGAIN)) continue;
-            return GLFW_FALSE;
+            return false;
         }
     }
 }
@@ -96,7 +96,7 @@ waitForX11Event(double timeout) {
 // Waits until a VisibilityNotify event arrives for the specified window or the
 // timeout period elapses (ICCCM section 4.2.2)
 //
-static GLFWbool waitForVisibilityNotify(_GLFWwindow* window)
+static bool waitForVisibilityNotify(_GLFWwindow* window)
 {
     XEvent dummy;
 
@@ -106,10 +106,10 @@ static GLFWbool waitForVisibilityNotify(_GLFWwindow* window)
                                    &dummy))
     {
         if (!waitForX11Event(0.1))
-            return GLFW_FALSE;
+            return false;
     }
 
-    return GLFW_TRUE;
+    return true;
 }
 
 // Returns whether the window is iconified
@@ -270,7 +270,7 @@ is_window_fullscreen(_GLFWwindow* window)
 {
     Atom* states;
     unsigned long i;
-    GLFWbool ans = GLFW_FALSE;
+    bool ans = false;
     if (!_glfw.x11.NET_WM_STATE || !_glfw.x11.NET_WM_STATE_FULLSCREEN)
         return ans;
     const unsigned long count =
@@ -283,7 +283,7 @@ is_window_fullscreen(_GLFWwindow* window)
     {
         if (states[i] == _glfw.x11.NET_WM_STATE_FULLSCREEN)
         {
-            ans = GLFW_TRUE;
+            ans = true;
             break;
         }
     }
@@ -499,7 +499,7 @@ static void enableCursor(_GLFWwindow* window)
 
 // Create the X11 window (and its colormap)
 //
-static GLFWbool createNativeWindow(_GLFWwindow* window,
+static bool createNativeWindow(_GLFWwindow* window,
                                    const _GLFWwndconfig* wndconfig,
                                    Visual* visual, int depth)
 {
@@ -551,7 +551,7 @@ static GLFWbool createNativeWindow(_GLFWwindow* window,
         {
             _glfwInputErrorX11(GLFW_PLATFORM_ERROR,
                                "X11: Failed to create window");
-            return GLFW_FALSE;
+            return false;
         }
 
         XSaveContext(_glfw.x11.display,
@@ -561,7 +561,7 @@ static GLFWbool createNativeWindow(_GLFWwindow* window,
     }
 
     if (!wndconfig->decorated)
-        _glfwPlatformSetWindowDecorated(window, GLFW_FALSE);
+        _glfwPlatformSetWindowDecorated(window, false);
 
     if (_glfw.x11.NET_WM_STATE && !window->monitor)
     {
@@ -581,7 +581,7 @@ static GLFWbool createNativeWindow(_GLFWwindow* window,
             {
                 states[count++] = _glfw.x11.NET_WM_STATE_MAXIMIZED_VERT;
                 states[count++] = _glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ;
-                window->x11.maximized = GLFW_TRUE;
+                window->x11.maximized = true;
             }
         }
 
@@ -630,7 +630,7 @@ static GLFWbool createNativeWindow(_GLFWwindow* window,
         {
             _glfwInputError(GLFW_OUT_OF_MEMORY,
                             "X11: Failed to allocate WM hints");
-            return GLFW_FALSE;
+            return false;
         }
 
         hints->flags = StateHint;
@@ -684,7 +684,7 @@ static GLFWbool createNativeWindow(_GLFWwindow* window,
     _glfwPlatformGetWindowPos(window, &window->x11.xpos, &window->x11.ypos);
     _glfwPlatformGetWindowSize(window, &window->x11.width, &window->x11.height);
 
-    return GLFW_TRUE;
+    return true;
 }
 
 // Set the specified property to the selection converted to the requested target
@@ -1056,7 +1056,7 @@ static void releaseMonitor(_GLFWwindow* window)
 static void onConfigChange(void)
 {
     float xscale, yscale;
-    _glfwGetSystemContentScaleX11(&xscale, &yscale, GLFW_TRUE);
+    _glfwGetSystemContentScaleX11(&xscale, &yscale, true);
 
     if (xscale != _glfw.x11.contentScaleX || yscale != _glfw.x11.contentScaleY)
     {
@@ -1076,8 +1076,8 @@ static void onConfigChange(void)
 static void processEvent(XEvent *event)
 {
     _GLFWwindow* window = NULL;
-    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); }
+    static bool keymap_dirty = false;
+#define UPDATE_KEYMAP_IF_NEEDED if (keymap_dirty) { keymap_dirty = false; glfw_xkb_compile_keymap(&_glfw.x11.xkb, NULL); }
 
     if (_glfw.x11.randr.available)
     {
@@ -1153,7 +1153,7 @@ static void processEvent(XEvent *event)
                 /* fallthrough */
             case XkbMapNotify:
             {
-                keymap_dirty = GLFW_TRUE;
+                keymap_dirty = true;
                 return;
             }
             case XkbStateNotify:
@@ -1310,7 +1310,7 @@ static void processEvent(XEvent *event)
             if (window->cursorMode == GLFW_CURSOR_HIDDEN)
                 updateCursorImage(window);
 
-            _glfwInputCursorEnter(window, GLFW_TRUE);
+            _glfwInputCursorEnter(window, true);
             _glfwInputCursorPos(window, x, y);
 
             window->x11.lastCursorPosX = x;
@@ -1320,7 +1320,7 @@ static void processEvent(XEvent *event)
 
         case LeaveNotify:
         {
-            _glfwInputCursorEnter(window, GLFW_FALSE);
+            _glfwInputCursorEnter(window, false);
             return;
         }
 
@@ -1430,7 +1430,7 @@ static void processEvent(XEvent *event)
                 // A drag operation has entered the window
                 unsigned long i, count;
                 Atom* formats = NULL;
-                const GLFWbool list = event->xclient.data.l[1] & 1;
+                const bool list = event->xclient.data.l[1] & 1;
 
                 _glfw.x11.xdnd.source  = event->xclient.data.l[0];
                 _glfw.x11.xdnd.version = event->xclient.data.l[1] >> 24;
@@ -1612,7 +1612,7 @@ static void processEvent(XEvent *event)
                 return;
             }
 
-            _glfwInputWindowFocus(window, GLFW_TRUE);
+            _glfwInputWindowFocus(window, true);
             return;
         }
 
@@ -1632,7 +1632,7 @@ static void processEvent(XEvent *event)
             if (window->monitor && window->autoIconify)
                 _glfwPlatformIconifyWindow(window);
 
-            _glfwInputWindowFocus(window, GLFW_FALSE);
+            _glfwInputWindowFocus(window, false);
             return;
         }
 
@@ -1653,7 +1653,7 @@ static void processEvent(XEvent *event)
                 if (state != IconicState && state != NormalState)
                     return;
 
-                const GLFWbool iconified = (state == IconicState);
+                const bool iconified = (state == IconicState);
                 if (window->x11.iconified != iconified)
                 {
                     if (window->monitor)
@@ -1670,7 +1670,7 @@ static void processEvent(XEvent *event)
             }
             else if (event->xproperty.atom == _glfw.x11.NET_WM_STATE)
             {
-                const GLFWbool maximized = _glfwPlatformWindowMaximized(window);
+                const bool maximized = _glfwPlatformWindowMaximized(window);
                 if (window->x11.maximized != maximized)
                 {
                     window->x11.maximized = maximized;
@@ -1720,10 +1720,10 @@ unsigned long _glfwGetWindowPropertyX11(Window window,
     return itemCount;
 }
 
-GLFWbool _glfwIsVisualTransparentX11(Visual* visual)
+bool _glfwIsVisualTransparentX11(Visual* visual)
 {
     if (!_glfw.x11.xrender.available)
-        return GLFW_FALSE;
+        return false;
 
     XRenderPictFormat* pf = XRenderFindVisualFormat(_glfw.x11.display, visual);
     return pf && pf->direct.alphaMask;
@@ -1795,21 +1795,21 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
         if (ctxconfig->source == GLFW_NATIVE_CONTEXT_API)
         {
             if (!_glfwInitGLX())
-                return GLFW_FALSE;
+                return false;
             if (!_glfwChooseVisualGLX(wndconfig, ctxconfig, fbconfig, &visual, &depth))
-                return GLFW_FALSE;
+                return false;
         }
         else if (ctxconfig->source == GLFW_EGL_CONTEXT_API)
         {
             if (!_glfwInitEGL())
-                return GLFW_FALSE;
+                return false;
             if (!_glfwChooseVisualEGL(wndconfig, ctxconfig, fbconfig, &visual, &depth))
-                return GLFW_FALSE;
+                return false;
         }
         else if (ctxconfig->source == GLFW_OSMESA_CONTEXT_API)
         {
             if (!_glfwInitOSMesa())
-                return GLFW_FALSE;
+                return false;
         }
     }
 
@@ -1821,24 +1821,24 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
     }
 
     if (!createNativeWindow(window, wndconfig, visual, depth))
-        return GLFW_FALSE;
+        return false;
 
     if (ctxconfig->client != GLFW_NO_API)
     {
         if (ctxconfig->source == GLFW_NATIVE_CONTEXT_API)
         {
             if (!_glfwCreateContextGLX(window, ctxconfig, fbconfig))
-                return GLFW_FALSE;
+                return false;
         }
         else if (ctxconfig->source == GLFW_EGL_CONTEXT_API)
         {
             if (!_glfwCreateContextEGL(window, ctxconfig, fbconfig))
-                return GLFW_FALSE;
+                return false;
         }
         else if (ctxconfig->source == GLFW_OSMESA_CONTEXT_API)
         {
             if (!_glfwCreateContextOSMesa(window, ctxconfig, fbconfig))
-                return GLFW_FALSE;
+                return false;
         }
     }
 
@@ -1850,7 +1850,7 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
     }
 
     XFlush(_glfw.x11.display);
-    return GLFW_TRUE;
+    return true;
 }
 
 void _glfwPlatformDestroyWindow(_GLFWwindow* window)
@@ -2194,7 +2194,7 @@ void _glfwPlatformRequestWindowAttention(_GLFWwindow* window)
 
 int _glfwPlatformWindowBell(_GLFWwindow* window)
 {
-    return XkbBell(_glfw.x11.display, window->x11.handle, 100, (Atom)0) ? GLFW_TRUE : GLFW_FALSE;
+    return XkbBell(_glfw.x11.display, window->x11.handle, 100, (Atom)0) ? true : false;
 }
 
 void _glfwPlatformFocusWindow(_GLFWwindow* window)
@@ -2274,7 +2274,7 @@ int _glfwPlatformWindowFocused(_GLFWwindow* window)
 
 int _glfwPlatformWindowOccluded(_GLFWwindow* window)
 {
-    return GLFW_FALSE;
+    return false;
 }
 
 int _glfwPlatformWindowIconified(_GLFWwindow* window)
@@ -2293,7 +2293,7 @@ int _glfwPlatformWindowMaximized(_GLFWwindow* window)
 {
     Atom* states;
     unsigned long i;
-    GLFWbool maximized = GLFW_FALSE;
+    bool maximized = false;
     if (!_glfw.x11.NET_WM_STATE ||
             !_glfw.x11.NET_WM_STATE_MAXIMIZED_VERT ||
             !_glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ)
@@ -2309,7 +2309,7 @@ int _glfwPlatformWindowMaximized(_GLFWwindow* window)
         if (states[i] == _glfw.x11.NET_WM_STATE_MAXIMIZED_VERT ||
             states[i] == _glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ)
         {
-            maximized = GLFW_TRUE;
+            maximized = true;
             break;
         }
     }
@@ -2332,32 +2332,32 @@ int _glfwPlatformWindowHovered(_GLFWwindow* window)
         if (!XQueryPointer(_glfw.x11.display, w,
                            &root, &w, &rootX, &rootY, &childX, &childY, &mask))
         {
-            return GLFW_FALSE;
+            return false;
         }
 
         if (w == window->x11.handle)
-            return GLFW_TRUE;
+            return true;
     }
 
-    return GLFW_FALSE;
+    return false;
 }
 
 int _glfwPlatformFramebufferTransparent(_GLFWwindow* window)
 {
     if (!window->x11.transparent)
-        return GLFW_FALSE;
+        return false;
 
     return XGetSelectionOwner(_glfw.x11.display, _glfw.x11.NET_WM_CM_Sx) != None;
 }
 
-void _glfwPlatformSetWindowResizable(_GLFWwindow* window, GLFWbool enabled)
+void _glfwPlatformSetWindowResizable(_GLFWwindow* window, bool enabled)
 {
     int width, height;
     _glfwPlatformGetWindowSize(window, &width, &height);
     updateNormalHints(window, width, height);
 }
 
-void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, GLFWbool enabled)
+void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, bool enabled)
 {
     if (enabled)
     {
@@ -2388,7 +2388,7 @@ void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, GLFWbool enabled)
     }
 }
 
-void _glfwPlatformSetWindowFloating(_GLFWwindow* window, GLFWbool enabled)
+void _glfwPlatformSetWindowFloating(_GLFWwindow* window, bool enabled)
 {
     if (!_glfw.x11.NET_WM_STATE || !_glfw.x11.NET_WM_STATE_ABOVE)
         return;
@@ -2612,9 +2612,9 @@ int _glfwPlatformCreateCursor(_GLFWcursor* cursor,
 {
     cursor->x11.handle = _glfwCreateCursorX11(image, xhot, yhot);
     if (!cursor->x11.handle)
-        return GLFW_FALSE;
+        return false;
 
-    return GLFW_TRUE;
+    return true;
 }
 
 int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, GLFWCursorShape shape)
@@ -2633,7 +2633,7 @@ int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, GLFWCursorShape shape
         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;
+            return false;
     }
 #undef C
 
@@ -2642,10 +2642,10 @@ int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, GLFWCursorShape shape
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "X11: Failed to create standard cursor");
-        return GLFW_FALSE;
+        return false;
     }
 
-    return GLFW_TRUE;
+    return true;
 }
 
 void _glfwPlatformDestroyCursor(_GLFWcursor* cursor)
@@ -2747,7 +2747,7 @@ int _glfwPlatformGetPhysicalDevicePresentationSupport(VkInstance instance,
         {
             _glfwInputError(GLFW_API_UNAVAILABLE,
                             "X11: Vulkan instance missing VK_KHR_xcb_surface extension");
-            return GLFW_FALSE;
+            return false;
         }
 
         xcb_connection_t* connection = XGetXCBConnection(_glfw.x11.display);
@@ -2755,7 +2755,7 @@ int _glfwPlatformGetPhysicalDevicePresentationSupport(VkInstance instance,
         {
             _glfwInputError(GLFW_PLATFORM_ERROR,
                             "X11: Failed to retrieve XCB connection");
-            return GLFW_FALSE;
+            return false;
         }
 
         return vkGetPhysicalDeviceXcbPresentationSupportKHR(device,
@@ -2773,7 +2773,7 @@ int _glfwPlatformGetPhysicalDevicePresentationSupport(VkInstance instance,
         {
             _glfwInputError(GLFW_API_UNAVAILABLE,
                             "X11: Vulkan instance missing VK_KHR_xlib_surface extension");
-            return GLFW_FALSE;
+            return false;
         }
 
         return vkGetPhysicalDeviceXlibPresentationSupportKHR(device,
@@ -2880,7 +2880,7 @@ GLFWAPI Window glfwGetX11Window(GLFWwindow* handle)
     return window->x11.handle;
 }
 
-GLFWAPI int glfwGetXKBScancode(const char* keyName, GLFWbool caseSensitive) {
+GLFWAPI int glfwGetXKBScancode(const char* keyName, bool caseSensitive) {
     return glfw_xkb_keysym_from_name(keyName, caseSensitive);
 }
 

glfw/xkb_glfw.c

@@ -47,6 +47,7 @@
         S(backslash, BACKSLASH); \
         S(bracketright, RIGHT_BRACKET); \
         S(plus, PLUS); \
+        S(underscore, UNDERSCORE); \
         S(grave, GRAVE_ACCENT); \
         S(Escape, ESCAPE); \
         S(Return, ENTER); \
@@ -135,30 +136,30 @@ glfw_xkb_sym_for_key(int key) {
 
 #ifdef _GLFW_X11
 
-GLFWbool
+bool
 glfw_xkb_set_x11_events_mask(void) {
     if (!XkbSelectEvents(_glfw.x11.display, XkbUseCoreKbd, XkbNewKeyboardNotifyMask | XkbMapNotifyMask | XkbStateNotifyMask, XkbNewKeyboardNotifyMask | XkbMapNotifyMask | XkbStateNotifyMask)) {
         _glfwInputError(GLFW_PLATFORM_ERROR, "Failed to set XKB events mask");
-        return GLFW_FALSE;
+        return false;
     }
-    return GLFW_TRUE;
+    return true;
 }
 
-GLFWbool
+bool
 glfw_xkb_update_x11_keyboard_id(_GLFWXKBData *xkb) {
     xkb->keyboard_device_id = -1;
     xcb_connection_t* conn = XGetXCBConnection(_glfw.x11.display);
     if (!conn) {
         _glfwInputError(GLFW_PLATFORM_ERROR, "X11: Failed to retrieve XCB connection");
-        return GLFW_FALSE;
+        return false;
     }
 
     xkb->keyboard_device_id = xkb_x11_get_core_keyboard_device_id(conn);
     if (xkb->keyboard_device_id == -1) {
         _glfwInputError(GLFW_PLATFORM_ERROR, "X11: Failed to retrieve core keyboard device id");
-        return GLFW_FALSE;
+        return false;
     }
-    return GLFW_TRUE;
+    return true;
 }
 
 #define xkb_glfw_load_keymap(keymap, ...) {\
@@ -203,17 +204,17 @@ glfw_xkb_release(_GLFWXKBData *xkb) {
     glfw_ibus_terminate(&xkb->ibus);
 }
 
-GLFWbool
+bool
 glfw_xkb_create_context(_GLFWXKBData *xkb) {
     xkb->context = xkb_context_new(0);
     if (!xkb->context)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "Failed to initialize XKB context");
-        return GLFW_FALSE;
+        return false;
     }
     glfw_connect_to_ibus(&xkb->ibus);
-    return GLFW_TRUE;
+    return true;
 }
 
 static const char*
@@ -259,7 +260,7 @@ load_compose_tables(_GLFWXKBData *xkb) {
     xkb_compose_table_unref(compose_table);
 }
 
-GLFWbool
+bool
 glfw_xkb_compile_keymap(_GLFWXKBData *xkb, const char *map_str) {
     const char *err;
     release_keyboard_data(xkb);
@@ -267,13 +268,13 @@ glfw_xkb_compile_keymap(_GLFWXKBData *xkb, const char *map_str) {
     if (err) {
         _glfwInputError(GLFW_PLATFORM_ERROR, "%s", err);
         release_keyboard_data(xkb);
-        return GLFW_FALSE;
+        return false;
     }
     err = load_states(xkb);
     if (err) {
         _glfwInputError(GLFW_PLATFORM_ERROR, "%s", err);
         release_keyboard_data(xkb);
-        return GLFW_FALSE;
+        return false;
     }
     load_compose_tables(xkb);
 #define S(a, n) xkb->a##Idx = xkb_keymap_mod_get_index(xkb->keymap, n); xkb->a##Mask = 1 << xkb->a##Idx;
@@ -291,7 +292,7 @@ glfw_xkb_compile_keymap(_GLFWXKBData *xkb, const char *map_str) {
     }
     xkb->states.modifiers = 0;
     xkb->states.activeUnknownModifiers = 0;
-    return GLFW_TRUE;
+    return true;
 }
 
 static inline xkb_mod_mask_t
@@ -325,7 +326,7 @@ glfw_xkb_update_modifiers(_GLFWXKBData *xkb, xkb_mod_mask_t depressed, xkb_mod_m
     update_modifiers(xkb, &xkb->states);
 }
 
-GLFWbool
+bool
 glfw_xkb_should_repeat(_GLFWXKBData *xkb, xkb_keycode_t scancode) {
 #ifdef _GLFW_WAYLAND
     scancode += 8;
@@ -365,7 +366,7 @@ glfw_xkb_keysym_name(xkb_keysym_t sym) {
 }
 
 int
-glfw_xkb_keysym_from_name(const char *name, GLFWbool case_sensitive) {
+glfw_xkb_keysym_from_name(const char *name, bool case_sensitive) {
     return (int)xkb_keysym_from_name(name, case_sensitive ? XKB_KEYSYM_NO_FLAGS : XKB_KEYSYM_CASE_INSENSITIVE);
 }
 
@@ -412,7 +413,7 @@ glfw_xkb_update_ime_state(_GLFWwindow *w, _GLFWXKBData *xkb, int which, int a, i
     int x = 0, y = 0;
     switch(which) {
         case 1:
-            glfw_ibus_set_focused(&xkb->ibus, a ? GLFW_TRUE : GLFW_FALSE);
+            glfw_ibus_set_focused(&xkb->ibus, a ? true : false);
             break;
         case 2:
             _glfwPlatformGetWindowPos(w, &x, &y);
@@ -423,7 +424,7 @@ glfw_xkb_update_ime_state(_GLFWwindow *w, _GLFWXKBData *xkb, int which, int a, i
 }
 
 void
-glfw_xkb_key_from_ime(KeyEvent *ev, GLFWbool handled_by_ime, GLFWbool failed) {
+glfw_xkb_key_from_ime(KeyEvent *ev, bool handled_by_ime, bool failed) {
     _GLFWwindow *window = _glfwWindowForId(ev->window_id);
     if (failed && window && window->callbacks.keyboard) {
         // notify application to remove any existing pre-edit text
@@ -436,7 +437,7 @@ glfw_xkb_key_from_ime(KeyEvent *ev, GLFWbool handled_by_ime, GLFWbool failed) {
     // you'd need to implement a ring buffer to store pending key presses.
     xkb_keycode_t prev_handled_press = last_handled_press_keycode;
     last_handled_press_keycode = 0;
-    GLFWbool is_release = ev->action == GLFW_RELEASE;
+    bool is_release = ev->action == GLFW_RELEASE;
     debug("From IBUS: scancode: 0x%x name: %s is_release: %d\n", ev->keycode, glfw_xkb_keysym_name(ev->keysym), is_release);
     if (window && !handled_by_ime && !(is_release && ev->keycode == prev_handled_press)) {
         debug("↳ to application: glfw_keycode: 0x%x (%s) keysym: 0x%x (%s) action: %s %s text: %s\n",
@@ -499,13 +500,13 @@ glfw_xkb_handle_key_event(_GLFWwindow *window, _GLFWXKBData *xkb, xkb_keycode_t
         if (key_event.text[0]) { debug("%s: %s ", text_type, key_event.text); }
     }
     int glfw_keycode = glfw_key_for_sym(glfw_sym);
-    GLFWbool is_fallback = GLFW_FALSE;
+    bool is_fallback = false;
     if (glfw_keycode == GLFW_KEY_UNKNOWN && !key_event.text[0]) {
         int num_default_syms = xkb_state_key_get_syms(sg->default_state, code_for_sym, &default_syms);
         if (num_default_syms > 0) {
             glfw_sym = default_syms[0];
             glfw_keycode = glfw_key_for_sym(glfw_sym);
-            is_fallback = GLFW_TRUE;
+            is_fallback = true;
         }
     }
     debug(

glfw/xkb_glfw.h

@@ -67,8 +67,8 @@ typedef struct {
 
 #ifdef _GLFW_X11
     int32_t                 keyboard_device_id;
-    GLFWbool                available;
-    GLFWbool                detectable;
+    bool                available;
+    bool                detectable;
     int                     majorOpcode;
     int                     eventBase;
     int                     errorBase;
@@ -79,18 +79,18 @@ typedef struct {
 } _GLFWXKBData;
 
 #ifdef _GLFW_X11
-GLFWbool glfw_xkb_set_x11_events_mask(void);
-GLFWbool glfw_xkb_update_x11_keyboard_id(_GLFWXKBData *xkb);
+bool glfw_xkb_set_x11_events_mask(void);
+bool glfw_xkb_update_x11_keyboard_id(_GLFWXKBData *xkb);
 #endif
 
 void glfw_xkb_release(_GLFWXKBData *xkb);
-GLFWbool glfw_xkb_create_context(_GLFWXKBData *xkb);
-GLFWbool glfw_xkb_compile_keymap(_GLFWXKBData *xkb, const char *map_str);
+bool glfw_xkb_create_context(_GLFWXKBData *xkb);
+bool glfw_xkb_compile_keymap(_GLFWXKBData *xkb, const char *map_str);
 void glfw_xkb_update_modifiers(_GLFWXKBData *xkb, xkb_mod_mask_t depressed, xkb_mod_mask_t latched, xkb_mod_mask_t locked, xkb_layout_index_t base_group, xkb_layout_index_t latched_group, xkb_layout_index_t locked_group);
-GLFWbool glfw_xkb_should_repeat(_GLFWXKBData *xkb, xkb_keycode_t scancode);
+bool glfw_xkb_should_repeat(_GLFWXKBData *xkb, xkb_keycode_t scancode);
 const char* glfw_xkb_keysym_name(xkb_keysym_t sym);
 xkb_keysym_t glfw_xkb_sym_for_key(int key);
 void glfw_xkb_handle_key_event(_GLFWwindow *window, _GLFWXKBData *xkb, xkb_keycode_t scancode, int action);
-int glfw_xkb_keysym_from_name(const char *name, GLFWbool case_sensitive);
+int glfw_xkb_keysym_from_name(const char *name, bool case_sensitive);
 void glfw_xkb_update_ime_state(_GLFWwindow *w, _GLFWXKBData *xkb, int which, int a, int b, int c, int d);
-void glfw_xkb_key_from_ime(KeyEvent *ev, GLFWbool handled_by_ime, GLFWbool failed);
+void glfw_xkb_key_from_ime(KeyEvent *ev, bool handled_by_ime, bool failed);

kittens/ask/main.py

@@ -3,6 +3,7 @@
 # License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
 
 import os
+from contextlib import suppress
 
 from kitty.cli import parse_args
 from kitty.constants import cache_dir
@@ -27,10 +28,8 @@ class HistoryCompleter:
         self.history_path = None
         if name:
             ddir = os.path.join(cache_dir(), 'ask')
-            try:
+            with suppress(FileExistsError):
                 os.makedirs(ddir)
-            except FileExistsError:
-                pass
             self.history_path = os.path.join(ddir, name)
 
     def complete(self, text, state):
@@ -50,10 +49,8 @@ class HistoryCompleter:
 
     def __enter__(self):
         if self.history_path:
-            try:
+            with suppress(Exception):
                 readline.read_history_file(self.history_path)
-            except Exception:
-                pass
             readline.set_completer(self.complete)
         return self
 
@@ -106,10 +103,8 @@ def main(args):
             print(styled(args.message, bold=True))
 
         prompt = '> '
-        try:
+        with suppress(KeyboardInterrupt, EOFError):
             ans['response'] = input(prompt)
-        except (KeyboardInterrupt, EOFError):
-            pass
     return ans
 
 

kittens/clipboard/main.py

@@ -22,6 +22,12 @@ class Clipboard(Handler):
         if self.data_to_send is not None:
             self.cmd.write_to_clipboard(self.data_to_send, self.args.use_primary)
         if not self.args.get_clipboard:
+            if self.args.wait_for_completion:
+                # ask kitty for the TN terminfo capability and
+                # only quit after a response is received
+                self.print('\x1bP+q544e\x1b\\', end='')
+                self.print('Waiting for completion...')
+                return
             self.quit_loop(0)
             return
         self.cmd.request_from_clipboard(self.args.use_primary)
@@ -30,6 +36,15 @@ class Clipboard(Handler):
         self.clipboard_contents = text
         self.quit_loop(0)
 
+    def on_capability_response(self, name, val):
+        self.quit_loop(0)
+
+    def on_interrupt(self):
+        self.quit_loop(1)
+
+    def on_eot(self):
+        self.quit_loop(1)
+
 
 OPTIONS = r'''
 --get-clipboard
@@ -45,6 +60,13 @@ default=False
 type=bool-set
 Use the primary selection rather than the clipboard on systems that support it,
 such as X11.
+
+
+--wait-for-completion
+default=False
+type=bool-set
+Wait till the copy to clipboard is complete before exiting. Useful if running
+the kitten in a dedicated, ephemeral window.
 '''.format
 help_text = '''\
 Read or write to the system clipboard.
@@ -54,6 +76,7 @@ To set the clipboard text, pipe in the new text on stdin. Use the
 :file:`stdout`. Note that you must enable reading of clipboard in
 :file:`kitty.conf` first.
 '''
+
 usage = ''
 
 

kittens/diff/collect.py

@@ -7,6 +7,7 @@ import re
 from functools import lru_cache
 from hashlib import md5
 from mimetypes import guess_type
+from contextlib import suppress
 
 path_name_map = {}
 
@@ -140,10 +141,8 @@ def is_image(path):
 def data_for_path(path):
     ans = raw_data_for_path(path)
     if not is_image(path) and not os.path.samefile(path, os.devnull):
-        try:
+        with suppress(UnicodeDecodeError):
             ans = ans.decode('utf-8')
-        except UnicodeDecodeError:
-            pass
     return ans
 
 

kittens/diff/main.py

@@ -9,6 +9,7 @@ import warnings
 from collections import defaultdict
 from functools import partial
 from gettext import gettext as _
+from contextlib import suppress
 
 from kitty.cli import CONFIG_HELP, parse_args
 from kitty.constants import appname
@@ -511,10 +512,8 @@ usage = 'file_or_directory_left file_or_directory_right'
 
 def terminate_processes(processes):
     for pid in processes:
-        try:
+        with suppress(Exception):
             os.kill(pid, signal.SIGKILL)
-        except Exception:
-            pass
 
 
 def main(args):

kittens/hints/main.py

@@ -213,7 +213,7 @@ def url(text, s, e):
 @postprocessor
 def brackets(text, s, e):
     # Remove matching brackets
-    if e > s and e <= len(text):
+    if s < e <= len(text):
         before = text[s]
         if before in '({[<' and text[e-1] == closing_bracket_map[before]:
             s += 1
@@ -224,7 +224,7 @@ def brackets(text, s, e):
 @postprocessor
 def quotes(text, s, e):
     # Remove matching quotes
-    if e > s and e <= len(text):
+    if s < e <= len(text):
         before = text[s]
         if before in '\'"' and text[e-1] == before:
             s += 1
@@ -246,7 +246,9 @@ def run_loop(args, text, all_marks, index_map):
     handler = Hints(text, all_marks, index_map, args)
     loop.loop(handler)
     if handler.chosen and loop.return_code == 0:
-        return {'match': handler.chosen, 'program': args.program}
+        return {'match': handler.chosen, 'program': args.program,
+                'multiple_joiner': args.multiple_joiner,
+                'type': args.type}
     raise SystemExit(loop.return_code)
 
 
@@ -374,6 +376,17 @@ Select multiple matches and perform the action on all of them together at the en
 In this mode, press :kbd:`Esc` to finish selecting.
 
 
+--multiple-joiner
+default=auto
+String to use to join multiple selections when copying to the clipboard or
+inserting into the terminal. The special strings: "space", "newline", "empty",
+"json" and "auto" are interpreted as a space character, a newline an empty
+joiner, a JSON serialized list and an automatic choice, based on the type of
+text being selected. In addition, integers are interpreted as zero-based
+indices into the list of selections. You can use 0 for the first selection and
+-1 for the last.
+
+
 --add-trailing-space
 default=auto
 choices=auto,always,never
@@ -422,13 +435,34 @@ def main(args):
 def handle_result(args, data, target_window_id, boss):
     program = data['program']
     matches = tuple(filter(None, data['match']))
+    joiner = data['multiple_joiner']
+    try:
+        is_int = int(joiner)
+    except Exception:
+        is_int = None
+    text_type = data['type']
+
+    def joined_text():
+        if is_int is not None:
+            try:
+                return matches[is_int]
+            except IndexError:
+                return matches[-1]
+        if joiner == 'json':
+            import json
+            return json.dumps(matches, ensure_ascii=False, indent='\t')
+        if joiner == 'auto':
+            q = '\n\r' if text_type in ('line', 'url') else ' '
+        else:
+            q = {'newline': '\n\r', 'space': ' '}.get(joiner, '')
+        return q.join(matches)
+
     if program == '-':
         w = boss.window_id_map.get(target_window_id)
         if w is not None:
-            for m in matches:
-                w.paste(m)
+            w.paste(joined_text())
     elif program == '@':
-        set_clipboard_string(matches[-1])
+        set_clipboard_string(joined_text())
     else:
         cwd = None
         w = boss.window_id_map.get(target_window_id)

kittens/icat/main.py

@@ -270,7 +270,7 @@ help_text = (
 usage = 'image-file-or-url-or-directory ...'
 
 
-def process_single_item(item, args, url_pat, maybe_dir=True):
+def process_single_item(item, args, url_pat=None, maybe_dir=True):
     is_tempfile = False
     try:
         if isinstance(item, bytes):
@@ -278,7 +278,7 @@ def process_single_item(item, args, url_pat, maybe_dir=True):
             tf.write(item), tf.close()
             item = tf.name
             is_tempfile = True
-        if url_pat.match(item) is not None:
+        if url_pat is not None and url_pat.match(item) is not None:
             from urllib.request import urlretrieve
             with NamedTemporaryFile(prefix='url-image-data-', delete=False) as tf:
                 try:
@@ -300,8 +300,8 @@ def process_single_item(item, args, url_pat, maybe_dir=True):
             process(item, args, is_tempfile)
         else:
             if maybe_dir and os.path.isdir(item):
-                for x in scan(item):
-                    process_single_item(item, args, url_pat, maybe_dir=False)
+                for (x, mt) in scan(item):
+                    process_single_item(x, args, url_pat=None, maybe_dir=False)
             else:
                 process(item, args, is_tempfile)
     finally:

kittens/panel/main.py

@@ -2,12 +2,13 @@
 # vim:fileencoding=utf-8
 # License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
 
+import os
 import shutil
 import subprocess
 import sys
 
 from kitty.cli import parse_args
-from kitty.constants import is_macos, is_wayland
+from kitty.constants import is_macos
 
 OPTIONS = r'''
 --lines
@@ -121,7 +122,7 @@ def initial_window_size_func(opts, *a):
 
 def main(sys_args):
     global args
-    if is_macos or is_wayland:
+    if is_macos or not os.environ.get('DISPLAY'):
         raise SystemExit('Currently the panel kitten is supported only on X11 desktops')
     if not shutil.which('xprop'):
         raise SystemExit('The xprop program is required for the panel kitten')

kittens/tui/handler.py

@@ -84,6 +84,9 @@ class Handler:
     def on_clipboard_response(self, text, from_primary=False):
         pass
 
+    def on_capability_response(self, name, val):
+        pass
+
     def write(self, data):
         if isinstance(data, str):
             data = data.encode('utf-8')

kittens/tui/images.py

@@ -8,6 +8,7 @@ import sys
 from base64 import standard_b64encode
 from collections import defaultdict, deque
 from itertools import count
+from contextlib import suppress
 
 from kitty.utils import fit_image
 
@@ -172,10 +173,8 @@ class ImageManager:
             if in_flight:
                 pl = in_flight.popleft()
                 if payload.startswith('ENOENT:'):
-                    try:
+                    with suppress(Exception):
                         self.resend_image(image_id, pl)
-                    except Exception:
-                        pass
                 if not in_flight:
                     self.placements_in_flight.pop(image_id, None)
 

kittens/tui/loop.py

@@ -214,9 +214,20 @@ class Loop:
                 self.handler.on_text(chunk, self.in_bracketed_paste)
 
     def _on_dcs(self, dcs):
+        debug(dcs)
         if dcs.startswith('@kitty-cmd'):
             import json
             self.handler.on_kitty_cmd_response(json.loads(dcs[len('@kitty-cmd'):]))
+        elif dcs.startswith('1+r'):
+            from binascii import unhexlify
+            vals = dcs[3:].split(';')
+            for q in vals:
+                parts = q.split('=', 1)
+                try:
+                    name, val = parts[0], unhexlify(parts[1]).decode('utf-8', 'replace')
+                except Exception:
+                    continue
+                self.handler.on_capability_response(name, val)
 
     def _on_csi(self, csi):
         q = csi[-1]

kittens/unicode_input/main.py

@@ -7,6 +7,7 @@ import string
 import subprocess
 from functools import lru_cache
 from gettext import gettext as _
+from contextlib import suppress
 
 from kitty.config import cached_values_for
 from kitty.constants import config_dir
@@ -293,24 +294,20 @@ class UnicodeInput(Handler):
         self.update_codepoints()
         self.current_char = None
         if self.mode is HEX:
-            try:
+            with suppress(Exception):
                 if self.line_edit.current_input.startswith(INDEX_CHAR) and len(self.line_edit.current_input) > 1:
                     self.current_char = chr(self.table.codepoint_at_hint(self.line_edit.current_input[1:]))
                 else:
                     code = int(self.line_edit.current_input, 16)
                     self.current_char = chr(code)
-            except Exception:
-                pass
         elif self.mode is NAME:
             cc = self.table.current_codepoint
             if cc:
                 self.current_char = chr(cc)
         else:
-            try:
+            with suppress(Exception):
                 if self.line_edit.current_input:
                     self.current_char = chr(self.table.codepoint_at_hint(self.line_edit.current_input.lstrip(INDEX_CHAR)))
-            except Exception:
-                pass
         if self.current_char is not None:
             code = ord(self.current_char)
             if not codepoint_ok(code):
@@ -483,10 +480,8 @@ def main(args):
         handler = UnicodeInput(cached_values)
         loop.loop(handler)
         if handler.current_char and loop.return_code == 0:
-            try:
+            with suppress(Exception):
                 handler.recent.remove(ord(handler.current_char))
-            except Exception:
-                pass
             recent = [ord(handler.current_char)] + handler.recent
             cached_values['recent'] = recent[:len(DEFAULT_SET)]
             return handler.current_char

kitty/borders.py

@@ -11,7 +11,7 @@ from .utils import load_shaders
 
 try:
     from enum import IntFlag
-except Exception:
+except ImportError:
     from enum import IntEnum as IntFlag
 
 

kitty/boss.py

@@ -9,6 +9,7 @@ import re
 from functools import partial
 from gettext import gettext as _
 from weakref import WeakValueDictionary
+from contextlib import suppress
 
 from .child import cached_process_data
 from .cli import create_opts, parse_args
@@ -24,10 +25,11 @@ from .fast_data_types import (
     change_os_window_state, create_os_window, current_os_window,
     destroy_global_data, get_clipboard_string, global_font_size,
     mark_os_window_for_close, os_window_font_size, patch_global_colors,
-    set_clipboard_string, set_in_sequence_mode, toggle_fullscreen
+    set_clipboard_string, set_in_sequence_mode, toggle_fullscreen,
+    toggle_maximized
 )
 from .keys import get_shortcut, shortcut_matches
-from .layout import set_draw_borders_options
+from .layout import set_layout_options
 from .remote_control import handle_cmd
 from .rgb import Color, color_from_int
 from .session import create_sessions
@@ -104,7 +106,7 @@ class DumpCommands:  # {{{
 class Boss:
 
     def __init__(self, os_window_id, opts, args, cached_values, new_os_window_trigger):
-        set_draw_borders_options(opts)
+        set_layout_options(opts)
         self.clipboard_buffers = {}
         self.update_check_process = None
         self.window_id_map = WeakValueDictionary()
@@ -133,13 +135,13 @@ class Boss:
         if new_os_window_trigger is not None:
             self.keymap.pop(new_os_window_trigger, None)
         for startup_session in startup_sessions:
-            os_window_id = self.add_os_window(startup_session, os_window_id=os_window_id)
+            self.add_os_window(startup_session, os_window_id=os_window_id)
+            os_window_id = None
             if args.start_as != 'normal':
                 if args.start_as == 'fullscreen':
                     self.toggle_fullscreen()
                 else:
                     change_os_window_state(args.start_as)
-            os_window_id = None
         if is_macos:
             from .fast_data_types import cocoa_set_notification_activated_callback
             cocoa_set_notification_activated_callback(self.notification_activated)
@@ -361,6 +363,9 @@ class Boss:
     def toggle_fullscreen(self):
         toggle_fullscreen()
 
+    def toggle_maximized(self):
+        toggle_maximized()
+
     def start(self):
         if not getattr(self, 'io_thread_started', False):
             self.child_monitor.start()
@@ -635,16 +640,12 @@ class Boss:
     def notify_on_os_window_death(self, address):
         import socket
         s = socket.socket(family=socket.AF_UNIX)
-        try:
+        with suppress(Exception):
             s.connect(address)
             s.sendall(b'c')
-            try:
+            with suppress(EnvironmentError):
                 s.shutdown(socket.SHUT_RDWR)
-            except EnvironmentError:
-                pass
             s.close()
-        except Exception:
-            pass
 
     def display_scrollback(self, window, data, cmd):
         tab = self.active_tab
@@ -756,10 +757,10 @@ class Boss:
     def kitty_shell(self, window_type):
         cmd = ['@', kitty_exe(), '@']
         if window_type == 'tab':
-            self._new_tab(cmd).active_window
+            self._new_tab(cmd)
         elif window_type == 'os_window':
             os_window_id = self._new_os_window(cmd)
-            self.os_window_map[os_window_id].active_window
+            self.os_window_map[os_window_id]
         elif window_type == 'overlay':
             w = self.active_window
             tab = self.active_tab
@@ -909,6 +910,11 @@ class Boss:
                 tm.new_tab(special_window=create_window(), cwd_from=cwd_from)
         elif dest == 'os_window':
             self._new_os_window(create_window(), cwd_from=cwd_from)
+        elif dest in ('clipboard', 'primary'):
+            env, stdin = self.process_stdin_source(stdin=source, window=window)
+            if stdin:
+                func = set_clipboard_string if dest == 'clipboard' else set_primary_selection
+                func(stdin)
         else:
             import subprocess
             env, stdin = self.process_stdin_source(stdin=source, window=window)
@@ -1028,18 +1034,14 @@ class Boss:
 
     def safe_delete_temp_file(self, path):
         if is_path_in_temp_dir(path):
-            try:
+            with suppress(FileNotFoundError):
                 os.remove(path)
-            except FileNotFoundError:
-                pass
 
     def set_update_check_process(self, process=None):
         if self.update_check_process is not None:
-            try:
+            with suppress(Exception):
                 if self.update_check_process.poll() is None:
                     self.update_check_process.kill()
-            except Exception:
-                pass
         self.update_check_process = process
 
     def on_monitored_pid_death(self, pid, exit_status):

kitty/child.py

@@ -6,6 +6,7 @@ import fcntl
 import os
 from collections import defaultdict
 from contextlib import contextmanager
+from contextlib import suppress
 
 import kitty.fast_data_types as fast_data_types
 
@@ -57,6 +58,13 @@ else:
         return ans
 
 
+def checked_terminfo_dir():
+    ans = getattr(checked_terminfo_dir, 'ans', None)
+    if ans is None:
+        ans = checked_terminfo_dir.ans = terminfo_dir if os.path.isdir(terminfo_dir) else None
+    return ans
+
+
 def processes_in_group(grp):
     gmap = getattr(process_group_map, 'cached_map', None)
     if gmap is None:
@@ -149,6 +157,23 @@ class Child:
         self.stdin = stdin
         self.env = env or {}
 
+    @property
+    def final_env(self):
+        env = getattr(self, '_final_env', None)
+        if env is None:
+            env = self._final_env = default_env().copy()
+            env.update(self.env)
+            env['TERM'] = self.opts.term
+            env['COLORTERM'] = 'truecolor'
+            if self.cwd:
+                # needed incase cwd is a symlink, in which case shells
+                # can use it to display the current directory name rather
+                # than the resolved path
+                env['PWD'] = self.cwd
+            if checked_terminfo_dir():
+                env['TERMINFO'] = checked_terminfo_dir()
+        return env
+
     def fork(self):
         if self.forked:
             return
@@ -164,17 +189,7 @@ class Child:
             remove_cloexec(stdin_read_fd)
         else:
             stdin_read_fd = stdin_write_fd = -1
-        env = default_env().copy()
-        env.update(self.env)
-        env['TERM'] = self.opts.term
-        env['COLORTERM'] = 'truecolor'
-        if self.cwd:
-            # needed incase cwd is a symlink, in which case shells
-            # can use it to display the current directory name rather
-            # than the resolved path
-            env['PWD'] = self.cwd
-        if os.path.isdir(terminfo_dir):
-            env['TERMINFO'] = terminfo_dir
+        env = self.final_env
         env = tuple('{}={}'.format(k, v) for k, v in env.items())
         argv = list(self.argv)
         exe = argv[0]
@@ -206,14 +221,10 @@ class Child:
 
             def process_desc(pid):
                 ans = {'pid': pid}
-                try:
+                with suppress(Exception):
                     ans['cmdline'] = cmdline_of_process(pid)
-                except Exception:
-                    pass
-                try:
+                with suppress(Exception):
                     ans['cwd'] = cwd_of_process(pid) or None
-                except Exception:
-                    pass
                 return ans
 
             return list(map(process_desc, foreground_processes))
@@ -236,25 +247,19 @@ class Child:
 
     @property
     def current_cwd(self):
-        try:
+        with suppress(Exception):
             return cwd_of_process(self.pid)
-        except Exception:
-            pass
 
     @property
     def pid_for_cwd(self):
-        try:
+        with suppress(Exception):
             pgrp = os.tcgetpgrp(self.child_fd)
             foreground_processes = processes_in_group(pgrp) if pgrp >= 0 else []
             if len(foreground_processes) == 1:
                 return foreground_processes[0]
-        except Exception:
-            pass
         return self.pid
 
     @property
     def foreground_cwd(self):
-        try:
+        with suppress(Exception):
             return cwd_of_process(self.pid_for_cwd) or None
-        except Exception:
-            pass

kitty/cli.py

@@ -719,8 +719,6 @@ def create_opts(args, debug_config=False, accumulate_bad_lines=None):
         if is_macos:
             import subprocess
             print(' '.join(subprocess.check_output(['sw_vers']).decode('utf-8').splitlines()).strip())
-        else:
-            print('Running under:', green('Wayland' if is_wayland else 'X11'))
         if os.path.exists('/etc/issue'):
             print(open('/etc/issue', encoding='utf-8', errors='replace').read().strip())
         if os.path.exists('/etc/lsb-release'):
@@ -731,5 +729,7 @@ def create_opts(args, debug_config=False, accumulate_bad_lines=None):
     overrides = (a.replace('=', ' ', 1) for a in args.override or ())
     opts = load_config(*config, overrides=overrides, accumulate_bad_lines=accumulate_bad_lines)
     if debug_config:
+        if not is_macos:
+            print('Running under:', green('Wayland' if is_wayland(opts) else 'X11'))
         compare_opts(opts)
     return opts

kitty/client.py

@@ -9,6 +9,7 @@
 # will replay the commands and pause at the end waiting for user to press enter
 
 import sys
+from contextlib import suppress
 
 
 CSI = '\033['
@@ -158,7 +159,5 @@ def replay(raw):
 def main(path):
     raw = open(path).read()
     replay(raw)
-    try:
+    with suppress(EOFError, KeyboardInterrupt):
         input()
-    except (EOFError, KeyboardInterrupt):
-        pass

kitty/cmds.py

@@ -5,6 +5,7 @@
 import json
 import os
 import sys
+from contextlib import suppress
 
 from .cli import parse_args
 from .config import parse_config, parse_send_text_bytes
@@ -904,7 +905,5 @@ def parse_subcommand_cli(func, args):
 
 
 def display_subcommand_help(func):
-    try:
+    with suppress(SystemExit):
         parse_args(['--help'], (func.options_spec or '\n').format, func.argspec, func.desc, func.name)
-    except SystemExit:
-        pass

kitty/config.py

@@ -8,6 +8,7 @@ import re
 import sys
 from collections import namedtuple
 from contextlib import contextmanager
+from contextlib import suppress
 from functools import partial
 
 from . import fast_data_types as defines
@@ -19,11 +20,13 @@ from .conf.utils import (
 from .config_data import all_options, parse_mods, type_map
 from .constants import cache_dir, defconf, is_macos
 from .utils import log_error
+from .key_names import get_key_name_lookup
 
 named_keys = {
     "'": 'APOSTROPHE',
     ',': 'COMMA',
     '-': 'MINUS',
+    '_': 'UNDERSCORE',
     '.': 'PERIOD',
     '/': 'SLASH',
     ';': 'SEMICOLON',
@@ -45,13 +48,12 @@ def parse_shortcut(sc):
     key = getattr(defines, 'GLFW_KEY_' + named_keys.get(key, key), None)
     is_native = False
     if key is None:
-        if parts[-1].startswith('0x'):
-            try:
-                key = int(parts[-1], 16)
-            except Exception:
-                pass
+        q = parts[-1]
+        if q.startswith('0x'):
+            with suppress(Exception):
+                key = int(q, 16)
         else:
-            key = defines.key_for_native_key_name(parts[-1])
+            key = get_key_name_lookup()(q)
         is_native = key is not None
     return mods, is_native, key
 
@@ -577,10 +579,8 @@ def commented_out_default_config():
 def prepare_config_file_for_editing():
     if not os.path.exists(defconf):
         d = os.path.dirname(defconf)
-        try:
+        with suppress(FileExistsError):
             os.makedirs(d)
-        except FileExistsError:
-            pass
         with open(defconf, 'w', encoding='utf-8') as f:
             f.write(commented_out_default_config())
     return defconf

kitty/config_data.py

@@ -513,6 +513,9 @@ o('bell_on_tab', True, long_text=_('''
 Show a bell symbol on the tab if a bell occurs in one of the windows in the
 tab and the window is not the currently focused window'''))
 
+o('command_on_bell', 'none', option_type=to_cmdline, long_text=_('''
+Program to run when a bell occurs.
+'''))
 # }}}
 
 g('window')  # {{{
@@ -583,6 +586,14 @@ Negative values will cause the value of :opt:`window_margin_width` to be used in
 o('window_padding_width', 0.0, option_type=positive_float, long_text=_('''
 The window padding (in pts) (blank area between the text and the window border)'''))
 
+o('placement_strategy', 'center', option_type=choices('center', 'top-left'), long_text=_('''
+When the window size is not an exact multiple of the cell size, the cell area of the terminal
+window will have some extra padding on the sides. You can control how that padding is
+distributed with this option. Using a value of :code:`center` means the cell area will
+be placed centrally. A value of :code:`top-left` means the padding will be on only
+the bottom and right edges.
+'''))
+
 o('active_border_color', '#00ff00', option_type=to_color_or_none, long_text=_('''
 The color for the border of the active window. Set this to none to not draw borders
 around the active window.'''))
@@ -607,7 +618,7 @@ window manager/operating system.
 o('resize_debounce_time', 0.1, option_type=positive_float, long_text=_('''
 The time (in seconds) to wait before redrawing the screen when a
 resize event is received. On platforms such as macOS, where the
-operating system sends event corresponding to the start and end
+operating system sends events corresponding to the start and end
 of a resize, this number is ignored.'''))
 
 
@@ -954,6 +965,12 @@ o('macos_custom_beam_cursor', False, long_text=_('''
 Enable/disable custom mouse cursor for macOS that is easier to see on both
 light and dark backgrounds. WARNING: this might make your mouse cursor
 invisible on dual GPU machines.'''))
+
+o('linux_display_server', 'auto', option_type=choices('auto', 'x11', 'wayland'), long_text=_('''
+Choose between Wayland and X11 backends. By default, an
+appropriate backend based on the system state is chosen
+automatically. Set it to :code:`x11` or :code:`wayland`
+to force the choice.'''))
 # }}}
 
 g('shortcuts')  # {{{
@@ -981,7 +998,8 @@ k('paste_from_selection', 'shift+insert', 'paste_from_selection', _('Paste from
 k('pass_selection_to_program', 'kitty_mod+o', 'pass_selection_to_program', _('Pass selection to program'), long_text=_('''
 You can also pass the contents of the current selection to any program using
 :code:`pass_selection_to_program`. By default, the system's open program is used, but
-you can specify your own, for example::
+you can specify your own, the selection will be passed as a command line argument to the program,
+for example::
 
     map kitty_mod+o pass_selection_to_program firefox
 
@@ -1154,6 +1172,7 @@ Useful with git, which uses sha1 hashes to identify commits'''))
 
 g('shortcuts.misc')  # {{{
 k('toggle_fullscreen', 'kitty_mod+f11', 'toggle_fullscreen', _('Toggle fullscreen'))
+k('toggle_maximized', 'kitty_mod+f10', 'toggle_maximized', _('Toggle maximized'))
 k('input_unicode_character', 'kitty_mod+u', 'kitten unicode_input', _('Unicode input'))
 k('edit_config_file', 'kitty_mod+f2', 'edit_config_file', _('Edit config file'))
 k('kitty_shell', 'kitty_mod+escape', 'kitty_shell window', _('Open the kitty command shell'), long_text=_('''

kitty/constants.py

@@ -6,9 +6,10 @@ import os
 import pwd
 import sys
 from collections import namedtuple
+from contextlib import suppress
 
 appname = 'kitty'
-version = (0, 14, 0)
+version = (0, 14, 2)
 str_version = '.'.join(map(str, version))
 _plat = sys.platform.lower()
 is_macos = 'darwin' in _plat
@@ -70,10 +71,8 @@ def _get_config_dir():
 
         def cleanup():
             import shutil
-            try:
+            with suppress(Exception):
                 shutil.rmtree(ans)
-            except Exception:
-                pass
         atexit.register(cleanup)
     return ans
 
@@ -124,10 +123,8 @@ beam_cursor_data_file = os.path.join(base_dir, 'logo', 'beam-cursor.png')
 try:
     shell_path = pwd.getpwuid(os.geteuid()).pw_shell or '/bin/sh'
 except KeyError:
-    try:
+    with suppress(Exception):
         print('Failed to read login shell via getpwuid() for current user, falling back to /bin/sh', file=sys.stderr)
-    except Exception:
-        pass
     shell_path = '/bin/sh'
 
 
@@ -135,9 +132,47 @@ def glfw_path(module):
     return os.path.join(base, 'glfw-{}.so'.format(module))
 
 
-is_wayland = False
-if os.environ.get('WAYLAND_DISPLAY') and 'KITTY_DISABLE_WAYLAND' not in os.environ and os.path.exists(glfw_path('wayland')):
-    is_wayland = True
+def detect_if_wayland_ok():
+    if 'WAYLAND_DISPLAY' not in os.environ:
+        return False
+    if 'KITTY_DISABLE_WAYLAND' in os.environ:
+        return False
+    wayland = glfw_path('wayland')
+    if not os.path.exists(wayland):
+        return False
+    # GNOME does not support xdg-decorations
+    # https://gitlab.gnome.org/GNOME/mutter/issues/217
+    import ctypes
+    lib = ctypes.CDLL(wayland)
+    check = lib.glfwWaylandCheckForServerSideDecorations
+    check.restype = ctypes.c_char_p
+    check.argtypes = ()
+    try:
+        ans = bytes(check())
+    except Exception:
+        return False
+    if ans == b'NO':
+        print(
+                'Your Wayland compositor does not support server side window decorations,'
+                ' disabling Wayland. You can force Wayland support using the'
+                ' linux_display_server option in kitty.conf'
+                ' See https://drewdevault.com/2018/01/27/Sway-and-client-side-decorations.html'
+                ' for more information.',
+                file=sys.stderr)
+    return ans == b'YES'
+
+
+def is_wayland(opts=None):
+    if is_macos:
+        return False
+    if opts is None:
+        return is_wayland.ans
+    if opts.linux_display_server == 'auto':
+        ans = detect_if_wayland_ok()
+    else:
+        ans = opts.linux_display_server == 'wayland'
+    setattr(is_wayland, 'ans', ans)
+    return ans
 
 
 supports_primary_selection = not is_macos

kitty/core_text.m

@@ -280,7 +280,9 @@ cell_metrics(PyObject *s, unsigned int* cell_width, unsigned int* cell_height, u
     *baseline = (unsigned int)self->ascent;
     // float line_height = MAX(1, floor(self->ascent + self->descent + MAX(0, self->leading) + 0.5));
     // Let CoreText's layout engine calculate the line height. Slower, but hopefully more accurate.
-    CFStringRef ts = CFSTR("test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test");
+#define W "AQWMH_gyl "
+    CFStringRef ts = CFSTR(W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W);
+#undef W
     CFMutableAttributedStringRef test_string = CFAttributedStringCreateMutable(kCFAllocatorDefault, CFStringGetLength(ts));
     CFAttributedStringReplaceString(test_string, CFRangeMake(0, 0), ts);
     CFAttributedStringSetAttribute(test_string, CFRangeMake(0, CFStringGetLength(ts)), kCTFontAttributeName, self->ct_font);

kitty/data-types.h

@@ -259,9 +259,9 @@ typedef struct {FONTS_DATA_HEAD} *FONTS_DATA_HANDLE;
     }
 
 #define remove_i_from_array(array, i, count) { \
-    count--; \
-    if (i < count) { \
-        memmove(array + i, array + i + 1, sizeof(array[0]) * (count - 1)); \
+    (count)--; \
+    if ((i) < (count)) { \
+        memmove((array) + (i), (array) + (i) + 1, sizeof((array)[0]) * ((count) - (i))); \
     }}
 
 // Global functions

kitty/fonts/render.py

@@ -88,7 +88,7 @@ def set_font_family(opts=None, override_font_size=None, debug_font_matching=Fals
 
 def add_line(buf, cell_width, position, thickness, cell_height):
     y = position - thickness // 2
-    while thickness > 0 and y > -1 and y < cell_height:
+    while thickness > 0 and -1 < y < cell_height:
         thickness -= 1
         ctypes.memset(ctypes.addressof(buf) + (cell_width * y), 255, cell_width)
         y += 1

kitty/freetype.c

@@ -75,8 +75,6 @@ set_freetype_error(const char* prefix, int err_code) {
 
 static FT_Library  library;
 
-#define CALC_CELL_HEIGHT(self) font_units_to_pixels_y(self, self->height)
-
 static inline int
 font_units_to_pixels_y(Face *self, int x) {
     return ceil((double)FT_MulFix(x, self->face->size->metrics.y_scale) / 64.0);
@@ -87,11 +85,56 @@ font_units_to_pixels_x(Face *self, int x) {
     return ceil((double)FT_MulFix(x, self->face->size->metrics.x_scale) / 64.0);
 }
 
+
+static inline int
+get_load_flags(int hinting, int hintstyle, int base) {
+    int flags = base;
+    if (hinting) {
+        if (hintstyle >= 3) flags |= FT_LOAD_TARGET_NORMAL;
+        else if (0 < hintstyle  && hintstyle < 3) flags |= FT_LOAD_TARGET_LIGHT;
+    } else flags |= FT_LOAD_NO_HINTING;
+    return flags;
+}
+
+
+static inline bool
+load_glyph(Face *self, int glyph_index, int load_type) {
+    int flags = get_load_flags(self->hinting, self->hintstyle, load_type);
+    int error = FT_Load_Glyph(self->face, glyph_index, flags);
+    if (error) { set_freetype_error("Failed to load glyph, with error:", error); return false; }
+    return true;
+}
+
+static inline unsigned int
+get_height_for_char(Face *self, char ch) {
+    unsigned int ans = 0;
+    int glyph_index = FT_Get_Char_Index(self->face, ch);
+    if (load_glyph(self, glyph_index, FT_LOAD_DEFAULT)) {
+        unsigned int baseline = font_units_to_pixels_y(self, self->ascender);
+        FT_GlyphSlotRec *glyph = self->face->glyph;
+        FT_Bitmap *bm = &glyph->bitmap;
+        if (glyph->bitmap_top <= 0 || (glyph->bitmap_top > 0 && (unsigned int)glyph->bitmap_top < baseline)) {
+            ans = baseline - glyph->bitmap_top + bm->rows;
+        }
+    }
+    return ans;
+}
+
+static inline unsigned int
+calc_cell_height(Face *self, bool for_metrics) {
+    unsigned int ans = font_units_to_pixels_y(self, self->height);
+    unsigned int underscore_height = get_height_for_char(self, '_');
+    if (for_metrics && global_state.debug_font_fallback && underscore_height > ans) {
+        printf("Increasing cell height by %u pixels to work around buggy font that renders underscore outside the bounding box\n", underscore_height - ans);
+    }
+    return MAX(ans, underscore_height);
+}
+
 static inline bool
 set_font_size(Face *self, FT_F26Dot6 char_width, FT_F26Dot6 char_height, FT_UInt xdpi, FT_UInt ydpi, unsigned int desired_height, unsigned int cell_height) {
     int error = FT_Set_Char_Size(self->face, 0, char_height, xdpi, ydpi);
     if (!error) {
-        unsigned int ch = CALC_CELL_HEIGHT(self);
+        unsigned int ch = calc_cell_height(self, false);
         if (desired_height && ch != desired_height) {
             FT_F26Dot6 h = floor((double)char_height * (double)desired_height / (double) ch);
             return set_font_size(self, 0, h, xdpi, ydpi, 0, cell_height);
@@ -147,17 +190,6 @@ set_size_for_face(PyObject *s, unsigned int desired_height, bool force, FONTS_DA
     return set_font_size(self, w, w, xdpi, ydpi, desired_height, fg->cell_height);
 }
 
-static inline int
-get_load_flags(int hinting, int hintstyle, int base) {
-    int flags = base;
-    if (hinting) {
-        if (hintstyle >= 3) flags |= FT_LOAD_TARGET_NORMAL;
-        else if (0 < hintstyle  && hintstyle < 3) flags |= FT_LOAD_TARGET_LIGHT;
-    } else flags |= FT_LOAD_NO_HINTING;
-    return flags;
-}
-
-
 static inline bool
 init_ft_face(Face *self, PyObject *path, int hinting, int hintstyle, FONTS_DATA_HANDLE fg) {
 #define CPY(n) self->n = self->face->n;
@@ -236,14 +268,6 @@ repr(Face *self) {
 }
 
 
-static inline bool
-load_glyph(Face *self, int glyph_index, int load_type) {
-    int flags = get_load_flags(self->hinting, self->hintstyle, load_type);
-    int error = FT_Load_Glyph(self->face, glyph_index, flags);
-    if (error) { set_freetype_error("Failed to load glyph, with error:", error); return false; }
-    return true;
-}
-
 static inline unsigned int
 calc_cell_width(Face *self) {
     unsigned int ans = 0;
@@ -260,7 +284,7 @@ void
 cell_metrics(PyObject *s, unsigned int* cell_width, unsigned int* cell_height, unsigned int* baseline, unsigned int* underline_position, unsigned int* underline_thickness) {
     Face *self = (Face*)s;
     *cell_width = calc_cell_width(self);
-    *cell_height = CALC_CELL_HEIGHT(self);
+    *cell_height = calc_cell_height(self, true);
     *baseline = font_units_to_pixels_y(self, self->ascender);
     *underline_position = MIN(*cell_height - 1, (unsigned int)font_units_to_pixels_y(self, MAX(0, self->ascender - self->underline_position)));
     *underline_thickness = MAX(1, font_units_to_pixels_y(self, self->underline_thickness));
@@ -366,9 +390,9 @@ render_bitmap(Face *self, int glyph_id, ProcessedBitmap *ans, unsigned int cell_
         // Normalize gray levels to the range [0..255]
         bitmap.num_grays = 256;
         unsigned int stride = bitmap.pitch < 0 ? -bitmap.pitch : bitmap.pitch;
-        for (unsigned int i = 0; i < bitmap.rows; ++i) {
+        for (unsigned i = 0; i < (unsigned)bitmap.rows; ++i) {
             // We only have 2 levels
-            for (unsigned int j = 0; j < bitmap.width; ++j) bitmap.buffer[i * stride + j] *= 255;
+            for (unsigned j = 0; j < (unsigned)bitmap.width; ++j) bitmap.buffer[i * stride + j] *= 255;
         }
         populate_processed_bitmap(self->face->glyph, &bitmap, ans, true);
         FT_Bitmap_Done(library, &bitmap);

kitty/glfw-wrapper.h

@@ -28,24 +28,6 @@
 #define GLFW_VERSION_REVISION       0
 /*! @} */
 
-/*! @name Boolean values
- *  @{ */
-/*! @brief One.
- *
- *  One.  Seriously.  You don't _need_ to use this symbol in your code.  It's
- *  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                   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                  false
-/*! @} */
-
 /*! @name Key and button actions
  *  @{ */
 /*! @brief The key or mouse button was released.
@@ -167,6 +149,7 @@
 #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
@@ -978,8 +961,8 @@ typedef void (* GLFWwindowrefreshfun)(GLFWwindow*);
  *  This is the function signature for window focus callback functions.
  *
  *  @param[in] window The window that gained or lost input focus.
- *  @param[in] focused `GLFW_TRUE` if the window was given input focus, or
- *  `GLFW_FALSE` if it lost it.
+ *  @param[in] focused `true` if the window was given input focus, or
+ *  `false` if it lost it.
  *
  *  @sa @ref window_focus
  *  @sa @ref glfwSetWindowFocusCallback
@@ -995,7 +978,7 @@ typedef void (* GLFWwindowfocusfun)(GLFWwindow*,int);
  *  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`
+ *  @param[in] occluded `true` if the window was occluded, or `false`
  *  if the window is no longer occluded.
  *
  *  @sa @ref window_occlusion
@@ -1014,8 +997,8 @@ typedef void (* GLFWwindowocclusionfun)(GLFWwindow*, bool);
  *  functions.
  *
  *  @param[in] window The window that was iconified or restored.
- *  @param[in] iconified `GLFW_TRUE` if the window was iconified, or
- *  `GLFW_FALSE` if it was restored.
+ *  @param[in] iconified `true` if the window was iconified, or
+ *  `false` if it was restored.
  *
  *  @sa @ref window_iconify
  *  @sa @ref glfwSetWindowIconifyCallback
@@ -1032,8 +1015,8 @@ typedef void (* GLFWwindowiconifyfun)(GLFWwindow*,int);
  *  functions.
  *
  *  @param[in] window The window that was maximized or restored.
- *  @param[in] iconified `GLFW_TRUE` if the window was maximized, or
- *  `GLFW_FALSE` if it was restored.
+ *  @param[in] iconified `true` if the window was maximized, or
+ *  `false` if it was restored.
  *
  *  @sa @ref window_maximize
  *  @sa glfwSetWindowMaximizeCallback
@@ -1125,8 +1108,8 @@ typedef void (* GLFWcursorposfun)(GLFWwindow*,double,double);
  *  This is the function signature for cursor enter/leave callback functions.
  *
  *  @param[in] window The window that received the event.
- *  @param[in] entered `GLFW_TRUE` if the cursor entered the window's client
- *  area, or `GLFW_FALSE` if it left it.
+ *  @param[in] entered `true` if the cursor entered the window's client
+ *  area, or `false` if it left it.
  *
  *  @sa @ref cursor_enter
  *  @sa @ref glfwSetCursorEnterCallback
@@ -1378,9 +1361,9 @@ typedef struct GLFWgamepadstate
  *  succeeds, you should call @ref glfwTerminate before the application exits.
  *
  *  Additional calls to this function after successful initialization but before
- *  termination will return `GLFW_TRUE` immediately.
+ *  termination will return `true` immediately.
  *
- *  @return `GLFW_TRUE` if successful, or `GLFW_FALSE` if an
+ *  @return `true` if successful, or `false` if an
  *  [error](@ref error_handling) occurred.
  *
  *  @errors Possible errors include @ref GLFW_PLATFORM_ERROR.

kitty/glfw.c

@@ -34,6 +34,8 @@ request_tick_callback(void) {
 #endif
 }
 
+static int min_width = 100, min_height = 100;
+
 void
 update_os_window_viewport(OSWindow *window, bool notify_boss) {
     int w, h, fw, fh;
@@ -42,6 +44,10 @@ update_os_window_viewport(OSWindow *window, bool notify_boss) {
     if (fw == window->viewport_width && fh == window->viewport_height && w == window->window_width && h == window->window_height) {
         return; // no change, ignore
     }
+    if (fw / w > 5 || fh / h > 5 || fw < min_width || fh < min_height || fw < w || fh < h) {
+        log_error("Invalid geometry ignored: framebuffer: %dx%d window: %dx%d\n", fw, fh, w, h);
+        return;
+    }
     window->viewport_width = fw; window->viewport_height = fh;
     double xr = window->viewport_x_ratio, yr = window->viewport_y_ratio;
     window->viewport_x_ratio = w > 0 ? (double)window->viewport_width / (double)w : xr;
@@ -51,8 +57,8 @@ update_os_window_viewport(OSWindow *window, bool notify_boss) {
     bool dpi_changed = (xr != 0.0 && xr != window->viewport_x_ratio) || (yr != 0.0 && yr != window->viewport_y_ratio) || (xdpi != window->logical_dpi_x) || (ydpi != window->logical_dpi_y);
 
     window->viewport_size_dirty = true;
-    window->viewport_width = MAX(window->viewport_width, 100);
-    window->viewport_height = MAX(window->viewport_height, 100);
+    window->viewport_width = MAX(window->viewport_width, min_width);
+    window->viewport_height = MAX(window->viewport_height, min_height);
     window->window_width = MAX(w, 100);
     window->window_height = MAX(h, 100);
     if (notify_boss) {
@@ -99,11 +105,20 @@ show_mouse_cursor(GLFWwindow *w) {
     glfwSetInputMode(w, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
 }
 
-static int min_width = 100, min_height = 100;
-
 void
 blank_os_window(OSWindow *w) {
-    blank_canvas(w->is_semi_transparent ? w->background_opacity : 1.0f);
+    color_type color = OPT(background);
+    if (w->num_tabs > 0) {
+        Tab *t = w->tabs + w->active_tab;
+        if (t->num_windows == 1) {
+            Window *w = t->windows + t->active_window;
+            Screen *s = w->render_data.screen;
+            if (s) {
+                color = colorprofile_to_color(s->color_profile, s->color_profile->overridden.default_bg, s->color_profile->configured.default_bg);
+            }
+        }
+    }
+    blank_canvas(w->is_semi_transparent ? w->background_opacity : 1.0f, color);
 }
 
 static void
@@ -387,6 +402,20 @@ toggle_fullscreen_for_os_window(OSWindow *w) {
     return false;
 }
 
+static bool
+toggle_maximized_for_os_window(OSWindow *w) {
+    bool maximized = false;
+    if (w && w->handle) {
+        if (glfwGetWindowAttrib(w->handle, GLFW_MAXIMIZED)) {
+            glfwRestoreWindow(w->handle);
+        } else {
+            glfwMaximizeWindow(w->handle);
+            maximized = true;
+        }
+    }
+    return maximized;
+}
+
 
 #ifdef __APPLE__
 static int
@@ -477,7 +506,7 @@ create_os_window(PyObject UNUSED *self, PyObject *args) {
     // We use a temp window to avoid the need to set the window size after
     // creation, which causes a resize event and all the associated processing.
     // The temp window is used to get the DPI.
-    glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
+    glfwWindowHint(GLFW_VISIBLE, false);
     GLFWwindow *common_context = global_state.num_os_windows ? global_state.os_windows[0].handle : NULL;
 #ifdef __APPLE__
     if (is_first_window && !application_quit_canary) {
@@ -502,7 +531,7 @@ create_os_window(PyObject UNUSED *self, PyObject *args) {
     // https://github.com/glfw/glfw/issues/1268 It doesn't matter since there
     // is no startup notification in Wayland anyway. It amazes me that anyone
     // uses Wayland as anything other than a butt for jokes.
-    if (global_state.is_wayland) glfwWindowHint(GLFW_VISIBLE, GLFW_TRUE);
+    if (global_state.is_wayland) glfwWindowHint(GLFW_VISIBLE, true);
     GLFWwindow *glfw_window = glfwCreateWindow(width, height, title, NULL, temp_window);
     glfwDestroyWindow(temp_window); temp_window = NULL;
     if (glfw_window == NULL) { PyErr_SetString(PyExc_ValueError, "Failed to create GLFWwindow"); return NULL; }
@@ -513,7 +542,7 @@ create_os_window(PyObject UNUSED *self, PyObject *args) {
     bool is_semi_transparent = glfwGetWindowAttrib(glfw_window, GLFW_TRANSPARENT_FRAMEBUFFER);
     // blank the window once so that there is no initial flash of color
     // changing, in case the background color is not black
-    blank_canvas(is_semi_transparent ? OPT(background_opacity) : 1.0f);
+    blank_canvas(is_semi_transparent ? OPT(background_opacity) : 1.0f, OPT(background));
 #ifndef __APPLE__
     if (is_first_window) glfwSwapInterval(OPT(sync_to_monitor) && !global_state.is_wayland ? 1 : 0);
 #endif
@@ -818,7 +847,8 @@ get_content_scale_for_window(PYNOARG) {
 static PyObject*
 set_clipboard_string(PyObject UNUSED *self, PyObject *args) {
     char *title;
-    if(!PyArg_ParseTuple(args, "s", &title)) return NULL;
+    Py_ssize_t sz;
+    if(!PyArg_ParseTuple(args, "s#", &title, &sz)) return NULL;
     OSWindow *w = current_os_window();
     if (w) glfwSetClipboardString(w->handle, title);
     Py_RETURN_NONE;
@@ -832,6 +862,14 @@ toggle_fullscreen(PYNOARG) {
     Py_RETURN_FALSE;
 }
 
+static PyObject*
+toggle_maximized(PYNOARG) {
+    OSWindow *w = current_os_window();
+    if (!w) Py_RETURN_NONE;
+    if (toggle_maximized_for_os_window(w)) { Py_RETURN_TRUE; }
+    Py_RETURN_FALSE;
+}
+
 static PyObject*
 change_os_window_state(PyObject *self UNUSED, PyObject *args) {
     char *state;
@@ -954,7 +992,8 @@ get_primary_selection(PYNOARG) {
 static PyObject*
 set_primary_selection(PyObject UNUSED *self, PyObject *args) {
     char *text;
-    if (!PyArg_ParseTuple(args, "s", &text)) return NULL;
+    Py_ssize_t sz;
+    if (!PyArg_ParseTuple(args, "s#", &text, &sz)) return NULL;
     if (glfwSetPrimarySelectionString) {
         OSWindow *w = current_os_window();
         if (w) glfwSetPrimarySelectionString(w->handle, text);
@@ -1101,6 +1140,7 @@ static PyMethodDef module_methods[] = {
     METHODB(ring_bell, METH_NOARGS),
     METHODB(set_clipboard_string, METH_VARARGS),
     METHODB(toggle_fullscreen, METH_NOARGS),
+    METHODB(toggle_maximized, METH_NOARGS),
     METHODB(change_os_window_state, METH_VARARGS),
     METHODB(glfw_window_hint, METH_VARARGS),
     METHODB(get_primary_selection, METH_NOARGS),
@@ -1136,7 +1176,7 @@ init_glfw(PyObject *m) {
     ADDC(GLFW_RELEASE);
     ADDC(GLFW_PRESS);
     ADDC(GLFW_REPEAT);
-    ADDC(GLFW_TRUE); ADDC(GLFW_FALSE);
+    ADDC(true); ADDC(false);
     ADDC(GLFW_IBEAM_CURSOR); ADDC(GLFW_HAND_CURSOR); ADDC(GLFW_ARROW_CURSOR);
 
 // --- Keys --------------------------------------------------------------------
@@ -1196,6 +1236,7 @@ init_glfw(PyObject *m) {
     ADDC(GLFW_KEY_WORLD_1);
     ADDC(GLFW_KEY_WORLD_2);
     ADDC(GLFW_KEY_PLUS);
+    ADDC(GLFW_KEY_UNDERSCORE);
 
 // --- Function keys -----------------------------------------------------------
     ADDC(GLFW_KEY_ESCAPE);

kitty/graphics.c

@@ -77,14 +77,6 @@ dealloc(GraphicsManager* self) {
 
 static size_t internal_id_counter = 1;
 
-static inline void
-remove_from_array(void *array, size_t item_size, size_t idx, size_t array_count) {
-    size_t num_to_right = array_count - 1 - idx;
-    uint8_t *p = (uint8_t*)array;
-    if (num_to_right > 0) memmove(p + (idx * item_size), p + ((idx + 1) * item_size), num_to_right * item_size);
-    memset(p + (item_size * (array_count - 1)), 0, item_size);
-}
-
 static inline Image*
 img_by_internal_id(GraphicsManager *self, size_t id) {
     for (size_t i = 0; i < self->image_count; i++) {
@@ -104,7 +96,7 @@ img_by_client_id(GraphicsManager *self, uint32_t id) {
 static inline void
 remove_image(GraphicsManager *self, size_t idx) {
     free_image(self, self->images + idx);
-    remove_from_array(self->images, sizeof(Image), idx, self->image_count--);
+    remove_i_from_array(self->images, idx, self->image_count);
     self->layers_dirty = true;
 }
 
@@ -607,7 +599,7 @@ filter_refs(GraphicsManager *self, const void* data, bool free_images, bool (*fi
             for (j = img->refcnt; j-- > 0;) {
                 ref = img->refs + j;
                 if (filter_func(ref, img, data, cell)) {
-                    remove_from_array(img->refs, sizeof(ImageRef), j, img->refcnt--);
+                    remove_i_from_array(img->refs, j, img->refcnt);
                 }
             }
             if (img->refcnt == 0 && (free_images || img->client_id == 0)) remove_image(self, i);

kitty/key_encoding.py

@@ -128,7 +128,8 @@ ENCODING = {
     'X': 'p',
     'Y': 'q',
     'Z': 'r',
-    'PLUS': 'Bi'
+    'PLUS': 'Bi',
+    'UNDERSCORE': 'Bj'
 }
 KEY_MAP = {
     32: 'A',
@@ -182,6 +183,7 @@ KEY_MAP = {
     161: 'w',
     162: 'x',
     163: 'Bi',
+    164: 'Bj',
     256: 'y',
     257: 'z',
     258: '0',

kitty/key_names.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python
+# vim:fileencoding=utf-8
+# License: GPLv3 Copyright: 2019, Kovid Goyal <kovid at kovidgoyal.net>
+
+import sys
+
+from .constants import is_macos
+
+
+def null_lookup(name, case_sensitive=False):
+    pass
+
+
+if is_macos:
+    def get_key_name_lookup():
+        return null_lookup
+else:
+
+    def load_libxkb_lookup():
+        import ctypes
+        lib = ctypes.CDLL('libxkbcommon.so')
+        f = lib.xkb_keysym_from_name
+        f.argtypes = [ctypes.c_char_p, ctypes.c_int]
+        f.restype = ctypes.c_int
+
+        def xkb_lookup(name, case_sensitive=False):
+            name = name.encode('utf-8')
+            return f(name, int(case_sensitive)) or None
+
+        return xkb_lookup
+
+    def get_key_name_lookup():
+        ans = getattr(get_key_name_lookup, 'ans', None)
+        if ans is None:
+            try:
+                ans = load_libxkb_lookup()
+            except Exception as e:
+                print('Failed to load libxkbcommon.xkb_keysym_from_name with error:', e, file=sys.stderr)
+                ans = null_lookup
+            get_key_name_lookup.ans = ans
+        return ans

kitty/keys.c

@@ -223,7 +223,7 @@ PYWRAP1(key_to_bytes) {
 PYWRAP1(key_for_native_key_name) {
     const char *name;
     int case_sensitive = 0;
-    PA("s|p", &name, case_sensitive);
+    PA("s|p", &name, &case_sensitive);
 #ifndef __APPLE__
     if (glfwGetXKBScancode) {  // if this function is called before GLFW is initialized glfwGetXKBScancode will be NULL
         int scancode = glfwGetXKBScancode(name, case_sensitive);

kitty/keys.py

@@ -121,6 +121,7 @@ control_codes.update({
     enumerate(range(defines.GLFW_KEY_A, defines.GLFW_KEY_RIGHT_BRACKET + 1))
 })
 control_codes[defines.GLFW_KEY_GRAVE_ACCENT] = (0,)
+control_codes[defines.GLFW_KEY_UNDERSCORE] = (0,)
 control_codes[defines.GLFW_KEY_SPACE] = (0,)
 control_codes[defines.GLFW_KEY_2] = (0,)
 control_codes[defines.GLFW_KEY_3] = (27,)
@@ -206,8 +207,8 @@ UN_SHIFTED_PRINTABLE.update(pmap(
     " ',-./;="
 ))
 UN_SHIFTED_PRINTABLE.update(pmap(
-    'LEFT_BRACKET BACKSLASH RIGHT_BRACKET GRAVE_ACCENT',
-    "[\\]`"
+    'LEFT_BRACKET BACKSLASH RIGHT_BRACKET GRAVE_ACCENT UNDERSCORE',
+    "[\\]`_"
 ))
 SHIFTED_PRINTABLE = UN_SHIFTED_PRINTABLE.copy()
 SHIFTED_PRINTABLE.update({

kitty/layout.py

@@ -18,6 +18,7 @@ all_borders = True, True, True, True
 no_borders = False, False, False, False
 draw_minimal_borders = False
 draw_active_borders = True
+align_top_left = False
 
 
 def idx_for_id(win_id, windows):
@@ -26,10 +27,11 @@ def idx_for_id(win_id, windows):
             return i
 
 
-def set_draw_borders_options(opts):
-    global draw_minimal_borders, draw_active_borders
+def set_layout_options(opts):
+    global draw_minimal_borders, draw_active_borders, align_top_left
     draw_minimal_borders = opts.draw_minimal_borders and opts.window_margin_width == 0
     draw_active_borders = opts.active_border_color is not None
+    align_top_left = opts.placement_strategy == 'top-left'
 
 
 def layout_dimension(start_at, length, cell_length, decoration_pairs, left_align=False, bias=None):
@@ -52,7 +54,7 @@ def layout_dimension(start_at, length, cell_length, decoration_pairs, left_align
         inner_length = cells_in_window * cell_length
         return inner_length + decoration_pairs[i][1]
 
-    if bias is not None and number_of_windows > 1 and len(bias) == number_of_windows and cells_per_window > 5:
+    if bias is not None and 1 < number_of_windows == len(bias) and cells_per_window > 5:
         cells_map = [int(b * number_of_cells) for b in bias]
         while min(cells_map) < 5:
             maxi, mini = map(cells_map.index, (max(cells_map), min(cells_map)))
@@ -86,9 +88,9 @@ def window_geometry(xstart, xnum, ystart, ynum):
     return WindowGeometry(left=xstart, top=ystart, xnum=xnum, ynum=ynum, right=xstart + cell_width * xnum, bottom=ystart + cell_height * ynum)
 
 
-def layout_single_window(xdecoration_pairs, ydecoration_pairs):
-    xstart, xnum = next(layout_dimension(central.left, central.width, cell_width, xdecoration_pairs))
-    ystart, ynum = next(layout_dimension(central.top, central.height, cell_height, ydecoration_pairs))
+def layout_single_window(xdecoration_pairs, ydecoration_pairs, left_align=False):
+    xstart, xnum = next(layout_dimension(central.left, central.width, cell_width, xdecoration_pairs, left_align=align_top_left))
+    ystart, ynum = next(layout_dimension(central.top, central.height, cell_height, ydecoration_pairs, left_align=align_top_left))
     return window_geometry(xstart, xnum, ystart, ynum)
 
 
@@ -368,12 +370,12 @@ class Layout:  # {{{
     def xlayout(self, num, bias=None):
         decoration = self.margin_width + self.border_width + self.padding_width
         decoration_pairs = tuple(repeat((decoration, decoration), num))
-        return layout_dimension(central.left, central.width, cell_width, decoration_pairs, bias=bias)
+        return layout_dimension(central.left, central.width, cell_width, decoration_pairs, bias=bias, left_align=align_top_left)
 
     def ylayout(self, num, left_align=True, bias=None):
         decoration = self.margin_width + self.border_width + self.padding_width
         decoration_pairs = tuple(repeat((decoration, decoration), num))
-        return layout_dimension(central.top, central.height, cell_height, decoration_pairs, bias=bias)
+        return layout_dimension(central.top, central.height, cell_height, decoration_pairs, bias=bias, left_align=align_top_left)
 
     def simple_blank_rects(self, first_window, last_window):
         br = self.blank_rects
@@ -417,7 +419,7 @@ class Stack(Layout):  # {{{
     def do_layout(self, windows, active_window_idx):
         mw = self.margin_width if self.single_window_margin_width < 0 else self.single_window_margin_width
         decoration_pairs = ((mw + self.padding_width, mw + self.padding_width),)
-        wg = layout_single_window(decoration_pairs, decoration_pairs)
+        wg = layout_single_window(decoration_pairs, decoration_pairs, left_align=align_top_left)
         for i, w in enumerate(windows):
             w.set_geometry(i, wg)
             if w.is_visible_in_layout:

kitty/main.py

@@ -6,6 +6,7 @@ import locale
 import os
 import sys
 from contextlib import contextmanager
+from contextlib import suppress
 
 from .borders import load_borders_program
 from .boss import Boss
@@ -66,19 +67,15 @@ def talk_to_instance(args):
 
     data = json.dumps(data, ensure_ascii=False).encode('utf-8')
     single_instance.socket.sendall(data)
-    try:
+    with suppress(EnvironmentError):
         single_instance.socket.shutdown(socket.SHUT_RDWR)
-    except EnvironmentError:
-        pass
     single_instance.socket.close()
 
     if args.wait_for_single_instance_window_close:
         conn = notify_socket.accept()[0]
         conn.recv(1)
-        try:
+        with suppress(EnvironmentError):
             conn.shutdown(socket.SHUT_RDWR)
-        except EnvironmentError:
-            pass
         conn.close()
 
 
@@ -87,8 +84,8 @@ def load_all_shaders(semi_transparent=0):
     load_borders_program()
 
 
-def init_glfw(debug_keyboard=False):
-    glfw_module = 'cocoa' if is_macos else ('wayland' if is_wayland else 'x11')
+def init_glfw(opts, debug_keyboard=False):
+    glfw_module = 'cocoa' if is_macos else ('wayland' if is_wayland(opts) else 'x11')
     if not glfw_init(glfw_path(glfw_module), debug_keyboard):
         raise SystemExit('GLFW initialization failed')
     return glfw_module
@@ -119,7 +116,7 @@ def _run_app(opts, args, bad_lines=()):
     new_os_window_trigger = get_new_os_window_trigger(opts)
     if is_macos and opts.macos_custom_beam_cursor:
         set_custom_ibeam_cursor()
-    if not is_wayland and not is_macos:  # no window icons on wayland
+    if not is_wayland() and not is_macos:  # no window icons on wayland
         with open(logo_data_file, 'rb') as f:
             set_default_window_icon(f.read(), 256, 256)
     load_shader_programs.use_selection_fg = opts.selection_foreground is not None
@@ -142,7 +139,7 @@ def _run_app(opts, args, bad_lines=()):
 
 def run_app(opts, args, bad_lines=()):
     set_scale(opts.box_drawing_scale)
-    set_options(opts, is_wayland, args.debug_gl, args.debug_font_fallback)
+    set_options(opts, is_wayland(), args.debug_gl, args.debug_font_fallback)
     set_font_family(opts, debug_font_matching=args.debug_font_fallback)
     try:
         _run_app(opts, args, bad_lines)
@@ -212,10 +209,8 @@ def setup_environment(opts, args):
 
 
 def _main():
-    try:
+    with suppress(AttributeError):  # python compiled without threading
         sys.setswitchinterval(1000.0)  # we have only a single python thread
-    except AttributeError:
-        pass  # python compiled without threading
     if is_macos:
         ensure_macos_locale()
     try:
@@ -249,7 +244,6 @@ def _main():
     args, rest = parse_args(args=args)
     args.args = rest
     if args.debug_config:
-        init_glfw(args.debug_keyboard)  # needed for parsing native keysyms
         create_opts(args, debug_config=True)
         return
     if getattr(args, 'detach', False):
@@ -263,9 +257,9 @@ def _main():
         if not is_first:
             talk_to_instance(args)
             return
-    init_glfw(args.debug_keyboard)  # needed for parsing native keysyms
     bad_lines = []
     opts = create_opts(args, accumulate_bad_lines=bad_lines)
+    init_glfw(opts, args.debug_keyboard)
     setup_environment(opts, args)
     try:
         with setup_profiling(args):

kitty/remote_control.py

@@ -8,6 +8,7 @@ import re
 import sys
 import types
 from functools import partial
+from contextlib import suppress
 
 from .cli import emph, parse_args
 from .cmds import cmap, parse_subcommand_cli
@@ -67,10 +68,8 @@ class SocketIO:
 
     def __exit__(self, *a):
         import socket
-        try:
+        with suppress(EnvironmentError):  # on some OSes such as macOS the socket is already closed at this point
             self.socket.shutdown(socket.SHUT_RDWR)
-        except EnvironmentError:
-            pass  # on some OSes such as macOS the socket is already closed at this point
         self.socket.close()
 
     def send(self, data):

kitty/rgb.py

@@ -4,6 +4,7 @@
 
 import re
 from collections import namedtuple
+from contextlib import suppress
 
 Color = namedtuple('Color', 'red green blue')
 
@@ -62,13 +63,11 @@ def to_color(raw, validate=False):
     if ans is not None:
         return ans
     val = None
-    try:
+    with suppress(Exception):
         if raw.startswith('#'):
             val = parse_sharp(raw[1:])
         elif raw[:4].lower() == 'rgb:':
             val = parse_rgb(raw[4:])
-    except Exception:
-        pass
     if val is None and validate:
         raise ValueError('Invalid color name: {}'.format(raw))
     return val

kitty/screen.c

@@ -2310,6 +2310,7 @@ static PyMemberDef members[] = {
     {"grman", T_OBJECT_EX, offsetof(Screen, grman), READONLY, "grman"},
     {"color_profile", T_OBJECT_EX, offsetof(Screen, color_profile), READONLY, "color_profile"},
     {"linebuf", T_OBJECT_EX, offsetof(Screen, linebuf), READONLY, "linebuf"},
+    {"main_linebuf", T_OBJECT_EX, offsetof(Screen, main_linebuf), READONLY, "main_linebuf"},
     {"historybuf", T_OBJECT_EX, offsetof(Screen, historybuf), READONLY, "historybuf"},
     {"scrolled_by", T_UINT, offsetof(Screen, scrolled_by), READONLY, "scrolled_by"},
     {"lines", T_UINT, offsetof(Screen, lines), READONLY, "lines"},

kitty/shaders.c

@@ -476,8 +476,8 @@ set_cell_uniforms(float current_inactive_text_alpha) {
 }
 
 void
-blank_canvas(float background_opacity) {
-#define C(shift) (((GLfloat)((OPT(background) >> shift) & 0xFF)) / 255.0f)
+blank_canvas(float background_opacity, color_type color) {
+#define C(shift) (((GLfloat)((color >> shift) & 0xFF)) / 255.0f)
         glClearColor(C(16), C(8), C(0), background_opacity);
 #undef C
         glClear(GL_COLOR_BUFFER_BIT);

kitty/shell.py

@@ -8,6 +8,7 @@ import shlex
 import sys
 import traceback
 from functools import lru_cache
+from contextlib import suppress
 
 from .cli import (
     emph, green, italic, parse_option_spec, print_help_for_seq, title
@@ -68,10 +69,8 @@ class Completer:
     def __init__(self):
         self.matches = []
         ddir = cache_dir()
-        try:
+        with suppress(FileExistsError):
             os.makedirs(ddir)
-        except FileExistsError:
-            pass
         self.history_path = os.path.join(ddir, 'shell.history')
 
     def complete(self, text, state):
@@ -86,10 +85,8 @@ class Completer:
             return self.matches[state]
 
     def __enter__(self):
-        try:
+        with suppress(Exception):
             readline.read_history_file(self.history_path)
-        except Exception:
-            pass
         readline.set_completer(self.complete)
         delims = readline.get_completer_delims()
         readline.set_completer_delims(delims.replace('-', ''))

kitty/state.c

@@ -10,14 +10,12 @@
 
 GlobalState global_state = {{0}};
 
-#define REMOVER(array, qid, count, structure, destroy, capacity) { \
+#define REMOVER(array, qid, count, destroy, capacity) { \
     for (size_t i = 0; i < count; i++) { \
         if (array[i].id == qid) { \
             destroy(array + i); \
-            memset(array + i, 0, sizeof(structure)); \
-            size_t num_to_right = count - 1 - i; \
-            if (num_to_right) memmove(array + i, array + i + 1, num_to_right * sizeof(structure)); \
-            (count)--; \
+            memset(array + i, 0, sizeof(array[0])); \
+            remove_i_from_array(array, i, count); \
             break; \
         } \
     }}
@@ -140,7 +138,7 @@ destroy_window(Window *w) {
 
 static inline void
 remove_window_inner(Tab *tab, id_type id) {
-    REMOVER(tab->windows, id, tab->num_windows, Window, destroy_window, tab->capacity);
+    REMOVER(tab->windows, id, tab->num_windows, destroy_window, tab->capacity);
 }
 
 static inline void
@@ -162,7 +160,7 @@ destroy_tab(Tab *tab) {
 static inline void
 remove_tab_inner(OSWindow *os_window, id_type id) {
     make_os_window_context_current(os_window);
-    REMOVER(os_window->tabs, id, os_window->num_tabs, Tab, destroy_tab, os_window->capacity);
+    REMOVER(os_window->tabs, id, os_window->num_tabs, destroy_tab, os_window->capacity);
 }
 
 static inline void
@@ -194,7 +192,7 @@ remove_os_window(id_type os_window_id) {
     END_WITH_OS_WINDOW
     if (found) {
         WITH_OS_WINDOW_REFS
-            REMOVER(global_state.os_windows, os_window_id, global_state.num_os_windows, OSWindow, destroy_os_window_item, global_state.capacity);
+            REMOVER(global_state.os_windows, os_window_id, global_state.num_os_windows, destroy_os_window_item, global_state.capacity);
         END_WITH_OS_WINDOW_REFS
         update_os_window_references();
     }

kitty/state.h

@@ -214,7 +214,7 @@ void update_surface_size(int, int, uint32_t);
 void free_texture(uint32_t*);
 void send_image_to_gpu(uint32_t*, const void*, int32_t, int32_t, bool, bool);
 void send_sprite_to_gpu(FONTS_DATA_HANDLE fg, unsigned int, unsigned int, unsigned int, pixel*);
-void blank_canvas(float);
+void blank_canvas(float, color_type);
 void blank_os_window(OSWindow *);
 void set_titlebar_color(OSWindow *w, color_type color);
 FONTS_DATA_HANDLE load_fonts_data(double, double, double);

kitty/tab_bar.py

@@ -45,12 +45,14 @@ def draw_tab_with_separator(draw_data, screen, tab, before, max_title_length, in
     if draw_data.leading_spaces:
         screen.draw(' ' * draw_data.leading_spaces)
     draw_title(draw_data, screen, tab, index)
-    if draw_data.trailing_spaces:
-        screen.draw(' ' * draw_data.trailing_spaces)
+    trailing_spaces = min(max_title_length - 1, draw_data.trailing_spaces)
+    max_title_length -= trailing_spaces
     extra = screen.cursor.x - before - max_title_length
     if extra > 0:
         screen.cursor.x -= extra + 1
         screen.draw('…')
+    if trailing_spaces:
+        screen.draw(' ' * trailing_spaces)
     end = screen.cursor.x
     screen.cursor.bold = screen.cursor.italic = False
     screen.cursor.fg = screen.cursor.bg = 0

kitty/tabs.py

@@ -5,6 +5,7 @@
 import weakref
 from collections import deque, namedtuple
 from functools import partial
+from contextlib import suppress
 
 from .borders import Borders
 from .child import Child
@@ -28,10 +29,8 @@ def SpecialWindow(cmd, stdin=None, override_title=None, cwd_from=None, cwd=None,
 
 
 def add_active_id_to_history(items, item_id, maxlen=64):
-    try:
+    with suppress(ValueError):
         items.remove(item_id)
-    except ValueError:
-        pass
     items.append(item_id)
     if len(items) > maxlen:
         items.popleft()
@@ -223,7 +222,7 @@ class Tab:  # {{{
         if env:
             fenv.update(env)
         fenv['KITTY_WINDOW_ID'] = str(next_window_id())
-        if not is_macos and not is_wayland:
+        if not is_macos and not is_wayland():
             try:
                 fenv['WINDOWID'] = str(x11_window_id(self.os_window_id))
             except Exception:
@@ -481,7 +480,7 @@ class TabManager:  # {{{
             self.set_active_tab_idx((self.active_tab_idx + len(self.tabs) + delta) % len(self.tabs))
 
     def goto_tab(self, tab_num):
-        if tab_num < len(self.tabs) and 0 <= tab_num:
+        if 0 <= tab_num < len(self.tabs):
             self.set_active_tab_idx(tab_num)
         elif tab_num < 0:
             try:

kitty/update_check.py

@@ -7,6 +7,7 @@ import subprocess
 import time
 from collections import namedtuple
 from urllib.request import urlopen
+from contextlib import suppress
 
 from .config import atomic_save
 from .constants import cache_dir, get_boss, kitty_exe, version
@@ -56,7 +57,7 @@ def parse_line(line):
 
 def read_cache():
     notified_versions = {}
-    try:
+    with suppress(FileNotFoundError):
         with open(version_notification_log()) as f:
             for line in f:
                 try:
@@ -64,8 +65,6 @@ def read_cache():
                 except Exception:
                     continue
                 notified_versions[n.version] = n
-    except FileNotFoundError:
-        pass
     return notified_versions
 
 
@@ -100,10 +99,8 @@ def run_worker():
     import time
     import random
     time.sleep(random.randint(1000, 4000) / 1000)
-    try:
+    with suppress(BrokenPipeError):  # happens if parent process is killed before us
         print(get_released_version())
-    except BrokenPipeError:
-        pass  # happens if parent process is killed before us
 
 
 def update_check(timer_id=None):

kitty/utils.py

@@ -11,6 +11,7 @@ import re
 import string
 import sys
 from time import monotonic
+from contextlib import suppress
 
 from .constants import (
     appname, is_macos, is_wayland, supports_primary_selection
@@ -28,19 +29,15 @@ def load_shaders(name):
 
 
 def safe_print(*a, **k):
-    try:
+    with suppress(Exception):
         print(*a, **k)
-    except Exception:
-        pass
 
 
 def log_error(*a, **k):
     from .fast_data_types import log_error_string
-    try:
+    with suppress(Exception):
         msg = k.get('sep', ' ').join(map(str, a)) + k.get('end', '')
         log_error_string(msg.replace('\0', ''))
-    except Exception:
-        pass
 
 
 def ceil_int(x):
@@ -210,7 +207,7 @@ def end_startup_notification_x11(ctx):
 
 
 def init_startup_notification(window_handle, startup_id=None):
-    if is_macos or is_wayland:
+    if is_macos or is_wayland():
         return
     if window_handle is None:
         log_error('Could not perform startup notification as window handle not present')
@@ -225,7 +222,7 @@ def init_startup_notification(window_handle, startup_id=None):
 def end_startup_notification(ctx):
     if not ctx:
         return
-    if is_macos or is_wayland:
+    if is_macos or is_wayland():
         return
     try:
         end_startup_notification_x11(ctx)
@@ -258,15 +255,11 @@ class startup_notification_handler:
 
 
 def remove_socket_file(s, path=None):
-    try:
+    with suppress(EnvironmentError):
         s.close()
-    except EnvironmentError:
-        pass
     if path:
-        try:
+        with suppress(EnvironmentError):
             os.unlink(path)
-        except EnvironmentError:
-            pass
 
 
 def unix_socket_paths(name, ext='.lock'):