ToolboxItem Classe

Definizione

Spazio dei nomi:

System.Drawing.Design

Assembly:

System.Windows.Forms.Design.dll

Fornisce un'implementazione base di un elemento della casella degli strumenti.

C#

public class ToolboxItem : System.Runtime.Serialization.ISerializable

Ereditarietà

Object

ToolboxItem

Derivato

System.Web.UI.Design.WebControlToolboxItem

System.Workflow.ComponentModel.Design.ActivityToolboxItem

Implementazioni

ISerializable

Esempio

Nell'esempio di codice seguente viene fornito un componente che usa l'interfaccia IToolboxService per aggiungere un gestore di formato dati di testo o ToolboxItemCreatorCallback, alla casella degli strumenti. Il delegato di callback dell'autore dei dati passa tutti i dati di testo incollati alla casella degli strumenti e trascinati in un modulo a un oggetto personalizzato ToolboxItem che crea un TextBox oggetto contenente il testo.

C#

using System;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Drawing;
using System.Drawing.Design;
using System.Security.Permissions;
using System.Windows.Forms;

namespace TextDataTextBoxComponent
{
    // Component that adds a "Text" data format ToolboxItemCreatorCallback 
    // to the Toolbox. This component uses a custom ToolboxItem that 
    // creates a TextBox containing the text data.
    public class TextDataTextBoxComponent : Component
    {
        private bool creatorAdded = false;
        private IToolboxService ts;

        public TextDataTextBoxComponent()
        {                     
        }

        // ISite override to register TextBox creator
        public override System.ComponentModel.ISite Site
        {
            get
            {
                return base.Site;
            }
            set
            {
                if( value != null )
                {                    
                    base.Site = value;

                    if (!creatorAdded)
                    {
                        AddTextTextBoxCreator();
                    }
                }
                else
                {
                    if (creatorAdded)
                    {
                        RemoveTextTextBoxCreator();
                    }

                    base.Site = value;             
                }
            }
        }

        // Adds a "Text" data format creator to the toolbox that creates 
        // a textbox from a text fragment pasted to the toolbox.
        private void AddTextTextBoxCreator()
        {
            ts = (IToolboxService)GetService(typeof(IToolboxService));

            if (ts != null) 
            {
                ToolboxItemCreatorCallback textCreator = 
                    new ToolboxItemCreatorCallback(this.CreateTextBoxForText);

                try
                {
                    ts.AddCreator(
                        textCreator, 
                        "Text", 
                        (IDesignerHost)GetService(typeof(IDesignerHost)));

                    creatorAdded = true;
                }
                catch(Exception ex)
                {
                    MessageBox.Show(
                        ex.ToString(), 
                        "Exception Information");
                }                
            }
        }

        // Removes any "Text" data format creator from the toolbox.
        private void RemoveTextTextBoxCreator()
        {
            if (ts != null)             
            {
                ts.RemoveCreator(
                    "Text", 
                    (IDesignerHost)GetService(typeof(IDesignerHost)));            

                creatorAdded = false;
            }
        }

        // ToolboxItemCreatorCallback delegate format method to create 
        // the toolbox item.
        private ToolboxItem CreateTextBoxForText(
            object serializedObject, 
            string format)
        {
            DataObject o = new DataObject((IDataObject)serializedObject);

            string[] formats = o.GetFormats();

            if (o.GetDataPresent("System.String", true))
            {
                string toolboxText = (string)(o.GetData("System.String", true));
                return (new TextToolboxItem(toolboxText));
            }

            return null;
        }

        protected override void Dispose(bool disposing)
        {
            if (creatorAdded)
            {
                RemoveTextTextBoxCreator();
            }
        }        
    }

    // Custom toolbox item creates a TextBox and sets its Text property
    // to the constructor-specified text.
    public class TextToolboxItem : ToolboxItem
    {
        private string text;
        private delegate void SetTextMethodHandler(Control c, string text);

        public TextToolboxItem(string text) : base()
        {
            this.text = text;
        }

        // ToolboxItem.CreateComponentsCore override to create the TextBox 
        // and link a method to set its Text property.
        protected override IComponent[] CreateComponentsCore(IDesignerHost host)
        {
            System.Windows.Forms.TextBox textbox = 
                (TextBox)host.CreateComponent(typeof(TextBox));
                
            // Because the designer resets the text of the textbox, use 
            // a SetTextMethodHandler to set the text to the value of 
            // the text data.
            Control c = host.RootComponent as Control;
            c.BeginInvoke(
                new SetTextMethodHandler(OnSetText), 
                new object[] {textbox, text});
           
            return new System.ComponentModel.IComponent[] { textbox };
        }        

        // Method to set the text property of a TextBox after it is initialized.
        private void OnSetText(Control c, string text) 
        {
            c.Text = text;
        }
    }
}

Nell'esempio di codice seguente viene illustrato l'uso della classe come classe di base per un'implementazione personalizzata dell'elemento ToolboxItem della casella degli strumenti.

C#

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Design;
using System.Data;
using System.Runtime.Serialization;
using System.Text;
using System.Windows.Forms;

namespace CustomToolboxItem
{
    public class Form1 : Form
    {
        private System.ComponentModel.IContainer components = null;
        private UserControl1 userControl11;
        private System.Windows.Forms.Label label1;

        public Form1()
        {
            InitializeComponent();
        }

        private void InitializeComponent()
        {
            this.label1 = new System.Windows.Forms.Label();
            this.userControl11 = new CustomToolboxItem.UserControl1();
            this.SuspendLayout();
            // 
            // label1
            // 
            this.label1.Location = new System.Drawing.Point(15, 16);
            this.label1.Name = "label1";
            this.label1.Size = new System.Drawing.Size(265, 62);
            this.label1.TabIndex = 0;
            this.label1.Text = "Build the project and drop UserControl1 from the toolbox onto the form.";
            // 
            // userControl11
            // 
            this.userControl11.LabelText = "This is a custom user control.  The text you see here is provided by a custom too" +
                "lbox item when the user control is dropped on the form.";
            this.userControl11.Location = new System.Drawing.Point(74, 81);
            this.userControl11.Name = "userControl11";
            this.userControl11.Padding = new System.Windows.Forms.Padding(6);
            this.userControl11.Size = new System.Drawing.Size(150, 150);
            this.userControl11.TabIndex = 1;
            // 
            // Form1
            // 
            this.ClientSize = new System.Drawing.Size(292, 266);
            this.Controls.Add(this.userControl11);
            this.Controls.Add(this.label1);
            this.Name = "Form1";
            this.Text = "Form1";
            this.ResumeLayout(false);
        }

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

        static void Main()
        {
            Application.EnableVisualStyles();
            Application.Run(new Form1());
        }
    }

    // Configure this user control to have a custom toolbox item.
    [ToolboxItem(typeof(MyToolboxItem))]
    public class UserControl1 : UserControl
    {
        private System.ComponentModel.IContainer components = null;
        private System.Windows.Forms.Label label1;

        public UserControl1()
        {
            InitializeComponent();
        }

        public string LabelText
        {
            get
            {
                return label1.Text;
            }
            set
            {
                label1.Text = value;
            }
        }

        private void InitializeComponent()
        {
            this.label1 = new System.Windows.Forms.Label();
            this.SuspendLayout();
            // 
            // label1
            // 
            this.label1.Dock = System.Windows.Forms.DockStyle.Fill;
            this.label1.Location = new System.Drawing.Point(6, 6);
            this.label1.Name = "label1";
            this.label1.Size = new System.Drawing.Size(138, 138);
            this.label1.TabIndex = 0;
            this.label1.Text = "This is a custom user control.  " + 
                "The text you see here is provided by a custom toolbox" +
                " item when the user control is dropped on the form.\r\n";
            this.label1.TextAlign = 
                System.Drawing.ContentAlignment.MiddleCenter;
            // 
            // UserControl1
            // 
            this.Controls.Add(this.label1);
            this.Name = "UserControl1";
            this.Padding = new System.Windows.Forms.Padding(6);
            this.ResumeLayout(false);
        }

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

    // Toolbox items must be serializable.
    [Serializable]
    class MyToolboxItem : ToolboxItem
    {
        // The add components dialog in Visual Studio looks for a public
        // constructor that takes a type.
        public MyToolboxItem(Type toolType)
            : base(toolType)
        {
        }

        // And you must provide this special constructor for serialization.
        // If you add additional data to MyToolboxItem that you
        // want to serialize, you may override Deserialize and
        // Serialize methods to add that data.  
        MyToolboxItem(SerializationInfo info, StreamingContext context)
        {
            Deserialize(info, context);
        }

        // Let's override the creation code and pop up a dialog.
        protected override IComponent[] CreateComponentsCore(
            System.ComponentModel.Design.IDesignerHost host, 
            System.Collections.IDictionary defaultValues)
        {
            // Get the string we want to fill in the custom
            // user control.  If the user cancels out of the dialog,
            // return null or an empty array to signify that the 
            // tool creation was canceled.
            using (ToolboxItemDialog d = new ToolboxItemDialog())
            {
                if (d.ShowDialog() == DialogResult.OK)
                {
                    string text = d.CreationText;

                    IComponent[] comps =
                        base.CreateComponentsCore(host, defaultValues);
                    // comps will have a single component: our data type.
                    ((UserControl1)comps[0]).LabelText = text;
                    return comps;
                }
                else
                {
                    return null;
                }
            }
        }
    }

    public class ToolboxItemDialog : Form
    {
        private System.ComponentModel.IContainer components = null;
        private System.Windows.Forms.Label label1;
        private System.Windows.Forms.TextBox textBox1;
        private System.Windows.Forms.Button button1;
        private System.Windows.Forms.Button button2;

        public ToolboxItemDialog()
        {
            InitializeComponent();
        }

        private void InitializeComponent()
        {
            this.label1 = new System.Windows.Forms.Label();
            this.textBox1 = new System.Windows.Forms.TextBox();
            this.button1 = new System.Windows.Forms.Button();
            this.button2 = new System.Windows.Forms.Button();
            this.SuspendLayout();
            // 
            // label1
            // 
            this.label1.Location = new System.Drawing.Point(10, 9);
            this.label1.Name = "label1";
            this.label1.Size = new System.Drawing.Size(273, 43);
            this.label1.TabIndex = 0;
            this.label1.Text = "Enter the text you would like" + 
                " to have the user control populated with:";
            // 
            // textBox1
            // 
            this.textBox1.AutoSize = false;
            this.textBox1.Location = new System.Drawing.Point(10, 58);
            this.textBox1.Multiline = true;
            this.textBox1.Name = "textBox1";
            this.textBox1.Size = new System.Drawing.Size(270, 67);
            this.textBox1.TabIndex = 1;
            this.textBox1.Text = "This is a custom user control.  " + 
                "The text you see here is provided by a custom toolbox" +
                " item when the user control is dropped on the form.";
            // 
            // button1
            // 
            this.button1.DialogResult = System.Windows.Forms.DialogResult.OK;
            this.button1.Location = new System.Drawing.Point(124, 131);
            this.button1.Name = "button1";
            this.button1.TabIndex = 2;
            this.button1.Text = "OK";
            // 
            // button2
            // 
            this.button2.DialogResult = System.Windows.Forms.DialogResult.Cancel;
            this.button2.Location = new System.Drawing.Point(205, 131);
            this.button2.Name = "button2";
            this.button2.TabIndex = 3;
            this.button2.Text = "Cancel";
            // 
            // ToolboxItemDialog
            // 
            this.AcceptButton = this.button1;
            this.CancelButton = this.button2;
            this.ClientSize = new System.Drawing.Size(292, 162);
            this.ControlBox = false;
            this.Controls.Add(this.button2);
            this.Controls.Add(this.button1);
            this.Controls.Add(this.textBox1);
            this.Controls.Add(this.label1);
            this.FormBorderStyle = 
                System.Windows.Forms.FormBorderStyle.FixedDialog;
            this.Name = "ToolboxItemDialog";
            this.Text = "ToolboxItemDialog";
            this.ResumeLayout(false);
        }

        public string CreationText
        {
            get
            {
                return textBox1.Text;
            }
        }

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

Commenti

ToolboxItem è una classe di base per gli elementi della casella degli strumenti che possono essere visualizzati nella casella degli strumenti di un ambiente in fase di progettazione. Un elemento della casella degli strumenti rappresenta in genere un componente da creare quando viene richiamato in un documento in modalità progettazione. La ToolboxItem classe fornisce i metodi e le proprietà necessarie per fornire alla casella degli strumenti le proprietà di visualizzazione per l'elemento della casella degli strumenti, per creare un componente o componenti quando usato e serializzare e deserializzare se stesso per la persistenza all'interno del database della casella degli strumenti.

Un'istanza ToolboxItem della classe può essere configurata con un nome, una bitmap e un tipo da creare, senza creare una classe che deriva da ToolboxItem. La ToolboxItem classe fornisce anche una classe di base per le implementazioni personalizzate degli elementi della casella degli strumenti. Un oggetto personalizzato ToolboxItem può creare più componenti. Per implementare un elemento della casella degli strumenti personalizzato, è necessario derivare da ToolboxItem e eseguire l'override dei CreateComponentsCoremetodi , Serializee Deserialize .

Le proprietà e i metodi seguenti devono essere configurati per una ToolboxItem funzione corretta:

• La DisplayName proprietà specifica l'etichetta per l'elemento della casella degli strumenti quando viene visualizzata in una casella degli strumenti.

• La TypeName proprietà specifica il nome completo del tipo del componente creato dall'elemento. Se una classe derivata crea più componenti, la TypeName proprietà può o meno essere usata, a seconda che un CreateComponentsCore metodo venga sottoposto a override dipende dal valore di questa proprietà.

• La AssemblyName proprietà specifica l'assembly contenente il tipo di un componente creato dall'elemento.

• La Bitmap proprietà specifica facoltativamente un'immagine bitmap da visualizzare accanto al nome visualizzato per l'elemento della casella degli strumenti nella casella degli strumenti.

• La Filter proprietà contiene facoltativamente tutti gli ToolboxItemFilterAttribute oggetti che determinano se l'elemento della casella degli strumenti può essere usato in un determinato componente.

• Il CreateComponentsCore metodo restituisce l'istanza del componente o le istanze da inserire in cui viene usato questo strumento.

• Il Serialize metodo salva l'elemento della casella degli strumenti in un oggetto specificato SerializationInfo.

• Il Deserialize metodo configura l'elemento della casella degli strumenti dalle informazioni sullo stato contenute nell'oggetto specificato SerializationInfo.

• Il Initialize metodo configura l'elemento della casella degli strumenti per creare il tipo specificato di componente, se il CreateComponentsCore metodo non è stato sottoposto a override in modo diverso.

• La Locked proprietà indica se è possibile modificare le proprietà dell'elemento della casella degli strumenti. Un elemento della casella degli strumenti viene in genere bloccato dopo l'aggiunta a una casella degli strumenti.

• Il Lock metodo blocca un elemento della casella degli strumenti.

• Il CheckUnlocked metodo genera un'eccezione se la Locked proprietà è true.

Costruttori

ToolboxItem()	Inizializza una nuova istanza della classe ToolboxItem.
ToolboxItem(Type)	Inizializza una nuova istanza della classe ToolboxItem che consente di creare il tipo di componente specificato.

Proprietà

AssemblyName	Ottiene o imposta il nome dell'assembly che contiene il tipo o i tipi creati dall'elemento della casella di controllo.
Bitmap	Ottiene o imposta un'immagine bitmap per rappresentare l'elemento della casella degli strumenti.
Company	Ottiene o imposta il nome della società per questa classe ToolboxItem.
ComponentType	Ottiene il tipo di componente per questa classe ToolboxItem.
DependentAssemblies	Ottiene o imposta la classe AssemblyName per l'elemento della casella degli strumenti.
Description	Ottiene o imposta la descrizione per questa classe ToolboxItem.
DisplayName	Ottiene o imposta il nome visualizzato per l'elemento della casella degli strumenti.
Filter	Ottiene o imposta il filtro che determina se l'elemento della casella degli strumenti può essere usato su un componente di destinazione.
IsTransient	Ottiene un valore che indica se l'elemento della casella degli strumenti è temporaneo.
Locked	Ottiene un valore che indica se l'oggetto ToolboxItem è attualmente bloccato.
OriginalBitmap	Ottiene o imposta la bitmap originale che verrà usata nella casella degli strumenti per questo elemento.
Properties	Ottiene un dizionario delle proprietà.
TypeName	Ottiene o imposta il nome completo del tipo di oggetto IComponent creato dall'elemento della casella degli strumenti quando è richiamato.
Version	Ottiene la versione per questa classe ToolboxItem.

Metodi

CheckUnlocked()	Genera un'eccezione se l'elemento della casella degli strumenti è attualmente bloccato.
CreateComponents()	Crea i componenti la cui creazione è configurata nell'elemento della casella degli strumenti.
CreateComponents(IDesignerHost)	Crea i componenti la cui creazione è configurata nell'elemento della casella degli strumenti tramite l'host di progettazione specificato.
CreateComponents(IDesignerHost, IDictionary)	Crea i componenti la cui creazione è configurata nell'elemento della casella degli strumenti tramite l'host di progettazione specificato e i valori predefiniti.
CreateComponentsCore(IDesignerHost)	Crea un componente o una matrice di componenti quando viene richiamato l'elemento della casella degli strumenti.
CreateComponentsCore(IDesignerHost, IDictionary)	Crea una matrice di componenti quando viene richiamato l'elemento della casella degli strumenti.
Deserialize(SerializationInfo, StreamingContext)	Carica lo stato dell'elemento della casella degli strumenti dall'oggetto di informazioni di serializzazione specificato.
Equals(Object)	Determina se due istanze di ToolboxItem sono uguali.
FilterPropertyValue(String, Object)	Filtra un valore della proprietà prima di restituirlo.
GetHashCode()	Restituisce il codice hash per l'istanza.
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
GetType(IDesignerHost)	Permette l'accesso al tipo associato all'elemento della casella degli strumenti.
GetType(IDesignerHost, AssemblyName, String, Boolean)	Crea un'istanza del tipo specificato, specificando un host di progettazione e un nome assembly, se lo si desidera.
Initialize(Type)	Inizializza l'elemento della casella degli strumenti corrente con il tipo specificato da creare.
Lock()	Blocca l'elemento della casella di controllo e impedisce modifiche alle relative proprietà.
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
OnComponentsCreated(ToolboxComponentsCreatedEventArgs)	Genera l'evento ComponentsCreated.
OnComponentsCreating(ToolboxComponentsCreatingEventArgs)	Genera l'evento ComponentsCreating.
Serialize(SerializationInfo, StreamingContext)	Salva lo stato dell'elemento della casella degli strumenti nell'oggetto informazioni di serializzazione specificato.
ToString()	Restituisce un oggetto String che rappresenta l'oggetto ToolboxItem corrente.
ValidatePropertyType(String, Object, Type, Boolean)	Convalida che un oggetto è di un tipo specificato.
ValidatePropertyValue(String, Object)	Convalida una proprietà prima che venga assegnata al dizionario della proprietà.

Eventi

ComponentsCreated	Si verifica immediatamente dopo la creazione dei componenti.
ComponentsCreating	Si verifica quando i componenti stanno per essere creati.

Implementazioni dell'interfaccia esplicita

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Per una descrizione di questo membro, vedere il metodo GetObjectData(SerializationInfo, StreamingContext).

Si applica a

Vedi anche

• ToolboxItemFilterAttribute
• ToolboxItemAttribute
• IToolboxService
• IToolboxUser
• ToolboxComponentsCreatedEventArgs
• ToolboxComponentsCreatedEventHandler