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