appbar.cpp

Go to the documentation of this file.

/*
 * PROJECT:     ReactOS Explorer
 * LICENSE:     LGPL-2.1-or-later (https://spdx.org/licenses/LGPL-2.1-or-later)
 * PURPOSE:     AppBar implementation
 * COPYRIGHT:   Copyright 2008 Vincent Povirk for CodeWeavers
 *              Copyright 2025 Katayama Hirofumi MZ (katayama.hirofumi.mz@gmail.com)
 */
 
#include "precomp.h"
#include "appbar.h"
 
CAppBarManager::CAppBarManager()
    : m_hAppBarDPA(NULL)
{
}
 
CAppBarManager::~CAppBarManager()
{
    DestroyAppBarDPA();
}
 
PAPPBAR CAppBarManager::FindAppBar(_In_ HWND hwndAppBar) const
{
    if (!m_hAppBarDPA)
        return NULL;
 
    INT nItems = DPA_GetPtrCount(m_hAppBarDPA);
    while (--nItems >= 0)
    {
        PAPPBAR pAppBar = (PAPPBAR)DPA_GetPtr(m_hAppBarDPA, nItems);
        if (pAppBar && hwndAppBar == pAppBar->hWnd)
            return pAppBar;
    }
 
    return NULL;
}
 
void CAppBarManager::EliminateAppBar(_In_ INT iItem)
{
    LocalFree(DPA_GetPtr(m_hAppBarDPA, iItem));
    DPA_DeletePtr(m_hAppBarDPA, iItem);
}
 
void CAppBarManager::DestroyAppBarDPA()
{
    if (!m_hAppBarDPA)
        return;
 
    INT nItems = DPA_GetPtrCount(m_hAppBarDPA);
    while (--nItems >= 0)
    {
        ::LocalFree(DPA_GetPtr(m_hAppBarDPA, nItems));
    }
 
    DPA_Destroy(m_hAppBarDPA);
    m_hAppBarDPA = NULL;
}
 
// ABM_NEW
BOOL CAppBarManager::OnAppBarNew(_In_ const APPBAR_COMMAND *pData)
{
    HWND hWnd = (HWND)UlongToHandle(pData->abd.hWnd32);
 
    if (m_hAppBarDPA)
    {
        if (FindAppBar(hWnd))
        {
            ERR("Already exists: %p\n", hWnd);
            return FALSE;
        }
    }
    else
    {
        const UINT c_nGrow = 4;
        m_hAppBarDPA = DPA_Create(c_nGrow);
        if (!m_hAppBarDPA)
        {
            ERR("Out of memory\n");
            return FALSE;
        }
    }
 
    PAPPBAR pAppBar = (PAPPBAR)::LocalAlloc(LPTR, sizeof(*pAppBar));
    if (pAppBar)
    {
        pAppBar->hWnd = hWnd;
        pAppBar->uEdge = UINT_MAX;
        pAppBar->uCallbackMessage = pData->abd.uCallbackMessage;
        if (DPA_InsertPtr(m_hAppBarDPA, INT_MAX, pAppBar) >= 0)
            return TRUE; // Success!
 
        ::LocalFree(pAppBar);
    }
 
    ERR("Out of memory\n");
    return FALSE;
}
 
// ABM_REMOVE
void CAppBarManager::OnAppBarRemove(_In_ const APPBAR_COMMAND *pData)
{
    if (!m_hAppBarDPA)
        return;
 
    HWND hWnd = (HWND)UlongToHandle(pData->abd.hWnd32);
    INT nItems = DPA_GetPtrCount(m_hAppBarDPA);
    while (--nItems >= 0)
    {
        PAPPBAR pAppBar = (PAPPBAR)DPA_GetPtr(m_hAppBarDPA, nItems);
        if (!pAppBar)
            continue;
 
        if (pAppBar->hWnd == hWnd)
        {
            RECT rcOld = pAppBar->rc;
            EliminateAppBar(nItems);
            StuckAppChange(hWnd, &rcOld, NULL, FALSE);
        }
    }
}
 
// ABM_QUERYPOS
void CAppBarManager::OnAppBarQueryPos(_Inout_ PAPPBAR_COMMAND pData)
{
    HWND hWnd = (HWND)UlongToHandle(pData->abd.hWnd32);
    PAPPBAR pAppBar1 = FindAppBar(hWnd);
    if (!pAppBar1)
    {
        ERR("Not found: %p\n", hWnd);
        return;
    }
 
    PAPPBARDATAINTEROP pOutput = AppBar_LockOutput(pData);
    if (!pOutput)
    {
        ERR("!pOutput: %d\n", pData->dwProcessId);
        return;
    }
    pOutput->rc = pData->abd.rc;
 
    if (::IsRectEmpty(&pOutput->rc))
        ERR("IsRectEmpty\n");
 
    HMONITOR hMon1 = ::MonitorFromRect(&pOutput->rc, MONITOR_DEFAULTTOPRIMARY);
    ASSERT(hMon1 != NULL);
 
    // Subtract tray rectangle from pOutput->rc if necessary
    if (hMon1 == GetMonitor() && !IsAutoHideState())
    {
        APPBAR dummyAppBar;
        dummyAppBar.uEdge = GetPosition();
        GetDockedRect(&dummyAppBar.rc);
        AppBarSubtractRect(&dummyAppBar, &pOutput->rc);
    }
 
    // Subtract area from pOutput->rc
    UINT uEdge = pData->abd.uEdge;
    INT nItems = DPA_GetPtrCount(m_hAppBarDPA);
    while (--nItems >= 0)
    {
        PAPPBAR pAppBar2 = (PAPPBAR)DPA_GetPtr(m_hAppBarDPA, nItems);
        if (!pAppBar2 || pAppBar1->hWnd == pAppBar2->hWnd)
            continue;
 
        if ((Edge_IsVertical(uEdge) || !Edge_IsVertical(pAppBar2->uEdge)) &&
            (pAppBar1->uEdge != uEdge || !AppBarOutsideOf(pAppBar1, pAppBar2)))
        {
            if (pAppBar1->uEdge == uEdge || pAppBar2->uEdge != uEdge)
                continue;
        }
 
        HMONITOR hMon2 = ::MonitorFromRect(&pAppBar2->rc, MONITOR_DEFAULTTONULL);
        if (hMon1 == hMon2)
            AppBarSubtractRect(pAppBar2, &pOutput->rc);
    }
 
    AppBar_UnLockOutput(pOutput);
}
 
// ABM_SETPOS
void CAppBarManager::OnAppBarSetPos(_Inout_ PAPPBAR_COMMAND pData)
{
    HWND hWnd = (HWND)UlongToHandle(pData->abd.hWnd32);
    PAPPBAR pAppBar = FindAppBar(hWnd);
    if (!pAppBar)
        return;
 
    OnAppBarQueryPos(pData);
 
    PAPPBARDATAINTEROP pOutput = AppBar_LockOutput(pData);
    if (!pOutput)
        return;
 
    RECT rcOld = pAppBar->rc, rcNew = pData->abd.rc;
    BOOL bChanged = !::EqualRect(&rcOld, &rcNew);
 
    pAppBar->rc = rcNew;
    pAppBar->uEdge = pData->abd.uEdge;
 
    AppBar_UnLockOutput(pOutput);
 
    if (bChanged)
        StuckAppChange(hWnd, &rcOld, &rcNew, FALSE);
}
 
void CAppBarManager::OnAppBarNotifyAll(
    _In_opt_ HMONITOR hMon,
    _In_opt_ HWND hwndIgnore,
    _In_ DWORD dwNotify,
    _In_opt_ LPARAM lParam)
{
    TRACE("%p, %p, 0x%X, %p\n", hMon, hwndIgnore, dwNotify, lParam);
 
    if (!m_hAppBarDPA)
        return;
 
    INT nItems = DPA_GetPtrCount(m_hAppBarDPA);
    while (--nItems >= 0)
    {
        PAPPBAR pAppBar = (PAPPBAR)DPA_GetPtr(m_hAppBarDPA, nItems);
        if (!pAppBar || pAppBar->hWnd == hwndIgnore)
            continue;
 
        HWND hwndAppBar = pAppBar->hWnd;
        if (!::IsWindow(hwndAppBar))
        {
            EliminateAppBar(nItems);
            continue;
        }
 
        if (!hMon || hMon == ::MonitorFromWindow(hwndAppBar, MONITOR_DEFAULTTONULL))
            ::PostMessageW(hwndAppBar, pAppBar->uCallbackMessage, dwNotify, lParam);
    }
}
 
void CAppBarManager::AppBarSubtractRect(_In_ PAPPBAR pAppBar, _Inout_ PRECT prc)
{
    switch (pAppBar->uEdge)
    {
        case ABE_LEFT:   prc->left   = max(prc->left, pAppBar->rc.right); break;
        case ABE_TOP:    prc->top    = max(prc->top, pAppBar->rc.bottom); break;
        case ABE_RIGHT:  prc->right  = min(prc->right, pAppBar->rc.left); break;
        case ABE_BOTTOM: prc->bottom = min(prc->bottom, pAppBar->rc.top); break;
        default:
            ASSERT(FALSE);
            break;
    }
}
 
// Is pAppBar1 outside of pAppBar2?
BOOL CAppBarManager::AppBarOutsideOf(
    _In_ const APPBAR *pAppBar1,
    _In_ const APPBAR *pAppBar2)
{
    if (pAppBar1->uEdge != pAppBar2->uEdge)
        return FALSE;
 
    switch (pAppBar2->uEdge)
    {
        case ABE_LEFT:   return pAppBar1->rc.left >= pAppBar2->rc.left;
        case ABE_TOP:    return pAppBar1->rc.top >= pAppBar2->rc.top;
        case ABE_RIGHT:  return pAppBar1->rc.right <= pAppBar2->rc.right;
        case ABE_BOTTOM: return pAppBar1->rc.bottom <= pAppBar2->rc.bottom;
        default:
            ASSERT(FALSE);
            return FALSE;
    }
}
 
void CAppBarManager::GetDockedRect(_Out_ PRECT prcDocked)
{
    *prcDocked = *GetTrayRect();
    if (IsAutoHideState() && IsHidingState())
        ComputeHiddenRect(prcDocked, GetPosition());
}
 
void CAppBarManager::ComputeHiddenRect(_Inout_ PRECT prc, _In_ UINT uSide)
{
    MONITORINFO mi = { sizeof(mi) };
    HMONITOR hMonitor = ::MonitorFromRect(prc, MONITOR_DEFAULTTONULL);
    if (!::GetMonitorInfoW(hMonitor, &mi))
        return;
    RECT rcMon = mi.rcMonitor;
 
    INT cxy = Edge_IsVertical(uSide) ? (prc->bottom - prc->top) : (prc->right - prc->left);
    switch (uSide)
    {
        case ABE_LEFT:
            prc->right = rcMon.left + GetSystemMetrics(SM_CXFRAME) / 2;
            prc->left = prc->right - cxy;
            break;
        case ABE_TOP:
            prc->bottom = rcMon.top + GetSystemMetrics(SM_CYFRAME) / 2;
            prc->top = prc->bottom - cxy;
            break;
        case ABE_RIGHT:
            prc->left = rcMon.right - GetSystemMetrics(SM_CXFRAME) / 2;
            prc->right = prc->left + cxy;
            break;
        case ABE_BOTTOM:
            prc->top = rcMon.bottom - GetSystemMetrics(SM_CYFRAME) / 2;
            prc->bottom = prc->top + cxy;
            break;
        default:
            ASSERT(FALSE);
            break;
    }
}
 
void
CAppBarManager::StuckAppChange(
    _In_opt_ HWND hwndTarget,
    _In_opt_ const RECT *prcOld,
    _In_opt_ const RECT *prcNew,
    _In_ BOOL bTray)
{
    RECT rcWorkArea1, rcWorkArea2;
    HMONITOR hMon1 = NULL;
    UINT flags = 0;
    enum { SET_WORKAREA_1 = 1, SET_WORKAREA_2 = 2, NEED_SIZING = 4 }; // for flags
 
    if (prcOld)
    {
        hMon1 = (bTray ? GetPreviousMonitor() : ::MonitorFromRect(prcOld, MONITOR_DEFAULTTONEAREST));
        if (hMon1)
        {
            WORKAREA_TYPE type1 = RecomputeWorkArea(GetTrayRect(), hMon1, &rcWorkArea1);
            if (type1 == WORKAREA_IS_NOT_MONITOR)
                flags = SET_WORKAREA_1;
            if (type1 == WORKAREA_SAME_AS_MONITOR)
                flags = NEED_SIZING;
        }
    }
 
    if (prcNew)
    {
        HMONITOR hMon2 = ::MonitorFromRect(prcNew, MONITOR_DEFAULTTONULL);
        if (hMon2 && hMon2 != hMon1)
        {
            WORKAREA_TYPE type2 = RecomputeWorkArea(GetTrayRect(), hMon2, &rcWorkArea2);
            if (type2 == WORKAREA_IS_NOT_MONITOR)
                flags |= SET_WORKAREA_2;
            else if (type2 == WORKAREA_SAME_AS_MONITOR && !flags)
                flags = NEED_SIZING;
        }
    }
 
    if (flags & SET_WORKAREA_1)
    {
        UINT fWinIni = ((flags == SET_WORKAREA_1 && GetDesktopWnd()) ? SPIF_SENDCHANGE : 0);
        ::SystemParametersInfoW(SPI_SETWORKAREA, TRUE, &rcWorkArea1, fWinIni);
        RedrawDesktop(GetDesktopWnd(), &rcWorkArea1);
    }
 
    if (flags & SET_WORKAREA_2)
    {
        UINT fWinIni = (GetDesktopWnd() ? SPIF_SENDCHANGE : 0);
        ::SystemParametersInfoW(SPI_SETWORKAREA, TRUE, &rcWorkArea2, fWinIni);
        RedrawDesktop(GetDesktopWnd(), &rcWorkArea2);
    }
 
    if (bTray || flags == NEED_SIZING)
        ::SendMessageW(GetDesktopWnd(), WM_SIZE, 0, 0);
 
    // Post ABN_POSCHANGED messages to AppBar windows
    OnAppBarNotifyAll(NULL, hwndTarget, ABN_POSCHANGED, TRUE);
}
 
void CAppBarManager::RedrawDesktop(_In_ HWND hwndDesktop, _Inout_ PRECT prc)
{
    if (!hwndDesktop)
        return;
    ::MapWindowPoints(NULL, hwndDesktop, (POINT*)prc, sizeof(*prc) / sizeof(POINT));
    ::RedrawWindow(hwndDesktop, prc, 0, RDW_ALLCHILDREN | RDW_ERASE | RDW_INVALIDATE);
}
 
WORKAREA_TYPE
CAppBarManager::RecomputeWorkArea(
    _In_ const RECT *prcTray,
    _In_ HMONITOR hMonitor,
    _Out_ PRECT prcWorkArea)
{
    MONITORINFO mi = { sizeof(mi) };
    if (!::GetMonitorInfoW(hMonitor, &mi))
        return WORKAREA_NO_TRAY_AREA;
 
    if (IsAutoHideState())
        *prcWorkArea = mi.rcMonitor;
    else
        ::SubtractRect(prcWorkArea, &mi.rcMonitor, prcTray);
 
    if (m_hAppBarDPA)
    {
        INT nItems = DPA_GetPtrCount(m_hAppBarDPA);
        while (--nItems >= 0)
        {
            PAPPBAR pAppBar = (PAPPBAR)DPA_GetPtr(m_hAppBarDPA, nItems);
            if (pAppBar && hMonitor == ::MonitorFromRect(&pAppBar->rc, MONITOR_DEFAULTTONULL))
                AppBarSubtractRect(pAppBar, prcWorkArea);
        }
    }
 
    if (!::EqualRect(prcWorkArea, &mi.rcWork))
        return WORKAREA_IS_NOT_MONITOR;
 
    if (IsAutoHideState() || ::IsRectEmpty(prcTray))
        return WORKAREA_NO_TRAY_AREA;
 
    return WORKAREA_SAME_AS_MONITOR;
}
 
BOOL CALLBACK
CAppBarManager::MonitorEnumProc(
    _In_ HMONITOR hMonitor,
    _In_ HDC hDC,
    _In_ LPRECT prc,
    _Inout_ LPARAM lParam)
{
    CAppBarManager *pThis = (CAppBarManager *)lParam;
    UNREFERENCED_PARAMETER(hDC);
 
    RECT rcWorkArea;
    if (pThis->RecomputeWorkArea(prc, hMonitor, &rcWorkArea) != WORKAREA_IS_NOT_MONITOR)
        return TRUE;
 
    HWND hwndDesktop = pThis->GetDesktopWnd();
    ::SystemParametersInfoW(SPI_SETWORKAREA, 0, &rcWorkArea, hwndDesktop ? SPIF_SENDCHANGE : 0);
    pThis->RedrawDesktop(hwndDesktop, &rcWorkArea);
    return TRUE;
}
 
void CAppBarManager::RecomputeAllWorkareas()
{
    ::EnumDisplayMonitors(NULL, NULL, CAppBarManager::MonitorEnumProc, (LPARAM)this);
}
 
PAPPBAR_COMMAND
CAppBarManager::GetAppBarMessage(_Inout_ PCOPYDATASTRUCT pCopyData)
{
    PAPPBAR_COMMAND pData = (PAPPBAR_COMMAND)pCopyData->lpData;
 
    if (pCopyData->cbData != sizeof(*pData) ||
        pData->abd.cbSize != sizeof(pData->abd))
    {
        ERR("Invalid AppBar message\n");
        return NULL;
    }
 
    return pData;
}
 
// WM_COPYDATA TABDMC_APPBAR
LRESULT CAppBarManager::OnAppBarMessage(_Inout_ PCOPYDATASTRUCT pCopyData)
{
    PAPPBAR_COMMAND pData = GetAppBarMessage(pCopyData);
    if (!pData)
        return 0;
 
    switch (pData->dwMessage)
    {
        case ABM_NEW:
            return OnAppBarNew(pData);
        case ABM_REMOVE:
            OnAppBarRemove(pData);
            break;
        case ABM_QUERYPOS:
            OnAppBarQueryPos(pData);
            break;
        case ABM_SETPOS:
            OnAppBarSetPos(pData);
            break;
        default:
        {
            FIXME("0x%X\n", pData->dwMessage);
            return FALSE;
        }
    }
    return TRUE;
}