Partilhar via

Demonstra Passo a passo: Hospedagem de um controle Windows Presentation Foundation no Windows Forms

  • Artigo

Windows Presentation Foundation (WPF) provides a rich environment for creating applications. No entanto, quando houver investimento significativo no código Windows Forms, pode ser mais eficiente estender seu aplicativo Windows Forms com WPF em vez de reescrevê-lo a partir do zero. Um cenário comum é quando você deseja incorporar uma ou mais páginas implementadas com WPF dentro de seu aplicativo Windows Forms

Essa explicação passo a passo orienta a um aplicativo que hospede uma página WPF em um aplicativo Windows Forms. A página é um aplicativo simples de entrada de dados que está contido em uma DLL. Este exemplo é projetado para ser praticamente idêntico em aparência e funcionalidade ao Hospedagem de um Controlarar composto do Windows Forms no Windows Presentation Foundation Exemplo. A principal diferença é que o cenário de hospedagem é invertido.

ObservaçãoObservação:

A página host não é um WPF controlar no sentido estrito do termo. Em vez disso, ela é uma página WPF comum que está contida em uma DLL. No entanto, as técnicas para hospedar um controle WPF em um formulário são idênticas às usadoas para hospedar uma página comum. Consulte Control Customization para obter mais discussões sobre controles WPF.

A explicação passo a passo é dividida em duas seções. A primeira seção rapidamente descreve a implementação da página WPF. A segunda seção descreve detalhadamente como hospedar a página em um aplicativo Windows Forms, receber eventos a partir da página e acessar algumas das propriedades da página.

Tarefas ilustradas nesta explicação passo a passo incluem:

  • Implementando a página Windows Presentation Foundation.

  • Implementando o aplicativo host Windows Forms.

For a complete code listing of the tasks illustrated in this walkthrough, see Hospedagem um Controlarar de Foundation de apresentação do Windows simples no Windows Forms Exemplo.

Pré-requisitos

Para completar este passo a passo, são necessários os seguintes componentes:

  • Visual Studio 2008.

Implementando a página Windows Presentation Foundation.

A página WPF usada nesse exemplo é um formulário simples de entrada de dados que usa endereço e nome do usuário. Quando o usuário clica em um dos dois botões para indicar que a tarefa está concluída, a página gera um evento personalizado para retornar essa informação ao host. Esta página é essencialmente idêntica em forma e função ao controle Windows Forms usado em Demonstra Passo a passo: Hospedagem de um controle composto do Windows Forms no Windows Presentation Foundation. Não há nada de especial sobre a página para personalizá-la para hospedagem em um formula?io Windows Forms. Pode-se apenas tão facilmente carregá-lo em um Frame em uma página WPF maior. A ilustração a seguir mostra a página processada.

Página Windows Presentation Foundation

Controle simples do WPF

Criando o projeto

Para iniciar o projeto:

  1. Iniciar Microsoft Visual Studio e abrir a caixa de diálogo Novo Projeto.

  2. Selecione o modelo Aplicativo de Navegação WPF.

  3. Nomeie o novo projeto MeusControles , e coloque-o em uma pasta de nível superior convenientemente nomeada, por exemplo, WfHostingWpf. Posteriormente, o aplicativo host deverá ser colocado nessa pasta também. Clique em OK para criar o projeto. O projeto padrão contém uma única página denominada Page1.

  4. Clique com o botão direito do mouse no nome do projeto no Gerenciador de Soluções e selecione Propriedades.

  5. Defina o Tipo de Saída como Biblioteca de Classes para compilar a página como uma DLL.

  6. Exclua os arquivos de definição de aplicativo, MyApp.XAML e MyApp.XAML.cs, do projeto. Esses arquivos são necessários apenas se você estiver implementando a página como um aplicativo.

ObservaçãoObservação:

Quando você compila um WPF aplicativo sistema autônomo uma biblioteca de classes, você não é possível iniciá-la para exibir a página renderizada. Por esse motivo, talvez seja conveniente deixar o tipo de saída como "Aplicativo do Windows" até que o aplicativo esteja totalmente implementado. Isso permite a verificação da aparência das páginas, iniciando o aplicativo. Quando estiver satisfeito, exclua os arquivos de definição de aplicativo e altere o tipo de saída para "Biblioteca de Classes" para compilá-la como uma DLL.

Seu projeto deve ter referências às seguintes DLLs de sistema. Se quaisquer dessas DLLs não forem incluídas por padrão, adicione-as ao seu projeto.

  • Sistema

  • PresentationCore

  • PresentationFramework

  • WindowsBase

Implementando a Interface do Usuário da Página

A WPF interface do usuário (UI) da página é implementada com Extensible Application Markup Language (XAML). Ele é projetado para ser semelhante em aparência e funcionalidade ao controle Windows Forms abordado na Demonstra Passo a passo: Hospedagem de um controle composto do Windows Forms no Windows Presentation Foundation. A UI de entrada de dados da página consiste de cinco elementos TextBox. Cada elemento TextBox possui um elemento TextBlock associado que serve como um rótulo. Há dois elementos Button na parte inferior da página, OK e Cancelar. Quando o usuário clica em quaisquer dos botões, a página gera um evento personalizado para retornar as informações para o host.

Layout básico

Os vários elementos UI estão contidos em um elemento Grid. Você pode usar Grid para organizar o Sumário da página em grande parte da mesma forma que faria usa um Table elemento em HTML. WPF também tem um Table elemento, mas Grid é melhor adequado para tarefas simples de layout e mais leve.

O exemplo a seguir mostra o código de layout básico. Esse código define a estrutura geral da página especificando o número de colunas e linhas no elemento Grid. Use-o para substituir o código em Page1.xaml.

<Grid xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
      xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
      x:Class="MyControls.Page1"
      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>

Adicionando Elementos TextBox e TextBlock à Grade

Coloca-se um elemento UI na grade definindo os atributos RowProperty e ColumnProperty do elemento ao número da linha e da coluna apropriadas. Lembre-se de que a numeração de linha e coluna é baseada em zero. Pode-se fazer um elemento estender várias colunas definindo seu atributo ColumnSpanProperty. Consulte Como: Criar um Elemento de Grade para obter mais informações sobre elementos Grid.

O exemplo a seguir mostra TextBox e TextBlock elementos com suas RowProperty e ColumnProperty atributos, que são conjunto para colocar os elementos adequadamente na grade. Adicione este código para Page1.xaml, logo abaixo do elemento Grid.

<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"/>

Estilos de Elementos de Interface do Usuário

Muitos dos elementos no formulário de entrada de dados têm uma aparência semelhante, o que significa que eles tem configurações idênticas para várias de suas propriedades. Em vez definir atributos de cada elemento separadamente, o código de exemplo usa elementos Style para definir configurações padrão de propriedades para classes de elementos. Essa abordagem reduz a complexidade da página e permite que você altere a aparência dos vários elementos por um único atributo de estilo.

Os elementos Style estão contidos na Grid propriedade Resources do elemento, para que eles possam ser usados por todos os elementos na página. Se um estilo for nomeado, aplique-o a um elemento, adicionando uma definição de elemento Style ao nome do estilo. Estilos que não são nomeados tornam-se o estilo padrão para o elemento. Consulte Styling and Templating para obter informações adicionais em estilos WPF.

O exemplo a seguir mostra os elementos Style para a página WPF. Adicione o código para Page1.xaml, logo abaixo do elemento Grid. Para ver como os estilos são aplicados aos elementos, consulte o exemplo de código anterior. Por exemplo, o último elemento TextBlock tem o estilo inlineText, e o último elemento TextBox usa o estilo padrão.

<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>

Adicionando os Botões OK e Cancelar

Os últimos elementos na página são os elementos OK e Cancel Button, que ocupam as duas primeiras colunas da última linha do Grid. Esses elementos usam um manipulador de eventos comum, ButtonClicked, e o estilo Button padrão definidos no exemplo de código anterior. Adicione o seguinte código para Page1.XAML, logo abaixo do elemento TextBox final. A XAML parte da página foi 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>

Implementando o Arquivo Code-Behind da Página

O arquivo code-behind da página WPF , Page1.XAML.cs, implementa quatro tarefas essenciais:

  1. Registra o nome da DLL da página com o objeto Application, para que ele saiba de onde carregar a página.

  2. Manipula o evento que ocorre quando o usuário clica em um dos botões.

  3. Recupera os dados de elementos TextBox e o empacota em um objeto argumento de evento personalizado.

  4. Gera o evento OnButtonClick personalizado, que notifica o host que o usuário terminou e passa os dados de volta para o host.

A página também expõe várias cores e propriedades de fontes que permitem o controle da aparência da página. Ao contrário da classe WindowsFormsHost, que é usada para hospedar um controle Windows Forms, a classe ElementHost expõe a propriedade Background da página apenas. Para manter a semelhança entre este exemplo de código e o exemplo abordado na Demonstra Passo a passo: Hospedagem de um controle composto do Windows Forms no Windows Presentation Foundation, a página expõe as propriedades restantes diretamente.

A Estrutura Básica Arquivo Code-Behind

O arquivo code-behind é composto por um único namespace, MyControls,que contém duas classes, Page1 e MyControlEventArgs. Substitua o código em Page1.xaml.cs pelo seguinte.

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

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

A primeira classe, Page1, é uma classe parcial que contém o código que implementa a funcionalidade de UI definidos em Page1.xaml. Quando Page1.xaml é analisado, o XAML é convertido para a mesma classe parcial, e as duas classes parciais são mescladas para formar a página compilada. Por esse motivo, o nome da classe em um arquivo code-behind deve corresponder ao nome da classe atribuído a Page1.xaml, e ele deve herdá-lo do elemento raiz da página. A segunda classe, MyControlEventArgs, é uma classe argumentos de evento que é usada para enviar os dados de volta para o host.

Inicializando a classe Page1

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

  • Declara um evento particular, OnButtonClick, e seu representante associado, MyControlEventHandler.

  • Cria diversas variáveis globais particulares que armazenam os dados do usuário. Esses dados são expostos através de propriedades correspondentes.

  • Implementa um manipulador, Init, para o evento Loaded da página. Esse manipulador inicializa as variáveis globais atribuindo-lhes os valores definidos em Page1.xaml. Para fazer isso, ele usa o Name atribuído a um elemento TextBlock típico, nameLabel, para acessar configurações de propriedade desse elemento.

Adicione o seguinte código à sua classe Page1.

public partial class Page1 : 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;
    }

Manipulando os Eventos Click dos Botões

O usuário indica que a tarefa de entrada de dados foi concluída clicando no botão OK ou Cancel na parte inferior da página. Ambos os botões usam o mesmo manipulador de eventos Click , ButtonClicked. Ambos os botões têm um nome, btnOK ou btnFalse, que permite que o manipulador determine qual botão foi clicado examinando o valor do argumento sender. O manipulador faz o seguinte:

  • Cria um objeto MyControlEventArgs que contém os dados a partir dos elementos TextBox da página.

  • Se o usuário clicou no botão Cancel, define a propriedade MyControlEventArgs IsOK do objeto para false.

  • Gera o evento OnButtonClick para indicar ao host que o usuário concluiu e passa de volta os dados coletados.

Adicione o seguinte código à sua classe Page1, abaixo do método Init.

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);
}

Criando Propriedades

O restante da classe simplesmente expõe propriedades que correspondem às variáveis globais discutidas acima. Quando uma propriedade é alterada, o acessador definido modifica a aparência da página, alterando as propriedades de elemento correspondente e atualizando as variáveis globais subjacentes.

Adicione o código a seguir à sua classe Page1.

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;
    }
}

Enviando os Dados de volta ao Host

O componente final no arquivo é a classe MyControlEventArgs, que é usada para enviar os dados coletados de volta para o host. Adicione o código a seguir ao seu namespace MyControls. A implementação é simples e não será abordada posteriormente.

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; }
    }
}

Implementando o Aplicativo Host Windows Forms.

O aplicativo host Windows Forms usa um objeto ElementHost para hospedar a página WPF no formulário. O aplicativo trata do evento OnButtonClick da página para receber os dados do formulário. O aplicativo também tem um conjunto de botões de opção que podem ser usados para modificar a aparência da página. A tomada de tela a seguir mostra o formulário processado.

Página Windows Presentation Foundation hospedada em um Aplicativo Windows Forms

Controle Avalon de hospedagem do Window Forms

Criando o projeto

Para iniciar o projeto:

  1. Iniciar Visual Studio e abrir a caixa de diálogo Novo Projeto.

  2. Selecione Projetos C# com o modelo Aplicativo Windows Forms.

  3. Nomeie o novo projeto WFHost, e coloque-o na mesma pasta de nível superior que contém o projeto MyControls. Clique em OK para criar o projeto.

É necessário também adicionar uma referência para a DLL que contém a página WPF:

  1. Clique no nome do projeto em Gerenciador de Soluções e selecione Adicionar Referência.

  2. Clique na guia Procurar e navegue para a pasta que contém MyControls.dll.

  3. Selecione MyControls.dll e clique em OK para adicionar a DLL à lista de referências.

  4. No Solution Explorer, acrescente uma referência ao assembly WindowsFormsIntegration, que é chamado WindowsFormsIntegration.dll.

Implementando o Design de Interface de Usuário do Formulário

Abra o Windows Forms Designer e prepare o formulário como ele aparece na ilustração mostrada na Implementando o Aplicativo Host Windows Forms:

  1. Expanda o formulário padrão para acomodar os controles e a página WPF.

  2. Adicione um controle System.Windows.Forms.Panel ao canto superior direito do formulário para armazenar a página WPF.

  3. Adicione seis conjuntos de controles System.Windows.Forms.RadioButton, conforme mostrado na ilustração.

  4. Adicione cinco controles System.Windows.Forms.Label para o canto inferior direito do formulário, conforme mostrado na ilustração. Esses controles agem como rótulos para os dados retornados pelo controle de WPF.

  5. Adicione um controle Label à direita de cada controle Label adicionado na etapa anterior. Defina a propriedade Text de cada controle como "". Esses controles exibem os dados retornados pelo controle WPF.

  6. Adicione outro controle Label para servir como um título para o grupo de controles das duas últimas etapas. Como este Label se destina a servir como o título para o grupo, torne o tamanho da fonte dois pontos maiores do que os controles no grupo.

Inicializando o Formulário

Geralmente implementa-se o código de hospedagem no manipulador de eventos Load do formulário. No Windows Forms Designer, clique duas vezes no formulário para criar um método manipulador de eventos Load. O exemplo de código a seguir inclui o manipulador de eventos Load da amostra, um manipulador para o evento Loaded da página WPF, e declarações para diversas variáveis globais que são usadas mais tarde. Substitua o código em Form1.cs pelo seguinte:

partial class Form1 : Form
{
    private ElementHost ctrlHost;
    private MyControls.Page1 wpfAddressCtrl;
    System.Windows.FontWeight initFontWeight;
    double initFontSize;
    System.Windows.FontStyle initFontStyle;
    System.Windows.Media.SolidColorBrush initBackBrush;
    System.Windows.Media.SolidColorBrush initForeBrush;
    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.Page1();
        wpfAddressCtrl.InitializeComponent();
        ctrlHost.Child = wpfAddressCtrl;

        wpfAddressCtrl.OnButtonClick += 
            new MyControls.Page1.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 método Form1_Load no exemplo de código anterior mostra o procedimento geral para hospedar um controle WPF:

  1. Crie um novo objeto ElementHost.

  2. Defina a propriedade Dock do controle como DockStyle.Fill.

  3. Adicionar o controle ElementHost à coleção Controls do controle Panel.

  4. Crie um exemplo da página WPF.

  5. Hospede a página no formulário atribuindo a página à propriedade Child do controle ElementHost.

As duas linhas restantes no método Form1_Load anexam manipuladores para dois eventos da página:

  • OnButtonClick é um evento personalizado que é acionado pela página quando o usuário clica no botão OK ou Cancel. Manipule o evento para obter a resposta do usuário e para coletar quaisquer dados que o usuário preencheu.

  • Loaded é um evento padrão que é gerado por uma página WPF quando ela é totalmente carregada. O evento é usado aqui porque a amostra precisa inicializar diversas variáveis globais usando propriedades da página. No momento do evento Load do formulário, a página não está totalmente carregada e os valores ainda estão definidos como null. É necessário esperar até que o evento Loaded da página ocorra antes de poder acessar essas propriedades.

O manipulador de eventos Loaded é mostrado no exemplo de código anterior. O manipulador OnButtonClick é abordado na seção seguinte.

Manuseando OnButtonClick

O evento OnButtonClick ocorre quando o usuário clica no botão OK ou Cancel.

O manipulador de eventos verifica o campo IsOK do argumento do evento para determinar qual botão foi clicado. As variáveis lbldata correspondem aos controles Label invisíveis que foram abordados anteriormente. Se o usuário clicou no botão OK, os dados dos controles TextBox da página são atribuídos ao controle Label correspondente. Se o usuário clicou em Cancelar, os valores Text são definidos como null.

Adicione o seguinte código a Form1.cs. Agora já é possível compilar e executar o aplicativo.

void avAddressCtrl_OnButtonClick(
    object sender, 
    MyControls.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: ";
    }
}

Modificando Aparência da Página do Windows Presentation Foundation

Os controles RadioButton no lado esquerdo do formulário permitem que o usuário possa alterar cores de primeiro plano e plano de fundo da página WPF bem como várias propriedades de fonte. A cor do plano de fundo é exposta pelo objeto ElementHost. As propriedades restantes são expostas como propriedades personalizadas da página.

Clique duas vezes nos controles RadioButton no formulário para criar modelos para os manipuladores de eventos CheckedChanged correspondentes. Extraia o código dos manipuladores a seguir, e adicione-os aos manipuladores correspondentes em Form1.cs.

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 FontFamily("Times New Roman");
}

private void radioFamilyWingDings_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_FontFamily = new 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;
}

Consulte também

Tarefas

Demonstra Passo a passo: Hospedagem de um controle Windows Presentation Foundation composto do Windows Forms

Conceitos

Demonstra Passo a passo: Hospedagem de um controle composto do Windows Forms no Windows Presentation Foundation

Referência

ElementHost

WindowsFormsHost

Outros recursos

WPF Designer