ParentControlDesigner Klasse

Definition

Namespace:

System.Windows.Forms.Design

Assembly:

System.Windows.Forms.Design.dll

Quelle:

ParentControlDesigner.cs

Erweitert das Entwurfsmodusverhalten eines Control Steuerelements, 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

Das folgende Beispiel veranschaulicht, wie eine benutzerdefinierte ParentControlDesignerImplementierung implementiert wird. Dieses Codebeispiel ist Teil eines größeren Beispiels, das für die IToolboxUser Schnittstelle bereitgestellt wird.

#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

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 Und-Klassen ComponentDesigner geerbt wurden, ParentControlDesigner können untergeordnete Steuerelemente hinzugefügt, aus dem Steuerelement entfernt, ausgewählt und innerhalb des Steuerelements angeordnet werden, dessen Verhalten sie zur Entwurfszeit erweitert.

Sie können einen Designer einem Typ mithilfe eines DesignerAttributeTyps zuordnen.

Konstruktoren

Name	Beschreibung
ParentControlDesigner()	Initialisiert eine neue Instanz der ParentControlDesigner-Klasse.

Felder

Name	Beschreibung
accessibilityObj	Gibt das Barrierefreiheitsobjekt für den Designer an. (Geerbt von ControlDesigner)

Eigenschaften

Name	Beschreibung
AccessibilityObject	Ruft das AccessibleObject dem Steuerelement zugewiesene Ab. (Geerbt von ControlDesigner)
ActionLists	Ruft die Entwurfszeitaktionslisten ab, die von der Komponente unterstützt werden, die dem Designer zugeordnet ist. (Geerbt von ComponentDesigner)
AllowControlLasso	Ruft einen Wert ab, der angibt, ob ausgewählte Steuerelemente erneut übergeordnet werden.
AllowGenericDragBox	Ruft einen Wert ab, der angibt, ob ein generisches Ziehfeld gezeichnet werden soll, wenn ein Toolboxelement über die Oberfläche des Designers gezogen wird.
AllowSetChildIndexOnDrop	Ruft einen Wert ab, der angibt, ob die Z-Reihenfolge der gezogenen Steuerelemente beibehalten werden soll, wenn sie in einem ParentControlDesigner.
AssociatedComponents	Ruft die Auflistung der Komponenten ab, die der vom Designer verwalteten Komponente zugeordnet sind. (Geerbt von ControlDesigner)
AutoResizeHandles	Dient zum Abrufen oder Festlegen eines Werts, der angibt, ob die Zuordnung des Ziehpunkts von der AutoSize Eigenschaft abhängig ist. (Geerbt von ControlDesigner)
BehaviorService	Ruft die BehaviorService aus der Entwurfsumgebung ab. (Geerbt von ControlDesigner)
Component	Ruft die Komponente ab, die dieser Designer entwerfen soll. (Geerbt von ComponentDesigner)
Control	Ruft das Steuerelement ab, das der Designer entwerfen soll. (Geerbt von ControlDesigner)
DefaultControlLocation	Ruft den Standardspeicherort für ein Steuerelement ab, das dem Designer hinzugefügt wurde.
DrawGrid	Dient zum Abrufen oder Festlegen eines Werts, der angibt, ob ein Raster für das Steuerelement für diesen Designer gezeichnet werden soll.
EnableDragRect	Ruft einen Wert ab, der angibt, ob Ziehrechtecke vom Designer gezeichnet werden.
GridSize	Ruft die Größe der einzelnen Quadrate des Rasters ab, das gezeichnet wird, wenn sich der Designer im Raster-Zeichnungsmodus befindet, oder legt diese fest.
InheritanceAttribute	Ruft den InheritanceAttribute Designer ab. (Geerbt von ControlDesigner)
Inherited	Ruft einen Wert ab, der angibt, ob diese Komponente geerbt wird. (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 die ControlDesigner. (Geerbt von ControlDesigner)
ParticipatesWithSnapLines	Ruft einen Wert ab, der angibt, ob die ControlDesigner Andocklinienausrichtung während eines Ziehvorgangs zulässig ist. (Geerbt von ControlDesigner)
SelectionRules	Ruft die Auswahlregeln ab, die die Bewegungsfunktionen einer Komponente angeben. (Geerbt von ControlDesigner)
SetTextualDefaultProperty	Erweitert das Entwurfsmodusverhalten eines Control Steuerelements, das geschachtelte Steuerelemente unterstützt. (Geerbt von ComponentDesigner)
ShadowProperties	Ruft eine Auflistung von Eigenschaftswerten ab, die Benutzereinstellungen außer Kraft setzen. (Geerbt von ComponentDesigner)
SnapLines	Ruft eine Liste von Objekten ab, die SnapLine signifikante Ausrichtungspunkte für dieses Steuerelement darstellen.
Verbs	Ruft die Entwurfszeitverben ab, die von der Komponente unterstützt werden, die dem Designer zugeordnet ist. (Geerbt von ComponentDesigner)

Methoden

Name	Beschreibung
AddPaddingSnapLines(ArrayList)	Fügt Abstandsrastlinien hinzu.
BaseWndProc(Message)	Verarbeitet Windows Nachrichten. (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 vom Steuerelement des angegebenen Designers übergeordnet werden kann. (Geerbt von ControlDesigner)
CanParent(Control)	Gibt an, ob das angegebene Steuerelement ein untergeordnetes Element des von diesem Designer verwalteten Steuerelements sein kann.
CanParent(ControlDesigner)	Gibt an, ob das vom angegebenen Designer verwaltete Steuerelement ein untergeordnetes Element des von diesem Designer verwalteten Steuerelements sein kann.
CreateTool(ToolboxItem, Point)	Erstellt eine Komponente oder ein Steuerelement aus dem angegebenen Tool und fügt es dem aktuellen Entwurfsdokument an der angegebenen Position hinzu.
CreateTool(ToolboxItem, Rectangle)	Erstellt eine Komponente oder ein Steuerelement aus dem angegebenen Tool und fügt es dem aktuellen Entwurfsdokument innerhalb der Grenzen des angegebenen Rechtecks hinzu.
CreateTool(ToolboxItem)	Erstellt eine Komponente oder ein Steuerelement aus dem angegebenen Tool und fügt es dem aktuellen Entwurfsdokument hinzu.
CreateToolCore(ToolboxItem, Int32, Int32, Int32, Int32, Boolean, Boolean)	Stellt Kernfunktionen für alle CreateTool(ToolboxItem) Methoden bereit.
DefWndProc(Message)	Stellt die Standardverarbeitung für Windows Nachrichten bereit. (Geerbt von ControlDesigner)
DisplayError(Exception)	Zeigt Informationen zur angegebenen Ausnahme für den Benutzer an. (Geerbt von ControlDesigner)
Dispose()	Veröffentlicht alle ressourcen, die von der ComponentDesigner. (Geerbt von ComponentDesigner)
Dispose(Boolean)	Gibt die nicht verwalteten Ressourcen frei, die von den ParentControlDesignerverwalteten Ressourcen verwendet werden, und gibt optional die verwalteten Ressourcen frei.
DoDefaultAction()	Erstellt eine Methodensignatur in der Quellcodedatei für das Standardereignis in der Komponente und navigiert den Cursor des Benutzers zu diesem Speicherort. (Geerbt von ComponentDesigner)
EnableDesignMode(Control, String)	Aktiviert Entwurfszeitfunktionen für ein untergeordnetes Steuerelement. (Geerbt von ControlDesigner)
EnableDragDrop(Boolean)	Aktiviert oder deaktiviert die Drag-and-Drop-Unterstützung für das zu entwerfende Steuerelement. (Geerbt von ControlDesigner)
GetControl(Object)	Ruft das Steuerelement aus dem Designer der angegebenen Komponente ab.
GetControlGlyph(GlyphSelectionType)	Ruft eine Textkörperglyphe ab, die die Grenzen des Steuerelements darstellt.
GetGlyphs(GlyphSelectionType)	Ruft eine Auflistung von Glyph Objekten ab, die die Auswahlrahmen und Ziehpunkte für ein Standardsteuerelement darstellen.
GetHitTest(Point)	Gibt an, ob ein Mausklick an dem angegebenen Punkt vom Steuerelement behandelt werden soll. (Geerbt von ControlDesigner)
GetParentForComponent(IComponent)	Wird verwendet, indem Klassen abgeleitet werden, um zu bestimmen, ob das Steuerelement, das entworfen wird, oder ein anderes Container element beim Hinzufügen einer Komponente zurückgegeben wird.
GetService(Type)	Versucht, den angegebenen Diensttyp von der Entwurfsmoduswebsite der Komponente des Designers abzurufen. (Geerbt von ComponentDesigner)
GetUpdatedRect(Rectangle, Rectangle, Boolean)	Aktualisiert die Position des angegebenen Rechtecks, indem er für die Rasterausrichtung angepasst wird, wenn der Rasterausrichtungsmodus aktiviert ist.
HookChildControls(Control)	Leitet Nachrichten 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 neu. (Geerbt von ControlDesigner)
InitializeNewComponent(IDictionary)	Initialisiert eine neu erstellte Komponente.
InternalControlDesigner(Int32)	Gibt den internen Steuerelement-Designer mit dem angegebenen Index in der ControlDesigner. (Geerbt von ControlDesigner)
InvokeCreateTool(ParentControlDesigner, ToolboxItem)	Erstellt ein Tool aus dem angegebenen ToolboxItem.
InvokeGetInheritanceAttribute(ComponentDesigner)	Ruft den InheritanceAttribute angegebenen ComponentDesignerab. (Geerbt von ComponentDesigner)
NumberOfInternalControlDesigners()	Gibt die Anzahl der internen Steuerelement-Designer in der ControlDesigner. (Geerbt von ControlDesigner)
OnContextMenu(Int32, Int32)	Zeigt das Kontextmenü an und bietet die Möglichkeit, zusätzliche Verarbeitung durchzuführen, wenn das Kontextmenü angezeigt werden soll. (Geerbt von ControlDesigner)
OnCreateHandle()	Bietet die Möglichkeit, unmittelbar nach der Erstellung des Steuerpunkts weitere Verarbeitungen durchzuführen. (Geerbt von ControlDesigner)
OnDragComplete(DragEventArgs)	Wird aufgerufen, um einen Drag-and-Drop-Vorgang zu bereinigen.
OnDragDrop(DragEventArgs)	Wird aufgerufen, wenn ein Drag-and-Drop-Objekt in der Steuerelement-Designeransicht abgelegt wird.
OnDragEnter(DragEventArgs)	Wird aufgerufen, wenn ein Drag-and-Drop-Vorgang in die Steuerelement-Designeransicht wechselt.
OnDragLeave(EventArgs)	Wird aufgerufen, wenn ein Drag-and-Drop-Vorgang die Ansicht des Steuerelement-Designers verlässt.
OnDragOver(DragEventArgs)	Wird aufgerufen, wenn ein Drag-and-Drop-Objekt über die Steuerelement-Designeransicht gezogen wird.
OnGiveFeedback(GiveFeedbackEventArgs)	Empfängt einen Aufruf, wenn ein Drag-and-Drop-Vorgang ausgeführt wird, um visuelle Hinweise basierend auf der Position der Maus bereitzustellen, während ein Ziehvorgang ausgeführt wird. (Geerbt von ControlDesigner)
OnMouseDragBegin(Int32, Int32)	Wird als Reaktion darauf aufgerufen, dass die linke Maustaste gedrückt und während der Komponente gehalten wird.
OnMouseDragEnd(Boolean)	Wird am Ende eines Drag-and-Drop-Vorgangs aufgerufen, um den Vorgang abzuschließen oder abzubrechen.
OnMouseDragMove(Int32, Int32)	Fordert jede Bewegung der Maus während eines Drag-and-Drop-Vorgangs auf.
OnMouseEnter()	Empfängt einen Anruf, wenn die Maus das Steuerelement zum ersten Mal eingibt. (Geerbt von ControlDesigner)
OnMouseHover()	Empfängt einen Anruf, nachdem die Maus über das Steuerelement bewegt wurde. (Geerbt von ControlDesigner)
OnMouseLeave()	Empfängt einen Anruf, wenn die Maus das Steuerelement zum ersten Mal eingibt. (Geerbt von ControlDesigner)
OnPaintAdornments(PaintEventArgs)	Wird aufgerufen, wenn das Steuerelement, das der Designer verwaltet, seine Oberfläche gezeichnet hat, damit der Designer alle zusätzlichen Zierelemente über dem Steuerelement zeichnen kann.
OnSetComponentDefaults()	Veraltet. Wird aufgerufen, wenn der Designer initialisiert wird. (Geerbt von ControlDesigner)
OnSetCursor()	Bietet die Möglichkeit, den aktuellen Mauszeiger zu ändern.
PostFilterAttributes(IDictionary)	Ermöglicht es einem Designer, Elemente aus der Gruppe von Attributen zu ändern oder zu entfernen, die er über eine TypeDescriptor. (Geerbt von ComponentDesigner)
PostFilterEvents(IDictionary)	Ermöglicht einem Designer das Ändern oder Entfernen von Elementen aus der Gruppe von Ereignissen, die er über eine TypeDescriptor. (Geerbt von ComponentDesigner)
PostFilterProperties(IDictionary)	Ermöglicht es einem Designer, Elemente aus dem Satz von Eigenschaften zu ändern oder zu entfernen, die er über eine TypeDescriptor. (Geerbt von ComponentDesigner)
PreFilterAttributes(IDictionary)	Ermöglicht es einem Designer, den Satz von Attributen hinzuzufügen, die er über eine TypeDescriptor. (Geerbt von ComponentDesigner)
PreFilterEvents(IDictionary)	Ermöglicht es einem Designer, den Satz von Ereignissen hinzuzufügen, die er über eine TypeDescriptor. (Geerbt von ComponentDesigner)
PreFilterProperties(IDictionary)	Passt den Satz von Eigenschaften an, den die Komponente über eine TypeDescriptor.
RaiseComponentChanged(MemberDescriptor, Object, Object)	Benachrichtigt die IComponentChangeService Änderung dieser Komponente. (Geerbt von ComponentDesigner)
RaiseComponentChanging(MemberDescriptor)	Benachrichtigt die IComponentChangeService Komponente darüber, dass diese Komponente geändert werden soll. (Geerbt von ComponentDesigner)
UnhookChildControls(Control)	Leitet Nachrichten 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 Nachrichten und leitet sie optional an das Steuerelement weiter. (Geerbt von ControlDesigner)

Explizite Schnittstellenimplementierungen

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

Weitere Informationen

• ControlDesigner
• ComponentDesigner
• IDesigner
• IDesignerFilter
• DesignerAttribute