Partager via


ParentControlDesigner Classe

Définition

Étend le comportement en mode design d’un Control qui prend en charge les contrôles imbriqués.

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
ParentControlDesigner
Dérivé

Exemples

L’exemple suivant montre comment implémenter un personnalisé ParentControlDesigner. Cet exemple de code fait partie d’un exemple plus grand 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.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

Remarques

ParentControlDesigner fournit une classe de base pour les concepteurs de contrôles qui peuvent contenir des contrôles enfants. En plus des méthodes et fonctionnalités héritées des ControlDesigner classes et ComponentDesigner , ParentControlDesigner permet d’ajouter, de supprimer, de sélectionner et d’organiser des contrôles enfants au sein du contrôle dont le comportement est étendu au moment du design.

Vous pouvez associer un concepteur à un type à l’aide d’un DesignerAttribute. Pour obtenir une vue d’ensemble de la personnalisation du comportement au moment de la conception, consultez Extension de la prise en charge Design-Time.

Constructeurs

ParentControlDesigner()

Initialise une nouvelle instance de la classe ParentControlDesigner.

Champs

accessibilityObj

Spécifie l'objet d'accessibilité pour le concepteur.

(Hérité de ControlDesigner)

Propriétés

AccessibilityObject

Obtient le AccessibleObject assigné 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 à nouveau apparentés.

AllowGenericDragBox

Obtient une valeur qui indique si une zone de glisser générique doit être dessinée lors du glisser-déplacer d'un élément de boîte à outils sur la surface du concepteur.

AllowSetChildIndexOnDrop

Obtient une valeur qui indique si l'ordre de plan des contrôles déplacés par glisser-déplacer doit être maintenu lorsque ceux-ci sont placés 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 poignée de redimensionnement dépend de la valeur de la propriété AutoSize.

(Hérité de ControlDesigner)
BehaviorService

Obtient le BehaviorService de l'environnement de design.

(Hérité de ControlDesigner)
Component

Obtient le composant qui est créé par ce concepteur.

(Hérité de ComponentDesigner)
Control

Obtient le contrôle qui est créé par le concepteur.

(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 la grille doit être dessinée sur le contrôle pour 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 qui est dessinée lorsque le concepteur est en mode grille.

InheritanceAttribute

Obtient le InheritanceAttribute du concepteur.

(Hérité de ControlDesigner)
Inherited

Obtient une valeur indiquant si ce composant est hérité.

(Hérité de ComponentDesigner)
MouseDragTool

Obtient une valeur qui indique si le concepteur possède un outil valide durant une opération glisser.

ParentComponent

Obtient le composant parent de ControlDesigner.

(Hérité de ControlDesigner)
ParticipatesWithSnapLines

Obtient une valeur indiquant si le ControlDesigner doit autoriser l'alignement sur les lignes d'alignement (SnapLines) pendant une opération glisser.

(Hérité de ControlDesigner)
SelectionRules

Obtient les règles de sélection qui indiquent les possibilités de mouvement d'un composant.

(Hérité de ControlDesigner)
SetTextualDefaultProperty

Étend le comportement en mode design d’un Control qui prend en charge les contrôles imbriqués.

(Hérité de ComponentDesigner)
ShadowProperties

Obtient une collection de valeurs de propriétés qui substituent les paramètres utilisateur.

(Hérité de ComponentDesigner)
SnapLines

Obtient une liste d'objets SnapLine qui représentent des points d'alignement significatifs pour ce contrôle.

SnapLines

Obtient une liste d'objets SnapLine qui représentent des points d'alignement significatifs pour ce contrôle.

(Hérité de ControlDesigner)
Verbs

Obtient les verbes de design pris en charge par le composant associé au concepteur.

(Hérité de ComponentDesigner)

Méthodes

AddPaddingSnapLines(ArrayList)

Ajoute des lignes d'alignement (SnapLines) de marge intérieure.

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 apparenté au 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 managé par ce concepteur.

CanParent(ControlDesigner)

Indique si le contrôle managé par le concepteur spécifié peut être un enfant du contrôle managé par ce concepteur.

CreateTool(ToolboxItem)

Crée un composant ou un contrôle à partir de l'outil spécifié et l'ajoute au document de design en cours.

CreateTool(ToolboxItem, Point)

Crée un composant ou un contrôle à partir de l'outil spécifié et l'ajoute au document de design en cours, à 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 design en cours, à l'intérieur du rectangle spécifié.

CreateToolCore(ToolboxItem, Int32, Int32, Int32, Int32, Boolean, Boolean)

Fournit les fonctionnalités principales de toutes les méthodes CreateTool(ToolboxItem).

DefWndProc(Message)

Fournit le traitement par défaut pour les messages Windows.

(Hérité de ControlDesigner)
DisplayError(Exception)

Affiche des informations sur l'exception spécifiée pour l'utilisateur.

(Hérité de ControlDesigner)
Dispose()

Libère toutes les ressources utilisées par 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 de l'événement par défaut du composant et déplace le curseur de l'utilisateur jusqu'à cet emplacement.

(Hérité de ComponentDesigner)
EnableDesignMode(Control, String)

Active les fonctionnalités de design pour un contrôle enfant.

(Hérité de ControlDesigner)
EnableDragDrop(Boolean)

Active ou désactive la prise en charge de la fonctionnalité glisser-déplacer pour le contrôle en cours de création.

(Hérité de ControlDesigner)
Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

(Hérité de Object)
GetControl(Object)

Obtient le contrôle à partir du concepteur du composant spécifié.

GetControlGlyph(GlyphSelectionType)

Obtient un glyphe de corps qui représente les limites du contrôle.

GetControlGlyph(GlyphSelectionType)

Retourne un ControlBodyGlyph représentant les limites de ce contrôle.

(Hérité de ControlDesigner)
GetGlyphs(GlyphSelectionType)

Obtient une collection d'objets Glyph qui représentent les bordures de sélection et les poignées de manipulation d'un contrôle standard.

GetGlyphs(GlyphSelectionType)

Obtient une collection d'objets Glyph qui représentent les bordures de sélection et les poignées de manipulation d'un contrôle standard.

(Hérité de ControlDesigner)
GetHashCode()

Fait office de fonction de hachage par défaut.

(Hérité de Object)
GetHitTest(Point)

Indique si le contrôle doit gérer un clic de souris à un emplacement spécifié.

(Hérité de ControlDesigner)
GetParentForComponent(IComponent)

Utilisée par les classes dérivées pour déterminer si elle retourne le contrôle en cours de conception ou un autre Container en lui ajoutant un composant.

GetService(Type)

Tente de récupérer le type spécifié de service du composant du concepteur du site en mode Design.

(Hérité de ComponentDesigner)
GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
GetUpdatedRect(Rectangle, Rectangle, Boolean)

Met à jour la position du rectangle spécifié, en ajustant son alignement par rapport à la grille lorsque le mode grille est activé.

HookChildControls(Control)

Achemine les messages à partir 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)

Réinitialise un composant existant.

(Hérité de ControlDesigner)
InitializeNewComponent(IDictionary)

Initialise un composant nouvellement créé.

InitializeNewComponent(IDictionary)

Initialise un composant nouvellement créé.

(Hérité de ControlDesigner)
InitializeNonDefault()

Initialise les propriétés du contrôle dans une valeur non définie par défaut.

(Hérité de ControlDesigner)
InternalControlDesigner(Int32)

Retourne le Concepteur de contrôles internes avec l'index spécifié dans ControlDesigner.

(Hérité de ControlDesigner)
InvokeCreateTool(ParentControlDesigner, ToolboxItem)

Crée un outil à partir du ToolboxItem spécifié.

InvokeGetInheritanceAttribute(ComponentDesigner)

Obtient le InheritanceAttribute du ComponentDesigner spécifié.

(Hérité de ComponentDesigner)
MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
NumberOfInternalControlDesigners()

Retourne le nombre de Concepteurs de contrôles internes dans ControlDesigner.

(Hérité de ControlDesigner)
OnContextMenu(Int32, Int32)

Affiche le menu contextuel et fournit une possibilité de traitement supplémentaire lorsque le menu contextuel est sur le point d'être affiché.

(Hérité de ControlDesigner)
OnCreateHandle()

Fournit une possibilité de traitement supplémentaire immédiatement après la création du handle du contrôle.

(Hérité de ControlDesigner)
OnDragComplete(DragEventArgs)

Appelée dans le but de nettoyer une opération glisser-déplacer.

OnDragComplete(DragEventArgs)

Reçoit un appel pour nettoyer une opération glisser-déplacer.

(Hérité de ControlDesigner)
OnDragDrop(DragEventArgs)

Appelée lorsqu'un objet glissé est déplacé sur la vue de Concepteur de contrôles.

OnDragEnter(DragEventArgs)

Appelée lorsqu'une opération glisser-déplacer entre dans la vue de Concepteur de contrôles.

OnDragLeave(EventArgs)

Appelée lorsqu'une opération glisser-déplacer sort de la vue de Concepteur de contrôles.

OnDragOver(DragEventArgs)

Appelée lorsqu'un objet glissé-déplacé est glissé sur la vue de Concepteur de contrôles.

OnGiveFeedback(GiveFeedbackEventArgs)

Appelée quand une opération de glisser-déplacer est en cours pour fournir des indications visuelles en fonction de la position du curseur de la souris pendant l’opération de glisser.

OnGiveFeedback(GiveFeedbackEventArgs)

Reçoit un appel durant une opération glisser-déplacer pour fournir des indications visuelles en fonction de la position du curseur de la souris tandis que l'opération glisser est en cours.

(Hérité de ControlDesigner)
OnMouseDragBegin(Int32, Int32)

Appelée lorsque le bouton gauche de la souris est maintenu enfoncé au-dessus du composant.

OnMouseDragEnd(Boolean)

Appelée à la fin d'une opération glisser-déplacer pour terminer ou annuler l'opération.

OnMouseDragMove(Int32, Int32)

Appelée pour chaque mouvement de la souris pendant une opération glisser-déplacer.

OnMouseEnter()

Appelée quand la souris entre initialement dans le contrôle.

OnMouseEnter()

Reçoit un appel lorsque la souris entre initialement dans le contrôle.

(Hérité de ControlDesigner)
OnMouseHover()

Appelée après que le curseur de la souris est placé sur le contrôle.

OnMouseHover()

Reçoit un appel après que la souris pointe sur le contrôle.

(Hérité de ControlDesigner)
OnMouseLeave()

Appelée quand la souris entre initialement dans le contrôle.

OnMouseLeave()

Reçoit un appel lorsque la souris entre initialement dans le contrôle.

(Hérité de ControlDesigner)
OnPaintAdornments(PaintEventArgs)

Appelée lorsque le contrôle que le concepteur manage a peint sa surface de sorte que le concepteur puisse peindre d'autres motifs par-dessus le contrôle.

OnSetComponentDefaults()
Obsolète.
Obsolète.

Appelée quand le concepteur est initialisé.

(Hérité de ControlDesigner)
OnSetCursor()

Fournit une possibilité 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 à l'aide 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 à l'aide 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 à l'aide d'un TypeDescriptor.

(Hérité de ComponentDesigner)
PreFilterAttributes(IDictionary)

Permet à un concepteur d'ajouter des éléments à l'ensemble d'attributs qu'il expose à l'aide d'un TypeDescriptor.

(Hérité de ComponentDesigner)
PreFilterEvents(IDictionary)

Permet à un concepteur d'ajouter des éléments à l'ensemble d'événements qu'il expose à l'aide d'un TypeDescriptor.

(Hérité de ComponentDesigner)
PreFilterProperties(IDictionary)

Ajuste le jeu de propriétés exposées par le composant à l'aide de TypeDescriptor.

RaiseComponentChanged(MemberDescriptor, Object, Object)

Avertit le IComponentChangeService que ce composant a été modifié.

(Hérité de ComponentDesigner)
RaiseComponentChanging(MemberDescriptor)

Avertit le IComponentChangeService que ce composant est sur le point d'être modifié.

(Hérité de ComponentDesigner)
ToString()

Retourne une chaîne qui représente l'objet actuel.

(Hérité de Object)
UnhookChildControls(Control)

Achemine les messages pour les enfants du contrôle spécifié vers chaque contrôle plutôt que vers un concepteur parent.

(Hérité de ControlDesigner)
WndProc(Message)

Traite les messages Windows.

WndProc(Message)

Traite les messages Windows et les achemine éventuellement vers le contrôle.

(Hérité de ControlDesigner)

Implémentations d’interfaces explicites

IDesignerFilter.PostFilterAttributes(IDictionary)

Pour obtenir une description de ce membre, consultez la méthode PostFilterAttributes(IDictionary).

(Hérité de ComponentDesigner)
IDesignerFilter.PostFilterEvents(IDictionary)

Pour obtenir une description de ce membre, consultez la méthode PostFilterEvents(IDictionary).

(Hérité de ComponentDesigner)
IDesignerFilter.PostFilterProperties(IDictionary)

Pour obtenir une description de ce membre, consultez la méthode PostFilterProperties(IDictionary).

(Hérité de ComponentDesigner)
IDesignerFilter.PreFilterAttributes(IDictionary)

Pour obtenir une description de ce membre, consultez la méthode PreFilterAttributes(IDictionary).

(Hérité de ComponentDesigner)
IDesignerFilter.PreFilterEvents(IDictionary)

Pour obtenir une description de ce membre, consultez la méthode PreFilterEvents(IDictionary).

(Hérité de ComponentDesigner)
IDesignerFilter.PreFilterProperties(IDictionary)

Pour obtenir une description de ce membre, consultez la méthode PreFilterProperties(IDictionary).

(Hérité de ComponentDesigner)
ITreeDesigner.Children

Pour obtenir une description de ce membre, consultez la propriétéChildren.

(Hérité de ComponentDesigner)
ITreeDesigner.Parent

Pour obtenir une description de ce membre, consultez la propriétéParent.

(Hérité de ComponentDesigner)

S’applique à

Voir aussi