Demonstra Passo a passo: Hospedando um controle composto do WPF no Windows Forms

Windows Presentation Foundation (WPF) provides a rich environment for creating applications. However, when you have a substantial investment in Windows Forms code, it can be more effective to extend your existing Windows Forms application with WPF rather than to rewrite it from scratch. Um cenário comum é quando você deseja incorporar um ou mais controles implementados com WPF dentro de seu Windows Forms aplicativo. Para obter mais informações sobre como personalizar controles do WPF, consulte Control Customization.

Esta explicação passo a passo orienta através de um aplicativo que hospeda um WPF um controle composto para realizar a entrada de dados em um Windows Forms aplicativo. O controle composto é empacotado em uma DLL. This general procedure can be extended to more complex applications and controls. Esta explicação passo a passo é projetada para ser praticamente idêntico em aparência e funcionalidade para Demonstra Passo a passo: Hospedando um controle Windows Forms composto no WPF. The primary difference is that the hosting scenario is reversed.

The walkthrough is divided into two sections. A primeira seção descreve brevemente a implementação de WPF controle composto. A segunda seção discute em detalhes como hospedar o controle composto em um Windows Forms aplicativo, receber eventos de controle e acessar algumas das propriedades de. o controle

Tasks illustrated in this walkthrough include:

• Implementação do controle de composição do WPF.

• Implementing the Windows Forms host application.

Para obter uma listagem de código completo das tarefas ilustradas nesta explicação, consulte que hospeda um controle composto do WPF Windows Forms de exemplo.

Prerequisites

You need the following components to complete this walkthrough:

• Visual Studio 2010.

Implementação do controle de composição do WPF

O WPF um controle composto usado neste exemplo é um formulário de entrada de dados simples que leva o usuário nome e endereço. Quando o usuário clica em um dos dois botões para indicar que a tarefa é concluída, o controle dispara um evento personalizado para retornar as informações para o host. The following illustration shows the rendered control.

Controle composto do WPF

Creating the Project

To start the project:

1. Launch Microsoft Visual Studio, and open the New Project dialog box.

2. No Visual C# e a categoria do Windows, selecione o Biblioteca de controle de usuário do WPF modelo.

3. Nomeie o novo projeto MyControls.

4. O local, especifique uma pasta de nível superior convenientemente nomeada, como WindowsFormsHostingWpfControl. Posteriormente, você colocará o aplicativo host nesta pasta.

5. Click OK to create the project. The default project contains a single control named UserControl1.

6. No Solution Explorer, renomeie UserControl1 para MyControl1.

Your project should have references to the following system DLLs. Se qualquer uma dessas DLLs não são incluídos por padrão, você deve adicioná-los ao seu projeto.

• PresentationCore

• PresentationFramework

• System

• WindowsBase

Criando a Interface do usuário

O user interface (UI) para o controle composto é implementado com Extensible Application Markup Language (XAML). O controle composto UI consiste em cinco TextBox elementos. Each TextBox element has an associated TextBlock element that serves as a label. Há dois Button elementos na parte inferior, OK e Cancelar. Quando o usuário clica em um dos botões, o controle dispara um evento personalizado para retornar as informações para o host.

Basic Layout

The various UI elements are contained in a Grid element. Você pode usar Grid para organizar o conteúdo de composição controla quase da mesma maneira como você usaria uma Table elemento no HTML. WPFtambém tem um Table elemento, mas Grid é mais leve e mais adequada para tarefas de layout simples.

O XAML a seguir mostra o layout básico. Esse XAML define a estrutura geral do controle, especificando o número de colunas e linhas na Grid elemento.

No MyControl1.xaml, substitua o XAML existente com o seguinte XAML.

<Grid xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
      xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
      x:Class="MyControls.MyControl1"
      Background="#DCDCDC"
      Width="375"
      Height="250"
      Name="rootElement"
      Loaded="Init">

  <Grid.ColumnDefinitions>
    <ColumnDefinition Width="Auto" />
    <ColumnDefinition Width="Auto" />
    <ColumnDefinition Width="Auto"/>
    <ColumnDefinition Width="Auto"/>
  </Grid.ColumnDefinitions>

  <Grid.RowDefinitions>
    <RowDefinition Height="Auto" />
    <RowDefinition Height="Auto" />
    <RowDefinition Height="Auto" />
    <RowDefinition Height="Auto" />
    <RowDefinition Height="Auto" />
    <RowDefinition Height="Auto" />
  </Grid.RowDefinitions>


...


</Grid>

Adding TextBlock and TextBox Elements to the Grid

You place a UI element in the grid by setting the element's RowProperty and ColumnProperty attributes to the appropriate row and column number. Remember that row and column numbering are zero-based. You can have an element span multiple columns by setting its ColumnSpanProperty attribute. Para obter mais informações sobre Grid elementos, consulte Como: Criar um Elemento de Grade.

O XAML a seguir mostra o controle composto TextBox e TextBlock elementos com seus RowProperty e ColumnProperty atributos, que são definidos para colocar os elementos corretamente na grade.

No MyControl1.xaml, adicione o seguinte XAML dentro do Grid elemento.

<TextBlock Grid.Column="0"
      Grid.Row="0" 
      Grid.ColumnSpan="4"
      Margin="10,5,10,0"
      HorizontalAlignment="Center"
      Style="{StaticResource titleText}">Simple WPF Control</TextBlock>

<TextBlock Grid.Column="0"
      Grid.Row="1"
      Style="{StaticResource inlineText}"
      Name="nameLabel">Name</TextBlock>
<TextBox Grid.Column="1"
      Grid.Row="1"
      Grid.ColumnSpan="3"
      Name="txtName"/>

<TextBlock Grid.Column="0"
      Grid.Row="2"
      Style="{StaticResource inlineText}"
      Name="addressLabel">Street Address</TextBlock>
<TextBox Grid.Column="1"
      Grid.Row="2"
      Grid.ColumnSpan="3"
      Name="txtAddress"/>

<TextBlock Grid.Column="0"
      Grid.Row="3"
      Style="{StaticResource inlineText}"
      Name="cityLabel">City</TextBlock>
<TextBox Grid.Column="1"
      Grid.Row="3"
      Width="100"
      Name="txtCity"/>

<TextBlock Grid.Column="2"
      Grid.Row="3"
      Style="{StaticResource inlineText}"
      Name="stateLabel">State</TextBlock>
<TextBox Grid.Column="3"
      Grid.Row="3"
      Width="50"
      Name="txtState"/>

<TextBlock Grid.Column="0"
      Grid.Row="4"
      Style="{StaticResource inlineText}"
      Name="zipLabel">Zip</TextBlock>
<TextBox Grid.Column="1"
      Grid.Row="4"
      Width="100"
      Name="txtZip"/>

Styling the UI Elements

Many of the elements on the data-entry form have a similar appearance, which means that they have identical settings for several of their properties. Em vez de definir os atributos do elemento separadamente, o XAML anterior usa Style elementos para definir configurações de propriedade padrão para classes de elementos. Essa abordagem reduz a complexidade do controle e permite que você altere a aparência de vários elementos por meio de um atributo de estilo único.

O Style elementos estão contidos no Grid do elemento Resources propriedade, portanto, eles podem ser usados por todos os elementos de controle. If a style is named, you apply it to an element by adding a Style element set to the style's name. Os estilos que não são nomeados tornam-se o estilo padrão para o elemento. Para obter mais informações sobre WPF estilos, consulte Styling and Templating.

O XAML a seguir mostra a Style elementos para o controle composto. Para ver como os estilos são aplicados a elementos, consulte o XAML anterior. For example, the last TextBlock element has the inlineText style, and the last TextBox element uses the default style.

No MyControl1.xaml, adicione o seguinte XAML logo após o Grid Iniciar o elemento.

<Grid.Resources>
  <Style x:Key="inlineText" TargetType="{x:Type TextBlock}">
    <Setter Property="Margin" Value="10,5,10,0"/>
    <Setter Property="FontWeight" Value="Normal"/>
    <Setter Property="FontSize" Value="12"/>
  </Style>
  <Style x:Key="titleText" TargetType="{x:Type TextBlock}">
    <Setter Property="DockPanel.Dock" Value="Top"/>
    <Setter Property="FontWeight" Value="Bold"/>
    <Setter Property="FontSize" Value="14"/>
    <Setter Property="Margin" Value="10,5,10,0"/>
  </Style>
  <Style TargetType="{x:Type Button}">
    <Setter Property="Margin" Value="10,5,10,0"/>
    <Setter Property="Width" Value="60"/>
  </Style>
  <Style TargetType="{x:Type TextBox}">
    <Setter Property="Margin" Value="10,5,10,0"/>
  </Style>
</Grid.Resources>

Adding the OK and Cancel Buttons

Os elementos finais no controle composto são o OK e Cancelar Button elementos, que ocupam duas primeiras colunas da última linha do Grid. Esses elementos usam um manipulador de eventos comuns, ButtonClickede o padrão Button estilo definido em XAML anterior.

No MyControl1.xaml, adicione o seguinte XAML após a última TextBox elemento. O XAML parte do controle composto está agora concluída.

<Button Grid.Row="5"
        Grid.Column="0"
        Name="btnOK"
        Click="ButtonClicked">OK</Button>
<Button Grid.Row="5"
        Grid.Column="1"
        Name="btnCancel"
        Click="ButtonClicked">Cancel</Button>

Implementing the Code-Behind File

O arquivo de code-behind, MyControl1.xaml.cs, implementa três tarefas essenciais:

1. Handles the event that occurs when the user clicks one of the buttons.

2. Retrieves the data from the TextBox elements, and packages it in a custom event argument object.

3. Raises the custom OnButtonClick event, which notifies the host that the user is finished and passes the data back to the host.

O controle também expõe várias propriedades de cor e fonte que permitem alterar a aparência. Diferentemente a WindowsFormsHost classe, que é usada para host um Windows Forms controle, o ElementHost classe expõe o controle Background propriedade apenas. Para manter a similaridade entre este exemplo de código e exemplo abordado na Demonstra Passo a passo: Hospedando um controle Windows Forms composto no WPF, o controle expõe as propriedades restantes diretamente.

The Basic Structure of the Code-Behind File

O arquivo code-behind consiste em um único namespace, MyControls, que irá conter duas classes, MyControl1 e MyControlEventArgs.

namespace MyControls
{
  public partial class MyControl1 : Grid
  {
    //...
  }
  public class MyControlEventArgs : EventArgs
  {
    //...
  }
}

A primeira classe, MyControl1, é uma classe parcial que contém o código que implementa a funcionalidade da UI definido em MyControl1.xaml. Quando MyControl1.xaml é analisado, o XAML é convertido para a mesma classe parcial, e as duas classes parciais são mescladas para formar o controle compilado. Por esse motivo, o nome da classe no arquivo code-behind deve corresponder ao nome da classe atribuído a MyControl1.xaml e ela deve herdar do elemento raiz do controle. The second class, MyControlEventArgs, is an event arguments class that is used to send the data back to the host.

Abra MyControl1.xaml.cs. Alterar a declaração de classe existente, para que ele tem o seguinte nome e herda de Grid.

public partial class MyControl1 : Grid

Inicializar o controle

O código a seguir implementa várias tarefas básicas:

• Declares a private event, OnButtonClick, and its associated delegate, MyControlEventHandler.

• Creates several private global variables that store the user's data. This data is exposed through corresponding properties.

• Implementa um manipulador, Init, para o controle Loaded de evento. Esse manipulador inicializa as variáveis globais, atribuindo-lhes os valores definidos no MyControl1.xaml. To do this, it uses the Name assigned to a typical TextBlock element, nameLabel, to access that element's property settings.

Excluir o construtor existente e adicione o seguinte código para seu MyControl1 classe.

public delegate void MyControlEventHandler(object sender, MyControlEventArgs args);
public event MyControlEventHandler OnButtonClick;
private FontWeight _fontWeight;
private double _fontSize;
private FontFamily _fontFamily;
private FontStyle _fontStyle;
private SolidColorBrush _foreground;
private SolidColorBrush _background;

private void Init(object sender, EventArgs e)
{
    //They all have the same style, so use nameLabel to set initial values.
    _fontWeight = nameLabel.FontWeight;
    _fontSize = nameLabel.FontSize;
    _fontFamily = nameLabel.FontFamily;
    _fontStyle = nameLabel.FontStyle;
    _foreground = (SolidColorBrush)nameLabel.Foreground;
    _background = (SolidColorBrush)rootElement.Background;
}

Handling the Buttons' Click Events

O usuário indica que a tarefa de entrada de dados estiver concluída, clicando no OK botão ou o Cancelar botão. Both buttons use the same Click event handler, ButtonClicked. Both buttons have a name, btnOK or btnCancel, that enables the handler to determine which button was clicked by examining the value of the sender argument. The handler does the following:

• Cria um MyControlEventArgs o objeto que contém os dados a partir de TextBox elementos.

• If the user clicked the Cancel button, sets the MyControlEventArgs object's IsOK property to false.

• Raises the OnButtonClick event to indicate to the host that the user is finished, and passes back the collected data.

Adicione o seguinte código para seu MyControl1 de classe, após a Init método.

private void ButtonClicked(object sender, RoutedEventArgs e)
{
    MyControlEventArgs retvals = new MyControlEventArgs(true,
                                                        txtName.Text,
                                                        txtAddress.Text,
                                                        txtCity.Text,
                                                        txtState.Text,
                                                        txtZip.Text);
    if (sender == btnCancel)
    {
        retvals.IsOK = false;
    }
    if (OnButtonClick != null)
        OnButtonClick(this, retvals);
}

Creating Properties

O restante da classe simplesmente expõe propriedades que correspondem às variáveis globais discutidas anteriormente. Quando uma propriedade é alterada, o acessador set modifica a aparência do controle, alterando as propriedades do elemento correspondente e atualizar as variáveis globais subjacentes.

Add the following code to your MyControl1 class.

public FontWeight MyControl_FontWeight
{
    get { return _fontWeight; }
    set
    {
        _fontWeight = value;
        nameLabel.FontWeight = value;
        addressLabel.FontWeight = value;
        cityLabel.FontWeight = value;
        stateLabel.FontWeight = value;
        zipLabel.FontWeight = value;
    }
}
public double MyControl_FontSize
{
    get { return _fontSize; }
    set
    {
        _fontSize = value;
        nameLabel.FontSize = value;
        addressLabel.FontSize = value;
        cityLabel.FontSize = value;
        stateLabel.FontSize = value;
        zipLabel.FontSize = value;
    }
}
public FontStyle MyControl_FontStyle
{
    get { return _fontStyle; }
    set
    {
        _fontStyle = value;
        nameLabel.FontStyle = value;
        addressLabel.FontStyle = value;
        cityLabel.FontStyle = value;
        stateLabel.FontStyle = value;
        zipLabel.FontStyle = value;
    }
}
public FontFamily MyControl_FontFamily
{
    get { return _fontFamily; }
    set
    {
        _fontFamily = value;
        nameLabel.FontFamily = value;
        addressLabel.FontFamily = value;
        cityLabel.FontFamily = value;
        stateLabel.FontFamily = value;
        zipLabel.FontFamily = value;
    }
}

public SolidColorBrush MyControl_Background
{
    get { return _background; }
    set
    {
        _background = value;
        rootElement.Background = value;
    }
}
public SolidColorBrush MyControl_Foreground
{
    get { return _foreground; }
    set
    {
        _foreground = value;
        nameLabel.Foreground = value;
        addressLabel.Foreground = value;
        cityLabel.Foreground = value;
        stateLabel.Foreground = value;
        zipLabel.Foreground = value;
    }
}

Sending the Data Back to the Host

The final component in the file is the MyControlEventArgs class, which is used to send the collected data back to the host.

Add the following code to your MyControls namespace. The implementation is straightforward, and is not discussed further.

public class MyControlEventArgs : EventArgs
{
    private string _Name;
    private string _StreetAddress;
    private string _City;
    private string _State;
    private string _Zip;
    private bool _IsOK;

    public MyControlEventArgs(bool result,
                              string name,
                              string address,
                              string city,
                              string state,
                              string zip)
    {
        _IsOK = result;
        _Name = name;
        _StreetAddress = address;
        _City = city;
        _State = state;
        _Zip = zip;
    }

    public string MyName
    {
        get { return _Name; }
        set { _Name = value; }
    }
    public string MyStreetAddress
    {
        get { return _StreetAddress; }
        set { _StreetAddress = value; }
    }
    public string MyCity
    {
        get { return _City; }
        set { _City = value; }
    }
    public string MyState
    {
        get { return _State; }
        set { _State = value; }
    }
    public string MyZip
    {
        get { return _Zip; }
        set { _Zip = value; }
    }
    public bool IsOK
    {
        get { return _IsOK; }
        set { _IsOK = value; }
    }
}

Build the solution. The build will produce a DLL named MyControls.dll.

Implementing the Windows Forms Host Application

O Windows Forms hospedar o aplicativo usa um ElementHost o objeto de host de WPF controle composto. As alças de aplicativo do OnButtonClick evento para receber os dados do controle composto. O aplicativo também tem um conjunto de botões de opção que você pode usar para modificar a aparência do controle. A ilustração a seguir mostra o aplicativo.

Controle composto do WPF hospedado em um aplicativo Windows Forms

Creating the Project

To start the project:

1. Launch Visual Studio, and open the New Project dialog box.

2. No Visual C# e a categoria do Windows, selecione o Windows Forms Application modelo.

3. Nomeie o novo projeto WFHost.

4. O local, especifique a mesma pasta de nível superior que contém o projeto MyControls.

5. Click OK to create the project.

Você também precisará adicionar referências para a DLL que contém MyControl1 e outros assemblies.

1. Clique com o botão direito no nome do projeto no Solution Explorer e selecione Adicionar referência de.

2. Clique o Procurar guia e navegue até a pasta que contém MyControls. dll. Para esta explicação, esta pasta é MyControls\bin\Debug.

3. Selecione MyControls. dll e clique em OK.

4. Add references to the following assemblies.

   • PresentationCore

   • PresentationFramework

   • System.XAML

   • WindowsBase

   • WindowsFormsIntegration

Implementando a Interface do usuário para o aplicativo.

A interface do usuário para o aplicativo do Windows Form contém vários controles para interagir com o controle de composição do WPF.

1. Abra o Form1 no Designer de formulário do Windows.

2. Amplie o formulário para acomodar os controles.

3. No canto superior direito do formulário, adicione um System.Windows.Forms.Panel o controle para armazenar o WPF de controle composto.

4. Adicione o seguinte System.Windows.Forms.GroupBox controles no formulário.

   Name	Text
   groupBox1	Cor de plano de fundo
   groupBox2	Cor de primeiro plano
   groupBox3	Font Size
   groupBox4	Família de fontes
   groupBox5	Estilo da fonte
   groupBox6	Peso da fonte
   groupBox7	Dados de controle

5. Adicione o seguinte System.Windows.Forms.RadioButton os controles para o System.Windows.Forms.GroupBox controles.

   GroupBox	Name	Text
   groupBox1	radioBackgroundOriginal	Original
   groupBox1	radioBackgroundLightGreen	Verdeluz
   groupBox1	radioBackgroundLightSalmon	LightSalmon
   groupBox2	radioForegroundOriginal	Original
   groupBox2	radioForegroundRed	Red
   groupBox2	radioForegroundYellow	Yellow
   groupBox3	radioSizeOriginal	Original
   groupBox3	radioSizeTen	10
   groupBox3	radioSizeTwelve	12
   groupBox4	radioFamilyOriginal	Original
   groupBox4	radioFamilyTimes	Times New Roman
   groupBox4	radioFamilyWingDings	WingDings
   groupBox5	radioStyleOriginal	Normal
   groupBox5	radioStyleItalic	Itálico
   groupBox6	radioWeightOriginal	Original
   groupBox6	radioWeightBold	Negrito

6. Adicione o seguinte System.Windows.Forms.Label controla a última System.Windows.Forms.GroupBox. Esses controles exibem os dados retornados pelo WPF de controle composto.

   GroupBox	Name	Text
   groupBox7	lblName	Name:
   groupBox7	lblAddress	Endereço:
   groupBox7	lblCity	Cidade:
   groupBox7	lblState	Estado:
   groupBox7	lblZip	CEP:

Initializing the Form

You generally implement the hosting code in the form's Load event handler. O código a seguir mostra a Load manipulador de eventos, um manipulador para o WPF do controle composto Loaded de eventos e declarações para diversas variáveis globais que são usadas posteriormente.

No Windows Forms Designer, clique duas vezes no formulário para criar um Load manipulador de eventos. Na parte superior de Form1. cs, adicione o seguinte using instruções.

using System;
using System.Windows;
using System.Windows.Navigation;
using System.Windows.Controls;
using System.Windows.Media;

namespace MyControls
{
    public partial class MyControl1 : Grid
    {
        public delegate void MyControlEventHandler(object sender, MyControlEventArgs args);
        public event MyControlEventHandler OnButtonClick;
        private FontWeight _fontWeight;
        private double _fontSize;
        private FontFamily _fontFamily;
        private FontStyle _fontStyle;
        private SolidColorBrush _foreground;
        private SolidColorBrush _background;

        private void Init(object sender, EventArgs e)
        {
            //They all have the same style, so use nameLabel to set initial values.
            _fontWeight = nameLabel.FontWeight;
            _fontSize = nameLabel.FontSize;
            _fontFamily = nameLabel.FontFamily;
            _fontStyle = nameLabel.FontStyle;
            _foreground = (SolidColorBrush)nameLabel.Foreground;
            _background = (SolidColorBrush)rootElement.Background;
        }

        private void ButtonClicked(object sender, RoutedEventArgs e)
        {
            MyControlEventArgs retvals = new MyControlEventArgs(true,
                                                                txtName.Text,
                                                                txtAddress.Text,
                                                                txtCity.Text,
                                                                txtState.Text,
                                                                txtZip.Text);
            if (sender == btnCancel)
            {
                retvals.IsOK = false;
            }
            if (OnButtonClick != null)
                OnButtonClick(this, retvals);
        }

        public FontWeight MyControl_FontWeight
        {
            get { return _fontWeight; }
            set
            {
                _fontWeight = value;
                nameLabel.FontWeight = value;
                addressLabel.FontWeight = value;
                cityLabel.FontWeight = value;
                stateLabel.FontWeight = value;
                zipLabel.FontWeight = value;
            }
        }
        public double MyControl_FontSize
        {
            get { return _fontSize; }
            set
            {
                _fontSize = value;
                nameLabel.FontSize = value;
                addressLabel.FontSize = value;
                cityLabel.FontSize = value;
                stateLabel.FontSize = value;
                zipLabel.FontSize = value;
            }
        }
        public FontStyle MyControl_FontStyle
        {
            get { return _fontStyle; }
            set
            {
                _fontStyle = value;
                nameLabel.FontStyle = value;
                addressLabel.FontStyle = value;
                cityLabel.FontStyle = value;
                stateLabel.FontStyle = value;
                zipLabel.FontStyle = value;
            }
        }
        public FontFamily MyControl_FontFamily
        {
            get { return _fontFamily; }
            set
            {
                _fontFamily = value;
                nameLabel.FontFamily = value;
                addressLabel.FontFamily = value;
                cityLabel.FontFamily = value;
                stateLabel.FontFamily = value;
                zipLabel.FontFamily = value;
            }
        }

        public SolidColorBrush MyControl_Background
        {
            get { return _background; }
            set
            {
                _background = value;
                rootElement.Background = value;
            }
        }
        public SolidColorBrush MyControl_Foreground
        {
            get { return _foreground; }
            set
            {
                _foreground = value;
                nameLabel.Foreground = value;
                addressLabel.Foreground = value;
                cityLabel.Foreground = value;
                stateLabel.Foreground = value;
                zipLabel.Foreground = value;
            }
        }
    }

    public class MyControlEventArgs : EventArgs
    {
        private string _Name;
        private string _StreetAddress;
        private string _City;
        private string _State;
        private string _Zip;
        private bool _IsOK;

        public MyControlEventArgs(bool result,
                                  string name,
                                  string address,
                                  string city,
                                  string state,
                                  string zip)
        {
            _IsOK = result;
            _Name = name;
            _StreetAddress = address;
            _City = city;
            _State = state;
            _Zip = zip;
        }

        public string MyName
        {
            get { return _Name; }
            set { _Name = value; }
        }
        public string MyStreetAddress
        {
            get { return _StreetAddress; }
            set { _StreetAddress = value; }
        }
        public string MyCity
        {
            get { return _City; }
            set { _City = value; }
        }
        public string MyState
        {
            get { return _State; }
            set { _State = value; }
        }
        public string MyZip
        {
            get { return _Zip; }
            set { _Zip = value; }
        }
        public bool IsOK
        {
            get { return _IsOK; }
            set { _IsOK = value; }
        }
    }
}

using System.Windows;
using System.Windows.Forms.Integration;
using System.Windows.Media;

Substituir o conteúdo existente Form1 classe com o código a seguir.

private ElementHost ctrlHost;
private MyControls.MyControl1 wpfAddressCtrl;
System.Windows.FontWeight initFontWeight;
double initFontSize;
System.Windows.FontStyle initFontStyle;
System.Windows.Media.SolidColorBrush initBackBrush;
System.Windows.Media.SolidColorBrush initForeBrush;
System.Windows.Media.FontFamily initFontFamily;

public Form1()
{
    InitializeComponent();
}

private void Form1_Load(object sender, EventArgs e)
{
    ctrlHost = new ElementHost();
    ctrlHost.Dock = DockStyle.Fill;
    panel1.Controls.Add(ctrlHost);
    wpfAddressCtrl = new MyControls.MyControl1();
    wpfAddressCtrl.InitializeComponent();
    ctrlHost.Child = wpfAddressCtrl;

    wpfAddressCtrl.OnButtonClick +=
        new MyControls.MyControl1.MyControlEventHandler(
        avAddressCtrl_OnButtonClick);
    wpfAddressCtrl.Loaded += new RoutedEventHandler(
        avAddressCtrl_Loaded);
}

void avAddressCtrl_Loaded(object sender, EventArgs e)
{
    initBackBrush = (SolidColorBrush)wpfAddressCtrl.MyControl_Background;
    initForeBrush = wpfAddressCtrl.MyControl_Foreground;
    initFontFamily = wpfAddressCtrl.MyControl_FontFamily;
    initFontSize = wpfAddressCtrl.MyControl_FontSize;
    initFontWeight = wpfAddressCtrl.MyControl_FontWeight;
    initFontStyle = wpfAddressCtrl.MyControl_FontStyle;
}

O Form1_Load método no código anterior mostra o procedimento geral para hospedar uma WPF controle:

1. Create a new ElementHost object.

2. Set the control's Dock property to DockStyle.Fill.

3. Add the ElementHost control to the Panel control's Controls collection.

4. Criar uma instância de WPF de controle.

5. Hospedar o controle de composição no formulário atribuindo o controle para o ElementHost do controle Child propriedade.

As duas linhas restantes na Form1_Load método anexar manipuladores de eventos de controle de dois:

• OnButtonClické um evento personalizado que é acionado pelo controle composto, quando o usuário clica a OK ou Cancelar botão. Você manipular o evento para obter a resposta do usuário e para coletar todos os dados que o usuário especificado.

• Loadedé um evento padrão gerado por um WPF controle quando ele está totalmente carregado. O evento é usado aqui porque o exemplo precisa inicializar diversas variáveis globais usando propriedades do controle. No momento do formulário Load evento, o controle é não totalmente carregado e ainda, esses valores são definidos como null. Você precisa esperar até que o controle Loaded evento ocorre antes que você pode acessar essas propriedades.

O Loaded manipulador de eventos é mostrado no código anterior. The OnButtonClick handler is discussed in the next section.

Handling OnButtonClick

The OnButtonClick event occurs when the user clicks the OK or Cancel button.

The event handler checks the event argument's IsOK field to determine which button was clicked. O lbldados variáveis correspondem do Label controles que foram discutidos anteriormente. Se o usuário clica o OK botão, os dados a partir do controle TextBox controles é atribuído ao correspondente Label de controle. Se o usuário clica em Cancelar, o Text valores são definidos para as seqüências de caracteres padrão.

Adicionar o botão a seguir clique em código de manipulador de eventos para o Form1 classe.

void avAddressCtrl_OnButtonClick(
    object sender,
    MyControls.MyControl1.MyControlEventArgs args)
{
    if (args.IsOK)
    {
        lblAddress.Text = "Street Address: " + args.MyStreetAddress;
        lblCity.Text = "City: " + args.MyCity;
        lblName.Text = "Name: " + args.MyName;
        lblState.Text = "State: " + args.MyState;
        lblZip.Text = "Zip: " + args.MyZip;
    }
    else
    {
        lblAddress.Text = "Street Address: ";
        lblCity.Text = "City: ";
        lblName.Text = "Name: ";
        lblState.Text = "State: ";
        lblZip.Text = "Zip: ";
    }
}

Criar e executar o aplicativo. Adicionar algum texto no controle WPF composto e clique em OK. O texto é exibido nos rótulos. Neste ponto, código não foi adicionado para lidar com os botões de opção.

Modificação da aparência do controle

O RadioButton controles no formulário permitirá que o usuário altere a WPF do controle composto primeiro plano e cores de plano de fundo, bem como várias propriedades de fonte. The background color is exposed by the ElementHost object. As propriedades restantes são expostas como propriedades personalizadas do controle.

Clique duas vezes em cada RadioButton controle no formulário para criar CheckedChanged manipuladores de evento. Substituir o CheckedChanged manipuladores de eventos com o código a seguir.

private void radioBackgroundOriginal_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_Background = initBackBrush;
}

private void radioBackgroundLightGreen_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_Background = new SolidColorBrush(Colors.LightGreen);
}

private void radioBackgroundLightSalmon_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_Background = new SolidColorBrush(Colors.LightSalmon);
}

private void radioForegroundOriginal_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_Foreground = initForeBrush;
}

private void radioForegroundRed_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_Foreground = new System.Windows.Media.SolidColorBrush(Colors.Red);
}

private void radioForegroundYellow_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_Foreground = new System.Windows.Media.SolidColorBrush(Colors.Yellow);
}

private void radioFamilyOriginal_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_FontFamily = initFontFamily;
}

private void radioFamilyTimes_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_FontFamily = new System.Windows.Media.FontFamily("Times New Roman");
}

private void radioFamilyWingDings_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_FontFamily = new System.Windows.Media.FontFamily("WingDings");
}

private void radioSizeOriginal_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_FontSize = initFontSize;
}

private void radioSizeTen_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_FontSize = 10;
}

private void radioSizeTwelve_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_FontSize = 12;
}

private void radioStyleOriginal_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_FontStyle = initFontStyle;
}

private void radioStyleItalic_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_FontStyle = System.Windows.FontStyles.Italic;
}

private void radioWeightOriginal_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_FontWeight = initFontWeight;
}

private void radioWeightBold_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_FontWeight = FontWeights.Bold;
}

Criar e executar o aplicativo. Clique nos botões de rádio diferente para ver o efeito sobre o controle de composição do WPF.

Consulte também

Tarefas

Demonstra Passo a passo: Hospedando um controle composto do WPF 3D no Windows Forms

Referência

ElementHost

WindowsFormsHost

Conceitos

Demonstra Passo a passo: Hospedando um controle Windows Forms composto no WPF

Outros recursos

WPF Designer