Panduan: Hosting Konten WPF di Win32

Windows Presentation Foundation (WPF) menyediakan lingkungan yang kaya untuk membuat aplikasi. Namun, ketika Anda memiliki investasi besar dalam kode Win32, mungkin lebih efektif untuk menambahkan fungsionalitas WPF ke aplikasi Anda daripada menulis ulang kode asli Anda. WPF menyediakan mekanisme mudah untuk menghosting konten WPF di jendela Win32.

Tutorial ini menjelaskan cara menulis aplikasi sampel, Hosting Konten WPF dalam Sampel Jendela Win32, yang menghosting konten WPF di jendela Win32. Anda dapat memperluas sampel ini untuk menghosting jendela Win32 apa pun. Karena melibatkan pencampuran kode terkelola dan tidak terkelola, aplikasi ditulis dalam C++/CLI.

Persyaratan

Tutorial ini mengasumsikan keakraban dasar dengan pemrograman WPF dan Win32. Untuk pengenalan dasar pemrograman WPF, lihat Memulai. Untuk pengantar pemrograman Win32, Anda harus mereferensikan salah satu dari banyak buku tentang subjek, khususnya Pemrograman Windows oleh Charles Petzold.

Karena sampel yang menyertai tutorial ini diimplementasikan dalam C++/CLI, tutorial ini mengasumsikan pemahaman tentang penggunaan C++ untuk memprogram WINDOWS API ditambah pemahaman tentang pemrograman kode terkelola. Keakraban dengan C++/CLI sangat membantu tetapi tidak penting.

Catatan

Tutorial ini mencakup sejumlah contoh kode dari sampel terkait. Namun, untuk keterbacaan, kode sampel lengkap tidak disertakan. Untuk kode sampel lengkap, lihat Hosting Konten WPF dalam Sampel Jendela Win32.

Prosedur Dasar

Bagian ini menguraikan prosedur dasar yang Anda gunakan untuk menghosting konten WPF di jendela Win32. Bagian yang tersisa menjelaskan detail setiap langkah.

Kunci untuk menghosting konten WPF di jendela Win32 adalah kelasnya HwndSource . Kelas ini membungkus konten WPF di jendela Win32, memungkinkannya dimasukkan ke dalam antarmuka pengguna (UI) Anda sebagai jendela anak. Pendekatan berikut menggabungkan Win32 dan WPF dalam satu aplikasi.

1. Terapkan konten WPF Anda sebagai kelas terkelola.

2. Menerapkan aplikasi Windows dengan C++/CLI. Jika Anda memulai dengan aplikasi yang ada dan kode C++ yang tidak dikelola, Anda biasanya dapat mengaktifkannya untuk memanggil kode terkelola dengan mengubah pengaturan proyek Anda untuk menyertakan /clr bendera pengkompilasi.

3. Atur model utas ke apartemen berulir tunggal (STA).

4. Tangani pemberitahuan WM_CREATEdi prosedur jendela Anda dan lakukan hal berikut:

   1. Buat objek baru HwndSource dengan jendela induk sebagai parameternya parent .

   2. Buat instans kelas konten WPF Anda.

   3. Tetapkan referensi ke objek konten WPF ke RootVisual properti .HwndSource

   4. Dapatkan HWND untuk konten. Properti HandleHwndSource objek berisi handel jendela (HWND). Untuk mendapatkan HWND yang dapat Anda gunakan di bagian aplikasi yang tidak dikelola, transmisikan Handle.ToPointer() ke HWND.

5. Terapkan kelas terkelola yang berisi bidang statis untuk menyimpan referensi ke konten WPF Anda. Kelas ini memungkinkan Anda untuk mendapatkan referensi ke konten WPF dari kode Win32 Anda.

6. Tetapkan konten WPF ke bidang statis.

7. Terima pemberitahuan dari konten WPF dengan melampirkan handler ke satu atau beberapa peristiwa WPF.

8. Berkomunikasi dengan konten WPF dengan menggunakan referensi yang Anda simpan di bidang statis untuk mengatur properti, dan sebagainya.

Catatan

Anda juga dapat menggunakan konten WPF. Namun, Anda harus mengkompilasinya secara terpisah sebagai pustaka tautan dinamis (DLL) dan mereferensikan DLL tersebut dari aplikasi Win32 Anda. Sisa prosedur mirip dengan yang diuraikan di atas.

Menerapkan Aplikasi Host

Bagian ini menjelaskan cara menghosting konten WPF dalam aplikasi Win32 dasar. Konten itu sendiri diimplementasikan dalam C++/CLI sebagai kelas terkelola. Untuk sebagian besar, ini adalah pemrograman WPF langsung. Aspek utama implementasi konten dibahas dalam Mengimplementasikan Konten WPF.

• Aplikasi Dasar

• Hosting Konten WPF

• Menyimpan Referensi ke Konten WPF

• Berkomunikasi dengan Konten WPF

Aplikasi Dasar

Titik awal untuk aplikasi host adalah membuat templat Visual Studio 2005.

1. Buka Visual Studio 2005, dan pilih Proyek Baru dari menu File.

2. Pilih Win32 dari daftar jenis proyek Visual C++. Jika bahasa default Anda bukan C++, Anda akan menemukan jenis proyek ini di bawah Bahasa Lain.

3. Pilih templat Proyek Win32, tetapkan nama ke proyek dan klik OK untuk meluncurkan Panduan Aplikasi Win32.

4. Terima pengaturan default wizard dan klik Selesai untuk memulai proyek.

Templat membuat aplikasi Win32 dasar, termasuk:

• Titik masuk untuk aplikasi.

• Jendela, dengan prosedur jendela terkait (WndProc).

• Menu dengan judul File dan Bantuan . Menu File memiliki item Keluar yang menutup aplikasi. Menu Bantuan memiliki item Tentang yang meluncurkan kotak dialog sederhana.

Sebelum Anda mulai menulis kode untuk menghosting konten WPF, Anda perlu membuat dua modifikasi pada templat dasar.

Yang pertama adalah mengkompilasi proyek sebagai kode terkelola. Secara default, proyek dikompilasi sebagai kode yang tidak dikelola. Namun, karena WPF diimplementasikan dalam kode terkelola, proyek harus dikompilasi dengan sesuai.

1. Klik kanan nama proyek di Penjelajah Solusi dan pilih Properti dari menu konteks untuk meluncurkan kotak dialog Halaman Properti.

2. Pilih Properti Konfigurasi dari tampilan pohon di panel kiri.

3. Pilih dukungan Common Language Runtime dari daftar Default Proyek di panel kanan.

4. Pilih Dukungan Runtime Bahasa Umum (/clr) dari kotak daftar drop-down.

Catatan

Bendera kompilator ini memungkinkan Anda menggunakan kode terkelola di aplikasi Anda, tetapi kode Anda yang tidak dikelola masih akan dikompilasi seperti sebelumnya.

WPF menggunakan model utas apartemen berulir tunggal (STA). Untuk bekerja dengan baik dengan kode konten WPF, Anda harus mengatur model utas aplikasi ke STA dengan menerapkan atribut ke titik masuk.

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

Hosting Konten WPF

Konten WPF adalah aplikasi entri alamat sederhana. Ini terdiri dari beberapa TextBox kontrol untuk mengambil nama pengguna, alamat, dan sebagainya. Ada juga dua Button kontrol, OK dan Batal. Saat pengguna mengklik OK, penanganan aktivitas tombol Click mengumpulkan data dari TextBox kontrol, menetapkannya ke properti yang sesuai, dan menaikkan peristiwa kustom, OnButtonClicked. Ketika pengguna mengklik Batal, handler hanya menaikkan OnButtonClicked. Objek argumen peristiwa untuk OnButtonClicked berisi bidang Boolean yang menunjukkan tombol mana yang diklik.

Kode untuk menghosting konten WPF diimplementasikan dalam handler untuk pemberitahuan WM_CREATE di jendela host.

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;

Metode ini GetHwnd mengambil informasi ukuran dan posisi ditambah handel jendela induk dan mengembalikan handel jendela konten WPF yang dihosting.

Catatan

Anda tidak dapat menggunakan direktif #using untuk System::Windows::Interop namespace. Melakukannya menciptakan tabrakan nama antara MSG struktur di namespace layanan tersebut dan struktur MSG yang dideklarasikan dalam winuser.h. Anda harus menggunakan nama yang sepenuhnya memenuhi syarat untuk mengakses konten namespace tersebut.

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

Anda tidak dapat menghosting konten WPF langsung di jendela aplikasi Anda. Sebagai gantinya, Anda terlebih dahulu membuat HwndSource objek untuk membungkus konten WPF. Objek ini pada dasarnya adalah jendela yang dirancang untuk menghosting konten WPF. Anda menghosting HwndSource objek di jendela induk dengan membuatnya sebagai anak dari jendela Win32 yang merupakan bagian dari aplikasi Anda. Parameter HwndSource konstruktor berisi banyak informasi yang sama dengan yang akan Anda teruskan ke CreateWindow saat Anda membuat jendela anak Win32.

Anda selanjutnya membuat instans objek konten WPF. Dalam hal ini, konten WPF diimplementasikan sebagai kelas terpisah, WPFPage, menggunakan C++/CLI. Anda juga dapat menerapkan konten WPF dengan XAML. Namun, untuk melakukannya, Anda perlu menyiapkan proyek terpisah dan membangun konten WPF sebagai DLL. Anda dapat menambahkan referensi ke DLL tersebut ke proyek Anda, dan menggunakan referensi tersebut untuk membuat instans konten WPF.

Anda menampilkan konten WPF di jendela anak Anda dengan menetapkan referensi ke konten WPF ke RootVisual properti HwndSource.

Baris kode berikutnya melampirkan penanganan aktivitas, WPFButtonClicked, ke peristiwa konten OnButtonClicked WPF. Handler ini dipanggil ketika pengguna mengklik tombol OK atau Batal . Lihat konten communicating_with_the_WPF untuk diskusi lebih lanjut tentang penanganan aktivitas ini.

Baris akhir kode yang ditampilkan mengembalikan handel jendela (HWND) yang terkait dengan HwndSource objek. Anda dapat menggunakan handel ini dari kode Win32 Anda untuk mengirim pesan ke jendela yang dihosting, meskipun sampel tidak melakukannya. Objek HwndSource menaikkan peristiwa setiap kali menerima pesan. Untuk memproses pesan, panggil AddHook metode untuk melampirkan handler pesan lalu proses pesan di handler tersebut.

Menyimpan Referensi ke Konten WPF

Untuk banyak aplikasi, Anda akan ingin berkomunikasi dengan konten WPF nanti. Misalnya, Anda mungkin ingin memodifikasi properti konten WPF, atau mungkin memiliki HwndSource konten WPF host objek yang berbeda. Untuk melakukan ini, Anda memerlukan referensi ke HwndSource objek atau konten WPF. Objek HwndSource dan konten WPF terkait tetap dalam memori sampai Anda menghancurkan handel jendela. Namun, variabel yang Anda tetapkan ke HwndSource objek akan keluar dari cakupan segera setelah Anda kembali dari prosedur jendela. Cara kustom untuk menangani masalah ini dengan aplikasi Win32 adalah dengan menggunakan variabel statis atau global. Sayangnya, Anda tidak dapat menetapkan objek terkelola ke jenis variabel tersebut. Anda dapat menetapkan handel jendela yang terkait dengan HwndSource objek ke variabel global atau statis, tetapi itu tidak menyediakan akses ke objek itu sendiri.

Solusi paling sederhana untuk masalah ini adalah menerapkan kelas terkelola yang berisi sekumpulan bidang statis untuk menyimpan referensi ke objek terkelola apa pun yang perlu Anda akses. Sampel menggunakan WPFPageHost kelas untuk menyimpan referensi ke konten WPF, ditambah nilai awal sejumlah propertinya yang mungkin diubah nanti oleh pengguna. Ini didefinisikan di header.

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

Bagian terakhir dari GetHwnd fungsi menetapkan nilai ke bidang tersebut untuk digunakan nanti saat myPage masih dalam cakupan.

Berkomunikasi dengan Konten WPF

Ada dua jenis komunikasi dengan konten WPF. Aplikasi menerima informasi dari konten WPF ketika pengguna mengklik tombol OK atau Batal . Aplikasi ini juga memiliki UI yang memungkinkan pengguna mengubah berbagai properti konten WPF, seperti warna latar belakang atau ukuran font default.

Seperti disebutkan di atas, ketika pengguna mengklik salah satu tombol konten WPF memunculkan OnButtonClicked peristiwa. Aplikasi melampirkan handler ke kejadian ini untuk menerima pemberitahuan ini. Jika tombol OK diklik, handler mendapatkan informasi pengguna dari konten WPF dan menampilkannya dalam sekumpulan kontrol statis.

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

Handler menerima objek argumen peristiwa kustom dari konten WPF, MyPageEventArgs. Properti objek IsOK diatur ke true jika tombol OK diklik, dan false jika tombol Batal diklik.

Jika tombol OK diklik, handler mendapatkan referensi ke konten WPF dari kelas kontainer. Kemudian mengumpulkan informasi pengguna yang dipegang oleh properti konten WPF terkait dan menggunakan kontrol statis untuk menampilkan informasi di jendela induk. Karena data konten WPF dalam bentuk string terkelola, data harus dinamai untuk digunakan oleh kontrol Win32. Jika tombol Batalkan diklik, handler akan menghapus data dari kontrol statis.

Antarmuka pengguna aplikasi menyediakan sekumpulan tombol radio yang memungkinkan pengguna mengubah warna latar belakang konten WPF, dan beberapa properti terkait font. Contoh berikut adalah kutipan dari prosedur jendela aplikasi (WndProc) dan penanganan pesannya yang mengatur berbagai properti pada pesan yang berbeda, termasuk warna latar belakang. Yang lain serupa, dan tidak ditampilkan. Lihat sampel lengkap untuk detail dan konteks.

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;

Untuk mengatur warna latar belakang, dapatkan referensi ke konten WPF (hostedPage) dari WPFPageHost dan atur properti warna latar belakang ke warna yang sesuai. Sampel menggunakan tiga opsi warna: warna asli, hijau muda, atau salmon ringan. Warna latar belakang asli disimpan sebagai bidang statis di WPFPageHost kelas . Untuk mengatur dua lainnya, Anda membuat objek baru SolidColorBrush dan meneruskan konstruktor nilai warna statis dari Colors objek.

Menerapkan Halaman WPF

Anda dapat menghosting dan menggunakan konten WPF tanpa mengetahui implementasi aktual. Jika konten WPF telah dimas dalam DLL terpisah, konten tersebut bisa saja dibangun dalam bahasa umum runtime bahasa umum (CLR). Berikut ini adalah panduan singkat implementasi C++/CLI yang digunakan dalam sampel. Bagian ini berisi subbagian berikut.

• Tata letak

• Mengembalikan Data ke Jendela Host

• Mengatur Properti WPF

Tata letak

Elemen UI dalam konten WPF terdiri dari lima TextBox kontrol, dengan kontrol terkait Label : Nama, Alamat, Kota, Status, dan Zip. Ada juga dua Button kontrol, OK dan Batal

Konten WPF diimplementasikan di WPFPage kelas . Tata letak ditangani dengan Grid elemen tata letak. Kelas mewarisi dari Grid, yang secara efektif menjadikannya elemen akar konten WPF.

Konstruktor konten WPF mengambil lebar dan tinggi yang Grid diperlukan, dan mengukur yang sesuai. Kemudian mendefinisikan tata letak dasar dengan membuat sekumpulan ColumnDefinition objek dan RowDefinition dan menambahkannya ke Grid basis ColumnDefinitions objek dan RowDefinitions koleksi. Ini menentukan kisi lima baris dan tujuh kolom, dengan dimensi yang ditentukan oleh konten sel.

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

Selanjutnya, konstruktor menambahkan elemen UI ke Grid. Elemen pertama adalah teks judul, yang merupakan Label kontrol yang berpusat di baris pertama kisi.

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

Baris berikutnya berisi kontrol Nama Label dan kontrol terkaitnya TextBox . Karena kode yang sama digunakan untuk setiap pasangan label/kotak teks, kode tersebut ditempatkan dalam sepasang metode privat dan digunakan untuk kelima pasangan label/kotak teks. Metode membuat kontrol yang sesuai, dan memanggil Grid kelas statis SetColumn dan SetRow metode untuk menempatkan kontrol di sel yang sesuai. Setelah kontrol dibuat, sampel memanggil Add metode pada Children properti Grid untuk menambahkan kontrol ke kisi. Kode untuk menambahkan pasangan label/kotak teks yang tersisa serupa. Lihat kode sampel untuk detailnya.

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

Implementasi dari dua metode tersebut adalah sebagai berikut:

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

Terakhir, sampel menambahkan tombol OK dan Batalkan dan melampirkan penanganan aktivitas ke peristiwa mereka Click .

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

Mengembalikan Data ke Jendela Host

Saat salah satu tombol diklik, peristiwanya Click akan dinaikkan. Jendela host hanya dapat melampirkan handler ke peristiwa ini dan mendapatkan data langsung dari TextBox kontrol. Sampel menggunakan pendekatan langsung yang agak kurang. Ini menangani Click dalam konten WPF, dan kemudian menaikkan peristiwa OnButtonClickedkustom , untuk memberi tahu konten WPF. Ini memungkinkan konten WPF untuk melakukan beberapa validasi parameter sebelum memberi tahu host. Handler mendapatkan teks dari TextBox kontrol dan menetapkannya ke properti publik, tempat host dapat mengambil informasi.

Deklarasi acara, dalam WPFPage.h:

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

Penanganan Click aktivitas, di 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));
}

Mengatur Properti WPF

Host Win32 memungkinkan pengguna untuk mengubah beberapa properti konten WPF. Dari sisi Win32, itu hanya masalah mengubah properti. Implementasi dalam kelas konten WPF agak lebih rumit, karena tidak ada satu pun properti global yang mengontrol font untuk semua kontrol. Sebagai gantinya, properti yang sesuai untuk setiap kontrol diubah dalam aksesor set properti. Contoh berikut menunjukkan kode untuk DefaultFontFamily properti . Mengatur properti memanggil metode privat yang pada gilirannya FontFamily mengatur properti untuk berbagai kontrol.

Dari WPFPage.h:

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

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

Baca juga

• HwndSource
• Interoperatur WPF dan Win32