/// <summary> /// Applies the specified search result collection to the control by adding the nodes to the drop-down. /// </summary> /// <param name="results"></param> private void ApplySearchResults(ComboTreeNodeCollection results) { if (InvokeRequired) { Invoke(new Action <ComboTreeNodeCollection>(ApplySearchResults), results); } else { if (_inSearchMode) { BeginUpdate(); Nodes.Clear(); if (results.Count > 0) { Nodes.AddRange(results); } else { Nodes.Add(new ComboTreeNode("(no results found)") { Selectable = false, FontStyle = FontStyle.Italic }); } EndUpdate(); } } }
void nodes_AfterCheck(object sender, ComboTreeNodeEventArgs e) { if (_cascadeCheckState) { _recurseDepth++; if (_recurseDepth == 1) { IEnumerator <ComboTreeNode> enumerator = ComboTreeNodeCollection.GetNodesRecursive(e.Node.Nodes, false); while (enumerator.MoveNext()) { if (_threeState) { enumerator.Current.CheckState = e.Node.CheckState; } else { enumerator.Current.Checked = e.Node.Checked; } } ComboTreeNode parent = e.Node.Parent; while (parent != null) { parent.CheckState = parent.GetAggregateCheckState(); parent = parent.Parent; } } _recurseDepth--; } Invalidate(); OnAfterCheck(e); }
internal static IEnumerator <ComboTreeNode> GetNodesRecursive(ComboTreeNodeCollection collection, bool reverse) { if (!reverse) { for (int i = 0; i < collection.Count; i++) { yield return(collection[i]); IEnumerator <ComboTreeNode> e = GetNodesRecursive(collection[i].Nodes, reverse); while (e.MoveNext()) { yield return(e.Current); } } } else { for (int i = (collection.Count - 1); i >= 0; i--) { IEnumerator <ComboTreeNode> e = GetNodesRecursive(collection[i].Nodes, reverse); while (e.MoveNext()) { yield return(e.Current); } yield return(collection[i]); } } }
/// <summary> /// Returns the <see cref="ComboTreeNode"/> that corresponds to the specified path string. /// </summary> /// <param name="path">The path string.</param> /// <param name="pathSeparator">The path separator.</param> /// <param name="useNodeNamesForPath">Whether the path is constructed from the name of the node instead of its text.</param> /// <returns>The node, or null if the path is empty.</returns> internal ComboTreeNode ParsePath(string path, string pathSeparator, bool useNodeNamesForPath) { ComboTreeNode select = null; string[] parts = path.Split(new string[] { pathSeparator }, StringSplitOptions.RemoveEmptyEntries); for (int i = 0; i < parts.Length; i++) { ComboTreeNodeCollection collection = ((select == null) ? this : select.Nodes); if (useNodeNamesForPath) { try { select = collection[parts[i]]; } catch (KeyNotFoundException ex) { throw new ArgumentException("Invalid path string.", "value", ex); } } else { bool found = false; foreach (ComboTreeNode node in collection) { if (node.Text.Equals(parts[i], StringComparison.InvariantCultureIgnoreCase)) { select = node; found = true; break; } } if (!found) throw new ArgumentException("Invalid path string.", "value"); } } return select; }
/// <summary> /// Converts a TreeNodeCollection to a ComboTreeNodeCollection /// </summary> /// <param name="tnc"></param> /// <returns></returns> public static ComboTreeNodeCollection ConvertFromTreeNodeCollection(TreeNodeCollection tnc) { ComboTreeNodeCollection ctnc = null; for (int i = 0; i < tnc.Count; i++) { TreeNode tn = tnc[i]; ComboTreeNode ctn = new ComboTreeNode(); ctn.Text = tn.Text; ctn.Tag = tn.Tag; ctn.Name = tn.Name; ctn.Expanded = tn.IsExpanded; ctn.Nodes.AddRange(ConvertFromTreeNodeCollection(tn.Nodes)); ctn.Parent = ConvertFromTreeNode(tn.Parent); ctn.ToolTip = tn.ToolTipText; ctn.Checked = tn.Checked; if (ctnc == null) { ctnc = new ComboTreeNodeCollection(ctn); } else { ctnc.Add(ctn); } } return(ctnc); }
public static void RecursivelyForEach(this ComboTreeNodeCollection source, Action <ComboTreeNode> action) { foreach (var n in source) { action(n); n.Nodes.RecursivelyForEach(action); } }
/// <summary> /// Initialises a new instance of the <see cref="ComboTreeBoxColumn"/> class. /// </summary> public ComboTreeBoxColumn() { PathSeparator = ComboTreeBox.DEFAULT_PATH_SEPARATOR; UseNodeNamesForPath = false; Nodes = new ComboTreeNodeCollection(null); ExpandedImageIndex = ImageIndex = 0; ExpandedImageKey = ImageKey = String.Empty; CellTemplate = new ComboTreeBoxCell(); }
public static IEnumerable <T> RecursivelySelect <T>(this ComboTreeNodeCollection source, Func <ComboTreeNode, T> selector) { foreach (var n in source) { yield return(selector(n)); n.Nodes.RecursivelySelect(selector); } }
/// <summary> /// Initialises a new instance of ComboTreeNode using default (empty) values. /// </summary> public ComboTreeNode() { nodes = new ComboTreeNodeCollection(this); name = text = String.Empty; fontStyle = FontStyle.Regular; expandedImageIndex = imageIndex = -1; expandedImageKey = imageKey = String.Empty; expanded = false; }
/// <summary> /// Initialises a new instance of ComboTreeNode using default (empty) values. /// </summary> public ComboTreeNode() { _nodes = new ComboTreeNodeCollection(this); _name = _text = String.Empty; _fontStyle = FontStyle.Regular; _expandedImageIndex = _imageIndex = -1; _expandedImageKey = _imageKey = String.Empty; _expanded = false; }
private void AddNode(ComboTreeNodeCollection nodes, KindOfGoods kind) { var node = new ComboTreeNode(kind.Name) { Tag = kind, Expanded = true }; nodes.Add(node); kind.SubKinds.ForEach(k => this.AddNode(node.Nodes, k)); }
public static ComboTreeNode RecursivelyFirstOrDefault(this ComboTreeNodeCollection source, Func <ComboTreeNode, bool> predicate) { foreach (var n in source) { if (predicate(n)) { return(n); } var node = n.Nodes.RecursivelyFirstOrDefault(predicate); if (node != null) { return(node); } } return(null); }
/// <summary> /// Initialises a new instance of the <see cref="DropDownSearchBox"/> class using default values. /// </summary> public DropDownSearchBox() { _services = new TextServices(this, GetTextBoxBounds); DropDownStyle = DropDownControlStyles.FakeEditable; ShowGlyphs = false; _normalNodes = new ComboTreeNodeCollection(null); MinSearchTermLength = 3; DropDownHeight = 300; _services.TextChanged += _services_TextChanged; _services.ContextMenuClosed += _services_ContextMenuClosed; _services.ContextMenuOpening += _services_ContextMenuOpening; DropDownControl.KeyDown += DropDownControl_KeyDown; DropDownControl.KeyPress += DropDownControl_KeyPress; DropDownControl.MouseMove += DropDownControl_MouseMove; }
/// <summary> /// Initalises a new instance of ComboTreeBox. /// </summary> public ComboTreeBox() { // default property values nullValue = String.Empty; pathSeparator = @"\"; expandedImageIndex = imageIndex = 0; expandedImageKey = imageKey = String.Empty; // nodes collection nodes = new ComboTreeNodeCollection(null); nodes.CollectionChanged += new NotifyCollectionChangedEventHandler(nodes_CollectionChanged); // dropdown portion dropDown = new ComboTreeDropDown(this); dropDown.Opened += new EventHandler(dropDown_Opened); dropDown.Closed += new ToolStripDropDownClosedEventHandler(dropDown_Closed); dropDown.UpdateVisibleItems(); }
/// <summary> /// Initalises a new instance of ComboTreeBox. /// </summary> public ComboTreeBox() { // default property values _nullValue = String.Empty; _pathSeparator = DEFAULT_PATH_SEPARATOR; _checkedNodeSeparator = DEFAULT_CHECKED_NODE_SEPARATOR; _expandedImageIndex = _imageIndex = 0; _expandedImageKey = _imageKey = String.Empty; _cascadeCheckState = true; _showGlyphs = true; // nodes collection Nodes = new ComboTreeNodeCollection(null); // dropdown portion _dropDown = new ComboTreeDropDown(this); _dropDown.Opened += new EventHandler(dropDown_Opened); _dropDown.Closed += new ToolStripDropDownClosedEventHandler(dropDown_Closed); _dropDown.UpdateVisibleItems(); }
/// <summary> /// Initalises a new instance of ComboTreeBox. /// </summary> public ComboTreeBox() { // default property values _nullValue = String.Empty; _pathSeparator = DEFAULT_PATH_SEPARATOR; _checkedNodeSeparator = DEFAULT_CHECKED_NODE_SEPARATOR; _expandedImageIndex = _imageIndex = 0; _expandedImageKey = _imageKey = String.Empty; _cascadeCheckState = true; // nodes collection _nodes = new ComboTreeNodeCollection(null); _nodes.CollectionChanged += new NotifyCollectionChangedEventHandler(nodes_CollectionChanged); _nodes.AfterCheck += new EventHandler<ComboTreeNodeEventArgs>(nodes_AfterCheck); // dropdown portion _dropDown = new ComboTreeDropDown(this); _dropDown.Opened += new EventHandler(dropDown_Opened); _dropDown.Closed += new ToolStripDropDownClosedEventHandler(dropDown_Closed); _dropDown.UpdateVisibleItems(); }
/// <summary> /// Returns the previous selectable node, relative to the selected node. /// </summary> /// <returns></returns> public ComboTreeNode GetPrevSelectableNode() { bool started = false; IEnumerator <ComboTreeNode> e = ComboTreeNodeCollection.GetNodesRecursive(_nodes, true); while (e.MoveNext()) { if (started || (_selectedNode == null)) { if (IsNodeVisible(e.Current) && e.Current.Selectable) { return(e.Current); } } else if (e.Current == _selectedNode) { started = true; } } return(null); }
/// <summary> /// Returns the next displayable node, relative to the selected node. /// </summary> /// <returns></returns> private ComboTreeNode GetNextDisplayedNode() { bool started = false; IEnumerator <ComboTreeNode> e = ComboTreeNodeCollection.GetNodesRecursive(_nodes, false); while (e.MoveNext()) { if (started || (_selectedNode == null)) { if (IsNodeVisible(e.Current)) { return(e.Current); } } else if (e.Current == _selectedNode) { started = true; } } return(null); }
void dsbListItems_PerformSearch(object sender, PerformSearchEventArgs e) { if (chkRetainGroups.Checked) { foreach (ComboTreeNode node in dsbListItems.AllNormalNodes) { e.CancellationToken.ThrowIfCancellationRequested(); if (dsbListItems.DefaultSearchPredicate(node, e.SearchTerm)) { // get all ancestor nodes (including the result) Stack <ComboTreeNode> ancestors = new Stack <ComboTreeNode>(); ComboTreeNode current = node; while (current != null) { ancestors.Push(current); current = current.Parent; } // copy ancestor nodes into search results (or re-use existing) ComboTreeNodeCollection collection = e.Results; while (ancestors.Any()) { current = ancestors.Pop(); ComboTreeNode copy = e.Results.Find(x => dsbListItems.DefaultEquivalencePredicate(x, current), true); if (copy == null) { collection.Add(copy = current.Clone()); } collection = copy.Nodes; } } } e.Handled = true; } }
/// <summary> /// Determines all of the parameters for drawing the bitmap beside the /// specified node. If they represent a unique combination, the bitmap is /// generated and returned. Otherwise, the appropriate cached bitmap is /// returned. /// </summary> /// <param name="node"></param> /// <returns></returns> private Image GetItemBitmap(ComboTreeNode node) { BitmapInfo bitmapInfo = new BitmapInfo(); // the following factors determine the bitmap drawn: ComboTreeNodeCollection collection = GetCollectionContainingNode(node); bitmapInfo.HasChildren = (node.Nodes.Count > 0); bitmapInfo.IsLastPeer = (collection.IndexOf(node) == (collection.Count - 1)); bitmapInfo.IsFirst = (node == _sourceControl.Nodes[0]); bitmapInfo.NodeDepth = node.Depth; bitmapInfo.NodeExpanded = node.Expanded && bitmapInfo.HasChildren; bitmapInfo.ImageIndex = bitmapInfo.NodeExpanded ? node.ExpandedImageIndex : node.ImageIndex; bitmapInfo.ImageKey = bitmapInfo.NodeExpanded ? node.ExpandedImageKey : node.ImageKey; bitmapInfo.VerticalLines = new bool[bitmapInfo.NodeDepth]; ComboTreeNode parent = node; int i = 0; while ((parent = parent.Parent) != null) { // vertical line required if parent is expanded (and not last peer) ComboTreeNodeCollection parentCollection = GetCollectionContainingNode(parent); bitmapInfo.VerticalLines[i] = (parent.Expanded && (parentCollection.IndexOf(parent) != (parentCollection.Count - 1))); i++; } if (_bitmaps.ContainsKey(bitmapInfo)) { return(_bitmaps[bitmapInfo]); } else { return(_bitmaps[bitmapInfo] = GenerateBitmap(bitmapInfo, _sourceControl.GetNodeImage(node))); } }
/// <summary> /// Helper method for the AllNodes property. /// </summary> /// <param name="collection"></param> /// <returns></returns> private IEnumerator<ComboTreeNode> GetNodesRecursive(ComboTreeNodeCollection collection, bool reverse) { if (!reverse) { for (int i = 0; i < collection.Count; i++) { yield return collection[i]; IEnumerator<ComboTreeNode> e = GetNodesRecursive(collection[i].Nodes, reverse); while (e.MoveNext()) yield return e.Current; } } else { for (int i = (collection.Count - 1); i >= 0; i--) { IEnumerator<ComboTreeNode> e = GetNodesRecursive(collection[i].Nodes, reverse); while (e.MoveNext()) yield return e.Current; yield return collection[i]; } } }
/// <summary> /// Initialises a new instance of the <see cref="ComboTreeBoxCell"/> class. /// </summary> public ComboTreeBoxCell() { UseColumnNodes = true; _nodes = new ComboTreeNodeCollection(null); }
protected override void PerformSearch(string searchTerm, CancellationToken token, ComboTreeNodeCollection results) { string adoFilter = String.Format("Word LIKE '{0}%'", searchTerm.Replace("'", "''")); foreach (DataRow dr in _table.Select(adoFilter)) { token.ThrowIfCancellationRequested(); results.Add(new ComboTreeNode(dr.Field <string>(0))); } }
void _services_TextChanged(object sender, EventArgs e) { // cancel any existing search operation if (_cts != null) { _cts.Cancel(); _cts.Dispose(); _cts = null; } if (_services.Length > 0) { if (!_inSearchMode) { EnterSearchMode(); } if (_services.Length >= MinSearchTermLength) { // start async search operation BeginUpdate(); Nodes.Clear(); Nodes.Add(new ComboTreeNode("Searching...") { Selectable = false, FontStyle = FontStyle.Italic }); EndUpdate(); _cts = new CancellationTokenSource(); ComboTreeNodeCollection results = new ComboTreeNodeCollection(null); var task = Task.Factory.StartNew(() => OnPerformSearch(new PerformSearchEventArgs(_services.Text, _cts.Token, results)), _cts.Token); task.ContinueWith(t => { if (t.IsFaulted) { results.Clear(); string errorText = t.Exception.InnerExceptions.Select(x => x.Message).FirstOrDefault() ?? "an error occured"; results.Add(new ComboTreeNode(String.Format("({0})", errorText)) { Selectable = false, FontStyle = FontStyle.Italic }); } if (!t.IsCanceled) { ApplySearchResults(results); } }); } else { // wait until the search term is long enough BeginUpdate(); Nodes.Clear(); string msg = String.Format("(type at least {0} characters)", MinSearchTermLength); Nodes.Add(new ComboTreeNode(msg) { Selectable = false, FontStyle = FontStyle.Italic }); EndUpdate(); } } else { if (_inSearchMode) { LeaveSearchMode(false); } } }
/// <summary> /// Initialises a new instance of the <see cref="PerformSearchEventArgs"/> class using the specified values. /// </summary> /// <param name="searchTerm"></param> /// <param name="token"></param> /// <param name="results"></param> public PerformSearchEventArgs(string searchTerm, CancellationToken token, ComboTreeNodeCollection results) : base(false) { SearchTerm = searchTerm; CancellationToken = token; Results = results; }