ToolStripItem Classe

Definizione

Spazio dei nomi:

System.Windows.Forms

Assembly:

System.Windows.Forms.dll

Rappresenta la classe base astratta che gestisce gli eventi e il layout di tutti gli elementi che possono essere contenuti in ToolStrip o in ToolStripDropDown.

C#

public abstract class ToolStripItem : System.Windows.Forms.BindableComponent, IDisposable, System.Windows.Forms.IDropTarget

Ereditarietà

Object

MarshalByRefObject

Component

BindableComponent

ToolStripItem

Derivato

System.Windows.Forms.ToolStripButton

System.Windows.Forms.ToolStripControlHost

System.Windows.Forms.ToolStripDropDownItem

System.Windows.Forms.ToolStripLabel

System.Windows.Forms.ToolStripSeparator

Implementazioni

IComponent IDisposable IDropTarget

Esempio

Nell'esempio di codice seguente viene illustrato come implementare un controllo personalizzato ToolStripItem .

C#

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());
        }
    }
}

Commenti

Un ToolStripItem è un elemento, ad esempio un pulsante, una casella combinata, una casella di testo o un'etichetta che può essere contenuta in un controllo o in un ToolStripToolStripDropDown controllo, simile a un menu di scelta rapida di Windows. La ToolStrip classe gestisce l'input di disegno e tastiera e mouse, incluso l'input di trascinamento della selezione, per questi elementi e la ToolStripItem classe gestisce eventi e layout all'interno degli elementi stessi.

ToolStripItem le classi ereditano direttamente da ToolStripItemoppure ereditano indirettamente da tramite ToolStripItemToolStripControlHost o ToolStripDropDownItem.

ToolStripItem I controlli devono essere contenuti in un ToolStripoggetto , MenuStrip, StatusStripo ContextMenuStrip e non possono essere aggiunti direttamente a un modulo. Le varie classi contenitore sono progettate per contenere un subset appropriato di ToolStripItem controlli.

Nota Un dato ToolStripItem non può avere più di un elemento padre ToolStrip. È necessario copiare e ToolStripItem aggiungerlo ad altri ToolStrip controlli.

La tabella seguente illustra gli elementi che derivano dalla ToolStripItem classe e che possono quindi essere ospitati in un ToolStrip oggetto o ToolStripDropDown.

Elemento	Descrizione
ToolStripButton	Pulsante della barra degli strumenti che supporta immagini e testo.
ToolStripLabel	Un'etichetta di testo in genere utilizzata in una barra di stato o ToolStrip come commento o titolo.
ToolStripSeparator	Spazio o spazio non selezionabile con una barra verticale che raggruppa visivamente gli elementi.
ToolStripControlHost	Oggetto ToolStripItem che ospita un ToolStripComboBoxcontrollo , ToolStripTextBox, ToolStripProgressBar, altri controlli Windows Forms o controlli personalizzati. È ToolStripComboBox una casella di testo in cui l'utente può immettere testo, insieme a un elenco da cui l'utente può selezionare il testo per riempire la casella di testo. Un ToolStripTextBox consente all'utente di immettere testo. Un ToolStripProgressBar oggetto rappresenta un controllo indicatore di stato di Windows contenuto in un oggetto StatusStrip.
ToolStripDropDownItem	Oggetto ToolStripItem che ospita un ToolStripMenuItemoggetto , ToolStripSplitButtone ToolStripDropDownButton. È ToolStripMenuItem un'opzione selezionabile visualizzata in un menu o in un menu di scelta rapida. Un ToolStripSplitButton è una combinazione di un pulsante normale e di un pulsante a discesa. È ToolStripDropDownButton un pulsante che supporta la funzionalità a discesa.
ToolStripStatusLabel	Pannello in un StatusStrip controllo.

Costruttori

ToolStripItem()	Inizializza una nuova istanza della classe ToolStripItem.
ToolStripItem(String, Image, EventHandler)	Inizializza una nuova istanza della classe ToolStripItem con il nome, l'immagine e il gestore eventi specificati.
ToolStripItem(String, Image, EventHandler, String)	Inizializza una nuova istanza della classe ToolStripItem con il testo, l'immagine, il gestore eventi e il nome specificati.

Proprietà

AccessibilityObject	Ottiene l'oggetto AccessibleObject assegnato al controllo.
AccessibleDefaultActionDescription	Ottiene o imposta la descrizione dell'azione predefinita del controllo usata dalle applicazioni client di accessibilità.
AccessibleDescription	Ottiene o imposta la descrizione che verrà visualizzata alle applicazioni client di accessibilità.
AccessibleName	Ottiene o imposta il nome del controllo usato dalle applicazioni client di accessibilità.
AccessibleRole	Ottiene o imposta il ruolo accessibile del controllo, che specifica il tipo di elemento dell'interfaccia utente del controllo.
Alignment	Ottiene o imposta un valore che indica se l'elemento deve essere allineato verso l'inizio o verso la fine dell'oggetto ToolStrip.
AllowDrop	Ottiene o imposta un valore che indica se le operazioni di trascinamento della selezione e ridisposizione degli elementi devono essere gestite tramite eventi implementati dallo sviluppatore.
Anchor	Ottiene o imposta i bordi del contenitore a cui è associato un oggetto ToolStripItem e determina la modalità con cui un oggetto ToolStripItem viene ridimensionato con il relativo elemento padre.
AutoSize	Ottiene o imposta un valore che indica se l'elemento deve essere ridimensionato automaticamente.
AutoToolTip	Ottiene o imposta un valore che indica se usare la proprietà Text o ToolTipText per la descrizione comando di ToolStripItem ToolTip.
Available	Ottiene o imposta un valore che indica se l'oggetto ToolStripItem deve essere posizionato su ToolStrip.
BackColor	Ottiene o imposta il colore di sfondo dell'elemento.
BackgroundImage	Ottiene o imposta l'immagine di sfondo visualizzata nell'elemento.
BackgroundImageLayout	Ottiene o imposta il layout dell'immagine di sfondo usato per ToolStripItem.
BindingContext	Ottiene o imposta l'insieme di gestori della valuta per l'interfaccia IBindableComponent. (Ereditato da BindableComponent)
Bounds	Ottiene le dimensioni e la posizione dell'elemento.
CanRaiseEvents	Ottiene un valore che indica se il componente può generare un evento. (Ereditato da Component)
CanSelect	Ottiene un valore che indica se l'elemento può essere selezionato.
Command	Ottiene o imposta l'oggetto il ICommand cui Execute(Object) metodo verrà chiamato quando viene richiamato l'evento toolStripItem Click .
CommandParameter	Ottiene o imposta il parametro passato all'oggetto ICommand assegnato alla Command proprietà .
Container	Ottiene l'oggetto IContainer che contiene Component. (Ereditato da Component)
ContentRectangle	Ottiene l'area in cui il contenuto, come testo e icone, può essere posizionato all'interno di un oggetto ToolStripItem senza sovrascrivere i bordi dello sfondo.
DataBindings	Ottiene l'insieme di oggetti di associazione dati per questa interfaccia IBindableComponent. (Ereditato da BindableComponent)
DefaultAutoToolTip	Ottiene un valore che indica se visualizzare l'oggetto ToolTip specificato come valore predefinito.
DefaultDisplayStyle	Ottiene un valore che indica cosa è visualizzato su ToolStripItem.
DefaultMargin	Ottiene il margine predefinito di un elemento.
DefaultPadding	Ottiene le caratteristiche di spaziatura interna dell'elemento.
DefaultSize	Ottiene le dimensioni predefinite dell'elemento.
DesignMode	Ottiene un valore che indica se il Component si trova in modalità progettazione. (Ereditato da Component)
DismissWhenClicked	Ottiene un valore che indica se gli elementi di un oggetto ToolStripDropDown vengono nascosti dopo che si è fatto clic su di essi.
DisplayStyle	Ottiene o imposta se visualizzare o meno testo e immagini su ToolStripItem.
Dock	Ottiene o imposta i bordi di ToolStripItem ancorati al relativo controllo padre e determina la modalità con cui un oggetto ToolStripItem viene ridimensionato con il relativo elemento padre.
DoubleClickEnabled	Ottiene o imposta un valore che indica se l'oggetto ToolStripItem può essere attivato facendo doppio clic con il mouse.
Enabled	Ottiene o imposta un valore che indica se il controllo padre di ToolStripItem è abilitato.
Events	Ottiene l'elenco dei gestori eventi allegati a questo Component. (Ereditato da Component)
Font	Ottiene o imposta il tipo di carattere del testo visualizzato dall'elemento.
ForeColor	Ottiene o imposta il colore primo piano dell'elemento.
Height	Ottiene o imposta l'altezza in pixel di un oggetto ToolStripItem.
Image	Ottiene o imposta l'immagine visualizzata in un oggetto ToolStripItem.
ImageAlign	Ottiene o imposta l'allineamento dell'immagine su ToolStripItem.
ImageIndex	Ottiene o imposta il valore di indice dell'immagine visualizzata sull'elemento.
ImageKey	Ottiene o imposta la funzione di accesso alla chiave per l'immagine contenuta in ImageList visualizzata su ToolStripItem.
ImageScaling	Ottiene o imposta un valore che indica se un'immagine su ToolStripItem viene automaticamente ridimensionata per adattarla a un contenitore.
ImageTransparentColor	Ottiene o imposta il colore da considerare trasparente in un'immagine di ToolStripItem.
IsDisposed	Ottiene un valore che indica se l'oggetto è stato eliminato.
IsOnDropDown	Ottiene un valore che indica se il contenitore dell'oggetto Control corrente è ToolStripDropDown.
IsOnOverflow	Ottiene un valore che indica se la proprietà Placement è impostata su Overflow.
Margin	Ottiene o imposta lo spazio tra l'elemento e gli elementi adiacenti.
MergeAction	Ottiene o imposta il modo in cui i menu figlio vengono uniti ai menu padre.
MergeIndex	Ottiene o imposta la posizione di un elemento unito all'interno dell'oggetto ToolStrip corrente.
Name	Ottiene o imposta il nome dell'elemento.
Overflow	Ottiene o imposta l'elemento associato a ToolStrip o a ToolStripOverflowButton oppure che può spostarsi tra i due.
Owner	Ottiene o imposta il proprietario dell'elemento.
OwnerItem	Ottiene l'elemento padre ToolStripItem di ToolStripItem.
Padding	Ottiene o imposta la spaziatura interna, in pixel, tra il contenuto dell'elemento e i relativi bordi.
Parent	Ottiene o imposta il contenitore padre di ToolStripItem.
Placement	Ottiene il layout corrente dell'elemento.
Pressed	Ottiene un valore che indica se lo stato dell'elemento è premuto.
RightToLeft	Ottiene o imposta un valore che indica se gli elementi devono essere posizionati da destra a sinistra e il testo deve essere scritto da destra a sinistra.
RightToLeftAutoMirrorImage	Crea automaticamente l'immagine speculare di ToolStripItem quando la proprietà RightToLeft è impostata su Yes.
Selected	Ottiene un valore che indica se l'elemento è selezionato.
ShowKeyboardCues	Ottiene un valore che indica se mostrare o nascondere i tasti di scelta rapida.
Site	Ottiene o imposta l'oggetto ISite di Component. (Ereditato da Component)
Size	Ottiene o imposta le dimensioni dell'elemento.
Tag	Ottiene o imposta l'oggetto contenente i dati sull'elemento.
Text	Ottiene o imposta il testo che deve essere visualizzato sull'elemento.
TextAlign	Ottiene o imposta l'allineamento del testo su ToolStripLabel.
TextDirection	Ottiene l'orientamento del testo usato su ToolStripItem.
TextImageRelation	Ottiene o imposta la posizione del testo e dell'immagine di ToolStripItem relativamente l'uno all'altra.
ToolTipText	Ottiene o imposta il testo visualizzato come ToolTip per un controllo.
Visible	Ottiene o imposta un valore che indica se l'elemento è visualizzato.
Width	Ottiene o imposta la larghezza in pixel di ToolStripItem.

Metodi

CreateAccessibilityInstance()	Crea un nuovo oggetto di accessibilità per ToolStripItem.
CreateObjRef(Type)	Consente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto. (Ereditato da MarshalByRefObject)
Dispose()	Rilascia tutte le risorse usate da Component. (Ereditato da Component)
Dispose(Boolean)	Rilascia le risorse non gestite usate da ToolStripItem e, facoltativamente, le risorse gestite.
DoDragDrop(Object, DragDropEffects)	Inizia un'operazione di trascinamento e rilascio.
DoDragDrop(Object, DragDropEffects, Bitmap, Point, Boolean)	Avvia un'operazione di trascinamento.
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetCurrentParent()	Recupera l'oggetto ToolStrip che corrisponde al contenitore dell'oggetto ToolStripItem corrente.
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetLifetimeService()	Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza. (Ereditato da MarshalByRefObject)
GetPreferredSize(Size)	Recupera le dimensioni di un'area rettangolare in grado di contenere il controllo.
GetService(Type)	Consente di restituire un oggetto che rappresenta un servizio fornito da Component o dal relativo Container. (Ereditato da Component)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
InitializeLifetimeService()	Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza. (Ereditato da MarshalByRefObject)
Invalidate()	Invalida l'intera superficie di ToolStripItem e ne determina il ridisegno.
Invalidate(Rectangle)	Invalida l'area specificata dell'oggetto ToolStripItem aggiungendola all'area di aggiornamento di ToolStripItem, ossia quella che verrà ridisegnata alla successiva operazione di disegno, e determina l'invio di un messaggio di disegno a ToolStripItem.
IsInputChar(Char)	Determina se un carattere è un carattere di input riconosciuto dall'elemento.
IsInputKey(Keys)	Determina se il tasto specificato è un normale tasto di input o un tasto speciale che richiede una pre-elaborazione.
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
MemberwiseClone(Boolean)	Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente. (Ereditato da MarshalByRefObject)
OnAvailableChanged(EventArgs)	Genera l'evento AvailableChanged.
OnBackColorChanged(EventArgs)	Genera l'evento BackColorChanged.
OnBindingContextChanged(EventArgs)	Genera l'evento BindingContextChanged. (Ereditato da BindableComponent)
OnBoundsChanged()	Si verifica quando la proprietà Bounds cambia.
OnClick(EventArgs)	Genera l'evento Click.
OnCommandCanExecuteChanged(EventArgs)	Genera l'evento CommandCanExecuteChanged.
OnCommandChanged(EventArgs)	Genera l'evento CommandChanged.
OnCommandParameterChanged(EventArgs)	Genera l'evento CommandParameterChanged.
OnDisplayStyleChanged(EventArgs)	Genera l'evento DisplayStyleChanged.
OnDoubleClick(EventArgs)	Genera l'evento DoubleClick.
OnDragDrop(DragEventArgs)	Genera l'evento DragDrop.
OnDragEnter(DragEventArgs)	Genera l'evento DragEnter.
OnDragLeave(EventArgs)	Genera l'evento DragLeave.
OnDragOver(DragEventArgs)	Genera l'evento DragOver.
OnEnabledChanged(EventArgs)	Genera l'evento EnabledChanged.
OnFontChanged(EventArgs)	Genera l'evento FontChanged.
OnForeColorChanged(EventArgs)	Genera l'evento ForeColorChanged.
OnGiveFeedback(GiveFeedbackEventArgs)	Genera l'evento GiveFeedback.
OnLayout(LayoutEventArgs)	Genera l'evento Layout.
OnLocationChanged(EventArgs)	Genera l'evento LocationChanged.
OnMouseDown(MouseEventArgs)	Genera l'evento MouseDown.
OnMouseEnter(EventArgs)	Genera l'evento MouseEnter.
OnMouseHover(EventArgs)	Genera l'evento MouseHover.
OnMouseLeave(EventArgs)	Genera l'evento MouseLeave.
OnMouseMove(MouseEventArgs)	Genera l'evento MouseMove.
OnMouseUp(MouseEventArgs)	Genera l'evento MouseUp.
OnOwnerChanged(EventArgs)	Genera l'evento OwnerChanged.
OnOwnerFontChanged(EventArgs)	Genera l'evento FontChanged quando la proprietà Font dell'elemento padre di ToolStripItem cambia.
OnPaint(PaintEventArgs)	Genera l'evento Paint.
OnParentBackColorChanged(EventArgs)	Genera l'evento BackColorChanged.
OnParentChanged(ToolStrip, ToolStrip)	Genera l'evento ParentChanged.
OnParentEnabledChanged(EventArgs)	Genera l'evento EnabledChanged quando cambia il valore della proprietà Enabled del contenitore dell'elemento.
OnParentForeColorChanged(EventArgs)	Genera l'evento ForeColorChanged.
OnParentRightToLeftChanged(EventArgs)	Genera l'evento RightToLeftChanged.
OnQueryContinueDrag(QueryContinueDragEventArgs)	Genera l'evento QueryContinueDrag.
OnRequestCommandExecute(EventArgs)	Chiamato nel contesto di OnClick(EventArgs) per richiamare Execute(Object) se il contesto consente.
OnRightToLeftChanged(EventArgs)	Genera l'evento RightToLeftChanged.
OnTextChanged(EventArgs)	Genera l'evento TextChanged.
OnVisibleChanged(EventArgs)	Genera l'evento VisibleChanged.
PerformClick()	Consente di generare un evento Click per un pulsante.ToolStripItem
ProcessCmdKey(Message, Keys)	Elabora un tasto di comando.
ProcessDialogKey(Keys)	Elabora un tasto della finestra di dialogo.
ProcessMnemonic(Char)	Elabora un carattere per il tasto di scelta.
ResetBackColor()	Questo metodo non è pertinente per questa classe.
ResetDisplayStyle()	Questo metodo non è pertinente per questa classe.
ResetFont()	Questo metodo non è pertinente per questa classe.
ResetForeColor()	Questo metodo non è pertinente per questa classe.
ResetImage()	Questo metodo non è pertinente per questa classe.
ResetMargin()	Questo metodo non è pertinente per questa classe.
ResetPadding()	Questo metodo non è pertinente per questa classe.
ResetRightToLeft()	Questo metodo non è pertinente per questa classe.
ResetTextDirection()	Questo metodo non è pertinente per questa classe.
Select()	Seleziona l'elemento.
SetBounds(Rectangle)	Imposta le dimensioni e la posizione dell'elemento.
SetVisibleCore(Boolean)	Imposta il controllo ToolStripItem sullo stato visibile specificato.
ToString()	Restituisce un oggetto String che contiene il nome dell'eventuale oggetto Component. Questo metodo non deve essere sottoposto a override.

Eventi

AvailableChanged	Si verifica quando il valore della proprietà Available cambia.
BackColorChanged	Si verifica quando il valore della proprietà BackColor cambia.
BindingContextChanged	Si verifica quando il contesto di associazione è cambiato. (Ereditato da BindableComponent)
Click	Si verifica quando viene fatto clic sull'oggetto ToolStripItem.
CommandCanExecuteChanged	Si verifica quando lo CanExecute(Object) stato dell'oggetto ICommand assegnato alla Command proprietà è stato modificato.
CommandChanged	Si verifica quando l'oggetto assegnato ICommand della Command proprietà è stato modificato.
CommandParameterChanged	Si verifica quando cambia il valore della proprietà CommandParameter.
DisplayStyleChanged	Si verifica quando viene modificata la proprietà DisplayStyle.
Disposed	Si verifica quando il componente viene eliminato da una chiamata al metodo Dispose(). (Ereditato da Component)
DoubleClick	Si verifica quando viene fatto doppio clic sull'elemento con il mouse.
DragDrop	Si verifica quando l'utente trascina un elemento e rilascia il pulsante del mouse, indicando che l'elemento deve essere rilasciato in questo elemento.
DragEnter	Si verifica quando l'utente trascina un elemento nell'area client di questo elemento.
DragLeave	Si verifica quando l'utente trascina un elemento e il puntatore del mouse non è più posizionato sull'area client di questo elemento.
DragOver	Si verifica quando l'utente trascina un elemento sull'area client di questo elemento.
EnabledChanged	Si verifica quando viene modificato il valore della proprietà Enabled.
ForeColorChanged	Si verifica quando il valore della proprietà ForeColor cambia.
GiveFeedback	Si verifica durante un'operazione di trascinamento.
LocationChanged	Si verifica quando viene aggiornata la posizione di un oggetto ToolStripItem.
MouseDown	Si verifica quando il puntatore del mouse si trova sull'elemento e viene premuto un pulsante del mouse.
MouseEnter	Si verifica quando il puntatore del mouse entra nell'elemento.
MouseHover	Si verifica quando il puntatore del mouse passa sull'elemento.
MouseLeave	Si verifica quando il puntatore del mouse lascia l'elemento.
MouseMove	Si verifica quando il puntatore del mouse viene spostato sull'elemento.
MouseUp	Si verifica quando il puntatore del mouse si trova sull'elemento e viene rilasciato un pulsante del mouse.
OwnerChanged	Si verifica quando la proprietà Owner cambia.
Paint	Si verifica quando l'elemento viene ridisegnato.
QueryAccessibilityHelp	Si verifica quando un'applicazione client di accessibilità richiama la Guida per ToolStripItem.
QueryContinueDrag	Si verifica durante un'operazione di trascinamento della selezione e consente all'origine del trascinamento di determinare se l'operazione deve essere annullata.
RightToLeftChanged	Si verifica quando il valore della proprietà RightToLeft cambia.
TextChanged	Si verifica quando il valore della proprietà Text cambia.
VisibleChanged	Si verifica quando il valore della proprietà Visible cambia.

Implementazioni dell'interfaccia esplicita

IDropTarget.OnDragDrop(DragEventArgs)	Genera l'evento DragDrop.
IDropTarget.OnDragEnter(DragEventArgs)	Genera l'evento DragEnter.
IDropTarget.OnDragLeave(EventArgs)	Genera l'evento DragLeave.
IDropTarget.OnDragOver(DragEventArgs)	Genera l'evento DragOver.

Si applica a

Vedi anche

• ToolStrip
• ToolStripButton
• ToolStripLabel
• ToolStripSeparator
• ToolStripControlHost
• ToolStripComboBox
• ToolStripTextBox
• ToolStripDropDownItem
• ToolStripMenuItem
• ToolStripSplitButton
• ToolStripDropDownButton
• Controllo ToolStrip (Windows Form)