Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese
Questa documentazione è stata archiviata e non viene gestita.

Classe ToolStripItem

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

Spazio dei nomi:  System.Windows.Forms
Assembly:  System.Windows.Forms (in System.Windows.Forms.dll)

public abstract class ToolStripItem : Component, 
	IDropTarget, IComponent, IDisposable

Il tipo ToolStripItem espone i seguenti membri.

  NomeDescrizione
Metodo protettoToolStripItem()Inizializza una nuova istanza della classe ToolStripItem.
Metodo protettoToolStripItem(String, Image, EventHandler)Inizializza una nuova istanza della classe ToolStripItem con il nome, l'immagine e il gestore eventi specificati.
Metodo protettoToolStripItem(String, Image, EventHandler, String)Inizializza una nuova istanza della classe ToolStripItem con il testo di visualizzazione, l'immagine, il gestore eventi e il nome specificati.
In alto

  NomeDescrizione
Proprietà pubblicaAccessibilityObjectOttiene l'oggetto AccessibleObject assegnato al controllo.
Proprietà pubblicaAccessibleDefaultActionDescriptionOttiene o imposta la descrizione dell'azione predefinita del controllo utilizzata dalle applicazioni per l'accessibilità.
Proprietà pubblicaAccessibleDescriptionOttiene o imposta la descrizione che verrà visualizzata alle applicazioni per l'accessibilità.
Proprietà pubblicaAccessibleNameOttiene o imposta il nome del controllo utilizzato dalle applicazioni per l'accessibilità.
Proprietà pubblicaAccessibleRoleOttiene o imposta il ruolo accessibile del controllo, che specifica il tipo di elemento dell'interfaccia utente del controllo.
Proprietà pubblicaAlignmentOttiene o imposta un valore che indica se l'elemento deve essere allineato all'inizio o alla fine di ToolStrip.
Proprietà pubblicaAllowDropOttiene o imposta un valore che indica se le operazioni di trascinamento e di riordinamento degli elementi devono essere gestite tramite eventi implementati dallo sviluppatore.
Proprietà pubblicaAnchorOttiene o imposta i bordi del contenitore a cui è associato un ToolStripItem e determina la modalità con cui un ToolStripItem viene ridimensionato con il relativo elemento padre.
Proprietà pubblicaAutoSizeOttiene o imposta un valore che indica se l'elemento deve essere ridimensionato automaticamente.
Proprietà pubblicaAutoToolTipOttiene o imposta un valore che indica se deve essere utilizzata la proprietà Text o la proprietà ToolTipText per la descrizione comandi di ToolStripItem.
Proprietà pubblicaAvailableOttiene o imposta un valore che indica se l'oggetto ToolStripItem deve essere posizionato in un ToolStrip.
Proprietà pubblicaBackColorOttiene o imposta il colore di sfondo dell'elemento.
Proprietà pubblicaBackgroundImageOttiene o imposta l'immagine di sfondo visualizzata nell'elemento.
Proprietà pubblicaBackgroundImageLayoutOttiene o imposta il layout dell'immagine di sfondo utilizzato per il controllo ToolStripItem.
Proprietà pubblicaBoundsOttiene le dimensioni e la posizione dell'elemento.
Proprietà protetta.CanRaiseEventsOttiene un valore che indica se il componente può generare un evento. (Ereditato da Component)
Proprietà pubblicaCanSelectOttiene un valore che indica se l'elemento può essere selezionato.
Proprietà pubblicaContainerOttiene il IContainer che contiene il Component. (Ereditato da Component)
Proprietà pubblicaContentRectangleOttiene l'area il cui contenuto, ad esempio testo e icone, può essere posizionato all'interno di un elemento ToolStripItem senza sovrascrivere i bordi dello sfondo.
Proprietà protetta.DefaultAutoToolTipOttiene un valore che indica se deve essere visualizzato l'oggetto ToolTip definito come valore predefinito.
Proprietà protetta.DefaultDisplayStyleOttiene un valore che indica cosa deve essere visualizzato nell'elemento ToolStripItem.
Proprietà protetta.DefaultMarginOttiene il margine predefinito di un elemento.
Proprietà protetta.DefaultPaddingOttiene le caratteristiche di spaziatura interna dell'elemento.
Proprietà protetta.DefaultSizeOttiene le dimensioni predefinite dell'elemento.
Proprietà protetta.DesignModeOttiene un valore che indica se il Component si trova in modalità progettazione. (Ereditato da Component)
Proprietà protetta.DismissWhenClickedOttiene un valore che indica se gli elementi di un oggetto ToolStripDropDown devono essere nascosti dopo che è stato fatto clic su di essi.
Proprietà pubblicaDisplayStyleOttiene o imposta se il testo e le immagini devono essere visualizzati in un elemento ToolStripItem.
Proprietà pubblicaDockOttiene o imposta i bordi di ToolStripItem ancorati al relativo controllo padre e determina la modalità con cui un ToolStripItem viene ridimensionato con il relativo controllo padre.
Proprietà pubblicaDoubleClickEnabledOttiene o imposta un valore che indica se l'elemento ToolStripItem può essere attivato facendo doppio clic con il mouse.
Proprietà pubblicaEnabledOttiene o imposta un valore che indica se il controllo padre di ToolStripItem deve essere abilitato.
Proprietà protetta.EventsOttiene l'elenco dei gestori eventi allegati a questo Component. (Ereditato da Component)
Proprietà pubblicaFontOttiene o imposta il carattere del testo visualizzato dall'elemento.
Proprietà pubblicaForeColorOttiene o imposta il colore di primo piano dell'elemento.
Proprietà pubblicaHeightOttiene o imposta l'altezza, in pixel, di un elemento ToolStripItem.
Proprietà pubblicaImageOttiene o imposta l'immagine visualizzata in un controllo ToolStripItem.
Proprietà pubblicaImageAlignOttiene o imposta l'allineamento dell'immagine in un elemento ToolStripItem.
Proprietà pubblicaImageIndexOttiene o imposta il valore di indice dell'immagine visualizzata nell'elemento.
Proprietà pubblicaImageKeyOttiene o imposta la funzione di accesso al tasto per l'immagine in ImageList visualizzata in un elemento ToolStripItem.
Proprietà pubblicaImageScalingOttiene o imposta un valore che indica se un'immagine in un elemento ToolStripItem deve essere ridimensionata automaticamente per adattarla alle dimensioni di un contenitore.
Proprietà pubblicaImageTransparentColorOttiene o imposta il colore da considerare trasparente in un'immagine di ToolStripItem.
Proprietà pubblicaIsDisposedOttiene un valore che indica se l'oggetto è stato eliminato.
Proprietà pubblicaIsOnDropDownOttiene un valore che indica se il contenitore del controllo Control corrente è un oggetto ToolStripDropDown.
Proprietà pubblicaIsOnOverflowOttiene un valore che indica se la proprietà Placement è impostata su Overflow.
Proprietà pubblicaMarginOttiene o imposta lo spazio tra l'elemento e gli elementi adiacenti.
Proprietà pubblicaMergeActionOttiene o imposta il modo in cui i menu figlio devono essere uniti ai menu padre.
Proprietà pubblicaMergeIndexOttiene o imposta la posizione di un elemento unito all'interno dell'elemento ToolStrip corrente.
Proprietà pubblicaNameOttiene o imposta il nome dell'elemento.
Proprietà pubblicaOverflowOttiene o imposta se l'elemento deve essere associato a ToolStrip o ToolStripOverflowButton oppure può spostarsi tra i due oggetti.
Proprietà pubblicaOwnerOttiene o imposta il proprietario dell'elemento.
Proprietà pubblicaOwnerItemOttiene l'oggetto ToolStripItem padre dell'oggetto ToolStripItem.
Proprietà pubblicaPaddingOttiene o imposta la spaziatura interna, in pixel, tra il contenuto dell'elemento e i relativi bordi.
Proprietà protetta.ParentOttiene o imposta il contenitore padre dell'elemento ToolStripItem.
Proprietà pubblicaPlacementOttiene il layout corrente dell'elemento.
Proprietà pubblicaPressedOttiene un valore che indica se lo stato dell'elemento è attivo.
Proprietà pubblicaRightToLeftOttiene 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.
Proprietà pubblicaRightToLeftAutoMirrorImageEsegue automaticamente il mirroring dell'immagine di ToolStripItem quando la proprietà RightToLeft è impostata su Yes.
Proprietà pubblicaSelectedOttiene un valore che indica se l'elemento deve essere selezionato.
Proprietà protetta.ShowKeyboardCuesOttiene un valore che indica se visualizzare o nascondere i tasti di scelta rapida.
Proprietà pubblicaSiteOttiene o imposta il ISite del Component. (Ereditato da Component)
Proprietà pubblicaSizeOttiene o imposta le dimensioni dell'elemento.
Proprietà pubblicaTagOttiene o imposta l'oggetto che contiene i dati relativi all'elemento.
Proprietà pubblicaTextOttiene o imposta il testo che deve essere visualizzato nell'elemento.
Proprietà pubblicaTextAlignOttiene o imposta l'allineamento del testo in un controllo ToolStripLabel.
Proprietà pubblicaTextDirectionOttiene l'orientamento del testo utilizzato in un elemento ToolStripItem.
Proprietà pubblicaTextImageRelationOttiene o imposta la posizione relativa del testo e dell'immagine di ToolStripItem.
Proprietà pubblicaToolTipTextOttiene o imposta il testo visualizzato come ToolTip per un controllo.
Proprietà pubblicaVisibleOttiene o imposta un valore che indica se l'elemento deve essere visualizzato.
Proprietà pubblicaWidthOttiene o imposta la larghezza, in pixel, di un elemento ToolStripItem.
In alto

  NomeDescrizione
Metodo protettoCreateAccessibilityInstanceCrea un nuovo oggetto di accessibilità per ToolStripItem.
Metodo pubblicoCreateObjRefConsente 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)
Metodo pubblicoDispose()Libera tutte le risorse utilizzate da Component. (Ereditato da Component)
Metodo protettoDispose(Boolean)Rilascia le risorse non gestite utilizzate da ToolStripItem ed, eventualmente, anche le risorse gestite. (Esegue l'override di Component.Dispose(Boolean)).
Metodo pubblicoDoDragDropConsente di iniziare un'operazione di trascinamento.
Metodo pubblicoEquals(Object)Determina se l'oggetto Object specificato è uguale all'oggetto Object corrente. (Ereditato da Object)
Metodo protettoFinalizeLibera risorse non gestite ed esegue altre operazioni di pulitura prima che Component sia recuperato dalla procedura di Garbage Collection. (Ereditato da Component)
Metodo pubblicoGetCurrentParentRecupera l'oggetto ToolStrip che corrisponde al contenitore dell'elemento ToolStripItem corrente.
Metodo pubblicoGetHashCodeFunge da funzione hash per un determinato tipo. (Ereditato da Object)
Metodo pubblicoGetLifetimeServiceConsente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza. (Ereditato da MarshalByRefObject)
Metodo pubblicoGetPreferredSizeRecupera le dimensioni di un'area rettangolare in grado di contenere il controllo.
Metodo protettoGetServiceConsente di restituire un oggetto che rappresenta un servizio fornito da Component o dal relativo Container. (Ereditato da Component)
Metodo pubblicoGetTypeOttiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
Metodo pubblicoInitializeLifetimeServiceConsente di ottenere un oggetto servizio di durata per il controllo dei criteri di durata per l'istanza. (Ereditato da MarshalByRefObject)
Metodo pubblicoInvalidate()Consente di invalidare l'intera superficie della classe ToolStripItem e ne determina il ridisegno.
Metodo pubblicoInvalidate(Rectangle)Consente di invalidare l'area specificata della classe ToolStripItem aggiungendola all'area di aggiornamento della classe ToolStripItem, ossia all'area che verrà ridisegnata durante la successiva operazione di disegno, e fa sì che venga inviato un messaggio di disegno alla classe ToolStripItem.
Metodo protettoIsInputCharDetermina se un carattere è un carattere di input riconosciuto dall'elemento.
Metodo protettoIsInputKeyDetermina se il tasto specificato è un normale tasto di input o un tasto speciale, che richiede una pre-elaborazione.
Metodo protettoMemberwiseClone()Consente di creare una copia dei riferimenti dell'oggetto Object corrente. (Ereditato da Object)
Metodo protettoMemberwiseClone(Boolean)Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente. (Ereditato da MarshalByRefObject)
Metodo protettoOnAvailableChangedGenera l'evento AvailableChanged.
Metodo protettoOnBackColorChangedGenera l'evento BackColorChanged.
Metodo protettoOnBoundsChangedSi verifica quando la proprietà Bounds viene modificata.
Metodo protettoOnClickGenera l'evento Click.
Metodo protettoOnDisplayStyleChangedGenera l'evento DisplayStyleChanged.
Metodo protettoOnDoubleClickGenera l'evento DoubleClick.
Metodo protettoOnDragDropGenera l'evento DragDrop.
Metodo protettoOnDragEnterGenera l'evento DragEnter.
Metodo protettoOnDragLeaveGenera l'evento DragLeave.
Metodo protettoOnDragOverGenera l'evento DragOver.
Metodo protettoOnEnabledChangedGenera l'evento EnabledChanged.
Metodo protettoOnFontChangedGenera l'evento FontChanged.
Metodo protettoOnForeColorChangedGenera l'evento ForeColorChanged.
Metodo protettoOnGiveFeedbackGenera l'evento GiveFeedback.
Metodo protettoOnLayoutGenera l'evento Layout.
Metodo protettoOnLocationChangedGenera l'evento LocationChanged.
Metodo protettoOnMouseDownGenera l'evento MouseDown.
Metodo protettoOnMouseEnterGenera l'evento MouseEnter.
Metodo protettoOnMouseHoverGenera l'evento MouseHover.
Metodo protettoOnMouseLeaveGenera l'evento MouseLeave.
Metodo protettoOnMouseMoveGenera l'evento MouseMove.
Metodo protettoOnMouseUpGenera l'evento MouseUp.
Metodo protettoOnOwnerChangedGenera l'evento OwnerChanged.
Metodo protettoOnOwnerFontChangedGenera l'evento FontChanged quando cambia la proprietà Font sul padre di ToolStripItem.
Metodo protettoOnPaintGenera l'evento Paint.
Metodo protettoOnParentBackColorChangedGenera l'evento BackColorChanged.
Metodo protettoOnParentChangedGenera l'evento ParentChanged.
Metodo protettoOnParentEnabledChangedGenera l'evento EnabledChanged quando cambia il valore della proprietà Enabled del contenitore dell'elemento.
Metodo protettoOnParentForeColorChangedGenera l'evento ForeColorChanged.
Metodo protettoOnParentRightToLeftChangedGenera l'evento RightToLeftChanged.
Metodo protettoOnQueryContinueDragGenera l'evento QueryContinueDrag.
Metodo protettoOnRightToLeftChangedGenera l'evento RightToLeftChanged.
Metodo protettoOnTextChangedGenera l'evento TextChanged.
Metodo protettoOnVisibleChangedGenera l'evento VisibleChanged.
Metodo pubblicoPerformClickAttiva l'oggetto ToolStripItem quando viene fatto clic con il mouse.
Metodo protettoProcessCmdKeyConsente di elaborare un tasto di comando.
Metodo protettoProcessDialogKeyElabora un tasto della finestra di dialogo.
Metodo protettoProcessMnemonicElabora un carattere per i tasti di scelta rapida.
Metodo pubblicoResetBackColorInfrastruttura. Questo metodo non è pertinente per questa classe.
Metodo pubblicoResetDisplayStyleInfrastruttura. Questo metodo non è pertinente per questa classe.
Metodo pubblicoResetFontInfrastruttura. Questo metodo non è pertinente per questa classe.
Metodo pubblicoResetForeColorInfrastruttura. Questo metodo non è pertinente per questa classe.
Metodo pubblicoResetImageInfrastruttura. Questo metodo non è pertinente per questa classe.
Metodo pubblicoResetMarginInfrastruttura. Questo metodo non è pertinente per questa classe.
Metodo pubblicoResetPaddingInfrastruttura. Questo metodo non è pertinente per questa classe.
Metodo pubblicoResetRightToLeftInfrastruttura. Questo metodo non è pertinente per questa classe.
Metodo pubblicoResetTextDirectionInfrastruttura. Questo metodo non è pertinente per questa classe.
Metodo pubblicoSelectSeleziona l'elemento.
Metodo protettoSetBoundsImposta le dimensioni e la posizione dell'elemento.
Metodo protettoSetVisibleCoreImposta ToolStripItem sullo stato visibile specificato.
Metodo pubblicoToStringRestituisce un oggetto String contenente il nome dell'oggetto Component, se presente. Non è consigliabile eseguire l'override di questo metodo. (Esegue l'override di Component.ToString()).
In alto

  NomeDescrizione
Evento pubblicoAvailableChangedSi verifica quando cambia il valore della proprietà Available.
Evento pubblicoBackColorChangedSi verifica quando cambia il valore della proprietà BackColor.
Evento pubblicoClickSi verifica quando viene fatto clic sull'oggetto ToolStripItem.
Evento pubblicoDisplayStyleChangedViene generato quando è stata modificata la proprietà DisplayStyle.
Evento pubblicoDisposedSi verifica quando il componente viene eliminato da una chiamata al metodo Dispose. (Ereditato da Component)
Evento pubblicoDoubleClickSi verifica quando viene fatto doppio clic sull'elemento con il mouse.
Evento pubblicoDragDropSi verifica quando un elemento viene trascinato e il pulsante del mouse rilasciato, indicando che l'elemento deve essere rilasciato in questo elemento.
Evento pubblicoDragEnterSi verifica quando l'utente trascina un elemento nell'area client di questo elemento.
Evento pubblicoDragLeaveSi verifica quando un elemento viene trascinato e il puntatore del mouse non è più posizionato sull'area client di questo elemento.
Evento pubblicoDragOverSi verifica quando si trascina un elemento nell'area client di questo elemento.
Evento pubblicoEnabledChangedViene generato quando si modifica il valore della proprietà Enabled.
Evento pubblicoForeColorChangedSi verifica quando cambia il valore della proprietà ForeColor.
Evento pubblicoGiveFeedbackViene generato durante un'operazione di trascinamento.
Evento pubblicoLocationChangedSi verifica quando viene aggiornata la posizione di un elemento ToolStripItem.
Evento pubblicoMouseDownSi verifica quando il puntatore del mouse si trova sull'elemento e viene premuto un pulsante del mouse.
Evento pubblicoMouseEnterSi verifica quando il puntatore del mouse entra nell'elemento.
Evento pubblicoMouseHoverSi verifica quando il puntatore del mouse viene posizionato sull'elemento.
Evento pubblicoMouseLeaveSi verifica quando il puntatore del mouse esce dall'elemento.
Evento pubblicoMouseMoveSi verifica quando il puntatore del mouse viene spostato sull'elemento.
Evento pubblicoMouseUpSi verifica quando il puntatore del mouse si trova sull'elemento e viene rilasciato un pulsante del mouse.
Evento pubblicoOwnerChangedSi verifica quando cambia il valore della proprietà Owner.
Evento pubblicoPaintSi verifica quando l'elemento viene ridisegnato.
Evento pubblicoQueryAccessibilityHelpSi verifica quando un'applicazione per l'accessibilità richiama la Guida per l'elemento ToolStripItem.
Evento pubblicoQueryContinueDragViene generato durante un'operazione di trascinamento e consente all'origine del trascinamento di determinare se l'operazione deve essere annullata.
Evento pubblicoRightToLeftChangedSi verifica quando cambia il valore della proprietà RightToLeft.
Evento pubblicoTextChangedSi verifica quando cambia il valore della proprietà Text.
Evento pubblicoVisibleChangedSi verifica quando cambia il valore della proprietà Visible.
In alto

ToolStripItem è un elemento, ad esempio un pulsante, una casella combinata, una casella di testo o un'etichetta, che può essere contenuto in un controllo ToolStrip o ToolStripDropDown. Questo oggetto è simile a un menu di scelta rapida di Windows. La classe ToolStrip gestisce le operazioni di disegno e l'input della tastiera e del mouse, compreso l'input mediante trascinamento della selezione, per tali elementi, mentre la classe ToolStripItem gestisce gli eventi e il layout all'interno degli elementi stessi.

Le classi ToolStripItem ereditano direttamente da ToolStripItem o indirettamente da ToolStripItem tramite ToolStripControlHost o ToolStripDropDownItem.

I controlli ToolStripItem devono essere contenuti in un controllo ToolStrip, MenuStrip, StatusStrip o ContextMenuStrip e non possono essere aggiunti direttamente a un form. Le varie classi di contenitori sono progettate per contenere un sottoinsieme appropriato di controlli ToolStripItem.

Nota   Un determinato controllo ToolStripItem non può avere più di un controllo ToolStrip padre. È necessario copiare il controllo ToolStripItem e aggiungerlo agli altri controlli ToolStrip.

Nella tabella riportata di seguito sono visualizzati gli elementi che derivano dalla classe ToolStripItem e che, pertanto, possono essere contenuti in un oggetto ToolStrip o ToolStripDropDown.

Elemento

Oggetto di descrizione

ToolStripButton

Pulsante della barra degli strumenti che supporta immagini e testo.

ToolStripLabel

Etichetta di testo in genere utilizzata in una barra di stato o in un controllo ToolStrip come commento o titolo.

ToolStripSeparator

Area non selezionabile oppure area con una barra verticale in cui sono raggruppati visivamente gli elementi.

ToolStripControlHost

Oggetto ToolStripItem che contiene un ToolStripComboBox, ToolStripTextBox, ToolStripProgressBar, altri controlli Windows Form o controlli personalizzati.

Un elemento ToolStripComboBox è costituito da una casella di testo in cui l'utente può immettere del testo e da un elenco che può essere utilizzato dall'utente per selezionare il testo da inserire nella casella di testo.

Un elemento ToolStripTextBox consente all'utente di immettere del testo.

Oggetto ToolStripProgressBar che rappresenta un controllo indicatore di stato di Windows contenuto in un oggetto StatusStrip.

ToolStripDropDownItem

Oggetto ToolStripItem che contiene un elemento ToolStripMenuItem, un elemento ToolStripSplitButton e un elemento ToolStripDropDownButton.

Un elemento ToolStripMenuItem è un'opzione selezionabile visualizzata in un menu o in un menu di scelta rapida.

Un elemento ToolStripSplitButton è costituito dalla combinazione di un normale pulsante e un pulsante a discesa.

Un elemento ToolStripDropDownButton è un pulsante che supporta la funzionalità a discesa.

ToolStripStatusLabel

Pannello in un controllo StatusStrip.

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


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

}


.NET Framework

Supportato in: 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Supportato in: 4, 3.5 SP1

Windows 7, Windows Vista SP1 o versione successiva, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (componenti di base del server non supportati), Windows Server 2008 R2 (componenti di base del server supportati con SP1 o versione successiva), Windows Server 2003 SP2

.NET Framework non supporta tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

Qualsiasi membro static (Shared in Visual Basic) pubblico di questo tipo è thread-safe. I membri di istanza non sono garantiti come thread-safe.
Mostra: