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]
 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 ("Stub, 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")]
 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.Visible && this.Parent.Focused && this is ToolStripControlHost)
 929                                         (this as ToolStripControlHost).Focus ();
 930
 931                                 this.Invalidate ();
 932                                 this.Parent.NotifySelectedChanged (this);
 933                                 OnUIASelectionChanged ();
 934                         }
 935                 }
 936
 937                 public override string ToString ()
 938                 {
 939                         return this.text;
 940                 }
 941                 #endregion
 942
 943                 #region Protected Methods
 944                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 945                 protected virtual AccessibleObject CreateAccessibilityInstance ()
 946                 {
 947                         return new ToolStripItemAccessibleObject (this);
 948                 }
 949
 950                 protected override void Dispose (bool disposing)
 951                 {
 952                         if (!is_disposed && disposing)
 953                                 is_disposed = true;
 954
 955                         if (image != null) {
 956                                 StopAnimation ();
 957                                 image = null;
 958                         }
 959
 960                         base.Dispose (disposing);
 961                 }
 962
 963                 protected internal virtual bool IsInputChar (char charCode)
 964                 {
 965                         return false;
 966                 }
 967
 968                 protected internal virtual bool IsInputKey (Keys keyData)
 969                 {
 970                         return false;
 971                 }
 972
 973                 protected virtual void OnAvailableChanged (EventArgs e)
 974                 {
 975                         EventHandler eh = (EventHandler)(Events [AvailableChangedEvent]);
 976                         if (eh != null)
 977                                 eh (this, e);
 978                 }
 979
 980                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 981                 protected virtual void OnBackColorChanged (EventArgs e)
 982                 {
 983                         EventHandler eh = (EventHandler)(Events [BackColorChangedEvent]);
 984                         if (eh != null)
 985                                 eh (this, e);
 986                 }
 987
 988                 protected virtual void OnBoundsChanged ()
 989                 {
 990                         OnLayout (new LayoutEventArgs(null, string.Empty));
 991                 }
 992
 993                 protected virtual void OnClick (EventArgs e)
 994                 {
 995                         EventHandler eh = (EventHandler)(Events [ClickEvent]);
 996                         if (eh != null)
 997                                 eh (this, e);
 998                 }
 999
1000                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1001                 protected virtual void OnDisplayStyleChanged (EventArgs e)
1002                 {
1003                         EventHandler eh = (EventHandler)(Events [DisplayStyleChangedEvent]);
1004                         if (eh != null)
1005                                 eh (this, e);
1006                 }
1007
1008                 protected virtual void OnDoubleClick (EventArgs e)
1009                 {
1010                         EventHandler eh = (EventHandler)(Events [DoubleClickEvent]);
1011                         if (eh != null)
1012                                 eh (this, e);
1013
1014                         if (!double_click_enabled)
1015                                 OnClick (e);
1016                 }
1017
1018                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1019                 protected virtual void OnDragDrop (DragEventArgs dragEvent)
1020                 {
1021                         DragEventHandler eh = (DragEventHandler)(Events[DragDropEvent]);
1022                         if (eh != null)
1023                                 eh (this, dragEvent);
1024                 }
1025
1026                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1027                 protected virtual void OnDragEnter (DragEventArgs dragEvent)
1028                 {
1029                         DragEventHandler eh = (DragEventHandler)(Events[DragEnterEvent]);
1030                         if (eh != null)
1031                                 eh (this, dragEvent);
1032                 }
1033
1034                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1035                 protected virtual void OnDragLeave (EventArgs e)
1036                 {
1037                         EventHandler eh = (EventHandler)(Events[DragLeaveEvent]);
1038                         if (eh != null)
1039                                 eh (this, e);
1040                 }
1041
1042                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1043                 protected virtual void OnDragOver (DragEventArgs dragEvent)
1044                 {
1045                         DragEventHandler eh = (DragEventHandler)(Events[DragOverEvent]);
1046                         if (eh != null)
1047                                 eh (this, dragEvent);
1048                 }
1049
1050                 protected virtual void OnEnabledChanged (EventArgs e)
1051                 {
1052                         EventHandler eh = (EventHandler)(Events [EnabledChangedEvent]);
1053                         if (eh != null)
1054                                 eh (this, e);
1055                 }
1056
1057                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1058                 protected virtual void OnFontChanged (EventArgs e)
1059                 {
1060                 }
1061
1062                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1063                 protected virtual void OnForeColorChanged (EventArgs e)
1064                 {
1065                         EventHandler eh = (EventHandler)(Events [ForeColorChangedEvent]);
1066                         if (eh != null)
1067                                 eh (this, e);
1068                 }
1069
1070                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1071                 protected virtual void OnGiveFeedback (GiveFeedbackEventArgs giveFeedbackEvent)
1072                 {
1073                         GiveFeedbackEventHandler eh = (GiveFeedbackEventHandler)(Events[GiveFeedbackEvent]);
1074                         if (eh != null)
1075                                 eh (this, giveFeedbackEvent);
1076                 }
1077
1078                 protected virtual void OnLayout (LayoutEventArgs e)
1079                 {
1080                 }
1081
1082                 protected virtual void OnLocationChanged (EventArgs e)
1083                 {
1084                         EventHandler eh = (EventHandler)(Events [LocationChangedEvent]);
1085                         if (eh != null)
1086                                 eh (this, e);
1087                 }
1088
1089                 protected virtual void OnMouseDown (MouseEventArgs e)
1090                 {
1091                         if (this.Enabled) {
1092                                 this.is_pressed = true;
1093                                 this.Invalidate ();
1094
1095                                 MouseEventHandler eh = (MouseEventHandler)(Events [MouseDownEvent]);
1096                                 if (eh != null)
1097                                         eh (this, e);
1098                         }
1099                 }
1100
1101                 protected virtual void OnMouseEnter (EventArgs e)
1102                 {
1103                         this.Select ();
1104
1105                         EventHandler eh = (EventHandler)(Events [MouseEnterEvent]);
1106                         if (eh != null)
1107                                 eh (this, e);
1108                 }
1109
1110                 protected virtual void OnMouseHover (EventArgs e)
1111                 {
1112                         if (this.Enabled) {
1113                                 EventHandler eh = (EventHandler)(Events [MouseHoverEvent]);
1114                                 if (eh != null)
1115                                         eh (this, e);
1116                         }
1117                 }
1118
1119                 protected virtual void OnMouseLeave (EventArgs e)
1120                 {
1121                         if (this.CanSelect) {
1122                                 this.is_selected = false;
1123                                 this.is_pressed = false;
1124                                 this.Invalidate ();
1125                                 OnUIASelectionChanged ();
1126                         }
1127
1128                         EventHandler eh = (EventHandler)(Events [MouseLeaveEvent]);
1129                         if (eh != null)
1130                                 eh (this, e);
1131                 }
1132
1133                 protected virtual void OnMouseMove (MouseEventArgs mea)
1134                 {
1135                         if (this.Enabled) {
1136                                 MouseEventHandler eh = (MouseEventHandler)(Events [MouseMoveEvent]);
1137                                 if (eh != null)
1138                                         eh (this, mea);
1139                         }
1140                 }
1141
1142                 protected virtual void OnMouseUp (MouseEventArgs e)
1143                 {
1144                         if (this.Enabled) {
1145                                 this.is_pressed = false;
1146                                 this.Invalidate ();
1147
1148                                 if (this.IsOnDropDown)
1149                                         if (!(this is ToolStripDropDownItem) || !(this as ToolStripDropDownItem).HasDropDownItems || (this as ToolStripDropDownItem).DropDown.Visible == false) {
1150                                                 if ((this.Parent as ToolStripDropDown).OwnerItem != null)
1151                                                         ((this.Parent as ToolStripDropDown).OwnerItem as ToolStripDropDownItem).HideDropDown ();
1152                                                 else
1153                                                         (this.Parent as ToolStripDropDown).Hide ();
1154                                         }
1155
1156
1157                                 MouseEventHandler eh = (MouseEventHandler)(Events [MouseUpEvent]);
1158                                 if (eh != null)
1159                                         eh (this, e);
1160                         }
1161                 }
1162
1163                 protected virtual void OnOwnerChanged (EventArgs e)
1164                 {
1165                         EventHandler eh = (EventHandler)(Events [OwnerChangedEvent]);
1166                         if (eh != null)
1167                                 eh (this, e);
1168                 }
1169
1170                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1171                 protected internal virtual void OnOwnerFontChanged (EventArgs e)
1172                 {
1173                         this.CalculateAutoSize ();
1174                 }
1175
1176                 protected virtual void OnPaint (PaintEventArgs e)
1177                 {
1178                         if (this.parent != null)
1179                                 this.parent.Renderer.DrawItemBackground (new ToolStripItemRenderEventArgs (e.Graphics, this));
1180
1181                         PaintEventHandler eh = (PaintEventHandler)(Events [PaintEvent]);
1182                         if (eh != null)
1183                                 eh (this, e);
1184                 }
1185
1186                 // This is never called.
1187                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1188                 protected virtual void OnParentBackColorChanged (EventArgs e)
1189                 {
1190                 }
1191
1192                 protected virtual void OnParentChanged (ToolStrip oldParent, ToolStrip newParent)
1193                 {
1194                         this.text_size = TextRenderer.MeasureText (this.Text == null ? string.Empty : this.text, this.Font, Size.Empty, TextFormatFlags.HidePrefix);
1195
1196                         if (oldParent != null)
1197                                 oldParent.PerformLayout ();
1198
1199                         if (newParent != null)
1200                                 newParent.PerformLayout ();
1201                 }
1202
1203                 protected internal virtual void OnParentEnabledChanged (EventArgs e)
1204                 {
1205                         this.OnEnabledChanged (e);
1206                 }
1207
1208                 // This is never called.
1209                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1210                 protected virtual void OnParentForeColorChanged (EventArgs e)
1211                 {
1212                 }
1213
1214                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1215                 protected internal virtual void OnParentRightToLeftChanged (EventArgs e)
1216                 {
1217                         this.OnRightToLeftChanged (e);
1218                 }
1219
1220                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1221                 protected virtual void OnQueryContinueDrag (QueryContinueDragEventArgs queryContinueDragEvent)
1222                 {
1223                         QueryContinueDragEventHandler eh = (QueryContinueDragEventHandler)(Events[QueryContinueDragEvent]);
1224                         if (eh != null)
1225                                 eh (this, queryContinueDragEvent);
1226                 }
1227
1228                 protected virtual void OnRightToLeftChanged (EventArgs e)
1229                 {
1230                         EventHandler eh = (EventHandler)(Events[RightToLeftChangedEvent]);
1231                         if (eh != null)
1232                                 eh (this, e);
1233                 }
1234
1235                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1236                 protected virtual void OnTextChanged (EventArgs e)
1237                 {
1238                         EventHandler eh = (EventHandler)(Events [TextChangedEvent]);
1239                         if (eh != null)
1240                                 eh (this, e);
1241                 }
1242
1243                 protected virtual void OnVisibleChanged (EventArgs e)
1244                 {
1245                         EventHandler eh = (EventHandler)(Events [VisibleChangedEvent]);
1246                         if (eh != null)
1247                                 eh (this, e);
1248                 }
1249
1250                 protected internal virtual bool ProcessCmdKey (ref Message m, Keys keyData)
1251                 {
1252                         return false;
1253                 }
1254
1255                 protected internal virtual bool ProcessDialogKey (Keys keyData)
1256                 {
1257                         if (this.Selected && keyData == Keys.Enter) {
1258                                 this.FireEvent (EventArgs.Empty, ToolStripItemEventType.Click);
1259                                 return true;
1260                         }
1261
1262                         return false;
1263                 }
1264
1265                 // ProcessMnemonic will only be called if we are supposed to handle
1266                 // it.  None of that fancy "thinking" needed!
1267                 protected internal virtual bool ProcessMnemonic (char charCode)
1268                 {
1269                         ToolStripManager.SetActiveToolStrip (this.Parent, true);
1270                         this.PerformClick ();
1271                         return true;
1272                 }
1273
1274                 protected internal virtual void SetBounds (Rectangle bounds)
1275                 {
1276                         if (this.bounds != bounds) {
1277                                 this.bounds = bounds;
1278                                 OnBoundsChanged ();
1279                         }
1280                 }
1281
1282                 protected virtual void SetVisibleCore (bool visible)
1283                 {
1284                         this.visible = visible;
1285                         this.OnVisibleChanged (EventArgs.Empty);
1286
1287                         if (this.visible)
1288                                 BeginAnimation ();
1289                         else
1290                                 StopAnimation ();
1291                         this.Invalidate ();
1292                 }
1293                 #endregion
1294
1295                 #region Public Events
1296                 static object AvailableChangedEvent = new object ();
1297                 static object BackColorChangedEvent = new object ();
1298                 static object ClickEvent = new object ();
1299                 static object DisplayStyleChangedEvent = new object ();
1300                 static object DoubleClickEvent = new object ();
1301                 static object DragDropEvent = new object ();
1302                 static object DragEnterEvent = new object ();
1303                 static object DragLeaveEvent = new object ();
1304                 static object DragOverEvent = new object ();
1305                 static object EnabledChangedEvent = new object ();
1306                 static object ForeColorChangedEvent = new object ();
1307                 static object GiveFeedbackEvent = new object ();
1308                 static object LocationChangedEvent = new object ();
1309                 static object MouseDownEvent = new object ();
1310                 static object MouseEnterEvent = new object ();
1311                 static object MouseHoverEvent = new object ();
1312                 static object MouseLeaveEvent = new object ();
1313                 static object MouseMoveEvent = new object ();
1314                 static object MouseUpEvent = new object ();
1315                 static object OwnerChangedEvent = new object ();
1316                 static object PaintEvent = new object ();
1317                 static object QueryAccessibilityHelpEvent = new object ();
1318                 static object QueryContinueDragEvent = new object ();
1319                 static object RightToLeftChangedEvent = new object ();
1320                 static object TextChangedEvent = new object ();
1321                 static object VisibleChangedEvent = new object ();
1322
1323                 [Browsable (false)]
1324                 public event EventHandler AvailableChanged {
1325                         add { Events.AddHandler (AvailableChangedEvent, value); }
1326                         remove {Events.RemoveHandler (AvailableChangedEvent, value); }
1327                 }
1328
1329                 public event EventHandler BackColorChanged {
1330                         add { Events.AddHandler (BackColorChangedEvent, value); }
1331                         remove {Events.RemoveHandler (BackColorChangedEvent, value); }
1332                 }
1333
1334                 public event EventHandler Click {
1335                         add { Events.AddHandler (ClickEvent, value); }
1336                         remove {Events.RemoveHandler (ClickEvent, value); }
1337                 }
1338
1339                 public event EventHandler DisplayStyleChanged {
1340                         add { Events.AddHandler (DisplayStyleChangedEvent, value); }
1341                         remove {Events.RemoveHandler (DisplayStyleChangedEvent, value); }
1342                 }
1343
1344                 public event EventHandler DoubleClick {
1345                         add { Events.AddHandler (DoubleClickEvent, value); }
1346                         remove {Events.RemoveHandler (DoubleClickEvent, value); }
1347                 }
1348
1349                 [MonoTODO ("Not raised")]
1350                 [Browsable (false)]
1351                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1352                 public event DragEventHandler DragDrop {
1353                         add { Events.AddHandler (DragDropEvent, value); }
1354                         remove { Events.RemoveHandler (DragDropEvent, value); }
1355                 }
1356
1357                 [MonoTODO ("Not raised")]
1358                 [Browsable (false)]
1359                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1360                 public event DragEventHandler DragEnter {
1361                         add { Events.AddHandler (DragEnterEvent, value); }
1362                         remove { Events.RemoveHandler (DragEnterEvent, value); }
1363                 }
1364
1365                 [MonoTODO ("Not raised")]
1366                 [Browsable (false)]
1367                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1368                 public event EventHandler DragLeave {
1369                         add { Events.AddHandler (DragLeaveEvent, value); }
1370                         remove { Events.RemoveHandler (DragLeaveEvent, value); }
1371                 }
1372
1373                 [MonoTODO ("Not raised")]
1374                 [Browsable (false)]
1375                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1376                 public event DragEventHandler DragOver {
1377                         add { Events.AddHandler (DragOverEvent, value); }
1378                         remove { Events.RemoveHandler (DragOverEvent, value); }
1379                 }
1380
1381                 public event EventHandler EnabledChanged {
1382                         add { Events.AddHandler (EnabledChangedEvent, value); }
1383                         remove {Events.RemoveHandler (EnabledChangedEvent, value); }
1384                 }
1385
1386                 public event EventHandler ForeColorChanged {
1387                         add { Events.AddHandler (ForeColorChangedEvent, value); }
1388                         remove {Events.RemoveHandler (ForeColorChangedEvent, value); }
1389                 }
1390
1391                 [MonoTODO ("Not raised")]
1392                 [Browsable (false)]
1393                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1394                 public event GiveFeedbackEventHandler GiveFeedback {
1395                         add { Events.AddHandler (GiveFeedbackEvent, value); }
1396                         remove { Events.RemoveHandler (GiveFeedbackEvent, value); }
1397                 }
1398
1399                 public event EventHandler LocationChanged {
1400                         add { Events.AddHandler (LocationChangedEvent, value); }
1401                         remove {Events.RemoveHandler (LocationChangedEvent, value); }
1402                 }
1403
1404                 public event MouseEventHandler MouseDown {
1405                         add { Events.AddHandler (MouseDownEvent, value); }
1406                         remove {Events.RemoveHandler (MouseDownEvent, value); }
1407                 }
1408
1409                 public event EventHandler MouseEnter {
1410                         add { Events.AddHandler (MouseEnterEvent, value); }
1411                         remove {Events.RemoveHandler (MouseEnterEvent, value); }
1412                 }
1413
1414                 public event EventHandler MouseHover {
1415                         add { Events.AddHandler (MouseHoverEvent, value); }
1416                         remove {Events.RemoveHandler (MouseHoverEvent, value); }
1417                 }
1418
1419                 public event EventHandler MouseLeave {
1420                         add { Events.AddHandler (MouseLeaveEvent, value); }
1421                         remove {Events.RemoveHandler (MouseLeaveEvent, value); }
1422                 }
1423
1424                 public event MouseEventHandler MouseMove {
1425                         add { Events.AddHandler (MouseMoveEvent, value); }
1426                         remove {Events.RemoveHandler (MouseMoveEvent, value); }
1427                 }
1428
1429                 public event MouseEventHandler MouseUp {
1430                         add { Events.AddHandler (MouseUpEvent, value); }
1431                         remove {Events.RemoveHandler (MouseUpEvent, value); }
1432                 }
1433
1434                 public event EventHandler OwnerChanged {
1435                         add { Events.AddHandler (OwnerChangedEvent, value); }
1436                         remove {Events.RemoveHandler (OwnerChangedEvent, value); }
1437                 }
1438
1439                 public event PaintEventHandler Paint {
1440                         add { Events.AddHandler (PaintEvent, value); }
1441                         remove {Events.RemoveHandler (PaintEvent, value); }
1442                 }
1443
1444                 [MonoTODO ("Not raised")]
1445                 public event QueryAccessibilityHelpEventHandler QueryAccessibilityHelp {
1446                         add { Events.AddHandler (QueryAccessibilityHelpEvent, value); }
1447                         remove { Events.RemoveHandler (QueryAccessibilityHelpEvent, value); }
1448                 }
1449
1450                 [MonoTODO ("Not raised")]
1451                 [Browsable (false)]
1452                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1453                 public event QueryContinueDragEventHandler QueryContinueDrag {
1454                         add { Events.AddHandler (QueryContinueDragEvent, value); }
1455                         remove { Events.RemoveHandler (QueryContinueDragEvent, value); }
1456                 }
1457
1458                 public event EventHandler RightToLeftChanged {
1459                         add { Events.AddHandler (RightToLeftChangedEvent, value); }
1460                         remove { Events.RemoveHandler (RightToLeftChangedEvent, value); }
1461                 }
1462
1463                 public event EventHandler TextChanged {
1464                         add { Events.AddHandler (TextChangedEvent, value); }
1465                         remove {Events.RemoveHandler (TextChangedEvent, value); }
1466                 }
1467
1468                 public event EventHandler VisibleChanged {
1469                         add { Events.AddHandler (VisibleChangedEvent, value); }
1470                         remove {Events.RemoveHandler (VisibleChangedEvent, value); }
1471                 }
1472                 #endregion
1473
1474                 #region Internal Methods
1475                 internal Rectangle AlignInRectangle (Rectangle outer, Size inner, ContentAlignment align)
1476                 {
1477                         int x = 0;
1478                         int y = 0;
1479
1480                         if (align == ContentAlignment.BottomLeft || align == ContentAlignment.MiddleLeft || align == ContentAlignment.TopLeft)
1481                                 x = outer.X;
1482                         else if (align == ContentAlignment.BottomCenter || align == ContentAlignment.MiddleCenter || align == ContentAlignment.TopCenter)
1483                                 x = Math.Max (outer.X + ((outer.Width - inner.Width) / 2), outer.Left);
1484                         else if (align == ContentAlignment.BottomRight || align == ContentAlignment.MiddleRight || align == ContentAlignment.TopRight)
1485                                 x = outer.Right - inner.Width;
1486                         if (align == ContentAlignment.TopCenter || align == ContentAlignment.TopLeft || align == ContentAlignment.TopRight)
1487                                 y = outer.Y;
1488                         else if (align == ContentAlignment.MiddleCenter || align == ContentAlignment.MiddleLeft || align == ContentAlignment.MiddleRight)
1489                                 y = outer.Y + (outer.Height - inner.Height) / 2;
1490                         else if (align == ContentAlignment.BottomCenter || align == ContentAlignment.BottomRight || align == ContentAlignment.BottomLeft)
1491                                 y = outer.Bottom - inner.Height;
1492
1493                         return new Rectangle (x, y, Math.Min (inner.Width, outer.Width), Math.Min (inner.Height, outer.Height));
1494                 }
1495
1496                 internal void CalculateAutoSize ()
1497                 {
1498                         this.text_size = TextRenderer.MeasureText (this.Text == null ? string.Empty: this.text, this.Font, Size.Empty, TextFormatFlags.HidePrefix);
1499
1500                         // If our text is rotated, flip the width and height
1501                         ToolStripTextDirection direction = this.TextDirection;
1502
1503                         if (direction == ToolStripTextDirection.Vertical270 || direction == ToolStripTextDirection.Vertical90)
1504                                 this.text_size = new Size (this.text_size.Height, this.text_size.Width);
1505
1506                         if (!this.auto_size || this is ToolStripControlHost)
1507                                 return;
1508                         //this.text_size.Width += 6;
1509
1510                         Size final_size = this.CalculatePreferredSize (Size.Empty);
1511
1512                         if (final_size != this.Size) {
1513                                 this.bounds.Width = final_size.Width;
1514                                 if (this.parent != null)
1515                                         this.parent.PerformLayout ();
1516                         }
1517                 }
1518
1519                 internal virtual Size CalculatePreferredSize (Size constrainingSize)
1520                 {
1521                         if (!this.auto_size)
1522                                 return this.explicit_size;
1523
1524                         Size preferred_size = this.DefaultSize;
1525
1526                         switch (this.display_style) {
1527                                 case ToolStripItemDisplayStyle.Text:
1528                                         int width = text_size.Width + this.padding.Horizontal;
1529                                         int height = text_size.Height + this.padding.Vertical;
1530                                         preferred_size = new Size (width, height);
1531                                         break;
1532                                 case ToolStripItemDisplayStyle.Image:
1533                                         if (this.GetImageSize () == Size.Empty)
1534                                                 preferred_size = this.DefaultSize;
1535                                         else {
1536                                                 switch (this.image_scaling) {
1537                                                         case ToolStripItemImageScaling.None:
1538                                                                 preferred_size = this.GetImageSize ();
1539                                                                 break;
1540                                                         case ToolStripItemImageScaling.SizeToFit:
1541                                                                 if (this.parent == null)
1542                                                                         preferred_size = this.GetImageSize ();
1543                                                                 else
1544                                                                         preferred_size = this.parent.ImageScalingSize;
1545                                                                 break;
1546                                                 }
1547                                         }
1548                                         break;
1549                                 case ToolStripItemDisplayStyle.ImageAndText:
1550                                         int width2 = text_size.Width + this.padding.Horizontal;
1551                                         int height2 = text_size.Height + this.padding.Vertical;
1552
1553                                         if (this.GetImageSize () != Size.Empty) {
1554                                                 Size image_size = this.GetImageSize ();
1555
1556                                                 if (this.image_scaling == ToolStripItemImageScaling.SizeToFit && this.parent != null)
1557                                                         image_size = this.parent.ImageScalingSize;
1558
1559                                                 switch (this.text_image_relation) {
1560                                                         case TextImageRelation.Overlay:
1561                                                                 width2 = Math.Max (width2, image_size.Width);
1562                                                                 height2 = Math.Max (height2, image_size.Height);
1563                                                                 break;
1564                                                         case TextImageRelation.ImageAboveText:
1565                                                         case TextImageRelation.TextAboveImage:
1566                                                                 width2 = Math.Max (width2, image_size.Width);
1567                                                                 height2 += image_size.Height;
1568                                                                 break;
1569                                                         case TextImageRelation.ImageBeforeText:
1570                                                         case TextImageRelation.TextBeforeImage:
1571                                                                 height2 = Math.Max (height2, image_size.Height);
1572                                                                 width2 += image_size.Width;
1573                                                                 break;
1574                                                 }
1575                                         }
1576
1577                                         preferred_size = new Size (width2, height2);
1578                                         break;
1579                         }
1580
1581                         if (!(this is ToolStripLabel)) {                // Everything but labels have a border
1582                                 preferred_size.Height += 4;
1583                                 preferred_size.Width += 4;
1584                         }
1585
1586                         // Account for ToolStripDropDownButton's drop down arrow
1587                         if (this is ToolStripDropDownButton && (this as ToolStripDropDownButton).ShowDropDownArrow)
1588                                 preferred_size.Width += 9;
1589
1590                         return preferred_size;
1591                 }
1592
1593                 internal void CalculateTextAndImageRectangles (out Rectangle text_rect, out Rectangle image_rect)
1594                 {
1595                         this.CalculateTextAndImageRectangles (this.ContentRectangle, out text_rect, out image_rect);
1596                 }
1597
1598                 internal void CalculateTextAndImageRectangles (Rectangle contentRectangle, out Rectangle text_rect, out Rectangle image_rect)
1599                 {
1600                         text_rect = Rectangle.Empty;
1601                         image_rect = Rectangle.Empty;
1602
1603                         switch (this.display_style) {
1604                                 case ToolStripItemDisplayStyle.None:
1605                                         break;
1606                                 case ToolStripItemDisplayStyle.Text:
1607                                         if (this.text != string.Empty)
1608                                                 text_rect = AlignInRectangle (contentRectangle, this.text_size, this.text_align);
1609                                         break;
1610                                 case ToolStripItemDisplayStyle.Image:
1611                                         if (this.Image != null && this.UseImageMargin)
1612                                                 image_rect = AlignInRectangle (contentRectangle, GetImageSize (), this.image_align);
1613                                         break;
1614                                 case ToolStripItemDisplayStyle.ImageAndText:
1615                                         if (this.text != string.Empty && (this.Image == null || !this.UseImageMargin))
1616                                                 text_rect = AlignInRectangle (contentRectangle, this.text_size, this.text_align);
1617                                         else if (this.text == string.Empty && (this.Image == null || !this.UseImageMargin))
1618                                                 break;
1619                                         else if (this.text == string.Empty && this.Image != null)
1620                                                 image_rect = AlignInRectangle (contentRectangle, GetImageSize (), this.image_align);
1621                                         else {
1622                                                 Rectangle text_area;
1623                                                 Rectangle image_area;
1624
1625                                                 switch (this.text_image_relation) {
1626                                                         case TextImageRelation.Overlay:
1627                                                                 text_rect = AlignInRectangle (contentRectangle, this.text_size, this.text_align);
1628                                                                 image_rect = AlignInRectangle (contentRectangle, GetImageSize (), this.image_align);
1629                                                                 break;
1630                                                         case TextImageRelation.ImageAboveText:
1631                                                                 text_area = new Rectangle (contentRectangle.Left, contentRectangle.Bottom - (text_size.Height - 4), contentRectangle.Width, text_size.Height - 4);
1632                                                                 image_area = new Rectangle (contentRectangle.Left, contentRectangle.Top, contentRectangle.Width, contentRectangle.Height - text_area.Height);
1633
1634                                                                 text_rect = AlignInRectangle (text_area, this.text_size, this.text_align);
1635                                                                 image_rect = AlignInRectangle (image_area, GetImageSize (), this.image_align);
1636                                                                 break;
1637                                                         case TextImageRelation.TextAboveImage:
1638                                                                 text_area = new Rectangle (contentRectangle.Left, contentRectangle.Top, contentRectangle.Width, text_size.Height - 4);
1639                                                                 image_area = new Rectangle (contentRectangle.Left, text_area.Bottom, contentRectangle.Width, contentRectangle.Height - text_area.Height);
1640
1641                                                                 text_rect = AlignInRectangle (text_area, this.text_size, this.text_align);
1642                                                                 image_rect = AlignInRectangle (image_area, GetImageSize (), this.image_align);
1643                                                                 break;
1644                                                         case TextImageRelation.ImageBeforeText:
1645                                                                 LayoutTextBeforeOrAfterImage (contentRectangle, false, text_size, GetImageSize (), text_align, image_align, out text_rect, out image_rect);
1646                                                                 break;
1647                                                         case TextImageRelation.TextBeforeImage:
1648                                                                 LayoutTextBeforeOrAfterImage (contentRectangle, true, text_size, GetImageSize (), text_align, image_align, out text_rect, out image_rect);
1649                                                                 break;
1650                                                 }
1651                                         }
1652                                         break;
1653                         }
1654                 }
1655
1656                 private static Font DefaultFont { get { return new Font ("Tahoma", 8.25f); } }
1657
1658                 internal virtual ToolStripTextDirection DefaultTextDirection { get { return ToolStripTextDirection.Inherit; } }
1659
1660                 internal virtual void Dismiss (ToolStripDropDownCloseReason reason)
1661                 {
1662                         if (is_selected) {
1663                                 this.is_selected = false;
1664                                 this.Invalidate ();
1665                                 OnUIASelectionChanged ();
1666                         }
1667                 }
1668
1669                 internal virtual ToolStrip GetTopLevelToolStrip ()
1670                 {
1671                         if (this.Parent != null)
1672                                 return this.Parent.GetTopLevelToolStrip ();
1673
1674                         return null;
1675                 }
1676
1677                 private void LayoutTextBeforeOrAfterImage (Rectangle totalArea, bool textFirst, Size textSize, Size imageSize, ContentAlignment textAlign, ContentAlignment imageAlign, out Rectangle textRect, out Rectangle imageRect)
1678                 {
1679                         int element_spacing = 0;        // Spacing between the Text and the Image
1680                         int total_width = textSize.Width + element_spacing + imageSize.Width;
1681                         int excess_width = totalArea.Width - total_width;
1682                         int offset = 0;
1683
1684                         Rectangle final_text_rect;
1685                         Rectangle final_image_rect;
1686
1687                         HorizontalAlignment h_text = GetHorizontalAlignment (textAlign);
1688                         HorizontalAlignment h_image = GetHorizontalAlignment (imageAlign);
1689
1690                         if (h_image == HorizontalAlignment.Left)
1691                                 offset = 0;
1692                         else if (h_image == HorizontalAlignment.Right && h_text == HorizontalAlignment.Right)
1693                                 offset = excess_width;
1694                         else if (h_image == HorizontalAlignment.Center && (h_text == HorizontalAlignment.Left || h_text == HorizontalAlignment.Center))
1695                                 offset += (int)(excess_width / 3);
1696                         else
1697                                 offset += (int)(2 * (excess_width / 3));
1698
1699                         if (textFirst) {
1700                                 final_text_rect = new Rectangle (totalArea.Left + offset, AlignInRectangle (totalArea, textSize, textAlign).Top, textSize.Width, textSize.Height);
1701                                 final_image_rect = new Rectangle (final_text_rect.Right + element_spacing, AlignInRectangle (totalArea, imageSize, imageAlign).Top, imageSize.Width, imageSize.Height);
1702                         } else {
1703                                 final_image_rect = new Rectangle (totalArea.Left + offset, AlignInRectangle (totalArea, imageSize, imageAlign).Top, imageSize.Width, imageSize.Height);
1704                                 final_text_rect = new Rectangle (final_image_rect.Right + element_spacing, AlignInRectangle (totalArea, textSize, textAlign).Top, textSize.Width, textSize.Height);
1705                         }
1706
1707                         textRect = final_text_rect;
1708                         imageRect = final_image_rect;
1709                 }
1710
1711                 private HorizontalAlignment GetHorizontalAlignment (ContentAlignment align)
1712                 {
1713                         switch (align) {
1714                                 case ContentAlignment.BottomLeft:
1715                                 case ContentAlignment.MiddleLeft:
1716                                 case ContentAlignment.TopLeft:
1717                                         return HorizontalAlignment.Left;
1718                                 case ContentAlignment.BottomCenter:
1719                                 case ContentAlignment.MiddleCenter:
1720                                 case ContentAlignment.TopCenter:
1721                                         return HorizontalAlignment.Center;
1722                                 case ContentAlignment.BottomRight:
1723                                 case ContentAlignment.MiddleRight:
1724                                 case ContentAlignment.TopRight:
1725                                         return HorizontalAlignment.Right;
1726                         }
1727
1728                         return HorizontalAlignment.Left;
1729                 }
1730
1731                 internal Size GetImageSize ()
1732                 {
1733                         // Get the actual size of our internal image -or-
1734                         // Get the ImageList.ImageSize if we are using ImageLists
1735                         if (this.image_scaling == ToolStripItemImageScaling.None) {
1736                                 if (this.image != null)
1737                                         return image.Size;
1738
1739                                 if (this.image_index >= 0 || !string.IsNullOrEmpty (this.image_key))
1740                                         if (this.owner != null && this.owner.ImageList != null)
1741                                                 return this.owner.ImageList.ImageSize;
1742                         } else {
1743                                 // If we have an image and a parent, return ImageScalingSize
1744                                 if (this.Parent == null)
1745                                         return Size.Empty;
1746
1747                                 if (this.image != null)
1748                                         return this.Parent.ImageScalingSize;
1749
1750                                 if (this.image_index >= 0 || !string.IsNullOrEmpty (this.image_key))
1751                                         if (this.owner != null && this.owner.ImageList != null)
1752                                                 return this.Parent.ImageScalingSize;
1753                         }
1754
1755                         return Size.Empty;
1756                 }
1757
1758                 internal string GetToolTip ()
1759                 {
1760                         if (this.auto_tool_tip && string.IsNullOrEmpty (this.tool_tip_text))
1761                                 return this.Text;
1762
1763                         return this.tool_tip_text;
1764                 }
1765
1766                 internal void FireEvent (EventArgs e, ToolStripItemEventType met)
1767                 {
1768                         // If we're disabled, don't fire any of these events, except Paint
1769                         if (!this.Enabled && met != ToolStripItemEventType.Paint)
1770                                 return;
1771
1772                         switch (met) {
1773                                 case ToolStripItemEventType.MouseUp:
1774                                         this.HandleClick (e);
1775                                         this.OnMouseUp ((MouseEventArgs)e);
1776                                         break;
1777                                 case ToolStripItemEventType.MouseDown:
1778                                         this.OnMouseDown ((MouseEventArgs)e);
1779                                         break;
1780                                 case ToolStripItemEventType.MouseEnter:
1781                                         this.OnMouseEnter (e);
1782                                         break;
1783                                 case ToolStripItemEventType.MouseHover:
1784                                         this.OnMouseHover (e);
1785                                         break;
1786                                 case ToolStripItemEventType.MouseLeave:
1787                                         this.OnMouseLeave (e);
1788                                         break;
1789                                 case ToolStripItemEventType.MouseMove:
1790                                         this.OnMouseMove ((MouseEventArgs)e);
1791                                         break;
1792                                 case ToolStripItemEventType.Paint:
1793                                         this.OnPaint ((PaintEventArgs)e);
1794                                         break;
1795                                 case ToolStripItemEventType.Click:
1796                                         this.HandleClick (e);
1797                                         break;
1798                         }
1799                 }
1800
1801                 internal virtual void HandleClick (EventArgs e)
1802                 {
1803                         this.Parent.HandleItemClick (this);
1804                         this.OnClick (e);
1805                 }
1806
1807                 internal virtual void SetPlacement (ToolStripItemPlacement placement)
1808                 {
1809                         this.placement = placement;
1810                 }
1811
1812                 private void BeginAnimation ()
1813                 {
1814                         if (image != null && ImageAnimator.CanAnimate (image)) {
1815                                 frame_handler = new EventHandler (OnAnimateImage);
1816                                 ImageAnimator.Animate (image, frame_handler);
1817                         }
1818                 }
1819
1820                 private void OnAnimateImage (object sender, EventArgs e)
1821                 {
1822                         // This is called from a worker thread,BeginInvoke is used
1823                         // so the control is updated from the correct thread
1824
1825                         // Check if we have a handle again, since it may have gotten
1826                         // destroyed since the last time we checked.
1827                         if (Parent == null || !Parent.IsHandleCreated)
1828                                 return;
1829
1830                         Parent.BeginInvoke (new EventHandler (UpdateAnimatedImage), new object[] { this, e });
1831                 }
1832
1833                 private void StopAnimation ()
1834                 {
1835                         if (frame_handler == null)
1836                                 return;
1837
1838                         ImageAnimator.StopAnimate (image, frame_handler);
1839                         frame_handler = null;
1840                 }
1841
1842                 private void UpdateAnimatedImage (object sender, EventArgs e)
1843                 {
1844                         // Check if we have a handle again, since it may have gotten
1845                         // destroyed since the last time we checked.
1846                         if (Parent == null || !Parent.IsHandleCreated)
1847                                 return;
1848
1849                         ImageAnimator.UpdateFrames (image);
1850                         Invalidate ();
1851                 }
1852
1853                 internal bool ShowMargin {
1854                         get {
1855                                 if (!this.IsOnDropDown)
1856                                         return true;
1857
1858                                 if (!(this.Owner is ToolStripDropDownMenu))
1859                                         return false;
1860
1861                                 ToolStripDropDownMenu tsddm = (ToolStripDropDownMenu)this.Owner;
1862
1863                                 return tsddm.ShowCheckMargin || tsddm.ShowImageMargin;
1864                         }
1865                 }
1866
1867                 internal bool UseImageMargin {
1868                         get {
1869                                 if (!this.IsOnDropDown)
1870                                         return true;
1871
1872                                 if (!(this.Owner is ToolStripDropDownMenu))
1873                                         return false;
1874
1875                                 ToolStripDropDownMenu tsddm = (ToolStripDropDownMenu)this.Owner;
1876
1877                                 return tsddm.ShowImageMargin || tsddm.ShowCheckMargin;
1878                         }
1879                 }
1880
1881                 internal virtual bool InternalVisible {
1882                         get { return this.visible; }
1883                         set { this.visible = value; Invalidate (); }
1884                 }
1885
1886                 internal ToolStrip InternalOwner {
1887                         set {
1888                                 if (this.owner != value) {
1889                                         this.owner = value;
1890                                         this.CalculateAutoSize ();
1891                                         OnOwnerChanged (EventArgs.Empty);
1892                                 }
1893                         }
1894                 }
1895
1896                 internal Point Location {
1897                         get { return this.bounds.Location; }
1898                         set {
1899                                 if (this.bounds.Location != value) {
1900                                         this.bounds.Location = value;
1901                                         this.OnLocationChanged (EventArgs.Empty);
1902                                 }
1903                         }
1904                 }
1905
1906                 internal int Top {
1907                         get { return this.bounds.Y; }
1908                         set {
1909                                 if (this.bounds.Y != value) {
1910                                         this.bounds.Y = value;
1911                                         this.OnLocationChanged (EventArgs.Empty);
1912                                 }
1913                         }
1914                 }
1915
1916                 internal int Left {
1917                         get { return this.bounds.X; }
1918                         set {
1919                                 if (this.bounds.X != value) {
1920                                         this.bounds.X = value;
1921                                         this.OnLocationChanged (EventArgs.Empty);
1922                                 }
1923                         }
1924                 }
1925
1926                 internal int Right { get { return this.bounds.Right; } }
1927                 internal int Bottom { get { return this.bounds.Bottom; } }
1928                 #endregion
1929
1930                 #region IDropTarget Members
1931                 void IDropTarget.OnDragDrop (DragEventArgs dragEvent)
1932                 {
1933                         OnDragDrop (dragEvent);
1934                 }
1935
1936                 void IDropTarget.OnDragEnter (DragEventArgs dragEvent)
1937                 {
1938                         OnDragEnter (dragEvent);
1939                 }
1940
1941                 void IDropTarget.OnDragLeave (EventArgs e)
1942                 {
1943                         OnDragLeave (e);
1944                 }
1945
1946                 void IDropTarget.OnDragOver (DragEventArgs dragEvent)
1947                 {
1948                         OnDragOver (dragEvent);
1949                 }
1950                 #endregion
1951
1952                 #region UIA Framework: Methods, Properties and Events
1953
1954                 static object UIASelectionChangedEvent = new object ();
1955
1956                 internal event EventHandler UIASelectionChanged {
1957                         add { Events.AddHandler (UIASelectionChangedEvent, value); }
1958                         remove { Events.RemoveHandler (UIASelectionChangedEvent, value); }
1959                 }
1960
1961                 internal void OnUIASelectionChanged ()
1962                 {
1963                         EventHandler eh = (EventHandler)(Events [UIASelectionChangedEvent]);
1964                         if (eh != null)
1965                                 eh (this, EventArgs.Empty);
1966                 }
1967
1968                 #endregion
1969
1970                 [ComVisible (true)]
1971                 public class ToolStripItemAccessibleObject : AccessibleObject
1972                 {
1973                         internal ToolStripItem owner_item;
1974
1975                         public ToolStripItemAccessibleObject (ToolStripItem ownerItem)
1976                         {
1977                                 if (ownerItem == null)
1978                                         throw new ArgumentNullException ("ownerItem");
1979
1980                                 this.owner_item = ownerItem;
1981                                 base.default_action = string.Empty;
1982                                 base.keyboard_shortcut = string.Empty;
1983                                 base.name = string.Empty;
1984                                 base.value = string.Empty;
1985                         }
1986
1987                         #region Public Properties
1988                         public override Rectangle Bounds {
1989                                 get {
1990                                         return owner_item.Visible ? owner_item.Bounds : Rectangle.Empty;
1991                                 }
1992                         }
1993
1994                         public override string DefaultAction {
1995                                 get { return base.DefaultAction; }
1996                         }
1997
1998                         public override string Description {
1999                                 get { return base.Description; }
2000                         }
2001
2002                         public override string Help {
2003                                 get { return base.Help; }
2004                         }
2005
2006                         public override string KeyboardShortcut {
2007                                 get { return base.KeyboardShortcut; }
2008                         }
2009
2010                         public override string Name {
2011                                 get {
2012                                         if (base.name == string.Empty)
2013                                                 return owner_item.Text;
2014
2015                                         return base.Name;
2016                                 }
2017                                 set { base.Name = value; }
2018                         }
2019
2020                         public override AccessibleObject Parent {
2021                                 get { return base.Parent; }
2022                         }
2023
2024                         public override AccessibleRole Role {
2025                                 get { return base.Role; }
2026                         }
2027
2028                         public override AccessibleStates State {
2029                                 get { return base.State; }
2030                         }
2031                         #endregion
2032
2033                         #region Public Methods
2034                         public void AddState (AccessibleStates state)
2035                         {
2036                                 base.state = state;
2037                         }
2038
2039                         public override void DoDefaultAction ()
2040                         {
2041                                 base.DoDefaultAction ();
2042                         }
2043
2044                         public override int GetHelpTopic (out string fileName)
2045                         {
2046                                 return base.GetHelpTopic (out fileName);
2047                         }
2048
2049                         public override AccessibleObject Navigate (AccessibleNavigation navigationDirection)
2050                         {
2051                                 return base.Navigate (navigationDirection);
2052                         }
2053
2054                         public override string ToString ()
2055                         {
2056                                 return string.Format ("ToolStripItemAccessibleObject: Owner = {0}", owner_item.ToString());
2057                         }
2058                         #endregion
2059                 }
2060         }
2061
2062         internal class NoneExcludedImageIndexConverter : ImageIndexConverter
2063         {
2064         }
2065 }
2066
2067 #endif