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