Changeset 1446 for trunk/src


Ignore:
Timestamp:
Oct 25, 1999, 10:17:41 PM (26 years ago)
Author:
sandervl
Message:

menu changes + misc bugfixes

Location:
trunk/src/user32
Files:
1 added
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/user32/Makefile

    r1425 r1446  
    1 # $Id: Makefile,v 1.35 1999-10-23 23:04:31 sandervl Exp $
     1# $Id: Makefile,v 1.36 1999-10-25 20:17:16 sandervl Exp $
    22
    33#
    … …  
    8585loadres.obj: loadres.cpp user32.h dib.h
    8686icon.obj: icon.cpp $(PDWIN32_INCLUDE)\winicon.h
    87 winmenu.obj: winmenu.cpp user32.h $(PDWIN32_INCLUDE)\winres.h $(PDWIN32_INCLUDE)\winresmenu.h win32wbase.h
     87winmenu.obj: winmenu.cpp user32.h $(PDWIN32_INCLUDE)\winres.h $(PDWIN32_INCLUDE)\winresmenu.h win32wbase.h winmenudef.h oslibwin.h oslibmenu.h
    8888syscolor.obj: syscolor.cpp syscolor.h
    8989dde.obj: dde.cpp

  • trunk/src/user32/caret.cpp

    r1405 r1446  
    1 /* $Id: caret.cpp,v 1.6 1999-10-22 18:11:42 sandervl Exp $ */
     1/* $Id: caret.cpp,v 1.7 1999-10-25 20:17:16 sandervl Exp $ */
    22
    33/*
    … …  
    3333#pragma data_seg(_GLOBALDATA)
    3434
    35 static HWND hwndCaret;
     35static HWND hwndCaret = 0;
    3636static HBITMAP hbmCaret;
    3737static int CaretWidth, CaretHeight;
    … …  
    4444BOOL WIN32API CreateCaret (HWND hwnd, HBITMAP hBmp, int width, int height)
    4545{
    46    dprintf(("USER32:  CreateCaret"));
     46   dprintf(("USER32:  CreateCaret %x", hwnd));
    4747
    4848   if (hwnd == NULLHANDLE)
    … …  
    216216   BOOL   rc = FALSE;
    217217
    218    dprintf(("USER32:  ShowCaret"));
     218   dprintf(("USER32:  ShowCaret %x", hwnd));
    219219
    220220   CaretIsVisible = TRUE;

  • trunk/src/user32/edit.cpp

    r1433 r1446  
    1 /* $Id: edit.cpp,v 1.8 1999-10-24 22:56:03 sandervl Exp $ */
     1/* $Id: edit.cpp,v 1.9 1999-10-25 20:17:17 sandervl Exp $ */
    22/*
    33 *      Edit control
    … …  
    31753175
    31763176        //SvL: Set focus
    3177         SetFocus(hwnd);
     3177//        SetFocus(hwnd);
    31783178
    31793179        if (!(es->flags & EF_FOCUSED))

  • trunk/src/user32/oslibmenu.cpp

    r1031 r1446  
    1 /* $Id: oslibmenu.cpp,v 1.2 1999-09-24 12:47:50 sandervl Exp $ */
     1/* $Id: oslibmenu.cpp,v 1.3 1999-10-25 20:17:18 sandervl Exp $ */
    22/*
    33 * Window Menu wrapper functions for OS/2
    … …  
    4141         WinSetParent(hMenu, hwndParent, FALSE );
    4242         WinSetWindowUShort(hMenu, QWS_ID, FID_MENU);
    43         WinSendMsg(hwndParent, WM_UPDATEFRAME, (MPARAM)FCF_MENU, 0);
    44         return hMenu;
     43    WinSendMsg(hwndParent, WM_UPDATEFRAME, (MPARAM)FCF_MENU, 0);
     44    return hMenu;
    4545      }
    4646   }
    … …  
    5555//******************************************************************************
    5656//******************************************************************************
     57HMENU OSLibWinCreateMenu(PVOID menutemplate)
     58{
     59    return (HMENU)WinCreateMenu(HWND_OBJECT, menutemplate);
     60}
     61//******************************************************************************
     62//******************************************************************************
     63HMENU OSLibWinCreateEmptyMenu()
     64{
     65   return WinCreateWindow(HWND_OBJECT, WC_MENU, NULL, MS_ACTIONBAR | 0x0008 | WS_SAVEBITS,
     66                          0, 0, 0, 0, HWND_OBJECT, HWND_TOP, 0, NULL, NULL);
     67}
     68//******************************************************************************
     69//******************************************************************************
     70HMENU OSLibWinCreateEmptyPopupMenu()
     71{
     72   return WinCreateWindow(HWND_OBJECT, WC_MENU, NULL, WS_CLIPSIBLINGS | WS_SAVEBITS,
     73                          0, 0, 0, 0, HWND_OBJECT, HWND_TOP, 0, NULL, NULL);
     74}
     75//******************************************************************************
     76//******************************************************************************
     77

  • trunk/src/user32/oslibmenu.h

    r1031 r1446  
    1 /* $Id: oslibmenu.h,v 1.2 1999-09-24 12:47:50 sandervl Exp $ */
     1/* $Id: oslibmenu.h,v 1.3 1999-10-25 20:17:18 sandervl Exp $ */
    22/*
    33 * Window Menu wrapper functions for OS/2
    … …  
    1818
    1919HWND  OSLibWinSetMenu(HWND hwndParent, HMENU hMenu);
     20HMENU OSLibWinCreateMenu(PVOID menutemplate);
     21HMENU OSLibWinCreateEmptyMenu();
     22HMENU OSLibWinCreateEmptyPopupMenu();
    2023int   OSLibGetMenuItemCount(HWND hMenu);
    2124 

  • trunk/src/user32/oslibwin.cpp

    r1425 r1446  
    1 /* $Id: oslibwin.cpp,v 1.35 1999-10-23 23:04:35 sandervl Exp $ */
     1/* $Id: oslibwin.cpp,v 1.36 1999-10-25 20:17:19 sandervl Exp $ */
    22/*
    33 * Window API wrappers for OS/2
    … …  
    199199BOOL OSLibWinSetWindowULong(HWND hwnd, ULONG offset, ULONG value)
    200200{
     201  if(offset == OSLIB_QWL_USER)
     202        offset = QWL_USER;
     203
    201204  return WinSetWindowULong(hwnd, offset, value);
    202205}
    … …  
    205208ULONG OSLibWinGetWindowULong(HWND hwnd, ULONG offset)
    206209{
     210  if(offset == OSLIB_QWL_USER)
     211        offset = QWL_USER;
     212
    207213  return WinQueryWindowULong(hwnd, offset);
    208214}

  • trunk/src/user32/oslibwin.h

    r1425 r1446  
    1 /* $Id: oslibwin.h,v 1.20 1999-10-23 23:04:36 sandervl Exp $ */
     1/* $Id: oslibwin.h,v 1.21 1999-10-25 20:17:20 sandervl Exp $ */
    22/*
    33 * Window API wrappers for OS/2
    … …  
    4343BOOL  OSLibWinConvertStyle(ULONG dwStyle, ULONG *dwExStyle, ULONG *OSWinStyle, ULONG *OSFrameStyle, ULONG *borderWidth, ULONG *borderHeight);
    4444void  OSLibSetWindowStyle(HWND hwnd, ULONG dwStyle);
     45
     46#define OSLIB_QWL_USER -4
    4547
    4648BOOL  OSLibWinSetWindowULong(HWND hwnd, ULONG offset, ULONG value);

  • trunk/src/user32/pmwindow.cpp

    r1429 r1446  
    1 /* $Id: pmwindow.cpp,v 1.44 1999-10-24 12:30:28 sandervl Exp $ */
     1/* $Id: pmwindow.cpp,v 1.45 1999-10-25 20:17:20 sandervl Exp $ */
    22/*
    33 * Win32 Window Managment Code for OS/2
    … …  
    5151               0x09,    // VK_TAB           VK_TAB
    5252               0x00,    // VK_BACKTAB       No equivalent!
    53                0x0D,    // VK_NEWLINE       VK_RETURN
     53               0x0A,    // VK_NEWLINE       0x0A (no VK_* def)
    5454               0x10,    // VK_SHIFT         VK_SHIFT
    5555               0x11,    // VK_CTRL          VK_CONTROL
    … …  
    7373               0x91,    // VK_SCRLLOCK      VK_SCROLL
    7474               0x90,    // VK_NUMLOCK       VK_NUMLOCK
    75                0x2B,    // VK_ENTER         VK_EXECUTE, best match I guess
     75               0x0D,    // VK_ENTER         VK_RETURN
    7676               0x00,    // VK_SYSRQ         No equivalent!
    7777               0x70,    // VK_F1            VK_F1
    … …  
    448448      HWND hwndFocus = (HWND)mp1;
    449449
    450         dprintf(("OS2: WM_SETFOCUS %x %d", win32wnd->getWindowHandle(), mp2));
     450        dprintf(("OS2: WM_SETFOCUS %x %x %d", win32wnd->getWindowHandle(), mp1, mp2));
    451451        if(WinQueryWindowULong(hwndFocus, OFFSET_WIN32PM_MAGIC) != WIN32PM_MAGIC) {
    452452                //another (non-win32) application's window
    … …  
    664664        keyWasPressed = ((SHORT1FROMMP (mp1) & KC_PREVDOWN) == KC_PREVDOWN);
    665665
     666        dprintf(("PM: WM_CHAR: %x %x %d %x", SHORT1FROMMP(mp2), SHORT2FROMMP(mp2), repeatCount, scanCode));
    666667        // both WM_KEYUP & WM_KEYDOWN want a virtual key, find the right Win32 virtual key
    667668        // given the OS/2 virtual key and OS/2 character
    … …  
    737738            ULONG keyflags = 0, vkey = 0;
    738739            ULONG fl = SHORT1FROMMP(mp1);
     740            ULONG chCode = SHORT1FROMMP(mp2);
    739741
    740742            if(!(fl & KC_CHAR)) {
    741                 goto RunDefWndProc;
     743//SvL: Test
     744                break;
     745//                goto RunDefWndProc;
    742746            }
    743747            if(fl & KC_VIRTUALKEY) {
    744                 vkey = SHORT2FROMMP(mp2);
     748                if(virtualKey)
     749                        vkey = virtualKey;
     750                else    vkey = SHORT2FROMMP(mp2);
     751                chCode = vkey;
    745752            }
    746753            if(fl & KC_KEYUP) {
    … …  
    756763                keyflags |= KEY_DEADKEY;
    757764            }
    758             if(win32wnd->MsgChar(SHORT1FROMMP(mp2), CHAR3FROMMP(mp1), CHAR4FROMMP(mp1), virtualKey, keyflags)) {
    759                 goto RunDefWndProc;
    760             }
    761         }
    762         if(fRunDefWndProc) goto RunDefWndProc;
     765            if(win32wnd->MsgChar(chCode, CHAR3FROMMP(mp1), CHAR4FROMMP(mp1), virtualKey, keyflags)) {
     766//SvL: Test
     767//                goto RunDefWndProc;
     768
     769            }
     770        }
     771//SvL: Test
     772//        if(fRunDefWndProc) goto RunDefWndProc;
    763773        break;
    764774    }

  • trunk/src/user32/winmenu.cpp

    r1436 r1446  
    1 /* $Id: winmenu.cpp,v 1.9 1999-10-25 12:49:20 phaller Exp $ */
     1/* $Id: winmenu.cpp,v 1.10 1999-10-25 20:17:21 sandervl Exp $ */
    22
    33/*
    … …  
    77 * Copyright 1998 Patrick Haller
    88 *
    9  * Parts ported from Wine: (ChangeMenuA/W)
     9 * Parts ported from Wine:
    1010 * Copyright 1993 Martin Ayotte
    1111 * Copyright 1994 Alexandre Julliard
    1212 * Copyright 1997 Morten Welinder
    1313 *
     14 *
     15 * TODO: Set/GetMenu(Item)Info only partially implemented
     16 * TODO: Memory leak when deleting submenus
     17 * TODO: Check error nrs
    1418 *
    1519 * Project Odin Software License can be found in LICENSE.TXT
    … …  
    2327#include <win32wbase.h>
    2428#include "oslibmenu.h"
     29#include "oslibwin.h"
    2530#include <winresmenu.h>
    26 
     31#include "winmenudef.h"
    2732
    2833ODINDEBUGCHANNEL(USER32)
    2934
     35//******************************************************************************
     36//******************************************************************************
     37void SetInternalMenuInfo(HMENU hMenu)
     38{
     39  LPPOPUPMENU lpMenuInfo;
     40
     41    lpMenuInfo = (LPPOPUPMENU)malloc(sizeof(*lpMenuInfo));
     42    memset(lpMenuInfo, 0, sizeof(*lpMenuInfo));
     43    OSLibWinSetWindowULong(hMenu, OSLIB_QWL_USER, (ULONG)lpMenuInfo);
     44}
     45//******************************************************************************
     46//******************************************************************************
     47LPPOPUPMENU GetInternalMenuInfo(HMENU hMenu)
     48{
     49    return (LPPOPUPMENU)OSLibWinGetWindowULong(hMenu, OSLIB_QWL_USER);
     50}
     51//******************************************************************************
     52//******************************************************************************
     53void DeleteInternalMenuInfo(HMENU hMenu)
     54{
     55  LPPOPUPMENU lpMenuInfo;
     56
     57    lpMenuInfo = (LPPOPUPMENU)OSLibWinGetWindowULong(hMenu, OSLIB_QWL_USER);
     58    if(lpMenuInfo) {
     59        free(lpMenuInfo);
     60        OSLibWinSetWindowULong(hMenu, OSLIB_QWL_USER, 0);
     61    }
     62}
     63//******************************************************************************
     64//******************************************************************************
     65ODINFUNCTION0(HMENU, CreateMenu)
     66{
     67  HMENU hMenu;
     68
     69    dprintf(("USER32: CreateMenu\n"));
     70
     71    hMenu = OSLibWinCreateEmptyMenu();
     72    if(hMenu) {
     73            SetInternalMenuInfo(hMenu);
     74    }
     75    else    SetLastError(ERROR_INVALID_PARAMETER); //wrong error
     76
     77    return hMenu;
     78}
     79//******************************************************************************
     80//******************************************************************************
     81ODINFUNCTION0(HMENU, CreatePopupMenu)
     82{
     83  HMENU hMenu;
     84
     85    dprintf(("USER32: CreatePopupMenu\n"));
     86
     87    hMenu = OSLibWinCreateEmptyPopupMenu();
     88    if(hMenu) {
     89            SetInternalMenuInfo(hMenu);
     90    }
     91    else    SetLastError(ERROR_INVALID_PARAMETER); //wrong error
     92
     93    return hMenu;
     94}
    3095//******************************************************************************
    3196//******************************************************************************
    … …  
    37102  HMENU hMenu;
    38103
    39   winres = (Win32MenuRes *)FindResourceA(hinst, lpszMenu, RT_MENUA);
    40   if(winres) {
    41      //@@@PH 1999/10/25 crash in EFCW, stack corruption
    42         hMenu = O32_LoadMenuIndirect((MENUITEMTEMPLATEHEADER *)winres->lockOS2Resource());
    43         delete winres;
    44         return hMenu;
    45   }
    46   return 0;
     104    winres = (Win32MenuRes *)FindResourceA(hinst, lpszMenu, RT_MENUA);
     105    if(winres)
     106    {
     107        hMenu = OSLibWinCreateMenu(winres->lockOS2Resource());
     108        if(hMenu) {
     109                SetInternalMenuInfo(hMenu);
     110        }
     111        else    SetLastError(ERROR_INVALID_PARAMETER);
     112
     113        delete winres;
     114        return hMenu;
     115    }
     116    return 0;
    47117}
    48118//******************************************************************************
    … …  
    55125  HMENU hMenu;
    56126
    57   winres = (Win32MenuRes *)FindResourceW(hinst, lpszMenu, RT_MENUW);
    58   if(winres) {
    59      //@@@PH 1999/10/25 crash in EFCW, stack corruption
    60         hMenu = O32_LoadMenuIndirect((MENUITEMTEMPLATEHEADER *)winres->lockOS2Resource());
    61         delete winres;
    62         return hMenu;
    63   }
    64   return 0;
     127    winres = (Win32MenuRes *)FindResourceW(hinst, lpszMenu, RT_MENUW);
     128    if(winres) {
     129        hMenu = OSLibWinCreateMenu(winres->lockOS2Resource());
     130        if(hMenu) {
     131                SetInternalMenuInfo(hMenu);
     132        }
     133        else    SetLastError(ERROR_INVALID_PARAMETER);
     134
     135        delete winres;
     136        return hMenu;
     137    }
     138    return 0;
    65139}
    66140//******************************************************************************
    … …  
    73147  HMENU hMenu;
    74148
    75   winres = new Win32MenuRes((LPVOID)menuTemplate);
    76   if(winres == NULL)
    77     return 0;
    78 
    79   hMenu = O32_LoadMenuIndirect((MENUITEMTEMPLATEHEADER *)winres->lockOS2Resource());
    80   delete winres;
    81   return (HMENU)winres;
     149    winres = new Win32MenuRes((LPVOID)menuTemplate);
     150    if(winres == NULL)
     151        return 0;
     152
     153    hMenu = OSLibWinCreateMenu(winres->lockOS2Resource());
     154    if(hMenu) {
     155            SetInternalMenuInfo(hMenu);
     156    }
     157    else    SetLastError(ERROR_INVALID_PARAMETER);
     158
     159    delete winres;
     160    return (HMENU)winres;
    82161}
    83162//******************************************************************************
    … …  
    89168  HMENU hMenu;
    90169
    91   winres = new Win32MenuRes((LPVOID)menuTemplate);
    92   if(winres == NULL)
    93     return 0;
    94 
    95   hMenu = O32_LoadMenuIndirect((MENUITEMTEMPLATEHEADER *)winres->lockOS2Resource());
    96   delete winres;
    97   return (HMENU)winres;
     170    winres = new Win32MenuRes((LPVOID)menuTemplate);
     171    if(winres == NULL)
     172        return 0;
     173
     174    hMenu = OSLibWinCreateMenu(winres->lockOS2Resource());
     175    if(hMenu) {
     176            SetInternalMenuInfo(hMenu);
     177    }
     178    else    SetLastError(ERROR_INVALID_PARAMETER);
     179
     180    delete winres;
     181    return (HMENU)winres;
    98182}
    99183//******************************************************************************
    … …  
    102186              HMENU, hMenu)
    103187{
    104   return O32_DestroyMenu(hMenu);
     188    if(hMenu == 0)
     189    {
     190        SetLastError(ERROR_INVALID_PARAMETER);
     191        return 0;
     192    }
     193    DeleteInternalMenuInfo(hMenu);
     194    return O32_DestroyMenu(hMenu);
    105195}
    106196//******************************************************************************
    … …  
    111201  Win32BaseWindow *window;
    112202
    113   window = Win32BaseWindow::GetWindowFromHandle(hwnd);
    114   if(!window)
    115   {
    116     dprintf(("GetMenu, window %x not found", hwnd));
    117     return 0;
    118   }
    119 
    120   return window->GetMenu();
     203    window = Win32BaseWindow::GetWindowFromHandle(hwnd);
     204    if(!window)
     205    {
     206        dprintf(("GetMenu, window %x not found", hwnd));
     207        SetLastError(ERROR_INVALID_WINDOW_HANDLE);
     208        return 0;
     209    }
     210
     211    return window->GetMenu();
    121212}
    122213//******************************************************************************
    … …  
    128219  Win32BaseWindow *window;
    129220
    130   window = Win32BaseWindow::GetWindowFromHandle(hwnd);
    131   if(!window)
    132   {
    133     dprintf(("SetMenu, window %x not found", hwnd));
    134     return 0;
    135   }
    136 
    137   window->SetMenu(hMenu);
    138   return TRUE;
     221    window = Win32BaseWindow::GetWindowFromHandle(hwnd);
     222    if(!window)
     223    {
     224        dprintf(("SetMenu, window %x not found", hwnd));
     225        SetLastError(ERROR_INVALID_WINDOW_HANDLE);
     226        return 0;
     227    }
     228
     229    window->SetMenu(hMenu);
     230    return TRUE;
    139231}
    140232//******************************************************************************
    … …  
    149241              HMENU, hMenu)
    150242{
    151   if(hMenu == 0)
    152   {
    153     SetLastError(ERROR_INVALID_PARAMETER);
    154     return 0;
    155   }
    156   return OSLibGetMenuItemCount(hMenu);
     243    if(hMenu == 0)
     244    {
     245        SetLastError(ERROR_INVALID_PARAMETER);
     246        return 0;
     247    }
     248    return OSLibGetMenuItemCount(hMenu);
    157249}
    158250//******************************************************************************
    … …  
    162254              int,   nPos)
    163255{
    164   if(hMenu == 0)
    165   {
    166     SetLastError(ERROR_INVALID_PARAMETER);
    167     return 0;
    168   }
    169   return O32_GetMenuItemID(hMenu, nPos);
     256    if(hMenu == 0)
     257    {
     258        SetLastError(ERROR_INVALID_PARAMETER);
     259        return 0;
     260    }
     261    return O32_GetMenuItemID(hMenu, nPos);
    170262}
    171263//******************************************************************************
    … …  
    176268              UINT,  arg3)
    177269{
    178   if(hMenu == 0)
    179   {
    180     SetLastError(ERROR_INVALID_PARAMETER);
    181     return 0;
    182   }
    183 
    184   return O32_GetMenuState(hMenu, arg2, arg3);
     270    if(hMenu == 0)
     271    {
     272        SetLastError(ERROR_INVALID_PARAMETER);
     273        return 0;
     274    }
     275
     276    return O32_GetMenuState(hMenu, arg2, arg3);
    185277}
    186278//******************************************************************************
    … …  
    193285              UINT,  arg5)
    194286{
    195   if(hMenu == 0)
    196   {
    197     SetLastError(ERROR_INVALID_PARAMETER);
    198     return 0;
    199   }
    200 
    201   return O32_GetMenuString(hMenu, arg2, arg3, arg4, arg5);
     287    if(hMenu == 0)
     288    {
     289        SetLastError(ERROR_INVALID_PARAMETER);
     290        return 0;
     291    }
     292
     293    return O32_GetMenuString(hMenu, arg2, arg3, arg4, arg5);
    202294}
    203295//******************************************************************************
    … …  
    213305  int   rc;
    214306
    215   if(hMenu == 0)
    216   {
    217     SetLastError(ERROR_INVALID_PARAMETER);
    218     return 0;
    219   }
    220 
    221   rc = O32_GetMenuString(hMenu, idItem, astring, cchMax, fuFlags);
    222   free(astring);
    223   if(rc)
    224   {
    225     dprintf(("USER32: OS2GetMenuStringW %s\n", astring));
    226              AsciiToUnicode(astring, lpsz);
    227   }
    228   else
    229     lpsz[0] = 0;
    230 
    231   return(rc);
     307    if(hMenu == 0)
     308    {
     309        SetLastError(ERROR_INVALID_PARAMETER);
     310        return 0;
     311    }
     312
     313    rc = O32_GetMenuString(hMenu, idItem, astring, cchMax, fuFlags);
     314    free(astring);
     315    if(rc)
     316    {
     317            dprintf(("USER32: OS2GetMenuStringW %s\n", astring));
     318                     AsciiToUnicode(astring, lpsz);
     319    }
     320    else    lpsz[0] = 0;
     321
     322    return(rc);
    232323}
    233324//******************************************************************************
    … …  
    240331              HBITMAP, arg5)
    241332{
    242   dprintf(("USER32:  SetMenuItemBitmaps\n"));
    243   if(hMenu == 0)
    244   {
    245     SetLastError(ERROR_INVALID_PARAMETER);
    246     return 0;
    247   }
    248   return O32_SetMenuItemBitmaps(hMenu, arg2, arg3, arg4, arg5);
     333    dprintf(("USER32:  SetMenuItemBitmaps\n"));
     334    if(hMenu == 0)
     335    {
     336        SetLastError(ERROR_INVALID_PARAMETER);
     337        return 0;
     338    }
     339    return O32_SetMenuItemBitmaps(hMenu, arg2, arg3, arg4, arg5);
    249340}
    250341//******************************************************************************
    … …  
    254345              int, arg2)
    255346{
    256   if(hMenu == 0)
    257   {
    258     SetLastError(ERROR_INVALID_PARAMETER);
    259     return 0;
    260   }
    261 
    262   return O32_GetSubMenu(hMenu, arg2);
     347    if(hMenu == 0)
     348    {
     349        SetLastError(ERROR_INVALID_PARAMETER);
     350        return 0;
     351    }
     352
     353    return O32_GetSubMenu(hMenu, arg2);
    263354}
    264355//******************************************************************************
    … …  
    268359              BOOL,  bRevert)
    269360{
    270   Win32BaseWindow *window;
    271 
    272   window = Win32BaseWindow::GetWindowFromHandle(hSystemWindow);
    273   if(!window)
    274   {
    275     dprintf(("GetSystemMenu, window %x not found", hSystemWindow));
    276     return 0;
    277   }
    278 
    279   return O32_GetSystemMenu(window->getOS2FrameWindowHandle(), bRevert);
     361    Win32BaseWindow *window;
     362
     363    window = Win32BaseWindow::GetWindowFromHandle(hSystemWindow);
     364    if(!window)
     365    {
     366        dprintf(("GetSystemMenu, window %x not found", hSystemWindow));
     367        return 0;
     368    }
     369
     370    return O32_GetSystemMenu(window->getOS2FrameWindowHandle(), bRevert);
    280371}
    281372//******************************************************************************
    … …  
    300391  Win32BaseWindow *window;
    301392
    302   window = Win32BaseWindow::GetWindowFromHandle(arg6);
    303   if(!window)
    304   {
    305     dprintf(("TrackPopupMenu, window %x not found", arg6));
    306     return 0;
    307   }
    308   dprintf(("USER32:  TrackPopupMenu\n"));
    309   if(hMenu == 0)
    310   {
    311       SetLastError(ERROR_INVALID_PARAMETER);
    312       return 0;
    313   }
    314   return O32_TrackPopupMenu(hMenu, arg2, arg3, arg4, arg5, window->getOS2WindowHandle(),
    315                             arg7);
     393    window = Win32BaseWindow::GetWindowFromHandle(arg6);
     394    if(!window)
     395    {
     396        dprintf(("TrackPopupMenu, window %x not found", arg6));
     397        SetLastError(ERROR_INVALID_WINDOW_HANDLE);
     398        return 0;
     399    }
     400    dprintf(("USER32:  TrackPopupMenu\n"));
     401    if(hMenu == 0)
     402    {
     403        SetLastError(ERROR_INVALID_PARAMETER);
     404        return 0;
     405    }
     406    return O32_TrackPopupMenu(hMenu, arg2, arg3, arg4, arg5, window->getOS2WindowHandle(),
     407                              arg7);
    316408}
    317409//******************************************************************************
    … …  
    328420  Win32BaseWindow *window;
    329421
    330   window = Win32BaseWindow::GetWindowFromHandle(hwnd);
    331   if(!window)
    332   {
    333     dprintf(("TrackPopupMenu, window %x not found", hwnd));
    334     return 0;
    335   }
    336 
    337   dprintf(("USER32:  TrackPopupMenuEx, not completely implemented\n"));
    338   if(lpPM->cbSize != 0)
    339       rect = &lpPM->rcExclude;
    340 
    341   if(hMenu == 0)
    342   {
    343       SetLastError(ERROR_INVALID_PARAMETER);
    344       return 0;
    345   }
    346   return O32_TrackPopupMenu(hMenu, flags, X, Y, 0, window->getOS2WindowHandle(), rect);
     422    window = Win32BaseWindow::GetWindowFromHandle(hwnd);
     423    if(!window)
     424    {
     425        dprintf(("TrackPopupMenu, window %x not found", hwnd));
     426        SetLastError(ERROR_INVALID_WINDOW_HANDLE);
     427        return 0;
     428    }
     429
     430    dprintf(("USER32:  TrackPopupMenuEx, not completely implemented\n"));
     431    if(lpPM->cbSize != 0)
     432        rect = &lpPM->rcExclude;
     433
     434    if(hMenu == 0)
     435    {
     436        SetLastError(ERROR_INVALID_PARAMETER);
     437        return 0;
     438    }
     439    return O32_TrackPopupMenu(hMenu, flags, X, Y, 0, window->getOS2WindowHandle(), rect);
    347440}
    348441//******************************************************************************
    … …  
    412505    }
    413506    return O32_CheckMenuItem(hMenu, arg2, arg3);
    414 }
    415 //******************************************************************************
    416 //******************************************************************************
    417 ODINFUNCTION0(HMENU, CreateMenu)
    418 {
    419     dprintf(("USER32:  CreateMenu\n"));
    420     return O32_CreateMenu();
    421 }
    422 //******************************************************************************
    423 //******************************************************************************
    424 ODINFUNCTION0(HMENU, CreatePopupMenu)
    425 {
    426     dprintf(("USER32:  CreateMenu\n"));
    427     return O32_CreatePopupMenu();
    428507}
    429508//******************************************************************************
    … …  
    587666              DWORD, dwContextHelpId)
    588667{
    589   dprintf(("USER32:  OS2SetMenuContextHelpId, not implemented\n"));
    590   return(TRUE);
     668 POPUPMENU *menu;
     669
     670    menu = GetInternalMenuInfo(hMenu);
     671    if(menu == NULL) {
     672        dprintf(("USER32: SetMenuContextHelpId(%x) No POPUPMENU structure found!", hMenu));
     673        SetLastError(ERROR_INVALID_PARAMETER);
     674        return FALSE;
     675    }
     676    dprintf(("USER32:  SetMenuContextHelpId %x %d", hMenu, dwContextHelpId));
     677    menu->dwContextHelpID = dwContextHelpId;
     678    return(TRUE);
    591679}
    592680//******************************************************************************
    … …  
    595683              HMENU, hMenu)
    596684{
    597   dprintf(("USER32:  OS2GetMenuContextHelpId, not implemented\n"));
    598   return(0);
     685 POPUPMENU *menu;
     686
     687    menu = GetInternalMenuInfo(hMenu);
     688    if(menu == NULL) {
     689        dprintf(("USER32: GetMenuContextHelpId(%x) No POPUPMENU structure found!", hMenu));
     690        SetLastError(ERROR_INVALID_PARAMETER);
     691        return 0;
     692    }
     693    dprintf(("USER32:  GetMenuContextHelpId %x %d", hMenu, menu->dwContextHelpID));
     694    return menu->dwContextHelpID;
    599695}
    600696//******************************************************************************
    … …  
    660756              UINT, par1,
    661757              BOOL, par2,
    662               const MENUITEMINFOA *, lpMenuItemInfo)
    663 {
    664   dprintf(("USER32:  SetMenuItemInfoA, faked\n"));
    665   return(TRUE);
     758              const MENUITEMINFOA *, lpmii)
     759{
     760    dprintf(("USER32:  SetMenuItemInfoA faked %x", hMenu));
     761
     762    if (!hMenu) {
     763    SetLastError(ERROR_INVALID_PARAMETER);
     764    return FALSE;
     765    }
     766    return TRUE;
    666767}
    667768/*****************************************************************************
    … …  
    695796                           fByPosition,
    696797                           (const MENUITEMINFOA *)lpmmi));
    697 }
    698 //******************************************************************************
    699 //******************************************************************************
    700 ODINFUNCTION3(BOOL, SetMenuDefaultItem,
    701               HMENU, hMenu,
    702               UINT, uItem,
    703               UINT, fByPos)
    704 {
    705   dprintf(("USER32:  SetMenuDefaultItem, faked\n"));
    706   return(TRUE);
    707 }
    708 //******************************************************************************
    709 //******************************************************************************
    710 ODINFUNCTION4(BOOL, GetMenuItemInfoA,
    711               HMENU, hMenu,
    712               UINT, uItem,
    713               BOOL, aBool,
    714               MENUITEMINFOA *, lpMenuItemInfo)
    715 {
    716   dprintf(("USER32:  GetMenuItemInfoA, faked\n"));
    717   return(TRUE);
    718798}
    719799/*****************************************************************************
    … …  
    744824  return (-1);
    745825}
    746 
    747 
     826//******************************************************************************
     827//******************************************************************************
     828ODINFUNCTION3(BOOL, SetMenuDefaultItem,
     829              HMENU, hMenu,
     830              UINT, uItem,
     831              UINT, fByPos)
     832{
     833    dprintf(("USER32:  SetMenuDefaultItem, faked\n"));
     834    return(TRUE);
     835}
     836//******************************************************************************
     837//******************************************************************************
     838BOOL GetMenuItemInfoAW(HMENU hMenu, UINT uItem, BOOL byPos, MENUITEMINFOA *lpmii, BOOL unicode)
     839{
     840    if(byPos) {
     841        uItem = GetMenuItemID(hMenu, uItem);
     842    }
     843    if(GetMenuState(hMenu, uItem, MF_BYCOMMAND) == -1) {
     844        //item doesn't exist
     845        dprintf(("USER32:  GetMenuItemInfoAW %x item %d doesn't exist", hMenu, uItem));
     846        SetLastError(ERROR_INVALID_PARAMETER);
     847        return FALSE;
     848    }
     849    if (lpmii->fMask & MIIM_TYPE)
     850    {
     851        lpmii->fType = GetMenuState(hMenu, uItem, MF_BYCOMMAND); //not correct
     852//      lpmii->fType = menu->fType;
     853            if (unicode) {
     854                lpmii->cch = GetMenuStringW(hMenu, uItem, (LPWSTR)lpmii->dwTypeData, lpmii->cch, MF_BYCOMMAND);
     855            }
     856            else {
     857                lpmii->cch = GetMenuStringA(hMenu, uItem, (LPSTR)lpmii->dwTypeData, lpmii->cch, MF_BYCOMMAND);
     858            }
     859//TODO:
     860#if 0   
     861        switch (MENU_ITEM_TYPE(menu->fType)) {
     862                case MF_STRING:
     863                    if (menu->text && lpmii->dwTypeData && lpmii->cch) {
     864                            if (unicode) {
     865                            lstrcpynAtoW((LPWSTR) lpmii->dwTypeData, menu->text, lpmii->cch);
     866                            lpmii->cch = lstrlenW((LPWSTR)menu->text);
     867                        }
     868                        else {
     869                            lstrcpynA(lpmii->dwTypeData, menu->text, lpmii->cch);
     870                            lpmii->cch = lstrlenA(menu->text);
     871                        }
     872                    }
     873                    break;
     874                case MF_OWNERDRAW:
     875                case MF_BITMAP:
     876                    lpmii->dwTypeData = menu->text;
     877                    /* fall through */
     878                default:
     879                    lpmii->cch = 0;
     880            }
     881#endif
     882    }
     883
     884    if (lpmii->fMask & MIIM_STRING) {
     885            if (unicode) {
     886                lpmii->cch = GetMenuStringW(hMenu, uItem, (LPWSTR)lpmii->dwTypeData, lpmii->cch, MF_BYCOMMAND);
     887            }
     888            else {
     889                lpmii->cch = GetMenuStringA(hMenu, uItem, (LPSTR)lpmii->dwTypeData, lpmii->cch, MF_BYCOMMAND);
     890            }
     891    }
     892
     893//TODO:
     894#if 0
     895    if (lpmii->fMask & MIIM_FTYPE)
     896            lpmii->fType = menu->fType;
     897
     898    if (lpmii->fMask & MIIM_BITMAP)
     899            lpmii->hbmpItem = menu->hbmpItem;
     900#endif
     901
     902    if (lpmii->fMask & MIIM_STATE)
     903            lpmii->fState = GetMenuState(hMenu, uItem, MF_BYCOMMAND);
     904
     905    if (lpmii->fMask & MIIM_ID)
     906            lpmii->wID = uItem;
     907
     908//TODO:
     909#if 1
     910    lpmii->hSubMenu = 0;
     911    lpmii->hbmpChecked = 0;
     912    lpmii->hbmpUnchecked = 0;
     913    lpmii->dwItemData = 0;
     914#else
     915    if (lpmii->fMask & MIIM_SUBMENU)
     916            lpmii->hSubMenu = GetSubMenu(hMenu, uItem); //need index, not id
     917
     918    if (lpmii->fMask & MIIM_CHECKMARKS) {
     919            lpmii->hbmpChecked = menu->hCheckBit;
     920            lpmii->hbmpUnchecked = menu->hUnCheckBit;
     921    }
     922    if (lpmii->fMask & MIIM_DATA)
     923            lpmii->dwItemData = menu->dwItemData;
     924#endif
     925
     926    return(FALSE);
     927}
     928//******************************************************************************
     929//******************************************************************************
     930ODINFUNCTION4(BOOL, GetMenuItemInfoA,
     931              HMENU, hMenu,
     932              UINT, uItem,
     933              BOOL, byPos,
     934              MENUITEMINFOA *, lpMenuItemInfo)
     935{
     936    return GetMenuItemInfoAW(hMenu, uItem, byPos, lpMenuItemInfo, FALSE);
     937}
    748938/*****************************************************************************
    749939 * Function  : GetMenuItemInfoW
    … …  
    763953              HMENU, hMenu,
    764954              UINT, uItem,
    765               BOOL, fByPosition,
    766               MENUITEMINFOW *, lpmii)
    767 {
    768   dprintf(("USER32:GetMenuItemInfoW (%08xh,%08xh,%u,%08x) not implemented.\n",
    769          hMenu,
    770          uItem,
    771          fByPosition,
    772          lpmii));
    773 
    774   return(GetMenuItemInfoA(hMenu,
    775                           uItem,
    776                           fByPosition,
    777                           (MENUITEMINFOA *)lpmii));
    778 }
    779 
    780 
     955              BOOL, byPos,
     956              MENUITEMINFOW *, lpMenuItemInfo)
     957{
     958    return GetMenuItemInfoAW(hMenu, uItem, byPos, (MENUITEMINFOA*)lpMenuItemInfo, TRUE);
     959}
    781960/*****************************************************************************
    782961 * Function  : GetMenuItemRect
    … …  
    9111090              LPMENUINFO, lpmi)
    9121091{
    913   dprintf(("USER32: GetMenuInfo(%08xh,%08xh) not implemented.\n",
    914          hMenu,
    915          lpmi));
    916 
    917   memset(lpmi,0,sizeof(MENUINFO));
    918   return 0;
    919 }
    920 #if 0
    921    POPUPMENU *menu;
    922 
    923     TRACE("(0x%04x %p)\n", hMenu, lpmi);
    924 
    925     if (lpmi && (menu = (POPUPMENU *) USER_HEAP_LIN_ADDR(hMenu)))
    926     {
    927 
    928    if (lpmi->fMask & MIM_BACKGROUND)
    929        lpmi->hbrBack = menu->hbrBack;
    930 
    931    if (lpmi->fMask & MIM_HELPID)
    932        lpmi->dwContextHelpID = menu->dwContextHelpID;
    933 
    934    if (lpmi->fMask & MIM_MAXHEIGHT)
    935        lpmi->cyMax = menu->cyMax;
    936 
    937    if (lpmi->fMask & MIM_MENUDATA)
    938        lpmi->dwMenuData = menu->dwMenuData;
    939 
    940    if (lpmi->fMask & MIM_STYLE)
    941        lpmi->dwStyle = menu->dwStyle;
    942 
    943    return TRUE;
    944     }
     1092 POPUPMENU *menu;
     1093
     1094    menu = GetInternalMenuInfo(hMenu);
     1095    if(menu == NULL) {
     1096        dprintf(("USER32: GetMenuInfo(%08xh,%08xh) No POPUPMENU structure found!", hMenu, lpmi));
     1097        SetLastError(ERROR_INVALID_PARAMETER);
     1098        return FALSE;
     1099    }
     1100    dprintf(("USER32: GetMenuInfo(%08xh,%08xh)", hMenu, lpmi));
     1101
     1102    if (lpmi)
     1103    {
     1104        if (lpmi->fMask & MIM_BACKGROUND)
     1105            lpmi->hbrBack = menu->hbrBack;
     1106
     1107        if (lpmi->fMask & MIM_HELPID)
     1108            lpmi->dwContextHelpID = menu->dwContextHelpID;
     1109
     1110        if (lpmi->fMask & MIM_MAXHEIGHT)
     1111            lpmi->cyMax = menu->cyMax;
     1112
     1113        if (lpmi->fMask & MIM_MENUDATA)
     1114            lpmi->dwMenuData = menu->dwMenuData;
     1115
     1116        if (lpmi->fMask & MIM_STYLE)
     1117            lpmi->dwStyle = menu->dwStyle;
     1118
     1119        return TRUE;
     1120    }
     1121    SetLastError(ERROR_INVALID_PARAMETER);
    9451122    return FALSE;
    9461123}
    947 #endif
    948 
    949 
    9501124/*****************************************************************************
    9511125 * Function  :  SetMenuInfo
    … …  
    9671141              LPCMENUINFO, lpmi)
    9681142{
    969   dprintf(("USER32: SetMenuInfo(%08xh,%08xh) not implemented.\n",
    970          hMenu,
    971          lpmi));
    972 
    973   return 0;
    974 }
    975 #if 0
    976     POPUPMENU *menu;
    977 
    978     TRACE("(0x%04x %p)\n", hMenu, lpmi);
    979 
    980 
    981 
    982     if (lpmi && (lpmi->cbSize==sizeof(MENUINFO)) && (menu=(POPUPMENU*)USER_HEAP_LIN_ADDR(hMenu)))
    983     {
    984 
    985    if (lpmi->fMask & MIM_BACKGROUND)
    986        menu->hbrBack = lpmi->hbrBack;
    987 
    988    if (lpmi->fMask & MIM_HELPID)
    989        menu->dwContextHelpID = lpmi->dwContextHelpID;
    990 
    991    if (lpmi->fMask & MIM_MAXHEIGHT)
    992        menu->cyMax = lpmi->cyMax;
    993 
    994    if (lpmi->fMask & MIM_MENUDATA)
    995        menu->dwMenuData = lpmi->dwMenuData;
    996 
    997    if (lpmi->fMask & MIM_STYLE)
    998        menu->dwStyle = lpmi->dwStyle;
    999 
    1000    return TRUE;
    1001     }
     1143 POPUPMENU *menu;
     1144
     1145    menu = GetInternalMenuInfo(hMenu);
     1146    if(menu == NULL) {
     1147        dprintf(("USER32: SetMenuInfo(%08xh,%08xh) No POPUPMENU structure found!", hMenu, lpmi));
     1148        SetLastError(ERROR_INVALID_PARAMETER);
     1149        return FALSE;
     1150    }
     1151
     1152    dprintf(("USER32: SetMenuInfo(%08xh,%08xh)", hMenu, lpmi));
     1153
     1154    if (lpmi && (lpmi->cbSize==sizeof(MENUINFO)))
     1155    {
     1156        if (lpmi->fMask & MIM_BACKGROUND)
     1157            menu->hbrBack = lpmi->hbrBack;
     1158
     1159        if (lpmi->fMask & MIM_HELPID)
     1160            menu->dwContextHelpID = lpmi->dwContextHelpID;
     1161
     1162        if (lpmi->fMask & MIM_MAXHEIGHT)
     1163            menu->cyMax = lpmi->cyMax;
     1164
     1165        if (lpmi->fMask & MIM_MENUDATA)
     1166            menu->dwMenuData = lpmi->dwMenuData;
     1167
     1168        if (lpmi->fMask & MIM_STYLE)
     1169            menu->dwStyle = lpmi->dwStyle;
     1170
     1171        return TRUE;
     1172    }
     1173    SetLastError(ERROR_INVALID_PARAMETER);
    10021174    return FALSE;
    10031175}
    1004 #endif
    1005 
    1006 
     1176//******************************************************************************
     1177//******************************************************************************
     1178
Note: See TracChangeset for help on using the changeset viewer.