Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members  

winmenu.cpp

Go to the documentation of this file.
00001 /* $Id: winmenu.cpp,v 1.25 2000/01/18 20:11:17 sandervl Exp $ */
00002 
00003 /*
00004  * Win32 menu API functions for OS/2
00005  *
00006  * Copyright 1998 Sander van Leeuwen
00007  * Copyright 1998 Patrick Haller
00008  *
00009  * Parts ported from Wine:
00010  * Copyright 1993 Martin Ayotte
00011  * Copyright 1994 Alexandre Julliard
00012  * Copyright 1997 Morten Welinder
00013  *
00014  *
00015  * TODO: Set/GetMenu(Item)Info only partially implemented
00016  * TODO: Memory leak when deleting submenus
00017  * TODO: Check error nrs
00018  *
00019  * Project Odin Software License can be found in LICENSE.TXT
00020  *
00021  */
00022 #include <os2win.h>
00023 #include <odin.h>
00024 #include <odinwrap.h>
00025 #include <stdlib.h>
00026 #include <string.h>
00027 #include <win32wbase.h>
00028 #include "oslibmenu.h"
00029 #include "oslibwin.h"
00030 #include "winmenudef.h"
00031 
00032 ODINDEBUGCHANNEL(USER32)
00033 
00034 BOOL  ODIN_INTERNAL ODIN_InsertMenuA(HMENU,UINT,UINT,UINT,LPCSTR);
00035 BOOL  ODIN_INTERNAL ODIN_InsertMenuW(HMENU,UINT,UINT,UINT,LPCWSTR);
00036 BOOL  ODIN_INTERNAL ODIN_InsertMenuItemA(HMENU,UINT,BOOL,const MENUITEMINFOA*);
00037 BOOL  ODIN_INTERNAL ODIN_InsertMenuItemW(HMENU,UINT,BOOL,const MENUITEMINFOW*);
00038 BOOL  ODIN_INTERNAL ODIN_AppendMenuA(HMENU,UINT,UINT,LPCSTR);
00039 BOOL  ODIN_INTERNAL ODIN_AppendMenuW(HMENU,UINT,UINT,LPCWSTR);
00040 HMENU ODIN_INTERNAL ODIN_CreateMenu(void);
00041 HMENU ODIN_INTERNAL ODIN_CreatePopupMenu(void);
00042 BOOL  ODIN_INTERNAL ODIN_DestroyMenu(HMENU);
00043 BOOL  ODIN_INTERNAL ODIN_DeleteMenu(HMENU, UINT, UINT);
00044 
00045 //@@@PH: experiment with WINE LoadMenuIndirect code
00046 #include <heapstring.h>
00047 #define MENU_ITEM_TYPE(flags) \
00048   ((flags) & (MF_STRING | MF_BITMAP | MF_OWNERDRAW | MF_SEPARATOR))
00049 
00050 #define IS_STRING_ITEM(flags) (MENU_ITEM_TYPE ((flags)) == MF_STRING)
00051 #define IS_BITMAP_ITEM(flags) (MENU_ITEM_TYPE ((flags)) == MF_BITMAP)
00052 
00053 /**********************************************************************
00054  *         MENU_ParseResource
00055  *
00056  * Parse a standard menu resource and add items to the menu.
00057  * Return a pointer to the end of the resource.
00058  */
00059 static LPCSTR MENU_ParseResource( LPCSTR res, HMENU hMenu)
00060 {
00061     WORD flags, id = 0;
00062     LPCSTR str;
00063 
00064     do
00065     {
00066         flags = GET_WORD(res);
00067         res += sizeof(WORD);
00068         if (!(flags & MF_POPUP))
00069         {
00070             id = GET_WORD(res);
00071             res += sizeof(WORD);
00072         }
00073         if (!IS_STRING_ITEM(flags))
00074             dprintf(("USER32: WinMenu: MENU_ParseResource: not a string item %04x\n", flags ));
00075         str = res;
00076 
00077         res += (lstrlenW((LPCWSTR)str) + 1) * sizeof(WCHAR);
00078         if (flags & MF_POPUP)
00079         {
00080             HMENU hSubMenu = ODIN_CreatePopupMenu();
00081             if (!hSubMenu) return NULL;
00082             if (!(res = MENU_ParseResource( res, hSubMenu)))
00083                 return NULL;
00084             ODIN_AppendMenuW( hMenu, flags, (UINT)hSubMenu, (LPCWSTR)str );
00085         }
00086         else  /* Not a popup */
00087         {
00088             ODIN_AppendMenuW( hMenu, flags, id, *(LPCWSTR)str ? (LPCWSTR)str : NULL );
00089         }
00090     } while (!(flags & MF_END));
00091     return res;
00092 }
00093 
00094 
00095 /**********************************************************************
00096  *         MENUEX_ParseResource
00097  *
00098  * Parse an extended menu resource and add items to the menu.
00099  * Return a pointer to the end of the resource.
00100  */
00101 static LPCSTR MENUEX_ParseResource( LPCSTR res, HMENU hMenu)
00102 {
00103    WORD resinfo;
00104 
00105     do {
00106         MENUITEMINFOW mii;
00107 
00108         mii.cbSize = sizeof(mii);
00109         mii.fMask = MIIM_STATE | MIIM_ID | MIIM_TYPE;
00110         mii.fType = GET_DWORD(res);
00111         res += sizeof(DWORD);
00112         mii.fState = GET_DWORD(res);
00113         res += sizeof(DWORD);
00114         mii.wID = GET_DWORD(res);
00115         res += sizeof(DWORD);
00116         resinfo = GET_WORD(res); /* FIXME: for 16-bit apps this is a byte.  */
00117         res += sizeof(WORD);
00118 
00119         /* Align the text on a word boundary.  */
00120         res += (~((int)res - 1)) & 1;
00121         mii.dwTypeData = (LPWSTR) res;
00122         res += (1 + lstrlenW(mii.dwTypeData)) * sizeof(WCHAR);
00123         /* Align the following fields on a dword boundary.  */
00124         res += (~((int)res - 1)) & 3;
00125 
00126         /* FIXME: This is inefficient and cannot be optimised away by gcc.  */
00127         {
00128             LPSTR newstr = HEAP_strdupWtoA(GetProcessHeap(), 0, mii.dwTypeData);
00129 
00130             dprintf(("USER32:WinMenu:MENUEX_ParseResource Menu item: [%08x,%08x,%04x,%04x,%s]\n",
00131                      mii.fType, mii.fState, mii.wID, resinfo, newstr));
00132             HeapFree( GetProcessHeap(), 0, newstr );
00133         }
00134 
00135         if (resinfo & 1) {                    /* Pop-up? */
00136             /* DWORD helpid = GET_DWORD(res); FIXME: use this.  */
00137             res += sizeof(DWORD);
00138             mii.hSubMenu = ODIN_CreatePopupMenu();
00139             if (!mii.hSubMenu)
00140                 return NULL;
00141             if (!(res = MENUEX_ParseResource(res, mii.hSubMenu))) {
00142                 DestroyMenu(mii.hSubMenu);
00143                 return NULL;
00144             }
00145             mii.fMask |= MIIM_SUBMENU;
00146             mii.fType |= MF_POPUP;
00147         }
00148         ODIN_InsertMenuItemW(hMenu, -1, MF_BYPOSITION, &mii);
00149     }
00150     while (!(resinfo & MF_END));
00151 
00152     return res;
00153 }
00154 /**********************************************************************
00155  *    myLoadMenuIndirect
00156  */
00157 HMENU myLoadMenuIndirect(LPCVOID pMenuTemplate)
00158 {
00159   HMENU hMenu;
00160   WORD  version,
00161         offset;
00162   LPCSTR p = (LPCSTR)pMenuTemplate;
00163 
00164     version = GET_WORD(p);
00165     p += sizeof(WORD);
00166 
00167     switch (version)
00168     {
00169     case 0:
00170         offset = GET_WORD(p);
00171         p += sizeof(WORD) + offset;
00172         if (!(hMenu = ODIN_CreateMenu()))
00173             return 0;
00174         if (!MENU_ParseResource( p, hMenu))
00175         {
00176             DestroyMenu( hMenu );
00177             return 0;
00178         }
00179         return hMenu;
00180 
00181     case 1:
00182         offset = GET_WORD(p);
00183         p += sizeof(WORD) + offset;
00184         if (!(hMenu = ODIN_CreateMenu()))
00185             return 0;
00186         if (!MENUEX_ParseResource( p, hMenu))
00187         {
00188             ODIN_DestroyMenu( hMenu );
00189             return 0;
00190         }
00191         return hMenu;
00192 
00193     default:
00194         dprintf(("USER32: LoadMenuIndirectA: version %d not supported.\n", version));
00195         return 0;
00196     }
00197 }
00198 //******************************************************************************
00199 //******************************************************************************
00200 void SetInternalMenuInfo(HMENU hMenu)
00201 {
00202   LPPOPUPMENU lpMenuInfo;
00203 
00204     lpMenuInfo = (LPPOPUPMENU)malloc(sizeof(*lpMenuInfo));
00205     memset(lpMenuInfo, 0, sizeof(*lpMenuInfo));
00206     OSLibWinSetWindowULong(hMenu, OSLIB_QWL_USER, (ULONG)lpMenuInfo);
00207 }
00208 //******************************************************************************
00209 //******************************************************************************
00210 LPPOPUPMENU GetInternalMenuInfo(HMENU hMenu)
00211 {
00212     return (LPPOPUPMENU)OSLibWinGetWindowULong(hMenu, OSLIB_QWL_USER);
00213 }
00214 //******************************************************************************
00215 //******************************************************************************
00216 void DeleteInternalMenuInfo(HMENU hMenu)
00217 {
00218   LPPOPUPMENU lpMenuInfo;
00219 
00220     lpMenuInfo = (LPPOPUPMENU)OSLibWinGetWindowULong(hMenu, OSLIB_QWL_USER);
00221     if(lpMenuInfo) {
00222         free(lpMenuInfo);
00223         OSLibWinSetWindowULong(hMenu, OSLIB_QWL_USER, 0);
00224     }
00225 }
00226 //******************************************************************************
00227 //******************************************************************************
00228 ODINFUNCTION0(HMENU, CreateMenu)
00229 {
00230   HMENU hMenu;
00231 
00232     dprintf(("USER32: CreateMenu\n"));
00233 
00234     hMenu = OSLibWinCreateEmptyMenu();
00235     if(hMenu) {
00236             SetInternalMenuInfo(hMenu);
00237     }
00238     else    SetLastError(ERROR_INVALID_PARAMETER); //wrong error
00239 
00240     return hMenu;
00241 }
00242 //******************************************************************************
00243 //******************************************************************************
00244 ODINFUNCTION0(HMENU, CreatePopupMenu)
00245 {
00246   HMENU hMenu;
00247 
00248     dprintf(("USER32: CreatePopupMenu\n"));
00249 
00250     hMenu = OSLibWinCreateEmptyPopupMenu();
00251     if(hMenu) {
00252             SetInternalMenuInfo(hMenu);
00253     }
00254     else    SetLastError(ERROR_INVALID_PARAMETER); //wrong error
00255 
00256     return hMenu;
00257 }
00258 //******************************************************************************
00259 //******************************************************************************
00260 ODINFUNCTION2(HMENU,     LoadMenuA,
00261               HINSTANCE, hinst,
00262               LPCSTR,    lpszMenu)
00263 {
00264   Win32Resource *winres;
00265   HMENU hMenu;
00266 
00267     winres = (Win32Resource *)FindResourceA(hinst, lpszMenu, RT_MENUA);
00268     if(winres)
00269     {
00270         hMenu = myLoadMenuIndirect((MENUITEMTEMPLATEHEADER *)winres->lockResource());
00271         if(hMenu) {
00272                 SetInternalMenuInfo(hMenu);
00273         }
00274         else    SetLastError(ERROR_INVALID_PARAMETER);
00275 
00276         delete winres;
00277         return hMenu;
00278     }
00279     return 0;
00280 }
00281 //******************************************************************************
00282 //******************************************************************************
00283 ODINFUNCTION2(HMENU, LoadMenuW,
00284               HINSTANCE, hinst,
00285               LPCWSTR, lpszMenu)
00286 {
00287   Win32Resource *winres;
00288   HMENU hMenu;
00289 
00290     winres = (Win32Resource *)FindResourceW(hinst, lpszMenu, RT_MENUW);
00291     if(winres) {
00292         hMenu = myLoadMenuIndirect((MENUITEMTEMPLATEHEADER *)winres->lockResource());
00293         if(hMenu) {
00294                 SetInternalMenuInfo(hMenu);
00295         }
00296         else    SetLastError(ERROR_INVALID_PARAMETER);
00297 
00298         delete winres;
00299         return hMenu;
00300     }
00301     return 0;
00302 }
00303 //******************************************************************************
00304 //NOTE: menutemplate strings are always in Unicode format
00305 //******************************************************************************
00306 ODINFUNCTION1(HMENU, LoadMenuIndirectW,
00307               const MENUITEMTEMPLATEHEADER *, menuTemplate)
00308 {
00309   HMENU hMenu;
00310 
00311     hMenu = myLoadMenuIndirect(menuTemplate);
00312     if(hMenu) {
00313             SetInternalMenuInfo(hMenu);
00314     }
00315     else    SetLastError(ERROR_INVALID_PARAMETER);
00316 
00317     return (HMENU)hMenu;
00318 }
00319 //******************************************************************************
00320 //******************************************************************************
00321 ODINFUNCTION1(BOOL,  DestroyMenu,
00322               HMENU, hMenu)
00323 {
00324     if(hMenu == 0)
00325     {
00326         SetLastError(ERROR_INVALID_PARAMETER);
00327         return 0;
00328     }
00329     DeleteInternalMenuInfo(hMenu);
00330     return O32_DestroyMenu(hMenu);
00331 }
00332 //******************************************************************************
00333 //******************************************************************************
00334 ODINFUNCTION1(HMENU, GetMenu,
00335               HWND,  hwnd)
00336 {
00337   Win32BaseWindow *window;
00338 
00339     window = Win32BaseWindow::GetWindowFromHandle(hwnd);
00340     if(!window)
00341     {
00342         dprintf(("GetMenu, window %x not found", hwnd));
00343         SetLastError(ERROR_INVALID_WINDOW_HANDLE);
00344         return 0;
00345     }
00346 
00347     return window->GetMenu();
00348 }
00349 //******************************************************************************
00350 //******************************************************************************
00351 ODINFUNCTION2(BOOL,  SetMenu,
00352               HWND,  hwnd,
00353               HMENU, hMenu)
00354 {
00355   Win32BaseWindow *window;
00356 
00357     window = Win32BaseWindow::GetWindowFromHandle(hwnd);
00358     if(!window)
00359     {
00360         dprintf(("SetMenu, window %x not found", hwnd));
00361         SetLastError(ERROR_INVALID_WINDOW_HANDLE);
00362         return 0;
00363     }
00364 
00365     window->SetMenu(hMenu);
00366     return TRUE;
00367 }
00368 //******************************************************************************
00369 //******************************************************************************
00370 ODINFUNCTION0(DWORD, GetMenuCheckMarkDimensions)
00371 {
00372   return O32_GetMenuCheckMarkDimensions();
00373 }
00374 //******************************************************************************
00375 //******************************************************************************
00376 ODINFUNCTION1(int,   GetMenuItemCount,
00377               HMENU, hMenu)
00378 {
00379     if(hMenu == 0)
00380     {
00381         SetLastError(ERROR_INVALID_PARAMETER);
00382         return 0;
00383     }
00384     return OSLibGetMenuItemCount(hMenu);
00385 }
00386 //******************************************************************************
00387 //******************************************************************************
00388 ODINFUNCTION2(UINT,  GetMenuItemID,
00389               HMENU, hMenu,
00390               int,   nPos)
00391 {
00392     if(hMenu == 0)
00393     {
00394         SetLastError(ERROR_INVALID_PARAMETER);
00395         return 0;
00396     }
00397     return O32_GetMenuItemID(hMenu, nPos);
00398 }
00399 //******************************************************************************
00400 //******************************************************************************
00401 ODINFUNCTION3(UINT,  GetMenuState,
00402               HMENU, hMenu,
00403               UINT,  arg2,
00404               UINT,  arg3)
00405 {
00406     if(hMenu == 0)
00407     {
00408         SetLastError(ERROR_INVALID_PARAMETER);
00409         return 0;
00410     }
00411 
00412     return O32_GetMenuState(hMenu, arg2, arg3);
00413 }
00414 //******************************************************************************
00415 //******************************************************************************
00416 ODINFUNCTION5(int,   GetMenuStringA,
00417               HMENU, hMenu,
00418               UINT,  idItem,
00419               LPSTR, lpsz,
00420               int,   cchMax,
00421               UINT,  fuFlags)
00422 {
00423  int rc, nritems;
00424 
00425     if(hMenu == 0)
00426     {
00427         SetLastError(ERROR_INVALID_PARAMETER);
00428         return 0;
00429     }
00430     if(!lpsz || !cchMax) {//determine menu string length
00431         char menustr[256];
00432         rc = O32_GetMenuString(hMenu, idItem, menustr, sizeof(menustr), fuFlags);
00433         //SvL: Open32 returns the wrong error
00434         return (rc == -1) ? 0 : rc;
00435     }
00436     rc = O32_GetMenuString(hMenu, idItem, lpsz, cchMax, fuFlags);
00437     //SvL: Open32 returns the wrong error
00438     return (rc == -1) ? 0 : rc;
00439 }
00440 //******************************************************************************
00441 //******************************************************************************
00442 ODINFUNCTION5(int,   GetMenuStringW,
00443               HMENU, hMenu,
00444               UINT,  idItem,
00445               LPWSTR,lpsz,
00446               int,   cchMax,
00447               UINT,  fuFlags)
00448 {
00449   char *astring = (char *)malloc(cchMax);
00450   int   rc;
00451 
00452     rc = ODIN_GetMenuStringA(hMenu, idItem, astring, cchMax, fuFlags);
00453     if(rc)
00454     {
00455             dprintf(("USER32: GetMenuStringW %s\n", astring));
00456             AsciiToUnicode(astring, lpsz);
00457     }
00458     else    lpsz[0] = 0;
00459     free(astring);
00460 
00461     return(rc);
00462 }
00463 //******************************************************************************
00464 //******************************************************************************
00465 ODINFUNCTION5(BOOL, SetMenuItemBitmaps,
00466               HMENU, hMenu,
00467               UINT, arg2,
00468               UINT, arg3,
00469               HBITMAP, arg4,
00470               HBITMAP, arg5)
00471 {
00472     dprintf(("USER32:  SetMenuItemBitmaps\n"));
00473     if(hMenu == 0)
00474     {
00475         SetLastError(ERROR_INVALID_PARAMETER);
00476         return 0;
00477     }
00478     return O32_SetMenuItemBitmaps(hMenu, arg2, arg3, arg4, arg5);
00479 }
00480 //******************************************************************************
00481 //******************************************************************************
00482 ODINFUNCTION2(HMENU, GetSubMenu,
00483               HWND, hMenu,
00484               int, arg2)
00485 {
00486     if(hMenu == 0)
00487     {
00488         SetLastError(ERROR_INVALID_PARAMETER);
00489         return 0;
00490     }
00491 
00492     return O32_GetSubMenu(hMenu, arg2);
00493 }
00494 //******************************************************************************
00495 //******************************************************************************
00496 ODINFUNCTION2(HMENU, GetSystemMenu,
00497               HWND,  hSystemWindow,
00498               BOOL,  bRevert)
00499 {
00500     Win32BaseWindow *window;
00501 
00502     window = Win32BaseWindow::GetWindowFromHandle(hSystemWindow);
00503     if(!window)
00504     {
00505         dprintf(("GetSystemMenu, window %x not found", hSystemWindow));
00506         return 0;
00507     }
00508 
00509     return window->GetSystemMenu(bRevert);
00510 }
00511 //******************************************************************************
00512 //******************************************************************************
00513 ODINFUNCTION1(BOOL, IsMenu,
00514               HMENU, hMenu)
00515 {
00516     dprintf(("USER32:  IsMenu\n"));
00517     return O32_IsMenu(hMenu);
00518 }
00519 //******************************************************************************
00520 //******************************************************************************
00521 ODINFUNCTION7(BOOL, TrackPopupMenu,
00522               HMENU, hMenu,
00523               UINT, arg2,
00524               int, arg3,
00525               int, arg4,
00526               int, arg5,
00527               HWND, arg6,
00528               const RECT *, arg7)
00529 {
00530   Win32BaseWindow *window;
00531 
00532     window = Win32BaseWindow::GetWindowFromHandle(arg6);
00533     if(!window)
00534     {
00535         dprintf(("TrackPopupMenu, window %x not found", arg6));
00536         SetLastError(ERROR_INVALID_WINDOW_HANDLE);
00537         return 0;
00538     }
00539     dprintf(("USER32:  TrackPopupMenu\n"));
00540     if(hMenu == 0)
00541     {
00542         SetLastError(ERROR_INVALID_PARAMETER);
00543         return 0;
00544     }
00545     return O32_TrackPopupMenu(hMenu, arg2, arg3, arg4, arg5, window->getOS2WindowHandle(),
00546                               arg7);
00547 }
00548 //******************************************************************************
00549 //******************************************************************************
00550 ODINFUNCTION6(BOOL, TrackPopupMenuEx,
00551               HMENU, hMenu,
00552               UINT, flags,
00553               int, X,
00554               int, Y,
00555               HWND, hwnd,
00556               LPTPMPARAMS, lpPM)
00557 {
00558   RECT *rect = NULL;
00559   Win32BaseWindow *window;
00560 
00561     window = Win32BaseWindow::GetWindowFromHandle(hwnd);
00562     if(!window)
00563     {
00564         dprintf(("TrackPopupMenu, window %x not found", hwnd));
00565         SetLastError(ERROR_INVALID_WINDOW_HANDLE);
00566         return 0;
00567     }
00568 
00569     dprintf(("USER32:  TrackPopupMenuEx, not completely implemented\n"));
00570 
00571     if (lpPM != NULL) // this parameter can be NULL
00572       if(lpPM->cbSize != 0)
00573         rect = &lpPM->rcExclude;
00574 
00575     if(hMenu == 0)
00576     {
00577         SetLastError(ERROR_INVALID_PARAMETER);
00578         return 0;
00579     }
00580     return O32_TrackPopupMenu(hMenu, flags, X, Y, 0, window->getOS2WindowHandle(), rect);
00581 }
00582 //******************************************************************************
00583 //******************************************************************************
00584 ODINFUNCTION4(BOOL, AppendMenuA,
00585               HMENU, hMenu,
00586               UINT, uFlags,
00587               UINT, id,
00588               LPCSTR, lpNewItem)
00589 {
00590      return ODIN_InsertMenuA( hMenu, -1, uFlags | MF_BYPOSITION, id, lpNewItem );
00591 }
00592 //******************************************************************************
00593 //******************************************************************************
00594 ODINFUNCTION4(BOOL, AppendMenuW,
00595               HMENU, hMenu,
00596               UINT, uFlags,
00597               UINT, id,
00598               LPCWSTR, lpNewItem)
00599 {
00600      return ODIN_InsertMenuW( hMenu, -1, uFlags | MF_BYPOSITION, id, lpNewItem );
00601 }
00602 //******************************************************************************
00603 //******************************************************************************
00604 ODINFUNCTION3(DWORD, CheckMenuItem,
00605               HMENU, hMenu,
00606               UINT, arg2,
00607               UINT, arg3)
00608 {
00609     if(hMenu == 0)
00610     {
00611         SetLastError(ERROR_INVALID_PARAMETER);
00612         return 0;
00613     }
00614     return O32_CheckMenuItem(hMenu, arg2, arg3);
00615 }
00616 //******************************************************************************
00617 //******************************************************************************
00618 ODINFUNCTION3(BOOL,EnableMenuItem,HMENU,hMenu,
00619                                   UINT, uIDEnableItem,
00620                                   UINT, uEnable)
00621 {
00622     if(hMenu == 0)
00623     {
00624         SetLastError(ERROR_INVALID_PARAMETER);
00625         return 0;
00626     }
00627 
00628     return O32_EnableMenuItem(hMenu,
00629                               uIDEnableItem,
00630                               uEnable);
00631 }
00632 //******************************************************************************
00633 //******************************************************************************
00634 ODINFUNCTION5(BOOL, ModifyMenuA,
00635               HMENU, hMenu,
00636               UINT, uItem,
00637               UINT, fuFlags,
00638               UINT, idNewItem,
00639               LPCSTR, lpszNewItem)
00640 {
00641     if(hMenu == 0)
00642     {
00643         SetLastError(ERROR_INVALID_PARAMETER);
00644         return 0;
00645     }
00646     if(IS_STRING_ITEM(fuFlags) && HIWORD(lpszNewItem) != 0) {
00647         dprintf(("ModifyMenuA %s", lpszNewItem));
00648     }
00649 /* //CB: doesn't compile, but don't need it anyway
00650     if(((fuFlags & (MF_BYCOMMAND|MF_BYPOSITION|MF_POPUP)) == MF_BYCOMMAND) && uItem != idNewItem) {
00651         DWORD pos = OSLibGetMenuItemPos(hMenu, uItem);
00652         ODIN_DeleteMenu(hMenu, uItem, MF_BYCOMMAND);
00653         return ODIN_InsertMenuA(hMenu, pos, fuFlags | MF_BYPOSITION, idNewItem, lpszNewItem);
00654     }
00655 */
00656     return O32_ModifyMenu(hMenu, uItem, fuFlags, idNewItem, lpszNewItem);
00657 }
00658 //******************************************************************************
00659 //******************************************************************************
00660 ODINFUNCTION5(BOOL, ModifyMenuW,
00661               HMENU, hMenu,
00662               UINT, arg2,
00663               UINT, arg3,
00664               UINT, arg4,
00665               LPCWSTR, arg5)
00666 {
00667  BOOL  rc;
00668  char *astring = NULL;
00669 
00670     if(hMenu == 0)
00671     {
00672         SetLastError(ERROR_INVALID_PARAMETER);
00673         return 0;
00674     }
00675 
00676     if(IS_STRING_ITEM(arg3) && HIWORD(arg5) != 0)
00677       astring = UnicodeToAsciiString((LPWSTR)arg5);
00678     else
00679       astring = (char *) arg5;
00680 
00681     rc = ODIN_ModifyMenuA(hMenu, arg2, arg3, arg4, astring);
00682     if(IS_STRING_ITEM(arg3) && HIWORD(arg5) != 0)
00683       FreeAsciiString(astring);
00684 
00685     return(rc);
00686 }
00687 //******************************************************************************
00688 //******************************************************************************
00689 ODINFUNCTION3(BOOL, RemoveMenu,
00690               HMENU, hMenu,
00691               UINT, arg2,
00692               UINT, arg3)
00693 {
00694     if(hMenu == 0)
00695     {
00696         SetLastError(ERROR_INVALID_PARAMETER);
00697         return 0;
00698     }
00699 
00700     return O32_RemoveMenu(hMenu, arg2, arg3);
00701 }
00702 //******************************************************************************
00703 //******************************************************************************
00704 ODINFUNCTION3(BOOL, DeleteMenu,
00705               HMENU, hMenu,
00706               UINT, arg2,
00707               UINT, arg3)
00708 {
00709     if(hMenu == 0)
00710     {
00711         SetLastError(ERROR_INVALID_PARAMETER);
00712         return 0;
00713     }
00714 
00715     return O32_DeleteMenu(hMenu, arg2, arg3);
00716 }
00717 //******************************************************************************
00718 //******************************************************************************
00719 ODINFUNCTION4(BOOL, HiliteMenuItem,
00720               HWND, hMenu,
00721               HMENU, arg2,
00722               UINT, arg3,
00723               UINT, arg4)
00724 {
00725     dprintf(("USER32:  OS2HiliteMenuItem\n"));
00726     if(hMenu == 0)
00727     {
00728         SetLastError(ERROR_INVALID_PARAMETER);
00729         return 0;
00730     }
00731 
00732     return O32_HiliteMenuItem(hMenu, arg2, arg3, arg4);
00733 }
00734 //******************************************************************************
00735 //******************************************************************************
00736 ODINFUNCTION5(BOOL, InsertMenuA,
00737               HMENU, hMenu,
00738               UINT, pos,
00739               UINT, flags,
00740               UINT, id,
00741               LPCSTR, str)
00742 {
00743     if(IS_STRING_ITEM(flags) && HIWORD(str)) {
00744          dprintf(("USER32: InsertMenuA %x %d %x %d %s", hMenu, pos, flags, id, str));
00745     }
00746     else dprintf(("USER32: InsertMenuA %x %d %x %d %x", hMenu, pos, flags, id, str));
00747 
00748     if(hMenu == 0)
00749     {
00750         SetLastError(ERROR_INVALID_PARAMETER);
00751         return 0;
00752     }
00753 
00754     if(IS_STRING_ITEM(flags) && (!str || *str == NULL)) {
00755         flags |= MF_SEPARATOR;
00756     }
00757     //SvL: RealPlayer calls InsertMenu with flag 0 & pos -1
00758     if((flags & (MF_BYCOMMAND|MF_BYPOSITION)) == 0 && (pos == 0xffffffff))
00759         flags |= MF_BYPOSITION;
00760 
00761     return O32_InsertMenu(hMenu, pos, flags, id, str);
00762 }
00763 //******************************************************************************
00764 //******************************************************************************
00765 ODINFUNCTION5(BOOL, InsertMenuW,
00766               HMENU, hMenu,
00767               UINT, arg2,
00768               UINT, arg3,
00769               UINT, arg4,
00770               LPCWSTR, arg5)
00771 {
00772  BOOL  rc;
00773  char *astring = NULL;
00774 
00775     if(IS_STRING_ITEM(arg3) && HIWORD(arg5) != 0)
00776       astring = UnicodeToAsciiString((LPWSTR)arg5);
00777     else
00778       astring = (char *) arg5;
00779 
00780     rc = ODIN_InsertMenuA(hMenu, arg2, arg3, arg4, astring);
00781 
00782     if(IS_STRING_ITEM(arg3) && HIWORD(arg5) != 0)
00783       FreeAsciiString(astring);
00784 
00785     return(rc);
00786 }
00787 //******************************************************************************
00788 //******************************************************************************
00789 ODINFUNCTION2(BOOL, SetMenuContextHelpId,
00790               HMENU, hMenu,
00791               DWORD, dwContextHelpId)
00792 {
00793  POPUPMENU *menu;
00794 
00795     menu = GetInternalMenuInfo(hMenu);
00796     if(menu == NULL) {
00797         dprintf(("USER32: SetMenuContextHelpId(%x) No POPUPMENU structure found!", hMenu));
00798         SetLastError(ERROR_INVALID_PARAMETER);
00799         return FALSE;
00800     }
00801     dprintf(("USER32:  SetMenuContextHelpId %x %d", hMenu, dwContextHelpId));
00802     menu->dwContextHelpID = dwContextHelpId;
00803     return(TRUE);
00804 }
00805 //******************************************************************************
00806 //******************************************************************************
00807 ODINFUNCTION1(DWORD, GetMenuContextHelpId,
00808               HMENU, hMenu)
00809 {
00810  POPUPMENU *menu;
00811 
00812     menu = GetInternalMenuInfo(hMenu);
00813     if(menu == NULL) {
00814         dprintf(("USER32: GetMenuContextHelpId(%x) No POPUPMENU structure found!", hMenu));
00815         SetLastError(ERROR_INVALID_PARAMETER);
00816         return 0;
00817     }
00818     dprintf(("USER32:  GetMenuContextHelpId %x %d", hMenu, menu->dwContextHelpID));
00819     return menu->dwContextHelpID;
00820 }
00821 //******************************************************************************
00822 //******************************************************************************
00823 ODINFUNCTION5(BOOL, CheckMenuRadioItem,
00824               HMENU, hMenu,
00825               UINT, idFirst,
00826               UINT, idLast,
00827               UINT, idCheck,
00828               UINT, uFlags)
00829 {
00830   dprintf(("USER32:  OS2CheckMenuRadioItem, not implemented\n"));
00831   return(TRUE);
00832 }
00833 //******************************************************************************
00834 //******************************************************************************
00835 ODINFUNCTION5(BOOL, ChangeMenuA,
00836               HMENU, hMenu,
00837               UINT, pos,
00838               LPCSTR, data,
00839               UINT, id,
00840               UINT, flags)
00841 {
00842     dprintf(("USER32:  ChangeMenuA flags %X\n", flags));
00843 
00844     if (flags & MF_APPEND) return ODIN_AppendMenuA(hMenu, flags & ~MF_APPEND,
00845                                                    id, data );
00846     if (flags & MF_DELETE) return ODIN_DeleteMenu(hMenu, pos, flags & ~MF_DELETE);
00847     if (flags & MF_CHANGE) return ODIN_ModifyMenuA(hMenu, pos, flags & ~MF_CHANGE,
00848                                                    id, data );
00849     if (flags & MF_REMOVE) return ODIN_RemoveMenu(hMenu,
00850                                                   flags & MF_BYPOSITION ? pos : id,
00851                                                   flags & ~MF_REMOVE );
00852     /* Default: MF_INSERT */
00853     return InsertMenuA( hMenu, pos, flags, id, data );
00854 }
00855 //******************************************************************************
00856 //******************************************************************************
00857 ODINFUNCTION5(BOOL, ChangeMenuW,
00858               HMENU, hMenu,
00859               UINT, pos,
00860               LPCWSTR, data,
00861               UINT, id,
00862               UINT, flags)
00863 {
00864     dprintf(("USER32:  ChangeMenuW flags %X\n", flags));
00865 
00866     if (flags & MF_APPEND) return ODIN_AppendMenuW(hMenu, flags & ~MF_APPEND,
00867                                                    id, data );
00868     if (flags & MF_DELETE) return ODIN_DeleteMenu(hMenu, pos, flags & ~MF_DELETE);
00869     if (flags & MF_CHANGE) return ODIN_ModifyMenuW(hMenu, pos, flags & ~MF_CHANGE,
00870                                                    id, data );
00871     if (flags & MF_REMOVE) return ODIN_RemoveMenu(hMenu,
00872                                                   flags & MF_BYPOSITION ? pos : id,
00873                                                      flags & ~MF_REMOVE );
00874     /* Default: MF_INSERT */
00875     return InsertMenuW(hMenu, pos, flags, id, data);
00876 }
00877 //******************************************************************************
00878 //******************************************************************************
00879 ODINFUNCTION4(BOOL, SetMenuItemInfoA,
00880               HMENU, hMenu,
00881               UINT, par1,
00882               BOOL, par2,
00883               const MENUITEMINFOA *, lpmii)
00884 {
00885     dprintf(("USER32:  SetMenuItemInfoA faked %x", hMenu));
00886 
00887     if (!hMenu) {
00888         SetLastError(ERROR_INVALID_PARAMETER);
00889         return FALSE;
00890     }
00891     return TRUE;
00892 }
00893 /*****************************************************************************
00894  * Function  : SetMenuItemInfoW
00895  * Purpose   : The SetMenuItemInfo function changes information about a menu item.
00896  * Parameters:
00897  * Variables :
00898  * Result    : If the function succeeds, the return value is TRUE.
00899  *             If the function fails, the return value is FALSE. To get extended
00900  *               error information, use the GetLastError function.
00901  * Remark    :
00902  * Status    : UNTESTED STUB
00903  *
00904  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
00905  *****************************************************************************/
00906 
00907 ODINFUNCTION4(BOOL, SetMenuItemInfoW,
00908               HMENU, hMenu,
00909               UINT, uItem,
00910               BOOL, fByPosition,
00911               const MENUITEMINFOW *, lpmmi)
00912 {
00913   dprintf(("USER32:SetMenuItemInfoW (%08xh,%08xh,%08xh,%08x) not implemented.\n",
00914          hMenu,
00915          uItem,
00916          fByPosition,
00917          lpmmi));
00918 
00919   return (SetMenuItemInfoA(hMenu,
00920                            uItem,
00921                            fByPosition,
00922                            (const MENUITEMINFOA *)lpmmi));
00923 }
00924 /*****************************************************************************
00925  * Function  : GetMenuDefaultItem
00926  * Purpose   : TheGetMenuDefaultItem function determines the default menu item
00927  *             on the specified menu.
00928  * Parameters:
00929  * Variables :
00930  * Result    : If the function succeeds, the return value is the identifier or
00931  *             position of the menu item.
00932  *             If the function fails, the return value is - 1.
00933  * Remark    :
00934  * Status    : UNTESTED STUB
00935  *
00936  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
00937  *****************************************************************************/
00938 
00939 ODINFUNCTION3(UINT, GetMenuDefaultItem,
00940               HMENU, hMenu,
00941               UINT, fByPos,
00942               UINT, gmdiFlags)
00943 {
00944   dprintf(("USER32:GetMenuDefaultItem (%08xh,%u,%08x) not implemented.\n",
00945          hMenu,
00946          fByPos,
00947          gmdiFlags));
00948 
00949   return (-1);
00950 }
00951 //******************************************************************************
00952 //******************************************************************************
00953 ODINFUNCTION3(BOOL, SetMenuDefaultItem,
00954               HMENU, hMenu,
00955               UINT, uItem,
00956               UINT, fByPos)
00957 {
00958     dprintf(("USER32:  SetMenuDefaultItem, faked\n"));
00959     return(TRUE);
00960 }
00961 //******************************************************************************
00962 //******************************************************************************
00963 BOOL GetMenuItemInfoAW(HMENU hMenu, UINT uItem, BOOL byPos, MENUITEMINFOA *lpmii, BOOL unicode)
00964 {
00965     if(byPos) {
00966         uItem = GetMenuItemID(hMenu, uItem);
00967     }
00968     if(ODIN_GetMenuState(hMenu, uItem, MF_BYCOMMAND) == -1) {
00969         //item doesn't exist
00970         dprintf(("USER32:  GetMenuItemInfoAW %x item %d doesn't exist", hMenu, uItem));
00971         SetLastError(ERROR_INVALID_PARAMETER);
00972         return FALSE;
00973     }
00974     if (lpmii->fMask & MIIM_TYPE)
00975     {
00976         lpmii->fType = ODIN_GetMenuState(hMenu, uItem, MF_BYCOMMAND); //not correct
00977 //      lpmii->fType = menu->fType;
00978         if (unicode) {
00979             lpmii->cch = ODIN_GetMenuStringW(hMenu, uItem, (LPWSTR)lpmii->dwTypeData, lpmii->cch, MF_BYCOMMAND);
00980         }
00981         else {
00982             lpmii->cch = ODIN_GetMenuStringA(hMenu, uItem, (LPSTR)lpmii->dwTypeData, lpmii->cch, MF_BYCOMMAND);
00983         }
00984 //TODO:
00985 #if 0
00986         switch (MENU_ITEM_TYPE(menu->fType)) {
00987         case MF_STRING:
00988             if (menu->text && lpmii->dwTypeData && lpmii->cch) {
00989                 if (unicode) {
00990                     lstrcpynAtoW((LPWSTR) lpmii->dwTypeData, menu->text, lpmii->cch);
00991                     lpmii->cch = lstrlenW((LPWSTR)menu->text);
00992                 }
00993                 else {
00994                     lstrcpynA(lpmii->dwTypeData, menu->text, lpmii->cch);
00995                     lpmii->cch = lstrlenA(menu->text);
00996                 }
00997             }
00998             break;
00999         case MF_OWNERDRAW:
01000         case MF_BITMAP:
01001             lpmii->dwTypeData = menu->text;
01002             /* fall through */
01003         default:
01004             lpmii->cch = 0;
01005         }
01006 #endif
01007     }
01008 
01009     if (lpmii->fMask & MIIM_STRING) {
01010         if (unicode) {
01011             lpmii->cch = ODIN_GetMenuStringW(hMenu, uItem, (LPWSTR)lpmii->dwTypeData, lpmii->cch, MF_BYCOMMAND);
01012         }
01013         else {
01014             lpmii->cch = ODIN_GetMenuStringA(hMenu, uItem, (LPSTR)lpmii->dwTypeData, lpmii->cch, MF_BYCOMMAND);
01015         }
01016     }
01017 
01018 //TODO:
01019 #if 0
01020     if (lpmii->fMask & MIIM_FTYPE)
01021         lpmii->fType = menu->fType;
01022 
01023     if (lpmii->fMask & MIIM_BITMAP)
01024         lpmii->hbmpItem = menu->hbmpItem;
01025 #endif
01026 
01027     if (lpmii->fMask & MIIM_STATE)
01028         lpmii->fState = ODIN_GetMenuState(hMenu, uItem, MF_BYCOMMAND);
01029 
01030     if (lpmii->fMask & MIIM_ID)
01031         lpmii->wID = uItem;
01032 
01033 //TODO:
01034 #if 1
01035     lpmii->hSubMenu = 0;
01036     lpmii->hbmpChecked = 0;
01037     lpmii->hbmpUnchecked = 0;
01038     lpmii->dwItemData = 0;
01039 #else
01040     if (lpmii->fMask & MIIM_SUBMENU)
01041         lpmii->hSubMenu = ODIN_GetSubMenu(hMenu, uItem); //need index, not id
01042 
01043     if (lpmii->fMask & MIIM_CHECKMARKS) {
01044         lpmii->hbmpChecked = menu->hCheckBit;
01045         lpmii->hbmpUnchecked = menu->hUnCheckBit;
01046     }
01047     if (lpmii->fMask & MIIM_DATA)
01048         lpmii->dwItemData = menu->dwItemData;
01049 #endif
01050 
01051     return(FALSE);
01052 }
01053 //******************************************************************************
01054 //******************************************************************************
01055 ODINFUNCTION4(BOOL, GetMenuItemInfoA,
01056               HMENU, hMenu,
01057               UINT, uItem,
01058               BOOL, byPos,
01059               MENUITEMINFOA *, lpMenuItemInfo)
01060 {
01061     return GetMenuItemInfoAW(hMenu, uItem, byPos, lpMenuItemInfo, FALSE);
01062 }
01063 /*****************************************************************************
01064  * Function  : GetMenuItemInfoW
01065  * Purpose   : The GetMenuItemInfo function retrieves information about a menu item.
01066  * Parameters:
01067  * Variables :
01068  * Result    : If the function succeeds, the return value is TRUE.
01069  *             If the function fails, the return value is FALSE. To get extended
01070  *             error information, use the GetLastError function.
01071  * Remark    :
01072  * Status    : UNTESTED STUB
01073  *
01074  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
01075  *****************************************************************************/
01076 
01077 ODINFUNCTION4(BOOL, GetMenuItemInfoW,
01078               HMENU, hMenu,
01079               UINT, uItem,
01080               BOOL, byPos,
01081               MENUITEMINFOW *, lpMenuItemInfo)
01082 {
01083     return GetMenuItemInfoAW(hMenu, uItem, byPos, (MENUITEMINFOA*)lpMenuItemInfo, TRUE);
01084 }
01085 /*****************************************************************************
01086  * Function  : GetMenuItemRect
01087  * Purpose   : The GetMenuItemRect function retrieves the bounding rectangle
01088  *             for the specified menu item.
01089  * Parameters:
01090  * Variables :
01091  * Result    : If the function succeeds, the return value is TRUE.
01092  *             If the function fails, the return value is FALSE. To get
01093  *             extended error information, use the GetLastError function.
01094  * Remark    :
01095  * Status    :
01096  *
01097  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
01098  *****************************************************************************/
01099 
01100 BOOL GetMenuItemRect(HWND hwnd, HMENU hMenu, UINT uItem, LPRECT lprcItem)
01101 {
01102  BOOL rc;
01103 
01104     rc = OSLibGetMenuItemRect(hMenu, uItem, lprcItem);
01105     dprintf(("GetMenuItemRect %x %x %x (%d,%d)(%d,%d)", hwnd, hMenu, uItem, lprcItem->top, lprcItem->left, lprcItem->bottom, lprcItem->right));
01106     return rc;
01107 }
01108 /*****************************************************************************
01109  * Function  : InsertMenuItemA
01110  * Purpose   : The InsertMenuItem function inserts a new menu item at the specified
01111  *             position in a menu bar or pop-up menu.
01112  * Parameters:
01113  * Variables :
01114  * Result    : If the function succeeds, the return value is TRUE.
01115  *             If the function fails, the return value is FALSE. To get extended
01116  *             error information, use the GetLastError function.
01117  * Remark    :
01118  * Status    : UNTESTED STUB
01119  *
01120  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
01121  *****************************************************************************/
01122 
01123 ODINFUNCTION4(BOOL, InsertMenuItemA,
01124               HMENU, hMenu,
01125               UINT, uItem,
01126               BOOL, fByPosition,
01127               const MENUITEMINFOA*, lpmii)
01128 {
01129  DWORD dwType;
01130  BOOL rc;
01131 
01132     dprintf(("USER32:InsertMenuItemA (%08xh,%08xh,%u,%08x) not correctly implemented.\n",
01133          hMenu,
01134          uItem,
01135          fByPosition,
01136          lpmii));
01137 
01138     if(fByPosition) {
01139             dwType = lpmii->fType | MF_BYPOSITION;
01140     }
01141     else    dwType = lpmii->fType | MF_BYCOMMAND;
01142 
01143     if(lpmii->fMask & MIIM_SUBMENU && lpmii->hSubMenu) {
01144         rc &= ODIN_InsertMenuA(hMenu, uItem, dwType | MF_POPUP, lpmii->hSubMenu, lpmii->dwTypeData);
01145     }
01146     else
01147     if(lpmii->fMask & MIIM_ID) {
01148         rc = ODIN_InsertMenuA(hMenu, uItem, dwType, lpmii->wID, lpmii->dwTypeData);
01149     }
01150     if(lpmii->fMask & MIIM_STATE) {
01151     //TODO
01152     }
01153     return rc;
01154 }
01155 
01156 
01157 /*****************************************************************************
01158  * Function  : InsertMenuItemW
01159  * Purpose   : The InsertMenuItem function inserts a new menu item at the specified
01160  *             position in a menu bar or pop-up menu.
01161  * Parameters:
01162  * Variables :
01163  * Result    : If the function succeeds, the return value is TRUE.
01164  *             If the function fails, the return value is FALSE. To get extended
01165  *             error information, use the GetLastError function.
01166  * Remark    :
01167  * Status    : UNTESTED STUB
01168  *
01169  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
01170  *****************************************************************************/
01171 
01172 ODINFUNCTION4(BOOL, InsertMenuItemW,
01173               HMENU, hMenu,
01174               UINT, uItem,
01175               BOOL, fByPosition,
01176               const MENUITEMINFOW *, lpmii)
01177 {
01178     dprintf(("USER32:InsertMenuItemW (%08xh,%08xh,%u,%08x) not correctly implemented.\n",
01179          hMenu,
01180          uItem,
01181          fByPosition,
01182          lpmii));
01183 
01184     if(fByPosition) {
01185             return ODIN_InsertMenuW(hMenu, uItem, lpmii->fType | MF_BYPOSITION, (lpmii->fType & MF_POPUP) ? lpmii->hSubMenu : lpmii->wID, lpmii->dwTypeData);
01186     }
01187     else    return ODIN_InsertMenuW(hMenu, uItem, lpmii->fType | MF_BYCOMMAND, (lpmii->fType & MF_POPUP) ? lpmii->hSubMenu : lpmii->wID, lpmii->dwTypeData);
01188 }
01189 /*****************************************************************************
01190  * Function  : MenuItemFromPoint
01191  * Purpose   : TheMenuItemFromPoint function determines which menu item, if
01192  *             any, is at the specified location.
01193  * Parameters:
01194  * Variables :
01195  * Result    : Returns the zero-based position of the menu item at the specified
01196  *             location or -1 if no menu item is at the specified location.
01197  * Remark    :
01198  * Status    : UNTESTED STUB
01199  *
01200  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
01201  *****************************************************************************/
01202 
01203 ODINFUNCTION3(UINT, MenuItemFromPoint,
01204               HWND, hWnd,
01205               HMENU, hMenu,
01206               POINT, ptScreen)
01207 {
01208   dprintf(("USER32:MenuItemFromPoint (%08xh,%08xh,%u) not implemented.\n",
01209          hWnd,
01210          hMenu,
01211          ptScreen));
01212 
01213   return (-1);
01214 }
01215 
01216 
01217 /*****************************************************************************
01218  * Function  :  GetMenuInfo
01219  * Parameters:
01220  * Variables :
01221  * Result    :
01222  * Remark    :
01223  * Status    : UNTESTED STUB win98/NT5.0
01224  *
01225  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
01226  *****************************************************************************/
01227 
01228 ODINFUNCTION2(BOOL, GetMenuInfo,
01229               HMENU, hMenu,
01230               LPMENUINFO, lpmi)
01231 {
01232  POPUPMENU *menu;
01233 
01234     menu = GetInternalMenuInfo(hMenu);
01235     if(menu == NULL) {
01236         dprintf(("USER32: GetMenuInfo(%08xh,%08xh) No POPUPMENU structure found!", hMenu, lpmi));
01237         SetLastError(ERROR_INVALID_PARAMETER);
01238         return FALSE;
01239     }
01240     dprintf(("USER32: GetMenuInfo(%08xh,%08xh)", hMenu, lpmi));
01241 
01242     if (lpmi)
01243     {
01244         if (lpmi->fMask & MIM_BACKGROUND)
01245             lpmi->hbrBack = menu->hbrBack;
01246 
01247         if (lpmi->fMask & MIM_HELPID)
01248             lpmi->dwContextHelpID = menu->dwContextHelpID;
01249 
01250         if (lpmi->fMask & MIM_MAXHEIGHT)
01251             lpmi->cyMax = menu->cyMax;
01252 
01253         if (lpmi->fMask & MIM_MENUDATA)
01254             lpmi->dwMenuData = menu->dwMenuData;
01255 
01256         if (lpmi->fMask & MIM_STYLE)
01257             lpmi->dwStyle = menu->dwStyle;
01258 
01259         return TRUE;
01260     }
01261     SetLastError(ERROR_INVALID_PARAMETER);
01262     return FALSE;
01263 }
01264 /*****************************************************************************
01265  * Function  :  SetMenuInfo
01266  * Purpose   :
01267  * Parameters:
01268  * Variables :
01269  * Result    :
01270  * Remark    :
01271  * FIXME
01272  * MIM_APPLYTOSUBMENUS
01273  * actually use the items to draw the menu
01274  * Status    : UNTESTED STUB win98/NT5.0
01275  *
01276  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
01277  *****************************************************************************/
01278 
01279 ODINFUNCTION2(BOOL, SetMenuInfo,
01280               HMENU, hMenu,
01281               LPCMENUINFO, lpmi)
01282 {
01283  POPUPMENU *menu;
01284 
01285     menu = GetInternalMenuInfo(hMenu);
01286     if(menu == NULL) {
01287         dprintf(("USER32: SetMenuInfo(%08xh,%08xh) No POPUPMENU structure found!", hMenu, lpmi));
01288         SetLastError(ERROR_INVALID_PARAMETER);
01289         return FALSE;
01290     }
01291 
01292     dprintf(("USER32: SetMenuInfo(%08xh,%08xh)", hMenu, lpmi));
01293 
01294     if (lpmi && (lpmi->cbSize==sizeof(MENUINFO)))
01295     {
01296         if (lpmi->fMask & MIM_BACKGROUND)
01297             menu->hbrBack = lpmi->hbrBack;
01298 
01299         if (lpmi->fMask & MIM_HELPID)
01300             menu->dwContextHelpID = lpmi->dwContextHelpID;
01301 
01302         if (lpmi->fMask & MIM_MAXHEIGHT)
01303             menu->cyMax = lpmi->cyMax;
01304 
01305         if (lpmi->fMask & MIM_MENUDATA)
01306             menu->dwMenuData = lpmi->dwMenuData;
01307 
01308         if (lpmi->fMask & MIM_STYLE)
01309             menu->dwStyle = lpmi->dwStyle;
01310 
01311         return TRUE;
01312     }
01313     SetLastError(ERROR_INVALID_PARAMETER);
01314     return FALSE;
01315 }
01316 //******************************************************************************
01317 //******************************************************************************
01318 

Generated on Wed Jan 23 23:17:55 2002 for ODIN-user32 by doxygen1.2.11.1 written by Dimitri van Heesch, © 1997-2001