git.oblomov.eu Git - wine/blob - controls/menu.c

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