private string CanDrop(TreeViewExItem item, IDataObject data)
{
if (item == null)
{
return(null);
}
if (item.DropAction == null)
{
return(null);
}
foreach (string f in data.GetFormats())
{
if (item.CanDropFormat == null || item.CanDropFormat(f))
{
if (item.CanDrop == null || item.CanDrop(data.GetData(f)))
{
return(f);
}
else
{
return(null);
}
}
}
return(null);
}
private CanInsertReturn CanInsert(TreeViewExItem item, Func <UIElement, Point> getPositionDelegate, IDataObject data)
{
TreeViewExItem parentItem = item.ParentTreeViewItem;
if (parentItem == null)
{
return(null);
}
if (parentItem.Insert == null)
{
return(null);
}
// get position over element
Size size = item.RenderSize;
Point positionRelativeToItem = getPositionDelegate(item);
// decide whether to insert before or after item
bool after = true;
if (positionRelativeToItem.Y > dragAreaSize)
{
if (size.Height - positionRelativeToItem.Y > dragAreaSize)
{
return(null);
}
}
else
{
after = false;
}
// get index, where to insert
int index = parentItem.ItemContainerGenerator.IndexFromContainer(item);
if (after)
{
// dont allow insertion after item, if item has children
if (item.HasItems)
{
return(null);
}
index++;
}
// ask for all formats, if insertion is allowed
foreach (string f in data.GetFormats())
{
if (parentItem.CanInsertFormat == null || parentItem.CanInsertFormat(index, f))
{
if (parentItem.CanInsert == null || parentItem.CanInsert(index, data.GetData(f)))
{
return(new CanInsertReturn(f, index, !after));;
}
}
}
return(null);
}
private void ExecuteDrop(object parameter)
{
DropParameters dropParameters = (DropParameters)parameter;
TreeViewExItem tvei = dropParameters.DropToItem;
IDataObject dataObject = dropParameters.DropData as IDataObject;
int index = dropParameters.Index;
Node node = (tvei == null)?null:tvei.DataContext as Node;
foreach (string f in dataObject.GetFormats())
{
object obj = dataObject.GetData(f);
DragContent content = obj as DragContent;
if (content != null)
{
foreach (var item in content.Items.Reverse())
{
Node oldNode = (Node)item;
Node newNode = new Node();
newNode.Name = string.Format("Copy of {0}", oldNode.Name.Replace(" (Drag Allowed)", string.Empty));
AddNode(node, index, newNode);
}
}
else
{
AddNode(node, index, new Node()
{
Name = "New node"
});
}
}
return;
}
private void OnDrop(object sender, DragEventArgs e)
{
TreeViewExItem item = GetTreeViewItemUnderMouse(e.GetPosition(TreeView));
if (item == null)
{
CleanUpAdorners();
return;
}
CanInsertReturn canInsertReturn = CanInsert(item, e.GetPosition, e.Data);
if (canInsertReturn != null)
{
// insert and return
item.ParentTreeViewItem.Insert(canInsertReturn.Index, e.Data.GetData(canInsertReturn.Format));
CleanUpAdorners();
return;
}
// check if drop is possible
string dropformat = CanDrop(item, e.Data);
if (dropformat != null)
{
// drop and return
object data = e.Data.GetData(dropformat);
item.DropAction(data);
}
CleanUpAdorners();
}
private bool CanExecuteDrop(object parameter)
{
DropParameters dropParameters = (DropParameters)parameter;
TreeViewExItem tvei = dropParameters.DropToItem;
IDataObject dataObject = dropParameters.Data as IDataObject;
if (!dataObject.GetDataPresent("NewNode") && !dataObject.GetDataPresent("Nodes"))
{
return(false);
}
int index = dropParameters.Index;
Node node = (tvei == null)?null:tvei.DataContext as Node;
if (tvei == null)
{
return(true); //drop to root
}
if (index == -1)
{
return(node.AllowDrop);
}
else
{
return(node.AllowInsert);
}
}
private void OnDrop(object sender, DragEventArgs e)
{
TreeViewExItem item = GetTreeViewItemUnderMouse(e.GetPosition(TreeView));
//if (item == null)
//{
// CleanUpAdorners();
// return;
//}
CanInsertReturn canInsertReturn = CanInsert(item, e.GetPosition, e.Data);
if (canInsertReturn != null)
{
// insert and return
TreeView.DropCommand.Execute(new DropParameters(item.ParentTreeViewItem, e.Data, canInsertReturn.Index));
CleanUpAdorners();
return;
}
// check if drop is possible
if (CanDrop(item, e.Data))
{
// drop and return
TreeView.DropCommand.Execute(new DropParameters(item, e.Data));
}
CleanUpAdorners();
}
private void ExecuteDrop(object parameter)
{
DropParameters dropParameters = (DropParameters)parameter;
TreeViewExItem tvei = dropParameters.DropToItem;
IDataObject dataObject = dropParameters.Data as IDataObject;
int index = dropParameters.Index;
Node node = (tvei == null)?null:tvei.DataContext as Node;
if (dataObject.GetDataPresent("NewNode"))
{
AddNode(node, index, new Node()
{
Name = "New node"
});
}
if (dataObject.GetDataPresent("Nodes"))
{
var nodeList = dataObject.GetData("Nodes") as IEnumerable <Node>;
foreach (var item in nodeList)
{
Node oldNode = item as Node;
Node newNode = new Node();
newNode.Name = string.Format("Copy of {0}", oldNode.Name.Replace(" (Drag Allowed)", string.Empty));
AddNode(node, index, newNode);
}
}
return;
}
private void ExecuteDrag(object parameter)
{
DragParameters dragParameters = (DragParameters)parameter;
TreeViewExItem tvei = dragParameters.DragItem;
dragParameters.DraggedObject = tvei.DataContext;
return;
}
private bool CanDrop(TreeViewExItem item, IDataObject data)
{
if (TreeView.DropCommand == null)
{
return(false);
}
return(TreeView.DropCommand.CanExecute(new DropParameters(item, data)));
}
private CanInsertReturn CanInsert(TreeViewExItem item, Func <UIElement, Point> getPositionDelegate, IDataObject data)
{
if (TreeView.DropCommand == null)
{
return(null);
}
if (item == null)
{
return(null);
}
else
{
// get position over element
Size size = item.RenderSize;
Point positionRelativeToItem = getPositionDelegate(item);
// decide whether to insert before or after item
bool after = true;
if (positionRelativeToItem.Y > dragAreaSize)
{
if (size.Height - positionRelativeToItem.Y > dragAreaSize)
{
return(null);
}
}
else
{
after = false;
}
// get index, where to insert
TreeViewExItem parentItem = item.ParentTreeViewItem;
ItemContainerGenerator itemContainerGenerator = (parentItem != null)?parentItem.ItemContainerGenerator:TreeView.ItemContainerGenerator;
int index = itemContainerGenerator.IndexFromContainer(item);
if (after)
{
// dont allow insertion after item, if item has children
if (item.HasItems)
{
return(null);
}
index++;
}
// ask if insertion is allowed
if (TreeView.DropCommand.CanExecute(new DropParameters(parentItem, data, index)))
{
return(new CanInsertReturn("", index, !after));
}
}
return(null);
}
private bool CanExecuteDrag(object parameter)
{
DragParameters dragParameters = (DragParameters)parameter;
TreeViewExItem tvei = dragParameters.DragItem;
Node node = tvei.DataContext as Node;
if (node != null)
{
return(node.AllowDrag);
}
return(false);
}
public void Dispose()
{
if (TreeView != null)
{
TreeView.Drop -= OnDrop;
TreeView.DragOver -= OnDragOver;
TreeView.DragLeave -= OnDragLeave;
}
if (itemMouseIsOver != null)
{
itemMouseIsOver.IsCurrentDropTarget = false;
itemMouseIsOver = null;
}
}
public void Dispose()
{
if (TreeView != null)
{
TreeView.Drop -= OnDrop;
TreeView.DragOver -= OnDragOver;
TreeView.DragLeave -= OnDragLeave;
TreeView.GiveFeedback -= OnGiveFeedBack;
}
if (itemMouseIsOver != null)
{
itemMouseIsOver.IsCurrentDropTarget = false;
itemMouseIsOver = null;
}
}
protected override List <AutomationPeer> GetChildrenCore()
{
List <AutomationPeer> children = new List <AutomationPeer>();
for (int i = 0; i < treeViewExItem.Items.Count; i++)
{
TreeViewExItem child = treeViewExItem.ItemContainerGenerator.ContainerFromIndex(i) as TreeViewExItem;
if (child == null)
{
continue;
}
children.Add(new TreeViewExItemAutomationPeer(child, treeViewExAutomationPeer));
}
return(children);
}
public void Expand()
{
if (!IsEnabled())
{
throw new ElementNotEnabledException();
}
TreeViewExItem treeViewItem = (TreeViewExItem)Owner;
if (!treeViewItem.HasItems)
{
throw new InvalidOperationException("Cannot expand because item has no children.");
}
treeViewItem.IsExpanded = true;
}
private List <TreeViewExItem> GetDraggableItems(Point mousePositionRelativeToTree)
{
List <TreeViewExItem> items = TreeView.GetTreeViewItemsFor(TreeView.SelectedItems).ToList();
TreeViewExItem itemUnderMouse = GetTreeViewItemUnderMouse(mousePositionRelativeToTree);
if (itemUnderMouse == null)
{
return(new List <TreeViewExItem>());
}
if (items.Contains(itemUnderMouse))
{
foreach (var item in items)
{
if (item.Drag == null || item.CanDrag == null || !item.CanDrag())
{
// if one item is not draggable, nothing can be dragged
return(new List <TreeViewExItem>());
}
}
return(items);
}
//mouse is not over an selected item. We have to check if it is over the content. In this case we have to select and start drag n drop.
var contentPresenter = itemUnderMouse.Template.FindName("content", itemUnderMouse) as ContentPresenter;
if (contentPresenter.IsMouseOver)
{
if (itemUnderMouse.Drag == null || itemUnderMouse.CanDrag == null || !itemUnderMouse.CanDrag())
{
// if one item is not draggable, nothing can be dragged
return(new List <TreeViewExItem>());
}
return(new List <TreeViewExItem> {
itemUnderMouse
});
}
return(new List <TreeViewExItem>());
}
public InsertAdorner(TreeViewExItem treeViewItem, InsertContent content)
: base(GetParentBorder(treeViewItem))
{
this.treeViewItem = treeViewItem;
layer = AdornerLayer.GetAdornerLayer(AdornedElement);
layer.Add(this);
contentPresenter = new ContentPresenter();
contentPresenter.HorizontalAlignment = HorizontalAlignment.Stretch;
contentPresenter.Width = treeViewItem.ActualWidth;
contentPresenter.Content = content;
Binding b = new Binding("InsertTemplate");
b.Source = treeViewItem.ParentTreeView;
b.Mode = BindingMode.OneWay;
contentPresenter.SetBinding(ContentPresenter.ContentTemplateProperty, b);
content.InsertionMarkerBrush = treeViewItem.ParentTreeView.InsertionMarkerBrush;
content.Item = treeViewItem;
}
public void SetValue(string value)
{
try
{
if (String.IsNullOrWhiteSpace(value))
{
return;
}
string[] ids = value.Split(new[] { ';' });
object obj;
if (ids.Length > 0 && ids[0] == "Context")
{
TreeViewExItem treeViewItem = (TreeViewExItem)Owner;
obj = treeViewItem.DataContext;
}
else
{
obj = Owner;
}
if (ids.Length < 2)
{
requestedValue = obj.ToString();
}
else
{
System.Diagnostics.Debug.WriteLine("Get prop: " + ids[1] + " from " + obj);
Type type = obj.GetType();
PropertyInfo pi = type.GetProperty(ids[1]);
requestedValue = pi.GetValue(obj, null).ToString();
System.Diagnostics.Debug.WriteLine("Value: " + requestedValue);
}
}
catch (Exception ex)
{
requestedValue = ex.ToString();
}
}
public InsertAdorner(TreeViewExItem treeViewItem, InsertContent content)
: base(GetParentBorder(treeViewItem))
{
this.treeViewItem = treeViewItem;
layer = AdornerLayer.GetAdornerLayer(AdornedElement);
layer.Add(this);
contentPresenter = new ContentPresenter();
contentPresenter.HorizontalAlignment = HorizontalAlignment.Stretch;
contentPresenter.Width = treeViewItem.ActualWidth;
contentPresenter.Content = content;
Binding b = new Binding("InsertTemplate");
b.Source = treeViewItem.ParentTreeView;
b.Mode = BindingMode.OneWay;
contentPresenter.SetBinding(ContentPresenter.ContentTemplateProperty, b);
content.InsertionMarkerBrush = treeViewItem.ParentTreeView.InsertionMarkerBrush;
content.Item = treeViewItem;
}
private List <TreeViewExItem> GetDraggableItems(Point mousePositionRelativeToTree)
{
if (TreeView.DragCommand == null)
{
return(new List <TreeViewExItem>());
}
List <TreeViewExItem> items = TreeView.GetTreeViewItemsFor(TreeView.SelectedItems)
.Where(item => TreeView.DragCommand.CanExecute(new DragParameters(item))).ToList();
TreeViewExItem itemUnderMouse = GetTreeViewItemUnderMouse(mousePositionRelativeToTree);
if (itemUnderMouse == null)
{
return(new List <TreeViewExItem>());
}
if (items.Contains(itemUnderMouse))
{
return(items);
}
//mouse is not over an selected item. We have to check if it is over the content. In this case we have to select and start drag n drop.
var contentPresenter = itemUnderMouse.Template.FindName("content", itemUnderMouse) as ContentPresenter;
if (contentPresenter.IsMouseOver)
{
if (TreeView.DragCommand.CanExecute(new DragParameters(itemUnderMouse)))
{
return new List <TreeViewExItem> {
itemUnderMouse
}
}
;
}
return(new List <TreeViewExItem>());
}
/// <summary>
/// Update the domain computer list
/// </summary>
public async Task updateListComputers()
{
showLoading();
try {
// Only one domain for now
Domain domain = new Domain();
await domain.fill();
DomainModel domainModel = await DomainModel.createDomainModel(domain, errorHandler);
if (!List_Computer.Items.IsEmpty)
{
// Update the existing model with the new generated one
var needRefresh = (List_Computer.Items[0] as DomainModel).updateDomainModel(domainModel, checkBox_FilterOn.IsChecked.Value, checkBox_FilterOff.IsChecked.Value, List_Computer.SelectedItems);
if (needRefresh) // If an update is needed
{
updateSelectedComputers();
}
}
else
{
// Set the new domain model
List_Computer.Items.Add(domainModel);
// Expand the root node
TreeViewExItem item = (TreeViewExItem)List_Computer.ItemContainerGenerator.ContainerFromItem(domainModel);
item.IsExpanded = true;
}
} catch (Exception e) {
errorHandler.addError(e);
}
hideLoading();
}
/// <summary>
/// Overridden because original wpf tree does show the expander button and the contents of the
/// header as children, too. That was requested by the users.
/// </summary>
/// <returns>Returns a list of children.</returns>
protected override List <AutomationPeer> GetChildrenCore()
{
TreeViewExItem owner = (TreeViewExItem)Owner;
List <AutomationPeer> children = new List <AutomationPeer>();
var button = owner.Template.FindName("Expander", owner) as ToggleButton;
AddAutomationPeer(children, button);
var contentPresenter = GetContentPresenter(owner);
if (contentPresenter != null)
{
int childrenCount = VisualTreeHelper.GetChildrenCount(contentPresenter);
for (int i = 0; i < childrenCount; i++)
{
var child = VisualTreeHelper.GetChild(contentPresenter, i) as UIElement;
AddAutomationPeer(children, child);
}
}
ItemCollection items = owner.Items;
for (int i = 0; i < items.Count; i++)
{
TreeViewExItem treeViewItem = owner.ItemContainerGenerator.ContainerFromIndex(i) as TreeViewExItem;
AddAutomationPeer(children, treeViewItem);
}
if (children.Count > 0)
{
return(children);
}
return(null);
}
private List <TreeViewExItem> GetDraggableItems(Point mousePositionRelativeToTree)
{
TreeViewExItem itemUnderMouse = GetTreeViewItemUnderMouse(mousePositionRelativeToTree);
if (itemUnderMouse == null)
{
return(new List <TreeViewExItem>());
}
List <TreeViewExItem> items = TreeView.GetTreeViewItemsFor(TreeView.SelectedItems).ToList();
if (!items.Contains(itemUnderMouse))
{
//mouse is not over an selected item. We have to check if it is over the content. In this case we have to select and start drag n drop.
items = new List <TreeViewExItem>();
var contentPresenter = itemUnderMouse.Template.FindName("content", itemUnderMouse) as ContentPresenter;
if (contentPresenter.IsMouseOver)
{
items.Add(itemUnderMouse);
}
}
return(items);
}
private static ContentPresenter GetContentPresenter(TreeViewExItem treeViewExItem)
{
var contentPresenter = treeViewExItem.Template.FindName("PART_Header", treeViewExItem) as ContentPresenter;
return(contentPresenter);
}
public TreeViewExVM()
{
var a = new TreeViewExItem {
Title = "A"
};
var b = new TreeViewExItem {
Title = "B"
};
var c = new TreeViewExItem {
Title = "C"
};
var a1 = new TreeViewExItem {
Title = "A.1"
};
var a2 = new TreeViewExItem {
Title = "A.2"
};
var b1 = new TreeViewExItem {
Title = "B.1"
};
var b2 = new TreeViewExItem {
Title = "B.2"
};
var b3 = new TreeViewExItem {
Title = "B.3"
};
var b11 = new TreeViewExItem {
Title = "B.1.1"
};
var b12 = new TreeViewExItem {
Title = "B.1.2"
};
var b21 = new TreeViewExItem {
Title = "B.2.1"
};
var b22 = new TreeViewExItem {
Title = "B.2.2"
};
var a21 = new TreeViewExItem {
Title = "A.2.1"
};
a.Children = new TreeViewExItem[] { a1, a2 };
a2.Children = new TreeViewExItem[] { a21 };
b.Children = new TreeViewExItem[] { b1, b2, b3 };
b1.Children = new TreeViewExItem[] { b11, b12 };
b2.Children = new TreeViewExItem[] { b21, b22 };
Items = new TreeViewExItem[] { a, b, c };
m_SelectScope = new TreeViewExItem[] { b11, b, a21, b1, null };
m_CurSelIndex = -1;
SelectNextItemCommand = new RelayCommand(() =>
{
m_CurSelIndex++;
if (m_CurSelIndex > m_SelectScope.Length - 1)
{
m_CurSelIndex = 0;
}
SelectedItem = m_SelectScope[m_CurSelIndex];
});
SelectedItem = a1;
}
void OnDragOver(object sender, DragEventArgs e)
{
// drag over is the only event which returns the position
// GiveFeedback returns nonsense even from Mouse.GetPosition
Point point = e.GetPosition(TreeView);
if (TryScroll(point))
{
return;
}
if (dragAdorner == null)//external drop
{
var content = new DragContent();
content.Add(e.Data);
dragAdorner = new DragAdorner(TreeView, content);
}
dragAdorner.UpdatePosition(point);
if (IsMouseOverAdorner(point))
{
return;
}
var itemsPresenter = TreeView.ScrollViewer.Content as ItemsPresenter;
if (itemsPresenter.InputHitTest(e.GetPosition(itemsPresenter)) == null)
{
dragAdorner.Content.CanDrop = false;
dragAdorner.Content.CanInsert = false;
//dragAdorner.Content.InsertIndex = -1;
if (insertAdorner != null)
{
insertAdorner.Dispose();
}
return;
}
if (itemMouseIsOver != null)
{
itemMouseIsOver.IsCurrentDropTarget = false;
}
itemMouseIsOver = GetTreeViewItemUnderMouse(point);
if (itemMouseIsOver == null)
{
return;
}
CanInsertReturn canInsertReturn = CanInsert(itemMouseIsOver, e.GetPosition, e.Data);
if (canInsertReturn != null)
{
dragAdorner.Content.CanDrop = false;
dragAdorner.Content.CanInsert = true;
//dragAdorner.Content.InsertIndex = canInsertReturn.Index;
if (insertAdorner == null)
{
insertAdorner = new InsertAdorner(itemMouseIsOver, new InsertContent {
Before = canInsertReturn.Before
});
}
else
{
insertAdorner.Dispose();
insertAdorner = new InsertAdorner(itemMouseIsOver, new InsertContent {
Before = canInsertReturn.Before
});
}
itemMouseIsOver.IsCurrentDropTarget = false;
}
else
{
dragAdorner.Content.CanInsert = false;
//dragAdorner.Content.InsertIndex = -1;
if (insertAdorner != null)
{
insertAdorner.Dispose();
insertAdorner = null;
}
dragAdorner.Content.CanDrop = CanDrop(itemMouseIsOver, e.Data) != null;
if (itemMouseIsOver != null)
{
itemMouseIsOver.IsCurrentDropTarget = true;
}
}
}
private CanInsertReturn CanInsert(TreeViewExItem item, Func<UIElement, Point> getPositionDelegate, IDataObject data)
{
TreeViewExItem parentItem = item.ParentTreeViewItem;
if (parentItem == null)
{
return null;
}
if (parentItem.Insert == null)
{
return null;
}
// get position over element
Size size = item.RenderSize;
Point positionRelativeToItem = getPositionDelegate(item);
// decide whether to insert before or after item
bool after = true;
if (positionRelativeToItem.Y > dragAreaSize)
{
if (size.Height - positionRelativeToItem.Y > dragAreaSize)
{
return null;
}
}
else
{
after = false;
}
// get index, where to insert
int index = parentItem.ItemContainerGenerator.IndexFromContainer(item);
if (after)
{
// dont allow insertion after item, if item has children
if (item.HasItems)
{
return null;
}
index++;
}
// ask for all formats, if insertion is allowed
foreach (string f in data.GetFormats())
{
if (parentItem.CanInsertFormat == null || parentItem.CanInsertFormat(index, f))
{
if (parentItem.CanInsert == null || parentItem.CanInsert(index, data.GetData(f)))
{
return new CanInsertReturn(f, index, !after); ;
}
}
}
return null;
}
private string CanDrop(TreeViewExItem item, IDataObject data)
{
if (item == null) return null;
if (item.DropAction == null) return null;
foreach (string f in data.GetFormats())
{
if (item.CanDropFormat == null || item.CanDropFormat(f))
{
if (item.CanDrop == null || item.CanDrop(data.GetData(f)))
{
return f;
}
else
{
return null;
}
}
}
return null;
}
void OnDragOver(object sender, DragEventArgs e)
{
// drag over is the only event which returns the position
// GiveFeedback returns nonsense even from Mouse.GetPosition
Point point = e.GetPosition(TreeView);
if (TryScroll(point)) return;
if (dragAdorner == null)//external drop
{
var content = new DragContent();
content.Add(e.Data);
dragAdorner = new DragAdorner(TreeView, content);
}
dragAdorner.UpdatePosition(point);
if (IsMouseOverAdorner(point)) return;
var itemsPresenter = TreeView.ScrollViewer.Content as ItemsPresenter;
if (itemsPresenter.InputHitTest(e.GetPosition(itemsPresenter)) == null)
{
dragAdorner.Content.CanDrop = false;
dragAdorner.Content.CanInsert = false;
dragAdorner.Content.InsertIndex = -1;
if (insertAdorner != null) insertAdorner.Dispose();
return;
}
if (itemMouseIsOver != null)
{
itemMouseIsOver.IsCurrentDropTarget = false;
}
itemMouseIsOver = GetTreeViewItemUnderMouse(point);
if (itemMouseIsOver == null) return;
CanInsertReturn canInsertReturn = CanInsert(itemMouseIsOver, e.GetPosition, e.Data);
if (canInsertReturn != null)
{
dragAdorner.Content.CanDrop = false;
dragAdorner.Content.CanInsert = true;
dragAdorner.Content.InsertIndex = canInsertReturn.Index;
if (insertAdorner == null)
{
insertAdorner = new InsertAdorner(itemMouseIsOver, new InsertContent { Before = canInsertReturn.Before });
}
else
{
insertAdorner.Dispose();
insertAdorner = new InsertAdorner(itemMouseIsOver, new InsertContent { Before = canInsertReturn.Before });
}
itemMouseIsOver.IsCurrentDropTarget = false;
}
else
{
dragAdorner.Content.CanInsert = false;
dragAdorner.Content.InsertIndex = -1;
if (insertAdorner != null)
{
insertAdorner.Dispose();
insertAdorner = null;
}
dragAdorner.Content.CanDrop = CanDrop(itemMouseIsOver, e.Data) != null;
if (itemMouseIsOver != null)
{
itemMouseIsOver.IsCurrentDropTarget = true;
}
}
}
private void DragEnd()
{
DragDrop.RemoveGiveFeedbackHandler(TreeView, OnGiveFeedBack);
TreeView.Cursor = initialCursor;
autoScroller.IsEnabled = false;
// Remove the drag adorner from the adorner layer.
CleanUpAdorners();
if (insertAdorner != null)
{
insertAdorner.Dispose();
insertAdorner = null;
}
if (itemMouseIsOver != null)
{
itemMouseIsOver.IsCurrentDropTarget = false;
itemMouseIsOver = null;
}
}
public static Border GetParentBorder(TreeViewExItem item)
{
Border border = item.Template.FindName("border", item) as Border;
return(border);
}
void OnDragOver(object sender, DragEventArgs e)
{
e.Effects = DragDropEffects.None;
e.Handled = true;
// drag over is the only event which returns the position
Point point = e.GetPosition(TreeView);
if (TryScroll(point))
{
return;
}
if (IsMouseOverAdorner(point))
{
return;
}
var itemsPresenter = TreeView.ScrollViewer.Content as ItemsPresenter;
/*
* if (itemsPresenter.InputHitTest(e.GetPosition(itemsPresenter)) == null)
* {
* if (insertAdorner != null) insertAdorner.Dispose();
* return;
* }
*/
if (itemMouseIsOver != null)
{
itemMouseIsOver.IsCurrentDropTarget = false;
}
itemMouseIsOver = GetTreeViewItemUnderMouse(point);
//if (itemMouseIsOver == null) return;
CanInsertReturn canInsertReturn = CanInsert(itemMouseIsOver, e.GetPosition, e.Data);
if (canInsertReturn != null)
{
e.Effects = DragDropEffects.Move;
if (insertAdorner == null)
{
insertAdorner = new InsertAdorner(itemMouseIsOver, new InsertContent {
Before = canInsertReturn.Before
});
}
else
{
insertAdorner.Dispose();
insertAdorner = new InsertAdorner(itemMouseIsOver, new InsertContent {
Before = canInsertReturn.Before
});
}
itemMouseIsOver.IsCurrentDropTarget = false;
}
else
{
if (insertAdorner != null)
{
insertAdorner.Dispose();
insertAdorner = null;
}
if (CanDrop(itemMouseIsOver, e.Data))
{
e.Effects = DragDropEffects.Move;
}
if (itemMouseIsOver != null)
{
itemMouseIsOver.IsCurrentDropTarget = true;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref = "TreeViewExItemAutomationPeer" /> class.
/// Initialisiert eine neue Instanz der <see cref = "T:System.Windows.Automation.Peers.TreeViewExItemAutomationPeer" />-Klasse.
/// </summary>
/// <param name = "owner">
/// Das <see cref = "T:System.Windows.Controls.TreeViewExItem" />, das diesem <see cref = "T:System.Windows.Automation.Peers.TreeViewExItemAutomationPeer" /> zugeordnet ist.
/// </param>
public TreeViewExItemAutomationPeer(TreeViewExItem owner)
: base(owner)
{
}
public void Invoke()
{
TreeViewExItem treeViewItem = (TreeViewExItem)Owner;
treeViewItem.InvokeMouseDown();
}
public static Border GetParentBorder(TreeViewExItem item)
{
Border border = item.Template.FindName("border", item) as Border;
return border;
}
public DropParameters(TreeViewExItem dropToItem, IDataObject dropData, int index)
{
this.DropToItem = dropToItem;
this.DropData = dropData;
this.Index = index;
}
public DropParameters(TreeViewExItem dropToItem, IDataObject dropData) : this(dropToItem, dropData, -1)
{
}
