Megosztás a következőn keresztül:

Tudnivalók a párbeszédpanelekről

  • Cikk

Számos függvény, üzenet és előre definiált vezérlő segíti a párbeszédpanelek létrehozását és kezelését, így könnyebben fejleszthető az alkalmazás felhasználói felülete. Ez az áttekintés ismerteti a párbeszédpanel-függvényeket és üzeneteket, és ismerteti, hogyan használhatja őket párbeszédpanelek létrehozására és használatára.

Ez az áttekintés a következő témaköröket tartalmazza:

A gyakori párbeszédpanelekről további információt a Közös párbeszédpaneltárcímű témakörben talál.

Mikor érdemes párbeszédpanelt használni?

A legtöbb alkalmazás párbeszédpaneleket használ a felhasználói bevitelt igénylő menüelemek további információinak megadására. A párbeszédpanel használata az egyetlen ajánlott módja annak, hogy egy alkalmazás lekérje a bemenetet. Egy tipikus Megnyitás menüelemhez például egy fájl nevét kell megadni, ezért az alkalmazásnak párbeszédpanelt kell használnia, hogy elkérje a felhasználótól a nevet. Ilyen esetekben az alkalmazás akkor hozza létre a párbeszédpanelt, amikor a felhasználó a menüelemre kattint, és azonnal megsemmisíti a párbeszédpanelt, miután a felhasználó megadja az információkat.

Számos alkalmazás párbeszédpaneleket is használ az információk vagy beállítások megjelenítéséhez, miközben a felhasználó egy másik ablakban dolgozik. A szövegszerkesztő alkalmazások például gyakran használnak szövegkeresési lehetőséget tartalmazó párbeszédpanelt. Amíg az alkalmazás megkeresi a szöveget, a párbeszédpanel a képernyőn marad. A felhasználó ezután visszatérhet a párbeszédpanelre, és újra megkeresheti ugyanazt a szót; vagy a felhasználó módosíthatja a párbeszédpanelen lévő bejegyzést, és kereshet egy új szót. Az ilyen módon párbeszédpaneleket használó alkalmazások általában akkor hoznak létre egyet, amikor a felhasználó a menüelemre kattint, és addig jeleníti meg, amíg az alkalmazás fut, vagy amíg a felhasználó kifejezetten be nem zárja a párbeszédpanelt.

Az alkalmazások párbeszédpanelek használatának különböző módjainak támogatásához kétféle párbeszédpanel létezik: modális és mód nélküli. A modális párbeszédpanel megköveteli a felhasználótól, hogy adja meg az adatokat, vagy törölje a párbeszédpanelt, mielőtt engedélyezi az alkalmazás folytatását. Az alkalmazások modális párbeszédpaneleket használnak a menüelemekkel együtt, amelyek további információkat igényelnek a folytatás előtt. A modális ablak lehetővé teszi a felhasználó számára, hogy adatokat adjon meg, majd a párbeszédpanel bezárása nélkül visszatérjen az előző feladathoz. A modális párbeszédpanelek egyszerűbben kezelhetők, mint a modellmentes párbeszédpanelek, mert létrejönnek, végrehajtják a feladatukat, és egyetlen függvény meghívásával megsemmisülnek.

Modális vagy mód nélküli párbeszédpanel létrehozásához az alkalmazásnak meg kell adnia egy párbeszédpanelsablont a párbeszédpanel stílusának és tartalmának leírásához; az alkalmazásnak egy párbeszédpaneles eljárást is meg kell adnia a feladatok elvégzéséhez. A párbeszédpanelsablon a párbeszédpanel és a benne található vezérlők bináris leírása. A fejlesztő létrehozhatja ezt a sablont az alkalmazás végrehajtható fájljából betöltendő erőforrásként, vagy létrehozhatja a memóriában az alkalmazás futtatása közben. A párbeszédpanel-eljárás egy alkalmazás által meghatározott visszahívási függvény, amelyet a rendszer akkor hív meg, ha a párbeszédpanel bemenete vagy a párbeszédpanel végrehajtásához szükséges feladatok vannak megadva. Bár egy párbeszédpanel-eljárás hasonló az ablakos eljáráshoz, nem ugyanazokkal a feladatokkal rendelkezik.

Az alkalmazások általában a Párbeszédpanel vagy CreateDialog függvénnyel hoznak létre párbeszédpanelt. Párbeszédpanel létrehoz egy modális párbeszédpanelt; CreateDialog nem modális párbeszédpanelt hoz létre. Ez a két függvény betölt egy párbeszédpanelsablont az alkalmazás végrehajtható fájljából, és létrehoz egy előugró ablakot, amely megfelel a sablon specifikációinak. Vannak más függvények is, amelyek sablonokkal hoznak létre párbeszédpanelt a memóriában; a párbeszédpanel létrehozásakor további információkat adnak át a párbeszédpanel eljárásának.

A párbeszédpanelek általában egy előre definiált, kizárólagos ablakosztályhoz tartoznak. A rendszer ezt az ablakosztályt és annak megfelelő ablakeljárását használja mind a modális, mind a nem modális párbeszédpanelekhez. A függvény meghívásakor létrehozza a párbeszédpanel ablakát, valamint a párbeszédpanel vezérlőinek ablakait, majd a kijelölt üzeneteket elküldi a párbeszédpanel eljárásának. Bár a párbeszédpanel látható, az előre definiált ablakos eljárás kezeli az összes üzenetet, feldolgoz néhány üzenetet, és átad másokat a párbeszédpanel-eljárásnak, hogy az eljárás végrehajthassa a feladatokat. Az alkalmazások nem rendelkeznek közvetlen hozzáféréssel az előre definiált ablakosztályhoz vagy ablakművelethez, de a párbeszédpanel-sablon és a párbeszédpanel-eljárás használatával módosíthatják a párbeszédpanelek stílusát és viselkedését.

Párbeszédpanel tulajdonosának ablaka

A legtöbb párbeszédpanelen van egy tulajdonosi ablak (vagy egyszerűen egy tulajdonos). A párbeszédpanel létrehozásakor az alkalmazás a tulajdonos ablakleírójának megadásával állítja be a tulajdonost. A rendszer a tulajdonos használatával határozza meg a párbeszédpanel Z sorrendben való pozícióját, hogy a párbeszédpanel mindig a tulajdonosa fölött legyen. Emellett a rendszer üzeneteket küldhet a tulajdonos ablakos eljárásának, és értesítheti a párbeszédpanel eseményeiről.

A rendszer automatikusan elrejti vagy megsemmisíti a párbeszédpanelt, amikor a tulajdonosa el van rejtve vagy megsemmisül. Ez azt jelenti, hogy a párbeszédpanel-eljárás nem igényel speciális feldolgozást a tulajdonosi ablak állapotának változásainak észleléséhez.

Mivel a szokásos párbeszédpanel egy menüelemhez kapcsolódik, a tulajdonos ablaka általában a menüt tartalmazó ablak. Bár létrehozhat egy olyan párbeszédpanelt, amely nem rendelkezik tulajdonossal, nem ajánlott. Ha például egy modális párbeszédpanel nem rendelkezik tulajdonossal, a rendszer nem tiltja le az alkalmazás többi ablakát, és lehetővé teszi a felhasználó számára, hogy a többi ablakban folytassa a munkát, ezzel legyőzve a modális párbeszédpanel célját.

Ha egy független párbeszédpanelnek nincs tulajdonosa, a rendszer nem rejti el vagy semmisíti meg a párbeszédpanelt, ha az alkalmazás többi ablaka el van rejtve vagy megsemmisül. Bár ez nem rontja el a modellmentes párbeszédpanel célját, megköveteli, hogy az alkalmazás speciális feldolgozást végezzen annak érdekében, hogy a párbeszédpanelt a megfelelő időpontokban elrejtse és lezárja.

Üzenetmezők

Az üzenetpanel egy speciális párbeszédpanel, amellyel egy alkalmazás megjelenítheti az üzeneteket, és egyszerű bemenetet kérhet. Az üzenetmezők általában szöveges üzenetet és egy vagy több gombot tartalmaznak. Az alkalmazás a MessageBox vagy MessageBoxEx függvénnyel hozza létre az üzenetmezőt, megadva a megjelenítendő szöveget, valamint a megjelenítendő gombok számát és típusait. Vegye figyelembe, hogy jelenleg nincs különbség a MessageBox és a MessageBoxEx működése között.

Bár az üzenetpanel egy párbeszédpanel, a rendszer teljes mértékben felügyeli az üzenetpanel létrehozását és kezelését. Ez azt jelenti, hogy az alkalmazás nem biztosít párbeszédpanelsablont és párbeszédpanel-eljárást. A rendszer saját sablont hoz létre az üzenetmezőhöz megadott szöveg és gombok alapján, és saját párbeszédpanel-eljárást biztosít.

Az üzenetmezők egy modális párbeszédpanelek, és a rendszer ugyanazokkal a belső függvényekkel hozza létre, amelyeket a DialogBoxhasznál. Ha az alkalmazás tulajdonosi ablakot ad meg MessageBox vagy MessageBoxExhívásához, a rendszer letiltja a tulajdonost. Az alkalmazások arra is utasíthatják a rendszert, hogy tiltsa le az aktuális szálhoz tartozó összes felső szintű ablakot a párbeszédpanel létrehozásakor megadott MB_TASKMODAL érték megadásával.

A rendszer üzeneteket küldhet a tulajdonosnak, például WM_CANCELMODE és WM_ENABLE, ugyanúgy, mint egy modális párbeszédpanel létrehozásakor. A tulajdonos ablakának végre kell hajtania az üzenetek által kért műveleteket.

A modális párbeszédpanelnek egy előugró ablaknak kell lennie, amely ablakmenüvel, címsorral és vastag szegélyrel rendelkezik; vagyis a párbeszédpanelsablonnak meg kell adnia a WS_POPUP, WS_SYSMENU, WS_CAPTIONés DS_MODALFRAME stílusokat. Bár egy alkalmazás kijelölheti a WS_VISIBLE stílust, a rendszer mindig megjelenít egy modális párbeszédpanelt, függetlenül attól, hogy a párbeszédpanelsablon megadja-e a WS_VISIBLE stílust. Az alkalmazások nem hozhatnak létre olyan modális párbeszédpanelt, amely WS_CHILD stílussal rendelkezik. Az ezzel a stílussal rendelkező modális párbeszédpanel letiltja magát, megakadályozva, hogy a későbbi bemenetek elérjék az alkalmazást.

Az alkalmazások a DialogBox vagy DialogBoxIndirect függvénnyel hoznak létre egy modális párbeszédpanelt. Párbeszédpanel- egy párbeszédpanelsablont tartalmazó erőforrás nevét vagy azonosítóját igényli; DialogBoxIndirect egy párbeszédpanelsablont tartalmazó memóriaobjektum leíróját igényli. A DialogBoxParam és DialogBoxIndirectParam függvények is létrehoznak modális párbeszédpaneleket; megegyeznek a korábban említett függvényekkel, de a párbeszédpanel létrehozásakor egy megadott paramétert adnak át a párbeszédpanel-eljárásnak.

A modális párbeszédpanel létrehozásakor a rendszer aktív ablakká teszi. A párbeszédpanel addig aktív marad, amíg a párbeszédpanel-eljárás nem hívja meg a EndDialog függvényt, vagy a rendszer aktivál egy ablakot egy másik alkalmazásban. Sem a felhasználó, sem az alkalmazás nem teheti aktívvá a tulajdonosablakot, amíg a modális párbeszédpanel el nem pusztul.

Ha a tulajdonos ablaka még nincs letiltva, a rendszer automatikusan letiltja az ablakot és a hozzá tartozó gyermekablakokat, amikor létrehozza a modális párbeszédpanelt. A tulajdonos ablaka mindaddig le van tiltva, amíg a párbeszédpanel el nem pusztul. Bár egy párbeszédpanel-eljárás bármikor engedélyezheti a tulajdonosi ablakot, a tulajdonos engedélyezése nem teszi lehetővé a modális párbeszédpanel célját, ezért nem ajánlott. Ha a párbeszédpanel megszűnik, a rendszer ismét engedélyezi a tulajdonosablakot, de csak akkor, ha a modális párbeszédpanel okozta a tulajdonos letiltását.

Amikor a rendszer létrehozza a modális párbeszédpanelt, elküldi a WM_CANCELMODE üzenetet az ablakba (ha van ilyen), amely jelenleg az egér bemenetét rögzíti. Az üzenetet fogadó alkalmazásnak el kell engednie az egérrögzítést, hogy a felhasználó áthelyezhesse az egeret a modális párbeszédpanelen. Mivel a rendszer letiltja a tulajdonosablakot, az összes egérbemenet elveszik, ha a tulajdonos nem tudja felszabadítani az egeret az üzenet fogadásakor.

A modális párbeszédpanel üzeneteinek feldolgozásához a rendszer elindítja a saját üzenethurkját, amely ideiglenesen szabályozza a teljes alkalmazás üzenetsorát. Amikor a rendszer olyan üzenetet kér le, amely nem kifejezetten a párbeszédpanelhez tartozik, a megfelelő ablakba küldi az üzenetet. Ha egy WM_QUIT üzenetet kér le, az üzenet vissza lesz kapcsolva az alkalmazás üzenetsorába, hogy az alkalmazás fő üzenethurkja végül lekérhesse az üzenetet.

A rendszer elküldi a WM_ENTERIDLE üzenetet a tulajdonos ablakának, amikor az alkalmazásüzenet-üzenetsor üres. Az alkalmazás ezt az üzenetet használhatja háttérfeladat végrehajtására, amíg a párbeszédpanel a képernyőn marad. Ha egy alkalmazás így használja az üzenetet, az alkalmazásnak gyakran engedélyeznie kell a hozzáférés-vezérlést (például a PeekMessage függvény használatával), hogy a modális párbeszédpanel bármilyen felhasználói bemenetet fogadjon. Annak érdekében, hogy a modális párbeszédpanel ne küldjön WM_ENTERIDLE üzeneteket, az alkalmazás megadhatja a DS_NOIDLEMSG stílust a párbeszédpanel létrehozásakor.

Egy alkalmazás megsemmisít egy modális párbeszédpanelt az EndDialog függvénnyel. A legtöbb esetben a párbeszédpanel-eljárás meghívja a EndDialog utasítást, amikor a felhasználó a párbeszédpanel ablakmenüjéből a Bezárás parancsot választja, vagy a párbeszédpanelen az OK vagy a Mégse gombra kattint. A párbeszédpanel a Párbeszédpanel függvényen (vagy más létrehozási függvényeken) keresztül is visszaadhat egy értéket a EndDialog függvény meghívásakor. A rendszer ezt az értéket adja vissza a párbeszédpanel megsemmisítése után. A legtöbb alkalmazás ezt a visszatérési értéket használja annak megállapítására, hogy a párbeszédpanel sikeresen végrehajtotta-e a feladatát, vagy a felhasználó megszakította-e. A rendszer nem adja vissza a vezérlőt a párbeszédpanelt létrehozó függvényből, amíg a párbeszédpanel-eljárás nem hívja meg a EndDialog függvényt.

Mód nélküli párbeszédpanelek

A nem modális párbeszédpanelnek olyan felugró ablaknak kell lennie, amely ablakmenüvel, címsávról és vékony szegéllyel rendelkezik; vagyis a párbeszédpanelsablonnak meg kell adnia a WS_POPUP, WS_CAPTION, WS_BORDERés WS_SYSMENU stílusokat. A rendszer csak akkor jeleníti meg automatikusan a párbeszédpanelt, ha a sablon megadja a WS_VISIBLE stílust.

Az alkalmazás a CreateDialog vagy a CreateDialogIndirect függvény használatával hoz létre modell nélküli párbeszédpanelt. CreateDialog párbeszédpanelsablont tartalmazó erőforrás nevét vagy azonosítóját igényli; CreateDialogIndirect egy párbeszédpanelsablont tartalmazó memóriaobjektum leíróját igényli. Két másik függvény, CreateDialogParam és CreateDialogIndirectParam, szintén modeless párbeszédpanelek létrehozására szolgál, és a párbeszédpanel létrehozásakor megadott paramétert adnak át a párbeszédpanel-eljárásnak.

CreateDialog és más létrehozási függvények egy ablakkezelőt adnak vissza a párbeszédpanelhez. Az alkalmazás és a párbeszédpanel eljárása ezzel a leíróval kezelheti a párbeszédpanelt. Ha például WS_VISIBLE nincs megadva a párbeszédpanelsablonban, az alkalmazás megjelenítheti a párbeszédpanelt úgy, hogy az ablakfogópontot átadja a ShowWindow függvénynek.

A mód nélküli párbeszédpanel sem nem tiltja le a tulajdonosablakot, sem nem küld neki üzeneteket. A párbeszédpanel létrehozásakor a rendszer aktív ablakká teszi, de a felhasználó vagy az alkalmazás bármikor módosíthatja az aktív ablakot. Ha a párbeszédpanel inaktívvá válik, akkor a tulajdonos ablaka felett marad a Z sorrendben, még akkor is, ha a tulajdonosi ablak aktív.

Az alkalmazás feladata a bemeneti üzenetek beolvasása és elküldése a párbeszédpanelre. A legtöbb alkalmazás ehhez a fő üzenethurkot használja. Ha azonban lehetővé szeretné tenni a felhasználó számára, hogy a billentyűzettel lépjen a vezérlőkre, és válassza ki a vezérlőket, az alkalmazásnak meg kell hívnia az IsDialogMessage függvényt. A függvényről további információt a párbeszédpanel billentyűzetfelületénekcímű témakörben talál.

A mód nélküli párbeszédpanel nem adhat vissza értéket az alkalmazásnak, mint ahogy azt a modális párbeszédpanelek tehetik, de a párbeszédpanel-eljárás a SendMessage függvény használatával információt küldhet a tulajdonos ablakának.

Az alkalmazásnak a megszakítás előtt el kell pusztítania az összes nem modális párbeszédpanelt. A DestroyWindow függvénnyel elpusztíthat egy modális nélküli párbeszédpanelt. A legtöbb esetben a párbeszédpanel-eljárás a felhasználói bemenetre válaszul például a Mégse gombra kattintáskor meghívja a DestroyWindow-t. Ha a felhasználó soha nem zárja be így a párbeszédpanelt, az alkalmazásnak meg kell hívnia DestroyWindow.

DestroyWindow érvényteleníti az ablakfogópontot a párbeszédpanelen, így a leírót használó függvények későbbi hívásai hibaértékeket ad vissza. A hibák elkerülése érdekében a párbeszédpanel-eljárásnak értesítenie kell a tulajdonost arról, hogy a párbeszédpanel megsemmisült. Számos alkalmazás tart fenn egy globális változót, amely tartalmazza a párbeszédpanelhez tartozó fogópontot. Ha a párbeszédpanel-eljárás megsemmisíti a párbeszédpanelt, a globális változót is null állítja be, ami azt jelzi, hogy a párbeszédpanel már nem érvényes.

A párbeszédpanel-eljárás nem hívhatja meg az EndDialog függvényt egy modelless párbeszédpanel lezárásához.

Párbeszédpanelsablonok

A párbeszédpanelsablonok bináris adatok, amelyek ismertetik a párbeszédpanelt, meghatározva annak magasságát, szélességét, stílusát és a benne található vezérlőket. Párbeszédpanel létrehozásához a rendszer betölt egy párbeszédpanelsablont az alkalmazás végrehajtható fájljában lévő erőforrásokból, vagy az alkalmazás által a globális memóriában átadott sablont használja. Az alkalmazásnak mindkét esetben meg kell adnia egy sablont egy párbeszédpanel létrehozásakor.

A fejlesztő sablonerőforrásokat hoz létre egy erőforrás-fordítóval vagy egy párbeszédpanel-szerkesztővel. Az erőforrás-fordító egy szöveges leírást bináris erőforrássá alakít át, a párbeszédpanel-szerkesztő pedig bináris erőforrásként menti az interaktívan létrehozott párbeszédpaneleket.

Jegyzet

A sablonerőforrások létrehozásának és az alkalmazás végrehajtható fájlhoz való hozzáadásának magyarázata meghaladja az áttekintés hatókörét. A sablonerőforrások létrehozásáról és végrehajtható fájlhoz való hozzáadásáról az alkalmazásfejlesztési eszközök dokumentációjában talál további információt.

 

Ha sablonerőforrások használata nélkül szeretne párbeszédpanelt létrehozni, létre kell hoznia egy sablont a memóriában, és át kell adnia azt a CreateDialogIndirectParam vagy DialogBoxIndirectParam függvénynek, vagy a CreateDialogIndirect vagy DialogBoxIndirect makrónak.

A memória párbeszédpanelsablonja egy, a párbeszédpanelt leíró fejlécből áll, amelyet egy vagy több további adatblokk követ, amely a párbeszédpanel egyes vezérlőinek leírását tartalmazza. A sablon a szabványos vagy a kiterjesztett formátumot is használhatja. A standard sablonban a fejléc egy DLGTEMPLATE szerkezet, amelyet további változó hosszúságú tömbök követnek; és az egyes vezérlők adatai egy DLGITEMTEMPLATE struktúrából állnak, amelyet további változó hosszúságú tömbök követnek. Bővített párbeszédpanelsablonban a fejléc a DLGTEMPLATEEX formátumot használja, a vezérlődefiníciók pedig a DLGITEMTEMPLATEEX formátumot használják.

Memóriasablont úgy hozhat létre, hogy kioszt egy globális memóriaobjektumot, és kitölti a szabványos vagy kiterjesztett fejléc- és vezérlődefiníciókkal. A memóriasablonok formában és tartalomban megegyeznek egy sablonerőforrással. Sok memóriasablont használó alkalmazás először a LoadResource függvénnyel tölt be egy sablonerőforrást a memóriába, majd módosítja a betöltött erőforrást egy új memóriasablon létrehozásához. További információ a párbeszédpanelsablonok memóriában való létrehozásáról: Memóriasablonok.

A következő szakaszok a párbeszédpanelsablonokban használt stílusokat, mértékeket és egyéb értékeket ismertetik.

Párbeszédpanel-sablonstílusok

Minden párbeszédpanelsablon stílusértékek kombinációját adja meg, amelyek meghatározzák a párbeszédpanel megjelenését és funkcióit. A stílusértékek lehetnek ablakstílusok, például WS_POPUP és WS_SYSMENU, valamint párbeszédpanel-stílusok, például DS_MODALFRAME. A sablon stílusainak száma és típusa a párbeszédpanel típusától és céljától függ. Az értékek listáját a párbeszédpanelstílusokcímű témakörben találja.

A rendszer átadja a sablonban megadott összes ablakstílust a CreateWindowEx függvénynek a párbeszédpanel létrehozásakor. A rendszer a megadott párbeszédpanel-stílusoktól függően egy vagy több kiterjesztett stílust is átadhat. Ha például a sablon DS_MODALFRAMEad meg, a rendszer WS_EX_DLGMODALFRAME használ a párbeszédpanel létrehozásakor.

A legtöbb párbeszédpanel előugró ablak, amely ablakmenüvel és címsorral rendelkezik. Ezért a tipikus sablon a WS_POPUP, WS_SYSMENUés WS_CAPTION stílusokat határozza meg. A sablon egy szegélystílust is meghatároz: WS_BORDER a modell nélküli párbeszédpanelekhez, a modális párbeszédpanelekhez pedig egy szegélystílust is meghatároz: DS_MODALFRAME. A sablon az előugró ablaktól eltérő ablaktípust (például WS_OVERLAPPED) is megadhat, ha párbeszédpanel helyett testreszabott ablakot hoz létre.

A rendszer mindig megjelenít egy modális párbeszédpanelt, függetlenül attól, hogy a WS_VISIBLE stílus meg van-e adva. Amikor egy modeless párbeszédpanel sablonja megadja a WS_VISIBLE stílust, a rendszer automatikusan megjeleníti a párbeszédpanelt a létrehozáskor. Ellenkező esetben az alkalmazás feladata a párbeszédpanel megjelenítése a ShowWindow függvénnyel.

Párbeszédpanel mérései

Minden párbeszédpanelsablon olyan mértékeket tartalmaz, amelyek meghatározzák a párbeszédpanel helyét, szélességét és magasságát, valamint a benne található vezérlőket. Ezek a mérések eszközfüggetlenek, így az alkalmazások egyetlen sablonnal hozhatják létre ugyanazt a párbeszédpanelt minden megjelenítési eszköztípushoz. Ez biztosítja, hogy a párbeszédpanelek a különböző felbontások és a képernyők közötti méretarányok ellenére minden képernyőn azonos arányokkal és megjelenéssel rendelkezzenek.

A párbeszédpanelsablonok mérései a párbeszédpanel-sablonegységekben vannak megadva. A párbeszédpanel-sablonegységek méréseinek képernyőegységekké (képpontokká) alakításához használja a MapDialogRect függvényt, amely figyelembe veszi a párbeszédpanel által használt betűtípust, és helyesen konvertál egy téglalapot a párbeszédpanel-sablonegységekből képpontokká. A rendszer betűtípusát használó párbeszédpanelek esetében a GetDialogBaseUnits függvénnyel saját maga hajthatja végre a konvertálási számításokat, bár a MapDialogRect használata egyszerűbb.

A sablonnak meg kell adnia a párbeszédpanel bal felső sarkának kezdeti koordinátáit. A koordináták általában a tulajdonosi ablak ügyfélterületének bal felső sarkához vannak viszonyítva. Ha a sablon megadja a DS_ABSALIGN stílust, vagy a párbeszédpanel nem rendelkezik tulajdonossal, a pozíció a képernyő bal felső sarkához viszonyítva van. A rendszer beállítja ezt a kezdeti pozíciót a párbeszédpanel létrehozásakor, de lehetővé teszi, hogy az alkalmazás a párbeszédpanel megjelenítése előtt módosítsa a pozíciót. Egy alkalmazás például lekérheti a tulajdonosi ablak méreteit, kiszámíthat egy új pozíciót, amely a tulajdonos ablakában lévő párbeszédpanelt középre állítja, majd a SetWindowPos függvénnyel állíthatja be a pozíciót.

A sablonnak meg kell adnia egy párbeszédpanel szélességét és magasságát, amely nem haladja meg a képernyő szélességét és magasságát, és biztosítja, hogy minden vezérlő a párbeszédpanel ügyfélterületén belül legyen. Bár a rendszer bármilyen méretű párbeszédpanelt engedélyez, a túl kicsi vagy túl nagy párbeszédpanel létrehozása megakadályozhatja a felhasználót abban, hogy bemenetet adjon meg, és ezzel a párbeszédpanel célját nem tudja megakadályozni. Sok alkalmazás több párbeszédpanelt használ, ha nagy számú vezérlő van. Ilyen esetekben a kezdeti párbeszédpanel általában egy vagy több gombot tartalmaz, amelyet a felhasználó a következő párbeszédpanel megjelenítéséhez választhat.

Párbeszédpanel-vezérlők

A sablon a párbeszédpanel minden vezérlőeleméhez megadja a pozíciót, a szélességet, a magasságot, a stílust, az azonosítót és az ablakosztályt. A rendszer úgy hozza létre az egyes vezérlők létrehozását, hogy ezeket az adatokat átadja a CreateWindowEx függvénynek. A vezérlők a sablonban megadott sorrendben jönnek létre. A sablonnak meg kell adnia a vezérlők megfelelő számát, típusát és sorrendjét, hogy a felhasználó meg tudja adni a párbeszédpanelhez társított feladat elvégzéséhez szükséges bemenetet.

A sablon minden vezérlőelemhez olyan stílusértékeket határoz meg, amelyek meghatározzák a vezérlő megjelenését és működését. Minden vezérlő gyermekablak, ezért WS_CHILD stílussal kell rendelkeznie. Annak érdekében, hogy a vezérlő látható legyen a párbeszédpanel megjelenésekor, minden vezérlőnek WS_VISIBLE stílust is tartalmaznia kell. Az egyéb gyakran használt ablakstílusok WS_BORDER az opcionális szegélyekkel rendelkező vezérlőkhöz, WS_DISABLED a párbeszédpanel létrehozásakor letiltandó vezérlőkhöz, valamint WS_TABSTOP és WS_GROUP a billentyűzettel elérhető vezérlőkhöz. A WS_TABSTOP és WS_GROUP stílusok a témakör későbbi részében ismertetett párbeszédpanel-billentyűzetfelülettel együtt használhatók.

A sablon a vezérlő ablakosztályára jellemző vezérlőstílusokat is megadhat. Egy gombvezérlőt meghatározó sablonnak például gombvezérlési stílust kell megadnia, például BS_PUSHBUTTON vagy BS_CHECKBOX. A rendszer az WM_CREATE üzeneten keresztül továbbítja a vezérlőstílusokat a vezérlőablak eljárásának, lehetővé téve az eljárásnak, hogy a vezérlő megjelenését és működését módosítsa.

A rendszer képpontokká alakítja a pozíciókoordinátákat, valamint a szélesség- és magasságméréseket a párbeszédpanel alapegységeiből, mielőtt továbbadná őket CreateWindowEx. Amikor a rendszer létrehoz egy vezérlőt, a párbeszédpanelt adja meg szülőablakként. Ez azt jelenti, hogy a rendszer mindig ügyfélkoordinátaként értelmezi a vezérlő pozíciókoordinátáit a párbeszédpanel ügyfélterületének bal felső sarkához képest.

A sablon az egyes vezérlők ablakosztályát határozza meg. Egy tipikus párbeszédpanel az előre definiált vezérlőablak-osztályokhoz tartozó vezérlőket tartalmazza, például a gombot és a vezérlőablakosztályok szerkesztését. Ebben az esetben a sablon az osztályokhoz tartozó előre definiált atomértékek megadásával adja meg az ablakosztályokat. Ha egy párbeszédpanel egy egyéni vezérlőablak-osztályhoz tartozó vezérlőt tartalmaz, a sablon megadja a regisztrált ablakosztály nevét vagy a névhez jelenleg társított atomértéket.

A párbeszédpanel minden vezérlőjének egyedi azonosítóval kell rendelkeznie, hogy megkülönböztesse a többi vezérlőtől. A vezérlők WM_COMMAND üzeneteken keresztül küldenek információkat a párbeszédpanel-eljárásnak, így a vezérlőazonosítók elengedhetetlenek ahhoz, hogy az eljárás meghatározza, melyik vezérlő küldött egy adott üzenetet. A szabály egyetlen kivétele a statikus vezérlők vezérlőazonosítói. A statikus vezérlők nem igényelnek egyedi azonosítókat, mert nem küldenek WM_COMMAND üzeneteket.

Ahhoz, hogy a felhasználó bezárhassa a párbeszédpanelt, a sablonnak meg kell adnia legalább egy nyomógombot, és a vezérlő azonosítót IDCANCEL. Ha lehetővé szeretné tenni a felhasználó számára, hogy a párbeszédpanelhez társított feladat elvégzése vagy megszakítása között válasszon, a sablonnak két leküldéses gombot kell megadnia, amelyek OK és Mégsecímkével vannak ellátva, és a IDOK és IDCANCELvezérlőazonosítóit kell megadnia.

A sablon emellett opcionális szöveget és létrehozási adatokat is meghatároz egy vezérlőhöz. A szöveg általában feliratokat biztosít a gombvezérlőkhöz, vagy megadja egy statikus szövegvezérlő kezdeti tartalmát. A létrehozási adatok egy vagy több bájtnyi adat, amelyet a rendszer a vezérlő létrehozásakor továbbít a vezérlőablak eljárásának. A létrehozási adatok olyan vezérlők esetében hasznosak, amelyek a többi adatnál több információt igényelnek a kezdeti tartalomról vagy stílusról. Az alkalmazások például létrehozási adatokkal állíthatják be a görgetősáv-vezérlők kezdeti beállítását és tartományát.

Párbeszédpanel ablak menüje

A rendszer ablak menüjét adja a párbeszédpanelnek, amikor a sablon megadja a WS_SYSMENU stílust. A nem megfelelő bevitel megakadályozása érdekében a rendszer automatikusan letiltja a menü összes elemét, kivéve áthelyezése és bezárása. A felhasználó a párbeszédpanel áthelyezéséhez kattintson az Áthelyezés gombra. Amikor a felhasználó a Bezárásgombra kattint, a rendszer egy WM_COMMAND üzenetet küld a párbeszédpanel eljárásának, a wParam paramétert IDCANCELértékre állítva. Ez megegyezik a Mégse gomb által küldött üzenetével, amikor a felhasználó rá kattint. Az üzenet ajánlott művelete a párbeszédpanel bezárása és a kért feladat megszakítása.

Bár a párbeszédpanelek más menüi nem ajánlottak, a párbeszédpanelsablonok megadhatnak egy menüt egy menüerőforrás azonosítójának vagy nevének megadásával. Ebben az esetben a rendszer betölti az erőforrást, és létrehozza a párbeszédpanel menüjét. Az alkalmazások általában menüazonosítókat vagy neveket használnak a sablonokban, amikor a sablonokkal párbeszédpanelek helyett egyéni ablakokat hoznak létre.

Párbeszédpanel betűtípusai

A rendszer a párbeszédpanel betűtípusának átlagos karakterszélességével számítja ki a párbeszédpanel pozícióját és méreteit. A rendszer alapértelmezés szerint az SYSTEM_FONT betűtípussal rajzolja meg a párbeszédpanel összes szövegét.

Ha nem alapértelmezett betűtípust szeretne megadni egy párbeszédpanelhez, párbeszédpanelsablon használatával kell létrehoznia a párbeszédpanelt. Sablonerőforrásban használja a FONT utasítást. Egy párbeszédpanelsablonban állítsa be a DS_SETFONT vagy DS_SHELLFONT stílust, és adjon meg egy pontméretet és egy betűképnevet. Még akkor is, ha egy párbeszédpanelsablon ilyen módon határoz meg betűtípust, a rendszer mindig a rendszer betűtípusát használja a párbeszédpanel címéhez és a párbeszédpanel menüjéhez.

Ha a párbeszédpanel DS_SETFONT vagy DS_SHELLFONT stílussal rendelkezik, a rendszer a vezérlő létrehozásakor WM_SETFONT üzenetet küld a párbeszédpanel eljárásának és minden vezérlőnek. A párbeszédpanel-eljárás feladata a WM_SETFONT üzenettel átadott betűtípus-leíró mentése, és a leíró kijelölése a megjelenítési eszköz környezetébe, amikor szöveget ír az ablakba. Az előre definiált vezérlők alapértelmezés szerint ezt teszik.

A rendszer betűtípusa a Windows különböző verzióiban eltérő lehet. Ha azt szeretné, hogy az alkalmazás a rendszer betűtípusát használja, függetlenül attól, hogy melyik rendszeren fut, használja DS_SHELLFONT az MS Shell Dlg betűtípussal, és használja a DIALOGEX erőforrás a DIALOG-erőforráshelyett. A rendszer úgy képezi le ezt a betűtípust, hogy a párbeszédpanel a Tahoma betűtípust használja. Vegye figyelembe, hogy DS_SHELLFONT nincs hatása, ha a betűtípus nem MS Shell Dlg.

Sablonok a memóriában

A memória párbeszédpanelsablonja egy, a párbeszédpanelt leíró fejlécből áll, amelyet egy vagy több további adatblokk követ, amely a párbeszédpanel egyes vezérlőinek leírását tartalmazza. A sablon a szabványos vagy a kiterjesztett formátumot is használhatja. Egy standard sablonban a fejléc egy DLGTEMPLATE szerkezet, amelyet további változó hosszúságú tömbök követnek. Az egyes vezérlők adatai egy DLGITEMPLATE struktúrából állnak, amelyet további változó hosszúságú tömbök követnek. Bővített párbeszédpanelsablonban a fejléc a DLGTEMPLATEEX formátumot használja, a vezérlődefiníciók pedig a DLGITEMTEMPLATEEX formátumot használják.

Ha meg szeretne különböztetni egy szabványos sablont és egy kiterjesztett sablont, ellenőrizze a párbeszédpanel-sablon első 16 bites részét. Bővített sablonban az első WORD- 0xFFFF; bármely más érték egy szabványos sablont jelöl.

Ha párbeszédpanelsablont hoz létre a memóriában, győződjön meg arról, hogy a DLGITEMTEMPLATE vagy DLGITEMTEMPLATEEX vezérlődefiníciók igazodnak DWORD határaihoz. Ezenkívül a vezérlődefiníciót követő létrehozási adatokat egy DWORD határhoz kell igazítani. A párbeszédpanelsablon összes többi változó hosszúságú tömbjének hozzá kell igazodnia WORD határaihoz.

Sablonfejléc

A párbeszédpanelek szabványos és bővített sablonjaiban a fejléc a következő általános információkat tartalmazza:

  • A párbeszédpanel helye és méretei
  • A párbeszédpanel ablak- és párbeszédpanelstílusai
  • A párbeszédpanel vezérlőinek száma. Ez az érték határozza meg a DLGITEMPLATE vagy DLGITEMTEMPLATEEX vezérlődefiníciók számát a sablonban.
  • A párbeszédpanel választható menüerőforrása. A sablon jelezheti, hogy a párbeszédpanelen nincs menü, vagy megadhat egy sorszámértéket vagy null értékű Unicode-sztringet, amely egy végrehajtható fájl menüerőforrását azonosítja.
  • A párbeszédpanel ablakosztálya. Ez lehet az előre definiált párbeszédpanel-osztály, vagy egy sorszámérték vagy null értékű Unicode-sztring, amely egy regisztrált ablakosztályt azonosít.
  • Null értékű Unicode-sztring, amely megadja a párbeszédpanel ablakának címét. Ha a sztring üres, a párbeszédpanel címsora üres. Ha a párbeszédpanel nem rendelkezik a WS_CAPTION stílusával, a rendszer a címet a megadott sztringre állítja, de nem jeleníti meg.
  • Ha a párbeszédpanel DS_SETFONT stílussal rendelkezik, a fejléc az ügyfélterület szövegéhez és a párbeszédpanel vezérlőihez használandó betűtípus pontméretét és betűformázási nevét adja meg.

Kiterjesztett sablonban a DLGTEMPLATEEX fejléce a következő további információkat is megadja:

  • A párbeszédpanel ablakának súgókörnyezet-azonosítója, amikor a rendszer WM_HELP üzenetet küld.
  • Ha a párbeszédpanel DS_SETFONT vagy DS_SHELLFONT stílussal rendelkezik, a fejléc megadja a betűvastagságot, és azt is jelzi, hogy a betűtípus dőlt-e.

Vezérlődefiníciók

A sablonfejlécet követően egy vagy több vezérlődefiníció következik, amelyek leírják a párbeszédpanel vezérlőit. A szabványos és a kiterjesztett sablonokban a párbeszédpanel fejlécének egy olyan tagja van, amely a sablon vezérlődefinícióinak számát jelzi. Egy standard sablonban minden vezérlődefiníció egy DLGITEMTEMPLATE struktúrából áll, amelyet további változó hosszúságú tömbök követnek. Kiterjesztett sablonban a vezérlődefiníciók a DLGITEMTEMPLATEEX formátumot használják.

A standard és a kiterjesztett sablonokban a vezérlődefiníció a következő információkat tartalmazza:

  • A vezérlő helye és méretei.
  • A vezérlő ablak- és vezérlési stílusai.
  • A vezérlő azonosítója.
  • A vezérlő ablakosztálya. Ez lehet egy előre definiált rendszerosztály vagy egy null értékű Unicode-sztring sorszáma, amely egy regisztrált ablakosztály nevét adja meg.
  • Null értékű Unicode-sztring, amely megadja a vezérlő kezdeti szövegét, vagy egy olyan sorszámérték, amely egy végrehajtható fájlban egy erőforrást( például ikont) azonosít.
  • A létrehozási adatok nem kötelező változó hosszúságú blokkja. Amikor a rendszer létrehozza a vezérlőt, a vezérlőnek küldött WM_CREATE üzenet lParam paraméterében mutatót ad át ezekre az adatokra.

A kiterjesztett sablonban a vezérlődefiníció a vezérlő súgókörnyezet-azonosítóját is megadja, amikor a rendszer WM_HELP üzenetet küld.