Procedura dettagliata: hosting di controlli Windows Form compositi in WPF
Windows Presentation Foundation (WPF) fornisce un ambiente funzionale per la creazione di applicazioni. Tuttavia, quando si dispone di una grande quantità di codice Windows Forms, può essere opportuno riutilizzare almeno parte di tale codice nell'applicazione WPF anziché riscriverlo dall'inizio. Lo scenario più comune prevede l'esistenza di controlli Windows Forms. In alcuni casi potrebbe non disporsi nemmeno dell'accesso al codice sorgente per questi controlli. WPF fornisce una procedura molto semplice per l'hosting di tali controlli in un'applicazione WPF. È ad esempio possibile utilizzare WPF per la maggior parte della programmazione pur ospitando i controlli DataGridView specializzati.
In questa procedura dettagliata viene descritta un'applicazione che ospita un controllo composito Windows Forms per eseguire l'immissione di dati in un'applicazione WPF. Il controllo composito è compresso in una DLL. Questa procedura generale può essere estesa ad applicazioni e controlli più complessi. Questa procedura dettagliata è stata progettata in modo che risulti quasi identica per aspetto e funzionalità a Procedura dettagliata: hosting di controlli compositi di WPF in Windows Form. La differenza primaria risiede nel fatto che lo scenario di hosting risulta invertito.
La procedura dettagliata è divisa in due sezioni. Nella prima sezione viene brevemente descritta l'implementazione del controllo composito Windows Forms. Nella seconda sezione viene illustrato in dettaglio come ospitare il controllo composito in un'applicazione WPF, come ricevere eventi dal controllo e come accedere ad alcune delle proprietà del controllo.
Di seguito vengono elencate le attività illustrate nella procedura dettagliata:
Implementazione del controllo composito Windows Form.
Implementazione dell'applicazione host WPF.
Per un elenco di codice completo delle attività illustrate in questa procedura dettagliata, vedere Esempio di hosting di controlli Windows Form compositi in WPF (la pagina potrebbe essere in inglese).
Prerequisiti
Per completare la procedura dettagliata, è necessario disporre dei componenti seguenti:
- Visual Studio 2010.
Implementazione del controllo composito Windows Form
Il controllo composito Windows Forms utilizzato in questo esempio è un semplice form di immissione dati. Questo form accetta il nome e l'indirizzo dell'utente e utilizza un evento personalizzato per restituire tali informazioni all'host. Nell’immagine riportata di seguito viene illustrato il controllo sottoposto a rendering.
Distribuire un controllo composito Windows Form
.gif "Controllo Windows Form semplice")
Creazione del progetto
Per avviare il progetto:
Avviare Microsoft Visual Studio e aprire la finestra di dialogo Nuovo progetto.
Nella categoria Finestra, selezionare il modello Libreria di controllo Windows Form.
Denominare il nuovo progetto MyControls.
Come posizione, specificare una cartella di livello principale denominata in modo appropriato, ad esempio WpfHostingWindowsFormsControl. Successivamente, l'applicazione host verrà posizionata in questa cartella.
Scegliere OK per creare il progetto. Il progetto predefinito contiene un singolo controllo denominato UserControl1.
In Esplora soluzioni rinominare UserControl1 in MyControl1.
Il progetto dovrebbe presentare riferimenti alle DLL di sistema riportate di seguito. Se alcune di queste DLL non sono incluse per impostazione predefinita, aggiungerle al progetto.
Sistema
System.Data
System.Drawing
System.Windows.Forms
System.Xml
Aggiunta di controlli al form
Per aggiungere controlli al form:
- Aprire MyControl1 nella finestra di progettazione.
Aggiungere cinque controlli Label e i controlli TextBox corrispondenti, ridimensionati e disposti come nell'illustrazione precedente. Nell'esempio i controlli TextBox sono denominati:
txtName
txtAddress
txtCity
txtState
txtZip
Aggiungere due controlli Button con etichetta OK e Annulla. Nell'esempio i nomi dei pulsanti sono rispettivamente btnOK e btnCancel.
Implementazione del codice di supporto
Aprire il form in visualizzazione codice. Il controllo restituisce i dati raccolti all'host corrispondente generando l'evento personalizzato OnButtonClick. I dati sono contenuti nell'oggetto dell'argomento dell'evento. Nel codice riportato di seguito viene illustrato l'evento e la dichiarazione delegate.
Aggiungere il codice seguente alla classe MyControl1.
Public Delegate Sub MyControlEventHandler(ByVal sender As Object, ByVal args As MyControlEventArgs)
Public Event OnButtonClick As MyControlEventHandler
public delegate void MyControlEventHandler(object sender, MyControlEventArgs args);
public event MyControlEventHandler OnButtonClick;
La classe MyControlEventArgs contiene le informazioni da restituire all'host.
Aggiungere la classe seguente al form.
Public Class MyControlEventArgs
Inherits EventArgs
Private _Name As String
Private _StreetAddress As String
Private _City As String
Private _State As String
Private _Zip As String
Private _IsOK As Boolean
Public Sub New(ByVal result As Boolean, ByVal name As String, ByVal address As String, ByVal city As String, ByVal state As String, ByVal zip As String)
_IsOK = result
_Name = name
_StreetAddress = address
_City = city
_State = state
_Zip = zip
End Sub
Public Property MyName() As String
Get
Return _Name
End Get
Set
_Name = value
End Set
End Property
Public Property MyStreetAddress() As String
Get
Return _StreetAddress
End Get
Set
_StreetAddress = value
End Set
End Property
Public Property MyCity() As String
Get
Return _City
End Get
Set
_City = value
End Set
End Property
Public Property MyState() As String
Get
Return _State
End Get
Set
_State = value
End Set
End Property
Public Property MyZip() As String
Get
Return _Zip
End Get
Set
_Zip = value
End Set
End Property
Public Property IsOK() As Boolean
Get
Return _IsOK
End Get
Set
_IsOK = value
End Set
End Property
End Class
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; }
}
}
Quando l'utente fa clic su OK o su Annulla, il gestore eventi Click crea un oggetto MyControlEventArgs che contiene i dati e genera l'evento OnButtonClick. L'unica differenza tra i due gestori è la proprietà IsOK dell'argomento dell'evento. Questa proprietà consente all'host di determinare su quale pulsante è stato fatto clic. La proprietà è impostata su true per il pulsante OK e su false per il pulsante Annulla. Nel codice riportato di seguito vengono illustrati i gestori dei due pulsanti.
Aggiungere il codice seguente alla classe MyControl1.
Private Sub btnOK_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles btnOK.Click
Dim retvals As New MyControlEventArgs(True, txtName.Text, txtAddress.Text, txtCity.Text, txtState.Text, txtZip.Text)
RaiseEvent OnButtonClick(Me, retvals)
End Sub
Private Sub btnCancel_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles btnCancel.Click
Dim retvals As New MyControlEventArgs(False, txtName.Text, txtAddress.Text, txtCity.Text, txtState.Text, txtZip.Text)
RaiseEvent OnButtonClick(Me, retvals)
End Sub
private void btnOK_Click(object sender, System.EventArgs e)
{
MyControlEventArgs retvals = new MyControlEventArgs(true,
txtName.Text,
txtAddress.Text,
txtCity.Text,
txtState.Text,
txtZip.Text);
OnButtonClick(this, retvals);
}
private void btnCancel_Click(object sender, System.EventArgs e)
{
MyControlEventArgs retvals = new MyControlEventArgs(false,
txtName.Text,
txtAddress.Text,
txtCity.Text,
txtState.Text,
txtZip.Text);
OnButtonClick(this, retvals);
}
Assegnazione di un nome sicuro all'assembly e compilazione dell'assembly
Perché a questo assembly venga fatto riferimento in un'applicazione WPF, è necessario che abbia un nome sicuro. Per creare un nome sicuro, creare un file di chiave Sn.exe e aggiungerlo al progetto.
Aprire il prompt dei comandi di Visual Studio. Per effettuare tale operazione, fare clic sul pulsante Start e scegliere Programmi/Microsoft Visual Studio 2010/Visual Studio Tools/Prompt dei comandi di Visual Studio. Viene avviata una finestra della console con le variabili di ambiente personalizzate.
Al prompt dei comandi utilizzare il comando cd per passare alla cartella del progetto.
Generare un file di chiave denominato MyControls.snk eseguendo il comando indicato.
Sn.exe -k MyControls.snkPer includere il file di chiave nel progetto, fare clic con il pulsante destro del mouse sul nome del progetto in Esplora soluzioni e scegliere Proprietà. In Progettazione progetti fare clic sulla scheda Firma, selezionare la casella di controllo Firma assembly e passare al file di chiave.
Compilare la soluzione. La compilazione creerà una DLL denominata MyControls.dll.
Implementazione dell'applicazione host WPF.
L'applicazione host WPF utilizza il controllo WindowsFormsHost per ospitare MyControl1. L'applicazione gestisce l'evento OnButtonClick per ricevere i dati dal controllo. Dispone inoltre di un insieme di pulsanti di opzione che consente di modificare alcune delle proprietà del controllo dall'applicazione WPF. Nell'immagine riportata di seguito viene illustrata l'applicazione finita.
Applicazione completa che mostra il controllo incorporato nell'applicazione WPF
.gif "Controllo incorporato in una pagina WPF")
Creazione del progetto
Per avviare il progetto:
Aprire Visual Studio e selezionare Nuovo progetto.
Nella categoria Finestra selezionare il modello Applicazione WPF.
Denominare il nuovo progetto WpfHost.
Come posizione, specificare la stessa cartella di livello principale che contiene il progetto MyControls.
Scegliere OK per creare il progetto.
È inoltre necessario aggiungere riferimenti alla DLL che contiene MyControl1 e altri assembly.
Fare clic con il pulsante destro del mouse in Esplora soluzioni e selezionare Aggiungi riferimento.
Fare clic sulla scheda Sfoglia e passare alla cartella che contiene MyControls.dll. In questa procedura dettagliata, questa cartella è MyControls\bin\Debug.
Selezionare MyControls.dll, quindi scegliere OK.
Aggiungere un riferimento all'assembly WindowsFormsIntegration, denominato WindowsFormsIntegration.dll.
Implementazione del layout di base
L'user interface (UI) dell'applicazione host viene implementata in MainWindow.xaml. Questo file contiene il markup Extensible Application Markup Language (XAML) che definisce il layout e ospita il controllo Windows Forms. L'applicazione è suddivisa in tre aree:
Il pannello Proprietà del controllo che contiene un insieme di pulsanti di opzione che si possono utilizzare per modificare diverse proprietà del controllo ospitato.
Il pannello Dati dal controllo che contiene numerosi elementi TextBlock che consentono di visualizzare i dati restituiti dal controllo ospitato.
Il controllo ospitato stesso.
Nel codice XAML seguente viene mostrato il layout di base. Il markup necessario per ospitare MyControl1 viene omesso da questo esempio, ma verrà esaminato più avanti.
Sostituire il codice XAML in MainWindow.xaml con quanto segue. Se si utilizza Visual Basic, modificare la classe in x:Class="MainWindow".
<Window xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
x:Class="WpfHost.MainWindow"
xmlns:mcl="clr-namespace:MyControls;assembly=MyControls"
Loaded="Init">
<DockPanel>
<DockPanel.Resources>
<Style x:Key="inlineText" TargetType="{x:Type Inline}">
<Setter Property="FontWeight" Value="Normal"/>
</Style>
<Style x:Key="titleText" TargetType="{x:Type TextBlock}">
<Setter Property="DockPanel.Dock" Value="Top"/>
<Setter Property="FontWeight" Value="Bold"/>
<Setter Property="Margin" Value="10,5,10,0"/>
</Style>
</DockPanel.Resources>
<StackPanel Orientation="Vertical"
DockPanel.Dock="Left"
Background="Bisque"
Width="250">
<TextBlock Margin="10,10,10,10"
FontWeight="Bold"
FontSize="12">Control Properties</TextBlock>
<TextBlock Style="{StaticResource titleText}">Background Color</TextBlock>
<StackPanel Margin="10,10,10,10">
<RadioButton Name="rdbtnOriginalBackColor"
IsChecked="True"
Click="BackColorChanged">Original</RadioButton>
<RadioButton Name="rdbtnBackGreen"
Click="BackColorChanged">LightGreen</RadioButton>
<RadioButton Name="rdbtnBackSalmon"
Click="BackColorChanged">LightSalmon</RadioButton>
</StackPanel>
<TextBlock Style="{StaticResource titleText}">Foreground Color</TextBlock>
<StackPanel Margin="10,10,10,10">
<RadioButton Name="rdbtnOriginalForeColor"
IsChecked="True"
Click="ForeColorChanged">Original</RadioButton>
<RadioButton Name="rdbtnForeRed"
Click="ForeColorChanged">Red</RadioButton>
<RadioButton Name="rdbtnForeYellow"
Click="ForeColorChanged">Yellow</RadioButton>
</StackPanel>
<TextBlock Style="{StaticResource titleText}">Font Family</TextBlock>
<StackPanel Margin="10,10,10,10">
<RadioButton Name="rdbtnOriginalFamily"
IsChecked="True"
Click="FontChanged">Original</RadioButton>
<RadioButton Name="rdbtnTimes"
Click="FontChanged">Times New Roman</RadioButton>
<RadioButton Name="rdbtnWingdings"
Click="FontChanged">Wingdings</RadioButton>
</StackPanel>
<TextBlock Style="{StaticResource titleText}">Font Size</TextBlock>
<StackPanel Margin="10,10,10,10">
<RadioButton Name="rdbtnOriginalSize"
IsChecked="True"
Click="FontSizeChanged">Original</RadioButton>
<RadioButton Name="rdbtnTen"
Click="FontSizeChanged">10</RadioButton>
<RadioButton Name="rdbtnTwelve"
Click="FontSizeChanged">12</RadioButton>
</StackPanel>
<TextBlock Style="{StaticResource titleText}">Font Style</TextBlock>
<StackPanel Margin="10,10,10,10">
<RadioButton Name="rdbtnNormalStyle"
IsChecked="True"
Click="StyleChanged">Original</RadioButton>
<RadioButton Name="rdbtnItalic"
Click="StyleChanged">Italic</RadioButton>
</StackPanel>
<TextBlock Style="{StaticResource titleText}">Font Weight</TextBlock>
<StackPanel Margin="10,10,10,10">
<RadioButton Name="rdbtnOriginalWeight"
IsChecked="True"
Click="WeightChanged">
Original
</RadioButton>
<RadioButton Name="rdbtnBold"
Click="WeightChanged">Bold</RadioButton>
</StackPanel>
</StackPanel>
<WindowsFormsHost Name="wfh"
DockPanel.Dock="Top"
Height="300">
<mcl:MyControl1 Name="mc"/>
</WindowsFormsHost>
<StackPanel Orientation="Vertical"
Height="Auto"
Background="LightBlue">
<TextBlock Margin="10,10,10,10"
FontWeight="Bold"
FontSize="12">Data From Control</TextBlock>
<TextBlock Style="{StaticResource titleText}">
Name: <Span Name="txtName" Style="{StaticResource inlineText}"/>
</TextBlock>
<TextBlock Style="{StaticResource titleText}">
Street Address: <Span Name="txtAddress" Style="{StaticResource inlineText}"/>
</TextBlock>
<TextBlock Style="{StaticResource titleText}">
City: <Span Name="txtCity" Style="{StaticResource inlineText}"/>
</TextBlock>
<TextBlock Style="{StaticResource titleText}">
State: <Span Name="txtState" Style="{StaticResource inlineText}"/>
</TextBlock>
<TextBlock Style="{StaticResource titleText}">
Zip: <Span Name="txtZip" Style="{StaticResource inlineText}"/>
</TextBlock>
</StackPanel>
</DockPanel>
</Window>
Il primo elemento StackPanel contiene numerose serie di controlli RadioButton che consentono di modificare diverse proprietà predefinite del controllo ospitato. Tale elemento è seguito da un elemento WindowsFormsHost, che ospita MyControl1. L'elemento finale StackPanel contiene numerosi elementi TextBlock che consentono di visualizzare i dati restituiti dal controllo ospitato. L'ordine degli elementi e le impostazioni degli attributi Dock e Height consentono di incorporare il controllo ospitato nella finestra senza spazi o distorsioni.
Hosting del controllo
La versione modificata riportata di seguito del codice XAML precedente punta l'attenzione sugli elementi necessari per ospitare MyControl1.
<Window xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
x:Class="WpfHost.MainWindow"
xmlns:mcl="clr-namespace:MyControls;assembly=MyControls"
Loaded="Init">
...
<WindowsFormsHost Name="wfh"
DockPanel.Dock="Top"
Height="300">
<mcl:MyControl1 Name="mc"/>
</WindowsFormsHost>
L'attributo del mapping dello spazio dei nomi xmlns crea un riferimento allo spazio dei nomi MyControls che contiene il controllo ospitato. Questo mapping consente di rappresentare MyControl1 in XAML come <mcl:MyControl1>.
Due elementi dell'handle XAML gestiscono l'hosting:
WindowsFormsHost rappresenta l'elemento WindowsFormsHost che consente di ospitare un controllo Windows Forms in un'applicazione WPF.
mcl:MyControl1, che rappresenta MyControl1, viene aggiunto all'insieme figlio dell'elemento WindowsFormsHost. Di conseguenza, viene eseguito il rendering di questo controllo Windows Forms come parte della finestra WPF ed è possibile comunicare con il controllo dall'applicazione.
Implementazione del file code-behind
Il file code-behind, MainWindow.xaml.vb o MainWindow, contiene il codice procedurale che implementa la funzionalità dell'UI esaminata nella sezione precedente. Le attività principali sono:
Associare un gestore eventi all'evento OnButtonClick di MyControl1.
Modificare diverse proprietà di MyControl1, in base al modo in cui viene impostato l'insieme di pulsanti di opzione.
Visualizzare i dati raccolti dal controllo.
Inizializzazione dell'applicazione
Il codice di inizializzazione è contenuto in un gestore eventi per l'evento Loaded della finestra e associa un gestore eventi all'evento OnButtonClick del controllo.
In MainWindow.xaml.vb o MainWindow.xaml.cs aggiungere il codice seguente alla classe MainWindow.
Private app As Application
Private myWindow As Window
Private initFontWeight As FontWeight
Private initFontSize As [Double]
Private initFontStyle As FontStyle
Private initBackBrush As SolidColorBrush
Private initForeBrush As SolidColorBrush
Private initFontFamily As FontFamily
Private UIIsReady As Boolean = False
Private Sub Init(ByVal sender As Object, ByVal e As RoutedEventArgs)
app = System.Windows.Application.Current
myWindow = CType(app.MainWindow, Window)
myWindow.SizeToContent = SizeToContent.WidthAndHeight
wfh.TabIndex = 10
initFontSize = wfh.FontSize
initFontWeight = wfh.FontWeight
initFontFamily = wfh.FontFamily
initFontStyle = wfh.FontStyle
initBackBrush = CType(wfh.Background, SolidColorBrush)
initForeBrush = CType(wfh.Foreground, SolidColorBrush)
Dim mc As MyControl1 = wfh.Child
AddHandler mc.OnButtonClick, AddressOf Pane1_OnButtonClick
UIIsReady = True
End Sub
private Application app;
private Window myWindow;
FontWeight initFontWeight;
Double initFontSize;
FontStyle initFontStyle;
SolidColorBrush initBackBrush;
SolidColorBrush initForeBrush;
FontFamily initFontFamily;
bool UIIsReady = false;
private void Init(object sender, EventArgs e)
{
app = System.Windows.Application.Current;
myWindow = (Window)app.MainWindow;
myWindow.SizeToContent = SizeToContent.WidthAndHeight;
wfh.TabIndex = 10;
initFontSize = wfh.FontSize;
initFontWeight = wfh.FontWeight;
initFontFamily = wfh.FontFamily;
initFontStyle = wfh.FontStyle;
initBackBrush = (SolidColorBrush)wfh.Background;
initForeBrush = (SolidColorBrush)wfh.Foreground;
(wfh.Child as MyControl1).OnButtonClick += new MyControl1.MyControlEventHandler(Pane1_OnButtonClick);
UIIsReady = true;
}
Dato che il codice XAML esaminato in precedenza ha consentito di aggiungere MyControl1 all'insieme di elementi figlio dell'elemento WindowsFormsHost, è possibile eseguire il cast di Child dell'elemento WindowsFormsHost per ottenere il riferimento a MyControl1. È quindi possibile utilizzare tale riferimento per associare un gestore eventi a OnButtonClick.
Oltre a fornire un riferimento al controllo stesso, WindowsFormsHost espone numerose proprietà del controllo, che si possono modificare dall'applicazione. Il codice di inizializzazione assegna tali valori a variabili globali private per un uso successivo nell'applicazione.
Aggiungere l'istruzione Imports o using seguente all'inizio del file per poter accedere agevolmente ai tipi nella DLL MyControls.
Imports MyControls
using MyControls;
Gestione dell'evento OnButtonClick
MyControl1 genera l'evento OnButtonClick quando l'utente fa clic su uno dei pulsanti del controllo.
Aggiungere il codice seguente alla classe MainWindow.
'Handle button clicks on the Windows Form control
Private Sub Pane1_OnButtonClick(ByVal sender As Object, ByVal args As MyControlEventArgs)
txtName.Inlines.Clear()
txtAddress.Inlines.Clear()
txtCity.Inlines.Clear()
txtState.Inlines.Clear()
txtZip.Inlines.Clear()
If args.IsOK Then
txtName.Inlines.Add(" " + args.MyName)
txtAddress.Inlines.Add(" " + args.MyStreetAddress)
txtCity.Inlines.Add(" " + args.MyCity)
txtState.Inlines.Add(" " + args.MyState)
txtZip.Inlines.Add(" " + args.MyZip)
End If
End Sub
//Handle button clicks on the Windows Form control
private void Pane1_OnButtonClick(object sender, MyControlEventArgs args)
{
txtName.Inlines.Clear();
txtAddress.Inlines.Clear();
txtCity.Inlines.Clear();
txtState.Inlines.Clear();
txtZip.Inlines.Clear();
if (args.IsOK)
{
txtName.Inlines.Add( " " + args.MyName );
txtAddress.Inlines.Add( " " + args.MyStreetAddress );
txtCity.Inlines.Add( " " + args.MyCity );
txtState.Inlines.Add( " " + args.MyState );
txtZip.Inlines.Add( " " + args.MyZip );
}
}
I dati nelle caselle di testo vengono compressi nell'oggettoMyControlEventArgs. Se l'utente fa clic sul pulsante OK, il gestore eventi estrae i dati e li visualizza nel pannello sottostante a MyControl1.
Modifica delle proprietà del controllo
L'elemento WindowsFormsHost espone numerose proprietà predefinite del controllo ospitato. Di conseguenza è possibile modificare l'aspetto del controllo perché corrisponda più da vicino allo stile dell'applicazione. Le serie di pulsanti di opzione del pannello sinistro consentono all'utente di modificare numerose proprietà del colore e del carattere. Ogni serie di pulsanti dispone di un gestore per l'evento Click, che rileva le selezioni del pulsante di opzione da parte dell'utente e modifica la proprietà corrispondente nel controllo.
Aggiungere il codice seguente alla classe MainWindow.
Private Sub BackColorChanged(ByVal sender As Object, ByVal e As RoutedEventArgs)
If sender.Equals(rdbtnBackGreen) Then
wfh.Background = New SolidColorBrush(Colors.LightGreen)
ElseIf sender.Equals(rdbtnBackSalmon) Then
wfh.Background = New SolidColorBrush(Colors.LightSalmon)
ElseIf UIIsReady = True Then
wfh.Background = initBackBrush
End If
End Sub
Private Sub ForeColorChanged(ByVal sender As Object, ByVal e As RoutedEventArgs)
If sender.Equals(rdbtnForeRed) Then
wfh.Foreground = New SolidColorBrush(Colors.Red)
ElseIf sender.Equals(rdbtnForeYellow) Then
wfh.Foreground = New SolidColorBrush(Colors.Yellow)
ElseIf UIIsReady = True Then
wfh.Foreground = initForeBrush
End If
End Sub
Private Sub FontChanged(ByVal sender As Object, ByVal e As RoutedEventArgs)
If sender.Equals(rdbtnTimes) Then
wfh.FontFamily = New FontFamily("Times New Roman")
ElseIf sender.Equals(rdbtnWingdings) Then
wfh.FontFamily = New FontFamily("Wingdings")
ElseIf UIIsReady = True Then
wfh.FontFamily = initFontFamily
End If
End Sub
Private Sub FontSizeChanged(ByVal sender As Object, ByVal e As RoutedEventArgs)
If sender.Equals(rdbtnTen) Then
wfh.FontSize = 10
ElseIf sender.Equals(rdbtnTwelve) Then
wfh.FontSize = 12
ElseIf UIIsReady = True Then
wfh.FontSize = initFontSize
End If
End Sub
Private Sub StyleChanged(ByVal sender As Object, ByVal e As RoutedEventArgs)
If sender.Equals(rdbtnItalic) Then
wfh.FontStyle = FontStyles.Italic
ElseIf UIIsReady = True Then
wfh.FontStyle = initFontStyle
End If
End Sub
Private Sub WeightChanged(ByVal sender As Object, ByVal e As RoutedEventArgs)
If sender.Equals(rdbtnBold) Then
wfh.FontWeight = FontWeights.Bold
ElseIf UIIsReady = True Then
wfh.FontWeight = initFontWeight
End If
End Sub
private void BackColorChanged(object sender, RoutedEventArgs e)
{
if (sender == rdbtnBackGreen)
wfh.Background = new SolidColorBrush(Colors.LightGreen);
else if (sender == rdbtnBackSalmon)
wfh.Background = new SolidColorBrush(Colors.LightSalmon);
else if (UIIsReady == true)
wfh.Background = initBackBrush;
}
private void ForeColorChanged(object sender, RoutedEventArgs e)
{
if (sender == rdbtnForeRed)
wfh.Foreground = new SolidColorBrush(Colors.Red);
else if (sender == rdbtnForeYellow)
wfh.Foreground = new SolidColorBrush(Colors.Yellow);
else if (UIIsReady == true)
wfh.Foreground = initForeBrush;
}
private void FontChanged(object sender, RoutedEventArgs e)
{
if (sender == rdbtnTimes)
wfh.FontFamily = new FontFamily("Times New Roman");
else if (sender == rdbtnWingdings)
wfh.FontFamily = new FontFamily("Wingdings");
else if (UIIsReady == true)
wfh.FontFamily = initFontFamily;
}
private void FontSizeChanged(object sender, RoutedEventArgs e)
{
if (sender == rdbtnTen)
wfh.FontSize = 10;
else if (sender == rdbtnTwelve)
wfh.FontSize = 12;
else if (UIIsReady == true)
wfh.FontSize = initFontSize;
}
private void StyleChanged(object sender, RoutedEventArgs e)
{
if (sender == rdbtnItalic)
wfh.FontStyle = FontStyles.Italic;
else if (UIIsReady == true)
wfh.FontStyle = initFontStyle;
}
private void WeightChanged(object sender, RoutedEventArgs e)
{
if (sender == rdbtnBold)
wfh.FontWeight = FontWeights.Bold;
else if (UIIsReady == true)
wfh.FontWeight = initFontWeight;
}
Compilare ed eseguire l'applicazione. Aggiungere testo al controllo composito Windows Form, quindi scegliere OK. Il testo viene visualizzato nelle etichette. Fare clic sui diversi pulsanti di opzione per visualizzare l'effetto sul controllo.
Vedere anche
Attività
Procedura dettagliata: hosting di controlli Windows Form in WPF
Riferimenti
Concetti
Procedura dettagliata: hosting di controlli compositi di WPF in Windows Form
Altre risorse
Cronologia delle modifiche
Data |
Cronologia |
Motivo |
|---|---|---|
Agosto 2010 |
Aggiornamento per Visual Studio 2010 |
Commenti e suggerimenti dei clienti. |