Návod: Hostování obsahu WPF v Win32

Windows Presentation Foundation (WPF) poskytuje bohaté prostředí pro vytváření aplikací. Pokud ale máte značné investice do kódu Win32, může být efektivnější přidat funkce WPF do vaší aplikace místo přepsání původního kódu. WPF poskytuje jednoduchý mechanismus pro hostování obsahu WPF v okně Win32.

Tento kurz popisuje, jak napsat ukázkovou aplikaci hostující obsah WPF v ukázce okna Win32, která hostuje obsah WPF v okně Win32. Tuto ukázku můžete rozšířit tak, aby hostovat jakékoli okno Win32. Vzhledem k tomu, že zahrnuje kombinování spravovaného a nespravovaného kódu, je aplikace napsaná v jazyce C++/CLI.

Požadavky

V tomto kurzu se předpokládá základní znalost programování WPF i Win32. Základní úvod do programování WPF najdete v tématu Začínáme. Úvod do programování Win32 byste měli odkazovat na některou z mnoha knih na téma, zejména Programování Windows Charles Petzold.

Vzhledem k tomu, že ukázka, která doprovází tento kurz, je implementována v jazyce C++/CLI, předpokládá tento kurz znalost použití jazyka C++ k programování rozhraní API systému Windows a porozumění programování spravovaného kódu. Znalost jazyka C++/CLI je užitečná, ale není důležitá.

Základní postup

Tato část popisuje základní postup, který používáte k hostování obsahu WPF v okně Win32. Zbývající části popisují podrobnosti o jednotlivých krocích.

Klíčem k hostování obsahu WPF v okně Win32 je HwndSource třída. Tato třída zabalí obsah WPF do okna Win32, což umožňuje jeho začlenění do uživatelského rozhraní (UI) jako podřízeného okna. Následující přístup kombinuje Win32 a WPF v jedné aplikaci.

1. Implementujte obsah WPF jako spravovanou třídu.

2. Implementujte aplikaci pro Windows pomocí C++/CLI. Pokud začínáte s existující aplikací a nespravovaným kódem C++, můžete ho obvykle povolit volání spravovaného kódu změnou nastavení projektu tak, aby zahrnoval příznak kompilátoru /clr .

3. Nastavte model závitování na jednovláknový byt (STA).

4. Zpracujte WM_CREATEoznámení v okně a postupujte takto:

   1. Vytvořte nový HwndSource objekt s nadřazeným oknem jako jeho parent parametrem.

   2. Vytvořte instanci třídy obsahu WPF.

   3. Přiřaďte odkaz na objekt obsahu WPF vlastnosti RootVisualHwndSource.

   4. Získejte HWND pro obsah. Vlastnost Handle objektu HwndSource obsahuje popisovač okna (HWND). Chcete-li získat HWND, který můžete použít v nespravované části aplikace, přetypujte Handle.ToPointer() na HWND.

5. Implementujte spravovanou třídu, která obsahuje statické pole pro uložení odkazu na obsah WPF. Tato třída umožňuje získat odkaz na obsah WPF z kódu Win32.

6. Přiřaďte obsah WPF statickému poli.

7. Oznámení z obsahu WPF můžete přijímat připojením obslužné rutiny k jedné nebo více událostem WPF.

8. Komunikujte s obsahem WPF pomocí odkazu, který jste uložili ve statickém poli k nastavení vlastností atd.

Implementace hostitelské aplikace

Tato část popisuje, jak hostovat obsah WPF v základní aplikaci Win32. Samotný obsah se implementuje v C++/CLI jako spravovaná třída. Ve většině případů je to jednoduché programování WPF. Klíčové aspekty implementace obsahu jsou popsány v implementaci obsahu WPF.

• Základní aplikace

• Hostování obsahu WPF

• Uchovávání odkazu na obsah WPF

• Komunikace s obsahem WPF

Základní aplikace

Výchozím bodem hostitelské aplikace bylo vytvoření šablony sady Visual Studio 2005.

1. Otevřete Visual Studio 2005 a v nabídce Soubor vyberte Nový projekt.

2. Ze seznamu typů projektů Visual C++ vyberte Win32 . Pokud váš výchozí jazyk není C++, najdete tyto typy projektů v části Jiné jazyky.

3. Vyberte šablonu projektu Win32, přiřaďte projektu název a kliknutím na OK spusťte Průvodce aplikací Win32.

4. Přijměte výchozí nastavení průvodce a kliknutím na Tlačítko Dokončit spusťte projekt.

Šablona vytvoří základní aplikaci Win32, včetně následujících:

• Vstupní bod pro aplikaci.

• Okno s přidruženou procedurou okna (WndProc).

• Nabídka s nadpisy Soubor a Nápověda Nabídka Soubor obsahuje ukončovací položku, která aplikaci zavře. Nabídka Nápověda obsahuje položku O položce, která spustí jednoduché dialogové okno.

Než začnete psát kód pro hostování obsahu WPF, musíte provést dvě změny základní šablony.

Prvním je kompilace projektu jako spravovaného kódu. Ve výchozím nastavení se projekt zkompiluje jako nespravovaný kód. Vzhledem k tomu, že wpF je implementovaný ve spravovaném kódu, musí být projekt odpovídajícím způsobem zkompilován.

1. Klikněte pravým tlačítkem myši na název projektu v Průzkumník řešení a v místní nabídce vyberte Vlastnosti a spusťte dialogové okno Stránky vlastností.

2. V levém podokně vyberte Vlastnosti konfigurace ve stromovém zobrazení.

3. V pravém podokně vyberte podporu modulu CLR (Common Language Runtime) ze seznamu Výchozí nastavení projektu.

4. V rozevíracím seznamu vyberte podporu modulu Clr (/clr) modulu Common Language Runtime.

WPF používá model jednovláknového apartmánu (STA) threading. Aby bylo možné správně pracovat s kódem obsahu WPF, musíte nastavit model vláken aplikace na STA použitím atributu na vstupní bod.

[System::STAThreadAttribute] //Needs to be an STA thread to play nicely with WPF
int APIENTRY _tWinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPTSTR    lpCmdLine,
                     int       nCmdShow)
{

Hostování obsahu WPF

Obsah WPF je jednoduchá aplikace pro zadávání adres. Skládá se z několika TextBox ovládacích prvků, které přebírají uživatelské jméno, adresu atd. K dispozici jsou také dva Button ovládací prvky, OK a Zrušit. Když uživatel klikne na OK, obslužná rutina události tlačítka Click shromažďuje data z TextBox ovládacích prvků, přiřadí je k odpovídajícím vlastnostem a vyvolá vlastní událost OnButtonClicked. Když uživatel klikne na tlačítko Storno, obslužná rutina OnButtonClickedjednoduše vyvolá . Objekt argumentu události obsahuje OnButtonClicked logické pole, které označuje, na které tlačítko bylo kliknutí.

Kód pro hostování obsahu WPF je implementován v obslužné rutině pro WM_CREATE oznámení v okně hostitele.

case WM_CREATE :
  GetClientRect(hWnd, &rect);
  wpfHwnd = GetHwnd(hWnd, rect.right-375, 0, 375, 250);
  CreateDataDisplay(hWnd, 275, rect.right-375, 375);
  CreateRadioButtons(hWnd);
break;

Metoda GetHwnd přebírá informace o velikosti a poloze a nadřazený popisovač okna a vrátí popisovač okna hostovaného obsahu WPF.

HWND GetHwnd(HWND parent, int x, int y, int width, int height)
{
    System::Windows::Interop::HwndSourceParameters^ sourceParams = gcnew System::Windows::Interop::HwndSourceParameters(
    "hi" // NAME
    );
    sourceParams->PositionX = x;
    sourceParams->PositionY = y;
    sourceParams->Height = height;
    sourceParams->Width = width;
    sourceParams->ParentWindow = IntPtr(parent);
    sourceParams->WindowStyle = WS_VISIBLE | WS_CHILD; // style
    System::Windows::Interop::HwndSource^ source = gcnew System::Windows::Interop::HwndSource(*sourceParams);
    WPFPage ^myPage = gcnew WPFPage(width, height);
    //Assign a reference to the WPF page and a set of UI properties to a set of static properties in a class
    //that is designed for that purpose.
    WPFPageHost::hostedPage = myPage;
    WPFPageHost::initBackBrush = myPage->Background;
    WPFPageHost::initFontFamily = myPage->DefaultFontFamily;
    WPFPageHost::initFontSize = myPage->DefaultFontSize;
    WPFPageHost::initFontStyle = myPage->DefaultFontStyle;
    WPFPageHost::initFontWeight = myPage->DefaultFontWeight;
    WPFPageHost::initForeBrush = myPage->DefaultForeBrush;
    myPage->OnButtonClicked += gcnew WPFPage::ButtonClickHandler(WPFButtonClicked);
    source->RootVisual = myPage;
    return (HWND) source->Handle.ToPointer();
}

Obsah WPF nelze hostovat přímo v okně aplikace. Místo toho nejprve vytvoříte HwndSource objekt, který zabalí obsah WPF. Tento objekt je v podstatě okno, které je určeno k hostování obsahu WPF. Objekt hostujete HwndSource v nadřazené okně tak, že ho vytvoříte jako podřízené okno Win32, které je součástí vaší aplikace. Parametry HwndSource konstruktoru obsahují mnohem stejné informace, které byste předali CreateWindow při vytváření podřízeného okna Win32.

Dále vytvoříte instanci objektu obsahu WPF. V tomto případě se obsah WPF implementuje jako samostatná třída WPFPagepomocí C++/CLI. Obsah WPF můžete také implementovat pomocí XAML. Pokud to ale chcete udělat, musíte nastavit samostatný projekt a sestavit obsah WPF jako knihovnu DLL. Do projektu můžete přidat odkaz na tuto knihovnu DLL a tento odkaz použít k vytvoření instance obsahu WPF.

Obsah WPF zobrazíte v podřízené okně přiřazením odkazu na obsah WPF vlastnosti RootVisualHwndSource.

Další řádek kódu připojí obslužnou rutinu události , WPFButtonClickedk události obsahu OnButtonClicked WPF. Tato obslužná rutina se volá, když uživatel klikne na tlačítko OK nebo Zrušit . Další informace o této obslužné rutině události najdete v communicating_with_the_WPF obsahu .

Poslední řádek kódu, který se zobrazí, vrátí popisovač okna (HWND), který je přidružen k objektu HwndSource . Tento popisovač z kódu Win32 můžete použít k odesílání zpráv do hostovaného okna, i když ukázka to neudělá. Objekt HwndSource vyvolá událost pokaždé, když obdrží zprávu. Chcete-li zpracovat zprávy, zavolejte metodu AddHook pro připojení obslužné rutiny zprávy a pak zpracovat zprávy v této obslužné rutině.

Uchovávání odkazu na obsah WPF

U mnoha aplikací budete chtít později komunikovat s obsahem WPF. Můžete například chtít upravit vlastnosti obsahu WPF nebo mít pravděpodobně HwndSource hostitelem jiného obsahu WPF objektu. K tomu potřebujete odkaz na HwndSource objekt nebo obsah WPF. Objekt HwndSource a jeho přidružený obsah WPF zůstanou v paměti, dokud nezničíte popisovač okna. Proměnná, kterou přiřadíte k objektu HwndSource , však po návratu z okna přejde mimo rozsah. Vlastní způsob, jak tento problém vyřešit s aplikacemi Win32, je použít statickou nebo globální proměnnou. Spravované objekty bohužel nemůžete k těmto typům proměnných přiřadit. Popisovač okna přidružený k HwndSource objektu můžete přiřadit ke globální nebo statické proměnné, ale které neposkytují přístup k samotnému objektu.

Nejjednodušším řešením tohoto problému je implementace spravované třídy, která obsahuje sadu statických polí pro uchovávání odkazů na všechny spravované objekty, ke kterým potřebujete přístup. Ukázka používá WPFPageHost třídu k uložení odkazu na obsah WPF plus počáteční hodnoty řady jeho vlastností, které mohou být později změněny uživatelem. Toto je definováno v hlavičce.

public ref class WPFPageHost
{
public:
  WPFPageHost();
  static WPFPage^ hostedPage;
  //initial property settings
  static System::Windows::Media::Brush^ initBackBrush;
  static System::Windows::Media::Brush^ initForeBrush;
  static System::Windows::Media::FontFamily^ initFontFamily;
  static System::Windows::FontStyle initFontStyle;
  static System::Windows::FontWeight initFontWeight;
  static double initFontSize;
};

Druhá část GetHwnd funkce přiřazuje hodnoty k těmto polím pro pozdější použití, i když myPage je stále v oboru.

Komunikace s obsahem WPF

Existují dva typy komunikace s obsahem WPF. Aplikace obdrží informace z obsahu WPF, když uživatel klikne na tlačítko OK nebo Zrušit . Aplikace má také uživatelské rozhraní, které uživateli umožňuje změnit různé vlastnosti obsahu WPF, například barvu pozadí nebo výchozí velikost písma.

Jak je uvedeno výše, když uživatel klikne na libovolné tlačítko, obsah WPF vyvolá OnButtonClicked událost. Aplikace k této události připojí obslužnou rutinu pro příjem těchto oznámení. Pokud bylo tlačítko OK kliknuto, obslužná rutina získá informace o uživateli z obsahu WPF a zobrazí je v sadě statických ovládacích prvků.

void WPFButtonClicked(Object ^sender, MyPageEventArgs ^args)
{
    if(args->IsOK) //display data if OK button was clicked
    {
        WPFPage ^myPage = WPFPageHost::hostedPage;
        LPCWSTR userName = (LPCWSTR) InteropServices::Marshal::StringToHGlobalAuto("Name: " + myPage->EnteredName).ToPointer();
        SetWindowText(nameLabel, userName);
        LPCWSTR userAddress = (LPCWSTR) InteropServices::Marshal::StringToHGlobalAuto("Address: " + myPage->EnteredAddress).ToPointer();
        SetWindowText(addressLabel, userAddress);
        LPCWSTR userCity = (LPCWSTR) InteropServices::Marshal::StringToHGlobalAuto("City: " + myPage->EnteredCity).ToPointer();
        SetWindowText(cityLabel, userCity);
        LPCWSTR userState = (LPCWSTR) InteropServices::Marshal::StringToHGlobalAuto("State: " + myPage->EnteredState).ToPointer();
        SetWindowText(stateLabel, userState);
        LPCWSTR userZip = (LPCWSTR) InteropServices::Marshal::StringToHGlobalAuto("Zip: " + myPage->EnteredZip).ToPointer();
        SetWindowText(zipLabel, userZip);
    }
    else
    {
        SetWindowText(nameLabel, L"Name: ");
        SetWindowText(addressLabel, L"Address: ");
        SetWindowText(cityLabel, L"City: ");
        SetWindowText(stateLabel, L"State: ");
        SetWindowText(zipLabel, L"Zip: ");
    }
}

Obslužná rutina obdrží vlastní objekt argumentu události z obsahu WPF , MyPageEventArgs. Vlastnost objektu IsOK je nastavena tak, aby true se po kliknutí na tlačítko OK a false pokud bylo na tlačítko Storno kliknuto.

Pokud bylo tlačítko OK kliknuto, obslužná rutina získá odkaz na obsah WPF z třídy kontejneru. Potom shromažďuje informace o uživateli, které jsou uloženy přidruženými vlastnostmi obsahu WPF, a pomocí statických ovládacích prvků zobrazí informace v nadřazené okně. Vzhledem k tomu, že data obsahu WPF jsou ve formě spravovaného řetězce, musí být zařazována pro použití ovládacím prvku Win32. Pokud bylo kliknutí na tlačítko Storno, obslužná rutina vymaže data ze statických ovládacích prvků.

Uživatelské rozhraní aplikace poskytuje sadu přepínačů, které uživateli umožňují změnit barvu pozadí obsahu WPF a několik vlastností souvisejících s písmem. Následující příklad je výňatek z procedury okna aplikace (WndProc) a jeho zpracování zpráv, které nastavuje různé vlastnosti na různých zprávách, včetně barvy pozadí. Ostatní jsou podobné a nezobrazují se. Podrobnosti a kontext najdete v kompletní ukázce.

case WM_COMMAND:
  wmId    = LOWORD(wParam);
  wmEvent = HIWORD(wParam);

  switch (wmId)
  {
  //Menu selections
    case IDM_ABOUT:
      DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
    break;
    case IDM_EXIT:
      DestroyWindow(hWnd);
    break;
    //RadioButtons
    case IDC_ORIGINALBACKGROUND :
      WPFPageHost::hostedPage->Background = WPFPageHost::initBackBrush;
    break;
    case IDC_LIGHTGREENBACKGROUND :
      WPFPageHost::hostedPage->Background = gcnew SolidColorBrush(Colors::LightGreen);
    break;
    case IDC_LIGHTSALMONBACKGROUND :
      WPFPageHost::hostedPage->Background = gcnew SolidColorBrush(Colors::LightSalmon);
    break;

Pokud chcete nastavit barvu pozadí, získejte odkaz na obsah WPF (hostedPage) z WPFPageHost a nastavte vlastnost barvy pozadí na příslušnou barvu. Ukázka používá tři barevné možnosti: původní barvu, světle zelenou nebo světlá lososa. Původní barva pozadí je uložena jako statické pole ve WPFPageHost třídě. Pokud chcete nastavit další dva objekty, vytvoříte nový SolidColorBrush objekt a předáte konstruktor hodnotu statických barev z objektu Colors .

Implementace stránky WPF

Obsah WPF můžete hostovat a používat bez jakýchkoli znalostí o skutečné implementaci. Pokud byl obsah WPF zabalený v samostatné knihovně DLL, mohl být sestaven v jakémkoli jazyce CLR (Common Language Runtime). Následuje stručný návod k implementaci C++/CLI, která se používá v ukázce. Tato část obsahuje následující pododdíly.

• Rozložení

• Vrácení dat do okna hostitele

• Nastavení vlastností WPF

Rozložení

Prvky uživatelského rozhraní v obsahu WPF se skládají z pěti TextBox ovládacích prvků s přidruženými Label ovládacími prvky: Název, Adresa, Město, Stát a Zip. K dispozici jsou také dva Button ovládací prvky, OK a Zrušit.

Obsah WPF je implementován ve WPFPage třídě. Rozložení se zpracovává elementem Grid rozložení. Třída dědí z Grid, což efektivně dělá WPF obsah kořenový prvek.

Konstruktor obsahu WPF přebírá požadovanou šířku a výšku a odpovídajícím způsobem Grid velikost. Pak definuje základní rozložení tak, že vytvoří sadu ColumnDefinition objektů a RowDefinition přidá je do základu ColumnDefinitionsGrid objektů a RowDefinitions kolekcí. Tím se definuje mřížka pěti řádků a sedmi sloupců s rozměry určenými obsahem buněk.

WPFPage::WPFPage(int allottedWidth, int allotedHeight)
{
  array<ColumnDefinition ^> ^ columnDef = gcnew array<ColumnDefinition ^> (4);
  array<RowDefinition ^> ^ rowDef = gcnew array<RowDefinition ^> (6);

  this->Height = allotedHeight;
  this->Width = allottedWidth;
  this->Background = gcnew SolidColorBrush(Colors::LightGray);
  
  //Set up the Grid's row and column definitions
  for(int i=0; i<4; i++)
  {
    columnDef[i] = gcnew ColumnDefinition();
    columnDef[i]->Width = GridLength(1, GridUnitType::Auto);
    this->ColumnDefinitions->Add(columnDef[i]);
  }
  for(int i=0; i<6; i++)
  {
    rowDef[i] = gcnew RowDefinition();
    rowDef[i]->Height = GridLength(1, GridUnitType::Auto);
    this->RowDefinitions->Add(rowDef[i]);
  }

Dále konstruktor přidá prvky uživatelského rozhraní do Gridsouboru . Prvním prvkem je text nadpisu, což je Label ovládací prvek, který je na střed v prvním řádku mřížky.

//Add the title
titleText = gcnew Label();
titleText->Content = "Simple WPF Control";
titleText->HorizontalAlignment = System::Windows::HorizontalAlignment::Center;
titleText->Margin = Thickness(10, 5, 10, 0);
titleText->FontWeight = FontWeights::Bold;
titleText->FontSize = 14;
Grid::SetColumn(titleText, 0);
Grid::SetRow(titleText, 0);
Grid::SetColumnSpan(titleText, 4);
this->Children->Add(titleText);

Další řádek obsahuje ovládací prvek Název Label a jeho přidružený TextBox ovládací prvek. Vzhledem k tomu, že stejný kód se používá pro každou dvojici popisků a textového pole, je umístěn v páru privátních metod a používá se pro všechny pět dvojic popisků a textových pole. Metody vytvářejí příslušný ovládací prvek a volají Grid třídu staticky SetColumn a SetRow metody pro umístění ovládacích prvků do příslušné buňky. Po vytvoření ovládacího prvku volá ukázka Add metodu ve Children vlastnosti objektu Grid , která přidá ovládací prvek do mřížky. Kód pro přidání zbývajících dvojic popisků a textových adres je podobný. Podrobnosti najdete v ukázkovém kódu.

//Add the Name Label and TextBox
nameLabel = CreateLabel(0, 1, "Name");
this->Children->Add(nameLabel);
nameTextBox = CreateTextBox(1, 1, 3);
this->Children->Add(nameTextBox);

Implementace těchto dvou metod je následující:

Label ^WPFPage::CreateLabel(int column, int row, String ^ text)
{
  Label ^ newLabel = gcnew Label();
  newLabel->Content = text;
  newLabel->Margin = Thickness(10, 5, 10, 0);
  newLabel->FontWeight = FontWeights::Normal;
  newLabel->FontSize = 12;
  Grid::SetColumn(newLabel, column);
  Grid::SetRow(newLabel, row);
  return newLabel;
}
TextBox ^WPFPage::CreateTextBox(int column, int row, int span)
{
  TextBox ^newTextBox = gcnew TextBox();
  newTextBox->Margin = Thickness(10, 5, 10, 0);
  Grid::SetColumn(newTextBox, column);
  Grid::SetRow(newTextBox, row);
  Grid::SetColumnSpan(newTextBox, span);
  return newTextBox;
}

Nakonec ukázka přidá tlačítka OK a Zrušit a připojí obslužnou rutinu události k Click událostem.

//Add the Buttons and atttach event handlers
okButton = CreateButton(0, 5, "OK");
cancelButton = CreateButton(1, 5, "Cancel");
this->Children->Add(okButton);
this->Children->Add(cancelButton);
okButton->Click += gcnew RoutedEventHandler(this, &WPFPage::ButtonClicked);
cancelButton->Click += gcnew RoutedEventHandler(this, &WPFPage::ButtonClicked);

Vrácení dat do okna hostitele

Když kliknete na některé tlačítko, vyvolá se jeho Click událost. Okno hostitele může k těmto událostem jednoduše připojit obslužné rutiny a získat data přímo z ovládacích TextBox prvků. Ukázka používá poněkud méně přímý přístup. Zpracovává Click obsah WPF a pak vyvolá vlastní událost OnButtonClicked, která oznámí obsah WPF. Tím umožníte, aby obsah WPF před upozorňováním hostitele udělal ověření některých parametrů. Obslužná rutina získá text z ovládacích TextBox prvků a přiřadí ho k veřejným vlastnostem, ze kterých může hostitel načíst informace.

Deklarace události ve WPFPage.h:

public:
  delegate void ButtonClickHandler(Object ^, MyPageEventArgs ^);
  WPFPage();
  WPFPage(int height, int width);
  event ButtonClickHandler ^OnButtonClicked;

Obslužná rutina Click události v souboru WPFPage.cpp:

void WPFPage::ButtonClicked(Object ^sender, RoutedEventArgs ^args)
{

  //TODO: validate input data
  bool okClicked = true;
  if(sender == cancelButton)
    okClicked = false;
  EnteredName = nameTextBox->Text;
  EnteredAddress = addressTextBox->Text;
  EnteredCity = cityTextBox->Text;
  EnteredState = stateTextBox->Text;
  EnteredZip = zipTextBox->Text;
  OnButtonClicked(this, gcnew MyPageEventArgs(okClicked));
}

Nastavení vlastností WPF

Hostitel Win32 umožňuje uživateli změnit několik vlastností obsahu WPF. Ze strany Win32 je to jednoduše záležitost změny vlastností. Implementace třídy obsahu WPF je poněkud složitější, protože neexistuje žádná globální vlastnost, která řídí písma pro všechny ovládací prvky. Místo toho se v přístupových objektech sady vlastností změní příslušná vlastnost pro každý ovládací prvek. Následující příklad ukazuje kód vlastnosti DefaultFontFamily . Nastavení vlastnosti volá soukromou metodu, která zase nastaví FontFamily vlastnosti pro různé ovládací prvky.

Z WPFPage.h:

property FontFamily^ DefaultFontFamily
{
  FontFamily^ get() {return _defaultFontFamily;}
  void set(FontFamily^ value) {SetFontFamily(value);}
};

Z WPFPage.cpp:

void WPFPage::SetFontFamily(FontFamily^ newFontFamily)
{
  _defaultFontFamily = newFontFamily;
  titleText->FontFamily = newFontFamily;
  nameLabel->FontFamily = newFontFamily;
  addressLabel->FontFamily = newFontFamily;
  cityLabel->FontFamily = newFontFamily;
  stateLabel->FontFamily = newFontFamily;
  zipLabel->FontFamily = newFontFamily;
}

Viz také

• HwndSource
• Vzájemná spolupráce grafického subsystému WPF a systému Win32