514 lines
20 KiB
C#
514 lines
20 KiB
C#
using Lattice.Core.DragDrop.Models;
|
||
using Lattice.Core.Geometry;
|
||
using Lattice.UI.DragDrop.Abstractions;
|
||
using Lattice.UI.DragDrop.Behaviors;
|
||
using Microsoft.UI.Xaml;
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.Linq;
|
||
using System.Threading;
|
||
using System.Threading.Tasks;
|
||
|
||
namespace Lattice.UI.DragDrop.WinUI.Behaviors;
|
||
|
||
/// <summary>
|
||
/// Реализация поведения цели сброса для элементов WinUI.
|
||
/// Наследуется от <see cref="DropTargetBehaviorBase{FrameworkElement}"/> для использования
|
||
/// общей логики регистрации целей и обработки операций сброса.
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// Этот класс предоставляет конкретную реализацию для платформы WinUI, обрабатывая события
|
||
/// перетаскивания WinUI и преобразуя их в вызовы методов интерфейса <see cref="Core.DragDrop.Abstractions.IDropTarget"/>.
|
||
/// </para>
|
||
/// <para>
|
||
/// Основные функции:
|
||
/// <list type="bullet">
|
||
/// <item>Автоматическая регистрация в <see cref="IDragDropService"/> при прикреплении к элементу</item>
|
||
/// <item>Обработка событий DragEnter, DragOver, DragLeave, Drop</item>
|
||
/// <item>Автоматическое обновление границ элемента при изменении размера или позиции</item>
|
||
/// <item>Поддержка фильтрации принимаемых типов данных</item>
|
||
/// <item>Интеграция с визуальной обратной связью</item>
|
||
/// </list>
|
||
/// </para>
|
||
/// <para>
|
||
/// Для использования необходимо:
|
||
/// <list type="number">
|
||
/// <item>Создать экземпляр поведения через фабрику <see cref="Factories.WinUIDragDropFactory.CreateDropTargetBehavior"/></item>
|
||
/// <item>Прикрепить к элементу с помощью метода <see cref="Attach"/></item>
|
||
/// <item>Настроить фильтры принимаемых данных (опционально)</item>
|
||
/// </list>
|
||
/// </para>
|
||
/// <example>
|
||
/// <code>
|
||
/// // Создание поведения с фильтрацией типов
|
||
/// var behavior = WinUIDragDropFactory.CreateDropTargetBehavior(dragDropService, host);
|
||
/// behavior.AcceptTypes(typeof(MyDataModel), typeof(string));
|
||
/// behavior.Attach(myDropArea);
|
||
///
|
||
/// // Или через attached properties
|
||
/// <Border x:Name="DropArea"
|
||
/// local:DragDropProperties.IsDropTarget="True" />
|
||
/// </code>
|
||
/// </example>
|
||
/// </remarks>
|
||
public sealed class WinUIDropTargetBehavior : DropTargetBehaviorBase<FrameworkElement>
|
||
{
|
||
#region Поля
|
||
|
||
private readonly IDragDropHost _host;
|
||
private readonly List<Type> _acceptedTypes = new();
|
||
private readonly HashSet<string> _acceptedFormats = new();
|
||
|
||
#endregion
|
||
|
||
#region Конструктор
|
||
|
||
/// <summary>
|
||
/// Инициализирует новый экземпляр класса <see cref="WinUIDropTargetBehavior"/>.
|
||
/// </summary>
|
||
/// <param name="dragDropService">
|
||
/// Сервис управления операциями перетаскивания. Используется для регистрации
|
||
/// цели и координации операций сброса.
|
||
/// </param>
|
||
/// <param name="host">
|
||
/// Хост для управления визуальной обратной связью. Обеспечивает отображение
|
||
/// индикаторов возможности сброса.
|
||
/// </param>
|
||
/// <exception cref="ArgumentNullException">
|
||
/// Выбрасывается, если <paramref name="dragDropService"/> или <paramref name="host"/>
|
||
/// равны null.
|
||
/// </exception>
|
||
/// <remarks>
|
||
/// Конструктор инициализирует базовый класс и сохраняет ссылки на сервисы.
|
||
/// По умолчанию цель принимает все типы данных. Для настройки фильтрации
|
||
/// используйте методы <see cref="AcceptTypes"/> и <see cref="AcceptFormats"/>.
|
||
/// </remarks>
|
||
public WinUIDropTargetBehavior(
|
||
Core.DragDrop.Services.IDragDropService dragDropService,
|
||
IDragDropHost host)
|
||
: base(dragDropService)
|
||
{
|
||
_host = host ?? throw new ArgumentNullException(nameof(host));
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region Публичные методы
|
||
|
||
/// <summary>
|
||
/// Прикрепляет поведение к указанному элементу WinUI.
|
||
/// </summary>
|
||
/// <param name="element">
|
||
/// Элемент <see cref="FrameworkElement"/>, который должен стать целью сброса.
|
||
/// Не может быть null.
|
||
/// </param>
|
||
/// <exception cref="ArgumentNullException">
|
||
/// Выбрасывается, если <paramref name="element"/> равен null.
|
||
/// </exception>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// После вызова этого метода:
|
||
/// <list type="bullet">
|
||
/// <item>Элементу устанавливается свойство <see cref="UIElement.AllowDrop"/> = true</item>
|
||
/// <item>Поведение подписывается на события перетаскивания WinUI</item>
|
||
/// <item>Элемент регистрируется в системе перетаскивания с текущими границами</item>
|
||
/// <item>Начинается отслеживание изменений размера и позиции элемента</item>
|
||
/// </list>
|
||
/// </para>
|
||
/// <para>
|
||
/// Для открепления поведения используйте метод <see cref="Detach"/>.
|
||
/// </para>
|
||
/// </remarks>
|
||
public void Attach(FrameworkElement element)
|
||
{
|
||
if (element == null)
|
||
throw new ArgumentNullException(nameof(element));
|
||
|
||
element.AllowDrop = true;
|
||
AssociatedElement = element;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Настраивает поведение для приема только указанных типов данных.
|
||
/// </summary>
|
||
/// <param name="types">
|
||
/// Типы данных, которые может принимать цель. Если пусто, принимаются все типы.
|
||
/// </param>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// Этот метод позволяет ограничить типы данных, которые могут быть сброшены на цель.
|
||
/// Проверка выполняется в методе <see cref="CanAcceptDropAsync"/> путем сравнения
|
||
/// типа сбрасываемых данных с указанными типами.
|
||
/// </para>
|
||
/// <para>
|
||
/// Если метод не вызывался или передан пустой список, цель будет принимать данные любого типа.
|
||
/// </para>
|
||
/// <example>
|
||
/// <code>
|
||
/// // Принимать только строки и объекты MyModel
|
||
/// behavior.AcceptTypes(typeof(string), typeof(MyModel));
|
||
/// </code>
|
||
/// </example>
|
||
/// </remarks>
|
||
public void AcceptTypes(params Type[] types)
|
||
{
|
||
_acceptedTypes.Clear();
|
||
if (types != null && types.Length > 0)
|
||
{
|
||
_acceptedTypes.AddRange(types);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Настраивает поведение для приема только указанных форматов данных.
|
||
/// </summary>
|
||
/// <param name="formats">
|
||
/// Форматы данных (например, "Text", "Bitmap", "FileDrop"), которые может принимать цель.
|
||
/// Если пусто, формат не проверяется.
|
||
/// </param>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// Этот метод позволяет ограничить форматы данных, которые могут быть сброшены на цель.
|
||
/// Актуально для межпроцессного перетаскивания или работы с системными форматами.
|
||
/// </para>
|
||
/// <para>
|
||
/// Если метод не вызывался или передан пустой список, проверка формата не выполняется.
|
||
/// </para>
|
||
/// </remarks>
|
||
public void AcceptFormats(params string[] formats)
|
||
{
|
||
_acceptedFormats.Clear();
|
||
if (formats != null && formats.Length > 0)
|
||
{
|
||
foreach (var format in formats)
|
||
{
|
||
_acceptedFormats.Add(format);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Открепляет поведение от текущего элемента.
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// Этот метод выполняет следующие действия:
|
||
/// <list type="bullet">
|
||
/// <item>Отписывается от всех событий элемента</item>
|
||
/// <item>Отменяет регистрацию цели в системе перетаскивания</item>
|
||
/// <item>Сбрасывает свойство <see cref="UIElement.AllowDrop"/> = false</item>
|
||
/// <item>Освобождает ссылки на связанные объекты</item>
|
||
/// </list>
|
||
/// </para>
|
||
/// <para>
|
||
/// После вызова этого метода поведение может быть повторно прикреплено к другому элементу.
|
||
/// </para>
|
||
/// </remarks>
|
||
public new void Detach()
|
||
{
|
||
if (AssociatedElement != null)
|
||
{
|
||
AssociatedElement.AllowDrop = false;
|
||
}
|
||
base.Detach();
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region Реализация абстрактных методов DropTargetBehaviorBase<FrameworkElement>
|
||
|
||
/// <inheritdoc/>
|
||
protected override void SubscribeToEvents(FrameworkElement element)
|
||
{
|
||
if (element == null) return;
|
||
|
||
element.DragEnter += OnDragEnter;
|
||
element.DragOver += OnDragOver;
|
||
element.DragLeave += OnDragLeave;
|
||
element.Drop += OnDrop;
|
||
element.SizeChanged += OnSizeChanged;
|
||
element.LayoutUpdated += OnLayoutUpdated;
|
||
}
|
||
|
||
/// <inheritdoc/>
|
||
protected override void UnsubscribeFromEvents(FrameworkElement element)
|
||
{
|
||
if (element == null) return;
|
||
|
||
element.DragEnter -= OnDragEnter;
|
||
element.DragOver -= OnDragOver;
|
||
element.DragLeave -= OnDragLeave;
|
||
element.Drop -= OnDrop;
|
||
element.SizeChanged -= OnSizeChanged;
|
||
element.LayoutUpdated -= OnLayoutUpdated;
|
||
}
|
||
|
||
/// <inheritdoc/>
|
||
protected override Rect GetScreenBounds(FrameworkElement element)
|
||
{
|
||
if (element == null || !element.IsLoaded)
|
||
return Rect.Empty;
|
||
|
||
try
|
||
{
|
||
var window = Window.Current;
|
||
if (window?.Content == null)
|
||
return Rect.Empty;
|
||
|
||
// Преобразуем локальные координаты элемента в координаты окна
|
||
var transform = element.TransformToVisual(window.Content);
|
||
var position = transform.TransformPoint(new Windows.Foundation.Point(0, 0));
|
||
|
||
return new Rect(
|
||
position.X,
|
||
position.Y,
|
||
element.ActualWidth,
|
||
element.ActualHeight
|
||
);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
System.Diagnostics.Debug.WriteLine(
|
||
$"Ошибка получения границ элемента: {ex.Message}");
|
||
return Rect.Empty;
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region Реализация интерфейса IDropTarget
|
||
|
||
/// <inheritdoc/>
|
||
public override async Task<bool> CanAcceptDropAsync(
|
||
DropInfo dropInfo,
|
||
CancellationToken cancellationToken = default)
|
||
{
|
||
// Проверяем, есть ли данные для сброса
|
||
if (dropInfo.Data == null)
|
||
return false;
|
||
|
||
// Проверяем фильтр по типам
|
||
if (_acceptedTypes.Count > 0)
|
||
{
|
||
var dataType = dropInfo.Data.GetType();
|
||
if (!_acceptedTypes.Any(t => t.IsAssignableFrom(dataType)))
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// Проверяем фильтр по форматам (если данные предоставляют информацию о формате)
|
||
if (_acceptedFormats.Count > 0 && dropInfo.Data is Windows.ApplicationModel.DataTransfer.DataPackageView dataView)
|
||
{
|
||
var availableFormats = dataView.AvailableFormats;
|
||
if (!_acceptedFormats.Any(f => availableFormats.Contains(f)))
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// Дополнительная проверка может быть добавлена в производных классах
|
||
return await Task.FromResult(true);
|
||
}
|
||
|
||
/// <inheritdoc/>
|
||
public override async Task OnDragOverAsync(
|
||
DropInfo dropInfo,
|
||
CancellationToken cancellationToken = default)
|
||
{
|
||
await base.OnDragOverAsync(dropInfo, cancellationToken);
|
||
|
||
// Дополнительная логика для WinUI может быть добавлена здесь
|
||
// Например, обновление визуальной обратной связи через хост
|
||
}
|
||
|
||
/// <inheritdoc/>
|
||
public override async Task OnDropAsync(
|
||
DropInfo dropInfo,
|
||
CancellationToken cancellationToken = default)
|
||
{
|
||
// Базовая реализация вызывает CanAcceptDropAsync и помечает как обработанное
|
||
if (await CanAcceptDropAsync(dropInfo, cancellationToken))
|
||
{
|
||
dropInfo.MarkAsHandled();
|
||
|
||
// Здесь может быть добавлена логика обработки сброшенных данных
|
||
// Например, вызов события или обновление модели данных
|
||
}
|
||
}
|
||
|
||
/// <inheritdoc/>
|
||
public override async Task OnDragLeaveAsync(CancellationToken cancellationToken = default)
|
||
{
|
||
await base.OnDragLeaveAsync(cancellationToken);
|
||
|
||
// Дополнительная логика для WinUI может быть добавлена здесь
|
||
// Например, скрытие визуальной обратной связи
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region Обработчики событий WinUI
|
||
|
||
private async void OnDragEnter(object sender, DragEventArgs e)
|
||
{
|
||
if (AssociatedElement == null) return;
|
||
|
||
try
|
||
{
|
||
var position = e.GetPosition(AssociatedElement);
|
||
var dropInfo = CreateDropInfo(e, new Point(position.X, position.Y));
|
||
|
||
if (await CanAcceptDropAsync(dropInfo))
|
||
{
|
||
e.AcceptedOperation = Windows.ApplicationModel.DataTransfer.DataPackageOperation.Copy;
|
||
e.Handled = true;
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
System.Diagnostics.Debug.WriteLine($"Ошибка в OnDragEnter: {ex.Message}");
|
||
}
|
||
}
|
||
|
||
private async void OnDragOver(object sender, DragEventArgs e)
|
||
{
|
||
if (AssociatedElement == null) return;
|
||
|
||
try
|
||
{
|
||
var position = e.GetPosition(AssociatedElement);
|
||
var dropInfo = CreateDropInfo(e, new Point(position.X, position.Y));
|
||
|
||
if (await CanAcceptDropAsync(dropInfo))
|
||
{
|
||
e.AcceptedOperation = Windows.ApplicationModel.DataTransfer.DataPackageOperation.Copy;
|
||
await OnDragOverAsync(dropInfo);
|
||
e.Handled = true;
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
System.Diagnostics.Debug.WriteLine($"Ошибка в OnDragOver: {ex.Message}");
|
||
}
|
||
}
|
||
|
||
private async void OnDragLeave(object sender, DragEventArgs e)
|
||
{
|
||
await OnDragLeaveAsync();
|
||
}
|
||
|
||
private async void OnDrop(object sender, DragEventArgs e)
|
||
{
|
||
if (AssociatedElement == null) return;
|
||
|
||
try
|
||
{
|
||
var position = e.GetPosition(AssociatedElement);
|
||
var dropInfo = CreateDropInfo(e, new Point(position.X, position.Y));
|
||
|
||
if (await CanAcceptDropAsync(dropInfo))
|
||
{
|
||
await OnDropAsync(dropInfo);
|
||
e.Handled = true;
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
System.Diagnostics.Debug.WriteLine($"Ошибка в OnDrop: {ex.Message}");
|
||
}
|
||
}
|
||
|
||
private void OnSizeChanged(object sender, SizeChangedEventArgs e)
|
||
{
|
||
OnElementLayoutChanged();
|
||
}
|
||
|
||
private void OnLayoutUpdated(object sender, object e)
|
||
{
|
||
OnElementLayoutChanged();
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region Вспомогательные методы
|
||
|
||
/// <summary>
|
||
/// Создает объект <see cref="DropInfo"/> на основе события перетаскивания WinUI.
|
||
/// </summary>
|
||
/// <param name="e">Аргументы события перетаскивания WinUI.</param>
|
||
/// <param name="position">Локальная позиция курсора относительно элемента.</param>
|
||
/// <returns>
|
||
/// Экземпляр <see cref="DropInfo"/>, содержащий информацию о потенциальном сбросе.
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// Этот метод извлекает данные из события перетаскивания и преобразует их
|
||
/// в формат, понятный системе <see cref="Core.DragDrop"/>.
|
||
/// </para>
|
||
/// <para>
|
||
/// Поддерживаются как пользовательские данные (через свойство "DragData"),
|
||
/// так и стандартные форматы данных WinUI.
|
||
/// </para>
|
||
/// </remarks>
|
||
private DropInfo CreateDropInfo(DragEventArgs e, Point position)
|
||
{
|
||
object? data = null;
|
||
|
||
// Пытаемся получить пользовательские данные
|
||
if (e.DataView.Properties.TryGetValue("DragData", out var dragData))
|
||
{
|
||
data = dragData;
|
||
}
|
||
// Или получаем данные из DataPackage
|
||
else if (e.DataView.Contains(Windows.ApplicationModel.DataTransfer.StandardDataFormats.Text))
|
||
{
|
||
// Для текстовых данных можем установить асинхронную загрузку
|
||
data = new AsyncDataProvider(async () =>
|
||
{
|
||
return await e.DataView.GetTextAsync();
|
||
});
|
||
}
|
||
|
||
// Определяем разрешенные эффекты на основе модификаторов клавиатуры
|
||
var allowedEffects = Core.DragDrop.Enums.DragDropEffects.None;
|
||
if (e.AllowedOperations.HasFlag(Windows.ApplicationModel.DataTransfer.DataPackageOperation.Copy))
|
||
allowedEffects |= Core.DragDrop.Enums.DragDropEffects.Copy;
|
||
if (e.AllowedOperations.HasFlag(Windows.ApplicationModel.DataTransfer.DataPackageOperation.Move))
|
||
allowedEffects |= Core.DragDrop.Enums.DragDropEffects.Move;
|
||
if (e.AllowedOperations.HasFlag(Windows.ApplicationModel.DataTransfer.DataPackageOperation.Link))
|
||
allowedEffects |= Core.DragDrop.Enums.DragDropEffects.Link;
|
||
|
||
return new DropInfo(
|
||
data: data,
|
||
position: position,
|
||
allowedEffects: allowedEffects,
|
||
target: this
|
||
);
|
||
}
|
||
|
||
#endregion
|
||
}
|
||
|
||
/// <summary>
|
||
/// Предоставляет асинхронный доступ к данным перетаскивания.
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// Этот класс используется для отложенной загрузки данных перетаскивания,
|
||
/// что особенно важно для больших данных или данных, требующих обработки.
|
||
/// </remarks>
|
||
internal class AsyncDataProvider
|
||
{
|
||
private readonly Func<Task<object>> _dataLoader;
|
||
|
||
public AsyncDataProvider(Func<Task<object>> dataLoader)
|
||
{
|
||
_dataLoader = dataLoader;
|
||
}
|
||
|
||
public async Task<object> GetDataAsync()
|
||
{
|
||
return await _dataLoader();
|
||
}
|
||
} |