IRootDesigner Interfaccia

Definizione

Spazio dei nomi:

System.ComponentModel.Design

Assembly:

System.ComponentModel.TypeConverter.dll

Fornisce supporto per le tecnologie di visualizzazione della finestra di progettazione a livello radice.

public interface class IRootDesigner : IDisposable, System::ComponentModel::Design::IDesigner

public interface IRootDesigner : IDisposable, System.ComponentModel.Design.IDesigner

type IRootDesigner = interface
    interface IDesigner
    interface IDisposable

Public Interface IRootDesigner
Implements IDesigner, IDisposable

Derivato

System.Web.UI.Design.WebFormsRootDesigner

System.Workflow.ComponentModel.Design.ActivityDesigner

System.Workflow.ComponentModel.Design.IWorkflowRootDesigner

Implementazioni

IDesigner IDisposable

Esempio

Nell'esempio di codice seguente viene illustrata un'implementazione IRootDesigner associata a un controllo utente di esempio. Questa IRootDesigner implementazione visualizza un controllo per la visualizzazione in background nella visualizzazione progettazione eseguendo l'override del GetView metodo . È necessario aggiungere un riferimento all'assembly System.Design per compilare l'esempio.

Per usare questo esempio, aggiungere il codice sorgente a un progetto e visualizzare la RootViewSampleComponent visualizzazione nella finestra di progettazione per visualizzare la visualizzazione progettazione radice personalizzata.

#using <System.Windows.Forms.dll>
#using <System.Drawing.dll>
#using <System.Design.dll>
#using <System.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::Windows::Forms;
using namespace System::Windows::Forms::Design;

namespace SampleRootDesigner
{
   ref class SampleRootDesigner;

   // This sample demonstrates how to provide the root designer view, or
   // design mode background view, by overriding IRootDesigner.GetView().
   // The following attribute associates the SampleRootDesigner designer
   // with the SampleComponent component.

   [Designer(SampleRootDesigner::typeid,IRootDesigner::typeid)]
   public ref class RootDesignedComponent: public Component
   {
   public:
      RootDesignedComponent(){}

   };

   public ref class SampleRootDesigner: public ComponentDesigner, public IRootDesigner
   {
   private:
      ref class RootDesignerView;

      // Member field of custom type RootDesignerView, a control that
      // will be shown in the Forms designer view. This member is
      // cached to reduce processing needed to recreate the
      // view control on each call to GetView().
      RootDesignerView^ m_view;

      // This method returns an instance of the view for this root
      // designer. The "view" is the user interface that is presented
      // in a document window for the user to manipulate.
      virtual Object^ GetView( ViewTechnology technology ) sealed = IRootDesigner::GetView
      {
         if ( technology != ViewTechnology::WindowsForms )
         {
            throw gcnew ArgumentException( "Not a supported view technology","technology" );
         }

         if ( m_view == nullptr )
         {
            
            // Some type of displayable Form or control is required
            // for a root designer that overrides GetView(). In this
            // example, a Control of type RootDesignerView is used.
            // Any class that inherits from Control will work.
            m_view = gcnew RootDesignerView( this );
         }

         return m_view;
      }


      // IRootDesigner.SupportedTechnologies is a required override for an
      // IRootDesigner. WindowsForms is the view technology used by this designer.
public:
      property array<ViewTechnology>^ SupportedTechnologies 
      {
        virtual array<ViewTechnology>^ get() 
        {
            return gcnew array<ViewTechnology> {ViewTechnology::Default};
                    
        }
      }
      
      // RootDesignerView is a simple control that will be displayed
      // in the designer window.
      ref class RootDesignerView: public Control
      {
      private:
         SampleRootDesigner^ m_designer;

      public:
         RootDesignerView( SampleRootDesigner^ designer )
         {
            m_designer = designer;
            BackColor = Color::Blue;
            Font = gcnew System::Drawing::Font( Font->FontFamily->Name,24.0f );
         }


      protected:
         virtual void OnPaint( PaintEventArgs^ pe ) override
         {
            Control::OnPaint( pe );
            
            // Draws the name of the component in large letters.
            pe->Graphics->DrawString( m_designer->Component->Site->Name, Font, Brushes::Yellow, ClientRectangle );
         }

      };


   };


   // This sample component inherits from RootDesignedComponent which
   // uses the SampleRootDesigner.
   public ref class RootViewSampleComponent: public RootDesignedComponent
   {
   public:
      RootViewSampleComponent(){}

   };

}

using System;
using System.Collections;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Diagnostics;
using System.Drawing;
using System.Windows.Forms;
using System.Windows.Forms.Design;

namespace SampleRootDesigner
{	
    // This sample demonstrates how to provide the root designer view, or
    // design mode background view, by overriding IRootDesigner.GetView().

    // This sample component inherits from RootDesignedComponent which 
    // uses the SampleRootDesigner.
    public class RootViewSampleComponent : RootDesignedComponent
    {
        public RootViewSampleComponent()
        {
        }
    }

    // The following attribute associates the SampleRootDesigner designer 
    // with the SampleComponent component.
    [Designer(typeof(SampleRootDesigner), typeof(IRootDesigner))]
    public class RootDesignedComponent : Component
    {
        public RootDesignedComponent()
        {
        }
    }

    public class SampleRootDesigner : ComponentDesigner, IRootDesigner
    {
        // Member field of custom type RootDesignerView, a control that 
        // will be shown in the Forms designer view. This member is 
        // cached to reduce processing needed to recreate the 
        // view control on each call to GetView().
        private RootDesignerView m_view;			

        // This method returns an instance of the view for this root
        // designer. The "view" is the user interface that is presented
        // in a document window for the user to manipulate. 
        object IRootDesigner.GetView(ViewTechnology technology) 
        {
            if (technology != ViewTechnology.Default)
            {
                throw new ArgumentException("Not a supported view technology", "technology");
            }
            if (m_view == null)
            {
                   // Some type of displayable Form or control is required 
                   // for a root designer that overrides GetView(). In this 
                   // example, a Control of type RootDesignerView is used.
                   // Any class that inherits from Control will work.
                m_view = new RootDesignerView(this);
            }
            return m_view;
        }

        // IRootDesigner.SupportedTechnologies is a required override for an
        // IRootDesigner. Default is the view technology used by this designer.  
        ViewTechnology[] IRootDesigner.SupportedTechnologies 
        {
            get
            {
                return new ViewTechnology[] {ViewTechnology.Default};
            }
        }

        // RootDesignerView is a simple control that will be displayed 
        // in the designer window.
        private class RootDesignerView : Control 
        {
            private SampleRootDesigner m_designer;

            public RootDesignerView(SampleRootDesigner designer)
            {
                m_designer = designer;
                BackColor = Color.Blue;
                Font = new Font(Font.FontFamily.Name, 24.0f);
            }

            protected override void OnPaint(PaintEventArgs pe)
            {
                base.OnPaint(pe);

                // Draws 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.Windows.Forms
Imports System.Windows.Forms.Design

Namespace SampleRootDesigner

    ' This sample demonstrates how to provide the root designer view, or
    ' design mode background view, by overriding IRootDesigner.GetView().

    ' This sample component inherits from RootDesignedComponent which 
    ' uses the SampleRootDesigner.
    Public Class RootViewSampleComponent
        Inherits RootDesignedComponent

        Public Sub New()
        End Sub

    End Class

    ' The following attribute associates the SampleRootDesigner designer 
    ' with the SampleComponent component.
    <Designer(GetType(SampleRootDesigner), GetType(IRootDesigner))> _
    Public Class RootDesignedComponent
        Inherits Component

        Public Sub New()
        End Sub 

    End Class 

    Public Class SampleRootDesigner
        Inherits ComponentDesigner
        Implements IRootDesigner

        ' Member field of custom type RootDesignerView, a control that 
        ' will be shown in the Forms designer view. This member is 
        ' cached to reduce processing needed to recreate the 
        ' view control on each call to GetView().
        Private m_view As RootDesignerView

        ' This method returns an instance of the view for this root
        ' designer. The "view" is the user interface that is presented
        ' in a document window for the user to manipulate. 
        Function GetView(ByVal technology As ViewTechnology) As Object Implements IRootDesigner.GetView
            If Not technology = ViewTechnology.Default Then
                Throw New ArgumentException("Not a supported view technology", "technology")
            End If
            If m_view Is Nothing Then
                ' Some type of displayable Form or control is required for a root designer that overrides 
                ' GetView(). In this example, a Control of type RootDesignerView is used.
                ' Any class that inherits from Control will work. 
                m_view = New RootDesignerView(Me)
            End If
            Return m_view
        End Function 

        ' IRootDesigner.SupportedTechnologies is a required override for an 
        ' IRootDesigner. Default is the view technology used by this designer.
        ReadOnly Property SupportedTechnologies() As ViewTechnology() Implements IRootDesigner.SupportedTechnologies
            Get
                Return New ViewTechnology() {ViewTechnology.Default}
            End Get
        End Property

        ' RootDesignerView is a simple control that will be displayed 
        ' in the designer window.
        Private Class RootDesignerView
            Inherits Control
            Private m_designer As SampleRootDesigner

            Public Sub New(ByVal designer As SampleRootDesigner)
                m_designer = designer
                BackColor = Color.Blue
                Font = New Font(Font.FontFamily.Name, 24.0F)
            End Sub 

            Protected Overrides Sub OnPaint(ByVal pe As PaintEventArgs)
                MyBase.OnPaint(pe)
                ' Draws the name of the component in large letters.
                Dim rf As New RectangleF(ClientRectangle.X, ClientRectangle.Y, ClientRectangle.Width, ClientRectangle.Height)
                pe.Graphics.DrawString(m_designer.Component.Site.Name, Font, Brushes.Yellow, rf)
            End Sub 

        End Class
    End Class

End Namespace

Commenti

Una finestra di progettazione radice è la finestra di progettazione che si trova nella posizione superiore o nella radice della gerarchia dell'oggetto documento in fase di progettazione corrente. Una finestra di progettazione radice deve implementare l'interfaccia IRootDesigner . Una finestra di progettazione radice gestisce in genere la visualizzazione in background in modalità visualizzazione progettazione e in genere visualizza i controlli all'interno del contenitore di base del progetto in fase di progettazione corrente.

Proprietà

Component	Ottiene il componente di base in fase di progettazione nella finestra di progettazione. (Ereditato da IDesigner)
SupportedTechnologies	Ottiene il gruppo di tecnologie che questa finestra di progettazione è in grado di supportare per la visualizzazione.
Verbs	Ottiene un insieme di verbi della fase di progettazione supportati dalla finestra di progettazione. (Ereditato da IDesigner)

Metodi

Dispose()	Esegue attività definite dall'applicazione, come rilasciare o reimpostare risorse non gestite. (Ereditato da IDisposable)
DoDefaultAction()	Esegue l'azione predefinita per questa finestra di progettazione. (Ereditato da IDesigner)
GetView(ViewTechnology)	Ottiene un oggetto visualizzazione per la tecnologia di visualizzazione specificata.
Initialize(IComponent)	Inizializza la finestra di progettazione con il componente specificato. (Ereditato da IDesigner)