mcs/class/Managed.Windows.Forms/System.Windows.Forms/ToolStripItem.cs

   1 //
   2 // ToolStripItem.cs
   3 //
   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:
  11 //
  12 // The above copyright notice and this permission notice shall be
  13 // included in all copies or substantial portions of the Software.
  14 //
  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.
  22 //
  23 // Copyright (c) 2006 Jonathan Pobst
  24 //
  25 // Authors:
  26 //      Jonathan Pobst (monkey@jpobst.com)
  27 //
  28
  29 #if NET_2_0
  30
  31 using System;
  32 using System.Drawing;
  33 using System.ComponentModel;
  34 using System.Runtime.InteropServices;
  35
  36 namespace System.Windows.Forms
  37 {
  38         [DefaultEvent ("Click")]
  39         [DefaultProperty ("Text")]
  40         [DesignTimeVisible (false)]
  41         [ToolboxItem (false)]
  42         [Designer ("System.Windows.Forms.Design.ToolStripItemDesigner, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.IDesigner")]
  43         public abstract class ToolStripItem : Component, IDropTarget, IComponent, IDisposable
  44         {
  45                 #region Private Variables
  46                 private AccessibleObject accessibility_object;
  47                 private string accessible_default_action_description;
  48                 private bool allow_drop;
  49                 private ToolStripItemAlignment alignment;
  50                 private AnchorStyles anchor;
  51                 private bool available;
  52                 private bool auto_size;
  53                 private bool auto_tool_tip;
  54                 private Color back_color;
  55                 private Image background_image;
  56                 private ImageLayout background_image_layout;
  57                 private Rectangle bounds;
  58                 private bool can_select;
  59                 private ToolStripItemDisplayStyle display_style;
  60                 private DockStyle dock;
  61                 private bool double_click_enabled;
  62                 private bool enabled;
  63                 private Size explicit_size;
  64                 private Font font;
  65                 private Color fore_color;
  66                 private Image image;
  67                 private ContentAlignment image_align;
  68                 private int image_index;
  69                 private string image_key;
  70                 private ToolStripItemImageScaling image_scaling;
  71                 private Color image_transparent_color;
  72                 private bool is_disposed;
  73                 internal bool is_pressed;
  74                 private bool is_selected;
  75                 private Padding margin;
  76                 private MergeAction merge_action;
  77                 private int merge_index;
  78                 private string name;
  79                 private ToolStripItemOverflow overflow;
  80                 private ToolStrip owner;
  81                 internal ToolStripItem owner_item;
  82                 private Padding padding;
  83                 private ToolStripItemPlacement placement;
  84                 private RightToLeft right_to_left;
  85                 private bool right_to_left_auto_mirror_image;
  86                 private Object tag;
  87                 private string text;
  88                 private ContentAlignment text_align;
  89                 private ToolStripTextDirection text_direction;
  90                 private TextImageRelation text_image_relation;
  91                 private string tool_tip_text;
  92                 private bool visible;
  93
  94                 private EventHandler frame_handler;     // For animating images
  95                 private ToolStrip parent;
  96                 private Size text_size;
  97                 #endregion
  98
  99                 #region Public Constructors
 100                 protected ToolStripItem ()
 101                         : this (String.Empty, null, null, String.Empty)
 102                 {
 103                 }
 104
 105                 protected ToolStripItem (string text, Image image, EventHandler onClick)
 106                         : this (text, image, onClick, String.Empty)
 107                 {
 108                 }
 109
 110                 protected ToolStripItem (string text, Image image, EventHandler onClick, string name)
 111                 {
 112                         this.alignment = ToolStripItemAlignment.Left;
 113                         this.anchor = AnchorStyles.Left | AnchorStyles.Top;
 114                         this.auto_size = true;
 115                         this.auto_tool_tip = this.DefaultAutoToolTip;
 116                         this.available = true;
 117                         this.back_color = Color.Empty;
 118                         this.background_image_layout = ImageLayout.Tile;
 119                         this.can_select = true;
 120                         this.display_style = this.DefaultDisplayStyle;
 121                         this.dock = DockStyle.None;
 122                         this.enabled = true;
 123                         this.fore_color = Color.Empty;
 124                         this.image = image;
 125                         this.image_align = ContentAlignment.MiddleCenter;
 126                         this.image_index = -1;
 127                         this.image_key = string.Empty;
 128                         this.image_scaling = ToolStripItemImageScaling.SizeToFit;
 129                         this.image_transparent_color = Color.Empty;
 130                         this.margin = this.DefaultMargin;
 131                         this.merge_action = MergeAction.Append;
 132                         this.merge_index = -1;
 133                         this.name = name;
 134                         this.overflow = ToolStripItemOverflow.AsNeeded;
 135                         this.padding = this.DefaultPadding;
 136                         this.placement = ToolStripItemPlacement.None;
 137                         this.right_to_left = RightToLeft.Inherit;
 138                         this.bounds.Size = this.DefaultSize;
 139                         this.text = text;
 140                         this.text_align = ContentAlignment.MiddleCenter;
 141                         this.text_direction = DefaultTextDirection;
 142                         this.text_image_relation = TextImageRelation.ImageBeforeText;
 143                         this.visible = true;
 144
 145                         this.Click += onClick;
 146                         OnLayout (new LayoutEventArgs (null, string.Empty));
 147                 }
 148                 #endregion
 149
 150                 #region Public Properties
 151                 [Browsable (false)]
 152                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 153                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 154                 public AccessibleObject AccessibilityObject {
 155                         get {
 156                                 if (this.accessibility_object == null)
 157                                         this.accessibility_object = CreateAccessibilityInstance ();
 158
 159                                 return this.accessibility_object;
 160                         }
 161                 }
 162
 163                 [Browsable (false)]
 164                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 165                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 166                 public string AccessibleDefaultActionDescription {
 167                         get {
 168                                 if (this.accessibility_object == null)
 169                                         return null;
 170
 171                                 return this.accessible_default_action_description;
 172                         }
 173                         set { this.accessible_default_action_description = value; }
 174                 }
 175
 176                 [Localizable (true)]
 177                 [DefaultValue (null)]
 178                 public string AccessibleDescription {
 179                         get {
 180                                 if (this.accessibility_object == null)
 181                                         return null;
 182
 183                                 return this.AccessibilityObject.Description;
 184                         }
 185                         set { this.AccessibilityObject.description = value; }
 186                 }
 187
 188                 [Localizable (true)]
 189                 [DefaultValue (null)]
 190                 public string AccessibleName {
 191                         get {
 192                                 if (this.accessibility_object == null)
 193                                         return null;
 194
 195                                 return this.AccessibilityObject.Name;
 196                         }
 197                         set { this.AccessibilityObject.Name = value; }
 198                 }
 199
 200                 [DefaultValue (AccessibleRole.Default)]
 201                 public AccessibleRole AccessibleRole {
 202                         get
 203                         {
 204                                 if (this.accessibility_object == null)
 205                                         return AccessibleRole.Default;
 206
 207                                 return this.AccessibilityObject.Role;
 208                         }
 209                         set { this.AccessibilityObject.role = value; }
 210                 }
 211
 212                 [DefaultValue (ToolStripItemAlignment.Left)]
 213                 public ToolStripItemAlignment Alignment {
 214                         get { return this.alignment; }
 215                         set {
 216                                 if (!Enum.IsDefined (typeof (ToolStripItemAlignment), value))
 217                                         throw new InvalidEnumArgumentException (string.Format ("Enum argument value '{0}' is not valid for ToolStripItemAlignment", value));
 218
 219                                 if (this.alignment != value) {
 220                                         this.alignment = value;
 221                                         this.CalculateAutoSize ();
 222                                 }
 223                         }
 224                 }
 225
 226                 [MonoTODO ("Stub, does nothing")]
 227                 [Browsable (false)]
 228                 [DefaultValue (false)]
 229                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 230                 public virtual bool AllowDrop {
 231                         get { return this.allow_drop; }
 232                         set { this.allow_drop = value; }
 233                 }
 234
 235                 [Browsable (false)]
 236                 [DefaultValue (AnchorStyles.Top | AnchorStyles.Left)]
 237                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 238                 public AnchorStyles Anchor {
 239                         get { return this.anchor; }
 240                         set { this.anchor = value; }
 241                 }
 242
 243                 [Localizable (true)]
 244                 [DefaultValue (true)]
 245                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Visible)]
 246                 [RefreshProperties (RefreshProperties.All)]
 247                 public bool AutoSize {
 248                         get { return this.auto_size; }
 249                         set {
 250                                 this.auto_size = value;
 251                                 this.CalculateAutoSize ();
 252                         }
 253                 }
 254
 255                 [DefaultValue (false)]
 256                 public bool AutoToolTip {
 257                         get { return this.auto_tool_tip; }
 258                         set { this.auto_tool_tip = value; }
 259                 }
 260
 261                 [Browsable (false)]
 262                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 263                 public bool Available {
 264                         get { return this.available; }
 265                         set {
 266                                 if (this.available != value) {
 267                                         available = value;
 268                                         visible = value;
 269
 270                                         if (this.parent != null)
 271                                                 parent.PerformLayout ();
 272
 273                                         OnAvailableChanged (EventArgs.Empty);
 274                                         OnVisibleChanged (EventArgs.Empty);
 275                                 }
 276                         }
 277                 }
 278
 279                 public virtual Color BackColor {
 280                         get {
 281                                 if (back_color != Color.Empty)
 282                                         return back_color;
 283
 284                                 if (Parent != null)
 285                                         return parent.BackColor;
 286
 287                                 return Control.DefaultBackColor;
 288                         }
 289                         set {
 290                                 if (this.back_color != value) {
 291                                         back_color = value;
 292                                         OnBackColorChanged (EventArgs.Empty);
 293                                         this.Invalidate ();
 294                                 }
 295                         }
 296                 }
 297
 298                 [Localizable (true)]
 299                 [DefaultValue (null)]
 300                 public virtual Image BackgroundImage {
 301                         get { return this.background_image; }
 302                         set {
 303                                 if (this.background_image != value) {
 304                                         this.background_image = value;
 305                                         this.Invalidate ();
 306                                 }
 307                         }
 308                 }
 309
 310                 [Localizable (true)]
 311                 [DefaultValue (ImageLayout.Tile)]
 312                 public virtual ImageLayout BackgroundImageLayout {
 313                         get { return this.background_image_layout; }
 314                         set {
 315                                 if (this.background_image_layout != value) {
 316                                         this.background_image_layout = value;
 317                                         this.Invalidate ();
 318                                 }
 319                         }
 320                 }
 321
 322                 [Browsable (false)]
 323                 public virtual Rectangle Bounds {
 324                         get { return this.bounds; }
 325                 }
 326
 327                 [Browsable (false)]
 328                 public virtual bool CanSelect {
 329                         get { return this.can_select; }
 330                 }
 331
 332                 [Browsable (false)]
 333                 public Rectangle ContentRectangle {
 334                         get {
 335                                 // ToolStripLabels don't have a border
 336                                 if (this is ToolStripLabel || this is ToolStripStatusLabel)
 337                                         return new Rectangle (0, 0, this.bounds.Width, this.bounds.Height);
 338
 339                                 if (this is ToolStripDropDownButton && (this as ToolStripDropDownButton).ShowDropDownArrow)
 340                                         return new Rectangle (2, 2, this.bounds.Width - 13, this.bounds.Height - 4);
 341
 342                                 return new Rectangle (2, 2, this.bounds.Width - 4, this.bounds.Height - 4);
 343                         }
 344                 }
 345
 346                 public virtual ToolStripItemDisplayStyle DisplayStyle {
 347                         get { return this.display_style; }
 348                         set {
 349                                 if (this.display_style != value) {
 350                                         this.display_style = value;
 351                                         this.CalculateAutoSize ();
 352                                         OnDisplayStyleChanged (EventArgs.Empty);
 353                                 }
 354                         }
 355                 }
 356
 357                 [Browsable (false)]
 358                 public bool IsDisposed {
 359                         get { return this.is_disposed; }
 360                 }
 361
 362                 [Browsable (false)]
 363                 [DefaultValue (DockStyle.None)]
 364                 public DockStyle Dock {
 365                         get { return this.dock; }
 366                         set {
 367                                 if (this.dock != value) {
 368                                         if (!Enum.IsDefined (typeof (DockStyle), value))
 369                                                 throw new InvalidEnumArgumentException (string.Format ("Enum argument value '{0}' is not valid for DockStyle", value));
 370
 371                                         this.dock = value;
 372                                         this.CalculateAutoSize ();
 373                                 }
 374                         }
 375                 }
 376
 377                 [DefaultValue (false)]
 378                 public bool DoubleClickEnabled {
 379                         get { return this.double_click_enabled; }
 380                         set { this.double_click_enabled = value; }
 381                 }
 382
 383                 [Localizable (true)]
 384                 [DefaultValue (true)]
 385                 public virtual bool Enabled {
 386                         get {
 387                                 if (Parent != null)
 388                                         if (!Parent.Enabled)
 389                                                 return false;
 390
 391                                 if (Owner != null)
 392                                         if (!Owner.Enabled)
 393                                                 return false;
 394
 395                                 return enabled;
 396                         }
 397                         set {
 398                                 if (this.enabled != value) {
 399                                         this.enabled = value;
 400                                         OnEnabledChanged (EventArgs.Empty);
 401                                         this.Invalidate ();
 402                                 }
 403                         }
 404                 }
 405
 406                 [Localizable (true)]
 407                 public virtual Font Font {
 408                         get {
 409                                 if (font != null)
 410                                         return font;
 411
 412                                 if (Parent != null)
 413                                         return Parent.Font;
 414
 415                                 return DefaultFont;
 416                         }
 417                         set {
 418                                 if (this.font != value) {
 419                                         this.font = value;
 420                                         this.CalculateAutoSize ();
 421                                         this.OnFontChanged (EventArgs.Empty);
 422                                         this.Invalidate ();
 423                                 }
 424                         }
 425                 }
 426
 427                 public virtual Color ForeColor {
 428                         get {
 429                                 if (fore_color != Color.Empty)
 430                                         return fore_color;
 431
 432                                 if (Parent != null)
 433                                         return parent.ForeColor;
 434
 435                                 return Control.DefaultForeColor;
 436                         }
 437                         set {
 438                                 if (this.fore_color != value) {
 439                                         this.fore_color = value;
 440                                         this.OnForeColorChanged (EventArgs.Empty);
 441                                         this.Invalidate ();
 442                                 }
 443                         }
 444                 }
 445
 446                 [Browsable (false)]
 447                 [EditorBrowsable (EditorBrowsableState.Always)]
 448                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 449                 public int Height {
 450                         get { return this.Size.Height; }
 451                         set {
 452                                 this.Size = new Size (this.Size.Width, value);
 453                                 this.explicit_size.Height = value;
 454
 455                                 if (this.Visible) {
 456                                         this.CalculateAutoSize ();
 457                                         this.OnBoundsChanged ();
 458                                         this.Invalidate ();
 459                                 }
 460                         }
 461                 }
 462
 463                 [Localizable (true)]
 464                 public virtual Image Image {
 465                         get {
 466                                 if (this.image != null)
 467                                         return this.image;
 468
 469                                 if (this.image_index >= 0)
 470                                         if (this.owner != null && this.owner.ImageList != null && this.owner.ImageList.Images.Count > this.image_index)
 471                                                 return this.owner.ImageList.Images[this.image_index];
 472
 473
 474                                 if (!string.IsNullOrEmpty (this.image_key))
 475                                         if (this.owner != null && this.owner.ImageList != null && this.owner.ImageList.Images.Count > this.image_index)
 476                                                 return this.owner.ImageList.Images[this.image_key];
 477
 478                                 return null;
 479                         }
 480                         set {
 481                                 if (this.image != value) {
 482                                         StopAnimation ();
 483
 484                                         this.image = value;
 485                                         this.image_index = -1;
 486                                         this.image_key = string.Empty;
 487                                         this.CalculateAutoSize ();
 488                                         this.Invalidate ();
 489
 490                                         BeginAnimation ();
 491                                 }
 492                         }
 493                 }
 494
 495                 [Localizable (true)]
 496                 [DefaultValue (ContentAlignment.MiddleCenter)]
 497                 public ContentAlignment ImageAlign {
 498                         get { return this.image_align; }
 499                         set {
 500                                 if (!Enum.IsDefined (typeof (ContentAlignment), value))
 501                                         throw new InvalidEnumArgumentException (string.Format ("Enum argument value '{0}' is not valid for ContentAlignment", value));
 502
 503                                 if (image_align != value) {
 504                                         this.image_align = value;
 505                                         this.CalculateAutoSize ();
 506                                 }
 507                         }
 508                 }
 509
 510                 [Localizable (true)]
 511                 [Browsable (false)]
 512                 [RelatedImageList ("Owner.ImageList")]
 513                 [TypeConverter (typeof (NoneExcludedImageIndexConverter))]
 514                 [RefreshProperties (RefreshProperties.Repaint)]
 515                 [Editor ("System.Windows.Forms.Design.ToolStripImageIndexEditor, " + Consts.AssemblySystem_Design, typeof (System.Drawing.Design.UITypeEditor))]
 516                 public int ImageIndex {
 517                         get { return this.image_index; }
 518                         set {
 519                                 if (this.image_index != value) {
 520                                         // Lamespec: MSDN says ArgumentException, tests say otherwise
 521                                         if (value < -1)
 522                                                 throw new ArgumentOutOfRangeException ("ImageIndex cannot be less than -1");
 523
 524                                         this.image_index = value;
 525                                         this.image = null;
 526                                         this.image_key = string.Empty;
 527                                         this.CalculateAutoSize ();
 528                                         this.Invalidate ();
 529                                 }
 530                         }
 531                 }
 532
 533                 [Localizable (true)]
 534                 [Browsable (false)]
 535                 [RelatedImageList ("Owner.ImageList")]
 536                 [TypeConverter (typeof (ImageKeyConverter))]
 537                 [RefreshProperties (RefreshProperties.Repaint)]
 538                 [Editor ("System.Windows.Forms.Design.ToolStripImageIndexEditor, " + Consts.AssemblySystem_Design, typeof (System.Drawing.Design.UITypeEditor))]
 539                 public string ImageKey {
 540                         get { return this.image_key; }
 541                         set {
 542                                 if (this.image_key != value) {
 543                                         this.image = null;
 544                                         this.image_index = -1;
 545                                         this.image_key = value;
 546                                         this.CalculateAutoSize ();
 547                                         this.Invalidate ();
 548                                 }
 549                         }
 550                 }
 551
 552                 [Localizable (true)]
 553                 [DefaultValue (ToolStripItemImageScaling.SizeToFit)]
 554                 public ToolStripItemImageScaling ImageScaling {
 555                         get { return this.image_scaling; }
 556                         set {
 557                                 if (image_scaling != value) {
 558                                         this.image_scaling = value;
 559                                         this.CalculateAutoSize ();
 560                                 }
 561                         }
 562                 }
 563
 564                 [Localizable (true)]
 565                 public Color ImageTransparentColor {
 566                         get { return this.image_transparent_color; }
 567                         set { this.image_transparent_color = value; }
 568                 }
 569
 570                 [Browsable (false)]
 571                 public bool IsOnDropDown {
 572                         get {
 573                                 if (this.parent != null && this.parent is ToolStripDropDown)
 574                                         return true;
 575
 576                                 return false;
 577                         }
 578                 }
 579
 580                 [Browsable (false)]
 581                 public bool IsOnOverflow {
 582                         get { return this.placement == ToolStripItemPlacement.Overflow; }
 583                 }
 584
 585                 public Padding Margin {
 586                         get { return this.margin; }
 587                         set {
 588                                 this.margin = value;
 589                                 this.CalculateAutoSize ();
 590                         }
 591                 }
 592
 593                 [DefaultValue (MergeAction.Append)]
 594                 public MergeAction MergeAction {
 595                         get { return this.merge_action; }
 596                         set {
 597                                 if (!Enum.IsDefined (typeof (MergeAction), value))
 598                                         throw new InvalidEnumArgumentException (string.Format ("Enum argument value '{0}' is not valid for MergeAction", value));
 599
 600                                 this.merge_action = value;
 601                         }
 602                 }
 603
 604                 [DefaultValue (-1)]
 605                 public int MergeIndex {
 606                         get { return this.merge_index; }
 607                         set { this.merge_index = value; }
 608                 }
 609
 610                 [DefaultValue (null)]
 611                 [Browsable (false)]
 612                 public string Name {
 613                         get { return this.name; }
 614                         set { this.name = value; }
 615                 }
 616
 617                 [DefaultValue (ToolStripItemOverflow.AsNeeded)]
 618                 public ToolStripItemOverflow Overflow {
 619                         get { return this.overflow; }
 620                         set {
 621                                 if (this.overflow != value) {
 622                                         if (!Enum.IsDefined (typeof (ToolStripItemOverflow), value))
 623                                                 throw new InvalidEnumArgumentException (string.Format ("Enum argument value '{0}' is not valid for ToolStripItemOverflow", value));
 624
 625                                         this.overflow = value;
 626
 627                                         if (owner != null)
 628                                                 owner.PerformLayout ();
 629                                 }
 630                         }
 631                 }
 632
 633                 [Browsable (false)]
 634                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 635                 public ToolStrip Owner {
 636                         get { return this.owner; }
 637                         set {
 638                                 if (this.owner != value) {
 639                                         if (this.owner != null)
 640                                                 this.owner.Items.Remove (this);
 641
 642                                         if (value != null)
 643                                                 value.Items.Add (this);
 644                                         else
 645                                                 this.owner = null;
 646                                 }
 647                         }
 648                 }
 649
 650                 [Browsable (false)]
 651                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 652                 public ToolStripItem OwnerItem {
 653                         get { return this.owner_item; }
 654                 }
 655
 656                 public virtual Padding Padding {
 657                         get { return this.padding; }
 658                         set {
 659                                 this.padding = value;
 660                                 this.CalculateAutoSize ();
 661                                 this.Invalidate ();
 662                         }
 663                 }
 664
 665                 [Browsable (false)]
 666                 public ToolStripItemPlacement Placement {
 667                         get { return this.placement; }
 668                 }
 669
 670                 [Browsable (false)]
 671                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 672                 public virtual bool Pressed { get { return this.is_pressed; } }
 673
 674                 [MonoTODO ("RTL not implemented")]
 675                 [Localizable (true)]
 676                 public virtual RightToLeft RightToLeft {
 677                         get { return this.right_to_left; }
 678                         set {
 679                                 if (this.right_to_left != value) {
 680                                         this.right_to_left = value;
 681                                         this.OnRightToLeftChanged (EventArgs.Empty);
 682                                 }
 683                         }
 684                 }
 685
 686                 [Localizable (true)]
 687                 [DefaultValue (false)]
 688                 public bool RightToLeftAutoMirrorImage {
 689                         get { return this.right_to_left_auto_mirror_image; }
 690                         set {
 691                                 if (this.right_to_left_auto_mirror_image != value) {
 692                                         this.right_to_left_auto_mirror_image = value;
 693                                         this.Invalidate ();
 694                                 }
 695                         }
 696                 }
 697
 698                 [Browsable (false)]
 699                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 700                 public virtual bool Selected { get { return this.is_selected; } }
 701
 702                 [Localizable (true)]
 703                 public virtual Size Size {
 704                         get {
 705                                 if (!this.AutoSize && this.explicit_size != Size.Empty)
 706                                         return this.explicit_size;
 707
 708                                 return this.bounds.Size;
 709                         }
 710                         set {
 711                                 this.bounds.Size = value;
 712                                 this.explicit_size = value;
 713
 714                                 if (this.Visible) {
 715                                         this.CalculateAutoSize ();
 716                                         this.OnBoundsChanged ();
 717                                 }
 718                         }
 719                 }
 720
 721                 [Localizable (false)]
 722                 [Bindable (true)]
 723                 [DefaultValue (null)]
 724                 [TypeConverter (typeof (StringConverter))]
 725                 public Object Tag {
 726                         get { return this.tag; }
 727                         set { this.tag = value; }
 728                 }
 729
 730                 [Localizable (true)]
 731                 [DefaultValue ("")]
 732                 public virtual string Text
 733                 {
 734                         get { return this.text; }
 735                         set {
 736                                 if (this.text != value) {
 737                                         this.text = value;
 738                                         this.Invalidate ();
 739                                         this.CalculateAutoSize ();
 740                                         this.Invalidate ();
 741                                         this.OnTextChanged (EventArgs.Empty);
 742                                 }
 743                         }
 744                 }
 745
 746                 [Localizable (true)]
 747                 [DefaultValue (ContentAlignment.MiddleCenter)]
 748                 public virtual ContentAlignment TextAlign {
 749                         get { return this.text_align; }
 750                         set {
 751                                 if (!Enum.IsDefined (typeof (ContentAlignment), value))
 752                                         throw new InvalidEnumArgumentException (string.Format ("Enum argument value '{0}' is not valid for ContentAlignment", value));
 753
 754                                 if (this.text_align != value) {
 755                                         this.text_align = value;
 756                                         this.CalculateAutoSize ();
 757                                 }
 758                         }
 759                 }
 760
 761                 public virtual ToolStripTextDirection TextDirection {
 762                         get {
 763                                 if (this.text_direction == ToolStripTextDirection.Inherit) {
 764                                         if (this.Parent != null)
 765                                                 return this.Parent.TextDirection;
 766                                         else
 767                                                 return ToolStripTextDirection.Horizontal;
 768                                 }
 769
 770                                 return this.text_direction;
 771                         }
 772                         set {
 773                                 if (!Enum.IsDefined (typeof (ToolStripTextDirection), value))
 774                                         throw new InvalidEnumArgumentException (string.Format ("Enum argument value '{0}' is not valid for ToolStripTextDirection", value));
 775
 776                                 if (this.text_direction != value) {
 777                                         this.text_direction = value;
 778                                         this.CalculateAutoSize ();
 779                                         this.Invalidate ();
 780                                 }
 781                         }
 782                 }
 783
 784                 [Localizable (true)]
 785                 [DefaultValue (TextImageRelation.ImageBeforeText)]
 786                 public TextImageRelation TextImageRelation {
 787                         get { return this.text_image_relation; }
 788                         set {
 789                                 this.text_image_relation = value;
 790                                 this.CalculateAutoSize ();
 791                                 this.Invalidate ();
 792                         }
 793                 }
 794
 795                 [Localizable (true)]
 796                 [Editor ("System.ComponentModel.Design.MultilineStringEditor, " + Consts.AssemblySystem_Design,
 797                          "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
 798                 public string ToolTipText {
 799                         get { return this.tool_tip_text; }
 800                         set { this.tool_tip_text = value; }
 801                 }
 802
 803                 [Localizable (true)]
 804                 public bool Visible {
 805                         get {
 806                                 if (this.parent == null)
 807                                         return false;
 808
 809                                 return this.visible && this.parent.Visible;
 810                         }
 811                         set {
 812                                 if (this.visible != value) {
 813                                         this.available = value;
 814                                         this.SetVisibleCore (value);
 815                                         if (this.Owner != null)
 816                                                 this.Owner.PerformLayout ();
 817                                 }
 818                         }
 819                 }
 820
 821                 [Browsable (false)]
 822                 [EditorBrowsable (EditorBrowsableState.Always)]
 823                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 824                 public int Width {
 825                         get { return this.Size.Width; }
 826                         set {
 827                                 this.Size = new Size (value, this.Size.Height);
 828                                 this.explicit_size.Width = value;
 829
 830                                 if (this.Visible) {
 831                                         this.CalculateAutoSize ();
 832                                         this.OnBoundsChanged ();
 833                                         this.Invalidate ();
 834                                 }
 835                         }
 836                 }
 837                 #endregion
 838
 839                 #region Protected Properties
 840                 protected virtual bool DefaultAutoToolTip { get { return false; } }
 841                 protected virtual ToolStripItemDisplayStyle DefaultDisplayStyle { get { return ToolStripItemDisplayStyle.ImageAndText; } }
 842                 protected internal virtual Padding DefaultMargin { get { return new Padding (0, 1, 0, 2); } }
 843                 protected virtual Padding DefaultPadding { get { return new Padding (); } }
 844                 protected virtual Size DefaultSize { get { return new Size (23, 23); } }
 845                 protected internal virtual bool DismissWhenClicked { get { return true; } }
 846                 [Browsable (false)]
 847                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 848                 protected internal ToolStrip Parent {
 849                         get { return this.parent; }
 850                         set {
 851                                 if (this.parent != value) {
 852                                         ToolStrip old_parent = this.parent;
 853                                         this.parent = value;
 854                                         OnParentChanged(old_parent, this.parent);
 855                                 }
 856                         }
 857                 }
 858                 protected internal virtual bool ShowKeyboardCues { get { return false; } }
 859                 #endregion
 860
 861                 #region Public Methods
 862                 [MonoTODO ("Stub, does nothing")]
 863                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 864                 public DragDropEffects DoDragDrop (Object data, DragDropEffects allowedEffects)
 865                 {
 866                         return allowedEffects;
 867                 }
 868
 869                 public ToolStrip GetCurrentParent ()
 870                 {
 871                         return this.parent;
 872                 }
 873
 874                 public virtual Size GetPreferredSize (Size constrainingSize)
 875                 {
 876                         return this.CalculatePreferredSize (constrainingSize);
 877                 }
 878
 879                 public void Invalidate ()
 880                 {
 881                         if (parent != null)
 882                                 parent.Invalidate (this.bounds);
 883                 }
 884
 885                 public void Invalidate (Rectangle r)
 886                 {
 887                         if (parent != null)
 888                                 parent.Invalidate (r);
 889                 }
 890
 891                 public void PerformClick ()
 892                 {
 893                         this.OnClick (EventArgs.Empty);
 894                 }
 895
 896                 [EditorBrowsable (EditorBrowsableState.Never)]
 897                 public virtual void ResetBackColor () { this.BackColor = Color.Empty; }
 898
 899                 [EditorBrowsable (EditorBrowsableState.Never)]
 900                 public virtual void ResetDisplayStyle () { this.display_style = this.DefaultDisplayStyle; }
 901
 902                 [EditorBrowsable (EditorBrowsableState.Never)]
 903                 public virtual void ResetFont () { this.font = null; }
 904
 905                 [EditorBrowsable (EditorBrowsableState.Never)]
 906                 public virtual void ResetForeColor () { this.ForeColor = Color.Empty; }
 907
 908                 [EditorBrowsable (EditorBrowsableState.Never)]
 909                 public virtual void ResetImage () { this.image = null; }
 910
 911                 [EditorBrowsable (EditorBrowsableState.Never)]
 912                 public void ResetMargin () { this.margin = this.DefaultMargin; }
 913
 914                 [EditorBrowsable (EditorBrowsableState.Never)]
 915                 public void ResetPadding () { this.padding = this.DefaultPadding; }
 916
 917                 [EditorBrowsable (EditorBrowsableState.Never)]
 918                 public virtual void ResetRightToLeft () { this.right_to_left = RightToLeft.Inherit; }
 919
 920                 [EditorBrowsable (EditorBrowsableState.Never)]
 921                 public virtual void ResetTextDirection () { this.TextDirection = this.DefaultTextDirection; }
 922
 923                 public void Select ()
 924                 {
 925                         if (!this.is_selected && this.CanSelect) {
 926                                 this.is_selected = true;
 927
 928                                 if (this.Parent != null) {
 929                                         if (this.Visible && this.Parent.Focused && this is ToolStripControlHost)
 930                                                 (this as ToolStripControlHost).Focus ();
 931
 932                                         this.Invalidate ();
 933                                         this.Parent.NotifySelectedChanged (this);
 934                                 }
 935                                 OnUIASelectionChanged ();
 936                         }
 937                 }
 938
 939                 public override string ToString ()
 940                 {
 941                         return this.text;
 942                 }
 943                 #endregion
 944
 945                 #region Protected Methods
 946                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 947                 protected virtual AccessibleObject CreateAccessibilityInstance ()
 948                 {
 949                         return new ToolStripItemAccessibleObject (this);
 950                 }
 951
 952                 protected override void Dispose (bool disposing)
 953                 {
 954                         if (!is_disposed && disposing)
 955                                 is_disposed = true;
 956
 957                         if (image != null) {
 958                                 StopAnimation ();
 959                                 image = null;
 960                         }
 961
 962                         if (owner != null)
 963                                 owner.Items.Remove (this);
 964
 965                         base.Dispose (disposing);
 966                 }
 967
 968                 protected internal virtual bool IsInputChar (char charCode)
 969                 {
 970                         return false;
 971                 }
 972
 973                 protected internal virtual bool IsInputKey (Keys keyData)
 974                 {
 975                         return false;
 976                 }
 977
 978                 protected virtual void OnAvailableChanged (EventArgs e)
 979                 {
 980                         EventHandler eh = (EventHandler)(Events [AvailableChangedEvent]);
 981                         if (eh != null)
 982                                 eh (this, e);
 983                 }
 984
 985                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 986                 protected virtual void OnBackColorChanged (EventArgs e)
 987                 {
 988                         EventHandler eh = (EventHandler)(Events [BackColorChangedEvent]);
 989                         if (eh != null)
 990                                 eh (this, e);
 991                 }
 992
 993                 protected virtual void OnBoundsChanged ()
 994                 {
 995                         OnLayout (new LayoutEventArgs(null, string.Empty));
 996                 }
 997
 998                 protected virtual void OnClick (EventArgs e)
 999                 {
1000                         EventHandler eh = (EventHandler)(Events [ClickEvent]);
1001                         if (eh != null)
1002                                 eh (this, e);
1003                 }
1004
1005                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1006                 protected virtual void OnDisplayStyleChanged (EventArgs e)
1007                 {
1008                         EventHandler eh = (EventHandler)(Events [DisplayStyleChangedEvent]);
1009                         if (eh != null)
1010                                 eh (this, e);
1011                 }
1012
1013                 protected virtual void OnDoubleClick (EventArgs e)
1014                 {
1015                         EventHandler eh = (EventHandler)(Events [DoubleClickEvent]);
1016                         if (eh != null)
1017                                 eh (this, e);
1018
1019                         if (!double_click_enabled)
1020                                 OnClick (e);
1021                 }
1022
1023                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1024                 protected virtual void OnDragDrop (DragEventArgs dragEvent)
1025                 {
1026                         DragEventHandler eh = (DragEventHandler)(Events[DragDropEvent]);
1027                         if (eh != null)
1028                                 eh (this, dragEvent);
1029                 }
1030
1031                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1032                 protected virtual void OnDragEnter (DragEventArgs dragEvent)
1033                 {
1034                         DragEventHandler eh = (DragEventHandler)(Events[DragEnterEvent]);
1035                         if (eh != null)
1036                                 eh (this, dragEvent);
1037                 }
1038
1039                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1040                 protected virtual void OnDragLeave (EventArgs e)
1041                 {
1042                         EventHandler eh = (EventHandler)(Events[DragLeaveEvent]);
1043                         if (eh != null)
1044                                 eh (this, e);
1045                 }
1046
1047                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1048                 protected virtual void OnDragOver (DragEventArgs dragEvent)
1049                 {
1050                         DragEventHandler eh = (DragEventHandler)(Events[DragOverEvent]);
1051                         if (eh != null)
1052                                 eh (this, dragEvent);
1053                 }
1054
1055                 protected virtual void OnEnabledChanged (EventArgs e)
1056                 {
1057                         EventHandler eh = (EventHandler)(Events [EnabledChangedEvent]);
1058                         if (eh != null)
1059                                 eh (this, e);
1060                 }
1061
1062                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1063                 protected virtual void OnFontChanged (EventArgs e)
1064                 {
1065                 }
1066
1067                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1068                 protected virtual void OnForeColorChanged (EventArgs e)
1069                 {
1070                         EventHandler eh = (EventHandler)(Events [ForeColorChangedEvent]);
1071                         if (eh != null)
1072                                 eh (this, e);
1073                 }
1074
1075                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1076                 protected virtual void OnGiveFeedback (GiveFeedbackEventArgs giveFeedbackEvent)
1077                 {
1078                         GiveFeedbackEventHandler eh = (GiveFeedbackEventHandler)(Events[GiveFeedbackEvent]);
1079                         if (eh != null)
1080                                 eh (this, giveFeedbackEvent);
1081                 }
1082
1083                 protected virtual void OnLayout (LayoutEventArgs e)
1084                 {
1085                 }
1086
1087                 protected virtual void OnLocationChanged (EventArgs e)
1088                 {
1089                         EventHandler eh = (EventHandler)(Events [LocationChangedEvent]);
1090                         if (eh != null)
1091                                 eh (this, e);
1092                 }
1093
1094                 protected virtual void OnMouseDown (MouseEventArgs e)
1095                 {
1096                         if (this.Enabled) {
1097                                 this.is_pressed = true;
1098                                 this.Invalidate ();
1099
1100                                 MouseEventHandler eh = (MouseEventHandler)(Events [MouseDownEvent]);
1101                                 if (eh != null)
1102                                         eh (this, e);
1103                         }
1104                 }
1105
1106                 protected virtual void OnMouseEnter (EventArgs e)
1107                 {
1108                         this.Select ();
1109
1110                         EventHandler eh = (EventHandler)(Events [MouseEnterEvent]);
1111                         if (eh != null)
1112                                 eh (this, e);
1113                 }
1114
1115                 protected virtual void OnMouseHover (EventArgs e)
1116                 {
1117                         if (this.Enabled) {
1118                                 EventHandler eh = (EventHandler)(Events [MouseHoverEvent]);
1119                                 if (eh != null)
1120                                         eh (this, e);
1121                         }
1122                 }
1123
1124                 protected virtual void OnMouseLeave (EventArgs e)
1125                 {
1126                         if (this.CanSelect) {
1127                                 this.is_selected = false;
1128                                 this.is_pressed = false;
1129                                 this.Invalidate ();
1130                                 OnUIASelectionChanged ();
1131                         }
1132
1133                         EventHandler eh = (EventHandler)(Events [MouseLeaveEvent]);
1134                         if (eh != null)
1135                                 eh (this, e);
1136                 }
1137
1138                 protected virtual void OnMouseMove (MouseEventArgs mea)
1139                 {
1140                         if (this.Enabled) {
1141                                 MouseEventHandler eh = (MouseEventHandler)(Events [MouseMoveEvent]);
1142                                 if (eh != null)
1143                                         eh (this, mea);
1144                         }
1145                 }
1146
1147                 protected virtual void OnMouseUp (MouseEventArgs e)
1148                 {
1149                         if (this.Enabled) {
1150                                 this.is_pressed = false;
1151                                 this.Invalidate ();
1152
1153                                 if (this.IsOnDropDown)
1154                                         if (!(this is ToolStripDropDownItem) || !(this as ToolStripDropDownItem).HasDropDownItems || (this as ToolStripDropDownItem).DropDown.Visible == false) {
1155                                                 if ((this.Parent as ToolStripDropDown).OwnerItem != null)
1156                                                         ((this.Parent as ToolStripDropDown).OwnerItem as ToolStripDropDownItem).HideDropDown ();
1157                                                 else
1158                                                         (this.Parent as ToolStripDropDown).Hide ();
1159                                         }
1160
1161
1162                                 MouseEventHandler eh = (MouseEventHandler)(Events [MouseUpEvent]);
1163                                 if (eh != null)
1164                                         eh (this, e);
1165                         }
1166                 }
1167
1168                 protected virtual void OnOwnerChanged (EventArgs e)
1169                 {
1170                         EventHandler eh = (EventHandler)(Events [OwnerChangedEvent]);
1171                         if (eh != null)
1172                                 eh (this, e);
1173                 }
1174
1175                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1176                 protected internal virtual void OnOwnerFontChanged (EventArgs e)
1177                 {
1178                         this.CalculateAutoSize ();
1179                 }
1180
1181                 protected virtual void OnPaint (PaintEventArgs e)
1182                 {
1183                         if (this.parent != null)
1184                                 this.parent.Renderer.DrawItemBackground (new ToolStripItemRenderEventArgs (e.Graphics, this));
1185
1186                         PaintEventHandler eh = (PaintEventHandler)(Events [PaintEvent]);
1187                         if (eh != null)
1188                                 eh (this, e);
1189                 }
1190
1191                 // This is never called.
1192                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1193                 protected virtual void OnParentBackColorChanged (EventArgs e)
1194                 {
1195                 }
1196
1197                 protected virtual void OnParentChanged (ToolStrip oldParent, ToolStrip newParent)
1198                 {
1199                         this.text_size = TextRenderer.MeasureText (this.Text == null ? string.Empty : this.text, this.Font, Size.Empty, TextFormatFlags.HidePrefix);
1200
1201                         if (oldParent != null)
1202                                 oldParent.PerformLayout ();
1203
1204                         if (newParent != null)
1205                                 newParent.PerformLayout ();
1206                 }
1207
1208                 protected internal virtual void OnParentEnabledChanged (EventArgs e)
1209                 {
1210                         this.OnEnabledChanged (e);
1211                 }
1212
1213                 // This is never called.
1214                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1215                 protected virtual void OnParentForeColorChanged (EventArgs e)
1216                 {
1217                 }
1218
1219                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1220                 protected internal virtual void OnParentRightToLeftChanged (EventArgs e)
1221                 {
1222                         this.OnRightToLeftChanged (e);
1223                 }
1224
1225                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1226                 protected virtual void OnQueryContinueDrag (QueryContinueDragEventArgs queryContinueDragEvent)
1227                 {
1228                         QueryContinueDragEventHandler eh = (QueryContinueDragEventHandler)(Events[QueryContinueDragEvent]);
1229                         if (eh != null)
1230                                 eh (this, queryContinueDragEvent);
1231                 }
1232
1233                 protected virtual void OnRightToLeftChanged (EventArgs e)
1234                 {
1235                         EventHandler eh = (EventHandler)(Events[RightToLeftChangedEvent]);
1236                         if (eh != null)
1237                                 eh (this, e);
1238                 }
1239
1240                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1241                 protected virtual void OnTextChanged (EventArgs e)
1242                 {
1243                         EventHandler eh = (EventHandler)(Events [TextChangedEvent]);
1244                         if (eh != null)
1245                                 eh (this, e);
1246                 }
1247
1248                 protected virtual void OnVisibleChanged (EventArgs e)
1249                 {
1250                         EventHandler eh = (EventHandler)(Events [VisibleChangedEvent]);
1251                         if (eh != null)
1252                                 eh (this, e);
1253                 }
1254
1255                 protected internal virtual bool ProcessCmdKey (ref Message m, Keys keyData)
1256                 {
1257                         return false;
1258                 }
1259
1260                 protected internal virtual bool ProcessDialogKey (Keys keyData)
1261                 {
1262                         if (this.Selected && keyData == Keys.Enter) {
1263                                 this.FireEvent (EventArgs.Empty, ToolStripItemEventType.Click);
1264                                 return true;
1265                         }
1266
1267                         return false;
1268                 }
1269
1270                 // ProcessMnemonic will only be called if we are supposed to handle
1271                 // it.  None of that fancy "thinking" needed!
1272                 protected internal virtual bool ProcessMnemonic (char charCode)
1273                 {
1274                         ToolStripManager.SetActiveToolStrip (this.Parent, true);
1275                         this.PerformClick ();
1276                         return true;
1277                 }
1278
1279                 protected internal virtual void SetBounds (Rectangle bounds)
1280                 {
1281                         if (this.bounds != bounds) {
1282                                 this.bounds = bounds;
1283                                 OnBoundsChanged ();
1284                         }
1285                 }
1286
1287                 protected virtual void SetVisibleCore (bool visible)
1288                 {
1289                         this.visible = visible;
1290                         this.OnVisibleChanged (EventArgs.Empty);
1291
1292                         if (this.visible)
1293                                 BeginAnimation ();
1294                         else
1295                                 StopAnimation ();
1296                         this.Invalidate ();
1297                 }
1298                 #endregion
1299
1300                 #region Public Events
1301                 static object AvailableChangedEvent = new object ();
1302                 static object BackColorChangedEvent = new object ();
1303                 static object ClickEvent = new object ();
1304                 static object DisplayStyleChangedEvent = new object ();
1305                 static object DoubleClickEvent = new object ();
1306                 static object DragDropEvent = new object ();
1307                 static object DragEnterEvent = new object ();
1308                 static object DragLeaveEvent = new object ();
1309                 static object DragOverEvent = new object ();
1310                 static object EnabledChangedEvent = new object ();
1311                 static object ForeColorChangedEvent = new object ();
1312                 static object GiveFeedbackEvent = new object ();
1313                 static object LocationChangedEvent = new object ();
1314                 static object MouseDownEvent = new object ();
1315                 static object MouseEnterEvent = new object ();
1316                 static object MouseHoverEvent = new object ();
1317                 static object MouseLeaveEvent = new object ();
1318                 static object MouseMoveEvent = new object ();
1319                 static object MouseUpEvent = new object ();
1320                 static object OwnerChangedEvent = new object ();
1321                 static object PaintEvent = new object ();
1322                 static object QueryAccessibilityHelpEvent = new object ();
1323                 static object QueryContinueDragEvent = new object ();
1324                 static object RightToLeftChangedEvent = new object ();
1325                 static object TextChangedEvent = new object ();
1326                 static object VisibleChangedEvent = new object ();
1327
1328                 [Browsable (false)]
1329                 public event EventHandler AvailableChanged {
1330                         add { Events.AddHandler (AvailableChangedEvent, value); }
1331                         remove {Events.RemoveHandler (AvailableChangedEvent, value); }
1332                 }
1333
1334                 public event EventHandler BackColorChanged {
1335                         add { Events.AddHandler (BackColorChangedEvent, value); }
1336                         remove {Events.RemoveHandler (BackColorChangedEvent, value); }
1337                 }
1338
1339                 public event EventHandler Click {
1340                         add { Events.AddHandler (ClickEvent, value); }
1341                         remove {Events.RemoveHandler (ClickEvent, value); }
1342                 }
1343
1344                 public event EventHandler DisplayStyleChanged {
1345                         add { Events.AddHandler (DisplayStyleChangedEvent, value); }
1346                         remove {Events.RemoveHandler (DisplayStyleChangedEvent, value); }
1347                 }
1348
1349                 public event EventHandler DoubleClick {
1350                         add { Events.AddHandler (DoubleClickEvent, value); }
1351                         remove {Events.RemoveHandler (DoubleClickEvent, value); }
1352                 }
1353
1354                 [MonoTODO ("Event never raised")]
1355                 [Browsable (false)]
1356                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1357                 public event DragEventHandler DragDrop {
1358                         add { Events.AddHandler (DragDropEvent, value); }
1359                         remove { Events.RemoveHandler (DragDropEvent, value); }
1360                 }
1361
1362                 [MonoTODO ("Event never raised")]
1363                 [Browsable (false)]
1364                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1365                 public event DragEventHandler DragEnter {
1366                         add { Events.AddHandler (DragEnterEvent, value); }
1367                         remove { Events.RemoveHandler (DragEnterEvent, value); }
1368                 }
1369
1370                 [MonoTODO ("Event never raised")]
1371                 [Browsable (false)]
1372                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1373                 public event EventHandler DragLeave {
1374                         add { Events.AddHandler (DragLeaveEvent, value); }
1375                         remove { Events.RemoveHandler (DragLeaveEvent, value); }
1376                 }
1377
1378                 [MonoTODO ("Event never raised")]
1379                 [Browsable (false)]
1380                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1381                 public event DragEventHandler DragOver {
1382                         add { Events.AddHandler (DragOverEvent, value); }
1383                         remove { Events.RemoveHandler (DragOverEvent, value); }
1384                 }
1385
1386                 public event EventHandler EnabledChanged {
1387                         add { Events.AddHandler (EnabledChangedEvent, value); }
1388                         remove {Events.RemoveHandler (EnabledChangedEvent, value); }
1389                 }
1390
1391                 public event EventHandler ForeColorChanged {
1392                         add { Events.AddHandler (ForeColorChangedEvent, value); }
1393                         remove {Events.RemoveHandler (ForeColorChangedEvent, value); }
1394                 }
1395
1396                 [MonoTODO ("Event never raised")]
1397                 [Browsable (false)]
1398                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1399                 public event GiveFeedbackEventHandler GiveFeedback {
1400                         add { Events.AddHandler (GiveFeedbackEvent, value); }
1401                         remove { Events.RemoveHandler (GiveFeedbackEvent, value); }
1402                 }
1403
1404                 public event EventHandler LocationChanged {
1405                         add { Events.AddHandler (LocationChangedEvent, value); }
1406                         remove {Events.RemoveHandler (LocationChangedEvent, value); }
1407                 }
1408
1409                 public event MouseEventHandler MouseDown {
1410                         add { Events.AddHandler (MouseDownEvent, value); }
1411                         remove {Events.RemoveHandler (MouseDownEvent, value); }
1412                 }
1413
1414                 public event EventHandler MouseEnter {
1415                         add { Events.AddHandler (MouseEnterEvent, value); }
1416                         remove {Events.RemoveHandler (MouseEnterEvent, value); }
1417                 }
1418
1419                 public event EventHandler MouseHover {
1420                         add { Events.AddHandler (MouseHoverEvent, value); }
1421                         remove {Events.RemoveHandler (MouseHoverEvent, value); }
1422                 }
1423
1424                 public event EventHandler MouseLeave {
1425                         add { Events.AddHandler (MouseLeaveEvent, value); }
1426                         remove {Events.RemoveHandler (MouseLeaveEvent, value); }
1427                 }
1428
1429                 public event MouseEventHandler MouseMove {
1430                         add { Events.AddHandler (MouseMoveEvent, value); }
1431                         remove {Events.RemoveHandler (MouseMoveEvent, value); }
1432                 }
1433
1434                 public event MouseEventHandler MouseUp {
1435                         add { Events.AddHandler (MouseUpEvent, value); }
1436                         remove {Events.RemoveHandler (MouseUpEvent, value); }
1437                 }
1438
1439                 public event EventHandler OwnerChanged {
1440                         add { Events.AddHandler (OwnerChangedEvent, value); }
1441                         remove {Events.RemoveHandler (OwnerChangedEvent, value); }
1442                 }
1443
1444                 public event PaintEventHandler Paint {
1445                         add { Events.AddHandler (PaintEvent, value); }
1446                         remove {Events.RemoveHandler (PaintEvent, value); }
1447                 }
1448
1449                 [MonoTODO ("Event never raised")]
1450                 public event QueryAccessibilityHelpEventHandler QueryAccessibilityHelp {
1451                         add { Events.AddHandler (QueryAccessibilityHelpEvent, value); }
1452                         remove { Events.RemoveHandler (QueryAccessibilityHelpEvent, value); }
1453                 }
1454
1455                 [MonoTODO ("Event never raised")]
1456                 [Browsable (false)]
1457                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1458                 public event QueryContinueDragEventHandler QueryContinueDrag {
1459                         add { Events.AddHandler (QueryContinueDragEvent, value); }
1460                         remove { Events.RemoveHandler (QueryContinueDragEvent, value); }
1461                 }
1462
1463                 public event EventHandler RightToLeftChanged {
1464                         add { Events.AddHandler (RightToLeftChangedEvent, value); }
1465                         remove { Events.RemoveHandler (RightToLeftChangedEvent, value); }
1466                 }
1467
1468                 public event EventHandler TextChanged {
1469                         add { Events.AddHandler (TextChangedEvent, value); }
1470                         remove {Events.RemoveHandler (TextChangedEvent, value); }
1471                 }
1472
1473                 public event EventHandler VisibleChanged {
1474                         add { Events.AddHandler (VisibleChangedEvent, value); }
1475                         remove {Events.RemoveHandler (VisibleChangedEvent, value); }
1476                 }
1477                 #endregion
1478
1479                 #region Internal Methods
1480                 internal Rectangle AlignInRectangle (Rectangle outer, Size inner, ContentAlignment align)
1481                 {
1482                         int x = 0;
1483                         int y = 0;
1484
1485                         if (align == ContentAlignment.BottomLeft || align == ContentAlignment.MiddleLeft || align == ContentAlignment.TopLeft)
1486                                 x = outer.X;
1487                         else if (align == ContentAlignment.BottomCenter || align == ContentAlignment.MiddleCenter || align == ContentAlignment.TopCenter)
1488                                 x = Math.Max (outer.X + ((outer.Width - inner.Width) / 2), outer.Left);
1489                         else if (align == ContentAlignment.BottomRight || align == ContentAlignment.MiddleRight || align == ContentAlignment.TopRight)
1490                                 x = outer.Right - inner.Width;
1491                         if (align == ContentAlignment.TopCenter || align == ContentAlignment.TopLeft || align == ContentAlignment.TopRight)
1492                                 y = outer.Y;
1493                         else if (align == ContentAlignment.MiddleCenter || align == ContentAlignment.MiddleLeft || align == ContentAlignment.MiddleRight)
1494                                 y = outer.Y + (outer.Height - inner.Height) / 2;
1495                         else if (align == ContentAlignment.BottomCenter || align == ContentAlignment.BottomRight || align == ContentAlignment.BottomLeft)
1496                                 y = outer.Bottom - inner.Height;
1497
1498                         return new Rectangle (x, y, Math.Min (inner.Width, outer.Width), Math.Min (inner.Height, outer.Height));
1499                 }
1500
1501                 internal void CalculateAutoSize ()
1502                 {
1503                         this.text_size = TextRenderer.MeasureText (this.Text == null ? string.Empty: this.text, this.Font, Size.Empty, TextFormatFlags.HidePrefix);
1504
1505                         // If our text is rotated, flip the width and height
1506                         ToolStripTextDirection direction = this.TextDirection;
1507
1508                         if (direction == ToolStripTextDirection.Vertical270 || direction == ToolStripTextDirection.Vertical90)
1509                                 this.text_size = new Size (this.text_size.Height, this.text_size.Width);
1510
1511                         if (!this.auto_size || this is ToolStripControlHost)
1512                                 return;
1513                         //this.text_size.Width += 6;
1514
1515                         Size final_size = this.CalculatePreferredSize (Size.Empty);
1516
1517                         if (final_size != this.Size) {
1518                                 this.bounds.Width = final_size.Width;
1519                                 if (this.parent != null)
1520                                         this.parent.PerformLayout ();
1521                         }
1522                 }
1523
1524                 internal virtual Size CalculatePreferredSize (Size constrainingSize)
1525                 {
1526                         if (!this.auto_size)
1527                                 return this.explicit_size;
1528
1529                         Size preferred_size = this.DefaultSize;
1530
1531                         switch (this.display_style) {
1532                                 case ToolStripItemDisplayStyle.Text:
1533                                         int width = text_size.Width + this.padding.Horizontal;
1534                                         int height = text_size.Height + this.padding.Vertical;
1535                                         preferred_size = new Size (width, height);
1536                                         break;
1537                                 case ToolStripItemDisplayStyle.Image:
1538                                         if (this.GetImageSize () == Size.Empty)
1539                                                 preferred_size = this.DefaultSize;
1540                                         else {
1541                                                 switch (this.image_scaling) {
1542                                                         case ToolStripItemImageScaling.None:
1543                                                                 preferred_size = this.GetImageSize ();
1544                                                                 break;
1545                                                         case ToolStripItemImageScaling.SizeToFit:
1546                                                                 if (this.parent == null)
1547                                                                         preferred_size = this.GetImageSize ();
1548                                                                 else
1549                                                                         preferred_size = this.parent.ImageScalingSize;
1550                                                                 break;
1551                                                 }
1552                                         }
1553                                         break;
1554                                 case ToolStripItemDisplayStyle.ImageAndText:
1555                                         int width2 = text_size.Width + this.padding.Horizontal;
1556                                         int height2 = text_size.Height + this.padding.Vertical;
1557
1558                                         if (this.GetImageSize () != Size.Empty) {
1559                                                 Size image_size = this.GetImageSize ();
1560
1561                                                 if (this.image_scaling == ToolStripItemImageScaling.SizeToFit && this.parent != null)
1562                                                         image_size = this.parent.ImageScalingSize;
1563
1564                                                 switch (this.text_image_relation) {
1565                                                         case TextImageRelation.Overlay:
1566                                                                 width2 = Math.Max (width2, image_size.Width);
1567                                                                 height2 = Math.Max (height2, image_size.Height);
1568                                                                 break;
1569                                                         case TextImageRelation.ImageAboveText:
1570                                                         case TextImageRelation.TextAboveImage:
1571                                                                 width2 = Math.Max (width2, image_size.Width);
1572                                                                 height2 += image_size.Height;
1573                                                                 break;
1574                                                         case TextImageRelation.ImageBeforeText:
1575                                                         case TextImageRelation.TextBeforeImage:
1576                                                                 height2 = Math.Max (height2, image_size.Height);
1577                                                                 width2 += image_size.Width;
1578                                                                 break;
1579                                                 }
1580                                         }
1581
1582                                         preferred_size = new Size (width2, height2);
1583                                         break;
1584                         }
1585
1586                         if (!(this is ToolStripLabel)) {                // Everything but labels have a border
1587                                 preferred_size.Height += 4;
1588                                 preferred_size.Width += 4;
1589                         }
1590
1591                         return preferred_size;
1592                 }
1593
1594                 internal void CalculateTextAndImageRectangles (out Rectangle text_rect, out Rectangle image_rect)
1595                 {
1596                         this.CalculateTextAndImageRectangles (this.ContentRectangle, out text_rect, out image_rect);
1597                 }
1598
1599                 internal void CalculateTextAndImageRectangles (Rectangle contentRectangle, out Rectangle text_rect, out Rectangle image_rect)
1600                 {
1601                         text_rect = Rectangle.Empty;
1602                         image_rect = Rectangle.Empty;
1603
1604                         switch (this.display_style) {
1605                                 case ToolStripItemDisplayStyle.None:
1606                                         break;
1607                                 case ToolStripItemDisplayStyle.Text:
1608                                         if (this.text != string.Empty)
1609                                                 text_rect = AlignInRectangle (contentRectangle, this.text_size, this.text_align);
1610                                         break;
1611                                 case ToolStripItemDisplayStyle.Image:
1612                                         if (this.Image != null && this.UseImageMargin)
1613                                                 image_rect = AlignInRectangle (contentRectangle, GetImageSize (), this.image_align);
1614                                         break;
1615                                 case ToolStripItemDisplayStyle.ImageAndText:
1616                                         if (this.text != string.Empty && (this.Image == null || !this.UseImageMargin))
1617                                                 text_rect = AlignInRectangle (contentRectangle, this.text_size, this.text_align);
1618                                         else if (this.text == string.Empty && (this.Image == null || !this.UseImageMargin))
1619                                                 break;
1620                                         else if (this.text == string.Empty && this.Image != null)
1621                                                 image_rect = AlignInRectangle (contentRectangle, GetImageSize (), this.image_align);
1622                                         else {
1623                                                 Rectangle text_area;
1624                                                 Rectangle image_area;
1625
1626                                                 switch (this.text_image_relation) {
1627                                                         case TextImageRelation.Overlay:
1628                                                                 text_rect = AlignInRectangle (contentRectangle, this.text_size, this.text_align);
1629                                                                 image_rect = AlignInRectangle (contentRectangle, GetImageSize (), this.image_align);
1630                                                                 break;
1631                                                         case TextImageRelation.ImageAboveText:
1632                                                                 text_area = new Rectangle (contentRectangle.Left, contentRectangle.Bottom - (text_size.Height - 4), contentRectangle.Width, text_size.Height - 4);
1633                                                                 image_area = new Rectangle (contentRectangle.Left, contentRectangle.Top, contentRectangle.Width, contentRectangle.Height - text_area.Height);
1634
1635                                                                 text_rect = AlignInRectangle (text_area, this.text_size, this.text_align);
1636                                                                 image_rect = AlignInRectangle (image_area, GetImageSize (), this.image_align);
1637                                                                 break;
1638                                                         case TextImageRelation.TextAboveImage:
1639                                                                 text_area = new Rectangle (contentRectangle.Left, contentRectangle.Top, contentRectangle.Width, text_size.Height - 4);
1640                                                                 image_area = new Rectangle (contentRectangle.Left, text_area.Bottom, contentRectangle.Width, contentRectangle.Height - text_area.Height);
1641
1642                                                                 text_rect = AlignInRectangle (text_area, this.text_size, this.text_align);
1643                                                                 image_rect = AlignInRectangle (image_area, GetImageSize (), this.image_align);
1644                                                                 break;
1645                                                         case TextImageRelation.ImageBeforeText:
1646                                                                 LayoutTextBeforeOrAfterImage (contentRectangle, false, text_size, GetImageSize (), text_align, image_align, out text_rect, out image_rect);
1647                                                                 break;
1648                                                         case TextImageRelation.TextBeforeImage:
1649                                                                 LayoutTextBeforeOrAfterImage (contentRectangle, true, text_size, GetImageSize (), text_align, image_align, out text_rect, out image_rect);
1650                                                                 break;
1651                                                 }
1652                                         }
1653                                         break;
1654                         }
1655                 }
1656
1657                 private static Font DefaultFont { get { return new Font ("Tahoma", 8.25f); } }
1658
1659                 internal virtual ToolStripTextDirection DefaultTextDirection { get { return ToolStripTextDirection.Inherit; } }
1660
1661                 internal virtual void Dismiss (ToolStripDropDownCloseReason reason)
1662                 {
1663                         if (is_selected) {
1664                                 this.is_selected = false;
1665                                 this.Invalidate ();
1666                                 OnUIASelectionChanged ();
1667                         }
1668                 }
1669
1670                 internal virtual ToolStrip GetTopLevelToolStrip ()
1671                 {
1672                         if (this.Parent != null)
1673                                 return this.Parent.GetTopLevelToolStrip ();
1674
1675                         return null;
1676                 }
1677
1678                 private void LayoutTextBeforeOrAfterImage (Rectangle totalArea, bool textFirst, Size textSize, Size imageSize, ContentAlignment textAlign, ContentAlignment imageAlign, out Rectangle textRect, out Rectangle imageRect)
1679                 {
1680                         int element_spacing = 0;        // Spacing between the Text and the Image
1681                         int total_width = textSize.Width + element_spacing + imageSize.Width;
1682                         int excess_width = totalArea.Width - total_width;
1683                         int offset = 0;
1684
1685                         Rectangle final_text_rect;
1686                         Rectangle final_image_rect;
1687
1688                         HorizontalAlignment h_text = GetHorizontalAlignment (textAlign);
1689                         HorizontalAlignment h_image = GetHorizontalAlignment (imageAlign);
1690
1691                         if (h_image == HorizontalAlignment.Left)
1692                                 offset = 0;
1693                         else if (h_image == HorizontalAlignment.Right && h_text == HorizontalAlignment.Right)
1694                                 offset = excess_width;
1695                         else if (h_image == HorizontalAlignment.Center && (h_text == HorizontalAlignment.Left || h_text == HorizontalAlignment.Center))
1696                                 offset += (int)(excess_width / 3);
1697                         else
1698                                 offset += (int)(2 * (excess_width / 3));
1699
1700                         if (textFirst) {
1701                                 final_text_rect = new Rectangle (totalArea.Left + offset, AlignInRectangle (totalArea, textSize, textAlign).Top, textSize.Width, textSize.Height);
1702                                 final_image_rect = new Rectangle (final_text_rect.Right + element_spacing, AlignInRectangle (totalArea, imageSize, imageAlign).Top, imageSize.Width, imageSize.Height);
1703                         } else {
1704                                 final_image_rect = new Rectangle (totalArea.Left + offset, AlignInRectangle (totalArea, imageSize, imageAlign).Top, imageSize.Width, imageSize.Height);
1705                                 final_text_rect = new Rectangle (final_image_rect.Right + element_spacing, AlignInRectangle (totalArea, textSize, textAlign).Top, textSize.Width, textSize.Height);
1706                         }
1707
1708                         textRect = final_text_rect;
1709                         imageRect = final_image_rect;
1710                 }
1711
1712                 private HorizontalAlignment GetHorizontalAlignment (ContentAlignment align)
1713                 {
1714                         switch (align) {
1715                                 case ContentAlignment.BottomLeft:
1716                                 case ContentAlignment.MiddleLeft:
1717                                 case ContentAlignment.TopLeft:
1718                                         return HorizontalAlignment.Left;
1719                                 case ContentAlignment.BottomCenter:
1720                                 case ContentAlignment.MiddleCenter:
1721                                 case ContentAlignment.TopCenter:
1722                                         return HorizontalAlignment.Center;
1723                                 case ContentAlignment.BottomRight:
1724                                 case ContentAlignment.MiddleRight:
1725                                 case ContentAlignment.TopRight:
1726                                         return HorizontalAlignment.Right;
1727                         }
1728
1729                         return HorizontalAlignment.Left;
1730                 }
1731
1732                 internal Size GetImageSize ()
1733                 {
1734                         // Get the actual size of our internal image -or-
1735                         // Get the ImageList.ImageSize if we are using ImageLists
1736                         if (this.image_scaling == ToolStripItemImageScaling.None) {
1737                                 if (this.image != null)
1738                                         return image.Size;
1739
1740                                 if (this.image_index >= 0 || !string.IsNullOrEmpty (this.image_key))
1741                                         if (this.owner != null && this.owner.ImageList != null)
1742                                                 return this.owner.ImageList.ImageSize;
1743                         } else {
1744                                 // If we have an image and a parent, return ImageScalingSize
1745                                 if (this.Parent == null)
1746                                         return Size.Empty;
1747
1748                                 if (this.image != null)
1749                                         return this.Parent.ImageScalingSize;
1750
1751                                 if (this.image_index >= 0 || !string.IsNullOrEmpty (this.image_key))
1752                                         if (this.owner != null && this.owner.ImageList != null)
1753                                                 return this.Parent.ImageScalingSize;
1754                         }
1755
1756                         return Size.Empty;
1757                 }
1758
1759                 internal string GetToolTip ()
1760                 {
1761                         if (this.auto_tool_tip && string.IsNullOrEmpty (this.tool_tip_text))
1762                                 return this.Text;
1763
1764                         return this.tool_tip_text;
1765                 }
1766
1767                 internal void FireEvent (EventArgs e, ToolStripItemEventType met)
1768                 {
1769                         // If we're disabled, don't fire any of these events, except Paint
1770                         if (!this.Enabled && met != ToolStripItemEventType.Paint)
1771                                 return;
1772
1773                         switch (met) {
1774                                 case ToolStripItemEventType.MouseUp:
1775                                         this.HandleClick (e);
1776                                         this.OnMouseUp ((MouseEventArgs)e);
1777                                         break;
1778                                 case ToolStripItemEventType.MouseDown:
1779                                         this.OnMouseDown ((MouseEventArgs)e);
1780                                         break;
1781                                 case ToolStripItemEventType.MouseEnter:
1782                                         this.OnMouseEnter (e);
1783                                         break;
1784                                 case ToolStripItemEventType.MouseHover:
1785                                         this.OnMouseHover (e);
1786                                         break;
1787                                 case ToolStripItemEventType.MouseLeave:
1788                                         this.OnMouseLeave (e);
1789                                         break;
1790                                 case ToolStripItemEventType.MouseMove:
1791                                         this.OnMouseMove ((MouseEventArgs)e);
1792                                         break;
1793                                 case ToolStripItemEventType.Paint:
1794                                         this.OnPaint ((PaintEventArgs)e);
1795                                         break;
1796                                 case ToolStripItemEventType.Click:
1797                                         this.HandleClick (e);
1798                                         break;
1799                         }
1800                 }
1801
1802                 internal virtual void HandleClick (EventArgs e)
1803                 {
1804                         this.Parent.HandleItemClick (this);
1805                         this.OnClick (e);
1806                 }
1807
1808                 internal virtual void SetPlacement (ToolStripItemPlacement placement)
1809                 {
1810                         this.placement = placement;
1811                 }
1812
1813                 private void BeginAnimation ()
1814                 {
1815                         if (image != null && ImageAnimator.CanAnimate (image)) {
1816                                 frame_handler = new EventHandler (OnAnimateImage);
1817                                 ImageAnimator.Animate (image, frame_handler);
1818                         }
1819                 }
1820
1821                 private void OnAnimateImage (object sender, EventArgs e)
1822                 {
1823                         // This is called from a worker thread,BeginInvoke is used
1824                         // so the control is updated from the correct thread
1825
1826                         // Check if we have a handle again, since it may have gotten
1827                         // destroyed since the last time we checked.
1828                         if (Parent == null || !Parent.IsHandleCreated)
1829                                 return;
1830
1831                         Parent.BeginInvoke (new EventHandler (UpdateAnimatedImage), new object[] { this, e });
1832                 }
1833
1834                 private void StopAnimation ()
1835                 {
1836                         if (frame_handler == null)
1837                                 return;
1838
1839                         ImageAnimator.StopAnimate (image, frame_handler);
1840                         frame_handler = null;
1841                 }
1842
1843                 private void UpdateAnimatedImage (object sender, EventArgs e)
1844                 {
1845                         // Check if we have a handle again, since it may have gotten
1846                         // destroyed since the last time we checked.
1847                         if (Parent == null || !Parent.IsHandleCreated)
1848                                 return;
1849
1850                         ImageAnimator.UpdateFrames (image);
1851                         Invalidate ();
1852                 }
1853
1854                 internal bool ShowMargin {
1855                         get {
1856                                 if (!this.IsOnDropDown)
1857                                         return true;
1858
1859                                 if (!(this.Owner is ToolStripDropDownMenu))
1860                                         return false;
1861
1862                                 ToolStripDropDownMenu tsddm = (ToolStripDropDownMenu)this.Owner;
1863
1864                                 return tsddm.ShowCheckMargin || tsddm.ShowImageMargin;
1865                         }
1866                 }
1867
1868                 internal bool UseImageMargin {
1869                         get {
1870                                 if (!this.IsOnDropDown)
1871                                         return true;
1872
1873                                 if (!(this.Owner is ToolStripDropDownMenu))
1874                                         return false;
1875
1876                                 ToolStripDropDownMenu tsddm = (ToolStripDropDownMenu)this.Owner;
1877
1878                                 return tsddm.ShowImageMargin || tsddm.ShowCheckMargin;
1879                         }
1880                 }
1881
1882                 internal virtual bool InternalVisible {
1883                         get { return this.visible; }
1884                         set { this.visible = value; Invalidate (); }
1885                 }
1886
1887                 internal ToolStrip InternalOwner {
1888                         set {
1889                                 if (this.owner != value) {
1890                                         this.owner = value;
1891                                         this.CalculateAutoSize ();
1892                                         OnOwnerChanged (EventArgs.Empty);
1893                                 }
1894                         }
1895                 }
1896
1897                 internal Point Location {
1898                         get { return this.bounds.Location; }
1899                         set {
1900                                 if (this.bounds.Location != value) {
1901                                         this.bounds.Location = value;
1902                                         this.OnLocationChanged (EventArgs.Empty);
1903                                 }
1904                         }
1905                 }
1906
1907                 internal int Top {
1908                         get { return this.bounds.Y; }
1909                         set {
1910                                 if (this.bounds.Y != value) {
1911                                         this.bounds.Y = value;
1912                                         this.OnLocationChanged (EventArgs.Empty);
1913                                 }
1914                         }
1915                 }
1916
1917                 internal int Left {
1918                         get { return this.bounds.X; }
1919                         set {
1920                                 if (this.bounds.X != value) {
1921                                         this.bounds.X = value;
1922                                         this.OnLocationChanged (EventArgs.Empty);
1923                                 }
1924                         }
1925                 }
1926
1927                 internal int Right { get { return this.bounds.Right; } }
1928                 internal int Bottom { get { return this.bounds.Bottom; } }
1929                 #endregion
1930
1931                 #region IDropTarget Members
1932                 void IDropTarget.OnDragDrop (DragEventArgs dragEvent)
1933                 {
1934                         OnDragDrop (dragEvent);
1935                 }
1936
1937                 void IDropTarget.OnDragEnter (DragEventArgs dragEvent)
1938                 {
1939                         OnDragEnter (dragEvent);
1940                 }
1941
1942                 void IDropTarget.OnDragLeave (EventArgs e)
1943                 {
1944                         OnDragLeave (e);
1945                 }
1946
1947                 void IDropTarget.OnDragOver (DragEventArgs dragEvent)
1948                 {
1949                         OnDragOver (dragEvent);
1950                 }
1951                 #endregion
1952
1953                 #region UIA Framework: Methods, Properties and Events
1954
1955                 static object UIASelectionChangedEvent = new object ();
1956
1957                 internal event EventHandler UIASelectionChanged {
1958                         add { Events.AddHandler (UIASelectionChangedEvent, value); }
1959                         remove { Events.RemoveHandler (UIASelectionChangedEvent, value); }
1960                 }
1961
1962                 internal void OnUIASelectionChanged ()
1963                 {
1964                         EventHandler eh = (EventHandler)(Events [UIASelectionChangedEvent]);
1965                         if (eh != null)
1966                                 eh (this, EventArgs.Empty);
1967                 }
1968
1969                 #endregion
1970
1971                 [ComVisible (true)]
1972                 public class ToolStripItemAccessibleObject : AccessibleObject
1973                 {
1974                         internal ToolStripItem owner_item;
1975
1976                         public ToolStripItemAccessibleObject (ToolStripItem ownerItem)
1977                         {
1978                                 if (ownerItem == null)
1979                                         throw new ArgumentNullException ("ownerItem");
1980
1981                                 this.owner_item = ownerItem;
1982                                 base.default_action = string.Empty;
1983                                 base.keyboard_shortcut = string.Empty;
1984                                 base.name = string.Empty;
1985                                 base.value = string.Empty;
1986                         }
1987
1988                         #region Public Properties
1989                         public override Rectangle Bounds {
1990                                 get {
1991                                         return owner_item.Visible ? owner_item.Bounds : Rectangle.Empty;
1992                                 }
1993                         }
1994
1995                         public override string DefaultAction {
1996                                 get { return base.DefaultAction; }
1997                         }
1998
1999                         public override string Description {
2000                                 get { return base.Description; }
2001                         }
2002
2003                         public override string Help {
2004                                 get { return base.Help; }
2005                         }
2006
2007                         public override string KeyboardShortcut {
2008                                 get { return base.KeyboardShortcut; }
2009                         }
2010
2011                         public override string Name {
2012                                 get {
2013                                         if (base.name == string.Empty)
2014                                                 return owner_item.Text;
2015
2016                                         return base.Name;
2017                                 }
2018                                 set { base.Name = value; }
2019                         }
2020
2021                         public override AccessibleObject Parent {
2022                                 get { return base.Parent; }
2023                         }
2024
2025                         public override AccessibleRole Role {
2026                                 get { return base.Role; }
2027                         }
2028
2029                         public override AccessibleStates State {
2030                                 get { return base.State; }
2031                         }
2032                         #endregion
2033
2034                         #region Public Methods
2035                         public void AddState (AccessibleStates state)
2036                         {
2037                                 base.state = state;
2038                         }
2039
2040                         public override void DoDefaultAction ()
2041                         {
2042                                 base.DoDefaultAction ();
2043                         }
2044
2045                         public override int GetHelpTopic (out string fileName)
2046                         {
2047                                 return base.GetHelpTopic (out fileName);
2048                         }
2049
2050                         public override AccessibleObject Navigate (AccessibleNavigation navigationDirection)
2051                         {
2052                                 return base.Navigate (navigationDirection);
2053                         }
2054
2055                         public override string ToString ()
2056                         {
2057                                 return string.Format ("ToolStripItemAccessibleObject: Owner = {0}", owner_item.ToString());
2058                         }
2059                         #endregion
2060                 }
2061         }
2062
2063         internal class NoneExcludedImageIndexConverter : ImageIndexConverter
2064         {
2065         }
2066 }
2067
2068 #endif