/// <summary> /// Eine vorher Exportierte Xml Datei wieder in ein TreeView importieren /// </summary> /// <param name="path">Der Quellpfad der Xml Datei</param> /// <param name="treeView">Ein TreeView in dem der Inhalt der Xml Datei wieder angezeigt werden soll</param> /// <exception cref="FileNotFoundException">gibt an das die Datei nicht gefunden werden konnte</exception> public void XmlToTreeView(String path, TreeView treeView) { xmlDocument = new XmlDocument(); xmlDocument.Load(path); treeView.Nodes.Clear(); ElementList = new ArrayList(); TreeNode treeNode; treeNode = new TreeNode("skin"); treeView.Nodes.Add(treeNode); rootNode = treeNode.GetHashCode(); sElementList element = new sElementList(rootNode, 0, treeNode, xmlDocument.DocumentElement/*.ParentNode*/); ElementList.Add(element); XmlRekursivImport(treeNode.Nodes, xmlDocument.DocumentElement.ChildNodes); }
/// <summary> /// Checks if the TreeNode supplied is disabled or not. /// Note that passing in null as the TreeNode will result in false being returned. /// Note that being disabled means that BackColor and ForeColor has changed to give the TreeNode the appearance of being disabled. /// A whole TreeView can be disabled without the particular TreeNode supplied to this function returning true (as in being disabled). /// </summary> /// <param name="tn">TreeNode that should be checked if it is disabled or not.</param> /// <returns>True if supplied TreeNode is disabled or false otherwise.</returns> public bool IsTreeNodeDisabled(TreeNode tn) { bool bRetVal = false; if(tn != null) { if(htDisabledTreeNodes != null) { if(htDisabledTreeNodes.Contains(tn.GetHashCode())) { bRetVal = true; } } } return bRetVal; }
/// <summary> /// Get the MWTreeNodeWrapper that contains the supplied TreeNode if it exists in the Disabled MWTreeNodeWrapper Hashtable. /// </summary> /// <param name="tn">TreeNode for which to return an MWTreeNodeWrapper.</param> /// <returns>The MWTreeNodeWrapper that contains the supplied TreeNode if it exists in the Disabled MWTreeNodeWrapper Hashtable or null otherwise.</returns> public MWTreeNodeWrapper GetDisabledMWTreeNodeWrapper(TreeNode tn) { MWTreeNodeWrapper mwtnw = null; if(IsTreeNodeDisabled(tn)) { mwtnw = htDisabledTreeNodes[tn.GetHashCode()] as MWTreeNodeWrapper; } return mwtnw; }
/// <summary> /// Change the ForeColor of a TreeNode. /// This method handles selected as well as unselected TreeNodes. /// </summary> /// <param name="tn">TreeNode to change the ForeColor of.</param> /// <param name="cForeColor">Color to change the supplied TreeNode's ForeColor to.</param> public void ChangeForeColor(TreeNode tn, Color cForeColor) { if(tn != null) { if(this.IsTreeNodeSelected(tn)) { MWTreeNodeWrapper mwtnw = this.SelNodes[tn.GetHashCode()] as MWTreeNodeWrapper; if(mwtnw != null) { mwtnw.ForeColor = cForeColor; if( !this.Enabled && !this.UseExtendedDisabledColors || this.Enabled && (this.Focused || !this.HideSelection) || this.Enabled && !this.Focused && this.HideSelection) { mwtnw.Node.ForeColor = cForeColor; } } } else { if(!this.Enabled) { MWTreeNodeWrapper mwtnw = GetDisabledMWTreeNodeWrapper(tn); if(mwtnw != null) { mwtnw.Enable(); htDisabledTreeNodes.Remove(tn.GetHashCode()); } tn.ForeColor = cForeColor; DisableNode(tn); } else { tn.ForeColor = cForeColor; } } } }
/// <summary> /// Remove a TreeNode to the SelNodes property. /// </summary> /// <param name="tn">TreeNode to remove from the SelNodes property.</param> /// <param name="bTriggerEvents">True if calling this method should raise the OnBeforeSelNodesRemove and OnAfterSelNodesRemove events or false otherwise.</param> /// <returns>True if the TreeNode is actually removed or false otherwise.</returns> private bool SelNodesRemove(TreeNode tn, bool bTriggerEvents) { bool bRetVal = false; if(this.IsTreeNodeSelected(tn)) { MWCancelEventArgs e = new MWCancelEventArgs(this.SelNodes, tn); if(bTriggerEvents) { OnBeforeSelNodesRemove(e); } if(!e.Cancel) { MWTreeNodeWrapper.Deselect(this.SelNodes[tn.GetHashCode()] as MWTreeNodeWrapper); this.SelNodes.Remove(tn.GetHashCode()); if(bTriggerEvents) { OnAfterSelNodesRemove(new MWControlSuite.MWPropertyEventArgs(tn)); } bRetVal = true; } } return bRetVal; }
/// <summary> /// Enable TreeNode supplied. /// </summary> /// <param name="tn">TreeNode to enable.</param> private void EnableNode(TreeNode tn) { MWTreeNodeWrapper mwtnw = GetDisabledMWTreeNodeWrapper(tn); if(mwtnw != null) { EnableNode(mwtnw); htDisabledTreeNodes.Remove(tn.GetHashCode()); } }
/// <summary> /// Delete the supplied TreeNode from the SelNodes property, the CheckedNodes property and/or the SelNode property. /// </summary> /// <param name="tn">TreeNode to delete.</param> private void DeleteNode(TreeNode tn) { foreach(TreeNode tnChild in tn.Nodes) { DeleteNode(tnChild); } if(tn != null) { if(IsTreeNodeSelected(tn)) { if(this.SelNodes != null) { this.SelNodes.Remove(tn.GetHashCode()); } } if(IsTreeNodeChecked(tn)) { if(this.CheckedNodes != null) { this.CheckedNodes.Remove(tn.GetHashCode()); } } if(this.SelNode != null && this.SelNode == tn) { this.SelNode = null; } } }
/// <summary> /// Remove a TreeNode to the CheckedNodes property. /// </summary> /// <param name="tn">TreeNode to remove from the CheckedNodes property.</param> /// <param name="bTriggerEvents">True if calling this method should raise the OnBeforeCheckedNodesAdd and OnAfterCheckedNodesAdd events or false otherwise.</param> /// <returns>True if the TreeNode is actually removed or false otherwise.</returns> private bool CheckedNodesRemove(TreeNode tn, bool bTriggerEvents) { bool bRetVal = false; if(this.IsTreeNodeChecked(tn)) { MWCancelEventArgs e = new MWCancelEventArgs(this.CheckedNodes, tn); if(bTriggerEvents) { OnBeforeCheckedNodesRemove(e); } if(!e.Cancel) { this.CheckedNodes.Remove(tn.GetHashCode()); if(bTriggerEvents) { OnAfterCheckedNodesRemove(new MWControlSuite.MWPropertyEventArgs(tn)); } bRetVal = true; } } return bRetVal; }
/// <summary> /// Function used to update the background color of the selected node in the treeview /// </summary> public bool HighlightPickedGeometryNode(TreeNode ViewNode, GeometryNode node) { if (ViewNode == null) return false; if (ViewNode.Text == "GeometryNode") { int key = ViewNode.GetHashCode(); List<PropertyValue> pvlist = (List<PropertyValue>)PropertyValueTable[key]; foreach (PropertyValue pv in pvlist) { if (pv.Property == "ID" && pv.Value == node.ID.ToString()) { ViewNode.BackColor = System.Drawing.Color.Blue; return true; } } } foreach (TreeNode ChildNode in ViewNode.Nodes) { if (HighlightPickedGeometryNode(ChildNode, node)) return true; } return false; }
/// <summary> /// Recursive Function for drawing the SceneGraph tree structure. /// </summary> private Pair EvenInorderTraverseTree(TreeNode Head, int depth, int[] index, Graphics formgraphics, Pen mypen, SolidBrush myBrush, float NodeWidth, float NodeHeight, float WidthBetweenNodes, float HeightBetweenNodes, float XOffset, float YOffset, bool textEnabled) { int max; // Determing the x-coordinate (index[depth]) at the current depth by examining the x-coordinate values at [depth-1] and [depth+1] if (depth > 0) { max = index[depth - 1] - 1; } else { max = index[depth]; } max = (max < index[depth]) ? index[depth] : max; max = (max < index[depth + 1]) ? index[depth + 1] : max; index[depth] = max + 1; // High and low variables are used to store the extremities of the subtree starting from the current node. int high, low; if (Head.Nodes.Count > 0) { low = 10000; high = -1; } else { low = index[depth]; high = index[depth]; } Pair[] retval = new Pair[Head.Nodes.Count]; int counter = 0; foreach (TreeNode child in Head.Nodes) { retval[counter] = EvenInorderTraverseTree(child, depth + 1, index, formgraphics, mypen, myBrush, NodeWidth, NodeHeight, WidthBetweenNodes, HeightBetweenNodes, XOffset, YOffset, textEnabled); if (retval[counter].end > high) high = retval[counter].end; if (retval[counter].start < low) low = retval[counter].start; counter++; } // update the index[depth] (current x-coordinate) index[depth] = (high + low) / 2; mypen.Color = System.Drawing.Color.Black; for (int i = 0; i < counter; i++) formgraphics.DrawLine(mypen, new PointF(((high + low) / 2 * WidthBetweenNodes) + XOffset + NodeWidth / 2, (depth * HeightBetweenNodes) + YOffset + NodeHeight), new PointF(((retval[i].start + retval[i].end) / 2 * WidthBetweenNodes) + XOffset + NodeWidth / 2, ((depth + 1) * HeightBetweenNodes) + YOffset)); // highlighting the node, if it is the currentselected node if (Head == CurrentSelectedTreeNode) { myBrush.Color = System.Drawing.Color.Black; formgraphics.FillRectangle(myBrush, ((high + low) / 2 * WidthBetweenNodes) + XOffset, (depth * HeightBetweenNodes) + YOffset, NodeWidth, NodeHeight); } // Coloring the nodes based on the node types myBrush.Color = SGNodeDefaultColor; for (int i = 0; i < SGNodeNames.Length; i++) { if (Head.Text.StartsWith(SGNodeNames[i])) { myBrush.Color = SGNodeColors[i]; break; } } // if the node is either invisible (red) or currently selected node (blue) then use similar coloring of the geometry nodes even for the corresponding graphical display nodes if (Head.BackColor == System.Drawing.Color.Red || Head.BackColor == System.Drawing.Color.Blue) { myBrush.Color = Head.BackColor; } formgraphics.FillEllipse(myBrush, ((high + low) / 2 * WidthBetweenNodes) + XOffset, (depth * HeightBetweenNodes) + YOffset, NodeWidth, NodeHeight); // writing the string "NodeName(NodeID)" on the graphical display node if (textEnabled) { string nodeString = ""; int key = Head.GetHashCode(); string nodeName = "", nodeID = null; List<PropertyValue> pvlist = (List<PropertyValue>)PropertyValueTable[key]; foreach (PropertyValue pv in pvlist) { if (pv.Property == "Name") { nodeName = pv.Value; } if (pv.Property == "ID") { nodeID = pv.Value; } } nodeString = nodeName; if (nodeID != null) nodeString += "(" + nodeID + ")"; if (nodeString != "") { float FontSize = 8.0f; Font stringFont = new Font(FontFamily.GenericSansSerif, FontSize); SizeF stringSize = formgraphics.MeasureString(nodeString, stringFont); while (stringSize.Width > WidthBetweenNodes / 2 + NodeWidth / 2) { FontSize -= 0.5f; stringFont = new Font(FontFamily.GenericSansSerif, FontSize); stringSize = formgraphics.MeasureString(nodeString, stringFont); } float XPosition = ((high + low) / 2 * WidthBetweenNodes) + XOffset + (NodeWidth / 2.0f) - (stringSize.Width / 2.0f); float YPosition = (depth * HeightBetweenNodes) + YOffset + (NodeHeight / 2.0f) - (stringSize.Height / 2.0f); myBrush.Color = System.Drawing.Color.Black; formgraphics.FillRectangle(myBrush, new RectangleF(XPosition - 1, YPosition - 1, stringSize.Width + 2, stringSize.Height + 2)); myBrush.Color = System.Drawing.Color.White; formgraphics.DrawString(nodeString, stringFont, myBrush, new PointF(XPosition, YPosition)); } } else { // ******** workaround ********* // store the x and y coordinates of a graphical display node in the corresponding TreeNode name property // this information is used when a mouse click event is triggered on the panel displaying the structure, the entire TreeView is searched using this stored info and it is matched against the clicked mouse coordinates. Head.Name = "" + (((high + low) / 2 * WidthBetweenNodes) + XOffset) + "," + ((depth * HeightBetweenNodes) + YOffset); } return new Pair(low, high); }
public void EncapsulationCwTree() { foreach (KeyValuePair<string, IList<BinInformation>> pair in base.m_anaCWFile.CWFileInfo.CellBinInfoDic) { TreeNode child = this.m_MeasurementNode.ChildNode(pair.Key); if (child == null) { child = new TreeNode(pair.Key); this.m_MeasurementNode.AddChildNodeToParent(this.m_MeasurementNode.RootNode, child); } TreeNode node2 = new TreeNode(base.m_anaCWFile.CWFileInfo.FileName); MeasurementView.IDCreator++; node2.Tag = MeasurementView.IDCreator; string text = base.m_anaCWFile.CWFileInfo.FileName + node2.GetHashCode(); base.m_anaCWFile.CWFileInfo.FileNameIdentifier = text; node2.Name = text; this.m_MeasurementNode.AddChildNodeToParent(child, node2); CWFileInformation item = new CWFileInformation(); item.FileNameIdentifier = text; item.FileName = base.m_anaCWFile.CWFileInfo.FileName; item.BinInfoHeader = base.m_anaCWFile.CWFileInfo.BinInfoHeader; item.CellBinInfoDic.Add(pair.Key, pair.Value); item.CellInfo = base.m_anaCWFile.CWFileInfo.CellInfo; item.AntennaPara = base.m_anaCWFile.CWFileInfo.AntennaPara; this.m_cwFileInfoList.Add(item); base.m_AddedTreeNodes.Add(node2); } }
/// <summary> /// Preserves the nodes color. /// </summary> /// <param name="tn">Node to check.</param> private void PreserveNodeColors(TreeNode tn) { if (tn == null) return; if (!htblSelectedNodesOrigColors.ContainsKey(tn.GetHashCode())) { htblSelectedNodesOrigColors.Add(tn.GetHashCode(), new Color[] { tn.BackColor, tn.ForeColor }); } }
//生成文件方法 private void fileGenerate() { DoubleClickButton button1 = new DoubleClickButton(); button1.ImageList = this.imageList1; button1.ImageIndex = 1; button1.Size = new System.Drawing.Size(88, 77); button1.DoubleClick += new System.EventHandler(fileClicked); button1.Location = new System.Drawing.Point(3, 3); button1.TabIndex = 0; String btText = ""; //button1.Tag = btText; button1.Name = "file" + fileIndex; button1.Text = "新建文件" + fileIndex; fileIndex++; button1.Font = new System.Drawing.Font("微软雅黑", 7.5F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); button1.TextAlign = System.Drawing.ContentAlignment.BottomCenter; button1.TextImageRelation = System.Windows.Forms.TextImageRelation.ImageAboveText; button1.Margin = new System.Windows.Forms.Padding(7); button1.UseVisualStyleBackColor = true; button1.FlatStyle = System.Windows.Forms.FlatStyle.Flat; button1.FlatAppearance.BorderColor = System.Drawing.Color.White; button1.FlatStyle = FlatStyle.Flat; //样式 button1.ForeColor = Color.Transparent; //前景 button1.BackColor = Color.Transparent; //去背景 button1.FlatAppearance.BorderSize = 0; //去边线 button1.FlatAppearance.MouseDownBackColor = System.Drawing.Color.Transparent; button1.FlatAppearance.MouseOverBackColor = System.Drawing.Color.Transparent; //button1.ForeColor = System.Drawing.Color.Transparent; button1.ForeColor = System.Drawing.Color.Black; button1.Padding = new System.Windows.Forms.Padding(0); button1.ContextMenuStrip = this.文件右键菜单; System.Windows.Forms.TreeNode treeNode2 = new System.Windows.Forms.TreeNode(button1.Text); //treeNode2.ContextMenuStrip = this.文件右键菜单; //treeNode2.Tag = button1; button1.Tag = treeNode2; treeNode2.Tag = btText; treeNode2.ImageIndex = 2; treeNode2.SelectedImageIndex = 2; //foreach (TreeNode nodes in treeView1.Nodes) //{ // if (nodes.Name == "root") //判断符合条件的节点 // { // nodes.Nodes.Add(treeNode2); // } //} pathForNow.Nodes.Add(treeNode2); //this.treeView1.Nodes.Add(treeNode2); Hashtable folderForNow = (Hashtable)pathForNow.Tag; folderForNow.Add(button1.Name, button1); this.flowLayoutPanel1.Controls.Add(button1); for (int i = 2; i < 128; i++) { if (listView1.Items[i].SubItems[1].Text.Equals("0")) { fat[i] = treeNode2.GetHashCode() - 1; listView1.Items[i].SubItems[1].Text = "255"; break; } } treeView1.ExpandAll(); }
//生成文件夹方法 private void folderGenerate() { treeView1.LabelEdit = false;//不可编辑 DoubleClickButton button1 = new DoubleClickButton(); button1.Name = "folder" + folderIndex; button1.Text = "新建文件夹" + folderIndex; folderIndex++; button1.ImageList = this.imageList1; button1.ImageKey = "64x64.png"; //button1.Image = global::test4.Properties.Resources.folder; button1.Location = new System.Drawing.Point(3, 3); //button1.Name = "button1"; button1.Size = new System.Drawing.Size(88, 77); //button1.Size = new System.Drawing.Size(78, 77); button1.Font = new System.Drawing.Font("微软雅黑", 7.5F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); //button1.Size = new System.Drawing.Size(59, 68); //button1.Size = new System.Drawing.Size(103, 120); button1.TabIndex = 0; //button1.Text = "新建文件夹"; button1.TextAlign = System.Drawing.ContentAlignment.BottomCenter; button1.TextImageRelation = System.Windows.Forms.TextImageRelation.ImageAboveText; //button1.TextImageRelation = System.Windows.Forms.TextImageRelation.ImageAboveText; button1.UseVisualStyleBackColor = true; button1.FlatStyle = System.Windows.Forms.FlatStyle.Flat; button1.FlatAppearance.BorderColor = System.Drawing.Color.White; button1.FlatStyle = FlatStyle.Flat; //样式 button1.BackColor = Color.Transparent; //去背景 button1.FlatAppearance.BorderSize = 0; //去边线 button1.FlatAppearance.MouseDownBackColor = System.Drawing.Color.Transparent; button1.FlatAppearance.MouseOverBackColor = System.Drawing.Color.Transparent; button1.ForeColor = System.Drawing.Color.Black; button1.Padding = new System.Windows.Forms.Padding(0); button1.ContextMenuStrip = this.文件右键菜单; System.Windows.Forms.TreeNode treeNode2 = new System.Windows.Forms.TreeNode(button1.Text); treeNode2.ImageIndex = 0; treeNode2.SelectedImageIndex = 0; //treeNode2.ContextMenuStrip = this.文件右键菜单; //treeNode2.Tag = button1; button1.Tag = treeNode2; //button1.Tag = treeNode2; Hashtable folderContains = new Hashtable(); treeNode2.Tag = folderContains; //this.button5.ImageKey = "64x64.png"; //this.button5.ImageList = this.imageList1; //this.button5.Location = new System.Drawing.Point(3, 3); //this.button5.Name = "button5"; //this.button5.Size = new System.Drawing.Size(59, 68); //this.button5.TabIndex = 0; //this.button5.Text = "button5"; //this.button5.TextAlign = System.Drawing.ContentAlignment.BottomCenter; //this.button5.TextImageRelation = System.Windows.Forms.TextImageRelation.ImageAboveText; //this.button5.UseVisualStyleBackColor = true; //DoubleClickButton button2 = new DoubleClickButton(); //button2.Name = "folder11" ; //button2.Text = "新建文件夹11"; //DoubleClickButton button3 = new DoubleClickButton(); //button3.Name = "folder111"; //button3.Text = "新建文件夹111"; //folderContains.Add(1, button2); //folderContains.Add(2, button3); //button1.Tag = folderContains; //foreach (TreeNode nodes in treeView1.Nodes) //{ // if (nodes.Name == "root") //判断符合条件的节点 // { // nodes.Nodes.Add(treeNode2); // } //} pathForNow.Nodes.Add(treeNode2); button1.DoubleClick += new System.EventHandler(folderClicked); //fileList.Add(button1); //mainHash.Add(button1.Name, button1); Hashtable folderForNow = (Hashtable)pathForNow.Tag; folderForNow.Add(button1.Name, button1); this.flowLayoutPanel1.Controls.Add(button1); for (int i = 2; i < 128; i++) { if (listView1.Items[i].SubItems[1].Text.Equals("0")) { fat[i] = treeNode2.GetHashCode(); listView1.Items[i].SubItems[1].Text = "255"; break; } } //this.treeView1.treeNode1.Nodes.add treeView1.ExpandAll(); }
private void CatListRecurse(XmlTextReader aReader, Object aRootNode) { String inner = aReader.ReadInnerXml(); NameTable nt = new NameTable(); XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt); XmlParserContext ctxt = new XmlParserContext(null, nsmgr, null, XmlSpace.None); XmlTextReader reader2 = new XmlTextReader(inner, XmlNodeType.Element, ctxt); TreeNode node; while (reader2.Read()) { if (reader2.NodeType == XmlNodeType.Element) { switch (reader2.LocalName) { case "panel": // Tree node with children. Retrieve label and id. Label is // used for visual presentation, id is hashed against node // and is used as a key when looking for which panel to // load. String[] values = new String[2] {"", ""}; String[] names = new String[2] {"label", "id"}; for (int i = 0; i < names.Length; ++i) { if (reader2.MoveToAttribute(names[i]) && reader2.ReadAttributeValue()) values[i] = reader2.Value; reader2.MoveToElement(); } node = new TreeNode(values[0], 0, 0); if (aRootNode is TreeView) { TreeView rootView = aRootNode as TreeView; rootView.Nodes.Add(node); } else if (aRootNode is TreeNode) { TreeNode rootNode = aRootNode as TreeNode; rootNode.Nodes.Add(node); } mNodes.Add(node.GetHashCode(), values[1]); CatListRecurse(reader2, node); break; } } } }
private void XmlRekursivImport(TreeNodeCollection elem, XmlNodeList xmlNodeList) { TreeNode treeNode; foreach (XmlNode myXmlNode in xmlNodeList) { //if (myXmlNode.Attributes != null) { if (myXmlNode.Name == "output" || myXmlNode.Name == "colors" || myXmlNode.Name == "fonts" || myXmlNode.Name == "windowstyle") continue; if(myXmlNode.Name == "#whitespace") continue; String name = myXmlNode.Name; if (myXmlNode.Attributes != null && myXmlNode.Attributes["name"] != null) name += " - " + myXmlNode.Attributes["name"].Value; String ext = XmlElementStringLookup(myXmlNode.Name); if (ext.Length > 0) { if (myXmlNode.Attributes != null && myXmlNode.Attributes[ext] != null) name += " : " + myXmlNode.Attributes[ext].Value; else name += " " + myXmlNode.Value; } treeNode = new TreeNode(name/*Attributes["value"].Value*/); if (myXmlNode.ChildNodes.Count > 0) { XmlRekursivImport(treeNode.Nodes, myXmlNode.ChildNodes); } elem.Add(treeNode); sElementList element = new sElementList(treeNode.GetHashCode(), treeNode.Parent.GetHashCode(), treeNode, myXmlNode); ElementList.Add(element); } } }
/// <summary> /// (Un)selects the specified node. /// </summary> /// <param name="tn">Node to (un)select.</param> /// <param name="select">True to select node, false to unselect node.</param> /// <param name="tva">Specifies the action that caused the selection change.</param> /// <returns>True if node was selected, false if not.</returns> private bool SelectNode(TreeNode tn, bool select, TreeViewAction tva) { bool blnSelected = false; if (tn == null) return false; if (select) { // Only try to select node if it was not already selected if (!IsNodeSelected(tn)) { // Check if node selection is cancelled TreeViewCancelEventArgs tvcea = new TreeViewCancelEventArgs(tn, false, tva); base.OnBeforeSelect(tvcea); if (tvcea.Cancel) { // This node selection was cancelled! return false; } PreserveNodeColors(tn); tn.BackColor = SelectionBackColor; // GKM moved from above tn.ForeColor = BackColor; // GKM moved from above htblSelectedNodes.Add(tn.GetHashCode(), tn); blnSelected = true; blnSelectionChanged = true; base.OnAfterSelect(new TreeViewEventArgs(tn, tva)); } tnMostRecentSelectedNode = tn; } else { // Only unselect node if it was selected if (IsNodeSelected(tn)) { OnBeforeDeselect(tn); Color[] originalColors = (Color[])this.htblSelectedNodesOrigColors[tn.GetHashCode()]; if (originalColors != null) { htblSelectedNodes.Remove(tn.GetHashCode()); blnSelectionChanged = true; htblSelectedNodesOrigColors.Remove(tn.GetHashCode()); // GKM - Restore original node colors tn.BackColor = originalColors[0]; // GKM - was BackColor; tn.ForeColor = originalColors[1]; // GKM - was ForeColor; } OnAfterDeselect(tn); } } return blnSelected; }
/// <summary> /// Checks if the TreeNode supplied is selected or not. /// Note that passing in null as the TreeNode will result in false being returned. /// </summary> /// <param name="tn">TreeNode that should be checked if it is selected or not.</param> /// <returns>True if supplied TreeNode is selected or false otherwise.</returns> public bool IsTreeNodeSelected(TreeNode tn) { bool bRetVal = false; if (tn != null) { if (MultiSelect == TreeViewMultiSelect.NoMulti) { if (SelectedNode == tn) { bRetVal = true; } } else { if (SelNodes != null) { if (SelNodes.Contains(tn.GetHashCode())) { bRetVal = true; } } } } return bRetVal; }
/// <summary> /// Deactivate TreeNode supplied. /// Deactivating means removing higlighting ('lowlighting'). /// </summary> /// <param name="tn">TreeNode that should be deactivated.</param> private void DeactivateSelNode(TreeNode tn) { if(tn != null) { MWTreeNodeWrapper mwtnw = this.SelNodes[tn.GetHashCode()] as MWTreeNodeWrapper; if(mwtnw != null) { DeactivateSelNode(mwtnw); } } }
/// <summary> /// Select TreeNode supplied. /// Note that all selected TreeNodes can be found in the SelNodes property and the most recently selected TreeNode can be found in the SelNode property. /// </summary> /// <param name="tn">TreeNode to select.</param> /// <param name="bChangeSelNode">True if the SelNode property should be changed when selecting the TreeNode.</param> /// <returns>True if the SelNode property was changed to the TreeNode supplied (even if the SelNode property was already set to the TreeNode supplied before this method was called).</returns> public bool SelectNode(TreeNode tn, bool bChangeSelNode) { bool bRetVal = false; if (tn != null) { switch (MultiSelect) { case TreeViewMultiSelect.NoMulti: if (SelNodes.Count > 1) { ClearSelNodes(); } SelectedNode = tn; SelNodeInt = SelectedNode; break; case TreeViewMultiSelect.Multi: if (!IsTreeNodeSelected(tn) && IsSelectNodeRegExSatisfied(tn.Text)) { if (SelNodes == null) { SelNodes = new Hashtable(); } SelNodes.Add(tn.GetHashCode(), new MWTreeNodeWrapper(tn)); HighlightNode(tn); } if (bChangeSelNode) { ChangeSelNode(tn); } break; case TreeViewMultiSelect.MultiSameBranchAndLevel: if (SelNodes != null && SelNodes.Count > 0) { TreeNode tnGrandParentSelNodes = null; int iLevel = 0; foreach (MWTreeNodeWrapper mwtnw in SelNodes.Values) { tnGrandParentSelNodes = GetTreeNodeGrandParent(mwtnw.Node); iLevel = GetTreeNodeLevel(mwtnw.Node); break; } if (GetTreeNodeGrandParent(tn) == tnGrandParentSelNodes && GetTreeNodeLevel(tn) == iLevel) { if (!IsTreeNodeSelected(tn) && IsSelectNodeRegExSatisfied(tn.Text)) { SelNodes.Add(tn.GetHashCode(), new MWTreeNodeWrapper(tn)); HighlightNode(tn); } } else if (IsSelectNodeRegExSatisfied(tn.Text)) { ClearSelNodes(); SelNodes.Add(tn.GetHashCode(), new MWTreeNodeWrapper(tn)); HighlightNode(tn); } } else if (IsSelectNodeRegExSatisfied(tn.Text)) { if (SelNodes == null) { SelNodes = new Hashtable(); } SelNodes.Add(tn.GetHashCode(), new MWTreeNodeWrapper(tn)); HighlightNode(tn); } if (bChangeSelNode) { ChangeSelNode(tn); } break; case TreeViewMultiSelect.MultiSameBranch: if (SelNodes != null && SelNodes.Count > 0) { TreeNode tnGrandParentSelNodes = null; foreach (MWTreeNodeWrapper mwtnw in SelNodes.Values) { tnGrandParentSelNodes = GetTreeNodeGrandParent(mwtnw.Node); break; } if (GetTreeNodeGrandParent(tn) == tnGrandParentSelNodes) { if (!IsTreeNodeSelected(tn) && IsSelectNodeRegExSatisfied(tn.Text)) { SelNodes.Add(tn.GetHashCode(), new MWTreeNodeWrapper(tn)); HighlightNode(tn); } } else if (IsSelectNodeRegExSatisfied(tn.Text)) { ClearSelNodes(); SelNodes.Add(tn.GetHashCode(), new MWTreeNodeWrapper(tn)); HighlightNode(tn); } } else if (IsSelectNodeRegExSatisfied(tn.Text)) { if (SelNodes == null) { SelNodes = new Hashtable(); } SelNodes.Add(tn.GetHashCode(), new MWTreeNodeWrapper(tn)); HighlightNode(tn); } if (bChangeSelNode) { ChangeSelNode(tn); } break; case TreeViewMultiSelect.MultiSameLevel: if (SelNodes != null && SelNodes.Count > 0) { int iLevel = 0; foreach (MWTreeNodeWrapper mwtnw in SelNodes.Values) { iLevel = GetTreeNodeLevel(mwtnw.Node); break; } if (GetTreeNodeLevel(tn) == iLevel) { if (!IsTreeNodeSelected(tn) && IsSelectNodeRegExSatisfied(tn.Text)) { SelNodes.Add(tn.GetHashCode(), new MWTreeNodeWrapper(tn)); HighlightNode(tn); } } else if (IsSelectNodeRegExSatisfied(tn.Text)) { ClearSelNodes(); SelNodes.Add(tn.GetHashCode(), new MWTreeNodeWrapper(tn)); HighlightNode(tn); } } else if (IsSelectNodeRegExSatisfied(tn.Text)) { if (SelNodes == null) { SelNodes = new Hashtable(); } SelNodes.Add(tn.GetHashCode(), new MWTreeNodeWrapper(tn)); HighlightNode(tn); } if (bChangeSelNode) { ChangeSelNode(tn); } break; case TreeViewMultiSelect.MultiPathToParents: case TreeViewMultiSelect.MultiPathToParent: if (SelNodes != null && SelNodes.Count > 0) { TreeNode tnGrandParentSelNodes = null; foreach (MWTreeNodeWrapper mwtnw in SelNodes.Values) { tnGrandParentSelNodes = GetTreeNodeGrandParent(mwtnw.Node); break; } if (GetTreeNodeGrandParent(tn) == tnGrandParentSelNodes || MultiSelect == TreeViewMultiSelect.MultiPathToParents) { if (!IsTreeNodeSelected(tn)) { int iTNLevel = GetTreeNodeLevel(tn); TreeNode tnTNGrandParent = GetTreeNodeGrandParent(tn); int iMaxLevel = 0; foreach (MWTreeNodeWrapper mwtnw in SelNodes.Values) { iMaxLevel = Math.Max(iMaxLevel, GetTreeNodeLevel(mwtnw.Node)); } if (iMaxLevel < iTNLevel) { if (MultiSelect == TreeViewMultiSelect.MultiPathToParent) { ClearSelNodes(); } else if (MultiSelect == TreeViewMultiSelect.MultiPathToParents) { DeselectBranch(tnTNGrandParent, true, false); } } else { foreach (TreeNode tnRoot in Nodes) { if (GetTreeNodeGrandParent(tn) == tnRoot) { ArrayList al = new ArrayList(); foreach (MWTreeNodeWrapper mwtnw in SelNodes.Values) { if (tnRoot == GetTreeNodeGrandParent(mwtnw.Node)) { int iLevel = GetTreeNodeLevel(mwtnw.Node); if (iLevel > iTNLevel) { al.Add(mwtnw.Node); } } } for (int i = 0; i < al.Count; i++) { DeselectNode(al[i] as TreeNode, false); } } } } if (IsSelectNodeRegExSatisfied(tn.Text)) { SelNodes.Add(tn.GetHashCode(), new MWTreeNodeWrapper(tn)); HighlightNode(tn); TreeNode tnTemp = tn; while (tnTemp.Parent != null) { if (!IsTreeNodeSelected(tnTemp.Parent)) { SelNodes.Add(tnTemp.Parent.GetHashCode(), new MWTreeNodeWrapper(tnTemp.Parent)); } HighlightNode(tnTemp.Parent); tnTemp = tnTemp.Parent; } } } else { TreeNode tnTemp = tn; while (tnTemp.Parent != null) { if (IsSelectNodeRegExSatisfied(tn.Text)) { if (!IsTreeNodeSelected(tnTemp.Parent)) { SelNodes.Add(tnTemp.Parent.GetHashCode(), new MWTreeNodeWrapper(tnTemp.Parent)); } HighlightNode(tnTemp.Parent); } tnTemp = tnTemp.Parent; } } } else if (IsSelectNodeRegExSatisfied(tn.Text)) { ClearSelNodes(); SelNodes.Add(tn.GetHashCode(), new MWTreeNodeWrapper(tn)); HighlightNode(tn); TreeNode tnTemp = tn; while (tnTemp.Parent != null) { if (!IsTreeNodeSelected(tnTemp.Parent)) { SelNodes.Add(tnTemp.Parent.GetHashCode(), new MWTreeNodeWrapper(tnTemp.Parent)); } HighlightNode(tnTemp.Parent); tnTemp = tnTemp.Parent; } } } else if (IsSelectNodeRegExSatisfied(tn.Text)) { if (SelNodes == null) { SelNodes = new Hashtable(); } SelNodes.Add(tn.GetHashCode(), new MWTreeNodeWrapper(tn)); HighlightNode(tn); TreeNode tnTemp = tn; while (tnTemp.Parent != null) { if (!IsTreeNodeSelected(tnTemp.Parent)) { SelNodes.Add(tnTemp.Parent.GetHashCode(), new MWTreeNodeWrapper(tnTemp.Parent)); } HighlightNode(tnTemp.Parent); tnTemp = tnTemp.Parent; } } if (bChangeSelNode) { ChangeSelNode(tn); } break; case TreeViewMultiSelect.SinglePathToParent: if (!IsTreeNodeSelected(tn) && IsSelectNodeRegExSatisfied(tn.Text)) { ClearSelNodes(); if (SelNodes == null) { SelNodes = new Hashtable(); } SelNodes.Add(tn.GetHashCode(), new MWTreeNodeWrapper(tn)); HighlightNode(tn); TreeNode tnTemp = tn; while (tnTemp.Parent != null) { if (!IsTreeNodeSelected(tnTemp.Parent)) { SelNodes.Add(tnTemp.Parent.GetHashCode(), new MWTreeNodeWrapper(tnTemp.Parent)); } HighlightNode(tnTemp.Parent); tnTemp = tnTemp.Parent; } } if (bChangeSelNode) { ChangeSelNode(tn); } break; case TreeViewMultiSelect.SinglePathToParents: if (SelNodes != null && SelNodes.Count > 0) { GetTreeNodeLevel(tn); GetTreeNodeGrandParent(tn); foreach (TreeNode tnRoot in Nodes) { if (GetTreeNodeGrandParent(tn) == tnRoot) { if (IsSelectNodeRegExSatisfied(tn.Text)) { ClearSelBranch(tnRoot); if (!IsTreeNodeSelected(tn)) { SelNodes.Add(tn.GetHashCode(), new MWTreeNodeWrapper(tn)); } HighlightNode(tn); TreeNode tnTemp = tn; while (tnTemp.Parent != null) { if (!IsTreeNodeSelected(tnTemp.Parent)) { SelNodes.Add(tnTemp.Parent.GetHashCode(), new MWTreeNodeWrapper(tnTemp.Parent)); } HighlightNode(tnTemp.Parent); tnTemp = tnTemp.Parent; } } break; } } } else { if (!IsTreeNodeSelected(tn) && IsSelectNodeRegExSatisfied(tn.Text)) { ClearSelNodes(); if (SelNodes == null) { SelNodes = new Hashtable(); } if (!IsTreeNodeSelected(tn)) { SelNodes.Add(tn.GetHashCode(), new MWTreeNodeWrapper(tn)); } HighlightNode(tn); TreeNode tnTemp = tn; while (tnTemp.Parent != null) { if (!IsTreeNodeSelected(tnTemp.Parent)) { SelNodes.Add(tnTemp.Parent.GetHashCode(), new MWTreeNodeWrapper(tnTemp.Parent)); } HighlightNode(tnTemp.Parent); tnTemp = tnTemp.Parent; } } } if (bChangeSelNode) { ChangeSelNode(tn); } break; default: //Execution should never end up here! break; } if (SelNode == tn) { bRetVal = true; } } return bRetVal; }
/// <summary> /// Disable TreeNode supplied. /// </summary> /// <param name="tn">TreeNode to disable.</param> private void DisableNode(TreeNode tn) { if(this.UseExtendedDisabledColors) { htDisabledTreeNodes.Add(tn.GetHashCode(), new MWTreeNodeWrapper(tn, this.DisabledTreeNodeBackColor, this.DisabledTreeNodeForeColor)); } else { if(IsTreeNodeSelected(tn)) { MWTreeNodeWrapper mwtnw = GetSelectedMWTreeNodeWrapper(tn); if(mwtnw != null) { if(this.HideSelection) { htDisabledTreeNodes.Add(tn.GetHashCode(), new MWTreeNodeWrapper(tn, mwtnw.BackColor, mwtnw.ForeColor)); } else { htDisabledTreeNodes.Add(tn.GetHashCode(), new MWTreeNodeWrapper(tn, SystemColors.Control, SystemColors.ControlDark)); } } } else if(IsPlainColoredTreeNode(tn)) { htDisabledTreeNodes.Add(tn.GetHashCode(), new MWTreeNodeWrapper(tn, this.DisabledTreeNodeBackColor, this.DisabledTreeNodeForeColor)); } } }
/// <summary> /// Deselect TreeNode supplied. /// Note that all selected TreeNodes can be found in the SelNodes property and the most recently selected TreeNode can be found in the SelNode property. /// </summary> /// <param name="tn">TreeNode to deselect.</param> /// <param name="bChangeSelNode">True if the SelNode property should be changed when deselecting the TreeNode.</param> /// <returns>True if the TreeNode supplied was successfully removed from the SelNodes property.</returns> public bool DeselectNode(TreeNode tn, bool bChangeSelNode) { bool bRetVal = false; bool bDeselectNode = false; if (tn != null && SelNodes.Count > 0 && IsTreeNodeSelected(tn)) { if (MultiSelect == TreeViewMultiSelect.MultiPathToParent || MultiSelect == TreeViewMultiSelect.MultiPathToParents || MultiSelect == TreeViewMultiSelect.SinglePathToParent || MultiSelect == TreeViewMultiSelect.SinglePathToParents) { if (tn.Nodes.Count == 0 || !IsAnyChildTreeNodeSelected(tn)) { bDeselectNode = true; } } else { bDeselectNode = true; } } if (!AllowNoSelNode && SelNodes.Count == 1) { bDeselectNode = false; } if (bDeselectNode) { MWTreeNodeWrapper.Deselect(SelNodes[tn.GetHashCode()] as MWTreeNodeWrapper); SelNodes.Remove(tn.GetHashCode()); LowlightNode(tn); if (!IsTreeNodeSelected(tn)) { bRetVal = true; } } if (bChangeSelNode) { if (SelNode != null) { bRetVal = true; } SelNodeInt = null; } return bRetVal; }
/// <summary> /// Add a TreeNode to the SelNodes property. /// </summary> /// <param name="tn">TreeNode to add to the SelNodes property.</param> /// <param name="bTriggerEvents">True if calling this method should raise the OnBeforeSelNodesAdd and OnAfterSelNodesAdd events or false otherwise.</param> /// <returns>True if the TreeNode is actually added or false otherwise.</returns> private bool SelNodesAdd(TreeNode tn, bool bTriggerEvents) { bool bRetVal = false; if(!this.IsTreeNodeSelected(tn)) { MWCancelEventArgs e = new MWCancelEventArgs(this.SelNodes, tn); if(bTriggerEvents) { OnBeforeSelNodesAdd(e); } if(!e.Cancel) { this.SelNodes.Add(tn.GetHashCode(), new MWTreeNodeWrapper(tn, this.UseExtendedSelectionColors, this.SelectedTreeNodeBackColor, this.SelectedTreeNodeForeColor)); if(!bActive) { DeactivateSelNode(tn); } if(bTriggerEvents) { OnAfterSelNodesAdd(new MWControlSuite.MWPropertyEventArgs(tn)); } bRetVal = true; } } return bRetVal; }
/// <summary> /// Clear all TreeNodes in the SelNodes property and deselect them, except for the TreeNodes in the range between, and including, the /// two TreeNodes supplied. /// </summary> /// <param name="tnFrom">First TreeNode in range of TreeNodes that should not be deselected.</param> /// <param name="tnTo">Last TreeNode in range of TreeNodes that should not be deselected.</param> /// <param name="bOnlyVisible">True if only visible TreeNodes should be considered to be part of the range or false if both visible and non-visible TreeNodes should be considered to be part of the range.</param> public void ClearSelNodes(TreeNode tnFrom, TreeNode tnTo, bool bOnlyVisible) { if (tnFrom == tnTo) { if (tnFrom != null) { ClearSelNodes(tnFrom); } else { ClearSelNodes(); } } else if (SelNodes != null) { if (tnTo == null) { tnTo = Nodes[Nodes.Count - 1]; if (bOnlyVisible) { while (tnTo.NextVisibleNode != null) { tnTo = tnTo.NextVisibleNode; } } else { while (tnTo.NextNode != null) { tnTo = tnTo.NextNode; } } } Hashtable ht = new Hashtable(); TreeNode tn = tnFrom; while (tn != null && tn != tnTo) { ht.Add(tn.GetHashCode(), tn); tn = bOnlyVisible ? tn.NextVisibleNode : tn.NextNode; } ht.Add(tnTo.GetHashCode(), tnTo); int iMax = SelNodes.Count; for (int i = 0; i < iMax; i++) { foreach (MWTreeNodeWrapper mwtnw in SelNodes.Values) { if (!ht.Contains(mwtnw.Node.GetHashCode())) { MWTreeNodeWrapper.Deselect(mwtnw); LowlightNode(mwtnw.Node); SelNodes.Remove(mwtnw.Node.GetHashCode()); break; } } } } }
/// <summary> /// Change the SelectedImageIndex of the supplied TreeNode. /// </summary> /// <param name="tn">TreeNode to change the SelectedImageIndex of.</param> /// <param name="iImageIndex">SelectedImageIndex to change to.</param> public static void ChangeTreeNodeSelectedImageIndex(TreeNode tn, int iSelectedImageIndex) { if(tn != null) { if((tn.TreeView as MWTreeView).IsTreeNodeSelected(tn)) { MWTreeNodeWrapper mwtnw = (tn.TreeView as MWTreeView).SelNodes[tn.GetHashCode()] as MWTreeNodeWrapper; mwtnw.SelectedImageIndex = iSelectedImageIndex; tn.ImageIndex = iSelectedImageIndex; tn.SelectedImageIndex = iSelectedImageIndex; } else { tn.SelectedImageIndex = iSelectedImageIndex; } } }
/// <summary> /// Check the TreeNode supplied (set the Checked property to true). /// </summary> /// <param name="tn">TreeNode to check (set the Checked property to true).</param> /// <param name="bUpdate">True if the TreeNode's Checked property should be updated or false otherwise.</param> /// <returns>True if the TreeNodes was checked (Checked property set to true) or false otherwise.</returns> public bool CheckNode(TreeNode tn, bool bUpdate) { bool bRetVal = false; bool bOldChecked = tn.Checked; if (AllowMultiCheck) { if (IsTreeNodeChecked(tn)) { if (!tn.Checked && bUpdate) { tn.Checked = true; } } else { if (!tn.Checked) { if (bUpdate) { tn.Checked = true; } if (!IsTreeNodeChecked(tn) && IsCheckNodeRegExSatisfied(tn.Text)) { CheckedNodes.Add(tn.GetHashCode(), tn); } } } } else { ClearCheckedNodes(); if (bUpdate) { tn.Checked = true; } if (!IsTreeNodeChecked(tn) && IsCheckNodeRegExSatisfied(tn.Text)) { CheckedNodes.Add(tn.GetHashCode(), tn); } } if (bOldChecked != tn.Checked) { bRetVal = true; } return bRetVal; }
/// <summary> /// Clear all TreeNodes in the SelNodes property and deselect them, except for the TreeNodes in the range between, and including, the /// two TreeNodes supplied. /// </summary> /// <param name="tnFrom">First TreeNode in range of TreeNodes that should not be deselected.</param> /// <param name="tnTo">Last TreeNode in range of TreeNodes that should not be deselected.</param> /// <param name="bTriggerSelNodesAddRemoveEvents">True if calling this method should make the SelNodesAdd/SelNodesRemove methods raise the OnBeforeSelNodesAdd/OnBeforeSelNodesRemove and OnAfterSelNodesAdd/OnAfterSelNodesRemove events or false otherwise.</param> /// <param name="bOnlyVisible">True if only visible TreeNodes should be considered to be part of the range or false if both visible and non-visible TreeNodes should be considered to be part of the range.</param> public void ClearSelNodes(TreeNode tnFrom, TreeNode tnTo, bool bTriggerSelNodesAddRemoveEvents, bool bOnlyVisible) { if(tnFrom == tnTo) { if(tnFrom != null) { ClearSelNodes(tnFrom, bTriggerSelNodesAddRemoveEvents); } else { ClearSelNodes(bTriggerSelNodesAddRemoveEvents); } } else if(this.SelNodes != null) { if(tnTo == null) { tnTo = this.Nodes[this.Nodes.Count - 1]; if(bOnlyVisible) { while(tnTo.NextVisibleNode != null) { tnTo = tnTo.NextVisibleNode; } } else { while(tnTo.NextNode != null) { tnTo = tnTo.NextNode; } } } Hashtable ht = new Hashtable(); TreeNode tn = tnFrom; while(tn != null && tn != tnTo) { ht.Add(tn.GetHashCode(), tn); if(bOnlyVisible) { tn = tn.NextVisibleNode; } else { tn = tn.NextNode; } } ht.Add(tnTo.GetHashCode(), tnTo); int iMax = this.SelNodes.Count; for(int i = 0; i < iMax; i++) { foreach(MWTreeNodeWrapper mwtnw in this.SelNodes.Values) { if(!ht.Contains(mwtnw.Node.GetHashCode())) { if(this.SelNodesRemove(mwtnw.Node, bTriggerSelNodesAddRemoveEvents)) { break; } } } } } else { this.SelNodes = new Hashtable(); } }
/// <summary> /// Uncheck the TreeNode supplied (set the Checked property to false). /// </summary> /// <param name="tn">TreeNode to uncheck (set the Checked property to false).</param> /// <param name="bUpdate">True if the TreeNode's Checked property should be updated or false otherwise.</param> /// <returns>True if the TreeNodes was unchecked (Checked property set to false) or false otherwise.</returns> public bool UncheckNode(TreeNode tn, bool bUpdate) { bool bRetVal = false; bool bOldChecked = tn.Checked; if (IsTreeNodeChecked(tn)) { if (tn.Checked) { if (bUpdate) { tn.Checked = false; } CheckedNodes.Remove(tn.GetHashCode()); } } else { if (tn.Checked && bUpdate) { tn.Checked = false; } } if (bOldChecked != tn.Checked) { bRetVal = true; } return bRetVal; }
/// <summary> /// Get the MWTreeNodeWrapper that contains the supplied TreeNode if it exists in the Selected MWTreeNodeWrapper Hashtable. /// </summary> /// <param name="tn">TreeNode for which to return an MWTreeNodeWrapper.</param> /// <returns>The MWTreeNodeWrapper that contains the supplied TreeNode if it exists in the Selected MWTreeNodeWrapper Hashtable or null otherwise.</returns> public MWTreeNodeWrapper GetSelectedMWTreeNodeWrapper(TreeNode tn) { MWTreeNodeWrapper mwtnw = null; if(IsTreeNodeSelected(tn)) { mwtnw = htSelNodes[tn.GetHashCode()] as MWTreeNodeWrapper; } return mwtnw; }
/// <summary> /// Determines whether the specified node is selected or not. /// </summary> /// <param name="tn">Node to check.</param> /// <returns>True if specified node is selected, false if not.</returns> private bool IsNodeSelected(TreeNode tn) { if (tn != null) return htblSelectedNodes.ContainsKey(tn.GetHashCode()); return false; }
/// <summary> /// Checks if the TreeNode supplied is selected or not. /// Note that passing in null as the TreeNode will result in false being returned. /// </summary> /// <param name="tn">TreeNode that should be checked if it is selected or not.</param> /// <returns>True if supplied TreeNode is selected or false otherwise.</returns> public bool IsTreeNodeSelected(TreeNode tn) { bool bRetVal = false; if(tn != null) { if(this.SelNodes != null) { if(this.SelNodes.Contains(tn.GetHashCode())) { bRetVal = true; } } } return bRetVal; }
private void PreserveNodeColors(TreeNode tn) { if (tn == null) return; System.Diagnostics.Debug.WriteLine(tn.BackColor.ToString()); if (htblSelectedNodesOrigColors.ContainsKey(tn.GetHashCode())) { // Color[] color = (Color[])htblSelectedNodesOrigColors[tn.GetHashCode()]; // color[0]=tn.BackColor; // color[1]=tn.ForeColor; } else { htblSelectedNodesOrigColors.Add(tn.GetHashCode(), new Color[] { tn.BackColor, tn.ForeColor }); } }