Changeset 11621


Ignore:
Timestamp:
Sep 24, 1999, 2:47:51 PM (26 years ago)
Author:
sandervl
Message:

Menu changes

Location:
tags/trunk/src/user32
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • TabularUnified tags/trunk/src/user32/oslibmenu.cpp

    r11541 r11621  
    1 /* $Id: oslibmenu.cpp,v 1.1 1999-09-15 23:18:53 sandervl Exp $ */
     1/* $Id: oslibmenu.cpp,v 1.2 1999-09-24 12:47:50 sandervl Exp $ */
    22/*
    33 * Window Menu wrapper functions for OS/2
    … …  
    2525//******************************************************************************
    2626//******************************************************************************
    27 HWND OSLibWinCreateMenu(HWND hwndParent, PVOID menutemplate)
     27HWND OSLibWinSetMenu(HWND hwndParent, HMENU hMenu)
    2828{
    29   return WinCreateMenu(hwndParent, menutemplate);
     29   // Remove current menu from window
     30   HWND currMenu = WinWindowFromID( (HWND)hwndParent, FID_MENU );
     31   if (currMenu)
     32   {
     33      WinSetOwner (currMenu, HWND_OBJECT);
     34      WinSetParent(currMenu, HWND_OBJECT, FALSE);
     35   }
     36
     37   if (hMenu)
     38   {
     39      if(WinIsWindow(GetThreadHAB(), hMenu) == TRUE) {
     40         WinSetOwner (hMenu, hwndParent);
     41         WinSetParent(hMenu, hwndParent, FALSE );
     42         WinSetWindowUShort(hMenu, QWS_ID, FID_MENU);
     43         WinSendMsg(hwndParent, WM_UPDATEFRAME, (MPARAM)FCF_MENU, 0);
     44         return hMenu;
     45      }
     46   }
     47   return 0;
    3048}
    3149//******************************************************************************

  • TabularUnified tags/trunk/src/user32/oslibmenu.h

    r11541 r11621  
    1 /* $Id: oslibmenu.h,v 1.1 1999-09-15 23:18:54 sandervl Exp $ */
     1/* $Id: oslibmenu.h,v 1.2 1999-09-24 12:47:50 sandervl Exp $ */
    22/*
    33 * Window Menu wrapper functions for OS/2
    … …  
    1717#endif
    1818
    19 HWND  OSLibWinCreateMenu(HWND hwndParent, PVOID menutemplate);
     19HWND  OSLibWinSetMenu(HWND hwndParent, HMENU hMenu);
    2020int   OSLibGetMenuItemCount(HWND hMenu);
    2121 

  • TabularUnified tags/trunk/src/user32/win32wbase.cpp

    r11615 r11621  
    1 /* $Id: win32wbase.cpp,v 1.8 1999-09-23 16:44:33 sandervl Exp $ */
     1/* $Id: win32wbase.cpp,v 1.9 1999-09-24 12:47:50 sandervl Exp $ */
    22/*
    33 * Win32 Window Base Class for OS/2
    … …  
    114114
    115115  acceltableResource = NULL;
    116   menuResource       = NULL;
    117116  iconResource       = NULL;
    118117
    … …  
    15201519BOOL Win32BaseWindow::SetMenu(HMENU hMenu)
    15211520{
    1522  PVOID          menutemplate;
    1523  Win32Resource *winres = (Win32Resource *)hMenu;
    15241521
    15251522    dprintf(("SetMenu %x", hMenu));
    1526     if(HIWORD(winres) == 0) {
    1527         dprintf(("Win32BaseWindow:: Win32Resource *winres == 0"));
    1528         SetLastError(ERROR_INVALID_PARAMETER);
    1529         return FALSE;
    1530     }
    1531     menutemplate = winres->lockOS2Resource();
    1532     if(menutemplate == NULL)
    1533     {
    1534         dprintf(("Win32BaseWindow::SetMenu menutemplate == 0"));
    1535         return FALSE;
    1536     }
    1537     OS2HwndMenu = OSLibWinCreateMenu(OS2HwndFrame, menutemplate);
     1523    OS2HwndMenu = OSLibWinSetMenu(OS2HwndFrame, hMenu);
    15381524    if(OS2HwndMenu == 0) {
    15391525        dprintf(("Win32BaseWindow::SetMenu OS2HwndMenu == 0"));
    15401526        return FALSE;
    15411527    }
    1542     winres->setOS2Handle(OS2HwndMenu);
    1543     menuResource = winres;
    15441528    return TRUE;
    15451529}

  • TabularUnified tags/trunk/src/user32/win32wbase.h

    r11615 r11621  
    1 /* $Id: win32wbase.h,v 1.5 1999-09-23 16:44:33 sandervl Exp $ */
     1/* $Id: win32wbase.h,v 1.6 1999-09-24 12:47:51 sandervl Exp $ */
    22/*
    33 * Win32 Window Base Class for OS/2
    … …  
    134134         BOOL   SetAccelTable(ULONG hAccel);
    135135
    136          HMENU  GetMenu()                           { return (HMENU) menuResource; };
     136         HMENU  GetMenu()                           { return (HMENU) OS2HwndMenu; };
    137137         BOOL   SetMenu(ULONG hMenu);
    138138
    … …  
    230230
    231231 Win32Resource *acceltableResource;
    232  Win32Resource *menuResource;
    233232 Win32Resource *iconResource;
    234233

  • TabularUnified tags/trunk/src/user32/winmenu.cpp

    r11618 r11621  
    1 /* $Id: winmenu.cpp,v 1.6 1999-09-23 17:36:16 phaller Exp $ */
     1/* $Id: winmenu.cpp,v 1.7 1999-09-24 12:47:51 sandervl Exp $ */
    22
    33/*
    … …  
    3434              LPCSTR,    lpszMenu)
    3535{
    36   return (HMENU)FindResourceA(hinst, lpszMenu, RT_MENUA);
     36  Win32MenuRes *winres;
     37  HMENU hMenu;
     38
     39  winres = (Win32MenuRes *)FindResourceA(hinst, lpszMenu, RT_MENUA);
     40  if(winres) {
     41        hMenu = O32_LoadMenuIndirect((MENUITEMTEMPLATEHEADER *)winres->lockOS2Resource());
     42        delete winres;
     43        return hMenu;
     44  }
     45  return 0;
    3746}
    3847//******************************************************************************
    … …  
    4251              LPCWSTR, lpszMenu)
    4352{
    44   return (HMENU)FindResourceW(hinst, lpszMenu, RT_MENUW);
    45 }
    46 //******************************************************************************
    47 //TODO: Create PM object?
     53  Win32MenuRes *winres;
     54  HMENU hMenu;
     55
     56  winres = (Win32MenuRes *)FindResourceW(hinst, lpszMenu, RT_MENUW);
     57  if(winres) {
     58        hMenu = O32_LoadMenuIndirect((MENUITEMTEMPLATEHEADER *)winres->lockOS2Resource());
     59        delete winres;
     60        return hMenu;
     61  }
     62  return 0;
     63}
     64//******************************************************************************
    4865//NOTE: menutemplate strings are always in Unicode format
    4966//******************************************************************************
    … …  
    5269{
    5370  Win32MenuRes *winres;
     71  HMENU hMenu;
    5472
    5573  winres = new Win32MenuRes((LPVOID)menuTemplate);
    5674  if(winres == NULL)
    5775    return 0;
    58   else
    59     return (HMENU)winres;
     76
     77  hMenu = O32_LoadMenuIndirect((MENUITEMTEMPLATEHEADER *)winres->lockOS2Resource());
     78  delete winres;
     79  return (HMENU)winres;
    6080}
    6181//******************************************************************************
    … …  
    6585{
    6686  Win32MenuRes *winres;
     87  HMENU hMenu;
    6788
    6889  winres = new Win32MenuRes((LPVOID)menuTemplate);
    6990  if(winres == NULL)
    7091    return 0;
    71   else
    72     return (HMENU)winres;
     92
     93  hMenu = O32_LoadMenuIndirect((MENUITEMTEMPLATEHEADER *)winres->lockOS2Resource());
     94  delete winres;
     95  return (HMENU)winres;
    7396}
    7497//******************************************************************************
    7598//******************************************************************************
    7699ODINFUNCTION1(BOOL,  DestroyMenu,
    77               HMENU, hmenu)
    78 {
    79   Win32MenuRes *winres;
    80 
    81   if(HIWORD(hmenu) == 0)
    82   {
    83     SetLastError(ERROR_INVALID_PARAMETER);
    84     return FALSE;
    85   }
    86 
    87   winres = (Win32MenuRes *)hmenu;
    88   delete winres;
    89   return TRUE;
     100              HMENU, hMenu)
     101{
     102  return O32_DestroyMenu(hMenu);
    90103}
    91104//******************************************************************************
    … …  
    109122ODINFUNCTION2(BOOL,  SetMenu,
    110123              HWND,  hwnd,
    111               HMENU, hmenu)
     124              HMENU, hMenu)
    112125{
    113126  Win32BaseWindow *window;
    … …  
    120133  }
    121134
    122   window->SetMenu(hmenu);
     135  window->SetMenu(hMenu);
    123136  return TRUE;
    124137}
    … …  
    134147              HMENU, hMenu)
    135148{
    136   Win32MenuRes *menu = (Win32MenuRes *)hMenu;
    137 
    138   if(menu == NULL || menu->getOS2Handle() == 0)
     149  if(hMenu == 0)
    139150  {
    140151    SetLastError(ERROR_INVALID_PARAMETER);
    141152    return 0;
    142153  }
    143 
    144   return OSLibGetMenuItemCount(menu->getOS2Handle());
     154  return OSLibGetMenuItemCount(hMenu);
    145155}
    146156//******************************************************************************
    … …  
    150160              int,   nPos)
    151161{
    152   Win32MenuRes *menu = (Win32MenuRes *)hMenu;
    153 
    154   if(menu == NULL || menu->getOS2Handle() == 0)
     162  if(hMenu == 0)
    155163  {
    156164    SetLastError(ERROR_INVALID_PARAMETER);
    157165    return 0;
    158166  }
    159 
    160   return O32_GetMenuItemID(menu->getOS2Handle(), nPos);
     167  return O32_GetMenuItemID(hMenu, nPos);
    161168}
    162169//******************************************************************************
    … …  
    167174              UINT,  arg3)
    168175{
    169   Win32MenuRes *menu = (Win32MenuRes *)hMenu;
    170 
    171   if(menu == NULL || menu->getOS2Handle() == 0)
     176  if(hMenu == 0)
    172177  {
    173178    SetLastError(ERROR_INVALID_PARAMETER);
    … …  
    175180  }
    176181
    177   return O32_GetMenuState(menu->getOS2Handle(), arg2, arg3);
     182  return O32_GetMenuState(hMenu, arg2, arg3);
    178183}
    179184//******************************************************************************
    … …  
    186191              UINT,  arg5)
    187192{
    188   Win32MenuRes *menu = (Win32MenuRes *)hMenu;
    189 
    190   if(menu == NULL || menu->getOS2Handle() == 0)
     193  if(hMenu == 0)
    191194  {
    192195    SetLastError(ERROR_INVALID_PARAMETER);
    … …  
    194197  }
    195198
    196   return O32_GetMenuString(menu->getOS2Handle(), arg2, arg3, arg4, arg5);
     199  return O32_GetMenuString(hMenu, arg2, arg3, arg4, arg5);
    197200}
    198201//******************************************************************************
    … …  
    205208              UINT,  fuFlags)
    206209{
    207   Win32MenuRes *menu = (Win32MenuRes *)hMenu;
    208210  char *astring = (char *)malloc(cchMax);
    209211  int   rc;
    210212
    211   if(menu == NULL || menu->getOS2Handle() == 0)
     213  if(hMenu == 0)
    212214  {
    213215    SetLastError(ERROR_INVALID_PARAMETER);
    … …  
    215217  }
    216218
    217   rc = O32_GetMenuString(menu->getOS2Handle(), idItem, astring, cchMax, fuFlags);
     219  rc = O32_GetMenuString(hMenu, idItem, astring, cchMax, fuFlags);
    218220  free(astring);
    219221  if(rc)
    … …  
    236238              HBITMAP, arg5)
    237239{
    238  Win32MenuRes *menu = (Win32MenuRes *)hMenu;
    239 
    240     dprintf(("USER32:  SetMenuItemBitmaps\n"));
    241     if(menu == NULL || menu->getOS2Handle() == 0)
    242     {
    243         SetLastError(ERROR_INVALID_PARAMETER);
    244         return 0;
    245     }
    246     return O32_SetMenuItemBitmaps(menu->getOS2Handle(), arg2, arg3, arg4, arg5);
     240  dprintf(("USER32:  SetMenuItemBitmaps\n"));
     241  if(hMenu == 0)
     242  {
     243    SetLastError(ERROR_INVALID_PARAMETER);
     244    return 0;
     245  }
     246  return O32_SetMenuItemBitmaps(hMenu, arg2, arg3, arg4, arg5);
    247247}
    248248//******************************************************************************
    … …  
    252252              int, arg2)
    253253{
    254   Win32MenuRes *menu = (Win32MenuRes *)hMenu;
    255   Win32MenuRes *menuReturned;
    256   HMENU        hMenuReturned;
    257 
    258   if(menu == NULL || menu->getOS2Handle() == 0)
    259   {
    260      SetLastError(ERROR_INVALID_PARAMETER);
    261      return 0;
    262   }
    263 
    264   hMenuReturned = O32_GetSubMenu(menu->getOS2Handle(), arg2);
    265   /* @@@PH allocate Win32MenuRes object ! */
    266   /* @@@PH WARNING, memory leak! */
    267   menuReturned = new Win32MenuRes(hMenuReturned);
    268   return ((HMENU)menuReturned);
     254  if(hMenu == 0)
     255  {
     256    SetLastError(ERROR_INVALID_PARAMETER);
     257    return 0;
     258  }
     259
     260  return O32_GetSubMenu(hMenu, arg2);
    269261}
    270262//******************************************************************************
    … …  
    274266              BOOL,  bRevert)
    275267{
    276   Win32MenuRes *menuReturned;
    277   HMENU        hMenuReturned;
    278268  Win32BaseWindow *window;
    279269
    … …  
    285275  }
    286276
    287   //hMenuReturned = window->GetSystemMenu();
    288   hMenuReturned =  O32_GetSystemMenu(hSystemWindow, bRevert);
    289 
    290   /* @@@PH allocate Win32MenuRes object ! */
    291   /* @@@PH WARNING, memory leak! */
    292   menuReturned = new Win32MenuRes(hMenuReturned);
    293   return ((HMENU)menuReturned);
     277  return O32_GetSystemMenu(window->getOS2FrameWindowHandle(), bRevert);
    294278}
    295279//******************************************************************************
    … …  
    298282              HMENU, hMenu)
    299283{
    300  Win32MenuRes *menu = (Win32MenuRes *)hMenu;
    301 
    302284    dprintf(("USER32:  IsMenu\n"));
    303     if(menu == NULL || menu->getOS2Handle() == 0)
    304     {
    305         SetLastError(ERROR_INVALID_PARAMETER);
    306         return 0;
    307     }
    308     return O32_IsMenu(menu->getOS2Handle());
     285    return O32_IsMenu(hMenu);
    309286}
    310287//******************************************************************************
    … …  
    319296              const RECT *, arg7)
    320297{
    321  Win32MenuRes *menu = (Win32MenuRes *)hMenu;
    322 
    323298    dprintf(("USER32:  TrackPopupMenu\n"));
    324     if(menu == NULL || menu->getOS2Handle() == 0)
    325     {
    326         SetLastError(ERROR_INVALID_PARAMETER);
    327         return 0;
    328     }
    329     return O32_TrackPopupMenu(menu->getOS2Handle(), arg2, arg3, arg4, arg5, arg6, arg7);
     299    if(hMenu == 0)
     300    {
     301        SetLastError(ERROR_INVALID_PARAMETER);
     302        return 0;
     303    }
     304    return O32_TrackPopupMenu(hMenu, arg2, arg3, arg4, arg5, arg6, arg7);
    330305}
    331306//******************************************************************************
    … …  
    339314              LPTPMPARAMS, lpPM)
    340315{
    341  Win32MenuRes *menu = (Win32MenuRes *)hMenu;
    342316 RECT *rect = NULL;
    343 
    344317
    345318    dprintf(("USER32:  TrackPopupMenuEx, not completely implemented\n"));
    … …  
    347320        rect = &lpPM->rcExclude;
    348321
    349     if(menu == NULL || menu->getOS2Handle() == 0)
    350     {
    351         SetLastError(ERROR_INVALID_PARAMETER);
    352         return 0;
    353     }
    354     return O32_TrackPopupMenu(menu->getOS2Handle(), flags, X, Y, 0, hwnd, rect);
     322    if(hMenu == 0)
     323    {
     324        SetLastError(ERROR_INVALID_PARAMETER);
     325        return 0;
     326    }
     327    return O32_TrackPopupMenu(hMenu, flags, X, Y, 0, hwnd, rect);
    355328}
    356329//******************************************************************************
    … …  
    362335              LPCSTR, lpNewItem)
    363336{
    364  Win32MenuRes *menu = (Win32MenuRes *)hMenu;
    365337 BOOL rc;
    366338
    … …  
    370342            dprintf(("USER32:  OS2AppendMenuA %s\n", lpNewItem));
    371343
    372     if(menu == NULL || menu->getOS2Handle() == 0)
    373     {
    374         SetLastError(ERROR_INVALID_PARAMETER);
    375         return 0;
    376     }
    377     rc = O32_AppendMenu(menu->getOS2Handle(), uFlags, ulDNewItem, lpNewItem);
    378     dprintf(("USER32:  OS2AppendMenuA returned %d\n", rc));
     344    if(hMenu == 0)
     345    {
     346        SetLastError(ERROR_INVALID_PARAMETER);
     347        return 0;
     348    }
     349    rc = O32_AppendMenu(hMenu, uFlags, ulDNewItem, lpNewItem);
     350    dprintf(("USER32:  AppendMenuA returned %d\n", rc));
    379351    return rc;
    380352}
    … …  
    387359              LPCWSTR, arg4)
    388360{
    389     Win32MenuRes *menu = (Win32MenuRes *)hMenu;
    390361    BOOL  rc;
    391362    char *astring = NULL;
    … …  
    398369      astring = (char *) arg4;
    399370
    400     if(menu == NULL || menu->getOS2Handle() == 0)
    401     {
    402         SetLastError(ERROR_INVALID_PARAMETER);
    403         return 0;
    404     }
    405     rc = O32_AppendMenu(menu->getOS2Handle(), arg2, arg3, astring);
     371    if(hMenu == 0)
     372    {
     373        SetLastError(ERROR_INVALID_PARAMETER);
     374        return 0;
     375    }
     376    rc = O32_AppendMenu(hMenu, arg2, arg3, astring);
    406377    if(arg2 & MF_STRING  && (int)arg4 >> 16 != 0)
    407378      FreeAsciiString(astring);
    … …  
    415386              UINT, arg3)
    416387{
    417  Win32MenuRes *menu = (Win32MenuRes *)hMenu;
    418 
    419388    dprintf(("USER32:  OS2CheckMenuItem\n"));
    420     if(menu == NULL || menu->getOS2Handle() == 0)
    421     {
    422         SetLastError(ERROR_INVALID_PARAMETER);
    423         return 0;
    424     }
    425     return O32_CheckMenuItem(menu->getOS2Handle(), arg2, arg3);
     389    if(hMenu == 0)
     390    {
     391        SetLastError(ERROR_INVALID_PARAMETER);
     392        return 0;
     393    }
     394    return O32_CheckMenuItem(hMenu, arg2, arg3);
    426395}
    427396//******************************************************************************
    … …  
    429398ODINFUNCTION0(HMENU, CreateMenu)
    430399{
    431   Win32MenuRes *menu = 0;
    432   HMENU hMenu;
    433 
    434   hMenu = O32_CreateMenu();
    435   if(hMenu)
    436   {
    437     menu = new Win32MenuRes(hMenu);
    438     if(menu == NULL)
    439       return 0;
    440   }
    441 
    442   return (HMENU)menu;
     400    dprintf(("USER32:  CreateMenu\n"));
     401    return O32_CreateMenu();
    443402}
    444403//******************************************************************************
    … …  
    446405ODINFUNCTION0(HMENU, CreatePopupMenu)
    447406{
    448   Win32MenuRes *menu = 0;
    449   HMENU hMenu;
    450 
    451   hMenu = O32_CreatePopupMenu();
    452   if(hMenu)
    453   {
    454     menu = new Win32MenuRes(hMenu);
    455     if(menu == NULL)
    456       return 0;
    457   }
    458 
    459   return (HMENU)menu;
     407    dprintf(("USER32:  CreateMenu\n"));
     408    return O32_CreatePopupMenu();
    460409}
    461410//******************************************************************************
    … …  
    465414                                  UINT, uEnable)
    466415{
    467   Win32MenuRes *menu = (Win32MenuRes *)hMenu;
    468 
    469   if(menu == NULL || menu->getOS2Handle() == 0)
    470   {
    471     SetLastError(ERROR_INVALID_PARAMETER);
    472     return 0;
    473   }
    474 
    475   return O32_EnableMenuItem(menu->getOS2Handle(),
    476                             uIDEnableItem,
    477                             uEnable);
     416    if(hMenu == 0)
     417    {
     418        SetLastError(ERROR_INVALID_PARAMETER);
     419        return 0;
     420    }
     421
     422    return O32_EnableMenuItem(hMenu,
     423                              uIDEnableItem,
     424                              uEnable);
    478425}
    479426//******************************************************************************
    … …  
    486433              LPCSTR, arg5)
    487434{
    488  Win32MenuRes *menu = (Win32MenuRes *)hMenu;
    489 
    490435    dprintf(("USER32:  OS2ModifyMenuA\n"));
    491     if(menu == NULL || menu->getOS2Handle() == 0)
    492     {
    493         SetLastError(ERROR_INVALID_PARAMETER);
    494         return 0;
    495     }
    496     return O32_ModifyMenu(menu->getOS2Handle(), arg2, arg3, arg4, arg5);
     436    if(hMenu == 0)
     437    {
     438        SetLastError(ERROR_INVALID_PARAMETER);
     439        return 0;
     440    }
     441    return O32_ModifyMenu(hMenu, arg2, arg3, arg4, arg5);
    497442}
    498443//******************************************************************************
    … …  
    507452 BOOL  rc;
    508453 char *astring = NULL;
    509  Win32MenuRes *menu = (Win32MenuRes *)hMenu;
    510454
    511455    dprintf(("USER32: OS2ModifyMenuW %s\n", astring));
    512456
    513     if(menu == NULL || menu->getOS2Handle() == 0)
     457    if(hMenu == 0)
    514458    {
    515459        SetLastError(ERROR_INVALID_PARAMETER);
    … …  
    522466      astring = (char *) arg5;
    523467
    524     rc = O32_ModifyMenu(menu->getOS2Handle(), arg2, arg3, arg4, astring);
     468    rc = O32_ModifyMenu(hMenu, arg2, arg3, arg4, astring);
    525469    if(arg3 & MF_STRING  && (int)arg5 >> 16 != 0)
    526470      FreeAsciiString(astring);
    … …  
    534478              UINT, arg3)
    535479{
    536  Win32MenuRes *menu = (Win32MenuRes *)hMenu;
    537 
    538480    dprintf(("USER32:  OS2RemoveMenu\n"));
    539     if(menu == NULL || menu->getOS2Handle() == 0)
    540     {
    541         SetLastError(ERROR_INVALID_PARAMETER);
    542         return 0;
    543     }
    544 
    545     return O32_RemoveMenu(menu->getOS2Handle(), arg2, arg3);
     481    if(hMenu == 0)
     482    {
     483        SetLastError(ERROR_INVALID_PARAMETER);
     484        return 0;
     485    }
     486
     487    return O32_RemoveMenu(hMenu, arg2, arg3);
    546488}
    547489//******************************************************************************
    … …  
    552494              UINT, arg3)
    553495{
    554  Win32MenuRes *menu = (Win32MenuRes *)hMenu;
    555 
    556496    dprintf(("USER32:  OS2DeleteMenu\n"));
    557     if(menu == NULL || menu->getOS2Handle() == 0)
    558     {
    559         SetLastError(ERROR_INVALID_PARAMETER);
    560         return 0;
    561     }
    562 
    563     return O32_DeleteMenu(menu->getOS2Handle(), arg2, arg3);
     497    if(hMenu == 0)
     498    {
     499        SetLastError(ERROR_INVALID_PARAMETER);
     500        return 0;
     501    }
     502
     503    return O32_DeleteMenu(hMenu, arg2, arg3);
    564504}
    565505//******************************************************************************
    … …  
    571511              UINT, arg4)
    572512{
    573  Win32MenuRes *menu = (Win32MenuRes *)hMenu;
    574 
    575513    dprintf(("USER32:  OS2HiliteMenuItem\n"));
    576     if(menu == NULL || menu->getOS2Handle() == 0)
    577     {
    578         SetLastError(ERROR_INVALID_PARAMETER);
    579         return 0;
    580     }
    581 
    582     return O32_HiliteMenuItem(menu->getOS2Handle(), arg2, arg3, arg4);
     514    if(hMenu == 0)
     515    {
     516        SetLastError(ERROR_INVALID_PARAMETER);
     517        return 0;
     518    }
     519
     520    return O32_HiliteMenuItem(hMenu, arg2, arg3, arg4);
    583521}
    584522//******************************************************************************
    … …  
    591529              LPCSTR, arg5)
    592530{
    593  Win32MenuRes *menu = (Win32MenuRes *)hMenu;
    594 
    595531    dprintf(("USER32:  OS2InsertMenuA\n"));
    596     if(menu == NULL || menu->getOS2Handle() == 0)
    597     {
    598         SetLastError(ERROR_INVALID_PARAMETER);
    599         return 0;
    600     }
    601 
    602     return O32_InsertMenu(menu->getOS2Handle(), arg2, arg3, arg4, arg5);
     532    if(hMenu == 0)
     533    {
     534        SetLastError(ERROR_INVALID_PARAMETER);
     535        return 0;
     536    }
     537
     538    return O32_InsertMenu(hMenu, arg2, arg3, arg4, arg5);
    603539}
    604540//******************************************************************************
    … …  
    613549 BOOL  rc;
    614550 char *astring = NULL;
    615  Win32MenuRes *menu = (Win32MenuRes *)hMenu;
    616551
    617552    dprintf(("USER32:  OS2InsertMenuW %s\n", astring));
    618     if(menu == NULL || menu->getOS2Handle() == 0)
    619     {
    620         SetLastError(ERROR_INVALID_PARAMETER);
    621         return 0;
    622     }
     553
    623554    if(arg3 & MF_STRING  && (int)arg5 >> 16 != 0)
    624555      astring = UnicodeToAsciiString((LPWSTR)arg5);
    … …  
    626557      astring = (char *) arg5;
    627558
    628     rc = O32_InsertMenu(menu->getOS2Handle(), arg2, arg3, arg4, astring);
     559    rc = O32_InsertMenu(hMenu, arg2, arg3, arg4, astring);
    629560    if(arg3 & MF_STRING  && (int)arg5 >> 16 != 0)
    630561      FreeAsciiString(astring);
    … …  
    634565//******************************************************************************
    635566ODINFUNCTION2(BOOL, SetMenuContextHelpId,
    636               HMENU, hmenu,
     567              HMENU, hMenu,
    637568              DWORD, dwContextHelpId)
    638569{
    … …  
    643574//******************************************************************************
    644575ODINFUNCTION1(DWORD, GetMenuContextHelpId,
    645               HMENU, hmenu)
     576              HMENU, hMenu)
    646577{
    647578  dprintf(("USER32:  OS2GetMenuContextHelpId, not implemented\n"));
    … …  
    651582//******************************************************************************
    652583ODINFUNCTION5(BOOL, CheckMenuRadioItem,
    653               HMENU, hmenu,
     584              HMENU, hMenu,
    654585              UINT, idFirst,
    655586              UINT, idLast,
    … …  
    707638//******************************************************************************
    708639ODINFUNCTION4(BOOL, SetMenuItemInfoA,
    709               HMENU, hmenu,
     640              HMENU, hMenu,
    710641              UINT, par1,
    711642              BOOL, par2,
    … …  
    749680//******************************************************************************
    750681ODINFUNCTION3(BOOL, SetMenuDefaultItem,
    751               HMENU, hmenu,
     682              HMENU, hMenu,
    752683              UINT, uItem,
    753684              UINT, fByPos)
    … …  
    759690//******************************************************************************
    760691ODINFUNCTION4(BOOL, GetMenuItemInfoA,
    761               HMENU, hmenu,
     692              HMENU, hMenu,
    762693              UINT, uItem,
    763694              BOOL, aBool,
Note: See TracChangeset for help on using the changeset viewer.