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