ToolboxItem Classe

Définition

Espace de noms:

System.Drawing.Design

Assembly:

System.Windows.Forms.Design.dll

Fournit une implémentation de base d'un élément de boîte à outils.

C#

public class ToolboxItem : System.Runtime.Serialization.ISerializable

Héritage

Object

ToolboxItem

Dérivé

System.Web.UI.Design.WebControlToolboxItem

System.Workflow.ComponentModel.Design.ActivityToolboxItem

Implémente

ISerializable

Exemples

L’exemple de code suivant fournit un composant qui utilise l’interface IToolboxService pour ajouter un gestionnaire de format de données texte, ou ToolboxItemCreatorCallback, à la boîte à outils. Le délégué de rappel du créateur de données transmet toutes les données de texte collées à la boîte à outils et déplacées sur un formulaire vers un personnalisé ToolboxItem qui crée un TextBox contenant le texte.

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

L’exemple de code suivant illustre l’utilisation de la ToolboxItem classe comme classe de base pour une implémentation d’élément de boîte à outils personnalisée.

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

Remarques

ToolboxItem est une classe de base pour les éléments de boîte à outils qui peuvent être affichés dans la boîte à outils d’un environnement au moment du design. Un élément de boîte à outils représente généralement un composant à créer lorsqu’il est appelé sur un document en mode création. La ToolboxItem classe fournit les méthodes et les propriétés nécessaires pour fournir à la boîte à outils les propriétés d’affichage de l’élément de boîte à outils, créer un ou plusieurs composants lorsqu’il est utilisé, et pour sérialiser et se désérialiser pour la persistance dans la base de données de boîte à outils.

Une instance de la ToolboxItem classe peut être configurée avec un nom, une bitmap et un type à créer, sans créer de classe qui dérive de ToolboxItem. La ToolboxItem classe fournit également une classe de base pour les implémentations d’éléments de boîte à outils personnalisées. Un personnalisé ToolboxItem peut créer plusieurs composants. Pour implémenter un élément de ToolboxItem boîte à outils personnalisé, vous devez dériver et remplacer les CreateComponentsCoreméthodes , Serializeet Deserialize .

Les propriétés et méthodes suivantes doivent être configurées pour qu’un ToolboxItem fonctionne correctement :

• La DisplayName propriété spécifie l’étiquette de l’élément de boîte à outils lorsqu’il est affiché dans une boîte à outils.

• La TypeName propriété spécifie le nom complet du type du composant créé par l’élément. Si une classe dérivée crée plusieurs composants, la TypeName propriété peut être utilisée ou non, selon qu’un CreateComponentsCore remplacement de méthode dépend de la valeur de cette propriété.

• La AssemblyName propriété spécifie l’assembly qui contient le type d’un composant créé par l’élément.

• La Bitmap propriété spécifie éventuellement une image bitmap à afficher en regard du nom complet de l’élément de boîte à outils dans la boîte à outils.

• La Filter propriété contient éventuellement tous ToolboxItemFilterAttribute les objets qui déterminent si l’élément de boîte à outils peut être utilisé sur un composant particulier.

• La CreateComponentsCore méthode retourne le composant instance ou les instances à insérer là où cet outil est utilisé.

• La Serialize méthode enregistre l’élément de boîte à outils dans un spécifié SerializationInfo.

• La Deserialize méthode configure l’élément de boîte à outils à partir des informations d’état contenues dans le spécifié SerializationInfo.

• La Initialize méthode configure l’élément de boîte à outils pour créer le type de composant spécifié, si la CreateComponentsCore méthode n’a pas été remplacée pour se comporter différemment.

• La Locked propriété indique si les propriétés de l’élément de boîte à outils peuvent être modifiées. Un élément de boîte à outils est généralement verrouillé après son ajout à une boîte à outils.

• La Lock méthode verrouille un élément de boîte à outils.

• La CheckUnlocked méthode lève une exception si la Locked propriété est true.

Constructeurs

ToolboxItem()	Initialise une nouvelle instance de la classe ToolboxItem.
ToolboxItem(Type)	Initialise une nouvelle instance de la classe ToolboxItem qui crée le type de composant spécifié.

Propriétés

AssemblyName	Obtient ou définit le nom de l'assembly contenant les types créés par l'élément de boîte à outils.
Bitmap	Obtient ou définit une bitmap pour représenter l'élément de boîte à outils dans la boîte à outils.
Company	Obtient ou définit le nom de la société pour ToolboxItem.
ComponentType	Obtient le type de composant pour cet objet ToolboxItem.
DependentAssemblies	Obtient ou définit AssemblyName pour l'élément de boîte à outils.
Description	Obtient ou définit la description de cet objet ToolboxItem.
DisplayName	Obtient ou définit le nom complet de l'élément de boîte à outils.
Filter	Obtient ou définit le filtre qui détermine si l'élément de boîte à outils peut être utilisé sur un composant de destination.
IsTransient	Obtient une valeur qui indique si l'élément de boîte à outils est transitoire.
Locked	Obtient une valeur indiquant si ToolboxItem est actuellement verrouillé.
OriginalBitmap	Obtient ou définit l'image bitmap d'origine qui sera utilisée dans la boîte à outils pour cet élément.
Properties	Obtient un dictionnaire de propriétés.
TypeName	Obtient ou définit le nom qualifié complet du type de IComponent que l'élément de boîte à outils crée lorsqu'il est appelé.
Version	Obtient la version de cet objet ToolboxItem.

Méthodes

CheckUnlocked()	Lève une exception si l'élément de boîte à outils est actuellement verrouillé.
CreateComponents()	Crée les composants que l'élément de boîte à outils est configuré pour créer.
CreateComponents(IDesignerHost)	Crée les composants que l'élément de boîte à outils est configuré pour créer, à l'aide de l'hôte du concepteur spécifié.
CreateComponents(IDesignerHost, IDictionary)	Crée les composants que l'élément de boîte à outils est configuré pour créer, à l'aide de l'hôte du concepteur spécifié et des valeurs par défaut.
CreateComponentsCore(IDesignerHost)	Crée un composant ou un tableau de composants quand l'élément de boîte à outils est appelé.
CreateComponentsCore(IDesignerHost, IDictionary)	Crée un tableau de composants quand l'élément de boîte à outils est appelé.
Deserialize(SerializationInfo, StreamingContext)	Charge l'état de l'élément de boîte à outils à partir de l'objet des informations de sérialisation spécifiées.
Equals(Object)	Détermine si deux instances ToolboxItem sont égales.
FilterPropertyValue(String, Object)	Filtre une valeur de propriété avant de la retourner.
GetHashCode()	Retourne le code de hachage de cette instance.
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
GetType(IDesignerHost)	Permet l'accès au type associé à l'élément de boîte à outils.
GetType(IDesignerHost, AssemblyName, String, Boolean)	Crée une instance du type spécifié, en utilisant éventuellement un hôte du concepteur et un nom d'assembly spécifiés.
Initialize(Type)	Initialise l'élément de boîte à outils actuel avec le type spécifié à créer.
Lock()	Verrouille l'élément de boîte à outils et empêche toute modification de ses propriétés.
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
OnComponentsCreated(ToolboxComponentsCreatedEventArgs)	Déclenche l’événement ComponentsCreated.
OnComponentsCreating(ToolboxComponentsCreatingEventArgs)	Déclenche l’événement ComponentsCreating.
Serialize(SerializationInfo, StreamingContext)	Enregistre l'état de l'élément de boîte à outils dans l'objet des informations de sérialisation spécifiées.
ToString()	Retourne une valeur String qui représente le ToolboxItem actuel.
ValidatePropertyType(String, Object, Type, Boolean)	Vérifie qu'un objet est d'un type donné.
ValidatePropertyValue(String, Object)	Valide une propriété avant qu'elle ne soit assignée au dictionnaire de propriétés.

Événements

ComponentsCreated	Se produit dès que les composants ont été créés.
ComponentsCreating	Se produit quand des composants sont sur le point d'être créés.

Implémentations d’interfaces explicites

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Pour obtenir une description de ce membre, consultez la méthode GetObjectData(SerializationInfo, StreamingContext).

S’applique à

Voir aussi

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