Partilhar via

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

Windows Presentation Foundation (WPF) fornece um ambiente avançado para a criação de aplicativos. No entanto, quando você tem um investimento substancial no código do Windows Forms, pode ser mais eficaz estender seu aplicativo Windows Forms existente com WPF em vez de reescrevê-lo do zero. Um cenário comum é quando você deseja incorporar um ou mais controles implementados com WPF em seu aplicativo Windows Forms. Para obter mais informações sobre como personalizar controles WPF, consulte Personalização de controle.

Este passo a passo orienta você por um aplicativo que hospeda um controle composto WPF para executar a entrada de dados em um aplicativo Windows Forms. O controle composto é empacotado em uma DLL. Este procedimento geral pode ser alargado a aplicações e controlos mais complexos. Este passo a passo foi projetado para ser quase idêntico em aparência e funcionalidade ao Passo a passo: Hospedando um controle composto do Windows Forms no WPF. A principal diferença é que o cenário de hospedagem é invertido.

O passo a passo está dividido em duas seções. A primeira seção descreve brevemente a implementação do controle composto WPF. A segunda seção discute em detalhes como hospedar o controle composto em um aplicativo Windows Forms, receber eventos do controle e acessar algumas das propriedades do controle.

As tarefas ilustradas neste passo a passo incluem:

  • Implementando o controle composto WPF.

  • Implementando o aplicativo host do Windows Forms.

Para obter uma lista de código completa das tarefas ilustradas neste passo a passo, consulte Hospedando um controle composto WPF no exemplo de Windows Forms.

Pré-requisitos

Você precisa do Visual Studio para concluir este passo a passo.

Implementando o controle composto do WPF

O controle composto WPF usado neste exemplo é um formulário de entrada de dados simples que leva o nome e o endereço do usuário. Quando o usuário clica em um dos dois botões para indicar que a tarefa foi concluída, o controle gera um evento personalizado para retornar essas informações ao host. A ilustração a seguir mostra o controle renderizado.

A imagem a seguir mostra um controle composto WPF:

Captura de tela que mostra um controle WPF simples.

Criando o projeto

Para iniciar o projeto:

  1. Inicie o Visual Studio e abra a caixa de diálogo Novo Projeto .

  2. No Visual C# e na categoria Windows, selecione o modelo WPF User Control Library .

  3. Nomeie o novo projeto MyControls.

  4. Para o local, especifique uma pasta de nível superior com nome conveniente, como WindowsFormsHostingWpfControl. Mais tarde, você colocará o aplicativo host nesta pasta.

  5. Clique OK para criar o projeto. O projeto padrão contém um único controle chamado UserControl1.

  6. No Gerenciador de Soluções, renomeie UserControl1 para MyControl1.

Seu projeto deve ter referências às seguintes DLLs do sistema. Se alguma dessas DLLs não estiver incluída por padrão, adicione-as ao seu projeto.

  • PresentationCore

  • PresentationFramework

  • Sistema

  • WindowsBase

Criando a interface do usuário

A interface do usuário (UI) para o controle composto é implementada com Extensible Application Markup Language (XAML). A interface do usuário de controle composta consiste em cinco TextBox elementos. Cada TextBox elemento tem um elemento associado TextBlock que serve como um rótulo. Há dois Button elementos na parte inferior, OK e Cancelar. Quando o usuário clica em qualquer um dos botões, o controle gera um evento personalizado para retornar as informações ao host.

Layout básico

Os vários elementos da interface do usuário estão contidos em um Grid elemento . Você pode usar Grid para organizar o conteúdo do controle composto da mesma forma que usaria um Table elemento em HTML. WPF também tem um Table elemento, mas Grid é mais leve e mais adequado para tarefas de layout simples.

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

Em MyControl1.xaml, substitua o XAML existente pelo seguinte XAML.

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

Adicionando elementos TextBlock e TextBox à grelha

Você coloca um elemento da interface do utilizador na grelha, definindo os atributos RowProperty e ColumnProperty do elemento para o número de linha e coluna apropriado. Lembre-se de que a numeração de linhas e colunas é baseada em zero. Você pode fazer com que um elemento abranja várias colunas definindo seu ColumnSpanProperty atributo. Para obter mais informações sobre Grid elementos, consulte Criar um elemento de grade.

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

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

Estilizando os elementos da 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 têm configurações idênticas para várias de suas propriedades. Em vez de definir os atributos de cada 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 único atributo de estilo.

Os elementos Style estão contidos na propriedade Grid do elemento Resources, de modo que possam ser utilizados por todos os elementos no controle. Se um estilo tiver um nome, você aplicará esse estilo a um elemento, adicionando um elemento Style definido para o nome do estilo. Os estilos que não são nomeados tornam-se o estilo padrão para o elemento. Para obter mais informações sobre estilos WPF, consulte Estilo e modelos.

O XAML a seguir mostra os Style elementos para o controle composto. Para ver como os estilos são aplicados aos elementos, consulte o XAML anterior. Por exemplo, o último TextBlock elemento tem o inlineText estilo e o último TextBox elemento usa o estilo padrão.

Em MyControl1.xaml, adicione o seguinte XAML logo após o Grid elemento start.

<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 elementos finais no controle composto são os elementos OK e CancelarButton , que ocupam as duas primeiras colunas da última linha do Grid. Esses elementos usam um manipulador de ButtonClickedeventos comum e o estilo padrão Button definido no XAML anterior.

Em MyControl1.xaml, adicione o seguinte XAML após o último TextBox elemento. A parte XAML do controle composto agora está 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

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

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

  2. Recupera os dados dos elementos TextBox e os embala em um objeto de argumento de evento personalizado.

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

O controle também expõe uma série de propriedades de cor e fonte que permitem alterar a aparência. Ao contrário da WindowsFormsHost classe, que é usada para hospedar um controle Windows Forms, a ElementHost classe expõe somente a propriedade do Background controle. Para manter a semelhança entre este exemplo de código e o exemplo discutido em Passo a passo: Hospedando um controle composto do Windows Forms no WPF, o controle expõe as propriedades restantes diretamente.

A estrutura básica do arquivo Code-Behind

O arquivo code-behind consiste em um único namespace, MyControls, que 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 interface do usuário definida em MyControl1.xaml. Quando MyControl1.xaml é analisado, o XAML é convertido na 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 deve herdar do elemento raiz do controle. A segunda classe, MyControlEventArgs, é uma classe de argumentos de evento que é usada para enviar os dados de volta para o host.

Abra MyControl1.xaml.cs. Altere a declaração de classe existente para que ela tenha o seguinte nome e herde de Grid.

public partial class MyControl1 : Grid

Inicializando o controle

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

  • Declara um evento privado, OnButtonClicke seu representante associado, MyControlEventHandler.

  • Cria várias variáveis globais privadas que armazenam os dados do usuário. Estes dados são expostos através das propriedades correspondentes.

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

Exclua o construtor existente e adicione o seguinte código à sua 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;
}

Manipulando os eventos de clique dos botões

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

  • Cria um MyControlEventArgs objeto que contém os dados dos TextBox elementos.

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

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

Adicione o seguinte código à sua MyControl1 classe, após o 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);
}

Criando propriedades

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

Adicione o seguinte código à sua MyControl1 classe.

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 para o host

O componente final no arquivo é a MyControlEventArgs classe, que é usada para enviar os dados coletados de volta para o host.

Adicione o seguinte código ao seu MyControls namespace. A implementação é simples e não é discutida mais aprofundadamente.

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

Crie a solução. A compilação produzirá uma DLL chamada MyControls.dll.

Implementando o aplicativo host do Windows Forms

O aplicativo host do Windows Forms usa um ElementHost objeto para hospedar o controle composto WPF. O aplicativo manipula o 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.

A imagem a seguir mostra um controle composto WPF hospedado em um aplicativo Windows Forms

Captura de ecrã que mostra um controlo Avalon hospedado num Windows Form.

Criando o projeto

Para iniciar o projeto:

  1. Inicie o Visual Studio e abra a caixa de diálogo Novo Projeto .

  2. No Visual C# e na categoria Windows, selecione o modelo Aplicativo Windows Forms .

  3. Nomeie o novo projeto WFHost.

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

  5. Clique OK para criar o projeto.

Você também precisa adicionar referências à DLL que inclui MyControl1 e outros conjuntos.

  1. Clique com o botão direito do mouse no nome do projeto no Gerenciador de Soluções e selecione Adicionar Referência.

  2. Clique na guia Procurar e navegue até a pasta que contém MyControls.dll. Para este passo a passo, esta pasta é MyControls\bin\Debug.

  3. Selecione MyControls.dlle, em seguida, clique em OK.

  4. Adicione referências às assemblagens a seguir.

    • PresentationCore

    • PresentationFramework

    • System.Xaml

    • WindowsBase

    • Integração do WindowsForms

Implementando a interface do usuário para o aplicativo

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

  1. Abra o Form1 no Windows Form Designer.

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

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

  4. Adicione os seguintes System.Windows.Forms.GroupBox controles ao formulário.

    Nome Texto
    groupBox1 Cor de Fundo
    groupBox2 Cor de primeiro plano
    groupBox3 Tamanho da fonte
    groupBox4 Família de fontes
    groupBox5 Estilo da fonte
    groupBox6 Peso da fonte
    groupBox7 Dados do controlo

  5. Adicione os seguintes System.Windows.Forms.RadioButton controles aos System.Windows.Forms.GroupBox controles.

    Caixa de Grupo Nome Texto
    groupBox1 fundoOriginalDoRádio Original
    groupBox1 fundoRadioVerdeClaro Verde-claro
    groupBox1 radioBackgroundLightSalmão Salmão Leve
    groupBox2 radioPrimeiro planoOriginal Original
    groupBox2 radioForegroundRed Vermelho
    groupBox2 radioPrimeiro planoAmarelo Amarelo
    groupBox3 rádioTamanhoOriginal Original
    groupBox3 radioSizeTen 10
    groupBox3 radioSizeTwelve 12
    groupBox4 radioFamilyOriginal Original
    groupBox4 Rádio Tempos de Família Tempos Novos Romanos
    groupBox4 rádio Família WingDings WingDings
    groupBox5 radioStyleOriginal Normal
    groupBox5 radioStyleItalic Itálico
    groupBox6 radioPesoOriginal Original
    groupBox6 radioWeightBold Negrito

  6. Adicione os seguintes System.Windows.Forms.Label controles ao último System.Windows.Forms.GroupBox. Esses controles exibem os dados retornados pelo controle composto WPF.

    Caixa de Grupo Nome Texto
    groupBox7 lblNome Designação:
    groupBox7 lblEndereço Endereço:
    groupBox7 lblCidade Cidade:
    groupBox7 lblState Estado:
    groupBox7 lblZip CEP:

Inicializando o formulário

Você geralmente implementa o código de hospedagem no manipulador de Load eventos do formulário. O código a seguir mostra o manipulador de Load eventos, um manipulador para o evento do Loaded controle composto WPF e declarações para várias variáveis globais que são usadas posteriormente.

No Windows Forms Designer, clique duas vezes no formulário para criar um manipulador de Load eventos. No topo do Form1.cs, adicione as seguintes using instruções.

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

Substitua o conteúdo da classe existente Form1 pelo seguinte código.

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 um controle WPF:

  1. Crie um novo ElementHost objeto.

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

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

  4. Crie uma instância do controle WPF.

  5. Hospede o controlo composto no formulário, atribuindo-o à propriedade do controlo ElementHostChild.

As duas linhas restantes no método Form1_Load anexam manipuladores para dois eventos de controlo.

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

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

O Loaded manipulador de eventos é mostrado no código anterior. O OnButtonClick manipulador é discutido na próxima seção.

Gestão do OnButtonClick

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

O manipulador de eventos verifica o campo do IsOK argumento de evento para determinar qual botão foi clicado. As lbl variáveis de dados correspondem aos controles discutidos Label anteriormente. Se o usuário clicar no botão OK , os dados dos controles do TextBox controle serão atribuídos ao controle correspondente Label . Se o usuário clicar em Cancelar, os Text valores serão definidos como as cadeias de caracteres padrão.

Adicione o seguinte código do manipulador de eventos de clique de botão à classe Form1.

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

Compile e execute o aplicativo. Adicione algum texto no controle composto WPF e clique em OK. O texto aparece nos rótulos. Neste ponto, o código ainda não foi adicionado para manipular os botões de opção.

Modificando a aparência do controle

Os RadioButton controles no formulário permitirão que o usuário altere as cores de primeiro plano e plano de fundo do controle composto WPF, bem como várias propriedades de fonte. A cor de fundo é exposta pelo objeto ElementHost. 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 eventos. Substitua os CheckedChanged manipuladores de eventos pelo 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;
}

Compile e execute o aplicativo. Clique nos diferentes botões de rádio para ver o efeito no controlo composto WPF.

Ver também

  • Last updated on