/// <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 = @"\";
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);
}
/// <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="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();
}
/// <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;
}
