linux_internal.h File Reference

#include "sbgl_types.h"
#include "core/sbgl_input.h"
#include <stdint.h>
#include <stdbool.h>
#include <X11/Xlib.h>

Include dependency graph for linux_internal.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	sbgl_Window
	Native X11 window state. More...

Functions
void	x11_internal_process_event (XEvent *event, struct sbgl_Window *window)
void	linux_internal_update_input_states (struct sbgl_Window *window)

Function Documentation

linux_internal_update_input_states()

void linux_internal_update_input_states

(

struct sbgl_Window *

window

)

Definition at line 127 of file input_wayland.c.

                                                             {
    sbgl_InputState* input = window->input;
    if (!input) return;
 
    if (!window->relative_pointer) {
        input->mouseDeltaX = input->mouseX - input->_internalMouseX;
        input->mouseDeltaY = input->mouseY - input->_internalMouseY;
    }
    // Note: If relative_pointer is active, mouseDeltaX/Y were accumulated in relative_motion.
    // We do NOT reset them here, as they should be reset at the start of PollEvents 
    // or we should handle the accumulation window carefully.
    // For now, assume PollEvents or the next frame will clear them if needed, 
    // but actually sbgl_InputState usually expects deltas to be "since last frame".
 
    input->_internalMouseX = input->mouseX;
    input->_internalMouseY = input->mouseY;
}

x11_internal_process_event()

void x11_internal_process_event	(	XEvent *	event,
		struct 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;
        }
    }
}