ParentControlDesigner Classe

Définition

Espace de noms:

System.Windows.Forms.Design

Assembly:

System.Windows.Forms.Design.dll

Source:

ParentControlDesigner.cs

Étend le comportement du mode de conception d’un Control contrôle imbriqué.

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

Héritage

Object

ComponentDesigner

ControlDesigner

ParentControlDesigner

Dérivé

System.Windows.Forms.Design.ScrollableControlDesigner

Exemples

L’exemple suivant montre comment implémenter un fichier personnalisé ParentControlDesigner. Cet exemple de code fait partie d’un exemple plus large fourni pour l’interface IToolboxUser .

#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.ComponentModel;
using System.ComponentModel.Design;
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.
[Designer(typeof(SampleRootDesigner), typeof(IRootDesigner))]
public class RootDesignedComponent : 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".
[ToolboxItemFilter("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.
    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.
    readonly 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 => [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",
            nameof(technology));
        }

        // Creates the view object if it has not yet been initialized.
        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.
    [Designer(typeof(ParentControlDesigner), typeof(IDesigner))]
    internal class RootDesignerView : Control
    {
        // This field stores a reference to a designer.
        readonly 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

Remarques

ParentControlDesigner fournit une classe de base pour les concepteurs de contrôles qui peuvent contenir des contrôles enfants. Outre les méthodes et fonctionnalités héritées des ControlDesigner classes et ComponentDesigner des méthodes, ParentControlDesigner permet aux contrôles enfants d’être ajoutés, supprimés, sélectionnés et organisés dans le contrôle dont le comportement s’étend au moment du design.

Vous pouvez associer un concepteur à un type à l’aide d’un DesignerAttribute.

Constructeurs

Nom	Description
ParentControlDesigner()	Initialise une nouvelle instance de la classe ParentControlDesigner.

Champs

Nom	Description
accessibilityObj	Spécifie l’objet d’accessibilité pour le concepteur. (Hérité de ControlDesigner)

Propriétés

Nom	Description
AccessibilityObject	Obtient l’affectation AccessibleObject au contrôle. (Hérité de ControlDesigner)
ActionLists	Obtient les listes d’actions au moment du design prises en charge par le composant associé au concepteur. (Hérité de ComponentDesigner)
AllowControlLasso	Obtient une valeur indiquant si les contrôles sélectionnés seront re-parentés.
AllowGenericDragBox	Obtient une valeur indiquant si une zone de glisser générique doit être dessinée lors du glissement d’un élément de boîte à outils sur l’aire du concepteur.
AllowSetChildIndexOnDrop	Obtient une valeur indiquant si l’ordre z des contrôles déplacés doit être conservé lorsqu’il est supprimé sur un ParentControlDesigner.
AssociatedComponents	Obtient la collection de composants associés au composant géré par le concepteur. (Hérité de ControlDesigner)
AutoResizeHandles	Obtient ou définit une valeur indiquant si l’allocation de handle de redimensionnement dépend de la valeur de la AutoSize propriété. (Hérité de ControlDesigner)
BehaviorService	Obtient l’environnement BehaviorService de conception. (Hérité de ControlDesigner)
Component	Obtient le composant que ce concepteur conçoit. (Hérité de ComponentDesigner)
Control	Obtient le contrôle que le concepteur conçoit. (Hérité de ControlDesigner)
DefaultControlLocation	Obtient l’emplacement par défaut d’un contrôle ajouté au concepteur.
DrawGrid	Obtient ou définit une valeur indiquant si une grille doit être dessinée sur le contrôle de ce concepteur.
EnableDragRect	Obtient une valeur indiquant si les rectangles de glissement sont dessinés par le concepteur.
GridSize	Obtient ou définit la taille de chaque carré de la grille dessinée lorsque le concepteur est en mode dessin de grille.
InheritanceAttribute	Obtient le InheritanceAttribute concepteur. (Hérité de ControlDesigner)
Inherited	Obtient une valeur indiquant si ce composant est hérité. (Hérité de ComponentDesigner)
MouseDragTool	Obtient une valeur indiquant si le concepteur a un outil valide pendant une opération de glissement.
ParentComponent	Obtient le composant parent pour le ControlDesigner. (Hérité de ControlDesigner)
ParticipatesWithSnapLines	Obtient une valeur indiquant si l’alignement ControlDesigner de la ligne d’alignement est autorisé pendant une opération de glissement. (Hérité de ControlDesigner)
SelectionRules	Obtient les règles de sélection qui indiquent les fonctionnalités de déplacement d’un composant. (Hérité de ControlDesigner)
SetTextualDefaultProperty	Étend le comportement du mode de conception d’un Control contrôle imbriqué. (Hérité de ComponentDesigner)
ShadowProperties	Obtient une collection de valeurs de propriété qui remplacent les paramètres utilisateur. (Hérité de ComponentDesigner)
SnapLines	Obtient une liste d’objets représentant des points d’alignement SnapLine significatifs pour ce contrôle.
Verbs	Obtient les verbes au moment du design pris en charge par le composant associé au concepteur. (Hérité de ComponentDesigner)

Méthodes

Nom	Description
AddPaddingSnapLines(ArrayList)	Ajoute des alignements de remplissage.
BaseWndProc(Message)	Traite les messages Windows. (Hérité de ControlDesigner)
CanAddComponent(IComponent)	Appelé lorsqu’un composant est ajouté au conteneur parent.
CanBeParentedTo(IDesigner)	Indique si le contrôle de ce concepteur peut être parenté par le contrôle du concepteur spécifié. (Hérité de ControlDesigner)
CanParent(Control)	Indique si le contrôle spécifié peut être un enfant du contrôle géré par ce concepteur.
CanParent(ControlDesigner)	Indique si le contrôle géré par le concepteur spécifié peut être un enfant du contrôle géré par ce concepteur.
CreateTool(ToolboxItem, Point)	Crée un composant ou un contrôle à partir de l’outil spécifié et l’ajoute au document de conception actuel à l’emplacement spécifié.
CreateTool(ToolboxItem, Rectangle)	Crée un composant ou un contrôle à partir de l’outil spécifié et l’ajoute au document de conception actuel dans les limites du rectangle spécifié.
CreateTool(ToolboxItem)	Crée un composant ou un contrôle à partir de l’outil spécifié et l’ajoute au document de conception actuel.
CreateToolCore(ToolboxItem, Int32, Int32, Int32, Int32, Boolean, Boolean)	Fournit des fonctionnalités principales pour toutes les CreateTool(ToolboxItem) méthodes.
DefWndProc(Message)	Fournit le traitement par défaut des messages Windows. (Hérité de ControlDesigner)
DisplayError(Exception)	Affiche des informations sur l’exception spécifiée à l’utilisateur. (Hérité de ControlDesigner)
Dispose()	Libère toutes les ressources utilisées par le ComponentDesigner. (Hérité de ComponentDesigner)
Dispose(Boolean)	Libère les ressources non managées utilisées par le ParentControlDesigner, et libère éventuellement les ressources managées.
DoDefaultAction()	Crée une signature de méthode dans le fichier de code source pour l’événement par défaut sur le composant et accède au curseur de l’utilisateur à cet emplacement. (Hérité de ComponentDesigner)
EnableDesignMode(Control, String)	Active la fonctionnalité du temps de conception pour un contrôle enfant. (Hérité de ControlDesigner)
EnableDragDrop(Boolean)	Active ou désactive la prise en charge de glisser-déplacer pour le contrôle en cours de conception. (Hérité de ControlDesigner)
GetControl(Object)	Obtient le contrôle du concepteur du composant spécifié.
GetControlGlyph(GlyphSelectionType)	Obtient un glyphe de corps qui représente les limites du contrôle.
GetGlyphs(GlyphSelectionType)	Obtient une collection d’objets représentant les bordures de Glyph sélection et les poignées de saisie pour un contrôle standard.
GetHitTest(Point)	Indique si un clic de souris au point spécifié doit être géré par le contrôle. (Hérité de ControlDesigner)
GetParentForComponent(IComponent)	Utilisé en dérivant des classes pour déterminer s’il retourne le contrôle conçu ou un autre Container lors de l’ajout d’un composant à celui-ci.
GetService(Type)	Tente de récupérer le type de service spécifié à partir du site en mode conception du composant du concepteur. (Hérité de ComponentDesigner)
GetUpdatedRect(Rectangle, Rectangle, Boolean)	Met à jour la position du rectangle spécifié, en l’ajustant pour l’alignement de la grille si le mode d’alignement de la grille est activé.
HookChildControls(Control)	Route les messages des contrôles enfants du contrôle spécifié vers le concepteur. (Hérité de ControlDesigner)
Initialize(IComponent)	Initialise le concepteur avec le composant spécifié.
InitializeExistingComponent(IDictionary)	Initialise à nouveau un composant existant. (Hérité de ControlDesigner)
InitializeNewComponent(IDictionary)	Initialise un composant nouvellement créé.
InternalControlDesigner(Int32)	Retourne le concepteur de contrôles interne avec l’index spécifié dans le ControlDesigner. (Hérité de ControlDesigner)
InvokeCreateTool(ParentControlDesigner, ToolboxItem)	Crée un outil à partir du fichier spécifié ToolboxItem.
InvokeGetInheritanceAttribute(ComponentDesigner)	Obtient le InheritanceAttributeComponentDesigner. (Hérité de ComponentDesigner)
NumberOfInternalControlDesigners()	Retourne le nombre de concepteurs de contrôles internes dans le ControlDesigner. (Hérité de ControlDesigner)
OnContextMenu(Int32, Int32)	Affiche le menu contextuel et offre la possibilité d’effectuer un traitement supplémentaire lorsque le menu contextuel est sur le point d’être affiché. (Hérité de ControlDesigner)
OnCreateHandle()	Offre la possibilité d’effectuer un traitement supplémentaire immédiatement après la création du handle de contrôle. (Hérité de ControlDesigner)
OnDragComplete(DragEventArgs)	Appelé pour nettoyer une opération de glisser-déplacer.
OnDragDrop(DragEventArgs)	Appelé lorsqu’un objet glisser-déplacer est déposé dans la vue du concepteur de contrôles.
OnDragEnter(DragEventArgs)	Appelée lorsqu’une opération de glisser-déplacer entre en mode Concepteur de contrôles.
OnDragLeave(EventArgs)	Appelé lorsqu’une opération de glisser-déplacer quitte la vue du concepteur de contrôles.
OnDragOver(DragEventArgs)	Appelé lorsqu’un objet glisser-déplacer est déplacé sur la vue du concepteur de contrôles.
OnGiveFeedback(GiveFeedbackEventArgs)	Reçoit un appel lorsqu’une opération de glisser-déplacer est en cours pour fournir des signaux visuels en fonction de l’emplacement de la souris pendant qu’une opération de glissement est en cours. (Hérité de ControlDesigner)
OnMouseDragBegin(Int32, Int32)	Appelé en réponse au bouton gauche de la souris enfoncé et maintenu pendant le composant.
OnMouseDragEnd(Boolean)	Appelé à la fin d’une opération de glisser-déplacer pour terminer ou annuler l’opération.
OnMouseDragMove(Int32, Int32)	Appelé pour chaque mouvement de la souris pendant une opération de glisser-déplacer.
OnMouseEnter()	Reçoit un appel lorsque la souris entre d’abord dans le contrôle. (Hérité de ControlDesigner)
OnMouseHover()	Reçoit un appel après que la souris pointe sur le contrôle. (Hérité de ControlDesigner)
OnMouseLeave()	Reçoit un appel lorsque la souris entre d’abord dans le contrôle. (Hérité de ControlDesigner)
OnPaintAdornments(PaintEventArgs)	Appelé lorsque le contrôle que le concepteur gère a peint sa surface afin que le concepteur puisse peindre des ornements supplémentaires sur le contrôle.
OnSetComponentDefaults()	Obsolète. Appelé lorsque le concepteur est initialisé. (Hérité de ControlDesigner)
OnSetCursor()	Permet de modifier le curseur de la souris actuel.
PostFilterAttributes(IDictionary)	Permet à un concepteur de modifier ou de supprimer des éléments de l’ensemble d’attributs qu’il expose par le biais d’un TypeDescriptor. (Hérité de ComponentDesigner)
PostFilterEvents(IDictionary)	Permet à un concepteur de modifier ou de supprimer des éléments de l’ensemble d’événements qu’il expose par le biais d’un TypeDescriptor. (Hérité de ComponentDesigner)
PostFilterProperties(IDictionary)	Permet à un concepteur de modifier ou de supprimer des éléments de l’ensemble de propriétés qu’il expose par le biais d’un TypeDescriptor. (Hérité de ComponentDesigner)
PreFilterAttributes(IDictionary)	Permet à un concepteur d’ajouter à l’ensemble d’attributs qu’il expose par le biais d’un TypeDescriptor. (Hérité de ComponentDesigner)
PreFilterEvents(IDictionary)	Permet à un concepteur d’ajouter à l’ensemble d’événements qu’il expose par le biais d’un TypeDescriptor. (Hérité de ComponentDesigner)
PreFilterProperties(IDictionary)	Ajuste l’ensemble des propriétés que le composant expose par le biais d’un TypeDescriptor.
RaiseComponentChanged(MemberDescriptor, Object, Object)	Avertit que IComponentChangeService ce composant a été modifié. (Hérité de ComponentDesigner)
RaiseComponentChanging(MemberDescriptor)	Avertit que IComponentChangeService ce composant est sur le point d’être modifié. (Hérité de ComponentDesigner)
UnhookChildControls(Control)	Route les messages pour les enfants du contrôle spécifié vers chaque contrôle plutôt qu’vers un concepteur parent. (Hérité de ControlDesigner)
WndProc(Message)	Traite Windows messages et les achemine éventuellement vers le contrôle. (Hérité de ControlDesigner)

Implémentations d’interfaces explicites

Nom	Description
IDesignerFilter.PostFilterAttributes(IDictionary)	Pour obtenir une description de ce membre, consultez la PostFilterAttributes(IDictionary) méthode. (Hérité de ComponentDesigner)
IDesignerFilter.PostFilterEvents(IDictionary)	Pour obtenir une description de ce membre, consultez la PostFilterEvents(IDictionary) méthode. (Hérité de ComponentDesigner)
IDesignerFilter.PostFilterProperties(IDictionary)	Pour obtenir une description de ce membre, consultez la PostFilterProperties(IDictionary) méthode. (Hérité de ComponentDesigner)
IDesignerFilter.PreFilterAttributes(IDictionary)	Pour obtenir une description de ce membre, consultez la PreFilterAttributes(IDictionary) méthode. (Hérité de ComponentDesigner)
IDesignerFilter.PreFilterEvents(IDictionary)	Pour obtenir une description de ce membre, consultez la PreFilterEvents(IDictionary) méthode. (Hérité de ComponentDesigner)
IDesignerFilter.PreFilterProperties(IDictionary)	Pour obtenir une description de ce membre, consultez la PreFilterProperties(IDictionary) méthode. (Hérité de ComponentDesigner)
ITreeDesigner.Children	Pour obtenir une description de ce membre, consultez la Children propriété. (Hérité de ComponentDesigner)
ITreeDesigner.Parent	Pour obtenir une description de ce membre, consultez la Parent propriété. (Hérité de ComponentDesigner)

Voir aussi

• ControlDesigner
• ComponentDesigner
• IDesigner
• IDesignerFilter
• DesignerAttribute