public void AddDocument(Canvas canvas) { NuGenTreeNode treeNode = new NuGenTreeNode(canvas.ParentTabPage.Text, true, true); treeNode.Tag = canvas; _documents.Nodes.Add(treeNode); }
/* * DoDrop */ /// <summary> /// Invokes service specific nodes merge operation. /// </summary> /// <exception cref="T:System.ArgumentNullException"><paramref name="selectedNodes"/> is <see langword="null"/>.</exception> public override void DoDrop(NuGenTreeNode targetTreeNode, List <NuGenTreeNode> selectedNodes, NuGenDropPosition dropPosition) { if (selectedNodes == null) { throw new ArgumentNullException("selectedNodes"); } if ( targetTreeNode == null || this.CheckSelectedContainTarget(targetTreeNode, selectedNodes) || !this.CheckParent(targetTreeNode, selectedNodes) ) { return; } switch (dropPosition) { case NuGenDropPosition.After: case NuGenDropPosition.Before: { this.MoveNodes(targetTreeNode, selectedNodes, dropPosition); break; } case NuGenDropPosition.Inside: { this.InsertNodes(targetTreeNode, this.RetrieveInsertable(selectedNodes)); break; } } }
/* * Add */ private void Add(TreeNode parent) { string nodeText = Resources.Text_TreeNodeCollectionEditor_node; TreeNode node = new NuGenTreeNode(nodeText + _nextNodeIndex.ToString(CultureInfo.InvariantCulture)); node.Name = node.Text; if (parent == null) { _treeView.Nodes.Add(node); } else { parent.Nodes.Add(node); parent.Expand(); } _nextNodeIndex++; if (parent != null) { _treeView.SelectedNode = parent; } else { _treeView.SelectedNode = node; this.SetNodeProps(node); } }
/* * Add */ private void Add(TreeNode parent) { TreeNode node = null; string nodeText = Resources.Text_TreeNodeCollectionEditor_node; if (parent == null) { int num1; this.NextNode = (num1 = this.NextNode) + 1; int num2 = num1; node = new NuGenTreeNode(nodeText + num2.ToString(CultureInfo.InvariantCulture)); _treeView.Nodes.Add(node); node.Name = node.Text; } else { int num3; this.NextNode = (num3 = this.NextNode) + 1; int num4 = num3; node = new NuGenTreeNode(nodeText + num4.ToString(CultureInfo.InvariantCulture)); parent.Nodes.Add(node); node.Name = node.Text; parent.Expand(); } if (parent != null) { _treeView.SelectedNode = parent; } else { _treeView.SelectedNode = node; this.SetNodeProps(node); } }
/// <summary> /// </summary> /// <param name="treeNodeToCheck">Can be <see langword="null"/>.</param> /// <returns></returns> public bool Contains(NuGenTreeNode treeNodeToCheck) { NuGenContainsItemRequestedEventArgs eventArgs = new NuGenContainsItemRequestedEventArgs(treeNodeToCheck); this.OnContainsNodeRequested(eventArgs); return(eventArgs.ContainsNode); }
/// <summary> /// </summary> /// <param name="treeNodeToAdd"></param> /// <returns></returns> /// <exception cref="T:System.ArgumentNullException"> /// <paramref name="treeNodeToAdd"/> is <see langword="null"/>. /// </exception> public int AddNode(NuGenTreeNode treeNodeToAdd) { NuGenAddTreeNodeEventArgs eventArgs = new NuGenAddTreeNodeEventArgs(treeNodeToAdd); this.OnNodeAdded(eventArgs); return(eventArgs.TreeNodeIndex); }
public void ConstructorTest() { _treeNode = new NuGenTreeNode(); Assert.AreEqual(-1, _treeNode.ImageIndex); Assert.AreEqual(-1, _treeNode.SelectedImageIndex); Assert.AreEqual(-1, _treeNode.ExpandedImageIndex); Assert.AreEqual("", _treeNode.Text); Assert.IsTrue(_treeNode.HasCheckBox); Assert.IsFalse(_treeNode.Checked); bool hasCheckBox = false; bool isChecked = true; _treeNode = new NuGenTreeNode( _nodeText, hasCheckBox, isChecked, _imageIndex, _expandedImageIndex ); Assert.AreEqual(_nodeText, _treeNode.Text); Assert.AreEqual(_imageIndex, _treeNode.ImageIndex); Assert.AreEqual(_imageIndex, _treeNode.SelectedImageIndex); Assert.AreEqual(_expandedImageIndex, _treeNode.ExpandedImageIndex); Assert.AreEqual(_imageIndex, _treeNode.DefaultImageIndex); Assert.IsFalse(_treeNode.HasCheckBox); Assert.IsTrue(_treeNode.Checked); }
public void ConstructorTest() { this.treeNode = new NuGenTreeNode(); Assert.AreEqual(-1, this.treeNode.ImageIndex); Assert.AreEqual(-1, this.treeNode.SelectedImageIndex); Assert.AreEqual(-1, this.treeNode.ExpandedImageIndex); Assert.AreEqual("", this.treeNode.Text); Assert.IsTrue(this.treeNode.HasCheckBox); Assert.IsFalse(this.treeNode.Checked); string nodeText = "Node Text"; int imageIndex = 1; int expandedImageIndex = 2; bool hasCheckBox = false; bool isChecked = true; this.treeNode = new NuGenTreeNode( nodeText, hasCheckBox, isChecked, imageIndex, expandedImageIndex ); Assert.AreEqual(nodeText, this.treeNode.Text); Assert.AreEqual(imageIndex, this.treeNode.ImageIndex); Assert.AreEqual(imageIndex, this.treeNode.SelectedImageIndex); Assert.AreEqual(expandedImageIndex, this.treeNode.ExpandedImageIndex); Assert.AreEqual(imageIndex, this.treeNode.DefaultImageIndex); Assert.IsFalse(this.treeNode.HasCheckBox); Assert.IsTrue(this.treeNode.Checked); }
public void ConstructorTest() { _treeNode = new NuGenTreeNode(); Assert.AreEqual(-1, _treeNode.ImageIndex); Assert.AreEqual(-1, _treeNode.SelectedImageIndex); Assert.AreEqual(-1, _treeNode.ExpandedImageIndex); Assert.AreEqual("", _treeNode.Text); Assert.IsTrue(_treeNode.HasCheckBox); Assert.IsFalse(_treeNode.Checked); bool hasCheckBox = false; bool isChecked = true; _treeNode = new NuGenTreeNode( _nodeText, hasCheckBox, isChecked, _imageIndex, _expandedImageIndex ); Assert.AreEqual(_nodeText, _treeNode.Text); Assert.AreEqual(_imageIndex, _treeNode.ImageIndex); Assert.AreEqual(_imageIndex, _treeNode.SelectedImageIndex); Assert.AreEqual(_expandedImageIndex, _treeNode.ExpandedImageIndex); Assert.AreEqual(_imageIndex, _treeNode.DefaultImageIndex); Assert.IsFalse(_treeNode.HasCheckBox); Assert.IsTrue(_treeNode.Checked); }
public void ConstructorTest() { this.treeNode = new NuGenTreeNode(); Assert.AreEqual(-1, this.treeNode.ImageIndex); Assert.AreEqual(-1, this.treeNode.SelectedImageIndex); Assert.AreEqual(-1, this.treeNode.ExpandedImageIndex); Assert.AreEqual("", this.treeNode.Text); Assert.IsTrue(this.treeNode.HasCheckBox); Assert.IsFalse(this.treeNode.Checked); string nodeText = "Node Text"; int imageIndex = 1; int expandedImageIndex = 2; bool hasCheckBox = false; bool isChecked = true; this.treeNode = new NuGenTreeNode( nodeText, hasCheckBox, isChecked, imageIndex, expandedImageIndex ); Assert.AreEqual(nodeText, this.treeNode.Text); Assert.AreEqual(imageIndex, this.treeNode.ImageIndex); Assert.AreEqual(imageIndex, this.treeNode.SelectedImageIndex); Assert.AreEqual(expandedImageIndex, this.treeNode.ExpandedImageIndex); Assert.AreEqual(imageIndex, this.treeNode.DefaultImageIndex); Assert.IsFalse(this.treeNode.HasCheckBox); Assert.IsTrue(this.treeNode.Checked); }
/* * AddFolder */ /// <summary> /// </summary> /// <exception cref="T:System.ArgumentNullException"> /// <paramref name="folderNodeToAdd"/> is <see langword="null"/>. /// </exception> public void AddFolder(NuGenFolderTreeNode folderNodeToAdd) { if (folderNodeToAdd == null) { throw new ArgumentNullException("folderNodeToAdd"); } NuGenTreeNode selectedNode = (NuGenTreeNode)this.SelectedNode; if (selectedNode != null && selectedNode.Parent != null) { if ( selectedNode.Parent is NuGenTaskTreeNodeBase && ((NuGenTaskTreeNodeBase)selectedNode.Parent).IsRemovable ) { selectedNode.Parent.Nodes.AddNode(folderNodeToAdd); } else { this.Nodes.AddNode(folderNodeToAdd); } } else { this.Nodes.AddNode(folderNodeToAdd); } this.SelectedNode = folderNodeToAdd; this.OnFolderAdded(EventArgs.Empty); this.OnEventToBeDelayed(new NuGenTaskAddedEventArgs(folderNodeToAdd.Text)); }
public void SetUp() { this.dragService = new NuGenTreeViewDragDropService(); this.treeView = new NuGenTreeView(); this.treeNode = new NuGenTreeNode(); this.treeView.Nodes.Add(this.treeNode); }
public void SetUp() { this.dragService = new NuGenTreeViewDragDropService(); this.treeView = new NuGenTreeView(); this.treeNode = new NuGenTreeNode(); this.treeView.Nodes.Add(this.treeNode); }
public void ContainsTest() { NuGenTreeNode treeNodeToCheck = new NuGenTreeNode(); this.treeNode.Nodes.AddNode(treeNodeToCheck); Assert.IsTrue(this.treeNode.Nodes.Contains(treeNodeToCheck)); Assert.IsFalse(this.treeNode.Nodes.Contains(null)); }
public TreeNodeCollectionHandler(NuGenTreeNode treeNode) { if (treeNode == null) { Assert.Fail("treeNode cannot be null."); } this.treeNode = treeNode; }
public TreeNodeCollectionHandler(NuGenTreeNode treeNode) { if (treeNode == null) { Assert.Fail("treeNode cannot be null."); } this.treeNode = treeNode; }
private void _samplesTreeView_AfterSelect(object sender, TreeViewEventArgs e) { this.SuspendLayout(); NuGenTreeNode treeNode = e.Node as NuGenTreeNode; if (treeNode != null) { SampleDescriptor sampleDescriptor = treeNode.Tag as SampleDescriptor; if (sampleDescriptor != null) { _runButton.Enabled = sampleDescriptor.ExeIsAvailable; _csSampleButton.Enabled = sampleDescriptor.CsProjectIsAvailable; _vbSampleButton.Enabled = sampleDescriptor.VbProjectIsAvailable; _browseButton.Enabled = sampleDescriptor.SamplePath != null; _exePath = sampleDescriptor.ExePath; _csProjectPath = sampleDescriptor.CsProjectPath; _vbProjectPath = sampleDescriptor.VbProjectPath; _samplePath = sampleDescriptor.SamplePath; if (sampleDescriptor.DescriptionIsAvailable) { using (StreamReader sr = new StreamReader(sampleDescriptor.DescriptionPath)) { try { _descriptionTextBox.Text = sr.ReadToEnd(); } catch (IOException) { _descriptionTextBox.Text = ""; } catch (OutOfMemoryException) { _descriptionTextBox.Text = ""; } } } if (sampleDescriptor.ImageIsAvailable) { if (_imagePictureBox.Image != null) { _imagePictureBox.Image.Dispose(); _imagePictureBox.Image = null; } _imagePictureBox.Image = Image.FromFile(sampleDescriptor.ImagePath); } } } this.ResumeLayout(); }
public void DeleteTaskTest() { NuGenTreeNode treeNode = new NuGenTreeNode(); this._TaskTreeView.Nodes.AddNode(treeNode); Assert.AreEqual(this._InitialCount + 1, this._TaskTreeView.Nodes.Count); this._TaskTreeView.DeleteTask(treeNode); Assert.AreEqual(this._InitialCount, this._TaskTreeView.Nodes.Count); }
public void FirstNodeInvalidExceptionTest() { TreeNode firstNode = new TreeNode(); NuGenTreeNode secondNode = new NuGenTreeNode(); (this.treeNode as TreeNode).Nodes.Add(firstNode); this.treeNode.Nodes.AddNode(secondNode); Assert.IsNotNull(this.treeNode.FirstNode); }
public void FirstNodeTest() { NuGenTreeNode firstNode = new NuGenTreeNode(); NuGenTreeNode secondNode = new NuGenTreeNode(); this.treeNode.Nodes.AddNode(firstNode); this.treeNode.Nodes.AddNode(secondNode); Assert.AreEqual(firstNode, this.treeNode.FirstNode); }
public void FirstNodeTest() { NuGenTreeNode firstNode = new NuGenTreeNode(); NuGenTreeNode secondNode = new NuGenTreeNode(); this.treeNode.Nodes.AddNode(firstNode); this.treeNode.Nodes.AddNode(secondNode); Assert.AreEqual(firstNode, this.treeNode.FirstNode); }
public void FirstNodeInvalidExceptionTest() { TreeNode firstNode = new TreeNode(); NuGenTreeNode secondNode = new NuGenTreeNode(); (this.treeNode as TreeNode).Nodes.Add(firstNode); this.treeNode.Nodes.AddNode(secondNode); Assert.IsNotNull(this.treeNode.FirstNode); }
/// <summary> /// </summary> /// <param name="serviceProvider"><para>Requires:</para> /// <para><see cref="ISampleFolder"/></para></param> /// <param name="treeView"></param> /// <param name="folderImageIndex"></param> /// <param name="expandedFolderImageIndex"></param> /// <param name="sampleImageIndex"></param> /// <exception cref="ArgumentNullException"> /// <para><paramref name="serviceProvider"/> is <see langword="null"/>.</para> /// -or- /// <para><paramref name="treeView"/> is <see langword="null"/>.</para> /// </exception> public void PopulateSampleTree( INuGenServiceProvider serviceProvider , NuGenTreeView treeView , int folderImageIndex , int expandedFolderImageIndex , int sampleImageIndex ) { if (serviceProvider == null) { throw new ArgumentNullException("serviceProvider"); } if (treeView == null) { throw new ArgumentNullException("treeView"); } ISampleFolderDescriptor sampleFolder = serviceProvider.GetService <ISampleFolderDescriptor>(); Debug.Assert(sampleFolder != null, "sampleFolder != null"); DirectoryInfo sampleDirInfo = new DirectoryInfo(sampleFolder.Path); Debug.Write("Scanning \""); Debug.Write(sampleDirInfo.FullName); Debug.WriteLine("\" folder..."); if (!sampleDirInfo.Exists) { Trace.Write("Sample directory does not exist."); return; } DirectoryInfo[] samples = sampleDirInfo.GetDirectories(); Debug.WriteLine("Getting the list of sub-directories..."); Debug.WriteLineIf(samples != null, "samples.Length = " + samples.Length.ToString()); if (samples != null) { Debug.WriteLine("Looping through the sub-directories..."); foreach (DirectoryInfo dirInfo in samples) { NuGenTreeNode treeNode = new NuGenTreeNode(dirInfo.Name, folderImageIndex, expandedFolderImageIndex); treeView.Nodes.Add(treeNode); Debug.Write("Examining \""); Debug.Write(dirInfo.FullName); Debug.WriteLine("\" sub-directory..."); this.BuildSampleTreeNode(sampleFolder, dirInfo, treeNode, folderImageIndex, expandedFolderImageIndex, sampleImageIndex); } } }
public void IndexerTest() { NuGenTreeNode childNode = new NuGenTreeNode(); NuGenTreeNode childNode2 = new NuGenTreeNode(); this.treeNode.Nodes.AddNode(childNode); this.treeNode.Nodes.AddNode(childNode2); Assert.AreEqual(childNode, this.treeNode.Nodes[0]); Assert.AreEqual(childNode2, this.treeNode.Nodes[1]); }
public void RemoveSelectedNodeTest() { NuGenTreeNode node = new NuGenTreeNode(); this.selectionService.AddSelectedNode(node, Keys.None, MouseButtons.Left); this.selectionService.RemoveSelectedNode(node); Assert.AreEqual(0, this.selectionService.SelectedNodes.Count); this.selectionService.RemoveSelectedNode(null); }
/// <summary> /// </summary> /// <param name="treeNodeToRemove"></param> /// <exception cref="T:System.ArgumentNullException"> /// <paramref name="treeNodeToRemove"/> is <see langword="null"/>. /// </exception> public void RemoveNode(NuGenTreeNode treeNodeToRemove) { if (treeNodeToRemove == null) { throw new ArgumentNullException("treeNodeToRemove"); } else { this.OnNodeRemoved(new NuGenRemoveTreeNodeEventArgs(treeNodeToRemove)); } }
/// <summary> /// </summary> /// <param name="indexToInsertAt"></param> /// <param name="treeNodeToInsert"></param> /// <exception cref="T:System.ArgumentNullException"> /// <paramref name="treeNodeToInsert"/> is <see langword="null"/>. /// </exception> public void InsertNode(int indexToInsertAt, NuGenTreeNode treeNodeToInsert) { if (treeNodeToInsert == null) { throw new ArgumentNullException("treeNodeToInsert"); } else { this.OnNodeInserted(new NuGenAddTreeNodeEventArgs(treeNodeToInsert, indexToInsertAt)); } }
public void SetUp() { _treeView = new NuGenTreeView(); _treeNode = new NuGenTreeNode("Root", false); _nodes = new NuGenTreeNode[] { new NuGenTreeNode(), new NuGenTreeNode(), new NuGenTreeNode() }; }
public void SetUp() { _treeView = new NuGenTreeView(); _treeNode = new NuGenTreeNode("Root", false); _nodes = new NuGenTreeNode[] { new NuGenTreeNode(), new NuGenTreeNode(), new NuGenTreeNode() }; }
public void AddRangeTest() { NuGenTreeNode node = new NuGenTreeNode(); NuGenTreeNode node2 = new NuGenTreeNode(); NuGenTreeNode[] treeNodeRange = new NuGenTreeNode[] { node, node2 }; this.treeNode.Nodes.AddNodeRange(treeNodeRange); Assert.AreEqual(2, this.treeNode.Nodes.Count); Assert.AreEqual(node, this.treeNode.Nodes[0]); Assert.AreEqual(node2, this.treeNode.Nodes[1]); }
public void InsideTaskDoDropTest() { NuGenTreeNode sourceNode = this._TaskTreeView.Nodes[1]; List <NuGenTreeNode> selectedNodes = new List <NuGenTreeNode>(); selectedNodes.Add(sourceNode); this._DropService.DoDrop(this._TaskTreeView.Nodes[13], selectedNodes, NuGenDropPosition.Inside); Assert.AreEqual(this._InitialCount + 20, this._TaskTreeView.Nodes.Count); Assert.AreEqual(10, sourceNode.Nodes.Count); }
public void Constructor2Test() { NuGenTreeNode treeNode = new NuGenTreeNode(_nodeText, _nodes); Assert.AreEqual(3, treeNode.Nodes.Count); try { treeNode = new NuGenTreeNode(_nodeText, null); Assert.Fail(); } catch (ArgumentNullException) { } }
public void MultilevelShiftSelectionTest() { Keys pressedKeys = Keys.Shift; MouseButtons pressedMouseButtons = MouseButtons.Left; NuGenTreeNode node = this.treeView.Nodes[0].Nodes[2]; NuGenTreeNode node2 = this.treeView.Nodes[1].Nodes[3]; this.selectionService.AddSelectedNode(node, pressedKeys, pressedMouseButtons); this.selectionService.AddSelectedNode(node2, pressedKeys, pressedMouseButtons); Assert.AreEqual(1, this.selectionService.SelectedNodes.Count); Assert.AreEqual(node, this.selectionService.SelectedNodes[0]); }
public void SimpleControlSelectionTest() { Keys pressedKeys = Keys.Control; MouseButtons pressedMouseButtons = MouseButtons.Left; NuGenTreeNode node = this.treeView.Nodes[0]; NuGenTreeNode node2 = this.treeView.Nodes[5]; this.selectionService.AddSelectedNode(node, pressedKeys, pressedMouseButtons); this.selectionService.AddSelectedNode(node2, pressedKeys, pressedMouseButtons); Assert.AreEqual(2, this.selectionService.SelectedNodes.Count); Assert.AreEqual(node, this.selectionService.SelectedNodes[0]); Assert.AreEqual(node2, this.selectionService.SelectedNodes[1]); }
public void Constructor3Test() { NuGenTreeNode treeNode = new NuGenTreeNode(_nodeText, _imageIndex, _expandedImageIndex, _nodes); Assert.AreEqual(3, treeNode.Nodes.Count); try { treeNode = new NuGenTreeNode(_nodeText, _imageIndex, _expandedImageIndex, null); Assert.Fail(); } catch (ArgumentNullException) { } }
public void NoneKeysClearsSelection() { Keys pressedKeys = Keys.Shift; MouseButtons pressedMouseButtons = MouseButtons.Left; this.selectionService.AddSelectedNode(this.treeView.Nodes[0], pressedKeys, pressedMouseButtons); this.selectionService.AddSelectedNode(this.treeView.Nodes[3], pressedKeys, pressedMouseButtons); NuGenTreeNode node = this.treeView.Nodes[4]; this.selectionService.AddSelectedNode(node, Keys.None, pressedMouseButtons); Assert.AreEqual(1, this.selectionService.SelectedNodes.Count); Assert.AreEqual(node, this.selectionService.SelectedNodes[0]); }
public void AfterDoDropTest() { NuGenTreeNode sourceNode = this._TaskTreeView.Nodes[1]; List <NuGenTreeNode> selectedNodes = new List <NuGenTreeNode>(); selectedNodes.Add(sourceNode); NuGenTreeNode targetNode = this._TaskTreeView.Nodes[2]; this._DropService.DoDrop(targetNode, selectedNodes, NuGenDropPosition.After); Assert.AreEqual(1, targetNode.Index); Assert.AreEqual(3, sourceNode.Index); }
public void ParentNullInsideFolderDoDropTest() { List <NuGenTreeNode> selectedNodes = new List <NuGenTreeNode>(); for (int i = 10; i < 13; i++) { selectedNodes.Add(this._TaskTreeView.Nodes[i]); } NuGenTreeNode targetNode = this._TaskTreeView.Nodes[1]; this._DropService.DoDrop(targetNode, selectedNodes, NuGenDropPosition.Inside); Assert.AreEqual(this._InitialCount + 17, this._TaskTreeView.Nodes.Count); Assert.AreEqual(13, targetNode.Nodes.Count); }
public void EventTest() { TreeNodeCollectionEventSink eventSink = new TreeNodeCollectionEventSink(this.treeNodeCollection); NuGenTreeNode toAddNode = new NuGenTreeNode(); NuGenTreeNode toInsertNode = new NuGenTreeNode(); eventSink.ExpectedClearRequestedCount = 1; eventSink.ExpectedContainsNodeRequestedCount = 2; eventSink.ExpectedCountRequestedCount = 1; eventSink.ExpectedEnumeratorRequestsCount = 1; eventSink.ExpectedNodeByIndexAdjustedCount = 1; eventSink.ExpectedNodeByIndexRequestedCount = 1; eventSink.ExpectedNodeAddedCount = 2; eventSink.ExpectedNodeRangeAddedCount = 1; eventSink.ExpectedNodeInsertedCount = 1; eventSink.ExpectedNodeRemovedCount = 2; eventSink.AddExpectedContainsNodeRequested(toAddNode); eventSink.AddExpectedContainsNodeRequested(toInsertNode); eventSink.AddExpectedNodeAdded(toAddNode); eventSink.AddExpectedNodeAdded(toInsertNode); eventSink.AddExpectedNodeAdded(toAddNode); eventSink.AddExpectedNodeRangeAdded(new NuGenTreeNode[] { toAddNode, toInsertNode }); eventSink.AddExpectedNodeRemoved(toAddNode); eventSink.AddExpectedNodeRemoved(toInsertNode); this.treeNodeCollection.AddNode(toAddNode); this.treeNodeCollection.InsertNode(0, toInsertNode); this.treeNodeCollection.AddNode(toAddNode); this.treeNodeCollection.AddNodeRange(new NuGenTreeNode[] { toAddNode, toInsertNode }); this.treeNodeCollection.RemoveNode(toAddNode); this.treeNodeCollection.RemoveNode(toInsertNode); this.treeNodeCollection.GetEnumerator(); this.treeNodeCollection.Contains(toAddNode); this.treeNodeCollection.Contains(toInsertNode); Assert.AreEqual(0, this.treeNodeCollection.Count); Assert.AreEqual(null, this.treeNodeCollection[0]); this.treeNodeCollection[0] = null; this.treeNodeCollection.Clear(); eventSink.Verify(); }
public static void PopulateMultilevel(NuGenTreeView treeViewToPopulate, int levelCount, int nodeCount) { if (treeViewToPopulate == null) { Assert.Fail("treeViewToPopulate cannot be null."); } for (int level = 0; level < levelCount; level++) { NuGenTreeNode treeNode = new NuGenTreeNode(); treeViewToPopulate.Nodes.Add(treeNode); for (int node = 0; node < nodeCount; node++) { treeNode.Nodes.Add(new NuGenTreeNode()); } } }
public void CompareTest() { NuGenTreeNode mTreeNode = new NuGenTreeNode("m"); NuGenTreeNode dTreeNode = new NuGenTreeNode("d"); NuGenTreeNode cTreeNode = new NuGenTreeNode("c"); NuGenTreeNode kTreeNode = new NuGenTreeNode("k"); int mTodCompareResult = mTreeNode.Text.CompareTo(dTreeNode.Text); int kTomCompareResult = kTreeNode.Text.CompareTo(mTreeNode.Text); int dTocCompareResult = dTreeNode.Text.CompareTo(cTreeNode.Text); Assert.Greater(mTodCompareResult, 0); Assert.Less(kTomCompareResult, 0); Assert.Greater(dTocCompareResult, 0); Assert.AreEqual(mTodCompareResult, this.comparer.Compare(mTreeNode, dTreeNode)); Assert.AreEqual(kTomCompareResult, this.comparer.Compare(kTreeNode, mTreeNode)); Assert.AreEqual(dTocCompareResult, this.comparer.Compare(dTreeNode, cTreeNode)); }
public void AZSortTest() { NuGenTreeNode mTreeNode = new NuGenTreeNode("m"); NuGenTreeNode dTreeNode = new NuGenTreeNode("d"); NuGenTreeNode cTreeNode = new NuGenTreeNode("c"); NuGenTreeNode kTreeNode = new NuGenTreeNode("k"); this.treeView.Nodes.AddNode(mTreeNode); this.treeView.Nodes.AddNode(dTreeNode); this.treeView.Nodes.AddNode(cTreeNode); this.treeView.Nodes.AddNode(kTreeNode); Assert.AreEqual(mTreeNode, this.treeView.Nodes[0]); Assert.AreEqual(dTreeNode, this.treeView.Nodes[1]); Assert.AreEqual(cTreeNode, this.treeView.Nodes[2]); Assert.AreEqual(kTreeNode, this.treeView.Nodes[3]); this.sorter.Sort(this.treeView.Nodes, new NuGenAZTreeNodeComparer()); Assert.AreEqual(cTreeNode, this.treeView.Nodes[0]); Assert.AreEqual(dTreeNode, this.treeView.Nodes[1]); Assert.AreEqual(kTreeNode, this.treeView.Nodes[2]); Assert.AreEqual(mTreeNode, this.treeView.Nodes[3]); }
/* * Add */ private void Add(TreeNode parent) { TreeNode node = null; string nodeText = Resources.Text_TreeNodeCollectionEditor_node; if (parent == null) { int num1; this.NextNode = (num1 = this.NextNode) + 1; int num2 = num1; node = new NuGenTreeNode(nodeText + num2.ToString(CultureInfo.InvariantCulture)); _treeView.Nodes.Add(node); node.Name = node.Text; } else { int num3; this.NextNode = (num3 = this.NextNode) + 1; int num4 = num3; node = new NuGenTreeNode(nodeText + num4.ToString(CultureInfo.InvariantCulture)); parent.Nodes.Add(node); node.Name = node.Text; parent.Expand(); } if (parent != null) { _treeView.SelectedNode = parent; } else { _treeView.SelectedNode = node; this.SetNodeProps(node); } }
/// <summary> /// Initializes a new instance of the <see cref="NuGenIndexedTreeNodeEventArgs"/> class. /// </summary> public NuGenIndexedTreeNodeEventArgs(int treeNodeIndex, NuGenTreeNode treeNode) { this.treeNodeIndex = treeNodeIndex; this.treeNode = treeNode; }
public void ContainsTest() { NuGenTreeNode treeNodeToCheck = new NuGenTreeNode(); this.treeNode.Nodes.AddNode(treeNodeToCheck); Assert.IsTrue(this.treeNode.Nodes.Contains(treeNodeToCheck)); Assert.IsFalse(this.treeNode.Nodes.Contains(null)); }
/// <summary> /// </summary> /// <param name="indexToInsertAt"></param> /// <param name="treeNodeToInsert"></param> /// <exception cref="T:System.ArgumentNullException"> /// <paramref name="treeNodeToInsert"/> is <see langword="null"/>. /// </exception> public void InsertNode(int indexToInsertAt, NuGenTreeNode treeNodeToInsert) { if (treeNodeToInsert == null) { throw new ArgumentNullException("treeNodeToInsert"); } else { this.OnNodeInserted(new NuGenAddTreeNodeEventArgs(treeNodeToInsert, indexToInsertAt)); } }
/// <summary> /// </summary> /// <param name="treeNodeToRemove"></param> /// <exception cref="T:System.ArgumentNullException"> /// <paramref name="treeNodeToRemove"/> is <see langword="null"/>. /// </exception> public void RemoveNode(NuGenTreeNode treeNodeToRemove) { if (treeNodeToRemove == null) { throw new ArgumentNullException("treeNodeToRemove"); } else { this.OnNodeRemoved(new NuGenRemoveTreeNodeEventArgs(treeNodeToRemove)); } }
/// <summary> /// </summary> /// <exception cref="T:System.ArgumentNullException"> /// <paramref name="treeNodeRangeToAdd"/> is <see langword="null"/>. /// </exception> public void AddNodeRange(NuGenTreeNode[] treeNodeRangeToAdd) { this.OnNodeRangeAdded(new NuGenAddTreeNodeRangeEventArgs(treeNodeRangeToAdd)); }
/// <summary> /// </summary> /// <param name="treeNodeToCheck">Can be <see langword="null"/>.</param> /// <returns></returns> public bool Contains(NuGenTreeNode treeNodeToCheck) { NuGenContainsItemRequestedEventArgs eventArgs = new NuGenContainsItemRequestedEventArgs(treeNodeToCheck); this.OnContainsNodeRequested(eventArgs); return eventArgs.ContainsNode; }
/// <summary> /// Initializes a new instance of the <see cref="NuGenAddTreeNodeEventArgs"/> class.<para/> /// TreeNodeIndex = 0. /// </summary> public NuGenAddTreeNodeEventArgs(NuGenTreeNode treeNodeToAdd) : this(treeNodeToAdd, 0) { }
/// <summary> /// Initializes a new instance of the <see cref="NuGenContainsItemRequestedEventArgs"/> class. /// </summary> public NuGenContainsItemRequestedEventArgs(NuGenTreeNode nodeToCheck) { this.nodeToCheck = nodeToCheck; }
public void RemoveSelectedNodeTest() { NuGenTreeNode node = new NuGenTreeNode(); this.selectionService.AddSelectedNode(node, Keys.None, MouseButtons.Left); this.selectionService.RemoveSelectedNode(node); Assert.AreEqual(0, this.selectionService.SelectedNodes.Count); this.selectionService.RemoveSelectedNode(null); }
public void AddRangeTest() { NuGenTreeNode node = new NuGenTreeNode(); NuGenTreeNode node2 = new NuGenTreeNode(); NuGenTreeNode[] treeNodeRange = new NuGenTreeNode[] { node, node2 }; this.treeNode.Nodes.AddNodeRange(treeNodeRange); Assert.AreEqual(2, this.treeNode.Nodes.Count); Assert.AreEqual(node, this.treeNode.Nodes[0]); Assert.AreEqual(node2, this.treeNode.Nodes[1]); }
public void SetUp() { this.treeView = new NuGenTreeView(); this.treeNode = new NuGenTreeNode("Root", false); }
public void AddExpectedNodeRemoved(NuGenTreeNode treeNode) { this.nodeRemoved.AddExpected(treeNode); }
public void AddExpectedContainsNodeRequested(NuGenTreeNode treeNode) { this.containsNodeRequested.AddExpected(treeNode); }
/* * Add */ private void Add(TreeNode parent) { string nodeText = Resources.Text_TreeNodeCollectionEditor_node; TreeNode node = new NuGenTreeNode(nodeText + _nextNodeIndex.ToString(CultureInfo.InvariantCulture)); node.Name = node.Text; if (parent == null) { _treeView.Nodes.Add(node); } else { parent.Nodes.Add(node); parent.Expand(); } _nextNodeIndex++; if (parent != null) { _treeView.SelectedNode = parent; } else { _treeView.SelectedNode = node; this.SetNodeProps(node); } }
/// <summary> /// </summary> /// <param name="treeNodeToAdd"></param> /// <returns></returns> /// <exception cref="T:System.ArgumentNullException"> /// <paramref name="treeNodeToAdd"/> is <see langword="null"/>. /// </exception> public int AddNode(NuGenTreeNode treeNodeToAdd) { NuGenAddTreeNodeEventArgs eventArgs = new NuGenAddTreeNodeEventArgs(treeNodeToAdd); this.OnNodeAdded(eventArgs); return eventArgs.TreeNodeIndex; }
/// <summary> /// Initializes a new instance of the <see cref="NuGenAddTreeNodeEventArgs"/> class. /// </summary> public NuGenAddTreeNodeEventArgs(NuGenTreeNode treeNodeToAdd, int treeNodeIndex) { _treeNodeToAdd = treeNodeToAdd; _treeNodeIndex = treeNodeIndex; }
public void IndexerTest() { NuGenTreeNode childNode = new NuGenTreeNode(); NuGenTreeNode childNode2 = new NuGenTreeNode(); this.treeNode.Nodes.AddNode(childNode); this.treeNode.Nodes.AddNode(childNode2); Assert.AreEqual(childNode, this.treeNode.Nodes[0]); Assert.AreEqual(childNode2, this.treeNode.Nodes[1]); }