[SHELL32] -CMenuBand: forward WM_WININICHANGE to CMenuToolbarBase so that when themes...
[reactos.git] / reactos / dll / win32 / shell32 / shellmenu / CMenuToolbars.cpp
1 /*
2 * Shell Menu Band
3 *
4 * Copyright 2014 David Quintana
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20 #include "shellmenu.h"
21 #include <commoncontrols.h>
22 #include <shlwapi_undoc.h>
23 #include <uxtheme.h>
24 #include <vssym32.h>
25
26 #include "CMenuBand.h"
27 #include "CMenuToolbars.h"
28
29 #define IDS_MENU_EMPTY 34561
30
31 #define GET_X_LPARAM(lp) ((int)(short)LOWORD(lp))
32 #define GET_Y_LPARAM(lp) ((int)(short)HIWORD(lp))
33
34 WINE_DEFAULT_DEBUG_CHANNEL(CMenuToolbars);
35
36 // FIXME: Enable if/when wine comctl supports this flag properly
37 #define USE_TBSTYLE_EX_VERTICAL 0
38
39 // User-defined timer ID used while hot-tracking around the menu
40 #define TIMERID_HOTTRACK 1
41
42 LRESULT CMenuToolbarBase::OnWinEventWrap(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
43 {
44 LRESULT lr;
45 bHandled = OnWinEvent(m_hWnd, uMsg, wParam, lParam, &lr) != S_FALSE;
46 return lr;
47 }
48
49 HRESULT CMenuToolbarBase::OnWinEvent(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *theResult)
50 {
51 NMHDR * hdr;
52
53 *theResult = 0;
54 switch (uMsg)
55 {
56 case WM_COMMAND:
57 //return OnCommand(wParam, lParam, theResult);
58 return S_OK;
59
60 case WM_NOTIFY:
61 hdr = reinterpret_cast<LPNMHDR>(lParam);
62 switch (hdr->code)
63 {
64 case TBN_DELETINGBUTTON:
65 return OnDeletingButton(reinterpret_cast<LPNMTOOLBAR>(hdr));
66
67 case PGN_CALCSIZE:
68 return OnPagerCalcSize(reinterpret_cast<LPNMPGCALCSIZE>(hdr));
69
70 case TBN_DROPDOWN:
71 return ProcessClick(reinterpret_cast<LPNMTOOLBAR>(hdr)->iItem);
72
73 case TBN_HOTITEMCHANGE:
74 //return OnHotItemChange(reinterpret_cast<LPNMTBHOTITEM>(hdr), theResult);
75 return S_OK;
76
77 case NM_CUSTOMDRAW:
78 return OnCustomDraw(reinterpret_cast<LPNMTBCUSTOMDRAW>(hdr), theResult);
79
80 case TBN_GETINFOTIP:
81 return OnGetInfoTip(reinterpret_cast<LPNMTBGETINFOTIP>(hdr));
82
83 // Silence unhandled items so that they don't print as unknown
84 case RBN_CHILDSIZE:
85 return S_OK;
86
87 case TTN_GETDISPINFO:
88 return S_OK;
89
90 case NM_RELEASEDCAPTURE:
91 break;
92
93 case NM_CLICK:
94 case NM_RDOWN:
95 case NM_LDOWN:
96 break;
97
98 case TBN_GETDISPINFO:
99 break;
100
101 case TBN_BEGINDRAG:
102 case TBN_ENDDRAG:
103 break;
104
105 case NM_TOOLTIPSCREATED:
106 break;
107
108 // Unknown
109 case -714: return S_FALSE;
110
111 default:
112 TRACE("WM_NOTIFY unknown code %d, %d\n", hdr->code, hdr->idFrom);
113 return S_OK;
114 }
115 return S_FALSE;
116 case WM_WININICHANGE:
117 if (wParam == SPI_SETFLATMENU)
118 {
119 SystemParametersInfo(SPI_GETFLATMENU, 0, &m_useFlatMenus, 0);
120 }
121 }
122
123 return S_FALSE;
124 }
125
126 HRESULT CMenuToolbarBase::DisableMouseTrack(BOOL bDisable)
127 {
128 if (m_disableMouseTrack != bDisable)
129 {
130 m_disableMouseTrack = bDisable;
131 TRACE("DisableMouseTrack %d\n", bDisable);
132 }
133 return S_OK;
134 }
135
136 HRESULT CMenuToolbarBase::OnPagerCalcSize(LPNMPGCALCSIZE csize)
137 {
138 SIZE tbs;
139 GetSizes(NULL, &tbs, NULL);
140 if (csize->dwFlag == PGF_CALCHEIGHT)
141 {
142 csize->iHeight = tbs.cy;
143 }
144 else if (csize->dwFlag == PGF_CALCWIDTH)
145 {
146 csize->iWidth = tbs.cx;
147 }
148 return S_OK;
149 }
150
151 HRESULT CMenuToolbarBase::OnCustomDraw(LPNMTBCUSTOMDRAW cdraw, LRESULT * theResult)
152 {
153 bool isHot, isPopup;
154 TBBUTTONINFO btni;
155
156 switch (cdraw->nmcd.dwDrawStage)
157 {
158 case CDDS_PREPAINT:
159 *theResult = CDRF_NOTIFYITEMDRAW;
160 return S_OK;
161
162 case CDDS_ITEMPREPAINT:
163
164 // The item with an active submenu gets the CHECKED flag.
165 isHot = m_hotBar == this && (int) cdraw->nmcd.dwItemSpec == m_hotItem;
166 isPopup = m_popupBar == this && (int) cdraw->nmcd.dwItemSpec == m_popupItem;
167
168 if (m_hotItem < 0 && isPopup)
169 isHot = TRUE;
170
171 if ((m_useFlatMenus && isHot) || (m_initFlags & SMINIT_VERTICAL))
172 {
173 COLORREF clrText;
174 HBRUSH bgBrush;
175 RECT rc = cdraw->nmcd.rc;
176 HDC hdc = cdraw->nmcd.hdc;
177
178 // Remove HOT and CHECKED flags (will restore HOT if necessary)
179 cdraw->nmcd.uItemState &= ~(CDIS_HOT | CDIS_CHECKED);
180
181 // Decide on the colors
182 if (isHot)
183 {
184 cdraw->nmcd.uItemState |= CDIS_HOT;
185
186 clrText = GetSysColor(COLOR_HIGHLIGHTTEXT);
187 bgBrush = GetSysColorBrush(m_useFlatMenus ? COLOR_MENUHILIGHT : COLOR_HIGHLIGHT);
188 }
189 else
190 {
191 clrText = GetSysColor(COLOR_MENUTEXT);
192 bgBrush = GetSysColorBrush(COLOR_MENU);
193 }
194
195 // Paint the background color with the selected color
196 FillRect(hdc, &rc, bgBrush);
197
198 // Set the text color in advance, this color will be assigned when the ITEMPOSTPAINT triggers
199 SetTextColor(hdc, clrText);
200
201 // Set the text color, will be used by the internal drawing code
202 cdraw->clrText = clrText;
203 cdraw->iListGap += 4;
204
205 // Tell the default drawing code we don't want any fanciness, not even a background.
206 *theResult = CDRF_NOTIFYPOSTPAINT | TBCDRF_NOBACKGROUND | TBCDRF_NOEDGES | TBCDRF_NOOFFSET | TBCDRF_NOMARK | 0x00800000; // FIXME: the last bit is Vista+, useful for debugging only
207 }
208 else
209 {
210 // Remove HOT and CHECKED flags (will restore HOT if necessary)
211 cdraw->nmcd.uItemState &= ~CDIS_HOT;
212
213 // Decide on the colors
214 if (isHot)
215 {
216 cdraw->nmcd.uItemState |= CDIS_HOT;
217 }
218
219 *theResult = 0;
220 }
221
222 return S_OK;
223
224 case CDDS_ITEMPOSTPAINT:
225
226 // Fetch the button style
227 btni.cbSize = sizeof(btni);
228 btni.dwMask = TBIF_STYLE;
229 GetButtonInfo(cdraw->nmcd.dwItemSpec, &btni);
230
231 // Check if we need to draw a submenu arrow
232 if (btni.fsStyle & BTNS_DROPDOWN)
233 {
234 // TODO: Support RTL text modes by drawing a leftwards arrow aligned to the left of the control
235
236 // "8" is the rightwards dropdown arrow in the Marlett font
237 WCHAR text [] = L"8";
238
239 // Configure the font to draw with Marlett, keeping the current background color as-is
240 SelectObject(cdraw->nmcd.hdc, m_marlett);
241 SetBkMode(cdraw->nmcd.hdc, TRANSPARENT);
242
243 // Tweak the alignment by 1 pixel so the menu draws like the Windows start menu.
244 RECT rc = cdraw->nmcd.rc;
245 rc.right += 1;
246
247 // The arrow is drawn at the right of the item's rect, aligned vertically.
248 DrawTextEx(cdraw->nmcd.hdc, text, 1, &rc, DT_NOCLIP | DT_VCENTER | DT_RIGHT | DT_SINGLELINE, NULL);
249 }
250 *theResult = TRUE;
251 return S_OK;
252 }
253 return S_OK;
254 }
255
256 CMenuToolbarBase::CMenuToolbarBase(CMenuBand *menuBand, BOOL usePager) :
257 m_pager(this, 1),
258 m_useFlatMenus(FALSE),
259 m_SubclassOld(NULL),
260 m_disableMouseTrack(FALSE),
261 m_timerEnabled(FALSE),
262 m_menuBand(menuBand),
263 m_dwMenuFlags(0),
264 m_hasSizes(FALSE),
265 m_usePager(usePager),
266 m_hotBar(NULL),
267 m_hotItem(-1),
268 m_popupBar(NULL),
269 m_popupItem(-1),
270 m_isTrackingPopup(FALSE),
271 m_cancelingPopup(FALSE)
272 {
273 m_idealSize.cx = 0;
274 m_idealSize.cy = 0;
275 m_itemSize.cx = 0;
276 m_itemSize.cy = 0;
277 m_marlett = CreateFont(
278 0, 0, 0, 0, 0, 0, 0, 0, DEFAULT_CHARSET,
279 OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
280 DEFAULT_QUALITY, FF_DONTCARE, L"Marlett");
281 }
282
283 CMenuToolbarBase::~CMenuToolbarBase()
284 {
285 if (m_hWnd)
286 DestroyWindow();
287
288 if (m_pager.m_hWnd)
289 m_pager.DestroyWindow();
290
291 DeleteObject(m_marlett);
292 }
293
294 void CMenuToolbarBase::InvalidateDraw()
295 {
296 InvalidateRect(NULL, FALSE);
297 }
298
299 HRESULT CMenuToolbarBase::ShowDW(BOOL fShow)
300 {
301 ShowWindow(fShow ? SW_SHOW : SW_HIDE);
302
303 // Ensure that the right image list is assigned to the toolbar
304 UpdateImageLists();
305
306 // For custom-drawing
307 SystemParametersInfo(SPI_GETFLATMENU, 0, &m_useFlatMenus, 0);
308
309 return S_OK;
310 }
311
312 HRESULT CMenuToolbarBase::UpdateImageLists()
313 {
314 if ((m_initFlags & (SMINIT_TOPLEVEL | SMINIT_VERTICAL)) == SMINIT_TOPLEVEL) // not vertical.
315 {
316 // No image list, prevents the buttons from having a margin at the left side
317 SetImageList(NULL);
318 return S_OK;
319 }
320
321 // Assign the correct imagelist and padding based on the current icon size
322
323 int shiml;
324 if (m_menuBand->UseBigIcons())
325 {
326 shiml = SHIL_LARGE;
327 SetPadding(4, 0);
328 }
329 else
330 {
331 shiml = SHIL_SMALL;
332 SetPadding(4, 4);
333 }
334
335 IImageList * piml;
336 HRESULT hr = SHGetImageList(shiml, IID_PPV_ARG(IImageList, &piml));
337 if (FAILED_UNEXPECTEDLY(hr))
338 {
339 SetImageList(NULL);
340 }
341 else
342 {
343 SetImageList((HIMAGELIST)piml);
344 }
345 return S_OK;
346 }
347
348 HRESULT CMenuToolbarBase::Close()
349 {
350 if (m_hWnd)
351 DestroyWindow();
352
353 if (m_pager.m_hWnd)
354 m_pager.DestroyWindow();
355
356 return S_OK;
357 }
358
359 HRESULT CMenuToolbarBase::CreateToolbar(HWND hwndParent, DWORD dwFlags)
360 {
361 LONG tbStyles = WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN |
362 TBSTYLE_TOOLTIPS | TBSTYLE_TRANSPARENT | TBSTYLE_REGISTERDROP | TBSTYLE_LIST | TBSTYLE_FLAT | TBSTYLE_CUSTOMERASE |
363 CCS_NODIVIDER | CCS_NOPARENTALIGN | CCS_NORESIZE | CCS_TOP;
364 LONG tbExStyles = TBSTYLE_EX_DOUBLEBUFFER | WS_EX_TOOLWINDOW;
365
366 if (dwFlags & SMINIT_VERTICAL)
367 {
368 // Activate vertical semantics
369 tbStyles |= CCS_VERT;
370
371 #if USE_TBSTYLE_EX_VERTICAL
372 tbExStyles |= TBSTYLE_EX_VERTICAL;
373 #endif
374 }
375
376 m_initFlags = dwFlags;
377
378 // Get a temporary rect to use while creating the toolbar window.
379 // Ensure that it is not a null rect.
380 RECT rc;
381 if (!::GetClientRect(hwndParent, &rc) ||
382 (rc.left == rc.right) ||
383 (rc.top == rc.bottom))
384 {
385 rc.left = 0;
386 rc.top = 0;
387 rc.right = 1;
388 rc.bottom = 1;
389 }
390
391 SubclassWindow(CToolbar::Create(hwndParent, tbStyles, tbExStyles));
392
393 SetWindowTheme(m_hWnd, L"", L"");
394
395 SystemParametersInfo(SPI_GETFLATMENU, 0, &m_useFlatMenus, 0);
396
397 m_menuBand->AdjustForTheme(m_useFlatMenus);
398
399 // If needed, create the pager.
400 if (m_usePager)
401 {
402 LONG pgStyles = PGS_VERT | WS_CHILD | WS_VISIBLE;
403 LONG pgExStyles = 0;
404
405 HWND hwndPager = CreateWindowEx(
406 pgExStyles, WC_PAGESCROLLER, NULL,
407 pgStyles, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top,
408 hwndParent, NULL, _AtlBaseModule.GetModuleInstance(), 0);
409
410 m_pager.SubclassWindow(hwndPager);
411
412 ::SetParent(m_hWnd, hwndPager);
413
414 m_pager.SendMessageW(PGM_SETCHILD, 0, reinterpret_cast<LPARAM>(m_hWnd));
415 }
416
417 // Configure the image lists
418 UpdateImageLists();
419
420 return S_OK;
421 }
422
423 HRESULT CMenuToolbarBase::GetSizes(SIZE* pMinSize, SIZE* pMaxSize, SIZE* pIntegralSize)
424 {
425 if (pMinSize)
426 *pMinSize = m_idealSize;
427 if (pMaxSize)
428 *pMaxSize = m_idealSize;
429 if (pIntegralSize)
430 *pIntegralSize = m_itemSize;
431
432 if (m_hasSizes)
433 return S_OK;
434
435 TRACE("Sizes out of date, recalculating.\n");
436
437 if (!m_hWnd)
438 {
439 return S_OK;
440 }
441
442 // Obtain the ideal size, to be used as min and max
443 GetMaxSize(&m_idealSize);
444 GetIdealSize((m_initFlags & SMINIT_VERTICAL) != 0, &m_idealSize);
445
446 TRACE("Ideal Size: (%d, %d) for %d buttons\n", m_idealSize, GetButtonCount());
447
448 // Obtain the button size, to be used as the integral size
449 DWORD size = GetButtonSize();
450 m_itemSize.cx = GET_X_LPARAM(size);
451 m_itemSize.cy = GET_Y_LPARAM(size);
452 m_hasSizes = TRUE;
453
454 if (pMinSize)
455 *pMinSize = m_idealSize;
456 if (pMaxSize)
457 *pMaxSize = m_idealSize;
458 if (pIntegralSize)
459 *pIntegralSize = m_itemSize;
460
461 return S_OK;
462 }
463
464 HRESULT CMenuToolbarBase::SetPosSize(int x, int y, int cx, int cy)
465 {
466 // Update the toolbar or pager to fit the requested rect
467 // If we have a pager, set the toolbar height to the ideal height of the toolbar
468 if (m_pager.m_hWnd)
469 {
470 SetWindowPos(NULL, x, y, cx, m_idealSize.cy, 0);
471 m_pager.SetWindowPos(NULL, x, y, cx, cy, 0);
472 }
473 else
474 {
475 SetWindowPos(NULL, x, y, cx, cy, 0);
476 }
477
478 // In a vertical menu, resize the buttons to fit the width
479 if (m_initFlags & SMINIT_VERTICAL)
480 {
481 DWORD btnSize = GetButtonSize();
482 SetButtonSize(cx, GET_Y_LPARAM(btnSize));
483 }
484
485 return S_OK;
486 }
487
488 HRESULT CMenuToolbarBase::IsWindowOwner(HWND hwnd)
489 {
490 if (m_hWnd && m_hWnd == hwnd) return S_OK;
491 if (m_pager.m_hWnd && m_pager.m_hWnd == hwnd) return S_OK;
492 return S_FALSE;
493 }
494
495 HRESULT CMenuToolbarBase::GetWindow(HWND *phwnd)
496 {
497 if (!phwnd)
498 return E_FAIL;
499
500 if (m_pager.m_hWnd)
501 *phwnd = m_pager.m_hWnd;
502 else
503 *phwnd = m_hWnd;
504
505 return S_OK;
506 }
507
508 HRESULT CMenuToolbarBase::OnGetInfoTip(NMTBGETINFOTIP * tip)
509 {
510 INT index;
511 DWORD_PTR dwData;
512
513 INT iItem = tip->iItem;
514
515 GetDataFromId(iItem, &index, &dwData);
516
517 return InternalGetTooltip(iItem, index, dwData, tip->pszText, tip->cchTextMax);
518 }
519
520 HRESULT CMenuToolbarBase::OnPopupTimer(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
521 {
522 if (wParam != TIMERID_HOTTRACK)
523 {
524 bHandled = FALSE;
525 return 0;
526 }
527
528 KillTimer(TIMERID_HOTTRACK);
529
530 if (!m_timerEnabled)
531 return 0;
532
533 m_timerEnabled = FALSE;
534
535 if (m_hotItem < 0)
536 return 0;
537
538 // Returns S_FALSE if the current item did not show a submenu
539 HRESULT hr = PopupItem(m_hotItem, FALSE);
540 if (hr != S_FALSE)
541 return 0;
542
543 // If we didn't switch submenus, cancel the current popup regardless
544 if (m_popupBar)
545 {
546 HRESULT hr = CancelCurrentPopup();
547 if (FAILED_UNEXPECTEDLY(hr))
548 return 0;
549 }
550
551 return 0;
552 }
553
554 HRESULT CMenuToolbarBase::KillPopupTimer()
555 {
556 if (m_timerEnabled)
557 {
558 m_timerEnabled = FALSE;
559 KillTimer(TIMERID_HOTTRACK);
560 return S_OK;
561 }
562 return S_FALSE;
563 }
564
565 HRESULT CMenuToolbarBase::ChangeHotItem(CMenuToolbarBase * toolbar, INT item, DWORD dwFlags)
566 {
567 // Ignore the change if it already matches the stored info
568 if (m_hotBar == toolbar && m_hotItem == item)
569 return S_FALSE;
570
571 // Prevent a change of hot item if the change was triggered by the mouse,
572 // and mouse tracking is disabled.
573 if (m_disableMouseTrack && dwFlags & HICF_MOUSE)
574 {
575 TRACE("Hot item change prevented by DisableMouseTrack\n");
576 return S_OK;
577 }
578
579 // Notify the toolbar if the hot-tracking left this toolbar
580 if (m_hotBar == this && toolbar != this)
581 {
582 SetHotItem(-1);
583 }
584
585 TRACE("Hot item changed from %p %p, to %p %p\n", m_hotBar, m_hotItem, toolbar, item);
586 m_hotBar = toolbar;
587 m_hotItem = item;
588
589 if (m_hotBar == this)
590 {
591 if (m_isTrackingPopup && !(m_initFlags & SMINIT_VERTICAL))
592 {
593 // If the menubar has an open submenu, switch to the new item's submenu immediately
594 PopupItem(m_hotItem, FALSE);
595 }
596 else if (dwFlags & HICF_MOUSE)
597 {
598 // Vertical menus show/hide the submenu after a delay,
599 // but only with the mouse.
600 if (m_initFlags & SMINIT_VERTICAL)
601 {
602 DWORD elapsed = 0;
603 SystemParametersInfo(SPI_GETMENUSHOWDELAY, 0, &elapsed, 0);
604 SetTimer(TIMERID_HOTTRACK, elapsed);
605 m_timerEnabled = TRUE;
606 TRACE("SetTimer called with m_hotItem=%d\n", m_hotItem);
607 }
608 }
609 else
610 {
611 TBBUTTONINFO info;
612 info.cbSize = sizeof(info);
613 info.dwMask = 0;
614
615 int index = GetButtonInfo(item, &info);
616
617 SetHotItem(index);
618 }
619 }
620
621 InvalidateDraw();
622 return S_OK;
623 }
624
625 HRESULT CMenuToolbarBase::ChangePopupItem(CMenuToolbarBase * toolbar, INT item)
626 {
627 // Ignore the change if it already matches the stored info
628 if (m_popupBar == toolbar && m_popupItem == item)
629 return S_FALSE;
630
631 // Notify the toolbar if the popup-tracking this toolbar
632 if (m_popupBar == this && toolbar != this)
633 {
634 CheckButton(m_popupItem, FALSE);
635 m_isTrackingPopup = FALSE;
636 }
637
638 m_popupBar = toolbar;
639 m_popupItem = item;
640
641 if (m_popupBar == this)
642 {
643 CheckButton(m_popupItem, TRUE);
644 }
645
646 InvalidateDraw();
647 return S_OK;
648 }
649
650 LRESULT CMenuToolbarBase::IsTrackedItem(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
651 {
652 TBBUTTON btn;
653 INT idx = (INT)wParam;
654
655 if (m_hotBar != this)
656 return S_FALSE;
657
658 if (idx < 0)
659 return S_FALSE;
660
661 if (!GetButton(idx, &btn))
662 return E_FAIL;
663
664 if (m_hotItem == btn.idCommand)
665 return S_OK;
666
667 if (m_popupItem == btn.idCommand)
668 return S_OK;
669
670 return S_FALSE;
671 }
672
673 LRESULT CMenuToolbarBase::ChangeTrackedItem(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
674 {
675 TBBUTTON btn;
676 BOOL wasTracking = LOWORD(lParam);
677 BOOL mouse = HIWORD(lParam);
678 INT idx = (INT)wParam;
679
680 if (idx < 0)
681 {
682 m_isTrackingPopup = FALSE;
683 return m_menuBand->_ChangeHotItem(NULL, -1, HICF_MOUSE);
684 }
685
686 if (!GetButton(idx, &btn))
687 return E_FAIL;
688
689 TRACE("ChangeTrackedItem %d, %d\n", idx, wasTracking);
690 m_isTrackingPopup = wasTracking;
691 return m_menuBand->_ChangeHotItem(this, btn.idCommand, mouse ? HICF_MOUSE : 0);
692 }
693
694 HRESULT CMenuToolbarBase::PopupSubMenu(UINT iItem, UINT index, IShellMenu* childShellMenu, BOOL keyInitiated)
695 {
696 // Calculate the submenu position and exclude area
697 RECT rc = { 0 };
698
699 if (!GetItemRect(index, &rc))
700 return E_FAIL;
701
702 POINT a = { rc.left, rc.top };
703 POINT b = { rc.right, rc.bottom };
704
705 ClientToScreen(&a);
706 ClientToScreen(&b);
707
708 POINTL pt = { a.x, b.y };
709 RECTL rcl = { a.x, a.y, b.x, b.y };
710
711 if (m_initFlags & SMINIT_VERTICAL)
712 {
713 // FIXME: Hardcoding this here feels hacky.
714 if (IsAppThemed())
715 {
716 pt.x = b.x - 1;
717 pt.y = a.y - 1;
718 }
719 else
720 {
721 pt.x = b.x - 3;
722 pt.y = a.y - 3;
723 }
724 }
725
726 // Display the submenu
727 m_isTrackingPopup = TRUE;
728
729 m_menuBand->_ChangePopupItem(this, iItem);
730 m_menuBand->_OnPopupSubMenu(childShellMenu, &pt, &rcl, keyInitiated);
731
732 return S_OK;
733 }
734
735 HRESULT CMenuToolbarBase::PopupSubMenu(UINT iItem, UINT index, HMENU menu)
736 {
737 // Calculate the submenu position and exclude area
738 RECT rc = { 0 };
739
740 if (!GetItemRect(index, &rc))
741 return E_FAIL;
742
743 POINT a = { rc.left, rc.top };
744 POINT b = { rc.right, rc.bottom };
745
746 ClientToScreen(&a);
747 ClientToScreen(&b);
748
749 POINT pt = { a.x, b.y };
750 RECT rcl = { a.x, a.y, b.x, b.y };
751
752 if (m_initFlags & SMINIT_VERTICAL)
753 {
754 pt.x = b.x;
755 pt.y = a.y;
756 }
757
758 HMENU popup = GetSubMenu(menu, index);
759
760 // Display the submenu
761 m_isTrackingPopup = TRUE;
762 m_menuBand->_ChangePopupItem(this, iItem);
763 m_menuBand->_TrackSubMenu(popup, pt.x, pt.y, rcl);
764 m_menuBand->_ChangePopupItem(NULL, -1);
765 m_isTrackingPopup = FALSE;
766
767 return S_OK;
768 }
769
770 HRESULT CMenuToolbarBase::TrackContextMenu(IContextMenu* contextMenu, POINT pt)
771 {
772 // Cancel submenus
773 m_menuBand->_KillPopupTimers();
774 if (m_popupBar)
775 m_menuBand->_CancelCurrentPopup();
776
777 // Display the context menu
778 return m_menuBand->_TrackContextMenu(contextMenu, pt.x, pt.y);
779 }
780
781 HRESULT CMenuToolbarBase::BeforeCancelPopup()
782 {
783 m_cancelingPopup = TRUE;
784 TRACE("BeforeCancelPopup\n");
785 return S_OK;
786 }
787
788 HRESULT CMenuToolbarBase::ProcessClick(INT iItem)
789 {
790 if (m_disableMouseTrack)
791 {
792 TRACE("Item click prevented by DisableMouseTrack\n");
793 return S_OK;
794 }
795
796 // If a button is clicked while a submenu was open, cancel the submenu.
797 if (!(m_initFlags & SMINIT_VERTICAL) && m_isTrackingPopup)
798 {
799 TRACE("OnCommand cancelled because it was tracking submenu.\n");
800 return S_FALSE;
801 }
802
803 if (PopupItem(iItem, FALSE) == S_OK)
804 {
805 TRACE("PopupItem returned S_OK\n");
806 return S_FALSE;
807 }
808
809 TRACE("Executing...\n");
810
811 return m_menuBand->_MenuItemSelect(MPOS_EXECUTE);
812 }
813
814 HRESULT CMenuToolbarBase::ProcessContextMenu(INT iItem)
815 {
816 INT index;
817 DWORD_PTR data;
818
819 GetDataFromId(iItem, &index, &data);
820
821 DWORD pos = GetMessagePos();
822 POINT pt = { GET_X_LPARAM(pos), GET_Y_LPARAM(pos) };
823
824 return InternalContextMenu(iItem, index, data, pt);
825 }
826
827 HRESULT CMenuToolbarBase::MenuBarMouseDown(INT iIndex, BOOL isLButton)
828 {
829 TBBUTTON btn;
830
831 GetButton(iIndex, &btn);
832
833 if ((m_initFlags & SMINIT_VERTICAL)
834 || m_popupBar
835 || m_cancelingPopup)
836 {
837 m_cancelingPopup = FALSE;
838 return S_OK;
839 }
840
841 return ProcessClick(btn.idCommand);
842 }
843
844 HRESULT CMenuToolbarBase::MenuBarMouseUp(INT iIndex, BOOL isLButton)
845 {
846 TBBUTTON btn;
847
848 m_cancelingPopup = FALSE;
849
850 if (!(m_initFlags & SMINIT_VERTICAL))
851 return S_OK;
852
853 GetButton(iIndex, &btn);
854
855 if (isLButton)
856 return ProcessClick(btn.idCommand);
857 else
858 return ProcessContextMenu(btn.idCommand);
859 }
860
861 HRESULT CMenuToolbarBase::PrepareExecuteItem(INT iItem)
862 {
863 this->m_menuBand->_KillPopupTimers();
864
865 m_executeItem = iItem;
866 return GetDataFromId(iItem, &m_executeIndex, &m_executeData);
867 }
868
869 HRESULT CMenuToolbarBase::ExecuteItem()
870 {
871 return InternalExecuteItem(m_executeItem, m_executeItem, m_executeData);
872 }
873
874 HRESULT CMenuToolbarBase::KeyboardItemChange(DWORD dwSelectType)
875 {
876 int prev = m_hotItem;
877 int index = -1;
878
879 if (dwSelectType != 0xFFFFFFFF)
880 {
881 int count = GetButtonCount();
882
883 if (dwSelectType == VK_HOME)
884 {
885 index = 0;
886 dwSelectType = VK_DOWN;
887 }
888 else if (dwSelectType == VK_END)
889 {
890 index = count - 1;
891 dwSelectType = VK_UP;
892 }
893 else
894 {
895 if (m_hotItem >= 0)
896 {
897 TBBUTTONINFO info = { 0 };
898 info.cbSize = sizeof(TBBUTTONINFO);
899 info.dwMask = 0;
900 index = GetButtonInfo(m_hotItem, &info);
901 }
902
903 if (index < 0)
904 {
905 if (dwSelectType == VK_UP)
906 {
907 index = count - 1;
908 }
909 else if (dwSelectType == VK_DOWN)
910 {
911 index = 0;
912 }
913 }
914 else
915 {
916 if (dwSelectType == VK_UP)
917 {
918 index--;
919 }
920 else if (dwSelectType == VK_DOWN)
921 {
922 index++;
923 }
924 }
925 }
926
927 TBBUTTON btn = { 0 };
928 while (index >= 0 && index < count)
929 {
930 DWORD res = GetButton(index, &btn);
931 if (!res)
932 return E_FAIL;
933
934 if (btn.dwData)
935 {
936 if (prev != btn.idCommand)
937 {
938 TRACE("Setting Hot item to %d\n", index);
939 if (!(m_initFlags & SMINIT_VERTICAL) && m_isTrackingPopup)
940 {
941 HWND tlw;
942 m_menuBand->_GetTopLevelWindow(&tlw);
943 SendMessageW(tlw, WM_CANCELMODE, 0, 0);
944 PostMessageW(WM_USER_CHANGETRACKEDITEM, index, MAKELPARAM(m_isTrackingPopup, FALSE));
945 }
946 else
947 m_menuBand->_ChangeHotItem(this, btn.idCommand, 0);
948 }
949 return S_OK;
950 }
951
952 if (dwSelectType == VK_UP)
953 {
954 index--;
955 }
956 else if (dwSelectType == VK_DOWN)
957 {
958 index++;
959 }
960 }
961
962 return S_FALSE;
963 }
964
965 if (prev != -1)
966 {
967 TRACE("Setting Hot item to null\n");
968 m_menuBand->_ChangeHotItem(NULL, -1, 0);
969 }
970
971 return S_FALSE;
972 }
973
974 HRESULT CMenuToolbarBase::AddButton(DWORD commandId, LPCWSTR caption, BOOL hasSubMenu, INT iconId, DWORD_PTR buttonData, BOOL last)
975 {
976 TBBUTTON tbb = { 0 };
977
978 tbb.fsState = TBSTATE_ENABLED;
979 #if !USE_TBSTYLE_EX_VERTICAL
980 if (!last && (m_initFlags & SMINIT_VERTICAL))
981 tbb.fsState |= TBSTATE_WRAP;
982 #endif
983 tbb.fsStyle = BTNS_CHECKGROUP;
984
985 if (hasSubMenu && (m_initFlags & SMINIT_VERTICAL))
986 tbb.fsStyle |= BTNS_DROPDOWN;
987
988 if (!(m_initFlags & SMINIT_VERTICAL))
989 tbb.fsStyle |= BTNS_AUTOSIZE;
990
991 tbb.iString = (INT_PTR) caption;
992 tbb.idCommand = commandId;
993
994 tbb.iBitmap = iconId;
995 tbb.dwData = buttonData;
996
997 m_hasSizes = FALSE;
998
999 if (!AddButtons(1, &tbb))
1000 return HRESULT_FROM_WIN32(GetLastError());
1001 return S_OK;
1002 }
1003
1004 HRESULT CMenuToolbarBase::AddSeparator(BOOL last)
1005 {
1006 TBBUTTON tbb = { 0 };
1007
1008 tbb.fsState = TBSTATE_ENABLED;
1009 #if !USE_TBSTYLE_EX_VERTICAL
1010 if (!last && (m_initFlags & SMINIT_VERTICAL))
1011 tbb.fsState |= TBSTATE_WRAP;
1012 #endif
1013 tbb.fsStyle = BTNS_SEP;
1014 tbb.iBitmap = 0;
1015
1016 m_hasSizes = FALSE;
1017
1018 if (!AddButtons(1, &tbb))
1019 return HRESULT_FROM_WIN32(GetLastError());
1020
1021 return S_OK;
1022 }
1023
1024 HRESULT CMenuToolbarBase::AddPlaceholder()
1025 {
1026 TBBUTTON tbb = { 0 };
1027 WCHAR MenuString[128];
1028
1029 LoadStringW(GetModuleHandle(L"shell32.dll"), IDS_MENU_EMPTY, MenuString, _countof(MenuString));
1030
1031 tbb.fsState = 0;
1032 tbb.fsStyle = 0;
1033 tbb.iString = (INT_PTR) MenuString;
1034 tbb.iBitmap = -1;
1035
1036 m_hasSizes = FALSE;
1037
1038 if (!AddButtons(1, &tbb))
1039 return HRESULT_FROM_WIN32(GetLastError());
1040
1041 return S_OK;
1042 }
1043
1044 HRESULT CMenuToolbarBase::ClearToolbar()
1045 {
1046 while (DeleteButton(0))
1047 {
1048 // empty;
1049 }
1050 m_hasSizes = FALSE;
1051 return S_OK;
1052 }
1053
1054 HRESULT CMenuToolbarBase::GetDataFromId(INT iItem, INT* pIndex, DWORD_PTR* pData)
1055 {
1056 if (pData)
1057 *pData = NULL;
1058
1059 if (pIndex)
1060 *pIndex = -1;
1061
1062 if (iItem < 0)
1063 return S_OK;
1064
1065 TBBUTTONINFO info = { 0 };
1066
1067 info.cbSize = sizeof(TBBUTTONINFO);
1068 info.dwMask = TBIF_COMMAND | TBIF_LPARAM;
1069
1070 int index = GetButtonInfo(iItem, &info);
1071 if (index < 0)
1072 return E_FAIL;
1073
1074 if (pIndex)
1075 *pIndex = index;
1076
1077 if (pData)
1078 *pData = info.lParam;
1079
1080 return S_OK;
1081 }
1082
1083 HRESULT CMenuToolbarBase::CancelCurrentPopup()
1084 {
1085 return m_menuBand->_CancelCurrentPopup();
1086 }
1087
1088 HRESULT CMenuToolbarBase::PopupItem(INT iItem, BOOL keyInitiated)
1089 {
1090 INT index;
1091 DWORD_PTR dwData;
1092
1093 if (iItem < 0)
1094 return S_OK;
1095
1096 if (m_popupBar == this && m_popupItem == iItem)
1097 return S_OK;
1098
1099 GetDataFromId(iItem, &index, &dwData);
1100
1101 HRESULT hr = InternalHasSubMenu(iItem, index, dwData);
1102 if (hr != S_OK)
1103 return hr;
1104
1105 if (m_popupBar)
1106 {
1107 HRESULT hr = CancelCurrentPopup();
1108 if (FAILED_UNEXPECTEDLY(hr))
1109 return hr;
1110 }
1111
1112 if (!(m_initFlags & SMINIT_VERTICAL))
1113 {
1114 TRACE("PopupItem non-vertical %d %d\n", index, iItem);
1115 m_menuBand->_ChangeHotItem(this, iItem, 0);
1116 }
1117
1118 return InternalPopupItem(iItem, index, dwData, keyInitiated);
1119 }
1120
1121 CMenuStaticToolbar::CMenuStaticToolbar(CMenuBand *menuBand) :
1122 CMenuToolbarBase(menuBand, FALSE),
1123 m_hmenu(NULL),
1124 m_hwndMenu(NULL)
1125 {
1126 }
1127
1128 CMenuStaticToolbar::~CMenuStaticToolbar()
1129 {
1130 }
1131
1132 HRESULT CMenuStaticToolbar::GetMenu(
1133 _Out_opt_ HMENU *phmenu,
1134 _Out_opt_ HWND *phwnd,
1135 _Out_opt_ DWORD *pdwFlags)
1136 {
1137 if (phmenu)
1138 *phmenu = m_hmenu;
1139 if (phwnd)
1140 *phwnd = m_hwndMenu;
1141 if (pdwFlags)
1142 *pdwFlags = m_dwMenuFlags;
1143
1144 return S_OK;
1145 }
1146
1147 HRESULT CMenuStaticToolbar::SetMenu(
1148 HMENU hmenu,
1149 HWND hwnd,
1150 DWORD dwFlags)
1151 {
1152 m_hmenu = hmenu;
1153 m_hwndMenu = hwnd;
1154 m_dwMenuFlags = dwFlags;
1155
1156 ClearToolbar();
1157
1158 return S_OK;
1159 }
1160
1161 HRESULT CMenuStaticToolbar::FillToolbar(BOOL clearFirst)
1162 {
1163 int i;
1164 int ic = GetMenuItemCount(m_hmenu);
1165
1166 if (clearFirst)
1167 {
1168 ClearToolbar();
1169 }
1170
1171 int count = 0;
1172 for (i = 0; i < ic; i++)
1173 {
1174 BOOL last = i + 1 == ic;
1175
1176 MENUITEMINFOW info;
1177
1178 info.cbSize = sizeof(info);
1179 info.dwTypeData = NULL;
1180 info.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_ID;
1181
1182 if (!GetMenuItemInfoW(m_hmenu, i, TRUE, &info))
1183 {
1184 TRACE("Error obtaining info for menu item at pos=%d\n", i);
1185 continue;
1186 }
1187
1188 count++;
1189
1190 if (info.fType & MFT_SEPARATOR)
1191 {
1192 AddSeparator(last);
1193 }
1194 else if (!(info.fType & MFT_BITMAP))
1195 {
1196 info.cch++;
1197 info.dwTypeData = (PWSTR) HeapAlloc(GetProcessHeap(), 0, (info.cch + 1) * sizeof(WCHAR));
1198
1199 info.fMask = MIIM_STRING | MIIM_SUBMENU | MIIM_ID;
1200 GetMenuItemInfoW(m_hmenu, i, TRUE, &info);
1201
1202 SMINFO * sminfo = new SMINFO();
1203 sminfo->dwMask = SMIM_ICON | SMIM_FLAGS;
1204
1205 HRESULT hr = m_menuBand->_CallCBWithItemId(info.wID, SMC_GETINFO, 0, reinterpret_cast<LPARAM>(sminfo));
1206 if (FAILED_UNEXPECTEDLY(hr))
1207 {
1208 delete sminfo;
1209 return hr;
1210 }
1211
1212 AddButton(info.wID, info.dwTypeData, info.hSubMenu != NULL, sminfo->iIcon, reinterpret_cast<DWORD_PTR>(sminfo), last);
1213
1214 HeapFree(GetProcessHeap(), 0, info.dwTypeData);
1215 }
1216 }
1217
1218 return S_OK;
1219 }
1220
1221 HRESULT CMenuStaticToolbar::InternalGetTooltip(INT iItem, INT index, DWORD_PTR dwData, LPWSTR pszText, INT cchTextMax)
1222 {
1223 //SMINFO * info = reinterpret_cast<SMINFO*>(dwData);
1224 UNIMPLEMENTED;
1225 return E_NOTIMPL;
1226 }
1227
1228 HRESULT CMenuStaticToolbar::OnDeletingButton(const NMTOOLBAR * tb)
1229 {
1230 delete reinterpret_cast<SMINFO*>(tb->tbButton.dwData);
1231 return S_OK;
1232 }
1233
1234 HRESULT CMenuStaticToolbar::InternalContextMenu(INT iItem, INT index, DWORD_PTR dwData, POINT pt)
1235 {
1236 CComPtr<IContextMenu> contextMenu;
1237 HRESULT hr = m_menuBand->_CallCBWithItemId(iItem, SMC_GETOBJECT,
1238 reinterpret_cast<WPARAM>(&IID_IContextMenu), reinterpret_cast<LPARAM>(&contextMenu));
1239 if (hr != S_OK)
1240 return hr;
1241
1242 return TrackContextMenu(contextMenu, pt);
1243 }
1244
1245 HRESULT CMenuStaticToolbar::InternalExecuteItem(INT iItem, INT index, DWORD_PTR data)
1246 {
1247 return m_menuBand->_CallCBWithItemId(iItem, SMC_EXEC, 0, 0);
1248 }
1249
1250 HRESULT CMenuStaticToolbar::InternalPopupItem(INT iItem, INT index, DWORD_PTR dwData, BOOL keyInitiated)
1251 {
1252 SMINFO * nfo = reinterpret_cast<SMINFO*>(dwData);
1253 if (!nfo)
1254 return E_FAIL;
1255
1256 if (nfo->dwFlags&SMIF_TRACKPOPUP)
1257 {
1258 return PopupSubMenu(iItem, index, m_hmenu);
1259 }
1260 else
1261 {
1262 CComPtr<IShellMenu> shellMenu;
1263 HRESULT hr = m_menuBand->_CallCBWithItemId(iItem, SMC_GETOBJECT, reinterpret_cast<WPARAM>(&IID_IShellMenu), reinterpret_cast<LPARAM>(&shellMenu));
1264 if (FAILED_UNEXPECTEDLY(hr))
1265 return hr;
1266
1267 return PopupSubMenu(iItem, index, shellMenu, keyInitiated);
1268 }
1269 }
1270
1271 HRESULT CMenuStaticToolbar::InternalHasSubMenu(INT iItem, INT index, DWORD_PTR dwData)
1272 {
1273 return ::GetSubMenu(m_hmenu, index) ? S_OK : S_FALSE;
1274 }
1275
1276 CMenuSFToolbar::CMenuSFToolbar(CMenuBand * menuBand) :
1277 CMenuToolbarBase(menuBand, TRUE),
1278 m_shellFolder(NULL),
1279 m_idList(NULL),
1280 m_hKey(NULL)
1281 {
1282 }
1283
1284 CMenuSFToolbar::~CMenuSFToolbar()
1285 {
1286 }
1287
1288 int CALLBACK PidlListSort(void* item1, void* item2, LPARAM lParam)
1289 {
1290 IShellFolder * psf = (IShellFolder*) lParam;
1291 PCUIDLIST_RELATIVE pidl1 = (PCUIDLIST_RELATIVE) item1;
1292 PCUIDLIST_RELATIVE pidl2 = (PCUIDLIST_RELATIVE) item2;
1293 HRESULT hr = psf->CompareIDs(0, pidl1, pidl2);
1294 if (FAILED(hr))
1295 {
1296 // No way to cancel, so sort to equal.
1297 return 0;
1298 }
1299 return (int)(short)LOWORD(hr);
1300 }
1301
1302 HRESULT CMenuSFToolbar::FillToolbar(BOOL clearFirst)
1303 {
1304 HRESULT hr;
1305
1306 CComPtr<IEnumIDList> eidl;
1307 hr = m_shellFolder->EnumObjects(GetToolbar(), SHCONTF_FOLDERS | SHCONTF_NONFOLDERS, &eidl);
1308 if (FAILED_UNEXPECTEDLY(hr))
1309 return hr;
1310
1311 HDPA dpaSort = DPA_Create(10);
1312
1313 LPITEMIDLIST item = NULL;
1314 hr = eidl->Next(1, &item, NULL);
1315 while (hr == S_OK)
1316 {
1317 if (m_menuBand->_CallCBWithItemPidl(item, 0x10000000, 0, 0) == S_FALSE)
1318 {
1319 DPA_AppendPtr(dpaSort, ILClone(item));
1320 }
1321
1322 hr = eidl->Next(1, &item, NULL);
1323 }
1324
1325 // If no items were added, show the "empty" placeholder
1326 if (DPA_GetPtrCount(dpaSort) == 0)
1327 {
1328 DPA_Destroy(dpaSort);
1329 return AddPlaceholder();
1330 }
1331
1332 TRACE("FillToolbar added %d items to the DPA\n", DPA_GetPtrCount(dpaSort));
1333
1334 DPA_Sort(dpaSort, PidlListSort, (LPARAM) m_shellFolder.p);
1335
1336 for (int i = 0; i<DPA_GetPtrCount(dpaSort);)
1337 {
1338 PWSTR MenuString;
1339
1340 INT index = 0;
1341 INT indexOpen = 0;
1342
1343 STRRET sr = { STRRET_CSTR, { 0 } };
1344
1345 item = (LPITEMIDLIST)DPA_GetPtr(dpaSort, i);
1346
1347 hr = m_shellFolder->GetDisplayNameOf(item, SIGDN_NORMALDISPLAY, &sr);
1348 if (FAILED_UNEXPECTEDLY(hr))
1349 {
1350 DPA_Destroy(dpaSort);
1351 return hr;
1352 }
1353
1354 StrRetToStr(&sr, NULL, &MenuString);
1355
1356 index = SHMapPIDLToSystemImageListIndex(m_shellFolder, item, &indexOpen);
1357
1358 LPCITEMIDLIST itemc = item;
1359
1360 SFGAOF attrs = SFGAO_FOLDER;
1361 hr = m_shellFolder->GetAttributesOf(1, &itemc, &attrs);
1362
1363 DWORD_PTR dwData = reinterpret_cast<DWORD_PTR>(item);
1364
1365 // Fetch next item already, so we know if the current one is the last
1366 i++;
1367
1368 AddButton(i, MenuString, attrs & SFGAO_FOLDER, index, dwData, i >= DPA_GetPtrCount(dpaSort));
1369
1370 CoTaskMemFree(MenuString);
1371 }
1372
1373 DPA_Destroy(dpaSort);
1374 return hr;
1375 }
1376
1377 HRESULT CMenuSFToolbar::InternalGetTooltip(INT iItem, INT index, DWORD_PTR dwData, LPWSTR pszText, INT cchTextMax)
1378 {
1379 //ITEMIDLIST * pidl = reinterpret_cast<LPITEMIDLIST>(dwData);
1380 UNIMPLEMENTED;
1381 return E_NOTIMPL;
1382 }
1383
1384 HRESULT CMenuSFToolbar::OnDeletingButton(const NMTOOLBAR * tb)
1385 {
1386 ILFree(reinterpret_cast<LPITEMIDLIST>(tb->tbButton.dwData));
1387 return S_OK;
1388 }
1389
1390 HRESULT CMenuSFToolbar::SetShellFolder(IShellFolder *psf, LPCITEMIDLIST pidlFolder, HKEY hKey, DWORD dwFlags)
1391 {
1392 m_shellFolder = psf;
1393 m_idList = ILClone(pidlFolder);
1394 m_hKey = hKey;
1395 m_dwMenuFlags = dwFlags;
1396
1397 ClearToolbar();
1398
1399 return S_OK;
1400 }
1401
1402 HRESULT CMenuSFToolbar::GetShellFolder(DWORD *pdwFlags, LPITEMIDLIST *ppidl, REFIID riid, void **ppv)
1403 {
1404 HRESULT hr;
1405
1406 hr = m_shellFolder->QueryInterface(riid, ppv);
1407 if (FAILED_UNEXPECTEDLY(hr))
1408 return hr;
1409
1410 if (pdwFlags)
1411 *pdwFlags = m_dwMenuFlags;
1412
1413 if (ppidl)
1414 {
1415 LPITEMIDLIST pidl = NULL;
1416
1417 if (m_idList)
1418 {
1419 pidl = ILClone(m_idList);
1420 if (!pidl)
1421 {
1422 ERR("ILClone failed!\n");
1423 (*reinterpret_cast<IUnknown**>(ppv))->Release();
1424 return E_FAIL;
1425 }
1426 }
1427
1428 *ppidl = pidl;
1429 }
1430
1431 return hr;
1432 }
1433
1434 HRESULT CMenuSFToolbar::InternalContextMenu(INT iItem, INT index, DWORD_PTR dwData, POINT pt)
1435 {
1436 HRESULT hr;
1437 CComPtr<IContextMenu> contextMenu = NULL;
1438 LPCITEMIDLIST pidl = reinterpret_cast<LPCITEMIDLIST>(dwData);
1439
1440 hr = m_shellFolder->GetUIObjectOf(GetToolbar(), 1, &pidl, IID_NULL_PPV_ARG(IContextMenu, &contextMenu));
1441 if (FAILED_UNEXPECTEDLY(hr))
1442 {
1443 return hr;
1444 }
1445
1446 hr = TrackContextMenu(contextMenu, pt);
1447
1448 return hr;
1449 }
1450
1451 HRESULT CMenuSFToolbar::InternalExecuteItem(INT iItem, INT index, DWORD_PTR data)
1452 {
1453 return m_menuBand->_CallCBWithItemPidl(reinterpret_cast<LPITEMIDLIST>(data), SMC_SFEXEC, 0, 0);
1454 }
1455
1456 HRESULT CMenuSFToolbar::InternalPopupItem(INT iItem, INT index, DWORD_PTR dwData, BOOL keyInitiated)
1457 {
1458 HRESULT hr;
1459 UINT uId;
1460 UINT uIdAncestor;
1461 DWORD flags;
1462 CComPtr<IShellMenuCallback> psmc;
1463 CComPtr<IShellMenu> shellMenu;
1464
1465 LPITEMIDLIST pidl = reinterpret_cast<LPITEMIDLIST>(dwData);
1466
1467 if (!pidl)
1468 return E_FAIL;
1469
1470 hr = CMenuBand_Constructor(IID_PPV_ARG(IShellMenu, &shellMenu));
1471 if (FAILED_UNEXPECTEDLY(hr))
1472 return hr;
1473
1474 m_menuBand->GetMenuInfo(&psmc, &uId, &uIdAncestor, &flags);
1475
1476 // FIXME: not sure what to use as uId/uIdAncestor here
1477 hr = shellMenu->Initialize(psmc, 0, uId, SMINIT_VERTICAL);
1478 if (FAILED_UNEXPECTEDLY(hr))
1479 return hr;
1480
1481 CComPtr<IShellFolder> childFolder;
1482 hr = m_shellFolder->BindToObject(pidl, NULL, IID_PPV_ARG(IShellFolder, &childFolder));
1483 if (FAILED_UNEXPECTEDLY(hr))
1484 return hr;
1485
1486 hr = shellMenu->SetShellFolder(childFolder, NULL, NULL, 0);
1487 if (FAILED_UNEXPECTEDLY(hr))
1488 return hr;
1489
1490 return PopupSubMenu(iItem, index, shellMenu, keyInitiated);
1491 }
1492
1493 HRESULT CMenuSFToolbar::InternalHasSubMenu(INT iItem, INT index, DWORD_PTR dwData)
1494 {
1495 HRESULT hr;
1496 LPCITEMIDLIST pidl = reinterpret_cast<LPITEMIDLIST>(dwData);
1497
1498 SFGAOF attrs = SFGAO_FOLDER;
1499 hr = m_shellFolder->GetAttributesOf(1, &pidl, &attrs);
1500 if (FAILED_UNEXPECTEDLY(hr))
1501 return hr;
1502
1503 return (attrs & SFGAO_FOLDER) ? S_OK : S_FALSE;
1504 }