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