add Transfer

HandyControl/Controls/Base/SelectableItem.cs

@@ -29,7 +29,32 @@ namespace HandyControl.Controls
 
             if (_isMouseLeftButtonDown)
             {
-                RaiseEvent(new RoutedEventArgs(SelectedEvent, this));
+                if (SelfManage)
+                {
+                    if (!IsSelected)
+                    {
+                        IsSelected = true;
+                        RaiseEvent(new RoutedEventArgs(SelectedEvent, this));
+                    }
+                    else if (CanDeselect)
+                    {
+                        IsSelected = false;
+                        RaiseEvent(new RoutedEventArgs(DeselectedEvent, this));
+                    }
+                }
+                else
+                {
+                    if (CanDeselect)
+                    {
+                        RaiseEvent(IsSelected
+                            ? new RoutedEventArgs(DeselectedEvent, this)
+                            : new RoutedEventArgs(SelectedEvent, this));
+                    }
+                    else
+                    {
+                        RaiseEvent(new RoutedEventArgs(SelectedEvent, this));
+                    }
+                }
                 _isMouseLeftButtonDown = false;
             }
         }
@@ -43,6 +68,24 @@ namespace HandyControl.Controls
             set => SetValue(IsSelectedProperty, value);
         }
 
+        public static readonly DependencyProperty SelfManageProperty = DependencyProperty.Register(
+            "SelfManage", typeof(bool), typeof(SelectableItem), new PropertyMetadata(ValueBoxes.FalseBox));
+
+        public bool SelfManage
+        {
+            get => (bool) GetValue(SelfManageProperty);
+            set => SetValue(SelfManageProperty, value);
+        }
+
+        public static readonly DependencyProperty CanDeselectProperty = DependencyProperty.Register(
+            "CanDeselect", typeof(bool), typeof(SelectableItem), new PropertyMetadata(ValueBoxes.FalseBox));
+
+        public bool CanDeselect
+        {
+            get => (bool) GetValue(CanDeselectProperty);
+            set => SetValue(CanDeselectProperty, value);
+        }
+
         public static readonly RoutedEvent SelectedEvent =
             EventManager.RegisterRoutedEvent("Selected", RoutingStrategy.Bubble,
                 typeof(RoutedEventHandler), typeof(SelectableItem));
@@ -52,5 +95,15 @@ namespace HandyControl.Controls
             add => AddHandler(SelectedEvent, value);
             remove => RemoveHandler(SelectedEvent, value);
         }
+
+        public static readonly RoutedEvent DeselectedEvent =
+            EventManager.RegisterRoutedEvent("Deselected", RoutingStrategy.Bubble,
+                typeof(RoutedEventHandler), typeof(SelectableItem));
+
+        public event RoutedEventHandler Deselected
+        {
+            add => AddHandler(DeselectedEvent, value);
+            remove => RemoveHandler(DeselectedEvent, value);
+        }
     }
 }

HandyControl/Controls/Base/SimpleItemsControl.cs

@@ -1,4 +1,5 @@
-using System.Collections.ObjectModel;
+using System.Collections;
+using System.Collections.ObjectModel;
 using System.Collections.Specialized;
 using System.ComponentModel;
 using System.Windows;
@@ -25,13 +26,23 @@ namespace HandyControl.Controls
             "ItemContainerStyle", typeof(Style), typeof(SimpleItemsControl),
             new PropertyMetadata(default(Style), OnItemContainerStyleChanged));
 
+        public static readonly DependencyProperty ItemsSourceProperty = DependencyProperty.Register(
+            "ItemsSource", typeof(IEnumerable), typeof(SimpleItemsControl),
+            new PropertyMetadata(default(IEnumerable), OnItemsSourceChanged));
+
         public SimpleItemsControl()
         {
             var items = new ObservableCollection<object>();
-            items.CollectionChanged += OnItemsCollectionChanged;
+            items.CollectionChanged += OnItemsChanged;
             Items = items;
         }
 
+        public IEnumerable ItemsSource
+        {
+            get => (IEnumerable) GetValue(ItemsSourceProperty);
+            set => SetValue(ItemsSourceProperty, value);
+        }
+
         [Bindable(true)]
         [Category("Content")]
         public Style ItemContainerStyle
@@ -53,6 +64,15 @@ namespace HandyControl.Controls
 
         internal Panel ItemsHost { get; set; }
 
+        private static void OnItemsSourceChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            ((SimpleItemsControl) d).OnItemsSourceChanged((IEnumerable) e.OldValue, (IEnumerable) e.NewValue);
+        }
+
+        protected virtual void OnItemsSourceChanged(IEnumerable oldValue, IEnumerable newValue)
+        {
+        }
+
         public override void OnApplyTemplate()
         {
             ItemsHost?.Children.Clear();
@@ -63,7 +83,7 @@ namespace HandyControl.Controls
             Refresh();
         }
 
-        private void OnItemsCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
+        protected virtual void OnItemsChanged(object sender, NotifyCollectionChangedEventArgs e)
         {
             Refresh();
             UpdateItems();
@@ -88,17 +108,15 @@ namespace HandyControl.Controls
             }
         }
 
-        private static void OnItemTemplateChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
-        {
-            var target = d as SimpleItemsControl;
-            target?.Refresh();
-        }
+        private static void OnItemTemplateChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
+            => (d as SimpleItemsControl)?.OnItemTemplateChanged(e);
+
+        protected virtual void OnItemTemplateChanged(DependencyPropertyChangedEventArgs e) => Refresh();
 
         private static void OnItemContainerStyleChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
-        {
-            var target = d as SimpleItemsControl;
-            target?.Refresh();
-        }
+            => (d as SimpleItemsControl)?.OnItemContainerStyleChanged(e);
+
+        protected virtual void OnItemContainerStyleChanged(DependencyPropertyChangedEventArgs e) => Refresh();
 
         protected virtual void Refresh()
         {
@@ -128,7 +146,6 @@ namespace HandyControl.Controls
 
         protected virtual void UpdateItems()
         {
-
         }
     }
 }

HandyControl/Controls/Transfer/Transfer.cs

@@ -0,0 +1,223 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.Linq;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+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
+    {
+        private const string ElementItemsOrigin = "PART_ItemsOrigin";
+
+        private const string ElementItemsSelected = "PART_ItemsSelected";
+
+        private readonly Dictionary<object, TransferEntry> _entryDic = new Dictionary<object, TransferEntry>();
+
+        private SimpleItemsControl _itemsOrigin;
+
+        private SimpleItemsControl _itemsSelected;
+
+        private IEnumerable _itemsSourceInternal;
+
+        public static readonly RoutedEvent SelectionChangedEvent =
+            EventManager.RegisterRoutedEvent("SelectionChanged", RoutingStrategy.Bubble,
+                typeof(SelectionChangedEventHandler), typeof(Transfer));
+
+        public event SelectionChangedEventHandler SelectionChanged
+        {
+            add => AddHandler(SelectionChangedEvent, value);
+            remove => RemoveHandler(SelectionChangedEvent, 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);
+        }
+
+        public Transfer()
+        {
+            CommandBindings.Add(new CommandBinding(ControlCommands.Selected, SelectItems));
+            CommandBindings.Add(new CommandBinding(ControlCommands.Cancel, DeselectItems));
+
+            SetValue(SelectedItemsPropertyKey, new ObservableCollection<object>());
+        }
+
+        public override void OnApplyTemplate()
+        {
+            _itemsOrigin?.ItemsHost.Children.Clear();
+            _itemsSelected?.ItemsHost.Children.Clear();
+
+            _itemsOrigin = GetTemplateChild(ElementItemsOrigin) as SimpleItemsControl;
+            _itemsSelected = GetTemplateChild(ElementItemsSelected) as SimpleItemsControl;
+
+            Refresh();
+        }
+
+        private void AddItem(object item)
+        {
+            var origin = new TransferItem
+            {
+                Content = item
+            };
+            var selected = new TransferItem
+            {
+                Content = item,
+                IsOrigin = false
+            };
+            var entry = new TransferEntry
+            {
+                OriginItem = origin,
+                SelectedItem = selected
+            };
+            _entryDic.Add(item, entry);
+            _itemsOrigin.Items.Add(origin);
+            _itemsSelected.Items.Add(selected);
+        }
+
+        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);
+            }
+        }
+
+        private void ClearItems()
+        {
+            _entryDic.Clear();
+            _itemsOrigin.Items.Clear();
+            _itemsSelected.Items.Clear();
+        }
+
+        protected override void OnItemsSourceChanged(IEnumerable oldValue, IEnumerable newValue)
+        {
+            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 (e.OldItems != null)
+            {
+                foreach (var item in e.OldItems)
+                {
+                    RemoveItem(item);
+                }
+            }
+            if (e.NewItems != null)
+            {
+                foreach (var item in e.NewItems)
+                {
+                    AddItem(item);
+                }
+            }
+        }
+
+        protected override DependencyObject GetContainerForItemOverride() => new TransferItem();
+
+        protected override bool IsItemItsOwnContainerOverride(object item) => item is 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));
+        }
+
+        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 (_entryDic.Count > 0)
+            {
+                _entryDic.Select(item => item.Value.OriginItem).Do(item => _itemsOrigin.Items.Add(item));
+                _entryDic.Select(item => item.Value.SelectedItem).Do(item => _itemsSelected.Items.Add(item));
+            }
+        }
+
+        private struct TransferEntry
+        {
+            public TransferItem OriginItem { get; set; }
+
+            public TransferItem SelectedItem { get; set; }
+
+            public void StatusSwitch(bool isTransferred)
+            {
+                if (isTransferred)
+                {
+                    OriginItem.IsTransferred = true;
+                    SelectedItem.IsTransferred = true;
+                    OriginItem.IsSelected = false;
+                }
+                else
+                {
+                    OriginItem.IsTransferred = false;
+                    SelectedItem.IsTransferred = false;
+                    SelectedItem.IsSelected = false;
+                }
+            }
+        }
+    }
+}

HandyControl/Controls/Transfer/TransferGroup.cs

@@ -0,0 +1,54 @@
+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;
+            if (e.OldItems != null)
+            {
+                foreach (FrameworkElement item in e.OldItems)
+                {
+                    ItemsHost.Children.Remove(item);
+                }
+            }
+            if (e.NewItems != null)
+            {
+                foreach (FrameworkElement item in e.NewItems)
+                {
+                    item.Style = ItemContainerStyle;
+                    ItemsHost.Children.Add(item);
+                }
+            }
+        }
+    }
+}

HandyControl/Controls/Transfer/TransferItem.cs

@@ -0,0 +1,26 @@
+using System.Windows;
+using HandyControl.Data;
+
+namespace HandyControl.Controls
+{
+    public class TransferItem : SelectableItem
+    {
+        public static readonly DependencyProperty IsTransferredProperty = DependencyProperty.Register(
+            "IsTransferred", typeof(bool), typeof(TransferItem), new PropertyMetadata(ValueBoxes.FalseBox));
+
+        public bool IsTransferred
+        {
+            get => (bool) GetValue(IsTransferredProperty);
+            set => SetValue(IsTransferredProperty, value);
+        }
+
+        public static readonly DependencyProperty IsOriginProperty = DependencyProperty.Register(
+            "IsOrigin", typeof(bool), typeof(TransferItem), new PropertyMetadata(ValueBoxes.TrueBox));
+
+        public bool IsOrigin
+        {
+            get => (bool) GetValue(IsOriginProperty);
+            internal set => SetValue(IsOriginProperty, value);
+        }
+    }
+}

HandyControl/HandyControl.csproj

@@ -110,6 +110,9 @@
     <Compile Include="Controls\Button\ContextMenuToggleButton.cs" />
     <Compile Include="Controls\Other\Carousel.cs" />
     <Compile Include="Controls\Cover\CoverView\CoverView.cs" />
+    <Compile Include="Controls\Transfer\Transfer.cs" />
+    <Compile Include="Controls\Transfer\TransferGroup.cs" />
+    <Compile Include="Controls\Transfer\TransferItem.cs" />
     <Compile Include="Controls\Panel\CirclePanel.cs" />
     <Compile Include="Controls\Other\CircleProgressBar.cs" />
     <Compile Include="Controls\Other\RadioGroup.cs" />
@@ -167,6 +170,7 @@
     <Compile Include="Data\SystemVersionInfo.cs" />
     <Compile Include="Tools\Converter\Boolean2StrConverter.cs" />
     <Compile Include="Tools\Converter\Int2StrConverter.cs" />
+    <Compile Include="Tools\Extension\EnumerableExtension.cs" />
     <Compile Include="Tools\Helper\ColorHelper.cs" />
     <Compile Include="Tools\GifImageAnimator.cs" />
     <Compile Include="Data\GrowlInfo.cs" />
@@ -396,6 +400,10 @@
       <SubType>Designer</SubType>
       <Generator>MSBuild:Compile</Generator>
     </Page>
+    <Page Include="Themes\Styles\Base\TransferBaseStyle.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
     <Page Include="Themes\Styles\Base\TreeViewBaseStyle.xaml">
       <SubType>Designer</SubType>
       <Generator>MSBuild:Compile</Generator>
@@ -700,6 +708,10 @@
       <SubType>Designer</SubType>
       <Generator>MSBuild:Compile</Generator>
     </Page>
+    <Page Include="Themes\Styles\Transfer.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
     <Page Include="Themes\Styles\TransitioningContentControl.xaml">
       <SubType>Designer</SubType>
       <Generator>MSBuild:Compile</Generator>

HandyControl/Themes/Styles/Base/TransferBaseStyle.xaml

@@ -0,0 +1,115 @@
+<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                    xmlns:controls="clr-namespace:HandyControl.Controls"
+                    xmlns:interactivity="clr-namespace:HandyControl.Interactivity">
+
+    <ResourceDictionary.MergedDictionaries>
+        <ResourceDictionary Source="../../Basic/Geometries.xaml"/>
+        <ResourceDictionary Source="../../Basic/Behaviors.xaml"/>
+        <ResourceDictionary Source="../../Basic/Sizes.xaml"/>
+    </ResourceDictionary.MergedDictionaries>
+
+    <Style x:Key="TransferItemBaseStyle" TargetType="controls:TransferItem">
+        <Setter Property="HorizontalContentAlignment" Value="Stretch"/>
+        <Setter Property="CanDeselect" Value="True"/>
+        <Setter Property="SelfManage" Value="True"/>
+        <Setter Property="Padding" Value="10"/>
+        <Setter Property="MinHeight" Value="{StaticResource DefaultControlHeight}"/>
+        <Setter Property="Margin" Value="5,0,5,5"/>
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="controls:TransferItem">
+                    <Border x:Name="BorderRoot" Background="{DynamicResource RegionBrush}" CornerRadius="{Binding Path=(controls:BorderElement.CornerRadius),RelativeSource={RelativeSource TemplatedParent}}">
+                        <ContentPresenter x:Name="ContentPresenter" Margin="{TemplateBinding Padding}" ContentTemplate="{Binding ItemTemplate,RelativeSource={RelativeSource AncestorType=controls:TransferGroup}}"/>
+                    </Border>
+                    <ControlTemplate.Triggers>
+                        <Trigger Property="IsSelected" Value="True">
+                            <Setter TargetName="BorderRoot" Property="Background" Value="{DynamicResource PrimaryBrush}"/>
+                            <Setter TargetName="ContentPresenter" Property="TextElement.Foreground" Value="{DynamicResource TextIconBrush}"/>
+                        </Trigger>
+                    </ControlTemplate.Triggers>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+        <Style.Triggers>
+            <MultiTrigger>
+                <MultiTrigger.Conditions>
+                    <Condition Property="IsOrigin" Value="True"/>
+                    <Condition Property="IsTransferred" Value="False"/>
+                </MultiTrigger.Conditions>
+                <Setter Property="Visibility" Value="Visible"/>
+            </MultiTrigger>
+            <MultiTrigger>
+                <MultiTrigger.Conditions>
+                    <Condition Property="IsOrigin" Value="True"/>
+                    <Condition Property="IsTransferred" Value="True"/>
+                </MultiTrigger.Conditions>
+                <Setter Property="Visibility" Value="Collapsed"/>
+            </MultiTrigger>
+            <MultiTrigger>
+                <MultiTrigger.Conditions>
+                    <Condition Property="IsOrigin" Value="False"/>
+                    <Condition Property="IsTransferred" Value="True"/>
+                </MultiTrigger.Conditions>
+                <Setter Property="Visibility" Value="Visible"/>
+            </MultiTrigger>
+            <MultiTrigger>
+                <MultiTrigger.Conditions>
+                    <Condition Property="IsOrigin" Value="False"/>
+                    <Condition Property="IsTransferred" Value="False"/>
+                </MultiTrigger.Conditions>
+                <Setter Property="Visibility" Value="Collapsed"/>
+            </MultiTrigger>
+        </Style.Triggers>
+    </Style>
+
+    <Style x:Key="TransferGroupBaseStyle" TargetType="controls:TransferGroup">
+        <Setter Property="BorderThickness" Value="0"/>
+        <Setter Property="Background" Value="{DynamicResource DarkDefaultBrush}"/>
+        <Setter Property="BorderBrush" Value="{DynamicResource BorderBrush}"/>
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="controls:TransferGroup">
+                    <Border Background="{TemplateBinding Background}" CornerRadius="{Binding Path=(controls:BorderElement.CornerRadius),RelativeSource={RelativeSource TemplatedParent}}" BorderThickness="{TemplateBinding BorderThickness}" BorderBrush="{TemplateBinding BorderBrush}">
+                        <ScrollViewer Margin="0,5">
+                            <StackPanel x:Name="PART_Panel"/>
+                        </ScrollViewer>
+                    </Border>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <Style x:Key="TransferBaseStyle" TargetType="controls:Transfer">
+        <Setter Property="BorderThickness" Value="1"/>
+        <Setter Property="controls:BorderElement.CornerRadius" Value="4"/>
+        <Setter Property="BorderBrush" Value="{DynamicResource BorderBrush}"/>
+        <Setter Property="ItemContainerStyle" Value="{StaticResource TransferItemBaseStyle}"/>
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="controls:Transfer">
+                    <Grid>
+                        <Grid.ColumnDefinitions>
+                            <ColumnDefinition MinWidth="200"/>
+                            <ColumnDefinition Width="Auto"/>
+                            <ColumnDefinition MinWidth="200"/>
+                        </Grid.ColumnDefinitions>
+                        <Grid.RowDefinitions>
+                            <RowDefinition/>
+                            <RowDefinition/>
+                            <RowDefinition/>
+                            <RowDefinition/>
+                        </Grid.RowDefinitions>
+                        <controls:TransferGroup x:Name="PART_ItemsOrigin" Style="{StaticResource TransferGroupBaseStyle}" Grid.RowSpan="4" ItemTemplate="{TemplateBinding ItemTemplate}" ItemContainerStyle="{TemplateBinding ItemContainerStyle}"/>
+                        <StackPanel Margin="32,0" VerticalAlignment="Center" HorizontalAlignment="Center" Grid.Row="0" Grid.RowSpan="4" Grid.Column="1">
+                            <Button controls:IconElement.Geometry="{StaticResource LeftGeometry}" Command="interactivity:ControlCommands.Cancel"/>
+                            <Button controls:IconElement.Geometry="{StaticResource RightGeometry}" Margin="0,10,0,0" Command="interactivity:ControlCommands.Selected"/>
+                        </StackPanel>
+                        <controls:TransferGroup x:Name="PART_ItemsSelected" Style="{StaticResource TransferGroupBaseStyle}" Grid.Row="0" Grid.RowSpan="4" Grid.Column="2" ItemTemplate="{TemplateBinding ItemTemplate}" ItemContainerStyle="{TemplateBinding ItemContainerStyle}"/>
+                    </Grid>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+</ResourceDictionary>

HandyControl/Themes/Styles/Style.xaml

@@ -55,6 +55,7 @@
         <ResourceDictionary Source="CoverView.xaml"/>
         <ResourceDictionary Source="CoverFlow.xaml"/>
         <ResourceDictionary Source="ProgressButton.xaml"/>
+        <ResourceDictionary Source="Transfer.xaml"/>
     </ResourceDictionary.MergedDictionaries>
 
 </ResourceDictionary>

HandyControl/Themes/Styles/Transfer.xaml

@@ -0,0 +1,10 @@
+<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                    xmlns:controls="clr-namespace:HandyControl.Controls">
+
+    <ResourceDictionary.MergedDictionaries>
+        <ResourceDictionary Source="Base/TransferBaseStyle.xaml"/>
+    </ResourceDictionary.MergedDictionaries>
+
+    <Style BasedOn="{StaticResource TransferBaseStyle}" TargetType="controls:Transfer"/>
+    
+</ResourceDictionary>

HandyControl/Tools/Extension/EnumerableExtension.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace HandyControl.Tools.Extension
+{
+    public static class EnumerableExtension
+    {
+        public static IEnumerable<TSource> Do<TSource>(this IEnumerable<TSource> source, Action<TSource> predicate)
+        {
+            var enumerable = source as IList<TSource> ?? source.ToList();
+            foreach (var item in enumerable)
+            {
+                predicate.Invoke(item);
+            }
+
+            return enumerable;
+        }
+    }
+}