Move ShiftUI source code to ShiftOS

This'll be a lot easier to work on.

1 files changed, 2077 insertions, 0 deletions

diff --git a/source/ShiftUI/ToolStrip/ToolStripItem.cs b/source/ShiftUI/ToolStrip/ToolStripItem.cs
new file mode 100644
index 0000000..0a8ad4a
--- /dev/null
+++ b/source/ShiftUI/ToolStrip/ToolStripItem.cs
@@ -0,0 +1,2077 @@
+//
+// ToolStripItem.cs
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+// Copyright (c) 2006 Jonathan Pobst
+//
+// Authors:
+//	Jonathan Pobst ([email protected])
+//
+
+
+using System;
+using System.Drawing;
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+
+namespace ShiftUI
+{
+	[DefaultEvent ("Click")]
+	[DefaultProperty ("Text")]
+	[DesignTimeVisible (false)]
+	[ToolboxItem (false)]
+	//[Designer ("ShiftUI.Design.ToolStripItemDesigner, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.IDesigner")]
+	public abstract class ToolStripItem : Component, IDropTarget, IComponent, IDisposable
+	{
+		#region Private Variables
+		private AccessibleObject accessibility_object;
+		private string accessible_default_action_description;
+		private bool allow_drop;
+		private ToolStripItemAlignment alignment;
+		private AnchorStyles anchor;
+		private bool available;
+		private bool auto_size;
+		private bool auto_tool_tip;
+		private Color back_color;
+		private Image background_image;
+		private ImageLayout background_image_layout;
+		private Rectangle bounds;
+		private bool can_select;
+		private ToolStripItemDisplayStyle display_style;
+		private DockStyle dock;
+		private bool double_click_enabled;
+		private bool enabled;
+		private Size explicit_size;
+		private Font font;
+		private Color fore_color;
+		private Image image;
+		private ContentAlignment image_align;
+		private int image_index;
+		private string image_key;
+		private ToolStripItemImageScaling image_scaling;
+		private Color image_transparent_color;
+		private bool is_disposed;
+		internal bool is_pressed;
+		private bool is_selected;
+		private Padding margin;
+		private MergeAction merge_action;
+		private int merge_index;
+		private string name;
+		private ToolStripItemOverflow overflow;
+		private ToolStrip owner;
+		internal ToolStripItem owner_item;
+		private Padding padding;
+		private ToolStripItemPlacement placement;
+		private RightToLeft right_to_left;
+		private bool right_to_left_auto_mirror_image;
+		private Object tag;
+		private string text;
+		private ContentAlignment text_align;
+		private ToolStripTextDirection text_direction;
+		private TextImageRelation text_image_relation;
+		private string tool_tip_text;
+		private bool visible;
+
+		private EventHandler frame_handler;	// For animating images
+		private ToolStrip parent;
+		private Size text_size;
+		#endregion
+
+		#region Public Constructors
+		protected ToolStripItem ()
+			: this (String.Empty, null, null, String.Empty)
+		{
+		}
+
+		protected ToolStripItem (string text, Image image, EventHandler onClick)
+			: this (text, image, onClick, String.Empty)
+		{
+		}
+
+		protected ToolStripItem (string text, Image image, EventHandler onClick, string name)
+		{
+			this.alignment = ToolStripItemAlignment.Left;
+			this.anchor = AnchorStyles.Left | AnchorStyles.Top;
+			this.auto_size = true;
+			this.auto_tool_tip = this.DefaultAutoToolTip;
+			this.available = true;
+			this.back_color = Color.Empty;
+			this.background_image_layout = ImageLayout.Tile;
+			this.can_select = true;
+			this.display_style = this.DefaultDisplayStyle;
+			this.dock = DockStyle.None;
+			this.enabled = true;
+			this.fore_color = Color.Empty;
+			this.image = image;
+			this.image_align = ContentAlignment.MiddleCenter;
+			this.image_index = -1;
+			this.image_key = string.Empty;
+			this.image_scaling = ToolStripItemImageScaling.SizeToFit;
+			this.image_transparent_color = Color.Empty;
+			this.margin = this.DefaultMargin;
+			this.merge_action = MergeAction.Append;
+			this.merge_index = -1;
+			this.name = name;
+			this.overflow = ToolStripItemOverflow.AsNeeded;
+			this.padding = this.DefaultPadding;
+			this.placement = ToolStripItemPlacement.None;
+			this.right_to_left = RightToLeft.Inherit;
+			this.bounds.Size = this.DefaultSize;
+			this.text = text;
+			this.text_align = ContentAlignment.MiddleCenter;
+			this.text_direction = DefaultTextDirection;
+			this.text_image_relation = TextImageRelation.ImageBeforeText;
+			this.visible = true;
+
+			this.Click += onClick;
+			OnLayout (new LayoutEventArgs (null, string.Empty));
+		}
+		#endregion
+
+		#region Public Properties
+		[Browsable (false)]
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+		public AccessibleObject AccessibilityObject {
+			get { 
+				if (this.accessibility_object == null)
+					this.accessibility_object = CreateAccessibilityInstance ();
+					
+				return this.accessibility_object;
+			}
+		}
+
+		[Browsable (false)]
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+		public string AccessibleDefaultActionDescription {
+			get {
+				if (this.accessibility_object == null)
+					return null;
+				
+				return this.accessible_default_action_description;
+			}
+			set { this.accessible_default_action_description = value; }
+		}
+
+		[Localizable (true)]
+		[DefaultValue (null)]
+		public string AccessibleDescription {
+			get {
+				if (this.accessibility_object == null)
+					return null;
+				
+				return this.AccessibilityObject.Description;
+			}
+			set { this.AccessibilityObject.description = value; }
+		}
+
+		[Localizable (true)]
+		[DefaultValue (null)]
+		public string AccessibleName {
+			get { 
+				if (this.accessibility_object == null)
+					return null;
+					
+				return this.AccessibilityObject.Name; 
+			}
+			set { this.AccessibilityObject.Name = value; }
+		}
+		
+		[DefaultValue (AccessibleRole.Default)]
+		public AccessibleRole AccessibleRole {
+			get
+			{
+				if (this.accessibility_object == null)
+					return AccessibleRole.Default;
+				
+				return this.AccessibilityObject.Role;
+			}
+			set { this.AccessibilityObject.role = value; }
+		}
+		
+		[DefaultValue (ToolStripItemAlignment.Left)]
+		public ToolStripItemAlignment Alignment {
+			get { return this.alignment; }
+			set {
+				if (!Enum.IsDefined (typeof (ToolStripItemAlignment), value))
+					throw new InvalidEnumArgumentException (string.Format ("Enum argument value '{0}' is not valid for ToolStripItemAlignment", value));
+
+				if (this.alignment != value) {
+					this.alignment = value;
+					this.CalculateAutoSize (); 
+				}
+			}
+		}
+
+		[MonoTODO ("Stub, does nothing")]
+		[Browsable (false)]
+		[DefaultValue (false)]
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		public virtual bool AllowDrop {
+			get { return this.allow_drop; }
+			set { this.allow_drop = value; }
+		}
+		
+		[Browsable (false)]
+		[DefaultValue (AnchorStyles.Top | AnchorStyles.Left)]
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+		public AnchorStyles Anchor {
+			get { return this.anchor; }
+			set { this.anchor = value; }
+		}
+			
+		[Localizable (true)]
+		[DefaultValue (true)]
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Visible)]
+		[RefreshProperties (RefreshProperties.All)]
+		public bool AutoSize {
+			get { return this.auto_size; }
+			set { 
+				this.auto_size = value; 
+				this.CalculateAutoSize (); 
+			}
+		}
+
+		[DefaultValue (false)]
+		public bool AutoToolTip {
+			get { return this.auto_tool_tip; }
+			set { this.auto_tool_tip = value; }
+		}
+
+		[Browsable (false)]
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+		public bool Available {
+			get { return this.available; }
+			set {
+				if (this.available != value) {
+					available = value;
+					visible = value;
+
+					if (this.parent != null)
+						parent.PerformLayout (); 
+						
+					OnAvailableChanged (EventArgs.Empty); 
+					OnVisibleChanged (EventArgs.Empty);
+				}
+			}
+		}
+
+		public virtual Color BackColor {
+			get {
+				if (back_color != Color.Empty)
+					return back_color;
+
+				if (Parent != null)
+					return parent.BackColor;
+
+				return Widget.DefaultBackColor;
+			}
+			set {
+				if (this.back_color != value) {
+					back_color = value;
+					OnBackColorChanged (EventArgs.Empty);
+					this.Invalidate ();
+				}
+			}
+		}
+
+		[Localizable (true)]
+		[DefaultValue (null)]
+		public virtual Image BackgroundImage {
+			get { return this.background_image; }
+			set { 
+				if (this.background_image != value) {
+					this.background_image = value;
+					this.Invalidate ();
+				}
+			}
+		}
+
+		[Localizable (true)]
+		[DefaultValue (ImageLayout.Tile)]
+		public virtual ImageLayout BackgroundImageLayout {
+			get { return this.background_image_layout; }
+			set { 
+				if (this.background_image_layout != value) {
+					this.background_image_layout = value;
+					this.Invalidate (); 
+				}
+			}
+		}
+
+		[Browsable (false)]
+		public virtual Rectangle Bounds {
+			get { return this.bounds; }
+		}
+
+		[Browsable (false)]
+		public virtual bool CanSelect {
+			get { return this.can_select; }
+		}
+
+		[Browsable (false)]
+		public Rectangle ContentRectangle {
+			get {
+				// ToolStripLabels don't have a border
+				if (this is ToolStripLabel || this is ToolStripStatusLabel)
+					return new Rectangle (0, 0, this.bounds.Width, this.bounds.Height);
+
+				if (this is ToolStripDropDownButton && (this as ToolStripDropDownButton).ShowDropDownArrow)
+					return new Rectangle (2, 2, this.bounds.Width - 13, this.bounds.Height - 4);
+
+				return new Rectangle (2, 2, this.bounds.Width - 4, this.bounds.Height - 4);
+			}
+		}
+
+		public virtual ToolStripItemDisplayStyle DisplayStyle {
+			get { return this.display_style; }
+			set {
+				if (this.display_style != value) {
+					this.display_style = value; 
+					this.CalculateAutoSize (); 
+					OnDisplayStyleChanged (EventArgs.Empty);
+				}
+			}
+		}
+
+		[Browsable (false)]
+		public bool IsDisposed {
+			get { return this.is_disposed; }
+		}
+		
+		[Browsable (false)]
+		[DefaultValue (DockStyle.None)]
+		public DockStyle Dock {
+			get { return this.dock; }
+			set {
+				if (this.dock != value) {
+					if (!Enum.IsDefined (typeof (DockStyle), value))
+						throw new InvalidEnumArgumentException (string.Format ("Enum argument value '{0}' is not valid for DockStyle", value));
+
+					this.dock = value;
+					this.CalculateAutoSize ();
+				}
+			}
+		}
+
+		[DefaultValue (false)]
+		public bool DoubleClickEnabled {
+			get { return this.double_click_enabled; }
+			set { this.double_click_enabled = value; }
+		}
+
+		[Localizable (true)]
+		[DefaultValue (true)]
+		public virtual bool Enabled {
+			get { 
+				if (Parent != null)
+					if (!Parent.Enabled)
+						return false;
+
+				if (Owner != null)
+					if (!Owner.Enabled)
+						return false;
+						
+				return enabled;
+			}
+			set { 
+				if (this.enabled != value) {
+					this.enabled = value; 
+					OnEnabledChanged (EventArgs.Empty); 
+					this.Invalidate ();
+				}
+			}
+		}
+
+		[Localizable (true)]
+		public virtual Font Font {
+			get { 
+				if (font != null)
+					return font;
+					
+				if (Parent != null)
+					return Parent.Font;
+					
+				return DefaultFont;
+			}
+			set { 
+				if (this.font != value) {
+					this.font = value; 
+					this.CalculateAutoSize (); 
+					this.OnFontChanged (EventArgs.Empty); 
+					this.Invalidate ();
+				}
+			}
+		}
+
+		public virtual Color ForeColor {
+			get { 
+				if (fore_color != Color.Empty)
+					return fore_color;
+					
+				if (Parent != null)
+					return parent.ForeColor;
+					
+				return Widget.DefaultForeColor;
+			}
+			set { 
+				if (this.fore_color != value) {
+					this.fore_color = value; 
+					this.OnForeColorChanged (EventArgs.Empty); 
+					this.Invalidate ();
+				}
+			}
+		}
+
+		[Browsable (false)]
+		//[EditorBrowsable (EditorBrowsableState.Always)]
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+		public int Height {
+			get { return this.Size.Height; }
+			set { 
+				this.Size = new Size (this.Size.Width, value); 
+				this.explicit_size.Height = value;
+				
+				if (this.Visible) {
+					this.CalculateAutoSize ();
+					this.OnBoundsChanged ();
+					this.Invalidate (); 
+				} 
+			}
+		}
+
+		[Localizable (true)]
+		public virtual Image Image {
+			get { 
+				if (this.image != null)
+					return this.image;
+					
+				if (this.image_index >= 0)
+					if (this.owner != null && this.owner.ImageList != null && this.owner.ImageList.Images.Count > this.image_index)
+						return this.owner.ImageList.Images[this.image_index];
+
+
+				if (!string.IsNullOrEmpty (this.image_key))
+					if (this.owner != null && this.owner.ImageList != null && this.owner.ImageList.Images.Count > this.image_index)
+						return this.owner.ImageList.Images[this.image_key];
+						
+				return null;
+			}
+			set {
+				if (this.image != value) {
+					StopAnimation ();
+					
+					this.image = value; 
+					this.image_index = -1;
+					this.image_key = string.Empty;
+					this.CalculateAutoSize (); 
+					this.Invalidate ();
+					
+					BeginAnimation ();
+				}
+			}
+		}
+
+		[Localizable (true)]
+		[DefaultValue (ContentAlignment.MiddleCenter)]
+		public ContentAlignment ImageAlign {
+			get { return this.image_align; }
+			set {
+				if (!Enum.IsDefined (typeof (ContentAlignment), value))
+					throw new InvalidEnumArgumentException (string.Format ("Enum argument value '{0}' is not valid for ContentAlignment", value));
+
+				if (image_align != value) {
+					this.image_align = value;
+					this.CalculateAutoSize (); 
+				}
+			}
+		}
+
+		[Localizable (true)]
+		[Browsable (false)]
+		[RelatedImageList ("Owner.ImageList")]
+		[TypeConverter (typeof (NoneExcludedImageIndexConverter))]
+		[RefreshProperties (RefreshProperties.Repaint)]
+		//[Editor ("ShiftUI.Design.ToolStripImageIndexEditor, " + Consts.AssemblySystem_Design, typeof (System.Drawing.Design.UITypeEditor))]
+		public int ImageIndex {
+			get { return this.image_index; }
+			set {
+				if (this.image_index != value) {
+					// Lamespec: MSDN says ArgumentException, tests say otherwise
+					if (value < -1)
+						throw new ArgumentOutOfRangeException ("ImageIndex cannot be less than -1");
+
+					this.image_index = value;
+					this.image = null;
+					this.image_key = string.Empty;
+					this.CalculateAutoSize ();
+					this.Invalidate ();
+				}
+			}
+		}
+
+		[Localizable (true)]
+		[Browsable (false)]
+		[RelatedImageList ("Owner.ImageList")]
+		[TypeConverter (typeof (ImageKeyConverter))]
+		[RefreshProperties (RefreshProperties.Repaint)]
+		//[Editor ("ShiftUI.Design.ToolStripImageIndexEditor, " + Consts.AssemblySystem_Design, typeof (System.Drawing.Design.UITypeEditor))]
+		public string ImageKey {
+			get { return this.image_key; }
+			set { 
+				if (this.image_key != value) {
+					this.image = null;
+					this.image_index = -1;
+					this.image_key = value;
+					this.CalculateAutoSize ();
+					this.Invalidate ();
+				}
+			}
+		}
+		
+		[Localizable (true)]
+		[DefaultValue (ToolStripItemImageScaling.SizeToFit)]
+		public ToolStripItemImageScaling ImageScaling {
+			get { return this.image_scaling; }
+			set { 
+				if (image_scaling != value) {
+					this.image_scaling = value; 
+					this.CalculateAutoSize (); 
+				}
+			}
+		}
+
+		[Localizable (true)]
+		public Color ImageTransparentColor {
+			get { return this.image_transparent_color; }
+			set { this.image_transparent_color = value; }
+		}
+		
+		[Browsable (false)]
+		public bool IsOnDropDown {
+			get {
+				if (this.parent != null && this.parent is ToolStripDropDown)
+					return true;
+
+				return false;
+			}
+		}
+
+		[Browsable (false)]
+		public bool IsOnOverflow {
+			get { return this.placement == ToolStripItemPlacement.Overflow; }
+		}
+		
+		public Padding Margin {
+			get { return this.margin; }
+			set {
+				this.margin = value; 
+				this.CalculateAutoSize ();
+			}
+		}
+
+		[DefaultValue (MergeAction.Append)]
+		public MergeAction MergeAction {
+			get { return this.merge_action; }
+			set {
+				if (!Enum.IsDefined (typeof (MergeAction), value))
+					throw new InvalidEnumArgumentException (string.Format ("Enum argument value '{0}' is not valid for MergeAction", value));
+					
+				this.merge_action = value;
+			}
+		}
+
+		[DefaultValue (-1)]
+		public int MergeIndex {
+			get { return this.merge_index; }
+			set { this.merge_index = value; }
+		}
+
+		[DefaultValue (null)]
+		[Browsable (false)]
+		public string Name {
+			get { return this.name; }
+			set { this.name = value; }
+		}
+
+		[DefaultValue (ToolStripItemOverflow.AsNeeded)]
+		public ToolStripItemOverflow Overflow {
+			get { return this.overflow; }
+			set { 
+				if (this.overflow != value) {
+					if (!Enum.IsDefined (typeof (ToolStripItemOverflow), value))
+						throw new InvalidEnumArgumentException (string.Format ("Enum argument value '{0}' is not valid for ToolStripItemOverflow", value));
+				
+					this.overflow = value;
+					
+					if (owner != null)
+						owner.PerformLayout ();
+				}
+			}
+		}
+			
+		[Browsable (false)]
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+		public ToolStrip Owner {
+			get { return this.owner; }
+			set { 
+				if (this.owner != value) {
+					if (this.owner != null)
+						this.owner.Items.Remove (this);
+					
+					if (value != null)	
+						value.Items.Add (this);
+					else
+						this.owner = null;
+				}
+			}
+		}
+
+		[Browsable (false)]
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+		public ToolStripItem OwnerItem {
+			get { return this.owner_item; }
+		}
+
+		public virtual Padding Padding {
+			get { return this.padding; }
+			set { 
+				this.padding = value; 
+				this.CalculateAutoSize (); 
+				this.Invalidate (); 
+			}
+		}
+
+		[Browsable (false)]
+		public ToolStripItemPlacement Placement {
+			get { return this.placement; }
+		}
+		
+		[Browsable (false)]
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+		public virtual bool Pressed { get { return this.is_pressed; } }
+
+		[MonoTODO ("RTL not implemented")]
+		[Localizable (true)]
+		public virtual RightToLeft RightToLeft {
+			get { return this.right_to_left; }
+			set { 
+				if (this.right_to_left != value) {
+					this.right_to_left = value;
+					this.OnRightToLeftChanged (EventArgs.Empty);
+				}
+			}
+		}
+		
+		[Localizable (true)]
+		[DefaultValue (false)]
+		public bool RightToLeftAutoMirrorImage {
+			get { return this.right_to_left_auto_mirror_image; }
+			set { 
+				if (this.right_to_left_auto_mirror_image != value) {
+					this.right_to_left_auto_mirror_image = value;
+					this.Invalidate ();
+				}
+			}
+		}
+		
+		[Browsable (false)]
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+		public virtual bool Selected { get { return this.is_selected; } }
+
+		[Localizable (true)]
+		public virtual Size Size {
+			get { 
+				if (!this.AutoSize && this.explicit_size != Size.Empty) 
+					return this.explicit_size; 
+					
+				return this.bounds.Size; 
+			}
+			set { 
+				this.bounds.Size = value; 
+				this.explicit_size = value;
+				
+				if (this.Visible) {
+					this.CalculateAutoSize ();
+					this.OnBoundsChanged (); 
+				}
+			}
+		}
+
+		[Localizable (false)]
+		[Bindable (true)]
+		[DefaultValue (null)]
+		[TypeConverter (typeof (StringConverter))]
+		public Object Tag {
+			get { return this.tag; }
+			set { this.tag = value; }
+		}
+
+		[Localizable (true)]
+		[DefaultValue ("")]
+		public virtual string Text
+		{
+			get { return this.text; }
+			set { 
+				if (this.text != value) { 
+					this.text = value; 
+					this.Invalidate (); 
+					this.CalculateAutoSize (); 
+					this.Invalidate ();
+					this.OnTextChanged (EventArgs.Empty); 
+				} 
+			}
+		}
+
+		[Localizable (true)]
+		[DefaultValue (ContentAlignment.MiddleCenter)]
+		public virtual ContentAlignment TextAlign {
+			get { return this.text_align; }
+			set {
+				if (!Enum.IsDefined (typeof (ContentAlignment), value))
+					throw new InvalidEnumArgumentException (string.Format ("Enum argument value '{0}' is not valid for ContentAlignment", value));
+
+				if (this.text_align != value) {
+					this.text_align = value;
+					this.CalculateAutoSize (); 
+				}
+			}
+		}
+
+		public virtual ToolStripTextDirection TextDirection {
+			get {
+				if (this.text_direction == ToolStripTextDirection.Inherit) {
+					if (this.Parent != null)
+						return this.Parent.TextDirection;
+					else
+						return ToolStripTextDirection.Horizontal;
+				}
+
+				return this.text_direction;
+			}
+			set {
+				if (!Enum.IsDefined (typeof (ToolStripTextDirection), value))
+					throw new InvalidEnumArgumentException (string.Format ("Enum argument value '{0}' is not valid for ToolStripTextDirection", value));
+				
+				if (this.text_direction != value) {
+					this.text_direction = value;
+					this.CalculateAutoSize ();
+					this.Invalidate ();
+				}
+			}	
+		}
+
+		[Localizable (true)]
+		[DefaultValue (TextImageRelation.ImageBeforeText)]
+		public TextImageRelation TextImageRelation {
+			get { return this.text_image_relation; }
+			set { 
+				this.text_image_relation = value; 
+				this.CalculateAutoSize (); 
+				this.Invalidate (); 
+			}
+		}
+
+		[Localizable (true)]
+		//[Editor ("System.ComponentModel.Design.MultilineStringEditor, " + Consts.AssemblySystem_Design,
+		//	 //"System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
+		public string ToolTipText {
+			get { return this.tool_tip_text; }
+			set { this.tool_tip_text = value; }
+		}
+
+		[Localizable (true)]
+		public bool Visible {
+			get { 
+				if (this.parent == null)
+					return false;
+			
+				return this.visible && this.parent.Visible; 
+			}
+			set { 
+				if (this.visible != value) {
+					this.available = value;
+					this.SetVisibleCore (value);
+					if (this.Owner != null)
+						this.Owner.PerformLayout ();
+				}
+			}
+		}
+
+		[Browsable (false)]
+		//[EditorBrowsable (EditorBrowsableState.Always)]
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+		public int Width {
+			get { return this.Size.Width; }
+			set { 
+				this.Size = new Size (value, this.Size.Height); 
+				this.explicit_size.Width = value;
+				
+				if (this.Visible) {
+					this.CalculateAutoSize ();
+					this.OnBoundsChanged ();
+					this.Invalidate ();
+				}
+			}
+		}
+		#endregion
+
+		#region Protected Properties
+		protected virtual bool DefaultAutoToolTip { get { return false; } }
+		protected virtual ToolStripItemDisplayStyle DefaultDisplayStyle { get { return ToolStripItemDisplayStyle.ImageAndText; } }
+		protected internal virtual Padding DefaultMargin { get { return new Padding (0, 1, 0, 2); } }
+		protected virtual Padding DefaultPadding { get { return new Padding (); } }
+		protected virtual Size DefaultSize { get { return new Size (23, 23); } }
+		protected internal virtual bool DismissWhenClicked { get { return true; } }
+		[Browsable (false)]
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+		protected internal ToolStrip Parent {
+			get { return this.parent; }
+			set { 
+				if (this.parent != value) {
+					ToolStrip old_parent = this.parent;
+					this.parent = value; 
+					OnParentChanged(old_parent, this.parent);
+				}
+			}
+		}
+		protected internal virtual bool ShowKeyboardCues { get { return false; } }
+		#endregion
+
+		#region Public Methods
+		[MonoTODO ("Stub, does nothing")]
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		public DragDropEffects DoDragDrop (Object data, DragDropEffects allowedEffects)
+		{
+			return allowedEffects;
+		}
+		
+		public ToolStrip GetCurrentParent ()
+		{ 
+			return this.parent; 
+		}
+
+		public virtual Size GetPreferredSize (Size constrainingSize)
+		{
+			return this.CalculatePreferredSize (constrainingSize);
+		}
+
+		public void Invalidate ()
+		{
+			if (parent != null)
+				parent.Invalidate (this.bounds);
+		}
+
+		public void Invalidate (Rectangle r)
+		{
+			if (parent != null)
+				parent.Invalidate (r);
+		}
+
+		public void PerformClick ()
+		{ 
+			this.OnClick (EventArgs.Empty); 
+		}
+
+		//[EditorBrowsable (EditorBrowsableState.Never)]
+		public virtual void ResetBackColor () { this.BackColor = Color.Empty; }
+
+		//[EditorBrowsable (EditorBrowsableState.Never)]
+		public virtual void ResetDisplayStyle () { this.display_style = this.DefaultDisplayStyle; }
+
+		//[EditorBrowsable (EditorBrowsableState.Never)]
+		public virtual void ResetFont () { this.font = null; }
+
+		//[EditorBrowsable (EditorBrowsableState.Never)]
+		public virtual void ResetForeColor () { this.ForeColor = Color.Empty; }
+
+		//[EditorBrowsable (EditorBrowsableState.Never)]
+		public virtual void ResetImage () { this.image = null; }
+
+		//[EditorBrowsable (EditorBrowsableState.Never)]
+		public void ResetMargin () { this.margin = this.DefaultMargin; }
+
+		//[EditorBrowsable (EditorBrowsableState.Never)]
+		public void ResetPadding () { this.padding = this.DefaultPadding; }
+
+		//[EditorBrowsable (EditorBrowsableState.Never)]
+		public virtual void ResetRightToLeft () { this.right_to_left = RightToLeft.Inherit; }
+		
+		//[EditorBrowsable (EditorBrowsableState.Never)]
+		public virtual void ResetTextDirection () { this.TextDirection = this.DefaultTextDirection; }
+
+		public void Select ()
+		{
+			if (!this.is_selected && this.CanSelect) {
+				this.is_selected = true;
+				
+				if (this.Parent != null) {
+					if (this.Visible && this.Parent.Focused && this is ToolStripWidgetHost)
+						(this as ToolStripWidgetHost).Focus ();
+						
+					this.Invalidate ();
+					this.Parent.NotifySelectedChanged (this);
+				}
+				OnUIASelectionChanged ();
+			}
+		}
+
+		public override string ToString ()
+		{
+			return this.text;
+		}
+		#endregion
+
+		#region Protected Methods
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		protected virtual AccessibleObject CreateAccessibilityInstance ()
+		{
+			return new ToolStripItemAccessibleObject (this);
+		}
+
+		protected override void Dispose (bool disposing)
+		{
+			if (!is_disposed && disposing)
+				is_disposed = true;
+
+			if (image != null) {
+				StopAnimation ();
+				image = null;
+			}
+
+			if (owner != null && disposing)
+				owner.Items.Remove (this);
+			
+			base.Dispose (disposing);
+		}
+		
+		protected internal virtual bool IsInputChar (char charCode)
+		{
+			return false;
+		}
+		
+		protected internal virtual bool IsInputKey (Keys keyData)
+		{
+			return false;
+		}
+		
+		protected virtual void OnAvailableChanged (EventArgs e)
+		{
+			EventHandler eh = (EventHandler)(Events [AvailableChangedEvent]);
+			if (eh != null)
+				eh (this, e);
+		}
+
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		protected virtual void OnBackColorChanged (EventArgs e)
+		{
+			EventHandler eh = (EventHandler)(Events [BackColorChangedEvent]);
+			if (eh != null)
+				eh (this, e);
+		}
+
+		protected virtual void OnBoundsChanged ()
+		{
+			OnLayout (new LayoutEventArgs(null, string.Empty));
+		}
+
+		protected virtual void OnClick (EventArgs e)
+		{
+			EventHandler eh = (EventHandler)(Events [ClickEvent]);
+			if (eh != null)
+				eh (this, e);
+		}
+
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		protected virtual void OnDisplayStyleChanged (EventArgs e)
+		{
+			EventHandler eh = (EventHandler)(Events [DisplayStyleChangedEvent]);
+			if (eh != null)
+				eh (this, e);
+		}
+
+		protected virtual void OnDoubleClick (EventArgs e)
+		{
+			EventHandler eh = (EventHandler)(Events [DoubleClickEvent]);
+			if (eh != null)
+				eh (this, e);
+		}
+
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		protected virtual void OnDragDrop (DragEventArgs dragEvent)
+		{
+			DragEventHandler eh = (DragEventHandler)(Events[DragDropEvent]);
+			if (eh != null)
+				eh (this, dragEvent);
+		}
+
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		protected virtual void OnDragEnter (DragEventArgs dragEvent)
+		{
+			DragEventHandler eh = (DragEventHandler)(Events[DragEnterEvent]);
+			if (eh != null)
+				eh (this, dragEvent);
+		}
+
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		protected virtual void OnDragLeave (EventArgs e)
+		{
+			EventHandler eh = (EventHandler)(Events[DragLeaveEvent]);
+			if (eh != null)
+				eh (this, e);
+		}
+
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		protected virtual void OnDragOver (DragEventArgs dragEvent)
+		{
+			DragEventHandler eh = (DragEventHandler)(Events[DragOverEvent]);
+			if (eh != null)
+				eh (this, dragEvent);
+		}
+
+		protected virtual void OnEnabledChanged (EventArgs e)
+		{
+			EventHandler eh = (EventHandler)(Events [EnabledChangedEvent]);
+			if (eh != null)
+				eh (this, e);
+		}
+
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		protected virtual void OnFontChanged (EventArgs e)
+		{
+		}
+
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		protected virtual void OnForeColorChanged (EventArgs e)
+		{
+			EventHandler eh = (EventHandler)(Events [ForeColorChangedEvent]);
+			if (eh != null)
+				eh (this, e);
+		}
+
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		protected virtual void OnGiveFeedback (GiveFeedbackEventArgs giveFeedbackEvent)
+		{
+			GiveFeedbackEventHandler eh = (GiveFeedbackEventHandler)(Events[GiveFeedbackEvent]);
+			if (eh != null)
+				eh (this, giveFeedbackEvent);
+		}
+
+		protected virtual void OnLayout (LayoutEventArgs e)
+		{
+		}
+
+		protected virtual void OnLocationChanged (EventArgs e)
+		{
+			EventHandler eh = (EventHandler)(Events [LocationChangedEvent]);
+			if (eh != null)
+				eh (this, e);
+		}
+
+		protected virtual void OnMouseDown (MouseEventArgs e)
+		{
+			if (this.Enabled) {
+				this.is_pressed = true;
+				this.Invalidate ();
+
+				MouseEventHandler eh = (MouseEventHandler)(Events [MouseDownEvent]);
+				if (eh != null)
+					eh (this, e);
+			}
+		}
+
+		protected virtual void OnMouseEnter (EventArgs e)
+		{
+			this.Select ();
+
+			EventHandler eh = (EventHandler)(Events [MouseEnterEvent]);
+			if (eh != null)
+				eh (this, e);
+		}
+
+		protected virtual void OnMouseHover (EventArgs e)
+		{
+			if (this.Enabled) {
+				EventHandler eh = (EventHandler)(Events [MouseHoverEvent]);
+				if (eh != null)
+					eh (this, e);
+			}
+		}
+
+		protected virtual void OnMouseLeave (EventArgs e)
+		{
+			if (this.CanSelect) {
+				this.is_selected = false;
+				this.is_pressed = false;
+				this.Invalidate ();
+				OnUIASelectionChanged ();
+			}
+
+			EventHandler eh = (EventHandler)(Events [MouseLeaveEvent]);
+			if (eh != null)
+				eh (this, e);
+		}
+
+		protected virtual void OnMouseMove (MouseEventArgs mea)
+		{
+			if (this.Enabled) {
+				MouseEventHandler eh = (MouseEventHandler)(Events [MouseMoveEvent]);
+				if (eh != null)
+					eh (this, mea);
+			}
+		}
+
+		protected virtual void OnMouseUp (MouseEventArgs e)
+		{
+			if (this.Enabled) {
+				this.is_pressed = false;
+				this.Invalidate ();
+
+				if (this.IsOnDropDown)
+					if (!(this is ToolStripDropDownItem) || !(this as ToolStripDropDownItem).HasDropDownItems || (this as ToolStripDropDownItem).DropDown.Visible == false) {
+						if ((this.Parent as ToolStripDropDown).OwnerItem != null)
+							((this.Parent as ToolStripDropDown).OwnerItem as ToolStripDropDownItem).HideDropDown ();
+						else
+							(this.Parent as ToolStripDropDown).Hide ();
+					}
+						
+				
+				MouseEventHandler eh = (MouseEventHandler)(Events [MouseUpEvent]);
+				if (eh != null)
+					eh (this, e);
+			}
+		}
+
+		protected virtual void OnOwnerChanged (EventArgs e)
+		{
+			EventHandler eh = (EventHandler)(Events [OwnerChangedEvent]);
+			if (eh != null)
+				eh (this, e);
+		}
+
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		protected internal virtual void OnOwnerFontChanged (EventArgs e)
+		{
+			this.CalculateAutoSize ();
+			OnFontChanged (EventArgs.Empty);
+		}
+
+		void OnPaintInternal (PaintEventArgs e)
+		{
+			// Have the background rendered independently from OnPaint
+			if (this.parent != null)
+				this.parent.Renderer.DrawItemBackground (new ToolStripItemRenderEventArgs (e.Graphics, this));
+
+			OnPaint (e);
+		}
+
+		protected virtual void OnPaint (PaintEventArgs e)
+		{
+			PaintEventHandler eh = (PaintEventHandler)(Events [PaintEvent]);
+			if (eh != null)
+				eh (this, e);
+		}
+
+		// This is never called.
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		protected virtual void OnParentBackColorChanged (EventArgs e)
+		{
+		}
+		
+		protected virtual void OnParentChanged (ToolStrip oldParent, ToolStrip newParent)
+		{
+			this.text_size = 
+				TextRenderer.MeasureText (this.Text == null ? string.Empty : this.text, this.Font, Size.Empty, TextFormatFlags.HidePrefix);
+			
+			if (oldParent != null)
+				oldParent.PerformLayout ();
+				
+			if (newParent != null)
+				newParent.PerformLayout ();
+		}
+
+		protected internal virtual void OnParentEnabledChanged (EventArgs e)
+		{
+			this.OnEnabledChanged (e);
+		}
+
+		// This is never called.
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		protected virtual void OnParentForeColorChanged (EventArgs e)
+		{
+		}
+
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		protected internal virtual void OnParentRightToLeftChanged (EventArgs e)
+		{
+			this.OnRightToLeftChanged (e);
+		}
+
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		protected virtual void OnQueryContinueDrag (QueryContinueDragEventArgs queryContinueDragEvent)
+		{
+			QueryContinueDragEventHandler eh = (QueryContinueDragEventHandler)(Events[QueryContinueDragEvent]);
+			if (eh != null)
+				eh (this, queryContinueDragEvent);
+		}
+		
+		protected virtual void OnRightToLeftChanged (EventArgs e)
+		{
+			EventHandler eh = (EventHandler)(Events[RightToLeftChangedEvent]);
+			if (eh != null)
+				eh (this, e);
+		}
+		
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		protected virtual void OnTextChanged (EventArgs e)
+		{
+			EventHandler eh = (EventHandler)(Events [TextChangedEvent]);
+			if (eh != null)
+				eh (this, e);
+		}
+
+		protected virtual void OnVisibleChanged (EventArgs e)
+		{
+			EventHandler eh = (EventHandler)(Events [VisibleChangedEvent]);
+			if (eh != null)
+				eh (this, e);
+		}
+
+		protected internal virtual bool ProcessCmdKey (ref Message m, Keys keyData)
+		{
+			return false;
+		}
+		
+		protected internal virtual bool ProcessDialogKey (Keys keyData)
+		{
+			if (this.Selected && keyData == Keys.Enter) {
+				this.FireEvent (EventArgs.Empty, ToolStripItemEventType.Click);
+				return true;
+			}
+				
+			return false;
+		}
+		
+		// ProcessMnemonic will only be called if we are supposed to handle
+		// it.  None of that fancy "thinking" needed!
+		protected internal virtual bool ProcessMnemonic (char charCode)
+		{
+			ToolStripManager.SetActiveToolStrip (this.Parent, true);
+			this.PerformClick ();
+			return true;
+		}
+		
+		protected internal virtual void SetBounds (Rectangle bounds)
+		{
+			if (this.bounds != bounds) {
+				this.bounds = bounds;
+				OnBoundsChanged ();
+			}
+		}
+		
+		protected virtual void SetVisibleCore (bool visible)
+		{
+			this.visible = visible;
+			this.OnVisibleChanged (EventArgs.Empty);
+			
+			if (this.visible)
+				BeginAnimation ();
+			else
+				StopAnimation ();
+			this.Invalidate ();
+		}
+		#endregion
+
+		#region Public Events
+		static object AvailableChangedEvent = new object ();
+		static object BackColorChangedEvent = new object ();
+		static object ClickEvent = new object ();
+		static object DisplayStyleChangedEvent = new object ();
+		static object DoubleClickEvent = new object ();
+		static object DragDropEvent = new object ();
+		static object DragEnterEvent = new object ();
+		static object DragLeaveEvent = new object ();
+		static object DragOverEvent = new object ();
+		static object EnabledChangedEvent = new object ();
+		static object ForeColorChangedEvent = new object ();
+		static object GiveFeedbackEvent = new object ();
+		static object LocationChangedEvent = new object ();
+		static object MouseDownEvent = new object ();
+		static object MouseEnterEvent = new object ();
+		static object MouseHoverEvent = new object ();
+		static object MouseLeaveEvent = new object ();
+		static object MouseMoveEvent = new object ();
+		static object MouseUpEvent = new object ();
+		static object OwnerChangedEvent = new object ();
+		static object PaintEvent = new object ();
+		static object QueryAccessibilityHelpEvent = new object ();
+		static object QueryContinueDragEvent = new object ();
+		static object RightToLeftChangedEvent = new object ();
+		static object TextChangedEvent = new object ();
+		static object VisibleChangedEvent = new object ();
+
+		[Browsable (false)]
+		public event EventHandler AvailableChanged {
+			add { Events.AddHandler (AvailableChangedEvent, value); }
+			remove {Events.RemoveHandler (AvailableChangedEvent, value); }
+		}
+
+		public event EventHandler BackColorChanged {
+			add { Events.AddHandler (BackColorChangedEvent, value); }
+			remove {Events.RemoveHandler (BackColorChangedEvent, value); }
+		}
+
+		public event EventHandler Click {
+			add { Events.AddHandler (ClickEvent, value); }
+			remove {Events.RemoveHandler (ClickEvent, value); }
+		}
+
+		public event EventHandler DisplayStyleChanged {
+			add { Events.AddHandler (DisplayStyleChangedEvent, value); }
+			remove {Events.RemoveHandler (DisplayStyleChangedEvent, value); }
+		}
+
+		public event EventHandler DoubleClick {
+			add { Events.AddHandler (DoubleClickEvent, value); }
+			remove {Events.RemoveHandler (DoubleClickEvent, value); }
+		}
+
+		[MonoTODO ("Event never raised")]
+		[Browsable (false)]
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		public event DragEventHandler DragDrop {
+			add { Events.AddHandler (DragDropEvent, value); }
+			remove { Events.RemoveHandler (DragDropEvent, value); }
+		}
+
+		[MonoTODO ("Event never raised")]
+		[Browsable (false)]
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		public event DragEventHandler DragEnter {
+			add { Events.AddHandler (DragEnterEvent, value); }
+			remove { Events.RemoveHandler (DragEnterEvent, value); }
+		}
+
+		[MonoTODO ("Event never raised")]
+		[Browsable (false)]
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		public event EventHandler DragLeave {
+			add { Events.AddHandler (DragLeaveEvent, value); }
+			remove { Events.RemoveHandler (DragLeaveEvent, value); }
+		}
+
+		[MonoTODO ("Event never raised")]
+		[Browsable (false)]
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		public event DragEventHandler DragOver {
+			add { Events.AddHandler (DragOverEvent, value); }
+			remove { Events.RemoveHandler (DragOverEvent, value); }
+		}
+
+		public event EventHandler EnabledChanged {
+			add { Events.AddHandler (EnabledChangedEvent, value); }
+			remove {Events.RemoveHandler (EnabledChangedEvent, value); }
+		}
+
+		public event EventHandler ForeColorChanged {
+			add { Events.AddHandler (ForeColorChangedEvent, value); }
+			remove {Events.RemoveHandler (ForeColorChangedEvent, value); }
+		}
+
+		[MonoTODO ("Event never raised")]
+		[Browsable (false)]
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		public event GiveFeedbackEventHandler GiveFeedback {
+			add { Events.AddHandler (GiveFeedbackEvent, value); }
+			remove { Events.RemoveHandler (GiveFeedbackEvent, value); }
+		}
+
+		public event EventHandler LocationChanged {
+			add { Events.AddHandler (LocationChangedEvent, value); }
+			remove {Events.RemoveHandler (LocationChangedEvent, value); }
+		}
+
+		public event MouseEventHandler MouseDown {
+			add { Events.AddHandler (MouseDownEvent, value); }
+			remove {Events.RemoveHandler (MouseDownEvent, value); }
+		}
+
+		public event EventHandler MouseEnter {
+			add { Events.AddHandler (MouseEnterEvent, value); }
+			remove {Events.RemoveHandler (MouseEnterEvent, value); }
+		}
+
+		public event EventHandler MouseHover {
+			add { Events.AddHandler (MouseHoverEvent, value); }
+			remove {Events.RemoveHandler (MouseHoverEvent, value); }
+		}
+
+		public event EventHandler MouseLeave {
+			add { Events.AddHandler (MouseLeaveEvent, value); }
+			remove {Events.RemoveHandler (MouseLeaveEvent, value); }
+		}
+
+		public event MouseEventHandler MouseMove {
+			add { Events.AddHandler (MouseMoveEvent, value); }
+			remove {Events.RemoveHandler (MouseMoveEvent, value); }
+		}
+
+		public event MouseEventHandler MouseUp {
+			add { Events.AddHandler (MouseUpEvent, value); }
+			remove {Events.RemoveHandler (MouseUpEvent, value); }
+		}
+
+		public event EventHandler OwnerChanged {
+			add { Events.AddHandler (OwnerChangedEvent, value); }
+			remove {Events.RemoveHandler (OwnerChangedEvent, value); }
+		}
+
+		public event PaintEventHandler Paint {
+			add { Events.AddHandler (PaintEvent, value); }
+			remove {Events.RemoveHandler (PaintEvent, value); }
+		}
+
+		[MonoTODO ("Event never raised")]
+		public event QueryAccessibilityHelpEventHandler QueryAccessibilityHelp {
+			add { Events.AddHandler (QueryAccessibilityHelpEvent, value); }
+			remove { Events.RemoveHandler (QueryAccessibilityHelpEvent, value); }
+		}
+
+		[MonoTODO ("Event never raised")]
+		[Browsable (false)]
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		public event QueryContinueDragEventHandler QueryContinueDrag {
+			add { Events.AddHandler (QueryContinueDragEvent, value); }
+			remove { Events.RemoveHandler (QueryContinueDragEvent, value); }
+		}
+
+		public event EventHandler RightToLeftChanged {
+			add { Events.AddHandler (RightToLeftChangedEvent, value); }
+			remove { Events.RemoveHandler (RightToLeftChangedEvent, value); }
+		}
+		
+		public event EventHandler TextChanged {
+			add { Events.AddHandler (TextChangedEvent, value); }
+			remove {Events.RemoveHandler (TextChangedEvent, value); }
+		}
+
+		public event EventHandler VisibleChanged {
+			add { Events.AddHandler (VisibleChangedEvent, value); }
+			remove {Events.RemoveHandler (VisibleChangedEvent, value); }
+		}
+		#endregion
+
+		#region Internal Methods
+		internal Rectangle AlignInRectangle (Rectangle outer, Size inner, ContentAlignment align)
+		{
+			int x = 0;
+			int y = 0;
+
+			if (align == ContentAlignment.BottomLeft || align == ContentAlignment.MiddleLeft || align == ContentAlignment.TopLeft)
+				x = outer.X;
+			else if (align == ContentAlignment.BottomCenter || align == ContentAlignment.MiddleCenter || align == ContentAlignment.TopCenter)
+				x = Math.Max (outer.X + ((outer.Width - inner.Width) / 2), outer.Left);
+			else if (align == ContentAlignment.BottomRight || align == ContentAlignment.MiddleRight || align == ContentAlignment.TopRight)
+				x = outer.Right - inner.Width;
+			if (align == ContentAlignment.TopCenter || align == ContentAlignment.TopLeft || align == ContentAlignment.TopRight)
+				y = outer.Y;
+			else if (align == ContentAlignment.MiddleCenter || align == ContentAlignment.MiddleLeft || align == ContentAlignment.MiddleRight)
+				y = outer.Y + (outer.Height - inner.Height) / 2;
+			else if (align == ContentAlignment.BottomCenter || align == ContentAlignment.BottomRight || align == ContentAlignment.BottomLeft)
+				y = outer.Bottom - inner.Height;
+
+			return new Rectangle (x, y, Math.Min (inner.Width, outer.Width), Math.Min (inner.Height, outer.Height));
+		}
+
+		internal void CalculateAutoSize ()
+		{
+			this.text_size = TextRenderer.MeasureText (this.Text == null ? string.Empty: this.text, this.Font, Size.Empty, TextFormatFlags.HidePrefix);
+
+			// If our text is rotated, flip the width and height
+			ToolStripTextDirection direction = this.TextDirection;
+			
+			if (direction == ToolStripTextDirection.Vertical270 || direction == ToolStripTextDirection.Vertical90)
+				this.text_size = new Size (this.text_size.Height, this.text_size.Width);
+			
+			if (!this.auto_size || this is ToolStripWidgetHost)
+				return;
+			//this.text_size.Width += 6;
+
+			Size final_size = this.CalculatePreferredSize (Size.Empty);
+
+			if (final_size != this.Size) {
+				this.bounds.Width = final_size.Width;
+				if (this.parent != null)
+					this.parent.PerformLayout ();
+			}
+		}
+
+		internal virtual Size CalculatePreferredSize (Size constrainingSize)
+		{
+			if (!this.auto_size)
+				return this.explicit_size;
+				
+			Size preferred_size = this.DefaultSize;
+
+			switch (this.display_style) {
+				case ToolStripItemDisplayStyle.Text:
+					int width = text_size.Width + this.padding.Horizontal;
+					int height = text_size.Height + this.padding.Vertical;
+					preferred_size = new Size (width, height);
+					break;
+				case ToolStripItemDisplayStyle.Image:
+					if (this.GetImageSize () == Size.Empty)
+						preferred_size = this.DefaultSize;
+					else {
+						switch (this.image_scaling) {
+							case ToolStripItemImageScaling.None:
+								preferred_size = this.GetImageSize ();
+								break;
+							case ToolStripItemImageScaling.SizeToFit:
+								if (this.parent == null)
+									preferred_size = this.GetImageSize ();
+								else
+									preferred_size = this.parent.ImageScalingSize;
+								break;
+						}
+					}
+					break;
+				case ToolStripItemDisplayStyle.ImageAndText:
+					int width2 = text_size.Width + this.padding.Horizontal;
+					int height2 = text_size.Height + this.padding.Vertical;
+
+					if (this.GetImageSize () != Size.Empty) {
+						Size image_size = this.GetImageSize ();
+						
+						if (this.image_scaling == ToolStripItemImageScaling.SizeToFit && this.parent != null)
+							image_size = this.parent.ImageScalingSize;
+						
+						switch (this.text_image_relation) {
+							case TextImageRelation.Overlay:
+								width2 = Math.Max (width2, image_size.Width);
+								height2 = Math.Max (height2, image_size.Height);
+								break;
+							case TextImageRelation.ImageAboveText:
+							case TextImageRelation.TextAboveImage:
+								width2 = Math.Max (width2, image_size.Width);
+								height2 += image_size.Height;
+								break;
+							case TextImageRelation.ImageBeforeText:
+							case TextImageRelation.TextBeforeImage:
+								height2 = Math.Max (height2, image_size.Height);
+								width2 += image_size.Width;
+								break;
+						}
+					}
+
+					preferred_size = new Size (width2, height2);
+					break;
+			}
+
+			if (!(this is ToolStripLabel)) {		// Everything but labels have a border
+				preferred_size.Height += 4;
+				preferred_size.Width += 4;
+			}
+
+			return preferred_size;
+		}
+
+		internal void CalculateTextAndImageRectangles (out Rectangle text_rect, out Rectangle image_rect)
+		{
+			this.CalculateTextAndImageRectangles (this.ContentRectangle, out text_rect, out image_rect);
+		}
+		
+		internal void CalculateTextAndImageRectangles (Rectangle contentRectangle, out Rectangle text_rect, out Rectangle image_rect)
+		{
+			text_rect = Rectangle.Empty;
+			image_rect = Rectangle.Empty;
+				
+			switch (this.display_style) {
+				case ToolStripItemDisplayStyle.None:
+					break;
+				case ToolStripItemDisplayStyle.Text:
+					if (this.text != string.Empty)
+						text_rect = AlignInRectangle (contentRectangle, this.text_size, this.text_align);
+					break;
+				case ToolStripItemDisplayStyle.Image:
+					if (this.Image != null && this.UseImageMargin)
+						image_rect = AlignInRectangle (contentRectangle, GetImageSize (), this.image_align);
+					break;
+				case ToolStripItemDisplayStyle.ImageAndText:
+					if (this.text != string.Empty && (this.Image == null || !this.UseImageMargin))
+						text_rect = AlignInRectangle (contentRectangle, this.text_size, this.text_align);
+					else if (this.text == string.Empty && (this.Image == null || !this.UseImageMargin))
+						break;
+					else if (this.text == string.Empty && this.Image != null)
+						image_rect = AlignInRectangle (contentRectangle, GetImageSize (), this.image_align);
+					else {
+						Rectangle text_area;
+						Rectangle image_area;
+
+						switch (this.text_image_relation) {
+							case TextImageRelation.Overlay:
+								text_rect = AlignInRectangle (contentRectangle, this.text_size, this.text_align);
+								image_rect = AlignInRectangle (contentRectangle, GetImageSize (), this.image_align);
+								break;
+							case TextImageRelation.ImageAboveText:
+								text_area = new Rectangle (contentRectangle.Left, contentRectangle.Bottom - text_size.Height, contentRectangle.Width, text_size.Height);
+								image_area = new Rectangle (contentRectangle.Left, contentRectangle.Top, contentRectangle.Width, contentRectangle.Height - text_area.Height);
+
+								text_rect = AlignInRectangle (text_area, this.text_size, this.text_align);
+								image_rect = AlignInRectangle (image_area, GetImageSize (), this.image_align);
+								break;
+							case TextImageRelation.TextAboveImage:
+								text_area = new Rectangle (contentRectangle.Left, contentRectangle.Top, contentRectangle.Width, text_size.Height);
+								image_area = new Rectangle (contentRectangle.Left, text_area.Bottom, contentRectangle.Width, contentRectangle.Height - text_area.Height);
+
+								text_rect = AlignInRectangle (text_area, this.text_size, this.text_align);
+								image_rect = AlignInRectangle (image_area, GetImageSize (), this.image_align);
+								break;
+							case TextImageRelation.ImageBeforeText:
+								LayoutTextBeforeOrAfterImage (contentRectangle, false, text_size, GetImageSize (), text_align, image_align, out text_rect, out image_rect);
+								break;
+							case TextImageRelation.TextBeforeImage:
+								LayoutTextBeforeOrAfterImage (contentRectangle, true, text_size, GetImageSize (), text_align, image_align, out text_rect, out image_rect);
+								break;
+						}
+					}
+					break;
+			}
+		}
+
+		private static Font DefaultFont { get { return new Font ("Tahoma", 8.25f); } }
+		
+		internal virtual ToolStripTextDirection DefaultTextDirection { get { return ToolStripTextDirection.Inherit; } }
+
+		internal virtual void Dismiss (ToolStripDropDownCloseReason reason)
+		{
+			if (is_selected) {
+				this.is_selected = false;
+				this.Invalidate ();
+				OnUIASelectionChanged ();
+			}
+		}
+		
+		internal virtual ToolStrip GetTopLevelToolStrip ()
+		{
+			if (this.Parent != null)
+				return this.Parent.GetTopLevelToolStrip ();
+				
+			return null;
+		}
+
+		private void LayoutTextBeforeOrAfterImage (Rectangle totalArea, bool textFirst, Size textSize, Size imageSize, ContentAlignment textAlign, ContentAlignment imageAlign, out Rectangle textRect, out Rectangle imageRect)
+		{
+			int element_spacing = 0;	// Spacing between the Text and the Image
+			int total_width = textSize.Width + element_spacing + imageSize.Width;
+			int excess_width = totalArea.Width - total_width;
+			int offset = 0;
+			
+			Rectangle final_text_rect;
+			Rectangle final_image_rect;
+
+			HorizontalAlignment h_text = GetHorizontalAlignment (textAlign);
+			HorizontalAlignment h_image = GetHorizontalAlignment (imageAlign);
+			
+			if (h_image == HorizontalAlignment.Left)
+				offset = 0;
+			else if (h_image == HorizontalAlignment.Right && h_text == HorizontalAlignment.Right)
+				offset = excess_width;
+			else if (h_image == HorizontalAlignment.Center && (h_text == HorizontalAlignment.Left || h_text == HorizontalAlignment.Center))
+				offset += (int)(excess_width / 3);
+			else
+				offset += (int)(2 * (excess_width / 3));
+				
+			if (textFirst) {
+				final_text_rect = new Rectangle (totalArea.Left + offset, AlignInRectangle (totalArea, textSize, textAlign).Top, textSize.Width, textSize.Height);
+				final_image_rect = new Rectangle (final_text_rect.Right + element_spacing, AlignInRectangle (totalArea, imageSize, imageAlign).Top, imageSize.Width, imageSize.Height);
+			} else {
+				final_image_rect = new Rectangle (totalArea.Left + offset, AlignInRectangle (totalArea, imageSize, imageAlign).Top, imageSize.Width, imageSize.Height);
+				final_text_rect = new Rectangle (final_image_rect.Right + element_spacing, AlignInRectangle (totalArea, textSize, textAlign).Top, textSize.Width, textSize.Height);
+			}
+			
+			textRect = final_text_rect;
+			imageRect = final_image_rect;
+		}
+		
+		private HorizontalAlignment GetHorizontalAlignment (ContentAlignment align)
+		{
+			switch (align) {
+				case ContentAlignment.BottomLeft:
+				case ContentAlignment.MiddleLeft:
+				case ContentAlignment.TopLeft:
+					return HorizontalAlignment.Left;
+				case ContentAlignment.BottomCenter:
+				case ContentAlignment.MiddleCenter:
+				case ContentAlignment.TopCenter:
+					return HorizontalAlignment.Center;
+				case ContentAlignment.BottomRight:
+				case ContentAlignment.MiddleRight:
+				case ContentAlignment.TopRight:
+					return HorizontalAlignment.Right;
+			}
+			
+			return HorizontalAlignment.Left;
+		}
+		
+		internal Size GetImageSize ()
+		{
+			// Get the actual size of our internal image -or-
+			// Get the ImageList.ImageSize if we are using ImageLists
+			if (this.image_scaling == ToolStripItemImageScaling.None) {
+				if (this.image != null)
+					return image.Size;
+					
+				if (this.image_index >= 0 || !string.IsNullOrEmpty (this.image_key))
+					if (this.owner != null && this.owner.ImageList != null)
+						return this.owner.ImageList.ImageSize;
+			} else {
+				// If we have an image and a parent, return ImageScalingSize
+				if (this.Parent == null)
+					return Size.Empty;
+					
+				if (this.image != null)
+					return this.Parent.ImageScalingSize;
+
+				if (this.image_index >= 0 || !string.IsNullOrEmpty (this.image_key))
+					if (this.owner != null && this.owner.ImageList != null)
+						return this.Parent.ImageScalingSize;
+			}
+			
+			return Size.Empty;
+		}
+		
+		internal string GetToolTip ()
+		{
+			if (this.auto_tool_tip && string.IsNullOrEmpty (this.tool_tip_text))
+				return this.Text;
+				
+			return this.tool_tip_text;
+		}
+		
+		internal void FireEvent (EventArgs e, ToolStripItemEventType met)
+		{
+			// If we're disabled, don't fire any of these events, except Paint
+			if (!this.Enabled && met != ToolStripItemEventType.Paint)
+				return;
+				
+			switch (met) {
+				case ToolStripItemEventType.MouseUp:
+					if (((MouseEventArgs)e).Button == MouseButtons.Left)
+						this.HandleClick (((MouseEventArgs)e).Clicks, e);
+					this.OnMouseUp ((MouseEventArgs)e);
+					break;
+				case ToolStripItemEventType.MouseDown:
+					this.OnMouseDown ((MouseEventArgs)e);
+					break;
+				case ToolStripItemEventType.MouseEnter:
+					this.OnMouseEnter (e);
+					break;
+				case ToolStripItemEventType.MouseHover:
+					this.OnMouseHover (e);
+					break;
+				case ToolStripItemEventType.MouseLeave:
+					this.OnMouseLeave (e);
+					break;
+				case ToolStripItemEventType.MouseMove:
+					this.OnMouseMove ((MouseEventArgs)e);
+					break;
+				case ToolStripItemEventType.Paint:
+					this.OnPaintInternal ((PaintEventArgs)e);
+					break;
+				case ToolStripItemEventType.Click:
+					this.HandleClick (1, e);
+					break;
+			}
+		}
+		
+		internal virtual void HandleClick (int mouse_clicks, EventArgs e)
+		{
+			if (Parent == null)
+				return;
+			this.Parent.HandleItemClick (this);
+			if (mouse_clicks == 2 && double_click_enabled)
+				this.OnDoubleClick (e);
+			else
+				this.OnClick (e);
+		}
+		
+		internal virtual void SetPlacement (ToolStripItemPlacement placement)
+		{
+			this.placement = placement;
+		}
+
+		private void BeginAnimation ()
+		{
+			if (image != null && ImageAnimator.CanAnimate (image)) {
+				frame_handler = new EventHandler (OnAnimateImage);
+				ImageAnimator.Animate (image, frame_handler);
+			}
+		}
+
+		private void OnAnimateImage (object sender, EventArgs e)
+		{
+			// This is called from a worker thread,BeginInvoke is used
+			// so the Widget is updated from the correct thread
+
+			// Check if we have a handle again, since it may have gotten
+			// destroyed since the last time we checked.
+			if (Parent == null || !Parent.IsHandleCreated)
+				return;
+
+			Parent.BeginInvoke (new EventHandler (UpdateAnimatedImage), new object[] { this, e });
+		}
+
+		private void StopAnimation ()
+		{
+			if (frame_handler == null)
+				return;
+				
+			ImageAnimator.StopAnimate (image, frame_handler);
+			frame_handler = null;
+		}
+
+		private void UpdateAnimatedImage (object sender, EventArgs e)
+		{
+			// Check if we have a handle again, since it may have gotten
+			// destroyed since the last time we checked.
+			if (Parent == null || !Parent.IsHandleCreated)
+				return;
+
+			ImageAnimator.UpdateFrames (image);
+			Invalidate ();
+		}
+
+		internal bool ShowMargin {
+			get {
+				if (!this.IsOnDropDown)
+					return true;
+
+				if (!(this.Owner is ToolStripDropDownMenu))
+					return false;
+
+				ToolStripDropDownMenu tsddm = (ToolStripDropDownMenu)this.Owner;
+
+				return tsddm.ShowCheckMargin || tsddm.ShowImageMargin;
+			}
+		}
+
+		internal bool UseImageMargin {
+			get {
+				if (!this.IsOnDropDown)
+					return true;
+
+				if (!(this.Owner is ToolStripDropDownMenu))
+					return false;
+
+				ToolStripDropDownMenu tsddm = (ToolStripDropDownMenu)this.Owner;
+
+				return tsddm.ShowImageMargin || tsddm.ShowCheckMargin;
+			}
+		}
+
+		internal virtual bool InternalVisible {
+			get { return this.visible; }
+			set { this.visible = value; Invalidate (); }
+		}
+
+		internal ToolStrip InternalOwner {
+			set {
+				if (this.owner != value) {
+					this.owner = value;
+					if (this.owner != null)
+						this.CalculateAutoSize ();
+					OnOwnerChanged (EventArgs.Empty);
+				}
+			}
+		}
+
+		internal Point Location {
+			get { return this.bounds.Location; }
+			set {
+				if (this.bounds.Location != value) {
+					this.bounds.Location = value;
+					this.OnLocationChanged (EventArgs.Empty);
+				}
+			}
+		}
+
+		internal int Top {
+			get { return this.bounds.Y; }
+			set {
+				if (this.bounds.Y != value) {
+					this.bounds.Y = value;
+					this.OnLocationChanged (EventArgs.Empty);
+				}
+			}
+		}
+
+		internal int Left {
+			get { return this.bounds.X; }
+			set {
+				if (this.bounds.X != value) {
+					this.bounds.X = value;
+					this.OnLocationChanged (EventArgs.Empty);
+				}
+			}
+		}
+		
+		internal int Right { get { return this.bounds.Right; } }
+		internal int Bottom { get { return this.bounds.Bottom; } }
+		#endregion
+
+		#region IDropTarget Members
+		void IDropTarget.OnDragDrop (DragEventArgs dragEvent)
+		{
+			OnDragDrop (dragEvent);
+		}
+
+		void IDropTarget.OnDragEnter (DragEventArgs dragEvent)
+		{
+			OnDragEnter (dragEvent);
+		}
+
+		void IDropTarget.OnDragLeave (EventArgs e)
+		{
+			OnDragLeave (e);
+		}
+
+		void IDropTarget.OnDragOver (DragEventArgs dragEvent)
+		{
+			OnDragOver (dragEvent);
+		}
+		#endregion
+
+		#region UIA Framework: Methods, Properties and Events
+
+		static object UIASelectionChangedEvent = new object ();
+
+		internal event EventHandler UIASelectionChanged {
+			add { Events.AddHandler (UIASelectionChangedEvent, value); }
+			remove { Events.RemoveHandler (UIASelectionChangedEvent, value); }
+		}
+
+		internal void OnUIASelectionChanged ()
+		{
+			EventHandler eh = (EventHandler)(Events [UIASelectionChangedEvent]);
+			if (eh != null)
+				eh (this, EventArgs.Empty);
+		}
+		
+		#endregion
+
+		[ComVisible (true)]
+		public class ToolStripItemAccessibleObject : AccessibleObject
+		{
+			internal ToolStripItem owner_item;
+			
+			public ToolStripItemAccessibleObject (ToolStripItem ownerItem)
+			{
+				if (ownerItem == null)
+					throw new ArgumentNullException ("ownerItem");
+					
+				this.owner_item = ownerItem;
+				base.default_action = string.Empty;
+				base.keyboard_shortcut = string.Empty;
+				base.name = string.Empty;
+				base.value = string.Empty;
+			}
+
+			#region Public Properties
+			public override Rectangle Bounds {
+				get {
+					return owner_item.Visible ? owner_item.Bounds : Rectangle.Empty;
+				}
+			}
+
+			public override string DefaultAction {
+				get { return base.DefaultAction; }
+			}
+
+			public override string Description {
+				get { return base.Description; }
+			}
+
+			public override string Help {
+				get { return base.Help; }
+			}
+
+			public override string KeyboardShortcut {
+				get { return base.KeyboardShortcut; }
+			}
+
+			public override string Name {
+				get {
+					if (base.name == string.Empty)
+						return owner_item.Text;
+						
+					return base.Name;
+				}
+				set { base.Name = value; }
+			}
+
+			public override AccessibleObject Parent {
+				get { return base.Parent; }
+			}
+
+			public override AccessibleRole Role {
+				get { return base.Role; }
+			}
+
+			public override AccessibleStates State {
+				get { return base.State; }
+			}
+			#endregion
+
+			#region Public Methods
+			public void AddState (AccessibleStates state)
+			{
+				base.state = state;
+			}
+
+			public override void DoDefaultAction ()
+			{
+				base.DoDefaultAction ();
+			}
+
+			public override int GetHelpTopic (out string fileName)
+			{
+				return base.GetHelpTopic (out fileName);
+			}
+
+			public override AccessibleObject Navigate (AccessibleNavigation navigationDirection)
+			{
+				return base.Navigate (navigationDirection);
+			}
+
+			public override string ToString ()
+			{
+				return string.Format ("ToolStripItemAccessibleObject: Owner = {0}", owner_item.ToString());
+			}
+			#endregion
+		}
+	}
+
+	internal class NoneExcludedImageIndexConverter : ImageIndexConverter
+	{
+	}
+}