/// <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]); }