ParentControlDesigner Clase

Definición

Espacio de nombres:

System.Windows.Forms.Design

Ensamblado:

System.Windows.Forms.Design.dll

Extiende el comportamiento del modo de diseño de Control que admite controles anidados.

public ref class ParentControlDesigner : System::Windows::Forms::Design::ControlDesigner

public class ParentControlDesigner : System.Windows.Forms.Design.ControlDesigner

type ParentControlDesigner = class
    inherit ControlDesigner

Public Class ParentControlDesigner
Inherits ControlDesigner

Herencia

Object

ComponentDesigner

ControlDesigner

ParentControlDesigner

Derivado

System.Windows.Forms.Design.ScrollableControlDesigner

Ejemplos

En el ejemplo siguiente se muestra cómo implementar un personalizado ParentControlDesigner. Este ejemplo de código forma parte de un ejemplo más grande proporcionado para la IToolboxUser interfaz .

#using <System.Drawing.dll>
#using <System.dll>
#using <System.Design.dll>
#using <System.Windows.Forms.dll>

using namespace System;
using namespace System::Collections;
using namespace System::ComponentModel;
using namespace System::ComponentModel::Design;
using namespace System::Diagnostics;
using namespace System::Drawing;
using namespace System::Drawing::Design;
using namespace System::Windows::Forms;
using namespace 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.
public ref class SampleRootDesigner;

// The following attribute associates the SampleRootDesigner with this example component.

[DesignerAttribute(__typeof(SampleRootDesigner),__typeof(IRootDesigner))]
public ref class RootDesignedComponent: public Control{};


// 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 ref class RootViewSampleComponent: public RootDesignedComponent{};


// 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(S"System.Windows.Forms",ToolboxItemFilterType::Custom)]
public ref class SampleRootDesigner: public ParentControlDesigner, public IRootDesigner, public IToolboxUser
{
public private:
   ref class RootDesignerView;

private:

   // This field is a custom Control type named RootDesignerView. This field references
   // a control that is shown in the design mode document window.
   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.
   array<String^>^blockedTypeNames;

public:
   SampleRootDesigner()
   {
      array<String^>^tempTypeNames = {"System.Windows.Forms.ListBox","System.Windows.Forms.GroupBox"};
      blockedTypeNames = tempTypeNames;
   }


private:

   property array<ViewTechnology>^ SupportedTechnologies 
   {

      // IRootDesigner.SupportedTechnologies is a required override for an IRootDesigner.
      // This designer provides a display using the Windows Forms view technology.
      array<ViewTechnology>^ IRootDesigner::get()
      {
         ViewTechnology temp0[] = {ViewTechnology::WindowsForms};
         return temp0;
      }

   }

   // 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::WindowsForms )
            throw gcnew ArgumentException( "An unsupported view technology was requested","Unsupported view technology." );

      
      // Creates the view object if it has not yet been initialized.
      if ( view == nullptr )
            view = gcnew 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*/ ){}


public private:

   // This control provides a Windows Forms view technology view object that 
   // provides a display for the SampleRootDesigner.

   [DesignerAttribute(__typeof(ParentControlDesigner),__typeof(IDesigner))]
   ref class RootDesignerView: public Control
   {
   private:

      // This field stores a reference to a designer.
      IDesigner^ m_designer;

   public:
      RootDesignerView( IDesigner^ designer )
      {
         
         // Perform basic control initialization.
         m_designer = designer;
         BackColor = Color::Blue;
         Font = gcnew System::Drawing::Font( Font->FontFamily->Name,24.0f );
      }


   protected:

      // This method is called to draw the view for the SampleRootDesigner.
      void OnPaint( PaintEventArgs^ pe )
      {
         Control::OnPaint( pe );
         
         // Draw the name of the component in large letters.
         pe->Graphics->DrawString( m_designer->Component->Site->Name, Font, Brushes::Yellow, ClientRectangle );
      }

   };


};

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

Imports System.Collections
Imports System.ComponentModel
Imports System.ComponentModel.Design
Imports System.Diagnostics
Imports System.Drawing
Imports System.Drawing.Design
Imports System.Windows.Forms
Imports 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.
' 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
    Inherits RootDesignedComponent
End Class

' The following attribute associates the SampleRootDesigner with this example component.
<DesignerAttribute(GetType(SampleRootDesigner), GetType(IRootDesigner))> _
Public Class RootDesignedComponent
    Inherits System.Windows.Forms.Control
End Class

' 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.PermissionSetAttribute(System.Security.Permissions.SecurityAction.Demand, Name:="FullTrust")> _
Public Class SampleRootDesigner
    Inherits ParentControlDesigner
    Implements IRootDesigner, IToolboxUser

    ' Member field of custom type RootDesignerView, a control that is shown in the 
    ' design mode document window. This member is cached to reduce processing needed 
    ' to recreate the view control on each call to GetView().
    Private m_view As RootDesignerView

    ' 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 blockedTypeNames As String() = {"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.
    ReadOnly Property SupportedTechnologies() As ViewTechnology() Implements IRootDesigner.SupportedTechnologies
        Get
            Return New ViewTechnology() {ViewTechnology.Default}
        End Get
    End Property

    ' This method returns an object that provides the view for this root designer. 
    Function GetView(ByVal technology As ViewTechnology) As Object Implements IRootDesigner.GetView
        ' If the design environment requests a view technology other than Windows 
        ' Forms, this method throws an Argument Exception.
        If technology <> ViewTechnology.Default Then
            Throw New ArgumentException("An unsupported view technology was requested", "Unsupported view technology.")
        End If

        ' Creates the view object if it has not yet been initialized.
        If m_view Is Nothing Then
            m_view = New RootDesignerView(Me)
        End If
        Return m_view
    End Function

    ' This method can signal whether to enable or disable the specified
    ' ToolboxItem when the component associated with this designer is selected.
    Function GetToolSupported(ByVal tool As ToolboxItem) As Boolean Implements IToolboxUser.GetToolSupported
        ' 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.
        Dim i As Integer
        For i = 0 To blockedTypeNames.Length - 1
            If tool.TypeName = blockedTypeNames(i) Then
                Return False
            End If
        Next i ' 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
    End Function

    ' 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.
    Sub ToolPicked(ByVal tool As ToolboxItem) Implements IToolboxUser.ToolPicked
    End Sub

    ' This control provides a Windows Forms view technology view object that 
    ' provides a display for the SampleRootDesigner.
    <DesignerAttribute(GetType(ParentControlDesigner), GetType(IDesigner))> _
    Friend Class RootDesignerView
        Inherits Control
        ' This field stores a reference to a designer.
        Private m_designer As IDesigner

        Public Sub New(ByVal designer As IDesigner)
            ' Performs basic control initialization.
            m_designer = designer
            BackColor = Color.Blue
            Font = New Font(Font.FontFamily.Name, 24.0F)
        End Sub

        ' This method is called to draw the view for the SampleRootDesigner.
        Protected Overrides Sub OnPaint(ByVal pe As PaintEventArgs)
            MyBase.OnPaint(pe)
            ' Draws the name of the component in large letters.
            pe.Graphics.DrawString(m_designer.Component.Site.Name, Font, Brushes.Yellow, New RectangleF(ClientRectangle.X, ClientRectangle.Y, ClientRectangle.Width, ClientRectangle.Height))
        End Sub
    End Class
End Class

Comentarios

ParentControlDesigner proporciona una clase base para diseñadores de controles que pueden contener controles secundarios. Además de los métodos y la funcionalidad heredados de las ControlDesigner clases y ComponentDesigner , ParentControlDesigner permite que los controles secundarios se agreguen, quiten de, seleccionen y organicen dentro del control cuyo comportamiento se extiende en tiempo de diseño.

Puede asociar un diseñador a un tipo mediante .DesignerAttribute Para obtener información general sobre cómo personalizar el comportamiento del tiempo de diseño, consulte Extensión de Design-Time compatibilidad.

Constructores

ParentControlDesigner()

Inicializa una nueva instancia de la clase ParentControlDesigner.

Campos

accessibilityObj

Especifica el objeto de accesibilidad para el diseñador. (Heredado de ControlDesigner)

Propiedades

AccessibilityObject	Obtiene AccessibleObject asignado al control. (Heredado de ControlDesigner)
ActionLists	Obtiene las listas de acciones en tiempo de diseño que admite el componente asociado al diseñador. (Heredado de ComponentDesigner)
AllowControlLasso	Obtiene un valor que indica si los controles seleccionados volverán a ser principales.
AllowGenericDragBox	Obtiene un valor que indica si se debe dibujar un cuadro de arrastre genérico al arrastrar un elemento del cuadro de herramientas sobre la superficie del diseñador.
AllowSetChildIndexOnDrop	Obtiene un valor que indica si se debe mantener el orden Z de los controles arrastrados cuando se colocan en un control ParentControlDesigner.
AssociatedComponents	Obtiene la colección de componentes asociados al componente administrado por el diseñador. (Heredado de ControlDesigner)
AutoResizeHandles	Obtiene o establece un valor que indica si la asignación del controlador de cambio de tamaño depende del valor de la propiedad AutoSize. (Heredado de ControlDesigner)
BehaviorService	Obtiene el BehaviorService del entorno de diseño. (Heredado de ControlDesigner)
Component	Obtiene el componente que el diseñador está creando. (Heredado de ComponentDesigner)
Control	Obtiene el control que diseña el diseñador. (Heredado de ControlDesigner)
DefaultControlLocation	Obtiene la ubicación predeterminada de un control agregado al diseñador.
DrawGrid	Obtiene o establece un valor que indica si se debe dibujar una cuadrícula en el control para este diseñador.
EnableDragRect	Obtiene un valor que indica si el diseñador dibuja rectángulos de arrastre.
GridSize	Obtiene o establece el tamaño de cada cuadro de la cuadrícula que se dibuja cuando el diseñador está en modo de dibujo de cuadrícula.
InheritanceAttribute	Obtiene el InheritanceAttribute del diseñador. (Heredado de ControlDesigner)
Inherited	Obtiene un valor que indica si este componente es heredado. (Heredado de ComponentDesigner)
MouseDragTool	Obtiene un valor que indica si el diseñador tiene una herramienta válida durante una operación de arrastre.
ParentComponent	Obtiene el componente principal de ControlDesigner. (Heredado de ControlDesigner)
ParticipatesWithSnapLines	Obtiene un valor que indica si ControlDesigner permitirá la alineación de las líneas de ajuste durante una operación de arrastre. (Heredado de ControlDesigner)
SelectionRules	Obtiene las reglas de selección que indican las posibilidades de movimiento de un componente. (Heredado de ControlDesigner)
SetTextualDefaultProperty	Extiende el comportamiento del modo de diseño de Control que admite controles anidados. (Heredado de ComponentDesigner)
ShadowProperties	Obtiene una colección de valores de propiedad que reemplazan la configuración del usuario. (Heredado de ComponentDesigner)
SnapLines	Obtiene una lista de objetos SnapLine que representan los puntos de alineación significativos de este control.
Verbs	Obtiene los verbos en tiempo de diseño que admite el componente asociado al diseñador. (Heredado de ComponentDesigner)

Métodos

AddPaddingSnapLines(ArrayList)	Agrega las líneas de ajuste del relleno.
BaseWndProc(Message)	Procesa los mensajes de Windows. (Heredado de ControlDesigner)
CanAddComponent(IComponent)	Se invoca cuando se agrega un componente al contenedor primario.
CanBeParentedTo(IDesigner)	Indica si el control del diseñador especificado puede ser el principal de este control de diseñador. (Heredado de ControlDesigner)
CanParent(Control)	Indica si el control especificado puede ser secundario del control que administra este diseñador.
CanParent(ControlDesigner)	Indica si el control administrado por el diseñador especificado puede ser secundario del control que administra este diseñador.
CreateTool(ToolboxItem)	Crea un componente o control a partir de la herramienta especificada y lo agrega al documento de diseño actual.
CreateTool(ToolboxItem, Point)	Crea un componente o control a partir de la herramienta especificada y lo agrega al documento de diseño actual en la ubicación especificada.
CreateTool(ToolboxItem, Rectangle)	Crea un componente o control a partir de la herramienta especificada y lo agrega al documento de diseño actual dentro de los límites del rectángulo especificado.
CreateToolCore(ToolboxItem, Int32, Int32, Int32, Int32, Boolean, Boolean)	Proporciona la funcionalidad central de todos los métodos CreateTool(ToolboxItem).
DefWndProc(Message)	Proporciona procesamiento predeterminado para los mensajes de Windows. (Heredado de ControlDesigner)
DisplayError(Exception)	Muestra información al usuario acerca de la excepción especificada. (Heredado de ControlDesigner)
Dispose()	Libera todos los recursos que usa ComponentDesigner. (Heredado de ComponentDesigner)
Dispose(Boolean)	Libera los recursos no administrados utilizados por el objeto ParentControlDesigner y, de forma opcional, libera los recursos administrados.
DoDefaultAction()	Crea una firma de método en el archivo de código fuente para el evento predeterminado del componente y hace navegar el cursor del usuario en esa ubicación. (Heredado de ComponentDesigner)
EnableDesignMode(Control, String)	Habilita la funcionalidad en tiempo de diseño para un control secundario. (Heredado de ControlDesigner)
EnableDragDrop(Boolean)	Habilita o deshabilita la compatibilidad con arrastrar y colocar del control que se está diseñando. (Heredado de ControlDesigner)
Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
GetControl(Object)	Obtiene el control del componente especificado desde el diseñador.
GetControlGlyph(GlyphSelectionType)	Obtiene un glifo del cuerpo que representa los límites del control.
GetGlyphs(GlyphSelectionType)	Obtiene una colección de objetos Glyph que representan los bordes de selección y los identificadores de agarre de un control estándar.
GetHashCode()	Sirve como la función hash predeterminada. (Heredado de Object)
GetHitTest(Point)	Indica si el control debe controlar un clic con el mouse en el punto especificado. (Heredado de ControlDesigner)
GetParentForComponent(IComponent)	Utilizado por clases derivadas para determinar si devuelve el control que se está dibujando o algún otro control Container al agregarle un componente.
GetService(Type)	Intenta recuperar el tipo de servicio especificado del sitio en modo de diseño del componente del diseñador. (Heredado de ComponentDesigner)
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
GetUpdatedRect(Rectangle, Rectangle, Boolean)	Actualiza la posición del rectángulo especificado y lo alinea en la cuadrícula si el modo de alineación en la cuadrícula está habilitado.
HookChildControls(Control)	Enruta los mensajes desde los controles secundarios del control especificado al diseñador. (Heredado de ControlDesigner)
Initialize(IComponent)	Inicializa el diseñador con el componente especificado.
InitializeExistingComponent(IDictionary)	Vuelve a inicializar un componente existente. (Heredado de ControlDesigner)
InitializeNewComponent(IDictionary)	Inicializa un componente recién creado.
InitializeNonDefault()	Inicializa las propiedades del control con los valores no predeterminados. (Heredado de ControlDesigner)
InternalControlDesigner(Int32)	Devuelve al diseñador de controles internos el índice especificado en ControlDesigner. (Heredado de ControlDesigner)
InvokeCreateTool(ParentControlDesigner, ToolboxItem)	Crea una herramienta a partir del ToolboxItem especificado.
InvokeGetInheritanceAttribute(ComponentDesigner)	Obtiene el objeto InheritanceAttribute de la enumeración ComponentDesigner especificada. (Heredado de ComponentDesigner)
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
NumberOfInternalControlDesigners()	Devuelve el número de diseñadores de controles internos en ControlDesigner. (Heredado de ControlDesigner)
OnContextMenu(Int32, Int32)	Muestra el menú contextual y permite realizar otros procesos adicionales cuando el menú contextual está a punto de mostrarse. (Heredado de ControlDesigner)
OnCreateHandle()	Permite realizar otros procesos adicionales inmediatamente después de crear el identificador del control. (Heredado de ControlDesigner)
OnDragComplete(DragEventArgs)	Llamado para limpiar una operación de arrastrar y colocar.
OnDragDrop(DragEventArgs)	Se le llama cuando un objeto de arrastrar y colocar se coloca en la vista del diseñador del control.
OnDragEnter(DragEventArgs)	Se le llama cuando un objeto de arrastrar y colocar entra en la vista del diseñador del control.
OnDragLeave(EventArgs)	Se llama cuando un objeto de arrastrar y colocar sale de la vista del diseñador del control.
OnDragOver(DragEventArgs)	Se le llama cuando un objeto de arrastrar y colocar se arrastra sobre la vista del diseñador del control.
OnGiveFeedback(GiveFeedbackEventArgs)	Recibe una llamada mientras se está realizando una operación de arrastrar y colocar para proporcionar guías visuales basadas en la ubicación del mouse cuando se está realizando una operación de arrastre. (Heredado de ControlDesigner)
OnMouseDragBegin(Int32, Int32)	Se le llama cuando se presiona el botón primario del mouse y se mantiene presionado mientras está sobre el componente.
OnMouseDragEnd(Boolean)	Se le llama al final de una operación de arrastrar y colocar para terminar o cancelar la operación.
OnMouseDragMove(Int32, Int32)	Se le llama en cada movimiento del mouse durante una operación de arrastrar y colocar.
OnMouseEnter()	Recibe una llamada cuando el mouse entra en el control por primera vez. (Heredado de ControlDesigner)
OnMouseHover()	Recibe una llamada después de que el mouse se desplace sobre el control. (Heredado de ControlDesigner)
OnMouseLeave()	Recibe una llamada cuando el mouse entra en el control por primera vez. (Heredado de ControlDesigner)
OnPaintAdornments(PaintEventArgs)	Se llama cuando el control que el diseñador está administrando tiene su superficie dibujada, de manera que el diseñador pueda dibujar otros adornos en la parte superior del control.
OnSetComponentDefaults()	Obsoletos. Se llama cuando se inicializa el diseñador. (Heredado de ControlDesigner)
OnSetCursor()	Permite cambiar el cursor actual del mouse.
PostFilterAttributes(IDictionary)	Permite a un diseñador cambiar o quitar elementos en el conjunto de atributos que expone mediante un TypeDescriptor. (Heredado de ComponentDesigner)
PostFilterEvents(IDictionary)	Permite a un diseñador cambiar o quitar elementos del conjunto de eventos que expone mediante un objeto TypeDescriptor. (Heredado de ComponentDesigner)
PostFilterProperties(IDictionary)	Permite a un diseñador cambiar o quitar elementos del conjunto de propiedades que expone mediante un objeto TypeDescriptor. (Heredado de ComponentDesigner)
PreFilterAttributes(IDictionary)	Permite a un diseñador agregar elementos al conjunto de atributos que expone mediante un objeto TypeDescriptor. (Heredado de ComponentDesigner)
PreFilterEvents(IDictionary)	Permite a un diseñador agregar elementos al conjunto de eventos que expone mediante un objeto TypeDescriptor. (Heredado de ComponentDesigner)
PreFilterProperties(IDictionary)	Ajusta el conjunto de propiedades que el componente expondrá mediante un TypeDescriptor.
RaiseComponentChanged(MemberDescriptor, Object, Object)	Notifica a IComponentChangeService que este componente se ha cambiado. (Heredado de ComponentDesigner)
RaiseComponentChanging(MemberDescriptor)	Notifica a IComponentChangeService que este componente se va a cambiar. (Heredado de ComponentDesigner)
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)
UnhookChildControls(Control)	Enruta los mensajes para los secundarios del control especificado a cada uno de los controles en lugar de a un diseñador principal. (Heredado de ControlDesigner)
WndProc(Message)	Procesa los mensajes de Windows y, de forma opcional, los enruta al control. (Heredado de ControlDesigner)

Implementaciones de interfaz explícitas

IDesignerFilter.PostFilterAttributes(IDictionary)	Para obtener una descripción de este miembro, vea el método PostFilterAttributes(IDictionary). (Heredado de ComponentDesigner)
IDesignerFilter.PostFilterEvents(IDictionary)	Para obtener una descripción de este miembro, vea el método PostFilterEvents(IDictionary). (Heredado de ComponentDesigner)
IDesignerFilter.PostFilterProperties(IDictionary)	Para obtener una descripción de este miembro, vea el método PostFilterProperties(IDictionary). (Heredado de ComponentDesigner)
IDesignerFilter.PreFilterAttributes(IDictionary)	Para obtener una descripción de este miembro, vea el método PreFilterAttributes(IDictionary). (Heredado de ComponentDesigner)
IDesignerFilter.PreFilterEvents(IDictionary)	Para obtener una descripción de este miembro, vea el método PreFilterEvents(IDictionary). (Heredado de ComponentDesigner)
IDesignerFilter.PreFilterProperties(IDictionary)	Para obtener una descripción de este miembro, vea el método PreFilterProperties(IDictionary). (Heredado de ComponentDesigner)
ITreeDesigner.Children	Para una descripción de este miembro, consulte la propiedad Children. (Heredado de ComponentDesigner)
ITreeDesigner.Parent	Para una descripción de este miembro, consulte la propiedad Parent. (Heredado de ComponentDesigner)

Consulte también

• ControlDesigner
• ComponentDesigner
• IDesigner
• IDesignerFilter
• DesignerAttribute
• Ampliar compatibilidad en tiempo de diseño