window_sdl3.c 11 KB

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