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  */
   7
   8 /*
   9  * Note: the style MF_MOUSESELECT is used to mark popup items that
  10  * have been selected, i.e. their popup menu is currently displayed.
  11  * This is probably not the meaning this style has in MS-Windows.
  12  */
  13
  14 #include <ctype.h>
  15 #include <stdlib.h>
  16 #include <stdio.h>
  17 #include <string.h>
  18 #include "windows.h"
  19 #include "syscolor.h"
  20 #include "sysmetrics.h"
  21 #include "task.h"
  22 #include "win.h"
  23 #include "heap.h"
  24 #include "menu.h"
  25 #include "module.h"
  26 #include "neexe.h"
  27 #include "user.h"
  28 #include "message.h"
  29 #include "graphics.h"
  30 #include "resource.h"
  31 #include "string32.h"
  32 #include "stddebug.h"
  33 #include "debug.h"
  34
  35 /* Menu item structure */
  36 typedef struct
  37 {
  38     WORD        item_flags;    /* Item flags */
  39     UINT        item_id;       /* Item or popup id */
  40     RECT16      rect;          /* Item area (relative to menu window) */
  41     WORD        xTab;          /* X position of text after Tab */
  42     HBITMAP     hCheckBit;     /* Bitmap for checked item */
  43     HBITMAP     hUnCheckBit;   /* Bitmap for unchecked item */
  44     LPSTR       text;          /* Item text or bitmap handle */
  45 } MENUITEM;
  46
  47 /* Popup menu structure */
  48 typedef struct
  49 {
  50     WORD        wFlags;       /* Menu flags (MF_POPUP, MF_SYSMENU) */
  51     WORD        wMagic;       /* Magic number */
  52     HANDLE      hTaskQ;       /* Task queue for this menu */
  53     WORD        Width;        /* Width of the whole menu */
  54     WORD        Height;       /* Height of the whole menu */
  55     WORD        nItems;       /* Number of items in the menu */
  56     HWND        hWnd;         /* Window containing the menu */
  57     MENUITEM   *items;        /* Array of menu items */
  58     UINT        FocusedItem;  /* Currently focused item */
  59 } POPUPMENU, *LPPOPUPMENU;
  60
  61 #define MENU_MAGIC   0x554d  /* 'MU' */
  62
  63   /* Dimension of the menu bitmaps */
  64 static WORD check_bitmap_width = 0, check_bitmap_height = 0;
  65 static WORD arrow_bitmap_width = 0, arrow_bitmap_height = 0;
  66
  67   /* Flag set by EndMenu() to force an exit from menu tracking */
  68 static BOOL fEndMenuCalled = FALSE;
  69
  70   /* Space between 2 menu bar items */
  71 #define MENU_BAR_ITEMS_SPACE  16
  72
  73   /* Minimum width of a tab character */
  74 #define MENU_TAB_SPACE        8
  75
  76   /* Height of a separator item */
  77 #define SEPARATOR_HEIGHT      5
  78
  79   /* Values for menu->FocusedItem */
  80   /* (other values give the position of the focused item) */
  81 #define NO_SELECTED_ITEM  0xffff
  82 #define SYSMENU_SELECTED  0xfffe  /* Only valid on menu-bars */
  83
  84 #define IS_STRING_ITEM(flags) (!((flags) & (MF_BITMAP | MF_OWNERDRAW | \
  85                              MF_MENUBARBREAK | MF_MENUBREAK | MF_SEPARATOR)))
  86
  87 extern void NC_DrawSysButton(HWND hwnd, HDC hdc, BOOL down);  /* nonclient.c */
  88
  89 static HBITMAP hStdCheck = 0;
  90 static HBITMAP hStdMnArrow = 0;
  91 static HMENU MENU_DefSysMenu = 0;  /* Default system menu */
  92
  93
  94 /* we _can_ use global popup window because there's no way 2 menues can
  95  * be tracked at the same time.
  96  */
  97
  98 static WND* pTopPWnd   = 0;
  99 static UINT uSubPWndLevel = 0;
 100
 101
 102 /**********************************************************************
 103  *           MENU_CopySysMenu
 104  *
 105  * Load a copy of the system menu.
 106  */
 107 static HMENU MENU_CopySysMenu(void)
 108 {
 109     HMENU hMenu;
 110     HGLOBAL handle;
 111     POPUPMENU *menu;
 112
 113     if (!(handle = SYSRES_LoadResource( SYSRES_MENU_SYSMENU ))) return 0;
 114     hMenu = LoadMenuIndirect16( GlobalLock16( handle ) );
 115     SYSRES_FreeResource( handle );
 116     if (!hMenu)
 117     {
 118         dprintf_menu(stddeb,"No SYSMENU\n");
 119         return 0;
 120     }
 121     menu = (POPUPMENU*) USER_HEAP_LIN_ADDR(hMenu);
 122     menu->wFlags |= MF_SYSMENU | MF_POPUP;
 123     dprintf_menu(stddeb,"CopySysMenu hMenu=%04x !\n", hMenu);
 124     return hMenu;
 125 }
 126
 127
 128 /***********************************************************************
 129  *           MENU_Init
 130  *
 131  * Menus initialisation.
 132  */
 133 BOOL MENU_Init()
 134 {
 135     BITMAP bm;
 136
 137       /* Load bitmaps */
 138
 139     if (!(hStdCheck = LoadBitmap( 0, MAKEINTRESOURCE(OBM_CHECK) )))
 140         return FALSE;
 141     GetObject( hStdCheck, sizeof(BITMAP), (LPSTR)&bm );
 142     check_bitmap_width = bm.bmWidth;
 143     check_bitmap_height = bm.bmHeight;
 144     if (!(hStdMnArrow = LoadBitmap( 0, MAKEINTRESOURCE(OBM_MNARROW) )))
 145         return FALSE;
 146     GetObject( hStdMnArrow, sizeof(BITMAP), (LPSTR)&bm );
 147     arrow_bitmap_width = bm.bmWidth;
 148     arrow_bitmap_height = bm.bmHeight;
 149
 150     if (!(MENU_DefSysMenu = MENU_CopySysMenu()))
 151     {
 152         fprintf( stderr, "Unable to create default system menu\n" );
 153         return FALSE;
 154     }
 155     return TRUE;
 156 }
 157
 158
 159 /***********************************************************************
 160  *           MENU_GetDefSysMenu
 161  *
 162  * Return the default system menu.
 163  */
 164 HMENU MENU_GetDefSysMenu(void)
 165 {
 166     return MENU_DefSysMenu;
 167 }
 168
 169
 170 /***********************************************************************
 171  *           MENU_HasSysMenu
 172  *
 173  * Check whether the window owning the menu bar has a system menu.
 174  */
 175 static BOOL MENU_HasSysMenu( POPUPMENU *menu )
 176 {
 177     WND *wndPtr;
 178
 179     if (menu->wFlags & MF_POPUP) return FALSE;
 180     if (!(wndPtr = WIN_FindWndPtr( menu->hWnd ))) return FALSE;
 181     return (wndPtr->dwStyle & WS_SYSMENU) != 0;
 182 }
 183
 184
 185 /***********************************************************************
 186  *           MENU_IsInSysMenu
 187  *
 188  * Check whether the point (in screen coords) is in the system menu
 189  * of the window owning the given menu.
 190  */
 191 static BOOL MENU_IsInSysMenu( POPUPMENU *menu, POINT16 pt )
 192 {
 193     WND *wndPtr;
 194
 195     if (menu->wFlags & MF_POPUP) return FALSE;
 196     if (!(wndPtr = WIN_FindWndPtr( menu->hWnd ))) return FALSE;
 197     if (!(wndPtr->dwStyle & WS_SYSMENU)) return FALSE;
 198     if ((pt.x < wndPtr->rectClient.left) ||
 199         (pt.x >= wndPtr->rectClient.left+SYSMETRICS_CXSIZE+SYSMETRICS_CXBORDER))
 200         return FALSE;
 201     if ((pt.y >= wndPtr->rectClient.top - menu->Height) ||
 202         (pt.y < wndPtr->rectClient.top - menu->Height -
 203                       SYSMETRICS_CYSIZE - SYSMETRICS_CYBORDER)) return FALSE;
 204     return TRUE;
 205 }
 206
 207
 208 /***********************************************************************
 209  *           MENU_FindItem
 210  *
 211  * Find a menu item. Return a pointer on the item, and modifies *hmenu
 212  * in case the item was in a sub-menu.
 213  */
 214 static MENUITEM *MENU_FindItem( HMENU *hmenu, UINT *nPos, UINT wFlags )
 215 {
 216     POPUPMENU *menu;
 217     int i;
 218
 219     if (!(menu = (POPUPMENU *) USER_HEAP_LIN_ADDR(*hmenu))) return NULL;
 220     if (wFlags & MF_BYPOSITION)
 221     {
 222         if (*nPos >= menu->nItems) return NULL;
 223         return &menu->items[*nPos];
 224     }
 225     else
 226     {
 227         MENUITEM *item = menu->items;
 228         for (i = 0; i < menu->nItems; i++, item++)
 229         {
 230             if (item->item_id == *nPos)
 231             {
 232                 *nPos = i;
 233                 return item;
 234             }
 235             else if (item->item_flags & MF_POPUP)
 236             {
 237                 HMENU hsubmenu = (HMENU)item->item_id;
 238                 MENUITEM *subitem = MENU_FindItem( &hsubmenu, nPos, wFlags );
 239                 if (subitem)
 240                 {
 241                     *hmenu = hsubmenu;
 242                     return subitem;
 243                 }
 244             }
 245         }
 246     }
 247     return NULL;
 248 }
 249
 250
 251 /***********************************************************************
 252  *           MENU_FindItemByCoords
 253  *
 254  * Find the item at the specified coordinates (screen coords).
 255  */
 256 static MENUITEM *MENU_FindItemByCoords( POPUPMENU *menu, int x, int y, UINT *pos )
 257 {
 258     MENUITEM *item;
 259     WND *wndPtr;
 260     int i;
 261
 262     if (!(wndPtr = WIN_FindWndPtr( menu->hWnd ))) return NULL;
 263     x -= wndPtr->rectWindow.left;
 264     y -= wndPtr->rectWindow.top;
 265     item = menu->items;
 266     for (i = 0; i < menu->nItems; i++, item++)
 267     {
 268         if ((x >= item->rect.left) && (x < item->rect.right) &&
 269             (y >= item->rect.top) && (y < item->rect.bottom))
 270         {
 271             if (pos) *pos = i;
 272             return item;
 273         }
 274     }
 275     return NULL;
 276 }
 277
 278
 279 /***********************************************************************
 280  *           MENU_FindItemByKey
 281  *
 282  * Find the menu item selected by a key press.
 283  * Return item id, -1 if none, -2 if we should close the menu.
 284  */
 285 static UINT MENU_FindItemByKey( HWND hwndOwner, HMENU hmenu, UINT key )
 286 {
 287     POPUPMENU *menu;
 288     MENUITEM *item;
 289     int i;
 290     LONG menuchar;
 291
 292     if (!IsMenu( hmenu )) hmenu = WIN_FindWndPtr(hwndOwner)->hSysMenu;
 293     if (!hmenu) return -1;
 294
 295     menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu );
 296     item = menu->items;
 297     key = toupper(key);
 298     for (i = 0; i < menu->nItems; i++, item++)
 299     {
 300         if (IS_STRING_ITEM(item->item_flags))
 301         {
 302             char *p = strchr( item->text, '&' );
 303             if (p && (p[1] != '&') && (toupper(p[1]) == key)) return i;
 304         }
 305     }
 306 #ifdef WINELIB32
 307     menuchar = SendMessage32A( hwndOwner, WM_MENUCHAR,
 308                                MAKEWPARAM(key,menu->wFlags), hmenu );
 309 #else
 310     menuchar = SendMessage16( hwndOwner, WM_MENUCHAR, key,
 311                               MAKELONG( menu->wFlags, hmenu ) );
 312 #endif
 313     if (HIWORD(menuchar) == 2) return LOWORD(menuchar);
 314     if (HIWORD(menuchar) == 1) return -2;
 315     return -1;
 316 }
 317
 318
 319 /***********************************************************************
 320  *           MENU_CalcItemSize
 321  *
 322  * Calculate the size of the menu item and store it in lpitem->rect.
 323  */
 324 static void MENU_CalcItemSize( HDC hdc, MENUITEM *lpitem, HWND hwndOwner,
 325                                int orgX, int orgY, BOOL menuBar )
 326 {
 327     DWORD dwSize;
 328     char *p;
 329
 330     SetRect16( &lpitem->rect, orgX, orgY, orgX, orgY );
 331
 332     if (lpitem->item_flags & MF_OWNERDRAW)
 333     {
 334         MEASUREITEMSTRUCT *mis;
 335         if (!(mis = SEGPTR_NEW(MEASUREITEMSTRUCT))) return;
 336         mis->CtlType    = ODT_MENU;
 337         mis->itemID     = lpitem->item_id;
 338         mis->itemData   = (DWORD)lpitem->text;
 339         mis->itemHeight = 16;
 340         mis->itemWidth  = 30;
 341         SendMessage16( hwndOwner, WM_MEASUREITEM, 0, (LPARAM)SEGPTR_GET(mis) );
 342         lpitem->rect.bottom += mis->itemHeight;
 343         lpitem->rect.right  += mis->itemWidth;
 344         dprintf_menu( stddeb, "DrawMenuItem: MeasureItem %04x %dx%d!\n",
 345                       lpitem->item_id, mis->itemWidth, mis->itemHeight );
 346         SEGPTR_FREE(mis);
 347         return;
 348     }
 349
 350     if (lpitem->item_flags & MF_SEPARATOR)
 351     {
 352         lpitem->rect.bottom += SEPARATOR_HEIGHT;
 353         return;
 354     }
 355
 356     if (!menuBar)
 357     {
 358         lpitem->rect.right += 2 * check_bitmap_width;
 359         if (lpitem->item_flags & MF_POPUP)
 360             lpitem->rect.right += arrow_bitmap_width;
 361     }
 362
 363     if (lpitem->item_flags & MF_BITMAP)
 364     {
 365         BITMAP bm;
 366         if (GetObject( (HBITMAP16)(UINT32)lpitem->text,
 367                        sizeof(BITMAP), (LPSTR)&bm ))
 368         {
 369             lpitem->rect.right  += bm.bmWidth;
 370             lpitem->rect.bottom += bm.bmHeight;
 371         }
 372         return;
 373     }
 374
 375     /* If we get here, then it must be a text item */
 376
 377     if (IS_STRING_ITEM( lpitem->item_flags ))
 378     {
 379         dwSize = GetTextExtent( hdc, lpitem->text, strlen(lpitem->text) );
 380         lpitem->rect.right  += LOWORD(dwSize);
 381         lpitem->rect.bottom += MAX( HIWORD(dwSize), SYSMETRICS_CYMENU );
 382         lpitem->xTab = 0;
 383
 384         if (menuBar) lpitem->rect.right += MENU_BAR_ITEMS_SPACE;
 385         else if ((p = strchr( lpitem->text, '\t' )) != NULL)
 386         {
 387             /* Item contains a tab (only meaningful in popup menus) */
 388             lpitem->xTab = check_bitmap_width + MENU_TAB_SPACE +
 389                 LOWORD( GetTextExtent( hdc, lpitem->text,
 390                                        (int)(p - lpitem->text) ));
 391             lpitem->rect.right += MENU_TAB_SPACE;
 392         }
 393         else
 394         {
 395             if (strchr( lpitem->text, '\b' ))
 396                 lpitem->rect.right += MENU_TAB_SPACE;
 397             lpitem->xTab = lpitem->rect.right - check_bitmap_width
 398                            - arrow_bitmap_width;
 399         }
 400     }
 401 }
 402
 403
 404 /***********************************************************************
 405  *           MENU_PopupMenuCalcSize
 406  *
 407  * Calculate the size of a popup menu.
 408  */
 409 static void MENU_PopupMenuCalcSize( LPPOPUPMENU lppop, HWND hwndOwner )
 410 {
 411     MENUITEM *lpitem;
 412     HDC hdc;
 413     int start, i;
 414     int orgX, orgY, maxX, maxTab, maxTabWidth;
 415
 416     lppop->Width = lppop->Height = 0;
 417     if (lppop->nItems == 0) return;
 418     hdc = GetDC( 0 );
 419     maxX = start = 0;
 420     while (start < lppop->nItems)
 421     {
 422         lpitem = &lppop->items[start];
 423         orgX = maxX;
 424         orgY = 0;
 425         maxTab = maxTabWidth = 0;
 426
 427           /* Parse items until column break or end of menu */
 428         for (i = start; i < lppop->nItems; i++, lpitem++)
 429         {
 430             if ((i != start) &&
 431                 (lpitem->item_flags & (MF_MENUBREAK | MF_MENUBARBREAK))) break;
 432             MENU_CalcItemSize( hdc, lpitem, hwndOwner, orgX, orgY, FALSE );
 433             if (lpitem->item_flags & MF_MENUBARBREAK) orgX++;
 434             maxX = MAX( maxX, lpitem->rect.right );
 435             orgY = lpitem->rect.bottom;
 436             if (IS_STRING_ITEM(lpitem->item_flags) && lpitem->xTab)
 437             {
 438                 maxTab = MAX( maxTab, lpitem->xTab );
 439                 maxTabWidth = MAX(maxTabWidth,lpitem->rect.right-lpitem->xTab);
 440             }
 441         }
 442
 443           /* Finish the column (set all items to the largest width found) */
 444         maxX = MAX( maxX, maxTab + maxTabWidth );
 445         for (lpitem = &lppop->items[start]; start < i; start++, lpitem++)
 446         {
 447             lpitem->rect.right = maxX;
 448             if (IS_STRING_ITEM(lpitem->item_flags) && lpitem->xTab)
 449                 lpitem->xTab = maxTab;
 450         }
 451         lppop->Height = MAX( lppop->Height, orgY );
 452     }
 453
 454     lppop->Width  = maxX;
 455     ReleaseDC( 0, hdc );
 456 }
 457
 458
 459 /***********************************************************************
 460  *           MENU_MenuBarCalcSize
 461  *
 462  * Calculate the size of the menu bar.
 463  */
 464 static void MENU_MenuBarCalcSize( HDC hdc, LPRECT16 lprect, LPPOPUPMENU lppop,
 465                                   HWND hwndOwner )
 466 {
 467     MENUITEM *lpitem;
 468     int start, i, orgX, orgY, maxY, helpPos;
 469
 470     if ((lprect == NULL) || (lppop == NULL)) return;
 471     if (lppop->nItems == 0) return;
 472     dprintf_menu(stddeb,"MENU_MenuBarCalcSize left=%d top=%d right=%d bottom=%d\n",
 473                  lprect->left, lprect->top, lprect->right, lprect->bottom);
 474     lppop->Width  = lprect->right - lprect->left;
 475     lppop->Height = 0;
 476     maxY = lprect->top;
 477     start = 0;
 478     helpPos = -1;
 479     while (start < lppop->nItems)
 480     {
 481         lpitem = &lppop->items[start];
 482         orgX = lprect->left;
 483         orgY = maxY;
 484
 485           /* Parse items until line break or end of menu */
 486         for (i = start; i < lppop->nItems; i++, lpitem++)
 487         {
 488             if ((helpPos == -1) && (lpitem->item_flags & MF_HELP)) helpPos = i;
 489             if ((i != start) &&
 490                 (lpitem->item_flags & (MF_MENUBREAK | MF_MENUBARBREAK))) break;
 491             MENU_CalcItemSize( hdc, lpitem, hwndOwner, orgX, orgY, TRUE );
 492             if (lpitem->rect.right > lprect->right)
 493             {
 494                 if (i != start) break;
 495                 else lpitem->rect.right = lprect->right;
 496             }
 497             maxY = MAX( maxY, lpitem->rect.bottom );
 498             orgX = lpitem->rect.right;
 499         }
 500
 501           /* Finish the line (set all items to the largest height found) */
 502         while (start < i) lppop->items[start++].rect.bottom = maxY;
 503     }
 504
 505     lprect->bottom = maxY;
 506     lppop->Height = lprect->bottom - lprect->top;
 507
 508       /* Flush right all items between the MF_HELP and the last item */
 509       /* (if several lines, only move the last line) */
 510     if (helpPos != -1)
 511     {
 512         lpitem = &lppop->items[lppop->nItems-1];
 513         orgY = lpitem->rect.top;
 514         orgX = lprect->right;
 515         for (i = lppop->nItems - 1; i >= helpPos; i--, lpitem--)
 516         {
 517             if (lpitem->rect.top != orgY) break;    /* Other line */
 518             if (lpitem->rect.right >= orgX) break;  /* Too far right already */
 519             lpitem->rect.left += orgX - lpitem->rect.right;
 520             lpitem->rect.right = orgX;
 521             orgX = lpitem->rect.left;
 522         }
 523     }
 524 }
 525
 526
 527 /***********************************************************************
 528  *           MENU_DrawMenuItem
 529  *
 530  * Draw a single menu item.
 531  */
 532 static void MENU_DrawMenuItem( HWND hwnd, HDC hdc, MENUITEM *lpitem,
 533                                UINT height, BOOL menuBar )
 534 {
 535     RECT16 rect;
 536
 537     if (lpitem->item_flags & MF_OWNERDRAW)
 538     {
 539         DRAWITEMSTRUCT32 dis;
 540
 541         dprintf_menu( stddeb, "DrawMenuItem: Ownerdraw!\n" );
 542         dis.CtlType   = ODT_MENU;
 543         dis.itemID    = lpitem->item_id;
 544         dis.itemData  = (DWORD)lpitem->text;
 545         dis.itemState = 0;
 546         if (lpitem->item_flags & MF_CHECKED) dis.itemState |= ODS_CHECKED;
 547         if (lpitem->item_flags & MF_GRAYED)  dis.itemState |= ODS_GRAYED;
 548         if (lpitem->item_flags & MF_HILITE)  dis.itemState |= ODS_SELECTED;
 549         dis.itemAction = ODA_DRAWENTIRE | ODA_SELECT | ODA_FOCUS;
 550         dis.hwndItem   = hwnd;
 551         dis.hDC        = hdc;
 552         CONV_RECT16TO32( &lpitem->rect, &dis.rcItem );
 553         SendMessage32A( hwnd, WM_DRAWITEM, 0, (LPARAM)&dis );
 554         return;
 555     }
 556
 557     if (menuBar && (lpitem->item_flags & MF_SEPARATOR)) return;
 558     rect = lpitem->rect;
 559
 560       /* Draw the background */
 561
 562     if (lpitem->item_flags & MF_HILITE)
 563         FillRect16( hdc, &rect, sysColorObjects.hbrushHighlight );
 564     else FillRect16( hdc, &rect, sysColorObjects.hbrushMenu );
 565     SetBkMode( hdc, TRANSPARENT );
 566
 567       /* Draw the separator bar (if any) */
 568
 569     if (!menuBar && (lpitem->item_flags & MF_MENUBARBREAK))
 570     {
 571         SelectObject( hdc, sysColorObjects.hpenWindowFrame );
 572         MoveTo( hdc, rect.left, 0 );
 573         LineTo( hdc, rect.left, height );
 574     }
 575     if (lpitem->item_flags & MF_SEPARATOR)
 576     {
 577         SelectObject( hdc, sysColorObjects.hpenWindowFrame );
 578         MoveTo( hdc, rect.left, rect.top + SEPARATOR_HEIGHT/2 );
 579         LineTo( hdc, rect.right, rect.top + SEPARATOR_HEIGHT/2 );
 580         return;
 581     }
 582
 583       /* Setup colors */
 584
 585     if (lpitem->item_flags & MF_HILITE)
 586     {
 587         if (lpitem->item_flags & MF_GRAYED)
 588             SetTextColor( hdc, GetSysColor( COLOR_GRAYTEXT ) );
 589         else
 590             SetTextColor( hdc, GetSysColor( COLOR_HIGHLIGHTTEXT ) );
 591         SetBkColor( hdc, GetSysColor( COLOR_HIGHLIGHT ) );
 592     }
 593     else
 594     {
 595         if (lpitem->item_flags & MF_GRAYED)
 596             SetTextColor( hdc, GetSysColor( COLOR_GRAYTEXT ) );
 597         else
 598             SetTextColor( hdc, GetSysColor( COLOR_MENUTEXT ) );
 599         SetBkColor( hdc, GetSysColor( COLOR_MENU ) );
 600     }
 601
 602     if (!menuBar)
 603     {
 604           /* Draw the check mark */
 605
 606         if (lpitem->item_flags & MF_CHECKED)
 607         {
 608             GRAPH_DrawBitmap(hdc, lpitem->hCheckBit ? lpitem->hCheckBit :
 609                              hStdCheck, rect.left,
 610                              (rect.top+rect.bottom-check_bitmap_height) / 2,
 611                              0, 0, check_bitmap_width, check_bitmap_height );
 612         }
 613         else if (lpitem->hUnCheckBit != 0)  /* Not checked */
 614         {
 615             GRAPH_DrawBitmap(hdc, lpitem->hUnCheckBit, rect.left,
 616                              (rect.top+rect.bottom-check_bitmap_height) / 2,
 617                              0, 0, check_bitmap_width, check_bitmap_height );
 618         }
 619
 620           /* Draw the popup-menu arrow */
 621
 622         if (lpitem->item_flags & MF_POPUP)
 623         {
 624             GRAPH_DrawBitmap( hdc, hStdMnArrow,
 625                               rect.right-arrow_bitmap_width-1,
 626                               (rect.top+rect.bottom-arrow_bitmap_height) / 2,
 627                               0, 0, arrow_bitmap_width, arrow_bitmap_height );
 628         }
 629
 630         rect.left += check_bitmap_width;
 631         rect.right -= arrow_bitmap_width;
 632     }
 633
 634       /* Draw the item text or bitmap */
 635
 636     if (lpitem->item_flags & MF_BITMAP)
 637     {
 638         GRAPH_DrawBitmap( hdc, (HBITMAP16)(UINT32)lpitem->text,
 639                           rect.left, rect.top, 0, 0,
 640                           rect.right-rect.left, rect.bottom-rect.top );
 641         return;
 642     }
 643     /* No bitmap - process text if present */
 644     else if (IS_STRING_ITEM(lpitem->item_flags))
 645     {
 646         register int i;
 647
 648         if (menuBar)
 649         {
 650             rect.left += MENU_BAR_ITEMS_SPACE / 2;
 651             rect.right -= MENU_BAR_ITEMS_SPACE / 2;
 652             i = strlen( lpitem->text );
 653         }
 654         else
 655         {
 656             for (i = 0; lpitem->text[i]; i++)
 657                 if ((lpitem->text[i] == '\t') || (lpitem->text[i] == '\b'))
 658                     break;
 659         }
 660
 661         DrawText16( hdc, lpitem->text, i, &rect,
 662                     DT_LEFT | DT_VCENTER | DT_SINGLELINE );
 663
 664         if (lpitem->text[i])  /* There's a tab or flush-right char */
 665         {
 666             if (lpitem->text[i] == '\t')
 667             {
 668                 rect.left = lpitem->xTab;
 669                 DrawText16( hdc, lpitem->text + i + 1, -1, &rect,
 670                             DT_LEFT | DT_VCENTER | DT_SINGLELINE );
 671             }
 672             else DrawText16( hdc, lpitem->text + i + 1, -1, &rect,
 673                              DT_RIGHT | DT_VCENTER | DT_SINGLELINE );
 674         }
 675     }
 676 }
 677
 678
 679 /***********************************************************************
 680  *           MENU_DrawPopupMenu
 681  *
 682  * Paint a popup menu.
 683  */
 684 static void MENU_DrawPopupMenu( HWND hwnd, HDC hdc, HMENU hmenu )
 685 {
 686     POPUPMENU *menu;
 687     MENUITEM *item;
 688     RECT16 rect;
 689     int i;
 690
 691     GetClientRect16( hwnd, &rect );
 692     FillRect16( hdc, &rect, sysColorObjects.hbrushMenu );
 693     menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu );
 694     if (!menu || !menu->nItems) return;
 695     for (i = menu->nItems, item = menu->items; i > 0; i--, item++)
 696         MENU_DrawMenuItem( hwnd, hdc, item, menu->Height, FALSE );
 697 }
 698
 699
 700 /***********************************************************************
 701  *           MENU_DrawMenuBar
 702  *
 703  * Paint a menu bar. Returns the height of the menu bar.
 704  */
 705 UINT MENU_DrawMenuBar(HDC hDC, LPRECT16 lprect, HWND hwnd, BOOL suppress_draw)
 706 {
 707     LPPOPUPMENU lppop;
 708     int i;
 709     WND *wndPtr = WIN_FindWndPtr( hwnd );
 710
 711     lppop = (LPPOPUPMENU) USER_HEAP_LIN_ADDR( (HMENU)wndPtr->wIDmenu );
 712     if (lppop == NULL || lprect == NULL) return SYSMETRICS_CYMENU;
 713     dprintf_menu(stddeb,"MENU_DrawMenuBar(%04x, %p, %p); !\n",
 714                  hDC, lprect, lppop);
 715     if (lppop->Height == 0) MENU_MenuBarCalcSize(hDC, lprect, lppop, hwnd);
 716     lprect->bottom = lprect->top + lppop->Height;
 717     if (suppress_draw) return lppop->Height;
 718
 719     FillRect16(hDC, lprect, sysColorObjects.hbrushMenu );
 720     SelectObject( hDC, sysColorObjects.hpenWindowFrame );
 721     MoveTo( hDC, lprect->left, lprect->bottom );
 722     LineTo( hDC, lprect->right, lprect->bottom );
 723
 724     if (lppop->nItems == 0) return SYSMETRICS_CYMENU;
 725     for (i = 0; i < lppop->nItems; i++)
 726     {
 727         MENU_DrawMenuItem( hwnd, hDC, &lppop->items[i], lppop->Height, TRUE );
 728     }
 729     return lppop->Height;
 730 }
 731
 732
 733 /***********************************************************************
 734  *           MENU_SwitchTPWndTo
 735  */
 736 BOOL MENU_SwitchTPWndTo( HTASK hTask)
 737 {
 738   /* This is supposed to be called when popup is hidden */
 739
 740   TDB* task = (TDB*)GlobalLock16(hTask);
 741
 742   if( !task ) return 0;
 743
 744   /* if this task got as far as menu tracking it must have a queue */
 745
 746   pTopPWnd->hInstance = task->hInstance;
 747   pTopPWnd->hmemTaskQ = task->hQueue;
 748   return 1;
 749 }
 750
 751 /***********************************************************************
 752  *           MENU_ShowPopup
 753  *
 754  * Display a popup menu.
 755  */
 756 static BOOL MENU_ShowPopup(HWND hwndOwner, HMENU hmenu, UINT id, int x, int y)
 757 {
 758     POPUPMENU   *menu;
 759     WND         *wndPtr = NULL;
 760     BOOL         skip_init = 0;
 761
 762     if (!(menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu ))) return FALSE;
 763     if (menu->FocusedItem != NO_SELECTED_ITEM)
 764     {
 765         menu->items[menu->FocusedItem].item_flags &= ~(MF_HILITE|MF_MOUSESELECT);
 766         menu->FocusedItem = NO_SELECTED_ITEM;
 767     }
 768     SendMessage16( hwndOwner, WM_INITMENUPOPUP, (WPARAM)hmenu,
 769                  MAKELONG( id, (menu->wFlags & MF_SYSMENU) ? 1 : 0 ));
 770     MENU_PopupMenuCalcSize( menu, hwndOwner );
 771
 772     wndPtr = WIN_FindWndPtr( hwndOwner );
 773     if (!wndPtr) return FALSE;
 774
 775     if (!pTopPWnd)
 776     {
 777         pTopPWnd = WIN_FindWndPtr(CreateWindow16( POPUPMENU_CLASS_ATOM, NULL,
 778                                           WS_POPUP | WS_BORDER, x, y,
 779                                           menu->Width + 2*SYSMETRICS_CXBORDER,
 780                                           menu->Height + 2*SYSMETRICS_CYBORDER,
 781                                           0, 0, wndPtr->hInstance,
 782                                           (LPVOID)(HMENU32)hmenu ));
 783         if (!pTopPWnd) return FALSE;
 784         skip_init = TRUE;
 785     }
 786
 787     if( uSubPWndLevel )
 788     {
 789         /* create new window for the submenu */
 790         HWND  hWnd = CreateWindow16( POPUPMENU_CLASS_ATOM, NULL,
 791                                    WS_POPUP | WS_BORDER, x, y,
 792                                    menu->Width + 2*SYSMETRICS_CXBORDER,
 793                                    menu->Height + 2*SYSMETRICS_CYBORDER,
 794                                    menu->hWnd, 0, wndPtr->hInstance,
 795                                    (LPVOID)(HMENU32)hmenu );
 796         if( !hWnd ) return FALSE;
 797         menu->hWnd = hWnd;
 798     }
 799     else
 800     {
 801         if( !skip_init )
 802           {
 803             MENU_SwitchTPWndTo(GetCurrentTask());
 804             SendMessage16( pTopPWnd->hwndSelf, WM_USER, (WPARAM)hmenu, 0L);
 805           }
 806         menu->hWnd = pTopPWnd->hwndSelf;
 807     }
 808
 809     uSubPWndLevel++;
 810
 811     SetWindowPos(menu->hWnd, 0, x, y, menu->Width + 2*SYSMETRICS_CXBORDER,
 812                                       menu->Height + 2*SYSMETRICS_CYBORDER,
 813                                       SWP_NOACTIVATE | SWP_NOZORDER );
 814
 815       /* Display the window */
 816
 817     SetWindowPos( menu->hWnd, HWND_TOP, 0, 0, 0, 0,
 818                   SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE );
 819     UpdateWindow( menu->hWnd );
 820     return TRUE;
 821 }
 822
 823
 824 /***********************************************************************
 825  *           MENU_SelectItem
 826  */
 827 static void MENU_SelectItem( HWND hwndOwner, HMENU hmenu, UINT wIndex,
 828                              BOOL sendMenuSelect )
 829 {
 830     LPPOPUPMENU lppop;
 831     HDC hdc;
 832
 833     lppop = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu );
 834     if (!lppop->nItems) return;
 835     if ((wIndex != NO_SELECTED_ITEM) &&
 836         (wIndex != SYSMENU_SELECTED) &&
 837         (lppop->items[wIndex].item_flags & MF_SEPARATOR))
 838         wIndex = NO_SELECTED_ITEM;
 839     if (lppop->FocusedItem == wIndex) return;
 840     if (lppop->wFlags & MF_POPUP) hdc = GetDC( lppop->hWnd );
 841     else hdc = GetDCEx( lppop->hWnd, 0, DCX_CACHE | DCX_WINDOW);
 842
 843       /* Clear previous highlighted item */
 844     if (lppop->FocusedItem != NO_SELECTED_ITEM)
 845     {
 846         if (lppop->FocusedItem == SYSMENU_SELECTED)
 847             NC_DrawSysButton( lppop->hWnd, hdc, FALSE );
 848         else
 849         {
 850             lppop->items[lppop->FocusedItem].item_flags &=~(MF_HILITE|MF_MOUSESELECT);
 851             MENU_DrawMenuItem(lppop->hWnd,hdc,&lppop->items[lppop->FocusedItem],
 852                               lppop->Height, !(lppop->wFlags & MF_POPUP) );
 853         }
 854     }
 855
 856       /* Highlight new item (if any) */
 857     lppop->FocusedItem = wIndex;
 858     if (lppop->FocusedItem != NO_SELECTED_ITEM)
 859     {
 860         if (lppop->FocusedItem == SYSMENU_SELECTED)
 861         {
 862             NC_DrawSysButton( lppop->hWnd, hdc, TRUE );
 863             if (sendMenuSelect)
 864 #ifdef WINELIB32
 865 /* FIX: LostInfo */
 866                 SendMessage32A( hwndOwner, WM_MENUSELECT,
 867                              MAKEWPARAM( WIN_FindWndPtr(lppop->hWnd)->hSysMenu,
 868                                          lppop->wFlags | MF_MOUSESELECT ),
 869                              (LPARAM)hmenu );
 870 #else
 871                 SendMessage16( hwndOwner, WM_MENUSELECT,
 872                              WIN_FindWndPtr(lppop->hWnd)->hSysMenu,
 873                              MAKELONG(lppop->wFlags | MF_MOUSESELECT, hmenu));
 874 #endif
 875         }
 876         else
 877         {
 878             lppop->items[lppop->FocusedItem].item_flags |= MF_HILITE;
 879             MENU_DrawMenuItem( lppop->hWnd, hdc, &lppop->items[lppop->FocusedItem],
 880                                lppop->Height, !(lppop->wFlags & MF_POPUP) );
 881             if (sendMenuSelect)
 882 #ifdef WINELIB32
 883                 SendMessage32A( hwndOwner, WM_MENUSELECT,
 884                              MAKEWPARAM( lppop->items[lppop->FocusedItem].item_id,
 885                                          lppop->items[lppop->FocusedItem].item_flags|
 886                                          MF_MOUSESELECT ),
 887                              (LPARAM) hmenu );
 888 #else
 889                 SendMessage16( hwndOwner, WM_MENUSELECT,
 890                              lppop->items[lppop->FocusedItem].item_id,
 891                              MAKELONG( lppop->items[lppop->FocusedItem].item_flags | MF_MOUSESELECT, hmenu));
 892 #endif
 893         }
 894     }
 895 #ifdef WINELIB32
 896 /* FIX: Lost Info */
 897     else if (sendMenuSelect)
 898         SendMessage32A( hwndOwner, WM_MENUSELECT,
 899                      MAKEWPARAM( (DWORD)hmenu, lppop->wFlags | MF_MOUSESELECT),
 900                      hmenu );
 901 #else
 902     else if (sendMenuSelect)
 903         SendMessage16( hwndOwner, WM_MENUSELECT, hmenu,
 904                      MAKELONG( lppop->wFlags | MF_MOUSESELECT, hmenu ) );
 905 #endif
 906
 907     ReleaseDC( lppop->hWnd, hdc );
 908 }
 909
 910
 911 /***********************************************************************
 912  *           MENU_SelectNextItem
 913  */
 914 static void MENU_SelectNextItem( HWND hwndOwner, HMENU hmenu )
 915 {
 916     int i;
 917     POPUPMENU *menu;
 918
 919     menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu );
 920     if (!menu->items) return;
 921     if ((menu->FocusedItem != NO_SELECTED_ITEM) &&
 922         (menu->FocusedItem != SYSMENU_SELECTED))
 923     {
 924         for (i = menu->FocusedItem+1; i < menu->nItems; i++)
 925         {
 926             if (!(menu->items[i].item_flags & MF_SEPARATOR))
 927             {
 928                 MENU_SelectItem( hwndOwner, hmenu, i, TRUE );
 929                 return;
 930             }
 931         }
 932         if (MENU_HasSysMenu( menu ))
 933         {
 934             MENU_SelectItem( hwndOwner, hmenu, SYSMENU_SELECTED, TRUE );
 935             return;
 936         }
 937     }
 938     for (i = 0; i < menu->nItems; i++)
 939     {
 940         if (!(menu->items[i].item_flags & MF_SEPARATOR))
 941         {
 942             MENU_SelectItem( hwndOwner, hmenu, i, TRUE );
 943             return;
 944         }
 945     }
 946     if (MENU_HasSysMenu( menu ))
 947         MENU_SelectItem( hwndOwner, hmenu, SYSMENU_SELECTED, TRUE );
 948 }
 949
 950
 951 /***********************************************************************
 952  *           MENU_SelectPrevItem
 953  */
 954 static void MENU_SelectPrevItem( HWND hwndOwner, HMENU hmenu )
 955 {
 956     int i;
 957     POPUPMENU *menu;
 958
 959     menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu );
 960     if (!menu->items) return;
 961     if ((menu->FocusedItem != NO_SELECTED_ITEM) &&
 962         (menu->FocusedItem != SYSMENU_SELECTED))
 963     {
 964         for (i = menu->FocusedItem - 1; i >= 0; i--)
 965         {
 966             if (!(menu->items[i].item_flags & MF_SEPARATOR))
 967             {
 968                 MENU_SelectItem( hwndOwner, hmenu, i, TRUE );
 969                 return;
 970             }
 971         }
 972         if (MENU_HasSysMenu( menu ))
 973         {
 974             MENU_SelectItem( hwndOwner, hmenu, SYSMENU_SELECTED, TRUE );
 975             return;
 976         }
 977     }
 978     for (i = menu->nItems - 1; i > 0; i--)
 979     {
 980         if (!(menu->items[i].item_flags & MF_SEPARATOR))
 981         {
 982             MENU_SelectItem( hwndOwner, hmenu, i, TRUE );
 983             return;
 984         }
 985     }
 986     if (MENU_HasSysMenu( menu ))
 987         MENU_SelectItem( hwndOwner, hmenu, SYSMENU_SELECTED, TRUE );
 988 }
 989
 990
 991 /**********************************************************************
 992  *         MENU_SetItemData
 993  *
 994  * Set an item flags, id and text ptr.
 995  */
 996 static BOOL MENU_SetItemData( MENUITEM *item, UINT flags, UINT id, LPCSTR str )
 997 {
 998     LPSTR prevText = IS_STRING_ITEM(item->item_flags) ? item->text : NULL;
 999
1000     if (IS_STRING_ITEM(flags))
1001     {
1002         if (!str)
1003         {
1004             flags |= MF_SEPARATOR;
1005             item->text = NULL;
1006         }
1007         else
1008         {
1009             LPSTR text;
1010             /* Item beginning with a backspace is a help item */
1011             if (*str == '\b')
1012             {
1013                 flags |= MF_HELP;
1014                 str++;
1015             }
1016             if (!(text = HEAP_strdupA( SystemHeap, 0, str ))) return FALSE;
1017             item->text = text;
1018         }
1019     }
1020     else if ((flags & MF_BITMAP) || (flags & MF_OWNERDRAW))
1021         item->text = (LPSTR)str;
1022     else item->text = NULL;
1023
1024     item->item_flags = flags & ~(MF_HILITE | MF_MOUSESELECT);
1025     item->item_id    = id;
1026     SetRectEmpty16( &item->rect );
1027     if (prevText) HeapFree( SystemHeap, 0, prevText );
1028     return TRUE;
1029 }
1030
1031
1032 /**********************************************************************
1033  *         MENU_InsertItem
1034  *
1035  * Insert a new item into a menu.
1036  */
1037 static MENUITEM *MENU_InsertItem( HMENU hMenu, UINT pos, UINT flags )
1038 {
1039     MENUITEM *newItems;
1040     POPUPMENU *menu;
1041
1042     if (!(menu = (POPUPMENU *)USER_HEAP_LIN_ADDR(hMenu)))
1043     {
1044         dprintf_menu( stddeb, "MENU_InsertItem: %04x not a menu handle\n",
1045                       hMenu );
1046         return NULL;
1047     }
1048
1049     /* Find where to insert new item */
1050
1051     if ((flags & MF_BYPOSITION) &&
1052         ((pos == (UINT)-1) || (pos == menu->nItems)))
1053     {
1054         /* Special case: append to menu */
1055         /* Some programs specify the menu length to do that */
1056         pos = menu->nItems;
1057     }
1058     else
1059     {
1060         if (!MENU_FindItem( &hMenu, &pos, flags ))
1061         {
1062             dprintf_menu( stddeb, "MENU_InsertItem: item %x not found\n",
1063                           pos );
1064             return NULL;
1065         }
1066         if (!(menu = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu)))
1067         {
1068             dprintf_menu(stddeb,"MENU_InsertItem: %04x not a menu handle\n",
1069                          hMenu);
1070             return NULL;
1071         }
1072     }
1073
1074     /* Create new items array */
1075
1076     newItems = HeapAlloc( SystemHeap, 0, sizeof(MENUITEM) * (menu->nItems+1) );
1077     if (!newItems)
1078     {
1079         dprintf_menu( stddeb, "MENU_InsertItem: allocation failed\n" );
1080         return NULL;
1081     }
1082     if (menu->nItems > 0)
1083     {
1084           /* Copy the old array into the new */
1085         if (pos > 0) memcpy( newItems, menu->items, pos * sizeof(MENUITEM) );
1086         if (pos < menu->nItems) memcpy( &newItems[pos+1], &menu->items[pos],
1087                                         (menu->nItems-pos)*sizeof(MENUITEM) );
1088         HeapFree( SystemHeap, 0, menu->items );
1089     }
1090     menu->items = newItems;
1091     menu->nItems++;
1092     memset( &newItems[pos], 0, sizeof(*newItems) );
1093     return &newItems[pos];
1094 }
1095
1096
1097 /**********************************************************************
1098  *         MENU_ParseResource
1099  *
1100  * Parse a standard menu resource and add items to the menu.
1101  * Return a pointer to the end of the resource.
1102  */
1103 static LPCSTR MENU_ParseResource( LPCSTR res, HMENU hMenu, BOOL unicode )
1104 {
1105     WORD flags, id = 0;
1106     LPCSTR str;
1107
1108     do
1109     {
1110         flags = GET_WORD(res);
1111         res += sizeof(WORD);
1112         if (!(flags & MF_POPUP))
1113         {
1114             id = GET_WORD(res);
1115             res += sizeof(WORD);
1116         }
1117         if (!IS_STRING_ITEM(flags))
1118             fprintf( stderr, "MENU_ParseResource: not a string item %04x\n",
1119                      flags );
1120         str = res;
1121         if (!unicode) res += strlen(str) + 1;
1122         else res += (STRING32_lstrlenW((LPCWSTR)str) + 1) * sizeof(WCHAR);
1123         if (flags & MF_POPUP)
1124         {
1125             HMENU hSubMenu = CreatePopupMenu();
1126             if (!hSubMenu) return NULL;
1127             if (!(res = MENU_ParseResource( res, hSubMenu, unicode )))
1128                 return NULL;
1129             if (!unicode) AppendMenu32A( hMenu, flags, (UINT)hSubMenu, str );
1130             else AppendMenu32W( hMenu, flags, (UINT)hSubMenu, (LPCWSTR)str );
1131         }
1132         else  /* Not a popup */
1133         {
1134             if (!unicode) AppendMenu32A( hMenu, flags, id, *str ? str : NULL );
1135             else AppendMenu32W( hMenu, flags, id,
1136                                 *(LPCWSTR)str ? (LPCWSTR)str : NULL );
1137         }
1138     } while (!(flags & MF_END));
1139     return res;
1140 }
1141
1142
1143 /***********************************************************************
1144  *           MENU_GetSubPopup
1145  *
1146  * Return the handle of the selected sub-popup menu (if any).
1147  */
1148 static HMENU MENU_GetSubPopup( HMENU hmenu )
1149 {
1150     POPUPMENU *menu;
1151     MENUITEM *item;
1152
1153     menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu );
1154     if (menu->FocusedItem == NO_SELECTED_ITEM) return 0;
1155     else if (menu->FocusedItem == SYSMENU_SELECTED)
1156         return WIN_FindWndPtr(menu->hWnd)->hSysMenu;
1157
1158     item = &menu->items[menu->FocusedItem];
1159     if (!(item->item_flags & MF_POPUP) || !(item->item_flags & MF_MOUSESELECT))
1160         return 0;
1161     return (HMENU)item->item_id;
1162 }
1163
1164
1165 /***********************************************************************
1166  *           MENU_HideSubPopups
1167  *
1168  * Hide the sub-popup menus of this menu.
1169  */
1170 static void MENU_HideSubPopups( HWND hwndOwner, HMENU hmenu,
1171                                 BOOL sendMenuSelect )
1172 {
1173     MENUITEM *item;
1174     POPUPMENU *menu, *submenu;
1175     HMENU hsubmenu;
1176
1177     if (!(menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu ))) return;
1178     if (menu->FocusedItem == NO_SELECTED_ITEM) return;
1179     if (menu->FocusedItem == SYSMENU_SELECTED)
1180     {
1181         hsubmenu = WIN_FindWndPtr(menu->hWnd)->hSysMenu;
1182     }
1183     else
1184     {
1185         item = &menu->items[menu->FocusedItem];
1186         if (!(item->item_flags & MF_POPUP) ||
1187             !(item->item_flags & MF_MOUSESELECT)) return;
1188         item->item_flags &= ~MF_MOUSESELECT;
1189         hsubmenu = (HMENU)item->item_id;
1190     }
1191     submenu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hsubmenu );
1192     MENU_HideSubPopups( hwndOwner, hsubmenu, FALSE );
1193     MENU_SelectItem( hwndOwner, hsubmenu, NO_SELECTED_ITEM, sendMenuSelect );
1194     if (submenu->hWnd == pTopPWnd->hwndSelf )
1195     {
1196         ShowWindow( submenu->hWnd, SW_HIDE );
1197         uSubPWndLevel = 0;
1198     }
1199     else
1200     {
1201         DestroyWindow( submenu->hWnd );
1202         submenu->hWnd = 0;
1203     }
1204 }
1205
1206
1207 /***********************************************************************
1208  *           MENU_ShowSubPopup
1209  *
1210  * Display the sub-menu of the selected item of this menu.
1211  * Return the handle of the submenu, or hmenu if no submenu to display.
1212  */
1213 static HMENU MENU_ShowSubPopup( HWND hwndOwner, HMENU hmenu, BOOL selectFirst )
1214 {
1215     POPUPMENU *menu;
1216     MENUITEM *item;
1217     WND *wndPtr;
1218
1219     if (!(menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu ))) return hmenu;
1220     if (!(wndPtr = WIN_FindWndPtr( menu->hWnd ))) return hmenu;
1221     if (menu->FocusedItem == NO_SELECTED_ITEM) return hmenu;
1222     if (menu->FocusedItem == SYSMENU_SELECTED)
1223     {
1224         MENU_ShowPopup(hwndOwner, wndPtr->hSysMenu, 0, wndPtr->rectClient.left,
1225                 wndPtr->rectClient.top - menu->Height - 2*SYSMETRICS_CYBORDER);
1226         if (selectFirst) MENU_SelectNextItem( hwndOwner, wndPtr->hSysMenu );
1227         return wndPtr->hSysMenu;
1228     }
1229     item = &menu->items[menu->FocusedItem];
1230     if (!(item->item_flags & MF_POPUP) ||
1231         (item->item_flags & (MF_GRAYED | MF_DISABLED))) return hmenu;
1232     item->item_flags |= MF_MOUSESELECT;
1233     if (menu->wFlags & MF_POPUP)
1234     {
1235         MENU_ShowPopup( hwndOwner, (HMENU)item->item_id, menu->FocusedItem,
1236                  wndPtr->rectWindow.left + item->rect.right-arrow_bitmap_width,
1237                  wndPtr->rectWindow.top + item->rect.top );
1238     }
1239     else
1240     {
1241         MENU_ShowPopup( hwndOwner, (HMENU)item->item_id, menu->FocusedItem,
1242                         wndPtr->rectWindow.left + item->rect.left,
1243                         wndPtr->rectWindow.top + item->rect.bottom );
1244     }
1245     if (selectFirst) MENU_SelectNextItem( hwndOwner, (HMENU)item->item_id );
1246     return (HMENU)item->item_id;
1247 }
1248
1249
1250 /***********************************************************************
1251  *           MENU_FindMenuByCoords
1252  *
1253  * Find the menu containing a given point (in screen coords).
1254  */
1255 static HMENU MENU_FindMenuByCoords( HMENU hmenu, POINT16 pt )
1256 {
1257     POPUPMENU *menu;
1258     HWND hwnd;
1259
1260     if (!(hwnd = WindowFromPoint16( pt ))) return 0;
1261     while (hmenu)
1262     {
1263         menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu );
1264         if (menu->hWnd == hwnd)
1265         {
1266             if (!(menu->wFlags & MF_POPUP))
1267             {
1268                   /* Make sure it's in the menu bar (or in system menu) */
1269                 WND *wndPtr = WIN_FindWndPtr( menu->hWnd );
1270                 if ((pt.x < wndPtr->rectClient.left) ||
1271                     (pt.x >= wndPtr->rectClient.right) ||
1272                     (pt.y >= wndPtr->rectClient.top)) return 0;
1273                 if (pt.y < wndPtr->rectClient.top - menu->Height)
1274                 {
1275                     if (!MENU_IsInSysMenu( menu, pt )) return 0;
1276                 }
1277                 /* else it's in the menu bar */
1278             }
1279             return hmenu;
1280         }
1281         hmenu = MENU_GetSubPopup( hmenu );
1282     }
1283     return 0;
1284 }
1285
1286
1287 /***********************************************************************
1288  *           MENU_ExecFocusedItem
1289  *
1290  * Execute a menu item (for instance when user pressed Enter).
1291  * Return TRUE if we can go on with menu tracking.
1292  */
1293 static BOOL MENU_ExecFocusedItem( HWND hwndOwner, HMENU hmenu,
1294                                   HMENU *hmenuCurrent )
1295 {
1296     MENUITEM *item;
1297     POPUPMENU *menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu );
1298     if (!menu || !menu->nItems || (menu->FocusedItem == NO_SELECTED_ITEM) ||
1299         (menu->FocusedItem == SYSMENU_SELECTED)) return TRUE;
1300     item = &menu->items[menu->FocusedItem];
1301     if (!(item->item_flags & MF_POPUP))
1302     {
1303         if (!(item->item_flags & (MF_GRAYED | MF_DISABLED)))
1304         {
1305             PostMessage( hwndOwner, (menu->wFlags & MF_SYSMENU) ?
1306                         WM_SYSCOMMAND : WM_COMMAND, item->item_id, 0 );
1307             return FALSE;
1308         }
1309         else return TRUE;
1310     }
1311     else
1312     {
1313         *hmenuCurrent = MENU_ShowSubPopup( hwndOwner, hmenu, TRUE );
1314         return TRUE;
1315     }
1316 }
1317
1318
1319 /***********************************************************************
1320  *           MENU_ButtonDown
1321  *
1322  * Handle a button-down event in a menu. Point is in screen coords.
1323  * hmenuCurrent is the top-most visible popup.
1324  * Return TRUE if we can go on with menu tracking.
1325  */
1326 static BOOL MENU_ButtonDown( HWND hwndOwner, HMENU hmenu, HMENU *hmenuCurrent,
1327                              POINT16 pt )
1328 {
1329     POPUPMENU *menu;
1330     MENUITEM *item;
1331     UINT id;
1332
1333     if (!hmenu) return FALSE;  /* Outside all menus */
1334     menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu );
1335     item = MENU_FindItemByCoords( menu, pt.x, pt.y, &id );
1336     if (!item)  /* Maybe in system menu */
1337     {
1338         if (!MENU_IsInSysMenu( menu, pt )) return FALSE;
1339         id = SYSMENU_SELECTED;
1340     }
1341
1342     if (menu->FocusedItem == id)
1343     {
1344         if (id == SYSMENU_SELECTED) return FALSE;
1345         if (item->item_flags & MF_POPUP)
1346         {
1347             if (item->item_flags & MF_MOUSESELECT)
1348             {
1349                 if (menu->wFlags & MF_POPUP)
1350                 {
1351                     MENU_HideSubPopups( hwndOwner, hmenu, TRUE );
1352                     *hmenuCurrent = hmenu;
1353                 }
1354                 else return FALSE;
1355             }
1356             else *hmenuCurrent = MENU_ShowSubPopup( hwndOwner, hmenu, FALSE );
1357         }
1358     }
1359     else
1360     {
1361         MENU_HideSubPopups( hwndOwner, hmenu, FALSE );
1362         MENU_SelectItem( hwndOwner, hmenu, id, TRUE );
1363         *hmenuCurrent = MENU_ShowSubPopup( hwndOwner, hmenu, FALSE );
1364     }
1365     return TRUE;
1366 }
1367
1368
1369 /***********************************************************************
1370  *           MENU_ButtonUp
1371  *
1372  * Handle a button-up event in a menu. Point is in screen coords.
1373  * hmenuCurrent is the top-most visible popup.
1374  * Return TRUE if we can go on with menu tracking.
1375  */
1376 static BOOL MENU_ButtonUp( HWND hwndOwner, HMENU hmenu, HMENU *hmenuCurrent,
1377                            POINT16 pt )
1378 {
1379     POPUPMENU *menu;
1380     MENUITEM *item;
1381     HMENU hsubmenu = 0;
1382     UINT id;
1383
1384     if (!hmenu) return FALSE;  /* Outside all menus */
1385     menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu );
1386     item = MENU_FindItemByCoords( menu, pt.x, pt.y, &id );
1387     if (!item)  /* Maybe in system menu */
1388     {
1389         if (!MENU_IsInSysMenu( menu, pt )) return FALSE;
1390         id = SYSMENU_SELECTED;
1391         hsubmenu = WIN_FindWndPtr(menu->hWnd)->hSysMenu;
1392     }
1393
1394     if (menu->FocusedItem != id) return FALSE;
1395
1396     if (id != SYSMENU_SELECTED)
1397     {
1398         if (!(item->item_flags & MF_POPUP))
1399         {
1400             return MENU_ExecFocusedItem( hwndOwner, hmenu, hmenuCurrent );
1401         }
1402         hsubmenu = (HMENU)item->item_id;
1403     }
1404       /* Select first item of sub-popup */
1405     MENU_SelectItem( hwndOwner, hsubmenu, NO_SELECTED_ITEM, FALSE );
1406     MENU_SelectNextItem( hwndOwner, hsubmenu );
1407     return TRUE;
1408 }
1409
1410
1411 /***********************************************************************
1412  *           MENU_MouseMove
1413  *
1414  * Handle a motion event in a menu. Point is in screen coords.
1415  * hmenuCurrent is the top-most visible popup.
1416  * Return TRUE if we can go on with menu tracking.
1417  */
1418 static BOOL MENU_MouseMove( HWND hwndOwner, HMENU hmenu, HMENU *hmenuCurrent,
1419                             POINT16 pt )
1420 {
1421     MENUITEM *item;
1422     POPUPMENU *menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu );
1423     UINT id = NO_SELECTED_ITEM;
1424
1425     if (hmenu)
1426     {
1427         item = MENU_FindItemByCoords( menu, pt.x, pt.y, &id );
1428         if (!item)  /* Maybe in system menu */
1429         {
1430             if (!MENU_IsInSysMenu( menu, pt ))
1431                 id = NO_SELECTED_ITEM;  /* Outside all items */
1432             else id = SYSMENU_SELECTED;
1433         }
1434     }
1435     if (id == NO_SELECTED_ITEM)
1436     {
1437         MENU_SelectItem( hwndOwner, *hmenuCurrent, NO_SELECTED_ITEM, TRUE );
1438     }
1439     else if (menu->FocusedItem != id)
1440     {
1441         MENU_HideSubPopups( hwndOwner, hmenu, FALSE );
1442         MENU_SelectItem( hwndOwner, hmenu, id, TRUE );
1443         *hmenuCurrent = MENU_ShowSubPopup( hwndOwner, hmenu, FALSE );
1444     }
1445     return TRUE;
1446 }
1447
1448
1449 /***********************************************************************
1450  *           MENU_KeyLeft
1451  *
1452  * Handle a VK_LEFT key event in a menu.
1453  * hmenuCurrent is the top-most visible popup.
1454  */
1455 static void MENU_KeyLeft( HWND hwndOwner, HMENU hmenu, HMENU *hmenuCurrent )
1456 {
1457     POPUPMENU *menu;
1458     HMENU hmenutmp, hmenuprev;
1459
1460     menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu );
1461     hmenuprev = hmenutmp = hmenu;
1462     while (hmenutmp != *hmenuCurrent)
1463     {
1464         hmenutmp = MENU_GetSubPopup( hmenuprev );
1465         if (hmenutmp != *hmenuCurrent) hmenuprev = hmenutmp;
1466     }
1467     MENU_HideSubPopups( hwndOwner, hmenuprev, TRUE );
1468
1469     if ((hmenuprev == hmenu) && !(menu->wFlags & MF_POPUP))
1470     {
1471           /* Select previous item on the menu bar */
1472         MENU_SelectPrevItem( hwndOwner, hmenu );
1473         if (*hmenuCurrent != hmenu)
1474         {
1475               /* A popup menu was displayed -> display the next one */
1476             *hmenuCurrent = MENU_ShowSubPopup( hwndOwner, hmenu, TRUE );
1477         }
1478     }
1479     else *hmenuCurrent = hmenuprev;
1480 }
1481
1482
1483 /***********************************************************************
1484  *           MENU_KeyRight
1485  *
1486  * Handle a VK_RIGHT key event in a menu.
1487  * hmenuCurrent is the top-most visible popup.
1488  */
1489 static void MENU_KeyRight( HWND hwndOwner, HMENU hmenu, HMENU *hmenuCurrent )
1490 {
1491     POPUPMENU *menu;
1492     HMENU hmenutmp;
1493
1494     menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu );
1495
1496     if ((menu->wFlags & MF_POPUP) || (*hmenuCurrent != hmenu))
1497     {
1498           /* If already displaying a popup, try to display sub-popup */
1499         hmenutmp = MENU_ShowSubPopup( hwndOwner, *hmenuCurrent, TRUE );
1500         if (hmenutmp != *hmenuCurrent)  /* Sub-popup displayed */
1501         {
1502             *hmenuCurrent = hmenutmp;
1503             return;
1504         }
1505     }
1506
1507       /* If on menu-bar, go to next item */
1508     if (!(menu->wFlags & MF_POPUP))
1509     {
1510         MENU_HideSubPopups( hwndOwner, hmenu, FALSE );
1511         MENU_SelectNextItem( hwndOwner, hmenu );
1512         if (*hmenuCurrent != hmenu)
1513         {
1514               /* A popup menu was displayed -> display the next one */
1515             *hmenuCurrent = MENU_ShowSubPopup( hwndOwner, hmenu, TRUE );
1516         }
1517     }
1518     else if (*hmenuCurrent != hmenu)  /* Hide last level popup */
1519     {
1520         HMENU hmenuprev;
1521         hmenuprev = hmenutmp = hmenu;
1522         while (hmenutmp != *hmenuCurrent)
1523         {
1524             hmenutmp = MENU_GetSubPopup( hmenuprev );
1525             if (hmenutmp != *hmenuCurrent) hmenuprev = hmenutmp;
1526         }
1527         MENU_HideSubPopups( hwndOwner, hmenuprev, TRUE );
1528         *hmenuCurrent = hmenuprev;
1529     }
1530 }
1531
1532
1533 /***********************************************************************
1534  *           MENU_TrackMenu
1535  *
1536  * Menu tracking code.
1537  * If 'x' and 'y' are not 0, we simulate a button-down event at (x,y)
1538  * before beginning tracking. This is to help menu-bar tracking.
1539  */
1540 static BOOL MENU_TrackMenu( HMENU hmenu, UINT wFlags, int x, int y,
1541                             HWND hwnd, const RECT16 *lprect )
1542 {
1543     MSG *msg;
1544     HLOCAL16 hMsg;
1545     POPUPMENU *menu;
1546     HMENU hmenuCurrent = hmenu;
1547     BOOL fClosed = FALSE, fRemove;
1548     UINT pos;
1549
1550     fEndMenuCalled = FALSE;
1551     if (!(menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu ))) return FALSE;
1552     if (x && y)
1553     {
1554         POINT16 pt = { x, y };
1555         MENU_ButtonDown( hwnd, hmenu, &hmenuCurrent, pt );
1556     }
1557     SetCapture( hwnd );
1558     hMsg = USER_HEAP_ALLOC( sizeof(MSG) );
1559     msg = (MSG *)USER_HEAP_LIN_ADDR( hMsg );
1560     while (!fClosed)
1561     {
1562         if (!MSG_InternalGetMessage( (SEGPTR)USER_HEAP_SEG_ADDR(hMsg), 0,
1563                                      hwnd, MSGF_MENU, 0, TRUE ))
1564             break;
1565
1566         fRemove = FALSE;
1567         if ((msg->message >= WM_MOUSEFIRST) && (msg->message <= WM_MOUSELAST))
1568         {
1569               /* Find the sub-popup for this mouse event (if any) */
1570             HMENU hsubmenu = MENU_FindMenuByCoords( hmenu, msg->pt );
1571
1572             switch(msg->message)
1573             {
1574             case WM_RBUTTONDOWN:
1575             case WM_NCRBUTTONDOWN:
1576                 if (!(wFlags & TPM_RIGHTBUTTON)) break;
1577                 /* fall through */
1578             case WM_LBUTTONDOWN:
1579             case WM_NCLBUTTONDOWN:
1580                 fClosed = !MENU_ButtonDown( hwnd, hsubmenu,
1581                                             &hmenuCurrent, msg->pt );
1582                 break;
1583
1584             case WM_RBUTTONUP:
1585             case WM_NCRBUTTONUP:
1586                 if (!(wFlags & TPM_RIGHTBUTTON)) break;
1587                 /* fall through */
1588             case WM_LBUTTONUP:
1589             case WM_NCLBUTTONUP:
1590                   /* If outside all menus but inside lprect, ignore it */
1591                 if (!hsubmenu && lprect && PtInRect16(lprect, msg->pt)) break;
1592                 fClosed = !MENU_ButtonUp( hwnd, hsubmenu,
1593                                           &hmenuCurrent, msg->pt );
1594                 fRemove = TRUE;  /* Remove event even if outside menu */
1595                 break;
1596
1597             case WM_MOUSEMOVE:
1598             case WM_NCMOUSEMOVE:
1599                 if ((msg->wParam & MK_LBUTTON) ||
1600                     ((wFlags & TPM_RIGHTBUTTON) && (msg->wParam & MK_RBUTTON)))
1601                 {
1602                     fClosed = !MENU_MouseMove( hwnd, hsubmenu,
1603                                                &hmenuCurrent, msg->pt );
1604                 }
1605                 break;
1606             }
1607         }
1608         else if ((msg->message >= WM_KEYFIRST) && (msg->message <= WM_KEYLAST))
1609         {
1610             fRemove = TRUE;  /* Keyboard messages are always removed */
1611             switch(msg->message)
1612             {
1613             case WM_KEYDOWN:
1614                 switch(msg->wParam)
1615                 {
1616                 case VK_HOME:
1617                     MENU_SelectItem( hwnd, hmenuCurrent, NO_SELECTED_ITEM, FALSE );
1618                     MENU_SelectNextItem( hwnd, hmenuCurrent );
1619                     break;
1620
1621                 case VK_END:
1622                     MENU_SelectItem( hwnd, hmenuCurrent, NO_SELECTED_ITEM, FALSE );
1623                     MENU_SelectPrevItem( hwnd, hmenuCurrent );
1624                     break;
1625
1626                 case VK_UP:
1627                     MENU_SelectPrevItem( hwnd, hmenuCurrent );
1628                     break;
1629
1630                 case VK_DOWN:
1631                       /* If on menu bar, pull-down the menu */
1632                     if (!(menu->wFlags & MF_POPUP) && (hmenuCurrent == hmenu))
1633                         hmenuCurrent = MENU_ShowSubPopup( hwnd, hmenu, TRUE );
1634                     else
1635                         MENU_SelectNextItem( hwnd, hmenuCurrent );
1636                     break;
1637
1638                 case VK_LEFT:
1639                     MENU_KeyLeft( hwnd, hmenu, &hmenuCurrent );
1640                     break;
1641
1642                 case VK_RIGHT:
1643                     MENU_KeyRight( hwnd, hmenu, &hmenuCurrent );
1644                     break;
1645
1646                 case VK_SPACE:
1647                 case VK_RETURN:
1648                     fClosed = !MENU_ExecFocusedItem( hwnd, hmenuCurrent,
1649                                                      &hmenuCurrent );
1650                     break;
1651
1652                 case VK_ESCAPE:
1653                     fClosed = TRUE;
1654                     break;
1655
1656                 default:
1657                     break;
1658                 }
1659                 break;  /* WM_KEYDOWN */
1660
1661             case WM_SYSKEYDOWN:
1662                 switch(msg->wParam)
1663                 {
1664                 case VK_MENU:
1665                     fClosed = TRUE;
1666                     break;
1667
1668                 }
1669                 break;  /* WM_SYSKEYDOWN */
1670
1671             case WM_CHAR:
1672                 {
1673                       /* Hack to avoid control chars. */
1674                       /* We will find a better way real soon... */
1675                     if ((msg->wParam <= 32) || (msg->wParam >= 127)) break;
1676                     pos = MENU_FindItemByKey( hwnd, hmenuCurrent, msg->wParam );
1677                     if (pos == (UINT)-2) fClosed = TRUE;
1678                     else if (pos == (UINT)-1) MessageBeep(0);
1679                     else
1680                     {
1681                         MENU_SelectItem( hwnd, hmenuCurrent, pos, TRUE );
1682                         fClosed = !MENU_ExecFocusedItem( hwnd, hmenuCurrent,
1683                                                          &hmenuCurrent );
1684
1685                     }
1686                 }
1687                 break;  /* WM_CHAR */
1688             }  /* switch(msg->message) */
1689         }
1690         else
1691         {
1692             DispatchMessage( msg );
1693         }
1694         if (fEndMenuCalled) fClosed = TRUE;
1695         if (!fClosed) fRemove = TRUE;
1696
1697         if (fRemove)  /* Remove the message from the queue */
1698             PeekMessage( msg, 0, msg->message, msg->message, PM_REMOVE );
1699     }
1700     USER_HEAP_FREE( hMsg );
1701     ReleaseCapture();
1702     MENU_HideSubPopups( hwnd, hmenu, FALSE );
1703     if (menu->wFlags & MF_POPUP)
1704     {
1705          ShowWindow( menu->hWnd, SW_HIDE );
1706          uSubPWndLevel = 0;
1707     }
1708     MENU_SelectItem( hwnd, hmenu, NO_SELECTED_ITEM, FALSE );
1709     SendMessage16( hwnd, WM_MENUSELECT, 0, MAKELONG( 0xffff, 0 ) );
1710     fEndMenuCalled = FALSE;
1711     return TRUE;
1712 }
1713
1714
1715 /***********************************************************************
1716  *           MENU_TrackMouseMenuBar
1717  *
1718  * Menu-bar tracking upon a mouse event. Called from NC_HandleSysCommand().
1719  */
1720 void MENU_TrackMouseMenuBar( HWND hwnd, POINT16 pt )
1721 {
1722     WND *wndPtr = WIN_FindWndPtr( hwnd );
1723     HideCaret(0);
1724     SendMessage16( hwnd, WM_ENTERMENULOOP, 0, 0 );
1725     SendMessage16( hwnd, WM_INITMENU, wndPtr->wIDmenu, 0 );
1726     MENU_TrackMenu( (HMENU)wndPtr->wIDmenu, TPM_LEFTALIGN | TPM_LEFTBUTTON,
1727                     pt.x, pt.y, hwnd, NULL );
1728     SendMessage16( hwnd, WM_EXITMENULOOP, 0, 0 );
1729     ShowCaret(0);
1730 }
1731
1732
1733 /***********************************************************************
1734  *           MENU_TrackKbdMenuBar
1735  *
1736  * Menu-bar tracking upon a keyboard event. Called from NC_HandleSysCommand().
1737  */
1738 void MENU_TrackKbdMenuBar( WND* wndPtr, UINT wParam, INT vkey)
1739 {
1740     UINT uItem = NO_SELECTED_ITEM;
1741    HMENU hTrackMenu;
1742
1743     /* find window that has a menu
1744      */
1745
1746     if( !(wndPtr->dwStyle & WS_CHILD) )
1747       {
1748           wndPtr = WIN_FindWndPtr( GetActiveWindow() );
1749           if( !wndPtr ) return;
1750       }
1751     else
1752       while( wndPtr->dwStyle & WS_CHILD &&
1753            !(wndPtr->dwStyle & WS_SYSMENU) )
1754            if( !(wndPtr = wndPtr->parent) ) return;
1755
1756     if( wndPtr->dwStyle & WS_CHILD || !wndPtr->wIDmenu )
1757       if( !(wndPtr->dwStyle & WS_SYSMENU) )
1758         return;
1759
1760     hTrackMenu = ( IsMenu( wndPtr->wIDmenu ) )? wndPtr->wIDmenu:
1761                                                 wndPtr->hSysMenu;
1762
1763     HideCaret(0);
1764     SendMessage16( wndPtr->hwndSelf, WM_ENTERMENULOOP, 0, 0 );
1765     SendMessage16( wndPtr->hwndSelf, WM_INITMENU, wndPtr->wIDmenu, 0 );
1766
1767     /* find suitable menu entry
1768      */
1769
1770     if( vkey == VK_SPACE )
1771         uItem = SYSMENU_SELECTED;
1772     else if( vkey )
1773       {
1774         uItem = MENU_FindItemByKey( wndPtr->hwndSelf, wndPtr->wIDmenu, vkey );
1775         if( uItem >= 0xFFFE )
1776           {
1777             if( uItem == 0xFFFF )
1778                 MessageBeep(0);
1779             SendMessage16( wndPtr->hwndSelf, WM_EXITMENULOOP, 0, 0 );
1780             ShowCaret(0);
1781             return;
1782           }
1783       }
1784
1785     MENU_SelectItem( wndPtr->hwndSelf, hTrackMenu, uItem, TRUE );
1786     if( uItem == NO_SELECTED_ITEM )
1787       MENU_SelectNextItem( wndPtr->hwndSelf, hTrackMenu );
1788     else
1789       PostMessage( wndPtr->hwndSelf, WM_KEYDOWN, VK_DOWN, 0L );
1790
1791     MENU_TrackMenu( hTrackMenu, TPM_LEFTALIGN | TPM_LEFTBUTTON,
1792                     0, 0, wndPtr->hwndSelf, NULL );
1793
1794     SendMessage16( wndPtr->hwndSelf, WM_EXITMENULOOP, 0, 0 );
1795     ShowCaret(0);
1796 }
1797
1798
1799 /**********************************************************************
1800  *           TrackPopupMenu16   (USER.416)
1801  */
1802 BOOL16 TrackPopupMenu16( HMENU16 hMenu, UINT16 wFlags, INT16 x, INT16 y,
1803                          INT16 nReserved, HWND16 hWnd, const RECT16 *lpRect )
1804 {
1805     BOOL ret = FALSE;
1806
1807     HideCaret(0);
1808     if (MENU_ShowPopup( hWnd, hMenu, 0, x, y ))
1809         ret = MENU_TrackMenu( hMenu, wFlags, 0, 0, hWnd, lpRect );
1810     ShowCaret(0);
1811     return ret;
1812 }
1813
1814
1815 /**********************************************************************
1816  *           TrackPopupMenu32   (USER32.548)
1817  */
1818 BOOL32 TrackPopupMenu32( HMENU32 hMenu, UINT32 wFlags, INT32 x, INT32 y,
1819                          INT32 nReserved, HWND32 hWnd, const RECT32 *lpRect )
1820 {
1821     RECT16 r;
1822     CONV_RECT32TO16( lpRect, &r );
1823     return TrackPopupMenu16( hMenu, wFlags, x, y, nReserved, hWnd, &r );
1824 }
1825
1826
1827 /***********************************************************************
1828  *           PopupMenuWndProc
1829  */
1830 LRESULT PopupMenuWndProc(HWND hwnd,UINT message,WPARAM wParam,LPARAM lParam)
1831 {
1832     switch(message)
1833     {
1834     case WM_CREATE:
1835         {
1836             CREATESTRUCT16 *cs = (CREATESTRUCT16*)PTR_SEG_TO_LIN(lParam);
1837             SetWindowLong32A( hwnd, 0, (LONG)cs->lpCreateParams );
1838             return 0;
1839         }
1840
1841     case WM_MOUSEACTIVATE:  /* We don't want to be activated */
1842         return MA_NOACTIVATE;
1843
1844     case WM_PAINT:
1845         {
1846             PAINTSTRUCT16 ps;
1847             BeginPaint16( hwnd, &ps );
1848             MENU_DrawPopupMenu( hwnd, ps.hdc,
1849                                 (HMENU)GetWindowLong32A( hwnd, 0 ) );
1850             EndPaint16( hwnd, &ps );
1851             return 0;
1852         }
1853
1854     case WM_DESTROY:
1855             /* zero out global pointer in case system popup
1856              * was destroyed by AppExit
1857              */
1858
1859             if( hwnd == pTopPWnd->hwndSelf )
1860                 pTopPWnd = 0;
1861             else
1862                 uSubPWndLevel--;
1863             break;
1864
1865     case WM_USER:
1866         if (wParam) SetWindowLong32A( hwnd, 0, (HMENU)wParam );
1867         break;
1868     default:
1869         return DefWindowProc16(hwnd, message, wParam, lParam);
1870     }
1871     return 0;
1872 }
1873
1874
1875 /***********************************************************************
1876  *           MENU_GetMenuBarHeight
1877  *
1878  * Compute the size of the menu bar height. Used by NC_HandleNCCalcSize().
1879  */
1880 UINT MENU_GetMenuBarHeight( HWND hwnd, UINT menubarWidth, int orgX, int orgY )
1881 {
1882     HDC hdc;
1883     RECT16 rectBar;
1884     WND *wndPtr;
1885     LPPOPUPMENU lppop;
1886
1887     if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return 0;
1888     if (!(lppop = (LPPOPUPMENU)USER_HEAP_LIN_ADDR((HMENU)wndPtr->wIDmenu)))
1889       return 0;
1890     hdc = GetDC( hwnd );
1891     SetRect16(&rectBar, orgX, orgY, orgX+menubarWidth, orgY+SYSMETRICS_CYMENU);
1892     MENU_MenuBarCalcSize( hdc, &rectBar, lppop, hwnd );
1893     ReleaseDC( hwnd, hdc );
1894     return lppop->Height;
1895 }
1896
1897
1898 /*******************************************************************
1899  *         ChangeMenu16    (USER.153)
1900  */
1901 BOOL16 ChangeMenu16( HMENU16 hMenu, UINT16 pos, SEGPTR data,
1902                      UINT16 id, UINT16 flags )
1903 {
1904     dprintf_menu( stddeb,"ChangeMenu16: menu=%04x pos=%d data=%08lx id=%04x flags=%04x\n",
1905                   hMenu, pos, (DWORD)data, id, flags );
1906     if (flags & MF_APPEND) return AppendMenu16( hMenu, flags & ~MF_APPEND,
1907                                                 id, data );
1908     /* FIXME: Word passes the item id in 'pos' and 0 or 0xffff as id */
1909     /* for MF_DELETE. We should check the parameters for all others */
1910     /* MF_* actions also (anybody got a doc on ChangeMenu?). */
1911     if (flags & MF_DELETE) return DeleteMenu( hMenu, pos, flags & ~MF_DELETE );
1912     if (flags & MF_CHANGE) return ModifyMenu16( hMenu, pos, flags & ~MF_CHANGE,
1913                                                 id, data );
1914     if (flags & MF_REMOVE) return RemoveMenu( hMenu,
1915                                               flags & MF_BYPOSITION ? pos : id,
1916                                               flags & ~MF_REMOVE );
1917     /* Default: MF_INSERT */
1918     return InsertMenu16( hMenu, pos, flags, id, data );
1919 }
1920
1921
1922 /*******************************************************************
1923  *         ChangeMenu32A    (USER32.22)
1924  */
1925 BOOL32 ChangeMenu32A( HMENU32 hMenu, UINT32 pos, LPCSTR data,
1926                       UINT32 id, UINT32 flags )
1927 {
1928     dprintf_menu( stddeb,"ChangeMenu32A: menu=%08x pos=%d data=%08lx id=%08x flags=%08x\n",
1929                   hMenu, pos, (DWORD)data, id, flags );
1930     if (flags & MF_APPEND) return AppendMenu32A( hMenu, flags & ~MF_APPEND,
1931                                                  id, data );
1932     if (flags & MF_DELETE) return DeleteMenu( hMenu, pos, flags & ~MF_DELETE );
1933     if (flags & MF_CHANGE) return ModifyMenu32A(hMenu, pos, flags & ~MF_CHANGE,
1934                                                 id, data );
1935     if (flags & MF_REMOVE) return RemoveMenu( hMenu,
1936                                               flags & MF_BYPOSITION ? pos : id,
1937                                               flags & ~MF_REMOVE );
1938     /* Default: MF_INSERT */
1939     return InsertMenu32A( hMenu, pos, flags, id, data );
1940 }
1941
1942
1943 /*******************************************************************
1944  *         ChangeMenu32W    (USER32.23)
1945  */
1946 BOOL32 ChangeMenu32W( HMENU32 hMenu, UINT32 pos, LPCWSTR data,
1947                       UINT32 id, UINT32 flags )
1948 {
1949     dprintf_menu( stddeb,"ChangeMenu32W: menu=%08x pos=%d data=%08lx id=%08x flags=%08x\n",
1950                   hMenu, pos, (DWORD)data, id, flags );
1951     if (flags & MF_APPEND) return AppendMenu32W( hMenu, flags & ~MF_APPEND,
1952                                                  id, data );
1953     if (flags & MF_DELETE) return DeleteMenu( hMenu, pos, flags & ~MF_DELETE );
1954     if (flags & MF_CHANGE) return ModifyMenu32W(hMenu, pos, flags & ~MF_CHANGE,
1955                                                 id, data );
1956     if (flags & MF_REMOVE) return RemoveMenu( hMenu,
1957                                               flags & MF_BYPOSITION ? pos : id,
1958                                               flags & ~MF_REMOVE );
1959     /* Default: MF_INSERT */
1960     return InsertMenu32W( hMenu, pos, flags, id, data );
1961 }
1962
1963
1964 /*******************************************************************
1965  *         CheckMenuItem    (USER.154)
1966  */
1967 INT CheckMenuItem( HMENU hMenu, UINT id, UINT flags )
1968 {
1969     MENUITEM *item;
1970     INT ret;
1971
1972     dprintf_menu( stddeb,"CheckMenuItem: %04x %04x %04x\n", hMenu, id, flags );
1973     if (!(item = MENU_FindItem( &hMenu, &id, flags ))) return -1;
1974     ret = item->item_flags & MF_CHECKED;
1975     if (flags & MF_CHECKED) item->item_flags |= MF_CHECKED;
1976     else item->item_flags &= ~MF_CHECKED;
1977     return ret;
1978 }
1979
1980
1981 /**********************************************************************
1982  *                      EnableMenuItem          [USER.155]
1983  */
1984 BOOL EnableMenuItem(HMENU hMenu, UINT wItemID, UINT wFlags)
1985 {
1986     MENUITEM *item;
1987     dprintf_menu(stddeb,"EnableMenuItem (%04x, %04X, %04X) !\n",
1988                  hMenu, wItemID, wFlags);
1989     if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags ))) return FALSE;
1990
1991       /* We can't have MF_GRAYED and MF_DISABLED together */
1992     if (wFlags & MF_GRAYED)
1993     {
1994         item->item_flags = (item->item_flags & ~MF_DISABLED) | MF_GRAYED;
1995     }
1996     else if (wFlags & MF_DISABLED)
1997     {
1998         item->item_flags = (item->item_flags & ~MF_GRAYED) | MF_DISABLED;
1999     }
2000     else   /* MF_ENABLED */
2001     {
2002         item->item_flags &= ~(MF_GRAYED | MF_DISABLED);
2003     }
2004     return TRUE;
2005 }
2006
2007
2008 /*******************************************************************
2009  *         GetMenuString    (USER.161)
2010  */
2011 int GetMenuString( HMENU hMenu, UINT wItemID,
2012                    LPSTR str, short nMaxSiz, UINT wFlags )
2013 {
2014     MENUITEM *item;
2015
2016     dprintf_menu( stddeb, "GetMenuString: menu=%04x item=%04x ptr=%p len=%d flags=%04x\n",
2017                  hMenu, wItemID, str, nMaxSiz, wFlags );
2018     if (!str || !nMaxSiz) return 0;
2019     str[0] = '\0';
2020     if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags ))) return 0;
2021     if (!IS_STRING_ITEM(item->item_flags)) return 0;
2022     lstrcpyn( str, item->text, nMaxSiz );
2023     dprintf_menu( stddeb, "GetMenuString: returning '%s'\n", str );
2024     return strlen(str);
2025 }
2026
2027
2028 /**********************************************************************
2029  *                      HiliteMenuItem          [USER.162]
2030  */
2031 BOOL HiliteMenuItem(HWND hWnd, HMENU hMenu, UINT wItemID, UINT wHilite)
2032 {
2033     LPPOPUPMENU menu;
2034     dprintf_menu(stddeb,"HiliteMenuItem(%04x, %04x, %04x, %04x);\n",
2035                  hWnd, hMenu, wItemID, wHilite);
2036     if (!MENU_FindItem( &hMenu, &wItemID, wHilite )) return FALSE;
2037     if (!(menu = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu))) return FALSE;
2038     if (menu->FocusedItem == wItemID) return TRUE;
2039     MENU_HideSubPopups( hWnd, hMenu, FALSE );
2040     MENU_SelectItem( hWnd, hMenu, wItemID, TRUE );
2041     return TRUE;
2042 }
2043
2044
2045 /**********************************************************************
2046  *                      GetMenuState            [USER.250]
2047  */
2048 UINT GetMenuState(HMENU hMenu, UINT wItemID, UINT wFlags)
2049 {
2050     MENUITEM *item;
2051     dprintf_menu(stddeb,"GetMenuState(%04x, %04x, %04x);\n",
2052                  hMenu, wItemID, wFlags);
2053     if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags ))) return -1;
2054     if (item->item_flags & MF_POPUP)
2055     {
2056         POPUPMENU *menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( (HMENU)item->item_id );
2057         if (!menu) return -1;
2058         else return (menu->nItems << 8) | (menu->wFlags & 0xff);
2059     }
2060     else return item->item_flags;
2061 }
2062
2063
2064 /**********************************************************************
2065  *                      GetMenuItemCount                [USER.263]
2066  */
2067 INT GetMenuItemCount(HMENU hMenu)
2068 {
2069         LPPOPUPMENU     menu;
2070         dprintf_menu(stddeb,"GetMenuItemCount(%04x);\n", hMenu);
2071         menu = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu);
2072         if (menu == NULL) return (UINT)-1;
2073         dprintf_menu(stddeb,"GetMenuItemCount(%04x) return %d \n",
2074                      hMenu, menu->nItems);
2075         return menu->nItems;
2076 }
2077
2078
2079 /**********************************************************************
2080  *                      GetMenuItemID                   [USER.264]
2081  */
2082 UINT GetMenuItemID(HMENU hMenu, int nPos)
2083 {
2084     LPPOPUPMENU menu;
2085
2086     dprintf_menu(stddeb,"GetMenuItemID(%04x, %d);\n", hMenu, nPos);
2087     if (!(menu = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu))) return -1;
2088     if ((nPos < 0) || (nPos >= menu->nItems)) return -1;
2089     if (menu->items[nPos].item_flags & MF_POPUP) return -1;
2090     return menu->items[nPos].item_id;
2091 }
2092
2093
2094 /*******************************************************************
2095  *         InsertMenu16    (USER.410)
2096  */
2097 BOOL16 InsertMenu16( HMENU16 hMenu, UINT16 pos, UINT16 flags,
2098                      UINT16 id, SEGPTR data )
2099 {
2100     if (IS_STRING_ITEM(flags) && data)
2101         return InsertMenu32A( hMenu, (INT32)(INT16)pos, flags, id,
2102                               (LPSTR)PTR_SEG_TO_LIN(data) );
2103     return InsertMenu32A( hMenu, (INT32)(INT16)pos, flags, id, (LPSTR)data );
2104 }
2105
2106
2107 /*******************************************************************
2108  *         InsertMenu32A    (USER32.321)
2109  */
2110 BOOL32 InsertMenu32A( HMENU32 hMenu, UINT32 pos, UINT32 flags,
2111                       UINT32 id, LPCSTR str )
2112 {
2113     MENUITEM *item;
2114
2115     if (IS_STRING_ITEM(flags) && str)
2116         dprintf_menu( stddeb, "InsertMenu: %04x %d %04x %04x '%s'\n",
2117                       hMenu, pos, flags, id, str );
2118     else dprintf_menu( stddeb, "InsertMenu: %04x %d %04x %04x %08lx\n",
2119                        hMenu, pos, flags, id, (DWORD)str );
2120
2121     if (!(item = MENU_InsertItem( hMenu, pos, flags ))) return FALSE;
2122
2123     if (!(MENU_SetItemData( item, flags, id, str )))
2124     {
2125         RemoveMenu( hMenu, pos, flags );
2126         return FALSE;
2127     }
2128
2129     if (flags & MF_POPUP)  /* Set the MF_POPUP flag on the popup-menu */
2130         ((POPUPMENU *)USER_HEAP_LIN_ADDR((HMENU)id))->wFlags |= MF_POPUP;
2131
2132     item->hCheckBit   = hStdCheck;
2133     item->hUnCheckBit = 0;
2134     return TRUE;
2135 }
2136
2137
2138 /*******************************************************************
2139  *         InsertMenu32W    (USER32.324)
2140  */
2141 BOOL32 InsertMenu32W( HMENU32 hMenu, UINT32 pos, UINT32 flags,
2142                       UINT32 id, LPCWSTR str )
2143 {
2144     BOOL32 ret;
2145
2146     if (IS_STRING_ITEM(flags) && str)
2147     {
2148         LPSTR newstr = STRING32_DupUniToAnsi( str );
2149         ret = InsertMenu32A( hMenu, pos, flags, id, newstr );
2150         free( newstr );
2151         return ret;
2152     }
2153     else return InsertMenu32A( hMenu, pos, flags, id, (LPCSTR)str );
2154 }
2155
2156
2157 /*******************************************************************
2158  *         AppendMenu16    (USER.411)
2159  */
2160 BOOL16 AppendMenu16( HMENU16 hMenu, UINT16 flags, UINT16 id, SEGPTR data )
2161 {
2162     return InsertMenu16( hMenu, -1, flags | MF_BYPOSITION, id, data );
2163 }
2164
2165
2166 /*******************************************************************
2167  *         AppendMenu32A    (USER32.4)
2168  */
2169 BOOL32 AppendMenu32A( HMENU32 hMenu, UINT32 flags, UINT32 id, LPCSTR data )
2170 {
2171     return InsertMenu32A( hMenu, -1, flags | MF_BYPOSITION, id, data );
2172 }
2173
2174
2175 /*******************************************************************
2176  *         AppendMenu32W    (USER32.5)
2177  */
2178 BOOL32 AppendMenu32W( HMENU32 hMenu, UINT32 flags, UINT32 id, LPCWSTR data )
2179 {
2180     return InsertMenu32W( hMenu, -1, flags | MF_BYPOSITION, id, data );
2181 }
2182
2183
2184 /**********************************************************************
2185  *                      RemoveMenu              [USER.412]
2186  */
2187 BOOL RemoveMenu(HMENU hMenu, UINT nPos, UINT wFlags)
2188 {
2189     LPPOPUPMENU menu;
2190     MENUITEM *item;
2191
2192     dprintf_menu(stddeb,"RemoveMenu (%04x, %04x, %04x)\n",hMenu, nPos, wFlags);
2193     if (!(item = MENU_FindItem( &hMenu, &nPos, wFlags ))) return FALSE;
2194     if (!(menu = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu))) return FALSE;
2195
2196       /* Remove item */
2197
2198     if (IS_STRING_ITEM(item->item_flags) && item->text)
2199         HeapFree( SystemHeap, 0, item->text );
2200     if (--menu->nItems == 0)
2201     {
2202         HeapFree( SystemHeap, 0, menu->items );
2203         menu->items = NULL;
2204     }
2205     else
2206     {
2207         while(nPos < menu->nItems)
2208         {
2209             *item = *(item+1);
2210             item++;
2211             nPos++;
2212         }
2213         menu->items = HeapReAlloc( SystemHeap, 0, menu->items,
2214                                    menu->nItems * sizeof(MENUITEM) );
2215     }
2216     return TRUE;
2217 }
2218
2219
2220 /**********************************************************************
2221  *                      DeleteMenu              [USER.413]
2222  */
2223 BOOL DeleteMenu(HMENU hMenu, UINT nPos, UINT wFlags)
2224 {
2225     MENUITEM *item = MENU_FindItem( &hMenu, &nPos, wFlags );
2226     if (!item) return FALSE;
2227     if (item->item_flags & MF_POPUP) DestroyMenu( (HMENU)item->item_id );
2228       /* nPos is now the position of the item */
2229     RemoveMenu( hMenu, nPos, wFlags | MF_BYPOSITION );
2230     return TRUE;
2231 }
2232
2233
2234 /*******************************************************************
2235  *         ModifyMenu16    (USER.414)
2236  */
2237 BOOL16 ModifyMenu16( HMENU16 hMenu, UINT16 pos, UINT16 flags,
2238                      UINT16 id, SEGPTR data )
2239 {
2240     if (IS_STRING_ITEM(flags))
2241         return ModifyMenu32A( hMenu, (INT32)(INT16)pos, flags, id,
2242                               (LPSTR)PTR_SEG_TO_LIN(data) );
2243     return ModifyMenu32A( hMenu, (INT32)(INT16)pos, flags, id, (LPSTR)data );
2244 }
2245
2246
2247 /*******************************************************************
2248  *         ModifyMenu32A    (USER32.396)
2249  */
2250 BOOL32 ModifyMenu32A( HMENU32 hMenu, UINT32 pos, UINT32 flags,
2251                       UINT32 id, LPCSTR str )
2252 {
2253     MENUITEM *item;
2254     HMENU hMenu16 = hMenu;
2255     UINT16 pos16 = pos;
2256
2257     if (IS_STRING_ITEM(flags))
2258     {
2259         dprintf_menu( stddeb, "ModifyMenu: %04x %d %04x %04x '%s'\n",
2260                       hMenu, pos, flags, id, str ? str : "#NULL#" );
2261         if (!str) return FALSE;
2262     }
2263     else
2264     {
2265         dprintf_menu( stddeb, "ModifyMenu: %04x %d %04x %04x %08lx\n",
2266                       hMenu, pos, flags, id, (DWORD)str );
2267     }
2268
2269     if (!(item = MENU_FindItem( &hMenu16, &pos16, flags ))) return FALSE;
2270     return MENU_SetItemData( item, flags, id, str );
2271 }
2272
2273
2274 /*******************************************************************
2275  *         ModifyMenu32W    (USER32.397)
2276  */
2277 BOOL32 ModifyMenu32W( HMENU32 hMenu, UINT32 pos, UINT32 flags,
2278                       UINT32 id, LPCWSTR str )
2279 {
2280     BOOL32 ret;
2281
2282     if (IS_STRING_ITEM(flags) && str)
2283     {
2284         LPSTR newstr = STRING32_DupUniToAnsi( str );
2285         ret = ModifyMenu32A( hMenu, pos, flags, id, newstr );
2286         free( newstr );
2287         return ret;
2288     }
2289     else return ModifyMenu32A( hMenu, pos, flags, id, (LPCSTR)str );
2290 }
2291
2292
2293 /**********************************************************************
2294  *                      CreatePopupMenu         [USER.415]
2295  */
2296 HMENU CreatePopupMenu()
2297 {
2298     HMENU hmenu;
2299     POPUPMENU *menu;
2300
2301     if (!(hmenu = CreateMenu())) return 0;
2302     menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu );
2303     menu->wFlags |= MF_POPUP;
2304     return hmenu;
2305 }
2306
2307
2308 /**********************************************************************
2309  *                      GetMenuCheckMarkDimensions      [USER.417]
2310  */
2311 DWORD GetMenuCheckMarkDimensions()
2312 {
2313     return MAKELONG( check_bitmap_width, check_bitmap_height );
2314 }
2315
2316
2317 /**********************************************************************
2318  *                      SetMenuItemBitmaps      [USER.418]
2319  */
2320 BOOL SetMenuItemBitmaps(HMENU hMenu, UINT nPos, UINT wFlags,
2321                         HBITMAP hNewUnCheck, HBITMAP hNewCheck)
2322 {
2323     MENUITEM *item;
2324     dprintf_menu(stddeb,"SetMenuItemBitmaps(%04x, %04x, %04x, %04x, %04x)\n",
2325                  hMenu, nPos, wFlags, hNewCheck, hNewUnCheck);
2326     if (!(item = MENU_FindItem( &hMenu, &nPos, wFlags ))) return FALSE;
2327
2328     if (!hNewCheck && !hNewUnCheck)
2329     {
2330           /* If both are NULL, restore default bitmaps */
2331         item->hCheckBit   = hStdCheck;
2332         item->hUnCheckBit = 0;
2333         item->item_flags &= ~MF_USECHECKBITMAPS;
2334     }
2335     else  /* Install new bitmaps */
2336     {
2337         item->hCheckBit   = hNewCheck;
2338         item->hUnCheckBit = hNewUnCheck;
2339         item->item_flags |= MF_USECHECKBITMAPS;
2340     }
2341     return TRUE;
2342 }
2343
2344
2345 /**********************************************************************
2346  *                      CreateMenu              [USER.151]
2347  */
2348 HMENU CreateMenu()
2349 {
2350     HMENU hMenu;
2351     LPPOPUPMENU menu;
2352     dprintf_menu(stddeb,"CreateMenu !\n");
2353     if (!(hMenu = USER_HEAP_ALLOC( sizeof(POPUPMENU) )))
2354         return 0;
2355     menu = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu);
2356     menu->wFlags = 0;
2357     menu->wMagic = MENU_MAGIC;
2358     menu->hTaskQ = 0;
2359     menu->Width  = 0;
2360     menu->Height = 0;
2361     menu->nItems = 0;
2362     menu->hWnd   = 0;
2363     menu->items  = NULL;
2364     menu->FocusedItem = NO_SELECTED_ITEM;
2365     dprintf_menu(stddeb,"CreateMenu // return %04x\n", hMenu);
2366     return hMenu;
2367 }
2368
2369
2370 /**********************************************************************
2371  *                      DestroyMenu             [USER.152]
2372  */
2373 BOOL DestroyMenu(HMENU hMenu)
2374 {
2375     LPPOPUPMENU lppop;
2376     dprintf_menu(stddeb,"DestroyMenu (%04x) !\n", hMenu);
2377
2378     if (hMenu == 0) return FALSE;
2379     /* Silently ignore attempts to destroy default system menu */
2380     if (hMenu == MENU_DefSysMenu) return TRUE;
2381     lppop = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu);
2382     if (!lppop || (lppop->wMagic != MENU_MAGIC)) return FALSE;
2383     lppop->wMagic = 0;  /* Mark it as destroyed */
2384     if ((lppop->wFlags & MF_POPUP) && lppop->hWnd && lppop->hWnd != pTopPWnd->hwndSelf )
2385         DestroyWindow( lppop->hWnd );
2386
2387     if (lppop->items)
2388     {
2389         int i;
2390         MENUITEM *item = lppop->items;
2391         for (i = lppop->nItems; i > 0; i--, item++)
2392         {
2393             if (item->item_flags & MF_POPUP)
2394                 DestroyMenu( (HMENU)item->item_id );
2395             if (IS_STRING_ITEM(item->item_flags) && item->text)
2396                 HeapFree( SystemHeap, 0, item->text );
2397         }
2398         HeapFree( SystemHeap, 0, lppop->items );
2399     }
2400     USER_HEAP_FREE( hMenu );
2401     dprintf_menu(stddeb,"DestroyMenu (%04x) // End !\n", hMenu);
2402     return TRUE;
2403 }
2404
2405 /**********************************************************************
2406  *                      GetSystemMenu           [USER.156]
2407  */
2408 HMENU GetSystemMenu(HWND hWnd, BOOL bRevert)
2409 {
2410     WND *wndPtr = WIN_FindWndPtr( hWnd );
2411     if (!wndPtr) return 0;
2412
2413     if (!wndPtr->hSysMenu || (wndPtr->hSysMenu == MENU_DefSysMenu))
2414     {
2415         wndPtr->hSysMenu = MENU_CopySysMenu();
2416         return wndPtr->hSysMenu;
2417     }
2418     if (!bRevert) return wndPtr->hSysMenu;
2419     if (wndPtr->hSysMenu) DestroyMenu(wndPtr->hSysMenu);
2420     wndPtr->hSysMenu = MENU_CopySysMenu();
2421     return wndPtr->hSysMenu;
2422 }
2423
2424
2425 /*******************************************************************
2426  *         SetSystemMenu    (USER.280)
2427  */
2428 BOOL SetSystemMenu( HWND hwnd, HMENU hMenu )
2429 {
2430     WND *wndPtr;
2431
2432     if (!(wndPtr = WIN_FindWndPtr(hwnd))) return FALSE;
2433     if (wndPtr->hSysMenu && (wndPtr->hSysMenu != MENU_DefSysMenu))
2434         DestroyMenu( wndPtr->hSysMenu );
2435     wndPtr->hSysMenu = hMenu;
2436     return TRUE;
2437 }
2438
2439
2440 /**********************************************************************
2441  *                      GetMenu         [USER.157]
2442  */
2443 HMENU GetMenu(HWND hWnd)
2444 {
2445         WND * wndPtr = WIN_FindWndPtr(hWnd);
2446         if (wndPtr == NULL) return 0;
2447         return (HMENU)wndPtr->wIDmenu;
2448 }
2449
2450
2451 /**********************************************************************
2452  *                      SetMenu         [USER.158]
2453  */
2454 BOOL SetMenu(HWND hWnd, HMENU hMenu)
2455 {
2456         LPPOPUPMENU lpmenu;
2457         WND * wndPtr = WIN_FindWndPtr(hWnd);
2458         if (wndPtr == NULL) {
2459                 fprintf(stderr,"SetMenu(%04x, %04x) // Bad window handle !\n",
2460                         hWnd, hMenu);
2461                 return FALSE;
2462                 }
2463         dprintf_menu(stddeb,"SetMenu(%04x, %04x);\n", hWnd, hMenu);
2464         if (GetCapture() == hWnd) ReleaseCapture();
2465         wndPtr->wIDmenu = (UINT)hMenu;
2466         if (hMenu != 0)
2467         {
2468             lpmenu = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu);
2469             if (lpmenu == NULL) {
2470                 fprintf(stderr,"SetMenu(%04x, %04x) // Bad menu handle !\n",
2471                         hWnd, hMenu);
2472                 return FALSE;
2473                 }
2474             lpmenu->hWnd = hWnd;
2475             lpmenu->wFlags &= ~MF_POPUP;  /* Can't be a popup */
2476             lpmenu->Height = 0;  /* Make sure we recalculate the size */
2477         }
2478         if (IsWindowVisible(hWnd))
2479             SetWindowPos( hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
2480                           SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
2481         return TRUE;
2482 }
2483
2484
2485
2486 /**********************************************************************
2487  *                      GetSubMenu              [USER.159]
2488  */
2489 HMENU GetSubMenu(HMENU hMenu, short nPos)
2490 {
2491     LPPOPUPMENU lppop;
2492
2493     dprintf_menu(stddeb,"GetSubMenu (%04x, %04X) !\n", hMenu, nPos);
2494     if (!(lppop = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu))) return 0;
2495     if ((UINT)nPos >= lppop->nItems) return 0;
2496     if (!(lppop->items[nPos].item_flags & MF_POPUP)) return 0;
2497     return (HMENU)lppop->items[nPos].item_id;
2498 }
2499
2500
2501 /**********************************************************************
2502  *                      DrawMenuBar             [USER.160]
2503  */
2504 void DrawMenuBar(HWND hWnd)
2505 {
2506         WND             *wndPtr;
2507         LPPOPUPMENU lppop;
2508         dprintf_menu(stddeb,"DrawMenuBar (%04x)\n", hWnd);
2509         wndPtr = WIN_FindWndPtr(hWnd);
2510         if (wndPtr != NULL && (wndPtr->dwStyle & WS_CHILD) == 0 &&
2511                 wndPtr->wIDmenu != 0) {
2512                 dprintf_menu(stddeb,"DrawMenuBar wIDmenu=%04X \n",
2513                              wndPtr->wIDmenu);
2514                 lppop = (LPPOPUPMENU) USER_HEAP_LIN_ADDR((HMENU)wndPtr->wIDmenu);
2515                 if (lppop == NULL) return;
2516
2517                 lppop->Height = 0; /* Make sure we call MENU_MenuBarCalcSize */
2518                 SetWindowPos( hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
2519                             SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
2520             }
2521 }
2522
2523
2524 /***********************************************************************
2525  *           EndMenu   (USER.187)
2526  */
2527 void EndMenu(void)
2528 {
2529     /* FIXME: this won't work when we have multiple tasks... */
2530     fEndMenuCalled = TRUE;
2531 }
2532
2533
2534 /***********************************************************************
2535  *           LookupMenuHandle   (USER.217)
2536  */
2537 HMENU LookupMenuHandle( HMENU hmenu, INT id )
2538 {
2539     if (!MENU_FindItem( &hmenu, &id, MF_BYCOMMAND )) return 0;
2540     else return hmenu;
2541 }
2542
2543
2544 /**********************************************************************
2545  *          LoadMenu    (USER.150)
2546  */
2547 HMENU LoadMenu( HINSTANCE instance, SEGPTR name )
2548 {
2549     HRSRC hRsrc;
2550     HGLOBAL handle;
2551     HMENU hMenu;
2552
2553     if (HIWORD(name))
2554     {
2555         char *str = (char *)PTR_SEG_TO_LIN( name );
2556         dprintf_menu( stddeb, "LoadMenu(%04x,'%s')\n", instance, str );
2557         if (str[0] == '#') name = (SEGPTR)atoi( str + 1 );
2558     }
2559     else
2560         dprintf_resource(stddeb,"LoadMenu(%04x,%04x)\n",instance,LOWORD(name));
2561
2562     if (!name) return 0;
2563
2564     /* check for Win32 module */
2565     instance = GetExePtr( instance );
2566     if (MODULE_GetPtr(instance)->flags & NE_FFLAGS_WIN32)
2567         return WIN32_LoadMenuA(instance,PTR_SEG_TO_LIN(name));
2568
2569     if (!(hRsrc = FindResource( instance, name, RT_MENU ))) return 0;
2570     if (!(handle = LoadResource( instance, hRsrc ))) return 0;
2571     hMenu = LoadMenuIndirect16( LockResource(handle) );
2572     FreeResource( handle );
2573     return hMenu;
2574 }
2575
2576
2577 /**********************************************************************
2578  *          LoadMenuIndirect16    (USER.220)
2579  */
2580 HMENU16 LoadMenuIndirect16( LPCVOID template )
2581 {
2582     HMENU hMenu;
2583     WORD version, offset;
2584     LPCSTR p = (LPCSTR)template;
2585
2586     dprintf_menu(stddeb,"LoadMenuIndirect32A: %p\n", template );
2587     version = GET_WORD(p);
2588     p += sizeof(WORD);
2589     if (version)
2590     {
2591         fprintf( stderr, "LoadMenuIndirect16: version must be 0 for Win16\n" );
2592         return 0;
2593     }
2594     offset = GET_WORD(p);
2595     p += sizeof(WORD) + offset;
2596     if (!(hMenu = CreateMenu())) return 0;
2597     if (!MENU_ParseResource( p, hMenu, FALSE ))
2598     {
2599         DestroyMenu( hMenu );
2600         return 0;
2601     }
2602     return hMenu;
2603 }
2604
2605
2606 /**********************************************************************
2607  *          LoadMenuIndirect32A    (USER32.370)
2608  */
2609 HMENU32 LoadMenuIndirect32A( LPCVOID template )
2610 {
2611     HMENU hMenu;
2612     WORD version, offset;
2613     LPCSTR p = (LPCSTR)template;
2614
2615     dprintf_menu(stddeb,"LoadMenuIndirect32A: %p\n", template );
2616     version = GET_WORD(p);
2617     p += sizeof(WORD);
2618     if (version)
2619     {
2620         fprintf( stderr, "LoadMenuIndirect32A: version %d not supported.\n",
2621                  version );
2622         return 0;
2623     }
2624     offset = GET_WORD(p);
2625     p += sizeof(WORD) + offset;
2626     if (!(hMenu = CreateMenu())) return 0;
2627     if (!MENU_ParseResource( p, hMenu, TRUE ))
2628     {
2629         DestroyMenu( hMenu );
2630         return 0;
2631     }
2632     return hMenu;
2633 }
2634
2635
2636 /**********************************************************************
2637  *          LoadMenuIndirect32W    (USER32.371)
2638  */
2639 HMENU32 LoadMenuIndirect32W( LPCVOID template )
2640 {
2641     /* FIXME: is there anything different between A and W? */
2642     return LoadMenuIndirect32A( template );
2643 }
2644
2645
2646 /**********************************************************************
2647  *              IsMenu    (USER.358)
2648  */
2649 BOOL IsMenu( HMENU hmenu )
2650 {
2651     LPPOPUPMENU menu;
2652     if (!(menu = (LPPOPUPMENU) USER_HEAP_LIN_ADDR( hmenu ))) return FALSE;
2653     return (menu->wMagic == MENU_MAGIC);
2654 }