Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-04-04 12:39:35 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge 4da5e2864d into 81d845fb2c

Browse source
This commit is contained in:
Katayama Hirofumi MZ 2025-03-30 20:39:11 +09:00 committed by GitHub
commit 6fc13123c4
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
9 changed files with 719 additions and 476 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

692
base/shell/explorer/appbar.cpp
View file

@ -1,290 +1,472 @@
/*
* SHAppBarMessage implementation
*
* Copyright 2008 Vincent Povirk for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*
* TODO: freedesktop _NET_WM_STRUT integration
*
* TODO: find when a fullscreen app is in the foreground and send FULLSCREENAPP
* notifications
*
* TODO: detect changes in the screen size and send ABN_POSCHANGED ?
*
* TODO: multiple monitor support
* 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)
*/
//
// Adapted from Wine appbar.c .
//
#include "precomp.h"
#include "appbar.h"
#include <wine/list.h>
#define GetPrimaryTaskbar() FindWindowW(L"Shell_TrayWnd", NULL)
struct appbar_cmd
CAppBarManager::CAppBarManager()
: m_hAppBarDPA(NULL)
{
DWORD dwMsg;
ULONG return_map;
DWORD return_process;
struct _AppBarData abd;
};
}
struct appbar_response
CAppBarManager::~CAppBarManager()
{
ULONGLONG result;
struct _AppBarData abd;
};
DestroyAppBarDPA();
}
struct appbar_data
PAPPBAR CAppBarManager::FindAppBar(_In_ HWND hwndAppBar) const
{
struct list entry;
HWND hwnd;
UINT callback_msg;
UINT edge;
RECT rc;
BOOL space_reserved;
/* BOOL autohide; */
};
if (!m_hAppBarDPA)
return NULL;
static struct list appbars = LIST_INIT(appbars);
static struct appbar_data* get_appbar(HWND hwnd)
{
struct appbar_data* data;
LIST_FOR_EACH_ENTRY(data, &appbars, struct appbar_data, entry)
INT nItems = DPA_GetPtrCount(m_hAppBarDPA);
while (--nItems >= 0)
{
if (data->hwnd == hwnd)
return data;
PAPPBAR pAppBar = (PAPPBAR)DPA_GetPtr(m_hAppBarDPA, nItems);
if (pAppBar && hwndAppBar == pAppBar->hWnd)
return pAppBar;
}
return NULL;
}
void appbar_notify_all(HMONITOR hMon, UINT uMsg, HWND hwndExclude, LPARAM lParam)
void CAppBarManager::EliminateAppBar(_In_ INT iItem)
{
struct appbar_data* data;
LocalFree(DPA_GetPtr(m_hAppBarDPA, iItem));
DPA_DeletePtr(m_hAppBarDPA, iItem);
}
LIST_FOR_EACH_ENTRY(data, &appbars, struct appbar_data, entry)
void CAppBarManager::DestroyAppBarDPA()
{
if (!m_hAppBarDPA)
return;
INT nItems = DPA_GetPtrCount(m_hAppBarDPA);
while (--nItems >= 0)
{
if (data->hwnd == hwndExclude)
continue;
if (hMon && hMon != MonitorFromWindow(data->hwnd, MONITOR_DEFAULTTONULL))
continue;
SendMessageW(data->hwnd, data->callback_msg, uMsg, lParam);
::LocalFree(DPA_GetPtr(m_hAppBarDPA, nItems));
}
DPA_Destroy(m_hAppBarDPA);
m_hAppBarDPA = NULL;
}
/* send_poschanged: send ABN_POSCHANGED to every appbar except one */
static void send_poschanged(HWND hwnd)
// ABM_NEW
BOOL CAppBarManager::OnAppBarNew(_In_ const APPBAR_COMMAND *pData)
{
appbar_notify_all(NULL, ABN_POSCHANGED, hwnd, 0);
}
/* appbar_cliprect: cut out parts of the rectangle that interfere with existing appbars */
static void appbar_cliprect( HWND hwnd, RECT *rect )
{
struct appbar_data* data;
LIST_FOR_EACH_ENTRY(data, &appbars, struct appbar_data, entry)
if (m_hAppBarDPA)
{
if (data->hwnd == hwnd)
if (FindAppBar(pData->data.hWnd))
{
/* we only care about appbars that were added before this one */
return;
}
if (data->space_reserved)
{
/* move in the side that corresponds to the other appbar's edge */
switch (data->edge)
{
case ABE_BOTTOM:
rect->bottom = min(rect->bottom, data->rc.top);
break;
case ABE_LEFT:
rect->left = max(rect->left, data->rc.right);
break;
case ABE_RIGHT:
rect->right = min(rect->right, data->rc.left);
break;
case ABE_TOP:
rect->top = max(rect->top, data->rc.bottom);
break;
}
}
}
}
static UINT_PTR handle_appbarmessage(DWORD msg, _AppBarData *abd)
{
struct appbar_data* data;
HWND hwnd = abd->hWnd;
switch (msg)
{
case ABM_NEW:
if (get_appbar(hwnd))
{
/* fail when adding an hwnd the second time */
WARN("Already exists: %p\n", pData->data.hWnd);
return FALSE;
}
data = (struct appbar_data*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct appbar_data));
if (!data)
{
ERR("out of memory\n");
return FALSE;
}
data->hwnd = hwnd;
data->callback_msg = abd->uCallbackMessage;
list_add_tail(&appbars, &data->entry);
return TRUE;
case ABM_REMOVE:
if ((data = get_appbar(hwnd)))
{
list_remove(&data->entry);
send_poschanged(hwnd);
HeapFree(GetProcessHeap(), 0, data);
}
else
WARN("removing hwnd %p not on the list\n", hwnd);
return TRUE;
case ABM_QUERYPOS:
if (abd->uEdge > ABE_BOTTOM)
WARN("invalid edge %i for %p\n", abd->uEdge, hwnd);
appbar_cliprect( hwnd, &abd->rc );
return TRUE;
case ABM_SETPOS:
if (abd->uEdge > ABE_BOTTOM)
{
WARN("invalid edge %i for %p\n", abd->uEdge, hwnd);
return TRUE;
}
if ((data = get_appbar(hwnd)))
{
/* calculate acceptable space */
appbar_cliprect( hwnd, &abd->rc );
if (!EqualRect(&abd->rc, &data->rc))
send_poschanged(hwnd);
/* reserve that space for this appbar */
data->edge = abd->uEdge;
data->rc = abd->rc;
data->space_reserved = TRUE;
}
else
{
WARN("app sent ABM_SETPOS message for %p without ABM_ADD\n", hwnd);
}
return TRUE;
case ABM_GETSTATE:
TRACE("SHAppBarMessage(ABM_GETSTATE)\n");
return (g_TaskbarSettings.sr.AutoHide ? ABS_AUTOHIDE : 0) |
(g_TaskbarSettings.sr.AlwaysOnTop ? ABS_ALWAYSONTOP : 0);
case ABM_SETSTATE:
TRACE("SHAppBarMessage(ABM_SETSTATE lparam=%s)\n", wine_dbgstr_longlong(abd->lParam));
hwnd = GetPrimaryTaskbar();
if (hwnd)
{
TaskbarSettings settings = g_TaskbarSettings;
settings.sr.AutoHide = (abd->lParam & ABS_AUTOHIDE) != 0;
settings.sr.AlwaysOnTop = (abd->lParam & ABS_ALWAYSONTOP) != 0;
SendMessageW(hwnd, TWM_SETTINGSCHANGED, 0, (LPARAM)&settings);
return TRUE;
}
return FALSE;
case ABM_GETTASKBARPOS:
TRACE("SHAppBarMessage(ABM_GETTASKBARPOS, hwnd=%p)\n", hwnd);
abd->uEdge = g_TaskbarSettings.sr.Position;
abd->hWnd = GetPrimaryTaskbar();
return abd->hWnd && GetWindowRect(abd->hWnd, &abd->rc);
case ABM_ACTIVATE:
return TRUE;
case ABM_GETAUTOHIDEBAR:
FIXME("SHAppBarMessage(ABM_GETAUTOHIDEBAR, hwnd=%p, edge=%x): stub\n", hwnd, abd->uEdge);
if (abd->uEdge == g_TaskbarSettings.sr.Position && g_TaskbarSettings.sr.AutoHide)
return (SIZE_T)GetPrimaryTaskbar();
return NULL;
case ABM_SETAUTOHIDEBAR:
FIXME("SHAppBarMessage(ABM_SETAUTOHIDEBAR, hwnd=%p, edge=%x, lparam=%s): stub\n",
hwnd, abd->uEdge, wine_dbgstr_longlong(abd->lParam));
return TRUE;
case ABM_WINDOWPOSCHANGED:
return TRUE;
default:
FIXME("SHAppBarMessage(%x) unimplemented\n", msg);
return FALSE;
}
}
LRESULT appbar_message ( COPYDATASTRUCT* cds )
{
struct appbar_cmd cmd;
UINT_PTR result;
HANDLE return_hproc;
HANDLE return_map;
LPVOID return_view;
struct appbar_response* response;
if (cds->cbData != sizeof(struct appbar_cmd))
return TRUE;
RtlCopyMemory(&cmd, cds->lpData, cds->cbData);
result = handle_appbarmessage(cmd.dwMsg, &cmd.abd);
return_hproc = OpenProcess(PROCESS_DUP_HANDLE, FALSE, cmd.return_process);
if (return_hproc == NULL)
{
ERR("couldn't open calling process\n");
return TRUE;
}
if (!DuplicateHandle(return_hproc, UlongToHandle(cmd.return_map), GetCurrentProcess(), &return_map, 0, FALSE, DUPLICATE_SAME_ACCESS))
{
ERR("couldn't duplicate handle\n");
CloseHandle(return_hproc);
return TRUE;
}
CloseHandle(return_hproc);
return_view = MapViewOfFile(return_map, FILE_MAP_WRITE, 0, 0, sizeof(struct appbar_response));
if (return_view)
{
response = (struct appbar_response*)return_view;
response->result = result;
response->abd = cmd.abd;
UnmapViewOfFile(return_view);
}
else
{
ERR("couldn't map view of file\n");
const UINT c_nGrow = 4;
m_hAppBarDPA = DPA_Create(c_nGrow);
if (!m_hAppBarDPA)
{
ERR("Out of memory\n");
return FALSE;
}
}
CloseHandle(return_map);
PAPPBAR pAppBar = (PAPPBAR)::LocalAlloc(LPTR, sizeof(*pAppBar));
if (pAppBar)
{
pAppBar->hWnd = pData->data.hWnd;
pAppBar->uEdge = UINT_MAX;
pAppBar->uCallbackMessage = pData->data.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;
INT nItems = DPA_GetPtrCount(m_hAppBarDPA);
while (--nItems >= 0)
{
PAPPBAR pAppBar = (PAPPBAR)DPA_GetPtr(m_hAppBarDPA, nItems);
if (!pAppBar)
continue;
if (pAppBar->hWnd == pData->data.hWnd)
{
RECT rcOld = pAppBar->rc;
EliminateAppBar(nItems);
StuckAppChange(pData->data.hWnd, &rcOld, NULL, FALSE);
}
}
}
// ABM_QUERYPOS
void CAppBarManager::OnAppBarQueryPos(_Inout_ PAPPBAR_COMMAND pData)
{
PAPPBAR pAppBar1 = FindAppBar(pData->data.hWnd);
if (!pAppBar1)
{
ERR("Not found: %p\n", pData->data.hWnd);
return;
}
PAPPBARDATA pOutput = AppBar_LockOutput(pData);
if (!pOutput)
{
ERR("!pOutput: %d\n", pData->dwProcessId);
return;
}
pOutput->rc = pData->data.rc;
if (::IsRectEmpty(&pOutput->rc))
WARN("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->data.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)
{
PAPPBAR pAppBar = FindAppBar(pData->data.hWnd);
if (!pAppBar)
return;
OnAppBarQueryPos(pData);
PAPPBARDATA pOutput = AppBar_LockOutput(pData);
if (!pOutput)
return;
RECT rcOld = pAppBar->rc, rcNew = pData->data.rc;
BOOL bChanged = !::EqualRect(&rcOld, &rcNew);
pAppBar->rc = rcNew;
pAppBar->uEdge = pData->data.uEdge;
AppBar_UnLockOutput(pOutput);
if (bChanged)
StuckAppChange(pData->data.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);
}
}
/// @param pAppBar The target AppBar to subtract.
/// @param prc The rectangle to be subtracted.
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;
}
}
/// Get rectangle of the tray window.
/// @param prcDocked The pointer to the rectangle to be received.
void CAppBarManager::GetDockedRect(_Out_ PRECT prcDocked)
{
*prcDocked = *GetTrayRect();
if (IsAutoHideState() && IsHidingState())
ComputeHiddenRect(prcDocked, GetPosition());
}
/// Compute the position and size of the hidden TaskBar.
/// @param prc The rectangle before hiding TaskBar.
/// @param uSide The side of TaskBar (ABE_...).
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;
}
}
/// This function is called when AppBar and/or TaskBar is being moved, removed, and/or updated.
/// @param hwndTarget The target window. Optional.
/// @param prcOld The old position and size. Optional.
/// @param prcNew The new position and size. Optional.
/// @param bTray TRUE if the tray is being moved.
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);
}
/// Re-compute the work area.
/// @param prcTray The position and size of the tray window
/// @param hMonitor The monitor of the work area to re-compute.
/// @param prcWorkArea The work area to be re-computed.
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;
}
// TWM_NOTIFYALLAPPBARS
LRESULT CAppBarManager::OnNotifyAllAppBars(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
OnAppBarNotifyAll((HMONITOR)lParam, (HWND)wParam, ABN_POSCHANGED, FALSE);
return TRUE;
}
PAPPBAR_COMMAND
CAppBarManager::GetAppBarMessage(_Inout_ PCOPYDATASTRUCT pCopyData)
{
PAPPBAR_COMMAND pData = (PAPPBAR_COMMAND)pCopyData->lpData;
// For security check
if (pCopyData->cbData != sizeof(*pData) || pData->dwMagic != 0xBEEFCAFE)
{
WARN("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;
}

97
base/shell/explorer/appbar.h Normal file
View file

@ -0,0 +1,97 @@
/*
* PROJECT: ReactOS Explorer
* LICENSE: LGPL-2.1-or-later (https://spdx.org/licenses/LGPL-2.1-or-later)
* PURPOSE: AppBar implementation
* COPYRIGHT: Copyright 2025 Katayama Hirofumi MZ (katayama.hirofumi.mz@gmail.com)
*/
#pragma once
typedef struct _APPBAR
{
HWND hWnd;
UINT uCallbackMessage;
RECT rc;
UINT uEdge;
} APPBAR, *PAPPBAR;
static inline PAPPBARDATA
AppBar_LockOutput(_In_ PAPPBAR_COMMAND pData)
{
return (PAPPBARDATA)SHLockShared(pData->hOutput, pData->dwProcessId);
}
static inline VOID
AppBar_UnLockOutput(_Out_ PAPPBARDATA pOutput)
{
SHUnlockShared(pOutput);
}
static inline BOOL
Edge_IsVertical(_In_ UINT uEdge)
{
return uEdge == ABE_TOP || uEdge == ABE_BOTTOM;
}
// Return value of CAppBarManager::RecomputeWorkArea
enum WORKAREA_TYPE
{
WORKAREA_NO_TRAY_AREA = 0,
WORKAREA_IS_NOT_MONITOR = 1,
WORKAREA_SAME_AS_MONITOR = 2,
};
class CAppBarManager
{
public:
CAppBarManager();
virtual ~CAppBarManager();
LRESULT OnAppBarMessage(_Inout_ PCOPYDATASTRUCT pCopyData);
protected:
HDPA m_hAppBarDPA; // DPA (Dynamic Pointer Array)
PAPPBAR FindAppBar(_In_ HWND hwndAppBar) const;
void EliminateAppBar(_In_ INT iItem);
void DestroyAppBarDPA();
void AppBarSubtractRect(_In_ PAPPBAR pAppBar, _Inout_ PRECT prc);
BOOL AppBarOutsideOf(_In_ const APPBAR *pAppBar1, _In_ const APPBAR *pAppBar2);
void ComputeHiddenRect(_Inout_ PRECT prc, _In_ UINT uSide);
PAPPBAR_COMMAND GetAppBarMessage(_Inout_ PCOPYDATASTRUCT pCopyData);
void GetDockedRect(_Out_ PRECT prcDocked);
LRESULT OnNotifyAllAppBars(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
BOOL OnAppBarNew(_In_ const APPBAR_COMMAND *pData);
void OnAppBarRemove(_In_ const APPBAR_COMMAND *pData);
void OnAppBarQueryPos(_Inout_ PAPPBAR_COMMAND pData);
void OnAppBarSetPos(_Inout_ PAPPBAR_COMMAND pData);
void OnAppBarNotifyAll(
_In_opt_ HMONITOR hMon,
_In_opt_ HWND hwndIgnore,
_In_ DWORD dwNotify,
_In_opt_ LPARAM lParam);
WORKAREA_TYPE
RecomputeWorkArea(
_In_ const RECT *prcTray,
_In_ HMONITOR hMonitor,
_Out_ PRECT prcWorkArea);
void StuckAppChange(
_In_opt_ HWND hwndTarget,
_In_opt_ const RECT *prcOld,
_In_opt_ const RECT *prcNew,
_In_ BOOL bTray);
void RedrawDesktop(_In_ HWND hwndDesktop, _Inout_ PRECT prc);
virtual BOOL IsAutoHideState() const = 0;
virtual BOOL IsHidingState() const = 0;
virtual HMONITOR GetMonitor() const = 0;
virtual HMONITOR GetPreviousMonitor() const = 0;
virtual INT GetPosition() const = 0;
virtual LPRECT GetTrayRect() = 0;
virtual HWND GetDesktopWnd() const = 0;
};

1
base/shell/explorer/precomp.h
View file

@ -132,6 +132,7 @@ HRESULT WINAPI _CBandSite_CreateInstance(LPUNKNOWN pUnkOuter, REFIID riid, void
#define TWM_GETTASKSWITCH (WM_USER + 236)
#define TWM_OPENSTARTMENU (WM_USER + 260)
#define TWM_SETTINGSCHANGED (WM_USER + 300)
#define TWM_NOTIFYALLAPPBARS (WM_USER + 336)
#define TWM_PULSE (WM_USER + 400)
extern const GUID IID_IShellDesktopTray;

71
base/shell/explorer/traywnd.cpp
View file

@ -1,30 +1,16 @@
/*
* ReactOS Explorer
*
* Copyright 2006 - 2007 Thomas Weidenmueller <w3seek@reactos.org>
* Copyright 2018-2022 Katayama Hirofumi MZ <katayama.hirofumi.mz@gmail.com>
*
* this library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* this library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
* PROJECT: ReactOS Explorer
* LICENSE: LGPL-2.1-or-later (https://spdx.org/licenses/LGPL-2.1-or-later)
* PURPOSE: Tray window implementation
* COPYRIGHT: Copyright 2006-2007 Thomas Weidenmueller <w3seek@reactos.org>
* Copyright 2018-2025 Katayama Hirofumi MZ <katayama.hirofumi.mz@gmail.com>
*/
#include "precomp.h"
#include <commoncontrols.h>
#include "appbar.h"
HRESULT TrayWindowCtxMenuCreator(ITrayWindow * TrayWnd, IN HWND hWndOwner, IContextMenu ** ppCtxMenu);
LRESULT appbar_message(COPYDATASTRUCT* cds);
void appbar_notify_all(HMONITOR hMon, UINT uMsg, HWND hwndExclude, LPARAM lParam);
#define WM_APP_TRAYDESTROY (WM_APP + 0x100)
@ -56,8 +42,6 @@ void appbar_notify_all(HMONITOR hMon, UINT uMsg, HWND hwndExclude, LPARAM lParam
#define IDHK_DESKTOP 0x1fe
#define IDHK_PAGER 0x1ff
static const WCHAR szTrayWndClass[] = L"Shell_TrayWnd";
enum { NONE, TILED, CASCADED } g_Arrangement = NONE;
struct WINDOWPOSBACKUPDATA
@ -323,6 +307,7 @@ class CTrayWindow :
public CComCoClass<CTrayWindow>,
public CComObjectRootEx<CComMultiThreadModelNoCS>,
public CWindowImpl < CTrayWindow, CWindow, CControlWinTraits >,
public CAppBarManager,
public ITrayWindow,
public IShellDesktopTray,
public IOleWindow,
@ -681,35 +666,35 @@ public:
break;
case ID_SHELL_CMD_TILE_WND_H:
appbar_notify_all(NULL, ABN_WINDOWARRANGE, NULL, TRUE);
OnAppBarNotifyAll(NULL, NULL, ABN_WINDOWARRANGE, TRUE);
if (g_Arrangement == NONE)
{
BackupWindowPos();
}
TileWindows(NULL, MDITILE_HORIZONTAL, NULL, 0, NULL);
appbar_notify_all(NULL, ABN_WINDOWARRANGE, NULL, FALSE);
OnAppBarNotifyAll(NULL, NULL, ABN_WINDOWARRANGE, FALSE);
g_Arrangement = TILED;
break;
case ID_SHELL_CMD_TILE_WND_V:
appbar_notify_all(NULL, ABN_WINDOWARRANGE, NULL, TRUE);
OnAppBarNotifyAll(NULL, NULL, ABN_WINDOWARRANGE, TRUE);
if (g_Arrangement == NONE)
{
BackupWindowPos();
}
TileWindows(NULL, MDITILE_VERTICAL, NULL, 0, NULL);
appbar_notify_all(NULL, ABN_WINDOWARRANGE, NULL, FALSE);
OnAppBarNotifyAll(NULL, NULL, ABN_WINDOWARRANGE, FALSE);
g_Arrangement = TILED;
break;
case ID_SHELL_CMD_CASCADE_WND:
appbar_notify_all(NULL, ABN_WINDOWARRANGE, NULL, TRUE);
OnAppBarNotifyAll(NULL, NULL, ABN_WINDOWARRANGE, TRUE);
if (g_Arrangement == NONE)
{
BackupWindowPos();
}
CascadeWindows(NULL, MDITILE_SKIPDISABLED, NULL, 0, NULL);
appbar_notify_all(NULL, ABN_WINDOWARRANGE, NULL, FALSE);
OnAppBarNotifyAll(NULL, NULL, ABN_WINDOWARRANGE, FALSE);
g_Arrangement = CASCADED;
break;
@ -2503,11 +2488,14 @@ ChangePos:
LRESULT OnCopyData(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
COPYDATASTRUCT *pCopyData = (COPYDATASTRUCT *)lParam;
PCOPYDATASTRUCT pCopyData = (PCOPYDATASTRUCT)lParam;
if (!pCopyData)
return FALSE;
switch (pCopyData->dwData)
{
case TABDMC_APPBAR:
return appbar_message(pCopyData);
return OnAppBarMessage(pCopyData);
case TABDMC_NOTIFY:
case TABDMC_LOADINPROC:
return ::SendMessageW(m_TrayNotify, uMsg, wParam, lParam);
@ -2936,7 +2924,7 @@ HandleTrayContextMenu:
LRESULT Ret = FALSE;
/* FIXME: We can't check with IsChild whether the hwnd is somewhere inside
the rebar control! But we shouldn't forward messages that the band
site doesn't handle, such as other controls (start button, tray window */
site doesn't handle, such as other controls (start button, tray window) */
HRESULT hr = E_FAIL;
@ -3371,7 +3359,7 @@ HandleTrayContextMenu:
return 0;
}
DECLARE_WND_CLASS_EX(szTrayWndClass, CS_DBLCLKS, COLOR_3DFACE)
DECLARE_WND_CLASS_EX(L"Shell_TrayWnd", CS_DBLCLKS, COLOR_3DFACE)
BEGIN_MSG_MAP(CTrayWindow)
if (m_StartMenuBand != NULL)
@ -3435,6 +3423,7 @@ HandleTrayContextMenu:
MESSAGE_HANDLER(TWM_DOEXITWINDOWS, OnDoExitWindows)
MESSAGE_HANDLER(TWM_GETTASKSWITCH, OnGetTaskSwitch)
MESSAGE_HANDLER(TWM_PULSE, OnPulse)
MESSAGE_HANDLER(TWM_NOTIFYALLAPPBARS, OnNotifyAllAppBars)
ALT_MSG_MAP(1)
END_MSG_MAP()
@ -3562,6 +3551,24 @@ HandleTrayContextMenu:
COM_INTERFACE_ENTRY_IID(IID_IOleWindow, IOleWindow)
COM_INTERFACE_ENTRY_IID(IID_IContextMenu, IContextMenu)
END_COM_MAP()
protected:
//////////////////////////////////////////////////////////////////////////////////////////////
// AppBar section
//
// See also: appbar.cpp
// TODO: freedesktop _NET_WM_STRUT integration
// TODO: find when a fullscreen app is in the foreground and send FULLSCREENAPP notifications
// TODO: detect changes in the screen size and send ABN_POSCHANGED ?
// TODO: multiple monitor support
BOOL IsAutoHideState() const override { return g_TaskbarSettings.sr.AutoHide; }
BOOL IsHidingState() const override { return m_AutoHideState == AUTOHIDE_HIDING; }
HMONITOR GetMonitor() const override { return m_Monitor; }
HMONITOR GetPreviousMonitor() const override { return m_PreviousMonitor; }
INT GetPosition() const override { return m_Position; }
LPRECT GetTrayRect() override { return &m_TrayRects[m_Position]; }
HWND GetDesktopWnd() const override { return m_DesktopWnd; }
};
class CTrayWindowCtxMenu :

2
dll/win32/shell32/CMakeLists.txt
View file

@ -85,7 +85,7 @@ list(APPEND SOURCE
CFolderItemVerbs.cpp)
list(APPEND PCH_SKIP_SOURCE
wine/appbar.c
appbar.c
wine/classes.c
wine/clipboard.c
wine/control.c

120
dll/win32/shell32/appbar.c Normal file
View file

@ -0,0 +1,120 @@
/*
* PROJECT: ReactOS Shell32
* LICENSE: LGPL-2.1-or-later (https://spdx.org/licenses/LGPL-2.1-or-later)
* PURPOSE: SHAppBarMessage implementation
* COPYRIGHT: Copyright 2008 Vincent Povirk for CodeWeavers
* Copyright 2025 Katayama Hirofumi MZ <katayama.hirofumi.mz@gmail.com>
*/
#include <windef.h>
#include <winbase.h>
#include <winuser.h>
#include <shellapi.h>
#include <shlobj.h>
#include <shlwapi.h>
#include <undocshell.h>
#include <wine/debug.h>
#include <wine/unicode.h>
WINE_DEFAULT_DEBUG_CHANNEL(appbar);
static LPVOID
AppBar_CopyIn(
_In_ LPCVOID pvSrc,
_In_ SIZE_T dwSize,
_In_ DWORD dwProcessId)
{
HANDLE hMem = SHAllocShared(NULL, dwSize, dwProcessId);
if (!hMem)
return NULL;
LPVOID pvDest = SHLockShared(hMem, dwProcessId);
if (!pvDest)
{
SHFreeShared(hMem, dwProcessId);
return NULL;
}
CopyMemory(pvDest, pvSrc, dwSize);
SHUnlockShared(pvDest);
return hMem;
}
static BOOL
AppBar_CopyOut(
_In_ HANDLE hOutput,
_Out_ LPVOID pvDest,
_In_ SIZE_T cbDest,
_In_ DWORD dwProcessId)
{
LPVOID pvSrc = SHLockShared(hOutput, dwProcessId);
if (pvSrc)
{
CopyMemory(pvDest, pvSrc, cbDest);
SHUnlockShared(pvSrc);
}
SHFreeShared(hOutput, dwProcessId);
return pvSrc != NULL;
}
/*************************************************************************
* SHAppBarMessage [SHELL32.@]
*/
UINT_PTR
WINAPI
SHAppBarMessage(
_In_ DWORD dwMessage,
_Inout_ PAPPBARDATA pData)
{
TRACE("dwMessage=%d, pData={cb=%d, hwnd=%p}\n", dwMessage, pData->cbSize, pData->hWnd);
HWND hTrayWnd = FindWindowW(L"Shell_TrayWnd", NULL);
if (!hTrayWnd || pData->cbSize > sizeof(*pData))
{
WARN("%p, %d\n", hTrayWnd, pData->cbSize);
return FALSE;
}
APPBAR_COMMAND cmd;
cmd.data = *pData;
cmd.dwMessage = dwMessage;
cmd.dwProcessId = GetCurrentProcessId();
cmd.hOutput = NULL;
cmd.dwMagic = 0xBEEFCAFE; // For security check
/* Make output data if necessary */
switch (dwMessage)
{
case ABM_QUERYPOS:
case ABM_SETPOS:
case ABM_GETTASKBARPOS:
cmd.hOutput = AppBar_CopyIn(&cmd.data, sizeof(cmd.data), cmd.dwProcessId);
if (!cmd.hOutput)
{
ERR("AppBar_CopyIn: %d\n", dwMessage);
return FALSE;
}
break;
default:
break;
}
/* Send WM_COPYDATA message */
COPYDATASTRUCT copyData = { TABDMC_APPBAR, sizeof(cmd), &cmd };
UINT_PTR ret = SendMessageW(hTrayWnd, WM_COPYDATA, (WPARAM)pData->hWnd, (LPARAM)&copyData);
/* Apply output data */
if (cmd.hOutput)
{
if (!AppBar_CopyOut(cmd.hOutput, &cmd.data, sizeof(cmd.data), cmd.dwProcessId))
{
ERR("AppBar_CopyOut: %d\n", dwMessage);
return FALSE;
}
*pData = cmd.data;
}
return ret;
}

168
dll/win32/shell32/wine/appbar.c
View file

@ -1,168 +0,0 @@
/*
* SHAppBarMessage implementation
*
* Copyright 2008 Vincent Povirk for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
//
// Adapted from Wine appbar.c .
//
#include <wine/config.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <stdio.h>
#include <windef.h>
#include <winbase.h>
#include <winerror.h>
#include <shellapi.h>
#include <winuser.h>
#include <shlobj.h>
#include <shlwapi.h>
#include <undocshell.h>
#include <wine/debug.h>
#include <wine/unicode.h>
#include "shell32_main.h"
WINE_DEFAULT_DEBUG_CHANNEL(appbar);
struct appbar_cmd
{
DWORD dwMsg;
ULONG return_map;
DWORD return_process;
struct _AppBarData abd;
};
struct appbar_response
{
ULONGLONG result;
struct _AppBarData abd;
};
/*************************************************************************
* SHAppBarMessage [SHELL32.@]
*/
UINT_PTR WINAPI SHAppBarMessage(DWORD msg, PAPPBARDATA data)
{
struct appbar_cmd command;
struct appbar_response* response;
HANDLE return_map;
LPVOID return_view;
HWND appbarmsg_window;
COPYDATASTRUCT cds;
UINT_PTR ret = 0;
TRACE("msg=%d, data={cb=%d, hwnd=%p}\n", msg, data->cbSize, data->hWnd);
/* These members are message dependent */
switch(msg)
{
case ABM_NEW:
TRACE("callback: %x\n", data->uCallbackMessage);
break;
case ABM_GETAUTOHIDEBAR:
TRACE("edge: %d\n", data->uEdge);
break;
case ABM_QUERYPOS:
case ABM_SETPOS:
TRACE("edge: %d, rc: %s\n", data->uEdge, wine_dbgstr_rect(&data->rc));
break;
case ABM_GETTASKBARPOS:
TRACE("rc: %s\n", wine_dbgstr_rect(&data->rc));
break;
case ABM_SETAUTOHIDEBAR:
TRACE("edge: %d, lParam: %lx\n", data->uEdge, data->lParam);
break;
default:
FIXME("unknown msg: %d\n", msg);
break;
}
if (data->cbSize < sizeof(APPBARDATA))
{
WARN("data at %p is too small\n", data);
return FALSE;
}
command.dwMsg = msg;
command.abd.hWnd = data->hWnd;
command.abd.uCallbackMessage = data->uCallbackMessage;
command.abd.uEdge = data->uEdge;
command.abd.rc = data->rc;
command.abd.lParam = data->lParam;
return_map = CreateFileMappingW(INVALID_HANDLE_VALUE, 0, PAGE_READWRITE, 0, sizeof(struct appbar_response), NULL);
if (return_map == NULL)
{
ERR("couldn't create file mapping\n");
return 0;
}
command.return_map = HandleToUlong( return_map );
command.return_process = GetCurrentProcessId();
appbarmsg_window = FindWindowW(L"Shell_TrayWnd", NULL);
if (appbarmsg_window == NULL)
{
ERR("couldn't find appbar window\n");
CloseHandle(return_map);
return 0;
}
cds.dwData = TABDMC_APPBAR;
cds.cbData = sizeof(command);
cds.lpData = &command;
SendMessageW(appbarmsg_window, WM_COPYDATA, (WPARAM)data->hWnd, (LPARAM)&cds);
return_view = MapViewOfFile(return_map, FILE_MAP_READ, 0, 0, sizeof(struct appbar_response));
if (return_view == NULL)
{
ERR("MapViewOfFile failed\n");
CloseHandle(return_map);
return 0;
}
response = return_view;
ret = response->result;
if (ret)
{
data->hWnd = response->abd.hWnd;
data->uCallbackMessage = response->abd.uCallbackMessage;
data->uEdge = response->abd.uEdge;
data->rc = response->abd.rc;
data->lParam = response->abd.lParam;
}
UnmapViewOfFile(return_view);
CloseHandle(return_map);
return ret;
}

7
sdk/include/psdk/shellapi.h
View file

@ -494,7 +494,12 @@ FindExecutableW(
_In_opt_ LPCWSTR lpDirectory,
_Out_writes_(MAX_PATH) LPWSTR lpResult);
UINT_PTR WINAPI SHAppBarMessage(_In_ DWORD, _Inout_ PAPPBARDATA);
UINT_PTR
WINAPI
SHAppBarMessage(
_In_ DWORD dwMessage,
_Inout_ PAPPBARDATA pData);
BOOL WINAPI Shell_NotifyIconA(_In_ DWORD, _In_ PNOTIFYICONDATAA);
BOOL WINAPI Shell_NotifyIconW(_In_ DWORD, _In_ PNOTIFYICONDATAW);

37
sdk/include/reactos/undocshell.h
View file

@ -1,23 +1,14 @@
/*
* Copyright 1999, 2000 Juergen Schmied
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
* PROJECT: ReactOS Shell
* LICENSE: LGPL-2.1-or-later (https://spdx.org/licenses/LGPL-2.1-or-later)
* PURPOSE: Undocumented shell definitions
* COPYRIGHT: Copyright 1999, 2000 Juergen Schmied
* Copyright 2025 Katayama Hirofumi MZ (katayama.hirofumi.mz@gmail.com)
*/
#ifndef __WINE_UNDOCSHELL_H
#define __WINE_UNDOCSHELL_H
#pragma once
#include <shellapi.h>
#ifdef __cplusplus
extern "C" {
@ -1211,10 +1202,18 @@ typedef struct SFVM_CUSTOMVIEWINFO_DATA
COLORREF clrTextBack;
} SFVM_CUSTOMVIEWINFO_DATA, *LPSFVM_CUSTOMVIEWINFO_DATA;
/* For internal AppBar messaging (private) */
typedef struct _APPBAR_COMMAND
{
APPBARDATA data;
DWORD dwMessage;
DWORD dwProcessId;
HANDLE hOutput;
DWORD dwMagic;
} APPBAR_COMMAND, *PAPPBAR_COMMAND;
#include <poppack.h>
#ifdef __cplusplus
} /* extern "C" */
#endif /* defined(__cplusplus) */
#endif /* __WINE_UNDOCSHELL_H */