Implement new window dragging system
This commit is contained in:
@@ -10,24 +10,45 @@
|
||||
#include "Engine/Profiler/ProfilerCPU.h"
|
||||
#include "Engine/Core/Log.h"
|
||||
#include "Engine/Core/Collections/Array.h"
|
||||
#include "Engine/Core/Collections/Dictionary.h"
|
||||
#include "Engine/Engine/CommandLine.h"
|
||||
#include "Engine/Platform/WindowsManager.h"
|
||||
#include "Engine/Platform/Linux/IncludeX11.h"
|
||||
#include "Engine/Input/Input.h"
|
||||
#include "Engine/Input/Mouse.h"
|
||||
#include "Engine/Engine/Time.h"
|
||||
#include "Engine/Graphics/RenderTask.h"
|
||||
#include "Engine/Platform/Base/DragDropHelper.h"
|
||||
#include "Engine/Platform/Unix/UnixFile.h"
|
||||
|
||||
#include <SDL3/SDL_video.h>
|
||||
#include <SDL3/SDL_system.h>
|
||||
#include <SDL3/SDL_hints.h>
|
||||
|
||||
#include <errno.h>
|
||||
#include <wayland/xdg-toplevel-drag-v1.h>
|
||||
#include <wayland/xdg-shell.h>
|
||||
|
||||
// Wayland
|
||||
void WaylandRegistryGlobal(void* data, wl_registry *registry, uint32 id, const char* interface, uint32 version);
|
||||
void WaylandRegistryGlobalRemove(void* data, wl_registry *registry, uint32 id);
|
||||
|
||||
Dictionary<wl_surface*, SDLWindow*> SurfaceToWindowMap;
|
||||
uint32 ImplicitGrabSerial = 0;
|
||||
wl_display* WaylandDisplay = nullptr;
|
||||
wl_registry_listener WaylandRegistryListener = { WaylandRegistryGlobal, WaylandRegistryGlobalRemove };
|
||||
xdg_toplevel_drag_manager_v1* DragManager = nullptr;
|
||||
wl_seat* WaylandSeat = nullptr;
|
||||
wl_data_device_manager* WaylandDataDeviceManager = nullptr;
|
||||
xdg_wm_base* WaylandXdgWmBase = nullptr;
|
||||
wl_data_device* dataDevice;
|
||||
bool waylandDraggingActive = false;
|
||||
|
||||
// X11
|
||||
Delegate<void*> LinuxPlatform::xEventReceived;
|
||||
|
||||
// Missing Wayland features:
|
||||
// - Application icon (xdg-toplevel-icon-v1) https://github.com/libsdl-org/SDL/pull/9584
|
||||
// - Window positioning and position tracking
|
||||
// - Color picker (xdg-desktop-portal?) https://flatpak.github.io/xdg-desktop-portal/docs/doc-org.freedesktop.portal.Screenshot.html
|
||||
// -
|
||||
|
||||
@@ -73,6 +94,7 @@ class LinuxDropFilesData : public IGuiData
|
||||
{
|
||||
public:
|
||||
Array<String> Files;
|
||||
SDLWindow* Window;
|
||||
|
||||
Type GetType() const override
|
||||
{
|
||||
@@ -92,6 +114,8 @@ class LinuxDropTextData : public IGuiData
|
||||
{
|
||||
public:
|
||||
StringView Text;
|
||||
SDLWindow* Window;
|
||||
int64* dragOver;
|
||||
|
||||
Type GetType() const override
|
||||
{
|
||||
@@ -254,10 +278,618 @@ DragDropEffect Window::DoDragDrop(const StringView& data)
|
||||
return DoDragDropX11(data);
|
||||
}
|
||||
|
||||
DragDropEffect Window::DoDragDropWayland(const StringView& data)
|
||||
wl_data_source* dataSource;
|
||||
xdg_toplevel_drag_v1* toplevelDrag = nullptr;
|
||||
|
||||
wl_data_offer* WaylandDataOffer = nullptr; // The last accepted offer
|
||||
uint32 WaylandDataOfferSerial = 0; // The last accepted serial for offer
|
||||
StringAnsi WaylandDataOfferMimeType;
|
||||
SDLWindow* DragTargetWindow = nullptr;
|
||||
Float2 DragTargetPosition;
|
||||
wl_data_offer* WaylandDataSelectionOffer = nullptr;
|
||||
|
||||
void WaylandDataOffer_Offer(void* data, wl_data_offer* offer, const char *mime_type)
|
||||
{
|
||||
// TODO: Wayland
|
||||
LOG(Warning, "Wayland Drag and drop is not implemented yet.");
|
||||
// We are being offered these types of data
|
||||
//LOG(Info, "WaylandDataOffer_Offer: {}", String(mime_type));
|
||||
|
||||
//if (WaylandDataOffer == nullptr)
|
||||
// return;
|
||||
|
||||
//if (StringAnsi(mime_type) == "x.flaxengine.window.snap")
|
||||
// WaylandDataOfferMimeType = StringAnsi(mime_type);
|
||||
// wl_data_offer_accept(WaylandDataOffer, WaylandDataOfferSerial, mime_type);
|
||||
}
|
||||
|
||||
void WaylandDataOffer_SourceActions(void *data,
|
||||
struct wl_data_offer *wl_data_offer,
|
||||
uint32_t source_actions)
|
||||
{
|
||||
//
|
||||
//LOG(Info, "WaylandDataOffer_SourceActions: {}", source_actions);
|
||||
}
|
||||
|
||||
void WaylandDataOffer_Action(void *data,
|
||||
struct wl_data_offer *wl_data_offer,
|
||||
uint32_t dnd_action)
|
||||
{
|
||||
// DnD: This action will be performed if dropped
|
||||
//LOG(Info, "WaylandDataOffer_Action: {}", dnd_action);
|
||||
}
|
||||
|
||||
wl_data_offer_listener WaylandDataOfferListener = { WaylandDataOffer_Offer, WaylandDataOffer_SourceActions, WaylandDataOffer_Action};
|
||||
|
||||
void WaylandDataDevice_DataOffer(void *data, wl_data_device *wl_data_device, wl_data_offer *id)
|
||||
{
|
||||
LOG(Info, "WaylandDataDevice_DataOffer: {}", (uint64)id);
|
||||
/*int ret = wl_data_offer_add_listener(id, &WaylandDataOfferListener, nullptr);
|
||||
if (ret != 0)
|
||||
LOG(Error, "wl_data_offer_add_listener failed");*/
|
||||
}
|
||||
|
||||
void WaylandDataDevice_Enter(void *data, wl_data_device *wl_data_device, uint32 serial, wl_surface *surface, wl_fixed_t x, wl_fixed_t y, wl_data_offer *id)
|
||||
{
|
||||
// DnD: The cursor entered a target surface
|
||||
LOG(Info, "WaylandDataDevice_Enter serial: {}, surface: {}, pos: {}x{}, id: {}", serial, (uint64)surface, wl_fixed_to_double(x), wl_fixed_to_double(y), (uint64)id);
|
||||
WaylandDataOffer = id;
|
||||
WaylandDataOfferSerial = serial;
|
||||
|
||||
DragTargetPosition = Float2(MAX_float, MAX_float);
|
||||
SDLWindow* sourceWindow = (SDLWindow*)data;
|
||||
if (!SurfaceToWindowMap.TryGet(surface, DragTargetWindow))
|
||||
DragTargetWindow = nullptr;
|
||||
if (DragTargetWindow != nullptr)
|
||||
DragTargetWindow = DragTargetWindow;
|
||||
if (/*SurfaceToWindowMap.TryGet(surface, DragTargetWindow) && */DragTargetWindow != sourceWindow)
|
||||
{
|
||||
// Inform that we support the following action at this given point
|
||||
wl_data_offer_set_actions(id, WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE, WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE);
|
||||
|
||||
if (WaylandDataOfferMimeType == "x.flaxengine.window.snap")
|
||||
wl_data_offer_accept(WaylandDataOffer, WaylandDataOfferSerial, "x.flaxengine.window.snap");
|
||||
}
|
||||
else
|
||||
{
|
||||
wl_data_offer_set_actions(id, WL_DATA_DEVICE_MANAGER_DND_ACTION_NONE, WL_DATA_DEVICE_MANAGER_DND_ACTION_NONE);
|
||||
}
|
||||
}
|
||||
|
||||
void WaylandDataDevice_Leave(void *data, wl_data_device *wl_data_device)
|
||||
{
|
||||
// DnD: The cursor left the surface area
|
||||
// id from enter must be destroyed here
|
||||
LOG(Info, "WaylandDataDevice_Leave");
|
||||
|
||||
if (WaylandDataOffer != nullptr)
|
||||
wl_data_offer_destroy(WaylandDataOffer);
|
||||
WaylandDataOffer = nullptr;
|
||||
WaylandDataOfferSerial = 0;
|
||||
WaylandDataOfferMimeType = StringAnsi::Empty;
|
||||
}
|
||||
|
||||
void WaylandDataDevice_Motion(void *data, wl_data_device *wl_data_device, uint32_t time, wl_fixed_t x, wl_fixed_t y)
|
||||
{
|
||||
// DnD: The cursor moves along the surface
|
||||
Float2 dragPosition(wl_fixed_to_double(x), wl_fixed_to_double(y));
|
||||
LOG(Info, "WaylandDataDevice_Motion {},{}", (int)dragPosition.X, (int)dragPosition.Y);
|
||||
|
||||
|
||||
if (DragTargetWindow != nullptr)
|
||||
{
|
||||
Float2 mousePos = dragPosition * DragTargetWindow->GetDpiScale();
|
||||
mousePos = Float2::Floor(mousePos);
|
||||
if (DragTargetPosition != mousePos)
|
||||
{
|
||||
//LOG(Info, "{}: {}", time, mousePos);
|
||||
Input::Mouse->OnMouseMove(mousePos, DragTargetWindow);
|
||||
DragTargetPosition = mousePos;
|
||||
}
|
||||
}
|
||||
//SDLWindow* targetWindow;
|
||||
//if (SurfaceToWindowMap.TryGet(surface, targetWindow) && targetWindow == surfaceWindow)
|
||||
}
|
||||
|
||||
void WaylandDataDevice_Drop(void *data, wl_data_device *wl_data_device)
|
||||
{
|
||||
// DnD: The drop is accepted
|
||||
LOG(Info, "WaylandDataDevice_Drop");
|
||||
|
||||
/*int fds[2];
|
||||
pipe(fds);
|
||||
wl_data_offer_receive(offer, "text/plain", fds[1]);
|
||||
close(fds[1]);
|
||||
|
||||
// TODO: do something with fds[0]
|
||||
close(fds[0]);*/
|
||||
|
||||
if (WaylandDataOffer != nullptr)
|
||||
{
|
||||
wl_data_offer_finish(WaylandDataOffer);
|
||||
wl_data_offer_destroy(WaylandDataOffer);
|
||||
WaylandDataOffer = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
void WaylandDataDevice_Selection(void *data, wl_data_device *wl_data_device, wl_data_offer *id)
|
||||
{
|
||||
// Clipboard: We can read the clipboard content
|
||||
/*
|
||||
int fds[2];
|
||||
pipe(fds);
|
||||
wl_data_offer_receive(offer, "text/plain", fds[1]);
|
||||
close(fds[1]);
|
||||
|
||||
wl_display_roundtrip(display);
|
||||
|
||||
while (true)
|
||||
{
|
||||
char buf[1024];
|
||||
ssize_t n = read(fds[0], buf, sizeof(buf));
|
||||
if (n <= 0)
|
||||
break;
|
||||
//fwrite(buf, 1, n, stdout);
|
||||
}
|
||||
close(fds[0]);
|
||||
wl_data_offer_destroy(offer);
|
||||
*/
|
||||
|
||||
|
||||
LOG(Info, "WaylandDataDevice_Selection: {}", (uint64)id);
|
||||
|
||||
if (WaylandDataSelectionOffer != nullptr)
|
||||
wl_data_offer_destroy(WaylandDataSelectionOffer);
|
||||
WaylandDataSelectionOffer = id;
|
||||
}
|
||||
|
||||
|
||||
|
||||
wl_data_device_listener WaylandDataDeviceListener =
|
||||
{
|
||||
WaylandDataDevice_DataOffer,
|
||||
WaylandDataDevice_Enter,
|
||||
WaylandDataDevice_Leave,
|
||||
WaylandDataDevice_Motion,
|
||||
WaylandDataDevice_Drop,
|
||||
WaylandDataDevice_Selection
|
||||
};
|
||||
|
||||
void WaylandDataSource_Target(void *data,
|
||||
struct wl_data_source *wl_data_source,
|
||||
const char *mime_type)
|
||||
{
|
||||
// The destination accepts the following types, or null if nothing
|
||||
//SDLWindow* window = static_cast<SDLWindow*>(data);
|
||||
LOG(Info, "WaylandDataSource_Target mime: {}", String(mime_type));
|
||||
}
|
||||
|
||||
void WaylandDataSource_Send(void *data,
|
||||
struct wl_data_source *wl_data_source,
|
||||
const char *mime_type,
|
||||
int32_t fd)
|
||||
{
|
||||
// Clipboard: The other end has accepted the data?
|
||||
IGuiData* inputData = static_cast<IGuiData*>(data);
|
||||
//LOG(Info, "WaylandDataSource_Send mime: {}", String(mime_type));
|
||||
|
||||
if (inputData->GetType() == IGuiData::Type::Text)
|
||||
{
|
||||
UnixFile file(fd);
|
||||
StringAnsi text = StringAnsi(inputData->GetAsText());
|
||||
file.Write(text.Get(), text.Length() * sizeof(StringAnsi::CharType));
|
||||
file.Close();
|
||||
|
||||
//Platform::AtomicStore(((LinuxDropTextData*)inputData)->dragOver, 1);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void WaylandDataSource_Cancelled(void* data, wl_data_source *source)
|
||||
{
|
||||
// Clipboard: other application has replaced the content in clipboard
|
||||
//SDLWindow* window = static_cast<SDLWindow*>(data);
|
||||
//LOG(Info, "WaylandDataSource_Cancelled");
|
||||
|
||||
IGuiData* inputData = static_cast<IGuiData*>(data);
|
||||
Platform::AtomicStore(((LinuxDropTextData*)inputData)->dragOver, 1);
|
||||
|
||||
wl_data_source_destroy(source);
|
||||
|
||||
// The mouse up event was ignored earlier, release the button now
|
||||
//SDLWindow* window = ((LinuxDropTextData*)inputData)->Window;
|
||||
//Input::Mouse->OnMouseUp(Platform::GetMousePosition(), MouseButton::Left, window);
|
||||
|
||||
/*if (DragTargetWindow != nullptr)
|
||||
{
|
||||
Input::Mouse->OnMouseUp(DragTargetPosition, MouseButton::Left, DragTargetWindow);
|
||||
}
|
||||
else*/ /*if (window != nullptr)
|
||||
{
|
||||
Input::Mouse->OnMouseUp(DragTargetPosition, MouseButton::Left, window);
|
||||
}*/
|
||||
}
|
||||
|
||||
void WaylandDataSource_DnDDropPerformed(void *data,
|
||||
struct wl_data_source *wl_data_source)
|
||||
{
|
||||
// The destination is being asked to begin DnD, asking confirmation with ASK actionh
|
||||
//SDLWindow* window = static_cast<SDLWindow*>(data);
|
||||
LOG(Info, "WaylandDataSource_DnDDropPerformed");
|
||||
}
|
||||
|
||||
void WaylandDataSource_DnDFinished(void *data,
|
||||
struct wl_data_source *wl_data_source)
|
||||
{
|
||||
// The destination has finally accepted the last given dnd_action
|
||||
//SDLWindow* window = static_cast<SDLWindow*>(data);
|
||||
//LOG(Info, "WaylandDataSource_DnDFinished");
|
||||
|
||||
IGuiData* inputData = static_cast<IGuiData*>(data);
|
||||
Platform::AtomicStore(((LinuxDropTextData*)inputData)->dragOver, 1);
|
||||
|
||||
wl_data_source_destroy(wl_data_source);
|
||||
|
||||
// The mouse up event was ignored earlier, release the button now
|
||||
//SDLWindow* window = ((LinuxDropTextData*)inputData)->Window;
|
||||
//Input::Mouse->OnMouseUp(Platform::GetMousePosition(), MouseButton::Left, window);
|
||||
|
||||
/*if (DragTargetWindow != nullptr)
|
||||
{
|
||||
Input::Mouse->OnMouseUp(DragTargetPosition, MouseButton::Left, DragTargetWindow);
|
||||
}
|
||||
else*/ /*if (window != nullptr)
|
||||
{
|
||||
Input::Mouse->OnMouseUp(DragTargetPosition, MouseButton::Left, window);
|
||||
}*/
|
||||
}
|
||||
|
||||
void WaylandDataSource_Action(void *data,
|
||||
struct wl_data_source *wl_data_source,
|
||||
uint32_t dnd_action)
|
||||
{
|
||||
// DnD: The destination may accept the given action if confirmed
|
||||
//SDLWindow* window = static_cast<SDLWindow*>(data);
|
||||
LOG(Info, "WaylandDataSource_Action: {}", String(dnd_action == 0 ? "NONE" : dnd_action == 1 ? "COPY" : dnd_action == 2 ? "MOVE" : dnd_action == 4 ? "ASK" : ""));
|
||||
|
||||
}
|
||||
|
||||
wl_data_source_listener WaylandDataSourceListener =
|
||||
{
|
||||
WaylandDataSource_Target,
|
||||
WaylandDataSource_Send,
|
||||
WaylandDataSource_Cancelled,
|
||||
WaylandDataSource_DnDDropPerformed,
|
||||
WaylandDataSource_DnDFinished,
|
||||
WaylandDataSource_Action
|
||||
};
|
||||
|
||||
wl_event_queue* WaylandQueue = nullptr;
|
||||
wl_data_device_manager* wrappedManager = nullptr;
|
||||
wl_data_source* wrappedDataSource = nullptr;
|
||||
wl_data_device* wrappedDataDevice = nullptr;
|
||||
|
||||
class WaylandDragDropJob : public ThreadPoolTask
|
||||
{
|
||||
public:
|
||||
int64 StartFlag = 0;
|
||||
int64 ExitFlag = 0;
|
||||
StringView data;
|
||||
SDLWindow* window;
|
||||
SDLWindow* dragSourceWindow;
|
||||
Float2 dragOffset = Float2::Zero;
|
||||
int64 dragOver = 0;
|
||||
int64 waitFlag = 0;
|
||||
|
||||
// [ThreadPoolTask]
|
||||
bool Run() override
|
||||
{
|
||||
bool dragWindow = data == String("notawindow");
|
||||
wl_display* wrappedDisplay = WaylandDisplay;//(wl_display*)wl_proxy_create_wrapper(WaylandDisplay);
|
||||
//wl_proxy_set_queue((wl_proxy*)wrappedDisplay, queue);
|
||||
|
||||
if (WaylandQueue == nullptr)
|
||||
{
|
||||
if (wrappedDataDevice != nullptr)
|
||||
wl_proxy_wrapper_destroy(wrappedDataDevice);
|
||||
if (wrappedDataSource != nullptr)
|
||||
wl_proxy_wrapper_destroy(wrappedDataSource);
|
||||
if (wrappedManager != nullptr)
|
||||
wl_proxy_wrapper_destroy(wrappedManager);
|
||||
if (dataDevice != nullptr)
|
||||
wl_data_device_destroy(dataDevice);
|
||||
|
||||
// This seems to throw bogus warnings about wl_data_source still being attached to the queue
|
||||
if (WaylandQueue != nullptr)
|
||||
wl_event_queue_destroy(WaylandQueue);
|
||||
WaylandQueue = wl_display_create_queue(WaylandDisplay);
|
||||
|
||||
wrappedManager = (wl_data_device_manager*)wl_proxy_create_wrapper(WaylandDataDeviceManager);
|
||||
wl_proxy_set_queue((wl_proxy*)wrappedManager, WaylandQueue);
|
||||
|
||||
//
|
||||
//dataDevice = wl_data_device_manager_get_data_device(WaylandDataDeviceManager, WaylandSeat);
|
||||
//wl_data_device_add_listener(dataDevice, &WaylandDataDeviceListener, nullptr);
|
||||
|
||||
//wl_display_roundtrip(WaylandDisplay);
|
||||
/*auto */dataDevice = wl_data_device_manager_get_data_device(wrappedManager, WaylandSeat);
|
||||
wl_data_device_add_listener(dataDevice, &WaylandDataDeviceListener, nullptr);
|
||||
wl_display_roundtrip(wrappedDisplay);
|
||||
wl_data_device_set_user_data(dataDevice, dragWindow ? dragSourceWindow : window);
|
||||
wrappedDataDevice = (wl_data_device*)wl_proxy_create_wrapper(dataDevice);
|
||||
wl_proxy_set_queue((wl_proxy*)wrappedDataDevice, WaylandQueue);
|
||||
}
|
||||
|
||||
// We offer the following types of things for consumption:
|
||||
dataSource = wl_data_device_manager_create_data_source(wrappedManager);
|
||||
wrappedDataSource = (wl_data_source*)wl_proxy_create_wrapper(dataSource);
|
||||
wl_proxy_set_queue((wl_proxy*)wrappedDataSource, WaylandQueue);
|
||||
if (dragWindow)
|
||||
{
|
||||
wl_data_source_offer(dataSource, "flaxengine/window");
|
||||
wl_data_source_offer(dataSource, "text/plain;charset=utf-8"); // TODO: needs support for custom mime-types in SDL
|
||||
wl_data_source_set_actions(dataSource, wl_data_device_manager_dnd_action::WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE);
|
||||
}
|
||||
else
|
||||
{
|
||||
wl_data_source_offer(dataSource, "text/plain");
|
||||
wl_data_source_offer(dataSource, "text/plain;charset=utf-8");
|
||||
wl_data_source_set_actions(dataSource, wl_data_device_manager_dnd_action::WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE | wl_data_device_manager_dnd_action::WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY);
|
||||
}
|
||||
|
||||
LinuxDropTextData textData;
|
||||
textData.Text = *data;
|
||||
textData.Window = window;
|
||||
textData.dragOver = &dragOver;
|
||||
auto _window = window->GetSDLWindow();
|
||||
auto _mainwindow = dragSourceWindow->GetSDLWindow();
|
||||
//if (!window->IsVisible())
|
||||
// _window = mainwindow->GetSDLWindow();
|
||||
//wl_data_source_set_user_data(wrappedDataSource, &textData);
|
||||
|
||||
wl_data_source_add_listener(dataSource, &WaylandDataSourceListener, &textData);
|
||||
|
||||
xdg_toplevel* toplevel = nullptr;//(xdg_toplevel*)SDL_GetPointerProperty(SDL_GetWindowProperties(_window), SDL_PROP_WINDOW_WAYLAND_XDG_TOPLEVEL_POINTER, nullptr);
|
||||
if (toplevel == nullptr)
|
||||
{
|
||||
//Platform::AtomicStore(&StartFlag, 1);
|
||||
|
||||
/*while (Platform::AtomicRead(&waitFlag) == 0)
|
||||
{
|
||||
|
||||
}*/
|
||||
//toplevel = (xdg_toplevel*)SDL_GetPointerProperty(SDL_GetWindowProperties(_window), SDL_PROP_WINDOW_WAYLAND_XDG_TOPLEVEL_POINTER, nullptr);
|
||||
}
|
||||
|
||||
xdg_toplevel* wrappedToplevel = nullptr;
|
||||
|
||||
{
|
||||
wl_surface* origin = (wl_surface*)SDL_GetPointerProperty(SDL_GetWindowProperties(_mainwindow), SDL_PROP_WINDOW_WAYLAND_SURFACE_POINTER, nullptr);
|
||||
wl_surface* icon = nullptr;
|
||||
uint32 id = ImplicitGrabSerial;
|
||||
//id = (uint32)SDL_GetNumberProperty(SDL_GetGlobalProperties(), "wayland.serial", 0);
|
||||
wl_data_device_start_drag((wl_data_device*)SDL_GetPointerProperty(SDL_GetGlobalProperties(), "wayland.data_device", wrappedDataDevice), dataSource, origin, icon, id);
|
||||
|
||||
if (dragWindow)
|
||||
{
|
||||
if (toplevel != nullptr)
|
||||
{
|
||||
wrappedToplevel = (xdg_toplevel*)wl_proxy_create_wrapper(toplevel);
|
||||
wl_proxy_set_queue((wl_proxy*)wrappedToplevel, WaylandQueue);
|
||||
toplevelDrag = xdg_toplevel_drag_manager_v1_get_xdg_toplevel_drag(DragManager, dataSource);
|
||||
|
||||
Float2 scaledOffset = dragOffset / window->GetDpiScale();
|
||||
//xdg_toplevel_drag_v1_attach(toplevelDrag, toplevel, (int32)scaledOffset.X, (int32)scaledOffset.Y);
|
||||
|
||||
xdg_toplevel_drag_v1_attach(toplevelDrag, wrappedToplevel, (int32)scaledOffset.X, (int32)scaledOffset.Y);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*wl_display_dispatch_queue(wrappedDisplay, queue);
|
||||
wl_display_roundtrip_queue(wrappedDisplay, queue);
|
||||
wl_display_flush(wrappedDisplay);
|
||||
wl_display_dispatch_queue(wrappedDisplay, queue);
|
||||
wl_display_dispatch(wrappedDisplay);*/
|
||||
|
||||
//wl_display_dispatch_queue_pending(wrappedDisplay, queue);
|
||||
|
||||
/*int ret;
|
||||
while (ret = wl_display_prepare_read_queue(wrappedDisplay, queue), ret != 0)
|
||||
{
|
||||
if (ret == -1)
|
||||
LOG(Info, "err wl_display_prepare_read_queue: {}", errno);
|
||||
|
||||
if (wl_display_dispatch_queue_pending(wrappedDisplay, queue) == -1)
|
||||
LOG(Warning, "err wl_display_dispatch_queue_pending: {}", errno);
|
||||
//else
|
||||
// LOG(Info, "OK wl_display_dispatch_queue_pending");
|
||||
}*/
|
||||
//if (wl_display_flush(wrappedDisplay) == -1)
|
||||
// LOG(Warning, "err wl_display_flush: {}", errno);
|
||||
|
||||
Platform::AtomicStore(&StartFlag, 1);
|
||||
|
||||
while (Platform::AtomicRead(&ExitFlag) == 0)
|
||||
{
|
||||
//SDLPlatform::Tick();
|
||||
//Engine::OnDraw();
|
||||
|
||||
//wl_display_dispatch_queue(displayWrapped, queue);
|
||||
//wl_display_roundtrip_queue(displayWrapped, queue);
|
||||
//wl_display_flush(displayWrapped);
|
||||
//wl_display_dispatch_queue(displayWrapped, queue);
|
||||
//wl_display_dispatch(displayWrapped);
|
||||
//wl_display_dispatch_queue(wrappedDisplay, queue);
|
||||
|
||||
//if (wl_display_flush(wrappedDisplay) == -1)
|
||||
// LOG(Warning, "err wl_display_flush: {}", errno);
|
||||
//if (wl_display_dispatch_pending(wrappedDisplay) == -1)
|
||||
// LOG(Warning, "err wl_display_dispatch_pending: {}", errno);
|
||||
|
||||
if (wl_display_dispatch_queue(wrappedDisplay, WaylandQueue) == -1)
|
||||
LOG(Warning, "err wl_display_dispatch_queue: {}", errno);
|
||||
if (wl_display_roundtrip_queue(wrappedDisplay, WaylandQueue) == -1)
|
||||
LOG(Warning, "err wl_display_roundtrip_queue: {}", errno);
|
||||
|
||||
if (toplevel == nullptr && dragWindow)
|
||||
{
|
||||
if (Platform::AtomicRead(&waitFlag) != 0)
|
||||
{
|
||||
toplevel = (xdg_toplevel*)SDL_GetPointerProperty(SDL_GetWindowProperties(_window), SDL_PROP_WINDOW_WAYLAND_XDG_TOPLEVEL_POINTER, nullptr);
|
||||
if (toplevel != nullptr)
|
||||
{
|
||||
wrappedToplevel = (xdg_toplevel*)wl_proxy_create_wrapper(toplevel);
|
||||
wl_proxy_set_queue((wl_proxy*)wrappedToplevel, WaylandQueue);
|
||||
toplevelDrag = xdg_toplevel_drag_manager_v1_get_xdg_toplevel_drag(DragManager, dataSource);
|
||||
|
||||
Float2 scaledOffset = dragOffset / window->GetDpiScale();
|
||||
//xdg_toplevel_drag_v1_attach(toplevelDrag, toplevel, (int32)scaledOffset.X, (int32)scaledOffset.Y);
|
||||
|
||||
xdg_toplevel_drag_v1_attach(toplevelDrag, wrappedToplevel, (int32)scaledOffset.X, (int32)scaledOffset.Y);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//if (wl_display_dispatch_queue(wrappedDisplay, queue) == -1)
|
||||
// LOG(Warning, "err wl_display_dispatch_queue: {}", errno);
|
||||
//else
|
||||
// LOG(Info, "OK wl_display_dispatch_queue");
|
||||
|
||||
//if (wl_display_dispatch_queue_pending(wrappedDisplay, queue) == -1)
|
||||
// LOG(Warning, "err wl_display_dispatch_queue_pending: {}", errno);
|
||||
//else
|
||||
// LOG(Info, "OK wl_display_dispatch_queue_pending");
|
||||
//wl_display_dispatch_pending(WaylandDisplay
|
||||
|
||||
//Platform::Sleep(1);
|
||||
}
|
||||
|
||||
if (wl_display_roundtrip_queue(wrappedDisplay, WaylandQueue) == -1)
|
||||
LOG(Warning, "err wl_display_roundtrip_queue: {}", errno);
|
||||
//if (wl_display_dispatch_queue(wrappedDisplay, queue) == -1)
|
||||
// LOG(Warning, "err wl_display_dispatch_queue: {}", errno);
|
||||
|
||||
|
||||
if (toplevelDrag != nullptr)
|
||||
{
|
||||
wl_proxy_wrapper_destroy(wrappedToplevel);
|
||||
xdg_toplevel_drag_v1_destroy(toplevelDrag);
|
||||
toplevelDrag = nullptr;
|
||||
}
|
||||
|
||||
/*
|
||||
wl_proxy_wrapper_destroy(wrappedDataDevice);
|
||||
wl_proxy_wrapper_destroy(wrappedDataSource);
|
||||
wl_proxy_wrapper_destroy(wrappedManager);
|
||||
wl_data_device_destroy(dataDevice);*/
|
||||
|
||||
if (wrappedDataSource != nullptr)
|
||||
wl_proxy_wrapper_destroy(wrappedDataSource);
|
||||
|
||||
|
||||
//if (dataSource != nullptr)
|
||||
// wl_proxy_wrapper_destroy(dataSource);
|
||||
|
||||
if (WaylandDataSelectionOffer != nullptr)
|
||||
{
|
||||
wl_data_offer_destroy(WaylandDataSelectionOffer);
|
||||
WaylandDataSelectionOffer = nullptr;
|
||||
}
|
||||
|
||||
// This seems to throw bogus warnings about wl_data_source still being attached to the queue
|
||||
/*wl_event_queue_destroy(WaylandQueue);
|
||||
*/
|
||||
|
||||
|
||||
//dataDevice = nullptr;
|
||||
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
DragDropEffect Window::DoDragDropWayland(const StringView& data, Window* dragSourceWindow, Float2 dragOffset)
|
||||
{
|
||||
// For drag-and-drop, we need to setup the event queue in separate thread to avoid racing issues
|
||||
// while SDL is dispatching the main Wayland event queue when receiving the data offer from us.
|
||||
|
||||
// Show()?
|
||||
{
|
||||
if (!_visible)
|
||||
{
|
||||
if (_showAfterFirstPaint)
|
||||
{
|
||||
if (RenderTask)
|
||||
RenderTask->Enabled = true;
|
||||
}
|
||||
else
|
||||
SDL_ShowWindow(_window);
|
||||
}
|
||||
WindowBase::Show();
|
||||
}
|
||||
|
||||
//while (true)
|
||||
{
|
||||
const double time = Platform::GetTimeSeconds();
|
||||
|
||||
// Update game logic
|
||||
if (Time::OnBeginUpdate(time))
|
||||
{
|
||||
Engine::OnUpdate();
|
||||
Engine::OnLateUpdate();
|
||||
Time::OnEndUpdate();
|
||||
}
|
||||
|
||||
SDLPlatform::Tick();
|
||||
Engine::OnDraw();
|
||||
|
||||
Platform::Sleep(1);
|
||||
}
|
||||
|
||||
waylandDraggingActive = true;
|
||||
|
||||
auto task = New<WaylandDragDropJob>();
|
||||
task->data = data;
|
||||
task->window = this;
|
||||
task->dragSourceWindow = dragSourceWindow; // Needs to be the parent window when dragging a tab to window
|
||||
task->dragOver = 0;
|
||||
task->dragOffset = dragOffset;
|
||||
Task::StartNew(task);
|
||||
while (task->GetState() == TaskState::Queued)
|
||||
Platform::Sleep(1);
|
||||
|
||||
while (Platform::AtomicRead(&task->StartFlag) == 0)
|
||||
{
|
||||
Platform::Sleep(1);
|
||||
}
|
||||
|
||||
//Show();
|
||||
//Focus();
|
||||
int counter = 100;
|
||||
|
||||
while (Platform::AtomicRead(&task->dragOver) == 0)
|
||||
{
|
||||
SDLPlatform::Tick();
|
||||
Engine::OnUpdate();//Scripting::Update(); // For docking updates
|
||||
Engine::OnDraw();
|
||||
|
||||
Platform::Sleep(1);
|
||||
|
||||
if (IsVisible() && Platform::AtomicRead(&task->waitFlag) == 0)
|
||||
{
|
||||
/*if (counter > 0)
|
||||
counter--;
|
||||
else*/
|
||||
Platform::AtomicStore(&task->waitFlag, 1);
|
||||
}
|
||||
}
|
||||
|
||||
// The mouse up event was ignored earlier, release the button now
|
||||
Input::Mouse->OnMouseUp(Platform::GetMousePosition(), MouseButton::Left, this);
|
||||
|
||||
Platform::AtomicStore(&task->ExitFlag, 1);
|
||||
task->Wait();
|
||||
|
||||
waylandDraggingActive = false;
|
||||
|
||||
return DragDropEffect::None;
|
||||
}
|
||||
|
||||
@@ -846,8 +1478,58 @@ int X11ErrorHandler(X11::Display* display, X11::XErrorEvent* event)
|
||||
|
||||
bool SDLPlatform::InitPlatform()
|
||||
{
|
||||
if (LinuxPlatform::Init())
|
||||
return true;
|
||||
//if (LinuxPlatform::Init())
|
||||
// return true;
|
||||
|
||||
#if false
|
||||
if (!CommandLine::Options.Headless && strcmp(SDL_GetCurrentVideoDriver(), "wayland") == 0)
|
||||
{
|
||||
WaylandDisplay = (wl_display*)SDL_GetPointerProperty(SDL_GetGlobalProperties(), SDL_PROP_GLOBAL_VIDEO_WAYLAND_WL_DISPLAY_POINTER, nullptr);
|
||||
|
||||
wl_registry* registry = wl_display_get_registry(WaylandDisplay);
|
||||
wl_registry_add_listener(registry, &WaylandRegistryListener, nullptr);
|
||||
|
||||
wl_display_roundtrip(WaylandDisplay);
|
||||
|
||||
dataDevice = wl_data_device_manager_get_data_device(WaylandDataDeviceManager, WaylandSeat);
|
||||
wl_data_device_add_listener(dataDevice, &WaylandDataDeviceListener, nullptr);
|
||||
|
||||
wl_display_roundtrip(WaylandDisplay);
|
||||
}
|
||||
#else
|
||||
bool waylandRequested = (!CommandLine::Options.X11 || CommandLine::Options.Wayland) && StringAnsi(SDL_GetHint(SDL_HINT_VIDEO_DRIVER)) == "wayland";
|
||||
if (!CommandLine::Options.Headless && waylandRequested)
|
||||
{
|
||||
// Ignore in X11 session
|
||||
String waylandDisplayEnv;
|
||||
if (!GetEnvironmentVariable(String("WAYLAND_DISPLAY"), waylandDisplayEnv))
|
||||
{
|
||||
WaylandDisplay = (wl_display*)SDL_GetPointerProperty(SDL_GetGlobalProperties(), SDL_PROP_GLOBAL_VIDEO_WAYLAND_WL_DISPLAY_POINTER, nullptr);
|
||||
if (WaylandDisplay == nullptr)
|
||||
{
|
||||
WaylandDisplay = wl_display_connect(nullptr);
|
||||
SDL_SetPointerProperty(SDL_GetGlobalProperties(), SDL_PROP_GLOBAL_VIDEO_WAYLAND_WL_DISPLAY_POINTER, WaylandDisplay);
|
||||
}
|
||||
if (WaylandDisplay != nullptr)
|
||||
{
|
||||
// We need to manage the wl_display and create the wl_data_device
|
||||
// before SDL so we can receive drag-and-drop related events from compositor.
|
||||
|
||||
//SDL_SetPointerProperty(SDL_GetGlobalProperties(), SDL_PROP_GLOBAL_VIDEO_WAYLAND_WL_DISPLAY_POINTER, WaylandDisplay);
|
||||
|
||||
wl_registry* registry = wl_display_get_registry(WaylandDisplay);
|
||||
wl_registry_add_listener(registry, &WaylandRegistryListener, nullptr);
|
||||
|
||||
wl_display_roundtrip(WaylandDisplay);
|
||||
|
||||
/*dataDevice = wl_data_device_manager_get_data_device(WaylandDataDeviceManager, WaylandSeat);
|
||||
wl_data_device_add_listener(dataDevice, &WaylandDataDeviceListener, nullptr);
|
||||
|
||||
wl_display_roundtrip(WaylandDisplay);*/
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
return false;
|
||||
}
|
||||
@@ -913,14 +1595,186 @@ void SDLPlatform::SetHighDpiAwarenessEnabled(bool enable)
|
||||
base::SetHighDpiAwarenessEnabled(enable);
|
||||
}
|
||||
|
||||
bool SDLPlatform::UsesWindows()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
bool SDLPlatform::UsesWayland()
|
||||
{
|
||||
if (xDisplay == nullptr && WaylandDisplay == nullptr)
|
||||
{
|
||||
// In case the X11 display pointer has not been updated yet
|
||||
return strcmp(SDL_GetCurrentVideoDriver(), "wayland") == 0;
|
||||
}
|
||||
return WaylandDisplay != nullptr;
|
||||
}
|
||||
|
||||
bool SDLPlatform::UsesX11()
|
||||
{
|
||||
if (xDisplay == nullptr && WaylandDisplay == nullptr)
|
||||
{
|
||||
// In case the X11 display pointer has not been updated yet
|
||||
return strcmp(SDL_GetCurrentVideoDriver(), "x11") == 0;
|
||||
}
|
||||
return xDisplay != nullptr;
|
||||
}
|
||||
|
||||
void WaylandPointer_Enter(void *data,
|
||||
struct wl_pointer *wl_pointer,
|
||||
uint32_t serial,
|
||||
struct wl_surface *surface,
|
||||
wl_fixed_t surface_x,
|
||||
wl_fixed_t surface_y)
|
||||
{
|
||||
/*SDLWindow* window;
|
||||
if (!SurfaceToWindowMap.TryGet(surface, window))
|
||||
return;
|
||||
|
||||
LastPointerWindow = window;
|
||||
LastPointerPosition = Int2(surface_x, surface_y);*/
|
||||
//LOG(Info, "WaylandPointerEnter serial:{}", serial);
|
||||
//ImplicitGrabSerial = serial;
|
||||
}
|
||||
|
||||
void WaylandPointer_Leave(void *data,
|
||||
struct wl_pointer *wl_pointer,
|
||||
uint32_t serial,
|
||||
struct wl_surface *surface)
|
||||
{
|
||||
//LastPointerWindow = nullptr;
|
||||
//LOG(Info, "WaylandPointerLeave serial:{}", serial);
|
||||
}
|
||||
|
||||
void WaylandPointer_Motion(void *data,
|
||||
struct wl_pointer *wl_pointer,
|
||||
uint32_t time,
|
||||
wl_fixed_t surface_x,
|
||||
wl_fixed_t surface_y)
|
||||
{
|
||||
//LOG(Info, "WaylandPointerMotion time:{}", time);
|
||||
//LastPointerPosition = Int2(surface_x, surface_y);
|
||||
}
|
||||
|
||||
void WaylandPointer_Button(void* data, wl_pointer* wl_pointer, uint32_t serial, uint32_t time, uint32_t button, uint32_t state)
|
||||
{
|
||||
LOG(Info, "WaylandPointerButton serial:{}, button:{}, state:{}", serial, button, state);
|
||||
|
||||
// HACK: We store the serial for upcoming drag-and-drop action even though we are
|
||||
// not really performing the action during this specific button press event.
|
||||
// SDL receives the same event which actually starts the drag process.
|
||||
if (state == 1)
|
||||
ImplicitGrabSerial = serial;
|
||||
}
|
||||
|
||||
void WaylandPointer_Axis(void *data,
|
||||
struct wl_pointer *wl_pointer,
|
||||
uint32_t time,
|
||||
uint32_t axis,
|
||||
wl_fixed_t value)
|
||||
{
|
||||
//LOG(Info, "WaylandPointerAxis time:{}", time);
|
||||
}
|
||||
|
||||
void WaylandPointer_Frame(void *data,
|
||||
struct wl_pointer *wl_pointer)
|
||||
{
|
||||
//LOG(Info, "WaylandPointerFrame");
|
||||
}
|
||||
|
||||
void WaylandPointer_AxisSource(void *data,
|
||||
struct wl_pointer *wl_pointer,
|
||||
uint32_t axis_source)
|
||||
{
|
||||
//LOG(Info, "WaylandPointerAxisSource");
|
||||
}
|
||||
|
||||
void WaylandPointer_AxisStop(void *data,
|
||||
struct wl_pointer *wl_pointer,
|
||||
uint32_t time,
|
||||
uint32_t axis)
|
||||
{
|
||||
//LOG(Info, "WaylandPointerAxisStop time:{}", time);
|
||||
}
|
||||
|
||||
void WaylandPointer_AxisDiscrete(void *data,
|
||||
struct wl_pointer *wl_pointer,
|
||||
uint32_t axis,
|
||||
int32_t discrete)
|
||||
{
|
||||
//LOG(Info, "WaylandPointerAxisDiscrete");
|
||||
}
|
||||
|
||||
void WaylandPointer_AxisValue120(void *data,
|
||||
struct wl_pointer *wl_pointer,
|
||||
uint32_t axis,
|
||||
int32_t value120)
|
||||
{
|
||||
//LOG(Info, "WaylandPointerAxisValue120");
|
||||
}
|
||||
|
||||
void WaylandPointer_AxisRelativeDirection(void *data,
|
||||
struct wl_pointer *wl_pointer,
|
||||
uint32_t axis,
|
||||
uint32_t direction)
|
||||
{
|
||||
//LOG(Info, "WaylandPointerAxisRelativeDirection");
|
||||
}
|
||||
|
||||
|
||||
wl_pointer_listener WaylandPointerListener =
|
||||
{
|
||||
WaylandPointer_Enter,
|
||||
WaylandPointer_Leave,
|
||||
WaylandPointer_Motion,
|
||||
WaylandPointer_Button,
|
||||
WaylandPointer_Axis,
|
||||
WaylandPointer_Frame,
|
||||
WaylandPointer_AxisSource,
|
||||
WaylandPointer_AxisStop,
|
||||
WaylandPointer_AxisDiscrete,
|
||||
WaylandPointer_AxisValue120,
|
||||
WaylandPointer_AxisRelativeDirection
|
||||
};
|
||||
|
||||
wl_pointer* WaylandPointer = nullptr;
|
||||
|
||||
void SeatCapabilities(void* data, wl_seat* seat, uint32 capabilities)
|
||||
{
|
||||
if ((capabilities & wl_seat_capability::WL_SEAT_CAPABILITY_POINTER) != 0)
|
||||
{
|
||||
WaylandPointer = wl_seat_get_pointer(seat);
|
||||
wl_pointer_add_listener(WaylandPointer, &WaylandPointerListener, nullptr);
|
||||
}
|
||||
}
|
||||
|
||||
void SeatName(void* data, wl_seat* seat, const char* name)
|
||||
{
|
||||
}
|
||||
|
||||
wl_seat_listener SeatListener = { SeatCapabilities, SeatName };
|
||||
|
||||
void WaylandRegistryGlobal(void* data, wl_registry *registry, uint32 id, const char* interface, uint32 version)
|
||||
{
|
||||
StringAnsi interfaceStr(interface);
|
||||
//LOG(Info, "WaylandRegistryGlobal id: {}, interface: {}", id, String(interface));
|
||||
if (interfaceStr == "xdg_toplevel_drag_manager_v1")
|
||||
DragManager = (xdg_toplevel_drag_manager_v1*)wl_registry_bind(registry, id, &xdg_toplevel_drag_manager_v1_interface, Math::Min(1U, version));
|
||||
else if (interfaceStr == "wl_seat")
|
||||
{
|
||||
WaylandSeat = (wl_seat*)wl_registry_bind(registry, id, &wl_seat_interface, Math::Min(9U, version));
|
||||
wl_seat_add_listener(WaylandSeat, &SeatListener, nullptr);
|
||||
}
|
||||
else if (interfaceStr == "wl_data_device_manager")
|
||||
WaylandDataDeviceManager = (wl_data_device_manager*)wl_registry_bind(registry, id, &wl_data_device_manager_interface, Math::Min(3U, version));
|
||||
else if (interfaceStr == "xdg_wm_base")
|
||||
WaylandXdgWmBase = (xdg_wm_base*)wl_registry_bind(registry, id, &xdg_wm_base_interface, Math::Min(6U, version));
|
||||
|
||||
}
|
||||
|
||||
void WaylandRegistryGlobalRemove(void* data, wl_registry *registry, uint32 id)
|
||||
{
|
||||
LOG(Info, "WaylandRegistryGlobalRemove id:{}", id);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
Reference in New Issue
Block a user