Implement new window dragging system

Source/Editor/GUI/Docking/DockHintWindow.cs

@@ -1,535 +0,0 @@
-// Copyright (c) 2012-2024 Wojciech Figat. All rights reserved.
-
-using System;
-using FlaxEngine;
-using FlaxEngine.GUI;
-
-namespace FlaxEditor.GUI.Docking
-{
-    /// <summary>
-    /// Helper class used to handle docking windows dragging and docking.
-    /// </summary>
-    public class DockHintWindow
-    {
-        private FloatWindowDockPanel _toMove;
-
-        private Float2 _dragOffset;
-        private Float2 _defaultWindowSize;
-        private Rectangle _rectDock;
-        private Rectangle _rectWindow;
-        private Float2 _mouse;
-        private DockState _toSet;
-        private DockPanel _toDock;
-        private bool _lateDragOffsetUpdate;
-
-        private Rectangle _rLeft, _rRight, _rBottom, _rUpper, _rCenter;
-
-        private DockHintWindow(FloatWindowDockPanel toMove)
-        {
-            _toMove = toMove;
-            _toSet = DockState.Float;
-            var window = toMove.Window.Window;
-
-            // Remove focus from drag target
-            _toMove.Focus();
-            _toMove.Defocus();
-
-            // Focus window
-            window.Focus();
-
-            // Check if window is maximized and restore window.
-            if (window.IsMaximized)
-            {
-                // Restore window and set position to mouse.
-                var mousePos = window.MousePosition;
-                var previousSize = window.Size;
-                window.Restore();
-                window.Position = Platform.MousePosition - mousePos * window.Size / previousSize;
-            }
-
-            // Calculate dragging offset and move window to the destination position
-            var mouseScreenPosition = Platform.MousePosition;
-
-            // If the _toMove window was not focused when initializing this window, the result vector only contains zeros
-            // and to prevent a failure, we need to perform an update for the drag offset at later time which will be done in the OnMouseMove event handler.
-            if (mouseScreenPosition != Float2.Zero)
-                CalculateDragOffset(mouseScreenPosition);
-            else
-                _lateDragOffsetUpdate = true;
-
-            // Get initial size
-            _defaultWindowSize = window.Size;
-
-            // Init proxy window
-            Proxy.Init(ref _defaultWindowSize);
-
-            // Bind events
-            Proxy.Window.MouseUp += OnMouseUp;
-            Proxy.Window.MouseMove += OnMouseMove;
-            Proxy.Window.LostFocus += OnLostFocus;
-            _toMove.Window.Window.MouseUp += OnMouseUp; // Intercept the drag release mouse event from source window
-
-            // Update window GUI
-            Proxy.Window.GUI.PerformLayout();
-
-            // Update rectangles
-            UpdateRects();
-
-            // Enable hit window presentation
-            Proxy.Window.RenderingEnabled = true;
-            Proxy.Window.Show();
-            Proxy.Window.Focus();
-            
-            // Hide base window
-            window.Hide();
-            
-            // Start tracking mouse
-            Proxy.Window.StartTrackingMouse(false);
-        }
-
-        /// <summary>
-        /// Releases unmanaged and - optionally - managed resources.
-        /// </summary>
-        public void Dispose()
-        {
-            // End tracking mouse
-            Proxy.Window.EndTrackingMouse();
-
-            // Disable rendering
-            Proxy.Window.RenderingEnabled = false;
-
-            // Unbind events
-            Proxy.Window.MouseUp -= OnMouseUp;
-            Proxy.Window.MouseMove -= OnMouseMove;
-            Proxy.Window.LostFocus -= OnLostFocus;
-            if (_toMove?.Window?.Window)
-                _toMove.Window.Window.MouseUp -= OnMouseUp;
-
-            // Hide the proxy
-            Proxy.Hide();
-
-            if (_toMove == null)
-                return;
-
-            // Check if window won't be docked
-            if (_toSet == DockState.Float)
-            {
-                var window = _toMove.Window?.Window;
-                if (window == null)
-                    return;
-                var mouse = Platform.MousePosition;
-
-                // Move base window
-                window.Position = mouse - _dragOffset;
-
-                // Show base window
-                window.Show();
-            }
-            else
-            {
-                bool hasNoChildPanels = _toMove.ChildPanelsCount == 0;
-
-                // Check if window has only single tab
-                if (hasNoChildPanels && _toMove.TabsCount == 1)
-                {
-                    // Dock window
-                    _toMove.GetTab(0).Show(_toSet, _toDock);
-                }
-                // Check if dock as tab and has no child panels
-                else if (hasNoChildPanels && _toSet == DockState.DockFill)
-                {
-                    // Dock all tabs
-                    while (_toMove.TabsCount > 0)
-                    {
-                        _toMove.GetTab(0).Show(DockState.DockFill, _toDock);
-                    }
-                }
-                else
-                {
-                    var selectedTab = _toMove.SelectedTab;
-
-                    // Dock the first tab into the target location
-                    if (_toMove.TabsCount > 0)
-                    {
-                        var firstTab = _toMove.GetTab(0);
-                        firstTab.Show(_toSet, _toDock);
-
-                        // Dock rest of the tabs
-                        while (_toMove.TabsCount > 0)
-                        {
-                            _toMove.GetTab(0).Show(DockState.DockFill, firstTab);
-                        }
-                    }
-
-                    // Keep selected tab being selected
-                    selectedTab?.SelectTab();
-                }
-
-                // Focus target window
-                _toDock.Root.Focus();
-            }
-
-            _toMove = null;
-        }
-
-        /// <summary>
-        /// Creates the new dragging hit window.
-        /// </summary>
-        /// <param name="toMove">Floating dock panel to move.</param>
-        /// <returns>The dock hint window object.</returns>
-        public static DockHintWindow Create(FloatWindowDockPanel toMove)
-        {
-            if (toMove == null)
-                throw new ArgumentNullException();
-
-            return new DockHintWindow(toMove);
-        }
-
-        /// <summary>
-        /// Creates the new dragging hit window.
-        /// </summary>
-        /// <param name="toMove">Dock window to move.</param>
-        /// <returns>The dock hint window object.</returns>
-        public static DockHintWindow Create(DockWindow toMove)
-        {
-            if (toMove == null)
-                throw new ArgumentNullException();
-
-            // Show floating
-            toMove.ShowFloating();
-
-            // Move window to the mouse position (with some offset for caption bar)
-            var window = (WindowRootControl)toMove.Root;
-            var mouse = Platform.MousePosition;
-            window.Window.Position = mouse - new Float2(8, 8);
-
-            // Get floating panel
-            var floatingPanelToMove = window.GetChild(0) as FloatWindowDockPanel;
-
-            return new DockHintWindow(floatingPanelToMove);
-        }
-
-        /// <summary>
-        /// Calculates window rectangle in the dock window.
-        /// </summary>
-        /// <param name="state">Window dock state.</param>
-        /// <param name="rect">Dock panel rectangle.</param>
-        /// <returns>Calculated window rectangle.</returns>
-        public static Rectangle CalculateDockRect(DockState state, ref Rectangle rect)
-        {
-            Rectangle result = rect;
-            switch (state)
-            {
-            case DockState.DockFill:
-                result.Location.Y += DockPanel.DefaultHeaderHeight;
-                result.Size.Y -= DockPanel.DefaultHeaderHeight;
-                break;
-            case DockState.DockTop:
-                result.Size.Y *= DockPanel.DefaultSplitterValue;
-                break;
-            case DockState.DockLeft:
-                result.Size.X *= DockPanel.DefaultSplitterValue;
-                break;
-            case DockState.DockBottom:
-                result.Location.Y += result.Size.Y * (1 - DockPanel.DefaultSplitterValue);
-                result.Size.Y *= DockPanel.DefaultSplitterValue;
-                break;
-            case DockState.DockRight:
-                result.Location.X += result.Size.X * (1 - DockPanel.DefaultSplitterValue);
-                result.Size.X *= DockPanel.DefaultSplitterValue;
-                break;
-            }
-            return result;
-        }
-
-        private void CalculateDragOffset(Float2 mouseScreenPosition)
-        {
-            var baseWinPos = _toMove.Window.Window.Position;
-            _dragOffset = mouseScreenPosition - baseWinPos;
-        }
-
-        private void UpdateRects()
-        {
-            // Cache mouse position
-            _mouse = Platform.MousePosition;
-
-            // Check intersection with any dock panel
-            var uiMouse = _mouse;
-            _toDock = _toMove.MasterPanel.HitTest(ref uiMouse, _toMove);
-
-            // Check dock state to use
-            bool showProxyHints = _toDock != null;
-            bool showBorderHints = showProxyHints;
-            bool showCenterHint = showProxyHints;
-            if (showProxyHints)
-            {
-                // If moved window has not only tabs but also child panels disable docking as tab
-                if (_toMove.ChildPanelsCount > 0)
-                    showCenterHint = false;
-
-                // Disable docking windows with one or more dock panels inside
-                if (_toMove.ChildPanelsCount > 0)
-                    showBorderHints = false;
-
-                // Get dock area
-                _rectDock = _toDock.DockAreaBounds;
-
-                // Cache dock rectangles
-                var size = _rectDock.Size;
-                var offset = _rectDock.Location;
-                var borderMargin = 4.0f;
-                var hintWindowsSize = Proxy.HintWindowsSize * Platform.DpiScale;
-                var hintWindowsSize2 = hintWindowsSize * 0.5f;
-                var centerX = size.X * 0.5f;
-                var centerY = size.Y * 0.5f;
-                _rUpper = new Rectangle(centerX - hintWindowsSize2, borderMargin, hintWindowsSize, hintWindowsSize) + offset;
-                _rBottom = new Rectangle(centerX - hintWindowsSize2, size.Y - hintWindowsSize - borderMargin, hintWindowsSize, hintWindowsSize) + offset;
-                _rLeft = new Rectangle(borderMargin, centerY - hintWindowsSize2, hintWindowsSize, hintWindowsSize) + offset;
-                _rRight = new Rectangle(size.X - hintWindowsSize - borderMargin, centerY - hintWindowsSize2, hintWindowsSize, hintWindowsSize) + offset;
-                _rCenter = new Rectangle(centerX - hintWindowsSize2, centerY - hintWindowsSize2, hintWindowsSize, hintWindowsSize) + offset;
-
-                // Hit test
-                DockState toSet = DockState.Float;
-                if (showBorderHints)
-                {
-                    if (_rUpper.Contains(_mouse))
-                        toSet = DockState.DockTop;
-                    else if (_rBottom.Contains(_mouse))
-                        toSet = DockState.DockBottom;
-                    else if (_rLeft.Contains(_mouse))
-                        toSet = DockState.DockLeft;
-                    else if (_rRight.Contains(_mouse))
-                        toSet = DockState.DockRight;
-                }
-                if (showCenterHint && _rCenter.Contains(_mouse))
-                    toSet = DockState.DockFill;
-                _toSet = toSet;
-
-                // Show proxy hint windows
-                Proxy.Down.Position = _rBottom.Location;
-                Proxy.Left.Position = _rLeft.Location;
-                Proxy.Right.Position = _rRight.Location;
-                Proxy.Up.Position = _rUpper.Location;
-                Proxy.Center.Position = _rCenter.Location;
-            }
-            else
-            {
-                _toSet = DockState.Float;
-            }
-
-            // Update proxy hint windows visibility
-            Proxy.Down.IsVisible = showProxyHints & showBorderHints;
-            Proxy.Left.IsVisible = showProxyHints & showBorderHints;
-            Proxy.Right.IsVisible = showProxyHints & showBorderHints;
-            Proxy.Up.IsVisible = showProxyHints & showBorderHints;
-            Proxy.Center.IsVisible = showProxyHints & showCenterHint;
-
-            // Calculate proxy/dock/window rectangles
-            if (_toDock == null)
-            {
-                // Floating window over nothing
-                _rectWindow = new Rectangle(_mouse - _dragOffset, _defaultWindowSize);
-            }
-            else
-            {
-                if (_toSet == DockState.Float)
-                {
-                    // Floating window over dock panel
-                    _rectWindow = new Rectangle(_mouse - _dragOffset, _defaultWindowSize);
-                }
-                else
-                {
-                    // Use only part of the dock panel to show hint
-                    _rectWindow = CalculateDockRect(_toSet, ref _rectDock);
-                }
-            }
-
-            // Update proxy window
-            Proxy.Window.ClientBounds = _rectWindow;
-        }
-
-        private void OnMouseUp(ref Float2 location, MouseButton button, ref bool handled)
-        {
-            if (button == MouseButton.Left)
-            {
-                Dispose();
-            }
-        }
-
-        private void OnMouseMove(ref Float2 mousePos)
-        {
-            // Recalculate the drag offset because the current mouse screen position was invalid when we initialized the window
-            if (_lateDragOffsetUpdate)
-            {
-                // Calculate dragging offset and move window to the destination position
-                CalculateDragOffset(mousePos);
-
-                // Reset state
-                _lateDragOffsetUpdate = false;
-            }
-
-            UpdateRects();
-        }
-
-        private void OnLostFocus()
-        {
-            Dispose();
-        }
-
-        /// <summary>
-        /// Contains helper proxy windows shared across docking panels. They are used to visualize docking window locations.
-        /// </summary>
-        public static class Proxy
-        {
-            /// <summary>
-            /// The drag proxy window.
-            /// </summary>
-            public static Window Window;
-
-            /// <summary>
-            /// The left hint proxy window.
-            /// </summary>
-            public static Window Left;
-
-            /// <summary>
-            /// The right hint proxy window.
-            /// </summary>
-            public static Window Right;
-
-            /// <summary>
-            /// The up hint proxy window.
-            /// </summary>
-            public static Window Up;
-
-            /// <summary>
-            /// The down hint proxy window.
-            /// </summary>
-            public static Window Down;
-
-            /// <summary>
-            /// The center hint proxy window.
-            /// </summary>
-            public static Window Center;
-
-            /// <summary>
-            /// The hint windows size.
-            /// </summary>
-            public const float HintWindowsSize = 32.0f;
-
-            /// <summary>
-            /// Initializes the hit proxy windows. Those windows are used to indicate drag target areas (left, right, top, bottom, etc.).
-            /// </summary>
-            public static void InitHitProxy()
-            {
-                CreateProxy(ref Left, "DockHint.Left");
-                CreateProxy(ref Right, "DockHint.Right");
-                CreateProxy(ref Up, "DockHint.Up");
-                CreateProxy(ref Down, "DockHint.Down");
-                CreateProxy(ref Center, "DockHint.Center");
-            }
-
-            /// <summary>
-            /// Initializes the hint window.
-            /// </summary>
-            /// <param name="initSize">Initial size of the proxy window.</param>
-            public static void Init(ref Float2 initSize)
-            {
-                if (Window == null)
-                {
-                    var settings = CreateWindowSettings.Default;
-                    settings.Title = "DockHint.Window";
-                    settings.Size = initSize;
-                    settings.AllowInput = true;
-                    settings.AllowMaximize = false;
-                    settings.AllowMinimize = false;
-                    settings.HasBorder = false;
-                    settings.HasSizingFrame = false;
-                    settings.Type = WindowType.Utility;
-                    settings.SupportsTransparency = true;
-                    settings.ShowInTaskbar = false;
-                    settings.ShowAfterFirstPaint = false;
-                    settings.IsTopmost = true;
-
-                    Window = Platform.CreateWindow(ref settings);
-                    Window.Opacity = 0.6f;
-                    Window.GUI.BackgroundColor = Style.Current.DragWindow;
-                }
-                else
-                {
-                    // Resize proxy
-                    Window.ClientSize = initSize;
-                }
-
-                InitHitProxy();
-            }
-
-            private static void CreateProxy(ref Window win, string name)
-            {
-                if (win != null)
-                    return;
-
-                var settings = CreateWindowSettings.Default;
-                settings.Title = name;
-                settings.Size = new Float2(HintWindowsSize * Platform.DpiScale);
-                settings.AllowInput = false;
-                settings.AllowMaximize = false;
-                settings.AllowMinimize = false;
-                settings.HasBorder = false;
-                settings.HasSizingFrame = false;
-                settings.Type = WindowType.Utility;
-                settings.SupportsTransparency = true;
-                settings.ShowInTaskbar = false;
-                settings.ActivateWhenFirstShown = false;
-                settings.IsTopmost = true;
-                settings.ShowAfterFirstPaint = false;
-
-                win = Platform.CreateWindow(ref settings);
-                win.Opacity = 0.6f;
-                win.GUI.BackgroundColor = Style.Current.DragWindow;
-            }
-
-            /// <summary>
-            /// Hides proxy windows.
-            /// </summary>
-            public static void Hide()
-            {
-                HideProxy(ref Window);
-                HideProxy(ref Left);
-                HideProxy(ref Right);
-                HideProxy(ref Up);
-                HideProxy(ref Down);
-                HideProxy(ref Center);
-            }
-
-            private static void HideProxy(ref Window win)
-            {
-                if (win)
-                {
-                    win.Hide();
-                }
-            }
-
-            /// <summary>
-            /// Releases proxy data and windows.
-            /// </summary>
-            public static void Dispose()
-            {
-                DisposeProxy(ref Window);
-                DisposeProxy(ref Left);
-                DisposeProxy(ref Right);
-                DisposeProxy(ref Up);
-                DisposeProxy(ref Down);
-                DisposeProxy(ref Center);
-            }
-
-            private static void DisposeProxy(ref Window win)
-            {
-                if (win)
-                {
-                    win.Close(ClosingReason.User);
-                    win = null;
-                }
-            }
-        }
-    }
-}

Source/Editor/GUI/Docking/DockPanelProxy.cs

@@ -170,7 +170,7 @@ namespace FlaxEditor.GUI.Docking
                 if (_panel.ChildPanelsCount == 0 && _panel.TabsCount == 1 && _panel.IsFloating)
                 {
                     // Create docking hint window but in an async manner
-                    DockHintWindow.Create(_panel as FloatWindowDockPanel);
+                    WindowDragHelper.StartDragging(_panel as FloatWindowDockPanel);
                 }
                 else
                 {
@@ -181,7 +181,7 @@ namespace FlaxEditor.GUI.Docking
                     _panel.SelectTab(index - 1);
 
                     // Create docking hint window
-                    DockHintWindow.Create(win);
+                    WindowDragHelper.StartDragging(win, _panel.RootWindow.Window);
                 }
             }
         }

Source/Editor/GUI/Docking/DockWindow.cs

@@ -182,6 +182,25 @@ namespace FlaxEditor.GUI.Docking
         /// <param name="size">Window size, set <see cref="Float2.Zero"/> to use default.</param>
         /// <param name="position">Window location.</param>
         public void ShowFloating(Float2 location, Float2 size, WindowStartPosition position = WindowStartPosition.CenterParent)
+        {
+            CreateFloating(location, size, position, true);
+        }
+
+        /// <summary>
+        /// Creates the window in a floating state.
+        /// </summary>
+        public void CreateFloating()
+        {
+            CreateFloating(Float2.Zero, Float2.Zero);
+        }
+        /// <summary>
+        /// Creates the window in a floating state.
+        /// </summary>
+        /// <param name="location">Window location.</param>
+        /// <param name="size">Window size, set <see cref="Float2.Zero"/> to use default.</param>
+        /// <param name="position">Window location.</param>
+        /// <param name="showWindow">Window visibility.</param>
+        public void CreateFloating(Float2 location, Float2 size, WindowStartPosition position = WindowStartPosition.CenterParent, bool showWindow = false)
         {
             Undock();
 
@@ -199,14 +218,17 @@ namespace FlaxEditor.GUI.Docking
             windowGUI.UnlockChildrenRecursive();
             windowGUI.PerformLayout();
 
-            // Show
-            window.Show();
-            window.BringToFront();
-            window.Focus();
-            OnShow();
+            if (showWindow)
+            {
+                // Show
+                window.Show();
+                window.BringToFront();
+                window.Focus();
+                OnShow();
 
-            // Perform layout again
-            windowGUI.PerformLayout();
+                // Perform layout again
+                windowGUI.PerformLayout();
+            }
         }
 
         /// <summary>

Source/Editor/GUI/Docking/FloatWindowDockPanel.cs

@@ -52,7 +52,7 @@ namespace FlaxEditor.GUI.Docking
                 return;
 
             // Create docking hint window
-            DockHintWindow.Create(this);
+            WindowDragHelper.StartDragging(this);
         }
 
         /// <summary>

Source/Editor/GUI/Docking/MasterDockPanel.cs

@@ -81,7 +81,6 @@ namespace FlaxEditor.GUI.Docking
         public DockPanel HitTest(ref Float2 position, FloatWindowDockPanel excluded)
         {
             // Check all floating windows
-            // TODO: gather windows order and take it into account when performing test
             for (int i = 0; i < FloatingPanels.Count; i++)
             {
                 var win = FloatingPanels[i];
@@ -94,9 +93,44 @@ namespace FlaxEditor.GUI.Docking
             }
 
             // Base
+            //if (!Root?.RootWindow.Window.IsFocused ?? false)
+            //    return null;
             return base.HitTest(ref position);
         }
 
+        /// <summary>
+        /// Performs hit test over dock panel.
+        /// </summary>
+        /// <param name="position">Window space position to test.</param>
+        /// <param name="excluded">Floating window to omit during searching (and all docked to that one).</param>
+        /// <param name="hitResults">Results of the hit test</param>
+        /// <returns>True if any dock panels were hit, otherwise false.</returns>
+        public bool HitTest(ref Float2 position, FloatWindowDockPanel excluded, out DockPanel[] hitResults)
+        {
+            // Check all floating windows
+            List<DockPanel> results = new(FloatingPanels.Count);
+            for (int i = 0; i < FloatingPanels.Count; i++)
+            {
+                var win = FloatingPanels[i];
+                if (win.Visible && win != excluded)
+                {
+                    var result = win.HitTest(ref position);
+                    if (result != null)
+                        results.Add(result);
+                }
+            }
+
+            // Base
+            //if (!Root?.RootWindow.Window.IsFocused ?? false)
+            //    return null;
+            var baseResult = base.HitTest(ref position);
+            if (baseResult != null)
+                results.Add(baseResult);
+
+            hitResults = results.ToArray();
+            return hitResults.Length > 0;
+        }
+
         internal void LinkWindow(DockWindow window)
         {
             // Add to the windows list

Source/Editor/GUI/Docking/WindowDragHelper.cs

@@ -0,0 +1,445 @@
+// Copyright (c) 2012-2024 Wojciech Figat. All rights reserved.
+
+using System;
+using FlaxEngine;
+using FlaxEngine.GUI;
+
+namespace FlaxEditor.GUI.Docking
+{
+    /// <summary>
+    /// Helper class used to handle docking windows dragging and docking.
+    /// </summary>
+    public class WindowDragHelper
+    {
+        private FloatWindowDockPanel _toMove;
+
+        private Float2 _dragOffset;
+        private Rectangle _rectDock;
+        private Float2 _mouse;
+        private DockState _toSet;
+        private DockPanel _toDock;
+        private Window _dragSourceWindow;
+
+        private Rectangle _rLeft, _rRight, _rBottom, _rUpper, _rCenter;
+        private Control _dockHintDown, _dockHintUp, _dockHintLeft, _dockHintRight, _dockHintCenter;
+
+        /// <summary>
+        /// The hint control size.
+        /// </summary>
+        public const float HintControlSize = 32.0f;
+
+        /// <summary>
+        /// The opacity of the dragged window when hint controls are shown.
+        /// </summary>
+        public const float DragWindowOpacity = 0.4f;
+
+        private WindowDragHelper(FloatWindowDockPanel toMove, Window dragSourceWindow)
+        {
+            _toMove = toMove;
+            _toSet = DockState.Float;
+            var window = toMove.Window.Window;
+
+            // Check if window is maximized and restore window.
+            if (window.IsMaximized)
+            {
+                // Restore window and set position to mouse.
+                var mousePos = window.MousePosition;
+                var previousSize = window.Size;
+                window.Restore();
+                window.Position = Platform.MousePosition - mousePos * window.Size / previousSize;
+            }
+
+            // Bind events
+            FlaxEngine.Scripting.Update += OnUpdate;
+            window.MouseUp += OnMouseUp;
+            
+            // Update rectangles
+            UpdateRects();
+
+            _dragSourceWindow = dragSourceWindow;
+            if (_dragSourceWindow != null) // Detaching a tab from existing window
+            {
+                _dragOffset = new Float2(window.Size.X / 2, 10.0f);
+
+                // TODO: when detaching tab in floating window (not main window), the drag source window is still main window?
+                var dragSourceWindowWayland = toMove.MasterPanel?.RootWindow.Window ?? Editor.Instance.Windows.MainWindow;
+                window.DoDragDrop("", _dragOffset, dragSourceWindowWayland);
+
+                _dragSourceWindow.MouseUp += OnMouseUp; // The mouse up event is sent to the source window on Windows
+            }
+            else
+            {
+                window.DoDragDrop("", _dragOffset, window);
+            }
+
+            // Ensure the dragged window stays on top of every other window
+            //window.Show();
+            window.IsAlwaysOnTop = true;
+        }
+
+        /// <summary>
+        /// Releases unmanaged and - optionally - managed resources.
+        /// </summary>
+        public void Dispose()
+        {
+            var window = _toMove?.Window?.Window;
+
+            // Unbind events
+            FlaxEngine.Scripting.Update -= OnUpdate;
+            if (window != null)
+                window.MouseUp -= OnMouseUp;
+            if (_dragSourceWindow != null)
+                _dragSourceWindow.MouseUp -= OnMouseUp;
+
+            RemoveDockHints();
+
+            if (_toMove == null)
+                return;
+
+            if (window != null)
+            {
+                window.Opacity = 1.0f;
+                window.IsAlwaysOnTop = false;
+                window.BringToFront();
+            }
+
+            // Check if window won't be docked
+            if (_toSet == DockState.Float)
+            {
+                if (window == null)
+                    return;
+
+                // Show base window
+                window.Show();
+            }
+            else
+            {
+                bool hasNoChildPanels = _toMove.ChildPanelsCount == 0;
+
+                // Check if window has only single tab
+                if (hasNoChildPanels && _toMove.TabsCount == 1)
+                {
+                    // Dock window
+                    _toMove.GetTab(0).Show(_toSet, _toDock);
+                }
+                // Check if dock as tab and has no child panels
+                else if (hasNoChildPanels && _toSet == DockState.DockFill)
+                {
+                    // Dock all tabs
+                    while (_toMove.TabsCount > 0)
+                    {
+                        _toMove.GetTab(0).Show(DockState.DockFill, _toDock);
+                    }
+                }
+                else
+                {
+                    var selectedTab = _toMove.SelectedTab;
+
+                    // Dock the first tab into the target location
+                    if (_toMove.TabsCount > 0)
+                    {
+                        var firstTab = _toMove.GetTab(0);
+                        firstTab.Show(_toSet, _toDock);
+
+                        // Dock rest of the tabs
+                        while (_toMove.TabsCount > 0)
+                        {
+                            _toMove.GetTab(0).Show(DockState.DockFill, firstTab);
+                        }
+                    }
+
+                    // Keep selected tab being selected
+                    selectedTab?.SelectTab();
+                }
+
+                // Focus target window
+                _toDock.Root.Focus();
+            }
+
+            _toMove = null;
+        }
+
+        /// <summary>
+        /// Start dragging a floating dock panel.
+        /// </summary>
+        /// <param name="toMove">Floating dock panel to move.</param>
+        /// <returns>The dock hint window object.</returns>
+        public static WindowDragHelper StartDragging(FloatWindowDockPanel toMove)
+        {
+            if (toMove == null)
+                throw new ArgumentNullException();
+
+            return new WindowDragHelper(toMove, null);
+        }
+
+        /// <summary>
+        /// Start dragging a docked panel into a floating window.
+        /// </summary>
+        /// <param name="toMove">Dock window to move.</param>
+        /// <returns>The dock hint window object.</returns>
+        public static WindowDragHelper StartDragging(DockWindow toMove, Window dragSourceWindow)
+        {
+            if (toMove == null)
+                throw new ArgumentNullException();
+
+            // Create floating window
+            toMove.CreateFloating();
+
+            // Get floating panel
+            var window = (WindowRootControl)toMove.Root;
+            var floatingPanelToMove = window.GetChild(0) as FloatWindowDockPanel;
+
+            return new WindowDragHelper(floatingPanelToMove, dragSourceWindow);
+        }
+
+        private void AddDockHints()
+        {
+            if (_toDock == null)
+                return;
+
+            if (_toDock.RootWindow.Window != _dragSourceWindow)
+                _toDock.RootWindow.Window.MouseUp += OnMouseUp;
+
+            _dockHintDown = AddHintControl(new Float2(0.5f, 1));
+            _dockHintUp = AddHintControl(new Float2(0.5f, 0));
+            _dockHintLeft = AddHintControl(new Float2(0, 0.5f));
+            _dockHintRight = AddHintControl(new Float2(1, 0.5f));
+            _dockHintCenter = AddHintControl(new Float2(0.5f, 0.5f));
+
+            Control AddHintControl(Float2 pivot)
+            {
+                Control hintControl = _toDock.AddChild<Control>();
+                hintControl.AnchorPreset = AnchorPresets.StretchAll;
+                hintControl.Offsets = Margin.Zero;
+                hintControl.Size = new Float2(HintControlSize);
+                hintControl.BackgroundColor = Style.Current.DragWindow.AlphaMultiplied(0.6f);
+                hintControl.Pivot = pivot;
+                hintControl.PivotRelative = true;
+                return hintControl;
+            }
+        }
+        
+        private void RemoveDockHints()
+        {
+            if (_toDock == null)
+                return;
+
+            if (_toDock.RootWindow.Window != _dragSourceWindow)
+                _toDock.RootWindow.Window.MouseUp -= OnMouseUp;
+
+            _dockHintDown?.Parent.RemoveChild(_dockHintDown);
+            _dockHintUp?.Parent.RemoveChild(_dockHintUp);
+            _dockHintLeft?.Parent.RemoveChild(_dockHintLeft);
+            _dockHintRight?.Parent.RemoveChild(_dockHintRight);
+            _dockHintCenter?.Parent.RemoveChild(_dockHintCenter);
+            _dockHintDown = _dockHintUp = _dockHintLeft = _dockHintRight = _dockHintCenter = null;
+        }
+
+        private void UpdateRects()
+        {
+            // Cache mouse position
+            _mouse = Platform.MousePosition;
+
+            // Check intersection with any dock panel
+            DockPanel dockPanel = null;
+            if (_toMove.MasterPanel.HitTest(ref _mouse, _toMove, out var hitResults))
+            {
+                dockPanel = hitResults[0];
+
+                // Prefer panel which currently has focus
+                foreach (var hit in hitResults)
+                {
+                    if (hit.RootWindow.Window.IsFocused)
+                    {
+                        dockPanel = hit;
+                        break;
+                    }
+                }
+
+                // Prefer panel in the same window we hit earlier
+                if (dockPanel?.RootWindow != _toDock?.RootWindow)
+                {
+                    foreach (var hit in hitResults)
+                    {
+                        if (hit.RootWindow == _toDock?.RootWindow)
+                        {
+                            dockPanel = _toDock;
+                            break;
+                        }
+                    }
+                }
+            }
+            
+            if (dockPanel != _toDock)
+            {
+                RemoveDockHints();
+                _toDock = dockPanel;
+                AddDockHints();
+
+                // Make sure the all the dock hint areas are not under other windows
+                _toDock?.RootWindow.Window.BringToFront();
+
+                // Make the dragged window transparent when dock hints are visible
+                _toMove.Window.Window.Opacity = _toDock == null ? 1.0f : DragWindowOpacity;
+            }
+            
+            // Check dock state to use
+            bool showProxyHints = _toDock != null;
+            bool showBorderHints = showProxyHints;
+            bool showCenterHint = showProxyHints;
+            Control hoveredHintControl = null;
+            Float2 hoveredSizeOverride = Float2.Zero;
+            if (showProxyHints)
+            {
+                // If moved window has not only tabs but also child panels disable docking as tab
+                if (_toMove.ChildPanelsCount > 0)
+                    showCenterHint = false;
+
+                // Disable docking windows with one or more dock panels inside
+                if (_toMove.ChildPanelsCount > 0)
+                    showBorderHints = false;
+
+                // Get dock area
+                _rectDock = _toDock.DockAreaBounds;
+
+                // Cache dock rectangles
+                var size = _rectDock.Size / Platform.DpiScale;
+                var offset = _toDock.PointFromScreen(_rectDock.Location);
+                var borderMargin = 4.0f;
+                var hintWindowsSize = HintControlSize;
+                var hintWindowsSize2 = hintWindowsSize * 0.5f;
+                var hintPreviewSize = new Float2(Math.Max(HintControlSize * 2, size.X * 0.5f), Math.Max(HintControlSize * 2, size.Y * 0.5f));
+                var centerX = size.X * 0.5f;
+                var centerY = size.Y * 0.5f;
+                _rUpper = new Rectangle(centerX - hintWindowsSize2, borderMargin, hintWindowsSize, hintWindowsSize) + offset;
+                _rBottom = new Rectangle(centerX - hintWindowsSize2, size.Y - hintWindowsSize - borderMargin, hintWindowsSize, hintWindowsSize) + offset;
+                _rLeft = new Rectangle(borderMargin, centerY - hintWindowsSize2, hintWindowsSize, hintWindowsSize) + offset;
+                _rRight = new Rectangle(size.X - hintWindowsSize - borderMargin, centerY - hintWindowsSize2, hintWindowsSize, hintWindowsSize) + offset;
+                _rCenter = new Rectangle(centerX - hintWindowsSize2, centerY - hintWindowsSize2, hintWindowsSize, hintWindowsSize) + offset;
+
+                // Hit test, and calculate the approximation for filled area when hovered over the hint
+                DockState toSet = DockState.Float;
+                if (showBorderHints)
+                {
+                    if (_rUpper.Contains(_toDock.PointFromScreen(_mouse)))
+                    {
+                        toSet = DockState.DockTop;
+                        hoveredHintControl = _dockHintUp;
+                        hoveredSizeOverride = new Float2(size.X, hintPreviewSize.Y);
+                    }
+                    else if (_rBottom.Contains(_toDock.PointFromScreen(_mouse)))
+                    {
+                        toSet = DockState.DockBottom;
+                        hoveredHintControl = _dockHintDown;
+                        hoveredSizeOverride = new Float2(size.X, hintPreviewSize.Y);
+                    }
+                    else if (_rLeft.Contains(_toDock.PointFromScreen(_mouse)))
+                    {
+                        toSet = DockState.DockLeft;
+                        hoveredHintControl = _dockHintLeft;
+                        hoveredSizeOverride = new Float2(hintPreviewSize.X, size.Y);
+                    }
+                    else if (_rRight.Contains(_toDock.PointFromScreen(_mouse)))
+                    {
+                        toSet = DockState.DockRight;
+                        hoveredHintControl = _dockHintRight;
+                        hoveredSizeOverride = new Float2(hintPreviewSize.X, size.Y);
+                    }
+                }
+                if (showCenterHint && _rCenter.Contains(_toDock.PointFromScreen(_mouse)))
+                {
+                    toSet = DockState.DockFill;
+                    hoveredHintControl = _dockHintCenter;
+                    hoveredSizeOverride = new Float2(size.X, size.Y);
+                }
+
+                _toSet = toSet;
+            }
+            else
+            {
+                _toSet = DockState.Float;
+            }
+            
+            // Update sizes and opacity of hint controls
+            if (_toDock != null)
+            {
+                if (hoveredHintControl != _dockHintDown)
+                {
+                    _dockHintDown.Size = new Float2(HintControlSize);
+                    _dockHintDown.BackgroundColor = Style.Current.DragWindow.AlphaMultiplied(0.6f);
+                }
+                if (hoveredHintControl != _dockHintLeft)
+                {
+                    _dockHintLeft.Size = new Float2(HintControlSize);
+                    _dockHintLeft.BackgroundColor = Style.Current.DragWindow.AlphaMultiplied(0.6f);
+                }
+                if (hoveredHintControl != _dockHintRight)
+                {
+                    _dockHintRight.Size = new Float2(HintControlSize);
+                    _dockHintRight.BackgroundColor = Style.Current.DragWindow.AlphaMultiplied(0.6f);
+                }
+                if (hoveredHintControl != _dockHintUp)
+                {
+                    _dockHintUp.Size = new Float2(HintControlSize);
+                    _dockHintUp.BackgroundColor = Style.Current.DragWindow.AlphaMultiplied(0.6f);
+                }
+                if (hoveredHintControl != _dockHintCenter)
+                {
+                    _dockHintCenter.Size = new Float2(HintControlSize);
+                    _dockHintCenter.BackgroundColor = Style.Current.DragWindow.AlphaMultiplied(0.6f);
+                }
+
+                if (_toSet != DockState.Float)
+                {
+                    if (hoveredHintControl != null)
+                    {
+                        hoveredHintControl.BackgroundColor = Style.Current.DragWindow.AlphaMultiplied(1.0f);
+                        hoveredHintControl.Size = hoveredSizeOverride;
+                    }
+                }
+            }
+
+            // Update hint controls visibility and location
+            if (showProxyHints)
+            {
+                if (hoveredHintControl != _dockHintDown)
+                    _dockHintDown.Location = _rBottom.Location;
+                if (hoveredHintControl != _dockHintLeft)
+                    _dockHintLeft.Location = _rLeft.Location;
+                if (hoveredHintControl != _dockHintRight)
+                    _dockHintRight.Location = _rRight.Location;
+                if (hoveredHintControl != _dockHintUp)
+                    _dockHintUp.Location = _rUpper.Location;
+                if (hoveredHintControl != _dockHintCenter)
+                    _dockHintCenter.Location = _rCenter.Location;
+                
+                _dockHintDown.Visible = showProxyHints & showBorderHints;
+                _dockHintLeft.Visible = showProxyHints & showBorderHints;
+                _dockHintRight.Visible = showProxyHints & showBorderHints;
+                _dockHintUp.Visible = showProxyHints & showBorderHints;
+                _dockHintCenter.Visible = showProxyHints & showCenterHint;
+            }
+        }
+
+        private void OnMouseUp(ref Float2 location, MouseButton button, ref bool handled)
+        {
+            if (button == MouseButton.Left)
+                Dispose();
+        }
+
+        private void OnUpdate()
+        {
+            var mousePos = Platform.MousePosition;
+            if (_mouse != mousePos)
+                OnMouseMove(mousePos);
+        }
+        
+        private void OnMouseMove(Float2 mousePos)
+        {
+            if (_dragSourceWindow != null)
+                _toMove.Window.Window.Position = mousePos - _dragOffset;
+
+            UpdateRects();
+        }
+    }
+}

Source/Editor/Modules/UIModule.cs

@@ -16,7 +16,7 @@ using FlaxEditor.Windows;
 using FlaxEngine;
 using FlaxEngine.GUI;
 using FlaxEngine.Json;
-using DockHintWindow = FlaxEditor.GUI.Docking.DockHintWindow;
+using WindowDragHelper = FlaxEditor.GUI.Docking.WindowDragHelper;
 using MasterDockPanel = FlaxEditor.GUI.Docking.MasterDockPanel;
 using FlaxEditor.Content.Settings;
 using FlaxEditor.Options;
@@ -456,13 +456,6 @@ namespace FlaxEditor.Modules
             UpdateToolstrip();
         }
 
-        /// <inheritdoc />
-        public override void OnExit()
-        {
-            // Cleanup dock panel hint proxy windows (Flax will destroy them by var but it's better to clear them earlier)
-            DockHintWindow.Proxy.Dispose();
-        }
-
         private IColorPickerDialog ShowPickColorDialog(Control targetControl, Color initialValue, ColorValueBox.ColorPickerEvent colorChanged, ColorValueBox.ColorPickerClosedEvent pickerClosed, bool useDynamicEditing)
         {
             var dialog = new ColorPickerDialog(initialValue, colorChanged, pickerClosed, useDynamicEditing);

Source/Engine/Platform/Base/WindowBase.h

@@ -429,7 +429,7 @@ public:
 
 public:
     /// <summary>
-    /// Starts drag and drop operation
+    /// Starts a drag and drop operation.
     /// </summary>
     /// <param name="data">The data.</param>
     /// <returns>The result.</returns>
@@ -438,6 +438,18 @@ public:
         return DragDropEffect::None;
     }
 
+    /// <summary>
+    /// Starts a window drag and drop operation.
+    /// </summary>
+    /// <param name="data">The data.</param>
+    /// <param name="offset">The offset for positioning the window from cursor.</param>
+    /// <param name="dragSourceWindow">The window where dragging started.</param>
+    /// <returns>The result.</returns>
+    API_FUNCTION() virtual DragDropEffect DoDragDrop(const StringView& data, const Float2& offset, Window* dragSourceWindow)
+    {
+        return DragDropEffect::None;
+    }
+
     /// <summary>
     /// Starts the mouse tracking.
     /// </summary>

Source/Engine/Platform/SDL/SDLPlatform.Linux.cpp

@@ -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,8 +1595,18 @@ 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;
 }
 
@@ -930,7 +1622,169 @@ bool SDLPlatform::UsesXWayland()
 
 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

Source/Engine/Platform/SDL/SDLPlatform.Windows.cpp

@@ -1,16 +1,24 @@
 // 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)
@@ -31,22 +39,68 @@ bool SDLCALL SDLPlatform::EventMessageHook(void* userdata, MSG* msg)
         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);
-        
-        auto hit = static_cast<WindowHitCodes>(msg->wParam);
-        if (SDLPlatform::CheckWindowDragging(window, hit))
-            return false;
+        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::InitPlatform()
 {
-    // Workaround required for handling window dragging events properly for DockHintWindow
+    // Workaround required for handling window dragging events properly
     SDL_SetWindowsMessageHook(&EventMessageHook, nullptr);
 
     if (WindowsPlatform::Init())
@@ -55,6 +109,26 @@ bool SDLPlatform::InitPlatform()
     return false;
 }
 
+bool SDLPlatform::UsesWindows()
+{
+    return true;
+}
+
+bool SDLPlatform::UsesWayland()
+{
+    return false;
+}
+
+bool SDLPlatform::UsesXWayland()
+{
+    return false;
+}
+
+bool SDLPlatform::UsesX11()
+{
+    return false;
+}
+
 void SDLPlatform::SetHighDpiAwarenessEnabled(bool enable)
 {
     // Other supported values: "permonitor", "permonitorv2"

Source/Engine/Platform/SDL/SDLPlatform.cpp

@@ -10,6 +10,7 @@
 #include "Engine/Platform/BatteryInfo.h"
 #include "Engine/Platform/WindowsManager.h"
 #include "Engine/Platform/SDL/SDLInput.h"
+#include "Engine/Engine/Engine.h"
 
 #include <SDL3/SDL_hints.h>
 #include <SDL3/SDL_init.h>
@@ -19,6 +20,7 @@
 #include <SDL3/SDL_system.h>
 #include <SDL3/SDL_version.h>
 #include <SDL3/SDL_locale.h>
+#include <SDL3/SDL_timer.h>
 
 #if PLATFORM_LINUX
 #include "Engine/Engine/CommandLine.h"
@@ -28,6 +30,11 @@
 
 #define DefaultDPI 96
 
+Window* draggedWindow = nullptr;
+#if PLATFORM_WINDOWS
+extern Float2 draggedWindowStartPosition;
+extern Float2 draggedWindowMousePosition;
+#endif
 uint32 SDLPlatform::DraggedWindowId = 0;
 
 namespace
@@ -69,12 +76,14 @@ bool SDLPlatform::Init()
     SDL_SetHint(SDL_HINT_MOUSE_RELATIVE_WARP_MOTION, "0");
     SDL_SetHint(SDL_HINT_MOUSE_RELATIVE_CURSOR_VISIBLE, "1"); // Needed for tracking mode
     SDL_SetHint(SDL_HINT_MOUSE_RELATIVE_MODE_CENTER, "0"); // 
+    SDL_SetHint(SDL_HINT_MOUSE_DOUBLE_CLICK_RADIUS, "8"); // Reduce the default mouse double-click radius
 
     //SDL_SetHint(SDL_HINT_MOUSE_RELATIVE_MODE_WARP, "1"); // Disables raw mouse input
     SDL_SetHint(SDL_HINT_WINDOWS_RAW_KEYBOARD, "1");
 
     SDL_SetHint(SDL_HINT_VIDEO_WAYLAND_SCALE_TO_DISPLAY, "1");
 
+#if PLATFORM_WINDOWS
     // Disable SDL clipboard support
     SDL_SetEventEnabled(SDL_EVENT_CLIPBOARD_UPDATE, false);
 
@@ -84,6 +93,10 @@ bool SDLPlatform::Init()
     SDL_SetEventEnabled(SDL_EVENT_DROP_BEGIN, false);
     SDL_SetEventEnabled(SDL_EVENT_DROP_COMPLETE, false);
     SDL_SetEventEnabled(SDL_EVENT_DROP_POSITION, false);
+#endif
+
+    //if (InitPlatform())
+    //    return true;
 
     if (!SDL_InitSubSystem(SDL_INIT_VIDEO | SDL_INIT_GAMEPAD))
         Platform::Fatal(String::Format(TEXT("Failed to initialize SDL: {0}."), String(SDL_GetError())));
@@ -104,7 +117,7 @@ bool SDLPlatform::Init()
         }
     }
     SDL_free(locales);
-    
+
     if (InitPlatform())
         return true;
 
@@ -142,6 +155,7 @@ void SDLPlatform::Tick()
 {
     SDLInput::Update();
 
+#if false
     if (DraggedWindowId != 0)
     {
         Float2 mousePos;
@@ -196,6 +210,71 @@ void SDLPlatform::Tick()
 #endif
         }
     }
+#endif
+
+#if PLATFORM_WINDOWS
+    auto watch = [](void* userdata, SDL_Event* event) -> bool
+        {
+            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;
+        };
+
+    SDL_AddEventWatch(watch, &draggedWindow);
+#endif
 
     SDL_PumpEvents();
     SDL_Event events[32];
@@ -210,6 +289,32 @@ void SDLPlatform::Tick()
         else
             SDLPlatform::HandleEvent(events[i]);
     }
+
+#if PLATFORM_WINDOWS
+    SDL_RemoveEventWatch(watch, &draggedWindow);
+#endif
+    // Handle Windows and X11 window dragging release
+    if (draggedWindow != nullptr)
+    {
+        Float2 mousePosition;
+        auto buttons = SDL_GetGlobalMouseState(&mousePosition.X, &mousePosition.Y);
+        bool buttonReleased = (buttons & SDL_BUTTON_MASK(SDL_BUTTON_LEFT)) == 0;
+        if (buttonReleased || UsesWindows())
+        {
+            // 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 SDLPlatform::HandleEvent(SDL_Event& event)
@@ -264,7 +369,16 @@ void SDLPlatform::OpenUrl(const StringView& url)
 Float2 SDLPlatform::GetMousePosition()
 {
     Float2 pos;
-    SDL_GetGlobalMouseState(&pos.X, &pos.Y);
+    if (UsesWayland())
+    {
+        // Wayland doesn't support reporting global mouse position,
+        // use the last known reported position we got from received window events.
+        pos = Input::GetMouseScreenPosition();
+    }
+    else if (UsesX11())
+        SDL_GetGlobalMouseState(&pos.X, &pos.Y);
+    else
+        pos = Input::GetMouseScreenPosition();
     return pos;
 }
 
@@ -313,25 +427,6 @@ Window* SDLPlatform::CreateWindow(const CreateWindowSettings& settings)
     return New<SDLWindow>(settings);
 }
 
-#if !PLATFORM_LINUX
-
-bool SDLPlatform::UsesWayland()
-{
-    return false;
-}
-
-bool SDLPlatform::UsesXWayland()
-{
-    return false;
-}
-
-bool SDLPlatform::UsesX11()
-{
-    return false;
-}
-
-#endif
-
 #if PLATFORM_LINUX
 DialogResult MessageBox::Show(Window* parent, const StringView& text, const StringView& caption, MessageBoxButtons buttons, MessageBoxIcon icon)
 {

Source/Engine/Platform/SDL/SDLPlatform.h

@@ -57,6 +57,7 @@ public:
 #if PLATFORM_LINUX
     static void* GetXDisplay();
 #endif
+    static bool UsesWindows();
     static bool UsesWayland();
     static bool UsesXWayland();
     static bool UsesX11();

Source/Engine/Platform/SDL/SDLWindow.cpp

@@ -33,8 +33,23 @@
 #endif
 #elif PLATFORM_LINUX
 #include "Engine/Platform/Linux/IncludeX11.h"
+#include "Engine/Core/Collections/Dictionary.h"
+#include <wayland/xdg-toplevel-drag-v1.h>
+#include <wayland/xdg-shell.h>
+
+extern Dictionary<wl_surface*, SDLWindow*> SurfaceToWindowMap;
+extern SDLWindow* LastPointerWindow;
+extern Int2 LastPointerPosition;
+extern uint32 ImplicitGrabSerial;
+extern xdg_toplevel_drag_manager_v1* DragManager;
+extern wl_seat* WaylandSeat;
+extern wl_data_device_manager* WaylandDataDeviceManager;
+extern xdg_wm_base* WaylandXdgWmBase;
+extern bool waylandDraggingActive;
 #endif
 
+extern Window* draggedWindow;
+
 #define DefaultDPI 96
 
 namespace
@@ -52,6 +67,11 @@ void GetRelativeWindowOffset(WindowType type, SDLWindow* parentWindow, Int2& pos
 Int2 GetSDLWindowScreenPosition(const SDLWindow* window);
 void SetSDLWindowScreenPosition(const SDLWindow* window, const int x, const int y);
 
+bool IsPopupWindow(WindowType type)
+{
+    return type == WindowType::Popup || type == WindowType::Tooltip;
+}
+
 class SDLDropFilesData : public IGuiData
 {
 public:
@@ -214,9 +234,9 @@ void* GetNativeWindowPointer(SDL_Window* window)
 #if PLATFORM_WINDOWS
     windowPtr = SDL_GetPointerProperty(props, SDL_PROP_WINDOW_WIN32_HWND_POINTER, nullptr);
 #elif PLATFORM_LINUX
-    windowPtr = SDL_GetPointerProperty(SDL_GetWindowProperties(window), SDL_PROP_WINDOW_WAYLAND_SURFACE_POINTER, nullptr);
+    windowPtr = SDL_GetPointerProperty(props, SDL_PROP_WINDOW_WAYLAND_SURFACE_POINTER, nullptr);
     if (windowPtr == nullptr)
-        windowPtr = (void*)SDL_GetNumberProperty(SDL_GetWindowProperties(window), SDL_PROP_WINDOW_X11_WINDOW_NUMBER, 0);
+        windowPtr = (void*)SDL_GetNumberProperty(props, SDL_PROP_WINDOW_X11_WINDOW_NUMBER, 0);
 #elif PLATFORM_MAC
     windowPtr = SDL_GetPointerProperty(props, SDL_PROP_WINDOW_COCOA_WINDOW_POINTER, nullptr);
 #elif PLATFORM_ANDROID
@@ -266,6 +286,9 @@ SDLWindow::~SDLWindow()
     if (_window == nullptr)
         return;
 
+#if PLATFORM_LINUX
+    SurfaceToWindowMap.RemoveValue(this);
+#endif
     SDL_StopTextInput(_window);
     SDL_DestroyWindow(_window);
 
@@ -414,13 +437,19 @@ void SDLWindow::HandleEvent(SDL_Event& event)
     {
         _cachedClientRectangle.Location = Float2(static_cast<float>(event.window.data1), static_cast<float>(event.window.data2));
 #if PLATFORM_LINUX
-        if (SDLPlatform::UsesX11() && !SDLPlatform::UsesXWayland())
+        if (SDLPlatform::UsesX11())
         {
             // X11 doesn't report any mouse events when mouse is over the caption area, send a simulated event instead...
             Float2 mousePosition;
             auto buttons = SDL_GetGlobalMouseState(&mousePosition.X, &mousePosition.Y);
-            if ((buttons & SDL_BUTTON_MASK(SDL_BUTTON_LEFT)) != 0)
-                SDLPlatform::CheckWindowDragging(this, WindowHitCodes::Caption);
+            if ((buttons & SDL_BUTTON_MASK(SDL_BUTTON_LEFT)) != 0 && draggedWindow == nullptr)
+            {
+                // TODO: verify mouse position, window focus
+                bool result = false;
+                OnLeftButtonHit(WindowHitCodes::Caption, result);
+                if (result)
+                    draggedWindow = this;
+            }
         }
 #endif
         return;
@@ -543,10 +572,49 @@ void SDLWindow::HandleEvent(SDL_Event& event)
         }
         return;
     }
-#if false
-    case SDL_EVENT_DROP_BEGIN:
+#if true
+    case SDL_EVENT_CLIPBOARD_UPDATE:
     {
-        Focus();
+        LOG(Info, "SDL_EVENT_CLIPBOARD_UPDATE");
+        return;
+    }
+    case SDL_EVENT_DROP_BEGIN:
+    case SDL_EVENT_DROP_POSITION:
+    case SDL_EVENT_DROP_FILE:
+    case SDL_EVENT_DROP_TEXT:
+    case SDL_EVENT_DROP_COMPLETE:
+    {
+        //LOG(Info, "SDL_EVENT_DROP_BEGIN");
+
+        static Float2 dragStartPosition = Float2::Zero;
+
+        auto dpiScale = GetDpiScale();
+        //const Float2 mousePos = ClientToScreen({ event.drop.x * dpiScale, event.drop.y * dpiScale});
+        const Float2 mousePos = dragStartPosition + Float2(event.drop.x * dpiScale, event.drop.y * dpiScale);
+        DragDropEffect effect = DragDropEffect::None;
+        auto daata = event.drop.data;
+
+        SDLDropTextData dropData;
+
+        
+
+        if (event.type == SDL_EVENT_DROP_BEGIN)
+        {
+            dragStartPosition = Platform::GetMousePosition();
+            OnDragEnter(&dropData, mousePos, effect);
+        }
+        else if (event.type == SDL_EVENT_DROP_POSITION)
+        {
+            Input::Mouse->OnMouseMove(mousePos, this);
+            OnDragOver(&dropData, mousePos, effect);
+        }
+        else if (event.type == SDL_EVENT_DROP_FILE)
+            OnDragDrop(&dropData, mousePos, effect);
+        else if (event.type == SDL_EVENT_DROP_TEXT)
+            OnDragDrop(&dropData, mousePos, effect);
+        else if (event.type == SDL_EVENT_DROP_COMPLETE)
+            OnDragLeave();
+        /*Focus();
         Float2 mousePosition;
         SDL_GetGlobalMouseState(&mousePosition.X, &mousePosition.Y);
         mousePosition = ScreenToClient(mousePosition);
@@ -554,49 +622,68 @@ void SDLWindow::HandleEvent(SDL_Event& event)
         DragDropEffect effect;
         SDLDropTextData dropData;
         OnDragEnter(&dropData, mousePosition, effect);
-        OnDragOver(&dropData, mousePosition, effect);
-        return;
+        OnDragOver(&dropData, mousePosition, effect);*/
+        break;
     }
-    case SDL_EVENT_DROP_POSITION:
+    /*case SDL_EVENT_DROP_POSITION:
     {
+        auto dpiScale = GetDpiScale();
+        //const Float2 mousePos = ClientToScreen({ event.drop.x * dpiScale, event.drop.y * dpiScale});
+        const Float2 mousePos(event.drop.x * dpiScale, event.drop.y * dpiScale);
         DragDropEffect effect = DragDropEffect::None;
+        auto daata = event.drop.data;
 
         SDLDropTextData dropData;
-        OnDragOver(&dropData, Float2(static_cast<float>(event.drop.x), static_cast<float>(event.drop.y)), effect);
-        return;
+        OnDragOver(&dropData, mousePos, effect);
+
+        break;
     }
     case SDL_EVENT_DROP_FILE:
     {
-        SDLDropFilesData dropData;
-        dropData.Files.Add(StringAnsi(event.drop.data).ToString()); // TODO: collect multiple files at once?
-
-        Focus();
-        
-        Float2 mousePosition;
-        SDL_GetGlobalMouseState(&mousePosition.X, &mousePosition.Y);
-        mousePosition = ScreenToClient(mousePosition);
+        LOG(Info, "SDL_EVENT_DROP_FILE");
+        auto dpiScale = GetDpiScale();
+        const Float2 mousePos = ClientToScreen({ event.drop.x * dpiScale, event.drop.y * dpiScale});
         DragDropEffect effect = DragDropEffect::None;
-        OnDragDrop(&dropData, mousePosition, effect);
+        auto daata = event.drop.data;
+
+        SDLDropTextData dropData;
+        OnDragDrop(&dropData, mousePos, effect);
+
+        
+
         return;
     }
     case SDL_EVENT_DROP_TEXT:
     {
-        SDLDropTextData dropData;
-        String str = StringAnsi(event.drop.data).ToString();
-        dropData.Text = StringView(str);
-
-        Focus();
-        Float2 mousePosition;
-        SDL_GetGlobalMouseState(&mousePosition.X, &mousePosition.Y);
-        mousePosition = ScreenToClient(mousePosition);
+        auto dpiScale = GetDpiScale();
+        const Float2 mousePos = ClientToScreen({ event.drop.x * dpiScale, event.drop.y * dpiScale});
         DragDropEffect effect = DragDropEffect::None;
-        OnDragDrop(&dropData, mousePosition, effect);
+        auto daata = event.drop.data;
+        auto str = String(event.drop.data);
+
+        LOG(Info, "SDL_EVENT_DROP_TEXT: {}", str);
+        
+        SDLDropTextData dropData;
+        OnDragDrop(&dropData, mousePos, effect);
+        
         return;
     }
     case SDL_EVENT_DROP_COMPLETE:
     {
+        LOG(Info, "SDL_EVENT_DROP_COMPLETE");
+        auto dpiScale = GetDpiScale();
+        const Float2 mousePos = ClientToScreen({ event.drop.x * dpiScale, event.drop.y * dpiScale});
+        DragDropEffect effect = DragDropEffect::None;
+        auto daata = event.drop.data;
+        
+        OnDragLeave();
+        
+        if (SDLPlatform::UsesWayland())
+        {
+            //_dragOver = false;
+        }
         return;
-    }
+    }*/
 #endif
     case SDL_EVENT_WINDOW_MOUSE_LEAVE:
     {
@@ -605,6 +692,44 @@ void SDLWindow::HandleEvent(SDL_Event& event)
 #endif
         break;
     }
+//#if PLATFORM_LINUX
+    case SDL_EVENT_MOUSE_BUTTON_DOWN:
+    {
+        LOG(Info, "SDL_EVENT_MOUSE_BUTTON_DOWN");
+        break;
+    }
+    case SDL_EVENT_MOUSE_BUTTON_UP:
+    {
+#if PLATFORM_LINUX
+        if (SDLPlatform::UsesWayland() && waylandDraggingActive)
+        {
+            LOG(Info, "SDL_EVENT_MOUSE_BUTTON_UP, dragging");
+            // We are dragging a window, keep the button held down
+            return;
+        }
+        else
+#endif
+        {
+            LOG(Info, "SDL_EVENT_MOUSE_BUTTON_UP: {}", GetTitle());
+#if PLATFORM_WINDOWS
+            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);
+            }
+#endif
+        }
+        break;
+    }
+//#endif
     default:
         break;
     }
@@ -639,9 +764,9 @@ void SDLWindow::Show()
     else if (_settings.Parent == nullptr)
         BringToFront();
     
-    // Reused top-most windows (DockHintWindow) doesn't stay on top for some reason
-    if (_settings.IsTopmost && _settings.Type != WindowType::Tooltip)
-        SDL_SetWindowAlwaysOnTop(_window, true);
+    // Reused top-most windows doesn't stay on top for some reason
+    if (_settings.IsTopmost && !IsPopupWindow(_settings.Type))
+        SetIsAlwaysOnTop(true);
 
     if (_isTrackingMouse)
     {
@@ -662,6 +787,11 @@ void SDLWindow::Hide()
 
     SDL_HideWindow(_window);
 
+#if PLATFORM_LINUX
+    //if (SDLPlatform::UsesWayland() && _dragOver)
+    //    StopDragging();
+#endif
+
     WindowBase::Hide();
 }
 
@@ -760,10 +890,20 @@ bool SDLWindow::IsForegroundWindow() const
 
 void SDLWindow::BringToFront(bool force)
 {
+#if PLATFORM_WINDOWS // FIXME
     auto activateWhenRaised = SDL_GetHint(SDL_HINT_WINDOW_ACTIVATE_WHEN_RAISED);
     SDL_SetHint(SDL_HINT_WINDOW_ACTIVATE_WHEN_RAISED, "0");
     SDL_RaiseWindow(_window);
     SDL_SetHint(SDL_HINT_WINDOW_ACTIVATE_WHEN_RAISED, activateWhenRaised);
+#endif
+    if (SDLPlatform::UsesX11())
+    {
+        auto activateWhenRaised = SDL_GetHint(SDL_HINT_WINDOW_ACTIVATE_WHEN_RAISED);
+        SDL_SetHint(SDL_HINT_WINDOW_ACTIVATE_WHEN_RAISED, "0");
+        SDL_RaiseWindow(_window);
+        SDL_SetHint(SDL_HINT_WINDOW_ACTIVATE_WHEN_RAISED, activateWhenRaised);
+        SDL_SyncWindow(_window);
+    }
 }
 
 void SDLWindow::SetClientBounds(const Rectangle& clientArea)
@@ -777,11 +917,6 @@ void SDLWindow::SetClientBounds(const Rectangle& clientArea)
     SDL_SetWindowSize(_window, newW, newH);
 }
 
-bool IsPopupWindow(WindowType type)
-{
-    return type == WindowType::Popup || type == WindowType::Tooltip;
-}
-
 void GetRelativeWindowOffset(WindowType type, SDLWindow* parentWindow, Int2& positionOffset)
 {
     if (!IsPopupWindow(type))
@@ -848,7 +983,7 @@ void SDLWindow::SetIsFullscreen(bool isFullscreen)
     if (!isFullscreen)
     {
         // The window is set to always-on-top for some reason when leaving fullscreen
-        SDL_SetWindowAlwaysOnTop(_window, false);
+        SetIsAlwaysOnTop(false);
     }
 
     WindowBase::SetIsFullscreen(isFullscreen);
@@ -1116,5 +1251,68 @@ void SDLWindow::UpdateCursor()
     SDL_SetCursor(Cursors[index]);
 }
 
+//bool draggingActive = false;
+DragDropEffect SDLWindow::DoDragDrop(const StringView& data, const Float2& offset, Window* dragSourceWindow)
+{
+    // TODO: this needs to be non-blocking in all platforms
+    LOG(Info, "StartDragging {}", offset);
+
+    Float2 dragOffset = offset;
+    if (_settings.HasBorder)
+    {
+#if PLATFORM_LINUX
+        if (SDLPlatform::UsesWayland() && dragSourceWindow == this)
+        {
+            // Wayland includes the decorations in the client-space coordinates, adjust the offset for it.
+            // Assume the title decoration is 25px thick...
+            float topOffset = 25.0f;
+            dragOffset += Float2(0.0f, topOffset);
+        }
+#endif
+    }
+
+#if PLATFORM_LINUX
+    if (SDLPlatform::UsesWayland())
+        DoDragDropWayland(String("notawindow"), dragSourceWindow, dragOffset);
+    else
+#endif
+    {
+        Show();
+        
+        //draggingActive = true;
+
+        /*auto watch = [](void* userdata, SDL_Event* event) -> bool
+            {
+                if (event->window.type == SDL_EVENT_WINDOW_EXPOSED)
+                {
+                    LOG(Info, "exposedo");
+                }
+                else
+                    LOG(Info, "eventy");*/
+                /*SDLPlatform::Tick();
+                Engine::OnUpdate();//Scripting::Update(); // For docking updates
+                Engine::OnDraw();*//*
+                return true;
+            };
+
+        SDL_AddEventWatch(watch, nullptr);*/
+
+        /*while (draggingActive)
+        {
+            SDLPlatform::Tick();
+            Engine::OnUpdate();//Scripting::Update(); // For docking updates
+            Engine::OnDraw();
+
+            Platform::Sleep(1);
+        }*/
+
+        //SDL_RemoveEventWatch(watch, nullptr);
+
+        // The mouse up event was ignored earlier, release the button now
+        //Input::Mouse->OnMouseUp(Platform::GetMousePosition(), MouseButton::Left, this);
+    }
+    return DragDropEffect::None;
+}
+
 #endif
 

Source/Engine/Platform/SDL/SDLWindow.h

@@ -61,7 +61,7 @@ private:
     void UpdateCursor();
 
 #if PLATFORM_LINUX
-    DragDropEffect DoDragDropWayland(const StringView& data);
+    DragDropEffect DoDragDropWayland(const StringView& data, Window* dragSourceWindow = nullptr, Float2 dragOffset = Float2::Zero);
     DragDropEffect DoDragDropX11(const StringView& data);
 #endif
 
@@ -104,6 +104,7 @@ public:
     String GetTitle() const override;
     void SetTitle(const StringView& title) override;
     DragDropEffect DoDragDrop(const StringView& data) override;
+    DragDropEffect DoDragDrop(const StringView& data, const Float2& offset, Window* dragSourceWindow) override;
     void StartTrackingMouse(bool useMouseScreenOffset) override;
     void EndTrackingMouse() override;
     void StartClippingCursor(const Rectangle& bounds) override;

Source/Engine/UI/GUI/Tooltip.cs

@@ -207,7 +207,7 @@ namespace FlaxEngine.GUI
             var rightBottomLocationSS = locationSS + dpiSize;
 
             // Prioritize tooltip placement within parent window, fall back to virtual desktop
-            if (rightBottomMonitorBounds.Y < rightBottomLocationSS.Y)
+            /*if (rightBottomMonitorBounds.Y < rightBottomLocationSS.Y)
             {
                 // Direction: up
                 locationSS.Y -= dpiSize.Y + flipOffset;
@@ -216,7 +216,7 @@ namespace FlaxEngine.GUI
             {
                 // Direction: left
                 locationSS.X -= dpiSize.X + flipOffset * 2;
-            }
+            }*/
         }
 
         /// <inheritdoc />

Source/ThirdParty/Wayland/Wayland.Build.cs

@@ -33,5 +33,10 @@ public class Wayland : ThirdPartyModule
         // Include generated protocol files for dependency
         options.PublicIncludePaths.Add(Path.Combine(FolderPath, "include"));
         options.SourceFiles.AddRange(Directory.GetFiles(FolderPath, "*.cpp", SearchOption.TopDirectoryOnly));
+        options.SourceFiles.AddRange(Directory.GetFiles(FolderPath, "*.c", SearchOption.TopDirectoryOnly));
+
+        // TODO: The glue code needs to be generated as C-code: https://gitlab.freedesktop.org/wayland/wayland/-/issues/90
+        //options.CompileEnv.CustomArgs.Add("-x c");
+        //options.LinkEnv.InputLibraries.Add("wayland-client");
     }
 }

Source/ThirdParty/Wayland/include/wayland/xdg-toplevel-drag-v1.h

@@ -0,0 +1,320 @@
+/* Generated by wayland-scanner 1.23.1 */
+
+#ifndef XDG_TOPLEVEL_DRAG_V1_CLIENT_PROTOCOL_H
+#define XDG_TOPLEVEL_DRAG_V1_CLIENT_PROTOCOL_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include "wayland-client.h"
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @page page_xdg_toplevel_drag_v1 The xdg_toplevel_drag_v1 protocol
+ * @section page_ifaces_xdg_toplevel_drag_v1 Interfaces
+ * - @subpage page_iface_xdg_toplevel_drag_manager_v1 - Move a window during a drag
+ * - @subpage page_iface_xdg_toplevel_drag_v1 - Object representing a toplevel move during a drag
+ * @section page_copyright_xdg_toplevel_drag_v1 Copyright
+ * <pre>
+ *
+ * Copyright 2023 David Redondo
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ * </pre>
+ */
+struct wl_data_source;
+struct xdg_toplevel;
+struct xdg_toplevel_drag_manager_v1;
+struct xdg_toplevel_drag_v1;
+
+#ifndef XDG_TOPLEVEL_DRAG_MANAGER_V1_INTERFACE
+#define XDG_TOPLEVEL_DRAG_MANAGER_V1_INTERFACE
+/**
+ * @page page_iface_xdg_toplevel_drag_manager_v1 xdg_toplevel_drag_manager_v1
+ * @section page_iface_xdg_toplevel_drag_manager_v1_desc Description
+ *
+ * This protocol enhances normal drag and drop with the ability to move a
+ * window at the same time. This allows having detachable parts of a window
+ * that when dragged out of it become a new window and can be dragged over
+ * an existing window to be reattached.
+ *
+ * A typical workflow would be when the user starts dragging on top of a
+ * detachable part of a window, the client would create a wl_data_source and
+ * a xdg_toplevel_drag_v1 object and start the drag as normal via
+ * wl_data_device.start_drag. Once the client determines that the detachable
+ * window contents should be detached from the originating window, it creates
+ * a new xdg_toplevel with these contents and issues a
+ * xdg_toplevel_drag_v1.attach request before mapping it. From now on the new
+ * window is moved by the compositor during the drag as if the client called
+ * xdg_toplevel.move.
+ *
+ * Dragging an existing window is similar. The client creates a
+ * xdg_toplevel_drag_v1 object and attaches the existing toplevel before
+ * starting the drag.
+ *
+ * Clients use the existing drag and drop mechanism to detect when a window
+ * can be docked or undocked. If the client wants to snap a window into a
+ * parent window it should delete or unmap the dragged top-level. If the
+ * contents should be detached again it attaches a new toplevel as described
+ * above. If a drag operation is cancelled without being dropped, clients
+ * should revert to the previous state, deleting any newly created windows
+ * as appropriate. When a drag operation ends as indicated by
+ * wl_data_source.dnd_drop_performed the dragged toplevel window's final
+ * position is determined as if a xdg_toplevel_move operation ended.
+ *
+ * Warning! The protocol described in this file is currently in the testing
+ * phase. Backward compatible changes may be added together with the
+ * corresponding interface version bump. Backward incompatible changes can
+ * only be done by creating a new major version of the extension.
+ * @section page_iface_xdg_toplevel_drag_manager_v1_api API
+ * See @ref iface_xdg_toplevel_drag_manager_v1.
+ */
+/**
+ * @defgroup iface_xdg_toplevel_drag_manager_v1 The xdg_toplevel_drag_manager_v1 interface
+ *
+ * This protocol enhances normal drag and drop with the ability to move a
+ * window at the same time. This allows having detachable parts of a window
+ * that when dragged out of it become a new window and can be dragged over
+ * an existing window to be reattached.
+ *
+ * A typical workflow would be when the user starts dragging on top of a
+ * detachable part of a window, the client would create a wl_data_source and
+ * a xdg_toplevel_drag_v1 object and start the drag as normal via
+ * wl_data_device.start_drag. Once the client determines that the detachable
+ * window contents should be detached from the originating window, it creates
+ * a new xdg_toplevel with these contents and issues a
+ * xdg_toplevel_drag_v1.attach request before mapping it. From now on the new
+ * window is moved by the compositor during the drag as if the client called
+ * xdg_toplevel.move.
+ *
+ * Dragging an existing window is similar. The client creates a
+ * xdg_toplevel_drag_v1 object and attaches the existing toplevel before
+ * starting the drag.
+ *
+ * Clients use the existing drag and drop mechanism to detect when a window
+ * can be docked or undocked. If the client wants to snap a window into a
+ * parent window it should delete or unmap the dragged top-level. If the
+ * contents should be detached again it attaches a new toplevel as described
+ * above. If a drag operation is cancelled without being dropped, clients
+ * should revert to the previous state, deleting any newly created windows
+ * as appropriate. When a drag operation ends as indicated by
+ * wl_data_source.dnd_drop_performed the dragged toplevel window's final
+ * position is determined as if a xdg_toplevel_move operation ended.
+ *
+ * Warning! The protocol described in this file is currently in the testing
+ * phase. Backward compatible changes may be added together with the
+ * corresponding interface version bump. Backward incompatible changes can
+ * only be done by creating a new major version of the extension.
+ */
+extern const struct wl_interface xdg_toplevel_drag_manager_v1_interface;
+#endif
+#ifndef XDG_TOPLEVEL_DRAG_V1_INTERFACE
+#define XDG_TOPLEVEL_DRAG_V1_INTERFACE
+/**
+ * @page page_iface_xdg_toplevel_drag_v1 xdg_toplevel_drag_v1
+ * @section page_iface_xdg_toplevel_drag_v1_desc Description
+ *
+ * @section page_iface_xdg_toplevel_drag_v1_api API
+ * See @ref iface_xdg_toplevel_drag_v1.
+ */
+/**
+ * @defgroup iface_xdg_toplevel_drag_v1 The xdg_toplevel_drag_v1 interface
+ *
+ */
+extern const struct wl_interface xdg_toplevel_drag_v1_interface;
+#endif
+
+#ifndef XDG_TOPLEVEL_DRAG_MANAGER_V1_ERROR_ENUM
+#define XDG_TOPLEVEL_DRAG_MANAGER_V1_ERROR_ENUM
+enum xdg_toplevel_drag_manager_v1_error {
+	/**
+	 * data_source already used for toplevel drag
+	 */
+	XDG_TOPLEVEL_DRAG_MANAGER_V1_ERROR_INVALID_SOURCE = 0,
+};
+#endif /* XDG_TOPLEVEL_DRAG_MANAGER_V1_ERROR_ENUM */
+
+#define XDG_TOPLEVEL_DRAG_MANAGER_V1_DESTROY 0
+#define XDG_TOPLEVEL_DRAG_MANAGER_V1_GET_XDG_TOPLEVEL_DRAG 1
+
+
+/**
+ * @ingroup iface_xdg_toplevel_drag_manager_v1
+ */
+#define XDG_TOPLEVEL_DRAG_MANAGER_V1_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel_drag_manager_v1
+ */
+#define XDG_TOPLEVEL_DRAG_MANAGER_V1_GET_XDG_TOPLEVEL_DRAG_SINCE_VERSION 1
+
+/** @ingroup iface_xdg_toplevel_drag_manager_v1 */
+static inline void
+xdg_toplevel_drag_manager_v1_set_user_data(struct xdg_toplevel_drag_manager_v1 *xdg_toplevel_drag_manager_v1, void *user_data)
+{
+	wl_proxy_set_user_data((struct wl_proxy *) xdg_toplevel_drag_manager_v1, user_data);
+}
+
+/** @ingroup iface_xdg_toplevel_drag_manager_v1 */
+static inline void *
+xdg_toplevel_drag_manager_v1_get_user_data(struct xdg_toplevel_drag_manager_v1 *xdg_toplevel_drag_manager_v1)
+{
+	return wl_proxy_get_user_data((struct wl_proxy *) xdg_toplevel_drag_manager_v1);
+}
+
+static inline uint32_t
+xdg_toplevel_drag_manager_v1_get_version(struct xdg_toplevel_drag_manager_v1 *xdg_toplevel_drag_manager_v1)
+{
+	return wl_proxy_get_version((struct wl_proxy *) xdg_toplevel_drag_manager_v1);
+}
+
+/**
+ * @ingroup iface_xdg_toplevel_drag_manager_v1
+ *
+ * Destroy this xdg_toplevel_drag_manager_v1 object. Other objects,
+ * including xdg_toplevel_drag_v1 objects created by this factory, are not
+ * affected by this request.
+ */
+static inline void
+xdg_toplevel_drag_manager_v1_destroy(struct xdg_toplevel_drag_manager_v1 *xdg_toplevel_drag_manager_v1)
+{
+	wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel_drag_manager_v1,
+			 XDG_TOPLEVEL_DRAG_MANAGER_V1_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel_drag_manager_v1), WL_MARSHAL_FLAG_DESTROY);
+}
+
+/**
+ * @ingroup iface_xdg_toplevel_drag_manager_v1
+ *
+ * Create an xdg_toplevel_drag for a drag and drop operation that is going
+ * to be started with data_source.
+ *
+ * This request can only be made on sources used in drag-and-drop, so it
+ * must be performed before wl_data_device.start_drag. Attempting to use
+ * the source other than for drag-and-drop such as in
+ * wl_data_device.set_selection will raise an invalid_source error.
+ *
+ * Destroying data_source while a toplevel is attached to the
+ * xdg_toplevel_drag is undefined.
+ */
+static inline struct xdg_toplevel_drag_v1 *
+xdg_toplevel_drag_manager_v1_get_xdg_toplevel_drag(struct xdg_toplevel_drag_manager_v1 *xdg_toplevel_drag_manager_v1, struct wl_data_source *data_source)
+{
+	struct wl_proxy *id;
+
+	id = wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel_drag_manager_v1,
+			 XDG_TOPLEVEL_DRAG_MANAGER_V1_GET_XDG_TOPLEVEL_DRAG, &xdg_toplevel_drag_v1_interface, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel_drag_manager_v1), 0, NULL, data_source);
+
+	return (struct xdg_toplevel_drag_v1 *) id;
+}
+
+#ifndef XDG_TOPLEVEL_DRAG_V1_ERROR_ENUM
+#define XDG_TOPLEVEL_DRAG_V1_ERROR_ENUM
+enum xdg_toplevel_drag_v1_error {
+	/**
+	 * valid toplevel already attached
+	 */
+	XDG_TOPLEVEL_DRAG_V1_ERROR_TOPLEVEL_ATTACHED = 0,
+	/**
+	 * drag has not ended
+	 */
+	XDG_TOPLEVEL_DRAG_V1_ERROR_ONGOING_DRAG = 1,
+};
+#endif /* XDG_TOPLEVEL_DRAG_V1_ERROR_ENUM */
+
+#define XDG_TOPLEVEL_DRAG_V1_DESTROY 0
+#define XDG_TOPLEVEL_DRAG_V1_ATTACH 1
+
+
+/**
+ * @ingroup iface_xdg_toplevel_drag_v1
+ */
+#define XDG_TOPLEVEL_DRAG_V1_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel_drag_v1
+ */
+#define XDG_TOPLEVEL_DRAG_V1_ATTACH_SINCE_VERSION 1
+
+/** @ingroup iface_xdg_toplevel_drag_v1 */
+static inline void
+xdg_toplevel_drag_v1_set_user_data(struct xdg_toplevel_drag_v1 *xdg_toplevel_drag_v1, void *user_data)
+{
+	wl_proxy_set_user_data((struct wl_proxy *) xdg_toplevel_drag_v1, user_data);
+}
+
+/** @ingroup iface_xdg_toplevel_drag_v1 */
+static inline void *
+xdg_toplevel_drag_v1_get_user_data(struct xdg_toplevel_drag_v1 *xdg_toplevel_drag_v1)
+{
+	return wl_proxy_get_user_data((struct wl_proxy *) xdg_toplevel_drag_v1);
+}
+
+static inline uint32_t
+xdg_toplevel_drag_v1_get_version(struct xdg_toplevel_drag_v1 *xdg_toplevel_drag_v1)
+{
+	return wl_proxy_get_version((struct wl_proxy *) xdg_toplevel_drag_v1);
+}
+
+/**
+ * @ingroup iface_xdg_toplevel_drag_v1
+ *
+ * Destroy this xdg_toplevel_drag_v1 object. This request must only be
+ * called after the underlying wl_data_source drag has ended, as indicated
+ * by the dnd_drop_performed or cancelled events. In any other case an
+ * ongoing_drag error is raised.
+ */
+static inline void
+xdg_toplevel_drag_v1_destroy(struct xdg_toplevel_drag_v1 *xdg_toplevel_drag_v1)
+{
+	wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel_drag_v1,
+			 XDG_TOPLEVEL_DRAG_V1_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel_drag_v1), WL_MARSHAL_FLAG_DESTROY);
+}
+
+/**
+ * @ingroup iface_xdg_toplevel_drag_v1
+ *
+ * Request that the window will be moved with the cursor during the drag
+ * operation. The offset is a hint to the compositor how the toplevel
+ * should be positioned relative to the cursor hotspot in surface local
+ * coordinates and relative to the geometry of the toplevel being attached.
+ * See xdg_surface.set_window_geometry. For example it might only
+ * be used when an unmapped window is attached. The attached window
+ * does not participate in the selection of the drag target.
+ *
+ * If the toplevel is unmapped while it is attached, it is automatically
+ * detached from the drag. In this case this request has to be called again
+ * if the window should be attached after it is remapped.
+ *
+ * This request can be called multiple times but issuing it while a
+ * toplevel with an active role is attached raises a toplevel_attached
+ * error.
+ */
+static inline void
+xdg_toplevel_drag_v1_attach(struct xdg_toplevel_drag_v1 *xdg_toplevel_drag_v1, struct xdg_toplevel *toplevel, int32_t x_offset, int32_t y_offset)
+{
+	wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel_drag_v1,
+			 XDG_TOPLEVEL_DRAG_V1_ATTACH, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel_drag_v1), 0, toplevel, x_offset, y_offset);
+}
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif

Source/ThirdParty/Wayland/protocols/xdg-toplevel-drag-v1.xml

@@ -0,0 +1,142 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="xdg_toplevel_drag_v1">
+
+  <copyright>
+    Copyright 2023 David Redondo
+
+    Permission is hereby granted, free of charge, to any person obtaining a
+    copy of this software and associated documentation files (the "Software"),
+    to deal in the Software without restriction, including without limitation
+    the rights to use, copy, modify, merge, publish, distribute, sublicense,
+    and/or sell copies of the Software, and to permit persons to whom the
+    Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice (including the next
+    paragraph) shall be included in all copies or substantial portions of the
+    Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+    DEALINGS IN THE SOFTWARE.
+  </copyright>
+
+  <interface name="xdg_toplevel_drag_manager_v1" version="1">
+    <description summary="Move a window during a drag">
+      This protocol enhances normal drag and drop with the ability to move a
+      window at the same time. This allows having detachable parts of a window
+      that when dragged out of it become a new window and can be dragged over
+      an existing window to be reattached.
+
+      A typical workflow would be when the user starts dragging on top of a
+      detachable part of a window, the client would create a wl_data_source and
+      a xdg_toplevel_drag_v1 object and start the drag as normal via
+      wl_data_device.start_drag. Once the client determines that the detachable
+      window contents should be detached from the originating window, it creates
+      a new xdg_toplevel with these contents and issues a
+      xdg_toplevel_drag_v1.attach request before mapping it. From now on the new
+      window is moved by the compositor during the drag as if the client called
+      xdg_toplevel.move.
+
+      Dragging an existing window is similar. The client creates a
+      xdg_toplevel_drag_v1 object and attaches the existing toplevel before
+      starting the drag.
+
+      Clients use the existing drag and drop mechanism to detect when a window
+      can be docked or undocked. If the client wants to snap a window into a
+      parent window it should delete or unmap the dragged top-level. If the
+      contents should be detached again it attaches a new toplevel as described
+      above. If a drag operation is cancelled without being dropped, clients
+      should revert to the previous state, deleting any newly created windows
+      as appropriate. When a drag operation ends as indicated by
+      wl_data_source.dnd_drop_performed the dragged toplevel window's final
+      position is determined as if a xdg_toplevel_move operation ended.
+
+      Warning! The protocol described in this file is currently in the testing
+      phase. Backward compatible changes may be added together with the
+      corresponding interface version bump. Backward incompatible changes can
+      only be done by creating a new major version of the extension.
+    </description>
+
+    <enum name="error">
+      <entry name="invalid_source" value="0"
+             summary="data_source already used for toplevel drag"/>
+    </enum>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the xdg_toplevel_drag_manager_v1 object">
+        Destroy this xdg_toplevel_drag_manager_v1 object. Other objects,
+        including xdg_toplevel_drag_v1 objects created by this factory, are not
+        affected by this request.
+      </description>
+    </request>
+
+    <request name="get_xdg_toplevel_drag">
+      <description summary="get an xdg_toplevel_drag for a wl_data_source">
+        Create an xdg_toplevel_drag for a drag and drop operation that is going
+        to be started with data_source.
+
+        This request can only be made on sources used in drag-and-drop, so it
+        must be performed before wl_data_device.start_drag. Attempting to use
+        the source other than for drag-and-drop such as in
+        wl_data_device.set_selection will raise an invalid_source error.
+
+        Destroying data_source while a toplevel is attached to the
+        xdg_toplevel_drag is undefined.
+      </description>
+
+      <arg name="id" type="new_id" interface="xdg_toplevel_drag_v1"/>
+      <arg name="data_source" type="object" interface="wl_data_source"/>
+    </request>
+  </interface>
+
+  <interface name="xdg_toplevel_drag_v1" version="1">
+    <description summary="Object representing a toplevel move during a drag">
+    </description>
+
+    <enum name="error">
+      <entry name="toplevel_attached" value="0"
+             summary="valid toplevel already attached"/>
+      <entry name="ongoing_drag" value="1"
+             summary="drag has not ended" />
+    </enum>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy an xdg_toplevel_drag_v1 object">
+        Destroy this xdg_toplevel_drag_v1 object. This request must only be
+        called after the underlying wl_data_source drag has ended, as indicated
+        by the dnd_drop_performed or cancelled events. In any other case an
+        ongoing_drag error is raised.
+      </description>
+    </request>
+
+    <request name="attach">
+      <description summary="Move a toplevel with the drag operation">
+        Request that the window will be moved with the cursor during the drag
+        operation. The offset is a hint to the compositor how the toplevel
+        should be positioned relative to the cursor hotspot in surface local
+        coordinates and relative to the geometry of the toplevel being attached.
+        See xdg_surface.set_window_geometry. For example it might only
+        be used when an unmapped window is attached. The attached window
+        does not participate in the selection of the drag target.
+
+        If the toplevel is unmapped while it is attached, it is automatically
+        detached from the drag. In this case this request has to be called again
+        if the window should be attached after it is remapped.
+
+        This request can be called multiple times but issuing it while a
+        toplevel with an active role is attached raises a toplevel_attached
+        error.
+      </description>
+
+      <arg name="toplevel" type="object" interface="xdg_toplevel"/>
+      <arg name="x_offset" type="int" summary="dragged surface x offset"/>
+      <arg name="y_offset" type="int" summary="dragged surface y offset"/>
+    </request>
+
+  </interface>
+</protocol>
+

Source/ThirdParty/Wayland/xdg-shell.c

@@ -0,0 +1,184 @@
+/* Generated by wayland-scanner 1.23.1 */
+
+/*
+ * Copyright © 2008-2013 Kristian Høgsberg
+ * Copyright © 2013      Rafael Antognolli
+ * Copyright © 2013      Jasper St. Pierre
+ * Copyright © 2010-2013 Intel Corporation
+ * Copyright © 2015-2017 Samsung Electronics Co., Ltd
+ * Copyright © 2015-2017 Red Hat Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include "wayland-util.h"
+
+#ifndef __has_attribute
+# define __has_attribute(x) 0  /* Compatibility with non-clang compilers. */
+#endif
+
+#if (__has_attribute(visibility) || defined(__GNUC__) && __GNUC__ >= 4)
+#define WL_PRIVATE __attribute__ ((visibility("hidden")))
+#else
+#define WL_PRIVATE
+#endif
+
+extern const struct wl_interface wl_output_interface;
+extern const struct wl_interface wl_seat_interface;
+extern const struct wl_interface wl_surface_interface;
+extern const struct wl_interface xdg_popup_interface;
+extern const struct wl_interface xdg_positioner_interface;
+extern const struct wl_interface xdg_surface_interface;
+extern const struct wl_interface xdg_toplevel_interface;
+
+static const struct wl_interface *xdg_shell_types[] = {
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	&xdg_positioner_interface,
+	&xdg_surface_interface,
+	&wl_surface_interface,
+	&xdg_toplevel_interface,
+	&xdg_popup_interface,
+	&xdg_surface_interface,
+	&xdg_positioner_interface,
+	&xdg_toplevel_interface,
+	&wl_seat_interface,
+	NULL,
+	NULL,
+	NULL,
+	&wl_seat_interface,
+	NULL,
+	&wl_seat_interface,
+	NULL,
+	NULL,
+	&wl_output_interface,
+	&wl_seat_interface,
+	NULL,
+	&xdg_positioner_interface,
+	NULL,
+};
+
+static const struct wl_message xdg_wm_base_requests[] = {
+	{ "destroy", "", xdg_shell_types + 0 },
+	{ "create_positioner", "n", xdg_shell_types + 4 },
+	{ "get_xdg_surface", "no", xdg_shell_types + 5 },
+	{ "pong", "u", xdg_shell_types + 0 },
+};
+
+static const struct wl_message xdg_wm_base_events[] = {
+	{ "ping", "u", xdg_shell_types + 0 },
+};
+
+WL_PRIVATE const struct wl_interface xdg_wm_base_interface = {
+	"xdg_wm_base", 6,
+	4, xdg_wm_base_requests,
+	1, xdg_wm_base_events,
+};
+
+static const struct wl_message xdg_positioner_requests[] = {
+	{ "destroy", "", xdg_shell_types + 0 },
+	{ "set_size", "ii", xdg_shell_types + 0 },
+	{ "set_anchor_rect", "iiii", xdg_shell_types + 0 },
+	{ "set_anchor", "u", xdg_shell_types + 0 },
+	{ "set_gravity", "u", xdg_shell_types + 0 },
+	{ "set_constraint_adjustment", "u", xdg_shell_types + 0 },
+	{ "set_offset", "ii", xdg_shell_types + 0 },
+	{ "set_reactive", "3", xdg_shell_types + 0 },
+	{ "set_parent_size", "3ii", xdg_shell_types + 0 },
+	{ "set_parent_configure", "3u", xdg_shell_types + 0 },
+};
+
+WL_PRIVATE const struct wl_interface xdg_positioner_interface = {
+	"xdg_positioner", 6,
+	10, xdg_positioner_requests,
+	0, NULL,
+};
+
+static const struct wl_message xdg_surface_requests[] = {
+	{ "destroy", "", xdg_shell_types + 0 },
+	{ "get_toplevel", "n", xdg_shell_types + 7 },
+	{ "get_popup", "n?oo", xdg_shell_types + 8 },
+	{ "set_window_geometry", "iiii", xdg_shell_types + 0 },
+	{ "ack_configure", "u", xdg_shell_types + 0 },
+};
+
+static const struct wl_message xdg_surface_events[] = {
+	{ "configure", "u", xdg_shell_types + 0 },
+};
+
+WL_PRIVATE const struct wl_interface xdg_surface_interface = {
+	"xdg_surface", 6,
+	5, xdg_surface_requests,
+	1, xdg_surface_events,
+};
+
+static const struct wl_message xdg_toplevel_requests[] = {
+	{ "destroy", "", xdg_shell_types + 0 },
+	{ "set_parent", "?o", xdg_shell_types + 11 },
+	{ "set_title", "s", xdg_shell_types + 0 },
+	{ "set_app_id", "s", xdg_shell_types + 0 },
+	{ "show_window_menu", "ouii", xdg_shell_types + 12 },
+	{ "move", "ou", xdg_shell_types + 16 },
+	{ "resize", "ouu", xdg_shell_types + 18 },
+	{ "set_max_size", "ii", xdg_shell_types + 0 },
+	{ "set_min_size", "ii", xdg_shell_types + 0 },
+	{ "set_maximized", "", xdg_shell_types + 0 },
+	{ "unset_maximized", "", xdg_shell_types + 0 },
+	{ "set_fullscreen", "?o", xdg_shell_types + 21 },
+	{ "unset_fullscreen", "", xdg_shell_types + 0 },
+	{ "set_minimized", "", xdg_shell_types + 0 },
+};
+
+static const struct wl_message xdg_toplevel_events[] = {
+	{ "configure", "iia", xdg_shell_types + 0 },
+	{ "close", "", xdg_shell_types + 0 },
+	{ "configure_bounds", "4ii", xdg_shell_types + 0 },
+	{ "wm_capabilities", "5a", xdg_shell_types + 0 },
+};
+
+WL_PRIVATE const struct wl_interface xdg_toplevel_interface = {
+	"xdg_toplevel", 6,
+	14, xdg_toplevel_requests,
+	4, xdg_toplevel_events,
+};
+
+static const struct wl_message xdg_popup_requests[] = {
+	{ "destroy", "", xdg_shell_types + 0 },
+	{ "grab", "ou", xdg_shell_types + 22 },
+	{ "reposition", "3ou", xdg_shell_types + 24 },
+};
+
+static const struct wl_message xdg_popup_events[] = {
+	{ "configure", "iiii", xdg_shell_types + 0 },
+	{ "popup_done", "", xdg_shell_types + 0 },
+	{ "repositioned", "3u", xdg_shell_types + 0 },
+};
+
+WL_PRIVATE const struct wl_interface xdg_popup_interface = {
+	"xdg_popup", 6,
+	3, xdg_popup_requests,
+	3, xdg_popup_events,
+};
+

Source/ThirdParty/Wayland/xdg-toplevel-drag-v1.c

@@ -0,0 +1,74 @@
+/* Generated by wayland-scanner 1.23.1 */
+
+/*
+ * Copyright 2023 David Redondo
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include "wayland-util.h"
+
+#ifndef __has_attribute
+# define __has_attribute(x) 0  /* Compatibility with non-clang compilers. */
+#endif
+
+#if (__has_attribute(visibility) || defined(__GNUC__) && __GNUC__ >= 4)
+#define WL_PRIVATE __attribute__ ((visibility("hidden")))
+#else
+#define WL_PRIVATE
+#endif
+
+extern const struct wl_interface wl_data_source_interface;
+extern const struct wl_interface xdg_toplevel_interface;
+extern const struct wl_interface xdg_toplevel_drag_v1_interface;
+
+static const struct wl_interface *xdg_toplevel_drag_v1_types[] = {
+	&xdg_toplevel_drag_v1_interface,
+	&wl_data_source_interface,
+	&xdg_toplevel_interface,
+	NULL,
+	NULL,
+};
+
+static const struct wl_message xdg_toplevel_drag_manager_v1_requests[] = {
+	{ "destroy", "", xdg_toplevel_drag_v1_types + 0 },
+	{ "get_xdg_toplevel_drag", "no", xdg_toplevel_drag_v1_types + 0 },
+};
+
+WL_PRIVATE const struct wl_interface xdg_toplevel_drag_manager_v1_interface = {
+	"xdg_toplevel_drag_manager_v1", 1,
+	2, xdg_toplevel_drag_manager_v1_requests,
+	0, NULL,
+};
+
+static const struct wl_message xdg_toplevel_drag_v1_requests[] = {
+	{ "destroy", "", xdg_toplevel_drag_v1_types + 0 },
+	{ "attach", "oii", xdg_toplevel_drag_v1_types + 2 },
+};
+
+WL_PRIVATE const struct wl_interface xdg_toplevel_drag_v1_interface = {
+	"xdg_toplevel_drag_v1", 1,
+	2, xdg_toplevel_drag_v1_requests,
+	0, NULL,
+};
+

Source/Tools/Flax.Build/Platforms/Linux/LinuxToolchain.cs

@@ -126,6 +126,7 @@ namespace Flax.Build.Platforms
             args.Add("-lXcursor");
             args.Add("-lXinerama");
             args.Add("-lXfixes");
+            args.Add("-lwayland-client");
         }
 
         /// <inheritdoc />