307 lines
9.6 KiB
C++
307 lines
9.6 KiB
C++
// Copyright (c) 2012-2024 Wojciech Figat. All rights reserved.
|
|
|
|
#if PLATFORM_SDL && PLATFORM_WINDOWS
|
|
|
|
#include "SDLPlatform.h"
|
|
#include "SDLInput.h"
|
|
|
|
#include "Engine/Core/Collections/Array.h"
|
|
#include "Engine/Platform/WindowsManager.h"
|
|
#include "Engine/Platform/Win32/IncludeWindowsHeaders.h"
|
|
#include "Engine/Input/Mouse.h"
|
|
#include "Engine/Core/Log.h"
|
|
|
|
#include <SDL3/SDL_hints.h>
|
|
#include <SDL3/SDL_init.h>
|
|
#include <SDL3/SDL_system.h>
|
|
#include <SDL3/SDL_timer.h>
|
|
|
|
extern Window* draggedWindow;
|
|
Float2 draggedWindowStartPosition = Float2::Zero;
|
|
Float2 draggedWindowMousePosition = Float2::Zero;
|
|
|
|
// The events for releasing the mouse during window dragging are missing, handle the mouse release event here
|
|
bool SDLCALL SDLPlatform::EventMessageHook(void* userdata, MSG* msg)
|
|
{
|
|
#define GET_WINDOW_WITH_HWND(window, hwnd) \
|
|
do { \
|
|
(window) = nullptr; \
|
|
WindowsManager::WindowsLocker.Lock(); \
|
|
for (int32 i = 0; i < WindowsManager::Windows.Count(); i++) \
|
|
{ \
|
|
if (WindowsManager::Windows[i]->GetNativePtr() == (hwnd)) \
|
|
{ \
|
|
(window) = WindowsManager::Windows[i]; \
|
|
break; \
|
|
} \
|
|
} \
|
|
WindowsManager::WindowsLocker.Unlock(); \
|
|
ASSERT((window) != nullptr); \
|
|
} while (false)
|
|
|
|
if (draggedWindow != nullptr)
|
|
{
|
|
LOG(Info, "event hook message: {}", msg->message);
|
|
}
|
|
|
|
if (msg->message == WM_NCLBUTTONDOWN)
|
|
{
|
|
Window* window;
|
|
GET_WINDOW_WITH_HWND(window, msg->hwnd);
|
|
draggedWindow = window;
|
|
|
|
draggedWindowStartPosition = draggedWindow->GetClientPosition();
|
|
Float2 mousePos(static_cast<float>(static_cast<LONG>(WINDOWS_GET_X_LPARAM(msg->lParam))), static_cast<float>(static_cast<LONG>(WINDOWS_GET_Y_LPARAM(msg->lParam))));
|
|
draggedWindowMousePosition = mousePos;
|
|
draggedWindowMousePosition -= draggedWindowStartPosition;
|
|
|
|
bool result = false;
|
|
WindowHitCodes hit = static_cast<WindowHitCodes>(msg->wParam);
|
|
window->OnHitTest(mousePos, hit, result);
|
|
//if (result && hit != WindowHitCodes::Caption)
|
|
// return false;
|
|
|
|
if (hit == WindowHitCodes::Caption)
|
|
{
|
|
SDL_Event event{ 0 };
|
|
event.button.type = SDL_EVENT_MOUSE_BUTTON_DOWN;
|
|
event.button.down = true;
|
|
event.button.timestamp = SDL_GetTicksNS();
|
|
event.button.windowID = SDL_GetWindowID(window->GetSDLWindow());
|
|
event.button.button = SDL_BUTTON_LEFT;
|
|
event.button.clicks = 1;
|
|
event.button.x = draggedWindowMousePosition.X;
|
|
event.button.y = draggedWindowMousePosition.Y;
|
|
|
|
SDL_PushEvent(&event);
|
|
}
|
|
}
|
|
/*else if (msg->message == WM_NCLBUTTONUP || msg->message == WM_CAPTURECHANGED)
|
|
{
|
|
windowDragging = false;
|
|
Window* window;
|
|
GET_WINDOW_WITH_HWND(window, msg->hwnd);
|
|
|
|
SDL_Event event{ 0 };
|
|
event.button.type = SDL_EVENT_MOUSE_BUTTON_UP;
|
|
event.button.down = false;
|
|
event.button.timestamp = SDL_GetTicksNS();
|
|
event.button.windowID = SDL_GetWindowID(window->GetSDLWindow());
|
|
event.button.button = SDL_BUTTON_LEFT;
|
|
event.button.clicks = 1;
|
|
event.button.x = static_cast<float>(static_cast<LONG>(WINDOWS_GET_X_LPARAM(msg->lParam)));
|
|
event.button.y = static_cast<float>(static_cast<LONG>(WINDOWS_GET_Y_LPARAM(msg->lParam)));
|
|
|
|
SDL_PushEvent(&event);
|
|
}*/
|
|
return true;
|
|
#undef GET_WINDOW_WITH_HWND
|
|
}
|
|
|
|
bool SDLPlatform::InitInternal()
|
|
{
|
|
// Workaround required for handling window dragging events properly
|
|
SDL_SetWindowsMessageHook(&EventMessageHook, nullptr);
|
|
|
|
if (WindowsPlatform::Init())
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
bool EventFilterCallback(void* userdata, SDL_Event* event)
|
|
{
|
|
Window* draggedWindow = *(Window**)userdata;
|
|
if (draggedWindow == nullptr)
|
|
return true;
|
|
|
|
// When the window is being dragged on Windows, the internal message loop is blocking
|
|
// the SDL event queue. We need to handle all relevant events in this event watch callback
|
|
// to ensure dragging related functionality doesn't break due to engine not getting updated.
|
|
// This also happens to fix the engine freezing during the dragging operation.
|
|
|
|
SDLWindow* window = SDLWindow::GetWindowFromEvent(*event);
|
|
if (event->type == SDL_EVENT_WINDOW_EXPOSED)
|
|
{
|
|
// The internal timer is sending exposed events every ~16ms
|
|
Engine::OnUpdate();//Scripting::Update(); // For docking updates
|
|
Engine::OnDraw();
|
|
return false;
|
|
}
|
|
else if (event->type == SDL_EVENT_MOUSE_BUTTON_DOWN)
|
|
{
|
|
SDLWindow* window = SDLWindow::GetWindowFromEvent(*event);
|
|
if (window)
|
|
{
|
|
bool result = false;
|
|
window->OnLeftButtonHit(WindowHitCodes::Caption, result);
|
|
//if (result)
|
|
// return false;
|
|
window->HandleEvent(*event);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
else if (event->type == SDL_EVENT_WINDOW_MOVED)
|
|
{
|
|
Float2 start = draggedWindowStartPosition;
|
|
Float2 newPos = Float2(static_cast<float>(event->window.data1), static_cast<float>(event->window.data2));
|
|
Float2 offset = newPos - start;
|
|
Float2 mousePos = draggedWindowMousePosition;
|
|
|
|
SDL_Event mouseMovedEvent { 0 };
|
|
mouseMovedEvent.motion.type = SDL_EVENT_MOUSE_MOTION;
|
|
mouseMovedEvent.motion.windowID = SDL_GetWindowID(draggedWindow->GetSDLWindow());
|
|
mouseMovedEvent.motion.timestamp = SDL_GetTicksNS();
|
|
mouseMovedEvent.motion.state = SDL_BUTTON_LEFT;
|
|
mouseMovedEvent.motion.x = mousePos.X;
|
|
mouseMovedEvent.motion.y = mousePos.Y;
|
|
if (window)
|
|
window->HandleEvent(mouseMovedEvent);
|
|
if (window)
|
|
window->HandleEvent(*event);
|
|
|
|
return false;
|
|
}
|
|
if (window)
|
|
window->HandleEvent(*event);
|
|
|
|
return true;
|
|
}
|
|
|
|
void SDLPlatform::PreHandleEvents()
|
|
{
|
|
SDL_AddEventWatch(EventFilterCallback, &draggedWindow);
|
|
}
|
|
|
|
void SDLPlatform::PostHandleEvents()
|
|
{
|
|
SDL_RemoveEventWatch(watch, &draggedWindow);
|
|
|
|
// Handle window dragging release here
|
|
if (draggedWindow != nullptr)
|
|
{
|
|
Float2 mousePosition;
|
|
auto buttons = SDL_GetGlobalMouseState(&mousePosition.X, &mousePosition.Y);
|
|
|
|
// Send simulated mouse up event
|
|
SDL_Event buttonUpEvent { 0 };
|
|
buttonUpEvent.motion.type = SDL_EVENT_MOUSE_BUTTON_UP;
|
|
buttonUpEvent.button.down = false;
|
|
buttonUpEvent.motion.windowID = SDL_GetWindowID(draggedWindow->GetSDLWindow());
|
|
buttonUpEvent.motion.timestamp = SDL_GetTicksNS();
|
|
buttonUpEvent.motion.state = SDL_BUTTON_LEFT;
|
|
buttonUpEvent.button.clicks = 1;
|
|
buttonUpEvent.motion.x = mousePosition.X;
|
|
buttonUpEvent.motion.y = mousePosition.Y;
|
|
draggedWindow->HandleEvent(buttonUpEvent);
|
|
draggedWindow = nullptr;
|
|
}
|
|
}
|
|
|
|
bool SDLWindow::HandleEventInternal(SDL_Event& event)
|
|
{
|
|
switch (event.type)
|
|
{
|
|
case SDL_EVENT_WINDOW_DESTROYED:
|
|
{
|
|
#if USE_EDITOR
|
|
// Disable file dropping
|
|
if (_settings.AllowDragAndDrop)
|
|
{
|
|
const auto result = RevokeDragDrop((HWND)_handle);
|
|
if (result != S_OK)
|
|
LOG(Warning, "Window drag and drop service error: 0x{0:x}:{1}", result, 2);
|
|
}
|
|
#endif
|
|
break;
|
|
}
|
|
case SDL_EVENT_WINDOW_MAXIMIZED:
|
|
{
|
|
#if BORDERLESS_MAXIMIZE_WORKAROUND == 2
|
|
if (SkipMaximizeEventsCount > 0)
|
|
{
|
|
SkipMaximizeEventsCount--;
|
|
return;
|
|
}
|
|
|
|
if (!_settings.HasBorder && _settings.HasSizingFrame)
|
|
{
|
|
// Restore the window back to previous state
|
|
SDL_RestoreWindow(_window);
|
|
|
|
// Remove the resizable flags from borderless windows and maximize the window again
|
|
auto style = ::GetWindowLong((HWND)_handle, GWL_STYLE);
|
|
style &= ~STYLE_RESIZABLE;
|
|
::SetWindowLong((HWND)_handle, GWL_STYLE, style);
|
|
|
|
SDL_MaximizeWindow(_window);
|
|
|
|
// Re-enable the resizable borderless flags
|
|
style = ::GetWindowLong((HWND)_handle, GWL_STYLE) | STYLE_RESIZABLE;
|
|
::SetWindowLong((HWND)_handle, GWL_STYLE, style);
|
|
|
|
// The next SDL_EVENT_WINDOW_RESTORED and SDL_EVENT_WINDOW_MAXIMIZED events should be ignored
|
|
SkipMaximizeEventsCount = 2;
|
|
}
|
|
#endif
|
|
break;
|
|
}
|
|
case SDL_EVENT_WINDOW_RESTORED:
|
|
{
|
|
#if BORDERLESS_MAXIMIZE_WORKAROUND == 2
|
|
if (SkipMaximizeEventsCount > 0)
|
|
{
|
|
SkipMaximizeEventsCount--;
|
|
return true;
|
|
}
|
|
#endif
|
|
break;
|
|
}
|
|
case SDL_EVENT_MOUSE_BUTTON_UP:
|
|
{
|
|
if (draggedWindow != nullptr && draggedWindow->_windowId != event.button.windowID)
|
|
{
|
|
// Send the button event to dragged window as well
|
|
Float2 mousePos = ClientToScreen({ event.button.x, event.button.y });
|
|
Float2 clientPos = draggedWindow->ScreenToClient(mousePos);
|
|
|
|
SDL_Event event2 = event;
|
|
event2.button.windowID = draggedWindow->_windowId;
|
|
event2.button.x = clientPos.X;
|
|
event2.button.y = clientPos.Y;
|
|
|
|
SDLInput::HandleEvent(draggedWindow, event2);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool SDLPlatform::UsesWindows()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
bool SDLPlatform::UsesWayland()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool SDLPlatform::UsesX11()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
void SDLPlatform::SetHighDpiAwarenessEnabled(bool enable)
|
|
{
|
|
// Other supported values: "permonitor", "permonitorv2"
|
|
SDL_SetHint("SDL_WINDOWS_DPI_AWARENESS", enable ? "system" : "unaware");
|
|
}
|
|
|
|
#endif
|