4 // Permission is hereby granted, free of charge, to any person obtaining
5 // a copy of this software and associated documentation files (the
6 // "Software"), to deal in the Software without restriction, including
7 // without limitation the rights to use, copy, modify, merge, publish,
8 // distribute, sublicense, and/or sell copies of the Software, and to
9 // permit persons to whom the Software is furnished to do so, subject to
10 // the following conditions:
12 // The above copyright notice and this permission notice shall be
13 // included in all copies or substantial portions of the Software.
15 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
19 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
20 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
21 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 // Copyright (c) 2006 Jonathan Pobst
26 // Jonathan Pobst (monkey@jpobst.com)
31 using System.Runtime.InteropServices;
32 using System.ComponentModel;
34 using System.Windows.Forms.Layout;
35 using System.Collections.Generic;
36 using System.ComponentModel.Design.Serialization;
38 namespace System.Windows.Forms
41 [ClassInterface (ClassInterfaceType.AutoDispatch)]
42 [DefaultEvent ("ItemClicked")]
43 [DefaultProperty ("Items")]
44 [Designer ("System.Windows.Forms.Design.ToolStripDesigner, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.IDesigner")]
45 [DesignerSerializer ("System.Windows.Forms.Design.ToolStripCodeDomSerializer, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.Serialization.CodeDomSerializer, " + Consts.AssemblySystem_Design)]
46 public class ToolStrip : ScrollableControl, IComponent, IDisposable
48 #region Private Variables
49 private bool allow_item_reorder;
50 private bool allow_merge;
51 private Color back_color;
52 private bool can_overflow;
53 private ToolStrip currently_merged_with;
54 private ToolStripDropDownDirection default_drop_down_direction;
55 internal ToolStripItemCollection displayed_items;
56 private Color fore_color;
57 private Padding grip_margin;
58 private ToolStripGripStyle grip_style;
59 private List<ToolStripItem> hidden_merged_items;
60 private ImageList image_list;
61 private Size image_scaling_size;
62 private bool is_currently_merged;
63 private ToolStripItemCollection items;
64 private bool keyboard_active;
65 private LayoutEngine layout_engine;
66 private LayoutSettings layout_settings;
67 private ToolStripLayoutStyle layout_style;
68 private Orientation orientation;
69 private ToolStripOverflowButton overflow_button;
70 private List<ToolStripItem> pre_merge_items;
71 private ToolStripRenderer renderer;
72 private ToolStripRenderMode render_mode;
73 private ToolStripTextDirection text_direction;
74 private Timer tooltip_timer;
75 private ToolTip tooltip_window;
76 private bool show_item_tool_tips;
79 private ToolStripItem mouse_currently_over;
80 internal bool menu_selected;
81 private ToolStripItem tooltip_currently_showing;
84 #region Public Constructors
85 public ToolStrip () : this (null)
89 public ToolStrip (params ToolStripItem[] items) : base ()
91 SetStyle (ControlStyles.AllPaintingInWmPaint, true);
92 SetStyle (ControlStyles.OptimizedDoubleBuffer, true);
93 SetStyle (ControlStyles.Selectable, false);
94 SetStyle (ControlStyles.SupportsTransparentBackColor, true);
96 this.SuspendLayout ();
98 this.items = new ToolStripItemCollection (this, items, true);
99 this.allow_merge = true;
100 base.AutoSize = true;
101 this.back_color = Control.DefaultBackColor;
102 this.can_overflow = true;
103 base.CausesValidation = false;
104 this.default_drop_down_direction = ToolStripDropDownDirection.BelowRight;
105 this.displayed_items = new ToolStripItemCollection (this, null, true);
106 this.Dock = this.DefaultDock;
107 base.Font = new Font ("Tahoma", 8.25f);
108 this.fore_color = Control.DefaultForeColor;
109 this.grip_margin = this.DefaultGripMargin;
110 this.grip_style = ToolStripGripStyle.Visible;
111 this.image_scaling_size = new Size (16, 16);
112 this.layout_style = ToolStripLayoutStyle.HorizontalStackWithOverflow;
113 this.orientation = Orientation.Horizontal;
114 if (!(this is ToolStripDropDown))
115 this.overflow_button = new ToolStripOverflowButton (this);
116 this.renderer = null;
117 this.render_mode = ToolStripRenderMode.ManagerRenderMode;
118 this.show_item_tool_tips = this.DefaultShowItemToolTips;
119 base.TabStop = false;
120 this.text_direction = ToolStripTextDirection.Horizontal;
121 this.ResumeLayout ();
124 // Register with the ToolStripManager
125 ToolStripManager.AddToolStrip (this);
129 #region Public Properties
131 public override bool AllowDrop {
132 get { return base.AllowDrop; }
133 set { base.AllowDrop = value; }
137 [DefaultValue (false)]
138 public bool AllowItemReorder {
139 get { return this.allow_item_reorder; }
140 set { this.allow_item_reorder = value; }
143 [DefaultValue (true)]
144 public bool AllowMerge {
145 get { return this.allow_merge; }
146 set { this.allow_merge = false; }
149 public override AnchorStyles Anchor {
150 get { return base.Anchor; }
151 set { base.Anchor = value; }
155 [EditorBrowsable (EditorBrowsableState.Never)]
156 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
157 public override bool AutoScroll {
158 get { return base.AutoScroll; }
159 set { base.AutoScroll = value; }
163 [EditorBrowsable (EditorBrowsableState.Never)]
164 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
165 public new Size AutoScrollMargin {
166 get { return base.AutoScrollMargin; }
167 set { base.AutoScrollMargin = value; }
171 [EditorBrowsable (EditorBrowsableState.Never)]
172 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
173 public new Size AutoScrollMinSize {
174 get { return base.AutoScrollMinSize; }
175 set { base.AutoScrollMinSize = value; }
179 [EditorBrowsable (EditorBrowsableState.Never)]
180 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
181 public new Point AutoScrollPosition {
182 get { return base.AutoScrollPosition; }
183 set { base.AutoScrollPosition = value; }
186 [DesignerSerializationVisibility (DesignerSerializationVisibility.Visible)]
188 [EditorBrowsable (EditorBrowsableState.Always)]
189 [DefaultValue (true)]
190 public override bool AutoSize {
191 get { return base.AutoSize; }
192 set { base.AutoSize = value; }
195 new public Color BackColor {
196 get { return this.back_color; }
197 set { this.back_color = value; }
200 public override BindingContext BindingContext {
201 get { return base.BindingContext; }
202 set { base.BindingContext = value; }
205 [DefaultValue (true)]
206 public bool CanOverflow {
207 get { return this.can_overflow; }
208 set { this.can_overflow = value; }
212 [DefaultValue (false)]
213 public new bool CausesValidation {
214 get { return base.CausesValidation; }
215 set { base.CausesValidation = value; }
218 [EditorBrowsable (EditorBrowsableState.Never)]
219 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
220 public new ControlCollection Controls {
221 get { return base.Controls; }
225 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
226 public override Cursor Cursor {
227 get { return base.Cursor; }
228 set { base.Cursor = value; }
232 public virtual ToolStripDropDownDirection DefaultDropDownDirection {
233 get { return this.default_drop_down_direction; }
235 if (!Enum.IsDefined (typeof (ToolStripDropDownDirection), value))
236 throw new InvalidEnumArgumentException (string.Format ("Enum argument value '{0}' is not valid for ToolStripDropDownDirection", value));
238 this.default_drop_down_direction = value;
242 public override Rectangle DisplayRectangle {
244 if (this.orientation == Orientation.Horizontal)
245 if (this.grip_style == ToolStripGripStyle.Hidden || this.layout_style == ToolStripLayoutStyle.Flow || this.layout_style == ToolStripLayoutStyle.Table)
246 return new Rectangle (this.Padding.Left, this.Padding.Top, this.Width - this.Padding.Horizontal, this.Height - this.Padding.Vertical);
248 return new Rectangle (this.GripRectangle.Right + this.GripMargin.Right, this.Padding.Top, this.Width - this.Padding.Horizontal - this.GripRectangle.Right - this.GripMargin.Right, this.Height - this.Padding.Vertical);
250 if (this.grip_style == ToolStripGripStyle.Hidden || this.layout_style == ToolStripLayoutStyle.Flow || this.layout_style == ToolStripLayoutStyle.Table)
251 return new Rectangle (this.Padding.Left, this.Padding.Top, this.Width - this.Padding.Horizontal, this.Height - this.Padding.Vertical);
253 return new Rectangle (this.Padding.Left, this.GripRectangle.Bottom + this.GripMargin.Bottom + this.Padding.Top, this.Width - this.Padding.Horizontal, this.Height - this.Padding.Vertical - this.GripRectangle.Bottom - this.GripMargin.Bottom);
257 [DefaultValue (DockStyle.Top)]
258 public override DockStyle Dock {
259 get { return base.Dock; }
261 if (base.Dock != value) {
266 case DockStyle.Bottom:
268 this.LayoutStyle = ToolStripLayoutStyle.HorizontalStackWithOverflow;
271 case DockStyle.Right:
272 this.LayoutStyle = ToolStripLayoutStyle.VerticalStackWithOverflow;
279 public override Font Font {
280 get { return base.Font; }
282 if (base.Font != value) {
285 foreach (ToolStripItem tsi in this.Items)
286 tsi.OnOwnerFontChanged (EventArgs.Empty);
292 public new Color ForeColor {
293 get { return this.fore_color; }
295 if (this.fore_color != value) {
296 this.fore_color = value;
297 this.OnForeColorChanged (EventArgs.Empty);
303 public ToolStripGripDisplayStyle GripDisplayStyle {
304 get { return this.orientation == Orientation.Vertical ? ToolStripGripDisplayStyle.Horizontal : ToolStripGripDisplayStyle.Vertical; }
307 public Padding GripMargin {
308 get { return this.grip_margin; }
310 if (this.grip_margin != value) {
311 this.grip_margin = value;
312 this.PerformLayout ();
318 public Rectangle GripRectangle {
320 if (this.grip_style == ToolStripGripStyle.Hidden)
321 return Rectangle.Empty;
323 if (this.orientation == Orientation.Horizontal)
324 return new Rectangle (this.grip_margin.Left + this.Padding.Left, this.Padding.Top, 3, this.Height);
326 return new Rectangle (this.Padding.Left, this.grip_margin.Top + this.Padding.Top, this.Width, 3);
330 [DefaultValue (ToolStripGripStyle.Visible)]
331 public ToolStripGripStyle GripStyle {
332 get { return this.grip_style; }
334 if (this.grip_style != value) {
335 if (!Enum.IsDefined (typeof (ToolStripGripStyle), value))
336 throw new InvalidEnumArgumentException (string.Format ("Enum argument value '{0}' is not valid for ToolStripGripStyle", value));
337 this.grip_style = value;
338 this.PerformLayout ();
344 [EditorBrowsable (EditorBrowsableState.Never)]
345 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
346 public new bool HasChildren {
347 get { return base.HasChildren; }
351 [EditorBrowsable (EditorBrowsableState.Never)]
352 public new HScrollProperties HorizontalScroll {
353 get { return base.HorizontalScroll; }
357 [DefaultValue (null)]
358 public ImageList ImageList {
359 get { return this.image_list; }
360 set { this.image_list = value; }
363 [DefaultValue ("{Width=16, Height=16}")]
364 public Size ImageScalingSize {
365 get { return this.image_scaling_size; }
366 set { this.image_scaling_size = value; }
369 [MonoTODO ("Always returns false, dragging not implemented yet.")]
371 [EditorBrowsable (EditorBrowsableState.Advanced)]
372 public bool IsCurrentlyDragging {
373 get { return false; }
377 public bool IsDropDown {
379 if (this is ToolStripDropDown)
386 [MergableProperty (false)]
387 [DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
388 public virtual ToolStripItemCollection Items {
389 get { return this.items; }
392 public override LayoutEngine LayoutEngine {
394 if (layout_engine == null)
395 this.layout_engine = new ToolStripSplitStackLayout ();
397 return this.layout_engine;
402 [DefaultValue (null)]
403 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
404 public LayoutSettings LayoutSettings {
405 get { return this.layout_settings; }
406 set { this.layout_settings = value; }
409 [AmbientValue (ToolStripLayoutStyle.StackWithOverflow)]
410 public ToolStripLayoutStyle LayoutStyle {
411 get { return layout_style; }
413 if (this.layout_style != value) {
414 if (!Enum.IsDefined (typeof (ToolStripLayoutStyle), value))
415 throw new InvalidEnumArgumentException (string.Format ("Enum argument value '{0}' is not valid for ToolStripLayoutStyle", value));
417 this.layout_style = value;
419 if (this.layout_style == ToolStripLayoutStyle.Flow)
420 this.layout_engine = new FlowLayout ();
422 this.layout_engine = new ToolStripSplitStackLayout ();
424 if (this.layout_style == ToolStripLayoutStyle.StackWithOverflow) {
425 if (this.Dock == DockStyle.Left || this.Dock == DockStyle.Right)
426 this.layout_style = ToolStripLayoutStyle.VerticalStackWithOverflow;
428 this.layout_style = ToolStripLayoutStyle.HorizontalStackWithOverflow;
431 if (this.layout_style == ToolStripLayoutStyle.HorizontalStackWithOverflow)
432 this.orientation = Orientation.Horizontal;
433 else if (this.layout_style == ToolStripLayoutStyle.VerticalStackWithOverflow)
434 this.orientation = Orientation.Vertical;
436 this.layout_settings = this.CreateLayoutSettings (value);
438 this.PerformLayout ();
439 this.OnLayoutStyleChanged (EventArgs.Empty);
445 public Orientation Orientation {
446 get { return this.orientation; }
450 [EditorBrowsable (EditorBrowsableState.Advanced)]
451 public ToolStripOverflowButton OverflowButton {
452 get { return this.overflow_button; }
456 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
457 public ToolStripRenderer Renderer {
459 if (this.render_mode == ToolStripRenderMode.ManagerRenderMode)
460 return ToolStripManager.Renderer;
462 return this.renderer;
465 if (this.renderer != value) {
466 this.renderer = value;
467 this.render_mode = ToolStripRenderMode.Custom;
468 this.PerformLayout ();
469 this.OnRendererChanged (EventArgs.Empty);
474 public ToolStripRenderMode RenderMode {
475 get { return this.render_mode; }
477 if (!Enum.IsDefined (typeof (ToolStripRenderMode), value))
478 throw new InvalidEnumArgumentException (string.Format ("Enum argument value '{0}' is not valid for ToolStripRenderMode", value));
480 if (value == ToolStripRenderMode.Custom && this.renderer == null)
481 throw new NotSupportedException ("Must set Renderer property before setting RenderMode to Custom");
482 else if (value == ToolStripRenderMode.Professional)
483 this.Renderer = new ToolStripProfessionalRenderer ();
484 else if (value == ToolStripRenderMode.System)
485 this.Renderer = new ToolStripSystemRenderer ();
487 this.render_mode = value;
491 [DefaultValue (true)]
492 public bool ShowItemToolTips {
493 get { return this.show_item_tool_tips; }
494 set { this.show_item_tool_tips = value; }
497 [DefaultValue (false)]
498 public bool Stretch {
499 get { return this.stretch; }
500 set { this.stretch = value; }
503 [DefaultValue (false)]
505 public new bool TabStop {
506 get { return base.TabStop; }
507 set { base.TabStop = value; }
510 [DefaultValue (ToolStripTextDirection.Horizontal)]
511 public virtual ToolStripTextDirection TextDirection {
512 get { return this.text_direction; }
514 if (!Enum.IsDefined (typeof (ToolStripTextDirection), value))
515 throw new InvalidEnumArgumentException (string.Format ("Enum argument value '{0}' is not valid for ToolStripTextDirection", value));
517 if (this.text_direction != value) {
518 this.text_direction = value;
520 this.PerformLayout (this, "TextDirection");
528 [EditorBrowsable (EditorBrowsableState.Never)]
529 public new VScrollProperties VerticalScroll {
530 get { return base.VerticalScroll; }
534 #region Protected Properties
535 protected virtual DockStyle DefaultDock { get { return DockStyle.Top; } }
536 protected virtual Padding DefaultGripMargin { get { return new Padding (2); } }
537 protected override Padding DefaultMargin { get { return Padding.Empty; } }
538 protected override Padding DefaultPadding { get { return new Padding (0, 0, 1, 0); } }
539 protected virtual bool DefaultShowItemToolTips { get { return true; } }
540 protected override Size DefaultSize { get { return new Size (100, 25); } }
541 protected internal virtual ToolStripItemCollection DisplayedItems { get { return this.displayed_items; } }
542 protected internal virtual Size MaxItemSize {
543 get { return new Size (Width - (GripStyle == ToolStripGripStyle.Hidden ? 1 : 8), Height); }
547 #region Public Methods
548 [EditorBrowsable (EditorBrowsableState.Never)]
549 public new Control GetChildAtPoint (Point point)
551 return base.GetChildAtPoint (point);
554 [EditorBrowsable (EditorBrowsableState.Never)]
555 public new Control GetChildAtPoint (Point pt, GetChildAtPointSkip skipValue)
557 return base.GetChildAtPoint (pt, skipValue);
560 public ToolStripItem GetItemAt (Point point)
562 foreach (ToolStripItem tsi in this.displayed_items)
563 if (tsi.Visible && tsi.Bounds.Contains (point))
569 public ToolStripItem GetItemAt (int x, int y)
571 return GetItemAt (new Point (x, y));
574 public virtual ToolStripItem GetNextItem (ToolStripItem start, ArrowDirection direction)
576 if (!Enum.IsDefined (typeof (ArrowDirection), direction))
577 throw new InvalidEnumArgumentException (string.Format ("Enum argument value '{0}' is not valid for ArrowDirection", direction));
579 ToolStripItem current_best = null;
580 int current_best_point;
583 case ArrowDirection.Right:
584 current_best_point = int.MaxValue;
587 foreach (ToolStripItem loop_tsi in this.DisplayedItems)
588 if (loop_tsi.Left >= start.Right && loop_tsi.Left < current_best_point && loop_tsi.Visible && loop_tsi.CanSelect) {
589 current_best = loop_tsi;
590 current_best_point = loop_tsi.Left;
593 if (current_best == null)
594 foreach (ToolStripItem loop_tsi in this.DisplayedItems)
595 if (loop_tsi.Left < current_best_point && loop_tsi.Visible && loop_tsi.CanSelect) {
596 current_best = loop_tsi;
597 current_best_point = loop_tsi.Left;
601 case ArrowDirection.Up:
602 current_best_point = int.MinValue;
605 foreach (ToolStripItem loop_tsi in this.DisplayedItems)
606 if (loop_tsi.Bottom <= start.Top && loop_tsi.Top > current_best_point && loop_tsi.Visible && loop_tsi.CanSelect) {
607 current_best = loop_tsi;
608 current_best_point = loop_tsi.Top;
611 if (current_best == null)
612 foreach (ToolStripItem loop_tsi in this.DisplayedItems)
613 if (loop_tsi.Top > current_best_point && loop_tsi.Visible && loop_tsi.CanSelect) {
614 current_best = loop_tsi;
615 current_best_point = loop_tsi.Top;
619 case ArrowDirection.Left:
620 current_best_point = int.MinValue;
623 foreach (ToolStripItem loop_tsi in this.DisplayedItems)
624 if (loop_tsi.Right <= start.Left && loop_tsi.Left > current_best_point && loop_tsi.Visible && loop_tsi.CanSelect) {
625 current_best = loop_tsi;
626 current_best_point = loop_tsi.Left;
629 if (current_best == null)
630 foreach (ToolStripItem loop_tsi in this.DisplayedItems)
631 if (loop_tsi.Left > current_best_point && loop_tsi.Visible && loop_tsi.CanSelect) {
632 current_best = loop_tsi;
633 current_best_point = loop_tsi.Left;
637 case ArrowDirection.Down:
638 current_best_point = int.MaxValue;
641 foreach (ToolStripItem loop_tsi in this.DisplayedItems)
642 if (loop_tsi.Top >= start.Bottom && loop_tsi.Bottom < current_best_point && loop_tsi.Visible && loop_tsi.CanSelect) {
643 current_best = loop_tsi;
644 current_best_point = loop_tsi.Top;
647 if (current_best == null)
648 foreach (ToolStripItem loop_tsi in this.DisplayedItems)
649 if (loop_tsi.Top < current_best_point && loop_tsi.Visible && loop_tsi.CanSelect) {
650 current_best = loop_tsi;
651 current_best_point = loop_tsi.Top;
660 [EditorBrowsable (EditorBrowsableState.Never)]
661 public void ResetMinimumSize ()
663 this.MinimumSize = new Size (-1, -1);
666 [EditorBrowsable (EditorBrowsableState.Never)]
667 public new void SetAutoScrollMargin (int x, int y)
669 base.SetAutoScrollMargin (x, y);
672 public override string ToString ()
674 return String.Format ("{0}, Name: {1}, Items: {2}", base.ToString(), this.Name, this.items.Count.ToString ());
678 #region Protected Methods
679 protected override AccessibleObject CreateAccessibilityInstance ()
681 return new ToolStripAccessibleObject (this);
684 protected override ControlCollection CreateControlsInstance ()
686 return base.CreateControlsInstance ();
689 protected internal virtual ToolStripItem CreateDefaultItem (string text, Image image, EventHandler onClick)
692 return new ToolStripSeparator ();
694 if (this is ToolStripDropDown)
695 return new ToolStripMenuItem (text, image, onClick);
697 return new ToolStripButton (text, image, onClick);
700 protected virtual LayoutSettings CreateLayoutSettings (ToolStripLayoutStyle layoutStyle)
702 switch (layoutStyle) {
703 case ToolStripLayoutStyle.Flow:
704 return new FlowLayoutSettings ();
705 case ToolStripLayoutStyle.Table:
706 //return new TableLayoutSettings ();
707 case ToolStripLayoutStyle.StackWithOverflow:
708 case ToolStripLayoutStyle.HorizontalStackWithOverflow:
709 case ToolStripLayoutStyle.VerticalStackWithOverflow:
715 protected override void Dispose (bool disposing)
718 ToolStripManager.RemoveToolStrip (this);
719 base.Dispose (disposing);
723 [MonoTODO ("Not called")]
724 protected virtual void OnBeginDrag (EventArgs e)
726 EventHandler eh = (EventHandler)(Events[BeginDragEvent]);
731 protected override void OnDockChanged (EventArgs e)
733 base.OnDockChanged (e);
736 [MonoTODO ("Not called")]
737 protected virtual void OnEndDrag (EventArgs e)
739 EventHandler eh = (EventHandler)(Events[EndDragEvent]);
744 protected override bool IsInputChar (char charCode)
746 return base.IsInputChar (charCode);
749 protected override bool IsInputKey (Keys keyData)
751 return base.IsInputKey (keyData);
754 protected override void OnEnabledChanged (EventArgs e)
756 base.OnEnabledChanged (e);
758 foreach (ToolStripItem tsi in this.Items)
759 tsi.OnParentEnabledChanged (EventArgs.Empty);
762 protected override void OnFontChanged (EventArgs e)
764 base.OnFontChanged (e);
767 protected override void OnHandleCreated (EventArgs e)
769 base.OnHandleCreated (e);
772 protected override void OnHandleDestroyed (EventArgs e)
774 base.OnHandleDestroyed (e);
777 protected override void OnInvalidated (InvalidateEventArgs e)
779 base.OnInvalidated (e);
782 protected internal virtual void OnItemAdded (ToolStripItemEventArgs e)
784 e.Item.Available = true;
785 e.Item.SetPlacement (ToolStripItemPlacement.Main);
789 this.PerformLayout ();
791 ToolStripItemEventHandler eh = (ToolStripItemEventHandler)(Events [ItemAddedEvent]);
796 protected virtual void OnItemClicked (ToolStripItemClickedEventArgs e)
798 if (this.KeyboardActive)
799 ToolStripManager.SetActiveToolStrip (null, false);
801 ToolStripItemClickedEventHandler eh = (ToolStripItemClickedEventHandler)(Events [ItemClickedEvent]);
806 protected internal virtual void OnItemRemoved (ToolStripItemEventArgs e)
808 ToolStripItemEventHandler eh = (ToolStripItemEventHandler)(Events [ItemRemovedEvent]);
813 protected override void OnLayout (LayoutEventArgs e)
818 this.SetDisplayedItems ();
819 this.OnLayoutCompleted (EventArgs.Empty);
823 protected virtual void OnLayoutCompleted (EventArgs e)
825 EventHandler eh = (EventHandler)(Events [LayoutCompletedEvent]);
830 protected virtual void OnLayoutStyleChanged (EventArgs e)
832 EventHandler eh = (EventHandler)(Events[LayoutStyleChangedEvent]);
837 protected override void OnLeave (EventArgs e)
842 protected override void OnLostFocus (EventArgs e)
844 base.OnLostFocus (e);
847 protected override void OnMouseCaptureChanged (EventArgs e)
849 base.OnMouseCaptureChanged (e);
852 protected override void OnMouseDown (MouseEventArgs mea)
854 if (mouse_currently_over != null)
856 ToolStripItem focused = GetCurrentlyFocusedItem ();
858 if (focused != null && focused != mouse_currently_over)
859 this.FocusInternal (true);
861 if (this is MenuStrip && !(mouse_currently_over as ToolStripMenuItem).HasDropDownItems) {
863 (this as MenuStrip).FireMenuActivate ();
868 mouse_currently_over.FireEvent (mea, ToolStripItemEventType.MouseDown);
870 if (this is MenuStrip && !menu_selected) {
871 (this as MenuStrip).FireMenuActivate ();
872 menu_selected = true;
875 if (this is MenuStrip)
876 this.HideMenus (true, ToolStripDropDownCloseReason.AppClicked);
879 if (this is MenuStrip)
880 this.Capture = false;
882 base.OnMouseDown (mea);
885 protected override void OnMouseLeave (EventArgs e)
887 if (mouse_currently_over != null) {
888 MouseLeftItem (mouse_currently_over);
889 mouse_currently_over.FireEvent (e, ToolStripItemEventType.MouseLeave);
890 mouse_currently_over = null;
893 base.OnMouseLeave (e);
896 protected override void OnMouseMove (MouseEventArgs mea)
899 // Find the item we are now
900 if (this.overflow_button != null && this.overflow_button.Visible && this.overflow_button.Bounds.Contains (mea.Location))
901 tsi = this.overflow_button;
903 tsi = this.GetItemAt (mea.X, mea.Y);
906 // If we were already hovering on this item, just send a mouse move
907 if (tsi == mouse_currently_over)
908 tsi.FireEvent (mea, ToolStripItemEventType.MouseMove);
910 // If we were over a different item, fire a mouse leave on it
911 if (mouse_currently_over != null) {
913 mouse_currently_over.FireEvent (mea, ToolStripItemEventType.MouseLeave);
916 // Set the new item we are currently over
917 mouse_currently_over = tsi;
919 // Fire mouse enter and mouse move
920 tsi.FireEvent (mea, ToolStripItemEventType.MouseEnter);
921 MouseEnteredItem (tsi);
922 tsi.FireEvent (mea, ToolStripItemEventType.MouseMove);
924 // If we're over something with a drop down, show it
925 if (menu_selected && mouse_currently_over.Enabled && mouse_currently_over is ToolStripDropDownItem && (mouse_currently_over as ToolStripDropDownItem).HasDropDownItems)
926 (mouse_currently_over as ToolStripDropDownItem).ShowDropDown ();
929 // We're not over anything now, just fire the mouse leave on what we used to be over
930 if (mouse_currently_over != null) {
932 mouse_currently_over.FireEvent (mea, ToolStripItemEventType.MouseLeave);
933 mouse_currently_over = null;
937 base.OnMouseMove (mea);
940 protected override void OnMouseUp (MouseEventArgs mea)
942 // If we're currently over an item (set in MouseMove)
943 if (mouse_currently_over != null) {
944 // Fire our ItemClicked event
945 OnItemClicked (new ToolStripItemClickedEventArgs (mouse_currently_over));
947 // Fire the item's MouseUp event
948 mouse_currently_over.FireEvent (mea, ToolStripItemEventType.MouseUp);
950 // The event handler may have blocked until the mouse moved off of the ToolStripItem
951 if (mouse_currently_over == null)
955 base.OnMouseUp (mea);
958 protected override void OnPaint (PaintEventArgs e)
963 this.OnPaintGrip (e);
965 // Make each item draw itself
966 foreach (ToolStripItem tsi in this.displayed_items) {
968 e.Graphics.TranslateTransform (tsi.Bounds.Left, tsi.Bounds.Top);
969 tsi.FireEvent (e, ToolStripItemEventType.Paint);
970 e.Graphics.ResetTransform ();
974 // Paint the Overflow button if it's visible
975 if (this.overflow_button != null && this.overflow_button.Visible) {
976 e.Graphics.TranslateTransform (this.overflow_button.Bounds.Left, this.overflow_button.Bounds.Top);
977 this.overflow_button.FireEvent (e, ToolStripItemEventType.Paint);
978 e.Graphics.ResetTransform ();
981 Rectangle affected_bounds = new Rectangle (Point.Empty, this.Size);
983 ToolStripRenderEventArgs pevent = new ToolStripRenderEventArgs (e.Graphics, this, affected_bounds, Color.Empty);
984 pevent.InternalConnectedArea = CalculateConnectedArea ();
986 this.Renderer.DrawToolStripBorder (pevent);
989 [EditorBrowsable (EditorBrowsableState.Advanced)]
990 protected override void OnPaintBackground (PaintEventArgs pevent)
992 base.OnPaintBackground (pevent);
994 Rectangle affected_bounds = new Rectangle (Point.Empty, this.Size);
995 ToolStripRenderEventArgs e = new ToolStripRenderEventArgs (pevent.Graphics, this, affected_bounds, SystemColors.Control);
997 this.Renderer.DrawToolStripBackground (e);
1000 protected internal virtual void OnPaintGrip (PaintEventArgs e)
1002 // Never draw a grip with these two layouts
1003 if (this.layout_style == ToolStripLayoutStyle.Flow || this.layout_style == ToolStripLayoutStyle.Table)
1006 PaintEventHandler eh = (PaintEventHandler)(Events [PaintGripEvent]);
1010 if (!(this is MenuStrip)) {
1011 if (this.orientation == Orientation.Horizontal)
1012 e.Graphics.TranslateTransform (2, 0);
1014 e.Graphics.TranslateTransform (0, 2);
1017 this.Renderer.DrawGrip (new ToolStripGripRenderEventArgs (e.Graphics, this, this.GripRectangle, this.GripDisplayStyle, this.grip_style));
1018 e.Graphics.ResetTransform ();
1021 protected virtual void OnRendererChanged (EventArgs e)
1023 EventHandler eh = (EventHandler)(Events [RendererChangedEvent]);
1028 [EditorBrowsable (EditorBrowsableState.Advanced)]
1029 protected override void OnRightToLeftChanged (EventArgs e)
1031 base.OnRightToLeftChanged (e);
1033 foreach (ToolStripItem tsi in this.Items)
1034 tsi.OnParentRightToLeftChanged (e);
1037 protected override void OnScroll (ScrollEventArgs se)
1042 protected override void OnTabStopChanged (EventArgs e)
1044 base.OnTabStopChanged (e);
1047 protected override void OnVisibleChanged (EventArgs e)
1049 base.OnVisibleChanged (e);
1052 protected override bool ProcessCmdKey (ref Message msg, Keys keyData)
1054 return base.ProcessCmdKey (ref msg, keyData);
1057 protected override bool ProcessDialogKey (Keys keyData)
1059 if (!this.KeyboardActive)
1062 // Give each item a chance to handle the key
1063 foreach (ToolStripItem tsi in this.Items)
1064 if (tsi.ProcessDialogKey (keyData))
1067 // See if I want to handle it
1068 if (this.ProcessArrowKey (keyData))
1071 ToolStrip ts = null;
1075 this.Dismiss (ToolStripDropDownCloseReason.Keyboard);
1078 case Keys.Control | Keys.Tab:
1079 ts = ToolStripManager.GetNextToolStrip (this, true);
1082 foreach (ToolStripItem tsi in this.Items)
1083 tsi.Dismiss (ToolStripDropDownCloseReason.Keyboard);
1085 ToolStripManager.SetActiveToolStrip (ts, true);
1086 ts.SelectNextToolStripItem (null, true);
1090 case Keys.Control | Keys.Shift | Keys.Tab:
1091 ts = ToolStripManager.GetNextToolStrip (this, false);
1094 foreach (ToolStripItem tsi in this.Items)
1095 tsi.Dismiss (ToolStripDropDownCloseReason.Keyboard);
1097 ToolStripManager.SetActiveToolStrip (ts, true);
1098 ts.SelectNextToolStripItem (null, true);
1106 if (GetCurrentlySelectedItem () is ToolStripControlHost)
1111 return base.ProcessDialogKey (keyData);
1114 protected override bool ProcessMnemonic (char charCode)
1116 // If any item has an explicit mnemonic, it gets the message
1117 foreach (ToolStripItem tsi in this.Items)
1118 if (tsi.Enabled && tsi.Visible && !string.IsNullOrEmpty (tsi.Text) && Control.IsMnemonic (charCode, tsi.Text))
1119 return tsi.ProcessMnemonic (charCode);
1121 string code = Char.ToUpper (charCode).ToString ();
1123 // If any item's text starts with our letter, it gets the message
1124 if (this is MenuStrip)
1125 foreach (ToolStripItem tsi in this.Items)
1126 if (tsi.Enabled && tsi.Visible && !string.IsNullOrEmpty (tsi.Text) && tsi.Text.ToUpper ().StartsWith (code))
1127 return tsi.ProcessMnemonic (charCode);
1129 return base.ProcessMnemonic (charCode);
1133 [EditorBrowsable (EditorBrowsableState.Advanced)]
1134 protected virtual void RestoreFocus ()
1139 protected override void Select (bool directed, bool forward)
1141 base.Select (directed, forward);
1144 protected override void SetBoundsCore (int x, int y, int width, int height, BoundsSpecified specified)
1146 base.SetBoundsCore (x, y, width, height, specified);
1149 protected virtual void SetDisplayedItems ()
1151 this.displayed_items.Clear ();
1153 foreach (ToolStripItem tsi in this.items)
1154 if (tsi.Placement == ToolStripItemPlacement.Main && tsi.Available) {
1155 this.displayed_items.AddNoOwnerOrLayout (tsi);
1158 else if (tsi.Placement == ToolStripItemPlacement.Overflow)
1159 tsi.Parent = this.OverflowButton.DropDown;
1161 if (this.OverflowButton != null)
1162 this.OverflowButton.DropDown.SetDisplayedItems ();
1165 protected internal void SetItemLocation (ToolStripItem item, Point location)
1168 throw new ArgumentNullException ("item");
1170 if (item.Owner != this)
1171 throw new NotSupportedException ("The item is not owned by this ToolStrip");
1173 item.SetBounds (new Rectangle (location, item.Size));
1176 protected internal static void SetItemParent (ToolStripItem item, ToolStrip parent)
1178 if (item.Owner != null) {
1179 item.Owner.Items.RemoveNoOwnerOrLayout (item);
1181 if (item.Owner is ToolStripOverflow)
1182 (item.Owner as ToolStripOverflow).ParentToolStrip.Items.RemoveNoOwnerOrLayout (item);
1185 parent.Items.AddNoOwnerOrLayout (item);
1186 item.Parent = parent;
1189 protected override void SetVisibleCore (bool value)
1191 base.SetVisibleCore (value);
1194 protected override void WndProc (ref Message m)
1196 base.WndProc (ref m);
1200 #region Public Events
1201 static object BeginDragEvent = new object ();
1202 static object EndDragEvent = new object ();
1203 static object ItemAddedEvent = new object ();
1204 static object ItemClickedEvent = new object ();
1205 static object ItemRemovedEvent = new object ();
1206 static object LayoutCompletedEvent = new object ();
1207 static object LayoutStyleChangedEvent = new object ();
1208 static object PaintGripEvent = new object ();
1209 static object RendererChangedEvent = new object ();
1212 [EditorBrowsable (EditorBrowsableState.Always)]
1213 public new event EventHandler AutoSizeChanged {
1214 add { base.AutoSizeChanged += value; }
1215 remove { base.AutoSizeChanged -= value; }
1219 public event EventHandler BeginDrag {
1220 add { Events.AddHandler (BeginDragEvent, value); }
1221 remove { Events.RemoveHandler (BeginDragEvent, value); }
1225 public new event EventHandler CausesValidationChanged {
1226 add { base.CausesValidationChanged += value; }
1227 remove { base.CausesValidationChanged -= value; }
1231 [EditorBrowsable (EditorBrowsableState.Never)]
1232 public new event ControlEventHandler ControlAdded {
1233 add { base.ControlAdded += value; }
1234 remove { base.ControlAdded -= value; }
1238 [EditorBrowsable (EditorBrowsableState.Never)]
1239 public new event ControlEventHandler ControlRemoved {
1240 add { base.ControlRemoved += value; }
1241 remove { base.ControlRemoved -= value; }
1245 public new event EventHandler CursorChanged {
1246 add { base.CursorChanged += value; }
1247 remove { base.CursorChanged -= value; }
1251 public event EventHandler EndDrag {
1252 add { Events.AddHandler (EndDragEvent, value); }
1253 remove { Events.RemoveHandler (EndDragEvent, value); }
1257 public new event EventHandler ForeColorChanged {
1258 add { base.ForeColorChanged += value; }
1259 remove { base.ForeColorChanged -= value; }
1262 public event ToolStripItemEventHandler ItemAdded {
1263 add { Events.AddHandler (ItemAddedEvent, value); }
1264 remove { Events.RemoveHandler (ItemAddedEvent, value); }
1267 public event ToolStripItemClickedEventHandler ItemClicked {
1268 add { Events.AddHandler (ItemClickedEvent, value); }
1269 remove { Events.RemoveHandler (ItemClickedEvent, value); }
1272 public event ToolStripItemEventHandler ItemRemoved {
1273 add { Events.AddHandler (ItemRemovedEvent, value); }
1274 remove { Events.RemoveHandler (ItemRemovedEvent, value); }
1277 public event EventHandler LayoutCompleted {
1278 add { Events.AddHandler (LayoutCompletedEvent, value); }
1279 remove { Events.RemoveHandler (LayoutCompletedEvent, value); }
1282 public event EventHandler LayoutStyleChanged {
1283 add { Events.AddHandler (LayoutStyleChangedEvent, value); }
1284 remove { Events.RemoveHandler (LayoutStyleChangedEvent, value); }
1287 public event PaintEventHandler PaintGrip {
1288 add { Events.AddHandler (PaintGripEvent, value); }
1289 remove { Events.RemoveHandler (PaintGripEvent, value); }
1292 public event EventHandler RendererChanged {
1293 add { Events.AddHandler (RendererChangedEvent, value); }
1294 remove { Events.RemoveHandler (RendererChangedEvent, value); }
1298 #region Internal Properties
1299 internal virtual bool KeyboardActive
1301 get { return this.keyboard_active; }
1303 if (this.keyboard_active != value) {
1304 this.keyboard_active = value;
1307 Application.KeyboardCapture = this;
1308 else if (Application.KeyboardCapture == this) {
1309 Application.KeyboardCapture = null;
1310 ToolStripManager.ActivatedByKeyboard = false;
1313 // Redraw for mnemonic underlines
1320 #region Private Methods
1321 internal virtual Rectangle CalculateConnectedArea ()
1323 return Rectangle.Empty;
1326 internal void ChangeSelection (ToolStripItem nextItem)
1328 if (Application.KeyboardCapture != this)
1329 ToolStripManager.SetActiveToolStrip (this, ToolStripManager.ActivatedByKeyboard);
1331 foreach (ToolStripItem tsi in this.Items)
1332 if (tsi != nextItem)
1333 tsi.Dismiss (ToolStripDropDownCloseReason.Keyboard);
1335 ToolStripItem current = GetCurrentlySelectedItem ();
1337 if (!(current is ToolStripControlHost))
1338 this.FocusInternal (true);
1340 if (nextItem is ToolStripControlHost)
1341 (nextItem as ToolStripControlHost).Focus ();
1345 if (nextItem.Parent is MenuStrip && (nextItem.Parent as MenuStrip).MenuDroppedDown)
1346 (nextItem as ToolStripMenuItem).HandleAutoExpansion ();
1349 internal virtual void Dismiss ()
1351 this.Dismiss (ToolStripDropDownCloseReason.AppClicked);
1354 internal virtual void Dismiss (ToolStripDropDownCloseReason reason)
1356 // Release our stranglehold on the keyboard
1357 this.KeyboardActive = false;
1359 // Set our drop down flag to false;
1360 this.menu_selected = false;
1362 // Make sure all of our items are deselected and repainted
1363 foreach (ToolStripItem tsi in this.Items)
1364 tsi.Dismiss (reason);
1366 // We probably need to redraw for mnemonic underlines
1370 private void DoAutoSize ()
1372 if (this.AutoSize == true && this.Dock == DockStyle.None) {
1373 Size new_size = GetToolStripPreferredSize (Size.Empty);
1374 SetBounds (Left, Top, new_size.Width, new_size.Height, BoundsSpecified.None);
1377 if (this.AutoSize == true && this.Orientation == Orientation.Horizontal && (this.Dock == DockStyle.Top || this.Dock == DockStyle.Bottom))
1378 SetBounds (Left, Top, Width, GetToolStripPreferredSize (Size.Empty).Height, BoundsSpecified.None);
1381 internal ToolStripItem GetCurrentlySelectedItem ()
1383 foreach (ToolStripItem tsi in this.DisplayedItems)
1390 internal ToolStripItem GetCurrentlyFocusedItem ()
1392 foreach (ToolStripItem tsi in this.DisplayedItems)
1393 if ((tsi is ToolStripControlHost) && (tsi as ToolStripControlHost).Control.Focused)
1399 internal virtual Size GetToolStripPreferredSize (Size proposedSize)
1401 Size new_size = new Size (0, this.Height);
1403 if (this.orientation == Orientation.Vertical) {
1404 foreach (ToolStripItem tsi in this.items)
1405 if (tsi.GetPreferredSize (Size.Empty).Height + tsi.Margin.Top + tsi.Margin.Bottom > new_size.Height)
1406 new_size.Height = tsi.GetPreferredSize (Size.Empty).Height + tsi.Margin.Top + tsi.Margin.Bottom;
1408 new_size.Height += this.Padding.Top + this.Padding.Bottom;
1409 new_size.Width = this.Width;
1411 foreach (ToolStripItem tsi in this.items)
1412 if (tsi.Available) {
1413 Size tsi_preferred = tsi.GetPreferredSize (Size.Empty);
1414 new_size.Width += tsi_preferred.Width + tsi.Margin.Left + tsi.Margin.Right;
1416 if (new_size.Height < (this.Padding.Vertical + tsi_preferred.Height))
1417 new_size.Height = (this.Padding.Vertical + tsi_preferred.Height);
1421 new_size.Width += (this.GripRectangle.Width + this.GripMargin.Horizontal + this.Padding.Horizontal + 4);
1425 internal virtual ToolStrip GetTopLevelToolStrip ()
1430 internal virtual void HandleItemClick (ToolStripItem dismissingItem)
1432 this.GetTopLevelToolStrip ().Dismiss (ToolStripDropDownCloseReason.ItemClicked);
1435 internal void HideMenus (bool release, ToolStripDropDownCloseReason reason)
1437 if (this is MenuStrip && release && menu_selected)
1438 (this as MenuStrip).FireMenuDeactivate ();
1441 menu_selected = false;
1443 NotifySelectedChanged (null);
1446 internal void NotifySelectedChanged (ToolStripItem tsi)
1448 foreach (ToolStripItem tsi2 in this.DisplayedItems)
1450 if (tsi2 is ToolStripDropDownItem)
1451 (tsi2 as ToolStripDropDownItem).HideDropDown (ToolStripDropDownCloseReason.Keyboard);
1453 if (this.OverflowButton != null) {
1454 ToolStripItemCollection tsic = this.OverflowButton.DropDown.DisplayedItems;
1456 foreach (ToolStripItem tsi2 in tsic)
1458 if (tsi2 is ToolStripDropDownItem)
1459 (tsi2 as ToolStripDropDownItem).HideDropDown (ToolStripDropDownCloseReason.Keyboard);
1461 this.OverflowButton.HideDropDown ();
1464 foreach (ToolStripItem tsi2 in this.Items)
1466 tsi2.Dismiss (ToolStripDropDownCloseReason.Keyboard);
1469 internal virtual bool OnMenuKey ()
1474 internal virtual bool ProcessArrowKey (Keys keyData)
1480 tsi = this.GetCurrentlySelectedItem ();
1482 if (tsi is ToolStripControlHost)
1485 tsi = this.SelectNextToolStripItem (tsi, true);
1487 if (tsi is ToolStripControlHost)
1488 (tsi as ToolStripControlHost).Focus ();
1492 tsi = this.GetCurrentlySelectedItem ();
1494 tsi = this.SelectNextToolStripItem (tsi, true);
1496 if (tsi is ToolStripControlHost)
1497 (tsi as ToolStripControlHost).Focus ();
1501 tsi = this.GetCurrentlySelectedItem ();
1503 if (tsi is ToolStripControlHost)
1506 tsi = this.SelectNextToolStripItem (tsi, false);
1508 if (tsi is ToolStripControlHost)
1509 (tsi as ToolStripControlHost).Focus ();
1512 case Keys.Shift | Keys.Tab:
1513 tsi = this.GetCurrentlySelectedItem ();
1515 tsi = this.SelectNextToolStripItem (tsi, false);
1517 if (tsi is ToolStripControlHost)
1518 (tsi as ToolStripControlHost).Focus ();
1526 internal virtual ToolStripItem SelectNextToolStripItem (ToolStripItem start, bool forward)
1528 ToolStripItem next_item = this.GetNextItem (start, forward ? ArrowDirection.Right : ArrowDirection.Left);
1530 this.ChangeSelection (next_item);
1532 if (next_item is ToolStripControlHost)
1533 (next_item as ToolStripControlHost).Focus ();
1538 #region Stuff for ToolTips
1539 private void MouseEnteredItem (ToolStripItem item)
1541 if (this.show_item_tool_tips) {
1542 tooltip_currently_showing = item;
1543 ToolTipTimer.Start ();
1547 private void MouseLeftItem (ToolStripItem item)
1549 ToolTipTimer.Stop ();
1550 ToolTipWindow.Hide (this);
1551 tooltip_currently_showing = null;
1554 private Timer ToolTipTimer {
1556 if (tooltip_timer == null) {
1557 tooltip_timer = new Timer ();
1558 tooltip_timer.Enabled = false;
1559 tooltip_timer.Interval = 500;
1560 tooltip_timer.Tick += new EventHandler (ToolTipTimer_Tick);
1563 return tooltip_timer;
1567 private ToolTip ToolTipWindow {
1569 if (tooltip_window == null)
1570 tooltip_window = new ToolTip ();
1572 return tooltip_window;
1576 private void ToolTipTimer_Tick (object o, EventArgs args)
1578 string tooltip = tooltip_currently_showing.GetToolTip ();
1580 if (!string.IsNullOrEmpty (tooltip))
1581 ToolTipWindow.Present (this, tooltip);
1583 tooltip_currently_showing.FireEvent (EventArgs.Empty, ToolStripItemEventType.MouseHover);
1585 ToolTipTimer.Stop ();
1589 #region Stuff for Merging
1590 internal ToolStrip CurrentlyMergedWith {
1591 get { return this.currently_merged_with; }
1592 set { this.currently_merged_with = value; }
1595 internal List<ToolStripItem> HiddenMergedItems {
1597 if (this.hidden_merged_items == null)
1598 this.hidden_merged_items = new List<ToolStripItem> ();
1600 return this.hidden_merged_items;
1604 internal bool IsCurrentlyMerged {
1605 get { return this.is_currently_merged; }
1607 this.is_currently_merged = value;
1609 if (!value && this is MenuStrip)
1610 foreach (ToolStripMenuItem tsmi in this.Items)
1611 tsmi.DropDown.IsCurrentlyMerged = value;
1615 internal void BeginMerge ()
1617 if (!IsCurrentlyMerged) {
1618 IsCurrentlyMerged = true;
1620 if (this.pre_merge_items == null) {
1621 this.pre_merge_items = new List<ToolStripItem> ();
1623 foreach (ToolStripItem tsi in this.Items)
1624 this.pre_merge_items.Add (tsi);
1629 internal void RevertMergeItem (ToolStripItem item)
1633 // Remove it from it's current Parent
1634 if (item.Parent != null && item.Parent != this) {
1635 if (item.Parent is ToolStripOverflow)
1636 (item.Parent as ToolStripOverflow).ParentToolStrip.Items.RemoveNoOwnerOrLayout (item);
1638 item.Parent.Items.RemoveNoOwnerOrLayout (item);
1640 item.Parent = item.Owner;
1643 // Find where the item was before the merge
1644 index = item.Owner.pre_merge_items.IndexOf (item);
1646 // Find the first pre-merge item that was after this item, that
1647 // is currently in the Items collection. Insert our item before
1649 for (int i = index; i < this.pre_merge_items.Count; i++) {
1650 if (this.Items.Contains (this.pre_merge_items[i])) {
1651 item.Owner.Items.InsertNoOwnerOrLayout (this.Items.IndexOf (this.pre_merge_items[i]), item);
1656 // There aren't any items that are supposed to be after this item,
1657 // so just append it to the end.
1658 item.Owner.Items.AddNoOwnerOrLayout (item);
1663 #region ToolStripAccessibleObject
1665 public class ToolStripAccessibleObject : ControlAccessibleObject
1667 #region Public Constructor
1668 public ToolStripAccessibleObject (ToolStrip owner) : base (owner)
1673 #region Public Properties
1674 public override AccessibleRole Role {
1675 get { return AccessibleRole.ToolBar; }
1679 #region Public Methods
1680 public override AccessibleObject GetChild (int index)
1682 return base.GetChild (index);
1685 public override int GetChildCount ()
1687 return (owner as ToolStrip).Items.Count;
1690 public override AccessibleObject HitTest (int x, int y)
1692 return base.HitTest (x, y);