public void TestNodeStaysSelected()
{
VirtualTreeNode root = new VirtualTreeNode("root");
root.Nodes.Add(new VirtualTreeNode("1")
{
Tag = new Folder(null, "1")
});
root.Nodes.Add(new VirtualTreeNode("2")
{
Tag = new Folder(null, "2")
});
_tv.BeginUpdate();
_tv.UpdateRootNodes(new VirtualTreeNode[] { root });
_tv.EndUpdate();
_tv.SelectedNode = _tv.Nodes[0].Nodes[0];
root = new VirtualTreeNode("root");
root.Nodes.Add(new VirtualTreeNode("1")
{
Tag = new Folder(null, "1")
});
root.Nodes.Add(new VirtualTreeNode("2")
{
Tag = new Folder(null, "2")
});
_tv.BeginUpdate();
_tv.UpdateRootNodes(new VirtualTreeNode[] { root });
_tv.EndUpdate();
Assert.AreEqual("1", _tv.SelectedNode.Text);
}
public void Test()
{
foreach (SelectedItemCollection selection in RunTest())
{
Folder folder = (Folder)selection[0].XenObject;
// choose new folder name
string newFolderName = Guid.NewGuid().ToString();
// execute rename folder command
MW(Command.Execute);
// get in-line edit box which is a child of the treeview.
MWWaitFor(delegate
{
foreach (Win32Window child in new Win32Window(MainWindowWrapper.TreeView.Handle).Children)
{
child.Text = newFolderName;
FindInTree(folder).EndEdit(false);
return(true);
}
return(false);
}, "Couldn't find rename-node edit box.");
// now check to see if folder has been renamed and is still selected, and is visible.
MWWaitFor(delegate
{
VirtualTreeNode n = MainWindowWrapper.TreeView.SelectedNode;
Folder f = n == null ? null : n.Tag as Folder;
return(f != null && n.Text == newFolderName && f.Name() == newFolderName && n.AllParentsAreExpanded);
}, "Couldn't find renamed folder.");
}
}
private VirtualTreeNode AddNode(string name, Icons icon, bool grayed, object obj)
{
VirtualTreeNode result = new VirtualTreeNode(name.Ellipsise(1000))
{
Tag = obj,
ImageIndex = (int)icon,
SelectedImageIndex = (int)icon
};
_parent.Nodes.Insert(_index, result);
_index++;
IXenObject xenObject = obj as IXenObject;
bool highlighted = _highlightedDragTarget != null && obj != null && _highlightedDragTarget.Equals(obj);
if (highlighted)
{
result.BackColor = SystemColors.Highlight;
result.ForeColor = SystemColors.HighlightText;
}
else if (grayed)
{
result.BackColor = _treeViewBackColor;
result.ForeColor = SystemColors.GrayText;
}
else
{
result.BackColor = _treeViewBackColor;
result.ForeColor = _treeViewForeColor;
}
return(result);
}
/// <summary>
/// Updates the <see cref="TreeView"/> with the specified new root node. This is done by merging the specified
/// root node with the existing root node to minimize updates to the treeview to reduce flicker.
/// </summary>
/// <param name="newRootNode">The new root node.</param>
/// <param name="searchText">The search text for the currently active search.</param>
public void RefreshTreeView(VirtualTreeNode newRootNode, string searchText, NavigationPane.NavigationMode searchMode)
{
Util.ThrowIfParameterNull(newRootNode, "newRootNode");
Util.ThrowIfParameterNull(searchText, "searchText");
Program.AssertOnEventThread();
_treeView.BeginUpdate();
PersistExpandedNodes(searchText);
_treeView.UpdateRootNodes(new[] { newRootNode });
RestoreExpandedNodes(searchText, searchMode);
bool searchTextCleared = (searchText.Length == 0 && searchText != _lastSearchText);
_lastSearchText = searchText;
_lastSearchMode = searchMode;
_treeView.EndUpdate();
// ensure that the selected nodes are visible when search text is cleared (CA-102127)
if (searchTextCleared)
{
ExpandSelection();
}
}
// In the expected items, represent a separator by a null
protected void VerifyContextMenu(object ixmo, ExpectedMenuItem[] expectedItems)
{
string ixmoString = (ixmo == null ? "XenCenter node" : ixmo.ToString());
// The easiest way to generate the context menu is to call TreeView_NodeMouseClick_ ourselves.
// So construct fake click event data.
VirtualTreeNode node = FindInTree(ixmo);
Assert.IsNotNull(node, "Couldn't find a node for " + ixmoString + " in the tree");
VirtualTreeNodeMouseClickEventArgs e = new VirtualTreeNodeMouseClickEventArgs(node, MouseButtons.Right, 1, 0, 0);
// Generate the TreeContextMenu
MW(delegate()
{
node.EnsureVisible();
MainWindowWrapper.TreeView_NodeMouseClick_(MainWindowWrapper.TreeView, e);
});
ContextMenuStrip menu = MainWindowWrapper.TreeContextMenu;
AssertToolStripItems(ixmoString, expectedItems, menu.Items, true);
// Close the menu again
MW(menu.Close);
Thread.Sleep(100);
}
private void PopulateTree()
{
VirtualTreeNode selectedNode = treeView.SelectedNode;
Folder selectedFolder = selectedNode == null?null: selectedNode.Tag as Folder;
EmptyTree();
TreeNodeGroupAcceptor tnga = new TreeNodeGroupAcceptor(treeView, true);
Search.SearchForAllFolders().PopulateAdapters(tnga);
if (selectedFolder != null)
{
// try the one we were on: if that's no longer present, back off to the one we started with
if (!SelectNode(selectedFolder.opaque_ref))
{
string folder = orig_folder;
SelectNode(folder);
}
}
else
{
SelectNode(null);
}
}
private ComparableList <IXenObject> Populate()
{
VirtualTreeNode rootNode = MW(() => new MainWindowTreeBuilder(new FlickerFreeTreeView()).CreateNewRootNode(new NavigationPane().Search, NavigationPane.NavigationMode.Infrastructure));
List <VirtualTreeNode> nodes = new List <VirtualTreeNode>(rootNode.Descendants);
return(new ComparableList <IXenObject>(nodes.ConvertAll(n => (IXenObject)n.Tag)));
}
private void treeView_SelectionsChanged(object sender, EventArgs e)
{
// this is fired when the selection of the main treeview changes.
VirtualTreeNode rootNode = treeView.Nodes.Count > 0 ? treeView.Nodes[0] : null;
List <SelectedItem> items = new List <SelectedItem>();
foreach (VirtualTreeNode node in treeView.SelectedNodes)
{
GroupingTag groupingTag = node.Tag as GroupingTag;
IXenObject xenObject = node.Tag as IXenObject;
if (xenObject != null)
{
items.Add(new SelectedItem(xenObject, xenObject.Connection,
HostAncestorOfNode(node), PoolAncestorOfNode(node),
GroupAncestorOfNode(node), rootNode));
}
else
{
items.Add(new SelectedItem(groupingTag, rootNode));
}
}
selectionManager.SetSelection(items);
if (TreeViewSelectionChanged != null)
{
TreeViewSelectionChanged();
}
}
public void TestPropertiesOnSimpleRootNodeUpdate()
{
_vtv.Nodes.Add(new VirtualTreeNode("root"));
_vtv.Nodes[0].Nodes.Add(new VirtualTreeNode("child"));
VirtualTreeNode newRoot = new VirtualTreeNode("newRoot");
//newRoot.ImageIndexFetcher = delegate { return 1; };
newRoot.ImageIndex = 3;
newRoot.SelectedImageIndex = 4;
newRoot.Text = "hello";
newRoot.NodeFont = SystemFonts.CaptionFont;
newRoot.BackColor = Color.Beige;
newRoot.ForeColor = Color.Bisque;
_vtv.UpdateRootNodes(new VirtualTreeNode[] { newRoot });
//Assert.IsNotNull(_vtv.Nodes[0].ImageIndexFetcher, "ImageIndexFetcher");
Assert.AreEqual(3, _vtv.Nodes[0].ImageIndex);
Assert.AreEqual(4, _vtv.Nodes[0].SelectedImageIndex);
Assert.AreEqual("hello", _vtv.Nodes[0].Text);
Assert.AreEqual(SystemFonts.CaptionFont, _vtv.Nodes[0].NodeFont);
Assert.AreEqual(Color.Beige, _vtv.Nodes[0].BackColor);
Assert.AreEqual(Color.Bisque, _vtv.Nodes[0].ForeColor);
Assert.AreEqual(3, _tv.Nodes[0].ImageIndex);
Assert.AreEqual(4, _tv.Nodes[0].SelectedImageIndex);
Assert.AreEqual("hello", _tv.Nodes[0].Text);
Assert.AreEqual(SystemFonts.CaptionFont, _tv.Nodes[0].NodeFont);
Assert.AreEqual(Color.Beige, _tv.Nodes[0].BackColor);
Assert.AreEqual(Color.Bisque, _tv.Nodes[0].ForeColor);
}
public void ContextMenu_XenCenterNode_PoolOpen()
{
VirtualTreeNode rootNode = FindInTree(null);
MW(delegate
{
rootNode.Collapse();
rootNode.Expand();
});
VirtualTreeNode poolNode = FindInTree(GetAnyPool());
MW(delegate
{
poolNode.Expand();
});
VerifyContextMenu(null, new ExpectedMenuItem[] {
new ExpectedTextMenuItem("&Add...", true),
new ExpectedTextMenuItem("&New Pool...", true),
new ExpectedTextMenuItem("C&onnect All", false),
new ExpectedTextMenuItem("Di&sconnect All", true),
new ExpectedTextMenuItem("E&xpand All", true),
new ExpectedTextMenuItem("&Collapse Children", true)
});
}
public void TestBeginUpdateOnlyCalledIfNecessary()
{
PutInNavigationMode(NavigationPane.NavigationMode.Objects);
ClearTreeSelections();
MW(delegate
{
MainWindowTreeBuilder builder = new MainWindowTreeBuilder(MainWindowWrapper.TreeView);
VirtualTreeNode newRoot = builder.CreateNewRootNode(TreeSearch.DefaultTreeSearch, NavigationPane.NavigationMode.Objects);
MainWindowWrapper.TreeView.UpdateRootNodes(new [] { newRoot }); // update once to set all the node names properly
MainWindowWrapper.TreeView.EndUpdate();
short updateCount = GetTreeUpdateCount();
MainWindowWrapper.TreeView.UpdateRootNodes(new[] { newRoot }); // update again: nothing should change this time
short updateCount2 = GetTreeUpdateCount();
Assert.AreEqual(updateCount, updateCount2, "BeginUpdate shouldn't have been called.");
// this time there is a different node, so an update should occur
newRoot = builder.CreateNewRootNode(TreeSearch.DefaultTreeSearch, NavigationPane.NavigationMode.Objects);
newRoot.Nodes[0].Text = "bla";
MainWindowWrapper.TreeView.UpdateRootNodes(new[] { newRoot });
short updateCount3 = GetTreeUpdateCount();
Assert.AreEqual(updateCount2 + 1, updateCount3, "BeginUpdate should have been called exactly once");
MainWindowWrapper.TreeView.EndUpdate();
Assert.AreEqual(0, GetTreeUpdateCount(), "FlickFreeTreeView didn't pass EndUpdate down to TreeView.");
});
}
private void treeView_DragOver(object sender, DragEventArgs e)
{
// CA-11457: When dragging in resource tree, view doesn't scroll
// http://www.fmsinc.com/freE/NewTips/NET/NETtip21.asp
const int SCROLL_REGION = 20;
Point pt = treeView.PointToClient(Cursor.Position);
VirtualTreeNode targetNode = treeView.GetNodeAt(treeView.PointToClient(new Point(e.X, e.Y)));
if ((pt.Y + SCROLL_REGION) > treeView.Height)
{
Win32.SendMessage(treeView.Handle, Win32.WM_VSCROLL, new IntPtr(1), IntPtr.Zero);
}
else if (pt.Y < SCROLL_REGION)
{
Win32.SendMessage(treeView.Handle, Win32.WM_VSCROLL, IntPtr.Zero, IntPtr.Zero);
}
VirtualTreeNode targetToHighlight = null;
string statusBarText = null;
foreach (DragDropCommand cmd in GetDragDropCommands(targetNode, e.Data))
{
if (cmd.CanExecute())
{
targetToHighlight = cmd.HighlightNode;
}
if (cmd.StatusBarText != null)
{
statusBarText = cmd.StatusBarText;
}
}
if (DragDropCommandActivated != null)
{
DragDropCommandActivated(statusBarText);
}
if (targetToHighlight != null)
{
if (_highlightedDragTarget != targetToHighlight)
{
ClearHighlightedDragTarget();
treeBuilder.HighlightedDragTarget = targetToHighlight.Tag;
_highlightedDragTarget = targetToHighlight;
_highlightedDragTarget.BackColor = SystemColors.Highlight;
_highlightedDragTarget.ForeColor = SystemColors.HighlightText;
}
e.Effect = DragDropEffects.Move;
}
else
{
ClearHighlightedDragTarget();
e.Effect = DragDropEffects.None;
}
}
protected virtual VirtualTreeNode AddNode(int index, Grouping grouping, Object obj)
{
VirtualTreeNode node = new VirtualTreeNode(obj.ToString());
node.Tag = obj;
parent.Nodes.Insert(index, node);
return(node);
}
public MainWindowTreeNodeGroupAcceptor(object highlightedDragTarget,
Color treeViewForeColor, Color treeViewBackColor, VirtualTreeNode parent)
{
_parent = parent;
_treeViewForeColor = treeViewForeColor;
_treeViewBackColor = treeViewBackColor;
_highlightedDragTarget = highlightedDragTarget;
}
private static bool IsTagInOrgMode(VirtualTreeNode node)
{
if (node != null)
{
GroupingTag gt = node.Tag as GroupingTag;
return(gt != null && gt.Grouping.GroupingName == Messages.TAGS);
}
return(false);
}
private List <VirtualTreeNode> GetNewRootNodes()
{
return(_canonRootNodes.ConvertAll(n =>
{
var nn = new VirtualTreeNode(string.Empty);
CopyNode(n, nn);
return nn;
}).FindAll(NodeMatches));
}
/// <summary>
/// Calculates the nodes that should be visible in the main window tree view when the specified xen object is hidden.
/// </summary>
/// <param name="hiddenObject">The hidden object.</param>
private ComparableList <IXenObject> CalculatePopulateWithHiddenObject(IXenObject hiddenObject)
{
VirtualTreeNode rootNode = MW(() => new MainWindowTreeBuilder(new FlickerFreeTreeView()).CreateNewRootNode(new NavigationPane().Search, NavigationPane.NavigationMode.Infrastructure));
List <VirtualTreeNode> nodes = new List <VirtualTreeNode>(rootNode.Descendants);
nodes.RemoveAll(n => hiddenObject.Equals(n.Tag));
nodes.RemoveAll(n => new List <VirtualTreeNode>(n.Ancestors).Find(nn => hiddenObject.Equals(nn.Tag)) != null);
return(new ComparableList <IXenObject>(nodes.ConvertAll(n => (IXenObject)n.Tag)));
}
/// <summary>
/// Gets the nearest ancestor of the target node that has a tag of the specified xen object or grouping tag type and returns that tag.
/// </summary>
protected T GetTargetNodeAncestorAsXenObjectOrGroupingTag <T>() where T : class
{
VirtualTreeNode node = GetTargetNodeAncestor <T>();
if (node != null)
{
return((T)node.Tag);
}
return(default(T));
}
public void TestMultipleNodesStaySelectedAsTheyMove()
{
VirtualTreeNode root = new VirtualTreeNode("root");
root.Nodes.Add(new VirtualTreeNode("1")
{
Tag = new Folder(null, "1")
});
root.Nodes.Add(new VirtualTreeNode("2")
{
Tag = new Folder(null, "2")
});
root.Nodes.Add(new VirtualTreeNode("3")
{
Tag = new Folder(null, "3")
});
root.Nodes.Add(new VirtualTreeNode("4")
{
Tag = new Folder(null, "4")
});
_tv.BeginUpdate();
_tv.UpdateRootNodes(new [] { root });
_tv.EndUpdate();
_tv.SelectedNodes.SetContents(new [] { root.Nodes[0], root.Nodes[1] });
root = new VirtualTreeNode("root");
root.Nodes.Add(new VirtualTreeNode("4")
{
Tag = new Folder(null, "4")
});
root.Nodes.Add(new VirtualTreeNode("3")
{
Tag = new Folder(null, "3")
});
root.Nodes.Add(new VirtualTreeNode("2")
{
Tag = new Folder(null, "2")
});
root.Nodes.Add(new VirtualTreeNode("1")
{
Tag = new Folder(null, "1")
});
_tv.BeginUpdate();
_tv.UpdateRootNodes(new [] { root });
_tv.EndUpdate();
Assert.AreEqual(2, _tv.SelectedNodes.Count, "Nodes didn't stay selected");
Assert.AreEqual("1", _tv.SelectedNodes[0].Text, "Nodes didn't stay selected");
Assert.AreEqual("2", _tv.SelectedNodes[1].Text, "Nodes didn't stay selected");
Assert.AreEqual(new Folder(null, "1"), _tv.SelectedNodes[0].Tag, "Nodes didn't stay selected");
Assert.AreEqual(new Folder(null, "2"), _tv.SelectedNodes[1].Tag, "Nodes didn't stay selected");
}
public void TestState1CorrectlyPopulatedInOrgView()
{
MW(() =>
{
MainWindowTreeBuilder _treeBuilder = new MainWindowTreeBuilder(MainWindowWrapper.TreeView);
VirtualTreeNode newRoot = _treeBuilder.CreateNewRootNode(new NavigationPane().Search, NavigationPane.NavigationMode.Objects);
MainWindowWrapper.TreeView.UpdateRootNodes(new[] { newRoot });
MainWindowWrapper.TreeView.EndUpdate();
AssertTreeViewsSame(DeserializeTreeView("state1.treeview.orgview.xml").Nodes, MainWindowWrapper.TreeView.Nodes);
});
}
public void TestState1CorrectlyPopulatedInServerView()
{
MW(() =>
{
MainWindowTreeBuilder _treeBuilder = new MainWindowTreeBuilder(MainWindowWrapper.TreeView);
VirtualTreeNode newRoot = _treeBuilder.CreateNewRootNode(new TreeSearchBox().Search, TreeSearchBox.Mode.Infrastructure);
MainWindowWrapper.TreeView.UpdateRootNodes(new[] { newRoot });
MainWindowWrapper.TreeView.EndUpdate();
AssertTreeViewsSame(DeserializeTreeView("state1.treeview.serverview.xml").Nodes, MainWindowWrapper.TreeView.Nodes);
});
}
private void SetOrganizationViewExpandedNodes()
{
VirtualTreeNode dummyRootNode = new VirtualTreeNode(Messages.VIEW_ORGANIZATION);
OrganizationalView.PopulateOrganizationView(CreateGroupAcceptor(dummyRootNode), TreeSearch.DefaultTreeSearch);
foreach (VirtualTreeNode n in dummyRootNode.Nodes)
{
_organizationViewExpandedTags.Add(n.GetPersistenceInfo());
}
}
private VirtualTreeNode AddNetworkNode(VirtualTreeNode parent, int index, XenAPI.Network network)
{
bool hidden = network.IsHidden;
bool slave = network.IsSlave;
string rawName = network.Name;
String name = slave ? String.Format(Messages.NIC_SLAVE, rawName) :
hidden?String.Format(Messages.X_HIDDEN, rawName) :
rawName;
return(AddNode(parent, index, name, Images.GetIconFor(network), slave || hidden, network));
}
public void Test()
{
foreach (SelectedItemCollection selection in RunTest())
{
Folder folder = (Folder)selection[0].XenObject;
// choose new folder name
string newFolderName = Guid.NewGuid().ToString();
if (folder == null)
{
GroupingTag tag = selection[0].GroupingTag;
if (tag != null && tag.Grouping is OrganizationViewFolders)
{
HandleModalDialog("New Folder", Command.Execute, delegate(NameAndConnectionPromptWrapper p)
{
p.NameTextBox.Text = newFolderName;
p.OKButton.PerformClick();
});
}
}
else
{
if (folder.IsRootFolder)
{
HandleModalDialog("New Folder", Command.Execute, delegate(NameAndConnectionPromptWrapper p)
{
p.NameTextBox.Text = newFolderName;
p.OKButton.PerformClick();
});
}
else
{
HandleModalDialog("New Folder", Command.Execute, delegate(InputPromptDialogWrapper p)
{
p.NameTextBox.Text = newFolderName;
p.OKButton.PerformClick();
});
}
}
// now check to see if new folder exists and is selected, and is visible.
MWWaitFor(delegate
{
VirtualTreeNode n = MainWindowWrapper.TreeView.SelectedNode;
Folder f = n == null ? null : n.Tag as Folder;
return(f != null &&
n.Text == newFolderName &&
f.Name == newFolderName &&
n.AllParentsAreExpanded);
}, "Couldn't find new folder.");
}
}
private void vtItems_OnGetNodeCellText(VirtualTreeView.VirtualTreeView tree, VirtualTreeNode node, int column, out string cellText)
{
var n = vtItems.GetNodeData <NodeData>(node);
switch (column)
{
case 0: cellText = (n.num).ToString(); break;
default: cellText = n.name; break;
}
}
private VirtualTreeNode FindNode(string tag)
{
foreach (VirtualTreeNode node in treeView.Nodes)
{
VirtualTreeNode found = FindNode(tag, node);
if (found != null)
{
return(found);
}
}
return(null);
}
public IAcceptGroups Add(Grouping grouping, Object group, int indent)
{
if (group == null)
return null;
VirtualTreeNode node = new VirtualTreeNode(group.ToString());
node.Tag = group;
parent.Nodes.Insert(index, node);
index++;
return new TreeNodeGroupAcceptor(node, null);
}
private VirtualTreeNode AddStorageLinkRepositoryNode(VirtualTreeNode parent, int index, StorageLinkRepository storageLinkRepository)
{
string name = storageLinkRepository.Name;
StorageLinkPool pool = storageLinkRepository.StorageLinkPool;
if (pool != null && !string.IsNullOrEmpty(pool.ParentStorageLinkPoolId))
{
name = string.Format("{0} ({1})", storageLinkRepository.Name, pool);
}
return(AddNode(parent, index, name, Images.GetIconFor(storageLinkRepository), false, storageLinkRepository));
}
private bool ChildrenHaveExpandedChildren(VirtualTreeNode node)
{
foreach (VirtualTreeNode child in node.Nodes)
{
if (child.Nodes.Count > 0 && child.IsExpanded)
{
return(true);
}
}
return(false);
}
internal override Command CreateCommand()
{
PutInNavigationMode(NativeMode);
_node = GetAllTreeNodes().Find(n => n.Tag is IXenObject && !(n.Tag is Folder) && n.Parent.Tag is Folder);
MW(() => _node.EnsureVisible());
return(new RemoveFromFolderCommand(Program.MainWindow, new List <VirtualTreeNode> {
_node
}));
}
public NavigationView()
{
InitializeComponent();
panel1.BackColor = Program.TitleBarBorderColor;
treeView.ImageList = Images.ImageList16;
if (treeView.ItemHeight < 18)
treeView.ItemHeight = 18;
//otherwise it's too close together on XP and the icons crash into each other
VirtualTreeNode n = new VirtualTreeNode(Messages.XENCENTER);
n.NodeFont = Program.DefaultFont;
treeView.Nodes.Add(n);
treeView.SelectedNode = treeView.Nodes[0];
treeBuilder = new MainWindowTreeBuilder(treeView);
treeViewUpdateManager.Update += treeViewUpdateManager_Update;
}
private void treeView_DragOver(object sender, DragEventArgs e)
{
// CA-11457: When dragging in resource tree, view doesn't scroll
// http://www.fmsinc.com/freE/NewTips/NET/NETtip21.asp
const int SCROLL_REGION = 20;
Point pt = treeView.PointToClient(Cursor.Position);
VirtualTreeNode targetNode = treeView.GetNodeAt(treeView.PointToClient(new Point(e.X, e.Y)));
if ((pt.Y + SCROLL_REGION) > treeView.Height)
{
Win32.SendMessage(treeView.Handle, Win32.WM_VSCROLL, new IntPtr(1), IntPtr.Zero);
}
else if (pt.Y < SCROLL_REGION)
{
Win32.SendMessage(treeView.Handle, Win32.WM_VSCROLL, IntPtr.Zero, IntPtr.Zero);
}
VirtualTreeNode targetToHighlight = null;
string statusBarText = null;
foreach (DragDropCommand cmd in GetDragDropCommands(targetNode, e.Data))
{
if (cmd.CanExecute())
targetToHighlight = cmd.HighlightNode;
if (cmd.StatusBarText != null)
statusBarText = cmd.StatusBarText;
}
if (DragDropCommandActivated != null)
DragDropCommandActivated(statusBarText);
if (targetToHighlight != null)
{
if (_highlightedDragTarget != targetToHighlight)
{
ClearHighlightedDragTarget();
treeBuilder.HighlightedDragTarget = targetToHighlight.Tag;
_highlightedDragTarget = targetToHighlight;
_highlightedDragTarget.BackColor = SystemColors.Highlight;
_highlightedDragTarget.ForeColor = SystemColors.HighlightText;
}
e.Effect = DragDropEffects.Move;
}
else
{
ClearHighlightedDragTarget();
e.Effect = DragDropEffects.None;
}
}
private List<DragDropCommand> GetDragDropCommands(VirtualTreeNode targetNode, IDataObject dragData)
{
List<DragDropCommand> commands = new List<DragDropCommand>();
commands.Add(new DragDropAddHostToPoolCommand(Program.MainWindow, targetNode, dragData));
commands.Add(new DragDropMigrateVMCommand(Program.MainWindow, targetNode, dragData));
commands.Add(new DragDropRemoveHostFromPoolCommand(Program.MainWindow, targetNode, dragData));
if (NavigationMode == NavigationPane.NavigationMode.Tags
|| NavigationMode == NavigationPane.NavigationMode.Folders
|| NavigationMode == NavigationPane.NavigationMode.CustomFields
|| NavigationMode == NavigationPane.NavigationMode.vApps)
{
commands.Add(new DragDropTagCommand(Program.MainWindow, targetNode, dragData));
commands.Add(new DragDropIntoFolderCommand(Program.MainWindow, targetNode, dragData));
}
return commands;
}
private void ClearHighlightedDragTarget()
{
if (_highlightedDragTarget != null)
{
_highlightedDragTarget.BackColor = treeView.BackColor;
_highlightedDragTarget.ForeColor = treeView.ForeColor;
_highlightedDragTarget = null;
treeBuilder.HighlightedDragTarget = null;
if (DragDropCommandActivated != null)
DragDropCommandActivated(null);
}
}
private static Pool PoolAncestorOfNode(VirtualTreeNode node)
{
while (node != null)
{
var pool = node.Tag as Pool;
if (pool != null)
return pool;
node = node.Parent;
}
return null;
}
private static Host HostAncestorOfNode(VirtualTreeNode node)
{
while (node != null)
{
var host = node.Tag as Host;
if (host != null)
return host;
node = node.Parent;
}
return null;
}
private static GroupingTag GroupAncestorOfNode(VirtualTreeNode node)
{
while (node != null)
{
var group = node.Tag as GroupingTag;
if (group != null)
return group;
node = node.Parent;
}
return null;
}
