git.oblomov.eu Git - wine/blob - controls/menu.c

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