private TreeNodeCollection nodes;
private TreeViewAction selection_action;
- private TreeNode selected_node;
+ internal TreeNode selected_node;
private TreeNode pre_selected_node;
private TreeNode focused_node;
- private TreeNode highlighted_node;
+ internal TreeNode highlighted_node;
private Rectangle mouse_rect;
private bool select_mmove;
private bool hide_selection = true;
private int max_visible_order = -1;
- private VScrollBar vbar;
- private HScrollBar hbar;
+ internal VScrollBar vbar;
+ internal HScrollBar hbar;
private bool vbar_bounds_set;
private bool hbar_bounds_set;
internal int skipped_nodes;
private Color line_color;
private StringFormat string_format;
- private int drag_begin_x = 0;
- private int drag_begin_y = 0;
+ private int drag_begin_x = -1;
+ private int drag_begin_y = -1;
private long handle_count = 1;
private TreeViewDrawMode draw_mode;
#region Public Constructors
public TreeView ()
{
+ vbar = new ImplicitVScrollBar ();
+ hbar = new ImplicitHScrollBar ();
+
InternalBorderStyle = BorderStyle.Fixed3D;
base.background_color = ThemeEngine.Current.ColorWindow;
base.foreground_color = ThemeEngine.Current.ColorWindowText;
+ draw_mode = TreeViewDrawMode.Normal;
root_node = new TreeNode (this);
root_node.Text = "ROOT NODE";
string_format.LineAlignment = StringAlignment.Center;
string_format.Alignment = StringAlignment.Center;
- vbar = new ImplicitVScrollBar ();
- hbar = new ImplicitHScrollBar ();
-
vbar.Visible = false;
hbar.Visible = false;
vbar.ValueChanged += new EventHandler (VScrollBarValueChanged);
root_node.CollapseAllUncheck ();
Invalidate ();
+#if NET_2_0
+ // UIA Framework Event: CheckBoxes Changed
+ OnUIACheckBoxesChanged (EventArgs.Empty);
+#endif
}
}
[DefaultValue(false)]
public bool LabelEdit {
get { return label_edit; }
- set { label_edit = value; }
+ set {
+ label_edit = value;
+#if NET_2_0
+ // UIA Framework Event: LabelEdit Changed
+ OnUIALabelEditChanged (EventArgs.Empty);
+#endif
+ }
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
#endif
#endregion // Public Instance Properties
+ #region UIA Framework Properties
+
+#if NET_2_0
+ internal ScrollBar UIAHScrollBar {
+ get { return hbar; }
+ }
+
+ internal ScrollBar UIAVScrollBar {
+ get { return vbar; }
+ }
+#endif
+ #endregion // UIA Framework Properties
+
#region Protected Instance Properties
protected override CreateParams CreateParams {
get {
#if NET_2_0
public void Sort ()
{
- Sort (Nodes.Count >= 2 ? tree_view_node_sorter : null);
+ Sort (tree_view_node_sorter);
}
#endif
void Sort (IComparer sorter)
{
+ sorted = true;
Nodes.Sort (sorter);
RecalculateVisibleOrder (root_node);
UpdateScrollBars (false);
} else {
RecalculateVisibleOrder (root_node);
UpdateScrollBars (true);
- SetTop (Nodes [Nodes.Count - 1]);
- SelectedNode = Nodes [Nodes.Count - 1];
+
+ // Only move the top node if we now have a scrollbar
+ if (vbar.VisibleInternal) {
+ SetTop (Nodes [Nodes.Count - 1]);
+ SelectedNode = Nodes [Nodes.Count - 1];
+ }
}
}
public void CollapseAll ()
{
- TreeNode walk = TopNode;
-
- while (walk.parent != root_node)
- walk = walk.parent;
-
BeginUpdate ();
root_node.CollapseAll ();
EndUpdate ();
- SetTop (walk);
+ if (vbar.VisibleInternal)
+ vbar.Value = vbar.Maximum - VisibleCount + 1;
}
public TreeNode GetNodeAt (Point pt) {
}
- public int GetNodeCount (bool include_subtrees) {
- return root_node.GetNodeCount (include_subtrees);
+ public int GetNodeCount (bool includeSubTrees) {
+ return root_node.GetNodeCount (includeSubTrees);
}
#if NET_2_0
return new TreeViewHitTestInfo (n, TreeViewHitTestLocations.Label);
else if (IsPlusMinusArea (n, x))
return new TreeViewHitTestInfo (n, TreeViewHitTestLocations.PlusMinus);
- else if (checkboxes && IsCheckboxArea (n, x))
+ else if ((checkboxes || n.StateImage != null) && IsCheckboxArea (n, x))
return new TreeViewHitTestInfo (n, TreeViewHitTestLocations.StateImage);
else if (x > n.Bounds.Right)
return new TreeViewHitTestInfo (n, TreeViewHitTestLocations.RightOfLabel);
public override string ToString () {
int count = Nodes.Count;
if (count <= 0)
- return String.Concat (base.ToString (), "Node Count: 0");
- return String.Concat (base.ToString (), "Node Count: ", count, " Nodes[0]: ", Nodes [0]);
+ return String.Concat (base.ToString (), ", Nodes.Count: 0");
+ return String.Concat (base.ToString (), ", Nodes.Count: ", count, ", Nodes[0]: ", Nodes [0]);
}
return node.prop_bag;
}
- protected override bool IsInputKey (Keys key_data)
+ protected override bool IsInputKey (Keys keyData)
{
- if (IsHandleCreated && (key_data & Keys.Alt) == 0) {
- switch (key_data & Keys.KeyCode) {
+ if (IsHandleCreated && (keyData & Keys.Alt) == 0) {
+ switch (keyData & Keys.KeyCode) {
case Keys.Left:
case Keys.Up:
case Keys.Right:
break;
}
}
- return base.IsInputKey (key_data);
+ return base.IsInputKey (keyData);
}
protected override void OnKeyDown (KeyEventArgs e)
break;
case Keys.Left:
if (selected_node != null) {
- if (selected_node.IsExpanded)
+ if (selected_node.IsExpanded && selected_node.Nodes.Count > 0)
selected_node.Collapse ();
else {
TreeNode parent = selected_node.Parent;
#endregion // Protected Instance Methods
#region Internal & Private Methods and Properties
+ internal override bool ScaleChildrenInternal {
+ get { return false; }
+ }
+
internal IntPtr CreateNodeHandle ()
{
return (IntPtr) handle_count++;
l -= ImageList.ImageSize.Width + 3;
if (checkboxes)
l -= 19;
+#if NET_2_0
+ // StateImage is basically a custom checkbox
+ else if (node.StateImage != null)
+ l -= 19;
+#endif
return (x > l && x < l + 8);
}
return (x > l && x < l + 10);
}
+#if NET_2_0
private bool IsImage (TreeNode node, int x)
{
if (ImageList == null)
return false;
}
+#endif
private int CheckBoxLeft (TreeNode node)
{
if (show_root_lines || node.Parent != null)
l -= indent;
+
+ if (!show_root_lines && node.Parent == null)
+ l -= indent;
+
if (ImageList != null)
l -= ImageList.ImageSize.Width + 3;
}
}
- private void DrawNodePlusMinus (TreeNode node, Graphics dc, int x, int middle)
- {
- int height = ActualItemHeight - 2;
- dc.FillRectangle (ThemeEngine.Current.ResPool.GetSolidBrush (BackColor), (x + 4) - (height / 2), node.GetY() + 1, height, height);
-
- dc.DrawRectangle (SystemPens.ControlDarkDark, x, middle - 4, 8, 8);
-
- if (node.IsExpanded) {
- dc.DrawLine (SystemPens.ControlDarkDark, x + 2, middle, x + 6, middle);
- } else {
- dc.DrawLine (SystemPens.ControlDarkDark, x + 2, middle, x + 6, middle);
- dc.DrawLine (SystemPens.ControlDarkDark, x + 4, middle - 2, x + 4, middle + 2);
- }
- }
-
#if NET_2_0
private void DrawNodeState (TreeNode node, Graphics dc, int x, int y)
{
int check_size = 5;
int lineWidth = 3;
- Rectangle rect = new Rectangle (x + 5, middle - 2, check_size, check_size);
+ Rectangle rect = new Rectangle (x + 4, middle - 3, check_size, check_size);
for (int i = 0; i < lineWidth; i++) {
dc.DrawLine (check_pen, rect.Left + 1, rect.Top + lineWidth + i, rect.Left + 3, rect.Top + 5 + i);
if (checkboxes)
radjust = 3;
- dc.DrawLine (dash, x - indent + ladjust, middle, x + radjust, middle);
+ if (show_root_lines || node.Parent != null)
+ dc.DrawLine (dash, x - indent + ladjust, middle, x + radjust, middle);
if (node.PrevNode != null || node.Parent != null) {
ladjust = 9;
private void DrawNodeImage (TreeNode node, Graphics dc, Rectangle clip, int x, int y)
{
- // Rectangle r = new Rectangle (x, y + 2, ImageList.ImageSize.Width, ImageList.ImageSize.Height);
-
if (!RectsIntersect (clip, x, y, ImageList.ImageSize.Width, ImageList.ImageSize.Height))
return;
- if (ImageList == null)
- return;
-
- int use_index = -1;
-
- if (!node.IsSelected) {
- if (node.ImageIndex > -1 && node.ImageIndex < ImageList.Images.Count) {
- use_index = node.ImageIndex;
- } else if (ImageIndex > -1 && ImageIndex < ImageList.Images.Count) {
- use_index = ImageIndex;
- }
- } else {
- if (node.SelectedImageIndex > -1 && node.SelectedImageIndex < ImageList.Images.Count) {
- use_index = node.SelectedImageIndex;
- } else if (SelectedImageIndex > -1 && SelectedImageIndex < ImageList.Images.Count) {
- use_index = SelectedImageIndex;
- }
- }
-
-#if NET_2_0
-
- if (!node.IsSelected) {
- if (use_index == -1 && !String.IsNullOrEmpty (node.ImageKey)) {
- use_index = image_list.Images.IndexOfKey (node.ImageKey);
- }
-
- if (use_index == -1 && !String.IsNullOrEmpty (ImageKey)) {
- use_index = image_list.Images.IndexOfKey (ImageKey);
- }
- } else {
- if (use_index == -1 && !String.IsNullOrEmpty (node.SelectedImageKey)) {
- use_index = image_list.Images.IndexOfKey (node.SelectedImageKey);
- }
-
- if (use_index == -1 && !String.IsNullOrEmpty (SelectedImageKey)) {
- use_index = image_list.Images.IndexOfKey (SelectedImageKey);
- }
- }
-#endif
-
- if (use_index == -1 && ImageList.Images.Count > 0) {
- use_index = 0;
- }
+ int use_index = node.Image;
- if (use_index != -1) {
- ImageList.Draw (dc, x, y, ImageList.ImageSize.Width,
- ImageList.ImageSize.Height, use_index);
- }
+ if (use_index > -1 && use_index < ImageList.Images.Count)
+ ImageList.Draw (dc, x, y, ImageList.ImageSize.Width, ImageList.ImageSize.Height, use_index);
}
private void LabelEditFinished (object sender, EventArgs e)
Focus ();
}
+ //
+ // If we get a call to BeginEdit from any AfterLabelEdit handler,
+ // the focus seems to always remain in the TreeView. This call seems
+ // to synchronize the focus events - I don't like it but it works
+ //
+ Application.DoEvents ();
+
if (edit_node != null && edit_node == node) {
+ edit_node = null;
+
NodeLabelEditEventArgs e = new NodeLabelEditEventArgs (edit_args.Node, edit_args.Label);
OnAfterLabelEdit (e);
return;
if (e.Label != null)
- edit_node.Text = e.Label;
+ e.Node.Text = e.Label;
}
+ // EndEdit ends editing even if not called on the editing node
edit_node = null;
UpdateNode (node);
}
return;
r.Inflate (-1, -1);
+
if (Focused && node == highlighted_node) {
- dc.FillRectangle (ThemeEngine.Current.ResPool.GetSolidBrush (ThemeEngine.Current.ColorHighlight), r);
+ // Use the node's BackColor if is not empty, and is not actually the selected one (yet)
+ Color back_color = node != selected_node && node.BackColor != Color.Empty ? node.BackColor :
+ ThemeEngine.Current.ColorHighlight;
+ dc.FillRectangle (ThemeEngine.Current.ResPool.GetSolidBrush (back_color), r);
+
} else if (!hide_selection && node == highlighted_node) {
dc.FillRectangle (SystemBrushes.Control, r);
} else {
- dc.FillRectangle (ThemeEngine.Current.ResPool.GetSolidBrush (node.BackColor), r);
+ // If selected_node is not the current highlighted one, use the color of the TreeView
+ Color back_color = node == selected_node ? BackColor : node.BackColor;
+ dc.FillRectangle (ThemeEngine.Current.ResPool.GetSolidBrush (back_color), r);
}
}
if (draw_mode == TreeViewDrawMode.Normal || draw_mode == TreeViewDrawMode.OwnerDrawText) {
if ((show_root_lines || node.Parent != null) && show_plus_minus && child_count > 0)
- DrawNodePlusMinus (node, dc, node.GetLinesX () - Indent + 5, middle);
+ ThemeEngine.Current.TreeViewDrawNodePlusMinus (this, node, dc, node.GetLinesX () - Indent + 5, middle);
#if NET_2_0
if (checkboxes && state_image_list == null)
bool vert = false;
bool horz = false;
- int height = -1;
+ int height = 0;
int width = -1;
+ int item_height = ActualItemHeight;
if (scrollable) {
OpenTreeNodeEnumerator walk = new OpenTreeNodeEnumerator (root_node);
while (walk.MoveNext ()) {
int r = walk.CurrentNode.Bounds.Right;
- int b = walk.CurrentNode.Bounds.Bottom;
-
if (r > width)
width = r;
- if (b > height)
- height = b;
+
+ height += item_height;
}
- // Remove scroll adjustments
- if (nodes.Count > 0)
- height -= nodes [0].Bounds.Top;
+ height -= item_height; // root_node adjustment
width += hbar_offset;
if (height > ClientRectangle.Height) {
if (skipped_nodes > 0) {
int skip = Math.Min (skipped_nodes, vbar.Maximum - VisibleCount + 1);
skipped_nodes = 0;
- vbar.Value = skip;
+ vbar.SafeValueSet (skip);
skipped_nodes = skip;
}
} else {
skipped_nodes = 0;
RecalculateVisibleOrder (root_node);
vbar.Visible = false;
+ vbar.Value = 0;
vbar_bounds_set = false;
}
private void SetVScrollPos (int pos, TreeNode new_top)
{
+ if (!vbar.VisibleInternal)
+ return;
+
if (pos < 0)
pos = 0;
return;
}
- Rectangle below = new Rectangle (0, node.Bounds.Bottom, ViewportRectangle.Width,
- ViewportRectangle.Height - node.Bounds.Bottom);
+ // If node Bottom is less than 0, the node is above and not visible,
+ // and we need to scroll the entire viewport
+ int node_bottom = node.Bounds.Bottom >= 0 ? node.Bounds.Bottom : 0;
+ Rectangle below = new Rectangle (0, node_bottom, ViewportRectangle.Width,
+ ViewportRectangle.Height - node_bottom);
int amount = count_to_next * ActualItemHeight;
mouse_click_node = node;
#endif
- if (show_plus_minus && IsPlusMinusArea (node, e.X)) {
+ if (show_plus_minus && IsPlusMinusArea (node, e.X) && e.Button == MouseButtons.Left) {
node.Toggle ();
return;
- } else if (checkboxes && IsCheckboxArea (node, e.X)) {
+ } else if (checkboxes && IsCheckboxArea (node, e.X) && e.Button == MouseButtons.Left) {
node.check_reason = TreeViewAction.ByMouse;
node.Checked = !node.Checked;
UpdateNode(node);
} else if (IsSelectableArea (node, e.X) || full_row_select) {
TreeNode old_highlighted = highlighted_node;
highlighted_node = node;
- if (label_edit && e.Clicks == 1 && highlighted_node == old_highlighted) {
+ if (label_edit && e.Clicks == 1 && highlighted_node == old_highlighted && e.Button == MouseButtons.Left) {
BeginEdit (node);
} else if (highlighted_node != focused_node) {
Size ds = SystemInformation.DragSize;
focused_node = highlighted_node;
OnAfterSelect (new TreeViewEventArgs (selected_node, TreeViewAction.ByMouse));
- if (prev_focused_node != null) {
- invalid = Rectangle.Union (Bloat (prev_focused_node.Bounds),
- Bloat (prev_highlighted_node.Bounds));
- } else {
- invalid = Bloat (prev_highlighted_node.Bounds);
- }
+ if (prev_highlighted_node != null) {
+ if (prev_focused_node != null) {
+ invalid = Rectangle.Union (Bloat (prev_focused_node.Bounds),
+ Bloat (prev_highlighted_node.Bounds));
+ } else {
+ invalid = Bloat (prev_highlighted_node.Bounds);
+ }
- if (full_row_select || draw_mode != TreeViewDrawMode.Normal) {
invalid.X = 0;
invalid.Width = ViewportRectangle.Width;
+
+ Invalidate (invalid);
}
- Invalidate (invalid);
} else {
+ if (highlighted_node != null)
+ Invalidate (highlighted_node.Bounds);
+
highlighted_node = focused_node;
selected_node = focused_node;
+ if (selected_node != null)
+ Invalidate (selected_node.Bounds);
}
}
return;
Invalidate (highlighted_node.Bounds);
- Invalidate (selected_node.Bounds);
- Invalidate (focused_node.Bounds);
+ if (selected_node != null)
+ Invalidate (selected_node.Bounds);
+ if (focused_node != null)
+ Invalidate (focused_node.Bounds);
highlighted_node = selected_node;
focused_node = selected_node;
private void DoubleClickHandler (object sender, MouseEventArgs e) {
TreeNode node = GetNodeAtUseX (e.X,e.Y);
- if(node != null) {
+ if(node != null && node.Nodes.Count > 0) {
node.Toggle();
}
}
add { base.TextChanged += value; }
remove { base.TextChanged -= value; }
}
+
+ #region UIA Framework Events
+#if NET_2_0
+ static object UIACheckBoxesChangedEvent = new object ();
+
+ internal event EventHandler UIACheckBoxesChanged {
+ add { Events.AddHandler (UIACheckBoxesChangedEvent, value); }
+ remove { Events.RemoveHandler (UIACheckBoxesChangedEvent, value); }
+ }
+
+ internal void OnUIACheckBoxesChanged (EventArgs e)
+ {
+ EventHandler eh = (EventHandler) Events [UIACheckBoxesChangedEvent];
+ if (eh != null)
+ eh (this, e);
+ }
+
+ static object UIALabelEditChangedEvent = new object ();
+
+ internal event EventHandler UIALabelEditChanged {
+ add { Events.AddHandler (UIALabelEditChangedEvent, value); }
+ remove { Events.RemoveHandler (UIALabelEditChangedEvent, value); }
+ }
+
+ internal void OnUIALabelEditChanged (EventArgs e)
+ {
+ EventHandler eh = (EventHandler) Events [UIALabelEditChangedEvent];
+ if (eh != null)
+ eh (this, e);
+ }
+
+ static object UIANodeTextChangedEvent = new object ();
+
+ internal event TreeViewEventHandler UIANodeTextChanged {
+ add { Events.AddHandler (UIANodeTextChangedEvent, value); }
+ remove { Events.RemoveHandler (UIANodeTextChangedEvent, value); }
+ }
+
+ internal void OnUIANodeTextChanged (TreeViewEventArgs e)
+ {
+ TreeViewEventHandler eh =
+ (TreeViewEventHandler) Events [UIANodeTextChangedEvent];
+ if (eh != null)
+ eh (this, e);
+ }
+
+ static object UIACollectionChangedEvent = new object ();
+
+ internal event CollectionChangeEventHandler UIACollectionChanged {
+ add { Events.AddHandler (UIACollectionChangedEvent, value); }
+ remove { Events.RemoveHandler (UIACollectionChangedEvent, value); }
+ }
+
+ internal void OnUIACollectionChanged (object sender, CollectionChangeEventArgs e)
+ {
+ CollectionChangeEventHandler eh =
+ (CollectionChangeEventHandler) Events [UIACollectionChangedEvent];
+ if (eh != null) {
+ if (sender == root_node)
+ sender = this;
+ eh (sender, e);
+ }
+ }
+#endif
+ #endregion // UIA Framework Events
#endregion // Events
}
}
+
projects / mono.git / blobdiff