protected void CreateDropPositions()
{
dropPositions = new List<DropPosition>();
var angleStep = 360f/dropPositionCount;
// Debug.Log("AngleStep = " + angleStep);
var angle = 180f;
var startVector = -transform.forward * dropRadius;
startVector.y = 0;
for (var i = 0; i < dropPositionCount; i++)
{
var newDropPos = new DropPosition();
newDropPos.offset = Quaternion.AngleAxis(angle, Vector3.up) * startVector;
newDropPos.inUse = false;
newDropPos.index = i;
dropPositions.Add(newDropPos);
angle += angleStep;
}
}
protected void CreateDropPositions()
{
dropPositions = new List <DropPosition>();
var angleStep = 360f / dropPositionCount;
// Debug.Log("AngleStep = " + angleStep);
var angle = 180f;
var startVector = -transform.forward * dropRadius;
startVector.y = 0;
for (var i = 0; i < dropPositionCount; i++)
{
var newDropPos = new DropPosition();
newDropPos.offset = Quaternion.AngleAxis(angle, Vector3.up) * startVector;
newDropPos.inUse = false;
newDropPos.index = i;
dropPositions.Add(newDropPos);
angle += angleStep;
}
}
protected virtual void PerformDragDrop(Point dropLocation, TreeNodeElement targetNodeElement, List <RadTreeNode> draggedNodes)
{
RadTreeNode targetNode = targetNodeElement.Data;
DropPosition position = this.GetDropPosition(dropLocation, targetNodeElement);
if (position == DropPosition.AsChildNode)
{
foreach (RadTreeNode node in draggedNodes)
{
if (!this.OnDragEnding(position, node, targetNode))
{
continue;
}
node.Remove();
targetNode.Nodes.Add(node);
this.owner.OnDragEnded(new RadTreeViewDragEventArgs(node, targetNode));
}
targetNode.Expand();
}
else
{
this.PerformDragDropCore(position, targetNode, draggedNodes);
}
}
/// <summary>
/// Sets drag indicators in appropriate position.
/// </summary>
/// <param name="dropPosition">
/// Indicates the drop position, based on that the indicators will shown.
/// </param>
/// <param name="rowColumnIndex">
/// Specifies the rowColumn index based on mouse hover.
/// </param>
protected virtual void ShowDragIndicators(DropPosition dropPosition, RowColumnIndex rowColumnIndex)
{
if (upArrowIndicator == null && downArrowIndicator == null)
{
upArrowIndicator = new Popup();
downArrowIndicator = new Popup();
upArrowIndicator.Child = new UpIndicatorContentControl();
downArrowIndicator.Child = new DownIndicatorContentControl();
}
var lineinfo = TreeGrid.TreeGridPanel.ScrollRows.GetVisibleLineAtLineIndex(rowColumnIndex.RowIndex);
var upHoffset = 0.0;
var downHoffset = 0.0;
var upVoffset = 0.0;
var downVoffset = 0.0;
double width = 0;
if (TreeGrid.showRowHeader)
{
width = this.TreeGrid.RowHeaderWidth / 2;
}
else
{
width = 22;
}
upHoffset = downHoffset = this.TreeGrid.GetControlRect(this.TreeGrid).X + width;
if (dropPosition == DropPosition.DropAbove)
{
CloseDragIndicators();
upVoffset = lineinfo.Origin + 5;
downVoffset = lineinfo.Origin - (22);
//VisualStateManager.GoToState(GetRowControl(rowColumnIndex), "DropAbove", true);
}
else if (dropPosition == DropPosition.DropBelow)
{
CloseDragIndicators();
upVoffset = lineinfo.Corner + 5;
downVoffset = lineinfo.Corner - 22;
//VisualStateManager.GoToState(GetRowControl(rowColumnIndex), "DropBelow", true);
}
else
{
CloseDragIndicators();
//VisualStateManager.GoToState(GetRowControl(rowColumnIndex), "DropOver", true);
return;
}
// Need to convert the values to their related screen coordinates
upArrowIndicator.IsOpen = true;
downArrowIndicator.IsOpen = true;
var pt1 = this.TreeGrid.TransformToVisual(null).TransformPoint(new Point(upHoffset, upVoffset));
var pt2 = this.TreeGrid.TransformToVisual(null).TransformPoint(new Point(downHoffset, downVoffset));
upArrowIndicator.HorizontalOffset = pt1.X;
downArrowIndicator.HorizontalOffset = pt2.X;
upArrowIndicator.VerticalOffset = pt1.Y;
downArrowIndicator.VerticalOffset = pt2.Y;
}
public virtual void Drop(List <object> node, DropPosition mode, bool copy)
{
bool isRunningCompositeTask = Services.TaskService.IsRunningCompositeTask;
if (!isRunningCompositeTask)
{
Services.TaskService.BeginCompositeTask("Drag drop GameObject");
}
foreach (object current in node)
{
if (!copy)
{
IDragSource dragSource = current as IDragSource;
if (dragSource != null)
{
dragSource.Detach();
}
}
NodeObject nodeObject = current as NodeObject;
if (nodeObject != null)
{
this.LoadDropObject(nodeObject, mode);
}
}
if (!isRunningCompositeTask)
{
Services.TaskService.EndCompositeTask();
}
}
static bool IsDropTargetUserModifiable(GameObjectTreeViewItem targetItem, DropPosition dropPos)
{
switch (dropPos)
{
case DropPosition.Upon:
if (targetItem.objectPPTR != null)
{
return(IsUserModifiable(targetItem.objectPPTR));
}
break;
case DropPosition.Below:
case DropPosition.Above:
var targetParent = targetItem.parent as GameObjectTreeViewItem;
if (targetParent != null && targetParent.objectPPTR != null)
{
return(IsUserModifiable(targetParent.objectPPTR));
}
break;
default:
throw new ArgumentOutOfRangeException(nameof(dropPos), dropPos, null);
}
return(true);
}
public void Drop(IEnumerable<IDragSource> nodes, DropPosition mode, DragDropEffect effect, DragDropKeyStates initialKeyStates)
{
foreach (var node in nodes)
{
this.Drop(node, mode, effect == DragDropEffect.Copy);
}
}
private Target(DockPane pane, DockPanePreviewPlacement placement)
{
_targetItem = pane.SelectedItem;
if (placement == DockPanePreviewPlacement.Left)
{
_targetPosition = DropPosition.Left;
}
else if (placement == DockPanePreviewPlacement.Right)
{
_targetPosition = DropPosition.Right;
}
else if (placement == DockPanePreviewPlacement.Top)
{
_targetPosition = DropPosition.Top;
}
else if (placement == DockPanePreviewPlacement.Bottom)
{
_targetPosition = DropPosition.Bottom;
}
else
{
Debug.Assert(placement == DockPanePreviewPlacement.Fill);
_targetPosition = DropPosition.Fill;
}
}
bool IsValidSubSceneDropTarget(int dropTargetGameObjectOrSceneInstanceID, DropPosition dropPosition, Object[] draggedObjects)
{
if (draggedObjects == null || draggedObjects.Length == 0)
{
return(false);
}
Transform parentForDrop = GetTransformParentForDrop(dropTargetGameObjectOrSceneInstanceID, dropPosition);
if (parentForDrop == null)
{
// Drop is on a root scene which is always allowed
return(true);
}
foreach (var obj in draggedObjects)
{
var gameObject = obj as GameObject;
if (gameObject == null)
{
continue;
}
// Require all dragged objects to be valid (since native cannot filter out invalid sub scene drags currently)
if (SubSceneGUI.IsChildOrSameAsOtherTransform(parentForDrop, gameObject.transform))
{
return(false);
}
}
// Valid drop target for current dragged objects
return(true);
}
void GetPreviousAndNextItemsIgnoringDraggedItems(int targetRow, DropPosition dropPosition, out TreeViewItem previousItem, out TreeViewItem nextItem)
{
if (dropPosition != DropPosition.Above && dropPosition != DropPosition.Below)
{
throw new ArgumentException("Invalid argument: " + dropPosition);
}
previousItem = nextItem = null;
int curPrevRow = (dropPosition == DropPosition.Above) ? targetRow - 1 : targetRow;
int curNextRow = (dropPosition == DropPosition.Above) ? targetRow : targetRow + 1;
while (curPrevRow > 0)
{
var curPreviousItem = m_TreeView.data.GetItem(curPrevRow);
if (!m_TreeView.IsDraggingItem(curPreviousItem))
{
previousItem = curPreviousItem;
break;
}
curPrevRow--;
}
while (curNextRow < m_TreeView.data.rowCount)
{
var curNextItem = m_TreeView.data.GetItem(curNextRow);
if (!m_TreeView.IsDraggingItem(curNextItem))
{
nextItem = curNextItem;
break;
}
curNextRow++;
}
}
private Target(DockTreePosition dockTreePosition)
{
_targetItem = null;
if (dockTreePosition == DockTreePosition.Left)
{
_targetPosition = DropPosition.Left;
}
else if (dockTreePosition == DockTreePosition.Right)
{
_targetPosition = DropPosition.Right;
}
else if (dockTreePosition == DockTreePosition.Top)
{
_targetPosition = DropPosition.Top;
}
else if (dockTreePosition == DockTreePosition.Bottom)
{
_targetPosition = DropPosition.Bottom;
}
else if (dockTreePosition == DockTreePosition.Document)
{
_targetPosition = DropPosition.Fill;
}
else
{
Debug.Assert(dockTreePosition == DockTreePosition.Floating);
_targetPosition = DropPosition.Floating;
}
}
public void Drop(IEnumerable <IDragSource> nodes, DropPosition mode, DragDropEffect effect, DragDropKeyStates initialKeyStates)
{
foreach (var node in nodes)
{
this.Drop(node, mode, effect == DragDropEffect.Copy);
}
}
int GetDropTargetInstanceID(GameObjectTreeViewItem hierarchyTargetItem, DropPosition dropPosition)
{
if (SubSceneGUI.IsUsingSubScenes())
{
var gameObjectDropTarget = hierarchyTargetItem.objectPPTR as GameObject;
if (gameObjectDropTarget != null)
{
if (dropPosition == DropPosition.Above)
{
return(hierarchyTargetItem.id);
}
if (SubSceneGUI.IsSubSceneHeader(gameObjectDropTarget))
{
Scene subScene = SubSceneGUI.GetSubScene(gameObjectDropTarget);
if (subScene.IsValid())
{
return(subScene.handle);
}
else
{
return(0);
}
}
}
}
return(hierarchyTargetItem.id);
}
public virtual void Drop(List <object> node, DropPosition mode, bool copy)
{
bool runningCompositeTask = Services.TaskService.IsRunningCompositeTask;
if (!runningCompositeTask)
{
Services.TaskService.BeginCompositeTask("Drag drop GameObject");
}
foreach (object obj in node)
{
if (!copy)
{
IDragSource dragSource = obj as IDragSource;
if (dragSource != null)
{
dragSource.Detach();
}
}
NodeObject gameObjectData = obj as NodeObject;
if (gameObjectData != null)
{
this.LoadDropObject(gameObjectData, mode);
}
}
if (runningCompositeTask)
{
return;
}
Services.TaskService.EndCompositeTask();
}
private static Target?GetTarget(DockItem targetItem, DropPosition targetPosition)
{
if (targetPosition == DropPosition.Left)
{
return(targetItem == null ? Target.LeftToolWindow : Target.LeftPane(targetItem));
}
else if (targetPosition == DropPosition.Right)
{
return(targetItem == null ? Target.RightToolWindow : Target.RightPane(targetItem));
}
else if (targetPosition == DropPosition.Top)
{
return(targetItem == null ? Target.TopToolWindow : Target.TopPane(targetItem));
}
else if (targetPosition == DropPosition.Bottom)
{
return(targetItem == null ? Target.BottomToolWindow : Target.BottomPane(targetItem));
}
else if (targetPosition == DropPosition.Fill)
{
return(targetItem == null ? Target.Document : Target.FillPane(targetItem));
}
else if (targetPosition == DropPosition.Tab && targetItem != null)
{
return(Target.Tab(targetItem));
}
return(null);
}
private void _tree_DragOver(object sender, DragEventArgs e)
{
e.Effect = DragDropEffects.None;
if (!e.Data.GetDataPresent(typeof(TreeNodeAdv[])))
{
return;
}
TreeNodeAdv[] nodes = e.Data.GetData(typeof(TreeNodeAdv[])) as TreeNodeAdv[];
if (nodes.Length == 0)
{
return;
}
DropPosition dp = _tree.DropPosition;
if (dp.Node != null)
{
if (dp.Node.Tag is FavouritesNode)
{
if ((dp.Position == NodePosition.Inside && (dp.Node.Tag as FavouritesNode).IsFolder) ||
(dp.Position != NodePosition.Inside))
{
e.Effect = e.AllowedEffect;
}
}
}
else
{
e.Effect = e.AllowedEffect;
}
}
public void Drop(object node, DropPosition mode, bool copy)
{
var cvm = node as NodeViewModel;
if (copy)
{
cvm = new NodeViewModel(cvm.Node, cvm.Parent);
}
switch (mode)
{
case DropPosition.Add:
this.Children.Add(cvm);
cvm.Parent = this;
this.IsExpanded = true;
break;
case DropPosition.InsertBefore:
int index = this.Parent.Children.IndexOf(this);
Parent.Children.Insert(index, cvm);
cvm.Parent = this.Parent;
break;
case DropPosition.InsertAfter:
int index2 = this.Parent.Children.IndexOf(this);
Parent.Children.Insert(index2 + 1, cvm);
cvm.Parent = this.Parent;
break;
}
}
public virtual bool CanDrop(object node, DropPosition mode, bool copy)
{
if (copy || !(node is NodeObject) || this.IsAncestor(node as NodeObject))
{
return(false);
}
NodeObject nodeObject = node as NodeObject;
switch (mode)
{
case DropPosition.InsertBefore:
if (this.Parent == null || !this.Parent.CanDrop(node, DropPosition.Add, copy))
{
return(false);
}
break;
case DropPosition.InsertAfter:
if (this.Parent == null || !this.Parent.CanDrop(node, DropPosition.Add, copy))
{
return(false);
}
break;
}
return(true);
}
private bool OnDragEnding(DropPosition position, RadTreeNode node, RadTreeNode targetNode)
{
RadTreeViewDragCancelEventArgs args = new RadTreeViewDragCancelEventArgs(node, targetNode);
args.DropPosition = position;
this.owner.OnDragEnding(args);
return(!args.Cancel);
}
public override bool CanDrop(object node, DropPosition mode, bool copy)
{
if (mode != DropPosition.Add)
{
return(base.CanDrop(node, mode, copy));
}
return(false);
}
public void FreeDropPosition(DropPosition position)
{
if (position == null)
{
return;
}
dropPositions[position.index].inUse = false;
}
public override bool CanDrop(object node, DropPosition mode, bool copy)
{
if (mode != DropPosition.Add || node is WidgetObject)
{
return(base.CanDrop(node, mode, copy));
}
LogConfig.Output.Info((object)LanguageInfo.ListViewOutputMessage);
return(false);
}
public override bool CanDrop(object node, DropPosition mode, bool copy)
{
if (mode != DropPosition.Add || node.GetType().Equals(typeof(PanelObject)))
{
return(base.CanDrop(node, mode, copy));
}
LogConfig.Logger.Error((object)LanguageInfo.OutputMessage);
return(false);
}
private void dragDropService_PreviewDragDrop(object sender, RadDropEventArgs e)
{
GridDataRowElement rowElement = e.DragInstance as GridDataRowElement;
if (rowElement == null)
{
return;
}
string sourceText = rowElement.RowInfo.Cells[0].Value.ToString();
TreeNodeElement targetNodeElement = e.HitTarget as TreeNodeElement;
if (targetNodeElement != null)
{
RadTreeViewElement treeViewElement = targetNodeElement.TreeViewElement;
RadTreeNode targetNode = targetNodeElement.Data;
DropPosition dropPosition = this.GetDropPosition(e.DropLocation, targetNodeElement);
switch (dropPosition)
{
case DropPosition.None:
break;
case DropPosition.BeforeNode:
radGridView1.Rows.Remove(rowElement.RowInfo);
RadTreeNodeCollection nodes = targetNode.Parent == null ? treeViewElement.Nodes : targetNode.Parent.Nodes;
nodes.Insert(targetNode.Index, new RadTreeNode(sourceText));
break;
case DropPosition.AfterNode:
radGridView1.Rows.Remove(rowElement.RowInfo);
RadTreeNodeCollection nodes1 = targetNode.Parent == null ? treeViewElement.Nodes : targetNode.Parent.Nodes;
int targetIndex = targetNodeElement.Data.Index <= treeViewElement.Nodes.Count - 1 ?
(targetNodeElement.Data.Index + 1) : treeViewElement.Nodes.Count - 1;
nodes1.Insert(targetIndex, new RadTreeNode(sourceText));
break;
case DropPosition.AsChildNode:
radGridView1.Rows.Remove(rowElement.RowInfo);
targetNode.Nodes.Add(new RadTreeNode(sourceText));
break;
}
}
RadTreeViewElement treeElement = e.HitTarget as RadTreeViewElement;
if (treeElement != null)
{
radGridView1.Rows.Remove(rowElement.RowInfo);
radTreeView1.Nodes.Add(new RadTreeNode(sourceText));
}
}
protected override bool CanDragOver(
DropPosition dropPosition,
TreeNodeElement targetNodeElement)
{
if ((this.Owner as RadDataFilterElement).RootNode == targetNodeElement.Data && dropPosition != DropPosition.AsChildNode)
{
return(false);
}
return(base.CanDragOver(dropPosition, targetNodeElement));
}
protected virtual void PerformDragDrop(
Point dropLocation,
TreeNodeElement targetNodeElement,
List <RadTreeNode> draggedNodes)
{
RadTreeNode data = targetNodeElement.Data;
DropPosition dropPosition = this.GetDropPosition(dropLocation, targetNodeElement);
if (dropPosition == DropPosition.AsChildNode)
{
bool isCopyingNodes = this.IsCopyingNodes;
int index = 0;
while (index < draggedNodes.Count)
{
if (!this.OnDragEnding(dropPosition, draggedNodes[index], data))
{
draggedNodes.RemoveAt(index);
}
else
{
++index;
}
}
if (this.owner.bindingProvider.CanDrop || data.treeView != null && data.treeView.bindingProvider.CanDrop)
{
this.owner.bindingProvider.DropNodes(data, draggedNodes);
foreach (RadTreeNode draggedNode in draggedNodes)
{
this.owner.OnDragEnded(new RadTreeViewDragEventArgs(draggedNode, data));
}
}
else
{
foreach (RadTreeNode draggedNode in draggedNodes)
{
RadTreeNode radTreeNode = draggedNode;
if (isCopyingNodes)
{
radTreeNode = this.CreateTreeNode(radTreeNode);
}
else
{
radTreeNode.Remove();
}
data.Nodes.Add(radTreeNode);
this.owner.OnDragEnded(new RadTreeViewDragEventArgs(radTreeNode, data));
}
}
data.Expand();
}
else
{
this.PerformDragDropCore(dropPosition, data, draggedNodes);
}
}
private double GetDropPositionFeedbackOffset(GridViewRow row, DropPosition dropPosition)
{
var yOffset = row.TransformToVisual(this.dropPositionFeedbackPresenterHost).Transform(new Point(0, 0)).Y;
if (dropPosition == DropPosition.After)
{
yOffset += row.ActualHeight;
}
yOffset -= (this.dropPositionFeedbackPresenter.ActualHeight / 2.0);
return(yOffset);
}
public virtual bool CanDropNode(object dataObject, DragOperation operation, DropPosition position)
{
if (position == DropPosition.Into)
{
return(CanDropNode(dataObject, operation));
}
else
{
return(false);
}
}
internal static bool CanHandleDropFromChild(object [] dataObjects, DropPosition position)
{
foreach (var o in dataObjects)
{
if (!(o is ProjectFolder || o is ProjectFile))
{
return(false);
}
}
return(position == DropPosition.Into);
}
protected virtual bool CanDragOver(DropPosition dropPosition, TreeNodeElement targetNodeElement)
{
RadTreeViewElement targetTreeView = targetNodeElement.TreeViewElement;
if (!targetNodeElement.Enabled || !targetTreeView.ElementTree.Control.AllowDrop || !this.IsInValidState(targetTreeView))
{
return(false);
}
RadTreeNode targetNode = targetNodeElement.Data;
List <RadTreeNode> nodes = new List <RadTreeNode>(draggedNode.TreeViewElement.SelectedNodes);
// If the count is empty, we are in single selection mode
if (nodes.Count == 0)
{
nodes.Add(draggedNode);
}
foreach (RadTreeNode selected in nodes)
{
if (selected == targetNode)
{
return(false);
}
RadTreeNode parent = targetNode.Parent;
while (parent != null)
{
if (parent == selected)
{
return(false);
}
parent = parent.Parent;
}
if (dropPosition == DropPosition.AsChildNode && selected.Parent == targetNode)
{
return(false);
}
}
if (dropPosition == DropPosition.AsChildNode)
{
targetTreeView.AutoExpand(targetNode);
}
targetTreeView.AutoScroll(targetNodeElement);
return(true);
}
public bool CanDrop(IDragSource node, DropPosition mode, DragDropEffect effect)
{
var cvm2 = this;
while (cvm2 != null)
{
if (cvm2 == node)
{
return(false);
}
cvm2 = cvm2.Parent;
}
return(node is NodeViewModel && (mode == DropPosition.Add || this.Parent != null));
}
public override bool CanDrop(object node, DropPosition mode, bool copy)
{
bool result;
if (mode == DropPosition.Add)
{
if (!(node is WidgetObject))
{
LogConfig.Output.Info(LanguageInfo.ListViewOutputMessage);
result = false;
return(result);
}
}
result = base.CanDrop(node, mode, copy);
return(result);
}
public void Move(PageItem from, PageItem to, DropPosition dropPosition)
{
var pageCache = PageCache.From(_session);
if (dropPosition == DropPosition.Over)
{
to.Pages.Add(from);
to.Pages.AdjustOrders(false);
return;
}
if (dropPosition == DropPosition.Before)
{
var pages = new PageItemCollectionWrapper(to.Parent == null ? pageCache.RootPages : to.Parent.Pages);
if (from.IsSiblingOf(to))
{
pages.MoveBefore(to, from);
}
else
{
pages.AddBefore(to, from);
}
pages.AdjustOrders(false);
return;
}
if (dropPosition == DropPosition.After)
{
var pages = new PageItemCollectionWrapper(to.Parent == null ? pageCache.RootPages : to.Parent.Pages);
if (from.IsSiblingOf(to))
{
pages.MoveAfter(to, from);
}
else
{
pages.AddAfter(to, from);
}
pages.AdjustOrders(false);
}
}
public void Drop(IDragSource node, DropPosition mode, bool copy)
{
var cvm = node as NodeViewModel;
if (copy) cvm = new NodeViewModel(cvm.Node, cvm.Parent);
switch (mode)
{
case DropPosition.Add:
this.Children.Add(cvm);
cvm.Parent = this;
this.IsExpanded = true;
break;
case DropPosition.InsertBefore:
int index = this.Parent.Children.IndexOf(this);
Parent.Children.Insert(index, cvm);
cvm.Parent = this.Parent;
break;
case DropPosition.InsertAfter:
int index2 = this.Parent.Children.IndexOf(this);
Parent.Children.Insert(index2 + 1, cvm);
cvm.Parent = this.Parent;
break;
}
}
public void FreeDropPosition(DropPosition position)
{
if (position == null) return;
dropPositions[position.index].inUse = false;
}
public static string ConverDropPositionToString(DropPosition dropPosition)
{
switch (dropPosition)
{
case DropPosition.After:
return "的后面";
case DropPosition.Before:
return "的前面";
default:
return "的里面";
}
}
/// <summary>
/// Decides the drop target.
/// </summary>
/// <param name="e">
/// The event args.
/// </param>
private void DecideDropTarget(DragEventArgs e)
{
// If the types of the dragged data and ItemsControl's source are compatible,
// there are 3 situations to have into account when deciding the drop target:
// 1. mouse is over an items container
// 2. mouse is over the empty part of an ItemsControl, but ItemsControl is not empty
// 3. mouse is over an empty ItemsControl.
// The goal of this method is to decide on the values of the following properties:
// targetItemContainer, insertionIndex and isInFirstHalf.
int targetItemsControlCount = this.targetItemsControl.Items.Count;
var draggedItems = e.Data.GetData(this.format.Name) as IList;
if (targetItemsControlCount > 0)
{
this.hasVerticalOrientation = true;
this.targetItemContainer =
this.targetItemsControl.ContainerFromElement((DependencyObject)e.OriginalSource) as TreeListBoxItem;
if (this.targetItemContainer != null)
{
Point positionRelativeToItemContainer = e.GetPosition(this.targetItemContainer);
double relativePosition = GetRelativePosition(
this.targetItemContainer, positionRelativeToItemContainer, this.hasVerticalOrientation);
this.isInFirstHalf = relativePosition < 0.5;
if (relativePosition > 0.3 && relativePosition < 0.7)
{
this.dropPosition = DropPosition.Add;
}
else
{
this.dropPosition = relativePosition < 0.5
? DropPosition.InsertBefore
: DropPosition.InsertAfter;
}
}
else
{
this.targetItemContainer = this.targetItemsControl.ContainerFromIndex(targetItemsControlCount - 1);
this.isInFirstHalf = false;
this.dropPosition = DropPosition.InsertAfter;
}
}
else
{
this.targetItemContainer = null;
this.dropPosition = DropPosition.InsertBefore;
}
if (this.targetItemContainer != null && draggedItems != null)
{
var dropTarget = this.targetItemContainer.DataContext as IDropTarget;
bool copy = (e.Effects & DragDropEffects.Copy) != 0;
foreach (var draggedItem in draggedItems)
{
var dragSource = draggedItem as IDragSource;
if ((dragSource == null || !dragSource.IsDraggable)
|| (dropTarget == null || !dropTarget.CanDrop(dragSource, this.dropPosition, copy)))
{
this.targetItemContainer = null;
e.Effects = DragDropEffects.None;
return;
}
}
}
}
public bool CanDrop(IDragSource node, DropPosition mode, DragDropEffect effect)
{
return node is NodeViewModel && (mode == DropPosition.Add || this.Parent != null);
}
public virtual void OnNodeDrop (object dataObjects, DragOperation operation, DropPosition position)
{
OnNodeDrop (dataObjects, operation);
}
public override bool CanDropNode (object dataObject, DragOperation operation, DropPosition position)
{
return false;
}
public abstract DragAndDropVisualMode DoDrag(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, DropPosition dropPosition);
public override bool CanDropNode (object dataObject, DragOperation operation, DropPosition pos)
{
object parent1 = CurrentNode.GetParentDataItem (typeof(Extension), false);
if (parent1 == null)
parent1 = CurrentNode.GetParentDataItem (typeof(ExtensionPoint), false);
ITreeNavigator nav = CurrentNode.Clone ();
if (!nav.MoveToObject (dataObject))
return false;
object parent2 = nav.GetParentDataItem (parent1.GetType (), false);
if (parent2 != parent1)
return false;
return true;
}
public override bool CanDropMultipleNodes (object[] dataObjects, DragOperation operation, DropPosition position)
{
foreach (object dataObject in dataObjects)
if (dataObjects is GuiProjectFolder)
return false;
return base.CanDropMultipleNodes (dataObjects, operation, position);
}
public override void OnMultipleNodeDrop (object[] dataObjects, DragOperation operation, DropPosition pos)
{
DotNetProject p = (DotNetProject) CurrentNode.GetParentDataItem (typeof(Project), false);
AddinData adata = p.GetAddinData ();
ExtensionNodeInfo en = (ExtensionNodeInfo) CurrentNode.DataItem;
foreach (ExtensionNodeInfo newNode in dataObjects) {
if (newNode.Node.Parent is ExtensionNodeDescription)
((ExtensionNodeDescription)newNode.Node.Parent).ChildNodes.Remove (en.Node);
else
((Extension)newNode.Node.Parent).ExtensionNodes.Remove (newNode.Node);
InsertNode (adata, en, pos, newNode.Node);
// Add all other nodes after the first node
en = newNode;
pos = DropPosition.After;
}
adata.CachedAddinManifest.Save ();
adata.NotifyChanged (false);
}
public virtual bool CanDropNode (object dataObject, DragOperation operation, DropPosition position)
{
if (position == DropPosition.Into)
return CanDropNode (dataObject, operation);
else
return false;
}
public override bool CanDropMultipleNodes (object[] dataObjects, DragOperation operation, DropPosition position)
{
return false;
}
public virtual bool CanDropMultipleNodes (object[] dataObjects, DragOperation operation, DropPosition position)
{
cachedPosition = position;
return CanDropMultipleNodes (dataObjects, operation);
}
public bool CanDrop(object node, DropPosition mode, bool copy)
{
return node is NodeViewModel && (mode == DropPosition.Add || this.Parent != null);
}
public virtual void OnMultipleNodeDrop (object[] dataObjects, DragOperation operation, DropPosition position)
{
cachedPosition = position;
OnMultipleNodeDrop (dataObjects, operation);
}
ExtensionNodeDescription InsertNode (AddinData adata, ExtensionNodeInfo refNode, DropPosition pos, ExtensionNodeDescription newNode)
{
ExtensionNodeDescriptionCollection nodes = null;
newNode.InsertBefore = "";
newNode.InsertAfter = "";
if (refNode.CanModify) {
if (pos == DropPosition.Into)
nodes = refNode.Node.ChildNodes;
else if (refNode.Node.Parent is ExtensionNodeDescription)
nodes = ((ExtensionNodeDescription)refNode.Node.Parent).ChildNodes;
} else {
if (pos == DropPosition.After)
newNode.InsertAfter = refNode.Node.Id;
else if (pos == DropPosition.Before)
newNode.InsertBefore = refNode.Node.Id;
}
if (nodes == null) {
string path = refNode.Node.GetParentPath ();
if (pos == DropPosition.Into)
path += "/" + refNode.Node.Id;
Extension ext = adata.CachedAddinManifest.MainModule.GetExtension (path);
nodes = ext.ExtensionNodes;
}
for (int n = 0; n < nodes.Count; n++) {
ExtensionNodeDescription node = nodes [n];
if (node == refNode.Node) {
if (pos == DropPosition.After) n++;
nodes.Insert (n, newNode);
return newNode;
}
}
nodes.Add (newNode);
return newNode;
}