Az asztali alkalmazás eszköztárainak használata
Az alkalmazás asztali eszköztára (más néven appbar) a Windows tálcához hasonló ablak. A képernyő egy széléhez van rögzítve, és általában olyan gombokat tartalmaz, amelyek gyors hozzáférést biztosítanak a felhasználónak más alkalmazásokhoz és ablakokhoz. A rendszer megakadályozza, hogy más alkalmazások az alkalmazássáv által használt asztali területet használják. Tetszőleges számú alkalmazássáv létezhet az asztalon bármikor.
Ez a témakör a következő szakaszokat tartalmazza.
- Az alkalmazás asztali eszköztárai
- Alkalmazás asztali eszköztárának regisztrálása
- Appbar méretének és pozíciójának beállítása
- Értesítési üzenetek feldolgozása az Appbarban
Tudnivalók az asztali alkalmazás eszköztárairól
A Windows olyan API-t biztosít, amellyel kihasználhatja a rendszer által biztosított appbar-szolgáltatásokat. A szolgáltatások segítségével biztosítható, hogy az alkalmazás által definiált alkalmazássávok zökkenőmentesen működjenek egymással és a tálcával. A rendszer fenntartja az egyes appbarok adatait, és elküldi az appbars-üzeneteket, hogy értesítést küldjön nekik a méretüket, pozíciójukat és megjelenésüket befolyásoló eseményekről.
Üzenetek küldése
Az alkalmazások speciális üzenetkészletet, úgynevezett appbar-üzeneteket használnak az appbarok hozzáadásához vagy eltávolításához, az appbar méretének és pozíciójának beállításához, valamint a tálca méretével, helyzetével és állapotával kapcsolatos információk lekéréséhez. Alkalmazássávüzenet küldéséhez az alkalmazásnak az SHAppBarMessage függvényt kell használnia. A függvény paraméterei közé tartozik egy üzenetazonosító, például ABM_NEW, valamint egy APPBARDATA-struktúra címe. A struktúratagok olyan információkat tartalmaznak, amelyeket a rendszernek fel kell dolgoznia az adott üzenetben.
Egy adott appbar-üzenet esetén a rendszer a APPBARDATA struktúrájának egyes tagjait használja, és figyelmen kívül hagyja a többit. A rendszer azonban mindig a cbSize és hWnd tagokat használja, így az alkalmazásnak minden appbar üzenethez ki kell töltenie ezeket a tagokat. A cbSize tag határozza meg a struktúra méretét, a hWnd tag pedig az appbar ablakának fogópontja.
Egyes appbar-üzenetek információt kérnek a rendszertől. Az üzenetek feldolgozásakor a rendszer a kért adatokat a APPBARDATA struktúrába másolja.
Regisztráció
A rendszer megőrzi az appbarok belső listáját, és megőrzi a lista egyes sávjaival kapcsolatos információkat. A rendszer az információkat az appbarok kezelésére, szolgáltatások végrehajtására és értesítési üzenetek küldésére használja.
Az alkalmazásnak regisztrálnia kell egy appbart (azaz fel kell vennie a belső listára), mielőtt appbar-szolgáltatásokat fogadhat a rendszertől. Alkalmazássáv regisztrálásához az alkalmazás elküldi a ABM_NEW üzenetet. A mellékelt APPBARDATA struktúra tartalmazza az appbar ablakának leíróját és egy alkalmazás által definiált üzenetazonosítót. A rendszer az üzenetazonosítóval küldi el az értesítési üzeneteket az appbar ablakának eljárásába. További információért lásd: Appbar értesítési üzenetek.
Az alkalmazás a ABM_REMOVE üzenet elküldésével megszünteti az alkalmazássáv regisztrációját. Az alkalmazássáv regisztrációjának megszüntetése eltávolítja azt a rendszer alkalmazássávjainak belső listájából. A rendszer többé nem küld értesítési üzeneteket az appbarnak, és nem akadályozza meg, hogy más alkalmazások használják az appbar által használt képernyőterületet. Az alkalmazásnak mindig ABM_REMOVE kell küldenie, mielőtt megsemmisítené az alkalmazássávot.
Az appbar mérete és pozíciója
Az alkalmazásnak úgy kell beállítania az alkalmazássáv méretét és pozícióját, hogy az ne zavarja a többi appbart vagy tálcát. Minden alkalmazássávot a képernyő egy adott széléhez kell rögzíteni, és több appbar is rögzíthető egy élhez. Ha azonban egy appbar a tálcával azonos élhez van rögzítve, a rendszer biztosítja, hogy a tálca mindig a legkülső élen legyen.
Az alkalmazássáv méretének és pozíciójának beállításához az alkalmazás először egy képernyőszélt és egy határoló téglalapot javasol az alkalmazássávhoz az ABM_QUERYPOS üzenet elküldésével. A rendszer meghatározza, hogy a javasolt téglalapon belüli képernyőterület bármely részét használja-e a tálca vagy egy másik appbar, módosítja a téglalapot (ha szükséges), és visszaadja a beállított téglalapot az alkalmazásnak.
Ezután az alkalmazás elküldi a ABM_SETPOS üzenetet az alkalmazássáv új határolókeretének beállításához. A rendszer ismét módosíthatja a téglalapot, mielőtt visszaküldené azt az alkalmazásnak. Ezért az alkalmazásnak a ABM_SETPOS által visszaadott igazított téglalapot kell használnia a végső méret és pozíció beállításához. Az alkalmazás a MoveWindow függvénnyel helyezheti át az appbart a pozícióba.
A méret és a pozíció kétlépéses beállításával a rendszer lehetővé teszi, hogy az alkalmazás köztes visszajelzést küldjön a felhasználónak az áthelyezési művelet során. Ha például a felhasználó húz egy appbart, az alkalmazás megjeleníthet egy árnyékolt téglalapot, amely jelzi az új pozíciót, mielőtt az appbar ténylegesen áthelyezné.
Az alkalmazásnak a regisztráció után és minden alkalommal meg kell állítania az alkalmazássáv méretét és pozícióját, amikor az appbar megkapja a ABN_POSCHANGED értesítési üzenetet. Az appbar ezt az értesítési üzenetet kapja, amikor változás történik a tálca méretében, pozíciójában vagy láthatósági állapotában, és amikor a képernyő ugyanazon oldalán egy másik appbart átméreteznek, hozzáadnak vagy eltávolítanak.
Amikor egy appbar megkapja a WM_ACTIVATE üzenetet, el kell küldenie a ABM_ACTIVATE üzenetet. Hasonlóképpen, amikor egy appbar WM_WINDOWPOSCHANGED üzenetet kap, meg kell hívnia ABM_WINDOWPOSCHANGED. Ezeknek az üzeneteknek az elküldése biztosítja, hogy a rendszer megfelelően beállítsa az automatikusan megjelenő appbarok z-sorrendjét ugyanazon a peremhálózaton.
Alkalmazás asztali eszköztárainak automatikus elrejtése
Az automatikusan elrejtett alkalmazássáv általában rejtett, de akkor válik láthatóvá, ha a felhasználó az egérmutatót arra a képernyő szélére helyezi, amelyhez az appbar társítva van. Az appbar ismét elrejti magát, amikor a felhasználó az egérmutatót a sáv határoló téglalapján kívülre helyezi.
Bár a rendszer egyszerre több különböző appbart is lehetővé tesz, minden képernyő szegélyhez egyszerre csak egy automatikusan elrejtődő appbart engedélyez, érkezési sorrendben. A rendszer automatikusan fenntartja az automatikusan elrejtő alkalmazássáv z-sorrendjét (csak a saját z-sorrendi csoportján belül).
Egy alkalmazás az ABM_SETAUTOHIDEBAR üzenet használatával regisztrál vagy töröl egy automatikusan megjelenő alkalmazássávot. Az üzenet megadja az alkalmazássáv szélét, és egy jelölőt, amely meghatározza, hogy az appbar regisztrálva vagy regisztráció nélkül legyen-e regisztrálva. Az üzenet meghiúsul, ha egy automatikusan megjelenő appbar regisztrálva van, de egy már társítva van a megadott élhez. Egy alkalmazás a ABM_GETAUTOHIDEBAR üzenet elküldésével lekérheti az élhez társított automatikusan elrejtő alkalmazássáv azonosítóját.
Az automatikusan felfedett alkalmazássávnak nem kell normál alkalmazássávként regisztrálnia; vagyis nem kell regisztrálnia a ABM_NEW üzenet elküldésével. A ABM_NEW által nem regisztrált appbarok átfedésben vannak a képernyő ugyanazon szélén rögzített appbarokkal.
Appbar értesítési üzenetek
A rendszer üzeneteket küld, amelyek értesítik az alkalmazássávot azokról az eseményekről, amelyek hatással lehetnek a helyzetére és megjelenésére. Az üzeneteket egy alkalmazás által definiált üzenet kontextusában küldi el a rendszer. Az alkalmazás megadja az üzenet azonosítóját, amikor elküldi a ABM_NEW üzenetet az appbar regisztrálásához. Az értesítési kód az alkalmazás által definiált üzenet wParam paraméterében található.
Az alkalmazássáv megkapja a ABN_POSCHANGED értesítési üzenetet, amikor a tálca mérete, pozíciója vagy láthatósági állapota megváltozik, amikor egy másik alkalmazássáv kerül hozzáadásra a képernyő ugyanazon széléhez, vagy amikor a képernyő ugyanazon szélén lévő másik alkalmazássáv átméreteződik vagy eltávolítják. Az alkalmazássávnak ABM_QUERYPOS és ABM_SETPOS üzenetek küldésével kell válaszolnia erre az értesítési üzenetre. Ha egy appbar pozíciója megváltozott, a MoveWindow függvényt kell meghívnia, hogy áthelyezhesse magát az új pozícióba.
A rendszer akkor küldi el a ABN_STATECHANGE értesítési üzenetet, ha a tálca automatikus elrejtése vagy mindig a tetején lévő állapota megváltozott – vagyis amikor a felhasználó kiválasztja vagy törli a Mindig a Tetején vagy Automatikus Elrejtése jelölőnégyzetet a tálca tulajdonságlapján. Az appbarok ezzel az értesítési üzenettel beállíthatják, hogy az állapota megfeleljen a tálca állapotának, ha szükséges.
Teljes képernyős alkalmazás indításakor vagy az utolsó teljes képernyős alkalmazás bezárásakor az alkalmazássáv megkapja a ABN_FULLSCREENAPP értesítési üzenetet. Az lParam paraméter azt jelzi, hogy a teljes képernyős alkalmazás megnyílik vagy bezárul. Ha megnyílik, az appbarnak a z-order aljára kell kerülnie. Az alkalmazássávnak vissza kell állítania a z-order pozícióját, amikor az utolsó teljes képernyős alkalmazás bezárult.
Az alkalmazássáv megkapja a ABN_WINDOWARRANGE értesítési üzenetet, amikor a felhasználó kiválasztja a Cascade, a Tile Horizontally vagy a Tile Vertically parancsot a tálca helyi menüjéből. A rendszer kétszer küldi el az üzenetet , mielőtt átrendezi az ablakokat (lParamIGAZ), majd az ablakok rendezése után (lParamHAMIS).
Az alkalmazássáv kizárhatja magát a kaszkádolt vagy csempe műveletből a ABN_WINDOWARRANGE üzenetek használatával. Az appbarnak el kell rejtenie magát, ha a lParam értéke igaz, és meg kell jelennie, ha a lParam értéke hamis. Ha egy appbar elrejti magát az üzenetre adott válaszként, nem kell elküldenie a ABM_QUERYPOS és ABM_SETPOS üzeneteket a kaszkád vagy csempe műveletre válaszul.
Alkalmazás asztali eszköztárának regisztrálása
Az alkalmazásnak regisztrálnia kell egy alkalmazássávot a ABM_NEW üzenet elküldésével. Az appbar regisztrálása hozzáadja azt a rendszer belső listájához, és egy üzenetazonosítót biztosít a rendszernek, amellyel értesítési üzeneteket küldhet az appbarnak. A kilépés előtt az alkalmazásnak meg kell szüntetnie az alkalmazássáv regisztrációját a ABM_REMOVE üzenet elküldésével. A regisztráció megszüntetése eltávolítja az appbart a rendszer belső listájából, és megakadályozza, hogy a sáv értesítést kapjon az appbar értesítéseiről.
Az alábbi példában szereplő függvény regisztrál vagy töröl egy alkalmazássávot a logikai jelző paraméter értékétől függően.
// RegisterAccessBar - registers or unregisters an appbar.
// Returns TRUE if successful, or FALSE otherwise.
// hwndAccessBar - handle to the appbar
// fRegister - register and unregister flag
// Global variables
// g_uSide - screen edge (defaults to ABE_TOP)
// g_fAppRegistered - flag indicating whether the bar is registered
BOOL RegisterAccessBar(HWND hwndAccessBar, BOOL fRegister)
{
APPBARDATA abd;
// An application-defined message identifier
APPBAR_CALLBACK = (WM_USER + 0x01);
// Specify the structure size and handle to the appbar.
abd.cbSize = sizeof(APPBARDATA);
abd.hWnd = hwndAccessBar;
if (fRegister)
{
// Provide an identifier for notification messages.
abd.uCallbackMessage = APPBAR_CALLBACK;
// Register the appbar.
if (!SHAppBarMessage(ABM_NEW, &abd))
return FALSE;
g_uSide = ABE_TOP; // default edge
g_fAppRegistered = TRUE;
}
else
{
// Unregister the appbar.
SHAppBarMessage(ABM_REMOVE, &abd);
g_fAppRegistered = FALSE;
}
return TRUE;
}
Az appbar méretének és pozíciójának beállítása
Az alkalmazásnak az appbar regisztrálása után, miután a felhasználó áthelyezi vagy átméretezi az appbart, és amikor az appbar megkapja a ABN_POSCHANGED értesítési üzenetet, be kell állítania az alkalmazássáv méretét és pozícióját. Mielőtt beállítja az appbar méretét és elhelyezkedését, az alkalmazás a rendszerhez fordul egy jóváhagyott határoló téglalap kérésével, amit a ABM_QUERYPOS üzenet elküldésével tesz meg. A rendszer egy határoló téglalapot ad vissza, amely nem zavarja a tálcát vagy bármely más alkalmazási sávot. A rendszer a téglalapot csak téglalap kivonásával állítja be; nem törekszik a téglalap kezdeti méretének megőrzésére. Ezért az appbarnak szükség szerint újra kell igazítania a téglalapot a ABM_QUERYPOSelküldése után.
Ezután az alkalmazás a ABM_SETPOS üzenettel visszaküldi a határolókeretet a rendszernek. Ezután meghívja a MoveWindow függvényt az appbar helyzetének áthelyezéséhez.
Az alábbi példa bemutatja, hogyan állíthatja be az appbar méretét és pozícióját.
// AppBarQuerySetPos - sets the size and position of an appbar.
// uEdge - screen edge to which the appbar is to be anchored
// lprc - current bounding rectangle of the appbar
// pabd - address of the APPBARDATA structure with the hWnd and cbSize members filled
void PASCAL AppBarQuerySetPos(UINT uEdge, LPRECT lprc, PAPPBARDATA pabd)
{
int iHeight = 0;
int iWidth = 0;
pabd->rc = *lprc;
pabd->uEdge = uEdge;
// Copy the screen coordinates of the appbar's bounding
// rectangle into the APPBARDATA structure.
if ((uEdge == ABE_LEFT) || (uEdge == ABE_RIGHT))
{
iWidth = pabd->rc.right - pabd->rc.left;
pabd->rc.top = 0;
pabd->rc.bottom = GetSystemMetrics(SM_CYSCREEN);
}
else
{
iHeight = pabd->rc.bottom - pabd->rc.top;
pabd->rc.left = 0;
pabd->rc.right = GetSystemMetrics(SM_CXSCREEN);
}
// Query the system for an approved size and position.
SHAppBarMessage(ABM_QUERYPOS, pabd);
// Adjust the rectangle, depending on the edge to which the appbar is anchored.
switch (uEdge)
{
case ABE_LEFT:
pabd->rc.right = pabd->rc.left + iWidth;
break;
case ABE_RIGHT:
pabd->rc.left = pabd->rc.right - iWidth;
break;
case ABE_TOP:
pabd->rc.bottom = pabd->rc.top + iHeight;
break;
case ABE_BOTTOM:
pabd->rc.top = pabd->rc.bottom - iHeight;
break;
}
// Pass the final bounding rectangle to the system.
SHAppBarMessage(ABM_SETPOS, pabd);
// Move and size the appbar so that it conforms to the
// bounding rectangle passed to the system.
MoveWindow(pabd->hWnd,
pabd->rc.left,
pabd->rc.top,
pabd->rc.right - pabd->rc.left,
pabd->rc.bottom - pabd->rc.top,
TRUE);
}
Appbar értesítési üzenetek feldolgozása
Az alkalmazássáv értesítést kap, ha a tálca állapota megváltozik, amikor egy teljes képernyős alkalmazás elindul (vagy az utolsó bezáródik), vagy amikor olyan esemény történik, amely befolyásolhatja az alkalmazássáv méretét és pozícióját. Az alábbi példa bemutatja, hogyan dolgozhatja fel a különböző értesítési üzeneteket.
// AppBarCallback - processes notification messages sent by the system.
// hwndAccessBar - handle to the appbar
// uNotifyMsg - identifier of the notification message
// lParam - message parameter
void AppBarCallback(HWND hwndAccessBar, UINT uNotifyMsg,
LPARAM lParam)
{
APPBARDATA abd;
UINT uState;
abd.cbSize = sizeof(abd);
abd.hWnd = hwndAccessBar;
switch (uNotifyMsg)
{
case ABN_STATECHANGE:
// Check to see if the taskbar's always-on-top state has changed
// and, if it has, change the appbar's state accordingly.
uState = SHAppBarMessage(ABM_GETSTATE, &abd);
SetWindowPos(hwndAccessBar,
(ABS_ALWAYSONTOP & uState) ? HWND_TOPMOST : HWND_BOTTOM,
0, 0, 0, 0,
SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
break;
case ABN_FULLSCREENAPP:
// A full-screen application has started, or the last full-screen
// application has closed. Set the appbar's z-order appropriately.
if (lParam)
{
SetWindowPos(hwndAccessBar,
(ABS_ALWAYSONTOP & uState) ? HWND_TOPMOST : HWND_BOTTOM,
0, 0, 0, 0,
SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
}
else
{
uState = SHAppBarMessage(ABM_GETSTATE, &abd);
if (uState & ABS_ALWAYSONTOP)
SetWindowPos(hwndAccessBar,
HWND_TOPMOST,
0, 0, 0, 0,
SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
}
case ABN_POSCHANGED:
// The taskbar or another appbar has changed its size or position.
AppBarPosChanged(&abd);
break;
}
}
Az alábbi függvény módosítja egy appbar határoló téglalapját, majd meghívja az alkalmazás által definiált AppBarQuerySetPos függvényt (amely az előző szakaszban szerepel), hogy ennek megfelelően állítsa be a sáv méretét és pozícióját.
// AppBarPosChanged - adjusts the appbar's size and position.
// pabd - address of an APPBARDATA structure that contains information
// used to adjust the size and position.
void PASCAL AppBarPosChanged(PAPPBARDATA pabd)
{
RECT rc;
RECT rcWindow;
int iHeight;
int iWidth;
rc.top = 0;
rc.left = 0;
rc.right = GetSystemMetrics(SM_CXSCREEN);
rc.bottom = GetSystemMetrics(SM_CYSCREEN);
GetWindowRect(pabd->hWnd, &rcWindow);
iHeight = rcWindow.bottom - rcWindow.top;
iWidth = rcWindow.right - rcWindow.left;
switch (g_uSide)
{
case ABE_TOP:
rc.bottom = rc.top + iHeight;
break;
case ABE_BOTTOM:
rc.top = rc.bottom - iHeight;
break;
case ABE_LEFT:
rc.right = rc.left + iWidth;
break;
case ABE_RIGHT:
rc.left = rc.right - iWidth;
break;
}
AppBarQuerySetPos(g_uSide, &rc, pabd);
}