namespace System.Windows.Forms {
#if NET_2_0
+ [ComVisible (true)]
[Docking (DockingBehavior.Ask)]
+ [ClassInterface (ClassInterfaceType.AutoDispatch)]
#endif
[DefaultProperty("Nodes")]
[DefaultEvent("AfterSelect")]
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;
#if NET_2_0
private string image_key;
+ private bool is_hovering;
+ private TreeNode mouse_click_node;
+ private bool right_to_left_layout;
private string selected_image_key;
+ private bool show_node_tool_tips;
+ private ImageList state_image_list;
+ private TreeNode tooltip_currently_showing;
+ private ToolTip tooltip_window;
#endif
private bool full_row_select;
private bool hot_tracking;
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 (-1)]
[RelatedImageList ("ImageList")]
[RefreshProperties (RefreshProperties.Repaint)]
- //[TypeConverter (typeof (NoneExcludedImageIndexConverter))]
+ [TypeConverter (typeof (NoneExcludedImageIndexConverter))]
#else
[DefaultValue (0)]
[TypeConverter (typeof (TreeViewImageIndexConverter))]
[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)]
get { return nodes; }
}
+#if NET_2_0
+ [Browsable (false)]
+ [EditorBrowsable (EditorBrowsableState.Never)]
+ [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+ public new Padding Padding {
+ get { return base.Padding; }
+ set { base.Padding = value; }
+ }
+#endif
+
[DefaultValue("\\")]
public string PathSeparator {
get { return path_separator; }
set { path_separator = value; }
}
+#if NET_2_0
+ [Localizable (true)]
+ [DefaultValue (false)]
+ public virtual bool RightToLeftLayout {
+ get { return right_to_left_layout; }
+ set {
+ if (right_to_left_layout != value) {
+ right_to_left_layout = value;
+ OnRightToLeftLayoutChanged (EventArgs.Empty);
+ }
+ }
+ }
+#endif
+
[DefaultValue(true)]
public bool Scrollable {
get { return scrollable; }
#if NET_2_0
[DefaultValue (-1)]
[RelatedImageList ("ImageList")]
- //[TypeConverter (typeof (NoneExcludedImageIndexConverter))]
+ [TypeConverter (typeof (NoneExcludedImageIndexConverter))]
#else
[DefaultValue (0)]
[TypeConverter (typeof (TreeViewImageIndexConverter))]
return;
}
- TreeViewCancelEventArgs e = new TreeViewCancelEventArgs (value, false, selection_action);
- OnBeforeSelect (e);
+ if (value != null) {
+ TreeViewCancelEventArgs e = new TreeViewCancelEventArgs (value, false, selection_action);
+ OnBeforeSelect (e);
- if (e.Cancel)
- return;
+ if (e.Cancel)
+ return;
+ }
Rectangle invalid = Rectangle.Empty;
if (selected_node != null)
selected_node.EnsureVisible ();
- OnAfterSelect (new TreeViewEventArgs (value, TreeViewAction.Unknown));
+ if (value != null) {
+ OnAfterSelect (new TreeViewEventArgs (value, TreeViewAction.Unknown));
+ }
selection_action = TreeViewAction.Unknown;
}
}
}
}
+#if NET_2_0
+ [DefaultValue (false)]
+ public bool ShowNodeToolTips {
+ get { return show_node_tool_tips; }
+ set { show_node_tool_tips = value; }
+ }
+#endif
+
[DefaultValue(true)]
public bool ShowPlusMinus {
get { return show_plus_minus; }
}
}
+#if NET_2_0
+ [DefaultValue (null)]
+ public ImageList StateImageList {
+ get { return state_image_list; }
+ set {
+ state_image_list = value;
+ Invalidate ();
+ }
+ }
+#endif
+
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
[Bindable(false)]
[DefaultValue ("")]
[RelatedImageList ("ImageList")]
[RefreshProperties (RefreshProperties.Repaint)]
+ [TypeConverter (typeof (ImageKeyConverter))]
[Editor ("System.Windows.Forms.Design.ImageIndexEditor, " + Consts.AssemblySystem_Design, typeof (System.Drawing.Design.UITypeEditor))]
public string ImageKey {
get { return image_key; }
[DefaultValue ("")]
[RelatedImageList ("ImageList")]
[RefreshProperties (RefreshProperties.Repaint)]
+ [TypeConverter (typeof (ImageKeyConverter))]
[Editor ("System.Windows.Forms.Design.ImageIndexEditor, " + Consts.AssemblySystem_Design, typeof (System.Drawing.Design.UITypeEditor))]
public string SelectedImageKey {
get { return selected_image_key; }
#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
-#else
- private
-#endif
- void Sort ()
+ public void Sort ()
{
-#if NET_2_0
- Sort (Nodes.Count >= 2 ? tree_view_node_sorter : null);
-#else
- Sort (null);
-#endif
+ Sort (tree_view_node_sorter);
}
+#endif
void Sort (IComparer sorter)
{
+ sorted = true;
Nodes.Sort (sorter);
RecalculateVisibleOrder (root_node);
UpdateScrollBars (false);
if (!found)
return;
- if (IsHandleCreated) {
+ if (IsHandleCreated && vbar.VisibleInternal) {
vbar.Value = vbar.Maximum - VisibleCount + 1;
} else {
RecalculateVisibleOrder (root_node);
UpdateScrollBars (true);
- SetTop (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
+ public TreeViewHitTestInfo HitTest (Point pt)
+ {
+ return HitTest (pt.X, pt.Y);
+ }
+
+ public TreeViewHitTestInfo HitTest (int x, int y)
+ {
+ TreeNode n = GetNodeAt (y);
+
+ if (n == null)
+ return new TreeViewHitTestInfo (null, TreeViewHitTestLocations.None);
+
+ if (IsTextArea (n, x))
+ return new TreeViewHitTestInfo (n, TreeViewHitTestLocations.Label);
+ else if (IsPlusMinusArea (n, x))
+ return new TreeViewHitTestInfo (n, TreeViewHitTestLocations.PlusMinus);
+ 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);
+ else if (IsImage (n, x))
+ return new TreeViewHitTestInfo (n, TreeViewHitTestLocations.Image);
+ else
+ return new TreeViewHitTestInfo (null, TreeViewHitTestLocations.Indent);
+ }
+#endif
+
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 ((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:
+ case Keys.Down:
+ return true;
case Keys.Enter:
case Keys.Escape:
case Keys.Prior:
case Keys.Next:
case Keys.End:
case Keys.Home:
- case Keys.Left:
- case Keys.Up:
- case Keys.Right:
- case Keys.Down:
- return true;
+ if (edit_node != null)
+ return true;
+
+ 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;
e.Handled = true;
}
+#if NET_2_0
+ protected override void OnMouseHover (EventArgs e)
+ {
+ base.OnMouseHover (e);
+
+ is_hovering = true;
+
+ TreeNode tn = GetNodeAt (PointToClient (MousePosition));
+
+ if (tn != null)
+ MouseEnteredItem (tn);
+ }
+
+ protected override void OnMouseLeave (EventArgs e)
+ {
+ base.OnMouseLeave (e);
+
+ is_hovering = false;
+
+ if (tooltip_currently_showing != null)
+ MouseLeftItem (tooltip_currently_showing);
+ }
+
+ protected virtual void OnNodeMouseClick (TreeNodeMouseClickEventArgs e)
+ {
+ TreeNodeMouseClickEventHandler eh = (TreeNodeMouseClickEventHandler)(Events[NodeMouseClickEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
+ protected virtual void OnNodeMouseDoubleClick (TreeNodeMouseClickEventArgs e)
+ {
+ TreeNodeMouseClickEventHandler eh = (TreeNodeMouseClickEventHandler)(Events[NodeMouseDoubleClickEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
+ protected virtual void OnNodeMouseHover (TreeNodeMouseHoverEventArgs e)
+ {
+ TreeNodeMouseHoverEventHandler eh = (TreeNodeMouseHoverEventHandler)(Events[NodeMouseHoverEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+#endif
+
protected virtual void OnItemDrag (ItemDragEventArgs e)
{
ItemDragEventHandler eh = (ItemDragEventHandler)(Events [ItemDragEvent]);
if (eh != null)
eh(this, e);
}
+
+ [EditorBrowsable (EditorBrowsableState.Advanced)]
+ protected virtual void OnRightToLeftLayoutChanged (EventArgs e) {
+ EventHandler eh = (EventHandler)(Events[RightToLeftLayoutChangedEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
#endif
protected internal virtual void OnAfterCheck (TreeViewEventArgs e) {
2, val & 0xffff,
(val>>16) & 0xffff, 0));
break;
+#if NET_2_0
+ case Msg.WM_CONTEXTMENU:
+ if (WmContextMenu (ref m))
+ return;
+
+ break;
+#endif
}
base.WndProc (ref m);
}
#endregion // Protected Instance Methods
#region Internal & Private Methods and Properties
+ internal override bool ScaleChildrenInternal {
+ get { return false; }
+ }
+
internal IntPtr CreateNodeHandle ()
{
return (IntPtr) handle_count++;
}
+ // According to MSDN docs, for these to be raised,
+ // the click must occur over a TreeNode
+ internal override void HandleClick (int clicks, MouseEventArgs me)
+ {
+ if (GetNodeAt (me.Location) != null) {
+ if ((clicks > 1) && GetStyle (ControlStyles.StandardDoubleClick)) {
+#if !NET_2_0
+ OnDoubleClick(EventArgs.Empty);
+ } else {
+ OnClick(EventArgs.Empty);
+#else
+ OnDoubleClick (me);
+ OnMouseDoubleClick (me);
+ } else {
+ OnClick (me);
+ OnMouseClick (me);
+#endif
+ }
+ }
+ }
+
+ internal override bool IsInputCharInternal (char charCode)
+ {
+ return true;
+ }
+
internal TreeNode NodeFromHandle (IntPtr handle)
{
// This method is called rarely, so instead of maintaining a table
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;
+
+ int l = node.Bounds.Left;
+
+ l -= ImageList.ImageSize.Width + 5;
+
+ if (x >= l && x <= (l + ImageList.ImageSize.Width + 5))
+ return true;
+
+ return false;
+ }
+#endif
+
private int CheckBoxLeft (TreeNode node)
{
int l = node.Bounds.Left + 5;
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)
+#if NET_2_0
+ private void DrawNodeState (TreeNode node, Graphics dc, int x, int y)
{
- dc.DrawRectangle (SystemPens.ControlDarkDark, x, middle - 4, 8, 8);
-
- if (node.IsExpanded) {
- dc.DrawLine (SystemPens.ControlDarkDark, x + 2, middle, x + 6, middle);
+ if (node.Checked) {
+ if (StateImageList.Images[1] != null)
+ dc.DrawImage (StateImageList.Images[1], new Rectangle (x, y, 16, 16));
} else {
- dc.DrawLine (SystemPens.ControlDarkDark, x + 2, middle, x + 6, middle);
- dc.DrawLine (SystemPens.ControlDarkDark, x + 4, middle - 2, x + 4, middle + 2);
+ if (StateImageList.Images[0] != null)
+ dc.DrawImage (StateImageList.Images[0], new Rectangle (x, y, 16, 16));
}
}
+#endif
private void DrawNodeCheckBox (TreeNode node, Graphics dc, int x, int middle)
{
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 = node.Image;
- 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;
- }
-
- 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)
if (edit_text_box == null) {
edit_text_box = new LabelEditTextBox ();
edit_text_box.BorderStyle = BorderStyle.FixedSingle;
+ edit_text_box.Visible = false;
+ edit_text_box.EditingCancelled += new EventHandler (LabelEditCancelled);
edit_text_box.EditingFinished += new EventHandler (LabelEditFinished);
+ edit_text_box.TextChanged += new EventHandler (LabelTextChanged);
Controls.Add (edit_text_box);
}
- edit_text_box.Bounds = node.Bounds;
- edit_text_box.Width += 4;
+ node.EnsureVisible ();
+ edit_text_box.Bounds = node.Bounds;
edit_text_box.Text = node.Text;
edit_text_box.Visible = true;
edit_text_box.Focus ();
edit_text_box.SelectAll ();
- edit_args = new NodeLabelEditEventArgs (edit_node);
+ edit_args = new NodeLabelEditEventArgs (node);
OnBeforeLabelEdit (edit_args);
- if (edit_args.CancelEdit)
- EndEdit (node);
-
edit_node = node;
+
+ if (edit_args.CancelEdit) {
+ edit_node = null;
+ EndEdit (node);
+ }
+ }
+
+ private void LabelEditCancelled (object sender, EventArgs e)
+ {
+ edit_args.SetLabel (null);
+ EndEdit (edit_node);
+ }
+
+ private void LabelTextChanged (object sender, EventArgs e)
+ {
+ int width = TextRenderer.MeasureTextInternal (edit_text_box.Text, edit_text_box.Font, false).Width + 4;
+ edit_text_box.Width = width;
+
+ if (edit_args != null)
+ edit_args.SetLabel (edit_text_box.Text);
}
internal void EndEdit (TreeNode node)
{
if (edit_text_box != null && edit_text_box.Visible) {
edit_text_box.Visible = false;
+ 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) {
- OnAfterLabelEdit (edit_args);
+ edit_node = null;
- if (!edit_args.CancelEdit) {
- if (edit_args.Label != null)
- edit_node.Text = edit_args.Label;
- else
- edit_node.Text = edit_text_box.Text;
- }
+ NodeLabelEditEventArgs e = new NodeLabelEditEventArgs (edit_args.Node, edit_args.Label);
+ OnAfterLabelEdit (e);
+
+ if (e.CancelEdit)
+ return;
+
+ if (e.Label != null)
+ e.Node.Text = e.Label;
}
+
+ // EndEdit ends editing even if not called on the editing node
+ edit_node = null;
+ UpdateNode (node);
+ }
+ internal void CancelEdit (TreeNode node)
+ {
+ edit_args.SetLabel (null);
+ if (edit_text_box != null && edit_text_box.Visible) {
+ edit_text_box.Visible = false;
+ Focus ();
+ }
+
edit_node = null;
UpdateNode (node);
}
Font font = node.NodeFont;
if (node.NodeFont == null)
font = Font;
- return (int) DeviceContext.MeasureString (node.Text, font, 0, string_format).Width + 3;
+ return (int)TextRenderer.MeasureString (node.Text, font, 0, string_format).Width + 3;
}
private void DrawSelectionAndFocus(TreeNode node, Graphics dc, Rectangle r)
{
- if (Focused && focused_node == node) {
+ if (Focused && focused_node == node && !full_row_select) {
ControlPaint.DrawFocusRectangle (dc, r, ForeColor, BackColor);
}
if (draw_mode != TreeViewDrawMode.Normal)
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);
}
}
private void DrawStaticNode (TreeNode node, Graphics dc)
{
- if (!full_row_select)
+ if (!full_row_select || show_lines)
DrawSelectionAndFocus(node, dc, node.Bounds);
int y = node.GetY ();
int middle = y + (ActualItemHeight / 2);
- if (full_row_select) {
+ if (full_row_select && !show_lines) {
Rectangle r = new Rectangle (1, y, ViewportRectangle.Width - 2, ActualItemHeight);
DrawSelectionAndFocus (node, dc, 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)
+ DrawNodeCheckBox (node, dc, CheckBoxLeft (node) - 3, middle);
+
+ if (checkboxes && state_image_list != null)
+ DrawNodeState (node, dc, CheckBoxLeft (node) - 3, y);
+
+ if (!checkboxes && node.StateImage != null)
+ dc.DrawImage (node.StateImage, new Rectangle (CheckBoxLeft (node) - 3, y, 16, 16));
+#else
if (checkboxes)
DrawNodeCheckBox (node, dc, CheckBoxLeft (node) - 3, middle);
+#endif
if (show_lines)
DrawNodeLines (node, dc, clip, dash, node.GetLinesX (), y, middle);
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;
XplatUI.ScrollWindow (Handle, ViewportRectangle, 0, y_move, false);
}
- private void SetVScrollTop (TreeNode new_top)
+ /*private void SetVScrollTop (TreeNode new_top)
{
vbar.Value = new_top.visible_order - VisibleCount;
- }
+ }*/
private void HScrollBarValueChanged(object sender, EventArgs e)
{
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;
SelectedNode = pre_selected_node;
return;
}
-#if NET_2_0
+
SelectedNode = TopNode;
-#else
- if (Nodes.Count > 1)
- SelectedNode = Nodes [0];
-#endif
+
} else if (selected_node != null)
UpdateNode (selected_node);
}
if (node == null)
return;
- if (show_plus_minus && IsPlusMinusArea (node, e.X)) {
+#if NET_2_0
+ mouse_click_node = node;
+#endif
+
+ 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;
}
private void MouseUpHandler (object sender, MouseEventArgs e) {
+#if NET_2_0
+ TreeNode node = GetNodeAt (e.Y);
+
+ if (node != null && node == mouse_click_node) {
+ if (e.Clicks == 2)
+ OnNodeMouseDoubleClick (new TreeNodeMouseClickEventArgs (node, e.Button, e.Clicks, e.X, e.Y));
+ else
+ OnNodeMouseClick (new TreeNodeMouseClickEventArgs (node, e.Button, e.Clicks, e.X, e.Y));
+ }
+
+ mouse_click_node = null;
+#endif
drag_begin_x = -1;
drag_begin_y = -1;
if (!select_mmove)
return;
+ select_mmove = false;
+
if (e.Button == MouseButtons.Right && selected_node != null) {
Invalidate (highlighted_node.Bounds);
highlighted_node = selected_node;
Invalidate (selected_node.Bounds);
+ return;
}
- select_mmove = false;
TreeViewCancelEventArgs ce = new TreeViewCancelEventArgs (highlighted_node, false, TreeViewAction.ByMouse);
OnBeforeSelect (ce);
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);
}
}
private void MouseMoveHandler (object sender, MouseEventArgs e) {
-
+#if NET_2_0
+ // XXX - This should use HitTest and only fire when we are over
+ // the important parts of a node, not things like gridlines or
+ // whitespace
+ TreeNode tn = GetNodeAt (e.Location);
+
+ if (tn != tooltip_currently_showing)
+ MouseLeftItem (tooltip_currently_showing);
+
+ if (tn != null && tn != tooltip_currently_showing)
+ MouseEnteredItem (tn);
+#endif
+
if (e.Button == MouseButtons.Left || e.Button == MouseButtons.Right) {
if (drag_begin_x == -1 && drag_begin_y == -1) {
drag_begin_x = e.X;
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();
}
}
(r.Top > top + height) || (r.Bottom < top));
}
+#if NET_2_0
+ // Return true if message was handled, false to send it to base
+ private bool WmContextMenu (ref Message m)
+ {
+ Point pt;
+ TreeNode tn;
+
+ pt = new Point (LowOrder ((int)m.LParam.ToInt32 ()), HighOrder ((int)m.LParam.ToInt32 ()));
+
+ // This means it's a keyboard menu request
+ if (pt.X == -1 || pt.Y == -1) {
+ tn = SelectedNode;
+
+ if (tn == null)
+ return false;
+
+ pt = new Point (tn.Bounds.Left, tn.Bounds.Top + (tn.Bounds.Height / 2));
+ } else {
+ pt = PointToClient (pt);
+
+ tn = GetNodeAt (pt);
+
+ if (tn == null)
+ return false;
+ }
+
+ // At this point, we have a valid TreeNode
+ if (tn.ContextMenu != null) {
+ tn.ContextMenu.Show (this, pt);
+ return true;
+ } else if (tn.ContextMenuStrip != null) {
+ tn.ContextMenuStrip.Show (this, pt);
+ return true;
+ }
+
+ // The node we found did not have its own menu, let the parent try to display its menu
+ return false;
+ }
+#endif
+
+ #region Stuff for ToolTips
+#if NET_2_0
+ private void MouseEnteredItem (TreeNode item)
+ {
+ tooltip_currently_showing = item;
+
+ if (!is_hovering)
+ return;
+
+ if (ShowNodeToolTips && !string.IsNullOrEmpty (tooltip_currently_showing.ToolTipText))
+ ToolTipWindow.Present (this, tooltip_currently_showing.ToolTipText);
+
+ OnNodeMouseHover (new TreeNodeMouseHoverEventArgs (tooltip_currently_showing));
+ }
+
+ private void MouseLeftItem (TreeNode item)
+ {
+ ToolTipWindow.Hide (this);
+ tooltip_currently_showing = null;
+ }
+
+ private ToolTip ToolTipWindow {
+ get {
+ if (tooltip_window == null)
+ tooltip_window = new ToolTip ();
+
+ return tooltip_window;
+ }
+ }
+#endif
+ #endregion
+
#endregion // Internal & Private Methods and Properties
#region Events
static object DrawNodeEvent = new object ();
static object NodeMouseClickEvent = new object ();
static object NodeMouseDoubleClickEvent = new object();
+ static object NodeMouseHoverEvent = new object ();
+ static object RightToLeftLayoutChangedEvent = new object ();
#endif
public event ItemDragEventHandler ItemDrag {
add { Events.AddHandler (NodeMouseDoubleClickEvent, value); }
remove { Events.RemoveHandler (NodeMouseDoubleClickEvent, value); }
}
+
+ public event TreeNodeMouseHoverEventHandler NodeMouseHover {
+ add { Events.AddHandler (NodeMouseHoverEvent, value); }
+ remove { Events.RemoveHandler (NodeMouseHoverEvent, value); }
+ }
+
+ public event EventHandler RightToLeftLayoutChanged {
+ add { Events.AddHandler (RightToLeftLayoutChangedEvent, value); }
+ remove { Events.RemoveHandler (RightToLeftLayoutChangedEvent, value); }
+ }
#endif
[Browsable (false)]
remove { base.BackgroundImageChanged -= value; }
}
+#if NET_2_0
+ [Browsable (false)]
+ [EditorBrowsable (EditorBrowsableState.Never)]
+ public new event EventHandler BackgroundImageLayoutChanged {
+ add { base.BackgroundImageLayoutChanged += value; }
+ remove { base.BackgroundImageLayoutChanged -= value; }
+ }
+
+ [Browsable (false)]
+ [EditorBrowsable (EditorBrowsableState.Never)]
+ public new event EventHandler PaddingChanged {
+ add { base.PaddingChanged += value; }
+ remove { base.PaddingChanged -= value; }
+ }
+#endif
+
[EditorBrowsable (EditorBrowsableState.Never)]
[Browsable (false)]
public new event PaintEventHandler Paint {
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