ParentControlDesigner Classe

Definição

Namespace:

System.Windows.Forms.Design

Assembly:

System.Windows.Forms.Design.dll

Estende o comportamento do modo de design de um Control que dá suporte a controles aninhados.

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

Herança

Object

ComponentDesigner

ControlDesigner

ParentControlDesigner

Derivado

System.Windows.Forms.Design.ScrollableControlDesigner

Exemplos

O exemplo a seguir demonstra como implementar um personalizado ParentControlDesigner. Este exemplo de código faz parte de um exemplo maior fornecido para a IToolboxUser interface .

#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

Comentários

ParentControlDesigner fornece uma classe base para designers de controles que podem conter controles filho. Além dos métodos e da funcionalidade herdados das classes e ComponentDesigner , ParentControlDesigner permite que os ControlDesigner controles filho sejam adicionados, removidos, selecionados dentro e organizados dentro do controle cujo comportamento ele estende em tempo de design.

Você pode associar um designer a um tipo usando um DesignerAttribute. Para obter uma visão geral da personalização do comportamento do tempo de design, consulte Estendendo Design-Time suporte.

Construtores

ParentControlDesigner()

Inicializa uma nova instância da classe ParentControlDesigner.

Campos

accessibilityObj

Especifica o objeto de acessibilidade do designer. (Herdado de ControlDesigner)

Propriedades

AccessibilityObject	Obtém o AccessibleObject atribuído ao controle. (Herdado de ControlDesigner)
ActionLists	Obtém as listas de ação de tempo de design com suporte pelo componente associado ao designer. (Herdado de ComponentDesigner)
AllowControlLasso	Obtém um valor que indica se os controles selecionados terão o parentesco redefinido.
AllowGenericDragBox	Obtém um valor que indica se uma caixa de arrastar genérica deve ser desenhada ao arrastar o item da caixa de ferramentas sobre a superfície de designer.
AllowSetChildIndexOnDrop	Obtém um valor que indica se a ordem z de controles arrastados deve ser mantida quando solto em um ParentControlDesigner.
AssociatedComponents	Obtém a coleção de componentes associados ao componente gerenciado pelo designer. (Herdado de ControlDesigner)
AutoResizeHandles	Obtém ou define um valor que indica se redimensionar a alocação de identificador depende do valor da propriedade AutoSize. (Herdado de ControlDesigner)
BehaviorService	Obtém o BehaviorService do ambiente de design. (Herdado de ControlDesigner)
Component	Obtém o componente que deste designer está criando. (Herdado de ComponentDesigner)
Control	Obtém o controle que o designer está criando. (Herdado de ControlDesigner)
DefaultControlLocation	Obtém o local padrão para um controle adicionado ao designer.
DrawGrid	Obtém ou define um valor que indica se uma grade deve ser desenhada no controle para este designer.
EnableDragRect	Obtém um valor que indica se retângulos de arraste são desenhados pelo designer.
GridSize	Obtém ou define o tamanho de cada quadrado da grade que é desenhada quando o designer está no modo de desenho de grade.
InheritanceAttribute	Obtém o InheritanceAttribute do designer. (Herdado de ControlDesigner)
Inherited	Obtém um valor que indica se este componente é herdado. (Herdado de ComponentDesigner)
MouseDragTool	Obtém um valor que indica se o designer tem uma ferramenta válida durante uma operação do tipo arrastar.
ParentComponent	Obtém o componente pai do ControlDesigner. (Herdado de ControlDesigner)
ParticipatesWithSnapLines	Obtém um valor que indica se o ControlDesigner permitirá que o alinhamento da guia de alinhamento durante uma operação do tipo arrastar. (Herdado de ControlDesigner)
SelectionRules	Obtém as regras de seleção que indicam os recursos de movimentação de um componente. (Herdado de ControlDesigner)
SetTextualDefaultProperty	Estende o comportamento do modo de design de um Control que dá suporte a controles aninhados. (Herdado de ComponentDesigner)
ShadowProperties	Obtém uma coleção de valores de propriedade que substituem as configurações do usuário. (Herdado de ComponentDesigner)
SnapLines	Obtém uma lista de objetos SnapLine que representam os pontos de alinhamento significativos desse controle.
Verbs	Obtém os verbos de tempo de design com suporte pelo componente associado ao designer. (Herdado de ComponentDesigner)

Métodos

AddPaddingSnapLines(ArrayList)	Adiciona guias de alinhamento de preenchimento.
BaseWndProc(Message)	Processa mensagens do Windows. (Herdado de ControlDesigner)
CanAddComponent(IComponent)	Chamado quando um componente é adicionado ao contêiner pai.
CanBeParentedTo(IDesigner)	Indica se esse controle do designer pode ter o controle do designer especificado como pai. (Herdado de ControlDesigner)
CanParent(Control)	Indica se o controle especificado pode ser um filho do controle gerenciado por este designer.
CanParent(ControlDesigner)	Indica se o controle gerenciado pelo designer especificado pode ser um filho do controle gerenciado por este designer.
CreateTool(ToolboxItem)	Cria um componente ou controle da ferramenta especificada e o adiciona ao documento de design atual.
CreateTool(ToolboxItem, Point)	Cria um componente ou controle da ferramenta especificada e o adiciona ao documento de design atual no local especificado.
CreateTool(ToolboxItem, Rectangle)	Cria um componente ou controle da ferramenta especificada e o adiciona ao documento de design atual dentro dos limites do retângulo especificado.
CreateToolCore(ToolboxItem, Int32, Int32, Int32, Int32, Boolean, Boolean)	Fornece a funcionalidade básica para todos os métodos CreateTool(ToolboxItem).
DefWndProc(Message)	Fornece o processamento padrão para mensagens do Windows. (Herdado de ControlDesigner)
DisplayError(Exception)	Exibe informações sobre a exceção especificada para o usuário. (Herdado de ControlDesigner)
Dispose()	Libera todos os recursos usados pelo ComponentDesigner. (Herdado de ComponentDesigner)
Dispose(Boolean)	Libera os recursos não gerenciados usados pelo ParentControlDesigner e opcionalmente libera os recursos gerenciados.
DoDefaultAction()	Cria uma assinatura de método no arquivo de código-fonte para o evento padrão no componente e navega o cursor do usuário para essa localização. (Herdado de ComponentDesigner)
EnableDesignMode(Control, String)	Habilita a funcionalidade de tempo de design para um controle filho. (Herdado de ControlDesigner)
EnableDragDrop(Boolean)	Habilita ou desabilita o suporte do tipo "arrastar e soltar" do controle que está sendo criado. (Herdado de ControlDesigner)
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetControl(Object)	Obtém o controle do designer do componente especificado.
GetControlGlyph(GlyphSelectionType)	Obtém ou define um glifo que representa os limites do controle.
GetGlyphs(GlyphSelectionType)	Obtém uma coleção de objetos Glyph que representam as bordas de seleção e as alças de captura de um controle padrão.
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetHitTest(Point)	Indica se um clique do mouse no ponto especificado deve ser manipulado pelo controle. (Herdado de ControlDesigner)
GetParentForComponent(IComponent)	Usado derivando classes para determinar se ele retorna o controle sendo criado ou algum outro Container durante a adição do componente a ele.
GetService(Type)	Tenta recuperar o tipo de serviço especificado do site no modo de design do componente do designer. (Herdado de ComponentDesigner)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
GetUpdatedRect(Rectangle, Rectangle, Boolean)	Atualiza a posição do retângulo especificado, ajustando-o para o alinhamento de grade se o modo de alinhamento de grade está habilitado.
HookChildControls(Control)	Encaminha mensagens dos controles filho do controle especificado para o designer. (Herdado de ControlDesigner)
Initialize(IComponent)	Inicializa o designer com o componente especificado.
InitializeExistingComponent(IDictionary)	Reinicializa um componente existente. (Herdado de ControlDesigner)
InitializeNewComponent(IDictionary)	Inicializa um componente recém-criado.
InitializeNonDefault()	Inicializa as propriedades do controle com qualquer valor não padrão. (Herdado de ControlDesigner)
InternalControlDesigner(Int32)	Retorna o designer de controle interno com o índice especificado no ControlDesigner. (Herdado de ControlDesigner)
InvokeCreateTool(ParentControlDesigner, ToolboxItem)	Cria uma ferramenta do ToolboxItem especificado.
InvokeGetInheritanceAttribute(ComponentDesigner)	Obtém o InheritanceAttribute do ComponentDesigner especificado. (Herdado de ComponentDesigner)
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
NumberOfInternalControlDesigners()	Retorna o número de designers de controle interno no ControlDesigner. (Herdado de ControlDesigner)
OnContextMenu(Int32, Int32)	Mostra o menu de contexto e oferece uma oportunidade de executar processamento adicional quando o menu de contexto está prestes a ser exibido. (Herdado de ControlDesigner)
OnCreateHandle()	Oferece uma oportunidade de executar processamento adicional imediatamente após a criação da alça de controle. (Herdado de ControlDesigner)
OnDragComplete(DragEventArgs)	Chamado para limpar uma operação do tipo "arrastar e soltar".
OnDragDrop(DragEventArgs)	Chamado quando um objeto do tipo "arrastar e soltar" é solto no modo de exibição do designer do controle.
OnDragEnter(DragEventArgs)	Chamado quando uma operação do tipo "arrastar e soltar" entra na exibição do designer do controle.
OnDragLeave(EventArgs)	Chamado quando uma operação do tipo "arrastar e soltar" sai da exibição do designer do controle.
OnDragOver(DragEventArgs)	Chamado quando um objeto do tipo "arrastar e soltar" é arrastado sobre a exibição do designer do controle.
OnGiveFeedback(GiveFeedbackEventArgs)	Recebe uma chamada quando uma operação do tipo "arrastar e soltar" está em andamento para fornecer dicas visuais com base no local do mouse enquanto uma operação do tipo "arrastar" está em andamento. (Herdado de ControlDesigner)
OnMouseDragBegin(Int32, Int32)	Chamada em resposta quando o botão esquerdo do mouse é pressionado e segurado enquanto está sobre o componente.
OnMouseDragEnd(Boolean)	Chamado no final de uma operação do tipo "arrastar e soltar" para concluir ou cancelar a operação.
OnMouseDragMove(Int32, Int32)	Chamada para cada movimento do mouse durante uma operação do tipo "arrastar e soltar".
OnMouseEnter()	Recebe uma chamada quando o mouse entra pela primeira vez no controle. (Herdado de ControlDesigner)
OnMouseHover()	Recebe uma chamada depois que o mouse passa sobre o controle. (Herdado de ControlDesigner)
OnMouseLeave()	Recebe uma chamada quando o mouse entra pela primeira vez no controle. (Herdado de ControlDesigner)
OnPaintAdornments(PaintEventArgs)	Chamada quando o controle que o designer está gerenciando pinta sua superfície para que o designer possa pintar quaisquer adornos adicionais sobre o controle.
OnSetComponentDefaults()	Obsoleto. Chamado quando o designer é inicializado. (Herdado de ControlDesigner)
OnSetCursor()	Fornece uma oportunidade para alterar o cursor do mouse atual.
PostFilterAttributes(IDictionary)	Permite que um designer altere ou remova itens do conjunto de atributos que ele expõe por meio de um TypeDescriptor. (Herdado de ComponentDesigner)
PostFilterEvents(IDictionary)	Permite que um designer altere ou remova itens do conjunto de eventos que ele expõe por meio de um TypeDescriptor. (Herdado de ComponentDesigner)
PostFilterProperties(IDictionary)	Permite que um designer altere ou remova itens do conjunto de propriedades que ele expõe por meio de um TypeDescriptor. (Herdado de ComponentDesigner)
PreFilterAttributes(IDictionary)	Permite um designer seja adicionado ao conjunto de atributos que ele expõe por meio de um TypeDescriptor. (Herdado de ComponentDesigner)
PreFilterEvents(IDictionary)	Permite um designer seja adicionado ao conjunto de eventos que ele expõe por meio de um TypeDescriptor. (Herdado de ComponentDesigner)
PreFilterProperties(IDictionary)	Ajusta o conjunto de propriedades que o componente exporá por meio de um TypeDescriptor.
RaiseComponentChanged(MemberDescriptor, Object, Object)	Notifica o IComponentChangeService de que este componente foi alterado. (Herdado de ComponentDesigner)
RaiseComponentChanging(MemberDescriptor)	Notifica o IComponentChangeService de que este componente está prestes a ser alterado. (Herdado de ComponentDesigner)
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)
UnhookChildControls(Control)	Encaminha mensagens dos filhos do controle especificado para cada controle em vez de para um designer pai. (Herdado de ControlDesigner)
WndProc(Message)	Processa mensagens do Windows e, opcionalmente, encaminha-as para o controle. (Herdado de ControlDesigner)

Implantações explícitas de interface

IDesignerFilter.PostFilterAttributes(IDictionary)	Para obter uma descrição desse membro, consulte o método PostFilterAttributes(IDictionary). (Herdado de ComponentDesigner)
IDesignerFilter.PostFilterEvents(IDictionary)	Para obter uma descrição desse membro, consulte o método PostFilterEvents(IDictionary). (Herdado de ComponentDesigner)
IDesignerFilter.PostFilterProperties(IDictionary)	Para obter uma descrição desse membro, consulte o método PostFilterProperties(IDictionary). (Herdado de ComponentDesigner)
IDesignerFilter.PreFilterAttributes(IDictionary)	Para obter uma descrição desse membro, consulte o método PreFilterAttributes(IDictionary). (Herdado de ComponentDesigner)
IDesignerFilter.PreFilterEvents(IDictionary)	Para obter uma descrição desse membro, consulte o método PreFilterEvents(IDictionary). (Herdado de ComponentDesigner)
IDesignerFilter.PreFilterProperties(IDictionary)	Para obter uma descrição desse membro, consulte o método PreFilterProperties(IDictionary). (Herdado de ComponentDesigner)
ITreeDesigner.Children	Para obter uma descrição desse membro, consulte o propriedade Children. (Herdado de ComponentDesigner)
ITreeDesigner.Parent	Para obter uma descrição desse membro, consulte o propriedade Parent. (Herdado de ComponentDesigner)

Confira também

• ControlDesigner
• ComponentDesigner
• IDesigner
• IDesignerFilter
• DesignerAttribute
• Estendendo o suporte para tempo de design