ToolStripItem Classe

Definição

Representa a classe base abstrata que gerencia eventos e o layout para todos os elementos que um ToolStrip ou ToolStripDropDown pode conter.

public ref class ToolStripItem abstract : System::ComponentModel::Component, IDisposable, System::Windows::Forms::IDropTarget
public ref class ToolStripItem abstract : System::Windows::Forms::BindableComponent, IDisposable, System::Windows::Forms::IDropTarget
public abstract class ToolStripItem : System.ComponentModel.Component, IDisposable, System.Windows.Forms.IDropTarget
public abstract class ToolStripItem : System.Windows.Forms.BindableComponent, IDisposable, System.Windows.Forms.IDropTarget
type ToolStripItem = class
    inherit Component
    interface IDropTarget
    interface IComponent
    interface IDisposable
type ToolStripItem = class
    inherit BindableComponent
    interface IDropTarget
    interface IComponent
    interface IDisposable
Public MustInherit Class ToolStripItem
Inherits Component
Implements IDisposable, IDropTarget
Public MustInherit Class ToolStripItem
Inherits BindableComponent
Implements IDisposable, IDropTarget
Herança
Herança
Derivado
Implementações

Exemplos

O exemplo de código a seguir demonstra como implementar um controle personalizado ToolStripItem .

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows.Forms;

namespace RolloverItemDemoLib
{
    // This class implements a ToolStripItem that highlights
    // its border and text when the mouse enters its
    // client rectangle. It has a clickable state which is
    // exposed through the Clicked property and displayed
    // by highlighting or graying out the item's image. 
    public class RolloverItem : ToolStripItem
    {
        private bool clickedValue = false;
        private bool rolloverValue = false;

        private Rectangle imageRect;
        private Rectangle textRect;

        // For brevity, this implementation limits the possible 
        // TextDirection values to ToolStripTextDirection.Horizontal. 
        public override ToolStripTextDirection TextDirection
        {
            get
            {
                return base.TextDirection;
            }
            set
            {
                if (value == ToolStripTextDirection.Horizontal)
                {
                    base.TextDirection = value;
                }
                else
                {
                    throw new ArgumentException(
                        "RolloverItem supports only horizontal text.");
                }
            }
        }

        // For brevity, this implementation limits the possible 
        // TextImageRelation values to ImageBeforeText and TextBeforeImage. 
        public new TextImageRelation TextImageRelation
        {
            get
            {
                return base.TextImageRelation;
            }

            set
            {
                if (value == TextImageRelation.ImageBeforeText || 
                    value == TextImageRelation.TextBeforeImage)
                {
                    base.TextImageRelation = value;
                }
                else
                {
                    throw new ArgumentException(
                        "Unsupported TextImageRelation value.");
                }
            }
        }
        
        // This property returns true if the mouse is 
        // inside the client rectangle.
        public bool Rollover
        {
            get
            {
                return this.rolloverValue;
            }   
        }

        // This property returns true if the item 
        // has been toggled into the clicked state.
        // Clicking again toggles it to the 
        // unclicked state.
        public bool Clicked
        {
            get
            {
                return this.clickedValue;
            }
        }

        // The method defines the behavior of the Click event.
        // It simply toggles the state of the clickedValue field.
        protected override void OnClick(EventArgs e)
        {
            base.OnClick(e);

            this.clickedValue ^= true;
        }

        // The method defines the behavior of the DoubleClick 
        // event. It shows a MessageBox with the item's text.
        protected override void OnDoubleClick(EventArgs e)
        {
            base.OnDoubleClick(e);

            string msg = String.Format("Item: {0}", this.Text);

            MessageBox.Show(msg);
        }

        // This method defines the behavior of the MouseEnter event.
        // It sets the state of the rolloverValue field to true and
        // tells the control to repaint.
        protected override void OnMouseEnter(EventArgs e)
        {
            base.OnMouseEnter(e);

            this.rolloverValue = true;

            this.Invalidate();
        }

        // This method defines the behavior of the MouseLeave event.
        // It sets the state of the rolloverValue field to false and
        // tells the control to repaint.
        protected override void OnMouseLeave(EventArgs e)
        {
            base.OnMouseLeave(e);

            this.rolloverValue = false;

            this.Invalidate();
        }

        // This method defines the painting behavior of the control.
        // It performs the following operations:
        //
        // Computes the layout of the item's image and text.
        // Draws the item's background image.
        // Draws the item's image.
        // Draws the item's text.
        //
        // Drawing operations are implemented in the 
        // RolloverItemRenderer class.
        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);

            if (this.Owner != null)
            {
                // Find the dimensions of the image and the text 
                // areas of the item. 
                this.ComputeImageAndTextLayout();

                // Draw the background. This includes drawing a highlighted 
                // border when the mouse is in the client area.
                ToolStripItemRenderEventArgs ea = new ToolStripItemRenderEventArgs(
                     e.Graphics,
                     this);
                this.Owner.Renderer.DrawItemBackground(ea);

                // Draw the item's image. 
                ToolStripItemImageRenderEventArgs irea =
                    new ToolStripItemImageRenderEventArgs(
                    e.Graphics,
                    this,
                    imageRect );
                this.Owner.Renderer.DrawItemImage(irea);

                // If the item is on a drop-down, give its
                // text a different highlighted color.
                Color highlightColor = 
                    this.IsOnDropDown ?
                    Color.Salmon : SystemColors.ControlLightLight;

                // Draw the text, and highlight it if the 
                // the rollover state is true.
                ToolStripItemTextRenderEventArgs rea =
                    new ToolStripItemTextRenderEventArgs(
                    e.Graphics,
                    this,
                    base.Text,
                    textRect,
                    this.rolloverValue ? highlightColor : base.ForeColor,
                    base.Font,
                    base.TextAlign);
                this.Owner.Renderer.DrawItemText(rea);
            }
        }

        // This utility method computes the layout of the 
        // RolloverItem control's image area and the text area.
        // For brevity, only the following settings are 
        // supported:
        //
        // ToolStripTextDirection.Horizontal
        // TextImageRelation.ImageBeforeText 
        // TextImageRelation.ImageBeforeText
        // 
        // It would not be difficult to support vertical text
        // directions and other image/text relationships.
        private void ComputeImageAndTextLayout()
        {
            Rectangle cr = base.ContentRectangle;
            Image img = base.Owner.ImageList.Images[base.ImageKey];

            // Compute the center of the item's ContentRectangle.
            int centerY = (cr.Height - img.Height) / 2;

            // Find the dimensions of the image and the text 
            // areas of the item. The text occupies the space 
            // not filled by the image. 
            if (base.TextImageRelation == TextImageRelation.ImageBeforeText &&
                base.TextDirection == ToolStripTextDirection.Horizontal)
            {
                imageRect = new Rectangle(
                    base.ContentRectangle.Left,
                    centerY,
                    base.Image.Width,
                    base.Image.Height);

                textRect = new Rectangle(
                    imageRect.Width,
                    base.ContentRectangle.Top,
                    base.ContentRectangle.Width - imageRect.Width,
                    base.ContentRectangle.Height);
            }
            else if (base.TextImageRelation == TextImageRelation.TextBeforeImage &&
                     base.TextDirection == ToolStripTextDirection.Horizontal)
            {
                imageRect = new Rectangle(
                    base.ContentRectangle.Right - base.Image.Width,
                    centerY,
                    base.Image.Width,
                    base.Image.Height);

                textRect = new Rectangle(
                    base.ContentRectangle.Left,
                    base.ContentRectangle.Top,
                    imageRect.X,
                    base.ContentRectangle.Bottom);
            }
        }
    }

    #region RolloverItemRenderer

    // This is the custom renderer for the RolloverItem control.
    // It draws a border around the item when the mouse is
    // in the item's client area. It also draws the item's image
    // in an inactive state (grayed out) until the user clicks
    // the item to toggle its "clicked" state.
    internal class RolloverItemRenderer : ToolStripSystemRenderer
    {
        protected override void OnRenderItemImage(
            ToolStripItemImageRenderEventArgs e)
        {
            base.OnRenderItemImage(e);

            RolloverItem item = e.Item as RolloverItem;

            // If the ToolSTripItem is of type RolloverItem, 
            // perform custom rendering for the image.
            if (item != null)
            {
                if (item.Clicked)
                {
                    // The item is in the clicked state, so 
                    // draw the image as usual.
                    e.Graphics.DrawImage(
                        e.Image,
                        e.ImageRectangle.X,
                        e.ImageRectangle.Y);
                }
                else
                {
                    // In the unclicked state, gray out the image.
                    ControlPaint.DrawImageDisabled(
                        e.Graphics,
                        e.Image,
                        e.ImageRectangle.X,
                        e.ImageRectangle.Y,
                        item.BackColor);
                }
            }
        }

        // This method defines the behavior for rendering the
        // background of a ToolStripItem. If the item is a
        // RolloverItem, it paints the item's BackgroundImage 
        // centered in the client area. If the mouse is in the 
        // item's client area, a border is drawn around it.
        // If the item is on a drop-down or if it is on the
        // overflow, a gradient is painted in the background.
        protected override void OnRenderItemBackground(
            ToolStripItemRenderEventArgs e)
        {
            base.OnRenderItemBackground(e);

            RolloverItem item = e.Item as RolloverItem;

            // If the ToolSTripItem is of type RolloverItem, 
            // perform custom rendering for the background.
            if (item != null)
            {
                if (item.Placement == ToolStripItemPlacement.Overflow ||
                    item.IsOnDropDown)
                {
                    using (LinearGradientBrush b = new LinearGradientBrush(
                        item.ContentRectangle,
                        Color.Salmon,
                        Color.DarkRed,
                        0f,
                        false))
                    {
                        e.Graphics.FillRectangle(b, item.ContentRectangle);
                    }
                }

                // The RolloverItem control only supports 
                // the ImageLayout.Center setting for the
                // BackgroundImage property.
                if (item.BackgroundImageLayout == ImageLayout.Center)
                {
                    // Get references to the item's ContentRectangle
                    // and BackgroundImage, for convenience.
                    Rectangle cr = item.ContentRectangle;
                    Image bgi = item.BackgroundImage;

                    // Compute the center of the item's ContentRectangle.
                    int centerX = (cr.Width - bgi.Width) / 2;
                    int centerY = (cr.Height - bgi.Height) / 2;

                    // If the item is selected, draw the background
                    // image as usual. Otherwise, draw it as disabled.
                    if (item.Selected)
                    {
                        e.Graphics.DrawImage(bgi, centerX, centerY);
                    }
                    else
                    {
                        ControlPaint.DrawImageDisabled(
                                e.Graphics,
                                bgi,
                                centerX,
                                centerY,
                                item.BackColor);
                    }
                }

                // If the item is in the rollover state, 
                // draw a border around it.
                if (item.Rollover)
                {
                    ControlPaint.DrawFocusRectangle(
                        e.Graphics,
                        item.ContentRectangle);
                }
            }
        }

    #endregion

    }

    // This form tests various features of the RolloverItem
    // control. RolloverItem conrols are created and added
    // to the form's ToolStrip. They are also created and 
    // added to a button's ContextMenuStrip. The behavior
    // of the RolloverItem control differs depending on 
    // the type of parent control.
    public class RolloverItemTestForm : Form
    {
        private System.Windows.Forms.ToolStrip toolStrip1;
        private System.Windows.Forms.Button button1;

        private string infoIconKey = "Information icon";
        private string handIconKey = "Hand icon";
        private string exclIconKey = "Exclamation icon";
        private string questionIconKey = "Question icon";
        private string warningIconKey = "Warning icon ";

        private System.ComponentModel.IContainer components = null;

        public RolloverItemTestForm()
        {
            InitializeComponent();

            // Set up the form's ToolStrip control.
            InitializeToolStrip();

            // Set up the ContextMenuStrip for the button.
            InitializeContextMenu();
        }

        // This utility method initializes the ToolStrip control's 
        // image list. For convenience, icons from the SystemIcons 
        // class are used for this demonstration, but any images
        // could be used.
        private void InitializeImageList(ToolStrip ts)
        {
            if (ts.ImageList == null)
            {
                ts.ImageList = new ImageList();
                ts.ImageList.ImageSize = SystemIcons.Exclamation.Size;

                ts.ImageList.Images.Add(
                    this.infoIconKey,
                    SystemIcons.Information);

                ts.ImageList.Images.Add(
                    this.handIconKey,
                    SystemIcons.Hand);

                ts.ImageList.Images.Add(
                    this.exclIconKey,
                    SystemIcons.Exclamation);

                ts.ImageList.Images.Add(
                    this.questionIconKey,
                    SystemIcons.Question);

                ts.ImageList.Images.Add(
                    this.warningIconKey,
                    SystemIcons.Warning);
            }
        }

        private void InitializeToolStrip()
        {
            this.InitializeImageList(this.toolStrip1);

            this.toolStrip1.Renderer = new RolloverItemRenderer();

            RolloverItem item = this.CreateRolloverItem(
                this.toolStrip1,
                "RolloverItem on ToolStrip",
                this.Font,
                infoIconKey,
                TextImageRelation.ImageBeforeText,
                exclIconKey);

            this.toolStrip1.Items.Add(item);

            item = this.CreateRolloverItem(
                this.toolStrip1,
                "RolloverItem on ToolStrip",
                this.Font,
                infoIconKey,
                TextImageRelation.ImageBeforeText,
                exclIconKey);

            this.toolStrip1.Items.Add(item);
        }

        private void InitializeContextMenu()
        {
            Font f = new System.Drawing.Font(
                "Arial",
                18f,
                FontStyle.Bold);

            ContextMenuStrip cms = new ContextMenuStrip();
            this.InitializeImageList(cms);

            cms.Renderer = new RolloverItemRenderer();
            cms.AutoSize = true;
            cms.ShowCheckMargin = false;
            cms.ShowImageMargin = false;

            RolloverItem item = this.CreateRolloverItem(
                cms,
                "RolloverItem on ContextMenuStrip",
                f,
                handIconKey,
                TextImageRelation.ImageBeforeText,
                exclIconKey);

            cms.Items.Add(item);

            item = this.CreateRolloverItem(
                cms,
                "Another RolloverItem on ContextMenuStrip",
                f,
                questionIconKey,
                TextImageRelation.ImageBeforeText,
                exclIconKey);

            cms.Items.Add(item);

            item = this.CreateRolloverItem(
                cms,
                "And another RolloverItem on ContextMenuStrip",
                f,
                warningIconKey,
                TextImageRelation.ImageBeforeText,
                exclIconKey);

            cms.Items.Add(item);

            cms.Closing += new ToolStripDropDownClosingEventHandler(cms_Closing);

            this.button1.ContextMenuStrip = cms;
        }

        // This method handles the ContextMenuStrip 
        // control's Closing event. It prevents the 
        // RolloverItem from closing the drop-down  
        // when the item is clicked.
        void cms_Closing(object sender, ToolStripDropDownClosingEventArgs e)
        {
            if (e.CloseReason == ToolStripDropDownCloseReason.ItemClicked)
            {
                e.Cancel = true;
            }
        }

        // This method handles the Click event for the button.
        // it selects the first item in the ToolStrip control
        // by using the ToolStripITem.Select method.
        private void button1_Click(object sender, EventArgs e)
        {
            RolloverItem item = this.toolStrip1.Items[0] as RolloverItem;

            if (item != null)
            {
                item.Select();

                this.Invalidate();
            }
        }

        // This utility method creates a RolloverItem 
        // and adds it to a ToolStrip control.
        private RolloverItem CreateRolloverItem(
            ToolStrip owningToolStrip,
            string txt,
            Font f,
            string imgKey,
            TextImageRelation tir,
            string backImgKey)
        {
            RolloverItem item = new RolloverItem();

            item.Alignment = ToolStripItemAlignment.Left;
            item.AllowDrop = false;
            item.AutoSize = true;

            item.BackgroundImage = owningToolStrip.ImageList.Images[backImgKey];
            item.BackgroundImageLayout = ImageLayout.Center;
            item.DisplayStyle = ToolStripItemDisplayStyle.ImageAndText;
            item.DoubleClickEnabled = true;
            item.Enabled = true;
            item.Font = f;

            // These assignments are equivalent. Each assigns an
            // image from the owning toolstrip's image list.
            item.ImageKey = imgKey;
            //item.Image = owningToolStrip.ImageList.Images[infoIconKey];
            //item.ImageIndex = owningToolStrip.ImageList.Images.IndexOfKey(infoIconKey);
            item.ImageScaling = ToolStripItemImageScaling.None;

            item.Owner = owningToolStrip;
            item.Padding = new Padding(2);
            item.Text = txt;
            item.TextAlign = ContentAlignment.MiddleLeft;
            item.TextDirection = ToolStripTextDirection.Horizontal;
            item.TextImageRelation = tir;

            return item;
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        private void InitializeComponent()
        {
            this.toolStrip1 = new System.Windows.Forms.ToolStrip();
            this.button1 = new System.Windows.Forms.Button();
            this.SuspendLayout();
            // 
            // toolStrip1
            // 
            this.toolStrip1.AllowItemReorder = true;
            this.toolStrip1.Location = new System.Drawing.Point(0, 0);
            this.toolStrip1.Name = "toolStrip1";
            this.toolStrip1.Size = new System.Drawing.Size(845, 25);
            this.toolStrip1.TabIndex = 0;
            this.toolStrip1.Text = "toolStrip1";
            // 
            // button1
            // 
            this.button1.Location = new System.Drawing.Point(12, 100);
            this.button1.Name = "button1";
            this.button1.Size = new System.Drawing.Size(86, 23);
            this.button1.TabIndex = 1;
            this.button1.Text = "Click to select";
            this.button1.UseVisualStyleBackColor = true;
            this.button1.Click += new System.EventHandler(this.button1_Click);
            // 
            // RolloverItemTestForm
            // 
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 14F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.AutoSize = true;
            this.ClientSize = new System.Drawing.Size(845, 282);
            this.Controls.Add(this.button1);
            this.Controls.Add(this.toolStrip1);
            this.Font = new System.Drawing.Font("Arial", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.Name = "RolloverItemTestForm";
            this.Text = "Form1";
            this.ResumeLayout(false);
            this.PerformLayout();
        }

        #endregion
    }

    static class Program
    {   
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new RolloverItemTestForm());
        }
    }
}
Option Strict On
Option Explicit On

Imports System.Collections.Generic
Imports System.ComponentModel
Imports System.Drawing
Imports System.Drawing.Drawing2D
Imports System.Windows.Forms

' This class implements a ToolStripItem that highlights
' its border and text when the mouse enters its
' client rectangle. It has a clickable state which is
' exposed through the Clicked property and displayed
' by highlighting or graying out the item's image. 
Public Class RolloverItem
    Inherits ToolStripItem

   Private clickedValue As Boolean = False
   Private rolloverValue As Boolean = False
   
   Private imageRect As Rectangle
   Private textRect As Rectangle
   
   ' For brevity, this implementation limits the possible 
   ' TextDirection values to ToolStripTextDirection.Horizontal. 
   Public Overrides Property TextDirection() As ToolStripTextDirection
      Get
         Return MyBase.TextDirection
      End Get
      Set
         If value = ToolStripTextDirection.Horizontal Then
            MyBase.TextDirection = value
         Else
                Throw New ArgumentException( _
                "RolloverItem supports only horizontal text.")
         End If
      End Set
   End Property
   
   ' For brevity, this implementation limits the possible 
   ' TextImageRelation values to ImageBeforeText and TextBeforeImage. 
   Public Shadows Property TextImageRelation() As TextImageRelation
      Get
         Return MyBase.TextImageRelation
      End Get
      
      Set
            If Value = TextImageRelation.ImageBeforeText OrElse _
               Value = TextImageRelation.TextBeforeImage Then
                MyBase.TextImageRelation = Value
            Else
                Throw New ArgumentException("Unsupported TextImageRelation value.")
            End If
      End Set
   End Property
   
   ' This property returns true if the mouse is 
   ' inside the client rectangle.
   Public ReadOnly Property Rollover() As Boolean
      Get
         Return Me.rolloverValue
      End Get
    End Property

   ' This property returns true if the item 
   ' has been toggled into the clicked state.
   ' Clicking again toggles it to the 
   ' unclicked state.
   Public ReadOnly Property Clicked() As Boolean
      Get
         Return Me.clickedValue
      End Get
   End Property
   
   ' The method defines the behavior of the Click event.
   ' It simply toggles the state of the clickedValue field.
   Protected Overrides Sub OnClick(e As EventArgs)
      MyBase.OnClick(e)
      
        Me.clickedValue = Me.clickedValue Xor True
    End Sub

   ' The method defines the behavior of the DoubleClick 
   ' event. It shows a MessageBox with the item's text.
   Protected Overrides Sub OnDoubleClick(e As EventArgs)
      MyBase.OnDoubleClick(e)
      
      Dim msg As String = String.Format("Item: {0}", Me.Text)
      
      MessageBox.Show(msg)
    End Sub

   ' This method defines the behavior of the MouseEnter event.
   ' It sets the state of the rolloverValue field to true and
   ' tells the control to repaint.
   Protected Overrides Sub OnMouseEnter(e As EventArgs)
      MyBase.OnMouseEnter(e)
      
      Me.rolloverValue = True
      
      Me.Invalidate()
    End Sub
   
   ' This method defines the behavior of the MouseLeave event.
   ' It sets the state of the rolloverValue field to false and
   ' tells the control to repaint.
   Protected Overrides Sub OnMouseLeave(e As EventArgs)
      MyBase.OnMouseLeave(e)
      
      Me.rolloverValue = False
      
      Me.Invalidate()
    End Sub
   
   ' This method defines the painting behavior of the control.
   ' It performs the following operations:
   '
   ' Computes the layout of the item's image and text.
   ' Draws the item's background image.
   ' Draws the item's image.
   ' Draws the item's text.
   '
   ' Drawing operations are implemented in the 
   ' RolloverItemRenderer class.
   Protected Overrides Sub OnPaint(e As PaintEventArgs)
      MyBase.OnPaint(e)
      
      If (Me.Owner IsNot Nothing) Then
         ' Find the dimensions of the image and the text 
         ' areas of the item. 
         Me.ComputeImageAndTextLayout()
         
         ' Draw the background. This includes drawing a highlighted 
         ' border when the mouse is in the client area.
         Dim ea As New ToolStripItemRenderEventArgs(e.Graphics, Me)
         Me.Owner.Renderer.DrawItemBackground(ea)
         
         ' Draw the item's image. 
         Dim irea As New ToolStripItemImageRenderEventArgs(e.Graphics, Me, imageRect)
         Me.Owner.Renderer.DrawItemImage(irea)
         
         ' If the item is on a drop-down, give its
         ' text a different highlighted color.
            Dim highlightColor As Color = CType(IIf(Me.IsOnDropDown, Color.Salmon, SystemColors.ControlLightLight), Color)
         
         ' Draw the text, and highlight it if the 
         ' the rollover state is true.
            Dim rea As New ToolStripItemTextRenderEventArgs( _
               e.Graphics, _
               Me, _
               MyBase.Text, _
               textRect, _
               CType(IIf(Me.rolloverValue, highlightColor, MyBase.ForeColor), Color), _
               MyBase.Font, _
               MyBase.TextAlign)
         Me.Owner.Renderer.DrawItemText(rea)
      End If
    End Sub

   ' This utility method computes the layout of the 
   ' RolloverItem control's image area and the text area.
   ' For brevity, only the following settings are 
   ' supported:
   '
   ' ToolStripTextDirection.Horizontal
   ' TextImageRelation.ImageBeforeText 
   ' TextImageRelation.ImageBeforeText
   ' 
   ' It would not be difficult to support vertical text
   ' directions and other image/text relationships.
   Private Sub ComputeImageAndTextLayout()
      Dim cr As Rectangle = MyBase.ContentRectangle
      Dim img As Image = MyBase.Owner.ImageList.Images(MyBase.ImageKey)
      
      ' Compute the center of the item's ContentRectangle.
        Dim centerY As Integer = CInt((cr.Height - img.Height) / 2)
      
      ' Find the dimensions of the image and the text 
      ' areas of the item. The text occupies the space 
      ' not filled by the image. 
        If MyBase.TextImageRelation = _
        TextImageRelation.ImageBeforeText AndAlso _
        MyBase.TextDirection = ToolStripTextDirection.Horizontal Then

            imageRect = New Rectangle( _
            MyBase.ContentRectangle.Left, _
            centerY, _
            MyBase.Image.Width, _
            MyBase.Image.Height)

            textRect = New Rectangle( _
            imageRect.Width, _
            MyBase.ContentRectangle.Top, _
            MyBase.ContentRectangle.Width - imageRect.Width, _
            MyBase.ContentRectangle.Height)

        ElseIf MyBase.TextImageRelation = _
        TextImageRelation.TextBeforeImage AndAlso _
        MyBase.TextDirection = ToolStripTextDirection.Horizontal Then

            imageRect = New Rectangle( _
            MyBase.ContentRectangle.Right - MyBase.Image.Width, _
            centerY, _
            MyBase.Image.Width, _
            MyBase.Image.Height)

            textRect = New Rectangle( _
            MyBase.ContentRectangle.Left, _
            MyBase.ContentRectangle.Top, _
            imageRect.X, _
            MyBase.ContentRectangle.Bottom)

        End If
    End Sub
End Class

' This is the custom renderer for the RolloverItem control.
' It draws a border around the item when the mouse is
' in the item's client area. It also draws the item's image
' in an inactive state (grayed out) until the user clicks
' the item to toggle its "clicked" state.
Friend Class RolloverItemRenderer
    Inherits ToolStripSystemRenderer

    Protected Overrides Sub OnRenderItemImage(ByVal e As ToolStripItemImageRenderEventArgs)
        MyBase.OnRenderItemImage(e)

        Dim item As RolloverItem = CType(e.Item, RolloverItem)

        ' If the ToolSTripItem is of type RolloverItem, 
        ' perform custom rendering for the image.
        If (item IsNot Nothing) Then
            If item.Clicked Then
                ' The item is in the clicked state, so 
                ' draw the image as usual.
                e.Graphics.DrawImage(e.Image, e.ImageRectangle.X, e.ImageRectangle.Y)
            Else
                ' In the unclicked state, gray out the image.
                ControlPaint.DrawImageDisabled(e.Graphics, e.Image, e.ImageRectangle.X, e.ImageRectangle.Y, item.BackColor)
            End If
        End If
    End Sub

    ' This method defines the behavior for rendering the
    ' background of a ToolStripItem. If the item is a
    ' RolloverItem, it paints the item's BackgroundImage 
    ' centered in the client area. If the mouse is in the 
    ' item's client area, a border is drawn around it.
    ' If the item is on a drop-down or if it is on the
    ' overflow, a gradient is painted in the background.
    Protected Overrides Sub OnRenderItemBackground(ByVal e As ToolStripItemRenderEventArgs)
        MyBase.OnRenderItemBackground(e)

        Dim item As RolloverItem = CType(e.Item, RolloverItem)

        ' If the ToolSTripItem is of type RolloverItem, 
        ' perform custom rendering for the background.
        If (item IsNot Nothing) Then
            If item.Placement = ToolStripItemPlacement.Overflow OrElse item.IsOnDropDown Then
                Dim b As New LinearGradientBrush(item.ContentRectangle, Color.Salmon, Color.DarkRed, 0.0F, False)
                Try
                    e.Graphics.FillRectangle(b, item.ContentRectangle)
                Finally
                    b.Dispose()
                End Try
            End If

            ' The RolloverItem control only supports 
            ' the ImageLayout.Center setting for the
            ' BackgroundImage property.
            If item.BackgroundImageLayout = ImageLayout.Center Then
                ' Get references to the item's ContentRectangle
                ' and BackgroundImage, for convenience.
                Dim cr As Rectangle = item.ContentRectangle
                Dim bgi As Image = item.BackgroundImage

                ' Compute the center of the item's ContentRectangle.
                Dim centerX As Integer = CInt((cr.Width - bgi.Width) / 2)
                Dim centerY As Integer = CInt((cr.Height - bgi.Height) / 2)

                ' If the item is selected, draw the background
                ' image as usual. Otherwise, draw it as disabled.
                If item.Selected Then
                    e.Graphics.DrawImage(bgi, centerX, centerY)
                Else
                    ControlPaint.DrawImageDisabled(e.Graphics, bgi, centerX, centerY, item.BackColor)
                End If
            End If

            ' If the item is in the rollover state, 
            ' draw a border around it.
            If item.Rollover Then
                ControlPaint.DrawFocusRectangle(e.Graphics, item.ContentRectangle)
            End If
        End If
    End Sub

End Class

' This form tests various features of the RolloverItem
' control. RolloverItem conrols are created and added
' to the form's ToolStrip. They are also created and 
' added to a button's ContextMenuStrip. The behavior
' of the RolloverItem control differs depending on 
' the type of parent control.

Public Class RolloverItemTestForm
   Inherits Form
   Private toolStrip1 As System.Windows.Forms.ToolStrip
   Private WithEvents button1 As System.Windows.Forms.Button
   
   Private infoIconKey As String = "Information icon"
   Private handIconKey As String = "Hand icon"
   Private exclIconKey As String = "Exclamation icon"
   Private questionIconKey As String = "Question icon"
   Private warningIconKey As String = "Warning icon "
   
   Private components As System.ComponentModel.IContainer = Nothing
   
   
   Public Sub New()
      InitializeComponent()
      
      ' Set up the form's ToolStrip control.
      InitializeToolStrip()
      
      ' Set up the ContextMenuStrip for the button.
      InitializeContextMenu()
    End Sub
   
   
   ' This utility method initializes the ToolStrip control's 
   ' image list. For convenience, icons from the SystemIcons 
   ' class are used for this demonstration, but any images
   ' could be used.
   Private Sub InitializeImageList(ts As ToolStrip)
      If ts.ImageList Is Nothing Then
         ts.ImageList = New ImageList()
         ts.ImageList.ImageSize = SystemIcons.Exclamation.Size
         
         ts.ImageList.Images.Add(Me.infoIconKey, SystemIcons.Information)
         
         ts.ImageList.Images.Add(Me.handIconKey, SystemIcons.Hand)
         
         ts.ImageList.Images.Add(Me.exclIconKey, SystemIcons.Exclamation)
         
         ts.ImageList.Images.Add(Me.questionIconKey, SystemIcons.Question)
         
         ts.ImageList.Images.Add(Me.warningIconKey, SystemIcons.Warning)
      End If
    End Sub
   
   
   Private Sub InitializeToolStrip()
      Me.InitializeImageList(Me.toolStrip1)
      
      Me.toolStrip1.Renderer = New RolloverItemRenderer()
      
      Dim item As RolloverItem = Me.CreateRolloverItem(Me.toolStrip1, "RolloverItem on ToolStrip", Me.Font, infoIconKey, TextImageRelation.ImageBeforeText, exclIconKey)
      
      Me.toolStrip1.Items.Add(item)
      
      item = Me.CreateRolloverItem(Me.toolStrip1, "RolloverItem on ToolStrip", Me.Font, infoIconKey, TextImageRelation.ImageBeforeText, exclIconKey)
      
      Me.toolStrip1.Items.Add(item)
    End Sub
   
   
   Private Sub InitializeContextMenu()
        Dim f As New System.Drawing.Font("Arial", 18.0F, FontStyle.Bold)
      
      Dim cms As New ContextMenuStrip()
      Me.InitializeImageList(cms)
      
      cms.Renderer = New RolloverItemRenderer()
      cms.AutoSize = True
      cms.ShowCheckMargin = False
      cms.ShowImageMargin = False
      
        Dim item As RolloverItem = Me.CreateRolloverItem( _
        cms, _
        "RolloverItem on ContextMenuStrip", _
        f, _
        handIconKey, _
        TextImageRelation.ImageBeforeText, _
        exclIconKey)
      
      cms.Items.Add(item)
      
        item = Me.CreateRolloverItem( _
        cms, _
        "Another RolloverItem on ContextMenuStrip", _
        f, _
        questionIconKey, _
        TextImageRelation.ImageBeforeText, _
        exclIconKey)
      
      cms.Items.Add(item)
      
        item = Me.CreateRolloverItem( _
        cms, _
        "And another RolloverItem on ContextMenuStrip", _
        CType(f, Drawing.Font), _
        warningIconKey, _
        TextImageRelation.ImageBeforeText, _
        exclIconKey)
      
      cms.Items.Add(item)
      
      AddHandler cms.Closing, AddressOf cms_Closing
      
      Me.button1.ContextMenuStrip = cms
    End Sub
   
   
   ' This method handles the ContextMenuStrip 
   ' control's Closing event. It prevents the 
   ' RolloverItem from closing the drop-down  
   ' when the item is clicked.
   Private Sub cms_Closing(sender As Object, e As ToolStripDropDownClosingEventArgs)
      If e.CloseReason = ToolStripDropDownCloseReason.ItemClicked Then
         e.Cancel = True
      End If
    End Sub
   
   
   ' This method handles the Click event for the button.
   ' it selects the first item in the ToolStrip control
   ' by using the ToolStripITem.Select method.
   Private Sub button1_Click(sender As Object, e As EventArgs) Handles button1.Click
        Dim item As RolloverItem = CType(Me.toolStrip1.Items(0), RolloverItem)
      
      If (item IsNot Nothing) Then
         item.Select()
         
         Me.Invalidate()
      End If
    End Sub

   ' This utility method creates a RolloverItem 
   ' and adds it to a ToolStrip control.
    Private Function CreateRolloverItem( _
    ByVal owningToolStrip As ToolStrip, _
    ByVal txt As String, _
    ByVal f As Font, _
    ByVal imgKey As String, _
    ByVal tir As TextImageRelation, _
    ByVal backImgKey As String) As RolloverItem

        Dim item As New RolloverItem()

        item.Alignment = ToolStripItemAlignment.Left
        item.AllowDrop = False
        item.AutoSize = True

        item.BackgroundImage = owningToolStrip.ImageList.Images(backImgKey)
        item.BackgroundImageLayout = ImageLayout.Center
        item.DisplayStyle = ToolStripItemDisplayStyle.ImageAndText
        item.DoubleClickEnabled = True
        item.Enabled = True
        item.Font = f

        ' These assignments are equivalent. Each assigns an
        ' image from the owning toolstrip's image list.
        item.ImageKey = imgKey
        'item.Image = owningToolStrip.ImageList.Images[infoIconKey];
        'item.ImageIndex = owningToolStrip.ImageList.Images.IndexOfKey(infoIconKey);
        item.ImageScaling = ToolStripItemImageScaling.None

        item.Owner = owningToolStrip
        item.Padding = New Padding(2)
        item.Text = txt
        item.TextAlign = ContentAlignment.MiddleLeft
        item.TextDirection = ToolStripTextDirection.Horizontal
        item.TextImageRelation = tir

        Return item
    End Function

   Protected Overrides Sub Dispose(disposing As Boolean)
      If disposing AndAlso (components IsNot Nothing) Then
         components.Dispose()
      End If
      MyBase.Dispose(disposing)
    End Sub
   
   #Region "Windows Form Designer generated code"
   
   Private Sub InitializeComponent()
      Me.toolStrip1 = New System.Windows.Forms.ToolStrip()
      Me.button1 = New System.Windows.Forms.Button()
      Me.SuspendLayout()
      ' 
      ' toolStrip1
      ' 
      Me.toolStrip1.AllowItemReorder = True
      Me.toolStrip1.Location = New System.Drawing.Point(0, 0)
      Me.toolStrip1.Name = "toolStrip1"
      Me.toolStrip1.Size = New System.Drawing.Size(845, 25)
      Me.toolStrip1.TabIndex = 0
      Me.toolStrip1.Text = "toolStrip1"
      ' 
      ' button1
      ' 
      Me.button1.Location = New System.Drawing.Point(12, 100)
      Me.button1.Name = "button1"
      Me.button1.Size = New System.Drawing.Size(86, 23)
      Me.button1.TabIndex = 1
      Me.button1.Text = "Click to select"
      Me.button1.UseVisualStyleBackColor = True
      ' 
      ' RolloverItemTestForm
      ' 
      Me.AutoScaleDimensions = New System.Drawing.SizeF(6F, 14F)
      Me.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font
      Me.AutoSize = True
      Me.ClientSize = New System.Drawing.Size(845, 282)
      Me.Controls.Add(button1)
      Me.Controls.Add(toolStrip1)
        Me.Font = New System.Drawing.Font("Arial", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, 0)
      Me.Name = "RolloverItemTestForm"
      Me.Text = "Form1"
      Me.ResumeLayout(False)
      Me.PerformLayout()
    End Sub
   
#End Region

End Class


Public Class Program

    <STAThread()> _
    Shared Sub Main()
        Application.EnableVisualStyles()
        Application.SetCompatibleTextRenderingDefault(False)
        Application.Run(New RolloverItemTestForm())
    End Sub
End Class

Comentários

Um ToolStripItem é um elemento como um botão, uma caixa de combinação, uma caixa de texto ou um rótulo que pode estar contido em um ToolStrip controle ou em um ToolStripDropDown controle, que é semelhante a um menu de atalho do Windows. A ToolStrip classe gerencia a pintura e a entrada do teclado e do mouse, incluindo entrada de arrastar e soltar, para esses elementos, e a ToolStripItem classe gerencia eventos e layout dentro dos próprios elementos.

ToolStripItemas classes herdam diretamente de ToolStripItemou herdam indiretamente de por meio ToolStripControlHost de ToolStripItem ou ToolStripDropDownItem.

ToolStripItem os controles devem estar contidos em um ToolStrip, MenuStrip, StatusStripou ContextMenuStrip e não podem ser adicionados diretamente a um formulário. As várias classes de contêiner foram projetadas para conter um subconjunto apropriado de ToolStripItem controles.

Nota Um determinado ToolStripItem não pode ter mais de um pai ToolStrip. Você deve copiar o ToolStripItem e adicioná-lo a outros ToolStrip controles.

A tabela a seguir mostra os elementos que derivam da ToolStripItem classe e que, portanto, podem ser hospedados em um ToolStrip ou ToolStripDropDown.

Elemento Descrição
ToolStripButton Um botão de barra de ferramentas que dá suporte a imagens e texto.
ToolStripLabel Um rótulo de texto normalmente usado em uma barra de status ou ToolStrip como um comentário ou título.
ToolStripSeparator Um espaço ou espaço não selecionável com uma barra vertical que agrupa elementos visualmente.
ToolStripControlHost Um ToolStripItem que hospeda um ToolStripComboBox, ToolStripTextBox, ToolStripProgressBar, outros controles Windows Forms ou controles personalizados.

Um ToolStripComboBox é uma caixa de texto na qual o usuário pode inserir texto, juntamente com uma lista da qual o usuário pode selecionar o texto para preencher a caixa de texto.

Um ToolStripTextBox permite que o usuário insira texto.

Um ToolStripProgressBar representa um controle de barra de progresso do Windows contido em um StatusStrip.
ToolStripDropDownItem Um ToolStripItem que hospeda um ToolStripMenuItem, ToolStripSplitButtone ToolStripDropDownButton.

Um ToolStripMenuItem é uma opção selecionável exibida em um menu ou menu de contexto.

Um ToolStripSplitButton é uma combinação de um botão regular e um botão suspenso.

Um ToolStripDropDownButton é um botão que dá suporte à funcionalidade suspensa.
ToolStripStatusLabel Um painel em um StatusStrip controle .

Construtores

ToolStripItem()

Inicializa uma nova instância da classe ToolStripItem.

ToolStripItem(String, Image, EventHandler)

Inicializa uma nova instância da classe ToolStripItem com o nome, a imagem e o manipulador de eventos especificados.

ToolStripItem(String, Image, EventHandler, String)

Inicializa uma nova instância da classe ToolStripItem com o texto de exibição, a imagem, o manipulador de eventos e o nome especificados.

Propriedades

AccessibilityObject

Obtém o AccessibleObject atribuído ao controle.

AccessibleDefaultActionDescription

Obtém ou define a descrição de ação padrão do controle para o uso por aplicativos cliente de acessibilidade.

AccessibleDescription

Obtém ou define a descrição que será relatada para os aplicativos cliente de acessibilidade.

AccessibleName

Obtém ou define o nome do controle para uso de aplicativos cliente de acessibilidade.

AccessibleRole

Obtém ou define a função acessível do controle, que especifica o tipo de elemento de interface do usuário do controle.

Alignment

Obtém ou define um valor que indica se o item é alinhado no início ou no final do ToolStrip.

AllowDrop

Obtém ou define um valor que indica se a operação do tipo "arrastar e soltar" e a reordenação de itens são manipulados por meio de eventos que você implementou.

Anchor

Obtém ou define as bordas do contêiner ao qual um ToolStripItem está vinculado e determina como um ToolStripItem é redimensionado com seu pai.

AutoSize

Obtém ou define um valor que indica se o item é dimensionado automaticamente.

AutoToolTip

Obtém ou define um valor que indica se a propriedade Text ou a propriedade ToolTipText para dica de ferramenta ToolStripItem deve ser usada.

Available

Obtém ou define um valor que indica se o ToolStripItem deve ser colocado em um ToolStrip.

BackColor

Obtém ou define a cor da tela de fundo do item.

BackgroundImage

Obtém ou define a imagem de tela de fundo exibida no item.

BackgroundImageLayout

Obtém ou define o layout da imagem de tela de fundo usado para o ToolStripItem.

BindingContext

Obtém ou define a coleção de gerenciadores de moeda para o IBindableComponent.

(Herdado de BindableComponent)
Bounds

Obtém o tamanho e o local do item.

CanRaiseEvents

Obtém um valor que indica se o componente pode acionar um evento.

(Herdado de Component)
CanSelect

Obtém um valor que indica se o item pode ser selecionado.

Command

Obtém ou define o ICommand cujo Execute(Object) método será chamado quando o evento ToolStripItem Click for invocado.

CommandParameter

Obtém ou define o parâmetro que é passado para o ICommand atribuído à Command propriedade .

Container

Obtém o IContainer que contém o Component.

(Herdado de Component)
ContentRectangle

Obtém a área na qual o conteúdo, como texto e ícones, pode ser colocado em um ToolStripItem sem substituir as bordas da tela de fundo.

DataBindings

Obtém a coleção de objetos de associação de dados para esse IBindableComponent.

(Herdado de BindableComponent)
DefaultAutoToolTip

Obtém um valor que indica se a ToolTip definida como o padrão será exibida.

DefaultDisplayStyle

Obtém um valor que indica o que é exibido no ToolStripItem.

DefaultMargin

Obtém a margem padrão de um item.

DefaultPadding

Obtém as características de espaçamento interno do item.

DefaultSize

Obtém o tamanho padrão do item.

DesignMode

Obtém um valor que indica se o Component está no modo de design no momento.

(Herdado de Component)
DismissWhenClicked

Obtém um valor que indica se os itens de um ToolStripDropDown ficam ocultos depois que recebem um clique.

DisplayStyle

Obtém ou define se texto e imagens são exibidos em um ToolStripItem.

Dock

Obtém ou define quais bordas de ToolStripItem são encaixadas em seu controle pai e determina como uma ToolStripItem é redimensionada com seu pai.

DoubleClickEnabled

Obtém ou define um valor que indica se o ToolStripItem pode ser ativado clicando duas vezes no mouse.

Enabled

Obtém ou define um valor que indica se o controle pai do ToolStripItem está habilitado.

Events

Obtém a lista de manipuladores de eventos que estão anexados a este Component.

(Herdado de Component)
Font

Obtém ou define a fonte do texto exibido pelo item.

ForeColor

Obtém ou define a cor de primeiro plano do item.

Height

Obtém ou define a altura, em pixels, de um ToolStripItem.

Image

Obtém ou define a imagem exibida em um ToolStripItem.

ImageAlign

Obtém ou define o alinhamento da imagem em um ToolStripItem.

ImageIndex

Obtém ou define o valor do índice da imagem que é exibido no item.

ImageKey

Obtém ou define o acessador de chave para a imagem na ImageList que é exibido em um ToolStripItem.

ImageScaling

Obtém ou define um valor que indica se uma imagem em um ToolStripItem é redimensionada automaticamente para se ajustar em um contêiner.

ImageTransparentColor

Obtém ou define a cor a ser tratada como transparente em uma imagem ToolStripItem.

IsDisposed

Obtém um valor que indica se o objeto foi descartado.

IsOnDropDown

Obtém um valor que indica se o contêiner do Control atual é um ToolStripDropDown.

IsOnOverflow

Obtém um valor que indica se a propriedade Placement foi definida como Overflow.

Margin

Obtém ou define o espaço entre o item e os itens adjacentes.

MergeAction

Obtém ou define como os menus filho são mescladas com menus pai.

MergeIndex

Obtém ou define a posição de um item mesclado no ToolStrip atual.

Name

Obtém ou define o nome do item.

Overflow

Obtém ou define se o item é anexado ao ToolStrip ou ao ToolStripOverflowButton ou se ele pode flutuar entre os dois.

Owner

Obtém ou define o proprietário desse item.

OwnerItem

Obtém o pai ToolStripItem desse ToolStripItem.

Padding

Obtém ou define o espaçamento interno, em pixels, entre o conteúdo do item e suas bordas.

Parent

Obtém ou define o contêiner pai do ToolStripItem.

Placement

Obtém o layout atual do item.

Pressed

Obtém um valor que indica se o estado do item é pressionado.

Renderer

Representa a classe base abstrata que gerencia eventos e o layout para todos os elementos que um ToolStrip ou ToolStripDropDown pode conter.

RightToLeft

Obtém ou define um valor que indica se os itens devem ser colocados da direita para a esquerda e se o texto deve ser escrito da direita para a esquerda.

RightToLeftAutoMirrorImage

Espelha automaticamente a imagem ToolStripItem quando a propriedade RightToLeft é definida como Yes.

Selected

Obtém um valor que indica se o item está selecionado.

ShowKeyboardCues

Obtém um valor que indica se as teclas de atalho devem ser mostradas ou ocultas.

Site

Obtém ou define o ISite do Component.

(Herdado de Component)
Size

Obtém ou define o tamanho do item.

Tag

Obtém ou define o objeto que contém dados sobre o item.

Text

Obtém ou define o texto a ser exibido no item.

TextAlign

Obtém ou define o alinhamento do texto em um ToolStripLabel.

TextDirection

Obtém a orientação do texto usada em um ToolStripItem.

TextImageRelation

Obtém ou define a posição do texto ToolStripItem e da imagem em relação um ao outro.

ToolTipText

Obtém ou define o texto exibido como ToolTip para um controle.

Visible

Obtém ou define um valor que indica se o item é exibido.

Width

Obtém ou define a largura em pixels de um ToolStripItem.

Métodos

CreateAccessibilityInstance()

Cria um novo objeto de acessibilidade para o ToolStripItem.

CreateObjRef(Type)

Cria um objeto que contém todas as informações relevantes necessárias para gerar um proxy usado para se comunicar com um objeto remoto.

(Herdado de MarshalByRefObject)
Dispose()

Libera todos os recursos usados pelo Component.

(Herdado de Component)
Dispose(Boolean)

Libera os recursos não gerenciados usados pelo ToolStripItem e opcionalmente libera os recursos gerenciados.

DoDragDrop(Object, DragDropEffects)

Começa uma operação de arrastar e soltar.

DoDragDrop(Object, DragDropEffects, Bitmap, Point, Boolean)

Inicia uma operação de arrastar.

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.

(Herdado de Object)
GetCurrentParent()

Recupera o ToolStrip que é o contêiner do ToolStripItem atual.

GetHashCode()

Serve como a função de hash padrão.

(Herdado de Object)
GetLifetimeService()
Obsoleto.

Recupera o objeto de serviço de tempo de vida atual que controla a política de ciclo de vida para esta instância.

(Herdado de MarshalByRefObject)
GetPreferredSize(Size)

Recupera o tamanho de uma área retangular na qual um controle pode ser ajustado.

GetService(Type)

Retorna um objeto que representa um serviço fornecido pelo Component ou pelo seu Container.

(Herdado de Component)
GetType()

Obtém o Type da instância atual.

(Herdado de Object)
InitializeLifetimeService()
Obsoleto.

Obtém um objeto de serviço de tempo de vida para controlar a política de tempo de vida para essa instância.

(Herdado de MarshalByRefObject)
Invalidate()

Invalida a superfície inteira do ToolStripItem e faz com que ele seja redesenhado.

Invalidate(Rectangle)

Invalida a região especificada do ToolStripItem adicionando-a à região de atualização do ToolStripItem, que é a área que será repintada na próxima operação de pintura e envia uma mensagem sobre a pintura ao ToolStripItem.

IsInputChar(Char)

Determina se um caractere é um caractere de entrada reconhecido pelo item.

IsInputKey(Keys)

Determina se a chave especificada é uma chave de entrada regular ou uma chave especial que exige o pré-processamento.

MemberwiseClone()

Cria uma cópia superficial do Object atual.

(Herdado de Object)
MemberwiseClone(Boolean)

Cria uma cópia superficial do objeto MarshalByRefObject atual.

(Herdado de MarshalByRefObject)
OnAvailableChanged(EventArgs)

Aciona o evento AvailableChanged.

OnBackColorChanged(EventArgs)

Aciona o evento BackColorChanged.

OnBindingContextChanged(EventArgs)

Aciona o evento BindingContextChanged.

(Herdado de BindableComponent)
OnBoundsChanged()

Ocorre quando a propriedade Bounds muda.

OnClick(EventArgs)

Aciona o evento Click.

OnCommandCanExecuteChanged(EventArgs)

Aciona o evento CommandCanExecuteChanged.

OnCommandChanged(EventArgs)

Aciona o evento CommandChanged.

OnCommandParameterChanged(EventArgs)

Aciona o evento CommandParameterChanged.

OnDisplayStyleChanged(EventArgs)

Aciona o evento DisplayStyleChanged.

OnDoubleClick(EventArgs)

Aciona o evento DoubleClick.

OnDragDrop(DragEventArgs)

Aciona o evento DragDrop.

OnDragEnter(DragEventArgs)

Aciona o evento DragEnter.

OnDragLeave(EventArgs)

Aciona o evento DragLeave.

OnDragOver(DragEventArgs)

Aciona o evento DragOver.

OnEnabledChanged(EventArgs)

Aciona o evento EnabledChanged.

OnFontChanged(EventArgs)

Aciona o evento FontChanged.

OnForeColorChanged(EventArgs)

Aciona o evento ForeColorChanged.

OnGiveFeedback(GiveFeedbackEventArgs)

Aciona o evento GiveFeedback.

OnLayout(LayoutEventArgs)

Aciona o evento Layout.

OnLocationChanged(EventArgs)

Aciona o evento LocationChanged.

OnMouseDown(MouseEventArgs)

Aciona o evento MouseDown.

OnMouseEnter(EventArgs)

Aciona o evento MouseEnter.

OnMouseHover(EventArgs)

Aciona o evento MouseHover.

OnMouseLeave(EventArgs)

Aciona o evento MouseLeave.

OnMouseMove(MouseEventArgs)

Aciona o evento MouseMove.

OnMouseUp(MouseEventArgs)

Aciona o evento MouseUp.

OnOwnerChanged(EventArgs)

Aciona o evento OwnerChanged.

OnOwnerFontChanged(EventArgs)

Aciona o evento FontChanged quando a propriedade Font foi alterada no pai do ToolStripItem.

OnPaint(PaintEventArgs)

Aciona o evento Paint.

OnParentBackColorChanged(EventArgs)

Aciona o evento BackColorChanged.

OnParentChanged(ToolStrip, ToolStrip)

Aciona o evento ParentChanged.

OnParentEnabledChanged(EventArgs)

Aciona o evento EnabledChanged quando o valor da propriedade Enabled do contêiner do item é alterado.

OnParentForeColorChanged(EventArgs)

Aciona o evento ForeColorChanged.

OnParentRightToLeftChanged(EventArgs)

Aciona o evento RightToLeftChanged.

OnQueryContinueDrag(QueryContinueDragEventArgs)

Aciona o evento QueryContinueDrag.

OnRequestCommandExecute(EventArgs)

Chamado no contexto de OnClick(EventArgs) para invocar Execute(Object) se o contexto permitir.

OnRightToLeftChanged(EventArgs)

Aciona o evento RightToLeftChanged.

OnSelectedChanged(EventArgs)

Representa a classe base abstrata que gerencia eventos e o layout para todos os elementos que um ToolStrip ou ToolStripDropDown pode conter.

OnTextChanged(EventArgs)

Aciona o evento TextChanged.

OnVisibleChanged(EventArgs)

Aciona o evento VisibleChanged.

PerformClick()

Gera um evento Click para um ToolStripItem.

ProcessCmdKey(Message, Keys)

Processa uma chave de comando.

ProcessDialogKey(Keys)

Processa uma chave de caixa de diálogo.

ProcessMnemonic(Char)

Processa um caractere mnemônico.

ResetBackColor()

Esse método não é relevante para essa classe.

ResetDisplayStyle()

Esse método não é relevante para essa classe.

ResetFont()

Esse método não é relevante para essa classe.

ResetForeColor()

Esse método não é relevante para essa classe.

ResetImage()

Esse método não é relevante para essa classe.

ResetMargin()

Esse método não é relevante para essa classe.

ResetPadding()

Esse método não é relevante para essa classe.

ResetRightToLeft()

Esse método não é relevante para essa classe.

ResetTextDirection()

Esse método não é relevante para essa classe.

Select()

Seleciona o item.

SetBounds(Rectangle)

Define o tamanho e o local do item.

SetVisibleCore(Boolean)

Define o ToolStripItem para o estado de visibilidade especificado.

ToString()

Retorna um String que contém o nome do Component, se houver. Esse método não deve ser substituído.

Eventos

AvailableChanged

Ocorre quando o valor da propriedade Available muda.

BackColorChanged

Ocorre quando o valor da propriedade BackColor muda.

BindingContextChanged

Ocorre quando o contexto de associação foi alterado.

(Herdado de BindableComponent)
Click

Ocorre quando o ToolStripItem é clicado.

CommandCanExecuteChanged

Ocorre quando o CanExecute(Object) status do ICommand atribuído à Command propriedade foi alterado.

CommandChanged

Ocorre quando o atribuído ICommand da Command propriedade foi alterado.

CommandParameterChanged

Ocorre quando o valor da propriedade CommandParameter foi alterado.

DisplayStyleChanged

Ocorre quando o DisplayStyle foi alterado.

Disposed

Ocorre quando o componente é disposto por uma chamada ao método Dispose().

(Herdado de Component)
DoubleClick

Ocorre quando o item recebe dois cliques com o mouse.

DragDrop

Ocorre quando o usuário arrasta um item e libera o botão do mouse, indicando que o item deve ser solto nesse item.

DragEnter

Ocorre quando o usuário arrasta um item para a área de cliente desse item.

DragLeave

Ocorre quando o usuário arrasta um item e o ponteiro do mouse não está mais na área de cliente desse item.

DragOver

Ocorre quando o usuário arrasta um item para a área de cliente deste item.

EnabledChanged

Ocorre quando o valor da propriedade Enabled é alterado.

ForeColorChanged

Ocorre quando o valor da propriedade ForeColor muda.

GiveFeedback

Ocorre durante uma operação de arrastar.

LocationChanged

Ocorre quando o local de um ToolStripItem é atualizado.

MouseDown

Ocorre quando o ponteiro do mouse está sobre o item e um botão do mouse é pressionado.

MouseEnter

Ocorre quando o ponteiro do mouse entra no item.

MouseHover

Ocorre quando o ponteiro do mouse focaliza o item.

MouseLeave

Ocorre quando o ponteiro do mouse deixa o item.

MouseMove

Ocorre quando o ponteiro do mouse é movido sobre o item.

MouseUp

Ocorre quando o ponteiro do mouse está sobre o item e um botão do mouse é liberado.

OwnerChanged

Ocorre quando a propriedade Owner muda.

Paint

Ocorre quando o item é redesenhado.

QueryAccessibilityHelp

Ocorre quando um aplicativo cliente de acessibilidade invoca a Ajuda para o ToolStripItem.

QueryContinueDrag

Ocorre durante uma operação do tipo "arrastar e soltar" e permite que a fonte de arrastar determine se a operação do tipo "arrastar e soltar" deve ser cancelada.

RightToLeftChanged

Ocorre quando o valor da propriedade RightToLeft muda.

SelectedChanged

Representa a classe base abstrata que gerencia eventos e o layout para todos os elementos que um ToolStrip ou ToolStripDropDown pode conter.

TextChanged

Ocorre quando o valor da propriedade Text muda.

VisibleChanged

Ocorre quando o valor da propriedade Visible muda.

Implantações explícitas de interface

IDropTarget.OnDragDrop(DragEventArgs)

Aciona o evento DragDrop.

IDropTarget.OnDragEnter(DragEventArgs)

Aciona o evento DragEnter.

IDropTarget.OnDragLeave(EventArgs)

Aciona o evento DragLeave.

IDropTarget.OnDragOver(DragEventArgs)

Aciona o evento DragOver.

Aplica-se a

Confira também