Tutorial: Hospedar un control de Windows Presentation Foundation en formularios Windows Forms
Actualización: noviembre 2007
Windows Presentation Foundation (WPF) proporciona un entorno enriquecido para crear aplicaciones. Sin embargo, cuando se tiene una inversión sustancial en código formularios Windows Forms, puede ser más efectivo extender la aplicación formularios Windows Forms existente con WPF en lugar de rescribirla desde el principio. Un escenario común se da cuando se desea incrustar una o más páginas implementadas con WPF dentro de una aplicación formularios Windows Forms
Este tutorial describe una aplicación que hospeda una página WPF en una aplicación formularios Windows Forms. La página es una aplicación simple de entrada de datos que se empaqueta en una DLL. Este ejemplo se ha diseñado para ser casi idéntico en aspecto y funcionalidad a Ejemplo Hosting a Windows Forms Composite Control in Windows Presentation Foundation. La diferencia principal es que se invierte el escenario de hospedaje.
Nota
La página hospedada no es un control WPF en el sentido estricto del término. Más bien, es una página WPF ordinaria que se empaqueta en una DLL. Sin embargo, las técnicas para hospedar un control WPF en un formulario son idénticas a las utilizadas para hospedar una página ordinaria. Vea Personalización de controles para ver una explicación más extensa de los controles WPF.
El tutorial está dividido en dos secciones. La primera sección describe brevemente la implementación de la página WPF. La segunda sección explica en detalle cómo hospedar la página en una aplicación formularios Windows Forms, recibir eventos de la página y obtener acceso a algunas de las propiedades de la página.
Entre las tareas ilustradas en este tutorial se incluyen:
Implementar la página de Windows Presentation Foundation.
Implementar la aplicación host de formularios de Windows Forms.
Para ver una lista de código completa de las tareas ilustrada en este tutorial, vea Ejemplo Hosting a Simple Windows Presentation Foundation Control in Windows Forms.
Requisitos previos
Necesita los componentes siguientes para completar este tutorial:
- Visual Studio 2008.
Implementar la página de Windows Presentation Foundation
La página WPF utilizada en este ejemplo es un formulario de entrada de datos simple que toma el nombre y la dirección del usuario. Cuando el usuario hace clic en uno de dos botones para indicar que la tarea ha finalizado, la página provoca un evento personalizado para devolver esa información al host. Esta página es esencialmente idéntica en forma y función al control formularios Windows Forms utilizado en Tutorial: Hospedar un control compuesto de formularios Windows Forms en Windows Presentation Foundation. No hay nada especial que personalizar en la página para hospedarla en un formulario de formularios Windows Forms. También podría cargarla fácilmente en un control Frame o en una página WPF mayor. En la siguiente ilustración se muestra la página representada.
Página de Windows Presentation Foundation
.png)
Crear el proyecto
Para iniciar el proyecto:
Inicie Microsoft Visual Studio y abra el cuadro de diálogo Nuevo proyecto.
Seleccione la plantilla Aplicación de explorador WPF.
Llame al nuevo MyControls y colóquelo en una carpeta de nivel superior con el nombre adecuado, por ejemplo, WfHostingWpf. Más adelante, también colocará la aplicación host en esta carpeta. Haga clic en Aceptar para crear el proyecto. El proyecto predeterminado contiene una única página llamada Page1.
Haga clic con el botón secundario en el nombre del proyecto, en el Explorador de soluciones y seleccione Propiedades.
Establezca el Tipo de resultado en Biblioteca de clases para compilar la página como una DLL.
Elimine del proyecto los archivos de definición de aplicación, MyApp.xaml y MyApp.xaml.cs. Solamente necesitará esos archivos si está implementando la página como una aplicación.
Nota
Cuando compile una aplicación WPF como una biblioteca de clases, no podrá iniciarla para ver la página representada. Por esa razón, puede que encuentre más cómodo dejar el tipo de salida como "Aplicación para Windows" hasta que la aplicación esté completamente implementada. Eso le permitirá comprobar el aspecto de las páginas iniciando la aplicación. Cuando encuentre el resultado satisfactorio, elimine los archivos de definición de aplicación y cambie el tipo de salida a "Biblioteca de clases" para compilarlo como una DLL.
El proyecto debe tener referencias a las siguientes DLL del sistema. Si cualquiera de estas DLL no está incluida de forma predeterminada, agréguela al proyecto.
System
PresentationCore
PresentationFramework
WindowsBase
Implementar la interfaz de usuario de la página
La interfaz de usuario (UI) de la página de WPF se implementa con Lenguaje de marcado de aplicaciones extensible (XAML). Esta diseñada para ser similar en aspecto y funcionalidad al control formularios Windows Forms explicado en Tutorial: Hospedar un control compuesto de formularios Windows Forms en Windows Presentation Foundation. La interfaz de usuario de entrada de datos de la página se compone de cinco elementos TextBox. Cada elemento TextBox tiene un elemento TextBlock asociado que actúa como una etiqueta. Hay dos elementos Button en la parte inferior de la página, Aceptar y Cancelar. Cuando el usuario hace clic en cualquiera de los botones, la página provoca un evento personalizado para devolver la información al host.
Diseño básico
Los diversos elementos interfaz de usuario se contienen en un elemento Grid. Puede utilizar Grid para organizar el contenido de la página de manera muy similar a como utilizaría un elemento Table en HTML. WPF también tiene un elemento Table, pero Grid es más ligero y más adecuado para las tareas sencillas de diseño.
En el siguiente ejemplo se muestra el código subyacente básico. Este código define la estructura global de la página especificando el número de columnas y filas del elemento Grid. Utilícelo para reemplazar el código de 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>
Agregar elementos TextBlock y TextBox a la cuadrícula
Para colocar un elemento interfaz de usuario en la cuadrícula, establezca los atributos RowProperty y ColumnProperty en los números de fila y columna correspondientes. Recuerde que la numeración de filas y columnas está basada en cero. Puede hacer que un elemento abarque varias columnas estableciendo su atributo ColumnSpanProperty. Vea Cómo: Crear un elemento Grid para obtener más información sobre los elementos Grid.
En el ejemplo siguiente se muestran los elementos TextBox y TextBlock de la página con sus atributos RowProperty y ColumnProperty, que se establecen para colocar correctamente los elementos en la cuadrícula. Agregue este código a Page1.xaml, inmediatamente debajo del 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"/>
Aplicar estilos a los elementos de la interfaz de usuario
Muchos de los elementos del formulario de entrada de datos tienen un aspecto similar, lo que significa que tienen valores idénticos para varias de sus propiedades. En lugar de establecer los atributos de cada elemento de forma independiente, en el código del ejemplo se utilizan elementos Style para definir los valores estándar de las propiedades para clases de elementos. Este enfoque reduce la complejidad de la página y permite cambiar el aspecto de varios elementos a través de un atributo de estilo único.
Los elementos Style están contenidos en la propiedad Resources del elemento Grid, por lo que pueden ser utilizados por todos los elementos de la página. Si un estilo tiene nombre, puede aplicarlo a un elemento agregando un elemento Style establecido en el nombre del estilo. Los estilos que no tienen nombre se convierten en el estilo predeterminado para el elemento. Vea Aplicar estilos y plantillas para obtener información adicional sobre los estilos de WPF.
En el ejemplo siguiente se muestran los elementos Style para la página WPF. Agregue el código a Page1.xaml, inmediatamente debajo del elemento Grid. Para ver cómo se aplican los estilos a los elementos, vea el ejemplo de código anterior. Por ejemplo, el último elemento TextBlock tiene el estilo inlineText y el último elemento TextBox utiliza el estilo predeterminado.
<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>
Agregar los botones Aceptar y Cancelar
Los elementos finales de la página son los elementos Aceptar y CancelarButton, que ocupan las primeras dos columnas de la última fila del control Grid. Estos elementos utilizan un controlador de eventos común, ButtonClickedy el estilo Button predeterminado definido en el ejemplo de código anterior. Agregue el código siguiente a Page1.xaml, inmediatamente debajo del elemento TextBox final. La parte XAML de la página está ahora completa.
<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>
Implementar el archivo de código subyacente de la página
El archivo de código subyacente de la página WPF, Page1.xaml.cs, implementa cuatro tareas esenciales:
Registra el nombre de la DLL de la página con el objeto Application, para que sepa de dónde cargar la página.
Controla el evento que se produce cuando el usuario hace clic en uno de los botones.
Recupera los datos de los elementos TextBox y lo empaqueta en un objeto de argumento de evento personalizado.
Provoca el evento OnButtonClick personalizado, que notifica al host que el usuario ha finalizado y devuelve los datos al host.
La página también expone diversas propiedades de color y fuente que permiten controlar el aspecto de la página. A diferencia de la clase WindowsFormsHost, que se utiliza para hospedar un control formularios Windows Forms, la clase ElementHost solamente expone la propiedad Background de la página. Para mantener la similitud entre este ejemplo de código y el ejemplo explicado en Tutorial: Hospedar un control compuesto de formularios Windows Forms en Windows Presentation Foundation, la página expone directamente las propiedades restantes.
Estructura básica del archivo de código subyacente
El archivo de código subyacente consta de un único espacio de nombres, MyControls, que contiene dos clases, Page1 y MyControlEventArgs. Reemplace el código de Page1.xaml.cs por lo siguiente.
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
{
//...
}
}
La primera clase, Page1, es una clase parcial que contiene el código que implementa la funcionalidad de la interfaz de usuario definida en Page1.xaml. Cuando se analiza Page1.xaml, el XAML se convierte en la misma clase parcial y las dos clases parciales se combinan para formar la página compilada. Por esta razón, el nombre de clase del archivo de código subyacente debe coincidir con el nombre de clase asignado a Page1.xaml y debe heredar del elemento raíz de la página. La segunda clase, MyControlEventArgs, es una clase de argumentos de evento que se utiliza para devolver los datos al host.
Inicializar la clase Page1
En el siguiente código de ejemplo se implementan varias tareas básicas:
Declara un evento privado, OnButtonClick y su delegado asociado, MyControlEventHandler.
Crea varias variables globales privadas que almacenan los datos del usuario. Estos datos se exponen a través de las propiedades correspondientes.
Implementa un controlador, Init, para el evento Loaded de la página. Este controlador inicializa las variables globales asignándoles los valores definidos en Page1.xaml. Utiliza para ello la propiedad Name asignada a un elemento TextBlock típico, nameLabel, para tener acceso a los valores de las propiedades de ese elemento.
Agregue el código siguiente a la clase 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;
}
Administrar los eventos de clic de los botones
El usuario indica que la tarea de entrada de datos finalizado haciendo clic en el botón Aceptar o en el botón Cancelar en la parte inferior de la página. Ambos botones utilizan el mismo controlador de eventos Click, ButtonClicked. Ambos botones tienen un nombre, btnOK o btnFalse, que permite al controlador determinar en qué botón se hizo clic examinando el valor del argumento sender. El controlador hace lo siguiente:
Crea un objeto MyControlEventArgs que contiene los datos de los elementos TextBox de la página.
Si el usuario hizo clic en el botón Cancelar, establece la propiedad IsOK del objeto MyControlEventArgs en false.
Provoca el evento OnButtonClick para indicar al host que el usuario ha terminado y devuelve los datos recopilados.
Agregue el código siguiente a la clase Page1, debajo del 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);
}
Crear propiedades
El resto de la clase simplemente expone propiedades que corresponden a las variables globales explicadas anteriormente. Cuando una propiedad cambia, el descriptor de acceso set modifica el aspecto de la página cambiando las propiedades de elemento correspondientes y actualizando las variables globales subyacentes.
Agregue el código siguiente a la clase 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;
}
}
Devolver los datos al host
El último componente del archivo es la clase MyControlEventArgs, que se utiliza para devolver los datos recopilados al host. Agregue el código siguiente al espacio de nombres MyControls. La implementación es sencilla y no se ofrece ninguna otra explicación.
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; }
}
}
Implementar la aplicación host de formularios de Windows Forms.
La aplicación host formularios Windows Forms utiliza un objeto ElementHost para hospedar la página WPF en el formulario. La aplicación administra el evento OnButtonClick de la página para recibir los datos del formulario. La aplicación también tiene un conjunto de botones de opción que puede utilizar para modificar el aspecto de la página. La siguiente captura de pantalla muestra el formulario representado.
Página de Windows Presentation Foundation hospedada en una aplicación de formularios Windows Forms
.png)
Crear el proyecto
Para iniciar el proyecto:
Inicie Visual Studio y abra el cuadro de diálogo Nuevo proyecto.
Seleccione Proyectos de C# con la plantilla Aplicación de Windows Forms.
Nombre el nuevo proyecto WFHost y colóquelo en la misma carpeta de nivel superior que contiene el proyecto MyControls. Haga clic en Aceptar para crear el proyecto.
También necesita agregar una referencia a la DLL que contiene la página WPF:
Haga clic en el nombre del proyecto en el Explorador de soluciones y seleccione Agregar referencia.
Haga clic en la ficha Examinar y navegue a la carpeta que contiene MyControls.dll.
Seleccione MyControls.dll y haga clic en Aceptar para agregar la DLL a la lista de referencias.
En el Explorador de soluciones, agregue una referencia al ensamblado WindowsFormsIntegration, denominado WindowsFormsIntegration.dll.
Implementar el diseño de la interfaz de usuario del formulario
Abra el Diseñador de Windows Forms y disponga el formulario como aparece en la ilustración que se muestra en Implementar la aplicación host de formularios de Windows Forms:
Expanda el formulario predeterminado para acomodar los controles y la página de WPF.
Agregue un control System.Windows.Forms.Panel a la esquina superior derecha del formulario para retener la página WPF.
Agregue seis conjuntos de controles System.Windows.Forms.RadioButton, como se muestra en la ilustración.
Agregue cinco controles System.Windows.Forms.Label a la esquina inferior derecha del formulario, como se muestra en la ilustración. Estos controles actúan como etiquetas para los datos devueltos por el control WPF.
Agregue un control Label a la derecha de cada control Label agregado en el paso anterior. Establezca la propiedad Text de cada control en "". Estos controles muestran los datos devueltos por el control WPF.
Agregue otro control Label para que actúe como un título para el grupo de controles de los últimos dos pasos. Dado que este control Label debe actuar como título para el grupo, haga que el tamaño de fuente sea dos puntos mayor que los controles del grupo.
Inicializar el formulario
Generalmente, implementará el código host en el controlador de eventos Load del formulario. En el Diseñador de Windows Forms, haga doble clic en el formulario para crear un método controlador del eventoLoad. En el siguiente ejemplo de código se incluye el controlador de eventos de Load, un controlador para el evento Loaded de la página WPF, y declaraciones para varias variables globales que se utilizan más adelante. Reemplace el código de Form1.cs por lo siguiente.
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;
}
El método Form1_Load del ejemplo de código anterior muestra el procedimiento general para hospedar un control WPF:
Crear un nuevo objeto ElementHost.
Establezca la propiedad Dock del control en DockStyle.Fill.
Agregue el control ElementHost a la colección Controls del control Panel.
Cree una instancia de la página WPF.
Hospede la página en el formulario asignando la página a la propiedad Child del control ElementHost.
Las restantes dos líneas del método Form1_Load asocian controladores a dos eventos de página:
OnButtonClick es un evento personalizado que inicia la página cuando el usuario hace clic en el botón Aceptar o Cancelar. Administre el evento para obtener la respuesta del usuario y recopilar los datos que introduzca.
Loaded es un evento estándar provocado por una página WPF al cargarse totalmente. El evento se utiliza aquí porque el ejemplo necesita inicializar varias variables globales utilizando propiedades de la página. En el momento del evento Load del formulario, la página no se carga totalmente y esos valores todavía están establecidos en null. Debe esperar hasta que se produzca el evento Loaded de la página para poder tener acceso a esas propiedades.
El controlador de eventos Loaded se muestra en el ejemplo de código anterior. El controlador OnButtonClick se explica en la sección siguiente.
Administrar OnButtonClick
El evento OnButtonClick se produce cuando el usuario hace clic en el botón Aceptar o Cancelar.
El controlador de eventos consulte el campo IsOK del argumento de evento para determinar en qué botón se hizo clic. Las variables lbldatos corresponden a los controles Label invisibles antes explicados. Si el usuario hizo clic en el botón Aceptar, los datos de los controles TextBox de la página se asignan al control Label correspondiente. Si el usuario hizo clic en Cancelar, los valores Text se establecen en null.
Agregue el código siguiente a Form1.cs. Ahora puede compilar y ejecutar la aplicación.
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: ";
}
}
Modificar el aspecto de la página de Windows Presentation Foundation
Los controles RadioButton de la izquierda del formulario permiten al usuario cambiar los colores de fondo y primero plano de la página WPF así como diversas propiedades de la fuente. El objeto ElementHost expone el color de fondo. Las propiedades restantes se exponen como propiedades personalizadas de la página.
Haga doble clic en los controles RadioButton del formulario para crear plantillas para los controladores de eventos CheckedChanged correspondientes. Extraiga el código de los siguientes controladores y agréguelo a los controladores correspondientes de 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;
}