ToolboxItem クラス

定義

名前空間:

System.Drawing.Design

アセンブリ:

System.Windows.Forms.Design.dll

ツールボックス項目の基本の実装を提供します。

C#

public class ToolboxItem : System.Runtime.Serialization.ISerializable

継承

Object

ToolboxItem

派生

System.Web.UI.Design.WebControlToolboxItem

System.Workflow.ComponentModel.Design.ActivityToolboxItem

実装

ISerializable

例

次のコード例では、 インターフェイスを使用 IToolboxService してテキスト データ形式ハンドラー (または ToolboxItemCreatorCallback) をツールボックスに追加するコンポーネントを提供します。 データ作成者コールバック デリゲートは、ツールボックスに貼り付け、フォームにドラッグしてテキストを含む をTextBox作成するカスタムToolboxItemにテキスト データを渡します。

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

次のコード例では、 クラスを ToolboxItem カスタム ツールボックス項目実装の基本クラスとして使用する方法を示します。

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

注釈

ToolboxItem は、デザイン時環境のツールボックスに表示できるツールボックス項目の基本クラスです。 ツールボックス項目は、通常、デザイン モード ドキュメントで呼び出されたときに作成するコンポーネントを表します。 クラスは ToolboxItem 、ツールボックスにツールボックス項目の表示プロパティを提供し、使用時にコンポーネントまたはコンポーネントを作成し、ツールボックス データベース内で永続化するためにそれ自体をシリアル化および逆シリアル化するために必要なメソッドとプロパティを提供します。

クラスの ToolboxItem インスタンスは、 から ToolboxItem派生したクラスを作成せずに、作成する名前、ビットマップ、および型で構成できます。 クラスには ToolboxItem 、カスタム ツールボックス項目の実装用の基本クラスも用意されています。 カスタム ToolboxItem では、複数のコンポーネントを作成できます。 カスタム ツールボックス項目を実装するには、 からToolboxItem派生し、、Serialize、および Deserialize メソッドをCreateComponentsCoreオーバーライドする必要があります。

を正しく機能させるには、次の ToolboxItem プロパティとメソッドを構成する必要があります。

• プロパティは DisplayName 、ツールボックスに表示されるツールボックス項目のラベルを指定します。

• プロパティは TypeName 、アイテムが作成するコンポーネントの型の完全修飾名を指定します。 派生クラスが複数のコンポーネントを TypeName 作成する場合、メソッドのオーバーライドがこのプロパティの値に依存するかどうかに応じて、 プロパティが使用される場合と使用されない場合 CreateComponentsCore があります。

• プロパティは AssemblyName 、アイテムが作成するコンポーネントの型を含むアセンブリを指定します。

• プロパティは Bitmap 、必要に応じて、ツールボックス内のツールボックス項目の表示名の横に表示するビットマップ イメージを指定します。

• プロパティには Filter 、必要に応じて、ツールボックス項目を特定のコンポーネントで使用できるかどうかを決定するオブジェクトが含 ToolboxItemFilterAttribute まれます。

• メソッドは CreateComponentsCore 、このツールを使用する場所に挿入するコンポーネント インスタンスまたはインスタンスを返します。

• メソッドは Serialize 、ツールボックス項目を指定した SerializationInfoに保存します。

• メソッドは Deserialize 、指定された に含まれる状態情報からツールボックス項目を構成します SerializationInfo。

• メソッドが Initialize 異なる動作をするようにオーバーライドされていない場合は、指定した種類のコンポーネントを CreateComponentsCore 作成するようにツールボックス項目を構成します。

• プロパティは Locked 、ツールボックス項目のプロパティを変更できるかどうかを示します。 ツールボックス項目は、通常、ツールボックスに追加された後にロックされます。

• メソッドは Lock ツールボックス項目をロックします。

• プロパティが の場合、メソッドはCheckUnlockedtrue例外をLockedスローします。

コンストラクター

ToolboxItem()	ToolboxItem クラスの新しいインスタンスを初期化します。
ToolboxItem(Type)	指定した型のコンポーネントを作成する ToolboxItem クラスの新しいインスタンスを初期化します。

プロパティ

AssemblyName	ツールボックス項目が作成する型が含まれるアセンブリの名前を取得または設定します。
Bitmap	ツールボックスでツールボックス項目を表すビットマップを取得または設定します。
Company	この ToolboxItem の会社名を取得または設定します。
ComponentType	この ToolboxItem のコンポーネントの型を取得します。
DependentAssemblies	ツールボックス項目の AssemblyName を取得または設定します。
Description	この ToolboxItem の説明を取得または設定します。
DisplayName	ツールボックス項目の表示名を取得または設定します。
Filter	ツールボックス項目が対象のコンポーネントで使用できるかどうかを決定するフィルターを取得または設定します。
IsTransient	ツールボックス項目が遷移的かどうかを示す値を取得します。
Locked	ToolboxItem がロックされているかどうかを示す値を取得します。
OriginalBitmap	この項目のツールボックスに使用する元のビットマップを取得または設定します。
Properties	プロパティのディクショナリを取得します。
TypeName	ツールボックス項目が呼び出されたときに作成する IComponent の型の完全限定名を取得または設定します。
Version	この ToolboxItem のバージョンを取得します。

メソッド

CheckUnlocked()	ツールボックス項目が現在ロックされている場合は、例外がスローされます。
CreateComponents()	ツールボックス項目で作成するように設定されているコンポーネントを作成します。
CreateComponents(IDesignerHost)	指定したデザイナー ホストを使用して、ツールボックス項目で作成するように設定されているコンポーネントを作成します。
CreateComponents(IDesignerHost, IDictionary)	指定したデザイナー ホストおよび既定値を使用して、ツールボックス項目で作成するように設定されているコンポーネントを作成します。
CreateComponentsCore(IDesignerHost)	ツールボックス項目が呼び出されたときに、コンポーネントまたはコンポーネントの配列を作成します。
CreateComponentsCore(IDesignerHost, IDictionary)	ツールボックス項目が呼び出されたときに、コンポーネントの配列を作成します。
Deserialize(SerializationInfo, StreamingContext)	指定したシリアル化情報オブジェクトから、このツールボックス項目の状態を読み込みます。
Equals(Object)	2 つの ToolboxItem インスタンスが等しいかどうかを判断します。
FilterPropertyValue(String, Object)	プロパティ値を返す前に、フィルター処理をします。
GetHashCode()	このインスタンスのハッシュ コードを返します。
GetType()	現在のインスタンスの Type を取得します。 (継承元 Object)
GetType(IDesignerHost)	ツールボックス項目に関連付けられた型にアクセスできるようにします。
GetType(IDesignerHost, AssemblyName, String, Boolean)	指定した型のインスタンスを作成します。オプションで、指定したデザイナー ホストとアセンブリの名前を使用します。
Initialize(Type)	作成する型を指定して、現在のツールボックス項目を初期化します。
Lock()	ツールボックス項目をロックして、プロパティが変更されないようにします。
MemberwiseClone()	現在の Object の簡易コピーを作成します。 (継承元 Object)
OnComponentsCreated(ToolboxComponentsCreatedEventArgs)	ComponentsCreated イベントを発生させます。
OnComponentsCreating(ToolboxComponentsCreatingEventArgs)	ComponentsCreating イベントを発生させます。
Serialize(SerializationInfo, StreamingContext)	指定したシリアル化情報オブジェクトに、このツールボックス項目の状態を保存します。
ToString()	現在の ToolboxItem を表す String を返します。
ValidatePropertyType(String, Object, Type, Boolean)	オブジェクトが特定の型であるかどうかを検証します。
ValidatePropertyValue(String, Object)	プロパティ ディクショナリに割り当てる前にプロパティを検証します。

イベント

ComponentsCreated	コンポーネントが作成された直後に発生します。
ComponentsCreating	コンポーネントが作成されるときに発生します。

明示的なインターフェイスの実装

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

このメンバーの説明については、GetObjectData(SerializationInfo, StreamingContext) メソッドのトピックを参照してください。

適用対象

こちらもご覧ください

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