Microsoft/WindowsXP-SP1
Microsoft
/
WindowsXP-SP1
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
WindowsXP-SP1/shell/explorer/desktop2/moreprog.cpp

898 lines
26 KiB
C++
Raw Permalink Blame History

#include "stdafx.h"
#include "sfthost.h"
#include "hostutil.h"
#include "moreprog.h"
#include <desktray.h>
#include "tray.h" // To get access to c_tray
#include "rcids.h" // for IDM_PROGRAMS etc.
//
// Unfortunately, WTL #undef's SelectFont, so we have to define it again.
//
inline HFONT SelectFont(HDC hdc, HFONT hf)
{
return (HFONT)SelectObject(hdc, hf);
}
CMorePrograms::CMorePrograms(HWND hwnd) :
_lRef(1),
_hwnd(hwnd),
_clrText(CLR_INVALID),
_clrBk(CLR_INVALID)
{
}
CMorePrograms::~CMorePrograms()
{
if (_hf)
DeleteObject(_hf);
if (_hfTTBold)
DeleteObject(_hfTTBold);
if (_hfMarlett)
DeleteObject(_hfMarlett);
ATOMICRELEASE(_pdth);
ATOMICRELEASE(_psmPrograms);
// Note that we do not need to clean up our HWNDs.
// USER does that for us automatically.
}
//
// Metrics changed -- update.
//
void CMorePrograms::_InitMetrics()
{
if (_hwndTT)
{
MakeMultilineTT(_hwndTT);
// Disable/enable infotips based on user preference
SendMessage(_hwndTT, TTM_ACTIVATE, ShowInfoTip(), 0);
}
}
LRESULT CMorePrograms::_OnNCCreate(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
CMorePrograms *self = new CMorePrograms(hwnd);
if (self)
{
SetWindowLongPtr(hwnd, GWLP_USERDATA, (LPARAM)self);
return ::DefWindowProc(hwnd, uMsg, wParam, lParam);
}
return FALSE;
}
//
// Create an inner button that is exactly the right size.
//
// Height of inner button = height of text.
// Width of inner button = full width.
//
// This allows us to let USER do most of the work of hit-testing and
// focus rectangling.
//
LRESULT CMorePrograms::_OnCreate(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
_hTheme = (PaneDataFromCreateStruct(lParam))->hTheme;
if (!_hTheme)
{
_clrText = GetSysColor(COLOR_MENUTEXT);
_clrBk = GetSysColor(COLOR_MENU);
_hbrBk = GetSysColorBrush(COLOR_MENU);
_colorHighlight = COLOR_HIGHLIGHT;
_colorHighlightText = COLOR_HIGHLIGHTTEXT;
// should match proglist values, in sfthost.cpp
_margins.cxLeftWidth = 2*GetSystemMetrics(SM_CXEDGE);
_margins.cxRightWidth = 2*GetSystemMetrics(SM_CXEDGE);
}
else
{
GetThemeColor(_hTheme, SPP_MOREPROGRAMS, 0, TMT_TEXTCOLOR, &_clrText );
_hbrBk = (HBRUSH) GetStockObject(HOLLOW_BRUSH);
_colorHighlight = COLOR_MENUHILIGHT;
_colorHighlightText = COLOR_HIGHLIGHTTEXT;
// theme designer should make it so these margins match proglist's
GetThemeMargins(_hTheme, NULL, SPP_MOREPROGRAMS, 0, TMT_CONTENTMARGINS, NULL, &_margins);
// get the width of the arrow
SIZE siz = { 0, 0 };
GetThemePartSize(_hTheme, NULL, SPP_MOREPROGRAMSARROW, 0, NULL, TS_TRUE, &siz);
_cxArrow = siz.cx;
}
// If we're restricted, just create the window without doing any work
// We still need to paint our background, so we can't just fail the create
if(SHRestricted(REST_NOSMMOREPROGRAMS))
return TRUE;
if (!LoadString(_Module.GetResourceInstance(),
IDS_STARTPANE_MOREPROGRAMS, _szMessage, ARRAYSIZE(_szMessage)))
{
return FALSE;
}
// Find the accelerator
_chMnem = CharUpperChar(SHFindMnemonic(_szMessage));
_hf = LoadControlFont(_hTheme, SPP_MOREPROGRAMS, FALSE, 0);
// Get some information about the font the user has selected
// and create a Marlett font at a matching size.
TEXTMETRIC tm;
HDC hdc = GetDC(hwnd);
if (hdc)
{
HFONT hfPrev = SelectFont(hdc, _hf);
if (hfPrev)
{
SIZE sizText;
GetTextExtentPoint32(hdc, _szMessage, lstrlen(_szMessage), &sizText);
_cxText = sizText.cx + GetSystemMetrics(SM_CXEDGE); // chevron should be a little right of the text
if (GetTextMetrics(hdc, &tm))
{
_tmAscent = tm.tmAscent;
LOGFONT lf;
ZeroMemory(&lf, sizeof(lf));
lf.lfHeight = _tmAscent;
lf.lfWeight = FW_NORMAL;
lf.lfCharSet = SYMBOL_CHARSET;
lstrcpy(lf.lfFaceName, TEXT("Marlett"));
_hfMarlett = CreateFontIndirect(&lf);
if (_hfMarlett)
{
SelectFont(hdc, _hfMarlett);
if (GetTextMetrics(hdc, &tm))
{
_tmAscentMarlett = tm.tmAscent;
}
if (0 == _cxArrow) // if we're not themed, or the GetThemePartSize failed,
{
// set the width of the Marlett arrow into _cxArrow
GetTextExtentPoint32(hdc, GetLayout(hdc) & LAYOUT_RTL ? TEXT("w") : TEXT("8"), 1, &sizText);
_cxArrow = sizText.cx;
}
}
}
SelectFont(hdc, hfPrev);
}
ReleaseDC(hwnd, hdc);
}
if (!_tmAscentMarlett)
{
return FALSE;
}
// This is the same large icon setting from proglist
BOOL bLargeIcons = SHRegGetBoolUSValue(REGSTR_EXPLORER_ADVANCED, REGSTR_VAL_DV2_LARGEICONS, FALSE, TRUE /* default to large*/);
RECT rc;
GetClientRect(_hwnd, &rc);
rc.left += _margins.cxLeftWidth;
rc.right -= _margins.cxRightWidth;
rc.top += _margins.cyTopHeight;
rc.bottom -= _margins.cyBottomHeight;
// Compute the text indent value, so more programs lines up with text on icons in programs list
_cxTextIndent = (3 * GetSystemMetrics(SM_CXEDGE)) + // 2 between icon&text + 1 before icon
GetSystemMetrics(bLargeIcons ? SM_CXICON : SM_CXSMICON);
// truncate the indent, if the text won't fit in the given area
if (_cxTextIndent > RECTWIDTH(rc) - (_cxText + _cxArrow))
{
TraceMsg(TF_WARNING, "StartMenu: '%s' is %dpx, only room for %d- notify localizers!",_szMessage, _cxText, RECTWIDTH(rc)-(_cxArrow+_cxTextIndent));
_cxTextIndent = max(0, RECTWIDTH(rc) - (_cxText + _cxArrow));
}
ASSERT(RECTHEIGHT(rc) > _tmAscent);
_iTextCenterVal = (RECTHEIGHT(rc) - _tmAscent) / 2;
// Do not set WS_TABSTOP or WS_GROUP; CMorePrograms handles that
// BS_NOTIFY ensures that we get BN_SETFOCUS and BN_KILLFOCUS
DWORD dwStyle = WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_VISIBLE |
BS_OWNERDRAW;
_hwndButton = CreateWindowEx(0, TEXT("button"), _szMessage, dwStyle,
rc.left, rc.top, RECTWIDTH(rc), RECTHEIGHT(rc),
_hwnd, (HMENU)IntToPtr(IDC_BUTTON),
_Module.GetModuleInstance(), NULL);
if (!_hwndButton)
{
return FALSE;
}
//
// Don't freak out if this fails. It just means that the accessibility
// stuff won't be perfect.
//
SetAccessibleSubclassWindow(_hwndButton);
if (_hf)
SetWindowFont(_hwndButton, _hf, FALSE);
// Unlike the button itself, failure to create the tooltip is nonfatal.
// only create the tooltip if auto-cascade is off
if (!SHRegGetBoolUSValue(REGSTR_EXPLORER_ADVANCED, REGSTR_VAL_DV2_AUTOCASCADE, FALSE, TRUE))
_hwndTT = _CreateTooltip();
_InitMetrics();
// We can survive if this fails to be created
CoCreateInstance(CLSID_DragDropHelper, NULL, CLSCTX_INPROC_SERVER,
IID_PPV_ARG(IDropTargetHelper, &_pdth));
//
// If this fails, no big whoop - you just don't get
// drag/drop, boo hoo.
//
RegisterDragDrop(_hwndButton, this);
return TRUE;
}
HWND CMorePrograms::_CreateTooltip()
{
DWORD dwStyle = WS_BORDER | TTS_NOPREFIX;
HWND hwnd = CreateWindowEx(0, TOOLTIPS_CLASS, NULL, dwStyle,
0, 0, 0, 0,
_hwndButton, NULL,
_Module.GetModuleInstance(), NULL);
if (hwnd)
{
TCHAR szBuf[MAX_PATH];
TOOLINFO ti;
ti.cbSize = sizeof(ti);
ti.hwnd = _hwnd;
ti.uId = reinterpret_cast<UINT_PTR>(_hwndButton);
ti.uFlags = TTF_IDISHWND | TTF_SUBCLASS;
ti.hinst = _Module.GetResourceInstance();
// We can't use MAKEINTRESOURCE because that allows only up to 80
// characters for text, and our text can be longer than that.
UINT ids = IDS_STARTPANE_MOREPROGRAMS_TIP;
ti.lpszText = szBuf;
if (LoadString(_Module.GetResourceInstance(), ids, szBuf, ARRAYSIZE(szBuf)))
{
SendMessage(hwnd, TTM_ADDTOOL, 0, reinterpret_cast<LPARAM>(&ti));
}
}
return hwnd;
}
LRESULT CMorePrograms::_OnDestroy(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
RevokeDragDrop(_hwndButton);
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
LRESULT CMorePrograms::_OnNCDestroy(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
// WARNING! "this" might be invalid (if WM_NCCREATE failed), so
// do not use any member variables!
LRESULT lres = DefWindowProc(hwnd, uMsg, wParam, lParam);
SetWindowPtr0(hwnd, 0);
if (this)
{
this->Release();
}
return lres;
}
LRESULT CMorePrograms::_OnCtlColorBtn(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
HDC hdc = reinterpret_cast<HDC>(wParam);
if (_clrText != CLR_INVALID)
{
SetTextColor(hdc, _clrText);
}
if (_clrBk != CLR_INVALID)
{
SetBkColor(hdc, _clrBk);
}
return reinterpret_cast<LRESULT>(_hbrBk);
}
LRESULT CMorePrograms::_OnDrawItem(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LPDRAWITEMSTRUCT pdis = reinterpret_cast<LPDRAWITEMSTRUCT>(lParam);
ASSERT(pdis->CtlType == ODT_BUTTON);
ASSERT(pdis->CtlID == IDC_BUTTON);
if (pdis->itemAction & (ODA_DRAWENTIRE | ODA_FOCUS))
{
BOOL fRTLReading = GetLayout(pdis->hDC) & LAYOUT_RTL;
UINT fuOptions = 0;
if (fRTLReading)
{
fuOptions |= ETO_RTLREADING;
}
HFONT hfPrev = SelectFont(pdis->hDC, _hf);
if (hfPrev)
{
BOOL fHot = (pdis->itemState & ODS_FOCUS) || _tmHoverStart;
if (fHot)
{
// hot background
FillRect(pdis->hDC, &pdis->rcItem, GetSysColorBrush(_colorHighlight));
SetTextColor(pdis->hDC, GetSysColor(_colorHighlightText));
}
else if (_hTheme)
{
// Themed non-hot background = custom
RECT rc;
GetClientRect(hwnd, &rc);
MapWindowRect(hwnd, pdis->hwndItem, &rc);
DrawThemeBackground(_hTheme, pdis->hDC, SPP_MOREPROGRAMS, 0, &rc, 0);
}
else
{
// non-themed non-hot background
FillRect(pdis->hDC, &pdis->rcItem, _hbrBk);
}
int iOldMode = SetBkMode(pdis->hDC, TRANSPARENT);
// _cxTextIndent will move it in the current width of an icon (small or large), plus the space we add between an icon and the text
pdis->rcItem.left += _cxTextIndent;
UINT dtFlags = DT_VCENTER | DT_SINGLELINE | DT_EDITCONTROL;
if (fRTLReading)
{
dtFlags |= DT_RTLREADING;
}
if (pdis->itemState & ODS_NOACCEL)
{
dtFlags |= DT_HIDEPREFIX;
}
DrawText(pdis->hDC, _szMessage, -1, &pdis->rcItem, dtFlags);
RECT rc = pdis->rcItem;
rc.left += _cxText;
if (_hTheme)
{
if (_iTextCenterVal < 0) // text is taller than the bitmap
rc.top += (-_iTextCenterVal);
rc.right = rc.left + _cxArrow; // clip rectangle down to the minumum size...
DrawThemeBackground(_hTheme, pdis->hDC, SPP_MOREPROGRAMSARROW,
fHot ? SPS_HOT : 0, &rc, 0);
}
else
{
if (SelectFont(pdis->hDC, _hfMarlett))
{
rc.top = rc.top + _tmAscent - _tmAscentMarlett + (_iTextCenterVal > 0 ? _iTextCenterVal : 0);
TCHAR chOut = fRTLReading ? TEXT('w') : TEXT('8');
if (EVAL(!IsRectEmpty(&rc)))
{
ExtTextOut(pdis->hDC, rc.left, rc.top, fuOptions, &rc, &chOut, 1, NULL);
rc.right = rc.left + _cxArrow;
}
}
}
_rcExclude = rc;
_rcExclude.left -= _cxText; // includes the text in the exclusion rectangle.
MapWindowRect(pdis->hwndItem, NULL, &_rcExclude);
SetBkMode(pdis->hDC, iOldMode);
SelectFont(pdis->hDC, hfPrev);
}
}
//
// Since we are emulating a menu item, we don't need to draw a
// focus rectangle.
//
return TRUE;
}
void CMorePrograms::_TrackShellMenu(DWORD dwFlags)
{
// Pop the balloon tip and tell the Start Menu not to offer it any more
_PopBalloon();
_SendNotify(_hwnd, SMN_SEENNEWITEMS);
SMNTRACKSHELLMENU tsm;
tsm.itemID = 0;
tsm.dwFlags = dwFlags;
if (!_psmPrograms)
{
CoCreateInstance(CLSID_PersonalStartMenu, NULL, CLSCTX_INPROC,
IID_PPV_ARG(IShellMenu, &_psmPrograms));
}
if (_psmPrograms)
{
tsm.psm = _psmPrograms;
tsm.rcExclude = _rcExclude;
HWND hwnd = _hwnd;
_fMenuOpen = TRUE;
_SendNotify(_hwnd, SMN_TRACKSHELLMENU, &tsm.hdr);
}
}
LRESULT CMorePrograms::_OnCommand(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (GET_WM_COMMAND_ID(wParam, lParam))
{
case IDC_BUTTON:
switch (GET_WM_COMMAND_CMD(wParam, lParam))
{
case BN_CLICKED:
_TrackShellMenu(0);
break;
}
break;
case IDC_KEYPRESS:
_TrackShellMenu(MPPF_KEYBOARD | MPPF_INITIALSELECT);
break;
}
return 0;
}
LRESULT CMorePrograms::_OnEraseBkgnd(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
RECT rc;
GetClientRect(hwnd, &rc);
if (_hTheme)
{
DrawThemeBackground(_hTheme, (HDC)wParam, SPP_MOREPROGRAMS, 0, &rc, 0);
}
else
SHFillRectClr((HDC)wParam, &rc, _clrBk);
return 0;
}
LRESULT CMorePrograms::_OnNotify(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LPNMHDR pnm = reinterpret_cast<LPNMHDR>(lParam);
switch (pnm->code)
{
case SMN_FINDITEM:
return _OnSMNFindItem(CONTAINING_RECORD(pnm, SMNDIALOGMESSAGE, hdr));
case SMN_SHOWNEWAPPSTIP:
return _OnSMNShowNewAppsTip(CONTAINING_RECORD(pnm, SMNMBOOL, hdr));
case SMN_DISMISS:
return _OnSMNDismiss();
case SMN_APPLYREGION:
return HandleApplyRegion(_hwnd, _hTheme, (SMNMAPPLYREGION *)lParam, SPP_MOREPROGRAMS, 0);
case SMN_SHELLMENUDISMISSED:
_fMenuOpen = FALSE;
return 0;
}
return 0;
}
LRESULT CMorePrograms::_OnSMNFindItem(PSMNDIALOGMESSAGE pdm)
{
if(SHRestricted(REST_NOSMMOREPROGRAMS))
return 0;
switch (pdm->flags & SMNDM_FINDMASK)
{
// Life is simple if you have only one item -- all searches succeed!
case SMNDM_FINDFIRST:
case SMNDM_FINDLAST:
case SMNDM_FINDNEAREST:
case SMNDM_HITTEST:
pdm->itemID = 0;
return TRUE;
case SMNDM_FINDFIRSTMATCH:
{
TCHAR tch = CharUpperChar((TCHAR)pdm->pmsg->wParam);
if (tch == _chMnem)
{
pdm->itemID = 0;
return TRUE;
}
}
break; // not found
case SMNDM_FINDNEXTMATCH:
break; // there is only one item so there can't be a "next"
case SMNDM_FINDNEXTARROW:
if (pdm->flags & SMNDM_TRYCASCADE)
{
FORWARD_WM_COMMAND(_hwnd, IDC_KEYPRESS, NULL, 0, PostMessage);
return TRUE;
}
break; // not found
case SMNDM_INVOKECURRENTITEM:
case SMNDM_OPENCASCADE:
if (pdm->flags & SMNDM_KEYBOARD)
{
FORWARD_WM_COMMAND(_hwnd, IDC_KEYPRESS, NULL, 0, PostMessage);
}
else
{
FORWARD_WM_COMMAND(_hwnd, IDC_BUTTON, NULL, 0, PostMessage);
}
return TRUE;
case SMNDM_FINDITEMID:
return TRUE;
default:
ASSERT(!"Unknown SMNDM command");
break;
}
//
// If not found, then tell caller what our orientation is (vertical)
// and where the currently-selected item is.
//
pdm->flags |= SMNDM_VERTICAL;
pdm->pt.x = 0;
pdm->pt.y = 0;
return FALSE;
}
//
// The boolean parameter in the SMNMBOOL tells us whether to display or
// hide the balloon tip.
//
LRESULT CMorePrograms::_OnSMNShowNewAppsTip(PSMNMBOOL psmb)
{
if(SHRestricted(REST_NOSMMOREPROGRAMS))
return 0;
if (psmb->f)
{
if (_hwndTT)
{
SendMessage(_hwndTT, TTM_ACTIVATE, FALSE, 0);
}
if (!_hwndBalloon)
{
RECT rc;
GetWindowRect(_hwndButton, &rc);
if (!_hfTTBold)
{
NONCLIENTMETRICS ncm;
ncm.cbSize = sizeof(ncm);
if (SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(ncm), &ncm, 0))
{
ncm.lfStatusFont.lfWeight = FW_BOLD;
SHAdjustLOGFONT(&ncm.lfStatusFont);
_hfTTBold = CreateFontIndirect(&ncm.lfStatusFont);
}
}
_hwndBalloon = CreateBalloonTip(_hwnd,
rc.left + _cxTextIndent + _cxText,
(rc.top + rc.bottom)/2,
_hfTTBold, 0,
IDS_STARTPANE_MOREPROGRAMS_BALLOONTITLE);
if (_hwndBalloon)
{
SetProp(_hwndBalloon, PROP_DV2_BALLOONTIP, DV2_BALLOONTIP_MOREPROG);
}
}
}
else
{
_PopBalloon();
}
return 0;
}
void CMorePrograms::_PopBalloon()
{
if (_hwndBalloon)
{
DestroyWindow(_hwndBalloon);
_hwndBalloon = NULL;
}
if (_hwndTT)
{
SendMessage(_hwndTT, TTM_ACTIVATE, TRUE, 0);
}
}
LRESULT CMorePrograms::_OnSMNDismiss()
{
_PopBalloon();
return 0;
}
LRESULT CMorePrograms::_OnSysColorChange(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
// update colors in classic mode
if (!_hTheme)
{
_clrText = GetSysColor(COLOR_MENUTEXT);
_clrBk = GetSysColor(COLOR_MENU);
_hbrBk = GetSysColorBrush(COLOR_MENU);
}
SHPropagateMessage(hwnd, uMsg, wParam, lParam, SPM_SEND | SPM_ONELEVEL);
return 0;
}
LRESULT CMorePrograms::_OnDisplayChange(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
_InitMetrics();
SHPropagateMessage(hwnd, uMsg, wParam, lParam, SPM_SEND | SPM_ONELEVEL);
return 0;
}
LRESULT CMorePrograms::_OnSettingChange(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
// _InitMetrics() is so cheap it's not worth getting too upset about
// calling it too many times.
_InitMetrics();
SHPropagateMessage(hwnd, uMsg, wParam, lParam, SPM_SEND | SPM_ONELEVEL);
return 0;
}
LRESULT CMorePrograms::_OnContextMenu(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
if(SHRestricted(REST_NOSMMOREPROGRAMS))
return 0;
if (IS_WM_CONTEXTMENU_KEYBOARD(lParam))
{
RECT rc;
GetWindowRect(_hwnd, &rc);
lParam = MAKELPARAM(rc.left, rc.top);
}
c_tray.StartMenuContextMenu(_hwnd, (DWORD)lParam);
return 0;
}
LRESULT CALLBACK CMorePrograms::s_WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
CMorePrograms *self = reinterpret_cast<CMorePrograms *>(GetWindowPtr(hwnd, GWLP_USERDATA));
switch (uMsg)
{
case WM_NCCREATE:
return self->_OnNCCreate(hwnd, uMsg, wParam, lParam);
case WM_CREATE:
return self->_OnCreate(hwnd, uMsg, wParam, lParam);
case WM_DESTROY:
return self->_OnDestroy(hwnd, uMsg, wParam, lParam);
case WM_NCDESTROY:
return self->_OnNCDestroy(hwnd, uMsg, wParam, lParam);
case WM_CTLCOLORBTN:
return self->_OnCtlColorBtn(hwnd, uMsg, wParam, lParam);
case WM_DRAWITEM:
return self->_OnDrawItem(hwnd, uMsg, wParam, lParam);
case WM_ERASEBKGND:
return self->_OnEraseBkgnd(hwnd, uMsg, wParam, lParam);
case WM_COMMAND:
return self->_OnCommand(hwnd, uMsg, wParam, lParam);
case WM_SYSCOLORCHANGE:
return self->_OnSysColorChange(hwnd, uMsg, wParam, lParam);
case WM_DISPLAYCHANGE:
return self->_OnDisplayChange(hwnd, uMsg, wParam, lParam);
case WM_SETTINGCHANGE:
return self->_OnSettingChange(hwnd, uMsg, wParam, lParam);
case WM_NOTIFY:
return self->_OnNotify(hwnd, uMsg, wParam, lParam);
case WM_CONTEXTMENU:
return self->_OnContextMenu(hwnd, uMsg, wParam, lParam);
}
return ::DefWindowProc(hwnd, uMsg, wParam, lParam);
}
BOOL WINAPI MorePrograms_RegisterClass()
{
WNDCLASSEX wc;
ZeroMemory(&wc, sizeof(wc));
wc.cbSize = sizeof(wc);
wc.style = CS_GLOBALCLASS;
wc.lpfnWndProc = CMorePrograms::s_WndProc;
wc.hInstance = _Module.GetModuleInstance();
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = NULL;
wc.lpszClassName = WC_MOREPROGRAMS;
return RegisterClassEx(&wc);
}
// We implement a minimal drop target so we can auto-open the More Programs
// list when the user hovers over the More Programs button.
// *** IUnknown ***
HRESULT CMorePrograms::QueryInterface(REFIID riid, void * *ppvOut)
{
static const QITAB qit[] = {
QITABENT(CMorePrograms, IDropTarget),
QITABENT(CMorePrograms, IAccessible),
QITABENT(CMorePrograms, IDispatch), // IAccessible derives from IDispatch
{ 0 },
};
return QISearch(this, qit, riid, ppvOut);
}
ULONG CMorePrograms::AddRef()
{
return InterlockedIncrement(&_lRef);
}
ULONG CMorePrograms::Release()
{
ULONG cRef = InterlockedDecrement(&_lRef);
if (cRef)
return cRef;
delete this;
return 0;
}
// *** IDropTarget::DragEnter ***
HRESULT CMorePrograms::DragEnter(IDataObject *pdto, DWORD grfKeyState, POINTL ptl, DWORD *pdwEffect)
{
POINT pt = { ptl.x, ptl.y };
if (_pdth) {
_pdth->DragEnter(_hwnd, pdto, &pt, *pdwEffect);
}
// Remember when the hover started.
_tmHoverStart = NonzeroGetTickCount();
InvalidateRect(_hwndButton, NULL, TRUE); // draw with drop highlight
return DragOver(grfKeyState, ptl, pdwEffect);
}
// *** IDropTarget::DragOver ***
HRESULT CMorePrograms::DragOver(DWORD grfKeyState, POINTL ptl, DWORD *pdwEffect)
{
POINT pt = { ptl.x, ptl.y };
if (_pdth) {
_pdth->DragOver(&pt, *pdwEffect);
}
// Hover time is 1 second, the same as the hard-coded value for the
// Start Button.
if (_tmHoverStart && GetTickCount() - _tmHoverStart > 1000)
{
_tmHoverStart = 0;
FORWARD_WM_COMMAND(_hwnd, IDC_BUTTON, _hwndButton, BN_CLICKED, PostMessage);
}
*pdwEffect = DROPEFFECT_NONE;
return S_OK;
}
// *** IDropTarget::DragLeave ***
HRESULT CMorePrograms::DragLeave()
{
if (_pdth) {
_pdth->DragLeave();
}
_tmHoverStart = 0;
InvalidateRect(_hwndButton, NULL, TRUE); // draw without drop highlight
return S_OK;
}
// *** IDropTarget::Drop ***
HRESULT CMorePrograms::Drop(IDataObject *pdto, DWORD grfKeyState, POINTL ptl, DWORD *pdwEffect)
{
POINT pt = { ptl.x, ptl.y };
if (_pdth) {
_pdth->Drop(pdto, &pt, *pdwEffect);
}
_tmHoverStart = 0;
InvalidateRect(_hwndButton, NULL, TRUE); // draw without drop highlight
return S_OK;
}
//****************************************************************************
//
// Accessibility
//
//
// The default accessibility object reports buttons as
// ROLE_SYSTEM_PUSHBUTTON, but we know that we are really a menu.
//
HRESULT CMorePrograms::get_accRole(VARIANT varChild, VARIANT *pvarRole)
{
HRESULT hr = CAccessible::get_accRole(varChild, pvarRole);
if (SUCCEEDED(hr) && V_VT(pvarRole) == VT_I4)
{
switch (V_I4(pvarRole))
{
case ROLE_SYSTEM_PUSHBUTTON:
V_I4(pvarRole) = ROLE_SYSTEM_MENUITEM;
break;
}
}
return hr;
}
HRESULT CMorePrograms::get_accState(VARIANT varChild, VARIANT *pvarState)
{
HRESULT hr = CAccessible::get_accState(varChild, pvarState);
if (SUCCEEDED(hr) && V_VT(pvarState) == VT_I4)
{
V_I4(pvarState) |= STATE_SYSTEM_HASPOPUP;
}
return hr;
}
HRESULT CMorePrograms::get_accKeyboardShortcut(VARIANT varChild, BSTR *pszKeyboardShortcut)
{
return CreateAcceleratorBSTR(_chMnem, pszKeyboardShortcut);
}
HRESULT CMorePrograms::get_accDefaultAction(VARIANT varChild, BSTR *pszDefAction)
{
DWORD dwRole = _fMenuOpen ? ACCSTR_CLOSE : ACCSTR_OPEN;
return GetRoleString(dwRole, pszDefAction);
}
HRESULT CMorePrograms::accDoDefaultAction(VARIANT varChild)
{
if (_fMenuOpen)
{
_SendNotify(_hwnd, SMN_CANCELSHELLMENU);
return S_OK;
}
else
{
return CAccessible::accDoDefaultAction(varChild);
}
}
Reference in New Issue View Git Blame Copy Permalink