mirror of
https://github.com/Ed94/raddebugger.git
synced 2026-11-17 11:40:13 -08:00
999 lines
31 KiB
C
999 lines
31 KiB
C
// Copyright (c) Epic Games Tools
|
|
// Licensed under the MIT license (https://opensource.org/license/mit/)
|
|
|
|
////////////////////////////////
|
|
//~ rjf: Helpers
|
|
|
|
internal LNX_WM_Window *
|
|
lnx_window_from_x11window(Window window)
|
|
{
|
|
LNX_WM_Window *result = 0;
|
|
for(LNX_WM_Window *w = lnx_wm_state->first_window; w != 0; w = w->next)
|
|
{
|
|
if(w->window == window)
|
|
{
|
|
result = w;
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
internal int
|
|
lnx_moveresize_code_from_pos(LNX_WM_Window *window, Vec2F32 pos, B32 *out_is_in_client_area)
|
|
{
|
|
B32 in_non_client_area = 0;
|
|
int moveresize_code = 0;
|
|
if(window->custom_border)
|
|
{
|
|
WM_Window handle = {(U64)window};
|
|
Rng2F32 window_rect = wm_client_rect_from_window(handle);
|
|
Rng2F32 inside_edges = pad_2f32(window_rect, -window->custom_edge_thickness);
|
|
Rng2F32 inside_edges_and_title_bar = inside_edges;
|
|
inside_edges_and_title_bar.y0 += window->custom_title_bar_thickness;
|
|
if(!contains_2f32(inside_edges_and_title_bar, pos))
|
|
{
|
|
in_non_client_area = 1;
|
|
for EachNode(n, LNX_WM_WindowClientArea, window->first_client_area)
|
|
{
|
|
if(contains_2f32(n->rect, pos))
|
|
{
|
|
in_non_client_area = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if(in_non_client_area)
|
|
{
|
|
Rng2F32 title_bar_rect = r2f32p(window_rect.x0 + window->custom_edge_thickness,
|
|
window_rect.y0 + window->custom_edge_thickness,
|
|
window_rect.x1 - window->custom_edge_thickness,
|
|
window_rect.y0 + window->custom_title_bar_thickness);
|
|
if(contains_2f32(title_bar_rect, pos))
|
|
{
|
|
moveresize_code = _NET_WM_MOVERESIZE_MOVE;
|
|
}
|
|
else if(contains_2f32(window_rect, pos) && !contains_2f32(inside_edges, pos))
|
|
{
|
|
if(pos.x <= inside_edges.x0 && pos.y <= inside_edges.y0)
|
|
{
|
|
moveresize_code = _NET_WM_MOVERESIZE_SIZE_TOPLEFT;
|
|
}
|
|
else if(pos.x <= inside_edges.x0 && pos.y >= inside_edges.y1)
|
|
{
|
|
moveresize_code = _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT;
|
|
}
|
|
else if(pos.x >= inside_edges.x1 && pos.y <= inside_edges.y0)
|
|
{
|
|
moveresize_code = _NET_WM_MOVERESIZE_SIZE_TOPRIGHT;
|
|
}
|
|
else if(pos.x >= inside_edges.x1 && pos.y >= inside_edges.y1)
|
|
{
|
|
moveresize_code = _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT;
|
|
}
|
|
else if(pos.x <= inside_edges.x0)
|
|
{
|
|
moveresize_code = _NET_WM_MOVERESIZE_SIZE_LEFT;
|
|
}
|
|
else if(pos.x >= inside_edges.x1)
|
|
{
|
|
moveresize_code = _NET_WM_MOVERESIZE_SIZE_RIGHT;
|
|
}
|
|
else if(pos.y <= inside_edges.y0)
|
|
{
|
|
moveresize_code = _NET_WM_MOVERESIZE_SIZE_TOP;
|
|
}
|
|
else if(pos.y >= inside_edges.y1)
|
|
{
|
|
moveresize_code = _NET_WM_MOVERESIZE_SIZE_BOTTOM;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
out_is_in_client_area[0] = !in_non_client_area;
|
|
return moveresize_code;
|
|
}
|
|
|
|
////////////////////////////////
|
|
//~ rjf: @per_os_impl Main Initialization API (Implemented Per-OS)
|
|
|
|
internal void
|
|
wm_init(void)
|
|
{
|
|
//- rjf: initialize basics
|
|
Arena *arena = arena_alloc();
|
|
lnx_wm_state = push_array(arena, LNX_WM_State, 1);
|
|
lnx_wm_state->arena = arena;
|
|
lnx_wm_state->display = XOpenDisplay(0);
|
|
|
|
//- rjf: calculate atoms
|
|
lnx_wm_state->wm_delete_window_atom = XInternAtom(lnx_wm_state->display, "WM_DELETE_WINDOW", 0);
|
|
lnx_wm_state->wm_sync_request_atom = XInternAtom(lnx_wm_state->display, "_NET_WM_SYNC_REQUEST", 0);
|
|
lnx_wm_state->wm_sync_request_counter_atom = XInternAtom(lnx_wm_state->display, "_NET_WM_SYNC_REQUEST_COUNTER", 0);
|
|
|
|
//- rjf: open im
|
|
lnx_wm_state->xim = XOpenIM(lnx_wm_state->display, 0, 0, 0);
|
|
|
|
//- rjf: fill out gfx info
|
|
lnx_wm_state->gfx_info.double_click_time = 0.5f;
|
|
lnx_wm_state->gfx_info.caret_blink_time = 0.5f;
|
|
lnx_wm_state->gfx_info.default_refresh_rate = 60.f;
|
|
|
|
//- rjf: fill out cursors
|
|
{
|
|
struct
|
|
{
|
|
WM_Cursor cursor;
|
|
unsigned int id;
|
|
}
|
|
map[] =
|
|
{
|
|
{WM_Cursor_Pointer, XC_left_ptr},
|
|
{WM_Cursor_IBar, XC_xterm},
|
|
{WM_Cursor_LeftRight, XC_sb_h_double_arrow},
|
|
{WM_Cursor_UpDown, XC_sb_v_double_arrow},
|
|
{WM_Cursor_DownRight, XC_bottom_right_corner},
|
|
{WM_Cursor_UpRight, XC_top_right_corner},
|
|
{WM_Cursor_UpDownLeftRight, XC_fleur},
|
|
{WM_Cursor_HandPoint, XC_hand1},
|
|
{WM_Cursor_Disabled, XC_X_cursor},
|
|
};
|
|
for EachElement(idx, map)
|
|
{
|
|
lnx_wm_state->cursors[map[idx].cursor] = XCreateFontCursor(lnx_wm_state->display, map[idx].id);
|
|
}
|
|
}
|
|
|
|
// create wakeup event for polling
|
|
lnx_wm_state->wakeup_fd = eventfd(0, EFD_CLOEXEC);
|
|
Assert(lnx_wm_state->wakeup_fd > 0);
|
|
}
|
|
|
|
////////////////////////////////
|
|
//~ rjf: @per_os_impl Graphics System Info (Implemented Per-OS)
|
|
|
|
internal WM_SystemInfo *
|
|
wm_get_system_info(void)
|
|
{
|
|
return &lnx_wm_state->gfx_info;
|
|
}
|
|
|
|
////////////////////////////////
|
|
//~ rjf: @per_os_impl Clipboards (Implemented Per-OS)
|
|
|
|
internal void
|
|
wm_set_clipboard_text(String8 string)
|
|
{
|
|
|
|
}
|
|
|
|
internal String8
|
|
wm_get_clipboard_text(Arena *arena)
|
|
{
|
|
String8 result = {0};
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////
|
|
//~ rjf: @per_os_impl Windows (Implemented Per-OS)
|
|
|
|
internal WM_Window
|
|
wm_window_open(Rng2F32 rect, WM_WindowFlags flags, String8 title)
|
|
{
|
|
Vec2F32 resolution = dim_2f32(rect);
|
|
|
|
//- rjf: allocate window
|
|
LNX_WM_Window *w = lnx_wm_state->free_window;
|
|
if(w)
|
|
{
|
|
SLLStackPop(lnx_wm_state->free_window);
|
|
}
|
|
else
|
|
{
|
|
w = push_array_no_zero(lnx_wm_state->arena, LNX_WM_Window, 1);
|
|
}
|
|
MemoryZeroStruct(w);
|
|
DLLPushBack(lnx_wm_state->first_window, lnx_wm_state->last_window, w);
|
|
|
|
//- rjf: create window & equip with x11 info
|
|
Visual *visual = lnx_wm_state->window_visual;
|
|
int depth = lnx_wm_state->window_depth;
|
|
Colormap colormap = lnx_wm_state->window_colormap;
|
|
unsigned long attr_mask = 0;
|
|
XSetWindowAttributes window_attribs = {0};
|
|
if(visual == 0)
|
|
{
|
|
visual = (Visual *)CopyFromParent;
|
|
depth = CopyFromParent;
|
|
}
|
|
else
|
|
{
|
|
window_attribs.background_pixmap = None;
|
|
window_attribs.border_pixel = 0;
|
|
window_attribs.colormap = colormap;
|
|
attr_mask = CWBackPixmap|CWBorderPixel|CWColormap;
|
|
}
|
|
w->window = XCreateWindow(lnx_wm_state->display,
|
|
XDefaultRootWindow(lnx_wm_state->display),
|
|
0, 0, resolution.x, resolution.y,
|
|
0,
|
|
depth,
|
|
InputOutput,
|
|
visual,
|
|
attr_mask,
|
|
&window_attribs);
|
|
XSelectInput(lnx_wm_state->display, w->window,
|
|
ExposureMask|
|
|
PointerMotionMask|
|
|
ButtonPressMask|
|
|
ButtonReleaseMask|
|
|
KeyPressMask|
|
|
KeyReleaseMask|
|
|
StructureNotifyMask|
|
|
FocusChangeMask);
|
|
XSetWindowBackgroundPixmap(lnx_wm_state->display, w->window, None);
|
|
Atom protocols[] =
|
|
{
|
|
lnx_wm_state->wm_delete_window_atom,
|
|
lnx_wm_state->wm_sync_request_atom,
|
|
};
|
|
XSetWMProtocols(lnx_wm_state->display, w->window, protocols, ArrayCount(protocols));
|
|
{
|
|
XSyncValue initial_value;
|
|
XSyncIntToValue(&initial_value, 0);
|
|
w->counter_xid = XSyncCreateCounter(lnx_wm_state->display, initial_value);
|
|
}
|
|
XChangeProperty(lnx_wm_state->display, w->window, lnx_wm_state->wm_sync_request_counter_atom, XA_CARDINAL, 32, PropModeReplace, (U8 *)&w->counter_xid, 1);
|
|
|
|
//- rjf: create xic
|
|
w->xic = XCreateIC(lnx_wm_state->xim,
|
|
XNInputStyle, XIMPreeditNothing|XIMStatusNothing,
|
|
XNClientWindow, w->window,
|
|
XNFocusWindow, w->window,
|
|
NULL);
|
|
|
|
//- rjf: attach name
|
|
Temp scratch = scratch_begin(0, 0);
|
|
String8 title_copy = push_str8_copy(scratch.arena, title);
|
|
XStoreName(lnx_wm_state->display, w->window, (char *)title_copy.str);
|
|
scratch_end(scratch);
|
|
|
|
//- rjf: set custom window border info
|
|
if(flags & WM_WindowFlag_CustomBorder)
|
|
{
|
|
w->custom_border = 1;
|
|
typedef struct Hints Hints;
|
|
struct Hints
|
|
{
|
|
U32 flags;
|
|
U32 functions;
|
|
U32 decorations;
|
|
S32 inputMode;
|
|
U32 status;
|
|
};
|
|
Hints hints = {.flags = 2, .decorations = 0};
|
|
Atom property = XInternAtom(lnx_wm_state->display, "_MOTIF_WM_HINTS", 1);
|
|
XChangeProperty(lnx_wm_state->display, w->window, property, property, 32, PropModeReplace, (unsigned char *)&hints, 5);
|
|
}
|
|
|
|
//- rjf: convert to handle & return
|
|
WM_Window handle = {(U64)w};
|
|
return handle;
|
|
}
|
|
|
|
internal void
|
|
wm_window_close(WM_Window handle)
|
|
{
|
|
if(wm_window_match(handle, wm_window_zero())) {return;}
|
|
LNX_WM_Window *w = (LNX_WM_Window *)handle.u64[0];
|
|
XDestroyWindow(lnx_wm_state->display, w->window);
|
|
}
|
|
|
|
internal void
|
|
wm_window_set_title(WM_Window handle, String8 title)
|
|
{
|
|
if(wm_window_match(handle, wm_window_zero())) {return;}
|
|
Temp scratch = scratch_begin(0, 0);
|
|
LNX_WM_Window *w = (LNX_WM_Window *)handle.u64[0];
|
|
String8 title_copy = push_str8_copy(scratch.arena, title);
|
|
XStoreName(lnx_wm_state->display, w->window, (char *)title_copy.str);
|
|
scratch_end(scratch);
|
|
}
|
|
|
|
internal void
|
|
wm_window_first_paint(WM_Window handle)
|
|
{
|
|
if(wm_window_match(handle, wm_window_zero())) {return;}
|
|
LNX_WM_Window *w = (LNX_WM_Window *)handle.u64[0];
|
|
XMapWindow(lnx_wm_state->display, w->window);
|
|
XFlush(lnx_wm_state->display);
|
|
}
|
|
|
|
internal void
|
|
wm_window_focus(WM_Window handle)
|
|
{
|
|
if(wm_window_match(handle, wm_window_zero())) {return;}
|
|
LNX_WM_Window *w = (LNX_WM_Window *)handle.u64[0];
|
|
//
|
|
// TODO: if the target is lightweight, the debugger may launch it even before the first frame is drawn;
|
|
// this is a problem because XSetInputFocus is now called before XMapWindow, we need a guard
|
|
// to prevent an X server error:
|
|
//
|
|
// X Error of failed request: BadMatch (invalid parameter attributes)
|
|
// Major opcode of failed request: 42 (X_SetInputFocus)
|
|
// Serial number of failed request: 373
|
|
// Current serial number in output stream: 374
|
|
//
|
|
XSetInputFocus(lnx_wm_state->display, w->window, RevertToNone, CurrentTime);
|
|
}
|
|
|
|
internal B32
|
|
wm_window_is_focused(WM_Window handle)
|
|
{
|
|
if(wm_window_match(handle, wm_window_zero())) {return 0;}
|
|
LNX_WM_Window *w = (LNX_WM_Window *)handle.u64[0];
|
|
Window focused_window = 0;
|
|
int revert_to = 0;
|
|
XGetInputFocus(lnx_wm_state->display, &focused_window, &revert_to);
|
|
B32 result = (w->window == focused_window);
|
|
return result;
|
|
}
|
|
|
|
internal B32
|
|
wm_window_is_fullscreen(WM_Window handle)
|
|
{
|
|
if(wm_window_match(handle, wm_window_zero())) {return 0;}
|
|
// TODO(rjf)
|
|
return 0;
|
|
}
|
|
|
|
internal void
|
|
wm_window_set_fullscreen(WM_Window handle, B32 fullscreen)
|
|
{
|
|
if(wm_window_match(handle, wm_window_zero())) {return;}
|
|
// TODO(rjf)
|
|
}
|
|
|
|
internal B32
|
|
wm_window_is_maximized(WM_Window handle)
|
|
{
|
|
if(wm_window_match(handle, wm_window_zero())) {return 0;}
|
|
// TODO(rjf)
|
|
return 0;
|
|
}
|
|
|
|
internal void
|
|
wm_window_set_maximized(WM_Window handle, B32 maximized)
|
|
{
|
|
if(wm_window_match(handle, wm_window_zero())) {return;}
|
|
// TODO(rjf)
|
|
}
|
|
|
|
internal B32
|
|
wm_window_is_minimized(WM_Window handle)
|
|
{
|
|
if(wm_window_match(handle, wm_window_zero())) {return 0;}
|
|
// TODO(rjf)
|
|
return 0;
|
|
}
|
|
|
|
internal void
|
|
wm_window_set_minimized(WM_Window handle, B32 minimized)
|
|
{
|
|
if(wm_window_match(handle, wm_window_zero())) {return;}
|
|
// TODO(rjf)
|
|
}
|
|
|
|
internal void
|
|
wm_window_bring_to_front(WM_Window handle)
|
|
{
|
|
if(wm_window_match(handle, wm_window_zero())) {return;}
|
|
// TODO(rjf)
|
|
}
|
|
|
|
internal void
|
|
wm_window_set_monitor(WM_Window handle, WM_Monitor monitor)
|
|
{
|
|
if(wm_window_match(handle, wm_window_zero())) {return;}
|
|
// TODO(rjf)
|
|
}
|
|
|
|
internal void
|
|
wm_window_clear_custom_border_data(WM_Window handle)
|
|
{
|
|
if(wm_window_match(handle, wm_window_zero())) {return;}
|
|
LNX_WM_Window *w = (LNX_WM_Window *)handle.u64[0];
|
|
for(LNX_WM_WindowClientArea *n = w->first_client_area, *next = 0; n != 0; n = next)
|
|
{
|
|
next = n->next;
|
|
SLLStackPush(lnx_wm_state->free_client_area, n);
|
|
}
|
|
w->first_client_area = w->last_client_area = 0;
|
|
}
|
|
|
|
internal void
|
|
wm_window_push_custom_title_bar(WM_Window handle, F32 thickness)
|
|
{
|
|
if(wm_window_match(handle, wm_window_zero())) {return;}
|
|
LNX_WM_Window *w = (LNX_WM_Window *)handle.u64[0];
|
|
w->custom_title_bar_thickness = thickness;
|
|
}
|
|
|
|
internal void
|
|
wm_window_push_custom_edges(WM_Window handle, F32 thickness)
|
|
{
|
|
if(wm_window_match(handle, wm_window_zero())) {return;}
|
|
LNX_WM_Window *w = (LNX_WM_Window *)handle.u64[0];
|
|
w->custom_edge_thickness = thickness;
|
|
}
|
|
|
|
internal void
|
|
wm_window_push_custom_title_bar_client_area(WM_Window handle, Rng2F32 rect)
|
|
{
|
|
if(wm_window_match(handle, wm_window_zero())) {return;}
|
|
LNX_WM_Window *w = (LNX_WM_Window *)handle.u64[0];
|
|
LNX_WM_WindowClientArea *n = lnx_wm_state->free_client_area;
|
|
if(n != 0)
|
|
{
|
|
SLLStackPop(lnx_wm_state->free_client_area);
|
|
}
|
|
else
|
|
{
|
|
n = push_array(lnx_wm_state->arena, LNX_WM_WindowClientArea, 1);
|
|
}
|
|
n->rect = rect;
|
|
SLLQueuePush(w->first_client_area, w->last_client_area, n);
|
|
}
|
|
|
|
internal Rng2F32
|
|
wm_rect_from_window(WM_Window handle)
|
|
{
|
|
if(wm_window_match(handle, wm_window_zero())) {return r2f32p(0, 0, 0, 0);}
|
|
LNX_WM_Window *w = (LNX_WM_Window *)handle.u64[0];
|
|
Rng2F32 result = {0};
|
|
if(w->resize_draw)
|
|
{
|
|
result = w->last_synced_rect;
|
|
}
|
|
else
|
|
{
|
|
XWindowAttributes atts = {0};
|
|
Status s = XGetWindowAttributes(lnx_wm_state->display, w->window, &atts);
|
|
result = r2f32p((F32)atts.x, (F32)atts.y, (F32)atts.x + (F32)atts.width, (F32)atts.y + (F32)atts.height);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
internal Rng2F32
|
|
wm_client_rect_from_window(WM_Window handle)
|
|
{
|
|
LNX_WM_Window *w = (LNX_WM_Window *)handle.u64[0];
|
|
Rng2F32 result = {0};
|
|
if(w->resize_draw)
|
|
{
|
|
Vec2F32 dim = dim_2f32(w->last_synced_rect);
|
|
result = r2f32p(0, 0, dim.x, dim.y);
|
|
}
|
|
else
|
|
{
|
|
XWindowAttributes atts = {0};
|
|
Status s = XGetWindowAttributes(lnx_wm_state->display, w->window, &atts);
|
|
result = r2f32p(0, 0, (F32)atts.width, (F32)atts.height);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
internal F32
|
|
wm_dpi_from_window(WM_Window handle)
|
|
{
|
|
// TODO(rjf)
|
|
return 96.f;
|
|
}
|
|
|
|
////////////////////////////////
|
|
//~ rjf: @per_os_impl External Windows (Implemented Per-OS)
|
|
|
|
internal WM_ExtWindow
|
|
wm_focused_external_window(void)
|
|
{
|
|
WM_ExtWindow result = {0};
|
|
// TODO(rjf)
|
|
return result;
|
|
}
|
|
|
|
internal void
|
|
wm_focus_external_window(WM_ExtWindow handle)
|
|
{
|
|
// TODO(rjf)
|
|
}
|
|
|
|
////////////////////////////////
|
|
//~ rjf: @per_os_impl Monitors (Implemented Per-OS)
|
|
|
|
internal WM_MonitorArray
|
|
wm_push_monitors_array(Arena *arena)
|
|
{
|
|
WM_MonitorArray result = {0};
|
|
// TODO(rjf)
|
|
return result;
|
|
}
|
|
|
|
internal WM_Monitor
|
|
wm_primary_monitor(void)
|
|
{
|
|
WM_Monitor result = {0};
|
|
// TODO(rjf)
|
|
return result;
|
|
}
|
|
|
|
internal WM_Monitor
|
|
wm_monitor_from_window(WM_Window window)
|
|
{
|
|
WM_Monitor result = {0};
|
|
// TODO(rjf)
|
|
return result;
|
|
}
|
|
|
|
internal String8
|
|
wm_name_from_monitor(Arena *arena, WM_Monitor monitor)
|
|
{
|
|
// TODO(rjf)
|
|
return str8_zero();
|
|
}
|
|
|
|
internal Vec2F32
|
|
wm_dim_from_monitor(WM_Monitor monitor)
|
|
{
|
|
// TODO(rjf)
|
|
return v2f32(0, 0);
|
|
}
|
|
|
|
internal F32
|
|
wm_dpi_from_monitor(WM_Monitor monitor)
|
|
{
|
|
// TODO(rjf)
|
|
return 96.f;
|
|
}
|
|
|
|
////////////////////////////////
|
|
//~ rjf: @per_os_impl Events (Implemented Per-OS)
|
|
|
|
internal void
|
|
wm_send_wakeup_event(void)
|
|
{
|
|
U64 dummy = 1;
|
|
ssize_t size = LNX_RETRY_ON_EINTR(write(lnx_wm_state->wakeup_fd, &dummy, sizeof(dummy)));
|
|
Assert(size == sizeof(dummy));
|
|
}
|
|
|
|
internal WM_EventList
|
|
wm_get_events(Arena *arena, B32 wait)
|
|
{
|
|
WM_EventList evts = {0};
|
|
for(;;)
|
|
{
|
|
if(XPending(lnx_wm_state->display) == 0)
|
|
{
|
|
struct pollfd poll_fds[2] =
|
|
{
|
|
{ .fd = ConnectionNumber(lnx_wm_state->display), .events = POLLIN },
|
|
{ .fd = lnx_wm_state->wakeup_fd, .events = POLLIN },
|
|
};
|
|
int timeout = wait && evts.count == 0 ? -1 : 0;
|
|
int poll_status = poll(poll_fds, ArrayCount(poll_fds), timeout);
|
|
Assert(poll_status >= 0);
|
|
if(poll_fds[1].revents & POLLIN)
|
|
{
|
|
U64 dummy = 0;
|
|
read(lnx_wm_state->wakeup_fd, &dummy, sizeof(dummy));
|
|
wait = 0;
|
|
}
|
|
}
|
|
while(XPending(lnx_wm_state->display))
|
|
{
|
|
//- rjf: get next event
|
|
XEvent evt = {0};
|
|
XNextEvent(lnx_wm_state->display, &evt);
|
|
|
|
//- rjf: do event response
|
|
B32 set_mouse_cursor = 0;
|
|
switch(evt.type)
|
|
{
|
|
default:{}break;
|
|
|
|
//- rjf: key presses/releases
|
|
case KeyPress:
|
|
case KeyRelease:
|
|
{
|
|
// rjf: determine flags
|
|
WM_Modifiers modifiers = 0;
|
|
if(evt.xkey.state & ShiftMask) { modifiers |= WM_Modifier_Shift; }
|
|
if(evt.xkey.state & ControlMask) { modifiers |= WM_Modifier_Ctrl; }
|
|
if(evt.xkey.state & Mod1Mask) { modifiers |= WM_Modifier_Alt; }
|
|
|
|
// rjf: map keycode -> keysym & codepoint
|
|
LNX_WM_Window *window = lnx_window_from_x11window(evt.xkey.window);
|
|
KeySym keysym = 0;
|
|
U8 text[256] = {0};
|
|
U64 text_size = Xutf8LookupString(window->xic, &evt.xkey, (char *)text, sizeof(text), &keysym, 0);
|
|
|
|
// rjf: map keysym -> WM_Key
|
|
B32 is_right_sided = 0;
|
|
WM_Key key = WM_Key_Null;
|
|
switch(keysym)
|
|
{
|
|
default:
|
|
{
|
|
if(0){}
|
|
else if(XK_F1 <= keysym && keysym <= XK_F24) { key = (WM_Key)(WM_Key_F1 + (keysym - XK_F1)); }
|
|
else if('0' <= keysym && keysym <= '9') { key = WM_Key_0 + (keysym-'0'); }
|
|
}break;
|
|
case XK_Escape:{key = WM_Key_Esc;};break;
|
|
case XK_BackSpace:{key = WM_Key_Backspace;}break;
|
|
case XK_Delete:{key = WM_Key_Delete;}break;
|
|
case XK_Return:{key = WM_Key_Return;}break;
|
|
case XK_Pause:{key = WM_Key_Pause;}break;
|
|
case XK_Tab:{key = WM_Key_Tab;}break;
|
|
case XK_Left:{key = WM_Key_Left;}break;
|
|
case XK_Right:{key = WM_Key_Right;}break;
|
|
case XK_Up:{key = WM_Key_Up;}break;
|
|
case XK_Down:{key = WM_Key_Down;}break;
|
|
case XK_Home:{key = WM_Key_Home;}break;
|
|
case XK_End:{key = WM_Key_End;}break;
|
|
case XK_Page_Up:{key = WM_Key_PageUp;}break;
|
|
case XK_Page_Down:{key = WM_Key_PageDown;}break;
|
|
case XK_Alt_L:{ key = WM_Key_Alt; }break;
|
|
case XK_Alt_R:{ key = WM_Key_Alt; is_right_sided = 1;}break;
|
|
case XK_Shift_L:{ key = WM_Key_Shift; }break;
|
|
case XK_Shift_R:{ key = WM_Key_Shift; is_right_sided = 1;}break;
|
|
case XK_Control_L:{ key = WM_Key_Ctrl; }break;
|
|
case XK_Control_R:{ key = WM_Key_Ctrl; is_right_sided = 1;}break;
|
|
case '-':{key = WM_Key_Minus;}break;
|
|
case '=':{key = WM_Key_Equal;}break;
|
|
case '[':{key = WM_Key_LeftBracket;}break;
|
|
case ']':{key = WM_Key_RightBracket;}break;
|
|
case ';':{key = WM_Key_Semicolon;}break;
|
|
case '\'':{key = WM_Key_Quote;}break;
|
|
case '.':{key = WM_Key_Period;}break;
|
|
case ',':{key = WM_Key_Comma;}break;
|
|
case '/':{key = WM_Key_Slash;}break;
|
|
case '\\':{key = WM_Key_BackSlash;}break;
|
|
case '\t':{key = WM_Key_Tab;}break;
|
|
case 'a':case 'A':{key = WM_Key_A;}break;
|
|
case 'b':case 'B':{key = WM_Key_B;}break;
|
|
case 'c':case 'C':{key = WM_Key_C;}break;
|
|
case 'd':case 'D':{key = WM_Key_D;}break;
|
|
case 'e':case 'E':{key = WM_Key_E;}break;
|
|
case 'f':case 'F':{key = WM_Key_F;}break;
|
|
case 'g':case 'G':{key = WM_Key_G;}break;
|
|
case 'h':case 'H':{key = WM_Key_H;}break;
|
|
case 'i':case 'I':{key = WM_Key_I;}break;
|
|
case 'j':case 'J':{key = WM_Key_J;}break;
|
|
case 'k':case 'K':{key = WM_Key_K;}break;
|
|
case 'l':case 'L':{key = WM_Key_L;}break;
|
|
case 'm':case 'M':{key = WM_Key_M;}break;
|
|
case 'n':case 'N':{key = WM_Key_N;}break;
|
|
case 'o':case 'O':{key = WM_Key_O;}break;
|
|
case 'p':case 'P':{key = WM_Key_P;}break;
|
|
case 'q':case 'Q':{key = WM_Key_Q;}break;
|
|
case 'r':case 'R':{key = WM_Key_R;}break;
|
|
case 's':case 'S':{key = WM_Key_S;}break;
|
|
case 't':case 'T':{key = WM_Key_T;}break;
|
|
case 'u':case 'U':{key = WM_Key_U;}break;
|
|
case 'v':case 'V':{key = WM_Key_V;}break;
|
|
case 'w':case 'W':{key = WM_Key_W;}break;
|
|
case 'x':case 'X':{key = WM_Key_X;}break;
|
|
case 'y':case 'Y':{key = WM_Key_Y;}break;
|
|
case 'z':case 'Z':{key = WM_Key_Z;}break;
|
|
case ' ':{key = WM_Key_Space;}break;
|
|
}
|
|
|
|
// rjf: push text event
|
|
if(evt.type == KeyPress && text_size != 0)
|
|
{
|
|
for(U64 off = 0; off < text_size;)
|
|
{
|
|
UnicodeDecode decode = utf8_decode(text+off, text_size-off);
|
|
if(decode.codepoint != 0 && decode.codepoint != 127 && (decode.codepoint >= 32 || decode.codepoint == '\t'))
|
|
{
|
|
WM_Event *e = wm_event_list_push_new(arena, &evts, WM_EventKind_Text);
|
|
e->window.u64[0] = (U64)window;
|
|
e->character = decode.codepoint;
|
|
}
|
|
if(decode.inc == 0)
|
|
{
|
|
break;
|
|
}
|
|
off += decode.inc;
|
|
}
|
|
}
|
|
|
|
// rjf: push key event
|
|
{
|
|
WM_Event *e = wm_event_list_push_new(arena, &evts, evt.type == KeyPress ? WM_EventKind_Press : WM_EventKind_Release);
|
|
e->window.u64[0] = (U64)window;
|
|
e->modifiers = modifiers;
|
|
e->key = key;
|
|
e->right_sided = is_right_sided;
|
|
}
|
|
}break;
|
|
|
|
//- rjf: mouse button presses/releases
|
|
case ButtonPress:
|
|
case ButtonRelease:
|
|
{
|
|
LNX_WM_Window *window = lnx_window_from_x11window(evt.xbutton.window);
|
|
|
|
// rjf: determine if this is outside client area, & where it is
|
|
B32 in_client_area = 0;
|
|
int moveresize_code = lnx_moveresize_code_from_pos(window, v2f32((F32)evt.xbutton.x, (F32)evt.xbutton.y), &in_client_area);
|
|
|
|
// rjf: if in non-client area -> redirect to default x11 server behavior
|
|
if(!in_client_area)
|
|
{
|
|
// rjf: ungrab pointer
|
|
XUngrabPointer(lnx_wm_state->display, evt.xbutton.time);
|
|
|
|
// rjf: get atom for moving/resizing event kind
|
|
Atom net_wm_moveresize = XInternAtom(lnx_wm_state->display, "_NET_WM_MOVERESIZE", 0);
|
|
|
|
// rjf: fill event
|
|
XEvent xev;
|
|
MemoryZeroStruct(&xev);
|
|
{
|
|
xev.xclient.type = ClientMessage;
|
|
xev.xclient.display = lnx_wm_state->display;
|
|
xev.xclient.window = window->window;
|
|
xev.xclient.message_type = net_wm_moveresize;
|
|
xev.xclient.format = 32;
|
|
xev.xclient.data.l[0] = evt.xbutton.x_root;
|
|
xev.xclient.data.l[1] = evt.xbutton.y_root;
|
|
xev.xclient.data.l[2] = moveresize_code;
|
|
}
|
|
|
|
// rjf: send event
|
|
XSendEvent(lnx_wm_state->display, DefaultRootWindow(lnx_wm_state->display), 0, SubstructureRedirectMask|SubstructureNotifyMask, &xev);
|
|
XFlush(lnx_wm_state->display);
|
|
}
|
|
|
|
// rjf: otherwise -> pipe the event to the application
|
|
else
|
|
{
|
|
// rjf: determine flags
|
|
WM_Modifiers modifiers = 0;
|
|
if(evt.xbutton.state & ShiftMask) { modifiers |= WM_Modifier_Shift; }
|
|
if(evt.xbutton.state & ControlMask) { modifiers |= WM_Modifier_Ctrl; }
|
|
if(evt.xbutton.state & Mod1Mask) { modifiers |= WM_Modifier_Alt; }
|
|
|
|
// rjf: map button -> WM_Key
|
|
WM_Key key = WM_Key_Null;
|
|
switch(evt.xbutton.button)
|
|
{
|
|
default:{}break;
|
|
case Button1:{key = WM_Key_LeftMouseButton;}break;
|
|
case Button2:{key = WM_Key_MiddleMouseButton;}break;
|
|
case Button3:{key = WM_Key_RightMouseButton;}break;
|
|
}
|
|
|
|
// rjf: push event
|
|
if(key != WM_Key_Null)
|
|
{
|
|
WM_Event *e = wm_event_list_push_new(arena, &evts, evt.type == ButtonPress ? WM_EventKind_Press : WM_EventKind_Release);
|
|
e->window.u64[0] = (U64)window;
|
|
e->modifiers = modifiers;
|
|
e->key = key;
|
|
e->pos = v2f32((F32)evt.xbutton.x, (F32)evt.xbutton.y);
|
|
}
|
|
else if(evt.xbutton.button == Button4 ||
|
|
evt.xbutton.button == Button5)
|
|
{
|
|
WM_Event *e = wm_event_list_push_new(arena, &evts, WM_EventKind_Scroll);
|
|
e->window.u64[0] = (U64)window;
|
|
e->modifiers = modifiers;
|
|
e->delta = v2f32(0, evt.xbutton.button == Button4 ? -1.f : +1.f);
|
|
e->pos = v2f32((F32)evt.xbutton.x, (F32)evt.xbutton.y);
|
|
}
|
|
}
|
|
}break;
|
|
|
|
//- rjf: mouse motion
|
|
case MotionNotify:
|
|
{
|
|
LNX_WM_Window *window = lnx_window_from_x11window(evt.xclient.window);
|
|
WM_Event *e = wm_event_list_push_new(arena, &evts, WM_EventKind_MouseMove);
|
|
e->window.u64[0] = (U64)window;
|
|
e->pos.x = (F32)evt.xmotion.x;
|
|
e->pos.y = (F32)evt.xmotion.y;
|
|
set_mouse_cursor = 1;
|
|
if(window->custom_border)
|
|
{
|
|
B32 in_client_area;
|
|
int moveresize_code = lnx_moveresize_code_from_pos(window, e->pos, &in_client_area);
|
|
if(!in_client_area)
|
|
{
|
|
switch(moveresize_code)
|
|
{
|
|
default:{}break;
|
|
case _NET_WM_MOVERESIZE_SIZE_TOPLEFT:{lnx_wm_state->last_set_cursor = WM_Cursor_DownRight;}break;
|
|
case _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT:{lnx_wm_state->last_set_cursor = WM_Cursor_DownRight;}break;
|
|
case _NET_WM_MOVERESIZE_SIZE_TOPRIGHT:{lnx_wm_state->last_set_cursor = WM_Cursor_UpRight;}break;
|
|
case _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT:{lnx_wm_state->last_set_cursor = WM_Cursor_UpRight;}break;
|
|
case _NET_WM_MOVERESIZE_SIZE_LEFT:{lnx_wm_state->last_set_cursor = WM_Cursor_LeftRight;}break;
|
|
case _NET_WM_MOVERESIZE_SIZE_RIGHT:{lnx_wm_state->last_set_cursor = WM_Cursor_LeftRight;}break;
|
|
case _NET_WM_MOVERESIZE_SIZE_TOP:{lnx_wm_state->last_set_cursor = WM_Cursor_UpDown;}break;
|
|
case _NET_WM_MOVERESIZE_SIZE_BOTTOM:{lnx_wm_state->last_set_cursor = WM_Cursor_UpDown;}break;
|
|
}
|
|
}
|
|
}
|
|
}break;
|
|
|
|
//- rjf: window focus/unfocus
|
|
case FocusIn:
|
|
{
|
|
}break;
|
|
case FocusOut:
|
|
{
|
|
LNX_WM_Window *window = lnx_window_from_x11window(evt.xfocus.window);
|
|
WM_Event *e = wm_event_list_push_new(arena, &evts, WM_EventKind_WindowLoseFocus);
|
|
e->window.u64[0] = (U64)window;
|
|
}break;
|
|
|
|
//- rjf: window moves & resizes
|
|
case ConfigureNotify:
|
|
{
|
|
LNX_WM_Window *window = lnx_window_from_x11window(evt.xconfigure.window);
|
|
if(!window->resize_draw)
|
|
{
|
|
window->last_synced_rect = r2f32p((F32)evt.xconfigure.x, (F32)evt.xconfigure.y, (F32)evt.xconfigure.x + (F32)evt.xconfigure.width, (F32)evt.xconfigure.y + (F32)evt.xconfigure.height);
|
|
}
|
|
}break;
|
|
|
|
//- rjf: re-paints
|
|
case Expose:
|
|
{
|
|
LNX_WM_Window *window = lnx_window_from_x11window(evt.xexpose.window);
|
|
if(XPending(lnx_wm_state->display) == 0)
|
|
{
|
|
window->resize_draw = window->waiting_for_resize;
|
|
update();
|
|
window->resize_draw = 0;
|
|
if(window->waiting_for_resize)
|
|
{
|
|
window->waiting_for_resize = 0;
|
|
XSyncValue sync_value;
|
|
XSyncIntsToValue(&sync_value, window->counter_value & 0xffffffffu, (int)((window->counter_value & 0xffffffff00000000ull) >> 32));
|
|
XSyncSetCounter(lnx_wm_state->display, window->counter_xid, sync_value);
|
|
XFlush(lnx_wm_state->display);
|
|
}
|
|
}
|
|
}break;
|
|
|
|
//- rjf: client messages
|
|
case ClientMessage:
|
|
{
|
|
if((Atom)evt.xclient.data.l[0] == lnx_wm_state->wm_delete_window_atom)
|
|
{
|
|
LNX_WM_Window *window = lnx_window_from_x11window(evt.xclient.window);
|
|
WM_Event *e = wm_event_list_push_new(arena, &evts, WM_EventKind_WindowClose);
|
|
e->window.u64[0] = (U64)window;
|
|
}
|
|
else if((Atom)evt.xclient.data.l[0] == lnx_wm_state->wm_sync_request_atom)
|
|
{
|
|
LNX_WM_Window *window = lnx_window_from_x11window(evt.xclient.window);
|
|
if(window != 0)
|
|
{
|
|
U32 counter_low = (U32)evt.xclient.data.l[2];
|
|
U32 counter_hi = (U32)evt.xclient.data.l[3];
|
|
window->counter_value = (counter_low | ((U64)counter_hi << 32));
|
|
window->waiting_for_resize = 1;
|
|
}
|
|
}
|
|
}break;
|
|
}
|
|
|
|
//- rjf: set mouse cursor
|
|
if(set_mouse_cursor)
|
|
{
|
|
Window root_window = 0;
|
|
Window child_window = 0;
|
|
int root_rel_x = 0;
|
|
int root_rel_y = 0;
|
|
int child_rel_x = 0;
|
|
int child_rel_y = 0;
|
|
unsigned int mask = 0;
|
|
if(XQueryPointer(lnx_wm_state->display, XDefaultRootWindow(lnx_wm_state->display), &root_window, &child_window, &root_rel_x, &root_rel_y, &child_rel_x, &child_rel_y, &mask))
|
|
{
|
|
XDefineCursor(lnx_wm_state->display, root_window, lnx_wm_state->cursors[lnx_wm_state->last_set_cursor]);
|
|
XFlush(lnx_wm_state->display);
|
|
}
|
|
}
|
|
}
|
|
if(evts.count > 0 || (wait == 0 && evts.count == 0))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
return evts;
|
|
}
|
|
|
|
internal WM_Modifiers
|
|
wm_get_modifiers(void)
|
|
{
|
|
// TODO(rjf)
|
|
return 0;
|
|
}
|
|
|
|
internal B32
|
|
wm_key_is_down(WM_Key key)
|
|
{
|
|
// TODO(rjf)
|
|
return 0;
|
|
}
|
|
|
|
internal Vec2F32
|
|
wm_mouse_from_window(WM_Window handle)
|
|
{
|
|
if(wm_window_match(handle, wm_window_zero())) {return v2f32(0, 0);}
|
|
LNX_WM_Window *w = (LNX_WM_Window *)handle.u64[0];
|
|
Vec2F32 result = {0};
|
|
{
|
|
Window root_window = 0;
|
|
Window child_window = 0;
|
|
int root_rel_x = 0;
|
|
int root_rel_y = 0;
|
|
int child_rel_x = 0;
|
|
int child_rel_y = 0;
|
|
unsigned int mask = 0;
|
|
if(XQueryPointer(lnx_wm_state->display, w->window, &root_window, &child_window, &root_rel_x, &root_rel_y, &child_rel_x, &child_rel_y, &mask))
|
|
{
|
|
result.x = child_rel_x;
|
|
result.y = child_rel_y;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////
|
|
//~ rjf: @per_os_impl Cursors (Implemented Per-OS)
|
|
|
|
internal void
|
|
wm_set_cursor(WM_Cursor cursor)
|
|
{
|
|
lnx_wm_state->last_set_cursor = cursor;
|
|
}
|
|
|
|
////////////////////////////////
|
|
//~ rjf: @per_os_impl Native User-Facing Graphical Messages (Implemented Per-OS)
|
|
|
|
internal void
|
|
wm_graphical_message(B32 error, String8 title, String8 message)
|
|
{
|
|
if(error)
|
|
{
|
|
fprintf(stderr, "[X] ");
|
|
}
|
|
fprintf(stderr, "%.*s\n", str8_varg(title));
|
|
fprintf(stderr, "%.*s\n\n", str8_varg(message));
|
|
}
|
|
|
|
internal String8
|
|
wm_graphical_pick_file(Arena *arena, String8 title, String8 initial_path)
|
|
{
|
|
return str8_zero();
|
|
}
|
|
|
|
////////////////////////////////
|
|
//~ rjf: @per_os_impl Shell Operations
|
|
|
|
internal void
|
|
wm_show_in_filesystem_ui(String8 path)
|
|
{
|
|
// TODO(rjf)
|
|
}
|
|
|
|
internal void
|
|
wm_open_in_browser(String8 url)
|
|
{
|
|
// TODO(rjf)
|
|
}
|