private bool SetFocusedItem(TreeNode node, bool bSelect, TreeNode oldNode, TreeViewAction action) { CMSTreeViewCancelEventArgs e = new CMSTreeViewCancelEventArgs(node, false, bSelect, action); OnBeforeSelect(e); if (e.Cancel) { return(false); } // temporary disable OnXXXSelect events this.bEnableSelectEvents = false; IntPtr hItem = SetFocusedItem(node); if (bSelect) { AddSelectedItem(node); } else { RemoveSelectedItem(node); } SetSelectedState(node, bSelect); // enable OnXXXSelect events this.bEnableSelectEvents = true; OnAfterSelect(new CMSTreeViewEventArgs(node, bSelect, action)); return(true); }
// Constructor. public TreeViewCancelEventArgs (TreeNode node, bool cancel, TreeViewAction action) : base(cancel) { this.node = node; this.action = action; }
public void Ctor_TreeNode_TreeViewAction(TreeNode node, TreeViewAction action) { var e = new TreeViewEventArgs(node, action); Assert.Equal(node, e.Node); Assert.Equal(action, e.Action); }
public bool SelectNode(TreeNode node, bool select, TreeViewAction action) { if (node == null || IsNodeSelected(node) == select) { return(false); } TreeViewCancelEventArgs ce = new TreeViewCancelEventArgs(node, false, action); SuspendBeforeSelect = true; OnBeforeSelect(ce); SuspendBeforeSelect = false; if (ce.Cancel) { return(false); } if (select) { node.EnsureVisible(); SelectedNodes.Add(node); } else { SelectedNodes.Remove(node); } OnAfterSelect(new TreeViewEventArgs(node, action)); return(true); }
/// <summary> /// Toggles the tri state check. /// </summary> /// <param name="node">The node.</param> /// <param name="action">The action.</param> private void ToggleTriStateCheck( TreeNode node, TreeViewAction action) { if (node.StateImageIndex == TriStateUncheckedStateImageIndex) { SetTriStateToNode( node, action, TriStateCheckedStateImageIndex, true); } else if (node.StateImageIndex == TriStateIndeterminateStateImageIndex && indeterminateToChecked) { SetTriStateToNode( node, action, TriStateCheckedStateImageIndex, true); } else { SetTriStateToNode( node, action, TriStateUncheckedStateImageIndex, true); } }
private void ClearSelectedNodes(TreeViewAction action) { for (int i = SelectedNodes.Count - 1; i >= 0; i--) { SelectNode(SelectedNodes[i], false, action); } }
private void SelectTo(TreeNode node, TreeViewAction action) { if (LastSelectedNode == null) { SelectNode(node, true, action); } else if (LastSelectedNode == node) { SelectNode(node, false, action); } else { TreeNode nodeBegin = LastSelectedNode; TreeNode tn = nodeBegin; while ((tn != null) && (tn != node)) { if (nodeBegin.Bounds.Y > node.Bounds.Y) { tn = tn.PrevVisibleNode; } else { tn = tn.NextVisibleNode; } if (tn != null) { SelectNode(tn, true, action); } } } }
public void Ctor_TreeNode_Bool_TreeViewAction(TreeNode node, bool cancel, TreeViewAction action) { var e = new TreeViewCancelEventArgs(node, cancel, action); Assert.Equal(node, e.Node); Assert.Equal(cancel, e.Cancel); Assert.Equal(action, e.Action); }
public static void TreeView_AfterSelect(TreeViewAction action, TreeNode node) { // 通过鼠标或者键盘触发事件,防止修改节点的Checked状态时候再次进入 if ((action == TreeViewAction.ByMouse || action == TreeViewAction.ByKeyboard) && node.Checked) { LogHelper.Log("select node " + node.Text + " tag " + node.Tag + " key " + OPCDAViewHelper.Key(node.FullPath.ToString())); } }
/// <summary> /// Initializes a new instance of the <see cref="TreeViewTriStateEventArgs"/> class. /// </summary> /// <param name="node">The node.</param> /// <param name="action">The action.</param> /// <param name="stateImageIndex">Index of the state image.</param> public TreeViewTriStateEventArgs( TreeNode node, TreeViewAction action, int stateImageIndex) : base(node, action) { this.stateImageIndex = stateImageIndex; }
private void UnselectNodesRecursively(MultiSelectTreeNode tn, TreeViewAction tva) { SelectNode(tn, false, tva); foreach (MultiSelectTreeNode node in tn.Nodes) { UnselectNodesRecursively(node, tva); } }
public static void TreeView_AfterCheck(TreeViewAction action, TreeNode node) { if (action != TreeViewAction.Unknown) { LogHelper.Log("check node " + node.Text + " tag " + node.Tag + " Level " + node.Level.ToString()); SetChildNodeCheckedState(node, node.Checked); SetParentNodeCheckedState(node, node.Checked); } }
/// <summary> /// Constructor. /// </summary> /// <param name="node">The node.</param> /// <param name="cancel">if set to <c>true</c> [cancel].</param> /// <param name="action">The action.</param> /// <param name="currentStateImageIndex">Index of the current state image.</param> /// <param name="newStateImageIndex">New index of the state image.</param> public TreeViewCancelTriStateEventArgs( TreeNode node, bool cancel, TreeViewAction action, int currentStateImageIndex, int newStateImageIndex) : base(node, cancel, action) { this.currentStateImageIndex = currentStateImageIndex; this.newStateImageIndex = newStateImageIndex; }
public void SelectNode(TreeNode[] nodes, TreeViewAction action, bool exclusive) { if (exclusive) { ClearSelectedNodes(action); } foreach (TreeNode node in nodes) { SelectNode(node, true, action); } }
/// <summary> /// Applies a new check state to the given tree node. /// The UseTriStateCheckBoxes property must be set to TRUE. /// </summary> /// <param name="node">The node.</param> /// <param name="action">The action.</param> /// <param name="checkState">State of the check.</param> private void DoSetNodeCheckState( TreeNode node, TreeViewAction action, CheckState checkState) { // Use TreeViewAction.ByKeyboard here, // to indicate that it was called from outside. SetTriStateToNode( node, action, ConvertCheckStateToImageIndex(checkState), true); }
/// <summary> /// Applies the given state to the given node. /// Raises events, too. /// </summary> /// <param name="node">The node.</param> /// <param name="action">The action.</param> /// <param name="stateImageIndex">Index of the state image.</param> /// <param name="raiseEvents">if set to <c>true</c> [raise events].</param> private void SetTriStateToNode( TreeNode node, TreeViewAction action, int stateImageIndex, bool raiseEvents) { bool canSet = true; if (raiseEvents) { TreeViewCancelEventArgs args = new TreeViewCancelEventArgs(node, false, action); OnBeforeCheck(args); TreeViewCancelTriStateEventArgs triArgs = new TreeViewCancelTriStateEventArgs( node, args.Cancel, action, node.StateImageIndex, stateImageIndex); OnBeforeTriStateCheck(triArgs); canSet = !triArgs.Cancel; } if (canSet) { // Actually set. // THIS IS THE ONLY PLACE to set. node.StateImageIndex = stateImageIndex; if (raiseEvents) { TreeViewEventArgs args = new TreeViewEventArgs(node, action); OnAfterCheck(args); TreeViewTriStateEventArgs triArgs = new TreeViewTriStateEventArgs( node, action, node.StateImageIndex); OnAfterTriStateCheck(triArgs); } } }
private void UnselectAllNodesNotBelongingToLevel(int level, TreeViewAction tva) { ArrayList list = new ArrayList(); foreach (MultiSelectTreeNode node in _selectedNodes) { if (GetNodeLevel(node) != level) { list.Add(node); } } foreach (MultiSelectTreeNode node2 in list) { SelectNode(node2, false, tva); } }
protected virtual void OnCustomCheck(TreeNode node, TreeViewAction action) { var e = new TreeViewCancelEventArgs(node, false, action); OnBeforeCheck(e); if (e.Cancel) { return; } if (node is IStateTreeNode) { ((IStateTreeNode)node).UpdateState(e); } OnAfterCheck(new TreeViewEventArgs(node, action)); }
/// <summary>Toggles the CheckState of the specified node on response of a click/keyboard event.</summary> /// <param name="node">The node affected by the event.</param> /// <param name="action">The action that caused the event.</param> private void ToggleNodeCheckState(TreeNode node, TreeViewAction action) { // Compute the new check box state of the node CheckState newState; switch ((CheckState)node.StateImageIndex) { case CheckState.Unchecked: newState = CheckState.Checked; break; case CheckState.Checked: newState = CheckState.Unchecked; break; case CheckState.Indeterminate: newState = CheckState.Checked; break; // Standard behaviour default: throw new InvalidOperationException("Invalid TreeNode.StateImageIndex - Check your code."); } // Update the checked state of the node SetCheckStateImpl(node, newState, action); }
private void ChangeNodeStateByUser(TreeNode node, TreeViewAction action) { if (this.BeforeNodeStateChangeByUser != null) { this.BeforeNodeStateChangeByUser(this, new TreeViewEventArgs(node, action)); } switch (node.StateImageIndex) { case ItemState.Unchecked: case ItemState.Mixed: node.StateImageIndex = ItemState.Checked; break; case ItemState.Checked: node.StateImageIndex = ItemState.Unchecked; break; } UpdateChildren(node); UpdateParent(node); }
private void SetCheckStateImpl(TreeNode node, CheckState newState, TreeViewAction action) { if (node == null) { throw new ArgumentNullException("node"); } if (newState != CheckState.Checked && newState != CheckState.Unchecked) { throw new ArgumentOutOfRangeException("newState", "Only checked and unchecked states can be set."); } // Set the check state and update the children and parent PropagateNodeCheckStateDown(node, newState); PropagateNodeCheckStateUp(node); // Trigger the AfterCheckState event on the affected node if (AfterCheckState != null) { AfterCheckState(this, new TreeViewEventArgs(node, action)); } }
private bool SelectNode(MultiSelectTreeNode node, bool select, TreeViewAction tva) { bool selected = false; if (node == null) { return(false); } if (select) { if (!IsNodeSelected(node)) { MultiSelectTreeViewCancelEventArgs e = new MultiSelectTreeViewCancelEventArgs(node, false, tva); OnBeforeSelect(e); if (e.Cancel) { return(false); } _selectedNodes.Add(node); selected = true; _selectionChanged = true; OnAfterSelect(new TreeViewEventArgs(node, tva)); } _mostRecentSelectedNode = node; return(selected); } if (IsNodeSelected(node)) { OnBeforeDeselect(new TreeViewEventArgs(node)); _selectedNodes.Remove(node); _selectionChanged = true; OnAfterDeselect(new TreeViewEventArgs(node)); } return(selected); }
private void tvClientesServicios_BeforeCheck(object sender, TreeViewCancelEventArgs e) { action = e.Action; }
// Constructor. public TreeViewEventArgs(TreeNode node, TreeViewAction action) { this.node = node; this.action = action; }
// 选中或取消选中 Dpu 时执行的操作 private void treDpuCatalog_AfterCheck(object sender, TreeViewEventArgs e) { // 改变子节点的选中状态 if ((e.Action == TreeViewAction.ByMouse || actionTemp == TreeViewAction.ByMouse) && e.Node.Nodes.Count > 0) { foreach (TreeNode node in e.Node.Nodes) { actionTemp = TreeViewAction.ByMouse; node.Checked = e.Node.Checked; } } actionTemp = TreeViewAction.Unknown; // 改变父节点的选中状态 if (e.Node.Parent != null) { if (!e.Node.Checked) { bool hasChecked = false; foreach (TreeNode node in e.Node.Parent.Nodes) { if (node.Checked) { hasChecked = true; break; } } e.Node.Parent.Checked = hasChecked; } else { e.Node.Parent.Checked = true; } } if ((e.Node.Tag as NodeTag).type == NodeType.Controller) { if (e.Node.Checked) { // 加载选中 Dpu 下的文档列表 BllManager bll = new BllManager(manager); IList <Prj_Document> documents = bll.manager.DocumentCRUD.GetPrj_Documents_By_Prj_Controller_ID((e.Node.Tag as NodeTag).id); foreach (Prj_Document doc in documents) { ListViewItem item = new ListViewItem( new string[] { doc.DocumentName.Substring(0, doc.DocumentName.IndexOf('-')).PadLeft(3, '0') + "-" + doc.DocumentName.Substring(doc.DocumentName.IndexOf('-') + 1).PadLeft(3, '0'), doc.DocumentCaption }); item.Tag = doc; item.ToolTipText = doc.DocumentCaption; this.lstPages.Items.Add(item); } } else { // 移除对应 Dpu 的文档列表 IList <int> mastLeavedId = new List <int>(); for (int i = 0; i < this.lstPages.Items.Count;) { if (((Prj_Document)this.lstPages.Items[i].Tag).Prj_Controller_ID == (((NodeTag)e.Node.Tag).id)) { this.lstPages.Items.Remove(this.lstPages.Items[i]); } else { i++; } } } } }
/// <summary> /// Unselects nodes outside the specified range. /// </summary> /// <param name="startNode">Start node.</param> /// <param name="endNode">End node.</param> /// <param name="tva">Specifies the action that caused the selection change.</param> private void UnselectNodesOutsideRange(TreeNode startNode, TreeNode endNode, TreeViewAction tva) { // Calculate start node and end node TreeNode firstNode = null; TreeNode lastNode = null; if (startNode.Bounds.Y < endNode.Bounds.Y) { firstNode = startNode; lastNode = endNode; } else { firstNode = endNode; lastNode = startNode; } // Unselect each node outside range TreeNode tnTemp = firstNode; while (tnTemp != null) { tnTemp = tnTemp.PrevVisibleNode; if (tnTemp != null) { SelectNode(tnTemp, false, tva); } } tnTemp = lastNode; while (tnTemp != null) { tnTemp = tnTemp.NextVisibleNode; if (tnTemp != null) { SelectNode(tnTemp, false, tva); } } }
/// <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> /// Unselects all selected nodes that don't belong directly or indirectly to the specified parent. /// </summary> /// <param name="parent">Parent node.</param> /// <param name="tva">Specifies the action that caused the selection change.</param> private void UnselectAllNodesNotBelongingToParent(TreeNode parent, TreeViewAction tva) { // First, build list of nodes that need to be unselected ArrayList arrNodesToDeselect = new ArrayList(); foreach (TreeNode selectedTreeNode in htblSelectedNodes.Values) { if (!IsChildOf(selectedTreeNode, parent)) { arrNodesToDeselect.Add(selectedTreeNode); } } // Do the actual unselect foreach (TreeNode tnToDeselect in arrNodesToDeselect) { SelectNode(tnToDeselect, false, tva); } }
/// <summary> /// Unselects all selected nodes. /// </summary> /// <param name="tva">Specifies the action that caused the selection change.</param> private void UnselectAllNodes(TreeViewAction tva) { UnselectAllNodesExceptNode(null, tva); }
private static void ModifyFolderExpandedState(TreeNode Node, TreeViewAction Action) { ConfigItems.NodeDescription nodeDescr = (ConfigItems.NodeDescription)Node.Tag; switch (nodeDescr.TreeNodeType) { case NodeType.Folder: ConfigItems.TDSQueriesTree.FoldersRow folder = (ConfigItems.TDSQueriesTree.FoldersRow)nodeDescr.NodeData; folder.Expanded = (Action == TreeViewAction.Expand ? true : false); break; } }
/// <summary> /// Constructor. /// </summary> /// <param name="node">The node.</param> /// <param name="cancel">if set to <c>true</c> [cancel].</param> /// <param name="action">The action.</param> /// <param name="currentStateImageIndex">Index of the current state image.</param> /// <param name="newStateImageIndex">New index of the state image.</param> public TreeViewCancelTriStateEventArgs( TreeNode node, bool cancel, TreeViewAction action, int currentStateImageIndex, int newStateImageIndex ) : base( node, cancel, action ) { this.currentStateImageIndex = currentStateImageIndex; this.newStateImageIndex = newStateImageIndex; }
/// <summary> /// Applies the given state to the given node. /// Raises events, too. /// </summary> /// <param name="node">The node.</param> /// <param name="action">The action.</param> /// <param name="stateImageIndex">Index of the state image.</param> /// <param name="raiseEvents">if set to <c>true</c> [raise events].</param> private void SetTriStateToNode( TreeNode node, TreeViewAction action, int stateImageIndex, bool raiseEvents ) { bool canSet = true; if ( raiseEvents ) { TreeViewCancelEventArgs args = new TreeViewCancelEventArgs( node, false, action ); OnBeforeCheck( args ); TreeViewCancelTriStateEventArgs triArgs = new TreeViewCancelTriStateEventArgs( node, args.Cancel, action, node.StateImageIndex, stateImageIndex ); OnBeforeTriStateCheck( triArgs ); canSet = !triArgs.Cancel; } if ( canSet ) { // Actually set. // THIS IS THE ONLY PLACE to set. node.StateImageIndex = stateImageIndex; if ( raiseEvents ) { TreeViewEventArgs args = new TreeViewEventArgs( node, action ); OnAfterCheck( args ); TreeViewTriStateEventArgs triArgs = new TreeViewTriStateEventArgs( node, action, node.StateImageIndex ); OnAfterTriStateCheck( triArgs ); } } }
internal bool TreeViewBeforeCheck(TreeNode node, TreeViewAction actionTaken) { TreeViewCancelEventArgs e = new TreeViewCancelEventArgs(node, false, actionTaken); this.OnBeforeCheck(e); return e.Cancel; }
public TreeViewEventArgs(TreeNode node, TreeViewAction action) { Action = action; Node = node; }
/// <summary> /// Selects nodes within the specified range. /// </summary> /// <param name="startNode">Start node.</param> /// <param name="endNode">End Node.</param> /// <param name="tva">Specifies the action that caused the selection change.</param> private void SelectNodesInsideRange(TreeNode startNode, TreeNode endNode, TreeViewAction tva) { // Calculate start node and end node TreeNode firstNode = null; TreeNode lastNode = null; SortNodes(ref startNode, ref endNode); firstNode = startNode; lastNode = endNode; //This was a terrible idea, whoever came up with it... // Bounds are not updated always and it's not fixable as it's part of .NET framework. // Much better is to rely on a real index in a tree model /* if (startNode.Bounds.Y < endNode.Bounds.Y) { firstNode = startNode; lastNode = endNode; } else { firstNode = endNode; lastNode = startNode; } */ // Select each node in range SelectNode(firstNode, true, tva); TreeNode tnTemp = firstNode; while (tnTemp != lastNode) { tnTemp = tnTemp.NextVisibleNode; if (tnTemp != null) { SelectNode(tnTemp, true, tva); } } SelectNode(lastNode, true, tva); }
public VirtualTreeViewEventArgs(VirtualTreeNode node, TreeViewAction action) : this(node) { _action = action; }
protected override void OnKeyDown (KeyEventArgs e) { OpenTreeNodeEnumerator ne; switch (e.KeyData & Keys.KeyCode) { case Keys.Add: if (selected_node != null && selected_node.IsExpanded) selected_node.Expand (); break; case Keys.Subtract: if (selected_node != null && selected_node.IsExpanded) selected_node.Collapse (); break; case Keys.Left: if (selected_node != null) { if (selected_node.IsExpanded && selected_node.Nodes.Count > 0) selected_node.Collapse (); else { TreeNode parent = selected_node.Parent; if (parent != null) { selection_action = TreeViewAction.ByKeyboard; SelectedNode = parent; } } } break; case Keys.Right: if (selected_node != null) { if (!selected_node.IsExpanded) selected_node.Expand (); else { TreeNode child = selected_node.FirstNode; if (child != null) SelectedNode = child; } } break; case Keys.Up: if (selected_node != null) { ne = new OpenTreeNodeEnumerator (selected_node); if (ne.MovePrevious () && ne.MovePrevious ()) { selection_action = TreeViewAction.ByKeyboard; SelectedNode = ne.CurrentNode; } } break; case Keys.Down: if (selected_node != null) { ne = new OpenTreeNodeEnumerator (selected_node); if (ne.MoveNext () && ne.MoveNext ()) { selection_action = TreeViewAction.ByKeyboard; SelectedNode = ne.CurrentNode; } } break; case Keys.Home: if (root_node.Nodes.Count > 0) { ne = new OpenTreeNodeEnumerator (root_node.Nodes [0]); if (ne.MoveNext ()) { selection_action = TreeViewAction.ByKeyboard; SelectedNode = ne.CurrentNode; } } break; case Keys.End: if (root_node.Nodes.Count > 0) { ne = new OpenTreeNodeEnumerator (root_node.Nodes [0]); while (ne.MoveNext ()) { } selection_action = TreeViewAction.ByKeyboard; SelectedNode = ne.CurrentNode; } break; case Keys.PageDown: if (selected_node != null) { ne = new OpenTreeNodeEnumerator (selected_node); int move = VisibleCount; for (int i = 0; i < move && ne.MoveNext (); i++) { } selection_action = TreeViewAction.ByKeyboard; SelectedNode = ne.CurrentNode; } break; case Keys.PageUp: if (selected_node != null) { ne = new OpenTreeNodeEnumerator (selected_node); int move = VisibleCount; for (int i = 0; i < move && ne.MovePrevious (); i++) { } selection_action = TreeViewAction.ByKeyboard; SelectedNode = ne.CurrentNode; } break; case Keys.Multiply: if (selected_node != null) selected_node.ExpandAll (); break; } base.OnKeyDown (e); if (!e.Handled && checkboxes && selected_node != null && (e.KeyData & Keys.KeyCode) == Keys.Space) { selected_node.check_reason = TreeViewAction.ByKeyboard; selected_node.Checked = !selected_node.Checked; e.Handled = true; } }
/// <summary> /// Processes a node range. /// </summary> /// <param name="startNode">Start node of range.</param> /// <param name="endNode">End node of range.</param> /// <param name="e">MouseEventArgs.</param> /// <param name="keys">Keys.</param> /// <param name="tva">TreeViewAction.</param> /// <param name="allowStartEdit">True if node can go to edit mode, false if not.</param> private void ProcessNodeRange(TreeNode startNode, TreeNode endNode, MouseEventArgs e, Keys keys, TreeViewAction tva, bool allowStartEdit) { blnSelectionChanged = false; // prepare for OnSelectionsChanged if (e.Button == MouseButtons.Left) { blnWasDoubleClick = (intMouseClicks == 2); TreeNode tnTemp = null; int intNodeLevelStart; if (((keys & Keys.Control) == 0) && ((keys & Keys.Shift) == 0)) { // CTRL and SHIFT not held down tnSelectionMirrorPoint = endNode; int intNumberOfSelectedNodes = SelectedNodes.Count; // If it was a double click, select node and suspend further processing if (blnWasDoubleClick) { base.OnMouseDown(e); return; } if (!IsPlusMinusClicked(endNode, e)) { bool blnNodeWasSelected = false; if (IsNodeSelected(endNode)) blnNodeWasSelected = true; UnselectAllNodesExceptNode(endNode, tva); SelectNode(endNode, true, tva); if ((blnNodeWasSelected) && (LabelEdit) && (allowStartEdit) && (!blnWasDoubleClick) && (intNumberOfSelectedNodes <= 1)) { // Node should be put in edit mode tnNodeToStartEditOn = endNode; System.Threading.Thread t = new System.Threading.Thread(new System.Threading.ThreadStart(StartEdit)); t.Start(); } } } else if (((keys & Keys.Control) != 0) && ((keys & Keys.Shift) == 0)) { // CTRL held down tnSelectionMirrorPoint = null; if (!IsNodeSelected(endNode)) { switch (selectionMode) { case TreeViewSelectionMode.SingleSelect: UnselectAllNodesExceptNode(endNode, tva); break; case TreeViewSelectionMode.MultiSelectSameRootBranch: TreeNode tnAbsoluteParent2 = GetRootParent(endNode); UnselectAllNodesNotBelongingToParent(tnAbsoluteParent2, tva); break; case TreeViewSelectionMode.MultiSelectSameLevel: UnselectAllNodesNotBelongingToLevel(GetNodeLevel(endNode), tva); break; case TreeViewSelectionMode.MultiSelectSameLevelAndRootBranch: TreeNode tnAbsoluteParent = GetRootParent(endNode); UnselectAllNodesNotBelongingToParent(tnAbsoluteParent, tva); UnselectAllNodesNotBelongingToLevel(GetNodeLevel(endNode), tva); break; case TreeViewSelectionMode.MultiSelectSameParent: TreeNode tnParent = endNode.Parent; UnselectAllNodesNotBelongingDirectlyToParent(tnParent, tva); break; } SelectNode(endNode, true, tva); } else { SelectNode(endNode, false, tva); } } else if (((keys & Keys.Control) == 0) && ((keys & Keys.Shift) != 0)) { // SHIFT pressed if (tnSelectionMirrorPoint == null) { tnSelectionMirrorPoint = startNode; } switch (selectionMode) { case TreeViewSelectionMode.SingleSelect: UnselectAllNodesExceptNode(endNode, tva); SelectNode(endNode, true, tva); break; case TreeViewSelectionMode.MultiSelectSameRootBranch: TreeNode tnAbsoluteParentStartNode = GetRootParent(startNode); tnTemp = startNode; // Check each visible node from startNode to endNode and select it if needed while ((tnTemp != null) && (tnTemp != endNode)) { if (startNode.Bounds.Y > endNode.Bounds.Y) tnTemp = tnTemp.PrevVisibleNode; else tnTemp = tnTemp.NextVisibleNode; if (tnTemp != null) { TreeNode tnAbsoluteParent = GetRootParent(tnTemp); if (tnAbsoluteParent == tnAbsoluteParentStartNode) { SelectNode(tnTemp, true, tva); } } } UnselectAllNodesNotBelongingToParent(tnAbsoluteParentStartNode, tva); UnselectNodesOutsideRange(tnSelectionMirrorPoint, endNode, tva); break; case TreeViewSelectionMode.MultiSelectSameLevel: intNodeLevelStart = GetNodeLevel(startNode); tnTemp = startNode; // Check each visible node from startNode to endNode and select it if needed while ((tnTemp != null) && (tnTemp != endNode)) { if (startNode.Bounds.Y > endNode.Bounds.Y) tnTemp = tnTemp.PrevVisibleNode; else tnTemp = tnTemp.NextVisibleNode; if (tnTemp != null) { int intNodeLevel = GetNodeLevel(tnTemp); if (intNodeLevel == intNodeLevelStart) { SelectNode(tnTemp, true, tva); } } } UnselectAllNodesNotBelongingToLevel(intNodeLevelStart, tva); UnselectNodesOutsideRange(tnSelectionMirrorPoint, endNode, tva); break; case TreeViewSelectionMode.MultiSelectSameLevelAndRootBranch: TreeNode tnAbsoluteParentStart = GetRootParent(startNode); intNodeLevelStart = GetNodeLevel(startNode); tnTemp = startNode; // Check each visible node from startNode to endNode and select it if needed while ((tnTemp != null) && (tnTemp != endNode)) { if (startNode.Bounds.Y > endNode.Bounds.Y) tnTemp = tnTemp.PrevVisibleNode; else tnTemp = tnTemp.NextVisibleNode; if (tnTemp != null) { int intNodeLevel = GetNodeLevel(tnTemp); TreeNode tnAbsoluteParent = GetRootParent(tnTemp); if ((intNodeLevel == intNodeLevelStart) && (tnAbsoluteParent == tnAbsoluteParentStart)) { SelectNode(tnTemp, true, tva); } } } UnselectAllNodesNotBelongingToParent(tnAbsoluteParentStart, tva); UnselectAllNodesNotBelongingToLevel(intNodeLevelStart, tva); UnselectNodesOutsideRange(tnSelectionMirrorPoint, endNode, tva); break; case TreeViewSelectionMode.MultiSelect: SelectNodesInsideRange(tnSelectionMirrorPoint, endNode, tva); UnselectNodesOutsideRange(tnSelectionMirrorPoint, endNode, tva); break; case TreeViewSelectionMode.MultiSelectSameParent: TreeNode tnParentStartNode = startNode.Parent; tnTemp = startNode; // Check each visible node from startNode to endNode and select it if needed while ((tnTemp != null) && (tnTemp != endNode)) { if (startNode.Bounds.Y > endNode.Bounds.Y) tnTemp = tnTemp.PrevVisibleNode; else tnTemp = tnTemp.NextVisibleNode; if (tnTemp != null) { TreeNode tnParent = tnTemp.Parent; if (tnParent == tnParentStartNode) { SelectNode(tnTemp, true, tva); } } } UnselectAllNodesNotBelongingDirectlyToParent(tnParentStartNode, tva); UnselectNodesOutsideRange(tnSelectionMirrorPoint, endNode, tva); break; } } else if (((keys & Keys.Control) != 0) && ((keys & Keys.Shift) != 0)) { // SHIFT AND CTRL pressed switch (selectionMode) { case TreeViewSelectionMode.SingleSelect: UnselectAllNodesExceptNode(endNode, tva); SelectNode(endNode, true, tva); break; case TreeViewSelectionMode.MultiSelectSameRootBranch: TreeNode tnAbsoluteParentStartNode = GetRootParent(startNode); tnTemp = startNode; // Check each visible node from startNode to endNode and select it if needed while ((tnTemp != null) && (tnTemp != endNode)) { if (startNode.Bounds.Y > endNode.Bounds.Y) tnTemp = tnTemp.PrevVisibleNode; else tnTemp = tnTemp.NextVisibleNode; if (tnTemp != null) { TreeNode tnAbsoluteParent = GetRootParent(tnTemp); if (tnAbsoluteParent == tnAbsoluteParentStartNode) { SelectNode(tnTemp, true, tva); } } } UnselectAllNodesNotBelongingToParent(tnAbsoluteParentStartNode, tva); break; case TreeViewSelectionMode.MultiSelectSameLevel: intNodeLevelStart = GetNodeLevel(startNode); tnTemp = startNode; // Check each visible node from startNode to endNode and select it if needed while ((tnTemp != null) && (tnTemp != endNode)) { if (startNode.Bounds.Y > endNode.Bounds.Y) tnTemp = tnTemp.PrevVisibleNode; else tnTemp = tnTemp.NextVisibleNode; if (tnTemp != null) { int intNodeLevel = GetNodeLevel(tnTemp); if (intNodeLevel == intNodeLevelStart) { SelectNode(tnTemp, true, tva); } } } UnselectAllNodesNotBelongingToLevel(intNodeLevelStart, tva); break; case TreeViewSelectionMode.MultiSelectSameLevelAndRootBranch: TreeNode tnAbsoluteParentStart = GetRootParent(startNode); intNodeLevelStart = GetNodeLevel(startNode); tnTemp = startNode; // Check each visible node from startNode to endNode and select it if needed while ((tnTemp != null) && (tnTemp != endNode)) { if (startNode.Bounds.Y > endNode.Bounds.Y) tnTemp = tnTemp.PrevVisibleNode; else tnTemp = tnTemp.NextVisibleNode; if (tnTemp != null) { int intNodeLevel = GetNodeLevel(tnTemp); TreeNode tnAbsoluteParent = GetRootParent(tnTemp); if ((intNodeLevel == intNodeLevelStart) && (tnAbsoluteParent == tnAbsoluteParentStart)) { SelectNode(tnTemp, true, tva); } } } UnselectAllNodesNotBelongingToParent(tnAbsoluteParentStart, tva); UnselectAllNodesNotBelongingToLevel(intNodeLevelStart, tva); break; case TreeViewSelectionMode.MultiSelect: tnTemp = startNode; // Check each visible node from startNode to endNode and select it if needed while ((tnTemp != null) && (tnTemp != endNode)) { if (startNode.Bounds.Y > endNode.Bounds.Y) tnTemp = tnTemp.PrevVisibleNode; else tnTemp = tnTemp.NextVisibleNode; if (tnTemp != null) { SelectNode(tnTemp, true, tva); } } break; case TreeViewSelectionMode.MultiSelectSameParent: TreeNode tnParentStartNode = startNode.Parent; tnTemp = startNode; // Check each visible node from startNode to endNode and select it if needed while ((tnTemp != null) && (tnTemp != endNode)) { if (startNode.Bounds.Y > endNode.Bounds.Y) tnTemp = tnTemp.PrevVisibleNode; else tnTemp = tnTemp.NextVisibleNode; if (tnTemp != null) { TreeNode tnParent = tnTemp.Parent; if (tnParent == tnParentStartNode) { SelectNode(tnTemp, true, tva); } } } UnselectAllNodesNotBelongingDirectlyToParent(tnParentStartNode, tva); break; } } } else if (e.Button == MouseButtons.Right) { // if right mouse button clicked, clear selection and select right-clicked node if (!IsNodeSelected(endNode)) { UnselectAllNodes(tva); SelectNode(endNode, true, tva); } } OnSelectionsChanged(); }
/// <summary> /// Toggles the tri state check. /// </summary> /// <param name="node">The node.</param> /// <param name="action">The action.</param> private void ToggleTriStateCheck( TreeNode node, TreeViewAction action ) { if ( node.StateImageIndex == TriStateUncheckedStateImageIndex ) { SetTriStateToNode( node, action, TriStateCheckedStateImageIndex, true ); } else if ( node.StateImageIndex == TriStateIndeterminateStateImageIndex && indeterminateToChecked ) { SetTriStateToNode( node, action, TriStateCheckedStateImageIndex, true ); } else { SetTriStateToNode( node, action, TriStateUncheckedStateImageIndex, true ); } }
/// <summary> /// Unselects all selected nodes that don't belong to the specified level. /// </summary> /// <param name="level">Node level.</param> /// <param name="tva">Specifies the action that caused the selection change.</param> private void UnselectAllNodesNotBelongingToLevel(int level, TreeViewAction tva) { // First, build list of nodes that need to be unselected ArrayList arrNodesToDeselect = new ArrayList(); foreach (TreeNode selectedTreeNode in htblSelectedNodes.Values) { if (GetNodeLevel(selectedTreeNode) != level) { arrNodesToDeselect.Add(selectedTreeNode); } } // Do the actual unselect foreach (TreeNode tnToDeselect in arrNodesToDeselect) { SelectNode(tnToDeselect, false, tva); } }
/// <summary> /// Applies a new check state to the given tree node. /// The UseTriStateCheckBoxes property must be set to TRUE. /// </summary> /// <param name="node">The node.</param> /// <param name="action">The action.</param> /// <param name="checkState">State of the check.</param> private void DoSetNodeCheckState( TreeNode node, TreeViewAction action, CheckState checkState ) { // Use TreeViewAction.ByKeyboard here, // to indicate that it was called from outside. SetTriStateToNode( node, action, ConvertCheckStateToImageIndex( checkState ), true ); }
/// <summary> /// Unselects all selected nodes, except for the specified node which should not be touched. /// </summary> /// <param name="nodeKeepSelected">Node not to touch.</param> /// <param name="tva">Specifies the action that caused the selection change.</param> private void UnselectAllNodesExceptNode(TreeNode nodeKeepSelected, TreeViewAction tva) { // First, build list of nodes that need to be unselected ArrayList arrNodesToDeselect = new ArrayList(); foreach (TreeNode selectedTreeNode in htblSelectedNodes.Values) { if (nodeKeepSelected == null) { arrNodesToDeselect.Add(selectedTreeNode); } else if ((nodeKeepSelected != null) && (selectedTreeNode != nodeKeepSelected)) { arrNodesToDeselect.Add(selectedTreeNode); } } // Do the actual unselect foreach (TreeNode tnToDeselect in arrNodesToDeselect) { SelectNode(tnToDeselect, false, tva); } }
public EasyTreeViewEventArgs(object node, TreeViewAction action) { this.node = node; this.action = action; }
/// <summary> /// Selects nodes within the specified range. /// </summary> /// <param name="startNode">Start node.</param> /// <param name="endNode">End Node.</param> /// <param name="tva">Specifies the action that caused the selection change.</param> private void SelectNodesInsideRange(TreeNode startNode, TreeNode endNode, TreeViewAction tva) { // Calculate start node and end node TreeNode firstNode = null; TreeNode lastNode = null; if (startNode.Bounds.Y < endNode.Bounds.Y) { firstNode = startNode; lastNode = endNode; } else { firstNode = endNode; lastNode = startNode; } // Select each node in range SelectNode(firstNode, true, tva); TreeNode tnTemp = firstNode; while (tnTemp != lastNode) { tnTemp = tnTemp.NextVisibleNode; if (tnTemp != null) { SelectNode(tnTemp, true, tva); } } SelectNode(lastNode, true, tva); }
/// <include file='doc\TreeView.uex' path='docs/doc[@for="TreeView.TreeViewBeforeAfterCheck"]/*' /> /// <devdoc> /// Defined so that a tree node can use it /// /// </devdoc> /// <internalonly/> internal bool TreeViewBeforeCheck(TreeNode node, TreeViewAction actionTaken) { TreeViewCancelEventArgs tvce = new TreeViewCancelEventArgs(node, false, actionTaken); OnBeforeCheck(tvce); return (tvce.Cancel); }
/// <summary> /// Recursively unselect node. /// </summary> /// <param name="tn">Node to recursively unselect.</param> /// <param name="tva">Specifies the action that caused the selection change.</param> private void UnselectNodesRecursively(TreeNode tn, TreeViewAction tva) { SelectNode(tn, false, tva); foreach (TreeNode child in tn.Nodes) { UnselectNodesRecursively(child, tva); } }
internal void TreeViewAfterCheck(TreeNode node, TreeViewAction actionTaken) { OnAfterCheck(new TreeViewEventArgs(node, actionTaken)); }
public TreeViewSelectedNodeChangedArgs(TreeNode beforeNode, TreeNode afterNode, TreeViewAction action) { BeforeNode = beforeNode; AfterNode = afterNode; Action = action; }
public TreeViewEventArgs(TreeNode node, TreeViewAction action) { }
public TreeViewEventArgs(TreeNode node) { this.node = node; this.action = TreeViewAction.Unknown; }
private void tsResults_AfterExpand(object sender, TreeViewEventArgs e) { TreeViewAction action = e.Action; }
/// <summary> /// Initializes a new instance of the <see cref="TreeViewTriStateEventArgs"/> class. /// </summary> /// <param name="node">The node.</param> /// <param name="action">The action.</param> /// <param name="stateImageIndex">Index of the state image.</param> public TreeViewTriStateEventArgs( TreeNode node, TreeViewAction action, int stateImageIndex ) : base( node, action ) { this.stateImageIndex = stateImageIndex; }
public TreeViewEventArgs(TreeNode?node, TreeViewAction action) { Node = node; Action = action; }
public VirtualTreeViewCancelEventArgs(VirtualTreeNode node, bool cancel, TreeViewAction action) : base(cancel) { _node = node; _action = action; }
public MultiSelectTreeViewCancelEventArgs(MultiSelectTreeNode node, bool cancel, TreeViewAction action) : base(cancel) { _node = node; _action = action; }
public TreeViewEventArgs(TreeNode node, TreeViewAction action) { this.node = node; this.action = action; }
public TreeViewEventArgs(TreeNode node, TreeViewAction action) : this(node) { this.action = action; }