refactor: improved transfer.

close #1273
This commit is contained in:
NaBian committed 2022-10-15 17:57:46 +08:00
1 parent c513f5c6f5
commit 76d1787b45
12 files changed
+329 -530

No files matched your search

@@ -1,288 +1,120 @@
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Input;
using HandyControl.Data;
using HandyControl.Interactivity;
using HandyControl.Tools.Extension;
namespace HandyControl.Controls;
/// <summary>
/// 穿梭框
/// </summary>
[TemplatePart(Name = ElementItemsOrigin, Type = typeof(SimpleItemsControl))]
[TemplatePart(Name = ElementItemsSelected, Type = typeof(SimpleItemsControl))]
public class Transfer : SimpleItemsControl
[TemplatePart(Name = ElementSelectedListBox, Type = typeof(ListBox))]
[DefaultEvent(nameof(Transferred))]
public class Transfer : ListBox
{
private const string ElementItemsOrigin = "PART_ItemsOrigin";
private const string ElementSelectedListBox = "PART_SelectedListBox";
private const string ElementItemsSelected = "PART_ItemsSelected";
public static readonly RoutedEvent TransferredEvent =
EventManager.RegisterRoutedEvent("Transferred", RoutingStrategy.Bubble,
typeof(RoutedEventHandler), typeof(Transfer));
private readonly Dictionary<object, TransferEntry> _entryDic = new();
private readonly List<TransferEntry> _entryList = new();
private SimpleItemsControl _itemsOrigin;
private SimpleItemsControl _itemsSelected;
private IEnumerable _itemsSourceInternal;
private IEnumerable _initEnumerable;
private NotifyCollectionChangedEventArgs _initArgs;
public static readonly RoutedEvent SelectionChangedEvent =
EventManager.RegisterRoutedEvent("SelectionChanged", RoutingStrategy.Bubble,
typeof(SelectionChangedEventHandler), typeof(Transfer));
public event SelectionChangedEventHandler SelectionChanged
[Category("Behavior")]
public event RoutedEventHandler Transferred
{
add => AddHandler(SelectionChangedEvent, value);
remove => RemoveHandler(SelectionChangedEvent, value);
add => AddHandler(TransferredEvent, value);
remove => RemoveHandler(TransferredEvent, value);
}
private static readonly DependencyPropertyKey SelectedItemsPropertyKey =
DependencyProperty.RegisterReadOnly(
"SelectedItems",
typeof(IList),
typeof(Transfer),
new FrameworkPropertyMetadata(default(IList)));
public static readonly DependencyProperty SelectedItemsProperty = SelectedItemsPropertyKey.DependencyProperty;
public IList SelectedItems
{
get => (IList) GetValue(SelectedItemsProperty);
set => SetValue(SelectedItemsProperty, value);
}
private ListBox _selectedListBox;
public Transfer()
{
CommandBindings.Add(new CommandBinding(ControlCommands.Selected, SelectItems));
CommandBindings.Add(new CommandBinding(ControlCommands.Cancel, DeselectItems));
Loaded += OnLoaded;
}
SetValue(SelectedItemsPropertyKey, new ObservableCollection<object>());
private void OnLoaded(object sender, RoutedEventArgs e)
{
SelectItems(null, null);
}
public override void OnApplyTemplate()
{
_itemsOrigin?.ItemsHost.Children.Clear();
_itemsSelected?.ItemsHost.Children.Clear();
base.OnApplyTemplate();
_itemsOrigin = GetTemplateChild(ElementItemsOrigin) as SimpleItemsControl;
_itemsSelected = GetTemplateChild(ElementItemsSelected) as SimpleItemsControl;
if (_itemsOrigin != null && _itemsSelected != null)
{
if (_initEnumerable != null)
{
OnItemsSourceChanged(null, _initEnumerable);
_initEnumerable = null;
}
if (_initArgs != null)
{
InternalCollectionChanged(null, _initArgs);
_initArgs = null;
}
if (_itemsOrigin.Items.Count == 0)
{
Refresh();
}
}
_selectedListBox = GetTemplateChild(ElementSelectedListBox) as ListBox;
}
private void InsertItem(int index, object item, bool isTransferred = false)
protected virtual void OnTransferred(RoutedEventArgs e)
{
var origin = new TransferItem
{
Content = item,
IsTransferred = isTransferred
};
var selected = new TransferItem
{
Content = item,
IsOrigin = false,
IsTransferred = isTransferred
};
var entry = new TransferEntry
{
OriginItem = origin,
SelectedItem = selected
};
_entryDic.Add(item, entry);
_entryList.Insert(index, entry);
_itemsOrigin.Items.Insert(index, origin);
_itemsSelected.Items.Insert(index, selected);
RaiseEvent(e);
}
private void AddItem(object item) => InsertItem(_entryDic.Count, item);
private void RemoveItem(object item)
{
if (_entryDic.TryGetValue(item, out var entry))
{
_itemsOrigin.Items.Remove(entry.OriginItem);
_itemsSelected.Items.Remove(entry.SelectedItem);
_entryDic.Remove(item);
_entryList.Remove(entry);
}
}
private void ClearItems()
{
_entryDic.Clear();
_entryList.Clear();
_itemsOrigin.Items.Clear();
_itemsSelected.Items.Clear();
}
protected override void OnItemsSourceChanged(IEnumerable oldValue, IEnumerable newValue)
{
if (_itemsOrigin == null || _itemsSelected == null)
{
_initEnumerable = newValue;
return;
}
if (_itemsSourceInternal != null)
{
if (_itemsSourceInternal is INotifyCollectionChanged s)
{
s.CollectionChanged -= InternalCollectionChanged;
}
ClearItems();
}
_itemsSourceInternal = newValue;
if (_itemsSourceInternal != null)
{
if (_itemsSourceInternal is INotifyCollectionChanged s)
{
s.CollectionChanged += InternalCollectionChanged;
}
foreach (var item in _itemsSourceInternal)
{
AddItem(item);
}
}
}
private void InternalCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
if (_itemsOrigin == null || _itemsSelected == null)
{
_initArgs = e;
return;
}
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
if (e.NewItems != null)
{
foreach (var item in e.NewItems)
{
AddItem(item);
}
}
break;
case NotifyCollectionChangedAction.Remove:
if (e.OldItems != null)
{
foreach (var item in e.OldItems)
{
RemoveItem(item);
}
}
break;
case NotifyCollectionChangedAction.Replace:
case NotifyCollectionChangedAction.Move:
if (e.OldItems != null && e.NewItems != null)
{
var oldItem = e.OldItems[0];
if (_entryDic.TryGetValue(oldItem, out var entry))
{
var isTransferred = entry.SelectedItem.IsTransferred;
RemoveItem(oldItem);
InsertItem(e.NewStartingIndex, e.NewItems[0], isTransferred);
}
}
break;
case NotifyCollectionChangedAction.Reset:
ClearItems();
break;
}
}
protected override DependencyObject GetContainerForItemOverride() => new TransferItem();
protected override bool IsItemItsOwnContainerOverride(object item) => item is TransferItem;
protected override DependencyObject GetContainerForItemOverride() => new TransferItem();
private void SelectItems(object sender, ExecutedRoutedEventArgs e)
{
var list = _entryDic.Where(item => item.Value.OriginItem.IsSelected).ToList();
list.Do(item => item.Value.StatusSwitch(true)).Do(item => SelectedItems.Add(item.Key));
RaiseEvent(new SelectionChangedEventArgs(SelectionChangedEvent, new List<object>(), list));
if (_selectedListBox == null)
{
return;
}
foreach (var item in SelectedItems)
{
if (ItemContainerGenerator.ContainerFromItem(item) is not TransferItem { IsTransferred: false } selectedItem)
{
continue;
}
selectedItem.IsTransferred = true;
var transferItem = new TransferItem
{
Tag = item
};
if (ItemsSource != null)
{
transferItem.SetBinding(ContentControl.ContentProperty, new Binding(DisplayMemberPath) { Source = item });
}
else
{
transferItem.Content = IsItemItsOwnContainerOverride(item) ? ((TransferItem) item).Content : item;
}
_selectedListBox.Items.Add(transferItem);
}
OnTransferred(new RoutedEventArgs(TransferredEvent, this));
}
private void DeselectItems(object sender, ExecutedRoutedEventArgs e)
{
var list = _entryDic.Where(item => item.Value.SelectedItem.IsSelected).ToList();
list.Do(item => item.Value.StatusSwitch(false)).Do(item => SelectedItems.Remove(item.Key));
RaiseEvent(new SelectionChangedEventArgs(SelectionChangedEvent, list, new List<object>()));
}
protected override void OnItemsChanged(object sender, NotifyCollectionChangedEventArgs e)
{
}
protected override void OnItemTemplateChanged(DependencyPropertyChangedEventArgs e)
{
}
protected override void OnItemContainerStyleChanged(DependencyPropertyChangedEventArgs e)
{
}
protected override void Refresh()
{
if (_entryList.Count > 0)
if (_selectedListBox == null)
{
_entryList.Select(item => item.OriginItem).Do(item => _itemsOrigin.Items.Add(item));
_entryList.Select(item => item.SelectedItem).Do(item => _itemsSelected.Items.Add(item));
return;
}
}
private struct TransferEntry
{
public TransferItem OriginItem { get; set; }
public TransferItem SelectedItem { get; set; }
public void StatusSwitch(bool isTransferred)
foreach (var transferItem in _selectedListBox.Items.OfType<TransferItem>().ToList())
{
if (isTransferred)
if (!transferItem.IsSelected)
{
OriginItem.IsTransferred = true;
SelectedItem.IsTransferred = true;
OriginItem.IsSelected = false;
continue;
}
else
if (ItemContainerGenerator.ContainerFromItem(transferItem.Tag) is TransferItem selectedItem)
{
OriginItem.IsTransferred = false;
SelectedItem.IsTransferred = false;
SelectedItem.IsSelected = false;
_selectedListBox.Items.Remove(transferItem);
selectedItem.SetCurrentValue(TransferItem.IsTransferredProperty, ValueBoxes.FalseBox);
selectedItem.SetCurrentValue(ListBoxItem.IsSelectedProperty, ValueBoxes.FalseBox);
}
}
OnTransferred(new RoutedEventArgs(TransferredEvent, this));
}
}
@@ -1,64 +0,0 @@
using System.Collections.Specialized;
using System.Windows;
namespace HandyControl.Controls;
public class TransferGroup : SimpleItemsControl
{
protected override void Refresh()
{
if (Items.Count > 0)
{
foreach (FrameworkElement item in Items)
{
item.Style = ItemContainerStyle;
ItemsHost.Children.Add(item);
}
}
}
protected override void OnItemTemplateChanged(DependencyPropertyChangedEventArgs e)
{
}
protected override void OnItemContainerStyleChanged(DependencyPropertyChangedEventArgs e)
{
}
protected override DependencyObject GetContainerForItemOverride() => new TransferItem();
protected override bool IsItemItsOwnContainerOverride(object item) => item is TransferItem;
protected override void OnItemsChanged(object sender, NotifyCollectionChangedEventArgs e)
{
if (ItemsHost == null) return;
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
if (e.NewItems != null)
{
if (e.NewItems[0] is FrameworkElement item)
{
item.Style = ItemContainerStyle;
ItemsHost.Children.Insert(e.NewStartingIndex, item);
}
}
break;
case NotifyCollectionChangedAction.Remove:
if (e.OldItems != null)
{
foreach (FrameworkElement item in e.OldItems)
{
ItemsHost.Children.Remove(item);
}
}
break;
case NotifyCollectionChangedAction.Reset:
ItemsHost.Children.Clear();
break;
}
}
}
@@ -1,9 +1,10 @@
using System.Windows;
using System.Windows.Controls;
using HandyControl.Data;
namespace HandyControl.Controls;
public class TransferItem : SelectableItem
public class TransferItem : ListBoxItem
{
public static readonly DependencyProperty IsTransferredProperty = DependencyProperty.Register(
nameof(IsTransferred), typeof(bool), typeof(TransferItem), new PropertyMetadata(ValueBoxes.FalseBox));
@@ -13,13 +14,4 @@ public class TransferItem : SelectableItem
get => (bool) GetValue(IsTransferredProperty);
set => SetValue(IsTransferredProperty, ValueBoxes.BooleanBox(value));
}
public static readonly DependencyProperty IsOriginProperty = DependencyProperty.Register(
nameof(IsOrigin), typeof(bool), typeof(TransferItem), new PropertyMetadata(ValueBoxes.TrueBox));
public bool IsOrigin
{
get => (bool) GetValue(IsOriginProperty);
internal set => SetValue(IsOriginProperty, ValueBoxes.BooleanBox(value));
}
}