Megjegyzés
Az oldalhoz való hozzáféréshez engedély szükséges. Megpróbálhat bejelentkezni vagy módosítani a címtárat.
Az oldalhoz való hozzáféréshez engedély szükséges. Megpróbálhatja módosítani a címtárat.
A Windows Presentation Foundation (WPF) gazdag környezetet biztosít az alkalmazások létrehozásához. Ha azonban jelentős befektetéssel rendelkezik a Win32-kódba, hatékonyabb lehet a WPF-funkciók hozzáadása az alkalmazáshoz az eredeti kód újraírása helyett. A WPF egyszerű mechanizmust biztosít a WPF-tartalmak Win32-ablakban való üzemeltetéséhez.
Ez az oktatóanyag bemutatja, hogyan írhat egy win32-ablakmintában WPF-tartalmat üzemeltető mintaalkalmazást, amely WPF-tartalmat üzemeltet egy Win32-ablakban. Ezt a mintát bármely Win32-ablak üzemeltetésére kiterjesztheti. Mivel ez magában foglalja a felügyelt és a nem felügyelt kód keverését, az alkalmazás C++/CLI nyelven van megírva.
Követelmények
Ez az oktatóanyag a WPF és a Win32 programozás alapszintű ismeretét feltételezi. A WPF-programozás alapszintű bemutatása: Első lépések. A Win32-programozás bemutatása érdekében hivatkozzon a témával kapcsolatos számos könyvre, különösen Charles Petzold Windows programozására .
Mivel az oktatóanyagot kísérő minta C++/CLI-ben implementálva van, ez az oktatóanyag feltételezi a C++ használatát a Windows API programozásához, valamint a felügyelt kód programozásának megértését. A C++/CLI ismerete hasznos, de nem nélkülözhetetlen.
Megjegyzés:
Ez az oktatóanyag számos példakódot tartalmaz a társított mintából. Az olvashatóság érdekében azonban nem tartalmazza a teljes mintakódot. A teljes mintakódért lásd: WPF-tartalom üzemeltetése Win32-példaablakban.
Az alapvető eljárás
Ez a szakasz a WPF-tartalmak Win32-ablakban való tárolására használt alapvető eljárást ismerteti. A többi szakasz ismerteti az egyes lépések részleteit.
A WPF-tartalmak Win32-ablakban való üzemeltetésének kulcsa az HwndSource osztály. Ez az osztály egy Win32 ablakba burkolja a WPF-tartalmat, így gyermekablakként beépíthető a felhasználói felületbe. Az alábbi megközelítés egyetlen alkalmazásban egyesíti a Win32 és a WPF protokollt.
A WPF-tartalmat valósítsa meg felügyelt osztályként.
Windows-alkalmazás implementálása C++/CLI használatával. Ha egy meglévő alkalmazással és nem felügyelt C++ kóddal kezd, általában engedélyezheti a felügyelt kód meghívását úgy, hogy a projektbeállításokat úgy módosítja, hogy tartalmazza a
/clrfordító jelölőt.Állítsa be a szálmodellt egyszálas apartmanra (STA).
Kezelje az WM_CREATEértesítést az ablakeljárásban, és tegye a következőket:
Hozzon létre egy új HwndSource objektumot, amelynek paramétere
parenta szülőablak.Hozzon létre egy példányt a WPF tartalom osztályból.
A WPF-tartalomobjektumra mutató hivatkozás hozzárendelése a RootVisualHwndSourcetulajdonsághoz.
A HWND-t kérje le a tartalomhoz. Az Handle objektum HwndSource tulajdonsága tartalmazza az ablakkezelő fogantyút (HWND). Ha szeretne egy HWND-t, amelyet az alkalmazás nem felügyelt részében használhat, alakítsa át a
Handle.ToPointer()-t HWND-vé.
Implementáljon egy felügyelt osztályt, amely statikus mezőt tartalmaz a WPF-tartalomra mutató hivatkozás tárolásához. Ez az osztály lehetővé teszi, hogy a Win32-kódból hivatkozzon a WPF-tartalomra.
A WPF-tartalom hozzárendelése a statikus mezőhöz.
Értesítések fogadása a WPF-tartalomból, ha egy kezelőt csatol egy vagy több WPF-eseményhez.
Kommunikáljon a WPF-tartalommal a statikus mezőben tárolt hivatkozással a tulajdonságok beállításához, és így tovább.
Megjegyzés:
A WPF-tartalmat is használhatja. Azonban külön kell lefordítania azt dinamikus csatolású kódtárként (DLL), és hivatkoznia kell arra a DLL-re a Win32-alkalmazásból. Az eljárás hátralevő része a fent vázolthoz hasonló.
A gazdaalkalmazás implementálása
Ez a szakasz azt ismerteti, hogyan üzemeltethet WPF-tartalmakat egy alapszintű Win32-alkalmazásban. Maga a tartalom felügyelt osztályként van implementálva a C++/CLI-ben. A legtöbb esetben ez egyszerű WPF-programozás. A tartalom implementálásának fő szempontjait a WPF-tartalom implementálásában tárgyaljuk.
Az alapszintű alkalmazás
A gazdaalkalmazás kiindulópontja egy Visual Studio 2005-sablon létrehozása volt.
Nyissa meg a Visual Studio 2005-öt, és válassza az Új projekt lehetőséget a Fájl menüben.
A Visual C++ projekttípusok listájában válassza a Win32 lehetőséget. Ha az alapértelmezett nyelv nem C++, ezeket a projekttípusokat az Egyéb nyelvek területen találja.
Válasszon ki egy Win32-projektsablont , rendeljen hozzá egy nevet a projekthez, majd kattintson az OKgombra a Win32 Alkalmazás varázsló elindításához.
Fogadja el a varázsló alapértelmezett beállításait, és kattintson a Befejezés gombra a projekt elindításához.
A sablon létrehoz egy alapszintű Win32-alkalmazást, beleértve a következőket:
Az alkalmazás belépési pontja.
Egy ablak egy társított ablakeljárással (WndProc).
Egy Fájl és Súgó menüpontokkal rendelkező menü. A Fájlmenüben található egy kilépési elem, amely bezárja az alkalmazást. A Súgó menüben található egy Névjegy elem, amely egy egyszerű párbeszédablakot nyit meg.
Mielőtt elkezdené írni a WPF-tartalom tárolására vonatkozó kódot, két módosítást kell végeznie az alapsablonon.
Az első a projekt lefordítása felügyelt kódként. Alapértelmezés szerint a projekt nem felügyelt kódként fordítható le. Mivel azonban a WPF felügyelt kódban van implementálva, a projektet ennek megfelelően kell lefordítani.
Kattintson a jobb gombbal a projekt nevére a Megoldáskezelőben , és válassza a Tulajdonságok lehetőséget a helyi menüben a Tulajdonságlapok párbeszédpanel elindításához.
Válassza ki a konfigurációs tulajdonságokat a bal oldali panel fanézetéből.
Válassza a Közös nyelvi futtatókörnyezet-támogatást a projekt alapértelmezett beállítások listájából a jobb oldali panelen.
Válassza a Common Language Runtime Support (/clr) lehetőséget a legördülő listából.
Megjegyzés:
Ez a fordítójelölő lehetővé teszi, hogy felügyelt kódot használjon az alkalmazásban, de a nem felügyelt kód továbbra is a korábbiakhoz hasonlóan fog lefordítani.
A WPF az egyszálú lakásmodell (STA) szálkezelési modellt használja. Ahhoz, hogy megfelelően működjön a WPF-tartalomkóddal, az alkalmazás szálkezelési modelljét sta értékre kell állítania egy attribútum alkalmazásával a belépési pontra.
[System::STAThreadAttribute] //Needs to be an STA thread to play nicely with WPF
int APIENTRY _tWinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPTSTR lpCmdLine,
int nCmdShow)
{
A WPF-tartalom üzemeltetése
A WPF-tartalom egy egyszerű címbejegyzési alkalmazás. Több, a felhasználó nevét, a címet és hasonló adatokat összegyűjtő vezérlőből TextBox áll. Két Button vezérlő is van, OK és Mégse. Amikor a felhasználó az OK gombra kattint, a gomb eseménykezelője Click összegyűjti az adatokat a vezérlőkből, hozzárendeli azokat a TextBox megfelelő tulajdonságokhoz, és egyéni eseményt hoz létre. OnButtonClicked Amikor a felhasználó a Mégse gombra kattint, a kezelő egyszerűen emel.OnButtonClicked A függvény eseményargumentum-objektuma OnButtonClicked egy logikai mezőt tartalmaz, amely jelzi, hogy melyik gombra kattintott.
A WPF-tartalom üzemeltetésére szolgáló kód a gazdagépablak WM_CREATE értesítésének kezelőjében lesz implementálva.
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;
A GetHwnd metódus a méret- és pozícióadatokat, valamint a szülőablak-leírót veszi figyelembe, és visszaadja az üzemeltetett WPF-tartalom ablakfogópontját.
Megjegyzés:
Nem használhat #using direktívát a System::Windows::Interop névtérhez. Ezzel névütközést okoz a MSG névtérben lévő struktúra és a winuser.h rendszerben deklarált MSG-struktúra között. Ehelyett teljesen képzett névvel kell hozzáférnie a névtér tartalmához.
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();
}
A WPF-tartalmat nem lehet közvetlenül az alkalmazásablakban üzemeltetni. Ehelyett először létre kell hoznia egy HwndSource objektumot a WPF-tartalom körbefuttatásához. Ez az objektum alapvetően egy WPF-tartalom üzemeltetésére tervezett ablak. Az HwndSource objektumot úgy üzemeltetheti a szülőablakban, hogy létrehozza azt az alkalmazásához tartozó Win32-ablak gyermekeként. A HwndSource konstruktorparaméterek ugyanazokat az információkat tartalmazzák, amelyeket a Win32 gyermekablak létrehozásakor a CreateWindow-nak adna át.
Ezután létre kell hoznia a WPF tartalomobjektum egy példányát. Ebben az esetben a WPF-tartalom egy külön osztályként van implementálva, WPFPagea C++/CLI használatával. A WPF-tartalmat az XAML használatával is implementálhatja. Ehhez azonban be kell állítania egy külön projektet, és DLL-ként kell létrehoznia a WPF-tartalmat. Hozzáadhat egy hivatkozást az adott DLL-hez a projekthez, és ezzel a hivatkozással létrehozhatja a WPF-tartalom egy példányát.
A WPF-tartalmat a gyermekablakban úgy jelenítheti meg, hogy a WPF-tartalomra mutató hivatkozást rendel a RootVisualHwndSourcetulajdonsághoz.
A következő kódsor egy eseménykezelőt WPFButtonClickedcsatol a WPF-tartalomeseményhez OnButtonClicked . Ezt a kezelőt akkor hívja meg a rendszer, ha a felhasználó az OK vagy a Mégse gombra kattint. Az eseménykezelő további megvitatásához tekintse meg communicating_with_the_WPF tartalmat .
A megjelenített kód utolsó sora az objektumhoz HwndSource társított ablakfogópontot (HWND) adja vissza. A Win32-kódból származó fogópont segítségével üzeneteket küldhet a üzemeltetett ablakba, bár a minta erre nem képes. Az HwndSource objektum minden alkalommal előhoz egy eseményt, amikor üzenetet kap. Az üzenetek feldolgozásához hívja meg a AddHook metódust, hogy csatoljon egy üzenetkezelőt, majd dolgozza fel a kezelőben lévő üzeneteket.
A WPF-tartalomra mutató hivatkozás megtartása
Számos alkalmazás esetén később szeretne kommunikálni a WPF-tartalommal. Előfordulhat például, hogy módosítani szeretné a WPF-tartalom tulajdonságait, vagy esetleg az HwndSource objektum különböző WPF-tartalmat üzemeltet. Ehhez az objektumra vagy a HwndSource WPF-tartalomra kell hivatkoznia. Az HwndSource objektum és a hozzá tartozó WPF-tartalom a memóriában marad, amíg el nem pusztítja az ablakfogópontot. Az objektumhoz HwndSource hozzárendelt változó azonban az ablakeljárásból való visszatéréskor azonnal ki fog lépni a hatókörből. A Win32-alkalmazások esetében a probléma megoldásának szokásos módja egy statikus vagy globális változó használata. Az ilyen típusú változókhoz sajnos nem rendelhet felügyelt objektumot. Az objektumhoz HwndSource társított ablakfogópontot hozzárendelheti egy globális vagy statikus változóhoz, de ez nem biztosít hozzáférést magához az objektumhoz.
A probléma legegyszerűbb megoldása egy olyan felügyelt osztály implementálása, amely statikus mezőket tartalmaz, amelyek hivatkozásokat tárolnak minden olyan felügyelt objektumra, amelyhez hozzáférésre van szüksége. A minta az WPFPageHost osztály használatával hivatkozik a WPF-tartalomra, valamint a felhasználó által később esetleg módosítható tulajdonságok kezdeti értékeire. Ez a fejlécben van definiálva.
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;
};
A függvény utóbbi része értékeket rendel ezekhez a GetHwnd mezőkhöz későbbi használatra, amíg myPage még hatókörben van.
Kommunikáció a WPF-tartalommal
A WPF-tartalommal kétféle kommunikáció érhető el. Az alkalmazás információt kap a WPF-tartalomtól, amikor a felhasználó az OK vagy a Mégse gombra kattint. Az alkalmazás felhasználói felülettel is rendelkezik, amellyel a felhasználó módosíthatja a WPF-tartalom különböző tulajdonságait, például a háttérszínt vagy az alapértelmezett betűméretet.
Ahogy fentebb említettük, amikor a felhasználó bármelyik gombra kattint, a WPF-tartalom eseményt OnButtonClicked idéz elő. Az alkalmazás egy kezelőt csatol ehhez az eseményhez az értesítések fogadásához. Ha az OK gombra kattintott, a kezelő lekéri a felhasználói adatokat a WPF-tartalomból, és statikus vezérlők készletében jeleníti meg.
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: ");
}
}
A kezelő egy egyéni eseményargumentum-objektumot kap a WPF-tartalomtól. MyPageEventArgs Az objektum IsOK tulajdonsága akkor van beállítva true, ha az OK gombra kattintottak, és false ha a Mégse gombra kattintottak.
Ha az OK gombra kattintott, a kezelő a tárolóosztály WPF-tartalmára mutató hivatkozást kap. Ezután összegyűjti a kapcsolódó WPF-tartalomtulajdonságok által tárolt felhasználói adatokat, és a statikus vezérlőkkel jeleníti meg az információkat a szülőablakban. Mivel a WPF-tartalomadatok felügyelt sztring formájában vannak, egy Win32-vezérlőnek kell használnia őket. Ha a Mégse gombra kattintott, a kezelő törli az adatokat a statikus vezérlőkből.
Az alkalmazás felhasználói felülete olyan választógombokat biztosít, amelyekkel a felhasználó módosíthatja a WPF-tartalom háttérszínét, valamint számos betűtípussal kapcsolatos tulajdonságot. Az alábbi példa az alkalmazás ablakkezelési eljárásának (WndProc) és üzenetkezelésének egy részlete, amely különböző tulajdonságokat állít be a különböző üzeneteken, beleértve a háttérszínt is. A többi hasonló, és nem jelenik meg. A részletekért és a kontextusért tekintse meg a teljes mintát.
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;
A háttérszín beállításához kérje le a WPF-tartalomra (hostedPage) WPFPageHost mutató hivatkozást, és állítsa a háttérszín tulajdonságot a megfelelő színre. A minta három színbeállítást használ: az eredeti színt, a világoszöldet vagy a világos lazacot. Az eredeti háttérszín statikus mezőként van tárolva az WPFPageHost osztályban. A másik kettő beállításához hozzon létre egy új SolidColorBrush objektumot, és adjon át a konstruktornak egy statikus színértéket az Colors objektumból.
A WPF-oldal implementálása
A WPF-tartalmakat a tényleges megvalósítás ismerete nélkül is üzemeltetheti és használhatja. Ha a WPF-tartalmat külön DLL-fájlba csomagolták volna, az bármilyen közös nyelvi futtatókörnyezeti (CLR- ) nyelven készült volna. Az alábbiakban röviden bemutatjuk a mintában használt C++/CLI implementációt. Ez a szakasz a következő alszakaszokat tartalmazza.
Elrendezés
A WPF-tartalom felhasználói felületi elemei öt TextBox vezérlőből állnak, a hozzájuk tartozó Label vezérlőkkel: Név, Cím, Város, Állam és Zip. Van még két Button vezérlő is, OK és Mégse
A WPF-tartalom az osztályban WPFPage van implementálva. Az elrendezést egy Grid elrendezési elem kezeli. Az osztály öröklődik a GridWPF-tartalom gyökérelemeként.
A WPF-tartalomkonstruktor a szükséges szélességet és magasságot veszi igénybe, és ennek megfelelően méretez.Grid Ezután meghatározza az alapszintű elrendezést úgy, hogy létrehoz egy készletet ColumnDefinition és RowDefinition objektumokat, majd hozzáadja őket az objektumbázishoz Grid és ColumnDefinitions a RowDefinitions gyűjteményekhez. Ez egy öt sorból és hét oszlopból álló rácsot határoz meg, amelynek méreteit a cellák tartalma határozza meg.
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]);
}
Ezután a konstruktor hozzáadja a felhasználói felület elemeit a Grid. Az első elem a címszöveg, amely a Label rács első sorában középre igazított vezérlőelem.
//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);
A következő sor tartalmazza a Név Label vezérlőelemet és a hozzá tartozó TextBox vezérlőt. Mivel minden címke/szövegdoboz párhoz ugyanazt a kódot használják, privát metóduspárba helyezik, és mind az öt címke-szövegdoboz párhoz használják. A metódusok létrehozzák a megfelelő vezérlést, majd meghívják az Grid osztály statikus SetColumn és SetRow metódusait, hogy elhelyezhessék a vezérlőket a megfelelő cellában. A vezérlő létrehozása után a minta meghívja a Add metódust a Children tulajdonságon, Grid hogy hozzáadja a vezérlőt a rácshoz. A többi címke/szövegdoboz pár hozzáadására szolgáló kód hasonló. Részletekért tekintse meg a mintakódot.
//Add the Name Label and TextBox
nameLabel = CreateLabel(0, 1, "Name");
this->Children->Add(nameLabel);
nameTextBox = CreateTextBox(1, 1, 3);
this->Children->Add(nameTextBox);
A két módszer megvalósítása a következő:
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;
}
Végül a minta hozzáadja az OK és a Mégse gombot, és egy eseménykezelőt csatol az eseményekhez 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);
Az adatok visszaadása a gazdagépablakba
Ha bármelyik gombra kattint, Click az eseménye fel lesz emelve. A gazdagépablak egyszerűen csatolhat kezelőket ezekhez az eseményekhez, és közvetlenül a vezérlőkből szerezheti be az TextBox adatokat. A minta valamivel kevésbé közvetlen megközelítést használ. Kezeli a Click WPF-tartalmat, majd létrehoz egy egyéni eseményt OnButtonClicked, amely értesíti a WPF-tartalmat. Ez lehetővé teszi, hogy a WPF-tartalom a gazdagép értesítése előtt elvégezze a paraméterek ellenőrzését. A kezelő megszerzi a szöveget a TextBox vezérlőkből, és hozzárendeli a nyilvános tulajdonságokhoz, ahonnan a hoszt lekérheti az információkat.
Az eseménydeklaráció a WPFPage.h-ban:
public:
delegate void ButtonClickHandler(Object ^, MyPageEventArgs ^);
WPFPage();
WPFPage(int height, int width);
event ButtonClickHandler ^OnButtonClicked;
Az Click eseménykezelő a WPFPage.cpp fájlban:
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));
}
A WPF tulajdonságainak beállítása
A Win32-gazdagép több WPF-tartalomtulajdonság módosítását teszi lehetővé a felhasználó számára. A Win32 oldalról egyszerűen a tulajdonságok módosításáról van szó. A WPF tartalomosztály implementációja valamivel bonyolultabb, mivel egyetlen globális tulajdonság sem szabályozza az összes vezérlő betűtípusait. Ehelyett az egyes vezérlők megfelelő tulajdonságainak hozzáférési metódusait módosítják. Az alábbi példa a tulajdonság kódját DefaultFontFamily mutatja be. A tulajdonság beállítása privát metódust hív meg, amely viszont beállítja a FontFamily különböző vezérlők tulajdonságait.
A WPFPage.h fájlból:
property FontFamily^ DefaultFontFamily
{
FontFamily^ get() {return _defaultFontFamily;}
void set(FontFamily^ value) {SetFontFamily(value);}
};
Forrás: 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;
}
Lásd még
Dolgozzon együtt velünk a GitHubon
A tartalom forrása a GitHubon található, ahol létrehozhat és áttekinthet problémákat és lekéréses kérelmeket is. További információért tekintse meg a közreműködői útmutatónkat.
.NET Desktop feedback