ad3laid3/rexglue-skate3
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1
rexglue-skate3/src/ui/window_sdl.cpp

816 lines
25 KiB
C++
Raw Blame History

#include <rex/ui/window_sdl.h>
#include <algorithm>
#include <cmath>
#include <cstdint>
#include <string>
#include <unordered_map>
#include <rex/assert.h>
#include <rex/cvar.h>
#include <rex/graphics/flags.h>
#include <rex/graphics/video_mode_util.h>
#include <rex/logging.h>
#include <rex/platform.h>
#include <rex/ui/surface_sdl.h>
#include <rex/ui/virtual_key.h>
#include <SDL3/SDL_hints.h>
#include <SDL3/SDL_keyboard.h>
#include <SDL3/SDL_mouse.h>
#include <SDL3/SDL_scancode.h>
#include <SDL3/SDL_timer.h>
namespace {
constexpr uint32_t kDefaultDpi = 96;
constexpr uint32_t kDefaultCursorAutoHideMilliseconds = 1000;
constexpr uint32_t kCursorAutoHideEvent = SDL_EVENT_USER + 1;
// Enabled on macOS: without a high-DPI backing the Metal drawable stays at
// logical point size and CoreAnimation upscales the whole window to the Retina
// panel, blurring everything (the settings UI most visibly). Internal 3D render
// cost is governed separately by the resolution-scale cvars, so this only makes
// the final composite and UI render at native panel resolution.
REXCVAR_DEFINE_BOOL(sdl_high_pixel_density, true, "UI/SDL",
"Request high-DPI backing pixels for SDL windows")
.lifecycle(rex::cvar::Lifecycle::kRequiresRestart);
std::unordered_map<SDL_WindowID, rex::ui::SDLWindow*>& WindowMap() {
static std::unordered_map<SDL_WindowID, rex::ui::SDLWindow*> windows;
return windows;
}
Uint32 SDLCALL AutoHideCursorTimerCallback(void* userdata, SDL_TimerID timer_id,
Uint32 interval) {
(void)interval;
SDL_Event event = {};
event.type = kCursorAutoHideEvent;
event.user.data1 = userdata;
event.user.data2 = reinterpret_cast<void*>(uintptr_t(timer_id));
SDL_PushEvent(&event);
return 0;
}
uint32_t ResolveWindowWidth(uint32_t requested_width) {
if (REXCVAR_GET(window_width) > 0) {
return uint32_t(REXCVAR_GET(window_width));
}
if (!rex::cvar::HasNonDefaultValue("window_width")) {
if (rex::cvar::HasNonDefaultValue("video_mode_width") && REXCVAR_GET(video_mode_width) > 0) {
return uint32_t(std::clamp(REXCVAR_GET(video_mode_width), 1, 8192));
}
int32_t preset_width = 0;
int32_t preset_height = 0;
if (rex::graphics::video_mode_util::TryGetResolutionPresetFromCVar(preset_width,
preset_height)) {
return uint32_t(std::clamp(preset_width, 1, 8192));
}
}
return requested_width;
}
uint32_t ResolveWindowHeight(uint32_t requested_height) {
if (REXCVAR_GET(window_height) > 0) {
return uint32_t(REXCVAR_GET(window_height));
}
if (!rex::cvar::HasNonDefaultValue("window_height")) {
if (rex::cvar::HasNonDefaultValue("video_mode_height") && REXCVAR_GET(video_mode_height) > 0) {
return uint32_t(std::clamp(REXCVAR_GET(video_mode_height), 1, 8192));
}
int32_t preset_width = 0;
int32_t preset_height = 0;
if (rex::graphics::video_mode_util::TryGetResolutionPresetFromCVar(preset_width,
preset_height)) {
return uint32_t(std::clamp(preset_height, 1, 8192));
}
}
return requested_height;
}
using rex::ui::VirtualKey;
VirtualKey TranslateSDLScancode(SDL_Scancode scancode) {
switch (scancode) {
case SDL_SCANCODE_F1:
return VirtualKey::kF1;
case SDL_SCANCODE_F2:
return VirtualKey::kF2;
case SDL_SCANCODE_F3:
return VirtualKey::kF3;
case SDL_SCANCODE_F4:
return VirtualKey::kF4;
case SDL_SCANCODE_F5:
return VirtualKey::kF5;
case SDL_SCANCODE_F6:
return VirtualKey::kF6;
case SDL_SCANCODE_F7:
return VirtualKey::kF7;
case SDL_SCANCODE_F8:
return VirtualKey::kF8;
case SDL_SCANCODE_F9:
return VirtualKey::kF9;
case SDL_SCANCODE_F10:
return VirtualKey::kF10;
case SDL_SCANCODE_F11:
return VirtualKey::kF11;
case SDL_SCANCODE_F12:
return VirtualKey::kF12;
case SDL_SCANCODE_ESCAPE:
return VirtualKey::kEscape;
case SDL_SCANCODE_RETURN:
case SDL_SCANCODE_KP_ENTER:
return VirtualKey::kReturn;
case SDL_SCANCODE_SPACE:
return VirtualKey::kSpace;
case SDL_SCANCODE_TAB:
return VirtualKey::kTab;
case SDL_SCANCODE_BACKSPACE:
return VirtualKey::kBack;
case SDL_SCANCODE_DELETE:
return VirtualKey::kDelete;
case SDL_SCANCODE_INSERT:
return VirtualKey::kInsert;
case SDL_SCANCODE_HOME:
return VirtualKey::kHome;
case SDL_SCANCODE_END:
return VirtualKey::kEnd;
case SDL_SCANCODE_PAGEUP:
return VirtualKey::kPrior;
case SDL_SCANCODE_PAGEDOWN:
return VirtualKey::kNext;
case SDL_SCANCODE_LEFT:
return VirtualKey::kLeft;
case SDL_SCANCODE_RIGHT:
return VirtualKey::kRight;
case SDL_SCANCODE_UP:
return VirtualKey::kUp;
case SDL_SCANCODE_DOWN:
return VirtualKey::kDown;
case SDL_SCANCODE_LSHIFT:
return VirtualKey::kLShift;
case SDL_SCANCODE_RSHIFT:
return VirtualKey::kRShift;
case SDL_SCANCODE_LCTRL:
return VirtualKey::kLControl;
case SDL_SCANCODE_RCTRL:
return VirtualKey::kRControl;
case SDL_SCANCODE_LALT:
return VirtualKey::kLMenu;
case SDL_SCANCODE_RALT:
return VirtualKey::kRMenu;
case SDL_SCANCODE_LGUI:
return VirtualKey::kLWin;
case SDL_SCANCODE_RGUI:
return VirtualKey::kRWin;
case SDL_SCANCODE_APPLICATION:
return VirtualKey::kApps;
case SDL_SCANCODE_CAPSLOCK:
return VirtualKey::kCapital;
case SDL_SCANCODE_NUMLOCKCLEAR:
return VirtualKey::kNumLock;
case SDL_SCANCODE_SCROLLLOCK:
return VirtualKey::kScroll;
case SDL_SCANCODE_PRINTSCREEN:
return VirtualKey::kSnapshot;
case SDL_SCANCODE_PAUSE:
return VirtualKey::kPause;
case SDL_SCANCODE_0:
return VirtualKey::k0;
case SDL_SCANCODE_1:
return VirtualKey::k1;
case SDL_SCANCODE_2:
return VirtualKey::k2;
case SDL_SCANCODE_3:
return VirtualKey::k3;
case SDL_SCANCODE_4:
return VirtualKey::k4;
case SDL_SCANCODE_5:
return VirtualKey::k5;
case SDL_SCANCODE_6:
return VirtualKey::k6;
case SDL_SCANCODE_7:
return VirtualKey::k7;
case SDL_SCANCODE_8:
return VirtualKey::k8;
case SDL_SCANCODE_9:
return VirtualKey::k9;
case SDL_SCANCODE_A:
return VirtualKey::kA;
case SDL_SCANCODE_B:
return VirtualKey::kB;
case SDL_SCANCODE_C:
return VirtualKey::kC;
case SDL_SCANCODE_D:
return VirtualKey::kD;
case SDL_SCANCODE_E:
return VirtualKey::kE;
case SDL_SCANCODE_F:
return VirtualKey::kF;
case SDL_SCANCODE_G:
return VirtualKey::kG;
case SDL_SCANCODE_H:
return VirtualKey::kH;
case SDL_SCANCODE_I:
return VirtualKey::kI;
case SDL_SCANCODE_J:
return VirtualKey::kJ;
case SDL_SCANCODE_K:
return VirtualKey::kK;
case SDL_SCANCODE_L:
return VirtualKey::kL;
case SDL_SCANCODE_M:
return VirtualKey::kM;
case SDL_SCANCODE_N:
return VirtualKey::kN;
case SDL_SCANCODE_O:
return VirtualKey::kO;
case SDL_SCANCODE_P:
return VirtualKey::kP;
case SDL_SCANCODE_Q:
return VirtualKey::kQ;
case SDL_SCANCODE_R:
return VirtualKey::kR;
case SDL_SCANCODE_S:
return VirtualKey::kS;
case SDL_SCANCODE_T:
return VirtualKey::kT;
case SDL_SCANCODE_U:
return VirtualKey::kU;
case SDL_SCANCODE_V:
return VirtualKey::kV;
case SDL_SCANCODE_W:
return VirtualKey::kW;
case SDL_SCANCODE_X:
return VirtualKey::kX;
case SDL_SCANCODE_Y:
return VirtualKey::kY;
case SDL_SCANCODE_Z:
return VirtualKey::kZ;
case SDL_SCANCODE_KP_0:
return VirtualKey::kNumpad0;
case SDL_SCANCODE_KP_1:
return VirtualKey::kNumpad1;
case SDL_SCANCODE_KP_2:
return VirtualKey::kNumpad2;
case SDL_SCANCODE_KP_3:
return VirtualKey::kNumpad3;
case SDL_SCANCODE_KP_4:
return VirtualKey::kNumpad4;
case SDL_SCANCODE_KP_5:
return VirtualKey::kNumpad5;
case SDL_SCANCODE_KP_6:
return VirtualKey::kNumpad6;
case SDL_SCANCODE_KP_7:
return VirtualKey::kNumpad7;
case SDL_SCANCODE_KP_8:
return VirtualKey::kNumpad8;
case SDL_SCANCODE_KP_9:
return VirtualKey::kNumpad9;
case SDL_SCANCODE_KP_PLUS:
return VirtualKey::kAdd;
case SDL_SCANCODE_KP_MINUS:
return VirtualKey::kSubtract;
case SDL_SCANCODE_KP_MULTIPLY:
return VirtualKey::kMultiply;
case SDL_SCANCODE_KP_DIVIDE:
return VirtualKey::kDivide;
case SDL_SCANCODE_KP_DECIMAL:
return VirtualKey::kDecimal;
case SDL_SCANCODE_GRAVE:
return VirtualKey::kOem3;
case SDL_SCANCODE_MINUS:
return VirtualKey::kOemMinus;
case SDL_SCANCODE_EQUALS:
return VirtualKey::kOemPlus;
case SDL_SCANCODE_COMMA:
return VirtualKey::kOemComma;
case SDL_SCANCODE_PERIOD:
return VirtualKey::kOemPeriod;
case SDL_SCANCODE_SEMICOLON:
return VirtualKey::kOem1;
case SDL_SCANCODE_SLASH:
return VirtualKey::kOem2;
case SDL_SCANCODE_BACKSLASH:
return VirtualKey::kOem5;
case SDL_SCANCODE_LEFTBRACKET:
return VirtualKey::kOem4;
case SDL_SCANCODE_RIGHTBRACKET:
return VirtualKey::kOem6;
case SDL_SCANCODE_APOSTROPHE:
return VirtualKey::kOem7;
default:
return VirtualKey::kNone;
}
}
rex::ui::MouseEvent::Button TranslateMouseButton(uint8_t button) {
switch (button) {
case SDL_BUTTON_LEFT:
return rex::ui::MouseEvent::Button::kLeft;
case SDL_BUTTON_RIGHT:
return rex::ui::MouseEvent::Button::kRight;
case SDL_BUTTON_MIDDLE:
return rex::ui::MouseEvent::Button::kMiddle;
case SDL_BUTTON_X1:
return rex::ui::MouseEvent::Button::kX1;
case SDL_BUTTON_X2:
return rex::ui::MouseEvent::Button::kX2;
default:
return rex::ui::MouseEvent::Button::kNone;
}
}
} // namespace
namespace rex {
namespace ui {
std::unique_ptr<Window> Window::Create(WindowedAppContext& app_context,
const std::string_view title, uint32_t desired_logical_width,
uint32_t desired_logical_height) {
desired_logical_width = ResolveWindowWidth(desired_logical_width);
desired_logical_height = ResolveWindowHeight(desired_logical_height);
return std::make_unique<SDLWindow>(app_context, title, desired_logical_width,
desired_logical_height);
}
SDLWindow::SDLWindow(WindowedAppContext& app_context, const std::string_view title,
uint32_t desired_logical_width, uint32_t desired_logical_height)
: Window(app_context, title, desired_logical_width, desired_logical_height) {}
SDLWindow::~SDLWindow() {
EnterDestructor();
RemoveCursorAutoHideTimer();
if (window_) {
WindowMap().erase(SDL_GetWindowID(window_));
}
if (metal_view_) {
SDL_Metal_DestroyView(metal_view_);
metal_view_ = nullptr;
metal_layer_ = nullptr;
}
if (window_) {
SDL_DestroyWindow(window_);
window_ = nullptr;
}
}
void SDLWindow::HandleSDLEvent(const SDL_Event& event) {
SDL_WindowID window_id = 0;
switch (event.type) {
case SDL_EVENT_WINDOW_SHOWN:
case SDL_EVENT_WINDOW_HIDDEN:
case SDL_EVENT_WINDOW_EXPOSED:
case SDL_EVENT_WINDOW_MOVED:
case SDL_EVENT_WINDOW_RESIZED:
case SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED:
case SDL_EVENT_WINDOW_METAL_VIEW_RESIZED:
case SDL_EVENT_WINDOW_FOCUS_GAINED:
case SDL_EVENT_WINDOW_FOCUS_LOST:
case SDL_EVENT_WINDOW_CLOSE_REQUESTED:
case SDL_EVENT_WINDOW_DISPLAY_SCALE_CHANGED:
case SDL_EVENT_WINDOW_ENTER_FULLSCREEN:
case SDL_EVENT_WINDOW_LEAVE_FULLSCREEN:
window_id = event.window.windowID;
break;
case kCursorAutoHideEvent:
window_id = SDL_WindowID(reinterpret_cast<uintptr_t>(event.user.data1));
break;
case SDL_EVENT_KEY_DOWN:
case SDL_EVENT_KEY_UP:
window_id = event.key.windowID;
break;
case SDL_EVENT_TEXT_INPUT:
window_id = event.text.windowID;
break;
case SDL_EVENT_MOUSE_BUTTON_DOWN:
case SDL_EVENT_MOUSE_BUTTON_UP:
window_id = event.button.windowID;
break;
case SDL_EVENT_MOUSE_MOTION:
window_id = event.motion.windowID;
break;
case SDL_EVENT_MOUSE_WHEEL:
window_id = event.wheel.windowID;
break;
default:
return;
}
auto it = WindowMap().find(window_id);
if (it != WindowMap().end()) {
it->second->HandleEvent(event);
}
}
uint32_t SDLWindow::GetLatestDpiImpl() const { return dpi_ ? dpi_ : kDefaultDpi; }
bool SDLWindow::OpenImpl() {
SDL_SetHint(SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH, "1");
SDL_WindowFlags flags = SDL_WINDOW_RESIZABLE;
if (REXCVAR_GET(sdl_high_pixel_density)) {
flags |= SDL_WINDOW_HIGH_PIXEL_DENSITY;
}
if (IsFullscreen()) {
flags |= SDL_WINDOW_FULLSCREEN;
}
window_ = SDL_CreateWindow(GetTitle().c_str(), int(GetDesiredLogicalWidth()),
int(GetDesiredLogicalHeight()), flags);
if (!window_) {
REXLOG_ERROR("SDLWindow: Failed to create window: {}", SDL_GetError());
return false;
}
WindowMap().emplace(SDL_GetWindowID(window_), this);
metal_view_ = SDL_Metal_CreateView(window_);
if (!metal_view_) {
REXLOG_ERROR("SDLWindow: Failed to create Metal view: {}", SDL_GetError());
WindowMap().erase(SDL_GetWindowID(window_));
SDL_DestroyWindow(window_);
window_ = nullptr;
return false;
}
metal_layer_ = SDL_Metal_GetLayer(metal_view_);
if (!metal_layer_) {
REXLOG_ERROR("SDLWindow: Failed to get Metal layer: {}", SDL_GetError());
SDL_Metal_DestroyView(metal_view_);
metal_view_ = nullptr;
WindowMap().erase(SDL_GetWindowID(window_));
SDL_DestroyWindow(window_);
window_ = nullptr;
return false;
}
dpi_ = QueryDpi();
SDL_ShowWindow(window_);
if (IsMouseCaptureRequested()) {
SDL_SetWindowMouseGrab(window_, true);
}
ApplyNewCursorVisibility(CursorVisibility::kVisible);
WindowDestructionReceiver destruction_receiver(this);
HandleSizeUpdate(destruction_receiver);
if (destruction_receiver.IsWindowDestroyedOrClosed()) {
return true;
}
OnFocusUpdate((SDL_GetWindowFlags(window_) & SDL_WINDOW_INPUT_FOCUS) != 0, destruction_receiver);
return true;
}
void SDLWindow::RequestCloseImpl() {
WindowDestructionReceiver destruction_receiver(this);
OnBeforeClose(destruction_receiver);
if (!destruction_receiver.IsWindowDestroyed()) {
RemoveCursorAutoHideTimer();
if (metal_view_) {
SDL_Metal_DestroyView(metal_view_);
metal_view_ = nullptr;
metal_layer_ = nullptr;
}
if (window_) {
WindowMap().erase(SDL_GetWindowID(window_));
SDL_DestroyWindow(window_);
window_ = nullptr;
}
OnAfterClose();
}
}
void SDLWindow::ApplyNewFullscreen() {
if (window_) {
SDL_SetWindowFullscreen(window_, IsFullscreen());
}
}
void SDLWindow::ApplyNewTitle() {
if (window_) {
SDL_SetWindowTitle(window_, GetTitle().c_str());
}
}
void SDLWindow::ApplyNewMouseCapture() {
if (window_) {
SDL_SetWindowMouseGrab(window_, true);
}
}
void SDLWindow::ApplyNewMouseRelease() {
if (window_) {
SDL_SetWindowMouseGrab(window_, false);
}
}
void SDLWindow::ApplyNewCursorVisibility(CursorVisibility old_cursor_visibility) {
(void)old_cursor_visibility;
RemoveCursorAutoHideTimer();
switch (GetCursorVisibility()) {
case CursorVisibility::kVisible:
cursor_currently_auto_hidden_ = false;
SDL_ShowCursor();
break;
case CursorVisibility::kAutoHidden:
cursor_currently_auto_hidden_ = true;
SDL_HideCursor();
break;
case CursorVisibility::kHidden:
cursor_currently_auto_hidden_ = true;
SDL_HideCursor();
break;
}
}
void SDLWindow::FocusImpl() {
if (window_) {
SDL_RaiseWindow(window_);
}
}
std::unique_ptr<Surface> SDLWindow::CreateSurfaceImpl(Surface::TypeFlags allowed_types) {
if (!(allowed_types & Surface::kTypeFlag_SDLMetalView)) {
return nullptr;
}
return std::make_unique<SDLMetalViewSurface>(window_, metal_view_, metal_layer_);
}
void SDLWindow::RequestPaintImpl() {
bool expected = false;
if (!paint_event_queued_.compare_exchange_strong(expected, true, std::memory_order_acq_rel,
std::memory_order_acquire)) {
return;
}
SDL_Event event = {};
event.type = SDL_EVENT_WINDOW_EXPOSED;
event.window.windowID = SDL_GetWindowID(window_);
if (!SDL_PushEvent(&event)) {
paint_event_queued_.store(false, std::memory_order_release);
}
}
void SDLWindow::HandleEvent(const SDL_Event& event) {
WindowDestructionReceiver destruction_receiver(this);
switch (event.type) {
case SDL_EVENT_WINDOW_EXPOSED:
paint_event_queued_.store(false, std::memory_order_release);
OnPaint();
break;
case SDL_EVENT_WINDOW_RESIZED:
case SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED:
case SDL_EVENT_WINDOW_METAL_VIEW_RESIZED:
case SDL_EVENT_WINDOW_DISPLAY_SCALE_CHANGED:
HandleSizeUpdate(destruction_receiver);
break;
case SDL_EVENT_WINDOW_FOCUS_GAINED:
OnFocusUpdate(true, destruction_receiver);
break;
case SDL_EVENT_WINDOW_FOCUS_LOST:
OnFocusUpdate(false, destruction_receiver);
break;
case SDL_EVENT_WINDOW_ENTER_FULLSCREEN:
OnDesiredFullscreenUpdate(true);
break;
case SDL_EVENT_WINDOW_LEAVE_FULLSCREEN:
OnDesiredFullscreenUpdate(false);
break;
case SDL_EVENT_WINDOW_CLOSE_REQUESTED:
#if REX_PLATFORM_MAC
app_context().QuitFromUIThread();
#else
RequestCloseImpl();
app_context().RequestDeferredQuit();
#endif
break;
case kCursorAutoHideEvent:
if (GetCursorVisibility() == CursorVisibility::kAutoHidden &&
SDL_TimerID(reinterpret_cast<uintptr_t>(event.user.data2)) == cursor_auto_hide_timer_) {
cursor_auto_hide_timer_ = 0;
cursor_currently_auto_hidden_ = true;
SDL_HideCursor();
}
break;
case SDL_EVENT_KEY_DOWN:
HandleKey(event.key, true, destruction_receiver);
break;
case SDL_EVENT_KEY_UP:
HandleKey(event.key, false, destruction_receiver);
break;
case SDL_EVENT_TEXT_INPUT:
HandleTextInput(event.text, destruction_receiver);
break;
case SDL_EVENT_MOUSE_BUTTON_DOWN:
HandleMouseButton(event.button, true, destruction_receiver);
break;
case SDL_EVENT_MOUSE_BUTTON_UP:
HandleMouseButton(event.button, false, destruction_receiver);
break;
case SDL_EVENT_MOUSE_MOTION:
HandleMouseMotion(event.motion, destruction_receiver);
break;
case SDL_EVENT_MOUSE_WHEEL:
HandleMouseWheel(event.wheel, destruction_receiver);
break;
default:
break;
}
}
void SDLWindow::HandleSizeUpdate(WindowDestructionReceiver& destruction_receiver) {
dpi_ = QueryDpi();
int width = 0;
int height = 0;
if (!SDL_GetWindowSizeInPixels(window_, &width, &height)) {
return;
}
if (!IsFullscreen()) {
int logical_width = 0;
int logical_height = 0;
if (SDL_GetWindowSize(window_, &logical_width, &logical_height)) {
OnDesiredLogicalSizeUpdate(uint32_t(std::max(logical_width, 0)),
uint32_t(std::max(logical_height, 0)));
}
}
OnActualSizeUpdate(uint32_t(std::max(width, 0)), uint32_t(std::max(height, 0)),
destruction_receiver);
}
void SDLWindow::HandleKey(const SDL_KeyboardEvent& event, bool down,
WindowDestructionReceiver& destruction_receiver) {
SDL_Keymod mod = SDL_GetModState();
KeyEvent e(this, TranslateSDLScancode(event.scancode), event.repeat ? 2 : 1, !down,
(mod & SDL_KMOD_SHIFT) != 0, (mod & SDL_KMOD_CTRL) != 0,
(mod & SDL_KMOD_ALT) != 0, (mod & SDL_KMOD_GUI) != 0);
if (down) {
OnKeyDown(e, destruction_receiver);
} else {
OnKeyUp(e, destruction_receiver);
}
}
void SDLWindow::HandleMouseButton(const SDL_MouseButtonEvent& event, bool down,
WindowDestructionReceiver& destruction_receiver) {
RevealAutoHiddenCursor();
int32_t physical_x = 0;
int32_t physical_y = 0;
WindowPointToPhysical(event.x, event.y, physical_x, physical_y);
MouseEvent e(this, TranslateMouseButton(event.button), physical_x, physical_y);
if (down) {
OnMouseDown(e, destruction_receiver);
} else {
OnMouseUp(e, destruction_receiver);
}
}
void SDLWindow::HandleMouseMotion(const SDL_MouseMotionEvent& event,
WindowDestructionReceiver& destruction_receiver) {
RevealAutoHiddenCursor();
int32_t physical_x = 0;
int32_t physical_y = 0;
WindowPointToPhysical(event.x, event.y, physical_x, physical_y);
MouseEvent e(this, MouseEvent::Button::kNone, physical_x, physical_y);
OnMouseMove(e, destruction_receiver);
}
void SDLWindow::HandleTextInput(const SDL_TextInputEvent& event,
WindowDestructionReceiver& destruction_receiver) {
if (!event.text) {
return;
}
SDL_Keymod mod = SDL_GetModState();
const uint8_t* s = reinterpret_cast<const uint8_t*>(event.text);
while (*s) {
// Decode one UTF-8 codepoint.
uint32_t codepoint = 0;
uint32_t continuation_count = 0;
uint8_t lead = *s++;
if (lead < 0x80) {
codepoint = lead;
} else if ((lead & 0xE0) == 0xC0) {
codepoint = lead & 0x1F;
continuation_count = 1;
} else if ((lead & 0xF0) == 0xE0) {
codepoint = lead & 0x0F;
continuation_count = 2;
} else if ((lead & 0xF8) == 0xF0) {
codepoint = lead & 0x07;
continuation_count = 3;
} else {
// Stray continuation or invalid lead byte - skip.
continue;
}
bool valid = true;
for (uint32_t i = 0; i < continuation_count; ++i) {
uint8_t continuation = *s;
if ((continuation & 0xC0) != 0x80) {
valid = false;
break;
}
codepoint = (codepoint << 6) | (continuation & 0x3F);
++s;
}
if (!valid || !codepoint) {
continue;
}
// Mirrors the Win32 WM_CHAR path - the character is carried in the
// KeyEvent's virtual key field.
KeyEvent e(this, VirtualKey(codepoint), 1, false, (mod & SDL_KMOD_SHIFT) != 0,
(mod & SDL_KMOD_CTRL) != 0, (mod & SDL_KMOD_ALT) != 0, (mod & SDL_KMOD_GUI) != 0);
OnKeyChar(e, destruction_receiver);
if (destruction_receiver.IsWindowDestroyedOrClosed()) {
return;
}
}
}
void SDLWindow::SetTextInputActive(bool active) {
if (!window_) {
return;
}
if (active) {
SDL_StartTextInput(window_);
} else {
SDL_StopTextInput(window_);
}
}
void SDLWindow::HandleMouseWheel(const SDL_MouseWheelEvent& event,
WindowDestructionReceiver& destruction_receiver) {
RevealAutoHiddenCursor();
int32_t physical_x = 0;
int32_t physical_y = 0;
WindowPointToPhysical(event.mouse_x, event.mouse_y, physical_x, physical_y);
MouseEvent e(this, MouseEvent::Button::kNone, physical_x, physical_y,
int32_t(std::lround(event.x * double(MouseEvent::kScrollPerDetent))),
int32_t(std::lround(event.y * double(MouseEvent::kScrollPerDetent))));
OnMouseWheel(e, destruction_receiver);
}
void SDLWindow::RevealAutoHiddenCursor() {
if (GetCursorVisibility() != CursorVisibility::kAutoHidden) {
return;
}
if (cursor_currently_auto_hidden_) {
cursor_currently_auto_hidden_ = false;
SDL_ShowCursor();
}
SetCursorAutoHideTimer();
}
void SDLWindow::SetCursorAutoHideTimer() {
RemoveCursorAutoHideTimer();
if (!window_) {
return;
}
cursor_auto_hide_timer_ =
SDL_AddTimer(kDefaultCursorAutoHideMilliseconds, AutoHideCursorTimerCallback,
reinterpret_cast<void*>(uintptr_t(SDL_GetWindowID(window_))));
}
void SDLWindow::RemoveCursorAutoHideTimer() {
if (!cursor_auto_hide_timer_) {
return;
}
SDL_RemoveTimer(cursor_auto_hide_timer_);
cursor_auto_hide_timer_ = 0;
}
void SDLWindow::WindowPointToPhysical(float x, float y, int32_t& physical_x,
int32_t& physical_y) const {
int logical_width = 0;
int logical_height = 0;
int physical_width = 0;
int physical_height = 0;
if (window_ && SDL_GetWindowSize(window_, &logical_width, &logical_height) &&
SDL_GetWindowSizeInPixels(window_, &physical_width, &physical_height) &&
logical_width > 0 && logical_height > 0 && physical_width > 0 && physical_height > 0) {
physical_x = int32_t(std::lround(double(x) * double(physical_width) / double(logical_width)));
physical_y = int32_t(std::lround(double(y) * double(physical_height) / double(logical_height)));
return;
}
physical_x = int32_t(std::lround(x));
physical_y = int32_t(std::lround(y));
}
uint32_t SDLWindow::QueryDpi() const {
if (!window_) {
return kDefaultDpi;
}
float scale = SDL_GetWindowDisplayScale(window_);
if (scale <= 0.0f) {
scale = 1.0f;
}
return std::clamp(uint32_t(std::lround(double(kDefaultDpi) * scale)), uint32_t(48),
uint32_t(384));
}
std::unique_ptr<ui::MenuItem> MenuItem::Create(Type type, const std::string& text,
const std::string& hotkey,
std::function<void()> callback) {
return std::make_unique<SDLMenuItem>(type, text, hotkey, std::move(callback));
}
} // namespace ui
} // namespace rex
Reference in a new issue View git blame Copy permalink