This documentation is archived and is not being maintained.

IToolboxService Interface

Provides methods and properties to manage and query the toolbox in the development environment.

For a list of all members of this type, see IToolboxService Members.

[Visual Basic]
<Guid("4BACD258-DE64-4048-BC4E-FEDBEF9ACB76")>
<InterfaceType(ComInterfaceType.InterfaceIsIUnknown)>
Public Interface IToolboxService
[C#]
[Guid("4BACD258-DE64-4048-BC4E-FEDBEF9ACB76")]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IToolboxService
[C++]
[Guid("4BACD258-DE64-4048-BC4E-FEDBEF9ACB76")]
[InterfaceType(ComInterfaceType::InterfaceIsIUnknown)]
public __gc __interface IToolboxService
[JScript]
public
   Guid("4BACD258-DE64-4048-BC4E-FEDBEF9ACB76")
 InterfaceType(ComInterfaceType.InterfaceIsIUnknown)
interface IToolboxService

Remarks

The IToolboxService interface provides properties and methods for adding and removing toolbox items and toolbox creator callback delegates, serializing and deserializing toolbox items, and retrieving toolbox state information and managing toolbox state.You can retrieve information about the contents of the toolbox with the following methods:

You can add and remove toolbox items with the following methods:

You can refresh the toolbox, mark a toolbox item as used, or set the mouse cursor to a cursor that represents the current toolbox item using the following methods:

  • The Refresh method refreshes the toolbox display to reflect the current state of the toolbox items.
  • The SelectedToolboxItemUsed method signals the toolbox that the selected toolbox item has been used.
  • The SetCursor method sets the mouse cursor to a cursor that represents the current toolbox item.

You can use the toolbox to serialize or deserialize a toolbox item using the following methods:

Example

[Visual Basic, C#, C++] The following example control demonstrates use of the IToolboxService in design mode to list and select toolbox categories and items, and to create components or controls from toolbox items and add them to a System.Windows.Forms.Form using code. Build the code and add it to the toolbox using the Customize Toolbox command on the Tools menu in Visual Studio .NET. Create an instance of the IToolboxServiceControl on a form to test its behavior.

[Visual Basic] 
Imports System
Imports System.Collections
Imports System.ComponentModel
Imports System.ComponentModel.Design
Imports System.Drawing
Imports System.Drawing.Design
Imports System.Data
Imports System.Diagnostics
Imports System.Reflection
Imports System.Windows.Forms

' Provides an example control that functions in design mode to 
' demonstrate use of the IToolboxService to list and select toolbox 
' categories and items, and to add components or controls 
' to the parent form using code.
<DesignerAttribute(GetType(WindowMessageDesigner), GetType(IDesigner))>  _
Public Class IToolboxServiceControl
    Inherits System.Windows.Forms.UserControl

   Private WithEvents listBox1 As System.Windows.Forms.ListBox
   Private listBox2 As System.Windows.Forms.ListBox
   Private toolboxService As IToolboxService = Nothing
   Private tools As ToolboxItemCollection
   Private controlSpacingMultiplier As Integer   
   
   Public Sub New()
      InitializeComponent()
      AddHandler listBox2.DoubleClick, AddressOf Me.CreateComponent
      controlSpacingMultiplier = 0
    End Sub

    ' Obtain or reset IToolboxService reference on each siting of control.
    Public Overrides Property Site() As System.ComponentModel.ISite
        Get
            Return MyBase.Site
        End Get
        Set(ByVal Value As System.ComponentModel.ISite)
            MyBase.Site = Value

            ' If the component was sited, attempt to obtain 
            ' an IToolboxService instance.
            If Not (MyBase.Site Is Nothing) Then
                toolboxService = CType(Me.GetService(GetType(IToolboxService)), IToolboxService)
                ' If an IToolboxService instance was located, update the 
                ' category list.
                If Not (toolboxService Is Nothing) Then
                    UpdateLists()
                End If
            Else
                toolboxService = Nothing
            End If
        End Set
    End Property

    ' Updates the list of categories and the list of items in the 
    ' selected category.
    Private Sub UpdateLists()
        If Not (toolboxService Is Nothing) Then
            RemoveHandler listBox1.SelectedIndexChanged, AddressOf Me.UpdateSelectedCategory
            RemoveHandler listBox2.SelectedIndexChanged, AddressOf Me.UpdateSelectedItem
            listBox1.Items.Clear()
            Dim i As Integer
            For i = 0 To toolboxService.CategoryNames.Count - 1
                listBox1.Items.Add(toolboxService.CategoryNames(i))
                If toolboxService.CategoryNames(i) = toolboxService.SelectedCategory Then
                    listBox1.SelectedIndex = i
                    tools = toolboxService.GetToolboxItems(toolboxService.SelectedCategory)
                    listBox2.Items.Clear()
                    Dim j As Integer
                    For j = 0 To tools.Count - 1
                        listBox2.Items.Add(tools(j).DisplayName)
                    Next j
                End If
            Next i
            AddHandler Me.listBox1.SelectedIndexChanged, AddressOf Me.UpdateSelectedCategory
            AddHandler Me.listBox2.SelectedIndexChanged, AddressOf Me.UpdateSelectedItem
        End If
    End Sub

    ' Sets the selected category when a category is clicked in the 
    ' category list.
    Private Sub UpdateSelectedCategory(ByVal sender As Object, ByVal e As System.EventArgs) Handles listBox1.SelectedIndexChanged
        If Not (toolboxService Is Nothing) Then
            toolboxService.SelectedCategory = CStr(listBox1.SelectedItem)
            UpdateLists()
        End If
    End Sub

    ' Sets the selected item when an item is clicked in the item list.
    Private Sub UpdateSelectedItem(ByVal sender As Object, ByVal e As System.EventArgs)
        If Not (toolboxService Is Nothing) Then
            If listBox1.SelectedIndex <> -1 Then
                If CStr(listBox1.SelectedItem) = toolboxService.SelectedCategory Then
                    toolboxService.SetSelectedToolboxItem(tools(listBox2.SelectedIndex))
                Else
                    UpdateLists()
                End If
            End If
        End If
    End Sub

    ' Creates a control from a double-clicked toolbox item and adds 
    ' it to the parent form.
    Private Sub CreateComponent(ByVal sender As Object, ByVal e As EventArgs)

        ' Obtains an IDesignerHost service from design environment.
        Dim host As IDesignerHost = CType(Me.GetService(GetType(IDesignerHost)), IDesignerHost)

        ' Gets the project components container. (Windows Forms control 
        ' containment depends on controls collections).
        Dim container As IContainer = host.Container

        ' Identifies the parent Form.
        Dim parentForm As System.Windows.Forms.Form = Me.FindForm()

        ' Retrieves the parent Form's designer host.
        Dim parentHost As IDesignerHost = CType(parentForm.Site.GetService(GetType(IDesignerHost)), IDesignerHost)

        ' Create the components.
        Dim comps As IComponent() = Nothing
        Try
            comps = toolboxService.GetSelectedToolboxItem().CreateComponents(parentHost)
        Catch ex As Exception
            ' Catch and show any exceptions to prevent 
            ' disabling the control's UI.
            MessageBox.Show(ex.ToString(), "Exception message")
        End Try

        If comps Is Nothing Then
            Return
        End If

        ' Add any created controls to the parent form's controls 
        ' collection. Note: components are added from the 
        ' ToolboxItem.CreateComponents(IDesignerHost) method.
        Dim i As Integer
        For i = 0 To comps.Length - 1
            If Not (parentForm Is Nothing) AndAlso CType(comps(i), Object).GetType().IsSubclassOf(GetType(System.Windows.Forms.Control)) Then
                CType(comps(i), System.Windows.Forms.Control).Location = New Point(20 * controlSpacingMultiplier, 20 * controlSpacingMultiplier)
                If controlSpacingMultiplier > 10 Then
                    controlSpacingMultiplier = 0
                Else
                    controlSpacingMultiplier += 1
                End If
                parentForm.Controls.Add(CType(comps(i), System.Windows.Forms.Control))
            End If
        Next i
    End Sub

    ' Displays labels.
    Protected Overrides Sub OnPaint(ByVal e As System.Windows.Forms.PaintEventArgs)
        e.Graphics.DrawString("IToolboxService Control", New Font("Arial", 14), New SolidBrush(Color.Black), 6, 4)
        e.Graphics.DrawString("Category List", New Font("Arial", 8), New SolidBrush(Color.Black), 8, 26)
        e.Graphics.DrawString("Items in Category", New Font("Arial", 8), New SolidBrush(Color.Black), 208, 26)
        e.Graphics.DrawString("(Double-click item to add to parent form)", New Font("Arial", 7), New SolidBrush(Color.Black), 232, 12)
    End Sub

    Private Sub InitializeComponent()
        Me.listBox1 = New System.Windows.Forms.ListBox()
        Me.listBox2 = New System.Windows.Forms.ListBox()
        Me.SuspendLayout()
        Me.listBox1.Anchor = System.Windows.Forms.AnchorStyles.Top Or System.Windows.Forms.AnchorStyles.Bottom Or System.Windows.Forms.AnchorStyles.Left
        Me.listBox1.Location = New System.Drawing.Point(8, 41)
        Me.listBox1.Name = "listBox1"
        Me.listBox1.Size = New System.Drawing.Size(192, 368)
        Me.listBox1.TabIndex = 0
        Me.listBox2.Anchor = System.Windows.Forms.AnchorStyles.Top Or System.Windows.Forms.AnchorStyles.Bottom Or System.Windows.Forms.AnchorStyles.Left Or System.Windows.Forms.AnchorStyles.Right
        Me.listBox2.Location = New System.Drawing.Point(208, 41)
        Me.listBox2.Name = "listBox2"
        Me.listBox2.Size = New System.Drawing.Size(228, 368)
        Me.listBox2.TabIndex = 3
        Me.BackColor = System.Drawing.Color.Beige
        Me.Controls.AddRange(New System.Windows.Forms.Control() {Me.listBox2, Me.listBox1})
        Me.Location = New System.Drawing.Point(500, 400)
        Me.Name = "IToolboxServiceControl"
        Me.Size = New System.Drawing.Size(442, 422)
        Me.ResumeLayout(False)
    End Sub

End Class

' This designer passes window messages to the controls at design time.    
Public Class WindowMessageDesigner
    Inherits System.Windows.Forms.Design.ControlDesigner

    Public Sub New()
    End Sub

    ' Window procedure override passes events to control.
    <System.Security.Permissions.PermissionSetAttribute(System.Security.Permissions.SecurityAction.Demand, Name:="FullTrust")> _
    Protected Overrides Sub WndProc(ByRef m As System.Windows.Forms.Message)
        If m.HWnd.Equals(Me.Control.Handle) Then
            MyBase.WndProc(m)
        Else
            Me.DefWndProc(m)
        End If
    End Sub

End Class

[C#] 
using System;
using System.Collections;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Drawing;
using System.Drawing.Design;
using System.Data;
using System.Diagnostics;
using System.Windows.Forms;

namespace IToolboxServiceExample
{    
    // Provides an example control that functions in design mode to 
    // demonstrate use of the IToolboxService to list and select toolbox 
    // categories and items, and to add components or controls 
    // to the parent form using code.
    [DesignerAttribute(typeof(WindowMessageDesigner), typeof(IDesigner))]
    public class IToolboxServiceControl : System.Windows.Forms.UserControl
    {        
        private System.Windows.Forms.ListBox listBox1;
        private System.Windows.Forms.ListBox listBox2;
        private IToolboxService toolboxService = null;
        private ToolboxItemCollection tools;
        private int controlSpacingMultiplier;

        public IToolboxServiceControl()
        {
            InitializeComponent();
            listBox2.DoubleClick += new EventHandler(this.CreateComponent);
            controlSpacingMultiplier = 0;
        }
        
        // Obtain or reset IToolboxService reference on each siting of control.
        public override System.ComponentModel.ISite Site
        {
            get
            {
                return base.Site;
            }
            set
            {     
                base.Site = value;

                // If the component was sited, attempt to obtain 
                // an IToolboxService instance.
                if( base.Site != null )
                {
                    toolboxService = (IToolboxService)this.GetService(typeof(IToolboxService));
                    // If an IToolboxService was located, update the 
                    // category list.
                    if( toolboxService != null )
                        UpdateLists();                    
                }
                else
                    toolboxService = null;
            }
        }

        // Updates the list of categories and the list of items in the 
        // selected category.
        private void UpdateLists()
        {
            if( toolboxService != null )
            {
                this.listBox1.SelectedIndexChanged -= new System.EventHandler(this.UpdateSelectedCategory);
                this.listBox2.SelectedIndexChanged -= new System.EventHandler(this.UpdateSelectedItem);
                listBox1.Items.Clear();
                for( int i=0; i<toolboxService.CategoryNames.Count; i++ )
                {
                    listBox1.Items.Add( toolboxService.CategoryNames[i] );
                    if( toolboxService.CategoryNames[i] == toolboxService.SelectedCategory )
                    {
                        listBox1.SelectedIndex = i;                        
                        tools = toolboxService.GetToolboxItems( toolboxService.SelectedCategory );
                        listBox2.Items.Clear();
                        for( int j=0; j<tools.Count; j++ )
                            listBox2.Items.Add( tools[j].DisplayName );
                    }
                }
                this.listBox1.SelectedIndexChanged += new System.EventHandler(this.UpdateSelectedCategory);
                this.listBox2.SelectedIndexChanged += new System.EventHandler(this.UpdateSelectedItem);
            }
        }

        // Sets the selected category when a category is clicked in the 
        // category list.
        private void UpdateSelectedCategory(object sender, System.EventArgs e)
        {
            if( toolboxService != null )
            {
                toolboxService.SelectedCategory = (string)listBox1.SelectedItem;
                UpdateLists();
            }
        }

        // Sets the selected item when an item is clicked in the item list.
        private void UpdateSelectedItem(object sender, System.EventArgs e)
        {
            if( toolboxService != null )      
            {
                if( listBox1.SelectedIndex != -1 )
                {
                    if( (string)listBox1.SelectedItem == toolboxService.SelectedCategory )
                        toolboxService.SetSelectedToolboxItem(tools[listBox2.SelectedIndex]);  
                    else
                        UpdateLists();
                }
            }            
        }   

        // Creates a control from a double-clicked toolbox item and adds 
        // it to the parent form.
        private void CreateComponent(object sender, EventArgs e)
        {
            // Obtains an IDesignerHost service from design environment.
            IDesignerHost host = (IDesignerHost)this.GetService(typeof(IDesignerHost));

            // Get the project components container (Windows Forms control 
            // containment depends on controls collections).
            IContainer container = host.Container;
                        
            // Identifies the parent Form.
            System.Windows.Forms.Form parentForm = this.FindForm();

            // Retrieves the parent Form's designer host.
            IDesignerHost parentHost = (IDesignerHost)parentForm.Site.GetService(typeof(IDesignerHost));

            // Create the components.
            IComponent[] comps = null;
            try
            {
                 comps = toolboxService.GetSelectedToolboxItem().CreateComponents(parentHost);
            }
            catch(Exception ex)
            {
                // Catch and show any exceptions to prevent disabling 
                // the control's UI.
                MessageBox.Show(ex.ToString(), "Exception message");
            }
            if( comps == null )
                return;

            // Add any created controls to the parent form's controls 
            // collection. Note: components are added from the 
            // ToolboxItem.CreateComponents(IDesignerHost) method.
            for( int i=0; i<comps.Length; i++ )            
            {
                if( parentForm!= null && comps[i].GetType().IsSubclassOf(typeof(System.Windows.Forms.Control)) )
                {                    
                    ((System.Windows.Forms.Control)comps[i]).Location = new Point(20*controlSpacingMultiplier, 20*controlSpacingMultiplier);
                    if( controlSpacingMultiplier > 10 )
                        controlSpacingMultiplier = 0;
                    else
                        controlSpacingMultiplier++;
                    parentForm.Controls.Add( (System.Windows.Forms.Control)comps[i] );
                }
            }
        }

        // Displays labels.
        protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
        {
            e.Graphics.DrawString("IToolboxService Control", new Font("Arial", 14), new SolidBrush(Color.Black), 6, 4);
            e.Graphics.DrawString("Category List", new Font("Arial", 8), new SolidBrush(Color.Black), 8, 26);
            e.Graphics.DrawString("Items in Category", new Font("Arial", 8), new SolidBrush(Color.Black), 208, 26);
            e.Graphics.DrawString("(Double-click item to add to parent form)", new Font("Arial", 7), new SolidBrush(Color.Black), 232, 12);
        }  

        private void InitializeComponent()
        {
            this.listBox1 = new System.Windows.Forms.ListBox();
            this.listBox2 = new System.Windows.Forms.ListBox();
            this.SuspendLayout();
            this.listBox1.Anchor = ((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
                | System.Windows.Forms.AnchorStyles.Left);
            this.listBox1.Location = new System.Drawing.Point(8, 41);
            this.listBox1.Name = "listBox1";
            this.listBox1.Size = new System.Drawing.Size(192, 368);
            this.listBox1.TabIndex = 0;
            this.listBox1.SelectedIndexChanged += new System.EventHandler(this.UpdateSelectedCategory);
            this.listBox2.Anchor = (((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
                | System.Windows.Forms.AnchorStyles.Left) 
                | System.Windows.Forms.AnchorStyles.Right);
            this.listBox2.Location = new System.Drawing.Point(208, 41);
            this.listBox2.Name = "listBox2";
            this.listBox2.Size = new System.Drawing.Size(228, 368);
            this.listBox2.TabIndex = 3;
            this.BackColor = System.Drawing.Color.Beige;
            this.Controls.AddRange(new System.Windows.Forms.Control[] {
                                                                          this.listBox2,
                                                                          this.listBox1});
            this.Location = new System.Drawing.Point(500, 400);
            this.Name = "IToolboxServiceControl";
            this.Size = new System.Drawing.Size(442, 422);
            this.ResumeLayout(false);
        }        
    }
    
    // This designer passes window messages to the controls at design time.    
    public class WindowMessageDesigner : System.Windows.Forms.Design.ControlDesigner
    {
        public WindowMessageDesigner()
        {
        }
        
        // Window procedure override passes events to control.
        [System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Demand, Name="FullTrust")] 
        protected override void WndProc(ref System.Windows.Forms.Message m)
        {   
            if( m.HWnd == this.Control.Handle )
                base.WndProc(ref m);            
            else            
                this.DefWndProc(ref m);            
        }        
    }
}

[C++] 
#using <mscorlib.dll>
#using <System.dll>
#using <System.Design.dll>
#using <System.Windows.Forms.dll>
#using <System.Data.dll>
#using <System.Drawing.dll>

using namespace System;
using namespace System::Collections;
using namespace System::ComponentModel;
using namespace System::ComponentModel::Design;
using namespace System::Drawing;
using namespace System::Drawing::Design;
using namespace System::Data;
using namespace System::Diagnostics;
using namespace System::Windows::Forms;

namespace IToolboxServiceExample {

   // This designer passes window messages to the controls at design time.
public __gc class WindowMessageDesigner : public System::Windows::Forms::Design::ControlDesigner {
public:
   WindowMessageDesigner() {
   }

   // Window procedure  passes events to control.
protected:
[System::Security::Permissions::PermissionSet(System::Security::Permissions::SecurityAction::Demand, Name="FullTrust")]
   void WndProc(System::Windows::Forms::Message* m) {
      if (m->HWnd == this->Control->Handle)
         ControlDesigner::WndProc(m);
      else
         ControlDesigner::DefWndProc(m);
   }
};

// Provides an example control that functions in design mode to
// demonstrate use of the IToolboxService to list and select toolbox
// categories and items, and to add components or controls
// to the parent form using code.
[DesignerAttribute(__typeof(WindowMessageDesigner), __typeof(IDesigner))]
public __gc class IToolboxServiceControl : public System::Windows::Forms::UserControl {
private:
   System::Windows::Forms::ListBox*  listBox1;
   System::Windows::Forms::ListBox*  listBox2;
   IToolboxService* toolboxService;
   ToolboxItemCollection*  tools;
   int  controlSpacingMultiplier;

public:
   IToolboxServiceControl() {
      InitializeComponent();
      listBox2->DoubleClick += new EventHandler(this, &IToolboxServiceControl::CreateComponent);
      controlSpacingMultiplier = 0;
   }

   // Obtain or reset IToolboxService reference on each siting of control.
   __property System::ComponentModel::ISite* get_Site() {
      return UserControl::get_Site();
   }
   __property void set_Site(System::ComponentModel::ISite* value) {
      UserControl::set_Site( value );

      // If the component was sited, attempt to obtain
      // an IToolboxService instance.
      if (UserControl::Site != 0) {
         toolboxService = dynamic_cast<IToolboxService*>(this->GetService(__typeof(IToolboxService)));
         // If an IToolboxService was located, update the
         // category list.
         if (toolboxService != 0)
            UpdateLists();
      } else toolboxService = 0;
   }

private:
   // Updates the list of categories and the list of items in the
   // selected category.
   void UpdateLists() {
      if (toolboxService != 0) {
         this->listBox1->SelectedIndexChanged -= new System::EventHandler(this, &IToolboxServiceControl::UpdateSelectedCategory);
         this->listBox2->SelectedIndexChanged -= new System::EventHandler(this, &IToolboxServiceControl::UpdateSelectedItem);
         listBox1->Items->Clear();
         for (int i=0; i<toolboxService->CategoryNames->Count; i++) {
            listBox1->Items->Add(toolboxService->CategoryNames->Item[i]);
            if (toolboxService->CategoryNames->Item[i] == toolboxService->SelectedCategory) {
               listBox1->SelectedIndex = i;
               tools = toolboxService->GetToolboxItems(toolboxService->SelectedCategory);
               listBox2->Items->Clear();
               for (int j=0; j<tools->Count; j++)
                  listBox2->Items->Add(tools->Item[j]->DisplayName);
            }
         }
         this->listBox1->SelectedIndexChanged += new System::EventHandler(this, &IToolboxServiceControl::UpdateSelectedCategory);
         this->listBox2->SelectedIndexChanged += new System::EventHandler(this, &IToolboxServiceControl::UpdateSelectedItem);
      }
   }

   // Sets the selected category when a category is clicked in the
   // category list.
   void UpdateSelectedCategory(Object* /*sender*/, System::EventArgs* /*e*/) {
      if (toolboxService != 0) {
         toolboxService->SelectedCategory = dynamic_cast<String*>(listBox1->SelectedItem);
         UpdateLists();
      }
   }

   // Sets the selected item when an item is clicked in the item list.
   void UpdateSelectedItem(Object* /*sender*/, System::EventArgs* /*e*/) {
      if (toolboxService != 0) {
         if (listBox1->SelectedIndex != -1) {
            if (dynamic_cast<String*>(listBox1->SelectedItem )== toolboxService->SelectedCategory)
               toolboxService->SetSelectedToolboxItem(tools->Item[listBox2->SelectedIndex]);
            else
               UpdateLists();
         }
      }
   }

   // Creates a control from a double-clicked toolbox item and adds
   // it to the parent form.
   void CreateComponent(Object* /*sender*/, EventArgs* /*e*/) {
      // Obtains an IDesignerHost service from design environment.
      IDesignerHost* host = dynamic_cast<IDesignerHost*>(this->GetService(__typeof(IDesignerHost)));

      // Get the project components container (Windows Forms control
      // containment depends on controls collections).
      IContainer* container = host->Container;

      // Identifies the parent Form.
      System::Windows::Forms::Form* parentForm = this->FindForm();

      // Retrieves the parent Form's designer host.
      IDesignerHost* parentHost = dynamic_cast<IDesignerHost*>(parentForm->Site->GetService(__typeof(IDesignerHost)));

      // Create the components.
      IComponent* comps [] = 0;
      try {
         comps = toolboxService->GetSelectedToolboxItem()->CreateComponents(parentHost);
      } catch (Exception* ex) {
         // Catch and show any exceptions to prevent disabling
         // the control's UI.
         MessageBox::Show(ex->ToString(), S"Exception message");
      }
      if (comps == 0)
         return;

      // Add any created controls to the parent form's controls
      // collection. Note: components are added from the
      // ToolboxItem::CreateComponents(IDesignerHost*) method.
      for (int i=0; i<comps->Length; i++) {
         if (parentForm!= 0 && comps->Item[i]->GetType()->IsSubclassOf(__typeof(System::Windows::Forms::Control))) {
            (dynamic_cast<System::Windows::Forms::Control*>(comps->Item[i]))->Location =  Point(20*controlSpacingMultiplier, 20*controlSpacingMultiplier);
            if (controlSpacingMultiplier > 10)
               controlSpacingMultiplier = 0;
            else
               controlSpacingMultiplier++;
            parentForm->Controls->Add(dynamic_cast<System::Windows::Forms::Control*>(comps->Item[i]));
         }
      }
   }

   // Displays labels.
protected:
   void OnPaint(System::Windows::Forms::PaintEventArgs* e) {
      e->Graphics->DrawString(S"IToolboxService Control", new System::Drawing::Font(S"Arial", 14), new SolidBrush(Color::Black), 6, 4);
      e->Graphics->DrawString(S"Category List", new System::Drawing::Font(S"Arial", 8), new SolidBrush(Color::Black), 8, 26);
      e->Graphics->DrawString(S"Items in Category", new System::Drawing::Font(S"Arial", 8), new SolidBrush(Color::Black), 208, 26);
      e->Graphics->DrawString(S"(Double-click item to add to parent form)", new System::Drawing::Font(S"Arial", 7), new SolidBrush(Color::Black), 232, 12);
   }

private:
   void InitializeComponent() {
      this->listBox1 = new System::Windows::Forms::ListBox();
      this->listBox2 = new System::Windows::Forms::ListBox();
      this->SuspendLayout();
      this->listBox1->Anchor = static_cast<AnchorStyles>(System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Bottom
         | System::Windows::Forms::AnchorStyles::Left);
      this->listBox1->Location =  System::Drawing::Point(8, 41);
      this->listBox1->Name = S"listBox1";
      this->listBox1->Size =  System::Drawing::Size(192, 368);
      this->listBox1->TabIndex = 0;
      this->listBox1->SelectedIndexChanged += new System::EventHandler(this, &IToolboxServiceControl::UpdateSelectedCategory);
      this->listBox2->Anchor = static_cast<AnchorStyles>(System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Bottom
         | System::Windows::Forms::AnchorStyles::Left
         | System::Windows::Forms::AnchorStyles::Right);
      this->listBox2->Location =  System::Drawing::Point(208, 41);
      this->listBox2->Name = S"listBox2";
      this->listBox2->Size =  System::Drawing::Size(228, 368);
      this->listBox2->TabIndex = 3;
      this->BackColor = System::Drawing::Color::Beige;

      System::Windows::Forms::Control* temp0 [] = {this->listBox2, this->listBox1};
      this->Controls->AddRange(temp0);
      this->Location =  System::Drawing::Point(500, 400);
      this->Name = S"IToolboxServiceControl*";
      this->Size =  System::Drawing::Size(442, 422);
      this->ResumeLayout(false);
   }
};
}

[Visual Basic, C#, C++] The following example provides a component that uses the IToolboxService to add a "Text" data format handler, or ToolboxItemCreatorCallback, to the toolbox. The data creator callback delegate passes any text data pasted to the toolbox and dragged onto a form to a custom ToolboxItem that creates a System.Windows.Forms.TextBox containing the text.

[Visual Basic] 
Imports System
Imports System.ComponentModel
Imports System.ComponentModel.Design
Imports System.Drawing
Imports System.Drawing.Design
Imports System.Windows.Forms

' Component that adds a "Text" data format ToolboxItemCreatorCallback 
' to the Toolbox that creates a custom ToolboxItem that 
' creates a TextBox containing the text data.
Public Class TextDataTextBoxComponent
    Inherits System.ComponentModel.Component

   Private creatorAdded As Boolean = False
   Private ts As IToolboxService   
   
   Public Sub New()
    End Sub

    ' ISite override to register TextBox creator
    Public Overrides Property Site() As System.ComponentModel.ISite
        Get
            Return MyBase.Site
        End Get
        Set(ByVal Value As System.ComponentModel.ISite)
            If Not (Value Is Nothing) Then
                MyBase.Site = Value
                If Not creatorAdded Then
                    AddTextTextBoxCreator()
                End If
            Else
                If creatorAdded Then
                    RemoveTextTextBoxCreator()
                End If
                MyBase.Site = Value
            End If
        End Set
    End Property

    ' Adds a "Text" data format creator to the toolbox that creates 
    ' a textbox from a text fragment pasted to the toolbox.
    Private Sub AddTextTextBoxCreator()
        ts = CType(GetService(GetType(IToolboxService)), IToolboxService)
        If Not (ts Is Nothing) Then
            Dim textCreator As New ToolboxItemCreatorCallback(AddressOf Me.CreateTextBoxForText)
            Try
                ts.AddCreator(textCreator, "Text", CType(GetService(GetType(IDesignerHost)), IDesignerHost))
                creatorAdded = True
            Catch ex As Exception
                MessageBox.Show(ex.ToString(), "Exception Information")
            End Try
        End If
    End Sub

    ' Removes any "Text" data format creator from the toolbox.
    Private Sub RemoveTextTextBoxCreator()
        If Not (ts Is Nothing) Then
            ts.RemoveCreator("Text", CType(GetService(GetType(IDesignerHost)), IDesignerHost))
            creatorAdded = False
        End If
    End Sub

    ' ToolboxItemCreatorCallback delegate format method to create 
    ' the toolbox item.
    Private Function CreateTextBoxForText(ByVal serializedObject As Object, ByVal format As String) As ToolboxItem
        Dim formats As String() = CType(serializedObject, System.Windows.Forms.DataObject).GetFormats()
        If CType(serializedObject, System.Windows.Forms.DataObject).GetDataPresent("System.String", True) Then
            Return New TextToolboxItem(CStr(CType(serializedObject, System.Windows.Forms.DataObject).GetData("System.String", True)))
        End If
        Return Nothing
    End Function

    Protected Overloads Overrides Sub Dispose(ByVal disposing As Boolean)
        If creatorAdded Then
            RemoveTextTextBoxCreator()
        End If
    End Sub

End Class

' Custom toolbox item creates a TextBox and sets its Text property
' to the constructor-specified text.
Public Class TextToolboxItem
    Inherits System.Drawing.Design.ToolboxItem

    Private [text] As String

    Delegate Sub SetTextMethodHandler(ByVal c As Control, ByVal [text] As String)

    Public Sub New(ByVal [text] As String)
        Me.text = [text]
    End Sub

    ' ToolboxItem.CreateComponentsCore override to create the TextBox 
    ' and link a method to set its Text property.
    <System.Security.Permissions.PermissionSetAttribute(System.Security.Permissions.SecurityAction.Demand, Name:="FullTrust")> _
    Protected Overrides Function CreateComponentsCore(ByVal host As System.ComponentModel.Design.IDesignerHost) As System.ComponentModel.IComponent()
        Dim textbox As System.Windows.Forms.TextBox = CType(host.CreateComponent(GetType(TextBox)), TextBox)

        ' Because the designer resets the text of the textbox, use 
        ' a SetTextMethodHandler to set the text to the value of 
        ' the text data.
        Dim c As Control = host.RootComponent

        c.BeginInvoke(New SetTextMethodHandler(AddressOf OnSetText), New Object() {textbox, [text]})

        Return New System.ComponentModel.IComponent() {textbox}
    End Function

    ' Method to set the text property of a TextBox after it is initialized.
    Private Sub OnSetText(ByVal c As Control, ByVal [text] As String)
        c.Text = [text]
    End Sub

End Class

[C#] 
using System;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Drawing;
using System.Drawing.Design;
using System.Windows.Forms;

namespace TextDataTextBoxComponent
{
    // Component that adds a "Text" data format ToolboxItemCreatorCallback 
    // to the Toolbox that creates a custom ToolboxItem that 
    // creates a TextBox containing the text data.
    public class TextDataTextBoxComponent : System.ComponentModel.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)
        {
            string[] formats = ((System.Windows.Forms.DataObject)serializedObject).GetFormats();
            if( ((System.Windows.Forms.DataObject)serializedObject).GetDataPresent("System.String", true) )           
                return new TextToolboxItem( (string)((System.Windows.Forms.DataObject)serializedObject).GetData("System.String", true) );            
            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 : System.Drawing.Design.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.
        [System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Demand, Name="FullTrust")] 
        protected override System.ComponentModel.IComponent[] CreateComponentsCore(System.ComponentModel.Design.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;
        }
    }
}

[C++] 
#using <mscorlib.dll>
#using <System.Windows.Forms.dll>
#using <System.Drawing.dll>
#using <System.dll>

using namespace System;
using namespace System::ComponentModel;
using namespace System::ComponentModel::Design;
using namespace System::Drawing;
using namespace System::Drawing::Design;
using namespace System::Windows::Forms;

namespace TextDataTextBoxComponent {

   // Custom toolbox item creates a TextBox and sets its Text property
   // to the constructor-specified text.
public __gc class TextToolboxItem : public System::Drawing::Design::ToolboxItem {
private:
   String*  text;
   __delegate void SetTextMethodHandler(Control* c, String*  text);

public:
   TextToolboxItem(String* text) : ToolboxItem() {
      this->text = text;
   }

   // ToolboxItem::CreateComponentsCore  to create the TextBox
   // and link a method to set its Text property.
protected:
   [System::Security::Permissions::PermissionSet(System::Security::Permissions::SecurityAction::Demand, Name="FullTrust")]
   System::ComponentModel::IComponent* CreateComponentsCore(System::ComponentModel::Design::IDesignerHost* host)[] {
      System::Windows::Forms::TextBox* textbox = dynamic_cast<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 = dynamic_cast<Control*>(host->RootComponent);

      Object* temp0 [] = {textbox, text};
      c->BeginInvoke(new SetTextMethodHandler(this, &TextToolboxItem::OnSetText), temp0);

      System::ComponentModel::IComponent* temp1 [] = {textbox};
      return temp1;
   }

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

// Component that adds a "Text" data format ToolboxItemCreatorCallback
// to the Toolbox that creates a custom ToolboxItem that
// creates a TextBox containing the text data.
public __gc class TextDataTextBoxComponent : public System::ComponentModel::Component {
private:
   bool  creatorAdded;
   IToolboxService*  ts;

public:
   TextDataTextBoxComponent() {
      creatorAdded = false;
   }

   // ISite to register TextBox creator
   __property System::ComponentModel::ISite* get_Site() {
      return Component::get_Site();
   }
   __property void set_Site(System::ComponentModel::ISite* value) {
      if (value != 0) {
         Component::set_Site(value);
         if (!creatorAdded)
            AddTextTextBoxCreator();
      } else {
         if (creatorAdded)
            RemoveTextTextBoxCreator();
         Component::set_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 = dynamic_cast<IToolboxService*>(GetService(__typeof(IToolboxService)));
      if (ts != 0) {
         ToolboxItemCreatorCallback* textCreator = new ToolboxItemCreatorCallback(this, &TextDataTextBoxComponent::CreateTextBoxForText);
         try {
            ts->AddCreator(textCreator, S"Text", dynamic_cast<IDesignerHost*>(GetService(__typeof(IDesignerHost))));
            creatorAdded = true;
         } catch (Exception* ex) {
            MessageBox::Show(ex->ToString(), S"Exception Information");
         }
      }
   }

   // Removes any "Text" data format creator from the toolbox.
   void RemoveTextTextBoxCreator() {
      if (ts != 0) {
         ts->RemoveCreator(S"Text", dynamic_cast<IDesignerHost*>(GetService(__typeof(IDesignerHost))));
         creatorAdded = false;
      }
   }

   // ToolboxItemCreatorCallback delegate format method to create
   // the toolbox item.
   ToolboxItem* CreateTextBoxForText(Object* serializedObject, String* format) {
      String* formats[] = (dynamic_cast<System::Windows::Forms::DataObject*>(serializedObject))->GetFormats();
      if ((dynamic_cast<System::Windows::Forms::DataObject*>(serializedObject))->GetDataPresent(S"System::String", true))
         return new TextToolboxItem(dynamic_cast<String*>((dynamic_cast<System::Windows::Forms::DataObject*>(serializedObject))->GetData(S"System::String", true)));
      return 0;
   }

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

}

[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button Language Filter in the upper-left corner of the page.

Requirements

Namespace: System.Drawing.Design

Platforms: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 family

Assembly: System.Drawing (in System.Drawing.dll)

See Also

IToolboxService Members | System.Drawing.Design Namespace

Show: