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