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

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