ToolboxItemFilterAttribute Class
Specifies the filter string and filter type to use for a toolbox item.
Assembly: System (in System.dll)
| Name | Description | |
|---|---|---|
![]() | ToolboxItemFilterAttribute(String) | Initializes a new instance of the ToolboxItemFilterAttribute class using the specified filter string. |
![]() | ToolboxItemFilterAttribute(String, ToolboxItemFilterType) | Initializes a new instance of the ToolboxItemFilterAttribute class using the specified filter string and type. |
| Name | Description | |
|---|---|---|
![]() | FilterString | Gets the filter string for the toolbox item. |
![]() | FilterType | Gets the type of the filter. |
![]() | TypeId | Gets the type ID for the attribute.(Overrides Attribute.TypeId.) |
| Name | Description | |
|---|---|---|
![]() | Equals(Object) | Returns a value that indicates whether this instance is equal to a specified object.(Overrides Attribute.Equals(Object).) |
![]() | GetHashCode() | Returns the hash code for this instance.(Overrides Attribute.GetHashCode().) |
![]() | GetType() | |
![]() | IsDefaultAttribute() | When overridden in a derived class, indicates whether the value of this instance is the default value for the derived class.(Inherited from Attribute.) |
![]() | Match(Object) | Indicates whether the specified object has a matching filter string.(Overrides Attribute.Match(Object).) |
![]() | ToString() | Returns a string that represents the current object.(Overrides Object.ToString().) |
| Name | Description | |
|---|---|---|
![]() ![]() | _Attribute.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) | Maps a set of names to a corresponding set of dispatch identifiers.(Inherited from Attribute.) |
![]() ![]() | _Attribute.GetTypeInfo(UInt32, UInt32, IntPtr) | Retrieves the type information for an object, which can be used to get the type information for an interface.(Inherited from Attribute.) |
![]() ![]() | _Attribute.GetTypeInfoCount(UInt32) | Retrieves the number of type information interfaces that an object provides (either 0 or 1).(Inherited from Attribute.) |
![]() ![]() | _Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) | Provides access to properties and methods exposed by an object.(Inherited from Attribute.) |
ToolboxItemFilterAttribute provides a mechanism by which toolbox items can be marked for use only with designers that have a matching attribute or code that determines whether the item should be enabled or disabled in the toolbox.
A ToolboxItemFilterAttribute can be applied to a ToolboxItem to indicate a filter string and filter type that specify when to enable or disable the item. ToolboxItemFilterAttribute can also be applied to a designer to indicate its requirements for enabling items in the toolbox. This type of attribute can be used to indicate that a toolbox item can only be enabled when a designer with a matching filter string is being used. The type of the filter is indicated in the FilterType property by a ToolboxItemFilterType that indicates whether and how a filter string match is used, or whether to use custom code to determine whether to enable an item.
The following code example demonstrates how to apply the ToolboxItemFilterAttribute.
using System; using System.Collections; using System.ComponentModel; using System.ComponentModel.Design; using System.Diagnostics; using System.Drawing; using System.Drawing.Design; using System.Windows.Forms; using System.Windows.Forms.Design; // This example contains an IRootDesigner that implements the IToolboxUser interface. // This example demonstrates how to enable the GetToolSupported method of an IToolboxUser // designer in order to disable specific toolbox items, and how to respond to the // invocation of a ToolboxItem in the ToolPicked method of an IToolboxUser implementation. namespace IToolboxUserExample { // This example component class demonstrates the associated IRootDesigner which // implements the IToolboxUser interface. When designer view is invoked, Visual // Studio .NET attempts to display a design mode view for the class at the top // of a code file. This can sometimes fail when the class is one of multiple types // in a code file, and has a DesignerAttribute associating it with an IRootDesigner. // Placing a derived class at the top of the code file solves this problem. A // derived class is not typically needed for this reason, except that placing the // RootDesignedComponent class in another file is not a simple solution for a code // example that is packaged in one segment of code. public class RootViewSampleComponent : RootDesignedComponent { } // The following attribute associates the SampleRootDesigner with this example component. [DesignerAttribute(typeof(SampleRootDesigner), typeof(IRootDesigner))] public class RootDesignedComponent : System.Windows.Forms.Control { } // This example IRootDesigner implements the IToolboxUser interface and provides a // Windows Forms view technology view for its associated component using an internal // Control type. // The following ToolboxItemFilterAttribute enables the GetToolSupported method of this // IToolboxUser designer to be queried to check for whether to enable or disable all // ToolboxItems which create any components whose type name begins with "System.Windows.Forms". [ToolboxItemFilterAttribute("System.Windows.Forms", ToolboxItemFilterType.Custom)] [System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Demand, Name = "FullTrust")] public class SampleRootDesigner : ParentControlDesigner, IRootDesigner, IToolboxUser { // This field is a custom Control type named RootDesignerView. This field references // a control that is shown in the design mode document window. private RootDesignerView view; // This string array contains type names of components that should not be added to // the component managed by this designer from the Toolbox. Any ToolboxItems whose // type name matches a type name in this array will be marked disabled according to // the signal returned by the IToolboxUser.GetToolSupported method of this designer. private string[] blockedTypeNames = { "System.Windows.Forms.ListBox", "System.Windows.Forms.GroupBox" }; // IRootDesigner.SupportedTechnologies is a required override for an IRootDesigner. // This designer provides a display using the Windows Forms view technology. ViewTechnology[] IRootDesigner.SupportedTechnologies { get { return new ViewTechnology[] {ViewTechnology.Default}; } } // This method returns an object that provides the view for this root designer. object IRootDesigner.GetView(ViewTechnology technology) { // If the design environment requests a view technology other than Windows // Forms, this method throws an Argument Exception. if (technology != ViewTechnology.Default) throw new ArgumentException("An unsupported view technology was requested", "Unsupported view technology."); // Creates the view object if it has not yet been initialized. if (view == null) view = new RootDesignerView(this); return view; } // This method can signal whether to enable or disable the specified // ToolboxItem when the component associated with this designer is selected. bool IToolboxUser.GetToolSupported(ToolboxItem tool) { // Search the blocked type names array for the type name of the tool // for which support for is being tested. Return false to indicate the // tool should be disabled when the associated component is selected. for( int i=0; i<blockedTypeNames.Length; i++ ) if( tool.TypeName == blockedTypeNames[i] ) return false; // Return true to indicate support for the tool, if the type name of the // tool is not located in the blockedTypeNames string array. return true; } // This method can perform behavior when the specified tool has been invoked. // Invocation of a ToolboxItem typically creates a component or components, // and adds any created components to the associated component. void IToolboxUser.ToolPicked(ToolboxItem tool) { } // This control provides a Windows Forms view technology view object that // provides a display for the SampleRootDesigner. [DesignerAttribute(typeof(ParentControlDesigner), typeof(IDesigner))] internal class RootDesignerView : Control { // This field stores a reference to a designer. private IDesigner m_designer; public RootDesignerView(IDesigner designer) { // Perform basic control initialization. m_designer = designer; BackColor = Color.Blue; Font = new Font(Font.FontFamily.Name, 24.0f); } // This method is called to draw the view for the SampleRootDesigner. protected override void OnPaint(PaintEventArgs pe) { base.OnPaint(pe); // Draw the name of the component in large letters. pe.Graphics.DrawString(m_designer.Component.Site.Name, Font, Brushes.Yellow, ClientRectangle); } } } }
Available since 1.1
Any public static ( Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.



