window_x11.c File Reference

#include "linux_internal.h"
#include "core/sbgl_platform.h"
#include "core/sbl_arena.h"
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/keysym.h>
#include <X11/extensions/Xfixes.h>
#include <time.h>
#include <string.h>

Include dependency graph for window_x11.c:

Go to the source code of this file.

Functions
void	x11_internal_process_event (XEvent *event, sbgl_Window *window)
sbgl_Window *	sbgl_os_CreateWindow (struct SblArena *arena, sbgl_InputState *input, int width, int height, const char *title)
void	sbgl_os_DestroyWindow (sbgl_Window *window)
	Destroys a native window.
bool	sbgl_os_WindowShouldClose (sbgl_Window *window)
	Checks the window's close flag.
void	sbgl_os_GetWindowSize (sbgl_Window *window, int *w, int *h)
	Retrieves the current client area size.
bool	sbgl_os_WasWindowResized (sbgl_Window *window)
	Checks if the window has been resized since the last check.
bool	sbgl_os_IsWindowFocused (sbgl_Window *window)
	Checks if the window currently has input focus.
void	sbgl_os_SetCursorVisible (sbgl_Window *window, bool visible)
	Sets the visibility of the OS cursor for the given window.
void	sbgl_os_SetCursorLocked (sbgl_Window *window, bool locked)
	Locks or unlocks the cursor within the window bounds.
void	sbgl_os_PollEvents (sbgl_Window *window)
	Dispatches OS events (messages/protocol requests).
uint64_t	sbgl_os_GetPerfCount (sbgl_Window *window)
	Gets the high-resolution performance counter.
uint64_t	sbgl_os_GetPerfFreq (sbgl_Window *window)
	Gets the performance counter frequency.
void *	sbgl_os_GetNativeWindowHandle (sbgl_Window *window)
	Retrieves the raw window handle for Vulkan surface creation.
void *	sbgl_os_GetNativeInstanceHandle (sbgl_Window *window)
	Retrieves the native instance handle (Win32 specific).
void *	sbgl_os_GetNativeDisplayHandle (sbgl_Window *window)
	Retrieves the native display handle (Linux specific).

Function Documentation

sbgl_os_CreateWindow()

sbgl_Window * sbgl_os_CreateWindow	(	struct SblArena *	arena,
		sbgl_InputState *	input,
		int	width,
		int	height,
		const char *	title )

Definition at line 14 of file window_x11.c.

                                                                                                                            {
    Display* display = XOpenDisplay(NULL);
    if (!display) return NULL;
 
    int screen = DefaultScreen(display);
    
    Window win = XCreateSimpleWindow(
        display, RootWindow(display, screen),
        0, 0, (unsigned int)width, (unsigned int)height, 0,
        BlackPixel(display, screen),
        WhitePixel(display, screen)
    );
 
    XStoreName(display, win, title);
    XSelectInput(display, win, ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | StructureNotifyMask | PointerMotionMask | FocusChangeMask);
 
    Atom wmDeleteMessage = XInternAtom(display, "WM_DELETE_WINDOW", False);
    XSetWMProtocols(display, win, &wmDeleteMessage, 1);
 
    XMapWindow(display, win);
    XFlush(display);
 
    sbgl_Window* window = SBL_ARENA_PUSH_STRUCT_ZERO(arena, sbgl_Window);
    if (!window) {
        XCloseDisplay(display);
        return NULL;
    }
    window->display = display;
    window->window = win;
    window->wmDeleteMessage = wmDeleteMessage;
    window->input = input;
    window->shouldClose = false;
    window->resized = false;
    window->width = width;
    window->height = height;
 
    return window;
}

sbgl_os_DestroyWindow()

void sbgl_os_DestroyWindow

(

sbgl_Window *

window

)

Destroys a native window.

Parameters

window

The window to destroy.

Definition at line 53 of file window_x11.c.

                                                {
    if (!window) return;
    XDestroyWindow(window->display, window->window);
    XCloseDisplay(window->display);
}

sbgl_os_GetNativeDisplayHandle()

void * sbgl_os_GetNativeDisplayHandle

(

sbgl_Window *

window

)

Retrieves the native display handle (Linux specific).

Parameters

window

The window handle.

Returns

Display* or wl_display*.

Definition at line 157 of file window_x11.c.

                                                          {
    return window ? (void*)window->display : NULL;
}

sbgl_os_GetNativeInstanceHandle()

void * sbgl_os_GetNativeInstanceHandle

(

sbgl_Window *

window

)

Retrieves the native instance handle (Win32 specific).

Parameters

window

The window handle.

Returns

HINSTANCE on Windows, NULL otherwise.

Definition at line 152 of file window_x11.c.

                                                           {
    (void)window;
    return NULL;
}

sbgl_os_GetNativeWindowHandle()

void * sbgl_os_GetNativeWindowHandle

(

sbgl_Window *

window

)

Retrieves the raw window handle for Vulkan surface creation.

Parameters

window

The window handle.

Returns

Native handle (e.g., HWND or wl_surface*).

Definition at line 148 of file window_x11.c.

                                                         {
    return window ? (void*)(uintptr_t)window->window : NULL;
}

sbgl_os_GetPerfCount()

uint64_t sbgl_os_GetPerfCount

(

sbgl_Window *

window

)

Gets the high-resolution performance counter.

Parameters

window

The window handle.

Returns

Absolute ticks.

Definition at line 136 of file window_x11.c.

                                                   {
    (void)window;
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    return (uint64_t)ts.tv_sec * 1000000000ULL + (uint64_t)ts.tv_nsec;
}

sbgl_os_GetPerfFreq()

uint64_t sbgl_os_GetPerfFreq

(

sbgl_Window *

window

)

Gets the performance counter frequency.

Parameters

window

The window handle.

Returns

Ticks per second.

Definition at line 143 of file window_x11.c.

                                                  {
    (void)window;
    return 1000000000ULL;
}

sbgl_os_GetWindowSize()

void sbgl_os_GetWindowSize	(	sbgl_Window *	window,
		int *	w,
		int *	h )

Retrieves the current client area size.

Parameters

window	The window handle.
w	Pointer to store width.
h	Pointer to store height.

Definition at line 63 of file window_x11.c.

                                                                {
    if (window) {
        *w = window->width;
        *h = window->height;
    }
}

sbgl_os_IsWindowFocused()

bool sbgl_os_IsWindowFocused

(

sbgl_Window *

window

)

Checks if the window currently has input focus.

Parameters

window

The native window handle.

Returns

True if focused.

Definition at line 76 of file window_x11.c.

                                                  {
    return window ? window->focused : false;
}

sbgl_os_PollEvents()

void sbgl_os_PollEvents

(

sbgl_Window *

window

)

Dispatches OS events (messages/protocol requests).

Parameters

window

The window to process events for.

Definition at line 107 of file window_x11.c.

                                             {
    if (!window || !window->display) return;
 
    linux_internal_update_input_states(window);
 
    while (XPending(window->display)) {
        XEvent event;
        XNextEvent(window->display, &event);
 
        if (event.type == ClientMessage) {
            if ((Atom)event.xclient.data.l[0] == window->wmDeleteMessage) {
                window->shouldClose = true;
            }
        } else if (event.type == ConfigureNotify) {
            int w = event.xconfigure.width;
            int h = event.xconfigure.height;
            if (w > 0 && h > 0 && (w != window->width || h != window->height)) {
                window->width = w;
                window->height = h;
                window->resized = true;
            }
        }
 
        // Pass event to input system
        x11_internal_process_event(&event, window);
    }
}

sbgl_os_SetCursorLocked()

void sbgl_os_SetCursorLocked	(	sbgl_Window *	window,
		bool	locked )

Locks or unlocks the cursor within the window bounds.

When locked, the cursor is typically constrained to the window center to support relative motion for 3D navigation.

Parameters

window	The native window handle.
locked	True to capture the cursor, false to release it.

Definition at line 92 of file window_x11.c.

                                                               {
    if (!window || !window->display) return;
 
    // Constrains or releases the pointer relative to the window.
    if (locked) {
        XGrabPointer(window->display, window->window, False,
                     ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
                     GrabModeAsync, GrabModeAsync,
                     window->window, None, CurrentTime);
    } else {
        XUngrabPointer(window->display, CurrentTime);
    }
    XFlush(window->display);
}

sbgl_os_SetCursorVisible()

void sbgl_os_SetCursorVisible	(	sbgl_Window *	window,
		bool	visible )

Sets the visibility of the OS cursor for the given window.

Provides a platform-agnostic way to show or hide the mouse pointer.

Parameters

window	The native window handle.
visible	True to show the cursor, false to hide it.

Definition at line 80 of file window_x11.c.

                                                                 {
    if (!window || !window->display) return;
    
    // Adjusts cursor visibility using XFixes extension.
    if (visible) {
        XFixesShowCursor(window->display, window->window);
    } else {
        XFixesHideCursor(window->display, window->window);
    }
    XFlush(window->display);
}

sbgl_os_WasWindowResized()

bool sbgl_os_WasWindowResized

(

sbgl_Window *

window

)

Checks if the window has been resized since the last check.

Resets the internal resize flag to false upon returning.

Parameters

window

The window handle.

Returns

True if a resize event occurred.

Definition at line 70 of file window_x11.c.

                                                   {
    bool r = window->resized;
    window->resized = false;
    return r;
}

sbgl_os_WindowShouldClose()

bool sbgl_os_WindowShouldClose

(

sbgl_Window *

window

)

Checks the window's close flag.

Parameters

window

The window to check.

Returns

True if closing.

Definition at line 59 of file window_x11.c.

                                                    {
    return window ? window->shouldClose : true;
}

x11_internal_process_event()

void x11_internal_process_event	(	XEvent *	event,
		sbgl_Window *	window )

Definition at line 32 of file input_x11.c.

                                                                    {
    sbgl_InputState* input = window->input;
    switch (event->type) {
        case KeyPress: {
            KeySym keysym = XLookupKeysym(&event->xkey, 0);
            SBGL_Scancode code = x11_keysym_to_scancode(keysym);
            if (code < SBGL_SCANCODE_MAX) {
                if (!input->keysDown[code]) input->keysPressed[code] = true;
                input->keysDown[code] = true;
            }
            break;
        }
        case KeyRelease: {
            // X11 Auto-repeat handling
            if (XEventsQueued(window->display, QueuedAfterReading)) {
                XEvent next;
                XPeekEvent(window->display, &next);
                if (next.type == KeyPress && next.xkey.time == event->xkey.time && next.xkey.keycode == event->xkey.keycode) {
                    XNextEvent(window->display, event); // Consume repeat
                    break;
                }
            }
            KeySym keysym = XLookupKeysym(&event->xkey, 0);
            SBGL_Scancode code = x11_keysym_to_scancode(keysym);
            if (code < SBGL_SCANCODE_MAX) input->keysDown[code] = false;
            break;
        }
        case MotionNotify: {
            input->mouseX = event->xmotion.x;
            input->mouseY = event->xmotion.y;
            break;
        }
        case ButtonPress:
        case ButtonRelease: {
            bool down = (event->type == ButtonPress);
            int btn = -1;
            if (event->xbutton.button == Button1) btn = SBGL_MOUSE_BUTTON_LEFT;
            else if (event->xbutton.button == Button3) btn = SBGL_MOUSE_BUTTON_RIGHT;
            else if (event->xbutton.button == Button2) btn = SBGL_MOUSE_BUTTON_MIDDLE;
            if (btn != -1 && btn < SBGL_MOUSE_BUTTON_MAX) input->mouseDown[btn] = down;
            break;
        }
        case FocusIn: {
            window->focused = true;
            break;
        }
        case FocusOut: {
            window->focused = false;
            break;
        }
    }
}