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