/// <summary>
/// Selects the specified object in the tree.
/// </summary>
/// <param name="o">The object to be selected.</param>
/// <param name="node">The node at which to start.</param>
/// <param name="expand">Expand the node when it's found.</param>
/// <param name="cancelled">if set to <c>true</c> then the node for the
/// specified object was not allowed to be selected.</param>
/// <returns>A value indicating whether selection was successful.</returns>
public bool SelectObject(IXenObject o, VirtualTreeNode node, bool expand, ref bool cancelled)
{
IXenObject candidate = node.Tag as IXenObject;
if (o == null || (candidate != null && candidate.opaque_ref == o.opaque_ref))
{
if (!CanSelectNode(node))
{
cancelled = true;
return(false);
}
SelectedNode = node;
if (expand)
{
node.Expand();
}
return(true);
}
foreach (VirtualTreeNode child in node.Nodes)
{
if (SelectObject(o, child, expand, ref cancelled))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Try and find a node by following the path in selection
/// </summary>
/// <param name="selection"></param>
/// <param name="match"></param>
/// <returns>How far it got along the path before it bailed.
/// If it returns >= selection.Count, then it succeded</returns>
public int TryExactMatch(IList <Object> selection, out VirtualTreeNode match)
{
int i = 0;
match = Nodes[0];
while (i < selection.Count)
{
bool found = false;
foreach (VirtualTreeNode child in match.Nodes)
{
if (child.Tag.Equals(selection[i]))
{
match = child;
found = true;
i++;
break;
}
}
if (!found)
{
break;
}
}
return(i);
}
protected sealed override void OnBeforeSelect(MultiSelectTreeViewCancelEventArgs e)
{
VirtualTreeNode node = (VirtualTreeNode)e.Node;
VirtualTreeViewCancelEventArgs args = new VirtualTreeViewCancelEventArgs(node, e.Cancel, e.Action);
OnBeforeSelect(args);
e.Cancel = args.Cancel;
}
protected sealed override void OnBeforeLabelEdit(NodeLabelEditEventArgs e)
{
VirtualTreeNode node = (VirtualTreeNode)e.Node;
VirtualNodeLabelEditEventArgs args = new VirtualNodeLabelEditEventArgs(node, e.Label);
OnBeforeLabelEdit(args);
e.CancelEdit = args.CancelEdit;
}
private static bool IsTagInOrgMode(VirtualTreeNode node)
{
if (node != null && node.Parent != null)//exclude the top node
{
GroupingTag gt = node.Tag as GroupingTag;
return gt != null && gt.Grouping.GroupingName == Messages.TAGS;
}
return false;
}
protected sealed override void OnBeforeExpand(TreeViewCancelEventArgs e)
{
VirtualTreeNode node = (VirtualTreeNode)e.Node;
Devirtualise(node.Nodes);
VirtualTreeViewCancelEventArgs args = new VirtualTreeViewCancelEventArgs(node, e.Cancel, e.Action);
OnBeforeExpand(args);
e.Cancel = args.Cancel;
}
internal override Command CreateCommand()
{
PutInOrgView(true);
_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.CommandInterface, new List<VirtualTreeNode> { _node });
}
private void TryToSelectNode(List <VirtualTreeNode> nodes, VirtualTreeNode node)
{
if (!CanSelectNode(node))
{
TryToSelectNode(nodes, node.Parent);
}
else if (!nodes.Contains(node))
{
nodes.Add(node);
}
}
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 bool ChildrenHaveExpandedChildren(VirtualTreeNode node)
{
foreach (VirtualTreeNode child in node.Nodes)
{
if (child.Nodes.Count > 0 && child.IsExpanded)
{
return true;
}
}
return false;
}
public PersistenceInfo(VirtualTreeNode node)
{
Util.ThrowIfParameterNull(node, "node");
Node = node;
Path = new ReadOnlyCollection <object>(GetPath(node));
var maxSubTree = MaximalSubTree(node, node.Tag);
PathToMaximalSubTree = new ReadOnlyCollection <object>(maxSubTree == null ? new List <object>() : GetPath(maxSubTree));
Tag = node.Tag;
}
private static List <object> GetPath(VirtualTreeNode node)
{
var path = new List <object>();
if (node.Tag != null && node.Parent != null)
{
path.Add(node.Tag);
}
path.AddRange(new List <VirtualTreeNode>(node.Ancestors).FindAll(o => o.Parent != null).ConvertAll(n => n.Tag).FindAll(o => o != null));
path.Reverse();
return(path);
}
/// <summary>
/// Ensures that the tree node is visible, expanding tree nodes and scrolling the tree view control as necessary.
/// </summary>
public new void EnsureVisible()
{
if (((TreeNode)this).TreeView == null)
{
VirtualTreeNode n = Parent;
while (n != null)
{
n.Expand();
n = n.Parent;
}
}
base.EnsureVisible();
}
public void TestParentNodeSelectedWhenSelectedNodeTagsChange()
{
// populate the tree-view with some folders
Folder foldersTag = new Folder(null, "Folders");
_tv.Nodes.Add(new VirtualTreeNode("XenCenter"));
VirtualTreeNode folders = new VirtualTreeNode("Folders") { Tag = foldersTag };
_tv.Nodes[0].Nodes.Add(folders);
folders.Nodes.Add(new VirtualTreeNode("folder1") { Tag = new Folder(null, "folder1") });
folders.Nodes.Add(new VirtualTreeNode("folder2") { Tag = new Folder(null, "folder2") });
// set the 2 folders to be the selected nodes.
_tv.SelectedNodes.SetContents(new VirtualTreeNode[] { folders.Nodes[0], folders.Nodes[1] });
// now build up a new nodes tree
VirtualTreeNode newRootNode = new VirtualTreeNode(Branding.BRAND_CONSOLE);
VirtualTreeNode newFolders = new VirtualTreeNode("Folders") { Tag = foldersTag };
newRootNode.Nodes.Add(newFolders);
newFolders.Nodes.Add(new VirtualTreeNode("folder1a") { Tag = new Folder(null, "folder1a") });
newFolders.Nodes.Add(new VirtualTreeNode("folder2a") { Tag = new Folder(null, "folder2a") });
int count = 0;
EventHandler handler = delegate
{
count++;
Assert.AreEqual(1, _tv.SelectedNodes.Count, "There should only be one node selected.");
Assert.AreEqual("Folders", _tv.SelectedNodes[0].Text, "The Folders node should be selected.");
};
_tv.SelectionsChanged += handler;
try
{
// merge the new node tree in.
_tv.BeginUpdate();
_tv.UpdateRootNodes(new VirtualTreeNode[] { newRootNode });
_tv.EndUpdate();
Assert.GreaterOrEqual(count, 1, "SelectionsChanged should fire.");
}
finally
{
_tv.SelectionsChanged -= handler;
}
}
private static List <VirtualTreeNode> GetParents(VirtualTreeNode node)
{
List <VirtualTreeNode> parents = new List <VirtualTreeNode>();
VirtualTreeNode nn = node.Parent;
while (nn != null)
{
parents.Add(nn);
nn = nn.Parent;
}
parents.Reverse();
return(parents);
}
private bool ObjectExistsUnder(Object o, VirtualTreeNode parent)
{
foreach (VirtualTreeNode child in parent.Nodes)
{
if (child.Tag == o)
{
return(true);
}
if (ObjectExistsUnder(o, child))
{
return(true);
}
}
return(false);
}
public VirtualTreeNode FindNodeIn(VirtualTreeNode match, Object o)
{
if (match.Tag == o)
{
return(match);
}
foreach (VirtualTreeNode child in match.Nodes)
{
VirtualTreeNode result = FindNodeIn(child, o);
if (result != null)
{
return(result);
}
}
return(null);
}
public new void EndUpdate()
{
base.EndUpdate();
int hPos = HScrollPos;
VirtualTreeNode restoredTopNode = ClosestMatch(_persistedTopNode);
if (restoredTopNode != TopNode)
{
TopNode = restoredTopNode;
// Restore the scroll position...
// Setting TopNode alters _both_ scrollbars. This sets the vertical one to the old position
// and the horizontal one to a different one depending on the width on the TopNode.
HScrollPos = hPos;
}
// Restore the selection...
if (_persistedSelectionInfo == null || _persistedSelectionInfo.Count == 0)
{
SelectedNode = Nodes[0];
}
else
{
RestoreSelection();
}
// if the selected nodes haven't change, but the selected tags have
// then a selections changed event still needs to be fired.
foreach (VirtualTreeNode node in SelectedNodes)
{
VirtualTreeNode.PersistenceInfo info = new VirtualTreeNode.PersistenceInfo(node);
if (!_persistedSelectionInfo.Contains(info))
{
// selection is different to old one. So fire an event.
ForceSelectionsChanged();
break;
}
}
}
/// <summary>
/// Find the maximal sub-tree under which the object appears only once
/// </summary>
/// <param name="me"></param>
/// <param name="o"></param>
/// <returns></returns>
private VirtualTreeNode MaximalSubTree(VirtualTreeNode me, Object o)
{
if (me.Parent == null)
{
return(me);
}
foreach (VirtualTreeNode sibling in me.Parent.Nodes)
{
if (sibling == me)
{
continue;
}
if (ObjectExistsUnder(o, sibling))
{
return(me);
}
}
return(MaximalSubTree(me.Parent, o));
}
public DragDropCrossPoolMoveHaltedVMCommand(IMainWindow mainWindow, VirtualTreeNode targetNode, IDataObject dragData)
: base(mainWindow, targetNode, dragData)
{
}
private void UpdateNode(VirtualTreeNode src, VirtualTreeNode dest, ref bool doneBeginUpdate)
{
if (dest.ImageIndex != src.ImageIndex)
{
DoBeginUpdateIfRequired(ref doneBeginUpdate);
dest.ImageIndex = src.ImageIndex;
}
if (dest.SelectedImageIndex != src.SelectedImageIndex)
{
DoBeginUpdateIfRequired(ref doneBeginUpdate);
dest.SelectedImageIndex = src.SelectedImageIndex;
}
if (dest.Text != src.Text)
{
LogTreeView("Overwriting " + src.Text + " with " + dest.Text);
DoBeginUpdateIfRequired(ref doneBeginUpdate);
dest.Text = src.Text;
}
if (dest.Tag != src.Tag)
{
dest.Tag = src.Tag;
}
if (dest.NodeFont != src.NodeFont)
{
DoBeginUpdateIfRequired(ref doneBeginUpdate);
dest.NodeFont = src.NodeFont;
}
if (dest.BackColor != src.BackColor)
{
DoBeginUpdateIfRequired(ref doneBeginUpdate);
dest.BackColor = src.BackColor;
}
if (dest.ForeColor != src.ForeColor)
{
DoBeginUpdateIfRequired(ref doneBeginUpdate);
dest.ForeColor = src.ForeColor;
}
if (dest.Name != src.Name)
{
DoBeginUpdateIfRequired(ref doneBeginUpdate);
dest.Name = src.Name;
}
if (dest.ShowCheckBox != src.ShowCheckBox)
{
DoBeginUpdateIfRequired(ref doneBeginUpdate);
dest.ShowCheckBox = src.ShowCheckBox;
}
if (dest.Checked != src.Checked)
{
DoBeginUpdateIfRequired(ref doneBeginUpdate);
dest.Checked = src.Checked;
}
}
protected sealed override void OnAfterSelect(TreeViewEventArgs e)
{
VirtualTreeNode node = (VirtualTreeNode)e.Node;
OnAfterSelect(new VirtualTreeViewEventArgs(node, e.Action));
}
/// <summary>
/// Initializes a new instance of the <see cref="SelectedItem"/> class.
/// </summary>
/// <param name="groupingTag">The grouping tag that is selected.</param>
public SelectedItem(GroupingTag groupingTag, VirtualTreeNode rootNode)
{
_groupingTag = groupingTag;
_rootNode = rootNode;
}
/// <summary>
/// Grey out all the folders from the given node downwards.
/// </summary>
private static void GreyAll(VirtualTreeNode node)
{
Folder folder = node.Tag as Folder;
if (folder != null)
{
folder.Grey = true;
node.SelectedImageIndex = (int)Icons.FolderGrey;
node.ImageIndex = node.SelectedImageIndex;
foreach (VirtualTreeNode child in node.Nodes)
{
GreyAll(child);
}
}
}
private VirtualTreeNode FindNode(string tag, VirtualTreeNode node)
{
Folder folder = node.Tag as Folder;
if (folder != null && folder.opaque_ref == tag)
return node;
foreach (VirtualTreeNode subNode in node.Nodes)
{
VirtualTreeNode found = FindNode(tag, subNode);
if (found != null)
return found;
}
return null;
}
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;
result.NodeFont = Program.DefaultFont;
}
else if (grayed)
{
result.BackColor = _treeViewBackColor;
result.ForeColor = SystemColors.GrayText;
result.NodeFont = Program.DefaultFont;
}
else
{
result.BackColor = _treeViewBackColor;
result.ForeColor = _treeViewForeColor;
result.NodeFont = Program.DefaultFont;
}
return result;
}
public VirtualTreeViewEventArgs(VirtualTreeNode node)
{
Util.ThrowIfParameterNull(node, "node");
_node = node;
}
public VirtualTreeViewEventArgs(VirtualTreeNode node, TreeViewAction action)
: this(node)
{
_action = action;
}
public DragDropMigrateVMCommand(IMainWindow mainWindow, VirtualTreeNode targetNode, IDataObject dragData)
: base(mainWindow, targetNode, dragData)
{
}
/// <summary>
/// Used by Deserialize method for setting properties of VirtualTreeNode from xml node attributes
/// </summary>
/// <param name="node"></param>
/// <param name="propertyName"></param>
/// <param name="value"></param>
private void SetAttributeValue(VirtualTreeNode node, string propertyName, string value)
{
if (propertyName == XmlNodeTextAtt)
{
node.Text = value;
}
else if (propertyName == XmlNodeImageIndexAtt)
{
Icons icon = (Icons)Enum.Parse(typeof(Icons), value);
node.ImageIndex = (int)icon;
}
else if (propertyName == XmlNodeTagAtt)
{
node.Tag = value;
}
}
public void DeserializeTreeView(VirtualTreeView treeView, string fileName)
{
Util.ThrowIfParameterNull(treeView, "treeView");
Util.ThrowIfStringParameterNullOrEmpty(fileName, "fileName");
XmlTextReader reader = null;
try
{
// disabling re-drawing of treeview till all nodes are added
treeView.BeginUpdate();
reader =
new XmlTextReader(fileName);
VirtualTreeNode parentNode = null;
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.Name == XmlNodeTag)
{
VirtualTreeNode newNode = new VirtualTreeNode("");
bool isEmptyElement = reader.IsEmptyElement;
// loading node attributes
int attributeCount = reader.AttributeCount;
if (attributeCount > 0)
{
for (int i = 0; i < attributeCount; i++)
{
reader.MoveToAttribute(i);
SetAttributeValue(newNode, reader.Name, reader.Value);
}
}
// add new node to Parent Node or VirtualTreeView
if(parentNode != null)
parentNode.Nodes.Add(newNode);
else
treeView.Nodes.Add(newNode);
// making current node 'ParentNode' if its not empty
if (!isEmptyElement)
{
parentNode = newNode;
}
}
}
// moving up to in VirtualTreeView if end tag is encountered
else if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.Name == XmlNodeTag)
{
parentNode = parentNode.Parent;
}
}
else if (reader.NodeType == XmlNodeType.XmlDeclaration)
{ //Ignore Xml Declaration
}
else if (reader.NodeType == XmlNodeType.None)
{
return;
}
else if (reader.NodeType == XmlNodeType.Text)
{
parentNode.Nodes.Add(new VirtualTreeNode(reader.Value));
}
}
}
finally
{
// enabling redrawing of treeview after all nodes are added
treeView.EndUpdate();
reader.Close();
}
}
public VirtualTreeNode CreateNewRootNode(Search search, bool organizationalMode)
{
if (!organizationalMode)
{
Util.ThrowIfParameterNull(search, "search");
}
VirtualTreeNode newRootNode = new VirtualTreeNode("XenCenter");
MainWindowTreeNodeGroupAcceptor groupAcceptor = new MainWindowTreeNodeGroupAcceptor(_highlightedDragTarget, _treeViewForeColor, _treeViewBackColor, newRootNode);
if (organizationalMode)
{
OrganizationalView.PopulateOrganizationalView(groupAcceptor, search);
}
else
{
search.PopulateAdapters(groupAcceptor);
}
return newRootNode;
}
public VirtualNodeLabelEditEventArgs(VirtualTreeNode node, string label)
: this(node)
{
_label = label;
}
public VirtualTreeNodeMouseClickEventArgs(VirtualTreeNode node, MouseButtons button, int clicks, int x, int y)
: base(button, clicks, x, y, 0)
{
_node = node;
}
private static object GetGroupingTagFromNode(VirtualTreeNode node)
{
if (node == null)
return null;
GroupingTag gt = node.Tag as GroupingTag;
if (gt != null)
{
// gt.Grouping is OrganizationalView means that we're at the Tags/Types/Custom Fields level.
// Custom field keys are the next level down, and values are the one after that.
return gt.Grouping is OrganizationalView ? null : gt.Group;
}
return node.Tag;
}
protected sealed override void OnNodeMouseDoubleClick(TreeNodeMouseClickEventArgs e)
{
VirtualTreeNode node = (VirtualTreeNode)e.Node;
OnNodeMouseDoubleClick(new VirtualTreeNodeMouseClickEventArgs(node, e.Button, e.Clicks, e.X, e.Y));
}
public DragDropRemoveHostFromPoolCommand(IMainWindow mainWindow, VirtualTreeNode targetNode, IDataObject dragData)
: base(mainWindow, targetNode, dragData)
{
}
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);
}
/// <summary>
/// Adds the "Expand All" and "Collapse Children" expected items to the specified list for the specified node.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="expectedItems">The expected items to be added to.</param>
protected void AddExpectedExpandAndCollapseItems(VirtualTreeNode node, List<ExpectedMenuItem> expectedItems)
{
bool expandAll = false;
bool collapseChildren = false;
MW(delegate
{
expandAll = new List<VirtualTreeNode>(node.Descendants).Find(n => !n.IsExpanded) != null;
collapseChildren = new List<VirtualTreeNode>(node.Nodes).Find(n => n.Nodes.Count > 0 && n.IsExpanded) != null;
});
if (expandAll)
{
expectedItems.Add(new ExpectedTextMenuItem("E&xpand All", true));
}
if (collapseChildren)
{
expectedItems.Add(new ExpectedTextMenuItem("&Collapse Children", true));
}
}
public void TestNodeDeleteOnRootNodeUpdate()
{
_vtv.Nodes.Add(new VirtualTreeNode("root"));
_vtv.Nodes.Add(new VirtualTreeNode("root2"));
_vtv.Nodes.Add(new VirtualTreeNode("root3"));
_vtv.Nodes[0].Nodes.Add(new VirtualTreeNode("child"));
_vtv.Nodes[0].Nodes.Add(new VirtualTreeNode("child2"));
_vtv.Nodes[0].Nodes.Add(new VirtualTreeNode("child3"));
_vtv.Nodes[0].Nodes[0].Nodes.Add(new VirtualTreeNode("grandchild"));
_vtv.Nodes[0].Nodes[0].Nodes.Add(new VirtualTreeNode("grandchild2"));
_vtv.Nodes[0].Nodes[0].Nodes.Add(new VirtualTreeNode("grandchild3"));
_vtv.Nodes[0].Expand();
_vtv.Nodes[1].Expand();
_vtv.Nodes[2].Expand();
_vtv.Nodes[0].Nodes[0].Expand();
VirtualTreeNode newRoot = new VirtualTreeNode("newRoot");
newRoot.Nodes.Add(new VirtualTreeNode("newChild"));
newRoot.Nodes[0].Nodes.Add(new VirtualTreeNode("newGrandChild"));
_vtv.UpdateRootNodes(new VirtualTreeNode[] { newRoot });
Assert.AreEqual(1, _vtv.Nodes.Count);
Assert.AreEqual(1, _vtv.Nodes[0].Nodes.Count);
Assert.AreEqual(1, _vtv.Nodes[0].Nodes[0].Nodes.Count);
Assert.AreEqual(1, _tv.Nodes.Count);
Assert.AreEqual(1, _tv.Nodes[0].Nodes.Count);
Assert.AreEqual("newRoot", _tv.Nodes[0].Text);
Assert.AreEqual("newChild", _tv.Nodes[0].Nodes[0].Text);
Assert.AreEqual("newGrandChild", _tv.Nodes[0].Nodes[0].Nodes[0].Text);
}
public DragDropIntoFolderCommand(IMainWindow mainWindow, VirtualTreeNode targetNode, IDataObject dragData)
: base(mainWindow, targetNode, dragData)
{
}
public void TestUpdateWhenRemoveAllChildNodesOfExandedParent()
{
// this is a test for the bug shown in CA-34486 and CA-36409.
// When merging sets of tree-nodes using UpdateRootNodes, if you remove all of
// the child-nodes from a node, the node still remembers its IsExpanded state
// from before the nodes were removed regardless of whether you call Collapse()
// or Expand() after the nodes were removed.
// This causes problems for the Virtual treeview as it
// relies the BeforeExpanded event to convert DummyTreeNodes into VirtualTreeNodes
// on population.
VirtualTreeNode rootNode = new VirtualTreeNode("root");
rootNode.Nodes.Add(new VirtualTreeNode("child"));
rootNode.Nodes[0].Nodes.Add(new VirtualTreeNode("grandchild"));
rootNode.Nodes[0].Nodes[0].Nodes.Add(new VirtualTreeNode("grandgrandchild"));
_vtv.UpdateRootNodes(new VirtualTreeNode[] { rootNode });
_vtv.EndUpdate();
// expand all nodes so that all DummyNodes are replaced.
_vtv.ExpandAll();
// now merge with smaller tree
VirtualTreeNode rootNode2 = new VirtualTreeNode("root2");
rootNode2.Nodes.Add(new VirtualTreeNode("child2"));
rootNode2.Nodes[0].Nodes.Add(new VirtualTreeNode("grandchild2"));
_vtv.UpdateRootNodes(new VirtualTreeNode[] { rootNode2 });
_vtv.EndUpdate();
// collapse all so the next merge doesn't replace DummyNodes.
_vtv.CollapseAll();
// now re-merge with big tree
VirtualTreeNode rootNode3 = new VirtualTreeNode("root3");
rootNode3.Nodes.Add(new VirtualTreeNode("child3"));
rootNode3.Nodes[0].Nodes.Add(new VirtualTreeNode("grandchild3"));
rootNode3.Nodes[0].Nodes[0].Nodes.Add(new VirtualTreeNode("grandgrandchild3"));
_vtv.UpdateRootNodes(new VirtualTreeNode[] { rootNode3 });
_vtv.EndUpdate();
_vtv.Nodes[0].Expand();
_vtv.Nodes[0].Nodes[0].Expand();
Assert.IsFalse(_vtv.Nodes[0].Nodes[0].Nodes[0].IsExpanded, "Expanded state was remembered. It shouldn't be.");
}
/// <summary>
/// Initializes a new instance of the <see cref="SelectedItem"/> class.
/// </summary>
/// <param name="xenObject">The xen object that is selected.</param>
/// <param name="connection">The connection of the xen object.</param>
/// <param name="hostAncestor">The host ancestor of the xen object in the tree.</param>
/// <param name="poolAncestor">The pool ancestor of the xen object in the tree.</param>
/// <param name="groupAncestor">In Objects view this is the type under which
/// the object is grouped.</param>
public SelectedItem(IXenObject xenObject, IXenConnection connection, Host hostAncestor,
Pool poolAncestor, GroupingTag groupAncestor, VirtualTreeNode rootNode)
: this(xenObject, connection, hostAncestor, poolAncestor)
{
_groupAncestor = groupAncestor;
_rootNode = rootNode;
}
public VirtualTreeNode CreateNewRootNode(Search search, NavigationPane.NavigationMode mode)
{
IAcceptGroups groupAcceptor;
VirtualTreeNode newRootNode;
switch (mode)
{
case NavigationPane.NavigationMode.Objects:
newRootNode = viewObjects.RootNode;
groupAcceptor = CreateGroupAcceptor(_highlightedDragTarget, newRootNode);
viewObjects.Populate(search, groupAcceptor);
break;
case NavigationPane.NavigationMode.Tags:
newRootNode = viewTags.RootNode;
groupAcceptor = CreateGroupAcceptor(_highlightedDragTarget, newRootNode);
viewTags.Populate(search, groupAcceptor);
break;
case NavigationPane.NavigationMode.Folders:
newRootNode = viewFolders.RootNode;
groupAcceptor = CreateGroupAcceptor(_highlightedDragTarget, newRootNode);
viewFolders.Populate(search, groupAcceptor);
break;
case NavigationPane.NavigationMode.CustomFields:
newRootNode = viewFields.RootNode;
groupAcceptor = CreateGroupAcceptor(_highlightedDragTarget, newRootNode);
viewFields.Populate(search, groupAcceptor);
break;
case NavigationPane.NavigationMode.vApps:
newRootNode = viewVapps.RootNode;
groupAcceptor = CreateGroupAcceptor(_highlightedDragTarget, newRootNode);
viewVapps.Populate(search, groupAcceptor);
break;
case NavigationPane.NavigationMode.SavedSearch:
Util.ThrowIfParameterNull(search, "search");
newRootNode = new VirtualTreeNode(search.Name)
{
Tag = search,
ImageIndex = search.DefaultSearch
? (int)Icons.DefaultSearch
: (int)Icons.Search
};
groupAcceptor = CreateGroupAcceptor(_highlightedDragTarget, newRootNode);
search.PopulateAdapters(groupAcceptor);
break;
default://includes Infrastructure and Notifications
Util.ThrowIfParameterNull(search, "search");
newRootNode = new VirtualTreeNode("XenCenter") { ImageIndex = (int)Icons.Home };
groupAcceptor = CreateGroupAcceptor(_highlightedDragTarget, newRootNode);
search.PopulateAdapters(groupAcceptor);
break;
}
return newRootNode;
}
protected sealed override void OnBeforeDeselect(TreeViewEventArgs e)
{
VirtualTreeNode node = (VirtualTreeNode)e.Node;
OnBeforeDeselect(new VirtualTreeViewEventArgs(node));
}
/// <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();
}
}
private MainWindowTreeNodeGroupAcceptor CreateGroupAcceptor(object dragTarget, VirtualTreeNode parent)
{
return new MainWindowTreeNodeGroupAcceptor(dragTarget, _treeViewForeColor, _treeViewBackColor, parent);
}
public MainWindowTreeNodeGroupAcceptor(object highlightedDragTarget,
Color treeViewForeColor, Color treeViewBackColor, VirtualTreeNode parent)
{
_parent = parent;
_treeViewForeColor = treeViewForeColor;
_treeViewBackColor = treeViewBackColor;
_highlightedDragTarget = highlightedDragTarget;
}
public void TestAddSubtreeWithRootCollapsed()
{
_vtv.Nodes.Add(new VirtualTreeNode("root"));
// build subtree
VirtualTreeNode subTree = new VirtualTreeNode("firstChild");
subTree.Nodes.Add(new VirtualTreeNode("secondChild"));
subTree.Nodes[0].Nodes.Add(new VirtualTreeNode("thirdChild"));
// only expand secondChild
subTree.Nodes[0].Expand();
// now add subtree
_vtv.Nodes[0].Nodes.Add(subTree);
// root node should only have dummy
Assert.AreEqual(1, _tv.Nodes[0].Nodes.Count);
AssertNodeIsDummy(_tv.Nodes[0].Nodes[0]);
// in the virtual collections, the expanded states should still be correct
Assert.IsFalse(subTree.IsExpanded);
Assert.IsTrue(subTree.Nodes[0].IsExpanded);
Assert.IsFalse(subTree.Nodes[0].Nodes[0].IsExpanded);
// now expand the root node. only the first child should be visible
_vtv.Nodes[0].Expand();
Assert.AreEqual(1, _tv.Nodes[0].Nodes.Count);
Assert.AreEqual("firstChild", _tv.Nodes[0].Nodes[0].Text);
Assert.AreEqual(1, _tv.Nodes[0].Nodes[0].Nodes.Count);
AssertNodeIsDummy(_tv.Nodes[0].Nodes[0].Nodes[0]);
// now expand the first child, this should result in the secondChild AND thirdChild becoming visible (as secondChild was expanded before it was added to the treeview)
_vtv.Nodes[0].Nodes[0].Expand();
Assert.AreEqual(1, _tv.Nodes[0].Nodes[0].Nodes.Count);
Assert.AreEqual("secondChild", _tv.Nodes[0].Nodes[0].Nodes[0].Text);
Assert.AreEqual(1, _tv.Nodes[0].Nodes[0].Nodes[0].Nodes.Count);
Assert.AreEqual("thirdChild", _tv.Nodes[0].Nodes[0].Nodes[0].Nodes[0].Text);
}
public VirtualTreeViewCancelEventArgs(VirtualTreeNode node, bool cancel, TreeViewAction action)
: base(cancel)
{
_node = node;
_action = action;
}
public bool CanSelectNode(VirtualTreeNode node)
{
return(node.Tag == null || node.Tag is IXenObject || node.Tag is GroupingTag || node.Tag is Search);
}
public void RemoveAndReAddTest()
{
_vtv.Nodes.Add(new VirtualTreeNode("root"));
_vtv.Nodes[0].Nodes.Insert(0, new VirtualTreeNode("firstChild"));
VirtualTreeNode secondChild = new VirtualTreeNode("secondChild");
_vtv.Nodes[0].Nodes.Insert(1, secondChild);
// expand and then collapse root node
_vtv.Nodes[0].Expand();
_vtv.Nodes[0].Collapse();
// now remove secondChild
_vtv.Nodes[0].Nodes.RemoveAt(1);
// now re-add it
_vtv.Nodes.Add(secondChild);
Assert.AreEqual(1, _vtv.Nodes[0].Nodes.Count, "node wasn't removed.");
Assert.AreEqual(secondChild, _vtv.Nodes[1], "node wasn't re-added");
}
internal override Command CreateCommand()
{
PutInOrgView(ORGANIZATION_VIEW);
_node = GetAllTreeNodes().Find(delegate(VirtualTreeNode n)
{
GroupingTag groupingTag = n.Parent == null ? null : n.Parent.Tag as GroupingTag;
if (n.Tag is IXenObject && groupingTag != null && (string)groupingTag.Grouping.GroupingName == "Tags")
{
_tag = (string)groupingTag.Group;
return true;
}
return false;
});
MW(() => _node.EnsureVisible());
return new UntagCommand(Program.MainWindow.CommandInterface, new List<VirtualTreeNode> { _node });
}
public void TestSimpleRootNodeUpdateWhenCollapsed()
{
_vtv.Nodes.Add(new VirtualTreeNode("root"));
_vtv.Nodes[0].Nodes.Add(new VirtualTreeNode("child"));
VirtualTreeNode newRoot = new VirtualTreeNode("newRoot");
newRoot.Nodes.Add(new VirtualTreeNode("newChild"));
_vtv.UpdateRootNodes(new VirtualTreeNode[] { newRoot });
Assert.AreEqual(1, _vtv.Nodes.Count, "Virtual nodes weren't correctly updated.");
Assert.AreEqual(1, _vtv.Nodes[0].Nodes.Count, "Virtual nodes weren't correctly updated.");
Assert.AreEqual("newRoot", _vtv.Nodes[0].Text, "Virtual nodes weren't correctly updated.");
Assert.AreEqual("newChild", _vtv.Nodes[0].Nodes[0].Text, "Virtual nodes weren't correctly updated.");
Assert.AreEqual(1, _tv.Nodes.Count, "Nodes weren't correctly updated.");
Assert.AreEqual(1, _tv.Nodes[0].Nodes.Count, "Nodes weren't correctly updated.");
Assert.AreEqual("newRoot", _tv.Nodes[0].Text, "Nodes weren't correctly updated.");
AssertNodeIsDummy(_tv.Nodes[0].Nodes[0]);
}
