DragAndDrop core

Lattice.UI.Docking.WinUI/Services/WinUIDockContextManager.cs

@@ -0,0 +1,116 @@
+using Lattice.UI.Docking.Abstractions;
+using Lattice.UI.Docking.Services;
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Controls;
+using System;
+using System.Collections.Concurrent;
+
+namespace Lattice.UI.Docking.WinUI.Services;
+
+/// <summary>
+/// Реализация менеджера контекстных меню для WinUI.
+/// </summary>
+public sealed class WinUIDockContextManager : DockContextManagerBase, IDisposable
+{
+    private readonly ConcurrentDictionary<string, IDockCommand> _commands = new();
+    private MenuFlyout? _currentFlyout;
+    private IDockControl? _currentContextTarget;
+
+    /// <summary>
+    /// Инициализирует новый экземпляр менеджера контекстных меню.
+    /// </summary>
+    public WinUIDockContextManager()
+    {
+    }
+
+    /// <inheritdoc/>
+    public override void ShowContextMenu(IDockControl element, double x, double y)
+    {
+        if (element is not FrameworkElement uiElement) return;
+
+        // Создаем контекстное меню
+        var flyout = new MenuFlyout();
+
+        // Получаем команды для элемента
+        var commands = GetCommandsForElement(element);
+
+        foreach (var command in commands)
+        {
+            var item = new MenuFlyoutItem
+            {
+                Text = command.Name,
+                Command = new RelayCommand(() => ExecuteCommand(command, element))
+            };
+
+            // Добавляем иконку, если есть
+            if (!string.IsNullOrEmpty(command.Icon))
+            {
+                // TODO: Добавить иконку команды
+            }
+
+            flyout.Items.Add(item);
+        }
+
+        // Если команд нет, не показываем меню
+        if (flyout.Items.Count == 0) return;
+
+        // Закрываем предыдущее меню, если оно открыто
+        HideContextMenu();
+
+        // Сохраняем ссылки
+        _currentFlyout = flyout;
+        _currentContextTarget = element;
+
+        // Показываем меню
+        flyout.ShowAt(uiElement, new Windows.Foundation.Point(x, y));
+
+        // Вызываем событие
+        OnContextMenuShown(element, x, y);
+    }
+
+    /// <inheritdoc/>
+    public override void HideContextMenu()
+    {
+        if (_currentFlyout != null)
+        {
+            _currentFlyout.Hide();
+            _currentFlyout = null;
+        }
+
+        if (_currentContextTarget != null)
+        {
+            OnContextMenuHidden();
+            _currentContextTarget = null;
+        }
+    }
+
+    /// <summary>
+    /// Класс-заглушка для реализации ICommand.
+    /// </summary>
+    private sealed class RelayCommand : System.Windows.Input.ICommand
+    {
+        private readonly Action _execute;
+        private readonly Func<bool>? _canExecute;
+
+        public event EventHandler? CanExecuteChanged;
+
+        public RelayCommand(Action execute, Func<bool>? canExecute = null)
+        {
+            _execute = execute ?? throw new ArgumentNullException(nameof(execute));
+            _canExecute = canExecute;
+        }
+
+        public bool CanExecute(object? parameter) => _canExecute?.Invoke() ?? true;
+
+        public void Execute(object? parameter) => _execute();
+
+        public void RaiseCanExecuteChanged() => CanExecuteChanged?.Invoke(this, EventArgs.Empty);
+    }
+
+    /// <inheritdoc/>
+    public void Dispose()
+    {
+        HideContextMenu();
+        _commands.Clear();
+    }
+}

Lattice.UI.Docking.WinUI/Services/WinUIDockUIService.cs

@@ -0,0 +1,167 @@
+using Lattice.UI.Docking.Abstractions;
+using Lattice.UI.Docking.Services;
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Controls;
+using System;
+using System.Threading.Tasks;
+
+namespace Lattice.UI.Docking.WinUI.Services;
+
+/// <summary>
+/// Реализация UI-сервиса для WinUI.
+/// </summary>
+public sealed class WinUIDockUIService : DockUIServiceBase
+{
+    /// <inheritdoc/>
+    public override object CreateMainWindow(IDockHost host)
+    {
+        if (host is not FrameworkElement hostElement)
+            throw new ArgumentException("Host must be a FrameworkElement", nameof(host));
+
+        var window = new Window();
+        window.Content = hostElement;
+        window.AppWindow.Title = "Lattice IDE";
+
+        // Регистрируем окно в трекере
+        Themes.WindowTracker.Register(window);
+
+        return window;
+    }
+
+    /// <inheritdoc/>
+    public override bool? ShowDialog(string title, object content)
+    {
+        if (content is not FrameworkElement contentElement)
+            return null;
+
+        var dialog = new ContentDialog
+        {
+            Title = title,
+            Content = contentElement,
+            PrimaryButtonText = "OK",
+            CloseButtonText = "Cancel",
+            XamlRoot = GetActiveXamlRoot()
+        };
+
+        // Показываем диалог и возвращаем результат
+        var result = dialog.ShowAsync();
+        return result.GetAwaiter().GetResult() switch
+        {
+            ContentDialogResult.Primary => true,
+            ContentDialogResult.Secondary => false,
+            _ => null
+        };
+    }
+
+    /// <inheritdoc/>
+    public override void ShowMessage(string message, string caption)
+    {
+        var dialog = new ContentDialog
+        {
+            Title = caption,
+            Content = new TextBlock { Text = message },
+            PrimaryButtonText = "OK",
+            XamlRoot = GetActiveXamlRoot()
+        };
+
+        dialog.ShowAsync();
+    }
+
+    /// <inheritdoc/>
+    public override bool Confirm(string message, string caption)
+    {
+        var dialog = new ContentDialog
+        {
+            Title = caption,
+            Content = new TextBlock { Text = message },
+            PrimaryButtonText = "Yes",
+            SecondaryButtonText = "No",
+            XamlRoot = GetActiveXamlRoot()
+        };
+
+        var result = dialog.ShowAsync().GetAwaiter().GetResult();
+        return result == ContentDialogResult.Primary;
+    }
+
+    /// <inheritdoc/>
+    public override string? Prompt(string prompt, string? defaultValue = null)
+    {
+        var textBox = new TextBox
+        {
+            Text = defaultValue ?? string.Empty,
+            Width = 300,
+            Height = 32
+        };
+
+        var dialog = new ContentDialog
+        {
+            Title = prompt,
+            Content = textBox,
+            PrimaryButtonText = "OK",
+            SecondaryButtonText = "Cancel",
+            XamlRoot = GetActiveXamlRoot()
+        };
+
+        var result = dialog.ShowAsync().GetAwaiter().GetResult();
+        return result == ContentDialogResult.Primary ? textBox.Text : null;
+    }
+
+    /// <inheritdoc/>
+    public override void InvokeOnUIThread(Action action)
+    {
+        if (action == null) return;
+
+        var dispatcherQueue = Microsoft.UI.Dispatching.DispatcherQueue.GetForCurrentThread();
+        if (dispatcherQueue.HasThreadAccess)
+        {
+            action();
+        }
+        else
+        {
+            dispatcherQueue.TryEnqueue(() => action());
+        }
+    }
+
+    /// <inheritdoc/>
+    public override async Task InvokeOnUIThreadAsync(Func<Task> action)
+    {
+        if (action == null) return;
+
+        var dispatcherQueue = Microsoft.UI.Dispatching.DispatcherQueue.GetForCurrentThread();
+        if (dispatcherQueue.HasThreadAccess)
+        {
+            await action();
+        }
+        else
+        {
+            var tcs = new TaskCompletionSource<bool>();
+            dispatcherQueue.TryEnqueue(async () =>
+            {
+                try
+                {
+                    await action();
+                    tcs.SetResult(true);
+                }
+                catch (Exception ex)
+                {
+                    tcs.SetException(ex);
+                }
+            });
+            await tcs.Task;
+        }
+    }
+
+    private XamlRoot? GetActiveXamlRoot()
+    {
+        // Получаем XamlRoot из активного окна
+        foreach (var window in Themes.WindowTracker.Windows)
+        {
+            if (window.Content is FrameworkElement element)
+            {
+                return element.XamlRoot;
+            }
+        }
+
+        return null;
+    }
+}

Lattice.UI.Docking.WinUI/Services/WinUIDragDropService.cs

@@ -0,0 +1,534 @@
+using Lattice.Core.DragDrop.Services;
+using Lattice.Core.Geometry;
+using Lattice.UI.Docking.Abstractions;
+using Lattice.UI.Docking.Models;
+using Lattice.UI.Docking.Services;
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Controls;
+using Microsoft.UI.Xaml.Controls.Primitives;
+using Microsoft.UI.Xaml.Media;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+
+namespace Lattice.UI.Docking.WinUI.Services;
+
+/// <summary>
+/// Предоставляет реализацию сервиса перетаскивания для платформы WinUI с расширенной
+/// поддержкой визуальных эффектов и интеграцией с системой докинга Lattice.
+/// Координирует взаимодействие между базовым менеджером перетаскивания и UI-контролами,
+/// обеспечивая богатую визуальную обратную связь во время операций drag-and-drop.
+/// </summary>
+/// <remarks>
+/// <para>
+/// <see cref="WinUIDragDropService"/> расширяет базовый функционал <see cref="DockDragDropService"/>
+/// платформенно-зависимыми визуальными эффектами, включая:
+/// </para>
+/// <list type="bullet">
+/// <item>Прозрачное визуальное представление перетаскиваемого элемента</item>
+/// <item>Интерактивные подсказки областей сброса</item>
+/// <item>Анимации при начале и завершении перетаскивания</item>
+/// <item>Подсветку допустимых целей сброса</item>
+/// </list>
+/// <para>
+/// Сервис поддерживает регистрацию UI-элементов и автоматически вычисляет их границы
+/// для точного определения целей сброса.
+/// </para>
+/// </remarks>
+public sealed class WinUIDragDropService : DockDragDropService, IDisposable
+{
+    private readonly ConcurrentDictionary<IDockControl, FrameworkElement> _controlToElement = new();
+    private readonly DragDropManagerEx _dragDropManager;
+    private Popup? _dragVisualPopup;
+    private Border? _dragVisual;
+    private DropHintOverlay? _dropHintOverlay;
+    private bool _disposed;
+
+    /// <summary>
+    /// Инициализирует новый экземпляр сервиса перетаскивания WinUI.
+    /// </summary>
+    /// <remarks>
+    /// Создает внутренний менеджер перетаскивания, инициализирует визуальные элементы
+    /// и подписывается на события менеджера для обработки операций перетаскивания.
+    /// </remarks>
+    public WinUIDragDropService()
+    {
+        _dragDropManager = new DragDropManagerEx();
+        HookEvents();
+        InitializeDragVisual();
+        InitializeDropHintOverlay();
+    }
+
+    /// <summary>
+    /// Инициализирует новый экземпляр с указанным менеджером перетаскивания.
+    /// </summary>
+    /// <param name="dragDropManager">
+    /// Предварительно настроенный менеджер перетаскивания.
+    /// </param>
+    /// <exception cref="ArgumentNullException">
+    /// Выбрасывается, если <paramref name="dragDropManager"/> равен null.
+    /// </exception>
+    /// <remarks>
+    /// Позволяет использовать кастомную конфигурацию менеджера перетаскивания
+    /// при сохранении всех визуальных эффектов WinUI.
+    /// </remarks>
+    public WinUIDragDropService(DragDropManagerEx dragDropManager)
+    {
+        _dragDropManager = dragDropManager ?? throw new ArgumentNullException(nameof(dragDropManager));
+        HookEvents();
+        InitializeDragVisual();
+        InitializeDropHintOverlay();
+    }
+
+    /// <summary>
+    /// Подписывается на события менеджера перетаскивания.
+    /// </summary>
+    /// <remarks>
+    /// Обрабатывает следующие события:
+    /// <list type="bullet">
+    /// <item>Начало перетаскивания</item>
+    /// <item>Обновление позиции перетаскивания</item>
+    /// <item>Завершение перетаскивания</item>
+    /// <item>Отмена перетаскивания</item>
+    /// <item>Изменение цели сброса</item>
+    /// </list>
+    /// </remarks>
+    private void HookEvents()
+    {
+        _dragDropManager.DragStarted += OnDragStarted;
+        _dragDropManager.DragUpdated += OnDragUpdated;
+        _dragDropManager.DragCompleted += OnDragCompleted;
+        _dragDropManager.DragCancelled += OnDragCancelled;
+        _dragDropManager.DropTargetChanged += OnDropTargetChanged;
+    }
+
+    /// <summary>
+    /// Инициализирует визуальное представление перетаскиваемого элемента.
+    /// </summary>
+    /// <remarks>
+    /// Создает Popup с Border для отображения полупрозрачной копии
+    /// перетаскиваемого элемента во время операции drag-and-drop.
+    /// </remarks>
+    private void InitializeDragVisual()
+    {
+        // Создаем Popup для отображения визуального представления перетаскивания
+        _dragVisualPopup = new Popup
+        {
+            IsHitTestVisible = false,
+            IsLightDismissEnabled = false,
+            Child = null
+        };
+
+        // Создаем визуальный элемент для перетаскивания
+        _dragVisual = new Border
+        {
+            Background = new SolidColorBrush(Microsoft.UI.Colors.Transparent),
+            BorderBrush = new SolidColorBrush(Microsoft.UI.Colors.DodgerBlue),
+            BorderThickness = new Thickness(2),
+            CornerRadius = new CornerRadius(4),
+            Opacity = 0.7
+        };
+    }
+
+    /// <summary>
+    /// Инициализирует оверлей для отображения подсказок при сбросе.
+    /// </summary>
+    /// <remarks>
+    /// Добавляет оверлей в корневой контейнер приложения для отображения
+    /// визуальных подсказок о возможных позициях сброса.
+    /// </remarks>
+    private void InitializeDropHintOverlay()
+    {
+        // Создаем оверлей для подсказок при сбросе
+        _dropHintOverlay = new DropHintOverlay();
+
+        // Добавляем оверлей в корневой контейнер приложения
+        if (Window.Current?.Content is Panel rootPanel)
+        {
+            rootPanel.Children.Add(_dropHintOverlay);
+        }
+    }
+
+    /// <summary>
+    /// Регистрирует связь между абстрактным контролом док-системы и конкретным UI-элементом WinUI.
+    /// </summary>
+    /// <param name="control">Абстрактный контрол док-системы.</param>
+    /// <param name="element">Конкретный UI-элемент WinUI.</param>
+    /// <exception cref="ArgumentNullException">
+    /// Выбрасывается, если <paramref name="control"/> или <paramref name="element"/> равны null.
+    /// </exception>
+    /// <remarks>
+    /// Эта связь необходима для:
+    /// <list type="bullet">
+    /// <item>Вычисления границ элемента на экране</item>
+    /// <item>Создания визуального представления перетаскивания</item>
+    /// <item>Определения позиции сброса относительно элемента</item>
+    /// </list>
+    /// </remarks>
+    public void RegisterControl(IDockControl control, FrameworkElement element)
+    {
+        if (control == null) throw new ArgumentNullException(nameof(control));
+        if (element == null) throw new ArgumentNullException(nameof(element));
+
+        _controlToElement[control] = element;
+    }
+
+    /// <summary>
+    /// Отменяет регистрацию связи между абстрактным контролом док-системы и UI-элементом WinUI.
+    /// </summary>
+    /// <param name="control">Абстрактный контрол док-системы.</param>
+    /// <exception cref="ArgumentNullException">
+    /// Выбрасывается, если <paramref name="control"/> равен null.
+    /// </exception>
+    /// <remarks>
+    /// Удаляет элемент из внутреннего словаря, освобождая связанные с ним ресурсы.
+    /// </remarks>
+    public void UnregisterControl(IDockControl control)
+    {
+        if (control == null) throw new ArgumentNullException(nameof(control));
+
+        _controlToElement.TryRemove(control, out _);
+    }
+
+    /// <summary>
+    /// Вычисляет границы элемента на экране.
+    /// </summary>
+    /// <param name="element">Элемент, для которого вычисляются границы.</param>
+    /// <returns>
+    /// Прямоугольник в экранных координатах, представляющий границы элемента.
+    /// </returns>
+    /// <remarks>
+    /// <para>
+    /// Метод выполняет преобразование координат элемента в экранные координаты
+    /// с использованием трансформации визуального дерева.
+    /// </para>
+    /// <para>
+    /// В случае ошибки вычисления возвращает прямоугольник размером 100x100 пикселей
+    /// в точке (0, 0).
+    /// </para>
+    /// </remarks>
+    protected override Rect CalculateBounds(IDockControl element)
+    {
+        if (_controlToElement.TryGetValue(element, out var uiElement))
+        {
+            try
+            {
+                // Получаем преобразование координат в экранные
+                var transform = uiElement.TransformToVisual(Window.Current.Content);
+                var point = transform.TransformPoint(new Windows.Foundation.Point(0, 0));
+
+                return new Rect(
+                    point.X, point.Y,
+                    uiElement.ActualWidth, uiElement.ActualHeight);
+            }
+            catch (Exception ex)
+            {
+                System.Diagnostics.Debug.WriteLine($"Failed to calculate bounds: {ex.Message}");
+            }
+        }
+
+        // Возвращаем значения по умолчанию, если не удалось вычислить
+        return new Rect(0, 0, 100, 100);
+    }
+
+    /// <summary>
+    /// Создает визуальное представление перетаскиваемого элемента.
+    /// </summary>
+    /// <param name="dragInfo">Информация о перетаскивании.</param>
+    /// <remarks>
+    /// <para>
+    /// На основе источника перетаскивания создает полупрозрачную копию элемента,
+    /// которая следует за курсором мыши во время операции перетаскивания.
+    /// </para>
+    /// <para>
+    /// Визуальное представление включает:
+    /// </para>
+    /// <list type="bullet">
+    /// <item>Тень для создания эффекта глубины</item>
+    /// <item>Прозрачность для видимости фонового содержимого</item>
+    /// <item>Синюю границу для визуального выделения</item>
+    /// </list>
+    /// </remarks>
+    protected override void CreateDragVisual(UiDragInfo dragInfo)
+    {
+        if (_dragVisual == null || _dragVisualPopup == null || dragInfo.SourceControl == null)
+            return;
+
+        // Настраиваем визуальное представление на основе источника
+        if (_controlToElement.TryGetValue(dragInfo.SourceControl, out var sourceElement))
+        {
+            // Устанавливаем размеры визуального представления
+            _dragVisual.Width = sourceElement.ActualWidth;
+            _dragVisual.Height = sourceElement.ActualHeight;
+
+            // Создаем эффект прозрачности и тени
+            _dragVisual.Opacity = 0.7;
+
+            // Устанавливаем позицию Popup
+            _dragVisualPopup.HorizontalOffset = dragInfo.BaseDragInfo.StartPosition.X;
+            _dragVisualPopup.VerticalOffset = dragInfo.BaseDragInfo.StartPosition.Y;
+            _dragVisualPopup.Child = _dragVisual;
+            _dragVisualPopup.IsOpen = true;
+        }
+    }
+
+    /// <summary>
+    /// Обновляет позицию визуального представления перетаскивания.
+    /// </summary>
+    /// <param name="position">Новая позиция курсора.</param>
+    /// <remarks>
+    /// Перемещает Popup с визуальным представлением в указанную позицию,
+    /// обеспечивая плавное следование за курсором мыши.
+    /// </remarks>
+    protected override void UpdateDragVisualPosition(Point position)
+    {
+        if (_dragVisualPopup != null)
+        {
+            _dragVisualPopup.HorizontalOffset = position.X;
+            _dragVisualPopup.VerticalOffset = position.Y;
+        }
+    }
+
+    /// <summary>
+    /// Очищает визуальное представление перетаскивания.
+    /// </summary>
+    /// <remarks>
+    /// Скрывает и освобождает ресурсы Popup, используемого для отображения
+    /// визуального представления перетаскиваемого элемента.
+    /// </remarks>
+    protected override void CleanupDragVisual()
+    {
+        if (_dragVisualPopup != null)
+        {
+            _dragVisualPopup.IsOpen = false;
+            _dragVisualPopup.Child = null;
+        }
+    }
+
+    /// <summary>
+    /// Показывает визуальную подсказку о возможной позиции сброса.
+    /// </summary>
+    /// <param name="element">Элемент, для которого показывается подсказка.</param>
+    /// <param name="position">Предполагаемая позиция сброса.</param>
+    /// <remarks>
+    /// Отображает полупрозрачный прямоугольник в указанной позиции относительно элемента,
+    /// давая пользователю визуальную обратную связь о том, куда будет помещен элемент.
+    /// </remarks>
+    protected override void ShowDropHint(IDockControl element, DropPosition position)
+    {
+        _dropHintOverlay?.ShowHint(element, position);
+    }
+
+    /// <summary>
+    /// Скрывает текущую визуальную подсказку о сбросе.
+    /// </summary>
+    /// <remarks>
+    /// Убирает все отображаемые подсказки сброса, очищая оверлей.
+    /// </remarks>
+    protected override void HideDropHint()
+    {
+        _dropHintOverlay?.HideHint();
+    }
+
+    /// <summary>
+    /// Освобождает ресурсы, используемые сервисом перетаскивания.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// Выполняет следующие действия:
+    /// </para>
+    /// <list type="bullet">
+    /// <item>Отписывается от всех событий менеджера перетаскивания</item>
+    /// <item>Удаляет оверлей подсказок из корневого контейнера</item>
+    /// <item>Очищает словарь зарегистрированных контролов</item>
+    /// <item>Освобождает визуальные элементы</item>
+    /// </list>
+    /// </remarks>
+    public void Dispose()
+    {
+        if (!_disposed)
+        {
+            if (_dragDropManager != null)
+            {
+                _dragDropManager.DragStarted -= OnDragStarted;
+                _dragDropManager.DragUpdated -= OnDragUpdated;
+                _dragDropManager.DragCompleted -= OnDragCompleted;
+                _dragDropManager.DragCancelled -= OnDragCancelled;
+                _dragDropManager.DropTargetChanged -= OnDropTargetChanged;
+            }
+
+            if (_dropHintOverlay != null && Window.Current?.Content is Panel rootPanel)
+            {
+                rootPanel.Children.Remove(_dropHintOverlay);
+                _dropHintOverlay = null;
+            }
+
+            _controlToElement.Clear();
+            _disposed = true;
+        }
+    }
+}
+
+/// <summary>
+/// Представляет оверлей для отображения визуальных подсказок при сбросе в операции перетаскивания.
+/// Этот элемент отображает полупрозрачные прямоугольники в местах возможного сброса,
+/// давая пользователю визуальную обратную связь о допустимых позициях.
+/// </summary>
+/// <remarks>
+/// <para>
+/// <see cref="DropHintOverlay"/> является внутренним вспомогательным классом,
+/// который отображается поверх всего пользовательского интерфейса во время операции
+/// перетаскивания для показа визуальных подсказок.
+/// </para>
+/// <para>
+/// Оверлей поддерживает все позиции сброса, определенные в <see cref="DropPosition"/>,
+/// и автоматически вычисляет размеры и положение подсказок на основе целевого элемента.
+/// </para>
+/// </remarks>
+internal sealed class DropHintOverlay : Grid
+{
+    private readonly Dictionary<DropPosition, Border> _hintRectangles = new();
+    private readonly SolidColorBrush _hintBrush;
+
+    /// <summary>
+    /// Инициализирует новый экземпляр класса <see cref="DropHintOverlay"/>.
+    /// </summary>
+    /// <remarks>
+    /// Создает прозрачный оверлей, который не участвует в тестировании попаданий,
+    /// и инициализирует прямоугольники для всех возможных позиций сброса.
+    /// </remarks>
+    public DropHintOverlay()
+    {
+        this.IsHitTestVisible = false;
+        this.Background = new SolidColorBrush(Microsoft.UI.Colors.Transparent);
+
+        // Используем акцентный цвет для подсказок
+        _hintBrush = new SolidColorBrush(Microsoft.UI.Colors.DodgerBlue);
+
+        InitializeHintRectangles();
+    }
+
+    /// <summary>
+    /// Инициализирует прямоугольники для всех позиций сброса.
+    /// </summary>
+    /// <remarks>
+    /// Создает отдельный Border для каждой позиции сброса и добавляет их в дочернюю коллекцию.
+    /// Все прямоугольники изначально скрыты и отображаются только при необходимости.
+    /// </remarks>
+    private void InitializeHintRectangles()
+    {
+        // Создаем прямоугольники для каждой позиции сброса
+        var positions = new[]
+        {
+            DropPosition.Left, DropPosition.Right,
+            DropPosition.Top, DropPosition.Bottom,
+            DropPosition.Center, DropPosition.Tab
+        };
+
+        foreach (var position in positions)
+        {
+            var rect = new Border
+            {
+                Background = _hintBrush,
+                Opacity = 0.3,
+                BorderBrush = new SolidColorBrush(Microsoft.UI.Colors.DodgerBlue),
+                BorderThickness = new Thickness(2),
+                Visibility = Visibility.Collapsed,
+                CornerRadius = new CornerRadius(4)
+            };
+
+            _hintRectangles[position] = rect;
+            this.Children.Add(rect);
+        }
+    }
+
+    /// <summary>
+    /// Показывает визуальную подсказку для указанного элемента и позиции сброса.
+    /// </summary>
+    /// <param name="element">Элемент, для которого показывается подсказка.</param>
+    /// <param name="position">Позиция сброса относительно элемента.</param>
+    /// <remarks>
+    /// Вычисляет положение и размер подсказки на основе границ элемента и позиции сброса,
+    /// затем делает соответствующий прямоугольник видимым.
+    /// </remarks>
+    public void ShowHint(IDockControl element, DropPosition position)
+    {
+        if (element is not FrameworkElement uiElement) return;
+        if (!_hintRectangles.TryGetValue(position, out var rect)) return;
+
+        // Вычисляем позицию и размер подсказки
+        var bounds = CalculateHintBounds(uiElement, position);
+
+        Canvas.SetLeft(rect, bounds.X);
+        Canvas.SetTop(rect, bounds.Y);
+        rect.Width = bounds.Width;
+        rect.Height = bounds.Height;
+        rect.Visibility = Visibility.Visible;
+    }
+
+    /// <summary>
+    /// Вычисляет границы подсказки для указанного элемента и позиции сброса.
+    /// </summary>
+    /// <param name="element">Целевой элемент.</param>
+    /// <param name="position">Позиция сброса.</param>
+    /// <returns>Прямоугольник с координатами и размерами подсказки.</returns>
+    /// <remarks>
+    /// Размеры подсказок зависят от позиции:
+    /// <list type="bullet">
+    /// <item>Слева/справа: ширина 50px, высота равна высоте элемента</item>
+    /// <item>Сверху/снизу: высота 50px, ширина равна ширине элемента</item>
+    /// <item>В центре: размеры равны размерам элемента</item>
+    /// <item>Вкладка: высота 30px, ширина равна ширине элемента, позиция сверху</item>
+    /// </list>
+    /// </remarks>
+    private Rect CalculateHintBounds(FrameworkElement element, DropPosition position)
+    {
+        // Получаем позицию элемента относительно оверлея
+        var transform = element.TransformToVisual(this);
+        var point = transform.TransformPoint(new Windows.Foundation.Point(0, 0));
+
+        // Вычисляем размеры подсказки в зависимости от позиции
+        return position switch
+        {
+            DropPosition.Left => new Rect(
+                point.X - 50, point.Y,
+                50, element.ActualHeight),
+
+            DropPosition.Right => new Rect(
+                point.X + element.ActualWidth, point.Y,
+                50, element.ActualHeight),
+
+            DropPosition.Top => new Rect(
+                point.X, point.Y - 50,
+                element.ActualWidth, 50),
+
+            DropPosition.Bottom => new Rect(
+                point.X, point.Y + element.ActualHeight,
+                element.ActualWidth, 50),
+
+            DropPosition.Center => new Rect(
+                point.X, point.Y,
+                element.ActualWidth, element.ActualHeight),
+
+            DropPosition.Tab => new Rect(
+                point.X, point.Y - 30,
+                element.ActualWidth, 30),
+
+            _ => new Rect(point.X, point.Y, 100, 100)
+        };
+    }
+
+    /// <summary>
+    /// Скрывает все визуальные подсказки.
+    /// </summary>
+    /// <remarks>
+    /// Делает все прямоугольники подсказок невидимыми, очищая оверлей.
+    /// </remarks>
+    public void HideHint()
+    {
+        foreach (var rect in _hintRectangles.Values)
+        {
+            rect.Visibility = Visibility.Collapsed;
+        }
+    }
+}