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