internal virtual void SetupDragDropProperties(IReorderItem item, int logicalIndex)
{
DragDrop.SetDragPositionMode(item.Visual, DragPositionMode.RailY);
item.Coordinator = this.reorderCoordinator;
item.LogicalIndex = logicalIndex;
}
private void ReorderItems(IReorderItem source, IReorderItem destination)
{
if (source != destination && !this.animatingElements.Contains(destination) && !this.animatingElements.Contains(source))
{
this.UpdatePositionAndIndices(source, destination);
}
}
protected virtual void UpdatePositionAndIndices(IReorderItem source, IReorderItem destination)
{
var step = source.LogicalIndex < destination.LogicalIndex ? 1 : -1;
var destinationIndex = destination.LogicalIndex;
var sourceIndex = source.LogicalIndex;
for (int i = sourceIndex + step; step > 0 ? i <= destinationIndex : i >= destinationIndex; i += step)
{
var currentDestinationItem = this.Host.ElementAt(i);
if (this.animatingElements.Contains(currentDestinationItem))
{
continue;
}
this.animatingElements.Add(currentDestinationItem);
var destinationPosition = GetRearrangePosition(currentDestinationItem, source);
source.ArrangePosition = GetRearrangePosition(source, currentDestinationItem);
var index = source.LogicalIndex;
source.LogicalIndex = currentDestinationItem.LogicalIndex;
currentDestinationItem.LogicalIndex = index;
this.AnimateItem(source, currentDestinationItem, destinationPosition);
}
}
private static Point GetRearangePosition(IReorderItem targetItem, IReorderItem adjasentItem)
{
Point position;
if (targetItem.LogicalIndex > adjasentItem.LogicalIndex)
{
position = adjasentItem.ArrangePosition;
}
else
{
double x = -1;
double y = -1;
var dragPositionMode = DragDrop.GetDragPositionMode(targetItem.Visual);
if (dragPositionMode == DragPositionMode.RailY || dragPositionMode == DragPositionMode.Free)
{
x = adjasentItem.ArrangePosition.X;
y = adjasentItem.ArrangePosition.Y + adjasentItem.ActualSize.Height - targetItem.ActualSize.Height;
}
if (dragPositionMode == DragPositionMode.RailX || dragPositionMode == DragPositionMode.Free)
{
x = adjasentItem.ArrangePosition.X + adjasentItem.ActualSize.Width - targetItem.ActualSize.Width;
y = adjasentItem.ArrangePosition.Y;
}
position = new Point(x, y);
}
return(position);
}
internal void SetupReorderItem(IReorderItem reorderItem)
{
if (reorderItem != null)
{
reorderItem.Coordinator = this.reorderCoordinator;
}
}
private static Point GetRearrangePosition(IReorderItem targetItem, IReorderItem adjacentItem)
{
var position = targetItem.ArrangePosition;
var dragPositionMode = DragDrop.GetDragPositionMode(targetItem.Visual);
if (dragPositionMode == DragPositionMode.RailY || dragPositionMode == DragPositionMode.Free)
{
position.Y = adjacentItem.ArrangePosition.Y;
if (targetItem.LogicalIndex < adjacentItem.LogicalIndex)
{
position.Y += adjacentItem.ActualSize.Height - targetItem.ActualSize.Height;
}
}
if (dragPositionMode == DragPositionMode.RailX || dragPositionMode == DragPositionMode.Free)
{
position.X = adjacentItem.ArrangePosition.X;
if (targetItem.LogicalIndex < adjacentItem.LogicalIndex)
{
position.X += adjacentItem.ActualSize.Width - targetItem.ActualSize.Width;
}
}
return(position);
}
internal int ReorderItem(int sourceIndex, IReorderItem destinationItem)
{
var sourceItem = this.Host.ElementAt(sourceIndex);
this.ReorderItems(sourceItem, destinationItem);
return(sourceItem.LogicalIndex);
}
internal override void SetupDragDropProperties(IReorderItem item, int logicalIndex)
{
base.SetupDragDropProperties(item, logicalIndex);
if (this.Owner.Owner.Columns.Count > 1)
{
DragDrop.SetAllowDrag(item.Visual, true);
}
}
protected void AnimateItem(IReorderItem source, IReorderItem destination, Point position)
{
var dragPositionMode = DragDrop.GetDragPositionMode(destination.Visual);
Storyboard b = new Storyboard();
Action actionCompleted = () =>
{
destination.ArrangePosition = position;
this.animatingElements.Remove(destination);
this.Host.OnItemsReordered(source, destination);
};
this.runningAnimations.Add(b, actionCompleted);
if (dragPositionMode == DragPositionMode.RailY || dragPositionMode == DragPositionMode.Free)
{
var topAnimation = new DoubleAnimation();
topAnimation.Duration = DefaultAnimationDuration;
topAnimation.EasingFunction = new QuadraticEase()
{
EasingMode = EasingMode.EaseIn
};
topAnimation.To = position.Y;
Storyboard.SetTargetProperty(topAnimation, "(Canvas.Top)");
Storyboard.SetTarget(topAnimation, destination.Visual);
b.Children.Add(topAnimation);
}
if (dragPositionMode == DragPositionMode.RailX || dragPositionMode == DragPositionMode.Free)
{
var leftAnimation = new DoubleAnimation();
leftAnimation.Duration = DefaultAnimationDuration;
leftAnimation.EasingFunction = new QuadraticEase()
{
EasingMode = EasingMode.EaseIn
};
leftAnimation.To = position.X;
Storyboard.SetTargetProperty(leftAnimation, "(Canvas.Left)");
Storyboard.SetTarget(leftAnimation, destination.Visual);
b.Children.Add(leftAnimation);
}
b.Completed += (s, e) =>
{
runningAnimations.Remove(b);
actionCompleted();
};
b.Begin();
}
internal void CancelReorderOperation(IReorderItem sourceItem, int initialSourceIndex)
{
var destinationItem = this.Host.ElementAt(initialSourceIndex);
foreach (var animationPair in this.runningAnimations)
{
animationPair.Key.Stop();
animationPair.Value();
}
this.runningAnimations.Clear();
this.UpdatePositionAndIndices(sourceItem, destinationItem);
}
void IReorderItemsHost.OnItemsReordered(IReorderItem sourceItem, IReorderItem destinationItem)
{
if (sourceItem == null || destinationItem == null)
{
return;
}
var childrenCount = this.Container.Children.Count;
var sourceVisual = sourceItem.Visual as DataGridFlyoutGroupHeader;
var destinationVisual = destinationItem.Visual as DataGridFlyoutGroupHeader;
sourceVisual.BottomGlyphOpacity = sourceItem.LogicalIndex == childrenCount - 1 ? 0.0 : 1;
destinationVisual.BottomGlyphOpacity = destinationItem.LogicalIndex == childrenCount - 1 ? 0.0 : 1;
}
protected virtual void AnimateItem(IReorderItem item, Point position, Action actionCompleted)
{
var dragPositionMode = DragDrop.GetDragPositionMode(item.Visual);
Storyboard b = new Storyboard();
this.runningAnimations.Add(b, actionCompleted);
if (dragPositionMode == DragPositionMode.RailY || dragPositionMode == DragPositionMode.Free)
{
var topAnimation = new DoubleAnimation();
topAnimation.Duration = DefaultAnimationDuration;
topAnimation.EasingFunction = new QuadraticEase()
{
EasingMode = EasingMode.EaseIn
};
topAnimation.To = position.Y;
Storyboard.SetTargetProperty(topAnimation, "(Canvas.Top)");
Storyboard.SetTarget(topAnimation, item.Visual);
b.Children.Add(topAnimation);
}
if (dragPositionMode == DragPositionMode.RailX || dragPositionMode == DragPositionMode.Free)
{
var leftAnimation = new DoubleAnimation();
leftAnimation.Duration = DefaultAnimationDuration;
leftAnimation.EasingFunction = new QuadraticEase()
{
EasingMode = EasingMode.EaseIn
};
leftAnimation.To = position.X;
Storyboard.SetTargetProperty(leftAnimation, "(Canvas.Left)");
Storyboard.SetTarget(leftAnimation, item.Visual);
b.Children.Add(leftAnimation);
}
b.Completed += (s, e) =>
{
runningAnimations.Remove(b);
actionCompleted();
};
b.Begin();
}
private void UpdatePositionAndIndices(IReorderItem source, IReorderItem destination)
{
var step = source.LogicalIndex < destination.LogicalIndex ? 1 : -1;
var destinationIndex = destination.LogicalIndex;
var sourceIndex = source.LogicalIndex;
for (int i = sourceIndex + step; step > 0 ? i <= destinationIndex : i >= destinationIndex; i += step)
{
var currentDestinationItem = this.Host.ElementAt(i);
if (this.animatingElements.Contains(currentDestinationItem))
{
continue;
}
this.animatingElements.Add(currentDestinationItem);
var destinationPosition = ReorderItemsCoordinator.GetRearangePosition(currentDestinationItem, source);
source.ArrangePosition = ReorderItemsCoordinator.GetRearangePosition(source, currentDestinationItem);
var index = source.LogicalIndex;
source.LogicalIndex = currentDestinationItem.LogicalIndex;
currentDestinationItem.LogicalIndex = index;
Action moveCompletedAction = () =>
{
currentDestinationItem.ArrangePosition = destinationPosition;
this.animatingElements.Remove(currentDestinationItem);
this.Host.OnItemsReordered(source, currentDestinationItem);
};
if (this.ReorderWithAnimation)
{
this.AnimateItem(currentDestinationItem, destinationPosition, moveCompletedAction);
}
else
{
moveCompletedAction();
}
}
}
void IReorderItemsHost.OnItemsReordered(IReorderItem sourceItem, IReorderItem destinationItem)
{
}
public ReorderItemsDragOperation(IReorderItem item)
{
this.initialSourceIndex = item.LogicalIndex;
this.item = item;
}
protected override void UpdatePositionAndIndices(IReorderItem source, IReorderItem destination)
{
var listView = (RadListView)this.Host;
if (listView.GroupDescriptors.Count == 0 || listView.LayoutDefinition is StackLayoutDefinition)
{
base.UpdatePositionAndIndices(source, destination);
return;
}
var sourceIndex = source.LogicalIndex;
var destinationIndex = destination.LogicalIndex;
var childrenPanel = listView.childrenPanel;
var reorderItems = childrenPanel.Children.OfType <IReorderItem>()
.OrderBy(reorderItem => reorderItem.LogicalIndex).ToArray();
var firstItem = reorderItems[0];
var layoutItem = (IArrangeChild)firstItem;
var layoutSlot = layoutItem.LayoutSlot;
var arrangePosition = firstItem.ArrangePosition;
for (int logicalIndex = 0; logicalIndex < reorderItems.Length; logicalIndex++)
{
IReorderItem reorderItem;
if (logicalIndex == destinationIndex)
{
reorderItem = reorderItems[sourceIndex];
}
else if (logicalIndex >= sourceIndex && logicalIndex < destinationIndex)
{
reorderItem = reorderItems[logicalIndex + 1];
}
else if (logicalIndex > destinationIndex && logicalIndex <= sourceIndex)
{
reorderItem = reorderItems[logicalIndex - 1];
}
else
{
reorderItem = reorderItems[logicalIndex];
}
reorderItem.LogicalIndex = logicalIndex;
var actualSize = reorderItem.ActualSize;
if (listView.Orientation == Orientation.Vertical)
{
if (arrangePosition.X + actualSize.Width > childrenPanel.ActualWidth)
{
arrangePosition.X = 0;
arrangePosition.Y += layoutSlot.Height;
}
}
else
{
if (arrangePosition.Y + actualSize.Height > childrenPanel.ActualHeight)
{
arrangePosition.Y = 0;
arrangePosition.X += layoutSlot.Width;
}
}
if (arrangePosition != reorderItem.ArrangePosition)
{
this.AnimateItem(source, reorderItem, arrangePosition);
}
if (listView.Orientation == Orientation.Vertical)
{
arrangePosition.X += actualSize.Width;
}
else
{
arrangePosition.Y += actualSize.Height;
}
layoutItem = (IArrangeChild)reorderItem;
layoutSlot = layoutItem.LayoutSlot;
}
}
public ReorderItemsDragOperation(IReorderItem item, object data)
{
this.initialSourceIndex = item.LogicalIndex;
this.item = item;
this.data = data;
}
