Blender V5.3
GHOST_SystemSDL.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2011-2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <cassert>
10#include <cstring>
11#include <stdexcept>
12
13#ifdef WITH_OPENGL_BACKEND
14# include "GHOST_ContextSDL.hh"
15#endif
16#ifdef WITH_VULKAN_BACKEND
17# include "GHOST_ContextVK.hh"
18#endif
19#include "GHOST_SystemSDL.hh"
20#include "GHOST_WindowSDL.hh"
21
23
24#include "GHOST_EventButton.hh"
25#include "GHOST_EventCursor.hh"
26#include "GHOST_EventKey.hh"
27#include "GHOST_EventWheel.hh"
28
30{
31 if (!SDL_Init(SDL_INIT_VIDEO)) {
32 throw std::runtime_error(SDL_GetError());
33 }
34
35 SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
36 SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
37 SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
38 SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
39 SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
40}
41
43{
44 SDL_Quit();
45}
46
47GHOST_IWindow *GHOST_SystemSDL::createWindow(const char *title,
48 int32_t left,
49 int32_t top,
50 uint32_t width,
51 uint32_t height,
53 GHOST_GPUSettings gpu_settings,
54 const bool exclusive,
55 const bool /*is_dialog*/,
56 const GHOST_IWindow *parent_window)
57{
58 GHOST_WindowSDL *window = nullptr;
59
60 const GHOST_ContextParams context_params = GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS(gpu_settings);
61
62 window = new GHOST_WindowSDL(this,
63 title,
64 left,
65 top,
66 width,
67 height,
68 state,
69 gpu_settings.context_type,
70 context_params,
71 gpu_settings.preferred_device,
72 exclusive,
73 parent_window);
74
75 if (window) {
77 SDL_Window *sdl_win = window->getSDLWindow();
78 SDL_SetWindowFullscreenMode(sdl_win, nullptr);
79 SDL_ShowWindow(sdl_win);
80 SDL_SetWindowFullscreen(sdl_win, true);
81 }
82
83 if (window->getValid()) {
86 pushEvent(std::make_unique<GHOST_Event>(getMilliSeconds(), GHOST_kEventWindowSize, window));
87 }
88 else {
89 delete window;
90 window = nullptr;
91 }
92 }
93 return window;
94}
95
97{
99
100 if (success) {
101 return GHOST_kSuccess;
102 }
103
104 return GHOST_kFailure;
105}
106
111void GHOST_SystemSDL::getAllDisplayDimensions(uint32_t &width, uint32_t &height) const
112{
113 SDL_DisplayID display_id = SDL_GetPrimaryDisplay();
114 const SDL_DisplayMode *mode = SDL_GetDesktopDisplayMode(display_id);
115 if (mode == nullptr) {
116 return;
117 }
118 width = mode->w;
119 height = mode->h;
120}
121
122void GHOST_SystemSDL::getMainDisplayDimensions(uint32_t &width, uint32_t &height) const
123{
124 SDL_DisplayID display_id = SDL_GetPrimaryDisplay();
125 const SDL_DisplayMode *mode = SDL_GetCurrentDisplayMode(display_id);
126 if (mode == nullptr) {
127 return;
128 }
129 width = mode->w;
130 height = mode->h;
131}
132
134{
135 int count = 0;
136 SDL_DisplayID *displays = SDL_GetDisplays(&count);
137 SDL_free(displays);
138 return uint8_t(count);
139}
140
142{
143 const GHOST_ContextParams context_params_offscreen =
145
146 switch (gpu_settings.context_type) {
147#ifdef WITH_OPENGL_BACKEND
148 case GHOST_kDrawingContextTypeOpenGL: {
149 for (int minor = 6; minor >= 3; --minor) {
150 GHOST_Context *context = new GHOST_ContextSDL(
151 context_params_offscreen,
152 nullptr,
153 0, /* Profile bit. */
154 4,
155 minor,
158
159 if (context->initializeDrawingContext()) {
160 return context;
161 }
162 delete context;
163 }
164 return nullptr;
165 }
166#endif
167
168#ifdef WITH_VULKAN_BACKEND
169 case GHOST_kDrawingContextTypeVulkan: {
170 GHOST_Context *context = new GHOST_ContextVK(
171 context_params_offscreen, nullptr, 1, 1, gpu_settings.preferred_device);
172 if (context->initializeDrawingContext()) {
173 return context;
174 }
175 delete context;
176 return nullptr;
177 }
178#endif
179
180 default:
181 /* Unsupported backend. */
182 return nullptr;
183 }
184}
185
187{
188 delete context;
189
190 return GHOST_kSuccess;
191}
192
194{
195 SDL_Keymod mod = SDL_GetModState();
196
197 keys.set(GHOST_kModifierKeyLeftShift, (mod & SDL_KMOD_LSHIFT) != 0);
198 keys.set(GHOST_kModifierKeyRightShift, (mod & SDL_KMOD_RSHIFT) != 0);
199 keys.set(GHOST_kModifierKeyLeftControl, (mod & SDL_KMOD_LCTRL) != 0);
200 keys.set(GHOST_kModifierKeyRightControl, (mod & SDL_KMOD_RCTRL) != 0);
201 keys.set(GHOST_kModifierKeyLeftAlt, (mod & SDL_KMOD_LALT) != 0);
202 keys.set(GHOST_kModifierKeyRightAlt, (mod & SDL_KMOD_RALT) != 0);
203 keys.set(GHOST_kModifierKeyLeftOS, (mod & SDL_KMOD_LGUI) != 0);
204 keys.set(GHOST_kModifierKeyRightOS, (mod & SDL_KMOD_RGUI) != 0);
205
206 return GHOST_kSuccess;
207}
208
209#define GXMAP(k, x, y) \
210 case x: \
211 k = y; \
212 break
213
214static GHOST_TKey convertSDLKey(SDL_Scancode key)
215{
216 GHOST_TKey type;
217
218 if ((key >= SDL_SCANCODE_A) && (key <= SDL_SCANCODE_Z)) {
219 type = GHOST_TKey(key - SDL_SCANCODE_A + int(GHOST_kKeyA));
220 }
221 else if ((key >= SDL_SCANCODE_1) && (key <= SDL_SCANCODE_0)) {
222 type = (key == SDL_SCANCODE_0) ? GHOST_kKey0 :
223 GHOST_TKey(key - SDL_SCANCODE_1 + int(GHOST_kKey1));
224 }
225 else if ((key >= SDL_SCANCODE_F1) && (key <= SDL_SCANCODE_F12)) {
226 type = GHOST_TKey(key - SDL_SCANCODE_F1 + int(GHOST_kKeyF1));
227 }
228 else if ((key >= SDL_SCANCODE_F13) && (key <= SDL_SCANCODE_F24)) {
229 type = GHOST_TKey(key - SDL_SCANCODE_F13 + int(GHOST_kKeyF13));
230 }
231 else {
232 switch (key) {
233 GXMAP(type, SDL_SCANCODE_BACKSPACE, GHOST_kKeyBackSpace);
234 GXMAP(type, SDL_SCANCODE_TAB, GHOST_kKeyTab);
235 GXMAP(type, SDL_SCANCODE_RETURN, GHOST_kKeyEnter);
236 GXMAP(type, SDL_SCANCODE_ESCAPE, GHOST_kKeyEsc);
237 GXMAP(type, SDL_SCANCODE_SPACE, GHOST_kKeySpace);
238
239 GXMAP(type, SDL_SCANCODE_SEMICOLON, GHOST_kKeySemicolon);
240 GXMAP(type, SDL_SCANCODE_PERIOD, GHOST_kKeyPeriod);
241 GXMAP(type, SDL_SCANCODE_COMMA, GHOST_kKeyComma);
242 GXMAP(type, SDL_SCANCODE_APOSTROPHE, GHOST_kKeyQuote);
243 GXMAP(type, SDL_SCANCODE_GRAVE, GHOST_kKeyAccentGrave);
244 GXMAP(type, SDL_SCANCODE_MINUS, GHOST_kKeyMinus);
245 GXMAP(type, SDL_SCANCODE_EQUALS, GHOST_kKeyEqual);
246
247 GXMAP(type, SDL_SCANCODE_SLASH, GHOST_kKeySlash);
248 GXMAP(type, SDL_SCANCODE_BACKSLASH, GHOST_kKeyBackslash);
249 GXMAP(type, SDL_SCANCODE_KP_EQUALS, GHOST_kKeyEqual);
250 GXMAP(type, SDL_SCANCODE_LEFTBRACKET, GHOST_kKeyLeftBracket);
251 GXMAP(type, SDL_SCANCODE_RIGHTBRACKET, GHOST_kKeyRightBracket);
252 GXMAP(type, SDL_SCANCODE_PAUSE, GHOST_kKeyPause);
253
254 GXMAP(type, SDL_SCANCODE_LSHIFT, GHOST_kKeyLeftShift);
255 GXMAP(type, SDL_SCANCODE_RSHIFT, GHOST_kKeyRightShift);
256 GXMAP(type, SDL_SCANCODE_LCTRL, GHOST_kKeyLeftControl);
257 GXMAP(type, SDL_SCANCODE_RCTRL, GHOST_kKeyRightControl);
258 GXMAP(type, SDL_SCANCODE_LALT, GHOST_kKeyLeftAlt);
259 GXMAP(type, SDL_SCANCODE_RALT, GHOST_kKeyRightAlt);
260 GXMAP(type, SDL_SCANCODE_LGUI, GHOST_kKeyLeftOS);
261 GXMAP(type, SDL_SCANCODE_RGUI, GHOST_kKeyRightOS);
262 GXMAP(type, SDL_SCANCODE_APPLICATION, GHOST_kKeyApp);
263
264 GXMAP(type, SDL_SCANCODE_INSERT, GHOST_kKeyInsert);
265 GXMAP(type, SDL_SCANCODE_DELETE, GHOST_kKeyDelete);
266 GXMAP(type, SDL_SCANCODE_HOME, GHOST_kKeyHome);
267 GXMAP(type, SDL_SCANCODE_END, GHOST_kKeyEnd);
268 GXMAP(type, SDL_SCANCODE_PAGEUP, GHOST_kKeyUpPage);
269 GXMAP(type, SDL_SCANCODE_PAGEDOWN, GHOST_kKeyDownPage);
270
271 GXMAP(type, SDL_SCANCODE_LEFT, GHOST_kKeyLeftArrow);
272 GXMAP(type, SDL_SCANCODE_RIGHT, GHOST_kKeyRightArrow);
273 GXMAP(type, SDL_SCANCODE_UP, GHOST_kKeyUpArrow);
274 GXMAP(type, SDL_SCANCODE_DOWN, GHOST_kKeyDownArrow);
275
276 GXMAP(type, SDL_SCANCODE_CAPSLOCK, GHOST_kKeyCapsLock);
277 GXMAP(type, SDL_SCANCODE_SCROLLLOCK, GHOST_kKeyScrollLock);
278 GXMAP(type, SDL_SCANCODE_NUMLOCKCLEAR, GHOST_kKeyNumLock);
279 GXMAP(type, SDL_SCANCODE_PRINTSCREEN, GHOST_kKeyPrintScreen);
280
281 /* keypad events */
282
283 /* NOTE: SDL defines a bunch of key-pad identifiers that aren't supported by GHOST,
284 * such as #SDL_SCANCODE_KP_PERCENT, #SDL_SCANCODE_KP_XOR. */
285 GXMAP(type, SDL_SCANCODE_KP_0, GHOST_kKeyNumpad0);
286 GXMAP(type, SDL_SCANCODE_KP_1, GHOST_kKeyNumpad1);
287 GXMAP(type, SDL_SCANCODE_KP_2, GHOST_kKeyNumpad2);
288 GXMAP(type, SDL_SCANCODE_KP_3, GHOST_kKeyNumpad3);
289 GXMAP(type, SDL_SCANCODE_KP_4, GHOST_kKeyNumpad4);
290 GXMAP(type, SDL_SCANCODE_KP_5, GHOST_kKeyNumpad5);
291 GXMAP(type, SDL_SCANCODE_KP_6, GHOST_kKeyNumpad6);
292 GXMAP(type, SDL_SCANCODE_KP_7, GHOST_kKeyNumpad7);
293 GXMAP(type, SDL_SCANCODE_KP_8, GHOST_kKeyNumpad8);
294 GXMAP(type, SDL_SCANCODE_KP_9, GHOST_kKeyNumpad9);
295 GXMAP(type, SDL_SCANCODE_KP_PERIOD, GHOST_kKeyNumpadPeriod);
296
297 GXMAP(type, SDL_SCANCODE_KP_ENTER, GHOST_kKeyNumpadEnter);
298 GXMAP(type, SDL_SCANCODE_KP_PLUS, GHOST_kKeyNumpadPlus);
299 GXMAP(type, SDL_SCANCODE_KP_MINUS, GHOST_kKeyNumpadMinus);
300 GXMAP(type, SDL_SCANCODE_KP_MULTIPLY, GHOST_kKeyNumpadAsterisk);
301 GXMAP(type, SDL_SCANCODE_KP_DIVIDE, GHOST_kKeyNumpadSlash);
302
303 /* Media keys in some keyboards and laptops with XFree86/XORG. */
304 GXMAP(type, SDL_SCANCODE_MEDIA_PLAY, GHOST_kKeyMediaPlay);
305 GXMAP(type, SDL_SCANCODE_MEDIA_STOP, GHOST_kKeyMediaStop);
306 GXMAP(type, SDL_SCANCODE_MEDIA_PREVIOUS_TRACK, GHOST_kKeyMediaFirst);
307 GXMAP(type, SDL_SCANCODE_MEDIA_NEXT_TRACK, GHOST_kKeyMediaLast);
308
309 /* International Keys. */
310
311 /* This key has multiple purposes,
312 * however the only GHOST key that uses the scan-code is GrLess. */
313 GXMAP(type, SDL_SCANCODE_NONUSBACKSLASH, GHOST_kKeyGrLess);
314
315 default:
316 printf("Unknown\n");
317 type = GHOST_kKeyUnknown;
318 break;
319 }
320 }
321
322 return type;
323}
324#undef GXMAP
325
326static char convert_keyboard_event_to_ascii(const SDL_KeyboardEvent &sdl_sub_evt)
327{
328 SDL_Keycode sym = sdl_sub_evt.key;
329 if (sym > 127) {
330 switch (sym) {
331 case SDLK_KP_DIVIDE:
332 sym = '/';
333 break;
334 case SDLK_KP_MULTIPLY:
335 sym = '*';
336 break;
337 case SDLK_KP_MINUS:
338 sym = '-';
339 break;
340 case SDLK_KP_PLUS:
341 sym = '+';
342 break;
343 case SDLK_KP_1:
344 sym = '1';
345 break;
346 case SDLK_KP_2:
347 sym = '2';
348 break;
349 case SDLK_KP_3:
350 sym = '3';
351 break;
352 case SDLK_KP_4:
353 sym = '4';
354 break;
355 case SDLK_KP_5:
356 sym = '5';
357 break;
358 case SDLK_KP_6:
359 sym = '6';
360 break;
361 case SDLK_KP_7:
362 sym = '7';
363 break;
364 case SDLK_KP_8:
365 sym = '8';
366 break;
367 case SDLK_KP_9:
368 sym = '9';
369 break;
370 case SDLK_KP_0:
371 sym = '0';
372 break;
373 case SDLK_KP_PERIOD:
374 sym = '.';
375 break;
376 default:
377 sym = 0;
378 break;
379 }
380 }
381 else {
382 if (sdl_sub_evt.mod & (SDL_KMOD_LSHIFT | SDL_KMOD_RSHIFT)) {
383 /* Weak US keyboard assumptions. */
384 if (sym >= 'a' && sym <= ('a' + 32)) {
385 sym -= 32;
386 }
387 else {
388 switch (sym) {
389 case '`':
390 sym = '~';
391 break;
392 case '1':
393 sym = '!';
394 break;
395 case '2':
396 sym = '@';
397 break;
398 case '3':
399 sym = '#';
400 break;
401 case '4':
402 sym = '$';
403 break;
404 case '5':
405 sym = '%';
406 break;
407 case '6':
408 sym = '^';
409 break;
410 case '7':
411 sym = '&';
412 break;
413 case '8':
414 sym = '*';
415 break;
416 case '9':
417 sym = '(';
418 break;
419 case '0':
420 sym = ')';
421 break;
422 case '-':
423 sym = '_';
424 break;
425 case '=':
426 sym = '+';
427 break;
428 case '[':
429 sym = '{';
430 break;
431 case ']':
432 sym = '}';
433 break;
434 case '\\':
435 sym = '|';
436 break;
437 case ';':
438 sym = ':';
439 break;
440 case '\'':
441 sym = '"';
442 break;
443 case ',':
444 sym = '<';
445 break;
446 case '.':
447 sym = '>';
448 break;
449 case '/':
450 sym = '?';
451 break;
452 default:
453 break;
454 }
455 }
456 }
457 }
458 return char(sym);
459}
460
465static SDL_Window *SDL_GetWindowFromID_fallback(SDL_WindowID id)
466{
467 SDL_Window *sdl_win = SDL_GetWindowFromID(id);
468 if (sdl_win == nullptr) {
469 sdl_win = SDL_GL_GetCurrentWindow();
470 }
471 return sdl_win;
472}
473
474void GHOST_SystemSDL::processEvent(SDL_Event *sdl_event)
475{
476 std::unique_ptr<GHOST_Event> g_event = nullptr;
477
478 switch (sdl_event->type) {
479 case SDL_EVENT_WINDOW_EXPOSED:
480 case SDL_EVENT_WINDOW_RESIZED:
481 case SDL_EVENT_WINDOW_MOVED:
482 case SDL_EVENT_WINDOW_FOCUS_GAINED:
483 case SDL_EVENT_WINDOW_FOCUS_LOST:
484 case SDL_EVENT_WINDOW_CLOSE_REQUESTED: {
485 const SDL_WindowEvent &sdl_sub_evt = sdl_event->window;
486 const uint64_t event_ms = SDL_NS_TO_MS(sdl_sub_evt.timestamp);
487 GHOST_WindowSDL *window = findGhostWindow(
488 SDL_GetWindowFromID_fallback(sdl_sub_evt.windowID));
489 /* Can be nullptr on close window. */
490
491 switch (sdl_event->type) {
492 case SDL_EVENT_WINDOW_EXPOSED:
493 g_event = std::make_unique<GHOST_Event>(event_ms, GHOST_kEventWindowUpdate, window);
494 break;
495 case SDL_EVENT_WINDOW_RESIZED:
496 g_event = std::make_unique<GHOST_Event>(event_ms, GHOST_kEventWindowSize, window);
497 break;
498 case SDL_EVENT_WINDOW_MOVED:
499 g_event = std::make_unique<GHOST_Event>(event_ms, GHOST_kEventWindowMove, window);
500 break;
501 case SDL_EVENT_WINDOW_FOCUS_GAINED:
502 g_event = std::make_unique<GHOST_Event>(event_ms, GHOST_kEventWindowActivate, window);
503 break;
504 case SDL_EVENT_WINDOW_FOCUS_LOST:
505 g_event = std::make_unique<GHOST_Event>(event_ms, GHOST_kEventWindowDeactivate, window);
506 break;
507 case SDL_EVENT_WINDOW_CLOSE_REQUESTED:
508 g_event = std::make_unique<GHOST_Event>(event_ms, GHOST_kEventWindowClose, window);
509 break;
510 }
511
512 break;
513 }
514
515 case SDL_EVENT_QUIT: {
516 const SDL_QuitEvent &sdl_sub_evt = sdl_event->quit;
517 const uint64_t event_ms = SDL_NS_TO_MS(sdl_sub_evt.timestamp);
518 GHOST_IWindow *window = window_manager_->getActiveWindow();
519 g_event = std::make_unique<GHOST_Event>(event_ms, GHOST_kEventQuitRequest, window);
520 break;
521 }
522
523 case SDL_EVENT_MOUSE_MOTION: {
524 const SDL_MouseMotionEvent &sdl_sub_evt = sdl_event->motion;
525 const uint64_t event_ms = SDL_NS_TO_MS(sdl_sub_evt.timestamp);
526 SDL_Window *sdl_win = SDL_GetWindowFromID_fallback(sdl_sub_evt.windowID);
527 GHOST_WindowSDL *window = findGhostWindow(sdl_win);
528 assert(window != nullptr);
529
530 int x_win, y_win;
531 SDL_GetWindowPosition(sdl_win, &x_win, &y_win);
532
533 int32_t x_root = int32_t(sdl_sub_evt.x) + x_win;
534 int32_t y_root = int32_t(sdl_sub_evt.y) + y_win;
535
536#if 0
537 if (window->getCursorGrabMode() != GHOST_kGrabDisable &&
539 {
540 int32_t x_new = x_root;
541 int32_t y_new = y_root;
542 int32_t x_accum, y_accum;
543 GHOST_Rect bounds;
544
545 /* fallback to window bounds */
546 if (window->getCursorGrabBounds(bounds) == GHOST_kFailure) {
547 window->getClientBounds(bounds);
548 }
549
550 /* Could also clamp to screen bounds wrap with a window outside the view will
551 * fail at the moment. Use offset of 8 in case the window is at screen bounds. */
552 bounds.wrapPoint(x_new, y_new, 8, window->getCursorGrabAxis());
553 window->getCursorGrabAccum(x_accum, y_accum);
554
555 /* Can't use #setCursorPosition because the mouse may have no focus! */
556 if (x_new != x_root || y_new != y_root) {
557 if (1 /* `xme.time > last_warp_` */) {
558 /* when wrapping we don't need to add an event because the
559 * #setCursorPosition call will cause a new event after */
560 SDL_WarpMouseInWindow(sdl_win, x_new - x_win, y_new - y_win); /* wrap */
561 window->setCursorGrabAccum(x_accum + (x_root - x_new), y_accum + (y_root - y_new));
562 // last_warp_ = lastEventTime(xme.time);
563 }
564 else {
565 // setCursorPosition(x_new, y_new); /* wrap but don't accumulate */
566 SDL_WarpMouseInWindow(sdl_win, x_new - x_win, y_new - y_win);
567 }
568
569 g_event = std::make_unique<GHOST_EventCursor>(
570 event_ms, GHOST_kEventCursorMove, window, x_new, y_new, GHOST_TABLET_DATA_NONE);
571 }
572 else {
573 g_event = std::make_unique<GHOST_EventCursor>(event_ms,
575 window,
576 x_root + x_accum,
577 y_root + y_accum,
578 GHOST_TABLET_DATA_NONE);
579 }
580 }
581 else
582#endif
583 {
584 g_event = std::make_unique<GHOST_EventCursor>(
585 event_ms, GHOST_kEventCursorMove, window, x_root, y_root, GHOST_TABLET_DATA_NONE);
586 }
587 break;
588 }
589 case SDL_EVENT_MOUSE_BUTTON_UP:
590 case SDL_EVENT_MOUSE_BUTTON_DOWN: {
591 const SDL_MouseButtonEvent &sdl_sub_evt = sdl_event->button;
592 const uint64_t event_ms = SDL_NS_TO_MS(sdl_sub_evt.timestamp);
595
596 GHOST_WindowSDL *window = findGhostWindow(
597 SDL_GetWindowFromID_fallback(sdl_sub_evt.windowID));
598 assert(window != nullptr);
599
600 /* process rest of normal mouse buttons */
601 if (sdl_sub_evt.button == SDL_BUTTON_LEFT) {
602 gbmask = GHOST_kButtonMaskLeft;
603 }
604 else if (sdl_sub_evt.button == SDL_BUTTON_MIDDLE) {
606 }
607 else if (sdl_sub_evt.button == SDL_BUTTON_RIGHT) {
608 gbmask = GHOST_kButtonMaskRight;
609 /* these buttons are untested! */
610 }
611 else if (sdl_sub_evt.button == SDL_BUTTON_X1) {
613 }
614 else if (sdl_sub_evt.button == SDL_BUTTON_X2) {
616 }
617 else {
618 break;
619 }
620
621 g_event = std::make_unique<GHOST_EventButton>(
622 event_ms, type, window, gbmask, GHOST_TABLET_DATA_NONE);
623 break;
624 }
625 case SDL_EVENT_MOUSE_WHEEL: {
626 const SDL_MouseWheelEvent &sdl_sub_evt = sdl_event->wheel;
627 const uint64_t event_ms = SDL_NS_TO_MS(sdl_sub_evt.timestamp);
628 GHOST_WindowSDL *window = findGhostWindow(
629 SDL_GetWindowFromID_fallback(sdl_sub_evt.windowID));
630 assert(window != nullptr);
631 if (sdl_sub_evt.x != 0.0f) {
632 g_event = std::make_unique<GHOST_EventWheel>(
633 event_ms, window, GHOST_kEventWheelAxisHorizontal, int(sdl_sub_evt.x));
634 }
635 else if (sdl_sub_evt.y != 0.0f) {
636 g_event = std::make_unique<GHOST_EventWheel>(
637 event_ms, window, GHOST_kEventWheelAxisVertical, int(sdl_sub_evt.y));
638 }
639 break;
640 }
641 case SDL_EVENT_KEY_DOWN:
642 case SDL_EVENT_KEY_UP: {
643 const SDL_KeyboardEvent &sdl_sub_evt = sdl_event->key;
644 const uint64_t event_ms = SDL_NS_TO_MS(sdl_sub_evt.timestamp);
645 GHOST_TEventType type = sdl_sub_evt.down ? GHOST_kEventKeyDown : GHOST_kEventKeyUp;
646 const bool is_repeat = sdl_sub_evt.repeat != 0;
647
648 GHOST_WindowSDL *window = findGhostWindow(
649 SDL_GetWindowFromID_fallback(sdl_sub_evt.windowID));
650 assert(window != nullptr);
651
652 GHOST_TKey gkey = convertSDLKey(sdl_sub_evt.scancode);
653 /* NOTE: the `sdl_sub_evt.key` is truncated,
654 * for unicode support ghost has to be modified. */
655
656 /* TODO(@ideasman42): support full unicode, SDL supports this but it needs to be
657 * explicitly enabled via #SDL_StartTextInput which GHOST would have to wrap. */
658 char utf8_buf[sizeof(GHOST_TEventKeyData::utf8_buf)] = {'\0'};
659 if (type == GHOST_kEventKeyDown) {
660 utf8_buf[0] = convert_keyboard_event_to_ascii(sdl_sub_evt);
661 }
662
663 g_event = std::make_unique<GHOST_EventKey>(
664 event_ms, type, window, gkey, is_repeat, utf8_buf);
665 break;
666 }
667 }
668
669 if (g_event) {
670 switch (g_event->getType()) {
672 window_manager_->setActiveWindow(g_event->getWindow());
673 break;
674 }
676 window_manager_->setWindowInactive(g_event->getWindow());
677 break;
678 }
679 default: {
680 break;
681 }
682 }
683 pushEvent(std::move(g_event));
684 }
685}
686
688{
689 int x_win, y_win;
690 SDL_Window *win = SDL_GetMouseFocus();
691 if (win == nullptr) {
692 return GHOST_kFailure;
693 }
694 SDL_GetWindowPosition(win, &x_win, &y_win);
695
696 float xf, yf;
697 SDL_GetMouseState(&xf, &yf);
698 x = int32_t(xf) + x_win;
699 y = int32_t(yf) + y_win;
700
701 return GHOST_kSuccess;
702}
703
705{
706 int x_win, y_win;
707 SDL_Window *win = SDL_GetMouseFocus();
708 if (win == nullptr) {
709 return GHOST_kFailure;
710 }
711 SDL_GetWindowPosition(win, &x_win, &y_win);
712
713 SDL_WarpMouseInWindow(win, x - x_win, y - y_win);
714 return GHOST_kSuccess;
715}
716
717bool GHOST_SystemSDL::generateWindowExposeEvents()
718{
719 std::vector<GHOST_WindowSDL *>::iterator w_start = dirty_windows_.begin();
720 std::vector<GHOST_WindowSDL *>::const_iterator w_end = dirty_windows_.end();
721 bool anyProcessed = false;
722
723 for (; w_start != w_end; ++w_start) {
724 /* The caller doesn't have a time-stamp. */
725 const uint64_t event_ms = getMilliSeconds();
726 auto g_event = std::make_unique<GHOST_Event>(event_ms, GHOST_kEventWindowUpdate, *w_start);
727
728 (*w_start)->validate();
729
730 if (g_event) {
731 // printf("Expose events pushed\n");
732 pushEvent(std::move(g_event));
733 anyProcessed = true;
734 }
735 }
736
737 dirty_windows_.clear();
738 return anyProcessed;
739}
740
741bool GHOST_SystemSDL::processEvents(bool waitForEvent)
742{
743 /* Get all the current events - translate them into
744 * ghost events and call base class #pushEvent() method. */
745
746 bool anyProcessed = false;
747
748 do {
750
751 if (waitForEvent && dirty_windows_.empty() && !SDL_HasEvents(SDL_EVENT_FIRST, SDL_EVENT_LAST))
752 {
753 uint64_t next = timerMgr->nextFireTime();
754
755 if (next == GHOST_kFireTimeNever) {
756 SDL_WaitEventTimeout(nullptr, -1);
757 // SleepTillEvent(display_, -1);
758 }
759 else {
760 int64_t maxSleep = next - getMilliSeconds();
761
762 if (maxSleep >= 0) {
763 SDL_WaitEventTimeout(nullptr, next - getMilliSeconds());
764 // SleepTillEvent(display_, next - getMilliSeconds()); /* X11. */
765 }
766 }
767 }
768
769 if (timerMgr->fireTimers(getMilliSeconds())) {
770 anyProcessed = true;
771 }
772
773 SDL_Event sdl_event;
774 while (SDL_PollEvent(&sdl_event)) {
775 processEvent(&sdl_event);
776 anyProcessed = true;
777 }
778
779 if (generateWindowExposeEvents()) {
780 anyProcessed = true;
781 }
782 } while (waitForEvent && !anyProcessed);
783
784 return anyProcessed;
785}
786
787GHOST_WindowSDL *GHOST_SystemSDL::findGhostWindow(SDL_Window *sdl_win)
788{
789 if (sdl_win == nullptr) {
790 return nullptr;
791 }
792 /* It is not entirely safe to do this as the back-pointer may point
793 * to a window that has recently been removed.
794 * We should always check the window manager's list of windows
795 * and only process events on these windows. */
796
797 const std::vector<GHOST_IWindow *> &win_vec = window_manager_->getWindows();
798
799 std::vector<GHOST_IWindow *>::const_iterator win_it = win_vec.begin();
800 std::vector<GHOST_IWindow *>::const_iterator win_end = win_vec.end();
801
802 for (; win_it != win_end; ++win_it) {
803 GHOST_WindowSDL *window = static_cast<GHOST_WindowSDL *>(*win_it);
804 if (window->getSDLWindow() == sdl_win) {
805 return window;
806 }
807 }
808 return nullptr;
809}
810
812{
813 GHOST_ASSERT((bad_wind != nullptr), "addDirtyWindow() nullptr ptr trapped (window)");
814
815 dirty_windows_.push_back(bad_wind);
816}
817
819{
820 SDL_MouseButtonFlags state = SDL_GetMouseState(nullptr, nullptr);
821 buttons.set(GHOST_kButtonMaskLeft, (state & SDL_BUTTON_LMASK) != 0);
822 buttons.set(GHOST_kButtonMaskMiddle, (state & SDL_BUTTON_MMASK) != 0);
823 buttons.set(GHOST_kButtonMaskRight, (state & SDL_BUTTON_RMASK) != 0);
824
825 return GHOST_kSuccess;
826}
827
829{
832 /* NOTE: order the following flags as they they're declared in the source. */
833 ~(
834 /* This SDL back-end has not yet implemented image copy/paste. */
836 /* This SDL back-end has not yet implemented color sampling the desktop. */
838 /* No support yet for IME input methods. */
840 /* No support for window decoration styles. */
842 /* No support for precisely placing windows on multiple monitors. */
844 /* No support for a Hyper modifier key. */
846 /* No support yet for RGBA mouse cursors. */
848 /* No support yet for dynamic cursor generation. */
850 /* No support for window path meta-data. */
852}
853
854char *GHOST_SystemSDL::getClipboard(bool selection) const
855{
856 /* The clipboard must be freed with `SDL_free`, copy for the return value. */
857 char *sdl_text = selection ? SDL_GetPrimarySelectionText() : SDL_GetClipboardText();
858 if (sdl_text == nullptr) {
859 return nullptr;
860 }
861 char *result = strdup(sdl_text);
862 SDL_free(sdl_text);
863 return result;
864}
865
866void GHOST_SystemSDL::putClipboard(const char *buffer, bool selection) const
867{
868 if (selection) {
869 SDL_SetPrimarySelectionText(buffer);
870 }
871 else {
872 SDL_SetClipboardText(buffer);
873 }
874}
875
877{
878 return SDL_GetTicks();
879}
#define GHOST_OPENGL_SDL_RESET_NOTIFICATION_STRATEGY
#define GHOST_OPENGL_SDL_CONTEXT_FLAGS
#define GHOST_ASSERT(x, info)
static char convert_keyboard_event_to_ascii(const SDL_KeyboardEvent &sdl_sub_evt)
static GHOST_TKey convertSDLKey(SDL_Scancode key)
#define GXMAP(k, x, y)
static SDL_Window * SDL_GetWindowFromID_fallback(SDL_WindowID id)
#define pushEvent
@ GHOST_kEventWheelAxisVertical
@ GHOST_kEventWheelAxisHorizontal
GHOST_TWindowState
@ GHOST_kWindowStateFullScreen
GHOST_TEventType
@ GHOST_kEventWindowClose
@ GHOST_kEventWindowMove
@ GHOST_kEventWindowSize
@ GHOST_kEventCursorMove
@ GHOST_kEventButtonUp
@ GHOST_kEventWindowActivate
@ GHOST_kEventWindowUpdate
@ GHOST_kEventWindowDeactivate
@ GHOST_kEventButtonDown
@ GHOST_kEventKeyDown
@ GHOST_kEventKeyUp
@ GHOST_kEventQuitRequest
GHOST_TCapabilityFlag
@ GHOST_kCapabilityKeyboardHyperKey
@ GHOST_kCapabilityCursorRGBA
@ GHOST_kCapabilityInputIME
@ GHOST_kCapabilityCursorGenerator
@ GHOST_kCapabilityWindowPath
@ GHOST_kCapabilityMultiMonitorPlacement
@ GHOST_kCapabilityClipboardImage
@ GHOST_kCapabilityWindowDecorationStyles
@ GHOST_kCapabilityDesktopSample
#define GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS(gpu_settings)
#define GHOST_CAPABILITY_FLAG_ALL
GHOST_TKey
@ GHOST_kKeyLeftOS
@ GHOST_kKeyInsert
@ GHOST_kKeySemicolon
@ GHOST_kKeyMediaPlay
@ GHOST_kKeyQuote
@ GHOST_kKeyNumpad3
@ GHOST_kKeyAccentGrave
@ GHOST_kKeyNumpad1
@ GHOST_kKeyLeftAlt
@ GHOST_kKeyRightShift
@ GHOST_kKeyNumLock
@ GHOST_kKeyEnter
@ GHOST_kKeyNumpadSlash
@ GHOST_kKeyRightArrow
@ GHOST_kKeyF13
@ GHOST_kKeyNumpad4
@ GHOST_kKeyPause
@ GHOST_kKeyCapsLock
@ GHOST_kKeyApp
@ GHOST_kKeyMinus
@ GHOST_kKeyMediaStop
@ GHOST_kKeyBackSpace
@ GHOST_kKey0
@ GHOST_kKeyDownPage
@ GHOST_kKeyGrLess
@ GHOST_kKeyDownArrow
@ GHOST_kKeyRightOS
@ GHOST_kKeyNumpadPeriod
@ GHOST_kKeyF1
@ GHOST_kKeyNumpadAsterisk
@ GHOST_kKeyPrintScreen
@ GHOST_kKeyLeftControl
@ GHOST_kKeyLeftBracket
@ GHOST_kKey1
@ GHOST_kKeyTab
@ GHOST_kKeyComma
@ GHOST_kKeyRightBracket
@ GHOST_kKeyBackslash
@ GHOST_kKeyNumpad2
@ GHOST_kKeyRightAlt
@ GHOST_kKeyPeriod
@ GHOST_kKeyNumpadPlus
@ GHOST_kKeyUpPage
@ GHOST_kKeyNumpad5
@ GHOST_kKeyLeftArrow
@ GHOST_kKeyEqual
@ GHOST_kKeyHome
@ GHOST_kKeyNumpad6
@ GHOST_kKeyNumpad8
@ GHOST_kKeyNumpad9
@ GHOST_kKeyEnd
@ GHOST_kKeyUpArrow
@ GHOST_kKeyDelete
@ GHOST_kKeyNumpad0
@ GHOST_kKeyA
@ GHOST_kKeyMediaFirst
@ GHOST_kKeyNumpad7
@ GHOST_kKeyRightControl
@ GHOST_kKeyEsc
@ GHOST_kKeyUnknown
@ GHOST_kKeyScrollLock
@ GHOST_kKeySlash
@ GHOST_kKeyNumpadEnter
@ GHOST_kKeyNumpadMinus
@ GHOST_kKeyLeftShift
@ GHOST_kKeyMediaLast
@ GHOST_kKeySpace
@ GHOST_kModifierKeyRightControl
@ GHOST_kModifierKeyLeftControl
@ GHOST_kModifierKeyRightAlt
@ GHOST_kModifierKeyRightShift
@ GHOST_kModifierKeyLeftAlt
@ GHOST_kModifierKeyLeftShift
@ GHOST_kModifierKeyLeftOS
@ GHOST_kModifierKeyRightOS
GHOST_TSuccess
@ GHOST_kFailure
@ GHOST_kSuccess
@ GHOST_kFireTimeNever
@ GHOST_kGrabDisable
@ GHOST_kGrabNormal
#define GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS_OFFSCREEN(gpu_settings)
GHOST_TButton
@ GHOST_kButtonMaskRight
@ GHOST_kButtonMaskButton4
@ GHOST_kButtonMaskLeft
@ GHOST_kButtonMaskButton5
@ GHOST_kButtonMaskMiddle
long long int int64_t
unsigned long long int uint64_t
GHOST_ContextSDL(const GHOST_ContextParams &context_params, SDL_Window *window, int contextProfileMask, int contextMajorVersion, int contextMinorVersion, int contextFlags, int contextResetNotificationStrategy)
GHOST_ContextVK(const GHOST_ContextParams &context_params, GHOST_TVulkanPlatformType platform, Window window, Display *display, wl_surface *wayland_surface, wl_display *wayland_display, const GHOST_ContextVK_WindowInfo *wayland_window_info, int contextMajorVersion, int contextMinorVersion, const GHOST_GPUDevice &preferred_device, const GHOST_WindowHDRInfo *hdr_info_=nullptr)
virtual GHOST_TSuccess init()=0
virtual void wrapPoint(int32_t &x, int32_t &y, int32_t ofs, GHOST_TAxisFlag axis)
GHOST_TSuccess getCursorPosition(int32_t &x, int32_t &y) const override
GHOST_TSuccess setCursorPosition(int32_t x, int32_t y) override
char * getClipboard(bool selection) const override
void getMainDisplayDimensions(uint32_t &width, uint32_t &height) const override
GHOST_IContext * createOffscreenContext(GHOST_GPUSettings gpu_settings) override
GHOST_TCapabilityFlag getCapabilities() const override
void addDirtyWindow(GHOST_WindowSDL *bad_wind)
void getAllDisplayDimensions(uint32_t &width, uint32_t &height) const override
uint8_t getNumDisplays() const override
GHOST_TSuccess disposeContext(GHOST_IContext *context) override
void putClipboard(const char *buffer, bool selection) const override
GHOST_TSuccess getButtons(GHOST_Buttons &buttons) const override
GHOST_TSuccess getModifierKeys(GHOST_ModifierKeys &keys) const override
uint64_t getMilliSeconds() const override
bool processEvents(bool waitForEvent) override
GHOST_WindowManager * window_manager_
GHOST_TSuccess init() override
GHOST_TimerManager * getTimerManager() const
GHOST_TSuccess pushEvent(std::unique_ptr< const GHOST_IEvent > event)
bool fireTimers(uint64_t time)
GHOST_TSuccess addWindow(GHOST_IWindow *window)
const std::vector< GHOST_IWindow * > & getWindows() const
GHOST_IWindow * getActiveWindow() const
GHOST_TSuccess setActiveWindow(GHOST_IWindow *window)
void setWindowInactive(const GHOST_IWindow *window)
GHOST_WindowSDL(GHOST_SystemSDL *system, const char *title, int32_t left, int32_t top, uint32_t width, uint32_t height, GHOST_TWindowState state, GHOST_TDrawingContextType type, const GHOST_ContextParams &context_params, const GHOST_GPUDevice &preferred_device, const bool exclusive=false, const GHOST_IWindow *parent_window=nullptr)
SDL_Window * getSDLWindow()
void getClientBounds(GHOST_Rect &bounds) const override
bool getValid() const override
virtual GHOST_TSuccess getCursorGrabBounds(GHOST_Rect &bounds) const
void setCursorGrabAccum(int32_t x, int32_t y)
GHOST_TAxisFlag getCursorGrabAxis() const
GHOST_TGrabCursorMode getCursorGrabMode() const
void getCursorGrabAccum(int32_t &x, int32_t &y) const
#define printf
#define assert(assertion)
VecBase< float, D > constexpr mod(VecOp< float, D >, VecOp< float, D >) RET
const int state
void set(GHOST_TButton mask, bool down)
GHOST_TDrawingContextType context_type
GHOST_GPUDevice preferred_device
void set(GHOST_TModifierKey mask, bool down)