window_sdl3.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509
  1. /* SDL3 window backend for the host browser harness.
  2. *
  3. * SDL3 selects the Wayland driver on this desktop (and falls back to X11 if
  4. * it cannot connect); the browser still owns a plain RGB565 canvas and only
  5. * sees the generic win_* ABI through host/syscall.c. */
  6. #include <SDL3/SDL.h>
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <string.h>
  10. #include <unistd.h>
  11. #include "window.h"
  12. #include "cursor_abi.h"
  13. #define KEYQ_MAX 256
  14. #define EVQ_MAX 64
  15. static SDL_Window *win;
  16. static SDL_Renderer *ren;
  17. static SDL_Texture *tex;
  18. static unsigned short *fb;
  19. static int win_w, win_h;
  20. static int inited;
  21. static int focused;
  22. static int inside;
  23. static int close_sent;
  24. static int mouse_x, mouse_y;
  25. static unsigned mouse_buttons;
  26. static int scroll_x, scroll_y;
  27. static char backend[32] = "none";
  28. static int keyq[KEYQ_MAX];
  29. static unsigned int key_head, key_tail;
  30. static struct win_event evq[EVQ_MAX];
  31. static unsigned int ev_head, ev_tail;
  32. static void push_key(int k)
  33. {
  34. unsigned int next = (key_head + 1) % KEYQ_MAX;
  35. if (next == key_tail)
  36. return;
  37. keyq[key_head] = k;
  38. key_head = next;
  39. }
  40. static int pop_key(void)
  41. {
  42. int k;
  43. if (key_tail == key_head)
  44. return 0;
  45. k = keyq[key_tail];
  46. key_tail = (key_tail + 1) % KEYQ_MAX;
  47. return k;
  48. }
  49. static void push_event(unsigned int type, int x, int y, unsigned int button)
  50. {
  51. unsigned int next = (ev_head + 1) % EVQ_MAX;
  52. struct win_event *ev;
  53. if (next == ev_tail)
  54. return;
  55. ev = &evq[ev_head];
  56. ev->type = type;
  57. ev->x = x;
  58. ev->y = y;
  59. ev->buttons = mouse_buttons;
  60. ev->button = button;
  61. ev_head = next;
  62. }
  63. static unsigned int neb_buttons(Uint32 state)
  64. {
  65. unsigned int b = 0;
  66. if (state & SDL_BUTTON_LMASK)
  67. b |= 1;
  68. if (state & SDL_BUTTON_RMASK)
  69. b |= 2;
  70. if (state & SDL_BUTTON_MMASK)
  71. b |= 4;
  72. return b;
  73. }
  74. static void set_mouse(float x, float y, Uint32 state)
  75. {
  76. mouse_x = (int)x;
  77. mouse_y = (int)y;
  78. mouse_buttons = neb_buttons(state);
  79. inside = mouse_x >= 0 && mouse_y >= 0 &&
  80. mouse_x < win_w && mouse_y < win_h;
  81. }
  82. static void key_down(const SDL_KeyboardEvent *e)
  83. {
  84. SDL_Keycode k = e->key;
  85. SDL_Keymod mod = e->mod;
  86. int ctrl = (mod & SDL_KMOD_CTRL) != 0;
  87. /* Ctrl+letter -> ASCII control code (Ctrl+L = 0x0C, Ctrl+R = 0x12). */
  88. if (ctrl && k >= SDLK_A && k <= SDLK_Z) {
  89. push_key((int)(k - SDLK_A + 1));
  90. return;
  91. }
  92. switch (k) {
  93. case SDLK_ESCAPE:
  94. push_key(0x1B);
  95. return;
  96. case SDLK_BACKSPACE:
  97. push_key(ctrl ? 0x10C : 0x08);
  98. return;
  99. case SDLK_TAB:
  100. push_key(0x09);
  101. return;
  102. case SDLK_RETURN:
  103. case SDLK_KP_ENTER:
  104. push_key('\n');
  105. return;
  106. case SDLK_DELETE:
  107. push_key(ctrl ? 0x10B : 0x108);
  108. return;
  109. case SDLK_LEFT:
  110. push_key(ctrl ? 0x109 : 0x100);
  111. return;
  112. case SDLK_RIGHT:
  113. push_key(ctrl ? 0x10A : 0x101);
  114. return;
  115. case SDLK_UP:
  116. push_key(0x102);
  117. return;
  118. case SDLK_DOWN:
  119. push_key(0x103);
  120. return;
  121. case SDLK_PAGEUP:
  122. push_key(0x104);
  123. return;
  124. case SDLK_PAGEDOWN:
  125. push_key(0x105);
  126. return;
  127. case SDLK_HOME:
  128. push_key(0x106);
  129. return;
  130. case SDLK_END:
  131. push_key(0x107);
  132. return;
  133. default:
  134. break;
  135. }
  136. /* Printable characters arrive through SDL_EVENT_TEXT_INPUT, which
  137. * honours the keyboard layout and key repeat. */
  138. }
  139. static void text_utf8(const char *s)
  140. {
  141. const unsigned char *p = (const unsigned char *)s;
  142. while (p && *p) {
  143. unsigned int cp;
  144. int n;
  145. if (*p < 0x80) {
  146. cp = *p++;
  147. n = 0;
  148. } else if ((*p & 0xE0) == 0xC0) {
  149. cp = *p++ & 0x1F;
  150. n = 1;
  151. } else if ((*p & 0xF0) == 0xE0) {
  152. cp = *p++ & 0x0F;
  153. n = 2;
  154. } else if ((*p & 0xF8) == 0xF0) {
  155. cp = *p++ & 0x07;
  156. n = 3;
  157. } else {
  158. p++;
  159. continue;
  160. }
  161. while (n-- > 0) {
  162. if ((*p & 0xC0) != 0x80) {
  163. cp = 0xFFFD;
  164. break;
  165. }
  166. cp = (cp << 6) | (*p++ & 0x3F);
  167. }
  168. if (cp == '\r' || cp == '\n')
  169. push_key('\n');
  170. else if (cp >= 0x20 && cp <= 0xFF)
  171. push_key((int)cp);
  172. else if (cp > 0xFF)
  173. push_key('?');
  174. }
  175. }
  176. static void handle_event(SDL_Event *e)
  177. {
  178. switch (e->type) {
  179. case SDL_EVENT_QUIT:
  180. case SDL_EVENT_WINDOW_CLOSE_REQUESTED:
  181. if (!close_sent) {
  182. close_sent = 1;
  183. push_key(0x1B);
  184. }
  185. break;
  186. case SDL_EVENT_WINDOW_FOCUS_GAINED:
  187. focused = 1;
  188. break;
  189. case SDL_EVENT_WINDOW_FOCUS_LOST:
  190. focused = 0;
  191. break;
  192. case SDL_EVENT_WINDOW_MOUSE_ENTER:
  193. inside = 1;
  194. break;
  195. case SDL_EVENT_WINDOW_MOUSE_LEAVE:
  196. inside = 0;
  197. break;
  198. case SDL_EVENT_MOUSE_MOTION:
  199. set_mouse(e->motion.x, e->motion.y, e->motion.state);
  200. break;
  201. case SDL_EVENT_MOUSE_BUTTON_DOWN:
  202. case SDL_EVENT_MOUSE_BUTTON_UP: {
  203. unsigned int bit = 0;
  204. if (e->button.button == SDL_BUTTON_LEFT)
  205. bit = 1;
  206. else if (e->button.button == SDL_BUTTON_RIGHT)
  207. bit = 2;
  208. else if (e->button.button == SDL_BUTTON_MIDDLE)
  209. bit = 4;
  210. mouse_x = (int)e->button.x;
  211. mouse_y = (int)e->button.y;
  212. inside = mouse_x >= 0 && mouse_y >= 0 &&
  213. mouse_x < win_w && mouse_y < win_h;
  214. if (bit) {
  215. if (e->type == SDL_EVENT_MOUSE_BUTTON_DOWN)
  216. mouse_buttons |= bit;
  217. else
  218. mouse_buttons &= ~bit;
  219. push_event(e->type == SDL_EVENT_MOUSE_BUTTON_DOWN ?
  220. WIN_EV_POINTER_DOWN : WIN_EV_POINTER_UP,
  221. mouse_x, mouse_y, bit);
  222. }
  223. break;
  224. }
  225. case SDL_EVENT_MOUSE_WHEEL:
  226. /* SDL's y is positive away from the user; the browser wants
  227. * +dy = later content. */
  228. scroll_x += (int)(-e->wheel.x * 48.0f);
  229. scroll_y += (int)(-e->wheel.y * 48.0f);
  230. break;
  231. case SDL_EVENT_KEY_DOWN:
  232. key_down(&e->key);
  233. break;
  234. case SDL_EVENT_TEXT_INPUT:
  235. text_utf8(e->text.text);
  236. break;
  237. default:
  238. break;
  239. }
  240. }
  241. int host_sdl_open(unsigned int w, unsigned int h, const char *title)
  242. {
  243. const char *drv;
  244. if (inited)
  245. return (win_w == (int)w && win_h == (int)h) ? 0 : -1;
  246. if (!SDL_Init(SDL_INIT_VIDEO)) {
  247. fprintf(stderr, "browser-host: SDL_Init: %s\n", SDL_GetError());
  248. return -1;
  249. }
  250. drv = SDL_GetCurrentVideoDriver();
  251. snprintf(backend, sizeof(backend), "%s", drv ? drv : "?");
  252. win = SDL_CreateWindow(title ? title : "Browser", (int)w, (int)h, 0);
  253. if (!win) {
  254. fprintf(stderr, "browser-host: SDL_CreateWindow: %s\n",
  255. SDL_GetError());
  256. SDL_Quit();
  257. return -1;
  258. }
  259. ren = SDL_CreateRenderer(win, 0);
  260. if (!ren)
  261. ren = SDL_CreateRenderer(win, "software");
  262. if (!ren) {
  263. fprintf(stderr, "browser-host: SDL_CreateRenderer: %s\n",
  264. SDL_GetError());
  265. SDL_DestroyWindow(win);
  266. win = 0;
  267. SDL_Quit();
  268. return -1;
  269. }
  270. SDL_SetRenderVSync(ren, 0);
  271. tex = SDL_CreateTexture(ren, SDL_PIXELFORMAT_RGB565,
  272. SDL_TEXTUREACCESS_STREAMING, (int)w, (int)h);
  273. if (!tex) {
  274. fprintf(stderr, "browser-host: SDL_CreateTexture: %s\n",
  275. SDL_GetError());
  276. SDL_DestroyRenderer(ren);
  277. ren = 0;
  278. SDL_DestroyWindow(win);
  279. win = 0;
  280. SDL_Quit();
  281. return -1;
  282. }
  283. SDL_SetTextureScaleMode(tex, SDL_SCALEMODE_NEAREST);
  284. SDL_SetWindowResizable(win, false);
  285. SDL_SetWindowMinimumSize(win, (int)w, (int)h);
  286. SDL_SetWindowMaximumSize(win, (int)w, (int)h);
  287. SDL_StartTextInput(win);
  288. fb = (unsigned short *)calloc((size_t)w * h, sizeof(unsigned short));
  289. if (!fb) {
  290. SDL_DestroyTexture(tex);
  291. tex = 0;
  292. SDL_DestroyRenderer(ren);
  293. ren = 0;
  294. SDL_DestroyWindow(win);
  295. win = 0;
  296. SDL_Quit();
  297. return -1;
  298. }
  299. win_w = (int)w;
  300. win_h = (int)h;
  301. focused = 1;
  302. inside = 1;
  303. inited = 1;
  304. fprintf(stderr, "browser-host: video driver=%s window=%ux%u\n",
  305. backend, w, h);
  306. return 0;
  307. }
  308. void host_sdl_close(void)
  309. {
  310. if (!inited)
  311. return;
  312. SDL_StopTextInput(win);
  313. free(fb);
  314. fb = 0;
  315. SDL_DestroyTexture(tex);
  316. tex = 0;
  317. SDL_DestroyRenderer(ren);
  318. ren = 0;
  319. SDL_DestroyWindow(win);
  320. win = 0;
  321. SDL_Quit();
  322. inited = 0;
  323. }
  324. void *host_sdl_fb(void)
  325. {
  326. return fb;
  327. }
  328. unsigned int host_sdl_width(void)
  329. {
  330. return (unsigned int)win_w;
  331. }
  332. unsigned int host_sdl_height(void)
  333. {
  334. return (unsigned int)win_h;
  335. }
  336. void host_sdl_present(void)
  337. {
  338. if (!inited || !tex)
  339. return;
  340. if (!SDL_UpdateTexture(tex, 0, fb, win_w * (int)sizeof(unsigned short)))
  341. return;
  342. SDL_SetRenderDrawColor(ren, 0, 0, 0, 255);
  343. SDL_RenderClear(ren);
  344. SDL_RenderTexture(ren, tex, 0, 0);
  345. SDL_RenderPresent(ren);
  346. }
  347. void host_sdl_pump(unsigned int timeout_ms)
  348. {
  349. SDL_Event e;
  350. if (!inited) {
  351. if (timeout_ms)
  352. usleep(timeout_ms * 1000u);
  353. return;
  354. }
  355. if (timeout_ms) {
  356. if (SDL_WaitEventTimeout(&e, (Sint32)timeout_ms))
  357. handle_event(&e);
  358. } else {
  359. SDL_PumpEvents();
  360. }
  361. while (SDL_PollEvent(&e))
  362. handle_event(&e);
  363. }
  364. int host_sdl_pointer(struct win_pointer *out)
  365. {
  366. SDL_WindowFlags flags;
  367. if (!inited)
  368. return -1;
  369. flags = SDL_GetWindowFlags(win);
  370. focused = (flags & SDL_WINDOW_INPUT_FOCUS) ? 1 : 0;
  371. out->x = mouse_x;
  372. out->y = mouse_y;
  373. out->buttons = mouse_buttons;
  374. out->inside = inside ? 1u : 0u;
  375. out->focused = focused ? 1u : 0u;
  376. return 0;
  377. }
  378. int host_sdl_event(struct win_event *out)
  379. {
  380. if (ev_tail == ev_head)
  381. return 0;
  382. *out = evq[ev_tail];
  383. ev_tail = (ev_tail + 1) % EVQ_MAX;
  384. return 1;
  385. }
  386. int host_sdl_scroll(struct win_scroll *out)
  387. {
  388. if (!scroll_x && !scroll_y)
  389. return 0;
  390. out->dx = scroll_x;
  391. out->dy = scroll_y;
  392. scroll_x = scroll_y = 0;
  393. return 1;
  394. }
  395. int host_sdl_key(void)
  396. {
  397. return pop_key();
  398. }
  399. /* NebOS cursor shapes on the desktop's own cursor theme. SDL has no
  400. * help/zoom/copy/... system cursors: those fall back to the arrow. */
  401. void host_sdl_set_cursor(int shape)
  402. {
  403. static SDL_Cursor *cache[CURSOR_COUNT];
  404. static int current = -1;
  405. SDL_SystemCursor sc = SDL_SYSTEM_CURSOR_DEFAULT;
  406. if (shape < 0 || shape >= CURSOR_COUNT || shape == current)
  407. return;
  408. switch (shape) {
  409. case CURSOR_POINTER: sc = SDL_SYSTEM_CURSOR_POINTER; break;
  410. case CURSOR_TEXT:
  411. case CURSOR_VERTICAL_TEXT: sc = SDL_SYSTEM_CURSOR_TEXT; break;
  412. case CURSOR_WAIT: sc = SDL_SYSTEM_CURSOR_WAIT; break;
  413. case CURSOR_PROGRESS: sc = SDL_SYSTEM_CURSOR_PROGRESS; break;
  414. case CURSOR_CROSSHAIR:
  415. case CURSOR_CELL: sc = SDL_SYSTEM_CURSOR_CROSSHAIR; break;
  416. case CURSOR_MOVE:
  417. case CURSOR_ALL_SCROLL:
  418. case CURSOR_ALL_RESIZE: sc = SDL_SYSTEM_CURSOR_MOVE; break;
  419. case CURSOR_NOT_ALLOWED:
  420. case CURSOR_NO_DROP: sc = SDL_SYSTEM_CURSOR_NOT_ALLOWED; break;
  421. case CURSOR_N_RESIZE: sc = SDL_SYSTEM_CURSOR_N_RESIZE; break;
  422. case CURSOR_E_RESIZE: sc = SDL_SYSTEM_CURSOR_E_RESIZE; break;
  423. case CURSOR_S_RESIZE: sc = SDL_SYSTEM_CURSOR_S_RESIZE; break;
  424. case CURSOR_W_RESIZE: sc = SDL_SYSTEM_CURSOR_W_RESIZE; break;
  425. case CURSOR_NE_RESIZE: sc = SDL_SYSTEM_CURSOR_NE_RESIZE; break;
  426. case CURSOR_NW_RESIZE: sc = SDL_SYSTEM_CURSOR_NW_RESIZE; break;
  427. case CURSOR_SE_RESIZE: sc = SDL_SYSTEM_CURSOR_SE_RESIZE; break;
  428. case CURSOR_SW_RESIZE: sc = SDL_SYSTEM_CURSOR_SW_RESIZE; break;
  429. case CURSOR_EW_RESIZE:
  430. case CURSOR_COL_RESIZE: sc = SDL_SYSTEM_CURSOR_EW_RESIZE; break;
  431. case CURSOR_NS_RESIZE:
  432. case CURSOR_ROW_RESIZE: sc = SDL_SYSTEM_CURSOR_NS_RESIZE; break;
  433. case CURSOR_NESW_RESIZE: sc = SDL_SYSTEM_CURSOR_NESW_RESIZE; break;
  434. case CURSOR_NWSE_RESIZE: sc = SDL_SYSTEM_CURSOR_NWSE_RESIZE; break;
  435. default: break;
  436. }
  437. if (!cache[shape])
  438. cache[shape] = SDL_CreateSystemCursor(sc);
  439. if (cache[shape])
  440. SDL_SetCursor(cache[shape]);
  441. current = shape;
  442. }
  443. int host_sdl_screen(unsigned int *w, unsigned int *h)
  444. {
  445. SDL_Rect r;
  446. if (SDL_GetDisplayBounds(SDL_GetPrimaryDisplay(), &r)) {
  447. *w = (unsigned int)r.w;
  448. *h = (unsigned int)r.h;
  449. } else {
  450. *w = (unsigned int)win_w;
  451. *h = (unsigned int)win_h;
  452. }
  453. return 0;
  454. }
  455. int host_sdl_key_wait(unsigned int timeout_ms)
  456. {
  457. int k = pop_key();
  458. if (k)
  459. return k;
  460. host_sdl_pump(timeout_ms);
  461. return pop_key();
  462. }
  463. const char *host_sdl_backend(void)
  464. {
  465. return backend;
  466. }