ReactOS  0.4.13-dev-249-gcba1a2f
shlmenu.c
Go to the documentation of this file.
1 /*
2  * see www.geocities.com/SiliconValley/4942/filemenu.html
3  *
4  * Copyright 1999, 2000 Juergen Schmied
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 
21 #define WIN32_NO_STATUS
22 #define _INC_WINDOWS
23 #define COBJMACROS
24 
25 #include <windef.h>
26 #include <winbase.h>
27 #include <shlobj.h>
28 #include <undocshell.h>
29 #include <shlwapi.h>
30 #include <wine/debug.h>
31 #include <wine/unicode.h>
32 
33 #include "pidl.h"
34 #include "shell32_main.h"
35 
36 #ifdef FM_SEPARATOR
37 #undef FM_SEPARATOR
38 #endif
39 #define FM_SEPARATOR (LPCWSTR)1
40 
41 static BOOL FileMenu_AppendItemW(HMENU hMenu, LPCWSTR lpText, UINT uID, int icon,
42  HMENU hMenuPopup, int nItemHeight);
43 
44 typedef struct
45 {
48  /* create */
52 
53  /* insert using pidl */
59 } FMINFO, *LPFMINFO;
60 
61 typedef struct
65  WCHAR szItemText[1];
66 } FMITEM, * LPFMITEM;
67 
69 
70 #define CCH_MAXITEMTEXT 256
71 
73 
75 {
77  LPFMINFO menudata;
78 
79  MenuInfo.cbSize = sizeof(MENUINFO);
80  MenuInfo.fMask = MIM_MENUDATA;
81 
82  if (! GetMenuInfo(hmenu, &MenuInfo))
83  return NULL;
84 
85  menudata = (LPFMINFO)MenuInfo.dwMenuData;
86 
87  if ((menudata == 0) || (MenuInfo.cbSize != sizeof(MENUINFO)))
88  {
89  ERR("menudata corrupt: %p %u\n", menudata, MenuInfo.cbSize);
90  return 0;
91  }
92 
93  return menudata;
94 
95 }
96 /*************************************************************************
97  * FM_SetMenuParameter [internal]
98  *
99  */
101  HMENU hmenu,
102  UINT uID,
103  LPCITEMIDLIST pidl,
104  UINT uFlags,
105  UINT uEnumFlags,
106  LPFNFMCALLBACK lpfnCallback)
107 {
108  LPFMINFO menudata;
109 
110  TRACE("\n");
111 
112  menudata = FM_GetMenuInfo(hmenu);
113 
114  SHFree(menudata->pidl);
115 
116  menudata->uID = uID;
117  menudata->pidl = ILClone(pidl);
118  menudata->uFlags = uFlags;
119  menudata->uEnumFlags = uEnumFlags;
120  menudata->lpfnCallback = lpfnCallback;
121 
122  return menudata;
123 }
124 
125 /*************************************************************************
126  * FM_InitMenuPopup [internal]
127  *
128  */
129 static int FM_InitMenuPopup(HMENU hmenu, LPCITEMIDLIST pAlternatePidl)
130 { IShellFolder *lpsf, *lpsf2;
131  ULONG ulItemAttr = SFGAO_FOLDER;
132  UINT uID, uEnumFlags;
133  LPFNFMCALLBACK lpfnCallback;
134  LPCITEMIDLIST pidl;
135  WCHAR sTemp[MAX_PATH];
136  int NumberOfItems = 0, iIcon;
138  LPFMINFO menudata;
139 
140  TRACE("%p %p\n", hmenu, pAlternatePidl);
141 
142  MenuInfo.cbSize = sizeof(MENUINFO);
143  MenuInfo.fMask = MIM_MENUDATA;
144 
145  if (! GetMenuInfo(hmenu, &MenuInfo))
146  return FALSE;
147 
148  menudata = (LPFMINFO)MenuInfo.dwMenuData;
149 
150  if ((menudata == 0) || (MenuInfo.cbSize != sizeof(MENUINFO)))
151  {
152  ERR("menudata corrupt: %p %u\n", menudata, MenuInfo.cbSize);
153  return 0;
154  }
155 
156  if (menudata->bInitialized)
157  return 0;
158 
159  pidl = (pAlternatePidl? pAlternatePidl: menudata->pidl);
160  if (!pidl)
161  return 0;
162 
163  uID = menudata->uID;
164  uEnumFlags = menudata->uEnumFlags;
165  lpfnCallback = menudata->lpfnCallback;
166  menudata->bInitialized = FALSE;
167 
169 
170  if (SUCCEEDED (SHGetDesktopFolder(&lpsf)))
171  {
172  if (SUCCEEDED(IShellFolder_BindToObject(lpsf, pidl,0,&IID_IShellFolder,(LPVOID *)&lpsf2)))
173  {
174  IEnumIDList *lpe = NULL;
175 
176  if (SUCCEEDED (IShellFolder_EnumObjects(lpsf2, 0, uEnumFlags, &lpe )))
177  {
178 
179  LPITEMIDLIST pidlTemp = NULL;
180  ULONG ulFetched;
181 
182  while ((!bAbortInit) && (S_OK == IEnumIDList_Next(lpe,1,&pidlTemp,&ulFetched)))
183  {
184  if (SUCCEEDED (IShellFolder_GetAttributesOf(lpsf, 1, (LPCITEMIDLIST*)&pidlTemp, &ulItemAttr)))
185  {
186  ILGetDisplayNameExW(NULL, pidlTemp, sTemp, ILGDN_FORPARSING);
187  if (! (PidlToSicIndex(lpsf, pidlTemp, FALSE, 0, &iIcon)))
188  iIcon = FM_BLANK_ICON;
189  if ( SFGAO_FOLDER & ulItemAttr)
190  {
191  LPFMINFO lpFmMi;
193  HMENU hMenuPopup = CreatePopupMenu();
194 
195  lpFmMi = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(FMINFO));
196 
197  lpFmMi->pidl = ILCombine(pidl, pidlTemp);
198  lpFmMi->uEnumFlags = SHCONTF_FOLDERS | SHCONTF_NONFOLDERS;
199 
200  MenuInfo.cbSize = sizeof(MENUINFO);
201  MenuInfo.fMask = MIM_MENUDATA;
202  MenuInfo.dwMenuData = (ULONG_PTR) lpFmMi;
203  SetMenuInfo (hMenuPopup, &MenuInfo);
204 
205  FileMenu_AppendItemW (hmenu, sTemp, uID, iIcon, hMenuPopup, FM_DEFAULT_HEIGHT);
206  }
207  else
208  {
209  LPWSTR pExt = PathFindExtensionW(sTemp);
210  if (pExt)
211  *pExt = 0;
212  FileMenu_AppendItemW (hmenu, sTemp, uID, iIcon, 0, FM_DEFAULT_HEIGHT);
213  }
214  }
215 
216  if (lpfnCallback)
217  {
218  TRACE("enter callback\n");
219  lpfnCallback ( pidl, pidlTemp);
220  TRACE("leave callback\n");
221  }
222 
223  NumberOfItems++;
224  }
225  IEnumIDList_Release (lpe);
226  }
227  IShellFolder_Release(lpsf2);
228  }
229  IShellFolder_Release(lpsf);
230  }
231 
232  if ( GetMenuItemCount (hmenu) == 0 )
233  {
234  static const WCHAR szEmpty[] = { '(','e','m','p','t','y',')',0 };
236  NumberOfItems++;
237  }
238 
239  menudata->bInitialized = TRUE;
241 
242  return NumberOfItems;
243 }
244 /*************************************************************************
245  * FileMenu_Create [SHELL32.114]
246  *
247  * NOTES
248  * for non-root menus values are
249  * (ffffffff,00000000,00000000,00000000,00000000)
250  */
252  COLORREF crBorderColor,
253  int nBorderWidth,
254  HBITMAP hBorderBmp,
255  int nSelHeight,
256  UINT uFlags)
257 {
259  LPFMINFO menudata;
260 
261  HMENU hMenu = CreatePopupMenu();
262 
263  TRACE("0x%08x 0x%08x %p 0x%08x 0x%08x hMenu=%p\n",
264  crBorderColor, nBorderWidth, hBorderBmp, nSelHeight, uFlags, hMenu);
265 
266  menudata = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(FMINFO));
267  menudata->crBorderColor = crBorderColor;
268  menudata->nBorderWidth = nBorderWidth;
269  menudata->hBorderBmp = hBorderBmp;
270 
271  MenuInfo.cbSize = sizeof(MENUINFO);
272  MenuInfo.fMask = MIM_MENUDATA;
273  MenuInfo.dwMenuData = (ULONG_PTR) menudata;
274  SetMenuInfo (hMenu, &MenuInfo);
275 
276  return hMenu;
277 }
278 
279 /*************************************************************************
280  * FileMenu_Destroy [SHELL32.118]
281  *
282  * NOTES
283  * exported by name
284  */
286 {
287  LPFMINFO menudata;
288 
289  TRACE("%p\n", hmenu);
290 
292 
293  menudata = FM_GetMenuInfo(hmenu);
294 
295  SHFree( menudata->pidl);
296  HeapFree(GetProcessHeap(), 0, menudata);
297 
298  DestroyMenu (hmenu);
299 }
300 
301 /*************************************************************************
302  * FileMenu_AppendItem [SHELL32.115]
303  *
304  */
306  HMENU hMenu,
307  LPCWSTR lpText,
308  UINT uID,
309  int icon,
310  HMENU hMenuPopup,
311  int nItemHeight)
312 {
313  MENUITEMINFOW mii;
314  LPFMITEM myItem;
315  LPFMINFO menudata;
317 
318 
319  TRACE("%p %s 0x%08x 0x%08x %p 0x%08x\n",
320  hMenu, (lpText!=FM_SEPARATOR) ? debugstr_w(lpText) : NULL,
321  uID, icon, hMenuPopup, nItemHeight);
322 
323  ZeroMemory (&mii, sizeof(MENUITEMINFOW));
324 
325  mii.cbSize = sizeof(MENUITEMINFOW);
326 
327  if (lpText != FM_SEPARATOR)
328  {
329  int len = strlenW (lpText);
330  myItem = SHAlloc(sizeof(FMITEM) + len*sizeof(WCHAR));
331  strcpyW (myItem->szItemText, lpText);
332  myItem->cchItemText = len;
333  myItem->iIconIndex = icon;
334  myItem->hMenu = hMenu;
335  mii.fMask = MIIM_DATA;
336  mii.dwItemData = (ULONG_PTR) myItem;
337  }
338 
339  if ( hMenuPopup )
340  { /* sub menu */
341  mii.fMask |= MIIM_TYPE | MIIM_SUBMENU;
342  mii.fType = MFT_OWNERDRAW;
343  mii.hSubMenu = hMenuPopup;
344  }
345  else if (lpText == FM_SEPARATOR )
346  { mii.fMask |= MIIM_ID | MIIM_TYPE;
347  mii.fType = MFT_SEPARATOR;
348  }
349  else
350  { /* normal item */
351  mii.fMask |= MIIM_ID | MIIM_TYPE | MIIM_STATE;
353  mii.fType = MFT_OWNERDRAW;
354  }
355  mii.wID = uID;
356 
357  InsertMenuItemW (hMenu, (UINT)-1, TRUE, &mii);
358 
359  /* set bFixedItems to true */
360  MenuInfo.cbSize = sizeof(MENUINFO);
361  MenuInfo.fMask = MIM_MENUDATA;
362 
363  if (! GetMenuInfo(hMenu, &MenuInfo))
364  return FALSE;
365 
366  menudata = (LPFMINFO)MenuInfo.dwMenuData;
367  if ((menudata == 0) || (MenuInfo.cbSize != sizeof(MENUINFO)))
368  {
369  ERR("menudata corrupt: %p %u\n", menudata, MenuInfo.cbSize);
370  return FALSE;
371  }
372 
373  menudata->bFixedItems = TRUE;
374  SetMenuInfo(hMenu, &MenuInfo);
375 
376  return TRUE;
377 
378 }
379 
380 /**********************************************************************/
381 
383  HMENU hMenu,
384  LPCVOID lpText,
385  UINT uID,
386  int icon,
387  HMENU hMenuPopup,
388  int nItemHeight)
389 {
390  BOOL ret;
391 
392  if (!lpText) return FALSE;
393 
394  if (SHELL_OsIsUnicode() || lpText == FM_SEPARATOR)
395  ret = FileMenu_AppendItemW(hMenu, lpText, uID, icon, hMenuPopup, nItemHeight);
396  else
397  {
398  DWORD len = MultiByteToWideChar( CP_ACP, 0, lpText, -1, NULL, 0 );
399  LPWSTR lpszText = HeapAlloc ( GetProcessHeap(), 0, len*sizeof(WCHAR) );
400  if (!lpszText) return FALSE;
401  MultiByteToWideChar( CP_ACP, 0, lpText, -1, lpszText, len );
402  ret = FileMenu_AppendItemW(hMenu, lpszText, uID, icon, hMenuPopup, nItemHeight);
403  HeapFree( GetProcessHeap(), 0, lpszText );
404  }
405 
406  return ret;
407 }
408 
409 /*************************************************************************
410  * FileMenu_InsertUsingPidl [SHELL32.110]
411  *
412  * NOTES
413  * uEnumFlags any SHCONTF flag
414  */
416  HMENU hmenu,
417  UINT uID,
418  LPCITEMIDLIST pidl,
419  UINT uFlags,
420  UINT uEnumFlags,
421  LPFNFMCALLBACK lpfnCallback)
422 {
423  TRACE("%p 0x%08x %p 0x%08x 0x%08x %p\n",
424  hmenu, uID, pidl, uFlags, uEnumFlags, lpfnCallback);
425 
426  pdump (pidl);
427 
428  bAbortInit = FALSE;
429 
430  FM_SetMenuParameter(hmenu, uID, pidl, uFlags, uEnumFlags, lpfnCallback);
431 
432  return FM_InitMenuPopup(hmenu, NULL);
433 }
434 
435 /*************************************************************************
436  * FileMenu_ReplaceUsingPidl [SHELL32.113]
437  *
438  * FIXME: the static items are deleted but won't be refreshed
439  */
441  HMENU hmenu,
442  UINT uID,
443  LPCITEMIDLIST pidl,
444  UINT uEnumFlags,
445  LPFNFMCALLBACK lpfnCallback)
446 {
447  TRACE("%p 0x%08x %p 0x%08x %p\n",
448  hmenu, uID, pidl, uEnumFlags, lpfnCallback);
449 
451 
452  FM_SetMenuParameter(hmenu, uID, pidl, 0, uEnumFlags, lpfnCallback);
453 
454  return FM_InitMenuPopup(hmenu, NULL);
455 }
456 
457 /*************************************************************************
458  * FileMenu_Invalidate [SHELL32.111]
459  */
461 {
462  FIXME("%p\n",hMenu);
463 }
464 
465 /*************************************************************************
466  * FileMenu_FindSubMenuByPidl [SHELL32.106]
467  */
469  HMENU hMenu,
470  LPCITEMIDLIST pidl)
471 {
472  FIXME("%p %p\n",hMenu, pidl);
473  return 0;
474 }
475 
476 /*************************************************************************
477  * FileMenu_AppendFilesForPidl [SHELL32.124]
478  */
480  HMENU hmenu,
481  LPCITEMIDLIST pidl,
482  BOOL bAddSeparator)
483 {
484  LPFMINFO menudata;
485 
486  menudata = FM_GetMenuInfo(hmenu);
487 
488  menudata->bInitialized = FALSE;
489 
490  FM_InitMenuPopup(hmenu, pidl);
491 
492  if (bAddSeparator)
494 
495  TRACE("%p %p 0x%08x\n",hmenu, pidl,bAddSeparator);
496 
497  return 0;
498 }
499 /*************************************************************************
500  * FileMenu_AddFilesForPidl [SHELL32.125]
501  *
502  * NOTES
503  * uEnumFlags any SHCONTF flag
504  */
506  HMENU hmenu,
507  UINT uReserved,
508  UINT uID,
509  LPCITEMIDLIST pidl,
510  UINT uFlags,
511  UINT uEnumFlags,
512  LPFNFMCALLBACK lpfnCallback)
513 {
514  TRACE("%p 0x%08x 0x%08x %p 0x%08x 0x%08x %p\n",
515  hmenu, uReserved, uID, pidl, uFlags, uEnumFlags, lpfnCallback);
516 
517  return FileMenu_InsertUsingPidl ( hmenu, uID, pidl, uFlags, uEnumFlags, lpfnCallback);
518 
519 }
520 
521 
522 /*************************************************************************
523  * FileMenu_TrackPopupMenuEx [SHELL32.116]
524  */
526  HMENU hMenu,
527  UINT uFlags,
528  int x,
529  int y,
530  HWND hWnd,
531  LPTPMPARAMS lptpm)
532 {
533  TRACE("%p 0x%08x 0x%x 0x%x %p %p\n",
534  hMenu, uFlags, x, y, hWnd, lptpm);
535  return TrackPopupMenuEx(hMenu, uFlags, x, y, hWnd, lptpm);
536 }
537 
538 /*************************************************************************
539  * FileMenu_GetLastSelectedItemPidls [SHELL32.107]
540  */
542  UINT uReserved,
543  LPCITEMIDLIST *ppidlFolder,
544  LPCITEMIDLIST *ppidlItem)
545 {
546  FIXME("0x%08x %p %p\n",uReserved, ppidlFolder, ppidlItem);
547  return FALSE;
548 }
549 
550 #define FM_ICON_SIZE 16
551 #define FM_Y_SPACE 4
552 #define FM_SPACE1 4
553 #define FM_SPACE2 2
554 #define FM_LEFTBORDER 2
555 #define FM_RIGHTBORDER 8
556 /*************************************************************************
557  * FileMenu_MeasureItem [SHELL32.112]
558  */
560  HWND hWnd,
561  LPMEASUREITEMSTRUCT lpmis)
562 {
563  LPFMITEM pMyItem = (LPFMITEM)(lpmis->itemData);
564  HDC hdc = GetDC(hWnd);
565  SIZE size;
566  LPFMINFO menuinfo;
567 
568  TRACE("%p %p %s\n", hWnd, lpmis, debugstr_w(pMyItem->szItemText));
569 
570  GetTextExtentPoint32W(hdc, pMyItem->szItemText, pMyItem->cchItemText, &size);
571 
573  lpmis->itemHeight = (size.cy > (FM_ICON_SIZE + FM_Y_SPACE)) ? size.cy : (FM_ICON_SIZE + FM_Y_SPACE);
574 
575  /* add the menubitmap */
576  menuinfo = FM_GetMenuInfo(pMyItem->hMenu);
577  if (menuinfo->nBorderWidth)
578  lpmis->itemWidth += menuinfo->nBorderWidth;
579 
580  TRACE("-- 0x%04x 0x%04x\n", lpmis->itemWidth, lpmis->itemHeight);
581  ReleaseDC (hWnd, hdc);
582  return 0;
583 }
584 /*************************************************************************
585  * FileMenu_DrawItem [SHELL32.105]
586  */
588  HWND hWnd,
589  LPDRAWITEMSTRUCT lpdis)
590 {
591  LPFMITEM pMyItem = (LPFMITEM)(lpdis->itemData);
592  COLORREF clrPrevText, clrPrevBkgnd;
593  int xi,yi,xt,yt;
594  HIMAGELIST hImageList;
595  RECT TextRect;
596  LPFMINFO menuinfo;
597 
598  TRACE("%p %p %s\n", hWnd, lpdis, debugstr_w(pMyItem->szItemText));
599 
600  if (lpdis->itemState & ODS_SELECTED)
601  {
602  clrPrevText = SetTextColor(lpdis->hDC, GetSysColor (COLOR_HIGHLIGHTTEXT));
603  clrPrevBkgnd = SetBkColor(lpdis->hDC, GetSysColor (COLOR_HIGHLIGHT));
604  }
605  else
606  {
607  clrPrevText = SetTextColor(lpdis->hDC, GetSysColor (COLOR_MENUTEXT));
608  clrPrevBkgnd = SetBkColor(lpdis->hDC, GetSysColor (COLOR_MENU));
609  }
610 
611  TextRect = lpdis->rcItem;
612 
613  /* add the menubitmap */
614  menuinfo = FM_GetMenuInfo(pMyItem->hMenu);
615  if (menuinfo->nBorderWidth)
616  TextRect.left += menuinfo->nBorderWidth;
617 
618  TextRect.left += FM_LEFTBORDER;
619  xi = TextRect.left + FM_SPACE1;
620  yi = TextRect.top + FM_Y_SPACE/2;
621  TextRect.bottom -= FM_Y_SPACE/2;
622 
623  xt = xi + FM_ICON_SIZE + FM_SPACE2;
624  yt = yi;
625 
626  ExtTextOutW (lpdis->hDC, xt , yt, ETO_OPAQUE, &TextRect, pMyItem->szItemText, pMyItem->cchItemText, NULL);
627 
628  Shell_GetImageLists(0, &hImageList);
629  ImageList_Draw(hImageList, pMyItem->iIconIndex, lpdis->hDC, xi, yi, ILD_NORMAL);
630 
631  TRACE("-- %s\n", wine_dbgstr_rect(&TextRect));
632 
633  SetTextColor(lpdis->hDC, clrPrevText);
634  SetBkColor(lpdis->hDC, clrPrevBkgnd);
635 
636  return TRUE;
637 }
638 
639 /*************************************************************************
640  * FileMenu_InitMenuPopup [SHELL32.109]
641  *
642  * NOTES
643  * The filemenu is an ownerdrawn menu. Call this function responding to
644  * WM_INITPOPUPMENU
645  *
646  */
648 {
650  return TRUE;
651 }
652 
653 /*************************************************************************
654  * FileMenu_HandleMenuChar [SHELL32.108]
655  */
657  HMENU hMenu,
658  WPARAM wParam)
659 {
660  FIXME("%p 0x%08lx\n",hMenu,wParam);
661  return 0;
662 }
663 
664 /*************************************************************************
665  * FileMenu_DeleteAllItems [SHELL32.104]
666  *
667  * NOTES
668  * exported by name
669  */
671 {
672  MENUITEMINFOW mii;
673  LPFMINFO menudata;
674 
675  int i;
676 
677  TRACE("%p\n", hmenu);
678 
679  ZeroMemory ( &mii, sizeof(MENUITEMINFOW));
680  mii.cbSize = sizeof(MENUITEMINFOW);
682 
683  for (i = 0; i < GetMenuItemCount( hmenu ); i++)
684  { GetMenuItemInfoW(hmenu, i, TRUE, &mii );
685 
686  SHFree((LPFMINFO)mii.dwItemData);
687 
688  if (mii.hSubMenu)
690  }
691 
692  while (DeleteMenu (hmenu, 0, MF_BYPOSITION)){};
693 
694  menudata = FM_GetMenuInfo(hmenu);
695 
696  menudata->bInitialized = FALSE;
697 
698  return TRUE;
699 }
700 
701 /*************************************************************************
702  * FileMenu_DeleteItemByCmd [SHELL32.117]
703  *
704  */
706 {
707  MENUITEMINFOW mii;
708 
709  TRACE("%p 0x%08x\n", hMenu, uID);
710 
711  ZeroMemory ( &mii, sizeof(MENUITEMINFOW));
712  mii.cbSize = sizeof(MENUITEMINFOW);
713  mii.fMask = MIIM_SUBMENU;
714 
715  GetMenuItemInfoW(hMenu, uID, FALSE, &mii );
716  if ( mii.hSubMenu )
717  {
718  /* FIXME: Do what? */
719  }
720 
721  DeleteMenu(hMenu, MF_BYCOMMAND, uID);
722  return TRUE;
723 }
724 
725 /*************************************************************************
726  * FileMenu_DeleteItemByIndex [SHELL32.140]
727  */
729 {
730  MENUITEMINFOW mii;
731 
732  TRACE("%p 0x%08x\n", hMenu, uPos);
733 
734  ZeroMemory ( &mii, sizeof(MENUITEMINFOW));
735  mii.cbSize = sizeof(MENUITEMINFOW);
736  mii.fMask = MIIM_SUBMENU;
737 
738  GetMenuItemInfoW(hMenu, uPos, TRUE, &mii );
739  if ( mii.hSubMenu )
740  {
741  /* FIXME: Do what? */
742  }
743 
744  DeleteMenu(hMenu, MF_BYPOSITION, uPos);
745  return TRUE;
746 }
747 
748 /*************************************************************************
749  * FileMenu_DeleteItemByFirstID [SHELL32.141]
750  */
752  HMENU hMenu,
753  UINT uID)
754 {
755  TRACE("%p 0x%08x\n", hMenu, uID);
756  return FALSE;
757 }
758 
759 /*************************************************************************
760  * FileMenu_DeleteSeparator [SHELL32.142]
761  */
763 {
764  TRACE("%p\n", hMenu);
765  return FALSE;
766 }
767 
768 /*************************************************************************
769  * FileMenu_EnableItemByCmd [SHELL32.143]
770  */
772  HMENU hMenu,
773  UINT uID,
774  BOOL bEnable)
775 {
776  TRACE("%p 0x%08x 0x%08x\n", hMenu, uID,bEnable);
777  return FALSE;
778 }
779 
780 /*************************************************************************
781  * FileMenu_GetItemExtent [SHELL32.144]
782  *
783  * NOTES
784  * if the menu is too big, entries are getting cut away!!
785  */
787 { RECT rect;
788 
789  FIXME("%p 0x%08x\n", hMenu, uPos);
790 
791  if (GetMenuItemRect(0, hMenu, uPos, &rect))
792  {
793  FIXME("%s\n", wine_dbgstr_rect(&rect));
794  return ((rect.right-rect.left)<<16) + (rect.top-rect.bottom);
795  }
796  return 0x00100010; /*FIXME*/
797 }
798 
799 /*************************************************************************
800  * FileMenu_AbortInitMenu [SHELL32.120]
801  *
802  */
804 { TRACE("\n");
805  bAbortInit = TRUE;
806 }
807 
808 /*************************************************************************
809  * SHFind_InitMenuPopup [SHELL32.149]
810  *
811  * Get the IContextMenu instance for the submenu of options displayed
812  * for the Search entry in the Classic style Start menu.
813  *
814  * PARAMETERS
815  * hMenu [in] handle of menu previously created
816  * hWndParent [in] parent window
817  * w [in] no pointer (0x209 over here) perhaps menu IDs ???
818  * x [in] no pointer (0x226 over here)
819  *
820  * RETURNS
821  * LPXXXXX pointer to struct containing a func addr at offset 8
822  * or NULL at failure.
823  */
825 {
826  FIXME("hmenu=%p hwnd=%p 0x%08x 0x%08x stub\n",
827  hMenu,hWndParent,w,x);
828  return NULL; /* this is supposed to be a pointer */
829 }
830 
831 /*************************************************************************
832  * _SHIsMenuSeparator (internal)
833  */
835 {
836  MENUITEMINFOW mii;
837 
838  mii.cbSize = sizeof(MENUITEMINFOW);
839  mii.fMask = MIIM_TYPE;
840  mii.cch = 0; /* WARNING: We MUST initialize it to 0*/
841  if (!GetMenuItemInfoW(hm, i, TRUE, &mii))
842  {
843  return(FALSE);
844  }
845 
846  if (mii.fType & MFT_SEPARATOR)
847  {
848  return(TRUE);
849  }
850 
851  return(FALSE);
852 }
853 
854 /*************************************************************************
855  * Shell_MergeMenus [SHELL32.67]
856  */
857 UINT WINAPI Shell_MergeMenus (HMENU hmDst, HMENU hmSrc, UINT uInsert, UINT uIDAdjust, UINT uIDAdjustMax, ULONG uFlags)
858 { int nItem;
859  HMENU hmSubMenu;
860  BOOL bAlreadySeparated;
861  MENUITEMINFOW miiSrc;
862  WCHAR szName[256];
863  UINT uTemp, uIDMax = uIDAdjust;
864 
865  TRACE("hmenu1=%p hmenu2=%p 0x%04x 0x%04x 0x%04x 0x%04x\n",
866  hmDst, hmSrc, uInsert, uIDAdjust, uIDAdjustMax, uFlags);
867 
868  if (!hmDst || !hmSrc)
869  return uIDMax;
870 
871  nItem = GetMenuItemCount(hmDst);
872  if (nItem == -1)
873  return uIDMax;
874 
875  if (uInsert >= (UINT)nItem) /* insert position inside menu? */
876  {
877  uInsert = (UINT)nItem; /* append on the end */
878  bAlreadySeparated = TRUE;
879  }
880  else
881  {
882  bAlreadySeparated = _SHIsMenuSeparator(hmDst, uInsert);
883  }
884 
885  if ((uFlags & MM_ADDSEPARATOR) && !bAlreadySeparated)
886  {
887  /* Add a separator between the menus */
888  InsertMenuA(hmDst, uInsert, MF_BYPOSITION | MF_SEPARATOR, 0, NULL);
889  bAlreadySeparated = TRUE;
890  }
891 
892 
893  /* Go through the menu items and clone them*/
894  for (nItem = GetMenuItemCount(hmSrc) - 1; nItem >= 0; nItem--)
895  {
896  miiSrc.cbSize = sizeof(MENUITEMINFOW);
898 
899  /* We need to reset this every time through the loop in case menus DON'T have IDs*/
900  miiSrc.fType = MFT_STRING;
901  miiSrc.dwTypeData = szName;
902  miiSrc.dwItemData = 0;
903  miiSrc.cch = sizeof(szName)/sizeof(WCHAR);
904 
905  if (!GetMenuItemInfoW(hmSrc, nItem, TRUE, &miiSrc))
906  {
907  continue;
908  }
909 
910 /* TRACE("found menu=0x%04x %s id=0x%04x mask=0x%08x smenu=0x%04x\n", hmSrc, debugstr_a(miiSrc.dwTypeData), miiSrc.wID, miiSrc.fMask, miiSrc.hSubMenu);
911 */
912  if (miiSrc.fType & MFT_SEPARATOR)
913  {
914  /* This is a separator; don't put two of them in a row */
915  if (bAlreadySeparated)
916  continue;
917 
918  bAlreadySeparated = TRUE;
919  }
920  else if (miiSrc.hSubMenu)
921  {
923  {
924  miiSrc.wID += uIDAdjust; /* add uIDAdjust to the ID */
925 
926  if (miiSrc.wID > uIDAdjustMax) /* skip IDs higher than uIDAdjustMax */
927  continue;
928 
929  if (uIDMax <= miiSrc.wID) /* remember the highest ID */
930  uIDMax = miiSrc.wID + 1;
931  }
932  else
933  {
934  miiSrc.fMask &= ~MIIM_ID; /* Don't set IDs for submenus that didn't have them already */
935  }
936  hmSubMenu = miiSrc.hSubMenu;
937 
938  miiSrc.hSubMenu = CreatePopupMenu();
939 
940  if (!miiSrc.hSubMenu) return(uIDMax);
941 
942  uTemp = Shell_MergeMenus(miiSrc.hSubMenu, hmSubMenu, 0, uIDAdjust, uIDAdjustMax, uFlags & MM_SUBMENUSHAVEIDS);
943 
944  if (uIDMax <= uTemp)
945  uIDMax = uTemp;
946 
947  bAlreadySeparated = FALSE;
948  }
949  else /* normal menu item */
950  {
951  miiSrc.wID += uIDAdjust; /* add uIDAdjust to the ID */
952 
953  if (miiSrc.wID > uIDAdjustMax) /* skip IDs higher than uIDAdjustMax */
954  continue;
955 
956  if (uIDMax <= miiSrc.wID) /* remember the highest ID */
957  uIDMax = miiSrc.wID + 1;
958 
959  bAlreadySeparated = FALSE;
960  }
961 
962 /* TRACE("inserting menu=0x%04x %s id=0x%04x mask=0x%08x smenu=0x%04x\n", hmDst, debugstr_a(miiSrc.dwTypeData), miiSrc.wID, miiSrc.fMask, miiSrc.hSubMenu);
963 */
964  if (!InsertMenuItemW(hmDst, uInsert, TRUE, &miiSrc))
965  {
966  return(uIDMax);
967  }
968  }
969 
970  /* Ensure the correct number of separators at the beginning of the
971  inserted menu items*/
972  if (uInsert == 0)
973  {
974  if (bAlreadySeparated)
975  {
976  DeleteMenu(hmDst, uInsert, MF_BYPOSITION);
977  }
978  }
979  else
980  {
981  if (_SHIsMenuSeparator(hmDst, uInsert-1))
982  {
983  if (bAlreadySeparated)
984  {
985  DeleteMenu(hmDst, uInsert, MF_BYPOSITION);
986  }
987  }
988  else
989  {
990  if ((uFlags & MM_ADDSEPARATOR) && !bAlreadySeparated)
991  {
992  /* Add a separator between the menus*/
993  InsertMenuW(hmDst, uInsert, MF_BYPOSITION | MF_SEPARATOR, 0, NULL);
994  }
995  }
996  }
997  return(uIDMax);
998 }
BOOL WINAPI ExtTextOutW(_In_ HDC hdc, _In_ int x, _In_ int y, _In_ UINT options, _In_opt_ const RECT *lprect, _In_reads_opt_(c) LPCWSTR lpString, _In_ UINT c, _In_reads_opt_(c) const INT *lpDx)
int WINAPI FileMenu_InsertUsingPidl(HMENU hmenu, UINT uID, LPCITEMIDLIST pidl, UINT uFlags, UINT uEnumFlags, LPFNFMCALLBACK lpfnCallback)
Definition: shlmenu.c:415
struct tagMENUINFO MENUINFO
#define MFT_STRING
Definition: winuser.h:741
#define TRUE
Definition: types.h:120
static LPFMINFO FM_SetMenuParameter(HMENU hmenu, UINT uID, LPCITEMIDLIST pidl, UINT uFlags, UINT uEnumFlags, LPFNFMCALLBACK lpfnCallback)
Definition: shlmenu.c:100
#define COLOR_HIGHLIGHT
Definition: winuser.h:916
GLubyte GLubyte GLubyte GLubyte w
Definition: glext.h:6102
#define MF_BYCOMMAND
Definition: winuser.h:202
struct FMITEM * LPFMITEM
WINE_UNICODE_INLINE unsigned int strlenW(const WCHAR *str)
Definition: unicode.h:212
UINT WINAPI Shell_MergeMenus(HMENU hmDst, HMENU hmSrc, UINT uInsert, UINT uIDAdjust, UINT uIDAdjustMax, ULONG uFlags)
Definition: shlmenu.c:857
UINT uEnumFlags
Definition: shlmenu.c:57
int WINAPI FileMenu_ReplaceUsingPidl(HMENU hmenu, UINT uID, LPCITEMIDLIST pidl, UINT uEnumFlags, LPFNFMCALLBACK lpfnCallback)
Definition: shlmenu.c:440
static HMENU hmenu
Definition: win.c:66
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
LPFNFMCALLBACK lpfnCallback
Definition: shlmenu.c:58
BOOL WINAPI InsertMenuW(_In_ HMENU, _In_ UINT, _In_ UINT, _In_ UINT_PTR, _In_opt_ LPCWSTR)
#define FM_DEFAULT_HEIGHT
Definition: undocshell.h:248
HDC WINAPI GetDC(_In_opt_ HWND)
#define CP_ACP
Definition: compat.h:99
LPITEMIDLIST WINAPI ILCombine(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
Definition: pidl.c:699
BOOL WINAPI TrackPopupMenuEx(_In_ HMENU, _In_ UINT, _In_ int, _In_ int, _In_ HWND, _In_opt_ LPTPMPARAMS)
void WINAPI FileMenu_AbortInitMenu(void)
Definition: shlmenu.c:803
const ITEMIDLIST UNALIGNED * LPCITEMIDLIST
Definition: shtypes.idl:42
static HDC
Definition: imagelist.c:92
HWND hWnd
Definition: settings.c:17
BOOL WINAPI FileMenu_AppendItemAW(HMENU hMenu, LPCVOID lpText, UINT uID, int icon, HMENU hMenuPopup, int nItemHeight)
Definition: shlmenu.c:382
LONG top
Definition: windef.h:292
ULONG_PTR itemData
Definition: winuser.h:3046
#define ZeroMemory
Definition: winbase.h:1635
#define FM_SPACE2
Definition: shlmenu.c:553
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
LPWSTR dwTypeData
Definition: winuser.h:3211
UINT_PTR WPARAM
Definition: windef.h:207
BOOL WINAPI ImageList_Draw(HIMAGELIST himl, INT i, HDC hdc, INT x, INT y, UINT fStyle)
Definition: imagelist.c:1193
LONG left
Definition: windef.h:291
static __inline BOOL SHELL_OsIsUnicode(void)
Definition: shell32_main.h:130
UINT uFlags
Definition: api.c:60
#define MFS_DEFAULT
Definition: winuser.h:743
BOOL WINAPI FileMenu_EnableItemByCmd(HMENU hMenu, UINT uID, BOOL bEnable)
Definition: shlmenu.c:771
DWORD WINAPI GetSysColor(_In_ int)
& rect
Definition: startmenu.cpp:1413
WPARAM wParam
Definition: combotst.c:138
#define ILGDN_FORPARSING
Definition: undocshell.h:68
COLORREF WINAPI SetBkColor(_In_ HDC, _In_ COLORREF)
Definition: dc.c:975
static BOOL _SHIsMenuSeparator(HMENU hm, int i)
Definition: shlmenu.c:834
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define MIIM_SUBMENU
Definition: winuser.h:718
void WINAPI FileMenu_Destroy(HMENU hmenu)
Definition: shlmenu.c:285
#define MFS_ENABLED
Definition: winuser.h:745
BOOL WINAPI FileMenu_InitMenuPopup(HMENU hmenu)
Definition: shlmenu.c:647
#define ETO_OPAQUE
Definition: wingdi.h:646
#define FM_LEFTBORDER
Definition: shlmenu.c:554
#define MIIM_STATE
Definition: winuser.h:716
unsigned int BOOL
Definition: ntddk_ex.h:94
#define MF_BYPOSITION
Definition: winuser.h:203
#define debugstr_w
Definition: kernel32.h:32
int WINAPI ReleaseDC(_In_opt_ HWND, _In_ HDC)
#define FIXME(fmt,...)
Definition: debug.h:110
int WINAPI GetMenuItemCount(_In_opt_ HMENU)
BOOL bInitialized
Definition: shlmenu.c:46
void(CALLBACK * LPFNFMCALLBACK)(LPCITEMIDLIST pidlFolder, LPCITEMIDLIST pidlFile)
Definition: undocshell.h:263
smooth NULL
Definition: ftsmooth.c:416
#define COLOR_MENU
Definition: winuser.h:907
#define MF_SEPARATOR
Definition: winuser.h:137
int iIconIndex
Definition: shlmenu.c:63
#define FM_Y_SPACE
Definition: shlmenu.c:551
BOOL ILGetDisplayNameExW(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, LPWSTR path, DWORD type)
Definition: pidl.c:91
#define COLOR_HIGHLIGHTTEXT
Definition: winuser.h:917
LPWSTR WINAPI PathFindExtensionW(LPCWSTR lpszPath)
Definition: path.c:442
LPITEMIDLIST pidl
Definition: shlmenu.c:54
IContextMenu *WINAPI SHFind_InitMenuPopup(HMENU hMenu, HWND hWndParent, UINT w, UINT x)
Definition: shlmenu.c:824
#define MIIM_ID
Definition: winuser.h:717
static BOOL bAbortInit
Definition: shlmenu.c:68
BOOL WINAPI InsertMenuA(_In_ HMENU, _In_ UINT, _In_ UINT, _In_ UINT_PTR, _In_opt_ LPCSTR)
static const WCHAR szEmpty[]
Definition: provider.c:47
BOOL WINAPI GetMenuItemInfoW(_In_ HMENU, _In_ UINT, _In_ BOOL, _Inout_ LPMENUITEMINFOW)
#define TRACE(s)
Definition: solgame.cpp:4
HRESULT WINAPI SHGetDesktopFolder(IShellFolder **psf)
GLsizeiptr size
Definition: glext.h:5919
HMENU WINAPI FileMenu_FindSubMenuByPidl(HMENU hMenu, LPCITEMIDLIST pidl)
Definition: shlmenu.c:468
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
UINT uFlags
Definition: shlmenu.c:56
if(!(yy_init))
Definition: macro.lex.yy.c:714
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define MM_ADDSEPARATOR
Definition: shlobj.h:2319
#define FM_RIGHTBORDER
Definition: shlmenu.c:555
BOOL WINAPI DeleteMenu(_In_ HMENU, _In_ UINT, _In_ UINT)
DWORD COLORREF
Definition: windef.h:285
static BOOL FileMenu_AppendItemW(HMENU hMenu, LPCWSTR lpText, UINT uID, int icon, HMENU hMenuPopup, int nItemHeight)
Definition: shlmenu.c:305
COLORREF crBorderColor
Definition: shlmenu.c:49
LRESULT WINAPI FileMenu_DrawItem(HWND hWnd, LPDRAWITEMSTRUCT lpdis)
Definition: shlmenu.c:587
#define MAX_PATH
Definition: compat.h:26
#define WINAPI
Definition: msvc.h:8
const char * wine_dbgstr_rect(const RECT *rect)
#define COLOR_MENUTEXT
Definition: winuser.h:910
LRESULT WINAPI FileMenu_HandleMenuChar(HMENU hMenu, WPARAM wParam)
Definition: shlmenu.c:656
unsigned long DWORD
Definition: ntddk_ex.h:95
HMENU WINAPI FileMenu_Create(COLORREF crBorderColor, int nBorderWidth, HBITMAP hBorderBmp, int nSelHeight, UINT uFlags)
Definition: shlmenu.c:251
BOOL WINAPI FileMenu_DeleteSeparator(HMENU hMenu)
Definition: shlmenu.c:762
#define MFT_SEPARATOR
Definition: winuser.h:739
#define FM_ICON_SIZE
Definition: shlmenu.c:550
#define FM_SEPARATOR
Definition: shlmenu.c:39
int ret
BOOL WINAPI FileMenu_DeleteAllItems(HMENU hmenu)
Definition: shlmenu.c:670
Definition: shlmenu.c:44
HBITMAP hBorderBmp
Definition: shlmenu.c:51
HDC hdc
Definition: main.c:9
BOOL WINAPI FileMenu_GetLastSelectedItemPidls(UINT uReserved, LPCITEMIDLIST *ppidlFolder, LPCITEMIDLIST *ppidlItem)
Definition: shlmenu.c:541
WCHAR szItemText[1]
Definition: shlmenu.c:65
#define MIIM_TYPE
Definition: winuser.h:720
int WINAPI FileMenu_AppendFilesForPidl(HMENU hmenu, LPCITEMIDLIST pidl, BOOL bAddSeparator)
Definition: shlmenu.c:479
ULONG_PTR itemData
Definition: winuser.h:3588
GLenum GLsizei len
Definition: glext.h:6722
#define MIIM_CHECKMARKS
Definition: winuser.h:719
#define FM_BLANK_ICON
Definition: undocshell.h:247
static int FM_InitMenuPopup(HMENU hmenu, LPCITEMIDLIST pAlternatePidl)
Definition: shlmenu.c:129
BOOL WINAPI FileMenu_DeleteItemByFirstID(HMENU hMenu, UINT uID)
Definition: shlmenu.c:751
#define FM_SPACE1
Definition: shlmenu.c:552
menu info structure
Definition: window.h:275
BOOL WINAPI DestroyMenu(_In_ HMENU)
BOOL WINAPI Shell_GetImageLists(HIMAGELIST *lpBigList, HIMAGELIST *lpSmallList)
Definition: iconcache.cpp:706
#define ERR(fmt,...)
Definition: debug.h:109
COLORREF WINAPI SetTextColor(_In_ HDC, _In_ COLORREF)
Definition: text.c:886
#define S_OK
Definition: intsafe.h:59
WINE_UNICODE_INLINE WCHAR * strcpyW(WCHAR *dst, const WCHAR *src)
Definition: unicode.h:219
WINE_DEFAULT_DEBUG_CHANNEL(shell)
DWORD WINAPI FileMenu_GetItemExtent(HMENU hMenu, UINT uPos)
Definition: shlmenu.c:786
_In_ BOOL bEnable
Definition: winddi.h:3426
int WINAPI FileMenu_AddFilesForPidl(HMENU hmenu, UINT uReserved, UINT uID, LPCITEMIDLIST pidl, UINT uFlags, UINT uEnumFlags, LPFNFMCALLBACK lpfnCallback)
Definition: shlmenu.c:505
BOOL WINAPI SetMenuInfo(_In_ HMENU, _In_ LPCMENUINFO)
void shell(int argc, const char *argv[])
Definition: cmds.c:1231
LPITEMIDLIST WINAPI ILClone(LPCITEMIDLIST pidl)
Definition: pidl.c:228
BOOL WINAPI GetMenuInfo(_In_ HMENU, _Inout_ LPMENUINFO)
void pdump(LPCITEMIDLIST pidl)
Definition: debughlp.cpp:248
Definition: shlmenu.c:61
int cchItemText
Definition: shlmenu.c:62
UINT uID
Definition: shlmenu.c:55
BOOL WINAPI InsertMenuItemW(_In_ HMENU, _In_ UINT, _In_ BOOL, _In_ LPCMENUITEMINFOW)
unsigned int UINT
Definition: ndis.h:50
#define HEAP_ZERO_MEMORY
Definition: compat.h:123
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
#define MultiByteToWideChar
Definition: compat.h:100
BOOL WINAPI GetMenuItemRect(_In_opt_ HWND, _In_ HMENU, _In_ UINT, _Out_ LPRECT)
HMENU WINAPI CreatePopupMenu(void)
Definition: menu.c:846
void WINAPI SHFree(LPVOID pv)
Definition: shellole.c:331
struct FMINFO * LPFMINFO
CONST void * LPCVOID
Definition: windef.h:191
void WINAPI FileMenu_Invalidate(HMENU hMenu)
Definition: shlmenu.c:460
#define MM_SUBMENUSHAVEIDS
Definition: shlobj.h:2320
static const WCHAR szName[]
Definition: msipriv.h:1194
#define ODS_SELECTED
Definition: winuser.h:2499
unsigned int ULONG
Definition: retypes.h:1
BOOL bFixedItems
Definition: shlmenu.c:47
BOOL WINAPI FileMenu_DeleteItemByCmd(HMENU hMenu, UINT uID)
Definition: shlmenu.c:705
LONG bottom
Definition: windef.h:294
#define ULONG_PTR
Definition: config.h:101
BOOL PidlToSicIndex(IShellFolder *sh, LPCITEMIDLIST pidl, BOOL bBigIcon, UINT uFlags, int *pIndex)
Definition: iconcache.cpp:732
int nBorderWidth
Definition: shlmenu.c:50
static HBITMAP
Definition: button.c:44
#define ILD_NORMAL
Definition: commctrl.h:402
#define MFT_OWNERDRAW
Definition: winuser.h:736
WCHAR * LPWSTR
Definition: xmlstorage.h:184
#define MIIM_DATA
Definition: winuser.h:721
LONG_PTR LRESULT
Definition: windef.h:209
LRESULT WINAPI FileMenu_MeasureItem(HWND hWnd, LPMEASUREITEMSTRUCT lpmis)
Definition: shlmenu.c:559
ITEMIDLIST UNALIGNED * LPITEMIDLIST
Definition: shtypes.idl:41
ULONG_PTR dwItemData
Definition: winuser.h:3210
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static HMENU
Definition: ordinal.c:60
BOOL WINAPI FileMenu_DeleteItemByIndex(HMENU hMenu, UINT uPos)
Definition: shlmenu.c:728
BOOL WINAPI FileMenu_TrackPopupMenuEx(HMENU hMenu, UINT uFlags, int x, int y, HWND hWnd, LPTPMPARAMS lptpm)
Definition: shlmenu.c:525
static LPFMINFO FM_GetMenuInfo(HMENU hmenu)
Definition: shlmenu.c:74
LPVOID WINAPI SHAlloc(SIZE_T len)
Definition: shellole.c:309
struct tagMENUITEMINFOW MENUITEMINFOW
#define HeapFree(x, y, z)
Definition: compat.h:394
HMENU hMenu
Definition: shlmenu.c:64
BOOL WINAPI GetTextExtentPoint32W(_In_ HDC hdc, _In_reads_(c) LPCWSTR lpString, _In_ int c, _Out_ LPSIZE psizl)
#define SUCCEEDED(hr)
Definition: intsafe.h:57