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

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