git.oblomov.eu Git - wine/blob - dlls/user/menu.c

   1 /*
   2  * Menu functions
   3  *
   4  * Copyright 1993 Martin Ayotte
   5  * Copyright 1994 Alexandre Julliard
   6  * Copyright 1997 Morten Welinder
   7  * Copyright 2005 Maxime Bellengé
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  */
  23
  24 /*
  25  * Note: the style MF_MOUSESELECT is used to mark popup items that
  26  * have been selected, i.e. their popup menu is currently displayed.
  27  * This is probably not the meaning this style has in MS-Windows.
  28  *
  29  * TODO:
  30  *    implements styles :
  31  *        - MNS_AUTODISMISS
  32  *        - MNS_DRAGDROP
  33  *        - MNS_MODELESS
  34  *        - MNS_NOCHECK
  35  *        - MNS_NOTIFYBYPOS
  36  */
  37
  38 #include "config.h"
  39 #include "wine/port.h"
  40
  41 #include <stdarg.h>
  42 #include <string.h>
  43
  44 #include "windef.h"
  45 #include "winbase.h"
  46 #include "wingdi.h"
  47 #include "winnls.h"
  48 #include "wine/winbase16.h"
  49 #include "wine/winuser16.h"
  50 #include "wownt32.h"
  51 #include "wine/server.h"
  52 #include "wine/unicode.h"
  53 #include "win.h"
  54 #include "controls.h"
  55 #include "user_private.h"
  56 #include "wine/debug.h"
  57
  58 WINE_DEFAULT_DEBUG_CHANNEL(menu);
  59 WINE_DECLARE_DEBUG_CHANNEL(accel);
  60
  61 /* internal popup menu window messages */
  62
  63 #define MM_SETMENUHANDLE        (WM_USER + 0)
  64 #define MM_GETMENUHANDLE        (WM_USER + 1)
  65
  66 /* Menu item structure */
  67 typedef struct {
  68     /* ----------- MENUITEMINFO Stuff ----------- */
  69     UINT fType;                 /* Item type. */
  70     UINT fState;                /* Item state.  */
  71     UINT_PTR wID;               /* Item id.  */
  72     HMENU hSubMenu;             /* Pop-up menu.  */
  73     HBITMAP hCheckBit;          /* Bitmap when checked.  */
  74     HBITMAP hUnCheckBit;        /* Bitmap when unchecked.  */
  75     LPWSTR text;                        /* Item text or bitmap handle.  */
  76     DWORD dwItemData;           /* Application defined.  */
  77     DWORD dwTypeData;           /* depends on fMask */
  78     HBITMAP hbmpItem;           /* bitmap in win98 style menus */
  79     /* ----------- Wine stuff ----------- */
  80     RECT      rect;             /* Item area (relative to menu window) */
  81     UINT      xTab;             /* X position of text after Tab */
  82 } MENUITEM;
  83
  84 /* Popup menu structure */
  85 typedef struct {
  86     WORD        wFlags;       /* Menu flags (MF_POPUP, MF_SYSMENU) */
  87     WORD        wMagic;       /* Magic number */
  88     WORD        Width;        /* Width of the whole menu */
  89     WORD        Height;       /* Height of the whole menu */
  90     UINT        nItems;       /* Number of items in the menu */
  91     HWND        hWnd;         /* Window containing the menu */
  92     MENUITEM    *items;       /* Array of menu items */
  93     UINT        FocusedItem;  /* Currently focused item */
  94     HWND        hwndOwner;    /* window receiving the messages for ownerdraw */
  95     BOOL        bTimeToHide;  /* Request hiding when receiving a second click in the top-level menu item */
  96     /* ------------ MENUINFO members ------ */
  97     DWORD       dwStyle;        /* Extended mennu style */
  98     UINT        cyMax;          /* max hight of the whole menu, 0 is screen hight */
  99     HBRUSH      hbrBack;        /* brush for menu background */
 100     DWORD       dwContextHelpID;
 101     DWORD       dwMenuData;     /* application defined value */
 102     HMENU       hSysMenuOwner;  /* Handle to the dummy sys menu holder */
 103     SIZE        maxBmpSize;     /* Maximum size of the bitmap items in MIIM_BITMAP state */
 104 } POPUPMENU, *LPPOPUPMENU;
 105
 106 /* internal flags for menu tracking */
 107
 108 #define TF_ENDMENU              0x0001
 109 #define TF_SUSPENDPOPUP         0x0002
 110 #define TF_SKIPREMOVE           0x0004
 111
 112 typedef struct
 113 {
 114     UINT        trackFlags;
 115     HMENU       hCurrentMenu; /* current submenu (can be equal to hTopMenu)*/
 116     HMENU       hTopMenu;     /* initial menu */
 117     HWND        hOwnerWnd;    /* where notifications are sent */
 118     POINT       pt;
 119 } MTRACKER;
 120
 121 #define MENU_MAGIC   0x554d  /* 'MU' */
 122
 123 #define ITEM_PREV               -1
 124 #define ITEM_NEXT                1
 125
 126   /* Internal MENU_TrackMenu() flags */
 127 #define TPM_INTERNAL            0xF0000000
 128 #define TPM_ENTERIDLEEX         0x80000000              /* set owner window for WM_ENTERIDLE */
 129 #define TPM_BUTTONDOWN          0x40000000              /* menu was clicked before tracking */
 130 #define TPM_POPUPMENU           0x20000000              /* menu is a popup menu */
 131
 132   /* popup menu shade thickness */
 133 #define POPUP_XSHADE            4
 134 #define POPUP_YSHADE            4
 135
 136   /* Space between 2 menu bar items */
 137 #define MENU_BAR_ITEMS_SPACE 12
 138
 139   /* Minimum width of a tab character */
 140 #define MENU_TAB_SPACE 8
 141
 142   /* Height of a separator item */
 143 #define SEPARATOR_HEIGHT 5
 144
 145   /* (other menu->FocusedItem values give the position of the focused item) */
 146 #define NO_SELECTED_ITEM  0xffff
 147
 148 #define MENU_ITEM_TYPE(flags) \
 149   ((flags) & (MF_STRING | MF_BITMAP | MF_OWNERDRAW | MF_SEPARATOR))
 150
 151 #define IS_STRING_ITEM(flags) (MENU_ITEM_TYPE ((flags)) == MF_STRING)
 152 #define IS_BITMAP_ITEM(flags) (MENU_ITEM_TYPE ((flags)) == MF_BITMAP)
 153 #define IS_MAGIC_ITEM(text)   (LOWORD((int)text)<12)
 154
 155 #define IS_SYSTEM_MENU(menu)  \
 156         (!((menu)->wFlags & MF_POPUP) && ((menu)->wFlags & MF_SYSMENU))
 157
 158 #define TYPE_MASK (MFT_STRING | MFT_BITMAP | MFT_OWNERDRAW | MFT_SEPARATOR | \
 159                    MFT_MENUBARBREAK | MFT_MENUBREAK | MFT_RADIOCHECK | \
 160                    MFT_RIGHTORDER | MFT_RIGHTJUSTIFY | \
 161                    MF_POPUP | MF_SYSMENU | MF_HELP)
 162 #define STATE_MASK (~TYPE_MASK)
 163
 164 #define WIN_ALLOWED_MENU(style) ((style & (WS_CHILD | WS_POPUP)) != WS_CHILD)
 165
 166   /* Dimension of the menu bitmaps */
 167 static WORD arrow_bitmap_width = 0, arrow_bitmap_height = 0;
 168
 169 static HBITMAP hStdMnArrow = 0;
 170 static HBITMAP hBmpSysMenu = 0;
 171
 172 static HBRUSH   hShadeBrush = 0;
 173 static HFONT    hMenuFont = 0;
 174 static HFONT    hMenuFontBold = 0;
 175
 176 static HMENU MENU_DefSysPopup = 0;  /* Default system menu popup */
 177
 178 /* Use global popup window because there's no way 2 menus can
 179  * be tracked at the same time.  */
 180 static HWND top_popup;
 181
 182   /* Flag set by EndMenu() to force an exit from menu tracking */
 183 static BOOL fEndMenu = FALSE;
 184
 185 static LRESULT WINAPI PopupMenuWndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam );
 186
 187 DWORD WINAPI DrawMenuBarTemp(HWND hwnd, HDC hDC, LPRECT lprect, HMENU hMenu, HFONT hFont);
 188
 189 /*********************************************************************
 190  * menu class descriptor
 191  */
 192 const struct builtin_class_descr MENU_builtin_class =
 193 {
 194     POPUPMENU_CLASS_ATOMA,         /* name */
 195     CS_DROPSHADOW | CS_SAVEBITS | CS_DBLCLKS,  /* style */
 196     NULL,                          /* procA (winproc is Unicode only) */
 197     PopupMenuWndProc,              /* procW */
 198     sizeof(HMENU),                 /* extra */
 199     IDC_ARROW,                     /* cursor */
 200     (HBRUSH)(COLOR_MENU+1)         /* brush */
 201 };
 202
 203
 204 /***********************************************************************
 205  *           debug_print_menuitem
 206  *
 207  * Print a menuitem in readable form.
 208  */
 209
 210 #define debug_print_menuitem(pre, mp, post) \
 211   if(!TRACE_ON(menu)) ; else do_debug_print_menuitem(pre, mp, post)
 212
 213 #define MENUOUT(text) \
 214   DPRINTF("%s%s", (count++ ? "," : ""), (text))
 215
 216 #define MENUFLAG(bit,text) \
 217   do { \
 218     if (flags & (bit)) { flags &= ~(bit); MENUOUT ((text)); } \
 219   } while (0)
 220
 221 static void do_debug_print_menuitem(const char *prefix, MENUITEM * mp,
 222                                     const char *postfix)
 223 {
 224     TRACE("%s ", prefix);
 225     if (mp) {
 226         UINT flags = mp->fType;
 227         int type = MENU_ITEM_TYPE(flags);
 228         DPRINTF( "{ ID=0x%x", mp->wID);
 229         if (flags & MF_POPUP)
 230             DPRINTF( ", Sub=%p", mp->hSubMenu);
 231         if (flags) {
 232             int count = 0;
 233             DPRINTF( ", Type=");
 234             if (type == MFT_STRING)
 235                 /* Nothing */ ;
 236             else if (type == MFT_SEPARATOR)
 237                 MENUOUT("sep");
 238             else if (type == MFT_OWNERDRAW)
 239                 MENUOUT("own");
 240             else if (type == MFT_BITMAP)
 241                 MENUOUT("bit");
 242             else
 243                 MENUOUT("???");
 244             flags -= type;
 245
 246             MENUFLAG(MF_POPUP, "pop");
 247             MENUFLAG(MFT_MENUBARBREAK, "barbrk");
 248             MENUFLAG(MFT_MENUBREAK, "brk");
 249             MENUFLAG(MFT_RADIOCHECK, "radio");
 250             MENUFLAG(MFT_RIGHTORDER, "rorder");
 251             MENUFLAG(MF_SYSMENU, "sys");
 252             MENUFLAG(MFT_RIGHTJUSTIFY, "right");        /* same as MF_HELP */
 253
 254             if (flags)
 255                 DPRINTF( "+0x%x", flags);
 256         }
 257         flags = mp->fState;
 258         if (flags) {
 259             int count = 0;
 260             DPRINTF( ", State=");
 261             MENUFLAG(MFS_GRAYED, "grey");
 262             MENUFLAG(MFS_DEFAULT, "default");
 263             MENUFLAG(MFS_DISABLED, "dis");
 264             MENUFLAG(MFS_CHECKED, "check");
 265             MENUFLAG(MFS_HILITE, "hi");
 266             MENUFLAG(MF_USECHECKBITMAPS, "usebit");
 267             MENUFLAG(MF_MOUSESELECT, "mouse");
 268             if (flags)
 269                 DPRINTF( "+0x%x", flags);
 270         }
 271         if (mp->hCheckBit)
 272             DPRINTF( ", Chk=%p", mp->hCheckBit);
 273         if (mp->hUnCheckBit)
 274             DPRINTF( ", Unc=%p", mp->hUnCheckBit);
 275
 276         if (type == MFT_STRING) {
 277             if (mp->text)
 278                 DPRINTF( ", Text=%s", debugstr_w(mp->text));
 279             else
 280                 DPRINTF( ", Text=Null");
 281         } else if (mp->text == NULL)
 282             /* Nothing */ ;
 283         else
 284             DPRINTF( ", Text=%p", mp->text);
 285         if (mp->dwItemData)
 286             DPRINTF( ", ItemData=0x%08lx", mp->dwItemData);
 287         DPRINTF( " }");
 288     } else {
 289         DPRINTF( "NULL");
 290     }
 291
 292     DPRINTF(" %s\n", postfix);
 293 }
 294
 295 #undef MENUOUT
 296 #undef MENUFLAG
 297
 298
 299 /***********************************************************************
 300  *           MENU_GetMenu
 301  *
 302  * Validate the given menu handle and returns the menu structure pointer.
 303  */
 304 static POPUPMENU *MENU_GetMenu(HMENU hMenu)
 305 {
 306     POPUPMENU *menu = USER_HEAP_LIN_ADDR(hMenu);
 307     if (!menu || menu->wMagic != MENU_MAGIC)
 308     {
 309         WARN("invalid menu handle=%p, ptr=%p, magic=%x\n", hMenu, menu, menu? menu->wMagic:0);
 310         menu = NULL;
 311     }
 312     return menu;
 313 }
 314
 315 /***********************************************************************
 316  *           get_win_sys_menu
 317  *
 318  * Get the system menu of a window
 319  */
 320 static HMENU get_win_sys_menu( HWND hwnd )
 321 {
 322     HMENU ret = 0;
 323     WND *win = WIN_GetPtr( hwnd );
 324     if (win && win != WND_OTHER_PROCESS && win != WND_DESKTOP)
 325     {
 326         ret = win->hSysMenu;
 327         WIN_ReleasePtr( win );
 328     }
 329     return ret;
 330 }
 331
 332 /***********************************************************************
 333  *           MENU_CopySysPopup
 334  *
 335  * Return the default system menu.
 336  */
 337 static HMENU MENU_CopySysPopup(void)
 338 {
 339     static const WCHAR sysmenuW[] = {'S','Y','S','M','E','N','U',0};
 340     HMENU hMenu = LoadMenuW(user32_module, sysmenuW);
 341
 342     if( hMenu ) {
 343         POPUPMENU* menu = MENU_GetMenu(hMenu);
 344         menu->wFlags |= MF_SYSMENU | MF_POPUP;
 345         SetMenuDefaultItem(hMenu, SC_CLOSE, FALSE);
 346     }
 347     else
 348         ERR("Unable to load default system menu\n" );
 349
 350     TRACE("returning %p.\n", hMenu );
 351
 352     return hMenu;
 353 }
 354
 355
 356 /**********************************************************************
 357  *           MENU_GetSysMenu
 358  *
 359  * Create a copy of the system menu. System menu in Windows is
 360  * a special menu bar with the single entry - system menu popup.
 361  * This popup is presented to the outside world as a "system menu".
 362  * However, the real system menu handle is sometimes seen in the
 363  * WM_MENUSELECT parameters (and Word 6 likes it this way).
 364  */
 365 HMENU MENU_GetSysMenu( HWND hWnd, HMENU hPopupMenu )
 366 {
 367     HMENU hMenu;
 368
 369     TRACE("loading system menu, hWnd %p, hPopupMenu %p\n", hWnd, hPopupMenu);
 370     if ((hMenu = CreateMenu()))
 371     {
 372         POPUPMENU *menu = MENU_GetMenu(hMenu);
 373         menu->wFlags = MF_SYSMENU;
 374         menu->hWnd = WIN_GetFullHandle( hWnd );
 375         TRACE("hWnd %p (hMenu %p)\n", menu->hWnd, hMenu);
 376
 377         if (hPopupMenu == (HMENU)(-1))
 378             hPopupMenu = MENU_CopySysPopup();
 379         else if( !hPopupMenu ) hPopupMenu = MENU_DefSysPopup;
 380
 381         if (hPopupMenu)
 382         {
 383             InsertMenuW( hMenu, -1, MF_SYSMENU | MF_POPUP | MF_BYPOSITION,
 384                          (UINT_PTR)hPopupMenu, NULL );
 385
 386             menu->items[0].fType = MF_SYSMENU | MF_POPUP;
 387             menu->items[0].fState = 0;
 388             if ((menu = MENU_GetMenu(hPopupMenu))) menu->wFlags |= MF_SYSMENU;
 389
 390             TRACE("hMenu=%p (hPopup %p)\n", hMenu, hPopupMenu );
 391             return hMenu;
 392         }
 393         DestroyMenu( hMenu );
 394     }
 395     ERR("failed to load system menu!\n");
 396     return 0;
 397 }
 398
 399
 400 /***********************************************************************
 401  *           MENU_Init
 402  *
 403  * Menus initialisation.
 404  */
 405 BOOL MENU_Init(void)
 406 {
 407     HBITMAP hBitmap;
 408     NONCLIENTMETRICSW ncm;
 409
 410     static unsigned char shade_bits[16] = { 0x55, 0, 0xAA, 0,
 411                                             0x55, 0, 0xAA, 0,
 412                                             0x55, 0, 0xAA, 0,
 413                                             0x55, 0, 0xAA, 0 };
 414
 415     /* Load menu bitmaps */
 416     hStdMnArrow = LoadBitmapW(0, MAKEINTRESOURCEW(OBM_MNARROW));
 417     /* Load system buttons bitmaps */
 418     hBmpSysMenu = LoadBitmapW(0, MAKEINTRESOURCEW(OBM_CLOSE));
 419
 420     if (hStdMnArrow)
 421     {
 422         BITMAP bm;
 423         GetObjectW( hStdMnArrow, sizeof(bm), &bm );
 424         arrow_bitmap_width = bm.bmWidth;
 425         arrow_bitmap_height = bm.bmHeight;
 426     } else
 427         return FALSE;
 428
 429     if (! (hBitmap = CreateBitmap( 8, 8, 1, 1, shade_bits)))
 430         return FALSE;
 431
 432     if(!(hShadeBrush = CreatePatternBrush( hBitmap )))
 433         return FALSE;
 434
 435     DeleteObject( hBitmap );
 436     if (!(MENU_DefSysPopup = MENU_CopySysPopup()))
 437         return FALSE;
 438
 439     ncm.cbSize = sizeof(NONCLIENTMETRICSW);
 440     if (!(SystemParametersInfoW(SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICSW), &ncm, 0)))
 441         return FALSE;
 442
 443     if (!(hMenuFont = CreateFontIndirectW( &ncm.lfMenuFont )))
 444         return FALSE;
 445
 446     ncm.lfMenuFont.lfWeight += 300;
 447     if ( ncm.lfMenuFont.lfWeight > 1000)
 448         ncm.lfMenuFont.lfWeight = 1000;
 449
 450     if (!(hMenuFontBold = CreateFontIndirectW( &ncm.lfMenuFont )))
 451         return FALSE;
 452
 453     return TRUE;
 454 }
 455
 456 /***********************************************************************
 457  *           MENU_InitSysMenuPopup
 458  *
 459  * Grey the appropriate items in System menu.
 460  */
 461 static void MENU_InitSysMenuPopup( HMENU hmenu, DWORD style, DWORD clsStyle )
 462 {
 463     BOOL gray;
 464
 465     gray = !(style & WS_THICKFRAME) || (style & (WS_MAXIMIZE | WS_MINIMIZE));
 466     EnableMenuItem( hmenu, SC_SIZE, (gray ? MF_GRAYED : MF_ENABLED) );
 467     gray = ((style & WS_MAXIMIZE) != 0);
 468     EnableMenuItem( hmenu, SC_MOVE, (gray ? MF_GRAYED : MF_ENABLED) );
 469     gray = !(style & WS_MINIMIZEBOX) || (style & WS_MINIMIZE);
 470     EnableMenuItem( hmenu, SC_MINIMIZE, (gray ? MF_GRAYED : MF_ENABLED) );
 471     gray = !(style & WS_MAXIMIZEBOX) || (style & WS_MAXIMIZE);
 472     EnableMenuItem( hmenu, SC_MAXIMIZE, (gray ? MF_GRAYED : MF_ENABLED) );
 473     gray = !(style & (WS_MAXIMIZE | WS_MINIMIZE));
 474     EnableMenuItem( hmenu, SC_RESTORE, (gray ? MF_GRAYED : MF_ENABLED) );
 475     gray = (clsStyle & CS_NOCLOSE) != 0;
 476
 477     /* The menu item must keep its state if it's disabled */
 478     if(gray)
 479         EnableMenuItem( hmenu, SC_CLOSE, MF_GRAYED);
 480 }
 481
 482
 483 /******************************************************************************
 484  *
 485  *   UINT  MENU_GetStartOfNextColumn(
 486  *     HMENU  hMenu )
 487  *
 488  *****************************************************************************/
 489
 490 static UINT  MENU_GetStartOfNextColumn(
 491     HMENU  hMenu )
 492 {
 493     POPUPMENU *menu = MENU_GetMenu(hMenu);
 494     UINT i;
 495
 496     if(!menu)
 497         return NO_SELECTED_ITEM;
 498
 499     i = menu->FocusedItem + 1;
 500     if( i == NO_SELECTED_ITEM )
 501         return i;
 502
 503     for( ; i < menu->nItems; ++i ) {
 504         if (menu->items[i].fType & MF_MENUBARBREAK)
 505             return i;
 506     }
 507
 508     return NO_SELECTED_ITEM;
 509 }
 510
 511
 512 /******************************************************************************
 513  *
 514  *   UINT  MENU_GetStartOfPrevColumn(
 515  *     HMENU  hMenu )
 516  *
 517  *****************************************************************************/
 518
 519 static UINT  MENU_GetStartOfPrevColumn(
 520     HMENU  hMenu )
 521 {
 522     POPUPMENU *menu = MENU_GetMenu(hMenu);
 523     UINT  i;
 524
 525     if( !menu )
 526         return NO_SELECTED_ITEM;
 527
 528     if( menu->FocusedItem == 0 || menu->FocusedItem == NO_SELECTED_ITEM )
 529         return NO_SELECTED_ITEM;
 530
 531     /* Find the start of the column */
 532
 533     for(i = menu->FocusedItem; i != 0 &&
 534          !(menu->items[i].fType & MF_MENUBARBREAK);
 535         --i); /* empty */
 536
 537     if(i == 0)
 538         return NO_SELECTED_ITEM;
 539
 540     for(--i; i != 0; --i) {
 541         if (menu->items[i].fType & MF_MENUBARBREAK)
 542             break;
 543     }
 544
 545     TRACE("ret %d.\n", i );
 546
 547     return i;
 548 }
 549
 550
 551
 552 /***********************************************************************
 553  *           MENU_FindItem
 554  *
 555  * Find a menu item. Return a pointer on the item, and modifies *hmenu
 556  * in case the item was in a sub-menu.
 557  */
 558 static MENUITEM *MENU_FindItem( HMENU *hmenu, UINT *nPos, UINT wFlags )
 559 {
 560     POPUPMENU *menu;
 561     UINT i;
 562
 563     if ((*hmenu == (HMENU)0xffff) || (!(menu = MENU_GetMenu(*hmenu)))) return NULL;
 564     if (wFlags & MF_BYPOSITION)
 565     {
 566         if (*nPos >= menu->nItems) return NULL;
 567         return &menu->items[*nPos];
 568     }
 569     else
 570     {
 571         MENUITEM *item = menu->items;
 572         for (i = 0; i < menu->nItems; i++, item++)
 573         {
 574             if (item->wID == *nPos)
 575             {
 576                 *nPos = i;
 577                 return item;
 578             }
 579             else if (item->fType & MF_POPUP)
 580             {
 581                 HMENU hsubmenu = item->hSubMenu;
 582                 MENUITEM *subitem = MENU_FindItem( &hsubmenu, nPos, wFlags );
 583                 if (subitem)
 584                 {
 585                     *hmenu = hsubmenu;
 586                     return subitem;
 587                 }
 588             }
 589         }
 590     }
 591     return NULL;
 592 }
 593
 594 /***********************************************************************
 595  *           MENU_FindSubMenu
 596  *
 597  * Find a Sub menu. Return the position of the submenu, and modifies
 598  * *hmenu in case it is found in another sub-menu.
 599  * If the submenu cannot be found, NO_SELECTED_ITEM is returned.
 600  */
 601 UINT MENU_FindSubMenu( HMENU *hmenu, HMENU hSubTarget )
 602 {
 603     POPUPMENU *menu;
 604     UINT i;
 605     MENUITEM *item;
 606     if (((*hmenu)==(HMENU)0xffff) ||
 607             (!(menu = MENU_GetMenu(*hmenu))))
 608         return NO_SELECTED_ITEM;
 609     item = menu->items;
 610     for (i = 0; i < menu->nItems; i++, item++) {
 611         if(!(item->fType & MF_POPUP)) continue;
 612         if (item->hSubMenu == hSubTarget) {
 613             return i;
 614         }
 615         else  {
 616             HMENU hsubmenu = item->hSubMenu;
 617             UINT pos = MENU_FindSubMenu( &hsubmenu, hSubTarget );
 618             if (pos != NO_SELECTED_ITEM) {
 619                 *hmenu = hsubmenu;
 620                 return pos;
 621             }
 622         }
 623     }
 624     return NO_SELECTED_ITEM;
 625 }
 626
 627 /***********************************************************************
 628  *           MENU_FreeItemData
 629  */
 630 static void MENU_FreeItemData( MENUITEM* item )
 631 {
 632     /* delete text */
 633     if (IS_STRING_ITEM(item->fType) && item->text)
 634         HeapFree( GetProcessHeap(), 0, item->text );
 635 }
 636
 637 /***********************************************************************
 638  *           MENU_FindItemByCoords
 639  *
 640  * Find the item at the specified coordinates (screen coords). Does
 641  * not work for child windows and therefore should not be called for
 642  * an arbitrary system menu.
 643  */
 644 static MENUITEM *MENU_FindItemByCoords( const POPUPMENU *menu,
 645                                         POINT pt, UINT *pos )
 646 {
 647     MENUITEM *item;
 648     UINT i;
 649     RECT wrect;
 650
 651     if (!GetWindowRect(menu->hWnd,&wrect)) return NULL;
 652     pt.x -= wrect.left;pt.y -= wrect.top;
 653     item = menu->items;
 654     for (i = 0; i < menu->nItems; i++, item++)
 655     {
 656         if ((pt.x >= item->rect.left) && (pt.x < item->rect.right) &&
 657             (pt.y >= item->rect.top) && (pt.y < item->rect.bottom))
 658         {
 659             if (pos) *pos = i;
 660             return item;
 661         }
 662     }
 663     return NULL;
 664 }
 665
 666
 667 /***********************************************************************
 668  *           MENU_FindItemByKey
 669  *
 670  * Find the menu item selected by a key press.
 671  * Return item id, -1 if none, -2 if we should close the menu.
 672  */
 673 static UINT MENU_FindItemByKey( HWND hwndOwner, HMENU hmenu,
 674                                 WCHAR key, BOOL forceMenuChar )
 675 {
 676     TRACE("\tlooking for '%c' (0x%02x) in [%p]\n", (char)key, key, hmenu );
 677
 678     if (!IsMenu( hmenu )) hmenu = GetSubMenu( get_win_sys_menu(hwndOwner), 0);
 679
 680     if (hmenu)
 681     {
 682         POPUPMENU *menu = MENU_GetMenu( hmenu );
 683         MENUITEM *item = menu->items;
 684         LRESULT menuchar;
 685
 686         if( !forceMenuChar )
 687         {
 688              UINT i;
 689
 690              for (i = 0; i < menu->nItems; i++, item++)
 691              {
 692                 if (IS_STRING_ITEM(item->fType) && item->text)
 693                 {
 694                     WCHAR *p = item->text - 2;
 695                     do
 696                     {
 697                         p = strchrW (p + 2, '&');
 698                     }
 699                     while (p != NULL && p [1] == '&');
 700                     if (p && (toupperW(p[1]) == toupperW(key))) return i;
 701                 }
 702              }
 703         }
 704         menuchar = SendMessageW( hwndOwner, WM_MENUCHAR,
 705                                  MAKEWPARAM( key, menu->wFlags ), (LPARAM)hmenu );
 706         if (HIWORD(menuchar) == 2) return LOWORD(menuchar);
 707         if (HIWORD(menuchar) == 1) return (UINT)(-2);
 708     }
 709     return (UINT)(-1);
 710 }
 711
 712
 713 /***********************************************************************
 714  *           MENU_GetBitmapItemSize
 715  *
 716  * Get the size of a bitmap item.
 717  */
 718 static void MENU_GetBitmapItemSize( UINT id, DWORD data, SIZE *size )
 719 {
 720     BITMAP bm;
 721     HBITMAP bmp = (HBITMAP)id;
 722
 723     size->cx = size->cy = 0;
 724
 725     /* check if there is a magic menu item associated with this item */
 726     if (id && IS_MAGIC_ITEM( id ))
 727     {
 728         switch(LOWORD(id))
 729         {
 730         case (INT_PTR)HBMMENU_SYSTEM:
 731             if (data)
 732             {
 733                 bmp = (HBITMAP)data;
 734                 break;
 735             }
 736             /* fall through */
 737         case (INT_PTR)HBMMENU_MBAR_RESTORE:
 738         case (INT_PTR)HBMMENU_MBAR_MINIMIZE:
 739         case (INT_PTR)HBMMENU_MBAR_MINIMIZE_D:
 740         case (INT_PTR)HBMMENU_MBAR_CLOSE:
 741         case (INT_PTR)HBMMENU_MBAR_CLOSE_D:
 742             size->cx = GetSystemMetrics( SM_CYMENU ) - 4;
 743             size->cy = size->cx;
 744             return;
 745         case (INT_PTR)HBMMENU_CALLBACK:
 746         case (INT_PTR)HBMMENU_POPUP_CLOSE:
 747         case (INT_PTR)HBMMENU_POPUP_RESTORE:
 748         case (INT_PTR)HBMMENU_POPUP_MAXIMIZE:
 749         case (INT_PTR)HBMMENU_POPUP_MINIMIZE:
 750         default:
 751             FIXME("Magic 0x%08x not implemented\n", id);
 752             return;
 753         }
 754     }
 755     if (GetObjectW(bmp, sizeof(bm), &bm ))
 756     {
 757         size->cx = bm.bmWidth;
 758         size->cy = bm.bmHeight;
 759     }
 760 }
 761
 762 /***********************************************************************
 763  *           MENU_DrawBitmapItem
 764  *
 765  * Draw a bitmap item.
 766  * drawhbmbitmap : True to draw the hbmbitmap(MIIM_BITMAP)/False to draw the MF_BITMAP
 767  */
 768 static void MENU_DrawBitmapItem( HDC hdc, MENUITEM *lpitem, const RECT *rect, BOOL menuBar, BOOL drawhbmbitmap )
 769 {
 770     BITMAP bm;
 771     DWORD rop;
 772     HDC hdcMem;
 773     HBITMAP bmp = (HBITMAP)lpitem->text;
 774     int w = rect->right - rect->left;
 775     int h = rect->bottom - rect->top;
 776     int bmp_xoffset = 0;
 777     int left, top;
 778     HBITMAP hbmToDraw = (drawhbmbitmap)?lpitem->hbmpItem:(HBITMAP)lpitem->text;
 779
 780     /* Check if there is a magic menu item associated with this item */
 781     if (hbmToDraw && IS_MAGIC_ITEM(hbmToDraw))
 782     {
 783         UINT flags = 0;
 784         RECT r;
 785
 786         switch(LOWORD(hbmToDraw))
 787         {
 788         case (INT_PTR)HBMMENU_SYSTEM:
 789             if (lpitem->dwItemData)
 790             {
 791                 bmp = (HBITMAP)lpitem->dwItemData;
 792                 if (!GetObjectW( bmp, sizeof(bm), &bm )) return;
 793             }
 794             else
 795             {
 796                 bmp = hBmpSysMenu;
 797                 if (!GetObjectW( bmp, sizeof(bm), &bm )) return;
 798                 /* only use right half of the bitmap */
 799                 bmp_xoffset = bm.bmWidth / 2;
 800                 bm.bmWidth -= bmp_xoffset;
 801             }
 802             goto got_bitmap;
 803         case (INT_PTR)HBMMENU_MBAR_RESTORE:
 804             flags = DFCS_CAPTIONRESTORE;
 805             break;
 806         case (INT_PTR)HBMMENU_MBAR_MINIMIZE:
 807             flags = DFCS_CAPTIONMIN;
 808             break;
 809         case (INT_PTR)HBMMENU_MBAR_MINIMIZE_D:
 810             flags = DFCS_CAPTIONMIN | DFCS_INACTIVE;
 811             break;
 812         case (INT_PTR)HBMMENU_MBAR_CLOSE:
 813             flags = DFCS_CAPTIONCLOSE;
 814             break;
 815         case (INT_PTR)HBMMENU_MBAR_CLOSE_D:
 816             flags = DFCS_CAPTIONCLOSE | DFCS_INACTIVE;
 817             break;
 818         case (INT_PTR)HBMMENU_CALLBACK:
 819         case (INT_PTR)HBMMENU_POPUP_CLOSE:
 820         case (INT_PTR)HBMMENU_POPUP_RESTORE:
 821         case (INT_PTR)HBMMENU_POPUP_MAXIMIZE:
 822         case (INT_PTR)HBMMENU_POPUP_MINIMIZE:
 823         default:
 824             FIXME("Magic 0x%08x not implemented\n", LOWORD(hbmToDraw));
 825             return;
 826         }
 827         r = *rect;
 828         InflateRect( &r, -1, -1 );
 829         if (lpitem->fState & MF_HILITE) flags |= DFCS_PUSHED;
 830         DrawFrameControl( hdc, &r, DFC_CAPTION, flags );
 831         return;
 832     }
 833
 834     if (!bmp || !GetObjectW( bmp, sizeof(bm), &bm )) return;
 835
 836  got_bitmap:
 837     hdcMem = CreateCompatibleDC( hdc );
 838     SelectObject( hdcMem, bmp );
 839
 840     /* handle fontsize > bitmap_height */
 841     top = (h>bm.bmHeight) ? rect->top+(h-bm.bmHeight)/2 : rect->top;
 842     left=rect->left;
 843     rop=((lpitem->fState & MF_HILITE) && !IS_MAGIC_ITEM(hbmToDraw)) ? NOTSRCCOPY : SRCCOPY;
 844     if ((lpitem->fState & MF_HILITE) && IS_BITMAP_ITEM(lpitem->fType))
 845         SetBkColor(hdc, GetSysColor(COLOR_HIGHLIGHT));
 846     BitBlt( hdc, left, top, w, h, hdcMem, bmp_xoffset, 0, rop );
 847     DeleteDC( hdcMem );
 848 }
 849
 850
 851 /***********************************************************************
 852  *           MENU_CalcItemSize
 853  *
 854  * Calculate the size of the menu item and store it in lpitem->rect.
 855  */
 856 static void MENU_CalcItemSize( HDC hdc, MENUITEM *lpitem, HWND hwndOwner,
 857                                INT orgX, INT orgY, BOOL menuBar, POPUPMENU* lppop )
 858 {
 859     WCHAR *p;
 860     UINT check_bitmap_width = GetSystemMetrics( SM_CXMENUCHECK );
 861
 862     TRACE("dc=%p owner=%p (%d,%d)\n", hdc, hwndOwner, orgX, orgY);
 863     debug_print_menuitem("MENU_CalcItemSize: menuitem:", lpitem,
 864                          (menuBar ? " (MenuBar)" : ""));
 865
 866     SetRect( &lpitem->rect, orgX, orgY, orgX, orgY );
 867
 868     if (lpitem->fType & MF_OWNERDRAW)
 869     {
 870         /*
 871         ** Experimentation under Windows reveals that an owner-drawn
 872         ** menu is expected to return the size of the content part of
 873         ** the menu item, not including the checkmark nor the submenu
 874         ** arrow.  Windows adds those values itself and returns the
 875         ** enlarged rectangle on subsequent WM_DRAWITEM messages.
 876         */
 877         MEASUREITEMSTRUCT mis;
 878         mis.CtlType    = ODT_MENU;
 879         mis.CtlID      = 0;
 880         mis.itemID     = lpitem->wID;
 881         mis.itemData   = (DWORD)lpitem->dwItemData;
 882         mis.itemHeight = 0;
 883         mis.itemWidth  = 0;
 884         SendMessageW( hwndOwner, WM_MEASUREITEM, 0, (LPARAM)&mis );
 885         lpitem->rect.right  += mis.itemWidth;
 886
 887         if (menuBar)
 888         {
 889              lpitem->rect.right += MENU_BAR_ITEMS_SPACE;
 890
 891
 892              /* under at least win95 you seem to be given a standard
 893                 height for the menu and the height value is ignored */
 894              lpitem->rect.bottom += GetSystemMetrics(SM_CYMENU)-1;
 895         }
 896         else
 897             lpitem->rect.bottom += mis.itemHeight;
 898
 899         TRACE("id=%04x size=%dx%d\n",
 900                      lpitem->wID, mis.itemWidth, mis.itemHeight);
 901         /* Fall through to get check/arrow width calculation. */
 902     }
 903
 904     if (lpitem->fType & MF_SEPARATOR)
 905     {
 906         lpitem->rect.bottom += SEPARATOR_HEIGHT;
 907         return;
 908     }
 909
 910     if (!menuBar)
 911     {
 912         /* New style MIIM_BITMAP */
 913         if (lpitem->hbmpItem)
 914         {
 915             if (lpitem->hbmpItem == HBMMENU_CALLBACK)
 916             {
 917                 MEASUREITEMSTRUCT measItem;
 918                 measItem.CtlType = ODT_MENU;
 919                 measItem.CtlID = 0;
 920                 measItem.itemID = lpitem->wID;
 921                 measItem.itemWidth = lpitem->rect.right - lpitem->rect.left;
 922                 measItem.itemHeight = lpitem->rect.bottom - lpitem->rect.top;
 923                 measItem.itemData = lpitem->dwItemData;
 924
 925                 SendMessageW( hwndOwner, WM_MEASUREITEM, lpitem->wID, (LPARAM)&measItem);
 926
 927                 /* Keep the size of the bitmap in callback mode to be able to draw it correctly */
 928                 lppop->maxBmpSize.cx = max(lppop->maxBmpSize.cx, measItem.itemWidth - (lpitem->rect.right - lpitem->rect.left));
 929                 lppop->maxBmpSize.cy = max(lppop->maxBmpSize.cy, measItem.itemHeight - (lpitem->rect.bottom - lpitem->rect.top));
 930                 lpitem->rect.right = lpitem->rect.left + measItem.itemWidth;
 931             } else {
 932                 SIZE size;
 933                 MENU_GetBitmapItemSize((UINT)lpitem->hbmpItem, lpitem->dwItemData, &size);
 934                 lppop->maxBmpSize.cx = max(lppop->maxBmpSize.cx, size.cx);
 935                 lppop->maxBmpSize.cy = max(lppop->maxBmpSize.cy, size.cy);
 936                 lpitem->rect.right  += size.cx;
 937                 lpitem->rect.bottom += size.cy;
 938             }
 939             if (lppop->dwStyle & MNS_CHECKORBMP)
 940                 lpitem->rect.right += check_bitmap_width;
 941             else
 942                 lpitem->rect.right += 2 * check_bitmap_width;
 943         } else
 944             lpitem->rect.right += 2 * check_bitmap_width;
 945         if (lpitem->fType & MF_POPUP)
 946             lpitem->rect.right += arrow_bitmap_width;
 947     }
 948
 949     if (lpitem->fType & MF_OWNERDRAW)
 950         return;
 951
 952     if (IS_BITMAP_ITEM(lpitem->fType))
 953     {
 954         SIZE size;
 955
 956         MENU_GetBitmapItemSize( (int)lpitem->text, lpitem->dwItemData, &size );
 957         lpitem->rect.right  += size.cx;
 958         lpitem->rect.bottom += size.cy;
 959         /* Leave space for the sunken border */
 960         lpitem->rect.right  += 2;
 961         lpitem->rect.bottom += 2;
 962     }
 963
 964
 965     /* it must be a text item - unless it's the system menu */
 966     if (!(lpitem->fType & MF_SYSMENU) && IS_STRING_ITEM( lpitem->fType ))
 967     {   SIZE size;
 968
 969         GetTextExtentPoint32W(hdc, lpitem->text,  strlenW(lpitem->text), &size);
 970
 971         lpitem->rect.right  += size.cx;
 972         lpitem->rect.bottom += max(max(size.cy, GetSystemMetrics(SM_CYMENU)-1), lppop->maxBmpSize.cy);
 973         lpitem->xTab = 0;
 974
 975         if (menuBar)
 976         {
 977              lpitem->rect.right += MENU_BAR_ITEMS_SPACE;
 978         }
 979         else if ((p = strchrW( lpitem->text, '\t' )) != NULL)
 980         {
 981             /* Item contains a tab (only meaningful in popup menus) */
 982             GetTextExtentPoint32W(hdc, lpitem->text, (int)(p - lpitem->text) , &size);
 983             lpitem->xTab = check_bitmap_width + MENU_TAB_SPACE + size.cx;
 984             lpitem->rect.right += MENU_TAB_SPACE;
 985         }
 986         else
 987         {
 988             if (strchrW( lpitem->text, '\b' ))
 989                 lpitem->rect.right += MENU_TAB_SPACE;
 990             lpitem->xTab = lpitem->rect.right - check_bitmap_width
 991                            - arrow_bitmap_width;
 992         }
 993     }
 994     TRACE("(%ld,%ld)-(%ld,%ld)\n", lpitem->rect.left, lpitem->rect.top, lpitem->rect.right, lpitem->rect.bottom);
 995 }
 996
 997
 998 /***********************************************************************
 999  *           MENU_PopupMenuCalcSize
1000  *
1001  * Calculate the size of a popup menu.
1002  */
1003 static void MENU_PopupMenuCalcSize( LPPOPUPMENU lppop, HWND hwndOwner )
1004 {
1005     MENUITEM *lpitem;
1006     HDC hdc;
1007     int start, i;
1008     int orgX, orgY, maxX, maxTab, maxTabWidth;
1009
1010     lppop->Width = lppop->Height = 0;
1011     if (lppop->nItems == 0) return;
1012     hdc = GetDC( 0 );
1013
1014     SelectObject( hdc, hMenuFont);
1015
1016     start = 0;
1017     maxX = 2 + 1;
1018
1019     lppop->maxBmpSize.cx = 0;
1020     lppop->maxBmpSize.cy = 0;
1021
1022     while (start < lppop->nItems)
1023     {
1024         lpitem = &lppop->items[start];
1025         orgX = maxX;
1026         orgY = 3;
1027
1028         maxTab = maxTabWidth = 0;
1029           /* Parse items until column break or end of menu */
1030         for (i = start; i < lppop->nItems; i++, lpitem++)
1031         {
1032             if ((i != start) &&
1033                 (lpitem->fType & (MF_MENUBREAK | MF_MENUBARBREAK))) break;
1034
1035             MENU_CalcItemSize( hdc, lpitem, hwndOwner, orgX, orgY, FALSE, lppop );
1036
1037             if (lpitem->fType & MF_MENUBARBREAK) orgX++;
1038             maxX = max( maxX, lpitem->rect.right );
1039             orgY = lpitem->rect.bottom;
1040             if (IS_STRING_ITEM(lpitem->fType) && lpitem->xTab)
1041             {
1042                 maxTab = max( maxTab, lpitem->xTab );
1043                 maxTabWidth = max(maxTabWidth,lpitem->rect.right-lpitem->xTab);
1044             }
1045         }
1046
1047           /* Finish the column (set all items to the largest width found) */
1048         maxX = max( maxX, maxTab + maxTabWidth );
1049         for (lpitem = &lppop->items[start]; start < i; start++, lpitem++)
1050         {
1051             lpitem->rect.right = maxX;
1052             if (IS_STRING_ITEM(lpitem->fType) && lpitem->xTab)
1053                 lpitem->xTab = maxTab;
1054
1055         }
1056         lppop->Height = max( lppop->Height, orgY );
1057     }
1058
1059     lppop->Width  = maxX;
1060
1061     /* space for 3d border */
1062     lppop->Height += 2;
1063     lppop->Width += 2;
1064
1065     ReleaseDC( 0, hdc );
1066 }
1067
1068
1069 /***********************************************************************
1070  *           MENU_MenuBarCalcSize
1071  *
1072  * FIXME: Word 6 implements its own MDI and its own 'close window' bitmap
1073  * height is off by 1 pixel which causes lengthy window relocations when
1074  * active document window is maximized/restored.
1075  *
1076  * Calculate the size of the menu bar.
1077  */
1078 static void MENU_MenuBarCalcSize( HDC hdc, LPRECT lprect,
1079                                   LPPOPUPMENU lppop, HWND hwndOwner )
1080 {
1081     MENUITEM *lpitem;
1082     int start, i, orgX, orgY, maxY, helpPos;
1083
1084     if ((lprect == NULL) || (lppop == NULL)) return;
1085     if (lppop->nItems == 0) return;
1086     TRACE("left=%ld top=%ld right=%ld bottom=%ld\n",
1087           lprect->left, lprect->top, lprect->right, lprect->bottom);
1088     lppop->Width  = lprect->right - lprect->left;
1089     lppop->Height = 0;
1090     maxY = lprect->top+1;
1091     start = 0;
1092     helpPos = -1;
1093     lppop->maxBmpSize.cx = 0;
1094     lppop->maxBmpSize.cy = 0;
1095     while (start < lppop->nItems)
1096     {
1097         lpitem = &lppop->items[start];
1098         orgX = lprect->left;
1099         orgY = maxY;
1100
1101           /* Parse items until line break or end of menu */
1102         for (i = start; i < lppop->nItems; i++, lpitem++)
1103         {
1104             if ((helpPos == -1) && (lpitem->fType & MF_RIGHTJUSTIFY)) helpPos = i;
1105             if ((i != start) &&
1106                 (lpitem->fType & (MF_MENUBREAK | MF_MENUBARBREAK))) break;
1107
1108             TRACE("calling MENU_CalcItemSize org=(%d, %d)\n",
1109                          orgX, orgY );
1110             debug_print_menuitem ("  item: ", lpitem, "");
1111             MENU_CalcItemSize( hdc, lpitem, hwndOwner, orgX, orgY, TRUE, lppop );
1112
1113             if (lpitem->rect.right > lprect->right)
1114             {
1115                 if (i != start) break;
1116                 else lpitem->rect.right = lprect->right;
1117             }
1118             maxY = max( maxY, lpitem->rect.bottom );
1119             orgX = lpitem->rect.right;
1120         }
1121
1122           /* Finish the line (set all items to the largest height found) */
1123         while (start < i) lppop->items[start++].rect.bottom = maxY;
1124     }
1125
1126     lprect->bottom = maxY;
1127     lppop->Height = lprect->bottom - lprect->top;
1128
1129     /* Flush right all items between the MF_RIGHTJUSTIFY and */
1130     /* the last item (if several lines, only move the last line) */
1131     lpitem = &lppop->items[lppop->nItems-1];
1132     orgY = lpitem->rect.top;
1133     orgX = lprect->right;
1134     for (i = lppop->nItems - 1; i >= helpPos; i--, lpitem--) {
1135         if ( (helpPos==-1) || (helpPos>i) )
1136             break;                              /* done */
1137         if (lpitem->rect.top != orgY) break;    /* Other line */
1138         if (lpitem->rect.right >= orgX) break;  /* Too far right already */
1139         lpitem->rect.left += orgX - lpitem->rect.right;
1140         lpitem->rect.right = orgX;
1141         orgX = lpitem->rect.left;
1142     }
1143 }
1144
1145 /***********************************************************************
1146  *           MENU_DrawMenuItem
1147  *
1148  * Draw a single menu item.
1149  */
1150 static void MENU_DrawMenuItem( HWND hwnd, HMENU hmenu, HWND hwndOwner, HDC hdc, MENUITEM *lpitem,
1151                                UINT height, BOOL menuBar, UINT odaction )
1152 {
1153     RECT rect;
1154
1155     debug_print_menuitem("MENU_DrawMenuItem: ", lpitem, "");
1156
1157     if (lpitem->fType & MF_SYSMENU)
1158     {
1159         if( !IsIconic(hwnd) )
1160             NC_DrawSysButton( hwnd, hdc, lpitem->fState & (MF_HILITE | MF_MOUSESELECT) );
1161         return;
1162     }
1163
1164       /* Setup colors */
1165
1166     if (lpitem->fState & MF_HILITE)
1167     {
1168         if(menuBar) {
1169             SetTextColor(hdc, GetSysColor(COLOR_MENUTEXT));
1170             SetBkColor(hdc, GetSysColor(COLOR_MENU));
1171         } else {
1172             if(lpitem->fState & MF_GRAYED)
1173                 SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
1174             else
1175                 SetTextColor(hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
1176             SetBkColor(hdc, GetSysColor(COLOR_HIGHLIGHT));
1177         }
1178     }
1179     else
1180     {
1181         if (lpitem->fState & MF_GRAYED)
1182             SetTextColor( hdc, GetSysColor( COLOR_GRAYTEXT ) );
1183         else
1184             SetTextColor( hdc, GetSysColor( COLOR_MENUTEXT ) );
1185         SetBkColor( hdc, GetSysColor( COLOR_MENU ) );
1186     }
1187
1188     if (lpitem->fType & MF_OWNERDRAW)
1189     {
1190         /*
1191         ** Experimentation under Windows reveals that an owner-drawn
1192         ** menu is given the rectangle which includes the space it requested
1193         ** in its response to WM_MEASUREITEM _plus_ width for a checkmark
1194         ** and a popup-menu arrow.  This is the value of lpitem->rect.
1195         ** Windows will leave all drawing to the application except for
1196         ** the popup-menu arrow.  Windows always draws that itself, after
1197         ** the menu owner has finished drawing.
1198         */
1199         DRAWITEMSTRUCT dis;
1200
1201         dis.CtlType   = ODT_MENU;
1202         dis.CtlID     = 0;
1203         dis.itemID    = lpitem->wID;
1204         dis.itemData  = (DWORD)lpitem->dwItemData;
1205         dis.itemState = 0;
1206         if (lpitem->fState & MF_CHECKED) dis.itemState |= ODS_CHECKED;
1207         if (lpitem->fState & MF_GRAYED)  dis.itemState |= ODS_GRAYED|ODS_DISABLED;
1208         if (lpitem->fState & MF_HILITE)  dis.itemState |= ODS_SELECTED;
1209         dis.itemAction = odaction; /* ODA_DRAWENTIRE | ODA_SELECT | ODA_FOCUS; */
1210         dis.hwndItem   = (HWND)hmenu;
1211         dis.hDC        = hdc;
1212         dis.rcItem     = lpitem->rect;
1213         TRACE("Ownerdraw: owner=%p itemID=%d, itemState=%d, itemAction=%d, "
1214               "hwndItem=%p, hdc=%p, rcItem={%ld,%ld,%ld,%ld}\n", hwndOwner,
1215               dis.itemID, dis.itemState, dis.itemAction, dis.hwndItem,
1216               dis.hDC, dis.rcItem.left, dis.rcItem.top, dis.rcItem.right,
1217               dis.rcItem.bottom);
1218         SendMessageW( hwndOwner, WM_DRAWITEM, 0, (LPARAM)&dis );
1219         /* Fall through to draw popup-menu arrow */
1220     }
1221
1222     TRACE("rect={%ld,%ld,%ld,%ld}\n", lpitem->rect.left, lpitem->rect.top,
1223                                         lpitem->rect.right,lpitem->rect.bottom);
1224
1225     if (menuBar && (lpitem->fType & MF_SEPARATOR)) return;
1226
1227     rect = lpitem->rect;
1228
1229     if (!(lpitem->fType & MF_OWNERDRAW))
1230     {
1231         if (lpitem->fState & MF_HILITE)
1232         {
1233              if(menuBar)
1234                 DrawEdge(hdc, &rect, BDR_SUNKENOUTER, BF_RECT);
1235              else
1236                 FillRect(hdc, &rect, GetSysColorBrush(COLOR_HIGHLIGHT));
1237         }
1238         else
1239             FillRect( hdc, &rect, GetSysColorBrush(COLOR_MENU) );
1240     }
1241
1242     SetBkMode( hdc, TRANSPARENT );
1243
1244     if (!(lpitem->fType & MF_OWNERDRAW))
1245     {
1246         /* vertical separator */
1247         if (!menuBar && (lpitem->fType & MF_MENUBARBREAK))
1248         {
1249             RECT rc = rect;
1250             rc.top = 3;
1251             rc.bottom = height - 3;
1252             DrawEdge (hdc, &rc, EDGE_ETCHED, BF_LEFT);
1253         }
1254
1255         /* horizontal separator */
1256         if (lpitem->fType & MF_SEPARATOR)
1257         {
1258             RECT rc = rect;
1259             rc.left++;
1260             rc.right--;
1261             rc.top += SEPARATOR_HEIGHT / 2;
1262             DrawEdge (hdc, &rc, EDGE_ETCHED, BF_TOP);
1263             return;
1264         }
1265     }
1266
1267         /* helper lines for debugging */
1268 /*      FrameRect(hdc, &rect, GetStockObject(BLACK_BRUSH));
1269         SelectObject( hdc, SYSCOLOR_GetPen(COLOR_WINDOWFRAME) );
1270         MoveToEx( hdc, rect.left, (rect.top + rect.bottom)/2, NULL );
1271         LineTo( hdc, rect.right, (rect.top + rect.bottom)/2 );
1272 */
1273
1274     if (!menuBar)
1275     {
1276         HBITMAP bm;
1277         INT y = rect.top + rect.bottom;
1278         UINT check_bitmap_width = GetSystemMetrics( SM_CXMENUCHECK );
1279         UINT check_bitmap_height = GetSystemMetrics( SM_CYMENUCHECK );
1280
1281         if (!(lpitem->fType & MF_OWNERDRAW))
1282         {
1283             /* New style MIIM_BITMAP */
1284             if (lpitem->hbmpItem)
1285             {
1286                 POPUPMENU *menu = MENU_GetMenu(hmenu);
1287                 HBITMAP hbm = lpitem->hbmpItem;
1288
1289                 if (hbm == HBMMENU_CALLBACK)
1290                 {
1291                     DRAWITEMSTRUCT drawItem;
1292                     drawItem.CtlType = ODT_MENU;
1293                     drawItem.CtlID = 0;
1294                     drawItem.itemID = lpitem->wID;
1295                     drawItem.itemAction = odaction;
1296                     drawItem.itemState |= (lpitem->fState & MF_CHECKED)?ODS_CHECKED:0;
1297                     drawItem.itemState |= (lpitem->fState & MF_DEFAULT)?ODS_DEFAULT:0;
1298                     drawItem.itemState |= (lpitem->fState & MF_DISABLED)?ODS_DISABLED:0;
1299                     drawItem.itemState |= (lpitem->fState & MF_GRAYED)?ODS_GRAYED|ODS_DISABLED:0;
1300                     drawItem.itemState |= (lpitem->fState & MF_HILITE)?ODS_SELECTED:0;
1301                     drawItem.hwndItem = (HWND)hmenu;
1302                     drawItem.hDC = hdc;
1303                     drawItem.rcItem = lpitem->rect;
1304                     drawItem.itemData = lpitem->dwItemData;
1305
1306                     if (!(lpitem->fState & MF_CHECKED))
1307                         SendMessageW( hwndOwner, WM_DRAWITEM, 0, (LPARAM)&drawItem);
1308
1309                 } else {
1310                     MENU_DrawBitmapItem(hdc, lpitem, &rect, FALSE, TRUE);
1311                 }
1312                 if (menu->dwStyle & MNS_CHECKORBMP)
1313                     rect.left += menu->maxBmpSize.cx - check_bitmap_width;
1314                 else
1315                     rect.left += menu->maxBmpSize.cx;
1316             }
1317             /* Draw the check mark
1318              *
1319              * FIXME:
1320              * Custom checkmark bitmaps are monochrome but not always 1bpp.
1321              */
1322             bm = (lpitem->fState & MF_CHECKED) ? lpitem->hCheckBit : lpitem->hUnCheckBit;
1323             if (bm)  /* we have a custom bitmap */
1324             {
1325                 HDC hdcMem = CreateCompatibleDC( hdc );
1326                 SelectObject( hdcMem, bm );
1327                 BitBlt( hdc, rect.left, (y - check_bitmap_height) / 2,
1328                         check_bitmap_width, check_bitmap_height,
1329                         hdcMem, 0, 0, SRCCOPY );
1330                 DeleteDC( hdcMem );
1331             }
1332             else if (lpitem->fState & MF_CHECKED)  /* standard bitmaps */
1333             {
1334                 RECT r;
1335                 HBITMAP bm = CreateBitmap( check_bitmap_width, check_bitmap_height, 1, 1, NULL );
1336                 HDC hdcMem = CreateCompatibleDC( hdc );
1337                 SelectObject( hdcMem, bm );
1338                 SetRect( &r, 0, 0, check_bitmap_width, check_bitmap_height );
1339                 DrawFrameControl( hdcMem, &r, DFC_MENU,
1340                                   (lpitem->fType & MFT_RADIOCHECK) ?
1341                                   DFCS_MENUBULLET : DFCS_MENUCHECK );
1342                 BitBlt( hdc, rect.left, (y - r.bottom) / 2, r.right, r.bottom,
1343                         hdcMem, 0, 0, SRCCOPY );
1344                 DeleteDC( hdcMem );
1345                 DeleteObject( bm );
1346             }
1347         }
1348
1349           /* Draw the popup-menu arrow */
1350         if (lpitem->fType & MF_POPUP)
1351         {
1352             HDC hdcMem = CreateCompatibleDC( hdc );
1353             HBITMAP hOrigBitmap;
1354
1355             hOrigBitmap = SelectObject( hdcMem, hStdMnArrow );
1356             BitBlt( hdc, rect.right - arrow_bitmap_width - 1,
1357                       (y - arrow_bitmap_height) / 2,
1358                       arrow_bitmap_width, arrow_bitmap_height,
1359                       hdcMem, 0, 0, SRCCOPY );
1360             SelectObject( hdcMem, hOrigBitmap );
1361             DeleteDC( hdcMem );
1362         }
1363
1364         rect.left += check_bitmap_width;
1365         rect.right -= arrow_bitmap_width;
1366     }
1367
1368     /* Done for owner-drawn */
1369     if (lpitem->fType & MF_OWNERDRAW)
1370         return;
1371
1372     /* Draw the item text or bitmap */
1373     if (IS_BITMAP_ITEM(lpitem->fType))
1374     {
1375         MENU_DrawBitmapItem( hdc, lpitem, &rect, menuBar, FALSE);
1376         return;
1377     }
1378     /* No bitmap - process text if present */
1379     else if (IS_STRING_ITEM(lpitem->fType))
1380     {
1381         register int i;
1382         HFONT hfontOld = 0;
1383
1384         UINT uFormat = (menuBar) ?
1385                         DT_CENTER | DT_VCENTER | DT_SINGLELINE :
1386                         DT_LEFT | DT_VCENTER | DT_SINGLELINE;
1387
1388         if ( lpitem->fState & MFS_DEFAULT )
1389         {
1390              hfontOld = SelectObject( hdc, hMenuFontBold);
1391         }
1392
1393         if (menuBar)
1394         {
1395             rect.left += MENU_BAR_ITEMS_SPACE / 2;
1396             rect.right -= MENU_BAR_ITEMS_SPACE / 2;
1397         }
1398
1399         for (i = 0; lpitem->text[i]; i++)
1400             if ((lpitem->text[i] == '\t') || (lpitem->text[i] == '\b'))
1401                 break;
1402
1403         if(lpitem->fState & MF_GRAYED)
1404         {
1405             if (!(lpitem->fState & MF_HILITE) )
1406             {
1407                 ++rect.left; ++rect.top; ++rect.right; ++rect.bottom;
1408                 SetTextColor(hdc, RGB(0xff, 0xff, 0xff));
1409                 DrawTextW( hdc, lpitem->text, i, &rect, uFormat );
1410                 --rect.left; --rect.top; --rect.right; --rect.bottom;
1411             }
1412             SetTextColor(hdc, RGB(0x80, 0x80, 0x80));
1413         }
1414
1415         DrawTextW( hdc, lpitem->text, i, &rect, uFormat);
1416
1417         /* paint the shortcut text */
1418         if (!menuBar && lpitem->text[i])  /* There's a tab or flush-right char */
1419         {
1420             if (lpitem->text[i] == '\t')
1421             {
1422                 rect.left = lpitem->xTab;
1423                 uFormat = DT_LEFT | DT_VCENTER | DT_SINGLELINE;
1424             }
1425             else
1426             {
1427                 uFormat = DT_RIGHT | DT_VCENTER | DT_SINGLELINE;
1428             }
1429
1430             if(lpitem->fState & MF_GRAYED)
1431             {
1432                 if (!(lpitem->fState & MF_HILITE) )
1433                 {
1434                     ++rect.left; ++rect.top; ++rect.right; ++rect.bottom;
1435                     SetTextColor(hdc, RGB(0xff, 0xff, 0xff));
1436                     DrawTextW( hdc, lpitem->text + i + 1, -1, &rect, uFormat );
1437                     --rect.left; --rect.top; --rect.right; --rect.bottom;
1438                 }
1439                 SetTextColor(hdc, RGB(0x80, 0x80, 0x80));
1440             }
1441             DrawTextW( hdc, lpitem->text + i + 1, -1, &rect, uFormat );
1442         }
1443
1444         if (hfontOld)
1445             SelectObject (hdc, hfontOld);
1446     }
1447 }
1448
1449
1450 /***********************************************************************
1451  *           MENU_DrawPopupMenu
1452  *
1453  * Paint a popup menu.
1454  */
1455 static void MENU_DrawPopupMenu( HWND hwnd, HDC hdc, HMENU hmenu )
1456 {
1457     HBRUSH hPrevBrush = 0;
1458     RECT rect;
1459
1460     TRACE("wnd=%p dc=%p menu=%p\n", hwnd, hdc, hmenu);
1461
1462     GetClientRect( hwnd, &rect );
1463
1464     if((hPrevBrush = SelectObject( hdc, GetSysColorBrush(COLOR_MENU) ))
1465         && (SelectObject( hdc, hMenuFont)))
1466     {
1467         HPEN hPrevPen;
1468
1469         Rectangle( hdc, rect.left, rect.top, rect.right, rect.bottom );
1470
1471         hPrevPen = SelectObject( hdc, GetStockObject( NULL_PEN ) );
1472         if( hPrevPen )
1473         {
1474             POPUPMENU *menu;
1475
1476             DrawEdge (hdc, &rect, EDGE_RAISED, BF_RECT);
1477
1478             /* draw menu items */
1479
1480             menu = MENU_GetMenu( hmenu );
1481             if (menu && menu->nItems)
1482             {
1483                 MENUITEM *item;
1484                 UINT u;
1485
1486                 for (u = menu->nItems, item = menu->items; u > 0; u--, item++)
1487                     MENU_DrawMenuItem( hwnd, hmenu, menu->hwndOwner, hdc, item,
1488                                        menu->Height, FALSE, ODA_DRAWENTIRE );
1489
1490             }
1491         } else
1492         {
1493             SelectObject( hdc, hPrevBrush );
1494         }
1495     }
1496 }
1497
1498 /***********************************************************************
1499  *           MENU_DrawMenuBar
1500  *
1501  * Paint a menu bar. Returns the height of the menu bar.
1502  * called from [windows/nonclient.c]
1503  */
1504 UINT MENU_DrawMenuBar( HDC hDC, LPRECT lprect, HWND hwnd,
1505                          BOOL suppress_draw)
1506 {
1507     LPPOPUPMENU lppop;
1508     HFONT hfontOld = 0;
1509     HMENU hMenu = GetMenu(hwnd);
1510
1511     lppop = MENU_GetMenu( hMenu );
1512     if (lppop == NULL || lprect == NULL)
1513     {
1514         return GetSystemMetrics(SM_CYMENU);
1515     }
1516
1517     if (suppress_draw)
1518     {
1519         hfontOld = SelectObject( hDC, hMenuFont);
1520
1521         if (lppop->Height == 0)
1522                 MENU_MenuBarCalcSize(hDC, lprect, lppop, hwnd);
1523
1524         lprect->bottom = lprect->top + lppop->Height;
1525
1526         if (hfontOld) SelectObject( hDC, hfontOld);
1527         return lppop->Height;
1528     }
1529     else
1530         return DrawMenuBarTemp(hwnd, hDC, lprect, hMenu, NULL);
1531 }
1532
1533
1534 /***********************************************************************
1535  *           MENU_ShowPopup
1536  *
1537  * Display a popup menu.
1538  */
1539 static BOOL MENU_ShowPopup( HWND hwndOwner, HMENU hmenu, UINT id,
1540                               INT x, INT y, INT xanchor, INT yanchor )
1541 {
1542     POPUPMENU *menu;
1543     UINT width, height;
1544
1545     TRACE("owner=%p hmenu=%p id=0x%04x x=0x%04x y=0x%04x xa=0x%04x ya=0x%04x\n",
1546           hwndOwner, hmenu, id, x, y, xanchor, yanchor);
1547
1548     if (!(menu = MENU_GetMenu( hmenu ))) return FALSE;
1549     if (menu->FocusedItem != NO_SELECTED_ITEM)
1550     {
1551         menu->items[menu->FocusedItem].fState &= ~(MF_HILITE|MF_MOUSESELECT);
1552         menu->FocusedItem = NO_SELECTED_ITEM;
1553     }
1554
1555     /* store the owner for DrawItem */
1556     menu->hwndOwner = hwndOwner;
1557
1558     MENU_PopupMenuCalcSize( menu, hwndOwner );
1559
1560     /* adjust popup menu pos so that it fits within the desktop */
1561
1562     width = menu->Width + GetSystemMetrics(SM_CXBORDER);
1563     height = menu->Height + GetSystemMetrics(SM_CYBORDER);
1564
1565     if( x + width > GetSystemMetrics(SM_CXSCREEN ))
1566     {
1567         if( xanchor )
1568             x -= width - xanchor;
1569         if( x + width > GetSystemMetrics(SM_CXSCREEN))
1570             x = GetSystemMetrics(SM_CXSCREEN) - width;
1571     }
1572     if( x < 0 ) x = 0;
1573
1574     if( y + height > GetSystemMetrics(SM_CYSCREEN ))
1575     {
1576         if( yanchor )
1577             y -= height + yanchor;
1578         if( y + height > GetSystemMetrics(SM_CYSCREEN ))
1579             y = GetSystemMetrics(SM_CYSCREEN) - height;
1580     }
1581     if( y < 0 ) y = 0;
1582
1583     /* NOTE: In Windows, top menu popup is not owned. */
1584     menu->hWnd = CreateWindowExW( 0, POPUPMENU_CLASS_ATOMW, NULL,
1585                                 WS_POPUP, x, y, width, height,
1586                                 hwndOwner, 0, (HINSTANCE)GetWindowLongPtrW(hwndOwner, GWLP_HINSTANCE),
1587                                 (LPVOID)hmenu );
1588     if( !menu->hWnd ) return FALSE;
1589     if (!top_popup) top_popup = menu->hWnd;
1590
1591     /* Display the window */
1592
1593     SetWindowPos( menu->hWnd, HWND_TOP, 0, 0, 0, 0,
1594                   SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE );
1595     UpdateWindow( menu->hWnd );
1596     return TRUE;
1597 }
1598
1599
1600 /***********************************************************************
1601  *           MENU_SelectItem
1602  */
1603 static void MENU_SelectItem( HWND hwndOwner, HMENU hmenu, UINT wIndex,
1604                              BOOL sendMenuSelect, HMENU topmenu )
1605 {
1606     LPPOPUPMENU lppop;
1607     HDC hdc;
1608
1609     TRACE("owner=%p menu=%p index=0x%04x select=0x%04x\n", hwndOwner, hmenu, wIndex, sendMenuSelect);
1610
1611     lppop = MENU_GetMenu( hmenu );
1612     if ((!lppop) || (!lppop->nItems) || (!lppop->hWnd)) return;
1613
1614     if (lppop->FocusedItem == wIndex) return;
1615     if (lppop->wFlags & MF_POPUP) hdc = GetDC( lppop->hWnd );
1616     else hdc = GetDCEx( lppop->hWnd, 0, DCX_CACHE | DCX_WINDOW);
1617     if (!top_popup) top_popup = lppop->hWnd;
1618
1619     SelectObject( hdc, hMenuFont);
1620
1621       /* Clear previous highlighted item */
1622     if (lppop->FocusedItem != NO_SELECTED_ITEM)
1623     {
1624         lppop->items[lppop->FocusedItem].fState &= ~(MF_HILITE|MF_MOUSESELECT);
1625         MENU_DrawMenuItem(lppop->hWnd, hmenu, hwndOwner, hdc,&lppop->items[lppop->FocusedItem],
1626                           lppop->Height, !(lppop->wFlags & MF_POPUP),
1627                           ODA_SELECT );
1628     }
1629
1630       /* Highlight new item (if any) */
1631     lppop->FocusedItem = wIndex;
1632     if (lppop->FocusedItem != NO_SELECTED_ITEM)
1633     {
1634         if(!(lppop->items[wIndex].fType & MF_SEPARATOR)) {
1635             lppop->items[wIndex].fState |= MF_HILITE;
1636             MENU_DrawMenuItem( lppop->hWnd, hmenu, hwndOwner, hdc,
1637                     &lppop->items[wIndex], lppop->Height,
1638                     !(lppop->wFlags & MF_POPUP), ODA_SELECT );
1639         }
1640         if (sendMenuSelect)
1641         {
1642             MENUITEM *ip = &lppop->items[lppop->FocusedItem];
1643             SendMessageW( hwndOwner, WM_MENUSELECT,
1644                      MAKELONG(ip->fType & MF_POPUP ? wIndex: ip->wID,
1645                      ip->fType | ip->fState |
1646                      (lppop->wFlags & MF_SYSMENU)), (LPARAM)hmenu);
1647         }
1648     }
1649     else if (sendMenuSelect) {
1650         if(topmenu){
1651             int pos;
1652             if((pos=MENU_FindSubMenu(&topmenu, hmenu))!=NO_SELECTED_ITEM){
1653                 POPUPMENU *ptm = MENU_GetMenu( topmenu );
1654                 MENUITEM *ip = &ptm->items[pos];
1655                 SendMessageW( hwndOwner, WM_MENUSELECT, MAKELONG(pos,
1656                          ip->fType | ip->fState |
1657                          (ptm->wFlags & MF_SYSMENU)), (LPARAM)topmenu);
1658             }
1659         }
1660     }
1661     ReleaseDC( lppop->hWnd, hdc );
1662 }
1663
1664
1665 /***********************************************************************
1666  *           MENU_MoveSelection
1667  *
1668  * Moves currently selected item according to the offset parameter.
1669  * If there is no selection then it should select the last item if
1670  * offset is ITEM_PREV or the first item if offset is ITEM_NEXT.
1671  */
1672 static void MENU_MoveSelection( HWND hwndOwner, HMENU hmenu, INT offset )
1673 {
1674     INT i;
1675     POPUPMENU *menu;
1676
1677     TRACE("hwnd=%p hmenu=%p off=0x%04x\n", hwndOwner, hmenu, offset);
1678
1679     menu = MENU_GetMenu( hmenu );
1680     if ((!menu) || (!menu->items)) return;
1681
1682     if ( menu->FocusedItem != NO_SELECTED_ITEM )
1683     {
1684         if( menu->nItems == 1 ) return; else
1685         for (i = menu->FocusedItem + offset ; i >= 0 && i < menu->nItems
1686                                             ; i += offset)
1687             if (!(menu->items[i].fType & MF_SEPARATOR))
1688             {
1689                 MENU_SelectItem( hwndOwner, hmenu, i, TRUE, 0 );
1690                 return;
1691             }
1692     }
1693
1694     for ( i = (offset > 0) ? 0 : menu->nItems - 1;
1695                   i >= 0 && i < menu->nItems ; i += offset)
1696         if (!(menu->items[i].fType & MF_SEPARATOR))
1697         {
1698             MENU_SelectItem( hwndOwner, hmenu, i, TRUE, 0 );
1699             return;
1700         }
1701 }
1702
1703
1704 /**********************************************************************
1705  *         MENU_SetItemData
1706  *
1707  * Set an item's flags, id and text ptr. Called by InsertMenu() and
1708  * ModifyMenu().
1709  */
1710 static BOOL MENU_SetItemData( MENUITEM *item, UINT flags, UINT_PTR id,
1711                                 LPCWSTR str )
1712 {
1713     LPWSTR prevText = IS_STRING_ITEM(item->fType) ? item->text : NULL;
1714
1715     debug_print_menuitem("MENU_SetItemData from: ", item, "");
1716     TRACE("flags=%x str=%p\n", flags, str);
1717
1718     if (IS_STRING_ITEM(flags))
1719     {
1720         if (!str)
1721         {
1722             flags |= MF_SEPARATOR;
1723             item->text = NULL;
1724         }
1725         else
1726         {
1727             LPWSTR text;
1728             /* Item beginning with a backspace is a help item */
1729             if (*str == '\b')
1730             {
1731                 flags |= MF_HELP;
1732                 str++;
1733             }
1734             if (!(text = HeapAlloc( GetProcessHeap(), 0, (strlenW(str)+1) * sizeof(WCHAR) )))
1735                 return FALSE;
1736             strcpyW( text, str );
1737             item->text = text;
1738         }
1739     }
1740     else if (IS_BITMAP_ITEM(flags))
1741         item->text = (LPWSTR)HBITMAP_32(LOWORD(str));
1742     else item->text = NULL;
1743
1744     if (flags & MF_OWNERDRAW)
1745         item->dwItemData = (DWORD)str;
1746     else
1747         item->dwItemData = 0;
1748
1749     if ((item->fType & MF_POPUP) && (flags & MF_POPUP) && (item->hSubMenu != (HMENU)id) )
1750         DestroyMenu( item->hSubMenu );   /* ModifyMenu() spec */
1751
1752     if (flags & MF_POPUP)
1753     {
1754         POPUPMENU *menu = MENU_GetMenu((HMENU)id);
1755         if (menu) menu->wFlags |= MF_POPUP;
1756         else
1757         {
1758             item->wID = 0;
1759             item->hSubMenu = 0;
1760             item->fType = 0;
1761             item->fState = 0;
1762             return FALSE;
1763         }
1764     }
1765
1766     item->wID = id;
1767     if (flags & MF_POPUP) item->hSubMenu = (HMENU)id;
1768
1769     if ((item->fType & MF_POPUP) && !(flags & MF_POPUP) )
1770       flags |= MF_POPUP; /* keep popup */
1771
1772     item->fType = flags & TYPE_MASK;
1773     item->fState = (flags & STATE_MASK) &
1774         ~(MF_HILITE | MF_MOUSESELECT | MF_BYPOSITION);
1775
1776
1777     /* Don't call SetRectEmpty here! */
1778
1779
1780     HeapFree( GetProcessHeap(), 0, prevText );
1781
1782     debug_print_menuitem("MENU_SetItemData to  : ", item, "");
1783     return TRUE;
1784 }
1785
1786
1787 /**********************************************************************
1788  *         MENU_InsertItem
1789  *
1790  * Insert (allocate) a new item into a menu.
1791  */
1792 static MENUITEM *MENU_InsertItem( HMENU hMenu, UINT pos, UINT flags )
1793 {
1794     MENUITEM *newItems;
1795     POPUPMENU *menu;
1796
1797     if (!(menu = MENU_GetMenu(hMenu)))
1798         return NULL;
1799
1800     /* Find where to insert new item */
1801
1802     if (flags & MF_BYPOSITION) {
1803         if (pos > menu->nItems)
1804             pos = menu->nItems;
1805     } else {
1806         if (!MENU_FindItem( &hMenu, &pos, flags ))
1807             pos = menu->nItems;
1808         else {
1809             if (!(menu = MENU_GetMenu( hMenu )))
1810                 return NULL;
1811         }
1812     }
1813
1814     /* Create new items array */
1815
1816     newItems = HeapAlloc( GetProcessHeap(), 0, sizeof(MENUITEM) * (menu->nItems+1) );
1817     if (!newItems)
1818     {
1819         WARN("allocation failed\n" );
1820         return NULL;
1821     }
1822     if (menu->nItems > 0)
1823     {
1824           /* Copy the old array into the new one */
1825         if (pos > 0) memcpy( newItems, menu->items, pos * sizeof(MENUITEM) );
1826         if (pos < menu->nItems) memcpy( &newItems[pos+1], &menu->items[pos],
1827                                         (menu->nItems-pos)*sizeof(MENUITEM) );
1828         HeapFree( GetProcessHeap(), 0, menu->items );
1829     }
1830     menu->items = newItems;
1831     menu->nItems++;
1832     memset( &newItems[pos], 0, sizeof(*newItems) );
1833     menu->Height = 0; /* force size recalculate */
1834     return &newItems[pos];
1835 }
1836
1837
1838 /**********************************************************************
1839  *         MENU_ParseResource
1840  *
1841  * Parse a standard menu resource and add items to the menu.
1842  * Return a pointer to the end of the resource.
1843  *
1844  * NOTE: flags is equivalent to the mtOption field
1845  */
1846 static LPCSTR MENU_ParseResource( LPCSTR res, HMENU hMenu, BOOL unicode )
1847 {
1848     WORD flags, id = 0;
1849     LPCSTR str;
1850
1851     do
1852     {
1853         flags = GET_WORD(res);
1854         res += sizeof(WORD);
1855         if (!(flags & MF_POPUP))
1856         {
1857             id = GET_WORD(res);
1858             res += sizeof(WORD);
1859         }
1860         str = res;
1861         if (!unicode) res += strlen(str) + 1;
1862         else res += (strlenW((LPCWSTR)str) + 1) * sizeof(WCHAR);
1863         if (flags & MF_POPUP)
1864         {
1865             HMENU hSubMenu = CreatePopupMenu();
1866             if (!hSubMenu) return NULL;
1867             if (!(res = MENU_ParseResource( res, hSubMenu, unicode )))
1868                 return NULL;
1869             if (!unicode) AppendMenuA( hMenu, flags, (UINT)hSubMenu, str );
1870             else AppendMenuW( hMenu, flags, (UINT)hSubMenu, (LPCWSTR)str );
1871         }
1872         else  /* Not a popup */
1873         {
1874             if (!unicode) AppendMenuA( hMenu, flags, id, *str ? str : NULL );
1875             else AppendMenuW( hMenu, flags, id,
1876                                 *(LPCWSTR)str ? (LPCWSTR)str : NULL );
1877         }
1878     } while (!(flags & MF_END));
1879     return res;
1880 }
1881
1882
1883 /**********************************************************************
1884  *         MENUEX_ParseResource
1885  *
1886  * Parse an extended menu resource and add items to the menu.
1887  * Return a pointer to the end of the resource.
1888  */
1889 static LPCSTR MENUEX_ParseResource( LPCSTR res, HMENU hMenu)
1890 {
1891     WORD resinfo;
1892     do {
1893         MENUITEMINFOW mii;
1894
1895         mii.cbSize = sizeof(mii);
1896         mii.fMask = MIIM_STATE | MIIM_ID | MIIM_TYPE;
1897         mii.fType = GET_DWORD(res);
1898         res += sizeof(DWORD);
1899         mii.fState = GET_DWORD(res);
1900         res += sizeof(DWORD);
1901         mii.wID = GET_DWORD(res);
1902         res += sizeof(DWORD);
1903         resinfo = GET_WORD(res); /* FIXME: for 16-bit apps this is a byte.  */
1904         res += sizeof(WORD);
1905         /* Align the text on a word boundary.  */
1906         res += (~((int)res - 1)) & 1;
1907         mii.dwTypeData = (LPWSTR) res;
1908         res += (1 + strlenW(mii.dwTypeData)) * sizeof(WCHAR);
1909         /* Align the following fields on a dword boundary.  */
1910         res += (~((int)res - 1)) & 3;
1911
1912         TRACE("Menu item: [%08x,%08x,%04x,%04x,%s]\n",
1913               mii.fType, mii.fState, mii.wID, resinfo, debugstr_w(mii.dwTypeData));
1914
1915         if (resinfo & 1) {      /* Pop-up? */
1916             /* DWORD helpid = GET_DWORD(res); FIXME: use this.  */
1917             res += sizeof(DWORD);
1918             mii.hSubMenu = CreatePopupMenu();
1919             if (!mii.hSubMenu)
1920                 return NULL;
1921             if (!(res = MENUEX_ParseResource(res, mii.hSubMenu))) {
1922                 DestroyMenu(mii.hSubMenu);
1923                 return NULL;
1924             }
1925             mii.fMask |= MIIM_SUBMENU;
1926             mii.fType |= MF_POPUP;
1927         }
1928         else if(!*mii.dwTypeData && !(mii.fType & MF_SEPARATOR))
1929         {
1930             WARN("Converting NULL menu item %04x, type %04x to SEPARATOR\n",
1931                 mii.wID, mii.fType);
1932             mii.fType |= MF_SEPARATOR;
1933         }
1934         InsertMenuItemW(hMenu, -1, MF_BYPOSITION, &mii);
1935     } while (!(resinfo & MF_END));
1936     return res;
1937 }
1938
1939
1940 /***********************************************************************
1941  *           MENU_GetSubPopup
1942  *
1943  * Return the handle of the selected sub-popup menu (if any).
1944  */
1945 static HMENU MENU_GetSubPopup( HMENU hmenu )
1946 {
1947     POPUPMENU *menu;
1948     MENUITEM *item;
1949
1950     menu = MENU_GetMenu( hmenu );
1951
1952     if ((!menu) || (menu->FocusedItem == NO_SELECTED_ITEM)) return 0;
1953
1954     item = &menu->items[menu->FocusedItem];
1955     if ((item->fType & MF_POPUP) && (item->fState & MF_MOUSESELECT))
1956         return item->hSubMenu;
1957     return 0;
1958 }
1959
1960
1961 /***********************************************************************
1962  *           MENU_HideSubPopups
1963  *
1964  * Hide the sub-popup menus of this menu.
1965  */
1966 static void MENU_HideSubPopups( HWND hwndOwner, HMENU hmenu,
1967                                 BOOL sendMenuSelect )
1968 {
1969     POPUPMENU *menu = MENU_GetMenu( hmenu );
1970
1971     TRACE("owner=%p hmenu=%p 0x%04x\n", hwndOwner, hmenu, sendMenuSelect);
1972
1973     if (menu && top_popup)
1974     {
1975         HMENU hsubmenu;
1976         POPUPMENU *submenu;
1977         MENUITEM *item;
1978
1979         if (menu->FocusedItem != NO_SELECTED_ITEM)
1980         {
1981             item = &menu->items[menu->FocusedItem];
1982             if (!(item->fType & MF_POPUP) ||
1983                 !(item->fState & MF_MOUSESELECT)) return;
1984             item->fState &= ~MF_MOUSESELECT;
1985             hsubmenu = item->hSubMenu;
1986         } else return;
1987
1988         submenu = MENU_GetMenu( hsubmenu );
1989         MENU_HideSubPopups( hwndOwner, hsubmenu, FALSE );
1990         MENU_SelectItem( hwndOwner, hsubmenu, NO_SELECTED_ITEM, sendMenuSelect, 0 );
1991         DestroyWindow( submenu->hWnd );
1992         submenu->hWnd = 0;
1993     }
1994 }
1995
1996
1997 /***********************************************************************
1998  *           MENU_ShowSubPopup
1999  *
2000  * Display the sub-menu of the selected item of this menu.
2001  * Return the handle of the submenu, or hmenu if no submenu to display.
2002  */
2003 static HMENU MENU_ShowSubPopup( HWND hwndOwner, HMENU hmenu,
2004                                   BOOL selectFirst, UINT wFlags )
2005 {
2006     RECT rect;
2007     POPUPMENU *menu;
2008     MENUITEM *item;
2009     HDC hdc;
2010
2011     TRACE("owner=%p hmenu=%p 0x%04x\n", hwndOwner, hmenu, selectFirst);
2012
2013     if (!(menu = MENU_GetMenu( hmenu ))) return hmenu;
2014
2015     if (menu->FocusedItem == NO_SELECTED_ITEM) return hmenu;
2016
2017     item = &menu->items[menu->FocusedItem];
2018     if (!(item->fType & MF_POPUP) || (item->fState & (MF_GRAYED | MF_DISABLED)))
2019         return hmenu;
2020
2021     /* message must be sent before using item,
2022        because nearly everything may be changed by the application ! */
2023
2024     /* Send WM_INITMENUPOPUP message only if TPM_NONOTIFY flag is not specified */
2025     if (!(wFlags & TPM_NONOTIFY))
2026        SendMessageW( hwndOwner, WM_INITMENUPOPUP, (WPARAM)item->hSubMenu,
2027                      MAKELONG( menu->FocusedItem, IS_SYSTEM_MENU(menu) ));
2028
2029     item = &menu->items[menu->FocusedItem];
2030     rect = item->rect;
2031
2032     /* correct item if modified as a reaction to WM_INITMENUPOPUP message */
2033     if (!(item->fState & MF_HILITE))
2034     {
2035         if (menu->wFlags & MF_POPUP) hdc = GetDC( menu->hWnd );
2036         else hdc = GetDCEx( menu->hWnd, 0, DCX_CACHE | DCX_WINDOW);
2037
2038         SelectObject( hdc, hMenuFont);
2039
2040         item->fState |= MF_HILITE;
2041         MENU_DrawMenuItem( menu->hWnd, hmenu, hwndOwner, hdc, item, menu->Height, !(menu->wFlags & MF_POPUP), ODA_DRAWENTIRE );
2042         ReleaseDC( menu->hWnd, hdc );
2043     }
2044     if (!item->rect.top && !item->rect.left && !item->rect.bottom && !item->rect.right)
2045       item->rect = rect;
2046
2047     item->fState |= MF_MOUSESELECT;
2048
2049     if (IS_SYSTEM_MENU(menu))
2050     {
2051         MENU_InitSysMenuPopup(item->hSubMenu,
2052                               GetWindowLongW( menu->hWnd, GWL_STYLE ),
2053                               GetClassLongW( menu->hWnd, GCL_STYLE));
2054
2055         NC_GetSysPopupPos( menu->hWnd, &rect );
2056         rect.top = rect.bottom;
2057         rect.right = GetSystemMetrics(SM_CXSIZE);
2058         rect.bottom = GetSystemMetrics(SM_CYSIZE);
2059     }
2060     else
2061     {
2062         GetWindowRect( menu->hWnd, &rect );
2063         if (menu->wFlags & MF_POPUP)
2064         {
2065             rect.left += item->rect.right - GetSystemMetrics(SM_CXBORDER);
2066             rect.top += item->rect.top;
2067             rect.right = item->rect.left - item->rect.right + GetSystemMetrics(SM_CXBORDER);
2068             rect.bottom = item->rect.top - item->rect.bottom;
2069         }
2070         else
2071         {
2072             rect.left += item->rect.left;
2073             rect.top += item->rect.bottom;
2074             rect.right = item->rect.right - item->rect.left;
2075             rect.bottom = item->rect.bottom - item->rect.top;
2076         }
2077     }
2078
2079     MENU_ShowPopup( hwndOwner, item->hSubMenu, menu->FocusedItem,
2080                     rect.left, rect.top, rect.right, rect.bottom );
2081     if (selectFirst)
2082         MENU_MoveSelection( hwndOwner, item->hSubMenu, ITEM_NEXT );
2083     return item->hSubMenu;
2084 }
2085
2086
2087
2088 /**********************************************************************
2089  *         MENU_IsMenuActive
2090  */
2091 HWND MENU_IsMenuActive(void)
2092 {
2093     return top_popup;
2094 }
2095
2096 /***********************************************************************
2097  *           MENU_PtMenu
2098  *
2099  * Walks menu chain trying to find a menu pt maps to.
2100  */
2101 static HMENU MENU_PtMenu( HMENU hMenu, POINT pt )
2102 {
2103    POPUPMENU *menu = MENU_GetMenu( hMenu );
2104    UINT item = menu->FocusedItem;
2105    HMENU ret;
2106
2107    /* try subpopup first (if any) */
2108    ret = (item != NO_SELECTED_ITEM &&
2109           (menu->items[item].fType & MF_POPUP) &&
2110           (menu->items[item].fState & MF_MOUSESELECT))
2111         ? MENU_PtMenu(menu->items[item].hSubMenu, pt) : 0;
2112
2113    if (!ret)  /* check the current window (avoiding WM_HITTEST) */
2114    {
2115        INT ht = NC_HandleNCHitTest( menu->hWnd, pt );
2116        if( menu->wFlags & MF_POPUP )
2117        {
2118            if (ht != HTNOWHERE && ht != HTERROR) ret = hMenu;
2119        }
2120        else if (ht == HTSYSMENU)
2121            ret = get_win_sys_menu( menu->hWnd );
2122        else if (ht == HTMENU)
2123            ret = GetMenu( menu->hWnd );
2124    }
2125    return ret;
2126 }
2127
2128 /***********************************************************************
2129  *           MENU_ExecFocusedItem
2130  *
2131  * Execute a menu item (for instance when user pressed Enter).
2132  * Return the wID of the executed item. Otherwise, -1 indicating
2133  * that no menu item was executed;
2134  * Have to receive the flags for the TrackPopupMenu options to avoid
2135  * sending unwanted message.
2136  *
2137  */
2138 static INT MENU_ExecFocusedItem( MTRACKER* pmt, HMENU hMenu, UINT wFlags )
2139 {
2140     MENUITEM *item;
2141     POPUPMENU *menu = MENU_GetMenu( hMenu );
2142
2143     TRACE("%p hmenu=%p\n", pmt, hMenu);
2144
2145     if (!menu || !menu->nItems ||
2146         (menu->FocusedItem == NO_SELECTED_ITEM)) return -1;
2147
2148     item = &menu->items[menu->FocusedItem];
2149
2150     TRACE("%p %08x %p\n", hMenu, item->wID, item->hSubMenu);
2151
2152     if (!(item->fType & MF_POPUP))
2153     {
2154         if (!(item->fState & (MF_GRAYED | MF_DISABLED)) && !(item->fType & MF_SEPARATOR))
2155         {
2156             /* If TPM_RETURNCMD is set you return the id, but
2157                do not send a message to the owner */
2158             if(!(wFlags & TPM_RETURNCMD))
2159             {
2160                 if( menu->wFlags & MF_SYSMENU )
2161                     PostMessageW( pmt->hOwnerWnd, WM_SYSCOMMAND, item->wID,
2162                                   MAKELPARAM((INT16)pmt->pt.x, (INT16)pmt->pt.y) );
2163                 else
2164                     PostMessageW( pmt->hOwnerWnd, WM_COMMAND, item->wID, 0 );
2165             }
2166             return item->wID;
2167         }
2168     }
2169     else
2170         pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd, hMenu, TRUE, wFlags);
2171
2172     return -1;
2173 }
2174
2175 /***********************************************************************
2176  *           MENU_SwitchTracking
2177  *
2178  * Helper function for menu navigation routines.
2179  */
2180 static void MENU_SwitchTracking( MTRACKER* pmt, HMENU hPtMenu, UINT id )
2181 {
2182     POPUPMENU *ptmenu = MENU_GetMenu( hPtMenu );
2183     POPUPMENU *topmenu = MENU_GetMenu( pmt->hTopMenu );
2184
2185     TRACE("%p hmenu=%p 0x%04x\n", pmt, hPtMenu, id);
2186
2187     if( pmt->hTopMenu != hPtMenu &&
2188         !((ptmenu->wFlags | topmenu->wFlags) & MF_POPUP) )
2189     {
2190         /* both are top level menus (system and menu-bar) */
2191         MENU_HideSubPopups( pmt->hOwnerWnd, pmt->hTopMenu, FALSE );
2192         MENU_SelectItem( pmt->hOwnerWnd, pmt->hTopMenu, NO_SELECTED_ITEM, FALSE, 0 );
2193         pmt->hTopMenu = hPtMenu;
2194     }
2195     else MENU_HideSubPopups( pmt->hOwnerWnd, hPtMenu, FALSE );
2196     MENU_SelectItem( pmt->hOwnerWnd, hPtMenu, id, TRUE, 0 );
2197 }
2198
2199
2200 /***********************************************************************
2201  *           MENU_ButtonDown
2202  *
2203  * Return TRUE if we can go on with menu tracking.
2204  */
2205 static BOOL MENU_ButtonDown( MTRACKER* pmt, HMENU hPtMenu, UINT wFlags )
2206 {
2207     TRACE("%p hPtMenu=%p\n", pmt, hPtMenu);
2208
2209     if (hPtMenu)
2210     {
2211         UINT id = 0;
2212         POPUPMENU *ptmenu = MENU_GetMenu( hPtMenu );
2213         MENUITEM *item;
2214
2215         if( IS_SYSTEM_MENU(ptmenu) )
2216             item = ptmenu->items;
2217         else
2218             item = MENU_FindItemByCoords( ptmenu, pmt->pt, &id );
2219
2220         if( item )
2221         {
2222             if( ptmenu->FocusedItem != id )
2223                 MENU_SwitchTracking( pmt, hPtMenu, id );
2224
2225             /* If the popup menu is not already "popped" */
2226             if(!(item->fState & MF_MOUSESELECT ))
2227             {
2228                 pmt->hCurrentMenu = MENU_ShowSubPopup( pmt->hOwnerWnd, hPtMenu, FALSE, wFlags );
2229             }
2230
2231             return TRUE;
2232         }
2233         /* Else the click was on the menu bar, finish the tracking */
2234     }
2235     return FALSE;
2236 }
2237
2238 /***********************************************************************
2239  *           MENU_ButtonUp
2240  *
2241  * Return the value of MENU_ExecFocusedItem if
2242  * the selected item was not a popup. Else open the popup.
2243  * A -1 return value indicates that we go on with menu tracking.
2244  *
2245  */
2246 static INT MENU_ButtonUp( MTRACKER* pmt, HMENU hPtMenu, UINT wFlags)
2247 {
2248     TRACE("%p hmenu=%p\n", pmt, hPtMenu);
2249
2250     if (hPtMenu)
2251     {
2252         UINT id = 0;
2253         POPUPMENU *ptmenu = MENU_GetMenu( hPtMenu );
2254         MENUITEM *item;
2255
2256         if( IS_SYSTEM_MENU(ptmenu) )
2257             item = ptmenu->items;
2258         else
2259             item = MENU_FindItemByCoords( ptmenu, pmt->pt, &id );
2260
2261         if( item && (ptmenu->FocusedItem == id ))
2262         {
2263             if( !(item->fType & MF_POPUP) )
2264                 return MENU_ExecFocusedItem( pmt, hPtMenu, wFlags);
2265
2266             /* If we are dealing with the top-level menu            */
2267             /* and this is a click on an already "popped" item:     */
2268             /* Stop the menu tracking and close the opened submenus */
2269             if((pmt->hTopMenu == hPtMenu) && ptmenu->bTimeToHide)
2270                 return 0;
2271         }
2272         ptmenu->bTimeToHide = TRUE;
2273     }
2274     return -1;
2275 }
2276
2277
2278 /***********************************************************************
2279  *           MENU_MouseMove
2280  *
2281  * Return TRUE if we can go on with menu tracking.
2282  */
2283 static BOOL MENU_MouseMove( MTRACKER* pmt, HMENU hPtMenu, UINT wFlags )
2284 {
2285     UINT id = NO_SELECTED_ITEM;
2286     POPUPMENU *ptmenu = NULL;
2287
2288     if( hPtMenu )
2289     {
2290         ptmenu = MENU_GetMenu( hPtMenu );
2291         if( IS_SYSTEM_MENU(ptmenu) )
2292             id = 0;
2293         else
2294             MENU_FindItemByCoords( ptmenu, pmt->pt, &id );
2295     }
2296
2297     if( id == NO_SELECTED_ITEM )
2298     {
2299         MENU_SelectItem( pmt->hOwnerWnd, pmt->hCurrentMenu,
2300                          NO_SELECTED_ITEM, TRUE, pmt->hTopMenu);
2301
2302     }
2303     else if( ptmenu->FocusedItem != id )
2304     {
2305             MENU_SwitchTracking( pmt, hPtMenu, id );
2306             pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd, hPtMenu, FALSE, wFlags);
2307     }
2308     return TRUE;
2309 }
2310
2311
2312 /***********************************************************************
2313  *           MENU_SetCapture
2314  */
2315 static void MENU_SetCapture( HWND hwnd )
2316 {
2317     HWND previous = 0;
2318
2319     SERVER_START_REQ( set_capture_window )
2320     {
2321         req->handle = hwnd;
2322         req->flags  = CAPTURE_MENU;
2323         if (!wine_server_call_err( req ))
2324         {
2325             previous = reply->previous;
2326             hwnd = reply->full_handle;
2327         }
2328     }
2329     SERVER_END_REQ;
2330
2331     if (previous && previous != hwnd)
2332         SendMessageW( previous, WM_CAPTURECHANGED, 0, (LPARAM)hwnd );
2333 }
2334
2335
2336 /***********************************************************************
2337  *           MENU_DoNextMenu
2338  *
2339  * NOTE: WM_NEXTMENU documented in Win32 is a bit different.
2340  */
2341 static LRESULT MENU_DoNextMenu( MTRACKER* pmt, UINT vk )
2342 {
2343     POPUPMENU *menu = MENU_GetMenu( pmt->hTopMenu );
2344
2345     if( (vk == VK_LEFT &&  menu->FocusedItem == 0 ) ||
2346         (vk == VK_RIGHT && menu->FocusedItem == menu->nItems - 1))
2347     {
2348         MDINEXTMENU next_menu;
2349         HMENU hNewMenu;
2350         HWND  hNewWnd;
2351         UINT  id = 0;
2352
2353         next_menu.hmenuIn = (IS_SYSTEM_MENU(menu)) ? GetSubMenu(pmt->hTopMenu,0) : pmt->hTopMenu;
2354         next_menu.hmenuNext = 0;
2355         next_menu.hwndNext = 0;
2356         SendMessageW( pmt->hOwnerWnd, WM_NEXTMENU, vk, (LPARAM)&next_menu );
2357
2358         TRACE("%p [%p] -> %p [%p]\n",
2359               pmt->hCurrentMenu, pmt->hOwnerWnd, next_menu.hmenuNext, next_menu.hwndNext );
2360
2361         if (!next_menu.hmenuNext || !next_menu.hwndNext)
2362         {
2363             DWORD style = GetWindowLongW( pmt->hOwnerWnd, GWL_STYLE );
2364             hNewWnd = pmt->hOwnerWnd;
2365             if( IS_SYSTEM_MENU(menu) )
2366             {
2367                 /* switch to the menu bar */
2368
2369                 if(style & WS_CHILD || !(hNewMenu = GetMenu(hNewWnd))) return FALSE;
2370
2371                 if( vk == VK_LEFT )
2372                 {
2373                     menu = MENU_GetMenu( hNewMenu );
2374                     id = menu->nItems - 1;
2375                 }
2376             }
2377             else if (style & WS_SYSMENU )
2378             {
2379                 /* switch to the system menu */
2380                 hNewMenu = get_win_sys_menu( hNewWnd );
2381             }
2382             else return FALSE;
2383         }
2384         else    /* application returned a new menu to switch to */
2385         {
2386             hNewMenu = next_menu.hmenuNext;
2387             hNewWnd = WIN_GetFullHandle( next_menu.hwndNext );
2388
2389             if( IsMenu(hNewMenu) && IsWindow(hNewWnd) )
2390             {
2391                 DWORD style = GetWindowLongW( hNewWnd, GWL_STYLE );
2392
2393                 if (style & WS_SYSMENU &&
2394                     GetSubMenu(get_win_sys_menu(hNewWnd), 0) == hNewMenu )
2395                 {
2396                     /* get the real system menu */
2397                     hNewMenu =  get_win_sys_menu(hNewWnd);
2398                 }
2399                 else if (style & WS_CHILD || GetMenu(hNewWnd) != hNewMenu )
2400                 {
2401                     /* FIXME: Not sure what to do here;
2402                      * perhaps try to track hNewMenu as a popup? */
2403
2404                     TRACE(" -- got confused.\n");
2405                     return FALSE;
2406                 }
2407             }
2408             else return FALSE;
2409         }
2410
2411         if( hNewMenu != pmt->hTopMenu )
2412         {
2413             MENU_SelectItem( pmt->hOwnerWnd, pmt->hTopMenu, NO_SELECTED_ITEM,
2414                     FALSE, 0 );
2415             if( pmt->hCurrentMenu != pmt->hTopMenu )
2416                 MENU_HideSubPopups( pmt->hOwnerWnd, pmt->hTopMenu, FALSE );
2417         }
2418
2419         if( hNewWnd != pmt->hOwnerWnd )
2420         {
2421             pmt->hOwnerWnd = hNewWnd;
2422             MENU_SetCapture( pmt->hOwnerWnd );
2423         }
2424
2425         pmt->hTopMenu = pmt->hCurrentMenu = hNewMenu; /* all subpopups are hidden */
2426         MENU_SelectItem( pmt->hOwnerWnd, pmt->hTopMenu, id, TRUE, 0 );
2427
2428         return TRUE;
2429     }
2430     return FALSE;
2431 }
2432
2433 /***********************************************************************
2434  *           MENU_SuspendPopup
2435  *
2436  * The idea is not to show the popup if the next input message is
2437  * going to hide it anyway.
2438  */
2439 static BOOL MENU_SuspendPopup( MTRACKER* pmt, UINT16 uMsg )
2440 {
2441     MSG msg;
2442
2443     msg.hwnd = pmt->hOwnerWnd;
2444
2445     PeekMessageW( &msg, 0, 0, 0, PM_NOYIELD | PM_REMOVE);
2446     pmt->trackFlags |= TF_SKIPREMOVE;
2447
2448     switch( uMsg )
2449     {
2450         case WM_KEYDOWN:
2451              PeekMessageW( &msg, 0, 0, 0, PM_NOYIELD | PM_NOREMOVE);
2452              if( msg.message == WM_KEYUP || msg.message == WM_PAINT )
2453              {
2454                  PeekMessageW( &msg, 0, 0, 0, PM_NOYIELD | PM_REMOVE);
2455                  PeekMessageW( &msg, 0, 0, 0, PM_NOYIELD | PM_NOREMOVE);
2456                  if( msg.message == WM_KEYDOWN &&
2457                     (msg.wParam == VK_LEFT || msg.wParam == VK_RIGHT))
2458                  {
2459                      pmt->trackFlags |= TF_SUSPENDPOPUP;
2460                      return TRUE;
2461                  }
2462              }
2463              break;
2464     }
2465
2466     /* failures go through this */
2467     pmt->trackFlags &= ~TF_SUSPENDPOPUP;
2468     return FALSE;
2469 }
2470
2471 /***********************************************************************
2472  *           MENU_KeyEscape
2473  *
2474  * Handle a VK_ESCAPE key event in a menu.
2475  */
2476 static BOOL MENU_KeyEscape(MTRACKER* pmt, UINT wFlags)
2477 {
2478     BOOL bEndMenu = TRUE;
2479
2480     if (pmt->hCurrentMenu != pmt->hTopMenu)
2481     {
2482         POPUPMENU *menu = MENU_GetMenu(pmt->hCurrentMenu);
2483
2484         if (menu->wFlags & MF_POPUP)
2485         {
2486             HMENU hmenutmp, hmenuprev;
2487
2488             hmenuprev = hmenutmp = pmt->hTopMenu;
2489
2490             /* close topmost popup */
2491             while (hmenutmp != pmt->hCurrentMenu)
2492             {
2493                 hmenuprev = hmenutmp;
2494                 hmenutmp = MENU_GetSubPopup( hmenuprev );
2495             }
2496
2497             MENU_HideSubPopups( pmt->hOwnerWnd, hmenuprev, TRUE );
2498             pmt->hCurrentMenu = hmenuprev;
2499             bEndMenu = FALSE;
2500         }
2501     }
2502
2503     return bEndMenu;
2504 }
2505
2506 /***********************************************************************
2507  *           MENU_KeyLeft
2508  *
2509  * Handle a VK_LEFT key event in a menu.
2510  */
2511 static void MENU_KeyLeft( MTRACKER* pmt, UINT wFlags )
2512 {
2513     POPUPMENU *menu;
2514     HMENU hmenutmp, hmenuprev;
2515     UINT  prevcol;
2516
2517     hmenuprev = hmenutmp = pmt->hTopMenu;
2518     menu = MENU_GetMenu( hmenutmp );
2519
2520     /* Try to move 1 column left (if possible) */
2521     if( (prevcol = MENU_GetStartOfPrevColumn( pmt->hCurrentMenu )) !=
2522         NO_SELECTED_ITEM ) {
2523
2524         MENU_SelectItem( pmt->hOwnerWnd, pmt->hCurrentMenu,
2525                          prevcol, TRUE, 0 );
2526         return;
2527     }
2528
2529     /* close topmost popup */
2530     while (hmenutmp != pmt->hCurrentMenu)
2531     {
2532         hmenuprev = hmenutmp;
2533         hmenutmp = MENU_GetSubPopup( hmenuprev );
2534     }
2535
2536     MENU_HideSubPopups( pmt->hOwnerWnd, hmenuprev, TRUE );
2537     pmt->hCurrentMenu = hmenuprev;
2538
2539     if ( (hmenuprev == pmt->hTopMenu) && !(menu->wFlags & MF_POPUP) )
2540     {
2541         /* move menu bar selection if no more popups are left */
2542
2543         if( !MENU_DoNextMenu( pmt, VK_LEFT) )
2544              MENU_MoveSelection( pmt->hOwnerWnd, pmt->hTopMenu, ITEM_PREV );
2545
2546         if ( hmenuprev != hmenutmp || pmt->trackFlags & TF_SUSPENDPOPUP )
2547         {
2548            /* A sublevel menu was displayed - display the next one
2549             * unless there is another displacement coming up */
2550
2551             if( !MENU_SuspendPopup( pmt, WM_KEYDOWN ) )
2552                 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd,
2553                                                 pmt->hTopMenu, TRUE, wFlags);
2554         }
2555     }
2556 }
2557
2558
2559 /***********************************************************************
2560  *           MENU_KeyRight
2561  *
2562  * Handle a VK_RIGHT key event in a menu.
2563  */
2564 static void MENU_KeyRight( MTRACKER* pmt, UINT wFlags )
2565 {
2566     HMENU hmenutmp;
2567     POPUPMENU *menu = MENU_GetMenu( pmt->hTopMenu );
2568     UINT  nextcol;
2569
2570     TRACE("MENU_KeyRight called, cur %p (%s), top %p (%s).\n",
2571           pmt->hCurrentMenu,
2572           debugstr_w((MENU_GetMenu(pmt->hCurrentMenu))->items[0].text),
2573           pmt->hTopMenu, debugstr_w(menu->items[0].text) );
2574
2575     if ( (menu->wFlags & MF_POPUP) || (pmt->hCurrentMenu != pmt->hTopMenu))
2576     {
2577         /* If already displaying a popup, try to display sub-popup */
2578
2579         hmenutmp = pmt->hCurrentMenu;
2580         pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd, hmenutmp, TRUE, wFlags);
2581
2582         /* if subpopup was displayed then we are done */
2583         if (hmenutmp != pmt->hCurrentMenu) return;
2584     }
2585
2586     /* Check to see if there's another column */
2587     if( (nextcol = MENU_GetStartOfNextColumn( pmt->hCurrentMenu )) !=
2588         NO_SELECTED_ITEM ) {
2589         TRACE("Going to %d.\n", nextcol );
2590         MENU_SelectItem( pmt->hOwnerWnd, pmt->hCurrentMenu,
2591                          nextcol, TRUE, 0 );
2592         return;
2593     }
2594
2595     if (!(menu->wFlags & MF_POPUP))     /* menu bar tracking */
2596     {
2597         if( pmt->hCurrentMenu != pmt->hTopMenu )
2598         {
2599             MENU_HideSubPopups( pmt->hOwnerWnd, pmt->hTopMenu, FALSE );
2600             hmenutmp = pmt->hCurrentMenu = pmt->hTopMenu;
2601         } else hmenutmp = 0;
2602
2603         /* try to move to the next item */
2604         if( !MENU_DoNextMenu( pmt, VK_RIGHT) )
2605              MENU_MoveSelection( pmt->hOwnerWnd, pmt->hTopMenu, ITEM_NEXT );
2606
2607         if( hmenutmp || pmt->trackFlags & TF_SUSPENDPOPUP )
2608             if( !MENU_SuspendPopup(pmt, WM_KEYDOWN) )
2609                 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd,
2610                                                        pmt->hTopMenu, TRUE, wFlags);
2611     }
2612 }
2613
2614 /***********************************************************************
2615  *           MENU_TrackMenu
2616  *
2617  * Menu tracking code.
2618  */
2619 static BOOL MENU_TrackMenu( HMENU hmenu, UINT wFlags, INT x, INT y,
2620                             HWND hwnd, const RECT *lprect )
2621 {
2622     MSG msg;
2623     POPUPMENU *menu;
2624     BOOL fRemove;
2625     INT executedMenuId = -1;
2626     MTRACKER mt;
2627     BOOL enterIdleSent = FALSE;
2628
2629     mt.trackFlags = 0;
2630     mt.hCurrentMenu = hmenu;
2631     mt.hTopMenu = hmenu;
2632     mt.hOwnerWnd = WIN_GetFullHandle( hwnd );
2633     mt.pt.x = x;
2634     mt.pt.y = y;
2635
2636     TRACE("hmenu=%p flags=0x%08x (%d,%d) hwnd=%p (%ld,%ld)-(%ld,%ld)\n",
2637           hmenu, wFlags, x, y, hwnd, (lprect) ? lprect->left : 0, (lprect) ? lprect->top : 0,
2638           (lprect) ? lprect->right : 0,  (lprect) ? lprect->bottom : 0);
2639
2640     fEndMenu = FALSE;
2641     if (!(menu = MENU_GetMenu( hmenu )))
2642     {
2643         WARN("Invalid menu handle %p\n", hmenu);
2644         SetLastError(ERROR_INVALID_MENU_HANDLE);
2645         return FALSE;
2646     }
2647
2648     if (wFlags & TPM_BUTTONDOWN)
2649     {
2650         /* Get the result in order to start the tracking or not */
2651         fRemove = MENU_ButtonDown( &mt, hmenu, wFlags );
2652         fEndMenu = !fRemove;
2653     }
2654
2655     if (wFlags & TF_ENDMENU) fEndMenu = TRUE;
2656
2657     MENU_SetCapture( mt.hOwnerWnd );
2658
2659     while (!fEndMenu)
2660     {
2661         menu = MENU_GetMenu( mt.hCurrentMenu );
2662         if (!menu) /* sometimes happens if I do a window manager close */
2663             break;
2664
2665         /* we have to keep the message in the queue until it's
2666          * clear that menu loop is not over yet. */
2667
2668         for (;;)
2669         {
2670             if (PeekMessageW( &msg, 0, 0, 0, PM_NOREMOVE ))
2671             {
2672                 if (!CallMsgFilterW( &msg, MSGF_MENU )) break;
2673                 /* remove the message from the queue */
2674                 PeekMessageW( &msg, 0, msg.message, msg.message, PM_REMOVE );
2675             }
2676             else
2677             {
2678                 if (!enterIdleSent)
2679                 {
2680                     HWND win = (wFlags & TPM_ENTERIDLEEX && menu->wFlags & MF_POPUP) ? menu->hWnd : 0;
2681                     enterIdleSent = TRUE;
2682                     SendMessageW( mt.hOwnerWnd, WM_ENTERIDLE, MSGF_MENU, (LPARAM)win );
2683                 }
2684                 WaitMessage();
2685             }
2686         }
2687
2688         /* check if EndMenu() tried to cancel us, by posting this message */
2689         if(msg.message == WM_CANCELMODE)
2690         {
2691             /* we are now out of the loop */
2692             fEndMenu = TRUE;
2693
2694             /* remove the message from the queue */
2695             PeekMessageW( &msg, 0, msg.message, msg.message, PM_REMOVE );
2696
2697             /* break out of internal loop, ala ESCAPE */
2698             break;
2699         }
2700
2701         TranslateMessage( &msg );
2702         mt.pt = msg.pt;
2703
2704         if ( (msg.hwnd==menu->hWnd) || (msg.message!=WM_TIMER) )
2705           enterIdleSent=FALSE;
2706
2707         fRemove = FALSE;
2708         if ((msg.message >= WM_MOUSEFIRST) && (msg.message <= WM_MOUSELAST))
2709         {
2710             /*
2711              * Use the mouse coordinates in lParam instead of those in the MSG
2712              * struct to properly handle synthetic messages. They are already
2713              * in screen coordinates.
2714              */
2715             mt.pt.x = (short)LOWORD(msg.lParam);
2716             mt.pt.y = (short)HIWORD(msg.lParam);
2717
2718             /* Find a menu for this mouse event */
2719             hmenu = MENU_PtMenu( mt.hTopMenu, mt.pt );
2720
2721             switch(msg.message)
2722             {
2723                 /* no WM_NC... messages in captured state */
2724
2725                 case WM_RBUTTONDBLCLK:
2726                 case WM_RBUTTONDOWN:
2727                     if (!(wFlags & TPM_RIGHTBUTTON)) break;
2728                     /* fall through */
2729                 case WM_LBUTTONDBLCLK:
2730                 case WM_LBUTTONDOWN:
2731                     /* If the message belongs to the menu, removes it from the queue */
2732                     /* Else, end menu tracking */
2733                     fRemove = MENU_ButtonDown( &mt, hmenu, wFlags );
2734                     fEndMenu = !fRemove;
2735                     break;
2736
2737                 case WM_RBUTTONUP:
2738                     if (!(wFlags & TPM_RIGHTBUTTON)) break;
2739                     /* fall through */
2740                 case WM_LBUTTONUP:
2741                     /* Check if a menu was selected by the mouse */
2742                     if (hmenu)
2743                     {
2744                         executedMenuId = MENU_ButtonUp( &mt, hmenu, wFlags);
2745
2746                         /* End the loop if executedMenuId is an item ID */
2747                         /* or if the job was done (executedMenuId = 0). */
2748                         fEndMenu = fRemove = (executedMenuId != -1);
2749                     }
2750                     /* No menu was selected by the mouse */
2751                     /* if the function was called by TrackPopupMenu, continue
2752                        with the menu tracking. If not, stop it */
2753                     else
2754                         fEndMenu = ((wFlags & TPM_POPUPMENU) ? FALSE : TRUE);
2755
2756                     break;
2757
2758                 case WM_MOUSEMOVE:
2759                     /* the selected menu item must be changed every time */
2760                      /* the mouse moves. */
2761
2762                     if (hmenu)
2763                         fEndMenu |= !MENU_MouseMove( &mt, hmenu, wFlags );
2764
2765             } /* switch(msg.message) - mouse */
2766         }
2767         else if ((msg.message >= WM_KEYFIRST) && (msg.message <= WM_KEYLAST))
2768         {
2769             fRemove = TRUE;  /* Keyboard messages are always removed */
2770             switch(msg.message)
2771             {
2772             case WM_KEYDOWN:
2773             case WM_SYSKEYDOWN:
2774                 switch(msg.wParam)
2775                 {
2776                 case VK_MENU:
2777                     fEndMenu = TRUE;
2778                     break;
2779
2780                 case VK_HOME:
2781                 case VK_END:
2782                     MENU_SelectItem( mt.hOwnerWnd, mt.hCurrentMenu,
2783                                      NO_SELECTED_ITEM, FALSE, 0 );
2784                 /* fall through */
2785                 case VK_UP:
2786                     MENU_MoveSelection( mt.hOwnerWnd, mt.hCurrentMenu,
2787                                        (msg.wParam == VK_HOME)? ITEM_NEXT : ITEM_PREV );
2788                     break;
2789
2790                 case VK_DOWN: /* If on menu bar, pull-down the menu */
2791
2792                     menu = MENU_GetMenu( mt.hCurrentMenu );
2793                     if (!(menu->wFlags & MF_POPUP))
2794                         mt.hCurrentMenu = MENU_ShowSubPopup(mt.hOwnerWnd, mt.hTopMenu, TRUE, wFlags);
2795                     else      /* otherwise try to move selection */
2796                         MENU_MoveSelection( mt.hOwnerWnd, mt.hCurrentMenu, ITEM_NEXT );
2797                     break;
2798
2799                 case VK_LEFT:
2800                     MENU_KeyLeft( &mt, wFlags );
2801                     break;
2802
2803                 case VK_RIGHT:
2804                     MENU_KeyRight( &mt, wFlags );
2805                     break;
2806
2807                 case VK_ESCAPE:
2808                     fEndMenu = MENU_KeyEscape(&mt, wFlags);
2809                     break;
2810
2811                 case VK_F1:
2812                     {
2813                         HELPINFO hi;
2814                         hi.cbSize = sizeof(HELPINFO);
2815                         hi.iContextType = HELPINFO_MENUITEM;
2816                         if (menu->FocusedItem == NO_SELECTED_ITEM)
2817                             hi.iCtrlId = 0;
2818                         else
2819                             hi.iCtrlId = menu->items[menu->FocusedItem].wID;
2820                         hi.hItemHandle = hmenu;
2821                         hi.dwContextId = menu->dwContextHelpID;
2822                         hi.MousePos = msg.pt;
2823                         SendMessageW(hwnd, WM_HELP, 0, (LPARAM)&hi);
2824                         break;
2825                     }
2826
2827                 default:
2828                     break;
2829                 }
2830                 break;  /* WM_KEYDOWN */
2831
2832             case WM_CHAR:
2833             case WM_SYSCHAR:
2834                 {
2835                     UINT        pos;
2836
2837                     if (msg.wParam == '\r' || msg.wParam == ' ')
2838                     {
2839                         executedMenuId = MENU_ExecFocusedItem(&mt,mt.hCurrentMenu, wFlags);
2840                         fEndMenu = (executedMenuId != -1);
2841
2842                         break;
2843                     }
2844
2845                       /* Hack to avoid control chars. */
2846                       /* We will find a better way real soon... */
2847                     if (msg.wParam < 32) break;
2848
2849                     pos = MENU_FindItemByKey( mt.hOwnerWnd, mt.hCurrentMenu,
2850                                               LOWORD(msg.wParam), FALSE );
2851                     if (pos == (UINT)-2) fEndMenu = TRUE;
2852                     else if (pos == (UINT)-1) MessageBeep(0);
2853                     else
2854                     {
2855                         MENU_SelectItem( mt.hOwnerWnd, mt.hCurrentMenu, pos,
2856                                 TRUE, 0 );
2857                         executedMenuId = MENU_ExecFocusedItem(&mt,mt.hCurrentMenu, wFlags);
2858                         fEndMenu = (executedMenuId != -1);
2859                     }
2860                 }
2861                 break;
2862             }  /* switch(msg.message) - kbd */
2863         }
2864         else
2865         {
2866             DispatchMessageW( &msg );
2867         }
2868
2869         if (!fEndMenu) fRemove = TRUE;
2870
2871         /* finally remove message from the queue */
2872
2873         if (fRemove && !(mt.trackFlags & TF_SKIPREMOVE) )
2874             PeekMessageW( &msg, 0, msg.message, msg.message, PM_REMOVE );
2875         else mt.trackFlags &= ~TF_SKIPREMOVE;
2876     }
2877
2878     MENU_SetCapture(0);  /* release the capture */
2879
2880     /* If dropdown is still painted and the close box is clicked on
2881        then the menu will be destroyed as part of the DispatchMessage above.
2882        This will then invalidate the menu handle in mt.hTopMenu. We should
2883        check for this first.  */
2884     if( IsMenu( mt.hTopMenu ) )
2885     {
2886         menu = MENU_GetMenu( mt.hTopMenu );
2887
2888         if( IsWindow( mt.hOwnerWnd ) )
2889         {
2890             MENU_HideSubPopups( mt.hOwnerWnd, mt.hTopMenu, FALSE );
2891
2892             if (menu && (menu->wFlags & MF_POPUP))
2893             {
2894                 DestroyWindow( menu->hWnd );
2895                 menu->hWnd = 0;
2896             }
2897             MENU_SelectItem( mt.hOwnerWnd, mt.hTopMenu, NO_SELECTED_ITEM, FALSE, 0 );
2898             SendMessageW( mt.hOwnerWnd, WM_MENUSELECT, MAKELONG(0,0xffff), 0 );
2899         }
2900
2901         /* Reset the variable for hiding menu */
2902         if( menu ) menu->bTimeToHide = FALSE;
2903     }
2904
2905     /* The return value is only used by TrackPopupMenu */
2906     if (!(wFlags & TPM_RETURNCMD)) return TRUE;
2907     if (executedMenuId == -1) executedMenuId = 0;
2908     return executedMenuId;
2909 }
2910
2911 /***********************************************************************
2912  *           MENU_InitTracking
2913  */
2914 static BOOL MENU_InitTracking(HWND hWnd, HMENU hMenu, BOOL bPopup, UINT wFlags)
2915 {
2916     POPUPMENU *menu;
2917
2918     TRACE("hwnd=%p hmenu=%p\n", hWnd, hMenu);
2919
2920     HideCaret(0);
2921
2922     /* Send WM_ENTERMENULOOP and WM_INITMENU message only if TPM_NONOTIFY flag is not specified */
2923     if (!(wFlags & TPM_NONOTIFY))
2924        SendMessageW( hWnd, WM_ENTERMENULOOP, bPopup, 0 );
2925
2926     SendMessageW( hWnd, WM_SETCURSOR, (WPARAM)hWnd, HTCAPTION );
2927
2928     if (!(wFlags & TPM_NONOTIFY))
2929     {
2930        SendMessageW( hWnd, WM_INITMENU, (WPARAM)hMenu, 0 );
2931        /* If an app changed/recreated menu bar entries in WM_INITMENU
2932         * menu sizes will be recalculated once the menu created/shown.
2933         */
2934     }
2935
2936     /* This makes the menus of applications built with Delphi work.
2937      * It also enables menus to be displayed in more than one window,
2938      * but there are some bugs left that need to be fixed in this case.
2939      */
2940     if ((menu = MENU_GetMenu( hMenu ))) menu->hWnd = hWnd;
2941
2942     return TRUE;
2943 }
2944 /***********************************************************************
2945  *           MENU_ExitTracking
2946  */
2947 static BOOL MENU_ExitTracking(HWND hWnd)
2948 {
2949     TRACE("hwnd=%p\n", hWnd);
2950
2951     SendMessageW( hWnd, WM_EXITMENULOOP, 0, 0 );
2952     ShowCaret(0);
2953     top_popup = 0;
2954     return TRUE;
2955 }
2956
2957 /***********************************************************************
2958  *           MENU_TrackMouseMenuBar
2959  *
2960  * Menu-bar tracking upon a mouse event. Called from NC_HandleSysCommand().
2961  */
2962 void MENU_TrackMouseMenuBar( HWND hWnd, INT ht, POINT pt )
2963 {
2964     HMENU hMenu = (ht == HTSYSMENU) ? get_win_sys_menu( hWnd ) : GetMenu( hWnd );
2965     UINT wFlags = TPM_ENTERIDLEEX | TPM_BUTTONDOWN | TPM_LEFTALIGN | TPM_LEFTBUTTON;
2966
2967     TRACE("wnd=%p ht=0x%04x (%ld,%ld)\n", hWnd, ht, pt.x, pt.y);
2968
2969     if (IsMenu(hMenu))
2970     {
2971         MENU_InitTracking( hWnd, hMenu, FALSE, wFlags );
2972         MENU_TrackMenu( hMenu, wFlags, pt.x, pt.y, hWnd, NULL );
2973         MENU_ExitTracking(hWnd);
2974     }
2975 }
2976
2977
2978 /***********************************************************************
2979  *           MENU_TrackKbdMenuBar
2980  *
2981  * Menu-bar tracking upon a keyboard event. Called from NC_HandleSysCommand().
2982  */
2983 void MENU_TrackKbdMenuBar( HWND hwnd, UINT wParam, WCHAR wChar)
2984 {
2985     UINT uItem = NO_SELECTED_ITEM;
2986     HMENU hTrackMenu;
2987     UINT wFlags = TPM_ENTERIDLEEX | TPM_LEFTALIGN | TPM_LEFTBUTTON;
2988
2989     TRACE("hwnd %p wParam 0x%04x wChar 0x%04x\n", hwnd, wParam, wChar);
2990
2991     /* find window that has a menu */
2992
2993     while (!WIN_ALLOWED_MENU(GetWindowLongW( hwnd, GWL_STYLE )))
2994         if (!(hwnd = GetAncestor( hwnd, GA_PARENT ))) return;
2995
2996     /* check if we have to track a system menu */
2997
2998     hTrackMenu = GetMenu( hwnd );
2999     if (!hTrackMenu || IsIconic(hwnd) || wChar == ' ' )
3000     {
3001         if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_SYSMENU)) return;
3002         hTrackMenu = get_win_sys_menu( hwnd );
3003         uItem = 0;
3004         wParam |= HTSYSMENU; /* prevent item lookup */
3005     }
3006
3007     if (!IsMenu( hTrackMenu )) return;
3008
3009     MENU_InitTracking( hwnd, hTrackMenu, FALSE, wFlags );
3010
3011     if( wChar && wChar != ' ' )
3012     {
3013         uItem = MENU_FindItemByKey( hwnd, hTrackMenu, wChar, (wParam & HTSYSMENU) );
3014         if ( uItem >= (UINT)(-2) )
3015         {
3016             if( uItem == (UINT)(-1) ) MessageBeep(0);
3017             /* schedule end of menu tracking */
3018             wFlags |= TF_ENDMENU;
3019             goto track_menu;
3020         }
3021     }
3022
3023     MENU_SelectItem( hwnd, hTrackMenu, uItem, TRUE, 0 );
3024
3025     if (wParam & HTSYSMENU)
3026     {
3027         /* prevent sysmenu activation for managed windows on Alt down/up */
3028         if (GetPropA( hwnd, "__wine_x11_managed" ))
3029             wFlags |= TF_ENDMENU; /* schedule end of menu tracking */
3030     }
3031     else
3032     {
3033         if( uItem == NO_SELECTED_ITEM )
3034             MENU_MoveSelection( hwnd, hTrackMenu, ITEM_NEXT );
3035         else
3036             PostMessageW( hwnd, WM_KEYDOWN, VK_DOWN, 0L );
3037     }
3038
3039 track_menu:
3040     MENU_TrackMenu( hTrackMenu, wFlags, 0, 0, hwnd, NULL );
3041     MENU_ExitTracking( hwnd );
3042 }
3043
3044
3045 /**********************************************************************
3046  *           TrackPopupMenu   (USER32.@)
3047  *
3048  * Like the win32 API, the function return the command ID only if the
3049  * flag TPM_RETURNCMD is on.
3050  *
3051  */
3052 BOOL WINAPI TrackPopupMenu( HMENU hMenu, UINT wFlags, INT x, INT y,
3053                            INT nReserved, HWND hWnd, const RECT *lpRect )
3054 {
3055     BOOL ret = FALSE;
3056
3057     MENU_InitTracking(hWnd, hMenu, TRUE, wFlags);
3058
3059     /* Send WM_INITMENUPOPUP message only if TPM_NONOTIFY flag is not specified */
3060     if (!(wFlags & TPM_NONOTIFY))
3061         SendMessageW( hWnd, WM_INITMENUPOPUP, (WPARAM)hMenu, 0);
3062
3063     if (MENU_ShowPopup( hWnd, hMenu, 0, x, y, 0, 0 ))
3064         ret = MENU_TrackMenu( hMenu, wFlags | TPM_POPUPMENU, 0, 0, hWnd, lpRect );
3065     MENU_ExitTracking(hWnd);
3066
3067     return ret;
3068 }
3069
3070 /**********************************************************************
3071  *           TrackPopupMenuEx   (USER32.@)
3072  */
3073 BOOL WINAPI TrackPopupMenuEx( HMENU hMenu, UINT wFlags, INT x, INT y,
3074                                 HWND hWnd, LPTPMPARAMS lpTpm )
3075 {
3076     FIXME("not fully implemented\n" );
3077     return TrackPopupMenu( hMenu, wFlags, x, y, 0, hWnd,
3078                              lpTpm ? &lpTpm->rcExclude : NULL );
3079 }
3080
3081 /***********************************************************************
3082  *           PopupMenuWndProc
3083  *
3084  * NOTE: Windows has totally different (and undocumented) popup wndproc.
3085  */
3086 static LRESULT WINAPI PopupMenuWndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
3087 {
3088     TRACE("hwnd=%p msg=0x%04x wp=0x%04x lp=0x%08lx\n", hwnd, message, wParam, lParam);
3089
3090     switch(message)
3091     {
3092     case WM_CREATE:
3093         {
3094             CREATESTRUCTW *cs = (CREATESTRUCTW*)lParam;
3095             SetWindowLongW( hwnd, 0, (LONG)cs->lpCreateParams );
3096             return 0;
3097         }
3098
3099     case WM_MOUSEACTIVATE:  /* We don't want to be activated */
3100         return MA_NOACTIVATE;
3101
3102     case WM_PAINT:
3103         {
3104             PAINTSTRUCT ps;
3105             BeginPaint( hwnd, &ps );
3106             MENU_DrawPopupMenu( hwnd, ps.hdc,
3107                                 (HMENU)GetWindowLongW( hwnd, 0 ) );
3108             EndPaint( hwnd, &ps );
3109             return 0;
3110         }
3111     case WM_ERASEBKGND:
3112         return 1;
3113
3114     case WM_DESTROY:
3115         /* zero out global pointer in case resident popup window was destroyed. */
3116         if (hwnd == top_popup) top_popup = 0;
3117         break;
3118
3119     case WM_SHOWWINDOW:
3120
3121         if( wParam )
3122         {
3123             if (!GetWindowLongW( hwnd, 0 )) ERR("no menu to display\n");
3124         }
3125         else
3126             SetWindowLongW( hwnd, 0, 0 );
3127         break;
3128
3129     case MM_SETMENUHANDLE:
3130         SetWindowLongW( hwnd, 0, wParam );
3131         break;
3132
3133     case MM_GETMENUHANDLE:
3134         return GetWindowLongW( hwnd, 0 );
3135
3136     default:
3137         return DefWindowProcW( hwnd, message, wParam, lParam );
3138     }
3139     return 0;
3140 }
3141
3142
3143 /***********************************************************************
3144  *           MENU_GetMenuBarHeight
3145  *
3146  * Compute the size of the menu bar height. Used by NC_HandleNCCalcSize().
3147  */
3148 UINT MENU_GetMenuBarHeight( HWND hwnd, UINT menubarWidth,
3149                               INT orgX, INT orgY )
3150 {
3151     HDC hdc;
3152     RECT rectBar;
3153     LPPOPUPMENU lppop;
3154
3155     TRACE("HWND %p, width %d, at (%d, %d).\n", hwnd, menubarWidth, orgX, orgY );
3156
3157     if (!(lppop = MENU_GetMenu( GetMenu(hwnd) ))) return 0;
3158
3159     hdc = GetDCEx( hwnd, 0, DCX_CACHE | DCX_WINDOW );
3160     SelectObject( hdc, hMenuFont);
3161     SetRect(&rectBar, orgX, orgY, orgX+menubarWidth, orgY+GetSystemMetrics(SM_CYMENU));
3162     MENU_MenuBarCalcSize( hdc, &rectBar, lppop, hwnd );
3163     ReleaseDC( hwnd, hdc );
3164     return lppop->Height;
3165 }
3166
3167
3168 /*******************************************************************
3169  *         ChangeMenuA    (USER32.@)
3170  */
3171 BOOL WINAPI ChangeMenuA( HMENU hMenu, UINT pos, LPCSTR data,
3172                              UINT id, UINT flags )
3173 {
3174     TRACE("menu=%p pos=%d data=%p id=%08x flags=%08x\n", hMenu, pos, data, id, flags );
3175     if (flags & MF_APPEND) return AppendMenuA( hMenu, flags & ~MF_APPEND,
3176                                                  id, data );
3177     if (flags & MF_DELETE) return DeleteMenu(hMenu, pos, flags & ~MF_DELETE);
3178     if (flags & MF_CHANGE) return ModifyMenuA(hMenu, pos, flags & ~MF_CHANGE,
3179                                                 id, data );
3180     if (flags & MF_REMOVE) return RemoveMenu( hMenu,
3181                                               flags & MF_BYPOSITION ? pos : id,
3182                                               flags & ~MF_REMOVE );
3183     /* Default: MF_INSERT */
3184     return InsertMenuA( hMenu, pos, flags, id, data );
3185 }
3186
3187
3188 /*******************************************************************
3189  *         ChangeMenuW    (USER32.@)
3190  */
3191 BOOL WINAPI ChangeMenuW( HMENU hMenu, UINT pos, LPCWSTR data,
3192                              UINT id, UINT flags )
3193 {
3194     TRACE("menu=%p pos=%d data=%p id=%08x flags=%08x\n", hMenu, pos, data, id, flags );
3195     if (flags & MF_APPEND) return AppendMenuW( hMenu, flags & ~MF_APPEND,
3196                                                  id, data );
3197     if (flags & MF_DELETE) return DeleteMenu(hMenu, pos, flags & ~MF_DELETE);
3198     if (flags & MF_CHANGE) return ModifyMenuW(hMenu, pos, flags & ~MF_CHANGE,
3199                                                 id, data );
3200     if (flags & MF_REMOVE) return RemoveMenu( hMenu,
3201                                               flags & MF_BYPOSITION ? pos : id,
3202                                               flags & ~MF_REMOVE );
3203     /* Default: MF_INSERT */
3204     return InsertMenuW( hMenu, pos, flags, id, data );
3205 }
3206
3207
3208 /*******************************************************************
3209  *         CheckMenuItem    (USER32.@)
3210  */
3211 DWORD WINAPI CheckMenuItem( HMENU hMenu, UINT id, UINT flags )
3212 {
3213     MENUITEM *item;
3214     DWORD ret;
3215
3216     TRACE("menu=%p id=%04x flags=%04x\n", hMenu, id, flags );
3217     if (!(item = MENU_FindItem( &hMenu, &id, flags ))) return -1;
3218     ret = item->fState & MF_CHECKED;
3219     if (flags & MF_CHECKED) item->fState |= MF_CHECKED;
3220     else item->fState &= ~MF_CHECKED;
3221     return ret;
3222 }
3223
3224
3225 /**********************************************************************
3226  *         EnableMenuItem    (USER32.@)
3227  */
3228 UINT WINAPI EnableMenuItem( HMENU hMenu, UINT wItemID, UINT wFlags )
3229 {
3230     UINT    oldflags;
3231     MENUITEM *item;
3232     POPUPMENU *menu;
3233
3234     TRACE("(%p, %04x, %04x) !\n", hMenu, wItemID, wFlags);
3235
3236     /* Get the Popupmenu to access the owner menu */
3237     if (!(menu = MENU_GetMenu(hMenu)))
3238         return (UINT)-1;
3239
3240     if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags )))
3241         return (UINT)-1;
3242
3243     oldflags = item->fState & (MF_GRAYED | MF_DISABLED);
3244     item->fState ^= (oldflags ^ wFlags) & (MF_GRAYED | MF_DISABLED);
3245
3246     /* If the close item in the system menu change update the close button */
3247     if((item->wID == SC_CLOSE) && (oldflags != wFlags))
3248     {
3249         if (menu->hSysMenuOwner != 0)
3250         {
3251             POPUPMENU* parentMenu;
3252
3253             /* Get the parent menu to access*/
3254             if (!(parentMenu = MENU_GetMenu(menu->hSysMenuOwner)))
3255                 return (UINT)-1;
3256
3257             /* Refresh the frame to reflect the change*/
3258             SetWindowPos(parentMenu->hWnd, 0, 0, 0, 0, 0,
3259                          SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER);
3260         }
3261     }
3262
3263     return oldflags;
3264 }
3265
3266
3267 /*******************************************************************
3268  *         GetMenuStringA    (USER32.@)
3269  */
3270 INT WINAPI GetMenuStringA(
3271         HMENU hMenu,    /* [in] menuhandle */
3272         UINT wItemID,   /* [in] menu item (dep. on wFlags) */
3273         LPSTR str,      /* [out] outbuffer. If NULL, func returns entry length*/
3274         INT nMaxSiz,    /* [in] length of buffer. if 0, func returns entry len*/
3275         UINT wFlags     /* [in] MF_ flags */
3276 ) {
3277     MENUITEM *item;
3278
3279     TRACE("menu=%p item=%04x ptr=%p len=%d flags=%04x\n", hMenu, wItemID, str, nMaxSiz, wFlags );
3280     if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags ))) return 0;
3281     if (!IS_STRING_ITEM(item->fType)) return 0;
3282     if (!str || !nMaxSiz) return strlenW(item->text);
3283     str[0] = '\0';
3284     if (!WideCharToMultiByte( CP_ACP, 0, item->text, -1, str, nMaxSiz, NULL, NULL ))
3285         str[nMaxSiz-1] = 0;
3286     TRACE("returning '%s'\n", str );
3287     return strlen(str);
3288 }
3289
3290
3291 /*******************************************************************
3292  *         GetMenuStringW    (USER32.@)
3293  */
3294 INT WINAPI GetMenuStringW( HMENU hMenu, UINT wItemID,
3295                                LPWSTR str, INT nMaxSiz, UINT wFlags )
3296 {
3297     MENUITEM *item;
3298
3299     TRACE("menu=%p item=%04x ptr=%p len=%d flags=%04x\n", hMenu, wItemID, str, nMaxSiz, wFlags );
3300     if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags ))) return 0;
3301     if (!IS_STRING_ITEM(item->fType)) return 0;
3302     if (!str || !nMaxSiz) return strlenW(item->text);
3303     str[0] = '\0';
3304     lstrcpynW( str, item->text, nMaxSiz );
3305     return strlenW(str);
3306 }
3307
3308
3309 /**********************************************************************
3310  *         HiliteMenuItem    (USER32.@)
3311  */
3312 BOOL WINAPI HiliteMenuItem( HWND hWnd, HMENU hMenu, UINT wItemID,
3313                                 UINT wHilite )
3314 {
3315     LPPOPUPMENU menu;
3316     TRACE("(%p, %p, %04x, %04x);\n", hWnd, hMenu, wItemID, wHilite);
3317     if (!MENU_FindItem( &hMenu, &wItemID, wHilite )) return FALSE;
3318     if (!(menu = MENU_GetMenu(hMenu))) return FALSE;
3319     if (menu->FocusedItem == wItemID) return TRUE;
3320     MENU_HideSubPopups( hWnd, hMenu, FALSE );
3321     MENU_SelectItem( hWnd, hMenu, wItemID, TRUE, 0 );
3322     return TRUE;
3323 }
3324
3325
3326 /**********************************************************************
3327  *         GetMenuState    (USER32.@)
3328  */
3329 UINT WINAPI GetMenuState( HMENU hMenu, UINT wItemID, UINT wFlags )
3330 {
3331     MENUITEM *item;
3332     TRACE("(menu=%p, id=%04x, flags=%04x);\n", hMenu, wItemID, wFlags);
3333     if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags ))) return -1;
3334     debug_print_menuitem ("  item: ", item, "");
3335     if (item->fType & MF_POPUP)
3336     {
3337         POPUPMENU *menu = MENU_GetMenu( item->hSubMenu );
3338         if (!menu) return -1;
3339         else return (menu->nItems << 8) | ((item->fState|item->fType) & 0xff);
3340     }
3341     else
3342     {
3343         /* We used to (from way back then) mask the result to 0xff.  */
3344         /* I don't know why and it seems wrong as the documented */
3345         /* return flag MF_SEPARATOR is outside that mask.  */
3346         return (item->fType | item->fState);
3347     }
3348 }
3349
3350
3351 /**********************************************************************
3352  *         GetMenuItemCount    (USER32.@)
3353  */
3354 INT WINAPI GetMenuItemCount( HMENU hMenu )
3355 {
3356     LPPOPUPMENU menu = MENU_GetMenu(hMenu);
3357     if (!menu) return -1;
3358     TRACE("(%p) returning %d\n", hMenu, menu->nItems );
3359     return menu->nItems;
3360 }
3361
3362
3363 /**********************************************************************
3364  *         GetMenuItemID    (USER32.@)
3365  */
3366 UINT WINAPI GetMenuItemID( HMENU hMenu, INT nPos )
3367 {
3368     MENUITEM * lpmi;
3369
3370     if (!(lpmi = MENU_FindItem(&hMenu,&nPos,MF_BYPOSITION))) return -1;
3371     if (lpmi->fType & MF_POPUP) return -1;
3372     return lpmi->wID;
3373
3374 }
3375
3376
3377 /*******************************************************************
3378  *         InsertMenuW    (USER32.@)
3379  */
3380 BOOL WINAPI InsertMenuW( HMENU hMenu, UINT pos, UINT flags,
3381                          UINT_PTR id, LPCWSTR str )
3382 {
3383     MENUITEM *item;
3384
3385     if (IS_STRING_ITEM(flags) && str)
3386         TRACE("hMenu %p, pos %d, flags %08x, id %04x, str %s\n",
3387               hMenu, pos, flags, id, debugstr_w(str) );
3388     else TRACE("hMenu %p, pos %d, flags %08x, id %04x, str %08lx (not a string)\n",
3389                hMenu, pos, flags, id, (DWORD)str );
3390
3391     if (!(item = MENU_InsertItem( hMenu, pos, flags ))) return FALSE;
3392
3393     if (!(MENU_SetItemData( item, flags, id, str )))
3394     {
3395         RemoveMenu( hMenu, pos, flags );
3396         return FALSE;
3397     }
3398
3399     if (flags & MF_POPUP)  /* Set the MF_POPUP flag on the popup-menu */
3400         (MENU_GetMenu((HMENU)id))->wFlags |= MF_POPUP;
3401
3402     item->hCheckBit = item->hUnCheckBit = 0;
3403     return TRUE;
3404 }
3405
3406
3407 /*******************************************************************
3408  *         InsertMenuA    (USER32.@)
3409  */
3410 BOOL WINAPI InsertMenuA( HMENU hMenu, UINT pos, UINT flags,
3411                          UINT_PTR id, LPCSTR str )
3412 {
3413     BOOL ret = FALSE;
3414
3415     if (IS_STRING_ITEM(flags) && str)
3416     {
3417         INT len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
3418         LPWSTR newstr = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
3419         if (newstr)
3420         {
3421             MultiByteToWideChar( CP_ACP, 0, str, -1, newstr, len );
3422             ret = InsertMenuW( hMenu, pos, flags, id, newstr );
3423             HeapFree( GetProcessHeap(), 0, newstr );
3424         }
3425         return ret;
3426     }
3427     else return InsertMenuW( hMenu, pos, flags, id, (LPCWSTR)str );
3428 }
3429
3430
3431 /*******************************************************************
3432  *         AppendMenuA    (USER32.@)
3433  */
3434 BOOL WINAPI AppendMenuA( HMENU hMenu, UINT flags,
3435                          UINT_PTR id, LPCSTR data )
3436 {
3437     return InsertMenuA( hMenu, -1, flags | MF_BYPOSITION, id, data );
3438 }
3439
3440
3441 /*******************************************************************
3442  *         AppendMenuW    (USER32.@)
3443  */
3444 BOOL WINAPI AppendMenuW( HMENU hMenu, UINT flags,
3445                          UINT_PTR id, LPCWSTR data )
3446 {
3447     return InsertMenuW( hMenu, -1, flags | MF_BYPOSITION, id, data );
3448 }
3449
3450
3451 /**********************************************************************
3452  *         RemoveMenu    (USER32.@)
3453  */
3454 BOOL WINAPI RemoveMenu( HMENU hMenu, UINT nPos, UINT wFlags )
3455 {
3456     LPPOPUPMENU menu;
3457     MENUITEM *item;
3458
3459     TRACE("(menu=%p pos=%04x flags=%04x)\n",hMenu, nPos, wFlags);
3460     if (!(item = MENU_FindItem( &hMenu, &nPos, wFlags ))) return FALSE;
3461     if (!(menu = MENU_GetMenu(hMenu))) return FALSE;
3462
3463       /* Remove item */
3464
3465     MENU_FreeItemData( item );
3466
3467     if (--menu->nItems == 0)
3468     {
3469         HeapFree( GetProcessHeap(), 0, menu->items );
3470         menu->items = NULL;
3471     }
3472     else
3473     {
3474         while(nPos < menu->nItems)
3475         {
3476             *item = *(item+1);
3477             item++;
3478             nPos++;
3479         }
3480         menu->items = HeapReAlloc( GetProcessHeap(), 0, menu->items,
3481                                    menu->nItems * sizeof(MENUITEM) );
3482     }
3483     return TRUE;
3484 }
3485
3486
3487 /**********************************************************************
3488  *         DeleteMenu    (USER32.@)
3489  */
3490 BOOL WINAPI DeleteMenu( HMENU hMenu, UINT nPos, UINT wFlags )
3491 {
3492     MENUITEM *item = MENU_FindItem( &hMenu, &nPos, wFlags );
3493     if (!item) return FALSE;
3494     if (item->fType & MF_POPUP) DestroyMenu( item->hSubMenu );
3495       /* nPos is now the position of the item */
3496     RemoveMenu( hMenu, nPos, wFlags | MF_BYPOSITION );
3497     return TRUE;
3498 }
3499
3500
3501 /*******************************************************************
3502  *         ModifyMenuW    (USER32.@)
3503  */
3504 BOOL WINAPI ModifyMenuW( HMENU hMenu, UINT pos, UINT flags,
3505                          UINT_PTR id, LPCWSTR str )
3506 {
3507     MENUITEM *item;
3508
3509     if (IS_STRING_ITEM(flags))
3510     {
3511         TRACE("%p %d %04x %04x %s\n", hMenu, pos, flags, id, debugstr_w(str) );
3512     }
3513     else
3514     {
3515         TRACE("%p %d %04x %04x %08lx\n", hMenu, pos, flags, id, (DWORD)str );
3516     }
3517
3518     if (!(item = MENU_FindItem( &hMenu, &pos, flags ))) return FALSE;
3519     return MENU_SetItemData( item, flags, id, str );
3520 }
3521
3522
3523 /*******************************************************************
3524  *         ModifyMenuA    (USER32.@)
3525  */
3526 BOOL WINAPI ModifyMenuA( HMENU hMenu, UINT pos, UINT flags,
3527                          UINT_PTR id, LPCSTR str )
3528 {
3529     BOOL ret = FALSE;
3530
3531     if (IS_STRING_ITEM(flags) && str)
3532     {
3533         INT len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
3534         LPWSTR newstr = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
3535         if (newstr)
3536         {
3537             MultiByteToWideChar( CP_ACP, 0, str, -1, newstr, len );
3538             ret = ModifyMenuW( hMenu, pos, flags, id, newstr );
3539             HeapFree( GetProcessHeap(), 0, newstr );
3540         }
3541         return ret;
3542     }
3543     else return ModifyMenuW( hMenu, pos, flags, id, (LPCWSTR)str );
3544 }
3545
3546
3547 /**********************************************************************
3548  *         CreatePopupMenu    (USER32.@)
3549  */
3550 HMENU WINAPI CreatePopupMenu(void)
3551 {
3552     HMENU hmenu;
3553     POPUPMENU *menu;
3554
3555     if (!(hmenu = CreateMenu())) return 0;
3556     menu = MENU_GetMenu( hmenu );
3557     menu->wFlags |= MF_POPUP;
3558     menu->bTimeToHide = FALSE;
3559     return hmenu;
3560 }
3561
3562
3563 /**********************************************************************
3564  *         GetMenuCheckMarkDimensions    (USER.417)
3565  *         GetMenuCheckMarkDimensions    (USER32.@)
3566  */
3567 DWORD WINAPI GetMenuCheckMarkDimensions(void)
3568 {
3569     return MAKELONG( GetSystemMetrics(SM_CXMENUCHECK), GetSystemMetrics(SM_CYMENUCHECK) );
3570 }
3571
3572
3573 /**********************************************************************
3574  *         SetMenuItemBitmaps    (USER32.@)
3575  */
3576 BOOL WINAPI SetMenuItemBitmaps( HMENU hMenu, UINT nPos, UINT wFlags,
3577                                     HBITMAP hNewUnCheck, HBITMAP hNewCheck)
3578 {
3579     MENUITEM *item;
3580     TRACE("(%p, %04x, %04x, %p, %p)\n",
3581           hMenu, nPos, wFlags, hNewCheck, hNewUnCheck);
3582     if (!(item = MENU_FindItem( &hMenu, &nPos, wFlags ))) return FALSE;
3583
3584     if (!hNewCheck && !hNewUnCheck)
3585     {
3586         item->fState &= ~MF_USECHECKBITMAPS;
3587     }
3588     else  /* Install new bitmaps */
3589     {
3590         item->hCheckBit = hNewCheck;
3591         item->hUnCheckBit = hNewUnCheck;
3592         item->fState |= MF_USECHECKBITMAPS;
3593     }
3594     return TRUE;
3595 }
3596
3597
3598 /**********************************************************************
3599  *         CreateMenu    (USER32.@)
3600  */
3601 HMENU WINAPI CreateMenu(void)
3602 {
3603     HMENU hMenu;
3604     LPPOPUPMENU menu;
3605     if (!(hMenu = USER_HEAP_ALLOC( sizeof(POPUPMENU) ))) return 0;
3606     menu = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu);
3607
3608     ZeroMemory(menu, sizeof(POPUPMENU));
3609     menu->wMagic = MENU_MAGIC;
3610     menu->FocusedItem = NO_SELECTED_ITEM;
3611     menu->bTimeToHide = FALSE;
3612
3613     TRACE("return %p\n", hMenu );
3614
3615     return hMenu;
3616 }
3617
3618
3619 /**********************************************************************
3620  *         DestroyMenu    (USER32.@)
3621  */
3622 BOOL WINAPI DestroyMenu( HMENU hMenu )
3623 {
3624     TRACE("(%p)\n", hMenu);
3625
3626     /* Silently ignore attempts to destroy default system popup */
3627
3628     if (hMenu && hMenu != MENU_DefSysPopup)
3629     {
3630         LPPOPUPMENU lppop = MENU_GetMenu(hMenu);
3631
3632         if (!lppop) return FALSE;
3633
3634         lppop->wMagic = 0;  /* Mark it as destroyed */
3635
3636         /* DestroyMenu should not destroy system menu popup owner */
3637         if ((lppop->wFlags & (MF_POPUP | MF_SYSMENU)) == MF_POPUP && lppop->hWnd)
3638         {
3639             DestroyWindow( lppop->hWnd );
3640             lppop->hWnd = 0;
3641         }
3642
3643         if (lppop->items) /* recursively destroy submenus */
3644         {
3645             int i;
3646             MENUITEM *item = lppop->items;
3647             for (i = lppop->nItems; i > 0; i--, item++)
3648             {
3649                 if (item->fType & MF_POPUP) DestroyMenu(item->hSubMenu);
3650                 MENU_FreeItemData( item );
3651             }
3652             HeapFree( GetProcessHeap(), 0, lppop->items );
3653         }
3654         USER_HEAP_FREE( hMenu );
3655     }
3656     return (hMenu != MENU_DefSysPopup);
3657 }
3658
3659
3660 /**********************************************************************
3661  *         GetSystemMenu    (USER32.@)
3662  */
3663 HMENU WINAPI GetSystemMenu( HWND hWnd, BOOL bRevert )
3664 {
3665     WND *wndPtr = WIN_GetPtr( hWnd );
3666     HMENU retvalue = 0;
3667
3668     if (wndPtr == WND_DESKTOP) return 0;
3669     if (wndPtr == WND_OTHER_PROCESS)
3670     {
3671         if (IsWindow( hWnd )) FIXME( "not supported on other process window %p\n", hWnd );
3672     }
3673     else if (wndPtr)
3674     {
3675         if( wndPtr->hSysMenu )
3676         {
3677             if( bRevert )
3678             {
3679                 DestroyMenu(wndPtr->hSysMenu);
3680                 wndPtr->hSysMenu = 0;
3681             }
3682             else
3683             {
3684                 POPUPMENU *menu = MENU_GetMenu( wndPtr->hSysMenu );
3685                 if( menu )
3686                 {
3687                    if( menu->nItems > 0 && menu->items[0].hSubMenu == MENU_DefSysPopup )
3688                       menu->items[0].hSubMenu = MENU_CopySysPopup();
3689                 }
3690                 else
3691                 {
3692                    WARN("Current sys-menu (%p) of wnd %p is broken\n",
3693                         wndPtr->hSysMenu, hWnd);
3694                    wndPtr->hSysMenu = 0;
3695                 }
3696             }
3697         }
3698
3699         if(!wndPtr->hSysMenu && (wndPtr->dwStyle & WS_SYSMENU) )
3700             wndPtr->hSysMenu = MENU_GetSysMenu( hWnd, (HMENU)(-1) );
3701
3702         if( wndPtr->hSysMenu )
3703         {
3704             POPUPMENU *menu;
3705             retvalue = GetSubMenu(wndPtr->hSysMenu, 0);
3706
3707             /* Store the dummy sysmenu handle to facilitate the refresh */
3708             /* of the close button if the SC_CLOSE item change */
3709             menu = MENU_GetMenu(retvalue);
3710             if ( menu )
3711                menu->hSysMenuOwner = wndPtr->hSysMenu;
3712         }
3713         WIN_ReleasePtr( wndPtr );
3714     }
3715     return bRevert ? 0 : retvalue;
3716 }
3717
3718
3719 /*******************************************************************
3720  *         SetSystemMenu    (USER32.@)
3721  */
3722 BOOL WINAPI SetSystemMenu( HWND hwnd, HMENU hMenu )
3723 {
3724     WND *wndPtr = WIN_GetPtr( hwnd );
3725
3726     if (wndPtr && wndPtr != WND_OTHER_PROCESS && wndPtr != WND_DESKTOP)
3727     {
3728         if (wndPtr->hSysMenu) DestroyMenu( wndPtr->hSysMenu );
3729         wndPtr->hSysMenu = MENU_GetSysMenu( hwnd, hMenu );
3730         WIN_ReleasePtr( wndPtr );
3731         return TRUE;
3732     }
3733     return FALSE;
3734 }
3735
3736
3737 /**********************************************************************
3738  *         GetMenu    (USER32.@)
3739  */
3740 HMENU WINAPI GetMenu( HWND hWnd )
3741 {
3742     HMENU retvalue = (HMENU)GetWindowLongPtrW( hWnd, GWLP_ID );
3743     TRACE("for %p returning %p\n", hWnd, retvalue);
3744     return retvalue;
3745 }
3746
3747
3748 /**********************************************************************
3749  *         MENU_SetMenu
3750  *
3751  * Helper for SetMenu. Also called by WIN_CreateWindowEx to avoid the
3752  * SetWindowPos call that would result if SetMenu were called directly.
3753  */
3754 BOOL MENU_SetMenu( HWND hWnd, HMENU hMenu )
3755 {
3756     TRACE("(%p, %p);\n", hWnd, hMenu);
3757
3758     if (hMenu && !IsMenu(hMenu))
3759     {
3760         WARN("hMenu %p is not a menu handle\n", hMenu);
3761         return FALSE;
3762     }
3763     if (!WIN_ALLOWED_MENU(GetWindowLongW( hWnd, GWL_STYLE )))
3764         return FALSE;
3765
3766     hWnd = WIN_GetFullHandle( hWnd );
3767     if (GetCapture() == hWnd) MENU_SetCapture(0);  /* release the capture */
3768
3769     if (hMenu != 0)
3770     {
3771         LPPOPUPMENU lpmenu;
3772
3773         if (!(lpmenu = MENU_GetMenu(hMenu))) return FALSE;
3774
3775         lpmenu->hWnd = hWnd;
3776         lpmenu->Height = 0;  /* Make sure we recalculate the size */
3777     }
3778     SetWindowLongPtrW( hWnd, GWLP_ID, (LONG_PTR)hMenu );
3779     return TRUE;
3780 }
3781
3782
3783 /**********************************************************************
3784  *         SetMenu    (USER32.@)
3785  */
3786 BOOL WINAPI SetMenu( HWND hWnd, HMENU hMenu )
3787 {
3788     if(!MENU_SetMenu(hWnd, hMenu))
3789         return FALSE;
3790
3791     SetWindowPos( hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
3792                   SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
3793     return TRUE;
3794 }
3795
3796
3797 /**********************************************************************
3798  *         GetSubMenu    (USER32.@)
3799  */
3800 HMENU WINAPI GetSubMenu( HMENU hMenu, INT nPos )
3801 {
3802     MENUITEM * lpmi;
3803
3804     if (!(lpmi = MENU_FindItem(&hMenu,&nPos,MF_BYPOSITION))) return 0;
3805     if (!(lpmi->fType & MF_POPUP)) return 0;
3806     return lpmi->hSubMenu;
3807 }
3808
3809
3810 /**********************************************************************
3811  *         DrawMenuBar    (USER32.@)
3812  */
3813 BOOL WINAPI DrawMenuBar( HWND hWnd )
3814 {
3815     LPPOPUPMENU lppop;
3816     HMENU hMenu = GetMenu(hWnd);
3817
3818     if (!WIN_ALLOWED_MENU(GetWindowLongW( hWnd, GWL_STYLE )))
3819         return FALSE;
3820     if (!hMenu || !(lppop = MENU_GetMenu( hMenu ))) return FALSE;
3821
3822     lppop->Height = 0; /* Make sure we call MENU_MenuBarCalcSize */
3823     lppop->hwndOwner = hWnd;
3824     SetWindowPos( hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
3825                   SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
3826     return TRUE;
3827 }
3828
3829 /***********************************************************************
3830  *           DrawMenuBarTemp   (USER32.@)
3831  *
3832  * UNDOCUMENTED !!
3833  *
3834  * called by W98SE desk.cpl Control Panel Applet
3835  *
3836  * Not 100% sure about the param names, but close.
3837  */
3838 DWORD WINAPI DrawMenuBarTemp(HWND hwnd, HDC hDC, LPRECT lprect, HMENU hMenu, HFONT hFont)
3839 {
3840     LPPOPUPMENU lppop;
3841     UINT i,retvalue;
3842     HFONT hfontOld = 0;
3843
3844     if (!hMenu)
3845         hMenu = GetMenu(hwnd);
3846
3847     if (!hFont)
3848         hFont = hMenuFont;
3849
3850     lppop = MENU_GetMenu( hMenu );
3851     if (lppop == NULL || lprect == NULL)
3852     {
3853         retvalue = GetSystemMetrics(SM_CYMENU);
3854         goto END;
3855     }
3856
3857     TRACE("(%p, %p, %p, %p, %p)\n", hwnd, hDC, lprect, hMenu, hFont);
3858
3859     hfontOld = SelectObject( hDC, hFont);
3860
3861     if (lppop->Height == 0)
3862         MENU_MenuBarCalcSize(hDC, lprect, lppop, hwnd);
3863
3864     lprect->bottom = lprect->top + lppop->Height;
3865
3866     FillRect(hDC, lprect, GetSysColorBrush(COLOR_MENU) );
3867
3868     SelectObject( hDC, SYSCOLOR_GetPen(COLOR_3DFACE));
3869     MoveToEx( hDC, lprect->left, lprect->bottom, NULL );
3870     LineTo( hDC, lprect->right, lprect->bottom );
3871
3872     if (lppop->nItems == 0)
3873     {
3874         retvalue = GetSystemMetrics(SM_CYMENU);
3875         goto END;
3876     }
3877
3878     for (i = 0; i < lppop->nItems; i++)
3879     {
3880         MENU_DrawMenuItem( hwnd, hMenu, hwnd,
3881                            hDC, &lppop->items[i], lppop->Height, TRUE, ODA_DRAWENTIRE );
3882     }
3883     retvalue = lppop->Height;
3884
3885 END:
3886     if (hfontOld) SelectObject (hDC, hfontOld);
3887     return retvalue;
3888 }
3889
3890 /***********************************************************************
3891  *           EndMenu   (USER.187)
3892  *           EndMenu   (USER32.@)
3893  */
3894 void WINAPI EndMenu(void)
3895 {
3896     /* if we are in the menu code, and it is active */
3897     if (!fEndMenu && top_popup)
3898     {
3899         /* terminate the menu handling code */
3900         fEndMenu = TRUE;
3901
3902         /* needs to be posted to wakeup the internal menu handler */
3903         /* which will now terminate the menu, in the event that */
3904         /* the main window was minimized, or lost focus, so we */
3905         /* don't end up with an orphaned menu */
3906         PostMessageW( top_popup, WM_CANCELMODE, 0, 0);
3907     }
3908 }
3909
3910
3911 /***********************************************************************
3912  *           LookupMenuHandle   (USER.217)
3913  */
3914 HMENU16 WINAPI LookupMenuHandle16( HMENU16 hmenu, INT16 id )
3915 {
3916     HMENU hmenu32 = HMENU_32(hmenu);
3917     UINT id32 = id;
3918     if (!MENU_FindItem( &hmenu32, &id32, MF_BYCOMMAND )) return 0;
3919     else return HMENU_16(hmenu32);
3920 }
3921
3922
3923 /**********************************************************************
3924  *          LoadMenu    (USER.150)
3925  */
3926 HMENU16 WINAPI LoadMenu16( HINSTANCE16 instance, LPCSTR name )
3927 {
3928     HRSRC16 hRsrc;
3929     HGLOBAL16 handle;
3930     HMENU16 hMenu;
3931
3932     if (HIWORD(name) && name[0] == '#') name = (LPCSTR)atoi( name + 1 );
3933     if (!name) return 0;
3934
3935     instance = GetExePtr( instance );
3936     if (!(hRsrc = FindResource16( instance, name, (LPSTR)RT_MENU ))) return 0;
3937     if (!(handle = LoadResource16( instance, hRsrc ))) return 0;
3938     hMenu = LoadMenuIndirect16(LockResource16(handle));
3939     FreeResource16( handle );
3940     return hMenu;
3941 }
3942
3943
3944 /*****************************************************************
3945  *        LoadMenuA   (USER32.@)
3946  */
3947 HMENU WINAPI LoadMenuA( HINSTANCE instance, LPCSTR name )
3948 {
3949     HRSRC hrsrc = FindResourceA( instance, name, (LPSTR)RT_MENU );
3950     if (!hrsrc) return 0;
3951     return LoadMenuIndirectA( (LPCVOID)LoadResource( instance, hrsrc ));
3952 }
3953
3954
3955 /*****************************************************************
3956  *        LoadMenuW   (USER32.@)
3957  */
3958 HMENU WINAPI LoadMenuW( HINSTANCE instance, LPCWSTR name )
3959 {
3960     HRSRC hrsrc = FindResourceW( instance, name, (LPWSTR)RT_MENU );
3961     if (!hrsrc) return 0;
3962     return LoadMenuIndirectW( (LPCVOID)LoadResource( instance, hrsrc ));
3963 }
3964
3965
3966 /**********************************************************************
3967  *          LoadMenuIndirect    (USER.220)
3968  */
3969 HMENU16 WINAPI LoadMenuIndirect16( LPCVOID template )
3970 {
3971     HMENU hMenu;
3972     WORD version, offset;
3973     LPCSTR p = (LPCSTR)template;
3974
3975     TRACE("(%p)\n", template );
3976     version = GET_WORD(p);
3977     p += sizeof(WORD);
3978     if (version)
3979     {
3980         WARN("version must be 0 for Win16\n" );
3981         return 0;
3982     }
3983     offset = GET_WORD(p);
3984     p += sizeof(WORD) + offset;
3985     if (!(hMenu = CreateMenu())) return 0;
3986     if (!MENU_ParseResource( p, hMenu, FALSE ))
3987     {
3988         DestroyMenu( hMenu );
3989         return 0;
3990     }
3991     return HMENU_16(hMenu);
3992 }
3993
3994
3995 /**********************************************************************
3996  *          LoadMenuIndirectW    (USER32.@)
3997  */
3998 HMENU WINAPI LoadMenuIndirectW( LPCVOID template )
3999 {
4000     HMENU hMenu;
4001     WORD version, offset;
4002     LPCSTR p = (LPCSTR)template;
4003
4004     version = GET_WORD(p);
4005     p += sizeof(WORD);
4006     TRACE("%p, ver %d\n", template, version );
4007     switch (version)
4008     {
4009       case 0: /* standard format is version of 0 */
4010         offset = GET_WORD(p);
4011         p += sizeof(WORD) + offset;
4012         if (!(hMenu = CreateMenu())) return 0;
4013         if (!MENU_ParseResource( p, hMenu, TRUE ))
4014           {
4015             DestroyMenu( hMenu );
4016             return 0;
4017           }
4018         return hMenu;
4019       case 1: /* extended format is version of 1 */
4020         offset = GET_WORD(p);
4021         p += sizeof(WORD) + offset;
4022         if (!(hMenu = CreateMenu())) return 0;
4023         if (!MENUEX_ParseResource( p, hMenu))
4024           {
4025             DestroyMenu( hMenu );
4026             return 0;
4027           }
4028         return hMenu;
4029       default:
4030         ERR("version %d not supported.\n", version);
4031         return 0;
4032     }
4033 }
4034
4035
4036 /**********************************************************************
4037  *          LoadMenuIndirectA    (USER32.@)
4038  */
4039 HMENU WINAPI LoadMenuIndirectA( LPCVOID template )
4040 {
4041     return LoadMenuIndirectW( template );
4042 }
4043
4044
4045 /**********************************************************************
4046  *              IsMenu    (USER32.@)
4047  */
4048 BOOL WINAPI IsMenu(HMENU hmenu)
4049 {
4050     LPPOPUPMENU menu = MENU_GetMenu(hmenu);
4051     return menu != NULL;
4052 }
4053
4054 /**********************************************************************
4055  *              GetMenuItemInfo_common
4056  */
4057
4058 static BOOL GetMenuItemInfo_common ( HMENU hmenu, UINT item, BOOL bypos,
4059                                         LPMENUITEMINFOW lpmii, BOOL unicode)
4060 {
4061     MENUITEM *menu = MENU_FindItem (&hmenu, &item, bypos? MF_BYPOSITION : 0);
4062
4063     debug_print_menuitem("GetMenuItemInfo_common: ", menu, "");
4064
4065     if (!menu)
4066         return FALSE;
4067
4068     if (lpmii->fMask & MIIM_TYPE) {
4069         lpmii->fType = menu->fType;
4070         switch (MENU_ITEM_TYPE(menu->fType)) {
4071         case MF_STRING:
4072             break;  /* will be done below */
4073         case MF_OWNERDRAW:
4074         case MF_BITMAP:
4075             lpmii->dwTypeData = menu->text;
4076             /* fall through */
4077         default:
4078             lpmii->cch = 0;
4079         }
4080     }
4081
4082     /* copy the text string */
4083     if ((lpmii->fMask & (MIIM_TYPE|MIIM_STRING)) &&
4084          (MENU_ITEM_TYPE(menu->fType) == MF_STRING) && menu->text)
4085     {
4086         int len;
4087         if (unicode)
4088         {
4089             len = strlenW(menu->text);
4090             if(lpmii->dwTypeData && lpmii->cch)
4091                 lstrcpynW(lpmii->dwTypeData, menu->text, lpmii->cch);
4092         }
4093         else
4094         {
4095             len = WideCharToMultiByte( CP_ACP, 0, menu->text, -1, NULL, 0, NULL, NULL );
4096             if(lpmii->dwTypeData && lpmii->cch)
4097                 if (!WideCharToMultiByte( CP_ACP, 0, menu->text, -1,
4098                                           (LPSTR)lpmii->dwTypeData, lpmii->cch, NULL, NULL ))
4099                     ((LPSTR)lpmii->dwTypeData)[lpmii->cch-1] = 0;
4100         }
4101         /* if we've copied a substring we return its length */
4102         if(lpmii->dwTypeData && lpmii->cch)
4103         {
4104             if (lpmii->cch <= len) lpmii->cch--;
4105         }
4106         else /* return length of string */
4107             lpmii->cch = len;
4108     }
4109
4110     if (lpmii->fMask & MIIM_FTYPE)
4111         lpmii->fType = menu->fType;
4112
4113     if (lpmii->fMask & MIIM_BITMAP)
4114         lpmii->hbmpItem = menu->hbmpItem;
4115
4116     if (lpmii->fMask & MIIM_STATE)
4117         lpmii->fState = menu->fState;
4118
4119     if (lpmii->fMask & MIIM_ID)
4120         lpmii->wID = menu->wID;
4121
4122     if (lpmii->fMask & MIIM_SUBMENU)
4123         lpmii->hSubMenu = menu->hSubMenu;
4124
4125     if (lpmii->fMask & MIIM_CHECKMARKS) {
4126         lpmii->hbmpChecked = menu->hCheckBit;
4127         lpmii->hbmpUnchecked = menu->hUnCheckBit;
4128     }
4129     if (lpmii->fMask & MIIM_DATA)
4130         lpmii->dwItemData = menu->dwItemData;
4131
4132   return TRUE;
4133 }
4134
4135 /**********************************************************************
4136  *              GetMenuItemInfoA    (USER32.@)
4137  */
4138 BOOL WINAPI GetMenuItemInfoA( HMENU hmenu, UINT item, BOOL bypos,
4139                                   LPMENUITEMINFOA lpmii)
4140 {
4141     return GetMenuItemInfo_common (hmenu, item, bypos,
4142                                     (LPMENUITEMINFOW)lpmii, FALSE);
4143 }
4144
4145 /**********************************************************************
4146  *              GetMenuItemInfoW    (USER32.@)
4147  */
4148 BOOL WINAPI GetMenuItemInfoW( HMENU hmenu, UINT item, BOOL bypos,
4149                                   LPMENUITEMINFOW lpmii)
4150 {
4151     return GetMenuItemInfo_common (hmenu, item, bypos,
4152                                      lpmii, TRUE);
4153 }
4154
4155
4156 /* set a menu item text from a ASCII or Unicode string */
4157 inline static void set_menu_item_text( MENUITEM *menu, LPCWSTR text, BOOL unicode )
4158 {
4159     if (!text)
4160     {
4161         menu->text = NULL;
4162         menu->fType |= MF_SEPARATOR;
4163     }
4164     else if (unicode)
4165     {
4166         if ((menu->text = HeapAlloc( GetProcessHeap(), 0, (strlenW(text)+1) * sizeof(WCHAR) )))
4167             strcpyW( menu->text, text );
4168     }
4169     else
4170     {
4171         LPCSTR str = (LPCSTR)text;
4172         int len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
4173         if ((menu->text = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
4174             MultiByteToWideChar( CP_ACP, 0, str, -1, menu->text, len );
4175     }
4176 }
4177
4178
4179 /**********************************************************************
4180  *              SetMenuItemInfo_common
4181  */
4182
4183 static BOOL SetMenuItemInfo_common(MENUITEM * menu,
4184                                        const MENUITEMINFOW *lpmii,
4185                                        BOOL unicode)
4186 {
4187     if (!menu) return FALSE;
4188
4189     debug_print_menuitem("MENU_SetItemInfo_common from: ", menu, "");
4190
4191     if (lpmii->fMask & MIIM_TYPE ) {
4192         /* Get rid of old string. */
4193         if (IS_STRING_ITEM(menu->fType) && menu->text) {
4194             HeapFree(GetProcessHeap(), 0, menu->text);
4195             menu->text = NULL;
4196         }
4197
4198         /* make only MENU_ITEM_TYPE bits in menu->fType equal lpmii->fType */
4199         menu->fType &= ~MENU_ITEM_TYPE(menu->fType);
4200         menu->fType |= MENU_ITEM_TYPE(lpmii->fType);
4201
4202         menu->text = lpmii->dwTypeData;
4203
4204        if (IS_STRING_ITEM(menu->fType))
4205            set_menu_item_text( menu, lpmii->dwTypeData, unicode );
4206     }
4207
4208     if (lpmii->fMask & MIIM_FTYPE ) {
4209         /* free the string when the type is changing */
4210         if ( (!IS_STRING_ITEM(lpmii->fType)) && IS_STRING_ITEM(menu->fType) && menu->text) {
4211             HeapFree(GetProcessHeap(), 0, menu->text);
4212             menu->text = NULL;
4213         }
4214         menu->fType &= ~MENU_ITEM_TYPE(menu->fType);
4215         menu->fType |= MENU_ITEM_TYPE(lpmii->fType);
4216         if ( IS_STRING_ITEM(menu->fType) && !menu->text )
4217             menu->fType |= MF_SEPARATOR;
4218     }
4219
4220     if (lpmii->fMask & MIIM_STRING ) {
4221         if (IS_STRING_ITEM(menu->fType)) {
4222             /* free the string when used */
4223             HeapFree(GetProcessHeap(), 0, menu->text);
4224             set_menu_item_text( menu, lpmii->dwTypeData, unicode );
4225         }
4226     }
4227
4228     if (lpmii->fMask & MIIM_STATE)
4229     {
4230         /* FIXME: MFS_DEFAULT do we have to reset the other menu items? */
4231         menu->fState = lpmii->fState;
4232     }
4233
4234     if (lpmii->fMask & MIIM_ID)
4235         menu->wID = lpmii->wID;
4236
4237     if (lpmii->fMask & MIIM_SUBMENU) {
4238         menu->hSubMenu = lpmii->hSubMenu;
4239         if (menu->hSubMenu) {
4240             POPUPMENU *subMenu = MENU_GetMenu(menu->hSubMenu);
4241             if (subMenu) {
4242                 subMenu->wFlags |= MF_POPUP;
4243                 menu->fType |= MF_POPUP;
4244             }
4245             else
4246                 /* FIXME: Return an error ? */
4247                 menu->fType &= ~MF_POPUP;
4248         }
4249         else
4250             menu->fType &= ~MF_POPUP;
4251     }
4252
4253     if (lpmii->fMask & MIIM_CHECKMARKS)
4254     {
4255         if (lpmii->fType & MFT_RADIOCHECK)
4256             menu->fType |= MFT_RADIOCHECK;
4257
4258         menu->hCheckBit = lpmii->hbmpChecked;
4259         menu->hUnCheckBit = lpmii->hbmpUnchecked;
4260     }
4261     if (lpmii->fMask & MIIM_DATA)
4262         menu->dwItemData = lpmii->dwItemData;
4263
4264     if (lpmii->fMask & MIIM_BITMAP)
4265         menu->hbmpItem = lpmii->hbmpItem;
4266
4267     debug_print_menuitem("SetMenuItemInfo_common to : ", menu, "");
4268     return TRUE;
4269 }
4270
4271 /**********************************************************************
4272  *              SetMenuItemInfoA    (USER32.@)
4273  */
4274 BOOL WINAPI SetMenuItemInfoA(HMENU hmenu, UINT item, BOOL bypos,
4275                                  const MENUITEMINFOA *lpmii)
4276 {
4277     return SetMenuItemInfo_common(MENU_FindItem(&hmenu, &item, bypos? MF_BYPOSITION : 0),
4278                                     (const MENUITEMINFOW *)lpmii, FALSE);
4279 }
4280
4281 /**********************************************************************
4282  *              SetMenuItemInfoW    (USER32.@)
4283  */
4284 BOOL WINAPI SetMenuItemInfoW(HMENU hmenu, UINT item, BOOL bypos,
4285                                  const MENUITEMINFOW *lpmii)
4286 {
4287     return SetMenuItemInfo_common(MENU_FindItem(&hmenu, &item, bypos? MF_BYPOSITION : 0),
4288                                     lpmii, TRUE);
4289 }
4290
4291 /**********************************************************************
4292  *              SetMenuDefaultItem    (USER32.@)
4293  *
4294  */
4295 BOOL WINAPI SetMenuDefaultItem(HMENU hmenu, UINT uItem, UINT bypos)
4296 {
4297         UINT i;
4298         POPUPMENU *menu;
4299         MENUITEM *item;
4300
4301         TRACE("(%p,%d,%d)\n", hmenu, uItem, bypos);
4302
4303         if (!(menu = MENU_GetMenu(hmenu))) return FALSE;
4304
4305         /* reset all default-item flags */
4306         item = menu->items;
4307         for (i = 0; i < menu->nItems; i++, item++)
4308         {
4309             item->fState &= ~MFS_DEFAULT;
4310         }
4311
4312         /* no default item */
4313         if ( -1 == uItem)
4314         {
4315             return TRUE;
4316         }
4317
4318         item = menu->items;
4319         if ( bypos )
4320         {
4321             if ( uItem >= menu->nItems ) return FALSE;
4322             item[uItem].fState |= MFS_DEFAULT;
4323             return TRUE;
4324         }
4325         else
4326         {
4327             for (i = 0; i < menu->nItems; i++, item++)
4328             {
4329                 if (item->wID == uItem)
4330                 {
4331                      item->fState |= MFS_DEFAULT;
4332                      return TRUE;
4333                 }
4334             }
4335
4336         }
4337         return FALSE;
4338 }
4339
4340 /**********************************************************************
4341  *              GetMenuDefaultItem    (USER32.@)
4342  */
4343 UINT WINAPI GetMenuDefaultItem(HMENU hmenu, UINT bypos, UINT flags)
4344 {
4345         POPUPMENU *menu;
4346         MENUITEM * item;
4347         UINT i = 0;
4348
4349         TRACE("(%p,%d,%d)\n", hmenu, bypos, flags);
4350
4351         if (!(menu = MENU_GetMenu(hmenu))) return -1;
4352
4353         /* find default item */
4354         item = menu->items;
4355
4356         /* empty menu */
4357         if (! item) return -1;
4358
4359         while ( !( item->fState & MFS_DEFAULT ) )
4360         {
4361             i++; item++;
4362             if  (i >= menu->nItems ) return -1;
4363         }
4364
4365         /* default: don't return disabled items */
4366         if ( (!(GMDI_USEDISABLED & flags)) && (item->fState & MFS_DISABLED )) return -1;
4367
4368         /* search rekursiv when needed */
4369         if ( (item->fType & MF_POPUP) &&  (flags & GMDI_GOINTOPOPUPS) )
4370         {
4371             UINT ret;
4372             ret = GetMenuDefaultItem( item->hSubMenu, bypos, flags );
4373             if ( -1 != ret ) return ret;
4374
4375             /* when item not found in submenu, return the popup item */
4376         }
4377         return ( bypos ) ? i : item->wID;
4378
4379 }
4380
4381
4382 /**********************************************************************
4383  *              InsertMenuItemA    (USER32.@)
4384  */
4385 BOOL WINAPI InsertMenuItemA(HMENU hMenu, UINT uItem, BOOL bypos,
4386                                 const MENUITEMINFOA *lpmii)
4387 {
4388     MENUITEM *item = MENU_InsertItem(hMenu, uItem, bypos ? MF_BYPOSITION : 0 );
4389     return SetMenuItemInfo_common(item, (const MENUITEMINFOW *)lpmii, FALSE);
4390 }
4391
4392
4393 /**********************************************************************
4394  *              InsertMenuItemW    (USER32.@)
4395  */
4396 BOOL WINAPI InsertMenuItemW(HMENU hMenu, UINT uItem, BOOL bypos,
4397                                 const MENUITEMINFOW *lpmii)
4398 {
4399     MENUITEM *item = MENU_InsertItem(hMenu, uItem, bypos ? MF_BYPOSITION : 0 );
4400     return SetMenuItemInfo_common(item, lpmii, TRUE);
4401 }
4402
4403 /**********************************************************************
4404  *              CheckMenuRadioItem    (USER32.@)
4405  */
4406
4407 BOOL WINAPI CheckMenuRadioItem(HMENU hMenu,
4408                                    UINT first, UINT last, UINT check,
4409                                    UINT bypos)
4410 {
4411      MENUITEM *mifirst, *milast, *micheck;
4412      HMENU mfirst = hMenu, mlast = hMenu, mcheck = hMenu;
4413
4414      TRACE("%p: %d-%d, check %d, bypos=%d\n", hMenu, first, last, check, bypos);
4415
4416      mifirst = MENU_FindItem (&mfirst, &first, bypos);
4417      milast = MENU_FindItem (&mlast, &last, bypos);
4418      micheck = MENU_FindItem (&mcheck, &check, bypos);
4419
4420      if (mifirst == NULL || milast == NULL || micheck == NULL ||
4421          mifirst > milast || mfirst != mlast || mfirst != mcheck ||
4422          micheck > milast || micheck < mifirst)
4423           return FALSE;
4424
4425      while (mifirst <= milast)
4426      {
4427           if (mifirst == micheck)
4428           {
4429                mifirst->fType |= MFT_RADIOCHECK;
4430                mifirst->fState |= MFS_CHECKED;
4431           } else {
4432                mifirst->fType &= ~MFT_RADIOCHECK;
4433                mifirst->fState &= ~MFS_CHECKED;
4434           }
4435           mifirst++;
4436      }
4437
4438      return TRUE;
4439 }
4440
4441
4442 /**********************************************************************
4443  *              GetMenuItemRect    (USER32.@)
4444  *
4445  *      ATTENTION: Here, the returned values in rect are the screen
4446  *                 coordinates of the item just like if the menu was
4447  *                 always on the upper left side of the application.
4448  *
4449  */
4450 BOOL WINAPI GetMenuItemRect (HWND hwnd, HMENU hMenu, UINT uItem,
4451                                  LPRECT rect)
4452 {
4453      POPUPMENU *itemMenu;
4454      MENUITEM *item;
4455      HWND referenceHwnd;
4456
4457      TRACE("(%p,%p,%d,%p)\n", hwnd, hMenu, uItem, rect);
4458
4459      item = MENU_FindItem (&hMenu, &uItem, MF_BYPOSITION);
4460      referenceHwnd = hwnd;
4461
4462      if(!hwnd)
4463      {
4464          itemMenu = MENU_GetMenu(hMenu);
4465          if (itemMenu == NULL)
4466              return FALSE;
4467
4468          if(itemMenu->hWnd == 0)
4469              return FALSE;
4470          referenceHwnd = itemMenu->hWnd;
4471      }
4472
4473      if ((rect == NULL) || (item == NULL))
4474          return FALSE;
4475
4476      *rect = item->rect;
4477
4478      MapWindowPoints(referenceHwnd, 0, (LPPOINT)rect, 2);
4479
4480      return TRUE;
4481 }
4482
4483
4484 /**********************************************************************
4485  *              SetMenuInfo    (USER32.@)
4486  *
4487  * FIXME
4488  *      MIM_APPLYTOSUBMENUS
4489  *      actually use the items to draw the menu
4490  */
4491 BOOL WINAPI SetMenuInfo (HMENU hMenu, LPCMENUINFO lpmi)
4492 {
4493     POPUPMENU *menu;
4494
4495     TRACE("(%p %p)\n", hMenu, lpmi);
4496
4497     if (lpmi && (lpmi->cbSize==sizeof(MENUINFO)) && (menu = MENU_GetMenu(hMenu)))
4498     {
4499
4500         if (lpmi->fMask & MIM_BACKGROUND)
4501             menu->hbrBack = lpmi->hbrBack;
4502
4503         if (lpmi->fMask & MIM_HELPID)
4504             menu->dwContextHelpID = lpmi->dwContextHelpID;
4505
4506         if (lpmi->fMask & MIM_MAXHEIGHT)
4507             menu->cyMax = lpmi->cyMax;
4508
4509         if (lpmi->fMask & MIM_MENUDATA)
4510             menu->dwMenuData = lpmi->dwMenuData;
4511
4512         if (lpmi->fMask & MIM_STYLE)
4513         {
4514             menu->dwStyle = lpmi->dwStyle;
4515             if (menu->dwStyle & MNS_AUTODISMISS) FIXME("MNS_AUTODISMISS unimplemented\n");
4516             if (menu->dwStyle & MNS_DRAGDROP) FIXME("MNS_DRAGDROP unimplemented\n");
4517             if (menu->dwStyle & MNS_MODELESS) FIXME("MNS_MODELESS unimplemented\n");
4518             if (menu->dwStyle & MNS_NOCHECK) FIXME("MNS_NOCHECK unimplemented\n");
4519             if (menu->dwStyle & MNS_NOTIFYBYPOS) FIXME("MNS_NOTIFYBYPOS unimplemented\n");
4520         }
4521
4522         return TRUE;
4523     }
4524     return FALSE;
4525 }
4526
4527 /**********************************************************************
4528  *              GetMenuInfo    (USER32.@)
4529  *
4530  *  NOTES
4531  *      win98/NT5.0
4532  *
4533  */
4534 BOOL WINAPI GetMenuInfo (HMENU hMenu, LPMENUINFO lpmi)
4535 {   POPUPMENU *menu;
4536
4537     TRACE("(%p %p)\n", hMenu, lpmi);
4538
4539     if (lpmi && (menu = MENU_GetMenu(hMenu)))
4540     {
4541
4542         if (lpmi->fMask & MIM_BACKGROUND)
4543             lpmi->hbrBack = menu->hbrBack;
4544
4545         if (lpmi->fMask & MIM_HELPID)
4546             lpmi->dwContextHelpID = menu->dwContextHelpID;
4547
4548         if (lpmi->fMask & MIM_MAXHEIGHT)
4549             lpmi->cyMax = menu->cyMax;
4550
4551         if (lpmi->fMask & MIM_MENUDATA)
4552             lpmi->dwMenuData = menu->dwMenuData;
4553
4554         if (lpmi->fMask & MIM_STYLE)
4555             lpmi->dwStyle = menu->dwStyle;
4556
4557         return TRUE;
4558     }
4559     return FALSE;
4560 }
4561
4562
4563 /**********************************************************************
4564  *         SetMenuContextHelpId    (USER32.@)
4565  */
4566 BOOL WINAPI SetMenuContextHelpId( HMENU hMenu, DWORD dwContextHelpID)
4567 {
4568     LPPOPUPMENU menu;
4569
4570     TRACE("(%p 0x%08lx)\n", hMenu, dwContextHelpID);
4571
4572     if ((menu = MENU_GetMenu(hMenu)))
4573     {
4574         menu->dwContextHelpID = dwContextHelpID;
4575         return TRUE;
4576     }
4577     return FALSE;
4578 }
4579
4580
4581 /**********************************************************************
4582  *         GetMenuContextHelpId    (USER32.@)
4583  */
4584 DWORD WINAPI GetMenuContextHelpId( HMENU hMenu )
4585 {
4586     LPPOPUPMENU menu;
4587
4588     TRACE("(%p)\n", hMenu);
4589
4590     if ((menu = MENU_GetMenu(hMenu)))
4591     {
4592         return menu->dwContextHelpID;
4593     }
4594     return 0;
4595 }
4596
4597 /**********************************************************************
4598  *         MenuItemFromPoint    (USER32.@)
4599  */
4600 INT WINAPI MenuItemFromPoint(HWND hWnd, HMENU hMenu, POINT ptScreen)
4601 {
4602     POPUPMENU *menu = MENU_GetMenu(hMenu);
4603     UINT pos;
4604
4605     /*FIXME: Do we have to handle hWnd here? */
4606     if (!menu) return -1;
4607     if (!MENU_FindItemByCoords(menu, ptScreen, &pos)) return -1;
4608     return pos;
4609 }
4610
4611
4612 /**********************************************************************
4613  *           translate_accelerator
4614  */
4615 static BOOL translate_accelerator( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam,
4616                                    BYTE fVirt, WORD key, WORD cmd )
4617 {
4618     INT mask = 0;
4619     UINT mesg = 0;
4620
4621     if (wParam != key) return FALSE;
4622
4623     if (GetKeyState(VK_CONTROL) & 0x8000) mask |= FCONTROL;
4624     if (GetKeyState(VK_MENU) & 0x8000) mask |= FALT;
4625     if (GetKeyState(VK_SHIFT) & 0x8000) mask |= FSHIFT;
4626
4627     if (message == WM_CHAR || message == WM_SYSCHAR)
4628     {
4629         if ( !(fVirt & FVIRTKEY) && (mask & FALT) == (fVirt & FALT) )
4630         {
4631             TRACE_(accel)("found accel for WM_CHAR: ('%c')\n", wParam & 0xff);
4632             goto found;
4633         }
4634     }
4635     else
4636     {
4637         if(fVirt & FVIRTKEY)
4638         {
4639             TRACE_(accel)("found accel for virt_key %04x (scan %04x)\n",
4640                           wParam, 0xff & HIWORD(lParam));
4641
4642             if(mask == (fVirt & (FSHIFT | FCONTROL | FALT))) goto found;
4643             TRACE_(accel)(", but incorrect SHIFT/CTRL/ALT-state\n");
4644         }
4645         else
4646         {
4647             if (!(lParam & 0x01000000))  /* no special_key */
4648             {
4649                 if ((fVirt & FALT) && (lParam & 0x20000000))
4650                 {                              /* ^^ ALT pressed */
4651                     TRACE_(accel)("found accel for Alt-%c\n", wParam & 0xff);
4652                     goto found;
4653                 }
4654             }
4655         }
4656     }
4657     return FALSE;
4658
4659  found:
4660     if (message == WM_KEYUP || message == WM_SYSKEYUP)
4661         mesg = 1;
4662     else
4663     {
4664         HMENU hMenu, hSubMenu, hSysMenu;
4665         UINT uSysStat = (UINT)-1, uStat = (UINT)-1, nPos;
4666
4667         hMenu = (GetWindowLongW( hWnd, GWL_STYLE ) & WS_CHILD) ? 0 : GetMenu(hWnd);
4668         hSysMenu = get_win_sys_menu( hWnd );
4669
4670         /* find menu item and ask application to initialize it */
4671         /* 1. in the system menu */
4672         hSubMenu = hSysMenu;
4673         nPos = cmd;
4674         if(MENU_FindItem(&hSubMenu, &nPos, MF_BYCOMMAND))
4675         {
4676             if (GetCapture())
4677                 mesg = 2;
4678             if (!IsWindowEnabled(hWnd))
4679                 mesg = 3;
4680             else
4681             {
4682                 SendMessageW(hWnd, WM_INITMENU, (WPARAM)hSysMenu, 0L);
4683                 if(hSubMenu != hSysMenu)
4684                 {
4685                     nPos = MENU_FindSubMenu(&hSysMenu, hSubMenu);
4686                     TRACE_(accel)("hSysMenu = %p, hSubMenu = %p, nPos = %d\n", hSysMenu, hSubMenu, nPos);
4687                     SendMessageW(hWnd, WM_INITMENUPOPUP, (WPARAM)hSubMenu, MAKELPARAM(nPos, TRUE));
4688                 }
4689                 uSysStat = GetMenuState(GetSubMenu(hSysMenu, 0), cmd, MF_BYCOMMAND);
4690             }
4691         }
4692         else /* 2. in the window's menu */
4693         {
4694             hSubMenu = hMenu;
4695             nPos = cmd;
4696             if(MENU_FindItem(&hSubMenu, &nPos, MF_BYCOMMAND))
4697             {
4698                 if (GetCapture())
4699                     mesg = 2;
4700                 if (!IsWindowEnabled(hWnd))
4701                     mesg = 3;
4702                 else
4703                 {
4704                     SendMessageW(hWnd, WM_INITMENU, (WPARAM)hMenu, 0L);
4705                     if(hSubMenu != hMenu)
4706                     {
4707                         nPos = MENU_FindSubMenu(&hMenu, hSubMenu);
4708                         TRACE_(accel)("hMenu = %p, hSubMenu = %p, nPos = %d\n", hMenu, hSubMenu, nPos);
4709                         SendMessageW(hWnd, WM_INITMENUPOPUP, (WPARAM)hSubMenu, MAKELPARAM(nPos, FALSE));
4710                     }
4711                     uStat = GetMenuState(hMenu, cmd, MF_BYCOMMAND);
4712                 }
4713             }
4714         }
4715
4716         if (mesg == 0)
4717         {
4718             if (uSysStat != (UINT)-1)
4719             {
4720                 if (uSysStat & (MF_DISABLED|MF_GRAYED))
4721                     mesg=4;
4722                 else
4723                     mesg=WM_SYSCOMMAND;
4724             }
4725             else
4726             {
4727                 if (uStat != (UINT)-1)
4728                 {
4729                     if (IsIconic(hWnd))
4730                         mesg=5;
4731                     else
4732                     {
4733                         if (uStat & (MF_DISABLED|MF_GRAYED))
4734                             mesg=6;
4735                         else
4736                             mesg=WM_COMMAND;
4737                     }
4738                 }
4739                 else
4740                     mesg=WM_COMMAND;
4741             }
4742         }
4743     }
4744
4745     if( mesg==WM_COMMAND )
4746     {
4747         TRACE_(accel)(", sending WM_COMMAND, wParam=%0x\n", 0x10000 | cmd);
4748         SendMessageW(hWnd, mesg, 0x10000 | cmd, 0L);
4749     }
4750     else if( mesg==WM_SYSCOMMAND )
4751     {
4752         TRACE_(accel)(", sending WM_SYSCOMMAND, wParam=%0x\n", cmd);
4753         SendMessageW(hWnd, mesg, cmd, 0x00010000L);
4754     }
4755     else
4756     {
4757         /*  some reasons for NOT sending the WM_{SYS}COMMAND message:
4758          *   #0: unknown (please report!)
4759          *   #1: for WM_KEYUP,WM_SYSKEYUP
4760          *   #2: mouse is captured
4761          *   #3: window is disabled
4762          *   #4: it's a disabled system menu option
4763          *   #5: it's a menu option, but window is iconic
4764          *   #6: it's a menu option, but disabled
4765          */
4766         TRACE_(accel)(", but won't send WM_{SYS}COMMAND, reason is #%d\n",mesg);
4767         if(mesg==0)
4768             ERR_(accel)(" unknown reason - please report!\n");
4769     }
4770     return TRUE;
4771 }
4772
4773 /**********************************************************************
4774  *      TranslateAccelerator      (USER32.@)
4775  *      TranslateAcceleratorA     (USER32.@)
4776  */
4777 INT WINAPI TranslateAcceleratorA( HWND hWnd, HACCEL hAccel, LPMSG msg )
4778 {
4779     /* YES, Accel16! */
4780     LPACCEL16 lpAccelTbl;
4781     int i;
4782     WPARAM wParam;
4783
4784     if (!hWnd || !msg) return 0;
4785
4786     if (!hAccel || !(lpAccelTbl = (LPACCEL16) LockResource16(HACCEL_16(hAccel))))
4787     {
4788         WARN_(accel)("invalid accel handle=%p\n", hAccel);
4789         return 0;
4790     }
4791
4792     wParam = msg->wParam;
4793
4794     switch (msg->message)
4795     {
4796     case WM_KEYDOWN:
4797     case WM_SYSKEYDOWN:
4798         break;
4799
4800     case WM_CHAR:
4801     case WM_SYSCHAR:
4802         {
4803             char ch = LOWORD(wParam);
4804             WCHAR wch;
4805             MultiByteToWideChar(CP_ACP, 0, &ch, 1, &wch, 1);
4806             wParam = MAKEWPARAM(wch, HIWORD(wParam));
4807         }
4808         break;
4809
4810     default:
4811         return 0;
4812     }
4813
4814     TRACE_(accel)("hAccel %p, hWnd %p, msg->hwnd %p, msg->message %04x, wParam %08x, lParam %08lx\n",
4815                   hAccel,hWnd,msg->hwnd,msg->message,msg->wParam,msg->lParam);
4816     i = 0;
4817     do
4818     {
4819         if (translate_accelerator( hWnd, msg->message, wParam, msg->lParam,
4820                                    lpAccelTbl[i].fVirt, lpAccelTbl[i].key, lpAccelTbl[i].cmd))
4821             return 1;
4822     } while ((lpAccelTbl[i++].fVirt & 0x80) == 0);
4823
4824     return 0;
4825 }
4826
4827 /**********************************************************************
4828  *      TranslateAcceleratorW     (USER32.@)
4829  */
4830 INT WINAPI TranslateAcceleratorW( HWND hWnd, HACCEL hAccel, LPMSG msg )
4831 {
4832     /* YES, Accel16! */
4833     LPACCEL16 lpAccelTbl;
4834     int i;
4835
4836     if (!hWnd || !msg) return 0;
4837
4838     if (!hAccel || !(lpAccelTbl = (LPACCEL16) LockResource16(HACCEL_16(hAccel))))
4839     {
4840         WARN_(accel)("invalid accel handle=%p\n", hAccel);
4841         return 0;
4842     }
4843
4844     switch (msg->message)
4845     {
4846     case WM_KEYDOWN:
4847     case WM_SYSKEYDOWN:
4848     case WM_CHAR:
4849     case WM_SYSCHAR:
4850         break;
4851
4852     default:
4853         return 0;
4854     }
4855
4856     TRACE_(accel)("hAccel %p, hWnd %p, msg->hwnd %p, msg->message %04x, wParam %08x, lParam %08lx\n",
4857                   hAccel,hWnd,msg->hwnd,msg->message,msg->wParam,msg->lParam);
4858     i = 0;
4859     do
4860     {
4861         if (translate_accelerator( hWnd, msg->message, msg->wParam, msg->lParam,
4862                                    lpAccelTbl[i].fVirt, lpAccelTbl[i].key, lpAccelTbl[i].cmd))
4863             return 1;
4864     } while ((lpAccelTbl[i++].fVirt & 0x80) == 0);
4865
4866     return 0;
4867 }