ParentControlDesigner Třída

Definice

Obor názvů:

System.Windows.Forms.Design

Sestavení:

System.Design.dll

Sestavení:

System.Windows.Forms.Design.dll

Rozšiřuje chování režimu návrhu Control , který podporuje vnořené ovládací prvky.

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

Dědičnost

Object

ComponentDesigner

ControlDesigner

ParentControlDesigner

Odvozené

System.Windows.Forms.Design.ScrollableControlDesigner

Příklady

Následující příklad ukazuje, jak implementovat vlastní ParentControlDesigner. Tento příklad kódu je součástí většího příkladu zadaného IToolboxUser pro rozhraní.

#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

Poznámky

ParentControlDesigner poskytuje základní třídu pro návrháře ovládacích prvků, které mohou obsahovat podřízené ovládací prvky. Kromě metod a funkcí zděděných z ControlDesigner a ComponentDesigner tříd ParentControlDesigner umožňuje přidávání podřízených ovládacích prvků do podřízených ovládacích prvků, odebírání, výběru v rámci ovládacího prvku a uspořádání v rámci ovládacího prvku, jehož chování se rozšiřuje v době návrhu.

Návrháře můžete přidružit k typu pomocí DesignerAttribute. Přehled přizpůsobení chování času návrhu najdete v tématu Rozšíření podpory Design-Time.

Konstruktory

ParentControlDesigner()

Inicializuje novou instanci ParentControlDesigner třídy.

Pole

accessibilityObj

Určuje objekt přístupnosti pro návrháře. (Zděděno od ControlDesigner)

Vlastnosti

AccessibilityObject	Získá přiřazený AccessibleObject ovládací prvek. (Zděděno od ControlDesigner)
ActionLists	Získá seznamy akcí v době návrhu podporované komponentou přidruženou k návrháři. (Zděděno od ComponentDesigner)
AllowControlLasso	Získá hodnotu označující, jestli budou vybrané ovládací prvky znovu nadřazené.
AllowGenericDragBox	Získá hodnotu určující, zda má být pole obecného přetažení nakresleno při přetažení položky panelu nástrojů přes plochu návrháře.
AllowSetChildIndexOnDrop	Získá hodnotu určující, zda pořadí z-pořadí přetažených ovládacích prvků by mělo být zachováno při vyřazení na ParentControlDesigner.
AssociatedComponents	Získá kolekci komponent přidružených k komponentě spravované návrhářem. (Zděděno od ControlDesigner)
AutoResizeHandles	Získá nebo nastaví hodnotu určující, zda velikost úchytu přidělení závisí na hodnotě AutoSize vlastnosti. (Zděděno od ControlDesigner)
BehaviorService	BehaviorService Získá z návrhového prostředí. (Zděděno od ControlDesigner)
Component	Získá komponentu, která návrhář navrhuje. (Zděděno od ComponentDesigner)
Control	Získá ovládací prvek, který návrhář navrhuje. (Zděděno od ControlDesigner)
DefaultControlLocation	Získá výchozí umístění ovládacího prvku přidaného do návrháře.
DrawGrid	Získá nebo nastaví hodnotu určující, zda má být mřížka nakreslena na ovládací prvek pro tohoto návrháře.
EnableDragRect	Získá hodnotu označující, zda jsou přetažení obdélníky nakresleny návrhářem.
GridSize	Získá nebo nastaví velikost každého čtverce mřížky, která je nakreslena, když návrhář je v režimu kreslení mřížky.
InheritanceAttribute	InheritanceAttribute Získá návrháře. (Zděděno od ControlDesigner)
Inherited	Získá hodnotu určující, zda je tato komponenta zděděna. (Zděděno od ComponentDesigner)
MouseDragTool	Získá hodnotu označující, zda návrhář má platný nástroj během operace přetažení.
ParentComponent	Získá nadřazenou komponentu ControlDesignerpro . (Zděděno od ControlDesigner)
ParticipatesWithSnapLines	Získá hodnotu označující, zda ControlDesigner bude povoleno zarovnání čáry při přetažení. (Zděděno od ControlDesigner)
SelectionRules	Získá pravidla výběru, která označují možnosti pohybu komponenty. (Zděděno od ControlDesigner)
ShadowProperties	Získá kolekci hodnot vlastností, které přepíší uživatelská nastavení. (Zděděno od ComponentDesigner)
SnapLines	Získá seznam SnapLine objektů představujících významné body zarovnání pro tento ovládací prvek.
SnapLines	Získá seznam SnapLine objektů představujících významné body zarovnání pro tento ovládací prvek. (Zděděno od ControlDesigner)
Verbs	Získá příkazy návrhu podporované komponentou, která je přidružená k návrháři. (Zděděno od ComponentDesigner)

Metody

AddPaddingSnapLines(ArrayList)	Přidá odsazení zasazení.
BaseWndProc(Message)	Zpracovává zprávy systému Windows. (Zděděno od ControlDesigner)
CanAddComponent(IComponent)	Volá se při přidání komponenty do nadřazeného kontejneru.
CanBeParentedTo(IDesigner)	Označuje, jestli lze ovládací prvek tohoto návrháře nadřazený ovládacím prvek zadaného návrháře. (Zděděno od ControlDesigner)
CanParent(Control)	Určuje, jestli zadaný ovládací prvek může být podřízený ovládací prvek spravovaný tímto návrhářem.
CanParent(ControlDesigner)	Určuje, jestli může být ovládací prvek spravovaný zadaným návrhářem podřízeným ovládacím prvku spravovaným tímto návrhářem.
CreateTool(ToolboxItem)	Vytvoří komponentu nebo ovládací prvek ze zadaného nástroje a přidá ji do aktuálního návrhového dokumentu.
CreateTool(ToolboxItem, Point)	Vytvoří součást nebo ovládací prvek ze zadaného nástroje a přidá ho do aktuálního návrhového dokumentu v zadaném umístění.
CreateTool(ToolboxItem, Rectangle)	Vytvoří součást nebo ovládací prvek ze zadaného nástroje a přidá ho do aktuálního návrhového dokumentu v mezích zadaného obdélníku.
CreateToolCore(ToolboxItem, Int32, Int32, Int32, Int32, Boolean, Boolean)	Poskytuje základní funkce pro všechny CreateTool(ToolboxItem) metody.
DefWndProc(Message)	Poskytuje výchozí zpracování Windows zpráv. (Zděděno od ControlDesigner)
DisplayError(Exception)	Zobrazí informace o zadané výjimce uživatele. (Zděděno od ControlDesigner)
Dispose()	Uvolní všechny prostředky používané nástrojem ComponentDesigner. (Zděděno od ComponentDesigner)
Dispose(Boolean)	Uvolní nespravované prostředky používané nástrojem ParentControlDesignera volitelně uvolní spravované prostředky.
DoDefaultAction()	Vytvoří podpis metody v souboru zdrojového kódu pro výchozí událost komponenty a přejde kurzor uživatele na toto umístění. (Zděděno od ComponentDesigner)
EnableDesignMode(Control, String)	Umožňuje funkci času návrhu podřízeného ovládacího prvku. (Zděděno od ControlDesigner)
EnableDragDrop(Boolean)	Povolí nebo zakáže podporu přetažení pro navržený ovládací prvek. (Zděděno od ControlDesigner)
Equals(Object)	Určí, zda se zadaný objekt rovná aktuálnímu objektu. (Zděděno od Object)
GetControl(Object)	Získá ovládací prvek od návrháře zadané komponenty.
GetControlGlyph(GlyphSelectionType)	Získá tělo glyph, který představuje hranice ovládacího prvku.
GetControlGlyph(GlyphSelectionType)	Vrátí reprezentaci ControlBodyGlyph hranic tohoto ovládacího prvku. (Zděděno od ControlDesigner)
GetGlyphs(GlyphSelectionType)	Získá kolekci Glyph objektů představujících ohraničení výběru a úchyty pro standardní ovládací prvek.
GetGlyphs(GlyphSelectionType)	Získá kolekci Glyph objektů představujících ohraničení výběru a úchyty pro standardní ovládací prvek. (Zděděno od ControlDesigner)
GetHashCode()	Slouží jako výchozí funkce hash. (Zděděno od Object)
GetHitTest(Point)	Určuje, zda má ovládací prvek zpracovat kliknutí myší na zadaný bod. (Zděděno od ControlDesigner)
GetParentForComponent(IComponent)	Používá se odvozením tříd k určení, zda vrací ovládací prvek, který je navržen nebo nějaký jiný Container při přidávání komponenty do ní.
GetService(Type)	Pokusí se načíst zadaný typ služby z webu režimu návrhu komponenty návrháře. (Zděděno od ComponentDesigner)
GetType()	Type Získá aktuální instanci. (Zděděno od Object)
GetUpdatedRect(Rectangle, Rectangle, Boolean)	Aktualizuje pozici zadaného obdélníku a upraví ji pro zarovnání mřížky, pokud je povolen režim zarovnání mřížky.
HookChildControls(Control)	Směruje zprávy z podřízených ovládacích prvků zadaného ovládacího prvku do návrháře. (Zděděno od ControlDesigner)
Initialize(IComponent)	Inicializuje návrháře se zadanou komponentou.
InitializeExistingComponent(IDictionary)	Znovu inicializuje existující komponentu. (Zděděno od ControlDesigner)
InitializeNewComponent(IDictionary)	Inicializuje nově vytvořenou komponentu.
InitializeNewComponent(IDictionary)	Inicializuje nově vytvořenou komponentu. (Zděděno od ControlDesigner)
InitializeNonDefault()	Inicializuje vlastnosti ovládacího prvku na všechny ne výchozí hodnoty. (Zděděno od ControlDesigner)
InternalControlDesigner(Int32)	Vrátí návrhář interního ovládacího prvku se zadaným indexem v souboru ControlDesigner. (Zděděno od ControlDesigner)
InvokeCreateTool(ParentControlDesigner, ToolboxItem)	Vytvoří nástroj ze zadaného ToolboxItemobjektu .
InvokeGetInheritanceAttribute(ComponentDesigner)	InheritanceAttribute Získá zadaný ComponentDesigner. (Zděděno od ComponentDesigner)
MemberwiseClone()	Vytvoří použádnou kopii aktuálního souboru Object. (Zděděno od Object)
NumberOfInternalControlDesigners()	Vrátí počet návrhářů interních ovládacích prvků v sadě ControlDesigner. (Zděděno od ControlDesigner)
OnContextMenu(Int32, Int32)	Zobrazuje místní nabídku a poskytuje příležitost provést další zpracování, když se má zobrazit místní nabídka. (Zděděno od ControlDesigner)
OnCreateHandle()	Poskytuje příležitost provést další zpracování ihned po vytvoření řídicího úchytu. (Zděděno od ControlDesigner)
OnDragComplete(DragEventArgs)	Volá se, aby se vyčistila operace přetažení.
OnDragComplete(DragEventArgs)	Přijme volání, které vyčistí operaci přetažením. (Zděděno od ControlDesigner)
OnDragDrop(DragEventArgs)	Volá se při přetažení objektu do zobrazení návrháře ovládacích prvků.
OnDragEnter(DragEventArgs)	Volá se, když operace přetažení přejde do zobrazení návrháře ovládacích prvků.
OnDragLeave(EventArgs)	Volá se, když operace přetažení opustí zobrazení návrháře ovládacích prvků.
OnDragOver(DragEventArgs)	Volána, když je objekt přetahování přetažen přes zobrazení návrháře ovládacích prvků.
OnGiveFeedback(GiveFeedbackEventArgs)	Volá se, když probíhá operace přetažení, která poskytuje vizuální pomůcky na základě umístění myši, zatímco probíhá operace přetažení.
OnGiveFeedback(GiveFeedbackEventArgs)	Přijme volání, když probíhá operace přetažení, která poskytuje vizuální upozornění na základě umístění myši, zatímco probíhá operace přetažení. (Zděděno od ControlDesigner)
OnMouseDragBegin(Int32, Int32)	Volané v reakci na levé tlačítko myši, které se stiskne a drží při procházení komponenty.
OnMouseDragEnd(Boolean)	Volána na konci operace přetažení, aby se operace dokončila nebo zrušila.
OnMouseDragMove(Int32, Int32)	Volá se pro každý pohyb myši během operace přetažení myší.
OnMouseEnter()	Volá se při prvním vstupu myši do ovládacího prvku.
OnMouseEnter()	Přijme hovor, když myš poprvé vstoupí do ovládacího prvku. (Zděděno od ControlDesigner)
OnMouseHover()	Volá se po najetí myší na ovládací prvek.
OnMouseHover()	Přijme hovor po najetí myší na ovládací prvek. (Zděděno od ControlDesigner)
OnMouseLeave()	Volá se při prvním vstupu myši do ovládacího prvku.
OnMouseLeave()	Přijme hovor, když myš poprvé vstoupí do ovládacího prvku. (Zděděno od ControlDesigner)
OnPaintAdornments(PaintEventArgs)	Volá se, když ovládací prvek, který návrhář spravuje, namaloval svůj povrch, aby návrhář mohl nakreslit jakékoli další doplňky nad ovládacím prvku.
OnSetComponentDefaults()	Zastaralé. Zastaralé. Volá se při inicializaci návrháře. (Zděděno od ControlDesigner)
OnSetCursor()	Poskytuje příležitost změnit aktuální kurzor myši.
PostFilterAttributes(IDictionary)	Umožňuje návrháři změnit nebo odebrat položky ze sady atributů, které zveřejňuje prostřednictvím TypeDescriptor. (Zděděno od ComponentDesigner)
PostFilterEvents(IDictionary)	Umožňuje návrháři změnit nebo odebrat položky ze sady událostí, které zveřejňuje prostřednictvím TypeDescriptor. (Zděděno od ComponentDesigner)
PostFilterProperties(IDictionary)	Umožňuje návrháři změnit nebo odebrat položky ze sady vlastností, které zveřejňuje prostřednictvím TypeDescriptor. (Zděděno od ComponentDesigner)
PreFilterAttributes(IDictionary)	Umožňuje návrháři přidat do sady atributů, které zveřejňuje prostřednictvím TypeDescriptor. (Zděděno od ComponentDesigner)
PreFilterEvents(IDictionary)	Umožňuje návrháři přidat do sady událostí, které zveřejňuje prostřednictvím TypeDescriptor. (Zděděno od ComponentDesigner)
PreFilterProperties(IDictionary)	Upraví sadu vlastností, které komponenta zveřejní prostřednictvím TypeDescriptor.
RaiseComponentChanged(MemberDescriptor, Object, Object)	Upozorní, IComponentChangeService že se tato komponenta změnila. (Zděděno od ComponentDesigner)
RaiseComponentChanging(MemberDescriptor)	Upozorní IComponentChangeService , že se tato komponenta chystá změnit. (Zděděno od ComponentDesigner)
ToString()	Vrátí řetězec, který představuje aktuální objekt. (Zděděno od Object)
UnhookChildControls(Control)	Směruje zprávy pro podřízené položky zadaného ovládacího prvku namísto nadřazeného návrháře. (Zděděno od ControlDesigner)
WndProc(Message)	Zpracovává zprávy systému Windows.
WndProc(Message)	Zpracovává Windows zprávy a volitelně je směruje do ovládacího prvku. (Zděděno od ControlDesigner)

Explicitní implementace rozhraní

IDesignerFilter.PostFilterAttributes(IDictionary)	Popis tohoto člena najdete v PostFilterAttributes(IDictionary) metodě. (Zděděno od ComponentDesigner)
IDesignerFilter.PostFilterEvents(IDictionary)	Popis tohoto člena najdete v PostFilterEvents(IDictionary) metodě. (Zděděno od ComponentDesigner)
IDesignerFilter.PostFilterProperties(IDictionary)	Popis tohoto člena najdete v PostFilterProperties(IDictionary) metodě. (Zděděno od ComponentDesigner)
IDesignerFilter.PreFilterAttributes(IDictionary)	Popis tohoto člena najdete v PreFilterAttributes(IDictionary) metodě. (Zděděno od ComponentDesigner)
IDesignerFilter.PreFilterEvents(IDictionary)	Popis tohoto člena najdete v PreFilterEvents(IDictionary) metodě. (Zděděno od ComponentDesigner)
IDesignerFilter.PreFilterProperties(IDictionary)	Popis tohoto člena najdete v PreFilterProperties(IDictionary) metodě. (Zděděno od ComponentDesigner)
ITreeDesigner.Children	Popis tohoto člena najdete v Children vlastnosti. (Zděděno od ComponentDesigner)
ITreeDesigner.Parent	Popis tohoto člena najdete v Parent vlastnosti. (Zděděno od ComponentDesigner)

Viz také

• ControlDesigner
• ComponentDesigner
• IDesigner
• IDesignerFilter
• DesignerAttribute
• Rozšíření podpory během návrhu