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

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