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