git.oblomov.eu Git - wine/blob - dlls/user/menu.c

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