Verwenden von Anwendungsdesktopsymbolleisten

Eine Anwendungsdesktopsymbolleiste (auch als App-Leiste bezeichnet) ist ein Fenster, das der Windows Taskleiste ähnelt. Er ist an einem Bildschirmrand verankert und enthält in der Regel Schaltflächen, die dem Benutzer schnellen Zugriff auf andere Anwendungen und Fenster ermöglichen. Das System verhindert, dass andere Anwendungen den Desktopbereich verwenden, der von einer App-Leiste verwendet wird. Jede Anzahl von App-Leisten kann jederzeit auf dem Desktop vorhanden sein.

Dieses Thema enthält folgende Abschnitte:

Informationen zu Anwendungsdesktopsymbolleisten

Windows stellt eine API bereit, mit der Sie appbar-Dienste nutzen können, die vom System bereitgestellt werden. Die Dienste helfen, sicherzustellen, dass anwendungsdefinierte App-Leisten reibungslos miteinander und mit der Taskleiste funktionieren. Das System verwaltet Informationen zu jeder App-Leiste und sendet die App-Leistennachrichten, um sie über Ereignisse zu benachrichtigen, die sich auf ihre Größe, Position und Darstellung auswirken können.

Senden von Nachrichten

Eine Anwendung verwendet einen speziellen Satz von Nachrichten, die als App-Leiste bezeichnet werden, um eine App-Leiste hinzuzufügen oder zu entfernen, die Größe und Position einer App-Leiste festzulegen und Informationen über die Größe, Position und den Status der Taskleiste abzurufen. Zum Senden einer App-Leiste muss eine Anwendung die SHAppBarMessage-Funktion verwenden. Die Parameter der Funktion umfassen einen Nachrichtenbezeichner, z. B. ABM_NEW, und die Adresse einer APPBARDATA-Struktur . Die Strukturelemente enthalten Informationen, die das System zum Verarbeiten der angegebenen Nachricht benötigt.

Für jede bestimmte Appleistennachricht verwendet das System einige Member der APPBARDATA-Struktur und ignoriert die anderen. Das System verwendet jedoch immer die cbSize - und hWnd-Member , sodass eine Anwendung diese Member für jede App-Leistennachricht ausfüllen muss. Das cbSize-Element gibt die Größe der Struktur an, und das hWnd-Element ist der Handle für das App-Fenster.

Einige Nachrichten auf der App-Leiste fordern Informationen vom System an. Beim Verarbeiten dieser Nachrichten kopiert das System die angeforderten Informationen in die APPBARDATA-Struktur .

Registrierung

Das System behält eine interne Liste der App-Leisten bei und verwaltet Informationen zu jeder Leiste in der Liste. Das System verwendet die Informationen, um App-Leisten zu verwalten, Dienste für sie auszuführen und Benachrichtigungen zu senden.

Eine Anwendung muss eine App-Leiste registrieren (also der internen Liste hinzufügen), bevor sie App-Leistendienste vom System empfangen kann. Um eine App-Leiste zu registrieren, sendet eine Anwendung die ABM_NEW Nachricht. Die zugehörige APPBARDATA-Struktur enthält das Handle zum Fenster der App-Leiste und einen anwendungsdefinierten Nachrichtenbezeichner. Das System verwendet den Nachrichtenbezeichner, um Benachrichtigungsnachrichten an die Fensterprozedur des Appleistenfensters zu senden. Weitere Informationen finden Sie unter Appbar-Benachrichtigungen.

Eine Anwendung hebt die Registrierung einer App-Leiste auf, indem Sie die ABM_REMOVE Nachricht senden. Wenn Sie die Registrierung einer App-Leiste aufheben, wird sie aus der internen Liste der App-Leisten des Systems entfernt. Das System sendet keine Benachrichtigungen mehr an die App-Leiste oder verhindert, dass andere Anwendungen den Bildschirmbereich verwenden, der von der App-Leiste verwendet wird. Eine Anwendung sollte immer ABM_REMOVE senden, bevor eine App-Leiste zerstört wird.

Größe und Position der App-Leiste

Eine Anwendung sollte die Größe und Position einer App-Leiste festlegen, damit sie keine anderen App-Leisten oder die Taskleiste beeinträchtigt. Jede App-Leiste muss an einem bestimmten Bildschirmrand verankert werden, und mehrere App-Leisten können an einem Rand verankert werden. Wenn jedoch eine App-Leiste an demselben Rand wie die Taskleiste verankert ist, stellt das System sicher, dass sich die Taskleiste immer am äußeren Rand befindet.

Um die Größe und Position einer App-Leiste festzulegen, schlägt eine Anwendung zunächst einen Bildschirmrand und ein Begrenzungsrechteck für die App-Leiste vor, indem die ABM_QUERYPOS Nachricht gesendet wird. Das System bestimmt, ob ein Teil des Bildschirmbereichs innerhalb des vorgeschlagenen Rechtecks von der Taskleiste oder einer anderen App-Leiste verwendet wird, das Rechteck (sofern erforderlich) anpasst und das angepasste Rechteck an die Anwendung zurückgibt.

Als Nächstes sendet die Anwendung die ABM_SETPOS Nachricht, um das neue Begrenzungsrechteck für die App-Leiste festzulegen. Erneut kann das System das Rechteck anpassen, bevor es an die Anwendung zurückgegeben wird. Aus diesem Grund sollte die Anwendung das angepasste Rechteck verwenden, das von ABM_SETPOS zurückgegeben wird, um die endgültige Größe und Position festzulegen. Die Anwendung kann die MoveWindow-Funktion verwenden, um die App-Leiste in die Position zu verschieben.

Mit einem zweistufigen Prozess zum Festlegen der Größe und Position ermöglicht das System der Anwendung, während des Bewegungsvorgangs zwischengeschaltetes Feedback für den Benutzer bereitzustellen. Wenn der Benutzer beispielsweise eine App-Leiste zieht, zeigt die Anwendung möglicherweise ein schattiertes Rechteck an, das die neue Position angibt, bevor die App-Leiste tatsächlich verschoben wird.

Eine Anwendung sollte die Größe und Position der App-Leiste nach der Registrierung festlegen und wann immer die App-Benachrichtigung die ABN_POSCHANGED Benachrichtigung empfängt. Eine App-Leiste empfängt diese Benachrichtigung, wenn eine Änderung in der Größe, Position oder Sichtbarkeit der Taskleiste auftritt und wann immer eine andere App-Leiste auf derselben Seite des Bildschirms geändert, hinzugefügt oder entfernt wird.

Wenn eine App-Leiste die WM_ACTIVATE Nachricht empfängt, sollte sie die ABM_ACTIVATE Nachricht senden. Ebenso muss eine App-Leiste eine WM_WINDOWPOSCHANGED Nachricht empfangen, ABM_WINDOWPOSCHANGED aufrufen. Durch das Senden dieser Nachrichten wird sichergestellt, dass das System die Z-Reihenfolge aller automatischen App-Leisten am gleichen Rand ordnungsgemäß festlegt.

Automatisches Aktivieren von Anwendungsdesktopsymbolleisten

Eine Autohide-Appleiste ist eine, die normalerweise ausgeblendet ist, aber sichtbar wird, wenn der Benutzer den Mauszeiger an den Bildschirmrand verschiebt, mit dem die App-Leiste verknüpft ist. Die App-Leiste blendet sich erneut aus, wenn der Benutzer den Mauszeiger aus dem umgebenden Rechteck der Leiste verschiebt.

Obwohl das System eine Reihe unterschiedlicher App-Leisten zu einem bestimmten Zeitpunkt zulässt, ermöglicht es jeweils nur eine automatische App-Leiste für jeden Bildschirmrand, der zuerst bereitgestellt wird. Das System verwaltet automatisch die Z-Reihenfolge einer Autohide-App-Leiste (nur innerhalb der Z-Reihenfolge-Gruppe).

Eine Anwendung verwendet die ABM_SETAUTOHIDEBAR Nachricht zum Registrieren oder Aufheben der Registrierung einer automatischen App-Leiste. Die Nachricht gibt den Rand für die App-Leiste und ein Flag an, das angibt, ob die App-Leiste registriert oder nicht registriert werden soll. Die Nachricht schlägt fehl, wenn eine automatische App-Leiste registriert wird, aber einer bereits dem angegebenen Edge zugeordnet ist. Eine Anwendung kann das Handle an die Autohide-Appleiste abrufen, die einem Edge zugeordnet ist, indem die ABM_GETAUTOHIDEBAR Nachricht gesendet wird.

Eine Autohide-Appleiste muss nicht als normale App-Leiste registriert werden; das heißt, es muss nicht registriert werden, indem die ABM_NEW Nachricht gesendet wird. Eine App-Leiste, die von ABM_NEW nicht registriert ist, überschneidet alle App-Leisten, die am gleichen Bildschirmrand verankert sind.

Benachrichtigungen über App-Benachrichtigungen

Das System sendet Nachrichten, um eine App-Leiste über Ereignisse zu benachrichtigen, die sich auf die Position und darstellung auswirken können. Die Nachrichten werden im Kontext einer anwendungsdefinierten Nachricht gesendet. Die Anwendung gibt den Bezeichner der Nachricht an, wenn sie die ABM_NEW Nachricht sendet, um die App-Leiste zu registrieren. Der Benachrichtigungscode befindet sich im wParam-Parameter der anwendungsdefinierten Nachricht.

Eine App-Leiste empfängt die ABN_POSCHANGED Benachrichtigungsnachricht, wenn sich die Größe, Position oder Sichtbarkeit der Taskleiste ändert, wenn eine andere App-Leiste demselben Bildschirmrand hinzugefügt wird oder wenn eine andere Appleiste am gleichen Bildschirmrand geändert oder entfernt wird. Eine App-Leiste sollte auf diese Benachrichtigung reagieren, indem ABM_QUERYPOS und ABM_SETPOS Nachrichten gesendet werden. Wenn sich die Position einer App-Leiste geändert hat, sollte die MoveWindow-Funktion aufgerufen werden, um sich an die neue Position zu bewegen.

Das System sendet die ABN_STATECHANGE Benachrichtigungsnachricht, wenn sich das autohide- oder always-on-top-Zustand der Taskleiste geändert hat– das heißt, wenn der Benutzer das Kontrollkästchen "Immer oben " oder " Automatisch ausblenden " im Eigenschaftenblatt der Taskleiste aktiviert oder deaktiviert. Eine App-Leiste kann diese Benachrichtigung verwenden, um den Status festzulegen, der der Taskleiste entspricht, falls gewünscht.

Wenn eine Vollbildanwendung gestartet oder die letzte Vollbildanwendung geschlossen wird, empfängt eine App-Leiste die ABN_FULLSCREENAPP Benachrichtigung. Der Parameter lParam gibt an, ob die Vollbildanwendung geöffnet oder geschlossen wird. Wenn sie geöffnet wird, muss die App-Leiste am unteren Rand der Z-Reihenfolge ablegen. Die App-Leiste sollte die z-Reihenfolge wiederherstellen, wenn die letzte Vollbildanwendung geschlossen wurde.

Eine App-Leiste empfängt die ABN_WINDOWARRANGE Benachrichtigung, wenn der Benutzer den Befehl "Kaskadiert", "Horizontal" oder "Vertikal kacheln" aus dem Kontextmenü der Taskleiste auswählt. Das System sendet die Nachricht zweimal – bevor sie die Fenster neu anordnen (lParam ist WAHR) und nach dem Anordnen der Fenster (lParam ist FALSE).

Eine App-Leiste kann ABN_WINDOWARRANGE Nachrichten verwenden, um sich selbst aus der Kaskade- oder Kacheloperation auszuschließen. Um sich selbst auszuschließen, sollte sich die App-Leiste ausblenden, wenn lParamWAHR ist und sich selbst anzeigen, wenn lParamFALSCH ist. Wenn sich eine App-Leiste als Reaktion auf diese Nachricht ausblendet, muss die ABM_QUERYPOS und ABM_SETPOS Nachrichten nicht als Reaktion auf den Kaskaden- oder Kachelvorgang gesendet werden.

Registrieren einer Anwendungsdesktopsymbolleiste

Eine Anwendung muss eine App-Leiste registrieren, indem sie die ABM_NEW Nachricht sendet. Das Registrieren einer App-Leiste fügt sie der internen Liste des Systems hinzu und stellt das System eine Nachrichten-ID bereit, mit der Benachrichtigungsnachrichten an die App-Leiste gesendet werden können. Vor dem Beenden muss eine Anwendung die Registrierung der App-Leiste aufheben, indem die ABM_REMOVE Nachricht gesendet wird. Durch das Aufheben der Registrierung wird die App-Leiste aus der internen Liste des Systems entfernt und verhindert, dass die Leiste App-Benachrichtigungen empfangen.

Die Funktion im folgenden Beispiel registriert oder deaktiviert die Registrierung einer App-Leiste abhängig vom Wert eines booleschen Flagparameters.

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

Festlegen der Größe und Position der App-Leiste

Eine Anwendung sollte die Größe und Position einer App-Leiste nach der Registrierung der App-Leiste festlegen, nachdem der Benutzer die App-Leiste verschoben oder größen hat und wann immer die App-Leiste die ABN_POSCHANGED Benachrichtigungsnachricht empfängt. Bevor Sie die Größe und Position der App-Leiste festlegen, fragt die Anwendung das System nach einem genehmigten Begrenzungsrechteck ab, indem die ABM_QUERYPOS Nachricht gesendet wird. Das System gibt ein begrenzungsgebundenes Rechteck zurück, das die Taskleiste oder eine andere App-Leiste nicht beeinträchtigt. Das System passt das Rechteck rein durch Rechteckunterführung an; es macht keinen Aufwand, die anfängliche Größe des Rechtecks beizubehalten. Aus diesem Grund sollte die App-Leiste das Rechteck nach dem Senden von ABM_QUERYPOS neu erstellen.

Als Nächstes übergibt die Anwendung das begrenzungsende Rechteck zurück an das System, indem Sie die ABM_SETPOS Nachricht verwenden. Anschließend wird die MoveWindow-Funktion aufgerufen, um die App-Leiste in die Position zu verschieben.

Im folgenden Beispiel wird gezeigt, wie Sie die Größe und Position einer App-Leiste festlegen.

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

}

Verarbeiten von Appbar-Benachrichtigungsnachrichten

Eine Appbar empfängt eine Benachrichtigungsnachricht, wenn sich der Status der Taskleiste ändert, wenn eine Vollbildanwendung gestartet wird (oder die letzte schließt), oder wenn ein Ereignis auftritt, das die Größe und Position der App-Leiste beeinflussen kann. Im folgenden Beispiel wird gezeigt, wie die verschiedenen Benachrichtigungsnachrichten verarbeitet werden.

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

Die folgende Funktion passt das begrenzungsende Rechteck einer Appbar an und ruft dann die anwendungsdefinierte AppBarQuerySetPos-Funktion (im vorherigen Abschnitt enthalten) auf, um die Größe und Position der Leiste entsprechend festzulegen.

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