Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-06-28 00:41:36 +00:00
Code Issues Packages Projects Releases Wiki Activity

[SHELL32]

Browse source 
- Use and register the shellmenu (former rshell) classes instead of the outdated copies in shell32
CORE-9892

svn path=/trunk/; revision=68764
This commit is contained in:
Thomas Faber 2015-08-19 11:17:08 +00:00
parent cc3d477818
commit 0afd339f06
20 changed files with 92 additions and 1489 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
reactos/dll/win32/shell32/CMakeLists.txt
View file

@ -18,8 +18,6 @@ include_directories(
${REACTOS_SOURCE_DIR})
list(APPEND SOURCE
CMenuBand.cpp
CMenuDeskBar.cpp
CIDLDataObj.cpp
CQueryAssociations.cpp
dde.cpp
@ -60,7 +58,6 @@ list(APPEND SOURCE
CDefaultContextMenu.cpp
COpenWithMenu.cpp
CNewMenu.cpp
CStartMenu.cpp
precomp.h)
add_library(shell32 SHARED
@ -85,8 +82,8 @@ add_library(shell32 SHARED
${CMAKE_CURRENT_BINARY_DIR}/shell32.def)
set_module_type(shell32 win32dll UNICODE HOTPATCHABLE)
target_link_libraries(shell32 atlnew wine uuid recyclebin)
add_delay_importlibs(shell32 ole32 userenv version fmifs)
target_link_libraries(shell32 shellmenu atlnew wine uuid recyclebin)
add_delay_importlibs(shell32 uxtheme ole32 userenv version fmifs)
add_importlibs(shell32 advapi32 browseui gdi32 user32 powrprof comctl32 comdlg32 shdocvw shlwapi devmgr winspool winmm msvcrt kernel32 ntdll)
add_pch(shell32 precomp.h SOURCE)
add_cd_file(TARGET shell32 DESTINATION reactos/system32 FOR all)

600
reactos/dll/win32/shell32/CMenuBand.cpp
View file

@ -1,600 +0,0 @@
/*
* PROJECT: shell32
* LICENSE: GPL - See COPYING in the top level directory
* FILE: dll/win32/shell32/CMenuBand.c
* PURPOSE: menu band implementation
* PROGRAMMERS: Giannis Adamopoulos (gadamopoulos@reactos.org)
*/
#include "precomp.h"
#include <windowsx.h>
WINE_DEFAULT_DEBUG_CHANNEL(CMenuBand);
BOOL
AllocAndGetMenuString(HMENU hMenu, UINT ItemIDByPosition, WCHAR** String)
{
int Length;
Length = GetMenuStringW(hMenu, ItemIDByPosition, NULL, 0, MF_BYPOSITION);
if(!Length)
return FALSE;
/* Also allocate space for the terminating NULL character */
++Length;
*String = (PWSTR)HeapAlloc(GetProcessHeap(), 0, Length * sizeof(WCHAR));
GetMenuStringW(hMenu, ItemIDByPosition, *String, Length, MF_BYPOSITION);
return TRUE;
}
CMenuStaticToolbar::CMenuStaticToolbar(CMenuBand *menuBand)
{
m_menuBand = menuBand;
m_menuBand = NULL;
m_hwnd = NULL;
m_hmenu = NULL;
m_hwndOwner = NULL;
m_dwMenuFlags = NULL;
}
HRESULT CMenuStaticToolbar::GetMenu(
HMENU *phmenu,
HWND *phwnd,
DWORD *pdwFlags)
{
*phmenu = m_hmenu;
*phwnd = m_hwndOwner;
*pdwFlags = m_dwMenuFlags;
return S_OK;
}
HRESULT CMenuStaticToolbar::SetMenu(
HMENU hmenu,
HWND hwnd,
DWORD dwFlags)
{
if (!hwnd)
return E_FAIL;
m_hmenu = hmenu;
m_hwndOwner = hwnd;
m_dwMenuFlags = dwFlags;
return S_OK;
}
HRESULT CMenuStaticToolbar::ShowWindow(BOOL fShow)
{
::ShowWindow(m_hwnd, fShow ? SW_SHOW : SW_HIDE);
return S_OK;
}
HRESULT CMenuStaticToolbar::Close()
{
DestroyWindow(m_hwnd);
m_hwnd = NULL;
return S_OK;
}
HRESULT CMenuStaticToolbar::CreateToolbar(HWND hwndParent, DWORD dwFlags)
{
HWND hwndToolbar;
hwndToolbar = CreateWindowEx(TBSTYLE_EX_DOUBLEBUFFER, TOOLBARCLASSNAMEW, NULL, WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS |
WS_CLIPCHILDREN | TBSTYLE_TOOLTIPS | TBSTYLE_TRANSPARENT | TBSTYLE_REGISTERDROP | TBSTYLE_LIST | TBSTYLE_FLAT |
CCS_NODIVIDER | CCS_NOPARENTALIGN | CCS_NORESIZE | CCS_TOP, 0, 0, 500, 20, m_hwndOwner, NULL,
_AtlBaseModule.GetModuleInstance(), 0);
if (hwndToolbar == NULL)
return E_FAIL;
::SetParent(hwndToolbar, hwndParent);
m_hwnd = hwndToolbar;
/* Identify the version of the used Common Controls DLL by sending the size of the TBBUTTON structure */
SendMessageW(m_hwnd, TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0);
if (dwFlags & SMINIT_TOPLEVEL)
{
/* Hide the placeholders for the button images */
SendMessageW(m_hwnd, TB_SETIMAGELIST, 0, 0);
}
return S_OK;
}
HRESULT CMenuStaticToolbar::FillToolbar()
{
TBBUTTON tbb = {0};
int i;
PWSTR MenuString;
tbb.fsState = TBSTATE_ENABLED;
tbb.fsStyle = BTNS_DROPDOWN | BTNS_AUTOSIZE;
for(i = 0; i < GetMenuItemCount(m_hmenu); i++)
{
if(!AllocAndGetMenuString(m_hmenu, i, &MenuString))
return E_OUTOFMEMORY;
tbb.idCommand = i;
tbb.iString = (INT_PTR)MenuString;
SendMessageW(m_hwnd, TB_ADDBUTTONS, 1, (LPARAM)(LPTBBUTTON)&tbb);
HeapFree(GetProcessHeap(), 0, MenuString);
}
return S_OK;
}
HRESULT CMenuStaticToolbar::GetWindow(HWND *phwnd)
{
if (!phwnd)
return E_FAIL;
*phwnd = m_hwnd;
return S_OK;
}
CMenuBand::CMenuBand()
{
m_site = NULL;
m_psmc = NULL;
m_staticToolbar = NULL;
}
CMenuBand::~CMenuBand()
{
if (m_site)
m_site->Release();
if (m_psmc)
m_psmc->Release();
if (m_staticToolbar)
delete m_staticToolbar;
}
HRESULT STDMETHODCALLTYPE CMenuBand::Initialize(
IShellMenuCallback *psmc,
UINT uId,
UINT uIdAncestor,
DWORD dwFlags)
{
if(m_psmc)
m_psmc->Release();
m_psmc = psmc;
m_uId = uId;
m_uIdAncestor = uIdAncestor;
m_dwFlags = dwFlags;
if (m_psmc)
m_psmc->AddRef();
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::GetMenuInfo(
IShellMenuCallback **ppsmc,
UINT *puId,
UINT *puIdAncestor,
DWORD *pdwFlags)
{
*ppsmc = m_psmc;
*puId = m_uId;
*puIdAncestor = m_uIdAncestor;
*pdwFlags = m_dwFlags;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::SetMenu(
HMENU hmenu,
HWND hwnd,
DWORD dwFlags)
{
if (m_staticToolbar == NULL)
m_staticToolbar = new CMenuStaticToolbar(this);
HRESULT hResult = m_staticToolbar->SetMenu(hmenu, hwnd, dwFlags);
if (FAILED(hResult))
return hResult;
if (m_site)
{
HWND hwndParent;
hResult = m_site->GetWindow(&hwndParent);
if (FAILED(hResult))
return hResult;
hResult = m_staticToolbar->CreateToolbar(hwndParent, m_dwFlags);
if (FAILED(hResult))
return hResult;
hResult = m_staticToolbar->FillToolbar();
}
return hResult;
}
HRESULT STDMETHODCALLTYPE CMenuBand::GetMenu(
HMENU *phmenu,
HWND *phwnd,
DWORD *pdwFlags)
{
if (m_staticToolbar == NULL)
return E_FAIL;
return m_staticToolbar->GetMenu(phmenu, phwnd, pdwFlags);
}
HRESULT STDMETHODCALLTYPE CMenuBand::SetSite(IUnknown *pUnkSite)
{
HWND hwndParent;
HRESULT hResult;
if (m_site != NULL)
m_site->Release();
if (pUnkSite == NULL)
return S_OK;
hwndParent = NULL;
hResult = pUnkSite->QueryInterface(IID_PPV_ARG(IOleWindow, &m_site));
if (SUCCEEDED(hResult))
{
m_site->GetWindow(&hwndParent);
m_site->Release();
}
if (!::IsWindow(hwndParent))
return E_FAIL;
if (m_staticToolbar != NULL)
{
m_staticToolbar->CreateToolbar(hwndParent, m_dwFlags);
m_staticToolbar->FillToolbar();
}
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::GetSite(REFIID riid, PVOID *ppvSite)
{
if (m_site == NULL)
return E_FAIL;
return m_site->QueryInterface(riid, ppvSite);
}
HRESULT STDMETHODCALLTYPE CMenuBand::GetWindow(
HWND *phwnd)
{
if (m_staticToolbar != NULL)
return m_staticToolbar->GetWindow(phwnd);
return E_FAIL;
}
HRESULT STDMETHODCALLTYPE CMenuBand::GetBandInfo(
DWORD dwBandID,
DWORD dwViewMode,
DESKBANDINFO *pdbi)
{
SIZE size;
HWND hwnd;
HRESULT hResult;
/* FIXME */
if (m_staticToolbar == NULL)
return E_FAIL;
hResult = m_staticToolbar->GetWindow(&hwnd);
if (FAILED(hResult))
return hResult;
if (hwnd == NULL)
return E_FAIL;
if (pdbi->dwMask & DBIM_MINSIZE)
{
SendMessageW( hwnd, TB_GETIDEALSIZE, TRUE, (LPARAM)&size);
pdbi->ptMinSize.x = 0;
pdbi->ptMinSize.y = size.cy;
}
if (pdbi->dwMask & DBIM_MAXSIZE)
{
SendMessageW( hwnd, TB_GETMAXSIZE, 0, (LPARAM)&size);
pdbi->ptMaxSize.x = size.cx;
pdbi->ptMaxSize.y = size.cy;
}
if (pdbi->dwMask & DBIM_INTEGRAL)
{
pdbi->ptIntegral.x = 0;
pdbi->ptIntegral.y = 0;
}
if (pdbi->dwMask & DBIM_ACTUAL)
{
SendMessageW( hwnd, TB_GETIDEALSIZE, TRUE, (LPARAM)&size);
SendMessageW( hwnd, TB_GETIDEALSIZE, FALSE, (LPARAM)&size);
pdbi->ptActual.x = size.cx;
pdbi->ptActual.y = size.cy;
}
if (pdbi->dwMask & DBIM_TITLE)
wcscpy(pdbi->wszTitle, L"");
if (pdbi->dwMask & DBIM_MODEFLAGS)
pdbi->dwModeFlags = DBIMF_UNDELETEABLE;
if (pdbi->dwMask & DBIM_BKCOLOR)
pdbi->crBkgnd = 0;
return S_OK;
}
/* IDockingWindow */
HRESULT STDMETHODCALLTYPE CMenuBand::ShowDW(BOOL fShow)
{
if (m_staticToolbar != NULL)
return m_staticToolbar->ShowWindow(fShow);
return E_FAIL;
}
HRESULT STDMETHODCALLTYPE CMenuBand::CloseDW(DWORD dwReserved)
{
ShowDW(FALSE);
if (m_staticToolbar != NULL)
return m_staticToolbar->Close();
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::ResizeBorderDW(LPCRECT prcBorder, IUnknown *punkToolbarSite, BOOL fReserved)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::ContextSensitiveHelp(BOOL fEnterMode)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::UIActivateIO(BOOL fActivate, LPMSG lpMsg)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::HasFocusIO()
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::TranslateAcceleratorIO(LPMSG lpMsg)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::IsDirty()
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::Load(IStream *pStm)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::Save(IStream *pStm, BOOL fClearDirty)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::GetSizeMax(ULARGE_INTEGER *pcbSize)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::GetClassID(CLSID *pClassID)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD prgCmds[ ], OLECMDTEXT *pCmdText)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::QueryService(REFGUID guidService, REFIID riid, void **ppvObject)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::Popup(POINTL *ppt, RECTL *prcExclude, MP_POPUPFLAGS dwFlags)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::OnSelect(DWORD dwSelectType)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::SetSubMenu(IMenuPopup *pmp, BOOL fSet)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::SetClient(IUnknown *punkClient)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::GetClient(IUnknown **ppunkClient)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::OnPosRectChangeDB(RECT *prc)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::IsMenuMessage(MSG *pmsg)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::TranslateMenuMessage(MSG *pmsg, LRESULT *plRet)
{
UNIMPLEMENTED;
return S_FALSE;
}
HRESULT STDMETHODCALLTYPE CMenuBand::SetShellFolder(IShellFolder *psf, LPCITEMIDLIST pidlFolder, HKEY hKey, DWORD dwFlags)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::GetShellFolder(DWORD *pdwFlags, LPITEMIDLIST *ppidl, REFIID riid, void **ppv)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::InvalidateItem(LPSMDATA psmd, DWORD dwFlags)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::GetState(LPSMDATA psmd)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::SetMenuToolbar(IUnknown *punk, DWORD dwFlags)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::OnWinEvent(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *theResult)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::IsWindowOwner(HWND hWnd)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::GetSubMenu(THIS)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::SetToolbar(THIS)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::SetMinWidth(THIS)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::SetNoBorder(THIS)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::SetTheme(THIS)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::GetTop(THIS)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::GetBottom(THIS)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::GetTracked(THIS)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::GetParentSite(THIS)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::GetState(THIS)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::DoDefaultAction(THIS)
{
UNIMPLEMENTED;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBand::IsEmpty(THIS)
{
UNIMPLEMENTED;
return S_OK;
}

164
reactos/dll/win32/shell32/CMenuBand.h
View file

@ -1,164 +0,0 @@
#pragma once
class CMenuBand;
class CMenuStaticToolbar
{
public:
CMenuStaticToolbar(CMenuBand *menuBand);
HRESULT CreateToolbar(HWND hwndParent, DWORD dwFlags);
HRESULT FillToolbar();
HRESULT GetWindow(HWND *phwnd);
HRESULT SetMenu(HMENU hmenu, HWND hwnd, DWORD dwFlags);
HRESULT GetMenu(HMENU *phmenu, HWND *phwnd, DWORD *pdwFlags);
HRESULT ShowWindow(BOOL fShow);
HRESULT Close();
private:
static const UINT WM_USER_SHOWPOPUPMENU = WM_USER + 1;
CMenuBand *m_menuBand;
HWND m_hwnd;
HMENU m_hmenu;
HWND m_hwndOwner;
DWORD m_dwMenuFlags;
};
class CMenuBand :
public CComCoClass<CMenuBand, &CLSID_MenuBand>,
public CComObjectRootEx<CComMultiThreadModelNoCS>,
public IDeskBand,
public IObjectWithSite,
public IInputObject,
public IPersistStream,
public IOleCommandTarget,
public IServiceProvider,
public IMenuPopup,
public IMenuBand,
public IShellMenu2,
public IWinEventHandler,
public IShellMenuAcc
{
public:
CMenuBand();
~CMenuBand();
private:
IOleWindow *m_site;
CMenuStaticToolbar *m_staticToolbar;
IShellMenuCallback *m_psmc;
UINT m_uId;
UINT m_uIdAncestor;
DWORD m_dwFlags;
public :
// *** IDeskBand methods ***
virtual HRESULT STDMETHODCALLTYPE GetBandInfo(DWORD dwBandID, DWORD dwViewMode, DESKBANDINFO *pdbi);
// *** IDockingWindow methods ***
virtual HRESULT STDMETHODCALLTYPE ShowDW(BOOL fShow);
virtual HRESULT STDMETHODCALLTYPE CloseDW(DWORD dwReserved);
virtual HRESULT STDMETHODCALLTYPE ResizeBorderDW(LPCRECT prcBorder, IUnknown *punkToolbarSite, BOOL fReserved);
// *** IOleWindow methods ***
virtual HRESULT STDMETHODCALLTYPE GetWindow(HWND *phwnd);
virtual HRESULT STDMETHODCALLTYPE ContextSensitiveHelp(BOOL fEnterMode);
// *** IObjectWithSite methods ***
virtual HRESULT STDMETHODCALLTYPE SetSite(IUnknown *pUnkSite);
virtual HRESULT STDMETHODCALLTYPE GetSite(REFIID riid, PVOID *ppvSite);
// *** IInputObject methods ***
virtual HRESULT STDMETHODCALLTYPE UIActivateIO(BOOL fActivate, LPMSG lpMsg);
virtual HRESULT STDMETHODCALLTYPE HasFocusIO();
virtual HRESULT STDMETHODCALLTYPE TranslateAcceleratorIO(LPMSG lpMsg);
// *** IPersistStream methods ***
virtual HRESULT STDMETHODCALLTYPE IsDirty();
virtual HRESULT STDMETHODCALLTYPE Load(IStream *pStm);
virtual HRESULT STDMETHODCALLTYPE Save(IStream *pStm, BOOL fClearDirty);
virtual HRESULT STDMETHODCALLTYPE GetSizeMax(ULARGE_INTEGER *pcbSize);
// *** IPersist methods ***
virtual HRESULT STDMETHODCALLTYPE GetClassID(CLSID *pClassID);
// *** IOleCommandTarget methods ***
virtual HRESULT STDMETHODCALLTYPE QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD prgCmds[ ], OLECMDTEXT *pCmdText);
virtual HRESULT STDMETHODCALLTYPE Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut);
// *** IServiceProvider methods ***
virtual HRESULT STDMETHODCALLTYPE QueryService(REFGUID guidService, REFIID riid, void **ppvObject);
// *** IMenuPopup methods ***
virtual HRESULT STDMETHODCALLTYPE Popup(POINTL *ppt, RECTL *prcExclude, MP_POPUPFLAGS dwFlags);
virtual HRESULT STDMETHODCALLTYPE OnSelect(DWORD dwSelectType);
virtual HRESULT STDMETHODCALLTYPE SetSubMenu(IMenuPopup *pmp, BOOL fSet);
// *** IDeskBar methods ***
virtual HRESULT STDMETHODCALLTYPE SetClient(IUnknown *punkClient);
virtual HRESULT STDMETHODCALLTYPE GetClient(IUnknown **ppunkClient);
virtual HRESULT STDMETHODCALLTYPE OnPosRectChangeDB(RECT *prc);
// *** IMenuBand methods ***
virtual HRESULT STDMETHODCALLTYPE IsMenuMessage(MSG *pmsg);
virtual HRESULT STDMETHODCALLTYPE TranslateMenuMessage(MSG *pmsg, LRESULT *plRet);
// *** IShellMenu methods ***
virtual HRESULT STDMETHODCALLTYPE Initialize(IShellMenuCallback *psmc, UINT uId, UINT uIdAncestor,DWORD dwFlags);
virtual HRESULT STDMETHODCALLTYPE GetMenuInfo(IShellMenuCallback **ppsmc, UINT *puId, UINT *puIdAncestor, DWORD *pdwFlags);
virtual HRESULT STDMETHODCALLTYPE SetShellFolder(IShellFolder *psf, LPCITEMIDLIST pidlFolder, HKEY hKey, DWORD dwFlags);
virtual HRESULT STDMETHODCALLTYPE GetShellFolder(DWORD *pdwFlags, LPITEMIDLIST *ppidl, REFIID riid, void **ppv);
virtual HRESULT STDMETHODCALLTYPE SetMenu(HMENU hmenu, HWND hwnd, DWORD dwFlags);
virtual HRESULT STDMETHODCALLTYPE GetMenu(HMENU *phmenu, HWND *phwnd, DWORD *pdwFlags);
virtual HRESULT STDMETHODCALLTYPE InvalidateItem(LPSMDATA psmd, DWORD dwFlags);
virtual HRESULT STDMETHODCALLTYPE GetState(LPSMDATA psmd);
virtual HRESULT STDMETHODCALLTYPE SetMenuToolbar(IUnknown *punk, DWORD dwFlags);
// *** IWinEventHandler methods ***
virtual HRESULT STDMETHODCALLTYPE OnWinEvent(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *theResult);
virtual HRESULT STDMETHODCALLTYPE IsWindowOwner(HWND hWnd);
// *** IShellMenu2 methods ***
virtual HRESULT STDMETHODCALLTYPE GetSubMenu(THIS);
virtual HRESULT STDMETHODCALLTYPE SetToolbar(THIS);
virtual HRESULT STDMETHODCALLTYPE SetMinWidth(THIS);
virtual HRESULT STDMETHODCALLTYPE SetNoBorder(THIS);
virtual HRESULT STDMETHODCALLTYPE SetTheme(THIS);
// *** IShellMenuAcc methods ***
virtual HRESULT STDMETHODCALLTYPE GetTop(THIS);
virtual HRESULT STDMETHODCALLTYPE GetBottom(THIS);
virtual HRESULT STDMETHODCALLTYPE GetTracked(THIS);
virtual HRESULT STDMETHODCALLTYPE GetParentSite(THIS);
virtual HRESULT STDMETHODCALLTYPE GetState(THIS);
virtual HRESULT STDMETHODCALLTYPE DoDefaultAction(THIS);
virtual HRESULT STDMETHODCALLTYPE IsEmpty(THIS);
DECLARE_REGISTRY_RESOURCEID(IDR_MENUBAND)
DECLARE_NOT_AGGREGATABLE(CMenuBand)
DECLARE_PROTECT_FINAL_CONSTRUCT()
BEGIN_COM_MAP(CMenuBand)
COM_INTERFACE_ENTRY_IID(IID_IDeskBar, IMenuPopup)
COM_INTERFACE_ENTRY_IID(IID_IShellMenu, IShellMenu)
COM_INTERFACE_ENTRY_IID(IID_IOleCommandTarget, IOleCommandTarget)
COM_INTERFACE_ENTRY_IID(IID_IOleWindow, IDeskBand)
COM_INTERFACE_ENTRY_IID(IID_IDockingWindow, IDockingWindow)
COM_INTERFACE_ENTRY_IID(IID_IDeskBand, IDeskBand)
COM_INTERFACE_ENTRY_IID(IID_IObjectWithSite, IObjectWithSite)
COM_INTERFACE_ENTRY_IID(IID_IInputObject, IInputObject)
COM_INTERFACE_ENTRY_IID(IID_IPersistStream, IPersistStream)
COM_INTERFACE_ENTRY_IID(IID_IPersist, IPersistStream)
COM_INTERFACE_ENTRY_IID(IID_IServiceProvider, IServiceProvider)
COM_INTERFACE_ENTRY_IID(IID_IMenuPopup, IMenuPopup)
COM_INTERFACE_ENTRY_IID(IID_IMenuBand, IMenuBand)
COM_INTERFACE_ENTRY_IID(IID_IShellMenu2, IShellMenu2)
COM_INTERFACE_ENTRY_IID(IID_IWinEventHandler, IWinEventHandler)
COM_INTERFACE_ENTRY_IID(IID_IShellMenuAcc, IShellMenuAcc)
END_COM_MAP()
};

137
reactos/dll/win32/shell32/CMenuDeskBar.cpp
View file

@ -1,137 +0,0 @@
#include "precomp.h"
HRESULT STDMETHODCALLTYPE CMenuDeskBar::Popup(
POINTL *ppt,
RECTL *prcExclude,
MP_POPUPFLAGS dwFlags)
{
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuDeskBar::OnSelect(
DWORD dwSelectType)
{
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuDeskBar::SetSubMenu(
IMenuPopup *pmp,
BOOL fSet)
{
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuDeskBar::SetClient(
IUnknown *punkClient)
{
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuDeskBar::GetClient(
IUnknown **ppunkClient)
{
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuDeskBar::OnPosRectChangeDB(
RECT *prc)
{
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuDeskBar::GetWindow(
HWND *phwnd)
{
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuDeskBar::ContextSensitiveHelp(
BOOL fEnterMode)
{
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuDeskBar::SetSite(
IUnknown *pUnkSite)
{
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuDeskBar::GetSite(
REFIID riid,
PVOID *ppvSite)
{
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuDeskBar::SetIconSize(THIS_ DWORD iIcon)
{
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuDeskBar::GetIconSize(THIS_ DWORD* piIcon)
{
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuDeskBar::SetBitmap(THIS_ HBITMAP hBitmap)
{
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuDeskBar::GetBitmap(THIS_ HBITMAP* phBitmap)
{
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuDeskBar::Initialize(THIS)
{
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuDeskBar::QueryStatus(
const GUID *pguidCmdGroup,
ULONG cCmds,
OLECMD prgCmds[],
OLECMDTEXT *pCmdText)
{
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuDeskBar::Exec(
const GUID *pguidCmdGroup,
DWORD nCmdID,
DWORD nCmdexecopt,
VARIANT *pvaIn,
VARIANT *pvaOut)
{
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuDeskBar::QueryService(
REFGUID guidService,
REFIID riid,
void **ppvObject)
{
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuDeskBar::OnFocusChangeIS(THIS_ IUnknown * lpUnknown, BOOL bFocus)
{
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuDeskBar::UIActivateIO(THIS_ BOOL bActivating, LPMSG lpMsg)
{
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuDeskBar::HasFocusIO(THIS)
{
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuDeskBar::TranslateAcceleratorIO(THIS_ LPMSG lpMsg)
{
return S_OK;
}

76
reactos/dll/win32/shell32/CMenuDeskBar.h
View file

@ -1,76 +0,0 @@
#pragma once
class CMenuDeskBar:
public CComCoClass<CMenuDeskBar, &CLSID_MenuDeskBar>,
public CComObjectRootEx<CComMultiThreadModelNoCS>,
public IOleCommandTarget,
public IServiceProvider,
public IInputObjectSite,
public IInputObject,
public IMenuPopup,
public IObjectWithSite,
public IBanneredBar,
public IInitializeObject
{
public:
// *** IMenuPopup methods ***
virtual HRESULT STDMETHODCALLTYPE Popup(POINTL *ppt, RECTL *prcExclude, MP_POPUPFLAGS dwFlags);
virtual HRESULT STDMETHODCALLTYPE OnSelect(DWORD dwSelectType);
virtual HRESULT STDMETHODCALLTYPE SetSubMenu(IMenuPopup *pmp,BOOL fSet);
// *** IDeskBar methods ***
virtual HRESULT STDMETHODCALLTYPE SetClient(IUnknown *punkClient);
virtual HRESULT STDMETHODCALLTYPE GetClient(IUnknown **ppunkClient);
virtual HRESULT STDMETHODCALLTYPE OnPosRectChangeDB(RECT *prc);
// *** IOleWindow methods ***
virtual HRESULT STDMETHODCALLTYPE GetWindow(HWND *phwnd);
virtual HRESULT STDMETHODCALLTYPE ContextSensitiveHelp(BOOL fEnterMode);
// *** IObjectWithSite methods ***
virtual HRESULT STDMETHODCALLTYPE SetSite(IUnknown *pUnkSite);
virtual HRESULT STDMETHODCALLTYPE GetSite(REFIID riid,PVOID *ppvSite);
// *** IBanneredBar methods ***
virtual HRESULT STDMETHODCALLTYPE SetIconSize(THIS_ DWORD iIcon);
virtual HRESULT STDMETHODCALLTYPE GetIconSize(THIS_ DWORD* piIcon);
virtual HRESULT STDMETHODCALLTYPE SetBitmap(THIS_ HBITMAP hBitmap);
virtual HRESULT STDMETHODCALLTYPE GetBitmap(THIS_ HBITMAP* phBitmap);
// *** IInitializeObject methods ***
virtual HRESULT STDMETHODCALLTYPE Initialize(THIS);
// *** IOleCommandTarget methods ***
virtual HRESULT STDMETHODCALLTYPE QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD prgCmds[], OLECMDTEXT *pCmdText);
virtual HRESULT STDMETHODCALLTYPE Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut);
// *** IServiceProvider methods ***
virtual HRESULT STDMETHODCALLTYPE QueryService(REFGUID guidService, REFIID riid, void **ppvObject);
// *** IInputObjectSite methods ***
virtual HRESULT STDMETHODCALLTYPE OnFocusChangeIS(THIS_ LPUNKNOWN lpUnknown, BOOL bFocus);
// *** IInputObject methods ***
virtual HRESULT STDMETHODCALLTYPE UIActivateIO(THIS_ BOOL bActivating, LPMSG lpMsg);
virtual HRESULT STDMETHODCALLTYPE HasFocusIO(THIS);
virtual HRESULT STDMETHODCALLTYPE TranslateAcceleratorIO(THIS_ LPMSG lpMsg);
DECLARE_REGISTRY_RESOURCEID(IDR_MENUDESKBAR)
DECLARE_NOT_AGGREGATABLE(CMenuDeskBar)
DECLARE_PROTECT_FINAL_CONSTRUCT()
BEGIN_COM_MAP(CMenuDeskBar)
COM_INTERFACE_ENTRY_IID(IID_IMenuPopup, IMenuPopup)
COM_INTERFACE_ENTRY_IID(IID_IOleCommandTarget, IOleCommandTarget)
COM_INTERFACE_ENTRY_IID(IID_IServiceProvider, IServiceProvider)
COM_INTERFACE_ENTRY_IID(IID_IInputObjectSite, IInputObjectSite)
COM_INTERFACE_ENTRY_IID(IID_IInputObject, IInputObject)
COM_INTERFACE_ENTRY_IID(IID_IDeskBar, IMenuPopup)
COM_INTERFACE_ENTRY_IID(IID_IOleWindow, IMenuPopup)
COM_INTERFACE_ENTRY_IID(IID_IObjectWithSite, IObjectWithSite)
COM_INTERFACE_ENTRY_IID(IID_IBanneredBar, IBanneredBar)
COM_INTERFACE_ENTRY_IID(IID_IInitializeObject, IInitializeObject)
END_COM_MAP()
};

345
reactos/dll/win32/shell32/CStartMenu.cpp
View file

@ -1,345 +0,0 @@
/*
* Start menu object
*
* Copyright 2009 Andrew Hill
*
* 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
*/
#include "precomp.h"
WINE_DEFAULT_DEBUG_CHANNEL(shell32start);
CStartMenu::CStartMenu() :
m_pBandSite(NULL),
m_pUnkSite(NULL)
{
}
CStartMenu::~CStartMenu()
{
}
HRESULT STDMETHODCALLTYPE CStartMenu::ContextSensitiveHelp(BOOL fEnterMode)
{
UNIMPLEMENTED;
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE CStartMenu::GetWindow(HWND *phwnd)
{
UNIMPLEMENTED;
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE CStartMenu::GetClient(IUnknown **ppunkClient)
{
TRACE("(%p, %p)\n", this, ppunkClient);
*ppunkClient = (IUnknown*)m_pBandSite;
(*ppunkClient)->AddRef();
return S_OK;
}
HRESULT STDMETHODCALLTYPE CStartMenu::OnPosRectChangeDB(LPRECT prc)
{
UNIMPLEMENTED;
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE CStartMenu::SetClient(IUnknown *punkClient)
{
UNIMPLEMENTED;
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE CStartMenu::OnSelect(DWORD dwSelectType)
{
UNIMPLEMENTED;
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE CStartMenu::Popup(POINTL *ppt, RECTL *prcExclude, MP_POPUPFLAGS dwFlags)
{
UNIMPLEMENTED;
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE CStartMenu::SetSubMenu(IMenuPopup *pmp, BOOL fSet)
{
UNIMPLEMENTED;
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE CStartMenu::SetSite(IUnknown *pUnkSite)
{
TRACE("(%p, %p)\n", this, pUnkSite);
if (m_pUnkSite)
m_pUnkSite->Release();
m_pUnkSite = pUnkSite;
if (m_pUnkSite)
m_pUnkSite->AddRef();
return S_OK;
}
HRESULT STDMETHODCALLTYPE CStartMenu::GetSite(REFIID riid, void **ppvSite)
{
TRACE("(%p, %s, %p)\n", this, debugstr_guid(&riid), ppvSite);
if (!m_pUnkSite)
return E_FAIL;
return m_pUnkSite->QueryInterface(riid, ppvSite);
}
HRESULT STDMETHODCALLTYPE CStartMenu::Initialize()
{
HRESULT hr;
CComObject<CMenuBandSite> *pBandSiteObj;
TRACE("(%p)\n", this);
//pBandSiteObj = new CComObject<CMenuBandSite>();
ATLTRY (pBandSiteObj = new CComObject<CMenuBandSite>);
if (pBandSiteObj == NULL)
return E_OUTOFMEMORY;
hr = pBandSiteObj->QueryInterface(IID_PPV_ARG(IBandSite, &m_pBandSite));
if (FAILED(hr))
return NULL;
return m_pBandSite->AddBand((IMenuBand*)this);
}
HRESULT STDMETHODCALLTYPE CStartMenu::IsMenuMessage(MSG *pmsg)
{
UNIMPLEMENTED;
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE CStartMenu::TranslateMenuMessage(MSG *pmsg, LRESULT *plRet)
{
UNIMPLEMENTED;
return E_NOTIMPL;
}
CMenuBandSite::CMenuBandSite() :
m_pObjects(NULL),
m_cObjects(0)
{
}
CMenuBandSite::~CMenuBandSite()
{
}
HRESULT STDMETHODCALLTYPE CMenuBandSite::AddBand(IUnknown *punk)
{
IUnknown **pObjects;
TRACE("punk %p\n", punk);
if (!punk)
return E_FAIL;
pObjects = (IUnknown**)CoTaskMemAlloc(sizeof(IUnknown*) * (m_cObjects + 1));
if (!pObjects)
return E_FAIL;
RtlMoveMemory(pObjects, m_pObjects, sizeof(IUnknown*) * m_cObjects);
CoTaskMemFree(m_pObjects);
m_pObjects = pObjects;
m_pObjects[m_cObjects] = punk;
punk->AddRef();
m_cObjects++;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBandSite::EnumBands(UINT uBand, DWORD *pdwBandID)
{
ULONG Index, ObjectCount;
TRACE("uBand %uu pdwBandID %p\n", uBand, pdwBandID);
if (uBand == (UINT)-1)
return m_cObjects;
ObjectCount = 0;
for (Index = 0; Index < m_cObjects; Index++)
{
if (m_pObjects[Index] != NULL)
{
if (uBand == ObjectCount)
{
*pdwBandID = Index;
return S_OK;
}
ObjectCount++;
}
}
return E_FAIL;
}
HRESULT STDMETHODCALLTYPE CMenuBandSite::QueryBand(DWORD dwBandID, IDeskBand **ppstb, DWORD *pdwState, LPWSTR pszName, int cchName)
{
UNIMPLEMENTED;
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE CMenuBandSite::SetBandState(DWORD dwBandID, DWORD dwMask, DWORD dwState)
{
UNIMPLEMENTED;
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE CMenuBandSite::RemoveBand(DWORD dwBandID)
{
TRACE("dwBandID %u\n", dwBandID);
if (m_cObjects <= dwBandID)
return E_FAIL;
if (m_pObjects[dwBandID])
{
m_pObjects[dwBandID]->Release();
m_pObjects[dwBandID] = NULL;
}
return S_OK;
}
HRESULT STDMETHODCALLTYPE CMenuBandSite::GetBandObject(DWORD dwBandID, REFIID riid, VOID **ppv)
{
TRACE("dwBandID %u riid %p ppv %p\n", dwBandID, riid, ppv);
if (m_cObjects <= dwBandID)
return E_FAIL;
if (m_pObjects[dwBandID])
{
return m_pObjects[dwBandID]->QueryInterface(riid, ppv);
}
return E_FAIL;
}
HRESULT STDMETHODCALLTYPE CMenuBandSite::SetBandSiteInfo(const BANDSITEINFO *pbsinfo)
{
UNIMPLEMENTED;
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE CMenuBandSite::GetBandSiteInfo(BANDSITEINFO *pbsinfo)
{
UNIMPLEMENTED;
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE CMenuBandSite::GetWindow(HWND *phwnd)
{
UNIMPLEMENTED;
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE CMenuBandSite::ContextSensitiveHelp(BOOL fEnterMode)
{
UNIMPLEMENTED;
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE CMenuBandSite::SetDeskBarSite(IUnknown *punkSite)
{
UNIMPLEMENTED;
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE CMenuBandSite::SetModeDBC(DWORD dwMode)
{
UNIMPLEMENTED;
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE CMenuBandSite::UIActivateDBC(DWORD dwState)
{
UNIMPLEMENTED;
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE CMenuBandSite::GetSize(DWORD dwWhich, LPRECT prc)
{
UNIMPLEMENTED;
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE CMenuBandSite::QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD prgCmds[ ], OLECMDTEXT *pCmdText)
{
UNIMPLEMENTED;
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE CMenuBandSite::Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
{
UNIMPLEMENTED;
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE CMenuBandSite::UIActivateIO(BOOL fActivate, LPMSG lpMsg)
{
UNIMPLEMENTED;
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE CMenuBandSite::HasFocusIO()
{
UNIMPLEMENTED;
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE CMenuBandSite::TranslateAcceleratorIO(LPMSG lpMsg)
{
UNIMPLEMENTED;
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE CMenuBandSite::OnFocusChangeIS(IUnknown *punkObj, BOOL fSetFocus)
{
UNIMPLEMENTED;
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE CMenuBandSite::OnWinEvent(HWND paramC, UINT param10, WPARAM param14, LPARAM param18, LRESULT *param1C)
{
UNIMPLEMENTED;
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE CMenuBandSite::IsWindowOwner(HWND paramC)
{
UNIMPLEMENTED;
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE CMenuBandSite::QueryService(REFGUID guidService, REFIID riid, void **ppvObject)
{
UNIMPLEMENTED;
return E_NOTIMPL;
}

155
reactos/dll/win32/shell32/CStartMenu.h
View file

@ -1,155 +0,0 @@
/*
* Start menu object
*
* Copyright 2009 Andrew Hill
*
* 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
*/
#ifndef _STARTMENU_H_
#define _STARTMENU_H_
class CStartMenu :
public CComCoClass<CStartMenu, &CLSID_StartMenu>,
public CComObjectRootEx<CComMultiThreadModelNoCS>,
public IMenuPopup,
public IObjectWithSite,
public IInitializeObject,
public IMenuBand // FIXME
{
private:
IBandSite *m_pBandSite;
IUnknown *m_pUnkSite;
public:
CStartMenu();
~CStartMenu();
// *** IOleWindow methods ***
virtual HRESULT STDMETHODCALLTYPE ContextSensitiveHelp(BOOL fEnterMode);
virtual HRESULT STDMETHODCALLTYPE GetWindow(HWND *phwnd);
// *** IDeskBar methods ***
virtual HRESULT STDMETHODCALLTYPE GetClient(IUnknown **ppunkClient);
virtual HRESULT STDMETHODCALLTYPE OnPosRectChangeDB(LPRECT prc);
virtual HRESULT STDMETHODCALLTYPE SetClient(IUnknown *punkClient);
// *** IMenuPopup methods ***
virtual HRESULT STDMETHODCALLTYPE OnSelect(DWORD dwSelectType);
virtual HRESULT STDMETHODCALLTYPE Popup(POINTL *ppt, RECTL *prcExclude, MP_POPUPFLAGS dwFlags);
virtual HRESULT STDMETHODCALLTYPE SetSubMenu(IMenuPopup *pmp, BOOL fSet);
// *** IObjectWithSite methods ***
virtual HRESULT STDMETHODCALLTYPE SetSite(IUnknown *pUnkSite);
virtual HRESULT STDMETHODCALLTYPE GetSite(REFIID riid, void **ppvSite);
// *** IInitializeObject methods ***
virtual HRESULT STDMETHODCALLTYPE Initialize();
// *** IMenuBand methods *** FIXME
virtual HRESULT STDMETHODCALLTYPE IsMenuMessage(MSG *pmsg);
virtual HRESULT STDMETHODCALLTYPE TranslateMenuMessage(MSG *pmsg, LRESULT *plRet);
DECLARE_REGISTRY_RESOURCEID(IDR_STARTMENU)
DECLARE_NOT_AGGREGATABLE(CStartMenu)
DECLARE_PROTECT_FINAL_CONSTRUCT()
BEGIN_COM_MAP(CStartMenu)
COM_INTERFACE_ENTRY_IID(IID_IOleWindow, IOleWindow)
COM_INTERFACE_ENTRY_IID(IID_IDeskBar, IDeskBar)
COM_INTERFACE_ENTRY_IID(IID_IMenuPopup, IMenuPopup)
COM_INTERFACE_ENTRY_IID(IID_IObjectWithSite, IObjectWithSite)
COM_INTERFACE_ENTRY_IID(IID_IInitializeObject, IInitializeObject)
COM_INTERFACE_ENTRY_IID(IID_IMenuBand, IMenuBand) // FIXME: Win does not export it
END_COM_MAP()
};
class CMenuBandSite :
public CComCoClass<CMenuBandSite, &CLSID_MenuBandSite>,
public CComObjectRootEx<CComMultiThreadModelNoCS>,
public IBandSite,
public IDeskBarClient,
public IOleCommandTarget,
public IInputObject,
public IInputObjectSite,
public IWinEventHandler,
public IServiceProvider
{
private:
IUnknown **m_pObjects;
ULONG m_cObjects;
public:
CMenuBandSite();
~CMenuBandSite();
// *** IBandSite methods ***
virtual HRESULT STDMETHODCALLTYPE AddBand(IUnknown *punk);
virtual HRESULT STDMETHODCALLTYPE EnumBands(UINT uBand, DWORD *pdwBandID);
virtual HRESULT STDMETHODCALLTYPE QueryBand(DWORD dwBandID, IDeskBand **ppstb, DWORD *pdwState, LPWSTR pszName, int cchName);
virtual HRESULT STDMETHODCALLTYPE SetBandState(DWORD dwBandID, DWORD dwMask, DWORD dwState);
virtual HRESULT STDMETHODCALLTYPE RemoveBand(DWORD dwBandID);
virtual HRESULT STDMETHODCALLTYPE GetBandObject(DWORD dwBandID, REFIID riid, VOID **ppv);
virtual HRESULT STDMETHODCALLTYPE SetBandSiteInfo(const BANDSITEINFO *pbsinfo);
virtual HRESULT STDMETHODCALLTYPE GetBandSiteInfo(BANDSITEINFO *pbsinfo);
// *** IOleWindow methods ***
virtual HRESULT STDMETHODCALLTYPE GetWindow(HWND *phwnd);
virtual HRESULT STDMETHODCALLTYPE ContextSensitiveHelp(BOOL fEnterMode);
// *** IDeskBarClient methods ***
virtual HRESULT STDMETHODCALLTYPE SetDeskBarSite(IUnknown *punkSite);
virtual HRESULT STDMETHODCALLTYPE SetModeDBC(DWORD dwMode);
virtual HRESULT STDMETHODCALLTYPE UIActivateDBC(DWORD dwState);
virtual HRESULT STDMETHODCALLTYPE GetSize(DWORD dwWhich, LPRECT prc);
// *** IOleCommandTarget methods ***
virtual HRESULT STDMETHODCALLTYPE QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD prgCmds[ ], OLECMDTEXT *pCmdText);
virtual HRESULT STDMETHODCALLTYPE Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut);
// *** IInputObject methods ***
virtual HRESULT STDMETHODCALLTYPE UIActivateIO(BOOL fActivate, LPMSG lpMsg);
virtual HRESULT STDMETHODCALLTYPE HasFocusIO();
virtual HRESULT STDMETHODCALLTYPE TranslateAcceleratorIO(LPMSG lpMsg);
// *** IInputObjectSite methods ***
virtual HRESULT STDMETHODCALLTYPE OnFocusChangeIS(IUnknown *punkObj, BOOL fSetFocus);
// *** IWinEventHandler methods ***
virtual HRESULT STDMETHODCALLTYPE OnWinEvent(HWND paramC, UINT param10, WPARAM param14, LPARAM param18, LRESULT *param1C);
virtual HRESULT STDMETHODCALLTYPE IsWindowOwner(HWND paramC);
// *** IServiceProvider methods ***
virtual HRESULT STDMETHODCALLTYPE QueryService(REFGUID guidService, REFIID riid, void **ppvObject);
DECLARE_REGISTRY_RESOURCEID(IDR_MENUBANDSITE)
DECLARE_NOT_AGGREGATABLE(CMenuBandSite)
DECLARE_PROTECT_FINAL_CONSTRUCT()
BEGIN_COM_MAP(CMenuBandSite)
COM_INTERFACE_ENTRY_IID(IID_IBandSite, IBandSite)
COM_INTERFACE_ENTRY_IID(IID_IOleWindow, IOleWindow)
COM_INTERFACE_ENTRY_IID(IID_IDeskBarClient, IDeskBarClient)
COM_INTERFACE_ENTRY_IID(IID_IOleCommandTarget, IOleCommandTarget)
COM_INTERFACE_ENTRY_IID(IID_IInputObject, IInputObject)
COM_INTERFACE_ENTRY_IID(IID_IInputObjectSite, IInputObjectSite)
COM_INTERFACE_ENTRY_IID(IID_IWinEventHandler, IWinEventHandler)
COM_INTERFACE_ENTRY_IID(IID_IServiceProvider, IServiceProvider)
END_COM_MAP()
};
#endif /* _STARTMENU_H_ */

5
reactos/dll/win32/shell32/iconcache.cpp
View file

@ -845,6 +845,11 @@ EXTERN_C INT WINAPI Shell_GetCachedImageIndexAW(LPCVOID szPath, INT nIndex, BOOL
return Shell_GetCachedImageIndexA((LPCSTR)szPath, nIndex, bSimulateDoc);
}
EXTERN_C INT WINAPI Shell_GetCachedImageIndex(LPCWSTR szPath, INT nIndex, UINT bSimulateDoc)
{
return Shell_GetCachedImageIndexAW(szPath, nIndex, bSimulateDoc);
}
/*************************************************************************
* ExtractIconExW [SHELL32.@]
* RETURNS

10
reactos/dll/win32/shell32/precomp.h
View file

@ -26,6 +26,7 @@
#include <strsafe.h>
#include <atlbase.h>
#include <atlcom.h>
#include <atlwin.h>
#include <powrprof.h>
#include <comctl32_undoc.h>
@ -61,12 +62,15 @@
#include "droptargets/CexeDropHandler.h"
#include "COpenWithMenu.h"
#include "CNewMenu.h"
#include "CStartMenu.h"
#include "filedefext.h"
#include "drvdefext.h"
#include "CMenuBand.h"
#include "CMenuDeskBar.h"
#include "CQueryAssociations.h"
#include "shellmenu/CBandSite.h"
#include "shellmenu/CMenuBand.h"
#include "shellmenu/CMenuDeskBar.h"
#include "shellmenu/CMenuSite.h"
#include "shellmenu/CMergedFolder.h"
#include "shellmenu/shellmenu.h"
#include <wine/debug.h>
#include <wine/unicode.h>

13
reactos/dll/win32/shell32/res/rgs/mergedfolder.rgs Normal file
View file

@ -0,0 +1,13 @@
HKCR
{
NoRemove CLSID
{
ForceRemove {26FDC864-BE88-46E7-9235-032D8EA5162E} = s 'Merged Shell Folder'
{
InprocServer32 = s '%MODULE%'
{
val ThreadingModel = s 'Apartment'
}
}
}
}

13
reactos/dll/win32/shell32/res/rgs/rebarbandsite.rgs Normal file
View file

@ -0,0 +1,13 @@
HKCR
{
NoRemove CLSID
{
ForceRemove {ECD4FC4D-521C-11D0-B792-00A0C90312E1} = s 'Shell Rebar Band Site'
{
InprocServer32 = s '%MODULE%'
{
val ThreadingModel = s 'Apartment'
}
}
}
}

4
reactos/dll/win32/shell32/rgs_res.rc
View file

@ -23,4 +23,6 @@ IDR_STARTMENU REGISTRY "res/rgs/startmenu.rgs"
IDR_OPENWITHMENU REGISTRY "res/rgs/openwithmenu.rgs"
IDR_FILEDEFEXT REGISTRY "res/rgs/shellfiledefext.rgs"
IDR_DRVDEFEXT REGISTRY "res/rgs/shelldrvdefext.rgs"
IDR_EXEDROPHANDLER REGISTRY "res/rgs/exedrophandler.rgs"
IDR_EXEDROPHANDLER REGISTRY "res/rgs/exedrophandler.rgs"
IDR_MERGEDFOLDER REGISTRY "res/rgs/mergedfolder.rgs"
IDR_REBARBANDSITE REGISTRY "res/rgs/rebarbandsite.rgs"

38
reactos/dll/win32/shell32/shell32.cpp
View file

@ -146,6 +146,38 @@ HRESULT WINAPI SHCreateDefClassObject(
return S_OK;
}
/**************************************************************************
* CStartMenuDummy
*/
class CStartMenuDummy :
public CComCoClass<CStartMenuDummy, &CLSID_StartMenu>,
public CComObjectRootEx<CComMultiThreadModelNoCS>
{
private:
CStartMenuDummy();
virtual ~CStartMenuDummy();
public:
DECLARE_REGISTRY_RESOURCEID(IDR_STARTMENU)
class _CreatorClass
{
public:
static STDMETHODIMP CreateInstance(void *pv, REFIID riid, LPVOID *ppv)
{
if (ppv == NULL)
return E_POINTER;
*ppv = NULL;
if (pv != NULL)
return CLASS_E_NOAGGREGATION;
return CStartMenu_Constructor(riid, ppv);
}
};
};
/**************************************************************************
* CShell32Module
*/
class CShell32Module : public CComModule
{
public:
@ -174,10 +206,12 @@ BEGIN_OBJECT_MAP(ObjectMap)
OBJECT_ENTRY(CLSID_RecycleBin, CRecycleBin)
OBJECT_ENTRY(CLSID_OpenWithMenu, COpenWithMenu)
OBJECT_ENTRY(CLSID_NewMenu, CNewMenu)
OBJECT_ENTRY(CLSID_StartMenu, CStartMenu)
OBJECT_ENTRY(CLSID_MenuBandSite, CMenuBandSite)
OBJECT_ENTRY(CLSID_StartMenu, CStartMenuDummy)
OBJECT_ENTRY(CLSID_MenuBandSite, CMenuSite)
OBJECT_ENTRY(CLSID_MenuBand, CMenuBand)
OBJECT_ENTRY(CLSID_MenuDeskBar, CMenuDeskBar)
OBJECT_ENTRY(CLSID_MergedFolder, CMergedFolder)
OBJECT_ENTRY(CLSID_RebarBandSite, CBandSite)
OBJECT_ENTRY(CLSID_ExeDropHandler, CExeDropHandler)
OBJECT_ENTRY(CLSID_QueryAssociations, CQueryAssociations)
END_OBJECT_MAP()

1
reactos/dll/win32/shell32/shellmenu/CBandSite.h
View file

@ -142,6 +142,7 @@ class CBandSite :
public CBandSiteBase
{
public:
DECLARE_REGISTRY_RESOURCEID(IDR_REBARBANDSITE)
DECLARE_AGGREGATABLE(CBandSite)
DECLARE_PROTECT_FINAL_CONSTRUCT()

2
reactos/dll/win32/shell32/shellmenu/CMenuBand.h
View file

@ -25,6 +25,7 @@ class CMenuSFToolbar;
class CMenuFocusManager;
class CMenuBand :
public CComCoClass<CMenuBand, &CLSID_MenuBand>,
public CComObjectRootEx<CComMultiThreadModelNoCS>,
public IDeskBand,
public IObjectWithSite,
@ -75,6 +76,7 @@ public:
CMenuBand();
virtual ~CMenuBand();
DECLARE_REGISTRY_RESOURCEID(IDR_MENUBAND)
DECLARE_NOT_AGGREGATABLE(CMenuBand)
DECLARE_PROTECT_FINAL_CONSTRUCT()

2
reactos/dll/win32/shell32/shellmenu/CMenuDeskBar.h
View file

@ -25,6 +25,7 @@ typedef CWinTraits<
> CMenuWinTraits;
class CMenuDeskBar :
public CComCoClass<CMenuDeskBar, &CLSID_MenuDeskBar>,
public CComObjectRootEx<CComMultiThreadModelNoCS>,
public CWindowImpl<CMenuDeskBar, CWindow, CMenuWinTraits>,
public IOleCommandTarget,
@ -57,6 +58,7 @@ public:
CMenuDeskBar();
virtual ~CMenuDeskBar();
DECLARE_REGISTRY_RESOURCEID(IDR_MENUDESKBAR)
DECLARE_NOT_AGGREGATABLE(CMenuDeskBar)
DECLARE_PROTECT_FINAL_CONSTRUCT()

2
reactos/dll/win32/shell32/shellmenu/CMenuSite.h
View file

@ -20,6 +20,7 @@
#pragma once
class CMenuSite :
public CComCoClass<CMenuSite, &CLSID_MenuBandSite>,
public CComObjectRootEx<CComMultiThreadModelNoCS>,
public CWindowImpl<CMenuSite, CWindow, CControlWinTraits>,
public IBandSite,
@ -43,6 +44,7 @@ public:
DECLARE_WND_CLASS_EX(_T("MenuSite"), 0, COLOR_MENU)
DECLARE_REGISTRY_RESOURCEID(IDR_MENUBANDSITE)
DECLARE_NOT_AGGREGATABLE(CMenuSite)
DECLARE_PROTECT_FINAL_CONSTRUCT()
BEGIN_COM_MAP(CMenuSite)

2
reactos/dll/win32/shell32/shellmenu/CMergedFolder.h
View file

@ -46,6 +46,7 @@ interface IAugmentedShellFolder3 : public IAugmentedShellFolder2
class CEnumMergedFolder;
class CMergedFolder :
public CComCoClass<CMergedFolder, &CLSID_MergedFolder>,
public CComObjectRootEx<CComMultiThreadModelNoCS>,
public IShellFolder2,
public IPersistFolder2,
@ -73,6 +74,7 @@ public:
HRESULT _SetSources(IShellFolder* userLocal, IShellFolder* allUSers);
DECLARE_REGISTRY_RESOURCEID(IDR_MERGEDFOLDER)
DECLARE_NOT_AGGREGATABLE(CMergedFolder)
DECLARE_PROTECT_FINAL_CONSTRUCT()

3
reactos/dll/win32/shell32/shellmenu/shellmenu.h
View file

@ -60,6 +60,7 @@
#include <shellutils.h>
#include <rosctrls.h>
#include "../shresdef.h"
#include <wine/debug.h>
@ -68,7 +69,7 @@
#pragma warning(pop)
#endif
#define shell32_hInstance 0
extern HINSTANCE shell32_hInstance;
extern "C" HRESULT WINAPI CStartMenu_Constructor(REFIID riid, void **ppv);
extern "C" HRESULT WINAPI CMenuDeskBar_Constructor(REFIID riid, LPVOID *ppv);

2
reactos/dll/win32/shell32/shresdef.h
View file

@ -580,3 +580,5 @@
#define IDR_MENUDESKBAR 150
#define IDR_EXEDROPHANDLER 151
#define IDR_QUERYASSOCIATIONS 152
#define IDR_MERGEDFOLDER 153
#define IDR_REBARBANDSITE 154