/*
 * Copyright (C) 2016 Kovid Goyal <kovid at kovidgoyal.net>
 *
 * Distributed under terms of the GPL3 license.
 */

#include "state.h"
#include "cleanup.h"
#include "monotonic.h"
#include "dnd.h"
#include "charsets.h"
#include "control-codes.h"
#include <structmember.h>
#include "glfw-wrapper.h"
#ifdef __APPLE__
#include "cocoa_window.h"
#else
#include "freetype_render_ui_text.h"
#endif
#define debug debug_rendering

typedef struct mouse_cursor {
    GLFWcursor *glfw;
    bool initialized, is_custom;
} mouse_cursor;

static mouse_cursor cursors[GLFW_INVALID_CURSOR+1] = {0};

static void
apply_swap_interval(int val) {
    (void)val;
#ifndef __APPLE__
    if (val < 0) val = OPT(sync_to_monitor) && !global_state.is_wayland ? 1 : 0;
    glfwSwapInterval(val);
#endif
}

void
get_platform_dependent_config_values(void *glfw_window) {
    if (OPT(click_interval) < 0) OPT(click_interval) = glfwGetDoubleClickInterval(glfw_window);
    if (OPT(cursor_blink_interval) < 0) {
        OPT(cursor_blink_interval) = ms_to_monotonic_t(500ll);
#ifdef __APPLE__
        monotonic_t cbi = cocoa_cursor_blink_interval();
        if (cbi >= 0) OPT(cursor_blink_interval) = cbi / 2;
#endif
    }
}

static const char*
appearance_name(GLFWColorScheme appearance) {
    const char *which = NULL;
    switch (appearance) {
        case GLFW_COLOR_SCHEME_NO_PREFERENCE: which = "no_preference"; break;
        case GLFW_COLOR_SCHEME_DARK: which = "dark"; break;
        case GLFW_COLOR_SCHEME_LIGHT: which = "light"; break;
    }
    return which;
}

static void
on_system_color_scheme_change(GLFWColorScheme appearance, bool is_initial_value) {
    const char *which = appearance_name(appearance);
    debug("system color-scheme changed to: %s is_initial_value: %d\n", which, is_initial_value);
    call_boss(on_system_color_scheme_change, "sO", which, is_initial_value ? Py_True : Py_False);
}

static void
on_clipboard_lost(GLFWClipboardType which) {
    call_boss(on_clipboard_lost, "s", which == GLFW_CLIPBOARD ? "clipboard" : "primary");
}

static bool
is_continuation_byte(unsigned char byte) {
    return (byte & 0xC0) == 0x80; // Continuation bytes have the form 10xxxxxx
}

static int
utf8_sequence_length(unsigned char byte) {
    if ((byte & 0x80) == 0) return 1; // 0xxxxxxx: Single-byte ASCII
    if ((byte & 0xE0) == 0xC0) return 2; // 110xxxxx: Two-byte sequence
    if ((byte & 0xF0) == 0xE0) return 3; // 1110xxxx: Three-byte sequence
    if ((byte & 0xF8) == 0xF0) return 4; // 11110xxx: Four-byte sequence
    return -1; // Invalid first byte
}

// Function to remove invalid UTF-8 bytes from the end of a string
static void
remove_invalid_utf8_from_end(char *str, size_t len) {
    if (!len) return;
    // Start from the end of the string and move backward
    size_t i = len - 1;
    while (i > 0) {
        if (is_continuation_byte((unsigned char)str[i])) {
            // Continue backward to find the start of the potential UTF-8 sequence
            size_t start = i;
            while (start > 0 && is_continuation_byte((unsigned char)str[start])) start--;
            // Check if the sequence is valid
            int seq_len = utf8_sequence_length((unsigned char)str[start]);
            if (seq_len > 0 && start + seq_len == len) return; // Valid sequence found, stop trimming
            // Invalid sequence, trim it
            str[start] = '\0';
            len = start;
            i = start - 1;
        } else {
            // Not a continuation byte, check if it's a valid start byte
            int seq_len = utf8_sequence_length((unsigned char)str[i]);
            if (seq_len > 0 && i + seq_len == len) return; // Valid sequence found, stop trimming
            // Invalid byte, trim it
            str[i] = '\0';
            len = i;
            i--;
        }
    }
    // Handle the case where the entire string is invalid
    if (utf8_sequence_length((unsigned char)str[0]) < 0) str[0] = '\0';
}

static void
strip_csi_(const char *title, char *buf, size_t bufsz) {
    enum { NORMAL, IN_ESC, IN_CSI} state = NORMAL;
    char *dest = buf, *last = &buf[bufsz-1];
    *dest = 0; *last = 0;

    for (; *title && dest < last; title++) {
        const unsigned char ch = *title;
        switch (state) {
            case NORMAL: {
                if (ch == 0x1b) { state = IN_ESC; }
                else *(dest++) = ch;
            } break;
            case IN_ESC: {
                if (ch == '[') { state = IN_CSI; }
                else {
                    if (ch >= ' ' && ch != DEL) *(dest++) = ch;
                    state = NORMAL;
                }
            } break;
            case IN_CSI: {
                if (!(('0' <= ch && ch <= '9') || ch == ';' || ch == ':')) {
                    if (ch > DEL) *(dest++) = ch;  // UTF-8 multibyte
                    state = NORMAL;
                }
            } break;
        }
    }
    *dest = 0;
    remove_invalid_utf8_from_end(buf, dest - buf);
}


void
update_menu_bar_title(PyObject *title UNUSED) {
#ifdef __APPLE__
    static char buf[2048];
    strip_csi_(PyUnicode_AsUTF8(title), buf, arraysz(buf));
    RAII_PyObject(stitle, PyUnicode_FromString(buf));
    if (stitle) cocoa_update_menu_bar_title(stitle);
    else PyErr_Print();
#endif
}


void
request_tick_callback(void) {
    glfwPostEmptyEvent();
}

static void
min_size_for_os_window(OSWindow *window, int *min_width, int *min_height) {
    *min_width = MAX(8u, window->fonts_data->fcm.cell_width + 1);
    *min_height = MAX(8u, window->fonts_data->fcm.cell_height + 1);
}


static void get_window_dpi(GLFWwindow *w, double *x, double *y);
static void get_window_content_scale(GLFWwindow *w, float *xscale, float *yscale, double *xdpi, double *ydpi);

static bool
set_layer_shell_config_for(OSWindow *w, GLFWLayerShellConfig *lsc) {
    if (lsc) {
        lsc->related.background_opacity = effective_os_window_alpha(w);
        lsc->related.background_blur = OPT(background_blur);
        lsc->related.color_space = OPT(macos_colorspace);
        lsc->related.use_physical_screen_frame = OPT(macos_use_physical_screen_frame);
        if (OPT(macos_ns_window_layer)) snprintf(lsc->related.ns_window_layer, sizeof(lsc->related.ns_window_layer), "%s", OPT(macos_ns_window_layer));
        else lsc->related.ns_window_layer[0] = '\0';
        w->hide_on_focus_loss = lsc->hide_on_focus_loss;
    }
    return glfwSetLayerShellConfig(w->handle, lsc);
}

void
update_os_window_viewport(OSWindow *window, bool notify_boss) {
    int w, h, fw, fh;
    glfwGetFramebufferSize(window->handle, &fw, &fh);
    glfwGetWindowSize(window->handle, &w, &h);
    double xdpi = window->fonts_data->logical_dpi_x, ydpi = window->fonts_data->logical_dpi_y, new_xdpi, new_ydpi;
    float xscale, yscale;
    get_window_content_scale(window->handle, &xscale, &yscale, &new_xdpi, &new_ydpi);

    if (fw == window->viewport_width && fh == window->viewport_height && w == window->window_width && h == window->window_height && xdpi == new_xdpi && ydpi == new_ydpi) {
        return; // no change, ignore
    }
    int min_width, min_height; min_size_for_os_window(window, &min_width, &min_height);
    window->viewport_resized_at = monotonic();
    if (w <= 0 || h <= 0 || fw < min_width || fh < min_height || (xscale >=1 && fw < w) || (yscale >= 1 && fh < h)) {
        log_error("Invalid geometry ignored: framebuffer: %dx%d window: %dx%d scale: %f %f\n", fw, fh, w, h, xscale, yscale);
        if (!window->viewport_updated_at_least_once) {
            window->viewport_width = min_width; window->viewport_height = min_height;
            window->window_width = min_width; window->window_height = min_height;
            window->viewport_x_ratio = 1; window->viewport_y_ratio = 1;
            window->viewport_size_dirty = true;
            if (notify_boss) {
                call_boss(on_window_resize, "KiiO", window->id, window->viewport_width, window->viewport_height, Py_False);
            }
        }
        return;
    }
    window->viewport_updated_at_least_once = true;
    window->viewport_width = fw; window->viewport_height = fh;
    double xr = window->viewport_x_ratio, yr = window->viewport_y_ratio;
    window->viewport_x_ratio = (double)window->viewport_width / (double)w;
    window->viewport_y_ratio = (double)window->viewport_height / (double)h;
    bool dpi_changed = (xr != 0.0 && xr != window->viewport_x_ratio) || (yr != 0.0 && yr != window->viewport_y_ratio) || (xdpi != new_xdpi) || (ydpi != new_ydpi);

    window->viewport_size_dirty = true;
    window->viewport_width = MAX(window->viewport_width, min_width);
    window->viewport_height = MAX(window->viewport_height, min_height);
    window->window_width = MAX(w, min_width);
    window->window_height = MAX(h, min_height);
    if (notify_boss) {
        call_boss(on_window_resize, "KiiO", window->id, window->viewport_width, window->viewport_height, dpi_changed ? Py_True : Py_False);
    }
    if (dpi_changed && window->is_layer_shell && window->handle) set_layer_shell_config_for(window, NULL);
}

// callbacks {{{

void
update_os_window_references(void) {
    for (size_t i = 0; i < global_state.num_os_windows; i++) {
        OSWindow *w = global_state.os_windows + i;
        if (w->handle) glfwSetWindowUserPointer(w->handle, w);
    }
}

static OSWindow*
os_window_for_glfw_window(GLFWwindow *w) {
    OSWindow *ans = glfwGetWindowUserPointer(w);
    if (ans != NULL) return ans;
    for (size_t i = 0; i < global_state.num_os_windows; i++) {
        if ((GLFWwindow*)(global_state.os_windows[i].handle) == w) {
            return global_state.os_windows + i;
        }
    }
    return NULL;
}

static bool
set_callback_window(GLFWwindow *w) {
    global_state.callback_os_window = os_window_for_glfw_window(w);
    return global_state.callback_os_window != NULL;
}

static bool
is_window_ready_for_callbacks(void) {
    OSWindow *w = global_state.callback_os_window;
    if (w->num_tabs == 0) return false;
    Tab *t = w->tabs + w->active_tab;
    if (t->num_windows == 0) return false;
    return true;
}

#define WINDOW_CALLBACK(name, fmt, ...) call_boss(name, "K" fmt, global_state.callback_os_window->id, __VA_ARGS__)

static void
show_mouse_cursor(GLFWwindow *w) {
    glfwSetInputMode(w, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
}

void
cursor_active_callback(monotonic_t now) {
    if (!global_state.callback_os_window) return;
    if (OPT(mouse_hide.unhide_wait) == 0) {
        show_mouse_cursor(global_state.callback_os_window->handle);
    } else if (OPT(mouse_hide.unhide_wait) > 0) {
            if (global_state.callback_os_window->mouse_activate_deadline == -1) {
                global_state.callback_os_window->mouse_activate_deadline = OPT(mouse_hide.unhide_wait) + now;
                global_state.callback_os_window->mouse_show_threshold = (int) (monotonic_t_to_s_double(OPT(mouse_hide.unhide_wait)) * OPT(mouse_hide.unhide_threshold));
            } else if (now < global_state.callback_os_window->mouse_activate_deadline) {
                if (global_state.callback_os_window->mouse_show_threshold > 0) {
                    global_state.callback_os_window->mouse_show_threshold--;
                }
            } else {
                if (
                        now < global_state.callback_os_window->mouse_activate_deadline + s_double_to_monotonic_t(0.5) &&
                        global_state.callback_os_window->mouse_show_threshold == 0
                ) {
                    show_mouse_cursor(global_state.callback_os_window->handle);
                }
                global_state.callback_os_window->mouse_activate_deadline = -1;
            }
    }
}

static void
window_pos_callback(GLFWwindow* window, int x UNUSED, int y UNUSED) {
    if (!set_callback_window(window)) return;
#ifdef __APPLE__
    // Apple needs IME position to be accurate before the next key event
    OSWindow *osw = global_state.callback_os_window;
    if (osw->is_focused && is_window_ready_for_callbacks()) {
        Tab *tab = osw->tabs + osw->active_tab;
        Window *w = tab->windows + tab->active_window;
        if (w->render_data.screen) update_ime_position(w, w->render_data.screen);
    }
#endif
    global_state.callback_os_window = NULL;
}

static void
window_close_callback(GLFWwindow* window) {
    if (!set_callback_window(window)) return;
    global_state.callback_os_window->close_request = CONFIRMABLE_CLOSE_REQUESTED;
    global_state.has_pending_closes = true;
    request_tick_callback();
    glfwSetWindowShouldClose(window, false);
    global_state.callback_os_window = NULL;
}

static void
window_occlusion_callback(GLFWwindow *window, bool occluded) {
    if (!set_callback_window(window)) return;
    debug("OSWindow %llu occlusion state changed, occluded: %d\n", global_state.callback_os_window->id, occluded);
    if (!occluded) global_state.check_for_active_animated_images = true;
    request_tick_callback();
    global_state.callback_os_window = NULL;
}

static void
window_iconify_callback(GLFWwindow *window, int iconified) {
    if (!set_callback_window(window)) return;
    if (!iconified) global_state.check_for_active_animated_images = true;
    request_tick_callback();
    global_state.callback_os_window = NULL;
}

#ifdef __APPLE__
static void
cocoa_out_of_sequence_render(OSWindow *window) {
    make_os_window_context_current(window);
    window->needs_render = true;

    // On macOS Tahoe, the default framebuffer can become undefined during
    // screen change events. Try to recover by recreating the drawable.
    // See https://github.com/kovidgoyal/kitty/issues/9463
    if (!current_framebuffer_is_ok()) {
        debug_rendering("Cocoa OpenGL framebuffer broken, re-creating\n");
        if (!glfwCocoaRecreateGLDrawable(window->handle) || !current_framebuffer_is_ok()) {
            debug_rendering("Cocoa OpenGL framebuffer re-creation failed\n");
            request_tick_callback();
            return;
        }
    }

    bool rendered = false;
    if (window->fonts_data->sprite_map) {
        window->needs_render = true;
        window->render_state = RENDER_FRAME_READY;
        rendered = render_os_window(window, monotonic(), true);
    }
    if (!rendered) {
        debug_rendering("Cocoa out of sequence render did not happen\n");
        blank_os_window(window);
        swap_window_buffers(window);
    }
    window->needs_render = true;
}

static void
cocoa_os_window_resized(GLFWwindow *w) {
    if (!set_callback_window(w)) return;
    if (global_state.callback_os_window->ignore_resize_events) return;
    cocoa_out_of_sequence_render(global_state.callback_os_window);
    global_state.callback_os_window = NULL;
}
#endif



void
change_live_resize_state(OSWindow *w, bool in_progress) {
    if (in_progress != w->live_resize.in_progress) {
        w->live_resize.in_progress = in_progress;
        w->live_resize.num_of_resize_events = 0;
#ifdef __APPLE__
        cocoa_out_of_sequence_render(w);
#else
        GLFWwindow *orig_ctx = make_os_window_context_current(w);
        apply_swap_interval(in_progress ? 0 : -1);
        if (orig_ctx) glfwMakeContextCurrent(orig_ctx);

#endif
    }
}

static void
live_resize_callback(GLFWwindow *w, bool started) {
    if (!set_callback_window(w)) return;
    if (global_state.callback_os_window->ignore_resize_events) return;
    global_state.callback_os_window->live_resize.from_os_notification = true;
    change_live_resize_state(global_state.callback_os_window, true);
    global_state.has_pending_resizes = true;
    if (!started) {
        global_state.callback_os_window->live_resize.os_says_resize_complete = true;
        request_tick_callback();
    }
    global_state.callback_os_window = NULL;
}

static void
framebuffer_size_callback(GLFWwindow *w, int width, int height) {
    if (!set_callback_window(w)) return;
    if (global_state.callback_os_window->ignore_resize_events) return;
    int min_width, min_height; min_size_for_os_window(global_state.callback_os_window, &min_width, &min_height);
    if (width >= min_width && height >= min_height) {
        OSWindow *window = global_state.callback_os_window;
        global_state.has_pending_resizes = true;
        change_live_resize_state(global_state.callback_os_window, true);
        window->live_resize.last_resize_event_at = monotonic();
        window->live_resize.width = MAX(0, width); window->live_resize.height = MAX(0, height);
        window->live_resize.num_of_resize_events++;
        make_os_window_context_current(window);
        set_gpu_viewport(width, height);
        request_tick_callback();
    } else log_error("Ignoring resize request for tiny size: %dx%d", width, height);
    global_state.callback_os_window = NULL;
}

static void
dpi_change_callback(GLFWwindow *w, float x_scale UNUSED, float y_scale UNUSED) {
    if (!set_callback_window(w)) return;
    if (global_state.callback_os_window->ignore_resize_events) return;
    // Ensure update_os_window_viewport() is called in the near future, it will
    // take care of DPI changes.
    OSWindow *window = global_state.callback_os_window;
    change_live_resize_state(global_state.callback_os_window, true);
    global_state.has_pending_resizes = true;
    window->live_resize.last_resize_event_at = monotonic();
    global_state.callback_os_window = NULL;
    request_tick_callback();
}

static void
refresh_callback(GLFWwindow *w) {
    if (!set_callback_window(w)) return;
    if (!global_state.callback_os_window->redraw_count) global_state.callback_os_window->redraw_count++;
    global_state.callback_os_window = NULL;
    request_tick_callback();
}

#ifndef __APPLE__
typedef struct modifier_key_state {
    bool left, right;
} modifier_key_state;

static int
key_to_modifier(uint32_t key, bool *is_left) {
    *is_left = false;
    switch(key) {
        case GLFW_FKEY_LEFT_SHIFT: *is_left = true; /* fallthrough */
        case GLFW_FKEY_RIGHT_SHIFT:
            return GLFW_MOD_SHIFT;
        case GLFW_FKEY_LEFT_CONTROL: *is_left = true; /* fallthrough */
        case GLFW_FKEY_RIGHT_CONTROL:
            return GLFW_MOD_CONTROL;
        case GLFW_FKEY_LEFT_ALT: *is_left = true; /* fallthrough */
        case GLFW_FKEY_RIGHT_ALT:
            return GLFW_MOD_ALT;
        case GLFW_FKEY_LEFT_SUPER: *is_left = true; /* fallthrough */
        case GLFW_FKEY_RIGHT_SUPER:
            return GLFW_MOD_SUPER;
        case GLFW_FKEY_LEFT_HYPER: *is_left = true; /* fallthrough */
        case GLFW_FKEY_RIGHT_HYPER:
            return GLFW_MOD_HYPER;
        case GLFW_FKEY_LEFT_META: *is_left = true; /* fallthrough */
        case GLFW_FKEY_RIGHT_META:
            return GLFW_MOD_META;
        default:
            return -1;
    }
}


static void
update_modifier_state_on_modifier_key_event(GLFWkeyevent *ev, int key_modifier, bool is_left) {
    // Update mods state to be what the kitty keyboard protocol requires, as on Linux modifier key events do not update modifier bits
    static modifier_key_state all_states[8] = {0};
    modifier_key_state *state = all_states + MIN((unsigned)__builtin_ctz(key_modifier), sizeof(all_states)-1);
    const int modifier_was_set_before_event = ev->mods & key_modifier;
    const bool is_release = ev->action == GLFW_RELEASE;
    if (modifier_was_set_before_event) {
        // a press with modifier already set means other modifier key is pressed
        if (!is_release) { if (is_left) state->right = true; else state->left = true;  }
    } else {
        // if modifier is not set before event, means both keys are released
        state->left = false; state->right = false;
    }
    if (is_release) {
        if (is_left) state->left = false; else state->right = false;
        if (modifier_was_set_before_event && !state->left && !state->right) ev->mods &= ~key_modifier;
    } else {
        if (is_left) state->left = true; else state->right = true;
        ev->mods |= key_modifier;
    }
}
#endif

static void
key_callback(GLFWwindow *w, GLFWkeyevent *ev) {
    if (!set_callback_window(w)) return;
#ifdef __APPLE__
    cocoa_clear_dock_badge_if_set();
#endif
#ifndef __APPLE__
    bool is_left;
    int key_modifier = key_to_modifier(ev->key, &is_left);
    if (key_modifier != -1) update_modifier_state_on_modifier_key_event(ev, key_modifier, is_left);
    #endif
    global_state.mods_at_last_key_or_button_event = ev->mods;
    global_state.callback_os_window->cursor_blink_zero_time = monotonic();
    if (is_window_ready_for_callbacks() && !ev->fake_event_on_focus_change) on_key_input(ev);
    global_state.callback_os_window = NULL;
    request_tick_callback();
}

static void
cursor_enter_callback(GLFWwindow *w, int entered) {
    if (!set_callback_window(w)) return;
    double x, y;
    glfwGetCursorPos(w, &x, &y);
    monotonic_t now = monotonic();
    global_state.callback_os_window->last_mouse_activity_at = now;
    double new_mouse_x = x * global_state.callback_os_window->viewport_x_ratio;
    double new_mouse_y = y * global_state.callback_os_window->viewport_y_ratio;
    // focus_follows_mouse should react to the mouse moving, not to a window
    // appearing under a stationary cursor (such as when returning to this
    // desktop/space). Detect genuine motion by comparing against the last
    // known cursor position so an enter caused by mouse motion still switches
    // focus, while a stationary reappearance does not.
    bool cursor_moved = new_mouse_x != global_state.callback_os_window->mouse_x || new_mouse_y != global_state.callback_os_window->mouse_y;
    global_state.callback_os_window->mouse_x = new_mouse_x;
    global_state.callback_os_window->mouse_y = new_mouse_y;
    if (entered) {
        debug_input("Mouse cursor entered window: %llu at %fx%f\n", global_state.callback_os_window->id, x, y);
        cursor_active_callback(now);
        if (is_window_ready_for_callbacks()) enter_event(global_state.mods_at_last_key_or_button_event, cursor_moved);
    } else {
        debug_input("Mouse cursor left window: %llu\n", global_state.callback_os_window->id);
        if (is_window_ready_for_callbacks()) leave_event(global_state.mods_at_last_key_or_button_event);
    }
    request_tick_callback();
    global_state.callback_os_window = NULL;
}

static void
mouse_button_callback(GLFWwindow *w, int button, int action, int mods) {
    if (!set_callback_window(w)) return;
#ifdef __APPLE__
    cocoa_clear_dock_badge_if_set();
#endif
    monotonic_t now = monotonic();
    cursor_active_callback(now);
    global_state.mods_at_last_key_or_button_event = mods;
    OSWindow *window = global_state.callback_os_window;
    window->last_mouse_activity_at = now;
    if (button >= 0 && (unsigned int)button < arraysz(global_state.callback_os_window->mouse_button_pressed)) {
        if (!window->has_received_cursor_pos_event) {  // ensure mouse position is correct
            window->has_received_cursor_pos_event = true;
            double x, y;
            glfwGetCursorPos(w, &x, &y);
            window->mouse_x = x * window->viewport_x_ratio;
            window->mouse_y = y * window->viewport_y_ratio;
            if (is_window_ready_for_callbacks()) mouse_event(-1, mods, -1);
        }
        global_state.callback_os_window->mouse_button_pressed[button] = action == GLFW_PRESS ? true : false;
        if (is_window_ready_for_callbacks()) mouse_event(button, mods, action);
    }
    request_tick_callback();
    global_state.callback_os_window = NULL;
}

static void
on_mouse_position_update(double x, double y) {
    monotonic_t now = monotonic();
    cursor_active_callback(now);
    global_state.callback_os_window->last_mouse_activity_at = now;
    global_state.callback_os_window->cursor_blink_zero_time = now;
    global_state.callback_os_window->mouse_x = x * global_state.callback_os_window->viewport_x_ratio;
    global_state.callback_os_window->mouse_y = y * global_state.callback_os_window->viewport_y_ratio;
    global_state.callback_os_window->has_received_cursor_pos_event = true;
    if (is_window_ready_for_callbacks()) mouse_event(-1, global_state.mods_at_last_key_or_button_event, -1);
    request_tick_callback();
}

static void
cursor_pos_callback(GLFWwindow *w, double x, double y) {
    if (!set_callback_window(w)) return;
    on_mouse_position_update(x, y);
    global_state.callback_os_window = NULL;
}

static void
scroll_callback(GLFWwindow *w, const GLFWScrollEvent *ev) {
    if (!set_callback_window(w)) return;
    monotonic_t now = monotonic();
    if (OPT(mouse_hide.scroll_unhide)) cursor_active_callback(now);
    global_state.callback_os_window->last_mouse_activity_at = now;
    if (is_window_ready_for_callbacks()) scroll_event(ev);
    request_tick_callback();
    global_state.callback_os_window = NULL;
}

static id_type focus_counter = 0;

static void
set_os_window_visibility(OSWindow *w, int set_visible, bool move_to_active_screen) {
    if (set_visible) {
        glfwShowWindow(w->handle, move_to_active_screen);
        w->needs_render = true;
        w->render_state = RENDER_FRAME_NOT_REQUESTED;
        w->keep_rendering_till_swap = 256;  // try this many times
        request_tick_callback();
    } else glfwHideWindow(w->handle);
}

static void
update_os_window_visibility_based_on_focus(id_type timer_id UNUSED, void*d) {
    OSWindow * osw = os_window_for_id((uintptr_t)d);
    if (osw && osw->hide_on_focus_loss && !osw->is_focused) set_os_window_visibility(osw, 0, false);
}

static void
window_focus_callback(GLFWwindow *w, int focused) {
    if (!set_callback_window(w)) return;
#define osw global_state.callback_os_window
    debug_input("\x1b[35mon_focus_change\x1b[m: window id: 0x%llu focused: %d\n", osw->id, focused);
    bool focus_changed = osw->is_focused != focused;
    osw->is_focused = focused ? true : false;
    monotonic_t now = monotonic();
    id_type wid = osw->id;
    if (focused) {
        cursor_active_callback(now);
        focus_in_event();
        osw->last_focused_counter = ++focus_counter;
        global_state.check_for_active_animated_images = true;
    }
    osw->last_mouse_activity_at = now;
    osw->cursor_blink_zero_time = now;
    if (is_window_ready_for_callbacks()) {
        WINDOW_CALLBACK(on_focus, "O", focused ? Py_True : Py_False);
        if (!osw || osw->id != wid) osw = os_window_for_id(wid);
        if (osw) {
            GLFWIMEUpdateEvent ev = { .type = GLFW_IME_UPDATE_FOCUS, .focused = focused };
            glfwUpdateIMEState(osw->handle, &ev);
            if (focused) {
                Tab *tab = osw->tabs + osw->active_tab;
                Window *window = tab->windows + tab->active_window;
                if (window->render_data.screen) update_ime_position(window, window->render_data.screen);
            }
        }
    }
    request_tick_callback();
    if (osw && osw->handle && !focused && focus_changed && osw->hide_on_focus_loss && glfwGetWindowAttrib(osw->handle, GLFW_VISIBLE)) {
        add_main_loop_timer(0, false, update_os_window_visibility_based_on_focus, (void*)(uintptr_t)osw->id, NULL);
    }
    osw = NULL;
#undef osw
}

#define TAB_DRAG_MIME_NUMBER 400
#define WINDOW_DRAG_MIME_NUMBER 401

static int
is_droppable_mime(const char *mime) {
    static char tab_mime[64] = {0};
    if (!tab_mime[0]) snprintf(tab_mime, sizeof(tab_mime), "application/net.kovidgoyal.kitty-tab-%d", getpid());
    if (strcmp(mime, tab_mime) == 0) return TAB_DRAG_MIME_NUMBER;
    static char window_mime[64] = {0};
    if (!window_mime[0]) snprintf(window_mime, sizeof(window_mime), "application/net.kovidgoyal.kitty-window-%d", getpid());
    if (strcmp(mime, window_mime) == 0) return WINDOW_DRAG_MIME_NUMBER;
    if (strcmp(mime, "text/uri-list") == 0) return 3;
    if (strcmp(mime, "text/plain;charset=utf-8") == 0) return 2;
    if (strcmp(mime, "text/plain") == 0) return 1;
    return 0;
}

static size_t
remove_duplicate_mimes(const char **mimes, size_t count) {
    // Use simple O(n²) scan since lists are typically small
    size_t new_count = 0;
    for (size_t i = 0; i < count; i++) {
        bool is_duplicate = false;
        for (size_t j = 0; j < new_count; j++) {
            if (strcmp(mimes[i], mimes[j]) == 0) { is_duplicate = true; break; }
        }
        if (!is_duplicate) {
            if (new_count != i) SWAP(mimes[i], mimes[new_count]);
            new_count++;
        }
    }
    return new_count;
}

static void
update_allowed_mimes_for_drop(GLFWDropEvent *ev) {
    if (ev->mimes && ev->num_mimes) {
        // Sort MIME types by priority (descending) and keep only accepted ones
        // Use simple bubble sort since lists are typically small
        size_t new_count = 0;
        // Use stack-allocated array for priorities (count is typically small)
        int priorities[32];
        int* prio_arr = (ev->num_mimes <= (int)arraysz(priorities)) ? priorities : (int*)malloc(ev->num_mimes * sizeof(int));
        if (!prio_arr) return;
        // First pass: filter droppable MIME types and cache priorities
        for (size_t i = 0; i < ev->num_mimes; i++) {
            int prio = is_droppable_mime(ev->mimes[i]);
            if (prio > 0) {
                // Move this mime to the new_count position
                if (new_count != i) { SWAP(ev->mimes[i], ev->mimes[new_count]); }
                prio_arr[new_count] = prio;
                new_count++;
            }
        }
        // Second pass: sort by cached priorities (descending)
        for (size_t i = 0; i + 1 < new_count; i++) {
            for (size_t j = i + 1; j < new_count; j++) {
                if (prio_arr[j] > prio_arr[i]) {
                    SWAP(ev->mimes[i], ev->mimes[j]);
                    SWAP(prio_arr[i], prio_arr[j]);
                }
            }
        }
        if (prio_arr != priorities) free(prio_arr);
        ev->num_mimes = new_count;
    }
}

static void
read_drop_data(GLFWwindow *window, GLFWDropEvent *ev) {
    RAII_PyObject(chunk, PyBytes_FromStringAndSize(NULL, 8192));
#define finish(ok) ev->finish_drop(window, ok ? GLFW_DRAG_OPERATION_COPY : GLFW_DRAG_OPERATION_GENERIC); Py_CLEAR(global_state.drop_dest.data); if (PyErr_Occurred()) PyErr_Print()
    if (!chunk) { finish(false); return; }
    ssize_t ret = ev->read_data(window, ev, PyBytes_AS_STRING(chunk), PyBytes_GET_SIZE(chunk));
    if (ret == 0) {
        global_state.drop_dest.num_left--;
        if (!global_state.drop_dest.num_left) {
            WINDOW_CALLBACK(on_drop, "OOii", global_state.drop_dest.data, Py_False,
                global_state.callback_os_window->last_drag_event.x, global_state.callback_os_window->last_drag_event.y);
            finish(true);
        }
    } else if (ret > 0) {
        _PyBytes_Resize(&chunk, ret);
        PyObject *data = chunk;
        RAII_PyObject(existing, PyDict_GetItemString(global_state.drop_dest.data, ev->mimes[0]));
        if (existing) {
            existing = Py_NewRef(existing);  // because PyBytes_Concat steals a reference
            PyBytes_Concat(&existing, chunk);
            data = existing;
        }
        if (!data || PyDict_SetItemString(global_state.drop_dest.data, ev->mimes[0], data) != 0) { finish(false); }
    } else {
        int posix_errno = -ret;
        WINDOW_CALLBACK(on_drop, "iOii", posix_errno, Py_False,
            global_state.callback_os_window->last_drag_event.x, global_state.callback_os_window->last_drag_event.y);
        finish(false);
    }
#undef finish
}

void
register_mimes_for_drop(OSWindow *w, const char **mimes, size_t sz) {
    (void)w; (void)mimes; (void)sz;
#ifdef __APPLE__
    if (w->handle) glfwCocoaRegisterMIMETypes(w->handle, mimes, sz);
#endif
}

int
request_drop_data(OSWindow *w, id_type wid, const char* mime) {
    global_state.drop_dest.client_window_data_request = wid;
    if (w->handle) return glfwRequestDropData(w->handle, mime);
    return ENOENT;
}

static void
drop_dest_callback(GLFWwindow *window, GLFWDropEvent *ev) {
    if (!set_callback_window(window)) return;
    OSWindow *os_window = global_state.callback_os_window;
    Window *w = NULL; id_type wid = global_state.mouse_hover_in_window;
    bool is_kitty_ui_drag = false;
    for (size_t i = 0; i < ev->num_mimes; i++) {
        if (is_droppable_mime(ev->mimes[i]) >= TAB_DRAG_MIME_NUMBER) { is_kitty_ui_drag = true; break;}
    }
    bool is_client_drop = !is_kitty_ui_drag && wid && (w = window_for_window_id(wid)) && w->drop.wanted;
    switch (ev->type) {
        case GLFW_DROP_ENTER:
        case GLFW_DROP_MOVE:
            global_state.drop_dest.drop_has_happened = false;
            global_state.drop_dest.os_window_id = os_window->id;
            os_window->last_drag_event.x = (int)(ev->xpos * os_window->viewport_x_ratio);
            os_window->last_drag_event.y = (int)(ev->ypos * os_window->viewport_y_ratio);
            on_mouse_position_update(ev->xpos, ev->ypos);
            // Re-evaluate which kitty window is now under the cursor after the
            // position update, so that drag enter/leave events are sent to the
            // correct kitty window when the drag crosses a kitty window boundary
            // within the same OS window.
            wid = global_state.mouse_hover_in_window;
            w = wid ? window_for_window_id(wid) : NULL;
            is_client_drop = !is_kitty_ui_drag && wid && w && w->drop.wanted;
            global_state.drop_dest.allowed_ops = ev->operation.source_actions;
            if (is_client_drop) {
                drop_move_on_child(w, ev->mimes, ev->num_mimes, false);
                ev->num_mimes = drop_update_mimes(w, ev->mimes, ev->num_mimes);
                ev->operation.allowed = w->drop.accepted_operation;
                ev->operation.preferred = w->drop.accepted_operation;
                return;
            }
            call_boss(on_drop_move, "KiiOO",
                os_window->id, os_window->last_drag_event.x, os_window->last_drag_event.y,
                ev->from_self ? Py_True : Py_False, Py_False);
            /* fallthrough */
        case GLFW_DROP_STATUS_UPDATE:
            if (is_client_drop) {
                ev->num_mimes = drop_update_mimes(w, ev->mimes, ev->num_mimes);
                ev->operation.allowed = w->drop.accepted_operation;
                ev->operation.preferred = w->drop.accepted_operation;
            } else {
                update_allowed_mimes_for_drop(ev);
                if (ev->num_mimes == 0) zero_at_ptr(&ev->operation);
                else if (is_kitty_ui_drag) {
                    ev->operation.preferred = GLFW_DRAG_OPERATION_MOVE;
                    ev->operation.allowed = GLFW_DRAG_OPERATION_MOVE;
                } else {
                    ev->operation.preferred = GLFW_DRAG_OPERATION_MOVE;
                    ev->operation.allowed = GLFW_DRAG_OPERATION_MOVE | GLFW_DRAG_OPERATION_COPY;
                }
            }
            break;
        case GLFW_DROP_LEAVE:
            global_state.drop_dest.os_window_id = 0;
            for (size_t tc = 0; tc < os_window->num_tabs; tc++) {
                Tab *t = os_window->tabs + tc;
                for (size_t i = 0; i < t->num_windows; i++) {
                    Window *w = t->windows + i;
                    if (w->drop.hovered) drop_left_child(w);
                }
            }
            call_boss(on_drop_move, "KiiOO",
                os_window->id, os_window->last_drag_event.x, os_window->last_drag_event.y,
                ev->from_self ? Py_True : Py_False, Py_True);
            break;
        case GLFW_DROP_DROP:
            if (w && OPT(focus_follows_mouse).on_drop) {
                call_boss(set_active_window, "KO", w->id, Py_True);
            }
            Py_CLEAR(global_state.drop_dest.data);
            global_state.drop_dest.drop_has_happened = true;
            global_state.drop_dest.client_window_data_request = 0;
            global_state.drop_dest.os_window_id = os_window->id;
            if (is_client_drop) {
                drop_move_on_child(w, ev->mimes, ev->num_mimes, true);
                ev->num_mimes = 0;  // we wait for the client to request MIMEs
            } else {
                if (ev->from_self && !global_state.drag_source.from_window) {
                    PyObject *data = global_state.drag_source.drag_data ? global_state.drag_source.drag_data : global_state.drop_dest.self_drag_data;
                    if (data) {
                        global_state.drag_source.was_dropped = true;
                        WINDOW_CALLBACK(on_drop, "OOii", data, Py_True,
                            global_state.callback_os_window->last_drag_event.x, global_state.callback_os_window->last_drag_event.y);
                    } else log_error("Got a drop from self but drag_source.drag_data is NULL");
                    Py_CLEAR(global_state.drop_dest.self_drag_data);
                    ev->finish_drop(window, GLFW_DRAG_OPERATION_COPY);
                    break;
                }
                update_allowed_mimes_for_drop(ev);
                ev->num_mimes = remove_duplicate_mimes(ev->mimes, ev->num_mimes);
                global_state.drop_dest.num_left = ev->num_mimes;
                if (!global_state.drop_dest.num_left || !(global_state.drop_dest.data = PyDict_New())) {
                    ev->finish_drop(window, GLFW_DRAG_OPERATION_GENERIC);
                }
            }
            break;
        case GLFW_DROP_DATA_AVAILABLE:
            if (global_state.drop_dest.client_window_data_request) {
                if ((w = window_for_window_id(global_state.drop_dest.client_window_data_request))) {
                    if (w->drop.getting_data_for_mime && strcmp(w->drop.getting_data_for_mime, ev->mimes[0]) == 0) {
                        char buf[3072];
                        ssize_t ret = ev->read_data(window, ev, buf, sizeof(buf));
                        drop_dispatch_data(w, ev->mimes[0], buf, ret);
                        if (ret < 0) ev->finish_drop(window, GLFW_DRAG_OPERATION_GENERIC);
                    }
                }
            } else {
                if (!global_state.drop_dest.data) ev->finish_drop(window, GLFW_DRAG_OPERATION_GENERIC);
                else read_drop_data(window, ev);
            }
            break;
    }
}

void
request_drop_status_update(OSWindow *osw) {
    if (osw && osw->handle && !global_state.drop_dest.drop_has_happened && global_state.drop_dest.os_window_id == osw->id) {
        glfwRequestDropUpdate(osw->handle);
    }
}

static void
application_close_requested_callback(int flags) {
    if (flags) {
        global_state.quit_request = IMPERATIVE_CLOSE_REQUESTED;
        global_state.has_pending_closes = true;
        request_tick_callback();
    } else {
        if (global_state.quit_request == NO_CLOSE_REQUESTED) {
            global_state.has_pending_closes = true;
            global_state.quit_request = CONFIRMABLE_CLOSE_REQUESTED;
            request_tick_callback();
        }
    }
}

#define ds (global_state.drag_source)

void
free_drag_source(void) {
    if (ds.accepted_mime_type) free(ds.accepted_mime_type);
    Py_CLEAR(ds.drag_data); Py_CLEAR(ds.thumbnails);
    zero_at_ptr(&ds);
}

void
cancel_current_drag_source(void) {
    if (!ds.from_os_window) return;
    OSWindow *w = os_window_for_id(ds.from_os_window); if (!w || !w->handle) return;
    glfwStartDrag(w->handle, NULL, 0, NULL, -3, false);
}

static void
drag_source_callback(GLFWwindow *window UNUSED, GLFWDragEvent *ev) {
#define finish { \
    call_boss(on_drag_source_finished, "OOsiOO", \
        ds.was_dropped && !global_state.drop_dest.os_window_id ? Py_True : Py_False, ds.was_canceled ? Py_True: Py_False, \
        ds.accepted_mime_type ? ds.accepted_mime_type : "", \
        ds.action, ds.drag_data ? ds.drag_data : Py_None, ds.needs_toplevel_on_wayland ? Py_True : Py_False); \
    free_drag_source(); \
}
    Window *w = NULL;
    bool is_client_drag = false;
    if (ds.from_window && (w = window_for_window_id(ds.from_window)) && w->drag_source.state) {
        is_client_drag = true;
    }
    // On Wayland, when compositor doesn't support top level drag protocol we get
    // a drop event for what is either a cancel or a drop on something that
    // does not accept the drop. In both of these cases we need to send the
    // client a drop cancel.
    GLFWDragEventType t = ev->type;
    if (is_client_drag && ev->drop_maybe_a_cancel) t = GLFW_DRAG_CANCELLED;

    switch (t) {
        case GLFW_DRAG_DATA_REQUEST:
            if (is_client_drag) {
                ev->err_num = 0;
                if (ev->data_sz) {
                    ev->err_num = drag_free_data(w, ev->mime_type, ev->data, ev->data_sz);
                } else {
                    ev->data = drag_get_data(w, ev->mime_type, &ev->data_sz, &ev->err_num);
                }
            } else ev->err_num = ENOENT;
            break;
        case GLFW_DRAG_ACCEPTED:
            free(ds.accepted_mime_type);
            ds.accepted_mime_type = ev->mime_type ? strdup(ev->mime_type) : NULL;
            if (is_client_drag) drag_notify(w, DRAG_NOTIFY_ACCEPTED);
            break;
        case GLFW_DRAG_ACTION_CHANGED:
            ds.action = ev->action;
            if (is_client_drag) drag_notify(w, DRAG_NOTIFY_ACTION_CHANGED);
            break;
        case GLFW_DRAG_DROPPED:
            ds.was_dropped = true;
            // On Wayland, we cant trust the value of ev->action as it is zero
            // when dropping outside any application which is a case we want to
            // handle.
            if (is_client_drag) {
                drag_notify(w, DRAG_NOTIFY_DROPPED);
            } else {
                if (global_state.drop_dest.os_window_id && ds.drag_data) {
                    Py_CLEAR(global_state.drop_dest.self_drag_data);
                    global_state.drop_dest.self_drag_data = Py_NewRef(ds.drag_data);
                }
                finish;
            }
            break;
        case GLFW_DRAG_CANCELLED:
            ds.was_canceled = true;
            /* fallthrough */
        case GLFW_DRAG_FINSHED:
            if (is_client_drag) drag_notify(w, DRAG_NOTIFY_FINISHED);
            finish
            break;
    }
#undef finish
}
#undef ds

int
notify_drag_data_ready(id_type os_window_id, const char *mime_type, const char *data, size_t data_sz, int type) {
    OSWindow *w = os_window_for_id(os_window_id);
    if (w && w->handle) {
        GLFWDragSourceItem item = {.mime_type = mime_type, .optional_data = data, .data_size = data_sz, .type = type};
        return glfwStartDrag(w->handle, &item, 1, NULL, -1, false);
    }
    return ENOENT;
}

static char*
get_current_selection(void) {
    if (!global_state.boss) return NULL;
    PyObject *ret = PyObject_CallMethod(global_state.boss, "get_active_selection", NULL);
    if (!ret) { PyErr_Print(); return NULL; }
    char* ans = NULL;
    if (PyUnicode_Check(ret)) ans = strdup(PyUnicode_AsUTF8(ret));
    Py_DECREF(ret);
    return ans;
}

static bool
has_current_selection(void) {
    if (!global_state.boss) return false;
    PyObject *ret = PyObject_CallMethod(global_state.boss, "has_active_selection", NULL);
    if (!ret) { PyErr_Print(); return false; }
    bool ans = ret == Py_True;
    Py_DECREF(ret);
    return ans;
}

void prepare_ime_position_update_event(OSWindow *osw, Window *w, Screen *screen, GLFWIMEUpdateEvent *ev);

static bool
get_ime_cursor_position(GLFWwindow *glfw_window, GLFWIMEUpdateEvent *ev) {
    bool ans = false;
    OSWindow *osw = os_window_for_glfw_window(glfw_window);
    if (osw && osw->is_focused && osw->num_tabs > 0) {
        Tab *tab = osw->tabs + osw->active_tab;
        if (tab->num_windows > 0) {
            Window *w = tab->windows + tab->active_window;
            Screen *screen = w->render_data.screen;
            if (screen) {
                prepare_ime_position_update_event(osw, w, screen, ev);
                ans = true;
            }
        }
    }
    return ans;
}


#ifdef __APPLE__
static bool
apple_url_open_callback(const char* url) {
    set_cocoa_pending_action(LAUNCH_URLS, url);
    return true;
}


bool
draw_window_title(double font_sz_pts UNUSED, double ydpi UNUSED, const char *text, color_type fg, color_type bg, uint8_t *output_buf, size_t width, size_t height, size_t *actual_width) {
    static char buf[2048];
    strip_csi_(text, buf, arraysz(buf));
    if (actual_width) {
        size_t text_w = cocoa_text_width_for_single_line(buf, height);
        if (text_w > 0 && text_w < width) width = text_w;
        *actual_width = width;
    }
    return cocoa_render_line_of_text(buf, fg, bg, output_buf, width, height);
}


uint8_t*
draw_single_ascii_char(const char ch, size_t *result_width, size_t *result_height) {
    uint8_t *ans = render_single_ascii_char_as_mask(ch, result_width, result_height);
    if (PyErr_Occurred()) PyErr_Print();
    return ans;
}

#else

static FreeTypeRenderCtx bold_render_ctx = NULL, normal_render_ctx = NULL;

static FreeTypeRenderCtx
freetype_render_ctx(bool bold) {
    FreeTypeRenderCtx *which = bold ? &bold_render_ctx : &normal_render_ctx;
    if (!*which) {
        *which = create_freetype_render_context(NULL, bold, false);
        if (!*which) {
            if (PyErr_Occurred()) PyErr_Print();
            return NULL;
        }
    }
    return *which;
}

static bool
draw_text_callback(GLFWwindow *window, const char *text, uint32_t fg, uint32_t bg, uint8_t *output_buf, size_t width, size_t height, float x_offset, float y_offset, size_t right_margin, bool is_single_glyph) {
    if (!set_callback_window(window)) return false;
    FreeTypeRenderCtx ctx;
    if (!(ctx = freetype_render_ctx(true))) return false;
    double xdpi, ydpi;
    get_window_dpi(window, &xdpi, &ydpi);
    unsigned px_sz = 2 * height / 3;
    static char title[2048];
    if (!is_single_glyph) {
        snprintf(title, sizeof(title), " ❭ %s", text);
        text = title;
    }
    bool ok = render_single_line(ctx, text, px_sz, fg, bg, output_buf, width, height, x_offset, y_offset, right_margin, is_single_glyph);
    if (!ok && PyErr_Occurred()) PyErr_Print();
    return ok;
}

bool
draw_window_title(double font_sz_pts, double ydpi, const char *text, color_type fg, color_type bg, uint8_t *output_buf, size_t width, size_t height, size_t *actual_width) {
    FreeTypeRenderCtx ctx;
    if (!(ctx = freetype_render_ctx(false))) return false;
    static char buf[2048];
    strip_csi_(text, buf, arraysz(buf));
    unsigned px_sz = (unsigned)(font_sz_pts * ydpi / 72.);
    px_sz = MIN(px_sz, 3 * height / 4);
    if (actual_width) {
        size_t text_w = freetype_text_width_for_single_line(ctx, buf, px_sz);
        if (text_w > 0 && text_w < width) width = text_w;
        *actual_width = width;
    }
#define RGB2BGR(x) (x & 0xFF000000) | ((x & 0xFF0000) >> 16) | (x & 0x00FF00) | ((x & 0x0000FF) << 16)
    bool ok = render_single_line(ctx, buf, px_sz, RGB2BGR(fg), RGB2BGR(bg), output_buf, width, height, 0, 0, 0, false);
#undef RGB2BGR
    if (!ok && PyErr_Occurred()) PyErr_Print();
    return ok;
}

uint8_t*
draw_single_ascii_char(const char ch, size_t *result_width, size_t *result_height) {
    FreeTypeRenderCtx ctx;
    if (!(ctx = freetype_render_ctx(true))) return false;
    uint8_t *ans = render_single_ascii_char_as_mask(ctx, ch, result_width, result_height);
    if (PyErr_Occurred()) PyErr_Print();
    return ans;
}
#endif
// }}}

static void
set_glfw_mouse_cursor(GLFWwindow *w, GLFWCursorShape shape) {
    if (!cursors[shape].initialized) {
        cursors[shape].initialized = true;
        cursors[shape].glfw = glfwCreateStandardCursor(shape);
    }
    if (cursors[shape].glfw) glfwSetCursor(w, cursors[shape].glfw);
}

static void
set_glfw_mouse_pointer_shape_in_window(GLFWwindow *w, MouseShape type) {
    switch(type) {
        case INVALID_POINTER: break;
        /* start enum to glfw (auto generated by gen-key-constants.py do not edit) */
        case DEFAULT_POINTER: set_glfw_mouse_cursor(w, GLFW_DEFAULT_CURSOR); break;
        case TEXT_POINTER: set_glfw_mouse_cursor(w, GLFW_TEXT_CURSOR); break;
        case POINTER_POINTER: set_glfw_mouse_cursor(w, GLFW_POINTER_CURSOR); break;
        case HELP_POINTER: set_glfw_mouse_cursor(w, GLFW_HELP_CURSOR); break;
        case WAIT_POINTER: set_glfw_mouse_cursor(w, GLFW_WAIT_CURSOR); break;
        case PROGRESS_POINTER: set_glfw_mouse_cursor(w, GLFW_PROGRESS_CURSOR); break;
        case CROSSHAIR_POINTER: set_glfw_mouse_cursor(w, GLFW_CROSSHAIR_CURSOR); break;
        case CELL_POINTER: set_glfw_mouse_cursor(w, GLFW_CELL_CURSOR); break;
        case VERTICAL_TEXT_POINTER: set_glfw_mouse_cursor(w, GLFW_VERTICAL_TEXT_CURSOR); break;
        case MOVE_POINTER: set_glfw_mouse_cursor(w, GLFW_MOVE_CURSOR); break;
        case E_RESIZE_POINTER: set_glfw_mouse_cursor(w, GLFW_E_RESIZE_CURSOR); break;
        case NE_RESIZE_POINTER: set_glfw_mouse_cursor(w, GLFW_NE_RESIZE_CURSOR); break;
        case NW_RESIZE_POINTER: set_glfw_mouse_cursor(w, GLFW_NW_RESIZE_CURSOR); break;
        case N_RESIZE_POINTER: set_glfw_mouse_cursor(w, GLFW_N_RESIZE_CURSOR); break;
        case SE_RESIZE_POINTER: set_glfw_mouse_cursor(w, GLFW_SE_RESIZE_CURSOR); break;
        case SW_RESIZE_POINTER: set_glfw_mouse_cursor(w, GLFW_SW_RESIZE_CURSOR); break;
        case S_RESIZE_POINTER: set_glfw_mouse_cursor(w, GLFW_S_RESIZE_CURSOR); break;
        case W_RESIZE_POINTER: set_glfw_mouse_cursor(w, GLFW_W_RESIZE_CURSOR); break;
        case EW_RESIZE_POINTER: set_glfw_mouse_cursor(w, GLFW_EW_RESIZE_CURSOR); break;
        case NS_RESIZE_POINTER: set_glfw_mouse_cursor(w, GLFW_NS_RESIZE_CURSOR); break;
        case NESW_RESIZE_POINTER: set_glfw_mouse_cursor(w, GLFW_NESW_RESIZE_CURSOR); break;
        case NWSE_RESIZE_POINTER: set_glfw_mouse_cursor(w, GLFW_NWSE_RESIZE_CURSOR); break;
        case ZOOM_IN_POINTER: set_glfw_mouse_cursor(w, GLFW_ZOOM_IN_CURSOR); break;
        case ZOOM_OUT_POINTER: set_glfw_mouse_cursor(w, GLFW_ZOOM_OUT_CURSOR); break;
        case ALIAS_POINTER: set_glfw_mouse_cursor(w, GLFW_ALIAS_CURSOR); break;
        case COPY_POINTER: set_glfw_mouse_cursor(w, GLFW_COPY_CURSOR); break;
        case NOT_ALLOWED_POINTER: set_glfw_mouse_cursor(w, GLFW_NOT_ALLOWED_CURSOR); break;
        case NO_DROP_POINTER: set_glfw_mouse_cursor(w, GLFW_NO_DROP_CURSOR); break;
        case GRAB_POINTER: set_glfw_mouse_cursor(w, GLFW_GRAB_CURSOR); break;
        case GRABBING_POINTER: set_glfw_mouse_cursor(w, GLFW_GRABBING_CURSOR); break;
/* end enum to glfw */
    }
}

void
set_mouse_cursor(MouseShape type) {
    if (global_state.callback_os_window) {
        GLFWwindow *w = (GLFWwindow*)global_state.callback_os_window->handle;
        set_glfw_mouse_pointer_shape_in_window(w, type);
    }
}

static GLFWimage logo = {0};

static PyObject*
set_default_window_icon(PyObject UNUSED *self, PyObject *args) {
    size_t sz;
    unsigned int width, height;
    const char *path;
    uint8_t *data;
    if(!PyArg_ParseTuple(args, "s", &path)) return NULL;
    if (png_path_to_bitmap(path, &data, &width, &height, &sz)) {
#ifndef __APPLE__
        if (!global_state.is_wayland && (width > 128 || height > 128)) {
            return PyErr_Format(PyExc_ValueError, "The window icon is too large (%dx%d). On X11 max window icon size is: 128x128. Create a file called ~/.config/kitty.app-128.png containing a 128x128 image to use as the window icon on X11.", width, height);
        }
#endif
        logo.width = width; logo.height = height;
        logo.pixels = data;
    }
    Py_RETURN_NONE;
}

static PyObject*
set_os_window_icon(PyObject UNUSED *self, PyObject *args) {
    size_t sz;
    unsigned int width, height;
    PyObject *what = NULL;
    uint8_t *data;
    unsigned long long id;
    if(!PyArg_ParseTuple(args, "K|O", &id, &what)) return NULL;
    OSWindow *os_window = os_window_for_id(id);
    if (!os_window) { PyErr_Format(PyExc_KeyError, "No OS Window with id: %llu", id); return NULL; }
    if (os_window->is_layer_shell && global_state.is_wayland) Py_RETURN_NONE;
    if (!what || what == Py_None) {
        glfwSetWindowIcon(os_window->handle, 0, NULL);
        Py_RETURN_NONE;
    }
    if (PyUnicode_Check(what)) {
        const char *path = PyUnicode_AsUTF8(what);
        if (png_path_to_bitmap(path, &data, &width, &height, &sz)) {
            GLFWimage img = { .pixels = data, .width = width, .height = height };
            glfwSetWindowIcon(os_window->handle, 1, &img);
            free(data);
        } else {
            PyErr_Format(PyExc_ValueError, "%s is not a valid PNG image", path);
            return NULL;
        }
        Py_RETURN_NONE;
    }
    RAII_PY_BUFFER(buf);
    if(!PyArg_ParseTuple(args, "Ky*", &id, &buf)) return NULL;
    if (png_from_data(buf.buf, buf.len, "<data>", &data, &width, &height, &sz)) {
        GLFWimage img = { .pixels = data, .width = width, .height = height };
        glfwSetWindowIcon(os_window->handle, 1, &img);
    } else {
        PyErr_Format(PyExc_ValueError, "The supplied data of %lu bytes is not a valid PNG image", (unsigned long)buf.len);
        return NULL;
    }
    Py_RETURN_NONE;
}



void*
make_os_window_context_current(OSWindow *w) {
    GLFWwindow *current_context = glfwGetCurrentContext();
    if (w->handle != current_context) {
        glfwMakeContextCurrent(w->handle);
        return current_context;
    }
    return NULL;
}

void
get_os_window_size(OSWindow *os_window, int *w, int *h, int *fw, int *fh) {
    if (w && h) glfwGetWindowSize(os_window->handle, w, h);
    if (fw && fh) glfwGetFramebufferSize(os_window->handle, fw, fh);
}

void
set_os_window_size(OSWindow *os_window, int x, int y) {
    glfwSetWindowSize(os_window->handle, x, y);
}

void
get_os_window_pos(OSWindow *os_window, int *x, int *y) {
    glfwGetWindowPos(os_window->handle, x, y);
}

void
set_os_window_pos(OSWindow *os_window, int x, int y) {
    glfwSetWindowPos(os_window->handle, x, y);
}

static void
dpi_from_scale(float xscale, float yscale, double *xdpi, double *ydpi) {
#ifdef __APPLE__
    const double factor = 72.0;
#else
    const double factor = 96.0;
#endif
    *xdpi = xscale * factor;
    *ydpi = yscale * factor;
}

static void
get_window_content_scale(GLFWwindow *w, float *xscale, float *yscale, double *xdpi, double *ydpi) {
    // if you change this function also change createSurface() in wl_window.c
    *xscale = 1; *yscale = 1;
    if (w) glfwGetWindowContentScale(w, xscale, yscale);
    else {
        GLFWmonitor *monitor = glfwGetPrimaryMonitor();
        if (monitor) glfwGetMonitorContentScale(monitor, xscale, yscale);
    }
    // check for zero, negative, NaN or excessive values of xscale/yscale
    if (*xscale <= 0.0001 || *xscale != *xscale || *xscale >= 24) *xscale = 1.0;
    if (*yscale <= 0.0001 || *yscale != *yscale || *yscale >= 24) *yscale = 1.0;
    dpi_from_scale(*xscale, *yscale, xdpi, ydpi);
}

static void
get_window_dpi(GLFWwindow *w, double *x, double *y) {
    float xscale, yscale;
    get_window_content_scale(w, &xscale, &yscale, x, y);
}

void
get_os_window_content_scale(OSWindow *os_window, double *xdpi, double *ydpi, float *xscale, float *yscale) {
    get_window_content_scale(os_window->handle, xscale, yscale, xdpi, ydpi);
}

static bool
do_toggle_fullscreen(OSWindow *w, unsigned int flags, bool restore_sizes) {
    int width, height, x, y;
    glfwGetWindowSize(w->handle, &width, &height);
    if (!global_state.is_wayland) glfwGetWindowPos(w->handle, &x, &y);
    bool was_maximized = glfwGetWindowAttrib(w->handle, GLFW_MAXIMIZED);
    if (glfwToggleFullscreen(w->handle, flags)) {
        w->before_fullscreen.is_set = true;
        w->before_fullscreen.w = width; w->before_fullscreen.h = height; w->before_fullscreen.x = x; w->before_fullscreen.y = y;
        w->before_fullscreen.was_maximized = was_maximized;
        return true;
    }
    if (w->before_fullscreen.is_set && restore_sizes) {
        glfwSetWindowSize(w->handle, w->before_fullscreen.w, w->before_fullscreen.h);
        if (!global_state.is_wayland) glfwSetWindowPos(w->handle, w->before_fullscreen.x, w->before_fullscreen.y);
        if (w->before_fullscreen.was_maximized) glfwMaximizeWindow(w->handle);
    }
    return false;
}

static bool
toggle_fullscreen_for_os_window(OSWindow *w) {
    if (!w || !w->handle) return false;
    if (!w->is_layer_shell) {
#ifdef __APPLE__
        if (!OPT(macos_traditional_fullscreen)) return do_toggle_fullscreen(w, 1, false);
        unsigned int flags = OPT(macos_fullscreen_ignore_safe_area_insets) ? 2u : 0u;
        return do_toggle_fullscreen(w, flags, true);
#endif
        return do_toggle_fullscreen(w, 0, true);
    }
    const GLFWLayerShellConfig *prev = glfwGetLayerShellConfig(w->handle);
    if (!prev) return false;
    GLFWLayerShellConfig lsc;
    memcpy(&lsc, prev, sizeof(lsc));
    if (prev->type == GLFW_LAYER_SHELL_OVERLAY || prev->type == GLFW_LAYER_SHELL_TOP) {
        if (prev->was_toggled_to_fullscreen) {
            lsc.edge = prev->previous.edge;
            lsc.requested_bottom_margin = prev->previous.requested_bottom_margin;
            lsc.requested_top_margin = prev->previous.requested_top_margin;
            lsc.requested_left_margin = prev->previous.requested_left_margin;
            lsc.requested_right_margin = prev->previous.requested_right_margin;
            lsc.was_toggled_to_fullscreen = false;
            glfwSetLayerShellConfig(w->handle, &lsc);
            return true;
        }
        lsc.edge = GLFW_EDGE_CENTER;
        lsc.previous.edge = prev->edge;
        lsc.previous.requested_right_margin = prev->requested_right_margin;
        lsc.previous.requested_left_margin = prev->requested_left_margin;
        lsc.previous.requested_top_margin = prev->requested_top_margin;
        lsc.previous.requested_bottom_margin = prev->requested_bottom_margin;
        lsc.requested_bottom_margin = 0; lsc.requested_top_margin = 0; lsc.requested_left_margin = 0; lsc.requested_right_margin = 0;
        lsc.was_toggled_to_fullscreen = true;
        glfwSetLayerShellConfig(w->handle, &lsc);
        return true;
    }
    return false;
}

bool
is_os_window_fullscreen(OSWindow *w) {
    unsigned int flags = 0;
    if (!w || !w->handle) return false;
    if (w->is_layer_shell) {
        const GLFWLayerShellConfig *c = glfwGetLayerShellConfig(w->handle);
        return c && c->was_toggled_to_fullscreen;
    }
#ifdef __APPLE__
    if (!OPT(macos_traditional_fullscreen)) flags = 1;
#endif
    return glfwIsFullscreen(w->handle, flags);
}

static bool
toggle_maximized_for_os_window(OSWindow *w) {
    bool maximized = false;
    if (w && w->handle && !w->is_layer_shell) {
        if (glfwGetWindowAttrib(w->handle, GLFW_MAXIMIZED)) {
            glfwRestoreWindow(w->handle);
        } else {
            glfwMaximizeWindow(w->handle);
            maximized = true;
        }
    }
    return maximized;
}

static void
change_state_for_os_window(OSWindow *w, int state) {
    if (!w || !w->handle) return;
    switch (state) {
        case WINDOW_MAXIMIZED:
            if (!w->is_layer_shell) glfwMaximizeWindow(w->handle);
            break;
        case WINDOW_MINIMIZED:
            if (!w->is_layer_shell) glfwIconifyWindow(w->handle);
            break;
        case WINDOW_FULLSCREEN:
            if (!is_os_window_fullscreen(w)) toggle_fullscreen_for_os_window(w);
            break;
        case WINDOW_NORMAL:
            if (is_os_window_fullscreen(w)) toggle_fullscreen_for_os_window(w);
            else if (!w->is_layer_shell) glfwRestoreWindow(w->handle);
            break;
        case WINDOW_HIDDEN:
            glfwHideWindow(w->handle); break;
    }
}

#ifdef __APPLE__

static int
filter_option(int key UNUSED, int mods, unsigned int native_key UNUSED, unsigned long flags) {
    mods &= ~(GLFW_MOD_NUM_LOCK | GLFW_MOD_CAPS_LOCK);
    if ((mods == GLFW_MOD_ALT) || (mods == (GLFW_MOD_ALT | GLFW_MOD_SHIFT))) {
        if (OPT(macos_option_as_alt) == 3) return 1;
        if (cocoa_alt_option_key_pressed(flags)) return 1;
    }
    return 0;
}

static bool
on_application_reopen(int has_visible_windows) {
    if (has_visible_windows) return true;
    set_cocoa_pending_action(NEW_OS_WINDOW, NULL);
    return false;
}

static bool
intercept_cocoa_fullscreen(GLFWwindow *w) {
    if (!set_callback_window(w)) return false;
    if (!OPT(macos_traditional_fullscreen)) {
        // In non traditional fullscreen macOS forces the window to opaque
        global_state.callback_os_window->background_opacity.os_forces_opaque = !is_os_window_fullscreen(
                global_state.callback_os_window);
        return false;
    }
    // macOS Split View uses Cocoa fullscreen internally, so the window
    // can end up with NSWindowStyleMaskFullScreen set even when
    // macos_traditional_fullscreen is enabled. Redirecting to traditional
    // fullscreen would crash in setStyleMask: (see #9572).
    if (glfwIsFullscreen(w, 1)) {
        global_state.callback_os_window->background_opacity.os_forces_opaque = false;
        return false;
    }
    toggle_fullscreen_for_os_window(global_state.callback_os_window);
    global_state.callback_os_window = NULL;
    return true;
}
#endif

static void
init_window_chrome_state(WindowChromeState *s, color_type active_window_bg, float background_opacity) {
    zero_at_ptr(s);
    const bool should_blur = background_opacity < 1.f && OPT(background_blur) > 0;
#define SET_TCOL(val) \
        s->use_system_color = false; \
        switch (val & 0xff) { \
            case 0: s->use_system_color = true; s->color = active_window_bg; break; \
            case 1: s->color = active_window_bg; break; \
            default: s->color = val >> 8; break; \
        }

#ifdef __APPLE__
    if (OPT(macos_titlebar_color) < 0) {
        s->use_system_color = true;
        s->system_color = -OPT(macos_titlebar_color);
    } else {
        unsigned long val = OPT(macos_titlebar_color);
        SET_TCOL(val);
    }
    s->macos_colorspace = OPT(macos_colorspace);
    s->resizable = OPT(macos_window_resizable);
#else
    if (global_state.is_wayland) { SET_TCOL(OPT(wayland_titlebar_color)); }
#endif
    s->background_blur = should_blur ? OPT(background_blur) : 0;
    s->hide_window_decorations = OPT(hide_window_decorations);
    s->show_title_in_titlebar = (OPT(macos_show_window_title_in) & WINDOW) != 0;
    s->background_opacity = background_opacity;
}

static void
apply_window_chrome_state(GLFWwindow *w, WindowChromeState new_state, int width, int height, bool window_decorations_changed) {
#ifdef __APPLE__
    glfwCocoaSetWindowChrome(w,
        new_state.color, new_state.use_system_color, new_state.system_color,
        new_state.background_blur, new_state.hide_window_decorations,
        new_state.show_title_in_titlebar, new_state.macos_colorspace,
        new_state.background_opacity, new_state.resizable
    );
    // Need to resize the window again after hiding decorations or title bar to take up screen space
    if (window_decorations_changed) glfwSetWindowSize(w, width, height);
#else
        if (global_state.is_wayland && glfwWaylandSetTitlebarHidden) {
            bool titlebar_only = (new_state.hide_window_decorations & 2) != 0;
            glfwWaylandSetTitlebarHidden(w, titlebar_only);
        }
        if (window_decorations_changed) {
            bool hide_window_decorations = new_state.hide_window_decorations & 1;
            glfwSetWindowAttrib(w, GLFW_DECORATED, !hide_window_decorations);
            glfwSetWindowSize(w, width, height);
        }
        glfwSetWindowBlur(w, new_state.background_blur);
        if (global_state.is_wayland) {
            if (glfwWaylandSetTitlebarColor) glfwWaylandSetTitlebarColor(w, new_state.color, new_state.use_system_color);
        }
#endif
}

void
set_os_window_chrome(OSWindow *w) {
    if (!w->handle || w->is_layer_shell) return;
    color_type bg = OPT(background);
    if (w->num_tabs > w->active_tab) {
        Tab *tab = w->tabs + w->active_tab;
        if (tab->num_windows > tab->active_window) {
            Window *window = tab->windows + tab->active_window;
            ColorProfile *c;
            if (window->render_data.screen && (c=window->render_data.screen->color_profile)) {
                bg = colorprofile_to_color(c, c->overridden.default_bg, c->configured.default_bg).rgb;
            }
        }
    }

    WindowChromeState new_state;
    init_window_chrome_state(&new_state, bg, effective_os_window_alpha(w));
    if (memcmp(&new_state, &w->last_window_chrome, sizeof(WindowChromeState)) != 0) {
        int width, height;
        glfwGetWindowSize(w->handle, &width, &height);
        bool window_decorations_changed = new_state.hide_window_decorations != w->last_window_chrome.hide_window_decorations;
        apply_window_chrome_state(w->handle, new_state, width, height, window_decorations_changed);
        w->last_window_chrome = new_state;
    }
}

static PyObject*
native_window_handle(GLFWwindow *w) {
#ifdef __APPLE__
    void *ans = glfwGetCocoaWindow(w);
    return PyLong_FromVoidPtr(ans);
#endif
    if (glfwGetX11Window) return PyLong_FromUnsignedLong(glfwGetX11Window(w));
    return Py_None;
}

static PyObject* edge_spacing_func = NULL;

static double
edge_spacing(GLFWEdge which) {
    const char* edge = "top";
    switch(which) {
        case GLFW_EDGE_TOP: edge = "top"; break;
        case GLFW_EDGE_BOTTOM: edge = "bottom"; break;
        case GLFW_EDGE_LEFT: edge = "left"; break;
        case GLFW_EDGE_RIGHT: edge = "right"; break;
        case GLFW_EDGE_CENTER: case GLFW_EDGE_NONE: case GLFW_EDGE_CENTER_SIZED: return 0;
    }
    if (!edge_spacing_func) {
        log_error("Attempt to call edge_spacing() without first setting edge_spacing_func");
        return 100;
    }
    RAII_PyObject(ret, PyObject_CallFunction(edge_spacing_func, "s", edge));
    if (!ret) { PyErr_Print(); return 100; }
    if (!PyFloat_Check(ret)) { log_error("edge_spacing_func() return something other than a float"); return 100; }
    return PyFloat_AsDouble(ret);
}

static void
calculate_layer_shell_window_size(
    GLFWwindow *window, float xscale, float yscale, unsigned *cell_width, unsigned *cell_height, double *left_edge_spacing, double *top_edge_spacing, double *right_edge_spacing, double *bottom_edge_spacing) {
    OSWindow *os_window = os_window_for_glfw_window(window);
    double xdpi, ydpi;
    dpi_from_scale(xscale, yscale, &xdpi, &ydpi);
    FONTS_DATA_HANDLE fonts_data = load_fonts_data(os_window ? os_window->fonts_data->font_sz_in_pts : OPT(font_size), xdpi, ydpi);
    *cell_width = fonts_data->fcm.cell_width; *cell_height = fonts_data->fcm.cell_height;
    double x_factor = xdpi / 72., y_factor = ydpi / 72.;
    *left_edge_spacing = edge_spacing(GLFW_EDGE_LEFT) * x_factor;
    *top_edge_spacing = edge_spacing(GLFW_EDGE_TOP) * y_factor;
    *right_edge_spacing = edge_spacing(GLFW_EDGE_RIGHT) * x_factor;
    *bottom_edge_spacing = edge_spacing(GLFW_EDGE_BOTTOM) * y_factor;
}

static PyObject*
layer_shell_config_to_python(const GLFWLayerShellConfig *c) {
    RAII_PyObject(ans, PyDict_New()); if (!ans) return ans;
#define fl(x) PyLong_FromLong((long)x)
#define fu(x) PyLong_FromUnsignedLong((unsigned long)x)
#define b(x) Py_NewRef(x ? Py_True : Py_False)
#define A(attr, convert) RAII_PyObject(attr, convert(c->attr)); if (!attr) return NULL; if (PyDict_SetItemString(ans, #attr, attr) != 0) return NULL;
    A(type, fl);
    A(output_name, PyUnicode_FromString);
    A(edge, fl);
    A(focus_policy, fl);
    A(x_size_in_cells, fu);
    A(y_size_in_cells, fu);
    A(x_size_in_pixels, fu);
    A(y_size_in_pixels, fu);
    A(requested_top_margin, fl);
    A(requested_left_margin, fl);
    A(requested_bottom_margin, fl);
    A(requested_right_margin, fl);
    A(requested_exclusive_zone, fl);
    A(hide_on_focus_loss, b)
    A(override_exclusive_zone, b);
#undef A
#undef fl
#undef fu
#undef b
    return Py_NewRef(ans);
}

static bool
layer_shell_config_from_python(PyObject *p, GLFWLayerShellConfig *ans) {
    memset(ans, 0, sizeof(GLFWLayerShellConfig));
    ans->size_callback = calculate_layer_shell_window_size;
#define A(attr, type_check, convert) RAII_PyObject(attr, PyObject_GetAttrString(p, #attr)); if (attr == NULL) return false; if (!type_check(attr)) { PyErr_SetString(PyExc_TypeError, #attr " not of the correct type"); return false; }; ans->attr = convert(attr);
    A(type, PyLong_Check, PyLong_AsLong);
    A(edge, PyLong_Check, PyLong_AsLong);
    A(focus_policy, PyLong_Check, PyLong_AsLong);
    A(x_size_in_cells, PyLong_Check, PyLong_AsUnsignedLong);
    A(y_size_in_cells, PyLong_Check, PyLong_AsUnsignedLong);
    A(x_size_in_pixels, PyLong_Check, PyLong_AsUnsignedLong);
    A(y_size_in_pixels, PyLong_Check, PyLong_AsUnsignedLong);
    A(requested_top_margin, PyLong_Check, PyLong_AsLong);
    A(requested_left_margin, PyLong_Check, PyLong_AsLong);
    A(requested_bottom_margin, PyLong_Check, PyLong_AsLong);
    A(requested_right_margin, PyLong_Check, PyLong_AsLong);
    A(requested_exclusive_zone, PyLong_Check, PyLong_AsLong);
    A(override_exclusive_zone, PyBool_Check, PyLong_AsLong);
    A(hide_on_focus_loss, PyBool_Check, PyLong_AsLong);
#undef A
#define A(attr) { \
    RAII_PyObject(attr, PyObject_GetAttrString(p, #attr)); if (attr == NULL) return false; \
    if (!PyUnicode_Check(attr)) { PyErr_SetString(PyExc_TypeError, #attr " not a string"); return false; };\
    Py_ssize_t sz; const char *t = PyUnicode_AsUTF8AndSize(attr, &sz); \
    if (sz > (ssize_t)sizeof(ans->attr)-1) { PyErr_Format(PyExc_ValueError, "%s: %s is too long", #attr, t); return false; } \
    memcpy(ans->attr, t, sz); }

    A(output_name);
    return true;
#undef A
}

static void
os_window_update_size_increments(OSWindow *window) {
    if (OPT(resize_in_steps)) {
        if (window->handle && window->fonts_data) glfwSetWindowSizeIncrements(
                window->handle, window->fonts_data->fcm.cell_width, window->fonts_data->fcm.cell_height);
    } else {
        if (window->handle) glfwSetWindowSizeIncrements(
                window->handle, GLFW_DONT_CARE, GLFW_DONT_CARE);
    }
}


// Borrowed reference to the get_window_size callable, valid only for the
// duration of a create_os_window() call. Used by the Wayland initial-size hook
// below, which fires synchronously from inside glfwCreateWindow().
static PyObject *initial_window_size_py_callback = NULL;

static void
wayland_initial_size_callback(GLFWwindow *window UNUSED, float xscale, float yscale, int *width, int *height) {
    // The compositor has told us the real scale before the window is mapped;
    // recompute the cell-based logical size for that scale so the window is
    // mapped at the correct size in the first place.
    if (!initial_window_size_py_callback) return;
    double xdpi, ydpi;
    dpi_from_scale(xscale, yscale, &xdpi, &ydpi);
    FONTS_DATA_HANDLE fonts_data = load_fonts_data(OPT(font_size), xdpi, ydpi);
    if (!fonts_data) return;
    PyObject *ret = PyObject_CallFunction(initial_window_size_py_callback, "IIddff",
            fonts_data->fcm.cell_width, fonts_data->fcm.cell_height,
            fonts_data->logical_dpi_x, fonts_data->logical_dpi_y, xscale, yscale);
    if (ret) {
        int w = PyLong_AsLong(PyTuple_GET_ITEM(ret, 0)), h = PyLong_AsLong(PyTuple_GET_ITEM(ret, 1));
        if (!PyErr_Occurred() && w > 0 && h > 0) { *width = w; *height = h; }
        else PyErr_Clear();
        Py_DECREF(ret);
    } else PyErr_Clear();
}

static PyObject*
create_os_window(PyObject UNUSED *self, PyObject *args, PyObject *kw) {
    int x = INT_MIN, y = INT_MIN, window_state = WINDOW_NORMAL, disallow_override_title = 0;
    char *title, *wm_class_class, *wm_class_name;
    PyObject *optional_window_state = NULL, *load_programs = NULL, *get_window_size, *pre_show_callback, *optional_x = NULL, *optional_y = NULL, *layer_shell_config = NULL;
    static const char* kwlist[] = {"get_window_size", "pre_show_callback", "title", "wm_class_name", "wm_class_class", "window_state", "load_programs", "x", "y", "disallow_override_title", "layer_shell_config", NULL};
    if (!PyArg_ParseTupleAndKeywords(args, kw, "OOsss|OOOOpO", (char**)kwlist,
        &get_window_size, &pre_show_callback, &title, &wm_class_name, &wm_class_class, &optional_window_state, &load_programs, &optional_x, &optional_y, &disallow_override_title, &layer_shell_config)) return NULL;
    GLFWLayerShellConfig *lsc = NULL, lsc_stack = {0};
    if (optional_window_state && optional_window_state != Py_None) {
        if (!PyLong_Check(optional_window_state)) { PyErr_SetString(PyExc_TypeError, "window_state must be an int"); return NULL; }
        window_state = (int) PyLong_AsLong(optional_window_state);
    }
    if (layer_shell_config && layer_shell_config != Py_None ) {
        if (!glfwIsLayerShellSupported()) {
            PyErr_SetString(PyExc_RuntimeError, "The window manager/compositor does not support the primitives needed to make panels.");
            return NULL;
        }
        lsc = &lsc_stack;
    } else {
        if (optional_x && optional_x != Py_None) { if (!PyLong_Check(optional_x)) { PyErr_SetString(PyExc_TypeError, "x must be an int"); return NULL;} x = (int)PyLong_AsLong(optional_x); }
        if (optional_y && optional_y != Py_None) { if (!PyLong_Check(optional_y)) { PyErr_SetString(PyExc_TypeError, "y must be an int"); return NULL;} y = (int)PyLong_AsLong(optional_y); }
        if (window_state < WINDOW_NORMAL || window_state > WINDOW_HIDDEN) window_state = WINDOW_NORMAL;
    }
    if (PyErr_Occurred()) return NULL;
    if (lsc && window_state != WINDOW_HIDDEN) window_state = WINDOW_NORMAL;

    static bool is_first_window = true;
    if (is_first_window) {
#ifndef __APPLE__
        glfwConfigureMomentumScroller(OPT(momentum_scroll), -1, -1, 0);
#endif
        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, OPENGL_REQUIRED_VERSION_MAJOR);
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, OPENGL_REQUIRED_VERSION_MINOR);
        glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, true);
        // We don't use depth and stencil buffers
        glfwWindowHint(GLFW_DEPTH_BITS, 0);
        glfwWindowHint(GLFW_STENCIL_BITS, 0);
        glfwSetApplicationCloseCallback(application_close_requested_callback);
        glfwSetCurrentSelectionCallback(get_current_selection);
        glfwSetHasCurrentSelectionCallback(has_current_selection);
        glfwSetIMECursorPositionCallback(get_ime_cursor_position);
        glfwSetSystemColorThemeChangeCallback(on_system_color_scheme_change);
        glfwSetClipboardLostCallback(on_clipboard_lost);
        // Request SRGB output buffer
        // Prevents kitty from starting on Wayland + NVIDIA, sigh: https://github.com/kovidgoyal/kitty/issues/7021
        // Remove after https://github.com/NVIDIA/egl-wayland/issues/85 is fixed.
        // Also apparently mesa has introduced a bug with sRGB surfaces and Wayland.
        // Sigh. Wayland is such a pile of steaming crap.
        // See https://github.com/kovidgoyal/kitty/issues/7174#issuecomment-2000033873
        // GL_FRAMEBUFFER_SRGB works anyway without this on Wayland.
        if (!global_state.is_wayland) glfwWindowHint(GLFW_SRGB_CAPABLE, true);
#ifdef __APPLE__
        cocoa_set_activation_policy(OPT(macos_hide_from_tasks) || lsc != NULL);
        glfwWindowHint(GLFW_COCOA_GRAPHICS_SWITCHING, true);
        glfwSetApplicationShouldHandleReopen(on_application_reopen);
        glfwSetApplicationWillFinishLaunching(cocoa_application_lifecycle_event);
#endif
    }
    if (OPT(hide_window_decorations) & 1) glfwWindowHint(GLFW_DECORATED, false);

    const bool set_blur = OPT(background_blur) > 0 && OPT(background_opacity) < 1.f;
    glfwWindowHint(GLFW_BLUR_RADIUS, set_blur ? OPT(background_blur) : 0);
#ifdef __APPLE__
    glfwWindowHint(GLFW_COCOA_COLOR_SPACE, OPT(macos_colorspace));
#else
    glfwWindowHintString(GLFW_X11_INSTANCE_NAME, wm_class_name);
    glfwWindowHintString(GLFW_X11_CLASS_NAME, wm_class_class);
    glfwWindowHintString(GLFW_WAYLAND_APP_ID, wm_class_class);
#endif

    if (global_state.num_os_windows >= MAX_CHILDREN) {
        PyErr_SetString(PyExc_ValueError, "Too many windows");
        return NULL;
    }
    bool want_semi_transparent = (1.0 - OPT(background_opacity) >= 0.01) || OPT(dynamic_background_opacity);
    glfwWindowHint(GLFW_TRANSPARENT_FRAMEBUFFER, want_semi_transparent);
    uint32_t bgcolor = OPT(background);
    uint32_t bgalpha = (uint32_t)((MAX(0.f, MIN((OPT(background_opacity) * 255), 255.f))));
    glfwWindowHint(GLFW_WAYLAND_BGCOLOR, ((bgalpha & 0xff) << 24) | bgcolor);
    // 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. On Wayland no temp window can be
    // used, so start with window visible unless hidden window requested.
    GLFWwindow *common_context = global_state.num_os_windows ? global_state.os_windows[0].handle : NULL;
    GLFWwindow *temp_window = NULL;
    glfwWindowHint(GLFW_VISIBLE, window_state != WINDOW_HIDDEN && global_state.is_wayland);
    float xscale, yscale;
    double xdpi, ydpi;
    if (global_state.is_wayland) {
        // Cannot use temp window on Wayland as scale is only sent by compositor after window is displayed.
        // For the first window, query the xdg-output fractional scale of the primary monitor directly;
        // this blocks until the compositor has sent size information so we get the true fractional scale
        // before creating any window.
#define QUERY_MONITOR \
            debug_rendering("Querying Wayland compositor for current monitor scale\n"); \
            double fscale = glfwGetWaylandCurrentMonitorFractionalScale(); \
            debug_rendering("Current monitor scale reported as: %.5f\n", fscale); \
            xscale = yscale = (float)fscale; \
            dpi_from_scale(xscale, yscale, &xdpi, &ydpi);

        if (is_first_window && glfwGetWaylandCurrentMonitorFractionalScale) {
            QUERY_MONITOR
        } else {
            bool found_window = false;
            get_window_content_scale(NULL, &xscale, &yscale, &xdpi, &ydpi);
            for (unsigned i = 0; i < global_state.num_os_windows; i++) {
                OSWindow *osw = global_state.os_windows + i;
                if (osw->handle && glfwGetWindowAttrib(osw->handle, GLFW_FOCUSED)) {
                    get_window_content_scale(osw->handle, &xscale, &yscale, &xdpi, &ydpi);
                    found_window = false;
                    break;
                }
            }
            if (!found_window) {
                // no focused window use monitor of last focused window
                QUERY_MONITOR
            }
#undef QUERY_MONITOR
        }
    } else {
#define glfw_failure { \
        PyErr_Format(PyExc_OSError, "Failed to create GLFWwindow. This usually happens because of old/broken OpenGL drivers. kitty requires working OpenGL %d.%d drivers.", OPENGL_REQUIRED_VERSION_MAJOR, OPENGL_REQUIRED_VERSION_MINOR); \
        return NULL; }

        temp_window = glfwCreateWindow(640, 480, "temp", NULL, common_context, NULL);
        if (temp_window == NULL) glfw_failure;
        get_window_content_scale(temp_window, &xscale, &yscale, &xdpi, &ydpi);
    }
    FONTS_DATA_HANDLE fonts_data = load_fonts_data(OPT(font_size), xdpi, ydpi);
    PyObject *ret = PyObject_CallFunction(get_window_size, "IIddff", fonts_data->fcm.cell_width, fonts_data->fcm.cell_height, fonts_data->logical_dpi_x, fonts_data->logical_dpi_y, xscale, yscale);
    if (ret == NULL) return NULL;
    int width = PyLong_AsLong(PyTuple_GET_ITEM(ret, 0)), height = PyLong_AsLong(PyTuple_GET_ITEM(ret, 1));
    Py_CLEAR(ret);
    if (lsc) {
        if (!layer_shell_config_from_python(layer_shell_config, lsc)) return NULL;
        lsc->expected.xscale = xscale; lsc->expected.yscale = yscale;
    }
    // On Wayland the true (fractional) scale is only known after the surface
    // exists. Register a hook so the window is mapped at the correct cell-based
    // size once the compositor reveals the scale, rather than being resized
    // afterwards (which loses to the compositor's authoritative configure).
    if (global_state.is_wayland && glfwWaylandSetInitialWindowSizeCallback) {
        glfwWaylandSetInitialWindowSizeCallback(wayland_initial_size_callback);
        initial_window_size_py_callback = get_window_size;
    }
    GLFWwindow *glfw_window = glfwCreateWindow(width, height, title, NULL, temp_window ? temp_window : common_context, lsc);
    initial_window_size_py_callback = NULL;
    if (temp_window) { glfwDestroyWindow(temp_window); temp_window = NULL; }
    if (glfw_window == NULL) glfw_failure;
#undef glfw_failure
    // Set titlebar-only mode before the window becomes visible
    if (global_state.is_wayland && (OPT(hide_window_decorations) & 2) && glfwWaylandSetTitlebarHidden) {
        glfwWaylandSetTitlebarHidden(glfw_window, true);
    }
    glfwMakeContextCurrent(glfw_window);
    if (is_first_window) gl_init();
    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, OPT(background), true);
    apply_swap_interval(-1);
    // On Wayland the initial swap is allowed only after the first XDG configure event
    if (glfwAreSwapsAllowed(glfw_window)) glfwSwapBuffers(glfw_window);
    glfwSetInputMode(glfw_window, GLFW_LOCK_KEY_MODS, true);
    PyObject *pret = PyObject_CallFunction(pre_show_callback, "N", native_window_handle(glfw_window));
    if (pret == NULL) return NULL;
    Py_DECREF(pret);
    if (x != INT_MIN && y != INT_MIN) glfwSetWindowPos(glfw_window, x, y);
    if (!global_state.is_apple && !global_state.is_wayland && window_state != WINDOW_HIDDEN) glfwShowWindow(glfw_window, false);
    if (global_state.is_wayland || global_state.is_apple) {
        float n_xscale, n_yscale;
        double n_xdpi, n_ydpi;
        get_window_content_scale(glfw_window, &n_xscale, &n_yscale, &n_xdpi, &n_ydpi);
        if (n_xdpi != xdpi || n_ydpi != ydpi || lsc) {
            // this can happen if the window is moved by the OS to a different monitor when shown or with fractional scales on Wayland
            // it can also happen with layer shell windows if the callback is
            // called before the window is fully created
            xdpi = n_xdpi; ydpi = n_ydpi;
            fonts_data = load_fonts_data(OPT(font_size), xdpi, ydpi);
        }
    }
    if (is_first_window) {
        PyObject *ret = PyObject_CallNoArgs(load_programs);
        if (ret == NULL) return NULL;
        Py_DECREF(ret);
        get_platform_dependent_config_values(glfw_window);
        if (!global_state.supports_framebuffer_srgb) {
            log_error("The OpenGL drivers dont support GL_FRAMEBUFFER_SRGB this will cause a small rendering performance penalty");
        }
        is_first_window = false;
    }
    OSWindow *w = add_os_window();
    w->handle = glfw_window;
    w->disallow_title_changes = disallow_override_title;
    if (lsc != NULL) {
        w->is_layer_shell = true;
        w->hide_on_focus_loss = lsc->hide_on_focus_loss;
    }
    update_os_window_references();
    if (!w->is_layer_shell || (global_state.is_apple && w->is_layer_shell && lsc->focus_policy == GLFW_FOCUS_EXCLUSIVE)) {
        for (size_t i = 0; i < global_state.num_os_windows; i++) {
            // On some platforms (macOS) newly created windows don't get the initial focus in event
            OSWindow *q = global_state.os_windows + i;
            q->is_focused = q == w ? true : false;
        }
    }
    w->fonts_data = fonts_data;
    w->shown_once = true;
    w->last_focused_counter = ++focus_counter;
    os_window_update_size_increments(w);
#ifdef __APPLE__
    if (OPT(macos_option_as_alt)) glfwSetCocoaTextInputFilter(glfw_window, filter_option);
    glfwSetCocoaToggleFullscreenIntercept(glfw_window, intercept_cocoa_fullscreen);
    glfwCocoaSetWindowResizeCallback(glfw_window, cocoa_os_window_resized);
#endif
    send_prerendered_sprites_for_window(w);
    if (logo.pixels && logo.width && logo.height && (!lsc || !global_state.is_wayland)) glfwSetWindowIcon(glfw_window, 1, &logo);
    set_glfw_mouse_pointer_shape_in_window(glfw_window, OPT(default_pointer_shape));
    update_os_window_viewport(w, false);
    glfwSetWindowPosCallback(glfw_window, window_pos_callback);
    // missing size callback
    glfwSetWindowCloseCallback(glfw_window, window_close_callback);
    glfwSetWindowRefreshCallback(glfw_window, refresh_callback);
    glfwSetWindowFocusCallback(glfw_window, window_focus_callback);
    glfwSetWindowOcclusionCallback(glfw_window, window_occlusion_callback);
    glfwSetWindowIconifyCallback(glfw_window, window_iconify_callback);
    // missing maximize/restore callback
    glfwSetFramebufferSizeCallback(glfw_window, framebuffer_size_callback);
    glfwSetLiveResizeCallback(glfw_window, live_resize_callback);
    glfwSetWindowContentScaleCallback(glfw_window, dpi_change_callback);
    glfwSetMouseButtonCallback(glfw_window, mouse_button_callback);
    glfwSetCursorPosCallback(glfw_window, cursor_pos_callback);
    glfwSetCursorEnterCallback(glfw_window, cursor_enter_callback);
    glfwSetScrollCallback(glfw_window, scroll_callback);
    glfwSetKeyboardCallback(glfw_window, key_callback);

    glfwSetDragSourceCallback(glfw_window, drag_source_callback);
    glfwSetDropEventCallback(glfw_window, drop_dest_callback);
    monotonic_t now = monotonic();
    w->is_focused = true;
    w->cursor_blink_zero_time = now;
    w->last_mouse_activity_at = now;
    w->mouse_activate_deadline = -1;
    w->mouse_show_threshold = 0;
    w->background_opacity.supports_transparency = is_semi_transparent;
    if (want_semi_transparent && !w->background_opacity.supports_transparency) {
        static bool warned = false;
        if (!warned) {
            log_error("Failed to enable transparency. This happens when your desktop environment does not support compositing.");
            warned = true;
        }
    }
    init_window_chrome_state(&w->last_window_chrome, OPT(background), effective_os_window_alpha(w));
    if (w->is_layer_shell) {
        if (global_state.is_apple) set_layer_shell_config_for(w, lsc);
    } else apply_window_chrome_state(
            w->handle, w->last_window_chrome, width, height, global_state.is_apple ? OPT(hide_window_decorations) != 0 : false);
#ifdef __APPLE__
    if (!w->is_layer_shell) glfwCocoaSetWindowLevel(w->handle, OPT(macos_ns_window_layer));
#endif
    // Update window state
    // We do not call glfwWindowHint to set GLFW_MAXIMIZED before the window is created.
    // That would cause the window to be set to maximize immediately after creation and use the wrong initial size when restored.
    if (window_state != WINDOW_NORMAL) change_state_for_os_window(w, window_state);
#ifdef __APPLE__
    // macOS: Show the window after it is ready
    if (window_state != WINDOW_HIDDEN) glfwShowWindow(glfw_window, false);
#endif
    w->redraw_count = 1;
    debug("OS Window created\n");
    return PyLong_FromUnsignedLongLong(w->id);
}

void
on_os_window_font_size_change(OSWindow *os_window, double new_sz) {
    double xdpi, ydpi; float xscale, yscale;
    get_os_window_content_scale(os_window, &xdpi, &ydpi, &xscale, &yscale);
    os_window->fonts_data = load_fonts_data(new_sz, xdpi, ydpi);
    os_window_update_size_increments(os_window);
    if (os_window->is_layer_shell) set_layer_shell_config_for(os_window, NULL);
}

#ifdef __APPLE__
static bool
window_in_same_cocoa_workspace(void *w, size_t *source_workspaces, size_t source_workspace_count) {
    static size_t workspaces[64];
    size_t workspace_count = cocoa_get_workspace_ids(w, workspaces, arraysz(workspaces));
    for (size_t i = 0; i < workspace_count; i++) {
        for (size_t s = 0; s < source_workspace_count; s++) {
            if (source_workspaces[s] == workspaces[i]) return true;
        }
    }
    return false;
}

static void
cocoa_focus_last_window(id_type source_window_id, size_t *source_workspaces, size_t source_workspace_count) {
    id_type highest_focus_number = 0;
    OSWindow *window_to_focus = NULL;
    for (size_t i = 0; i < global_state.num_os_windows; i++) {
        OSWindow *w = global_state.os_windows + i;
        if (
                w->id != source_window_id && w->handle && w->shown_once &&
                w->last_focused_counter >= highest_focus_number && !glfwGetWindowAttrib(w->handle, GLFW_ICONIFIED) &&
                (!source_workspace_count || window_in_same_cocoa_workspace(glfwGetCocoaWindow(w->handle), source_workspaces, source_workspace_count))
        ) {
            highest_focus_number = w->last_focused_counter;
            window_to_focus = w;
        }
    }
    if (window_to_focus) glfwFocusWindow(window_to_focus->handle);
}
#endif

void
destroy_os_window(OSWindow *w) {
#ifdef __APPLE__
    static size_t source_workspaces[64];
    size_t source_workspace_count = 0;
#endif
    if (w->handle) {
#ifdef __APPLE__
        source_workspace_count = cocoa_get_workspace_ids(glfwGetCocoaWindow(w->handle), source_workspaces, arraysz(source_workspaces));
#endif
        // Ensure mouse cursor is visible and reset to default shape, needed on macOS
        show_mouse_cursor(w->handle);
        glfwSetCursor(w->handle, NULL);
        glfwDestroyWindow(w->handle);
    }
    w->handle = NULL;
#ifdef __APPLE__
    // On macOS when closing a window, any other existing windows belonging to the same application do not
    // automatically get focus, so we do it manually.
    cocoa_focus_last_window(w->id, source_workspaces, source_workspace_count);
#endif
}

void
focus_os_window(OSWindow *w, bool also_raise, const char *activation_token) {
    if (w->handle) {
#ifdef __APPLE__
        if (!also_raise) cocoa_focus_window(glfwGetCocoaWindow(w->handle));
        else glfwFocusWindow(w->handle);
        (void)activation_token;
#else
        if (global_state.is_wayland && activation_token && activation_token[0] && also_raise) {
            glfwWaylandActivateWindow(w->handle, activation_token);
            return;
        }
        glfwFocusWindow(w->handle);
#endif
    }
}

// Global functions {{{
static void
error_callback(int error, const char* description) {
    log_error("[glfw error %d]: %s", error, description);
}


#ifndef __APPLE__
static PyObject *dbus_notification_callback = NULL;

static PyObject*
dbus_set_notification_callback(PyObject *self UNUSED, PyObject *callback) {
    Py_CLEAR(dbus_notification_callback);
    if (callback && callback != Py_None) {
        dbus_notification_callback = callback; Py_INCREF(callback);
        GLFWDBUSNotificationData d = {.timeout=-99999, .urgency=255};
        if (!glfwDBusUserNotify) {
            PyErr_SetString(PyExc_RuntimeError, "Failed to load glfwDBusUserNotify, did you call glfw_init?");
            return NULL;
        }
        glfwDBusUserNotify(&d, NULL, NULL);
    }
    Py_RETURN_NONE;
}

#define send_dbus_notification_event_to_python(event_type, a, b) { \
    if (dbus_notification_callback) { \
        const char call_args_fmt[] = {'s', \
            _Generic((a), unsigned long : 'k', unsigned long long : 'K'), _Generic((b), unsigned long : 'k', const char* : 's'), '\0' }; \
        RAII_PyObject(ret, PyObject_CallFunction(dbus_notification_callback, call_args_fmt, event_type, a, b)); \
        if (!ret) PyErr_Print(); \
    } \
}


static void
dbus_user_notification_activated(uint32_t notification_id, int type, const char* action) {
    unsigned long nid = notification_id;
    const char *stype = "activated";
    switch (type) {
        case 0: stype = "closed"; break;
        case 1: stype = "activation_token"; break;
        case -1: stype = "capabilities"; break;
    }
    send_dbus_notification_event_to_python(stype, nid, action);
}
#endif

static PyObject*
glfw_init(PyObject UNUSED *self, PyObject *args) {
    const char* path;
    int debug_keyboard = 0, debug_rendering = 0, wayland_enable_ime = 0;
    PyObject *edge_sf;
    if (!PyArg_ParseTuple(args, "sO|ppp", &path, &edge_sf, &debug_keyboard, &debug_rendering, &wayland_enable_ime)) return NULL;
    if (!PyCallable_Check(edge_sf)) { PyErr_SetString(PyExc_TypeError, "edge_spacing_func must be a callable"); return NULL; }
    Py_CLEAR(edge_spacing_func);
#ifdef __APPLE__
    cocoa_set_uncaught_exception_handler();
#endif
    const char* err = load_glfw(path);
    if (err) { PyErr_SetString(PyExc_RuntimeError, err); return NULL; }
    glfwSetErrorCallback(error_callback);
    glfwInitHint(GLFW_DEBUG_KEYBOARD, debug_keyboard);
    glfwInitHint(GLFW_DEBUG_RENDERING, debug_rendering);
    OPT(debug_keyboard) = debug_keyboard != 0;
    glfwInitHint(GLFW_WAYLAND_IME, wayland_enable_ime != 0);
#ifdef __APPLE__
    glfwInitHint(GLFW_COCOA_CHDIR_RESOURCES, 0);
    glfwInitHint(GLFW_COCOA_MENUBAR, 0);
#else
    if (glfwDBusSetUserNotificationHandler) {
        glfwDBusSetUserNotificationHandler(dbus_user_notification_activated);
    }
#endif
    bool supports_window_occlusion = false;
    bool ok = glfwInit(monotonic_start_time, &supports_window_occlusion);
    if (ok) {
#ifdef __APPLE__
        glfwSetCocoaURLOpenCallback(apple_url_open_callback);
#else
        glfwSetDrawTextFunction(draw_text_callback);
#endif
        get_window_dpi(NULL, &global_state.default_dpi.x, &global_state.default_dpi.y);
        edge_spacing_func = edge_sf; Py_INCREF(edge_spacing_func);
    }
    return Py_BuildValue("OO", ok ? Py_True : Py_False, supports_window_occlusion ? Py_True : Py_False);
}

static PyObject*
glfw_terminate(PYNOARG) {
    for (size_t i = 0; i < arraysz(cursors); i++) {
        if (cursors[i].is_custom && cursors[i].glfw) {
            glfwDestroyCursor(cursors[i].glfw);
            cursors[i] = (mouse_cursor){0};
        }
    }
    glfwTerminate();
    Py_CLEAR(edge_spacing_func);
    Py_RETURN_NONE;
}

static PyObject*
get_physical_dpi(GLFWmonitor *m) {
    int width = 0, height = 0;
    glfwGetMonitorPhysicalSize(m, &width, &height);
    if (width == 0 || height == 0) { PyErr_SetString(PyExc_ValueError, "Failed to get primary monitor size"); return NULL; }
    const GLFWvidmode *vm = glfwGetVideoMode(m);
    if (vm == NULL) { PyErr_SetString(PyExc_ValueError, "Failed to get video mode for monitor"); return NULL; }
    float dpix = (float)(vm->width / (width / 25.4));
    float dpiy = (float)(vm->height / (height / 25.4));
    return Py_BuildValue("ff", dpix, dpiy);
}

static PyObject*
glfw_get_physical_dpi(PYNOARG) {
    GLFWmonitor *m = glfwGetPrimaryMonitor();
    if (m == NULL) { PyErr_SetString(PyExc_ValueError, "Failed to get primary monitor"); return NULL; }
    return get_physical_dpi(m);
}

static PyObject*
glfw_get_system_color_theme(PyObject UNUSED *self, PyObject *args) {
    int query_if_unintialized = 1;
    if (!PyArg_ParseTuple(args, "|p", &query_if_unintialized)) return NULL;
    if (!glfwGetCurrentSystemColorTheme) {
        PyErr_SetString(PyExc_RuntimeError, "must initialize GFLW before calling this function"); return NULL;
    }
    const char *which = appearance_name(glfwGetCurrentSystemColorTheme(query_if_unintialized));
    return PyUnicode_FromString(which);
}

static PyObject*
glfw_get_key_name(PyObject UNUSED *self, PyObject *args) {
    int key, native_key;
    if (!PyArg_ParseTuple(args, "ii", &key, &native_key)) return NULL;
    if (key) {
        switch (key) {
            /* start glfw functional key names (auto generated by gen-key-constants.py do not edit) */
            case GLFW_FKEY_ESCAPE: return PyUnicode_FromString("escape");
            case GLFW_FKEY_ENTER: return PyUnicode_FromString("enter");
            case GLFW_FKEY_TAB: return PyUnicode_FromString("tab");
            case GLFW_FKEY_BACKSPACE: return PyUnicode_FromString("backspace");
            case GLFW_FKEY_INSERT: return PyUnicode_FromString("insert");
            case GLFW_FKEY_DELETE: return PyUnicode_FromString("delete");
            case GLFW_FKEY_LEFT: return PyUnicode_FromString("left");
            case GLFW_FKEY_RIGHT: return PyUnicode_FromString("right");
            case GLFW_FKEY_UP: return PyUnicode_FromString("up");
            case GLFW_FKEY_DOWN: return PyUnicode_FromString("down");
            case GLFW_FKEY_PAGE_UP: return PyUnicode_FromString("page_up");
            case GLFW_FKEY_PAGE_DOWN: return PyUnicode_FromString("page_down");
            case GLFW_FKEY_HOME: return PyUnicode_FromString("home");
            case GLFW_FKEY_END: return PyUnicode_FromString("end");
            case GLFW_FKEY_CAPS_LOCK: return PyUnicode_FromString("caps_lock");
            case GLFW_FKEY_SCROLL_LOCK: return PyUnicode_FromString("scroll_lock");
            case GLFW_FKEY_NUM_LOCK: return PyUnicode_FromString("num_lock");
            case GLFW_FKEY_PRINT_SCREEN: return PyUnicode_FromString("print_screen");
            case GLFW_FKEY_PAUSE: return PyUnicode_FromString("pause");
            case GLFW_FKEY_MENU: return PyUnicode_FromString("menu");
            case GLFW_FKEY_F1: return PyUnicode_FromString("f1");
            case GLFW_FKEY_F2: return PyUnicode_FromString("f2");
            case GLFW_FKEY_F3: return PyUnicode_FromString("f3");
            case GLFW_FKEY_F4: return PyUnicode_FromString("f4");
            case GLFW_FKEY_F5: return PyUnicode_FromString("f5");
            case GLFW_FKEY_F6: return PyUnicode_FromString("f6");
            case GLFW_FKEY_F7: return PyUnicode_FromString("f7");
            case GLFW_FKEY_F8: return PyUnicode_FromString("f8");
            case GLFW_FKEY_F9: return PyUnicode_FromString("f9");
            case GLFW_FKEY_F10: return PyUnicode_FromString("f10");
            case GLFW_FKEY_F11: return PyUnicode_FromString("f11");
            case GLFW_FKEY_F12: return PyUnicode_FromString("f12");
            case GLFW_FKEY_F13: return PyUnicode_FromString("f13");
            case GLFW_FKEY_F14: return PyUnicode_FromString("f14");
            case GLFW_FKEY_F15: return PyUnicode_FromString("f15");
            case GLFW_FKEY_F16: return PyUnicode_FromString("f16");
            case GLFW_FKEY_F17: return PyUnicode_FromString("f17");
            case GLFW_FKEY_F18: return PyUnicode_FromString("f18");
            case GLFW_FKEY_F19: return PyUnicode_FromString("f19");
            case GLFW_FKEY_F20: return PyUnicode_FromString("f20");
            case GLFW_FKEY_F21: return PyUnicode_FromString("f21");
            case GLFW_FKEY_F22: return PyUnicode_FromString("f22");
            case GLFW_FKEY_F23: return PyUnicode_FromString("f23");
            case GLFW_FKEY_F24: return PyUnicode_FromString("f24");
            case GLFW_FKEY_F25: return PyUnicode_FromString("f25");
            case GLFW_FKEY_F26: return PyUnicode_FromString("f26");
            case GLFW_FKEY_F27: return PyUnicode_FromString("f27");
            case GLFW_FKEY_F28: return PyUnicode_FromString("f28");
            case GLFW_FKEY_F29: return PyUnicode_FromString("f29");
            case GLFW_FKEY_F30: return PyUnicode_FromString("f30");
            case GLFW_FKEY_F31: return PyUnicode_FromString("f31");
            case GLFW_FKEY_F32: return PyUnicode_FromString("f32");
            case GLFW_FKEY_F33: return PyUnicode_FromString("f33");
            case GLFW_FKEY_F34: return PyUnicode_FromString("f34");
            case GLFW_FKEY_F35: return PyUnicode_FromString("f35");
            case GLFW_FKEY_KP_0: return PyUnicode_FromString("kp_0");
            case GLFW_FKEY_KP_1: return PyUnicode_FromString("kp_1");
            case GLFW_FKEY_KP_2: return PyUnicode_FromString("kp_2");
            case GLFW_FKEY_KP_3: return PyUnicode_FromString("kp_3");
            case GLFW_FKEY_KP_4: return PyUnicode_FromString("kp_4");
            case GLFW_FKEY_KP_5: return PyUnicode_FromString("kp_5");
            case GLFW_FKEY_KP_6: return PyUnicode_FromString("kp_6");
            case GLFW_FKEY_KP_7: return PyUnicode_FromString("kp_7");
            case GLFW_FKEY_KP_8: return PyUnicode_FromString("kp_8");
            case GLFW_FKEY_KP_9: return PyUnicode_FromString("kp_9");
            case GLFW_FKEY_KP_DECIMAL: return PyUnicode_FromString("kp_decimal");
            case GLFW_FKEY_KP_DIVIDE: return PyUnicode_FromString("kp_divide");
            case GLFW_FKEY_KP_MULTIPLY: return PyUnicode_FromString("kp_multiply");
            case GLFW_FKEY_KP_SUBTRACT: return PyUnicode_FromString("kp_subtract");
            case GLFW_FKEY_KP_ADD: return PyUnicode_FromString("kp_add");
            case GLFW_FKEY_KP_ENTER: return PyUnicode_FromString("kp_enter");
            case GLFW_FKEY_KP_EQUAL: return PyUnicode_FromString("kp_equal");
            case GLFW_FKEY_KP_SEPARATOR: return PyUnicode_FromString("kp_separator");
            case GLFW_FKEY_KP_LEFT: return PyUnicode_FromString("kp_left");
            case GLFW_FKEY_KP_RIGHT: return PyUnicode_FromString("kp_right");
            case GLFW_FKEY_KP_UP: return PyUnicode_FromString("kp_up");
            case GLFW_FKEY_KP_DOWN: return PyUnicode_FromString("kp_down");
            case GLFW_FKEY_KP_PAGE_UP: return PyUnicode_FromString("kp_page_up");
            case GLFW_FKEY_KP_PAGE_DOWN: return PyUnicode_FromString("kp_page_down");
            case GLFW_FKEY_KP_HOME: return PyUnicode_FromString("kp_home");
            case GLFW_FKEY_KP_END: return PyUnicode_FromString("kp_end");
            case GLFW_FKEY_KP_INSERT: return PyUnicode_FromString("kp_insert");
            case GLFW_FKEY_KP_DELETE: return PyUnicode_FromString("kp_delete");
            case GLFW_FKEY_KP_BEGIN: return PyUnicode_FromString("kp_begin");
            case GLFW_FKEY_MEDIA_PLAY: return PyUnicode_FromString("media_play");
            case GLFW_FKEY_MEDIA_PAUSE: return PyUnicode_FromString("media_pause");
            case GLFW_FKEY_MEDIA_PLAY_PAUSE: return PyUnicode_FromString("media_play_pause");
            case GLFW_FKEY_MEDIA_REVERSE: return PyUnicode_FromString("media_reverse");
            case GLFW_FKEY_MEDIA_STOP: return PyUnicode_FromString("media_stop");
            case GLFW_FKEY_MEDIA_FAST_FORWARD: return PyUnicode_FromString("media_fast_forward");
            case GLFW_FKEY_MEDIA_REWIND: return PyUnicode_FromString("media_rewind");
            case GLFW_FKEY_MEDIA_TRACK_NEXT: return PyUnicode_FromString("media_track_next");
            case GLFW_FKEY_MEDIA_TRACK_PREVIOUS: return PyUnicode_FromString("media_track_previous");
            case GLFW_FKEY_MEDIA_RECORD: return PyUnicode_FromString("media_record");
            case GLFW_FKEY_LOWER_VOLUME: return PyUnicode_FromString("lower_volume");
            case GLFW_FKEY_RAISE_VOLUME: return PyUnicode_FromString("raise_volume");
            case GLFW_FKEY_MUTE_VOLUME: return PyUnicode_FromString("mute_volume");
            case GLFW_FKEY_LEFT_SHIFT: return PyUnicode_FromString("left_shift");
            case GLFW_FKEY_LEFT_CONTROL: return PyUnicode_FromString("left_control");
            case GLFW_FKEY_LEFT_ALT: return PyUnicode_FromString("left_alt");
            case GLFW_FKEY_LEFT_SUPER: return PyUnicode_FromString("left_super");
            case GLFW_FKEY_LEFT_HYPER: return PyUnicode_FromString("left_hyper");
            case GLFW_FKEY_LEFT_META: return PyUnicode_FromString("left_meta");
            case GLFW_FKEY_RIGHT_SHIFT: return PyUnicode_FromString("right_shift");
            case GLFW_FKEY_RIGHT_CONTROL: return PyUnicode_FromString("right_control");
            case GLFW_FKEY_RIGHT_ALT: return PyUnicode_FromString("right_alt");
            case GLFW_FKEY_RIGHT_SUPER: return PyUnicode_FromString("right_super");
            case GLFW_FKEY_RIGHT_HYPER: return PyUnicode_FromString("right_hyper");
            case GLFW_FKEY_RIGHT_META: return PyUnicode_FromString("right_meta");
            case GLFW_FKEY_ISO_LEVEL3_SHIFT: return PyUnicode_FromString("iso_level3_shift");
            case GLFW_FKEY_ISO_LEVEL5_SHIFT: return PyUnicode_FromString("iso_level5_shift");
/* end glfw functional key names */
        }
        char buf[8] = {0};
        encode_utf8(key, buf);
        return PyUnicode_FromString(buf);
    }
    if (!glfwGetKeyName) {
        return PyUnicode_FromFormat("0x%x", native_key);
    }
    return Py_BuildValue("z", glfwGetKeyName(key, native_key));
}


static PyObject*
glfw_window_hint(PyObject UNUSED *self, PyObject *args) {
    int key, val;
    if (!PyArg_ParseTuple(args, "ii", &key, &val)) return NULL;
    glfwWindowHint(key, val);
    Py_RETURN_NONE;
}


// }}}

static PyObject*
toggle_secure_input(PYNOARG) {
#ifdef __APPLE__
    cocoa_toggle_secure_keyboard_entry();
#endif
    Py_RETURN_NONE;
}

static PyObject*
macos_cycle_through_os_windows(PyObject *self UNUSED, PyObject *backwards) {
#ifdef __APPLE__
    glfwCocoaCycleThroughOSWindows(PyObject_IsTrue(backwards));
#else
    (void)backwards;
#endif
    Py_RETURN_NONE;
}


static PyObject*
cocoa_hide_app(PYNOARG) {
#ifdef __APPLE__
    cocoa_hide();
#endif
    Py_RETURN_NONE;
}

static PyObject*
cocoa_hide_other_apps(PYNOARG) {
#ifdef __APPLE__
    cocoa_hide_others();
#endif
    Py_RETURN_NONE;
}

static void
ring_audio_bell(OSWindow *w) {
    static monotonic_t last_bell_at = -1;
    monotonic_t now = monotonic();
    if (last_bell_at >= 0 && now - last_bell_at <= ms_to_monotonic_t(100ll)) return;
    last_bell_at = now;
#ifdef __APPLE__
    (void)w;
    cocoa_system_beep(OPT(bell_path));
#else
    if (OPT(bell_path)) play_canberra_sound(OPT(bell_path), "kitty bell", true, "event", OPT(bell_theme));
    else {
        if (!global_state.is_wayland || !glfwWaylandBeep(w ? w->handle : NULL)) play_canberra_sound(
                "bell", "kitty bell", false, "event", OPT(bell_theme));
    }
#endif
}

static PyObject*
ring_bell(PyObject *self UNUSED, PyObject *args) {
    unsigned long long os_window_id = 0;
    if (!PyArg_ParseTuple(args, "|K", &os_window_id)) return NULL;
    OSWindow *w = os_window_for_id(os_window_id);
    ring_audio_bell(w);
    Py_RETURN_NONE;
}

static PyObject*
request_attention(PyObject *self UNUSED, PyObject *args) {
    unsigned long long os_window_id;
    if (!PyArg_ParseTuple(args, "K", &os_window_id)) return NULL;
    OSWindow *w = os_window_for_id(os_window_id);
    if (w && w->handle) glfwRequestWindowAttention(w->handle);
    Py_RETURN_NONE;
}


static PyObject*
get_content_scale_for_window(PYNOARG) {
    OSWindow *w = global_state.callback_os_window ? global_state.callback_os_window : global_state.os_windows;
    float xscale, yscale;
    glfwGetWindowContentScale(w->handle, &xscale, &yscale);
    return Py_BuildValue("ff", xscale, yscale);
}

static void
activation_token_callback(GLFWwindow *window UNUSED, const char *token, void *data) {
    if (!token || !token[0]) {
        token = "";
        log_error("Wayland: Did not get activation token from compositor. Use a better compositor.");
    }
    PyObject *ret = PyObject_CallFunction(data, "s", token);
    if (ret == NULL) PyErr_Print();
    else Py_DECREF(ret);
    Py_CLEAR(data);
}

void
run_with_activation_token_in_os_window(OSWindow *w, PyObject *callback) {
    if (global_state.is_wayland) {
        Py_INCREF(callback);
        glfwWaylandRunWithActivationToken(w->handle, activation_token_callback, callback);
    }
}

static PyObject*
toggle_fullscreen(PyObject UNUSED *self, PyObject *args) {
    id_type os_window_id = 0;
    if (!PyArg_ParseTuple(args, "|K", &os_window_id)) return NULL;
    OSWindow *w = os_window_id ? os_window_for_id(os_window_id) : current_os_window();
    if (!w) Py_RETURN_NONE;
    if (toggle_fullscreen_for_os_window(w)) { Py_RETURN_TRUE; }
    Py_RETURN_FALSE;
}

static PyObject*
toggle_maximized(PyObject UNUSED *self, PyObject *args) {
    id_type os_window_id = 0;
    if (!PyArg_ParseTuple(args, "|K", &os_window_id)) return NULL;
    OSWindow *w = os_window_id ? os_window_for_id(os_window_id) : current_os_window();
    if (!w) Py_RETURN_NONE;
    if (toggle_maximized_for_os_window(w)) { Py_RETURN_TRUE; }
    Py_RETURN_FALSE;
}

static PyObject*
cocoa_minimize_os_window(PyObject UNUSED *self, PyObject *args) {
    id_type os_window_id = 0;
    if (!PyArg_ParseTuple(args, "|K", &os_window_id)) return NULL;
#ifdef __APPLE__
    OSWindow *w = os_window_id ? os_window_for_id(os_window_id) : current_os_window();
    if (!w || !w->handle || w->is_layer_shell) Py_RETURN_NONE;
    if (!glfwGetCocoaWindow) { PyErr_SetString(PyExc_RuntimeError, "Failed to load glfwGetCocoaWindow"); return NULL; }
    void *window = glfwGetCocoaWindow(w->handle);
    if (!window) Py_RETURN_NONE;
    cocoa_minimize(window);
#else
    PyErr_SetString(PyExc_RuntimeError, "cocoa_minimize_os_window() is only supported on macOS");
    return NULL;
#endif
    Py_RETURN_NONE;
}

static PyObject*
change_os_window_state(PyObject *self UNUSED, PyObject *args) {
    int state;
    id_type wid = 0;
    if (!PyArg_ParseTuple(args, "i|K", &state, &wid)) return NULL;
    OSWindow *w = wid ? os_window_for_id(wid) : current_os_window();
    if (!w || !w->handle) Py_RETURN_NONE;
    if (state < WINDOW_NORMAL || state > WINDOW_MINIMIZED) {
        PyErr_SetString(PyExc_ValueError, "Unknown window state");
        return NULL;
    }
    change_state_for_os_window(w, state);
    Py_RETURN_NONE;
}

void
request_window_attention(id_type kitty_window_id, bool audio_bell) {
    OSWindow *w = os_window_for_kitty_window(kitty_window_id);
    if (w) {
        if (audio_bell) ring_audio_bell(w);
        if (OPT(window_alert_on_bell)) glfwRequestWindowAttention(w->handle);
#ifdef __APPLE__
        if (OPT(macos_dock_badge_on_bell)) cocoa_set_dock_badge("!");
#endif
        glfwPostEmptyEvent();
    }
}

void
set_os_window_title(OSWindow *w, const char *title) {
    if (!title) {
        if (global_state.is_wayland) glfwWaylandRedrawCSDWindowTitle(w->handle);
        return;
    }
    static char buf[2048];
    strip_csi_(title, buf, arraysz(buf));
    glfwSetWindowTitle(w->handle, buf);
}

void
hide_mouse(OSWindow *w) {
    glfwSetInputMode(w->handle, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
    w->mouse_activate_deadline = -1;
}

bool
is_mouse_hidden(OSWindow *w) {
    return w->handle && glfwGetInputMode(w->handle, GLFW_CURSOR) == GLFW_CURSOR_HIDDEN;
}


void
swap_window_buffers(OSWindow *os_window) {
    if (glfwAreSwapsAllowed(os_window->handle)) {
        glfwSwapBuffers(os_window->handle);
        os_window->keep_rendering_till_swap = 0;
    }
}

void
wakeup_main_loop(void) {
    glfwPostEmptyEvent();
}

bool
should_os_window_be_rendered(OSWindow* w) {
    return (
            glfwGetWindowAttrib(w->handle, GLFW_ICONIFIED)
            || !glfwGetWindowAttrib(w->handle, GLFW_VISIBLE)
            || glfwGetWindowAttrib(w->handle, GLFW_OCCLUDED)
            || !glfwAreSwapsAllowed(w->handle)
       ) ? false : true;
}

static PyObject*
primary_monitor_size(PYNOARG) {
    GLFWmonitor* monitor = glfwGetPrimaryMonitor();
    const GLFWvidmode* mode = glfwGetVideoMode(monitor);
    if (mode == NULL) { PyErr_SetString(PyExc_ValueError, "Failed to get video mode for primary monitor"); return NULL; }
    return Py_BuildValue("ii", mode->width, mode->height);
}

static PyObject*
get_monitor_workarea(PYNOARG) {
    int count = 0;
    GLFWmonitor **monitors = glfwGetMonitors(&count);
    if (count <= 0 || !monitors) return PyTuple_New(0);
    RAII_PyObject(result, PyTuple_New(count)); if (!result) return NULL;
    for (int i = 0; i < count; i++) {
        int xpos, ypos, width, height;
        glfwGetMonitorWorkarea(monitors[i], &xpos, &ypos, &width, &height);
        PyObject *monitor_workarea = Py_BuildValue("iiii", xpos, ypos, width, height);
        if (!monitor_workarea) return NULL;
        PyTuple_SET_ITEM(result, i, monitor_workarea);
    }
    return Py_NewRef(result);
}

static PyObject*
get_monitor_names(PYNOARG) {
    int count = 0;
    GLFWmonitor **monitors = glfwGetMonitors(&count);
    if (count <= 0 || !monitors) return PyTuple_New(0);
    RAII_PyObject(result, PyTuple_New(count)); if (!result) return NULL;
    for (int i = 0; i < count; i++) {
        const char *name = glfwGetMonitorName(monitors[i]);
        const char *description = glfwGetMonitorDescription(monitors[i]);
        PyObject *x = Py_BuildValue("ss", name, description);
        if (!x) return NULL;
        PyTuple_SET_ITEM(result, i, x);
    }
    return Py_NewRef(result);
}


static PyObject*
primary_monitor_content_scale(PYNOARG) {
    GLFWmonitor* monitor = glfwGetPrimaryMonitor();
    float xscale = 1.0, yscale = 1.0;
    if (monitor) glfwGetMonitorContentScale(monitor, &xscale, &yscale);
    return Py_BuildValue("ff", xscale, yscale);
}

static PyObject*
x11_display(PYNOARG) {
    if (glfwGetX11Display) {
        return PyLong_FromVoidPtr(glfwGetX11Display());
    } else log_error("Failed to load glfwGetX11Display");
    Py_RETURN_NONE;
}

static PyObject*
wayland_compositor_data(PYNOARG) {
    pid_t pid = -1;
    const char *missing_capabilities = NULL;
    if (global_state.is_wayland && glfwWaylandCompositorPID) {
        pid = glfwWaylandCompositorPID();
        missing_capabilities = glfwWaylandMissingCapabilities();
    }
    return Py_BuildValue("Ls", (long long)pid, missing_capabilities);
}

static PyObject*
x11_window_id(PyObject UNUSED *self, PyObject *os_wid) {
    OSWindow *w = os_window_for_id(PyLong_AsUnsignedLongLong(os_wid));
    if (!w) { PyErr_SetString(PyExc_ValueError, "No OSWindow with the specified id found"); return NULL; }
    if (!glfwGetX11Window) { PyErr_SetString(PyExc_RuntimeError, "Failed to load glfwGetX11Window"); return NULL; }
    return PyLong_FromUnsignedLong(glfwGetX11Window(w->handle));
}

static PyObject*
cocoa_window_id(PyObject UNUSED *self, PyObject *os_wid) {
    OSWindow *w = os_window_for_id(PyLong_AsUnsignedLongLong(os_wid));
    if (!w) { PyErr_SetString(PyExc_ValueError, "No OSWindow with the specified id found"); return NULL; }
    if (!glfwGetCocoaWindow) { PyErr_SetString(PyExc_RuntimeError, "Failed to load glfwGetCocoaWindow"); return NULL; }
#ifdef __APPLE__
    return Py_BuildValue("l", (long)cocoa_window_number(glfwGetCocoaWindow(w->handle)));
#else
    PyErr_SetString(PyExc_RuntimeError, "cocoa_window_id() is only supported on Mac");
    return NULL;
#endif
}

static GLFWCursorShape
pointer_name_to_glfw_name(const char *name) {
    /* start name to glfw (auto generated by gen-key-constants.py do not edit) */
    if (strcmp(name, "arrow") == 0) return GLFW_DEFAULT_CURSOR;
    if (strcmp(name, "beam") == 0) return GLFW_TEXT_CURSOR;
    if (strcmp(name, "text") == 0) return GLFW_TEXT_CURSOR;
    if (strcmp(name, "pointer") == 0) return GLFW_POINTER_CURSOR;
    if (strcmp(name, "hand") == 0) return GLFW_POINTER_CURSOR;
    if (strcmp(name, "help") == 0) return GLFW_HELP_CURSOR;
    if (strcmp(name, "wait") == 0) return GLFW_WAIT_CURSOR;
    if (strcmp(name, "progress") == 0) return GLFW_PROGRESS_CURSOR;
    if (strcmp(name, "crosshair") == 0) return GLFW_CROSSHAIR_CURSOR;
    if (strcmp(name, "cell") == 0) return GLFW_CELL_CURSOR;
    if (strcmp(name, "vertical-text") == 0) return GLFW_VERTICAL_TEXT_CURSOR;
    if (strcmp(name, "move") == 0) return GLFW_MOVE_CURSOR;
    if (strcmp(name, "e-resize") == 0) return GLFW_E_RESIZE_CURSOR;
    if (strcmp(name, "ne-resize") == 0) return GLFW_NE_RESIZE_CURSOR;
    if (strcmp(name, "nw-resize") == 0) return GLFW_NW_RESIZE_CURSOR;
    if (strcmp(name, "n-resize") == 0) return GLFW_N_RESIZE_CURSOR;
    if (strcmp(name, "se-resize") == 0) return GLFW_SE_RESIZE_CURSOR;
    if (strcmp(name, "sw-resize") == 0) return GLFW_SW_RESIZE_CURSOR;
    if (strcmp(name, "s-resize") == 0) return GLFW_S_RESIZE_CURSOR;
    if (strcmp(name, "w-resize") == 0) return GLFW_W_RESIZE_CURSOR;
    if (strcmp(name, "ew-resize") == 0) return GLFW_EW_RESIZE_CURSOR;
    if (strcmp(name, "ns-resize") == 0) return GLFW_NS_RESIZE_CURSOR;
    if (strcmp(name, "nesw-resize") == 0) return GLFW_NESW_RESIZE_CURSOR;
    if (strcmp(name, "nwse-resize") == 0) return GLFW_NWSE_RESIZE_CURSOR;
    if (strcmp(name, "zoom-in") == 0) return GLFW_ZOOM_IN_CURSOR;
    if (strcmp(name, "zoom-out") == 0) return GLFW_ZOOM_OUT_CURSOR;
    if (strcmp(name, "alias") == 0) return GLFW_ALIAS_CURSOR;
    if (strcmp(name, "copy") == 0) return GLFW_COPY_CURSOR;
    if (strcmp(name, "not-allowed") == 0) return GLFW_NOT_ALLOWED_CURSOR;
    if (strcmp(name, "no-drop") == 0) return GLFW_NO_DROP_CURSOR;
    if (strcmp(name, "grab") == 0) return GLFW_GRAB_CURSOR;
    if (strcmp(name, "grabbing") == 0) return GLFW_GRABBING_CURSOR;
/* end name to glfw */
    return GLFW_INVALID_CURSOR;
}

static PyObject*
is_css_pointer_name_valid(PyObject *self UNUSED, PyObject *name) {
    if (!PyUnicode_Check(name)) { PyErr_SetString(PyExc_TypeError, "pointer name must be a string"); return NULL; }
    const char *q = PyUnicode_AsUTF8(name);
    if (strcmp(q, "default") == 0) { Py_RETURN_TRUE; }
    if (pointer_name_to_glfw_name(q) == GLFW_INVALID_CURSOR) { Py_RETURN_FALSE; }
    Py_RETURN_TRUE;
}

static const char*
glfw_name_to_css_pointer_name(GLFWCursorShape q) {
    switch(q) {
        case GLFW_INVALID_CURSOR: return "";
        /* start glfw to css (auto generated by gen-key-constants.py do not edit) */
        case GLFW_DEFAULT_CURSOR: return "default";
        case GLFW_TEXT_CURSOR: return "text";
        case GLFW_POINTER_CURSOR: return "pointer";
        case GLFW_HELP_CURSOR: return "help";
        case GLFW_WAIT_CURSOR: return "wait";
        case GLFW_PROGRESS_CURSOR: return "progress";
        case GLFW_CROSSHAIR_CURSOR: return "crosshair";
        case GLFW_CELL_CURSOR: return "cell";
        case GLFW_VERTICAL_TEXT_CURSOR: return "vertical-text";
        case GLFW_MOVE_CURSOR: return "move";
        case GLFW_E_RESIZE_CURSOR: return "e-resize";
        case GLFW_NE_RESIZE_CURSOR: return "ne-resize";
        case GLFW_NW_RESIZE_CURSOR: return "nw-resize";
        case GLFW_N_RESIZE_CURSOR: return "n-resize";
        case GLFW_SE_RESIZE_CURSOR: return "se-resize";
        case GLFW_SW_RESIZE_CURSOR: return "sw-resize";
        case GLFW_S_RESIZE_CURSOR: return "s-resize";
        case GLFW_W_RESIZE_CURSOR: return "w-resize";
        case GLFW_EW_RESIZE_CURSOR: return "ew-resize";
        case GLFW_NS_RESIZE_CURSOR: return "ns-resize";
        case GLFW_NESW_RESIZE_CURSOR: return "nesw-resize";
        case GLFW_NWSE_RESIZE_CURSOR: return "nwse-resize";
        case GLFW_ZOOM_IN_CURSOR: return "zoom-in";
        case GLFW_ZOOM_OUT_CURSOR: return "zoom-out";
        case GLFW_ALIAS_CURSOR: return "alias";
        case GLFW_COPY_CURSOR: return "copy";
        case GLFW_NOT_ALLOWED_CURSOR: return "not-allowed";
        case GLFW_NO_DROP_CURSOR: return "no-drop";
        case GLFW_GRAB_CURSOR: return "grab";
        case GLFW_GRABBING_CURSOR: return "grabbing";
/* end glfw to css */
    }
    return "";
}

static PyObject*
pointer_name_to_css_name(PyObject *self UNUSED, PyObject *name) {
    if (!PyUnicode_Check(name)) { PyErr_SetString(PyExc_TypeError, "pointer name must be a string"); return NULL; }
    GLFWCursorShape s = pointer_name_to_glfw_name(PyUnicode_AsUTF8(name));
    return PyUnicode_FromString(glfw_name_to_css_pointer_name(s));
}

static PyObject*
set_custom_cursor(PyObject *self UNUSED, PyObject *args) {
    int x=0, y=0;
    Py_ssize_t sz;
    PyObject *images;
    const char *shape;
    if (!PyArg_ParseTuple(args, "sO!|ii", &shape, &PyTuple_Type, &images, &x, &y)) return NULL;
    static GLFWimage gimages[16] = {{0}};
    size_t count = MIN((size_t)PyTuple_GET_SIZE(images), arraysz(gimages));
    for (size_t i = 0; i < count; i++) {
        if (!PyArg_ParseTuple(PyTuple_GET_ITEM(images, i), "s#ii", &gimages[i].pixels, &sz, &gimages[i].width, &gimages[i].height)) return NULL;
        if ((Py_ssize_t)gimages[i].width * gimages[i].height * 4 != sz) {
            PyErr_SetString(PyExc_ValueError, "The image data size does not match its width and height");
            return NULL;
        }
    }
    GLFWCursorShape gshape = pointer_name_to_glfw_name(shape);
    if (gshape == GLFW_INVALID_CURSOR) { PyErr_Format(PyExc_KeyError, "Unknown pointer shape: %s", shape); return NULL; }
    GLFWcursor *c = glfwCreateCursor(gimages, x, y, count);
    if (c == NULL) { PyErr_SetString(PyExc_ValueError, "Failed to create custom cursor from specified images"); return NULL; }
    if (cursors[gshape].initialized && cursors[gshape].is_custom && cursors[gshape].glfw) {
        glfwDestroyCursor(cursors[gshape].glfw);
    }
    cursors[gshape].initialized = true; cursors[gshape].is_custom = true; cursors[gshape].glfw = c;
    Py_RETURN_NONE;
}

#ifdef __APPLE__
void
get_cocoa_key_equivalent(uint32_t key, int mods, char *cocoa_key, size_t key_sz, int *cocoa_mods) {
    memset(cocoa_key, 0, key_sz);
    uint32_t ans = glfwGetCocoaKeyEquivalent(key, mods, cocoa_mods);
    if (ans) encode_utf8(ans, cocoa_key);
}

static void
cocoa_frame_request_callback(GLFWwindow *window) {
    for (size_t i = 0; i < global_state.num_os_windows; i++) {
        if (global_state.os_windows[i].handle == window) {
            global_state.os_windows[i].render_state = RENDER_FRAME_READY;
            global_state.os_windows[i].last_render_frame_received_at = monotonic();
            request_tick_callback();
            break;
        }
    }
}

void
request_frame_render(OSWindow *w) {
    glfwCocoaRequestRenderFrame(w->handle, cocoa_frame_request_callback);
    w->render_state = RENDER_FRAME_REQUESTED;
}

static PyObject*
py_recreate_global_menu(PyObject *self UNUSED, PyObject *args UNUSED) {
    cocoa_recreate_global_menu();
    Py_RETURN_NONE;
}

static PyObject*
py_clear_global_shortcuts(PyObject *self UNUSED, PyObject *args UNUSED) {
    cocoa_clear_global_shortcuts();
    Py_RETURN_NONE;
}
#else

static void
wayland_frame_request_callback(id_type os_window_id) {
    for (size_t i = 0; i < global_state.num_os_windows; i++) {
        if (global_state.os_windows[i].id == os_window_id) {
            global_state.os_windows[i].render_state = RENDER_FRAME_READY;
            global_state.os_windows[i].last_render_frame_received_at = monotonic();
            request_tick_callback();
            break;
        }
    }
}

void
request_frame_render(OSWindow *w) {
    // Some Wayland compositors are too fragile to handle multiple
    // render frame requests, see https://github.com/kovidgoyal/kitty/issues/2329
    if (w->render_state != RENDER_FRAME_REQUESTED) {
        w->render_state = RENDER_FRAME_REQUESTED;
        glfwRequestWaylandFrameEvent(w->handle, w->id, wayland_frame_request_callback);
    }
}

void
dbus_notification_created_callback(unsigned long long notification_id, uint32_t new_notification_id, void* data UNUSED) {
    unsigned long new_id = new_notification_id;
    send_dbus_notification_event_to_python("created", notification_id, new_id);
}

static PyObject*
dbus_send_notification(PyObject *self UNUSED, PyObject *args, PyObject *kw) {
    int timeout = -1, urgency = 1; unsigned int replaces = 0;
    GLFWDBUSNotificationData d = {0};
    static const char* kwlist[] = {"app_name", "app_icon", "title", "body", "actions", "timeout", "urgency", "replaces", "category", "muted", NULL};
    PyObject *actions = NULL;
    if (!PyArg_ParseTupleAndKeywords(args, kw, "ssssO!|iiIsp", (char**)kwlist,
        &d.app_name, &d.icon, &d.summary, &d.body, &PyDict_Type, &actions, &timeout, &urgency, &replaces, &d.category, &d.muted)) return NULL;
    if (!glfwDBusUserNotify) {
        PyErr_SetString(PyExc_RuntimeError, "Failed to load glfwDBusUserNotify, did you call glfw_init?");
        return NULL;
    }
    d.timeout = timeout;
    d.urgency = urgency & 3;
    d.replaces = replaces;
    RAII_ALLOC(const char*, aclist, calloc(2*PyDict_Size(actions), sizeof(d.actions[0])));
    if (!aclist) { return PyErr_NoMemory(); }
    PyObject *key, *value; Py_ssize_t pos = 0;
    d.num_actions = 0;
    while (PyDict_Next(actions, &pos, &key, &value)) {
        if (!PyUnicode_Check(key) || !PyUnicode_Check(value)) { PyErr_SetString(PyExc_TypeError, "actions must be strings"); return NULL; }
        if (PyUnicode_GET_LENGTH(key) == 0 || PyUnicode_GET_LENGTH(value) == 0) { PyErr_SetString(PyExc_TypeError, "actions must be non-empty strings"); return NULL; }
        aclist[d.num_actions] = PyUnicode_AsUTF8(key); if (!aclist[d.num_actions++]) return NULL;
        aclist[d.num_actions] = PyUnicode_AsUTF8(value); if (!aclist[d.num_actions++]) return NULL;
    }
    d.actions = aclist;
    unsigned long long notification_id = glfwDBusUserNotify(&d, dbus_notification_created_callback, NULL);
    return PyLong_FromUnsignedLongLong(notification_id);
}

static PyObject*
dbus_close_notification(PyObject *self UNUSED, PyObject *args) {
    unsigned int id;
    if (!PyArg_ParseTuple(args, "I", &id)) return NULL;
    GLFWDBUSNotificationData d = {.timeout=-9999, .urgency=255};
    if (!glfwDBusUserNotify) {
        PyErr_SetString(PyExc_RuntimeError, "Failed to load glfwDBusUserNotify, did you call glfw_init?");
        return NULL;
    }
    if (glfwDBusUserNotify(&d, NULL, &id)) Py_RETURN_TRUE;
    Py_RETURN_FALSE;
}


#endif

static PyObject*
get_click_interval(PyObject *self UNUSED, PyObject *args UNUSED) {
    return PyFloat_FromDouble(monotonic_t_to_s_double(OPT(click_interval)));
}

static PyObject*
glfw_get_keyboard_repeat_interval(PyObject *self UNUSED, PyObject *args UNUSED) {
#define DEFAULT_KEYBOARD_REPEAT_INTERVAL_MS 30ll
    monotonic_t interval = ms_to_monotonic_t(DEFAULT_KEYBOARD_REPEAT_INTERVAL_MS);
    glfwGetKeyboardRepeatDelay(NULL, &interval);
    return PyFloat_FromDouble(monotonic_t_to_s_double(interval));
#undef DEFAULT_KEYBOARD_REPEAT_INTERVAL_MS
}

id_type
add_main_loop_timer(monotonic_t interval, bool repeats, timer_callback_fun callback, void *callback_data, timer_callback_fun free_callback) {
    return glfwAddTimer(interval, repeats, callback, callback_data, free_callback);
}

void
update_main_loop_timer(id_type timer_id, monotonic_t interval, bool enabled) {
    glfwUpdateTimer(timer_id, interval, enabled);
}

void
remove_main_loop_timer(id_type timer_id) {
    glfwRemoveTimer(timer_id);
}

void
run_main_loop(tick_callback_fun cb, void* cb_data) {
    glfwRunMainLoop(cb, cb_data);
}

void
stop_main_loop(void) {
    glfwStopMainLoop();
}

static PyObject*
strip_csi(PyObject *self UNUSED, PyObject *src) {
    if (!PyUnicode_Check(src)) { PyErr_SetString(PyExc_TypeError, "Unicode string expected"); return NULL; }
    Py_ssize_t sz;
    const char *title = PyUnicode_AsUTF8AndSize(src, &sz);
    if (!title) return NULL;
    RAII_ALLOC(char, buf, malloc(sz + 1));
    if (!buf) { return PyErr_NoMemory(); }
    strip_csi_(title, buf, sz + 1);
    return PyUnicode_FromString(buf);
}

void
set_ignore_os_keyboard_processing(bool enabled) {
    glfwSetIgnoreOSKeyboardProcessing(enabled);
}

static void
decref_pyobj(void *x) {
    Py_XDECREF(x);
}

static GLFWDataChunk
get_clipboard_data(const char *mime_type, void *iter, GLFWClipboardType ct) {
    GLFWDataChunk ans = {.iter=iter, .free=decref_pyobj};
    if (global_state.boss == NULL) return ans;
    if (iter == NULL) {
        PyObject *c = PyObject_GetAttrString(global_state.boss, ct == GLFW_PRIMARY_SELECTION ? "primary_selection" : "clipboard");
        if (c == NULL) { return ans; }
        PyObject *i = PyObject_CallFunction(c, "s", mime_type);
        Py_DECREF(c);
        if (!i) { return ans; }
        ans.iter = i;
        return ans;
    }
    if (mime_type == NULL) {
        Py_XDECREF(iter);
        return ans;
    }

    PyObject *ret = PyObject_CallFunctionObjArgs(iter, NULL);
    if (ret == NULL) return ans;
    ans.data = PyBytes_AS_STRING(ret);
    ans.sz = PyBytes_GET_SIZE(ret);
    ans.free_data = ret;
    return ans;
}

static PyObject*
set_clipboard_data_types(PyObject *self UNUSED, PyObject *args) {
    PyObject *mta;
    int ctype;
    if (!PyArg_ParseTuple(args, "iO!", &ctype, &PyTuple_Type, &mta)) return NULL;
    if (glfwSetClipboardDataTypes) {
        const char **mime_types = calloc(PyTuple_GET_SIZE(mta), sizeof(char*));
        if (!mime_types) return PyErr_NoMemory();
        for (Py_ssize_t i = 0; i < PyTuple_GET_SIZE(mta); i++) mime_types[i] = PyUnicode_AsUTF8(PyTuple_GET_ITEM(mta, i));
        glfwSetClipboardDataTypes(ctype, mime_types, PyTuple_GET_SIZE(mta), get_clipboard_data);
        free(mime_types);
    } else log_error("GLFW not initialized cannot set clipboard data");
    if (PyErr_Occurred()) return NULL;
    Py_RETURN_NONE;
}

static bool
write_clipboard_data(void *callback, const char *data, size_t sz) {
    Py_ssize_t z = sz;
    if (data == NULL) {
        PyErr_SetString(PyExc_RuntimeError, "is_self_offer");
        return false;
    }
    PyObject *ret = PyObject_CallFunction(callback, "y#", data, z);
    bool ok = false;
    if (ret != NULL) { ok = true; Py_DECREF(ret); }
    return ok;
}

static PyObject*
get_clipboard_mime(PyObject *self UNUSED, PyObject *args) {
    int ctype;
    const char *mime;
    PyObject *callback;
    if (!PyArg_ParseTuple(args, "izO", &ctype, &mime, &callback)) return NULL;
    glfwGetClipboard(ctype, mime, write_clipboard_data, callback);
    if (PyErr_Occurred()) return NULL;
    Py_RETURN_NONE;
}

static PyObject*
is_layer_shell_supported(PyObject *self UNUSED, PyObject *args UNUSED) {
    return Py_NewRef(glfwIsLayerShellSupported() ? Py_True : Py_False);
}

static PyObject*
toggle_os_window_visibility(PyObject *self UNUSED, PyObject *args, PyObject *kw) {
    unsigned long long wid;
    int set_visible = -1, move_to_active_screen = 0;
    static const char* kwlist[] = {"os_window_id", "visible", "move_to_active_screen", NULL};
    if (!PyArg_ParseTupleAndKeywords(
        args, kw, "K|pp", (char**)kwlist, &wid, &set_visible, &move_to_active_screen)) return NULL;
    OSWindow *w = os_window_for_id(wid);
    if (!w || !w->handle) Py_RETURN_FALSE;
    bool is_visible = glfwGetWindowAttrib(w->handle, GLFW_VISIBLE) != 0;
    if (set_visible == -1) set_visible = !is_visible;
    else if (set_visible == is_visible) Py_RETURN_FALSE;
    set_os_window_visibility(w, set_visible, move_to_active_screen);
    Py_RETURN_TRUE;
}

static PyObject*
layer_shell_config_for_os_window(PyObject *self UNUSED, PyObject *wid) {
    if (!PyLong_Check(wid)) { PyErr_SetString(PyExc_TypeError, "os_window_id must be a int"); return NULL; }
    id_type id = PyLong_AsUnsignedLongLong(wid);
    OSWindow *w = os_window_for_id(id);
    if (!w || !w->handle) Py_RETURN_NONE;
    const GLFWLayerShellConfig *c = glfwGetLayerShellConfig(w->handle);
    if (!c) Py_RETURN_NONE;
    return layer_shell_config_to_python(c);
}

static PyObject*
set_layer_shell_config(PyObject *self UNUSED, PyObject *args) {
    unsigned long long wid; PyObject *pylsc;
    if (!PyArg_ParseTuple(args, "KO", &wid, &pylsc)) return NULL;
    OSWindow *window = os_window_for_id(wid);
    if (!window || !window->handle || !window->is_layer_shell) Py_RETURN_FALSE;
    GLFWLayerShellConfig lsc = {0};
    if (!layer_shell_config_from_python(pylsc, &lsc)) return NULL;
    return Py_NewRef(set_layer_shell_config_for(window, &lsc) ? Py_True : Py_False);
}

static PyObject*
grab_keyboard(PyObject *self UNUSED, PyObject *action) {
    return Py_NewRef(glfwGrabKeyboard(action == Py_None ? 2 : PyObject_IsTrue(action)) ? Py_True : Py_False);
}

static PyObject*
draw_single_line_of_text(PyObject *self UNUSED, PyObject *args, PyObject *kw) {
    unsigned long long os_window_id;
    const char *text;
    unsigned int fg, bg;
    int width, padding_y = 2, max_width = 0;
    static const char* kwlist[] = {"os_window_id", "text", "fg", "bg", "width", "padding_y", "max_width", NULL};
    if (!PyArg_ParseTupleAndKeywords(args, kw, "KsIIi|ip", (char**)kwlist, &os_window_id, &text, &fg, &bg, &width, &padding_y, &max_width)) return NULL;
    OSWindow *w = os_window_for_id(os_window_id);
    if (!w || !w->fonts_data) {
        PyErr_SetString(PyExc_KeyError, "OS Window with specified id does not exist or has no fonts data");
        return NULL;
    }
    double font_sz_pts = w->fonts_data->font_sz_in_pts;
    double ydpi = w->fonts_data->logical_dpi_y;
    size_t height = (size_t)w->fonts_data->fcm.cell_height + padding_y;
    size_t buf_sz = (size_t)width * height * 4;
    RAII_PyObject(ans, PyBytes_FromStringAndSize(NULL, buf_sz)); if (!ans) return NULL;
    size_t actual_width = width;
    if (!draw_window_title(font_sz_pts, ydpi, text, fg, bg, (uint8_t*)PyBytes_AS_STRING(ans), width, height, max_width ? &actual_width : NULL)) {
        if (!PyErr_Occurred()) PyErr_SetString(PyExc_RuntimeError, "Failed to render text");
        return NULL;
    }
    if (actual_width < (size_t)width) {
        if (_PyBytes_Resize(&ans, actual_width * height * 4) < 0) return NULL;
    }
    return Py_BuildValue("Oi", ans, (int)actual_width);
}

static bool
get_thumbnail(PyObject *thumbnails, GLFWimage *thumbnail, int idx) {
    RAII_PyObject(t, PySequence_GetItem(thumbnails, idx));
    if (!PyTuple_Check(t) || PyTuple_GET_SIZE(t) != 3) { PyErr_SetString(PyExc_TypeError, "thumbnail must be a 3-tuple"); return false; }
    thumbnail->pixels = (uint8_t*)PyBytes_AS_STRING(PyTuple_GET_ITEM(t, 0));
    thumbnail->width = PyLong_AsUnsignedLong(PyTuple_GET_ITEM(t, 1));
    thumbnail->height = PyLong_AsUnsignedLong(PyTuple_GET_ITEM(t, 2));
    return true;
}

bool
change_drag_image(int idx) {
    if (!global_state.drag_source.from_os_window) return false;
    OSWindow *w = os_window_for_id(global_state.drag_source.from_os_window);
    if (!w || !w->handle) { errno = EINVAL; return false; }
    if (global_state.drag_source.thumbnail_idx == idx) return true;
    GLFWimage thumbnail = {0};
    if (idx >=0 && global_state.drag_source.thumbnails && idx < PySequence_Size(global_state.drag_source.thumbnails)) {
        if (!get_thumbnail(global_state.drag_source.thumbnails, &thumbnail, idx)) { errno = ENOMEM; PyErr_Clear(); return NULL; }
        global_state.drag_source.thumbnail_idx = idx;
    } else global_state.drag_source.thumbnail_idx = -1;
    errno = glfwStartDrag(w->handle, NULL, 0, thumbnail.pixels ? &thumbnail : NULL, -2, false);
    return errno == 0;
}

static PyObject*
change_drag_thumbnail(PyObject *self UNUSED, PyObject *args) {
    unsigned long long os_window_id; int idx = -1;
    if (!PyArg_ParseTuple(args, "K|i", &os_window_id, &idx)) return NULL;
    if (global_state.drag_source.thumbnail_idx == idx) Py_RETURN_NONE;
    OSWindow *w = os_window_for_id(os_window_id);
    if (!w || !w->handle) { PyErr_SetString(PyExc_KeyError, "OS Window with specified id does not exist"); return NULL; }
    GLFWimage thumbnail = {0};
    if (idx >=0 && global_state.drag_source.thumbnails && idx < PySequence_Size(global_state.drag_source.thumbnails)) {
        if (!get_thumbnail(global_state.drag_source.thumbnails, &thumbnail, idx)) return NULL;
        global_state.drag_source.thumbnail_idx = idx;
    } else global_state.drag_source.thumbnail_idx = -1;
    global_state.drag_source.from_os_window = w->id;
    global_state.drag_source.from_window = 0;
    errno = glfwStartDrag(w->handle, NULL, 0, thumbnail.pixels ? &thumbnail : NULL, -2, false);
    if (errno != 0) {
        PyErr_SetFromErrno(PyExc_OSError);
        return NULL;
    }
    Py_RETURN_NONE;
}

int
start_window_drag(Window *w, bool in_test_mode) {
    OSWindow *osw = os_window_for_kitty_window(w->id);
    if (!osw || (!in_test_mode && !osw->handle)) return EINVAL;
    if (!in_test_mode && !(
        // Deny the drag start if mouse is not still pressed and over the originating window
        osw->mouse_button_pressed[GLFW_MOUSE_BUTTON_LEFT] && global_state.mouse_hover_in_window == w->id)) return EPERM;
    RAII_ALLOC(GLFWDragSourceItem, items, calloc(w->drag_source.num_mimes, sizeof(GLFWDragSourceItem)));
    if (!items) return ENOMEM;
    for (size_t i = 0; i < w->drag_source.num_mimes; i++) {
        items[i].mime_type = w->drag_source.items[i].mime_type;
        items[i].is_remote_client = w->drag_source.is_remote_client;
        items[i].optional_data = (char*)w->drag_source.items[i].optional_data;
        items[i].data_size = w->drag_source.items[i].data_size;
#ifndef __APPLE__
        if (w->drag_source.is_remote_client && w->drag_source.items[i].is_uri_list) {
            // On platforms other than macOS we treat the request for data for
            // this MIME type as a trigger to start remote download. On macOS
            // requests for individual items from this list will come in.
            items[i].optional_data = NULL;
            items[i].data_size = 0;
        }
#endif
    }
    size_t num_images = 0;
    for (size_t i = 0; i < arraysz(w->drag_source.images); i++) if (w->drag_source.images[i].data) num_images++;
    RAII_PyObject(images, PyTuple_New(num_images));
    if (!images) { PyErr_Clear(); return ENOMEM; }
    for (size_t i = 0, n = 0; i < arraysz(w->drag_source.images); i++) {
        if (w->drag_source.images[i].data) {
            PyObject *t = Py_BuildValue(
                "y#ii", w->drag_source.images[i].data, w->drag_source.images[i].sz, w->drag_source.images[i].width, w->drag_source.images[i].height);
            if (!t) { PyErr_Clear(); return ENOMEM; }
            PyTuple_SET_ITEM(images, n, t); n++;
        }
    }
    GLFWimage thumbnail = {0};
    if (w->drag_source.img_idx < num_images && !get_thumbnail(images, &thumbnail, w->drag_source.img_idx)) return ENOMEM;
    free_drag_source();
    global_state.drag_source.thumbnails = Py_NewRef(images);
    global_state.drag_source.is_active = true;
    global_state.drag_source.needs_toplevel_on_wayland = true;
    global_state.drag_source.from_window = w->id;
    global_state.drag_source.from_os_window = osw->id;
    global_state.drag_source.thumbnail_idx = w->drag_source.img_idx < num_images ? (int)w->drag_source.img_idx : -1;
    global_state.tracked_drag_in_window = 0;  // this is now an OS global drag
    if (in_test_mode) return 0;
    GLFWDragOperationType ops = GLFW_DRAG_OPERATION_NONE;
    if (w->drag_source.allowed_operations & 1) ops |= GLFW_DRAG_OPERATION_COPY;
    if (w->drag_source.allowed_operations & 2) ops |= GLFW_DRAG_OPERATION_MOVE;
    int ret = glfwStartDrag(osw->handle, items, w->drag_source.num_mimes, thumbnail.pixels ? &thumbnail : NULL, ops, true);
    if (ret != 0) free_drag_source();
    return ret;
}


static PyObject*
start_drag_with_data(PyObject *self UNUSED, PyObject *args, PyObject *kw) {
    static const char* kwlist[] = {"os_window_id", "data_map", "thumbnails", "operations", NULL};
    unsigned long long os_window_id; PyObject *data_map;
    int operations = GLFW_DRAG_OPERATION_MOVE;
    PyObject *thumbnails = NULL;
    if (!PyArg_ParseTupleAndKeywords(args, kw, "KO!|Oi", (char**)kwlist,
            &os_window_id, &PyDict_Type, &data_map, &thumbnails, &operations)) return NULL;
    OSWindow *w = os_window_for_id(os_window_id);
    if (!w || !w->handle) { PyErr_SetString(PyExc_KeyError, "OS Window with specified id does not exist"); return NULL; }
    GLFWimage thumbnail = {0};
    if (!PySequence_Check(thumbnails)) { PyErr_SetString(PyExc_TypeError, "thumbnails must be a sequence"); return NULL; }
    if (thumbnails && PySequence_Size(thumbnails) && !get_thumbnail(thumbnails, &thumbnail, 0)) return NULL;
    RAII_ALLOC(GLFWDragSourceItem, items, calloc(PyDict_Size(data_map), sizeof(GLFWDragSourceItem)));
    if (!items) { PyErr_NoMemory(); return NULL; }
    PyObject *key, *value; Py_ssize_t pos = 0; size_t num = 0;
    bool needs_toplevel_on_wayland = false;
    while (PyDict_Next(data_map, &pos, &key, &value)) {
        if (!PyUnicode_Check(key)) { PyErr_SetString(PyExc_TypeError, "data_map must have string keys"); return NULL; }
        if (!PyBytes_Check(value)) { PyErr_SetString(PyExc_TypeError, "data_map must have bytes values"); return NULL; }
        GLFWDragSourceItem *item = items + num++;
        item->mime_type = PyUnicode_AsUTF8(key);
        item->optional_data = PyBytes_AS_STRING(value); item->data_size = PyBytes_GET_SIZE(value);
        if (global_state.is_wayland) {
            int mime_num = is_droppable_mime(item->mime_type);
            if (mime_num == TAB_DRAG_MIME_NUMBER || mime_num == WINDOW_DRAG_MIME_NUMBER)
                needs_toplevel_on_wayland = true;
        }
    }
    free_drag_source();
    global_state.drag_source.is_active = true;
    global_state.drag_source.needs_toplevel_on_wayland = needs_toplevel_on_wayland;
    global_state.drag_source.drag_data = Py_NewRef(data_map);
    if (thumbnails) global_state.drag_source.thumbnails = Py_NewRef(thumbnails);
    global_state.drag_source.thumbnail_idx = thumbnail.pixels ? 0 : -1;
    errno = glfwStartDrag(w->handle, items, num, thumbnail.pixels ? &thumbnail : NULL, operations, needs_toplevel_on_wayland);
    if (errno != 0) {
        PyErr_SetFromErrno(PyExc_OSError);
        free_drag_source();
        return NULL;
    }
    Py_RETURN_NONE;
}

// Boilerplate {{{

static PyMethodDef module_methods[] = {
    METHODB(set_custom_cursor, METH_VARARGS),
    METHODB(is_css_pointer_name_valid, METH_O),
    {"toggle_os_window_visibility", (PyCFunction)(void (*) (void))(toggle_os_window_visibility), METH_VARARGS | METH_KEYWORDS, NULL},
    METHODB(layer_shell_config_for_os_window, METH_O),
    METHODB(set_layer_shell_config, METH_VARARGS),
    METHODB(grab_keyboard, METH_O),
    METHODB(pointer_name_to_css_name, METH_O),
    {"create_os_window", (PyCFunction)(void (*) (void))(create_os_window), METH_VARARGS | METH_KEYWORDS, NULL},
    {"start_drag_with_data", (PyCFunction)(void (*) (void))(start_drag_with_data), METH_VARARGS | METH_KEYWORDS, NULL},
    METHODB(change_drag_thumbnail, METH_VARARGS),
    {"draw_single_line_of_text", (PyCFunction)(void (*) (void))(draw_single_line_of_text), METH_VARARGS | METH_KEYWORDS, NULL},
    METHODB(set_default_window_icon, METH_VARARGS),
    METHODB(set_os_window_icon, METH_VARARGS),
    METHODB(set_clipboard_data_types, METH_VARARGS),
    METHODB(get_clipboard_mime, METH_VARARGS),
    METHODB(toggle_secure_input, METH_NOARGS),
    METHODB(macos_cycle_through_os_windows, METH_O),
    METHODB(get_content_scale_for_window, METH_NOARGS),
    METHODB(ring_bell, METH_VARARGS),
    METHODB(request_attention, METH_VARARGS),
    METHODB(toggle_fullscreen, METH_VARARGS),
    METHODB(toggle_maximized, METH_VARARGS),
    METHODB(change_os_window_state, METH_VARARGS),
    METHODB(glfw_window_hint, METH_VARARGS),
    METHODB(x11_display, METH_NOARGS),
    METHODB(wayland_compositor_data, METH_NOARGS),
    METHODB(get_click_interval, METH_NOARGS),
    METHODB(glfw_get_keyboard_repeat_interval, METH_NOARGS),
    METHODB(is_layer_shell_supported, METH_NOARGS),
    METHODB(x11_window_id, METH_O),
    METHODB(strip_csi, METH_O),
#ifndef __APPLE__
    METHODB(dbus_close_notification, METH_VARARGS),
    METHODB(dbus_set_notification_callback, METH_O),
    {"dbus_send_notification", (PyCFunction)(void (*) (void))(dbus_send_notification), METH_KEYWORDS | METH_VARARGS, NULL},
#else
    {"cocoa_recreate_global_menu", (PyCFunction)py_recreate_global_menu, METH_NOARGS, ""},
    {"cocoa_clear_global_shortcuts", (PyCFunction)py_clear_global_shortcuts, METH_NOARGS, ""},
#endif
    METHODB(cocoa_window_id, METH_O),
    METHODB(cocoa_hide_app, METH_NOARGS),
    METHODB(cocoa_hide_other_apps, METH_NOARGS),
    METHODB(cocoa_minimize_os_window, METH_VARARGS),
    {"glfw_init", (PyCFunction)glfw_init, METH_VARARGS, ""},
    {"glfw_terminate", (PyCFunction)glfw_terminate, METH_NOARGS, ""},
    {"glfw_get_physical_dpi", (PyCFunction)glfw_get_physical_dpi, METH_NOARGS, ""},
    {"glfw_get_key_name", (PyCFunction)glfw_get_key_name, METH_VARARGS, ""},
    {"glfw_get_system_color_theme", (PyCFunction)glfw_get_system_color_theme, METH_VARARGS, ""},
    {"glfw_primary_monitor_size", (PyCFunction)primary_monitor_size, METH_NOARGS, ""},
    {"glfw_get_monitor_workarea", (PyCFunction)get_monitor_workarea, METH_NOARGS, ""},
    {"glfw_get_monitor_names", (PyCFunction)get_monitor_names, METH_NOARGS, ""},
    {"glfw_primary_monitor_content_scale", (PyCFunction)primary_monitor_content_scale, METH_NOARGS, ""},
    {NULL, NULL, 0, NULL}        /* Sentinel */
};

void cleanup_glfw(void) {
    if (logo.pixels) free((void*)logo.pixels);
    logo.pixels = NULL;
    Py_CLEAR(edge_spacing_func);
#ifndef __APPLE__
    Py_CLEAR(dbus_notification_callback);
    release_freetype_render_context(bold_render_ctx);
    release_freetype_render_context(normal_render_ctx);
#endif
}

bool
init_glfw(PyObject *m) {
    if (PyModule_AddFunctions(m, module_methods) != 0) return false;
    register_at_exit_cleanup_func(GLFW_CLEANUP_FUNC, cleanup_glfw);

// constants {{{
#define ADDC(n) if(PyModule_AddIntConstant(m, #n, n) != 0) return false;
    ADDC(GLFW_DRAG_OPERATION_MOVE);
    ADDC(GLFW_DRAG_OPERATION_COPY);
    ADDC(GLFW_DRAG_OPERATION_GENERIC);
    ADDC(GLFW_RELEASE);
    ADDC(GLFW_PRESS);
    ADDC(GLFW_REPEAT);
    ADDC(true); ADDC(false);
    ADDC(GLFW_PRIMARY_SELECTION); ADDC(GLFW_CLIPBOARD);
    ADDC(GLFW_LAYER_SHELL_NONE); ADDC(GLFW_LAYER_SHELL_PANEL); ADDC(GLFW_LAYER_SHELL_BACKGROUND); ADDC(GLFW_LAYER_SHELL_TOP); ADDC(GLFW_LAYER_SHELL_OVERLAY);
    ADDC(GLFW_FOCUS_NOT_ALLOWED); ADDC(GLFW_FOCUS_EXCLUSIVE); ADDC(GLFW_FOCUS_ON_DEMAND);
    ADDC(GLFW_EDGE_TOP); ADDC(GLFW_EDGE_BOTTOM); ADDC(GLFW_EDGE_LEFT); ADDC(GLFW_EDGE_RIGHT); ADDC(GLFW_EDGE_CENTER); ADDC(GLFW_EDGE_NONE);
    ADDC(GLFW_EDGE_CENTER_SIZED);
    ADDC(GLFW_COLOR_SCHEME_NO_PREFERENCE); ADDC(GLFW_COLOR_SCHEME_DARK); ADDC(GLFW_COLOR_SCHEME_LIGHT);

    /* start glfw functional keys (auto generated by gen-key-constants.py do not edit) */
    ADDC(GLFW_FKEY_ESCAPE);
    ADDC(GLFW_FKEY_ENTER);
    ADDC(GLFW_FKEY_TAB);
    ADDC(GLFW_FKEY_BACKSPACE);
    ADDC(GLFW_FKEY_INSERT);
    ADDC(GLFW_FKEY_DELETE);
    ADDC(GLFW_FKEY_LEFT);
    ADDC(GLFW_FKEY_RIGHT);
    ADDC(GLFW_FKEY_UP);
    ADDC(GLFW_FKEY_DOWN);
    ADDC(GLFW_FKEY_PAGE_UP);
    ADDC(GLFW_FKEY_PAGE_DOWN);
    ADDC(GLFW_FKEY_HOME);
    ADDC(GLFW_FKEY_END);
    ADDC(GLFW_FKEY_CAPS_LOCK);
    ADDC(GLFW_FKEY_SCROLL_LOCK);
    ADDC(GLFW_FKEY_NUM_LOCK);
    ADDC(GLFW_FKEY_PRINT_SCREEN);
    ADDC(GLFW_FKEY_PAUSE);
    ADDC(GLFW_FKEY_MENU);
    ADDC(GLFW_FKEY_F1);
    ADDC(GLFW_FKEY_F2);
    ADDC(GLFW_FKEY_F3);
    ADDC(GLFW_FKEY_F4);
    ADDC(GLFW_FKEY_F5);
    ADDC(GLFW_FKEY_F6);
    ADDC(GLFW_FKEY_F7);
    ADDC(GLFW_FKEY_F8);
    ADDC(GLFW_FKEY_F9);
    ADDC(GLFW_FKEY_F10);
    ADDC(GLFW_FKEY_F11);
    ADDC(GLFW_FKEY_F12);
    ADDC(GLFW_FKEY_F13);
    ADDC(GLFW_FKEY_F14);
    ADDC(GLFW_FKEY_F15);
    ADDC(GLFW_FKEY_F16);
    ADDC(GLFW_FKEY_F17);
    ADDC(GLFW_FKEY_F18);
    ADDC(GLFW_FKEY_F19);
    ADDC(GLFW_FKEY_F20);
    ADDC(GLFW_FKEY_F21);
    ADDC(GLFW_FKEY_F22);
    ADDC(GLFW_FKEY_F23);
    ADDC(GLFW_FKEY_F24);
    ADDC(GLFW_FKEY_F25);
    ADDC(GLFW_FKEY_F26);
    ADDC(GLFW_FKEY_F27);
    ADDC(GLFW_FKEY_F28);
    ADDC(GLFW_FKEY_F29);
    ADDC(GLFW_FKEY_F30);
    ADDC(GLFW_FKEY_F31);
    ADDC(GLFW_FKEY_F32);
    ADDC(GLFW_FKEY_F33);
    ADDC(GLFW_FKEY_F34);
    ADDC(GLFW_FKEY_F35);
    ADDC(GLFW_FKEY_KP_0);
    ADDC(GLFW_FKEY_KP_1);
    ADDC(GLFW_FKEY_KP_2);
    ADDC(GLFW_FKEY_KP_3);
    ADDC(GLFW_FKEY_KP_4);
    ADDC(GLFW_FKEY_KP_5);
    ADDC(GLFW_FKEY_KP_6);
    ADDC(GLFW_FKEY_KP_7);
    ADDC(GLFW_FKEY_KP_8);
    ADDC(GLFW_FKEY_KP_9);
    ADDC(GLFW_FKEY_KP_DECIMAL);
    ADDC(GLFW_FKEY_KP_DIVIDE);
    ADDC(GLFW_FKEY_KP_MULTIPLY);
    ADDC(GLFW_FKEY_KP_SUBTRACT);
    ADDC(GLFW_FKEY_KP_ADD);
    ADDC(GLFW_FKEY_KP_ENTER);
    ADDC(GLFW_FKEY_KP_EQUAL);
    ADDC(GLFW_FKEY_KP_SEPARATOR);
    ADDC(GLFW_FKEY_KP_LEFT);
    ADDC(GLFW_FKEY_KP_RIGHT);
    ADDC(GLFW_FKEY_KP_UP);
    ADDC(GLFW_FKEY_KP_DOWN);
    ADDC(GLFW_FKEY_KP_PAGE_UP);
    ADDC(GLFW_FKEY_KP_PAGE_DOWN);
    ADDC(GLFW_FKEY_KP_HOME);
    ADDC(GLFW_FKEY_KP_END);
    ADDC(GLFW_FKEY_KP_INSERT);
    ADDC(GLFW_FKEY_KP_DELETE);
    ADDC(GLFW_FKEY_KP_BEGIN);
    ADDC(GLFW_FKEY_MEDIA_PLAY);
    ADDC(GLFW_FKEY_MEDIA_PAUSE);
    ADDC(GLFW_FKEY_MEDIA_PLAY_PAUSE);
    ADDC(GLFW_FKEY_MEDIA_REVERSE);
    ADDC(GLFW_FKEY_MEDIA_STOP);
    ADDC(GLFW_FKEY_MEDIA_FAST_FORWARD);
    ADDC(GLFW_FKEY_MEDIA_REWIND);
    ADDC(GLFW_FKEY_MEDIA_TRACK_NEXT);
    ADDC(GLFW_FKEY_MEDIA_TRACK_PREVIOUS);
    ADDC(GLFW_FKEY_MEDIA_RECORD);
    ADDC(GLFW_FKEY_LOWER_VOLUME);
    ADDC(GLFW_FKEY_RAISE_VOLUME);
    ADDC(GLFW_FKEY_MUTE_VOLUME);
    ADDC(GLFW_FKEY_LEFT_SHIFT);
    ADDC(GLFW_FKEY_LEFT_CONTROL);
    ADDC(GLFW_FKEY_LEFT_ALT);
    ADDC(GLFW_FKEY_LEFT_SUPER);
    ADDC(GLFW_FKEY_LEFT_HYPER);
    ADDC(GLFW_FKEY_LEFT_META);
    ADDC(GLFW_FKEY_RIGHT_SHIFT);
    ADDC(GLFW_FKEY_RIGHT_CONTROL);
    ADDC(GLFW_FKEY_RIGHT_ALT);
    ADDC(GLFW_FKEY_RIGHT_SUPER);
    ADDC(GLFW_FKEY_RIGHT_HYPER);
    ADDC(GLFW_FKEY_RIGHT_META);
    ADDC(GLFW_FKEY_ISO_LEVEL3_SHIFT);
    ADDC(GLFW_FKEY_ISO_LEVEL5_SHIFT);
/* end glfw functional keys */
// --- Modifiers ---------------------------------------------------------------
    ADDC(GLFW_MOD_SHIFT);
    ADDC(GLFW_MOD_CONTROL);
    ADDC(GLFW_MOD_ALT);
    ADDC(GLFW_MOD_SUPER);
    ADDC(GLFW_MOD_HYPER);
    ADDC(GLFW_MOD_META);
    ADDC(GLFW_MOD_KITTY);
    ADDC(GLFW_MOD_CAPS_LOCK);
    ADDC(GLFW_MOD_NUM_LOCK);

// --- Mouse -------------------------------------------------------------------
    ADDC(GLFW_MOUSE_BUTTON_1);
    ADDC(GLFW_MOUSE_BUTTON_2);
    ADDC(GLFW_MOUSE_BUTTON_3);
    ADDC(GLFW_MOUSE_BUTTON_4);
    ADDC(GLFW_MOUSE_BUTTON_5);
    ADDC(GLFW_MOUSE_BUTTON_6);
    ADDC(GLFW_MOUSE_BUTTON_7);
    ADDC(GLFW_MOUSE_BUTTON_8);
    ADDC(GLFW_MOUSE_BUTTON_LAST);
    ADDC(GLFW_MOUSE_BUTTON_LEFT);
    ADDC(GLFW_MOUSE_BUTTON_RIGHT);
    ADDC(GLFW_MOUSE_BUTTON_MIDDLE);


// --- Joystick ----------------------------------------------------------------
    ADDC(GLFW_JOYSTICK_1);
    ADDC(GLFW_JOYSTICK_2);
    ADDC(GLFW_JOYSTICK_3);
    ADDC(GLFW_JOYSTICK_4);
    ADDC(GLFW_JOYSTICK_5);
    ADDC(GLFW_JOYSTICK_6);
    ADDC(GLFW_JOYSTICK_7);
    ADDC(GLFW_JOYSTICK_8);
    ADDC(GLFW_JOYSTICK_9);
    ADDC(GLFW_JOYSTICK_10);
    ADDC(GLFW_JOYSTICK_11);
    ADDC(GLFW_JOYSTICK_12);
    ADDC(GLFW_JOYSTICK_13);
    ADDC(GLFW_JOYSTICK_14);
    ADDC(GLFW_JOYSTICK_15);
    ADDC(GLFW_JOYSTICK_16);
    ADDC(GLFW_JOYSTICK_LAST);


// --- Error codes -------------------------------------------------------------
    ADDC(GLFW_NOT_INITIALIZED);
    ADDC(GLFW_NO_CURRENT_CONTEXT);
    ADDC(GLFW_INVALID_ENUM);
    ADDC(GLFW_INVALID_VALUE);
    ADDC(GLFW_OUT_OF_MEMORY);
    ADDC(GLFW_API_UNAVAILABLE);
    ADDC(GLFW_VERSION_UNAVAILABLE);
    ADDC(GLFW_PLATFORM_ERROR);
    ADDC(GLFW_FORMAT_UNAVAILABLE);

// ---
    ADDC(GLFW_FOCUSED);
    ADDC(GLFW_ICONIFIED);
    ADDC(GLFW_RESIZABLE);
    ADDC(GLFW_VISIBLE);
    ADDC(GLFW_DECORATED);
    ADDC(GLFW_AUTO_ICONIFY);
    ADDC(GLFW_FLOATING);

// ---
    ADDC(GLFW_RED_BITS);
    ADDC(GLFW_GREEN_BITS);
    ADDC(GLFW_BLUE_BITS);
    ADDC(GLFW_ALPHA_BITS);
    ADDC(GLFW_DEPTH_BITS);
    ADDC(GLFW_STENCIL_BITS);
    ADDC(GLFW_ACCUM_RED_BITS);
    ADDC(GLFW_ACCUM_GREEN_BITS);
    ADDC(GLFW_ACCUM_BLUE_BITS);
    ADDC(GLFW_ACCUM_ALPHA_BITS);
    ADDC(GLFW_AUX_BUFFERS);
    ADDC(GLFW_STEREO);
    ADDC(GLFW_SAMPLES);
    ADDC(GLFW_SRGB_CAPABLE);
    ADDC(GLFW_REFRESH_RATE);
    ADDC(GLFW_DOUBLEBUFFER);

// ---
    ADDC(GLFW_CLIENT_API);
    ADDC(GLFW_CONTEXT_VERSION_MAJOR);
    ADDC(GLFW_CONTEXT_VERSION_MINOR);
    ADDC(GLFW_CONTEXT_REVISION);
    ADDC(GLFW_CONTEXT_ROBUSTNESS);
    ADDC(GLFW_OPENGL_FORWARD_COMPAT);
    ADDC(GLFW_CONTEXT_DEBUG);
    ADDC(GLFW_OPENGL_PROFILE);

// ---
    ADDC(GLFW_OPENGL_API);
    ADDC(GLFW_OPENGL_ES_API);

// ---
    ADDC(GLFW_NO_ROBUSTNESS);
    ADDC(GLFW_NO_RESET_NOTIFICATION);
    ADDC(GLFW_LOSE_CONTEXT_ON_RESET);

// ---
    ADDC(GLFW_OPENGL_ANY_PROFILE);
    ADDC(GLFW_OPENGL_CORE_PROFILE);
    ADDC(GLFW_OPENGL_COMPAT_PROFILE);

// ---
    ADDC(GLFW_CURSOR);
    ADDC(GLFW_STICKY_KEYS);
    ADDC(GLFW_STICKY_MOUSE_BUTTONS);

// ---
    ADDC(GLFW_CURSOR_NORMAL);
    ADDC(GLFW_CURSOR_HIDDEN);
    ADDC(GLFW_CURSOR_DISABLED);

// ---
    ADDC(GLFW_CONNECTED);
    ADDC(GLFW_DISCONNECTED);
#undef ADDC
// }}}

    return true;
}
