ParentControlDesigner Klasse

Definition

Namespace:

System.Windows.Forms.Design

Assembly:

System.Windows.Forms.Design.dll

Erweitert das Entwurfsmodusverhalten eines Control, das geschachtelte Steuerelemente unterstützt.

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

Vererbung

Object

ComponentDesigner

ControlDesigner

ParentControlDesigner

Abgeleitet

System.Windows.Forms.Design.ScrollableControlDesigner

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie eine benutzerdefinierte ParentControlDesignerimplementiert wird. Dieses Codebeispiel ist Teil eines größeren Beispiels für die IToolboxUser -Schnittstelle.

#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

Hinweise

ParentControlDesigner stellt eine Basisklasse für Designer von Steuerelementen bereit, die untergeordnete Steuerelemente enthalten können. Zusätzlich zu den Methoden und Funktionen, die von den ControlDesigner Klassen und ComponentDesigner geerbt werden, ParentControlDesigner können untergeordnete Steuerelemente hinzugefügt, daraus entfernt, innerhalb des Steuerelements ausgewählt und innerhalb des Steuerelements angeordnet werden, dessen Verhalten zur Entwurfszeit erweitert wird.

Sie können einen Designer mit DesignerAttributeeinem -Typ zuordnen. Eine Übersicht über das Anpassen des Entwurfszeitverhaltens finden Sie unter Erweitern Design-Time Support.

Konstruktoren

ParentControlDesigner()

Initialisiert eine neue Instanz der ParentControlDesigner-Klasse.

Felder

accessibilityObj

Gibt das Objekt für die Barrierefreiheit für den Designer an. (Geerbt von ControlDesigner)

Eigenschaften

AccessibilityObject	Ruft das dem Steuerelement zugewiesene AccessibleObject ab. (Geerbt von ControlDesigner)
ActionLists	Ruft die Entwurfszeit-Aktionslisten ab, die von der dem Designer zugeordneten Komponente unterstützt werden. (Geerbt von ComponentDesigner)
AllowControlLasso	Ruft einen Wert ab, der angibt, ob ausgewählte Steuerelemente wieder untergeordnet werden.
AllowGenericDragBox	Ruft einen Wert ab, der angibt, ob ein generisches Ziehfeld gezeichnet werden soll, wenn ein Toolboxelement über die Designeroberfläche gezogen wird.
AllowSetChildIndexOnDrop	Ruft einen Wert ab, der angibt, ob die Z-Anordnung von gezogenen Steuerelementen beim Ablegen in einem ParentControlDesigner beibehalten werden soll.
AssociatedComponents	Ruft die Auflistung der Komponenten ab, die der durch den Designer verwalteten Komponente zugeordnet ist. (Geerbt von ControlDesigner)
AutoResizeHandles	Ruft einen Wert ab oder oder legt einen Wert fest, der angibt, ob die Vergrößerungspunktreservierung vom Wert der AutoSize-Eigenschaft abhängt. (Geerbt von ControlDesigner)
BehaviorService	Ruft den BehaviorService von der Entwurfsumgebung ab. (Geerbt von ControlDesigner)
Component	Ruft die Komponente ab, die von diesem Designer entworfen wird. (Geerbt von ComponentDesigner)
Control	Ruft das Steuerelement ab, das vom Designer entworfen wird. (Geerbt von ControlDesigner)
DefaultControlLocation	Ruft die Standardposition für ein Steuerelement ab, das dem Designer hinzugefügt wurde.
DrawGrid	Ruft einen Wert ab, der angibt, ob für diesen Designer ein Raster auf dem Steuerelement gezeichnet werden soll, oder legt diesen fest.
EnableDragRect	Ruft einen Wert ab, der angibt, ob vom Designer Ziehrechtecke gezeichnet werden.
GridSize	Wenn sich der Designer im Modus für Rasterzeichnung befindet, wird hiermit die Größe jedes Quadrats des gezeichneten Rasters abgerufen oder festgelegt.
InheritanceAttribute	Ruft das InheritanceAttribute für den Designer ab. (Geerbt von ControlDesigner)
Inherited	Ruft einen Wert ab, der angibt, ob diese Komponente geerbt wurde. (Geerbt von ComponentDesigner)
MouseDragTool	Ruft einen Wert ab, der angibt, ob der Designer während eines Ziehvorgangs über ein gültiges Tool verfügt.
ParentComponent	Ruft die übergeordnete Komponente für den ControlDesigner ab. (Geerbt von ControlDesigner)
ParticipatesWithSnapLines	Ruft einen Wert ab, der angibt, ob der ControlDesigner während eines Ziehvorgangs die Ausrichtung von Ausrichtungslinien ermöglicht. (Geerbt von ControlDesigner)
SelectionRules	Ruft die Auswahlregeln ab, die die Bewegungsfunktionen einer Komponente angeben. (Geerbt von ControlDesigner)
SetTextualDefaultProperty	Erweitert das Entwurfsmodusverhalten eines Control, das geschachtelte Steuerelemente unterstützt. (Geerbt von ComponentDesigner)
ShadowProperties	Ruft eine Auflistung von Eigenschaftswerten ab, die Benutzereinstellungen überschreiben. (Geerbt von ComponentDesigner)
SnapLines	Ruft eine Liste mit SnapLine-Objekten ab, die signifikante Ausrichtungspunkte für dieses Steuerelement darstellen.
Verbs	Ruft die Entwurfszeitverben ab, die von der dem Designer zugeordneten Komponente unterstützt werden. (Geerbt von ComponentDesigner)

Methoden

AddPaddingSnapLines(ArrayList)	Fügt Abstandsausrichtungslinien hinzu.
BaseWndProc(Message)	Verarbeitet Windows-Meldungen. (Geerbt von ControlDesigner)
CanAddComponent(IComponent)	Wird aufgerufen, wenn dem übergeordneten Container eine Komponente hinzugefügt wird.
CanBeParentedTo(IDesigner)	Gibt an, ob das Steuerelement dieses Designers dem Steuerelement des angegebenen Designers untergeordnet sein kann. (Geerbt von ControlDesigner)
CanParent(Control)	Gibt an, ob das angegebene Steuerelement dem Steuerelement untergeordnet sein kann, das von diesem Designer verwaltet wird.
CanParent(ControlDesigner)	Gibt an, ob das vom angegebenen Designer verwaltete Steuerelement ein untergeordnetes Element des von diesem Designer verwalteten Steuerelements sein kann.
CreateTool(ToolboxItem)	Erstellt eine Komponente oder ein Steuerelement aus dem angegebenen Tool und fügt diese(s) dem aktuellen Entwurfsdokument hinzu.
CreateTool(ToolboxItem, Point)	Erstellt eine Komponente oder ein Steuerelement aus dem angegebenen Tool und fügt diese(s) dem aktuellen Entwurfsdokument an der angegebenen Position hinzu.
CreateTool(ToolboxItem, Rectangle)	Erstellt eine Komponente oder ein Steuerelement aus dem angegebenen Tool und fügt diese(s) dem aktuellen Entwurfsdokument innerhalb der Grenzen des angegebenen Rechtecks hinzu.
CreateToolCore(ToolboxItem, Int32, Int32, Int32, Int32, Boolean, Boolean)	Stellt Kernfunktionen für alle CreateTool(ToolboxItem)-Methoden bereit.
DefWndProc(Message)	Stellt Standardverarbeitung für Windows-Meldungen bereit. (Geerbt von ControlDesigner)
DisplayError(Exception)	Zeigt dem Benutzer Informationen über die angegebene Ausnahme an. (Geerbt von ControlDesigner)
Dispose()	Gibt alle vom ComponentDesigner verwendeten Ressourcen frei. (Geerbt von ComponentDesigner)
Dispose(Boolean)	Gibt die von ParentControlDesigner verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei.
DoDefaultAction()	Erstellt eine Methodensignatur in der Quellcodedatei für das Standardereignis der Komponente und verschiebt den Cursor des Benutzers an diese Position. (Geerbt von ComponentDesigner)
EnableDesignMode(Control, String)	Aktiviert die Entwurfszeitfunktionen für ein untergeordnetes Steuerelement. (Geerbt von ControlDesigner)
EnableDragDrop(Boolean)	Aktiviert oder deaktiviert die Drag & Drop-Unterstützung für das Steuerelement, das entworfen wird. (Geerbt von ControlDesigner)
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GetControl(Object)	Ruft das Steuerelement vom Designer der angegebenen Komponente ab.
GetControlGlyph(GlyphSelectionType)	Ruft ein Inhaltssymbol ab, das die Begrenzungen des Steuerelements darstellt.
GetGlyphs(GlyphSelectionType)	Ruft eine Auflistung von Glyph-Objekt ab, die die Markierungsrahmen und Ziehpunkte für ein Standardsteuerelement darstellen.
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetHitTest(Point)	Gibt an, ob ein Mausklick auf den angegebenen Punkt von dem Steuerelement behandelt werden soll. (Geerbt von ControlDesigner)
GetParentForComponent(IComponent)	Wird von abgeleiteten Klassen beim Hinzufügen einer Komponente verwendet, um zu bestimmen, ob das gerade entworfene Steuerelement oder ein anderer Container zurückgegeben wird.
GetService(Type)	Versucht, den angegebenen Diensttyp von der Entwurfsmodussite der Komponente des Designers abzurufen. (Geerbt von ComponentDesigner)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
GetUpdatedRect(Rectangle, Rectangle, Boolean)	Aktualisiert die Position des angegebenen Rechtecks, wobei dieses am Raster ausgerichtet wird, sofern der entsprechende Modus aktiviert ist.
HookChildControls(Control)	Leitet Meldungen von den untergeordneten Steuerelementen des angegebenen Steuerelements an den Designer weiter. (Geerbt von ControlDesigner)
Initialize(IComponent)	Initialisiert den Designer mit der angegebenen Komponente.
InitializeExistingComponent(IDictionary)	Initialisiert eine vorhandene Komponente erneut. (Geerbt von ControlDesigner)
InitializeNewComponent(IDictionary)	Initialisiert eine neu erstellte Komponente.
InitializeNonDefault()	Initialisiert die Eigenschaften des Steuerelements auf einen beliebigen nicht standardmäßigen Wert. (Geerbt von ControlDesigner)
InternalControlDesigner(Int32)	Gibt den internen Steuerelement-Designer mit dem angegebenen Index im ControlDesigner zurück. (Geerbt von ControlDesigner)
InvokeCreateTool(ParentControlDesigner, ToolboxItem)	Erstellt ein Tool aus dem angegebenen ToolboxItem.
InvokeGetInheritanceAttribute(ComponentDesigner)	Ruft das InheritanceAttribute des angegebenen ComponentDesigner ab. (Geerbt von ComponentDesigner)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
NumberOfInternalControlDesigners()	Gibt die Anzahl von internen Steuerelement-Designern im ControlDesigner zurück. (Geerbt von ControlDesigner)
OnContextMenu(Int32, Int32)	Zeigt das Kontextmenü an und ermöglicht das Ausführen weiterer Verarbeitungsschritte, während das Kontextmenü gerade angezeigt wird. (Geerbt von ControlDesigner)
OnCreateHandle()	Ermöglicht das Ausführen weiterer Schritte direkt nach dem Erstellen des Steuerelementhandles. (Geerbt von ControlDesigner)
OnDragComplete(DragEventArgs)	Wird aufgerufen, um einen Drag & Drop-Vorgang zu bereinigen.
OnDragDrop(DragEventArgs)	Wird aufgerufen, wenn ein Drag & Drop-Objekt auf der Ansicht des Steuerelement-Designers abgelegt wird.
OnDragEnter(DragEventArgs)	Wird aufgerufen, wenn ein Drag & Drop-Vorgang in der Ansicht des Steuerelement-Designers eintritt.
OnDragLeave(EventArgs)	Wird aufgerufen, wenn ein Drag & Drop-Vorgang in der Ansicht des Steuerelement-Designers verlässt.
OnDragOver(DragEventArgs)	Wird aufgerufen, wenn ein Drag & Drop-Objekt über die Ansicht des Steuerelement-Designers gezogen wird.
OnGiveFeedback(GiveFeedbackEventArgs)	Empfängt einen Aufruf, wenn ein Drag & Drop-Vorgang ausgeführt wird, um visuelle Hinweise bereitzustellen, die auf der Position des Mauszeigers basieren, während ein Ziehvorgang ausgeführt wird. (Geerbt von ControlDesigner)
OnMouseDragBegin(Int32, Int32)	Wird als Reaktion auf das Drücken und Halten der linken Maustaste aufgerufen, während sich der Mauszeiger über der Komponente befindet.
OnMouseDragEnd(Boolean)	Wird am Ende eines Drag & Drop-Vorgangs aufgerufen, um diesen abzuschließen oder abzubrechen.
OnMouseDragMove(Int32, Int32)	Wird für jede Bewegung der Maus während eines Drag & Drop-Vorgangs aufgerufen.
OnMouseEnter()	Empfängt einen Aufruf, wenn der Mauszeiger zum ersten Mal in den Bereich des Steuerelements eintritt. (Geerbt von ControlDesigner)
OnMouseHover()	Empfängt einen Aufruf, nachdem mit dem Mauszeiger auf das Steuerelement gezeigt wurde. (Geerbt von ControlDesigner)
OnMouseLeave()	Empfängt einen Aufruf, wenn der Mauszeiger zum ersten Mal in den Bereich des Steuerelements eintritt. (Geerbt von ControlDesigner)
OnPaintAdornments(PaintEventArgs)	Wird aufgerufen, wenn die Oberfläche des vom Designer verwalteten Steuerelements gezeichnet ist, sodass der Designer die Darstellung des Steuerelements bearbeiten kann.
OnSetComponentDefaults()	Veraltet. Wird beim Initialisieren des Designers aufgerufen. (Geerbt von ControlDesigner)
OnSetCursor()	Ermöglicht die Änderung des aktuellen Mauszeigers.
PostFilterAttributes(IDictionary)	Ermöglicht einem Designer das Ändern oder Entfernen von Elementen aus dem Satz von Attributen, der über einen TypeDescriptor verfügbar gemacht wird. (Geerbt von ComponentDesigner)
PostFilterEvents(IDictionary)	Ermöglicht einem Designer das Ändern oder Entfernen von Elementen aus dem Satz von Ereignissen, der über einen TypeDescriptor verfügbar gemacht wird. (Geerbt von ComponentDesigner)
PostFilterProperties(IDictionary)	Ermöglicht einem Designer das Ändern oder Entfernen von Elementen aus dem Satz von Eigenschaften, der über einen TypeDescriptor verfügbar gemacht wird. (Geerbt von ComponentDesigner)
PreFilterAttributes(IDictionary)	Ermöglicht einem Designer das Hinzufügen zu dem Satz von Attributen, der über einen TypeDescriptor verfügbar gemacht wird. (Geerbt von ComponentDesigner)
PreFilterEvents(IDictionary)	Ermöglicht einem Designer ein Hinzufügen zu dem Satz von Ereignissen, der durch einen TypeDescriptor verfügbar gemacht wird. (Geerbt von ComponentDesigner)
PreFilterProperties(IDictionary)	Passt die Gruppe von Eigenschaften an, die die Komponente mithilfe eines TypeDescriptor verfügbar macht.
RaiseComponentChanged(MemberDescriptor, Object, Object)	Benachrichtigt IComponentChangeService darüber, dass diese Komponente geändert wurde. (Geerbt von ComponentDesigner)
RaiseComponentChanging(MemberDescriptor)	Benachrichtigt IComponentChangeService darüber, dass diese Komponente gerade geändert wird. (Geerbt von ComponentDesigner)
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)
UnhookChildControls(Control)	Leitet Meldungen für die untergeordneten Elemente des angegebenen Steuerelements an jedes Steuerelement und nicht an einen übergeordneten Designer weiter. (Geerbt von ControlDesigner)
WndProc(Message)	Verarbeitet Windows-Meldungen und leitet diese optional an das Steuerelement weiter. (Geerbt von ControlDesigner)

Explizite Schnittstellenimplementierungen

IDesignerFilter.PostFilterAttributes(IDictionary)	Eine Beschreibung dieses Members finden Sie unter der PostFilterAttributes(IDictionary)-Methode. (Geerbt von ComponentDesigner)
IDesignerFilter.PostFilterEvents(IDictionary)	Eine Beschreibung dieses Members finden Sie unter der PostFilterEvents(IDictionary)-Methode. (Geerbt von ComponentDesigner)
IDesignerFilter.PostFilterProperties(IDictionary)	Eine Beschreibung dieses Members finden Sie unter der PostFilterProperties(IDictionary)-Methode. (Geerbt von ComponentDesigner)
IDesignerFilter.PreFilterAttributes(IDictionary)	Eine Beschreibung dieses Members finden Sie unter der PreFilterAttributes(IDictionary)-Methode. (Geerbt von ComponentDesigner)
IDesignerFilter.PreFilterEvents(IDictionary)	Eine Beschreibung dieses Members finden Sie unter der PreFilterEvents(IDictionary)-Methode. (Geerbt von ComponentDesigner)
IDesignerFilter.PreFilterProperties(IDictionary)	Eine Beschreibung dieses Members finden Sie unter der PreFilterProperties(IDictionary)-Methode. (Geerbt von ComponentDesigner)
ITreeDesigner.Children	Eine Beschreibung dieses Members finden Sie unter der Children-Eigenschaft. (Geerbt von ComponentDesigner)
ITreeDesigner.Parent	Eine Beschreibung dieses Members finden Sie unter der Parent-Eigenschaft. (Geerbt von ComponentDesigner)

Weitere Informationen

• ControlDesigner
• ComponentDesigner
• IDesigner
• IDesignerFilter
• DesignerAttribute
• Erweitern der Entwurfszeitunterstützung