Changeset 1513 for trunk/src/user32


Ignore:
Timestamp:
Oct 30, 1999, 11:19:47 AM (26 years ago)
Author:
sandervl
Message:

EB's unicode changes + seticon + mdi fixes

Location:
trunk/src/user32
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/user32/oslibmenu.cpp

    r1446 r1513  
    1 /* $Id: oslibmenu.cpp,v 1.3 1999-10-25 20:17:18 sandervl Exp $ */
     1/* $Id: oslibmenu.cpp,v 1.4 1999-10-30 09:19:44 sandervl Exp $ */
    22/*
    33 * Window Menu wrapper functions for OS/2
    … …  
    3131   if (currMenu)
    3232   {
     33      dprintf(("OSLibWinSetMenu: old menu %x, new menu %x", currMenu, hMenu));
    3334      WinSetOwner (currMenu, HWND_OBJECT);
    3435      WinSetParent(currMenu, HWND_OBJECT, FALSE);
    … …  
    3738   if (hMenu)
    3839   {
    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       }
     40        if(WinIsWindow(GetThreadHAB(), hMenu) == TRUE)
     41        {
     42                WinSetOwner (hMenu, hwndParent);
     43                WinSetParent(hMenu, hwndParent, FALSE );
     44                WinSetWindowUShort(hMenu, QWS_ID, FID_MENU);
     45                WinSendMsg(hwndParent, WM_UPDATEFRAME, (MPARAM)FCF_MENU, 0);
     46                return hMenu;
     47        }
     48        else {
     49                dprintf(("OSLibWinSetMenu: %x = invalid menu handle", hMenu));
     50        }
    4651   }
    4752   return 0;

  • trunk/src/user32/uitools.cpp

    r1343 r1513  
    1 /* $Id: uitools.cpp,v 1.14 1999-10-17 19:32:05 cbratschi Exp $ */
     1/* $Id: uitools.cpp,v 1.15 1999-10-30 09:19:44 sandervl Exp $ */
    22/*
    33 * User Interface Functions
    … …  
    19081908        return 0;
    19091909    }
    1910     dprintf(("DrawMenuBar\n"));
     1910    dprintf(("DrawMenuBar %x", hwnd));
    19111911    return O32_DrawMenuBar(window->getOS2FrameWindowHandle());
    19121912}

  • trunk/src/user32/win32dlg.cpp

    r1507 r1513  
    1 /* $Id: win32dlg.cpp,v 1.21 1999-10-28 23:51:05 sandervl Exp $ */
     1/* $Id: win32dlg.cpp,v 1.22 1999-10-30 09:19:45 sandervl Exp $ */
    22/*
    33 * Win32 Dialog Code for OS/2
    … …  
    606606
    607607        dprintf(("Create CONTROL %d", info.id));
     608#if 0
    608609        if(isUnicode) {
    609610            hwndCtrl = ::CreateWindowExW( info.exStyle | WS_EX_NOPARENTNOTIFY,
    … …  
    619620        }
    620621        else {
     622#endif
    621623            char *classNameA = NULL;
    622624            char *windowNameA = NULL;
    … …  
    646648                FreeAsciiString(windowNameA);
    647649            }
    648         }
     650//        }
    649651
    650652        if (!hwndCtrl) return FALSE;

  • trunk/src/user32/win32wbase.cpp

    r1511 r1513  
    1 /* $Id: win32wbase.cpp,v 1.67 1999-10-29 16:06:56 cbratschi Exp $ */
     1/* $Id: win32wbase.cpp,v 1.68 1999-10-30 09:19:45 sandervl Exp $ */
    22/*
    33 * Win32 Window Base Class for OS/2
    … …  
    420420  hwndLinkAfter = ((cs->style & (WS_CHILD|WS_MAXIMIZE)) == WS_CHILD)
    421421                  ? HWND_BOTTOM : HWND_TOP;
    422 #endif
    423 
    424 #if 0
    425 //TODO
    426     /* Call the WH_CBT hook */
    427 
    428     if (HOOK_IsHooked( WH_CBT ))
    429     {
    430         CBT_CREATEWNDA cbtc;
    431         LRESULT ret;
    432 
    433         cbtc.lpcs = cs;
    434         cbtc.hwndInsertAfter = hwndLinkAfter;
    435         ret = unicode ? HOOK_CallHooksW(WH_CBT, HCBT_CREATEWND, Win32Hwnd, (LPARAM)&cbtc)
    436                       : HOOK_CallHooksA(WH_CBT, HCBT_CREATEWND, Win32Hwnd, (LPARAM)&cbtc);
    437         if (ret)
    438     {
    439         TRACE_(win)("CBT-hook returned 0\n");
    440         wndPtr->pDriver->pFinalize(wndPtr);
    441             retvalue =  0;
    442             goto end;
    443     }
    444     }
    445422#endif
    446423
    … …  
    12561233  return NULL;
    12571234}
    1258 /***********************************************************************/
    1259 /***********************************************************************/
     1235//******************************************************************************
     1236//******************************************************************************
    12601237VOID Win32BaseWindow::subclassScrollBars(BOOL subHorz,BOOL subVert)
    12611238{
    … …  
    15961573
    15971574    case WM_GETTEXT:   //TODO: SS_ICON controls
    1598         lstrcpynW((LPWSTR)lParam, windowNameW, wParam);
    1599         return min(wndNameLength, wParam);
     1575    {
     1576            LRESULT result;
     1577            char *str = (char *) malloc(wParam + 1);
     1578            result = DefWindowProcA(Msg, wParam, (LPARAM)str );
     1579            lstrcpynAtoW( (LPWSTR)lParam, str, wParam );
     1580            free(str);
     1581            return result;
     1582    }
    16001583
    16011584    case WM_SETTEXT:
    1602         if(!fInternalMsg) {
    1603                 return SetWindowTextW((LPWSTR)lParam);
     1585    {
     1586        if(!fInternalMsg)
     1587        {
     1588           LRESULT result;
     1589           char *aText = (char *) malloc((lstrlenW((LPWSTR)lParam)+1)*sizeof(WCHAR));
     1590           *aText = 0;
     1591           lstrcpyWtoA(aText, (LPWSTR) lParam);
     1592           result = SetWindowTextA(aText);
     1593           free(aText);
     1594           return result;
    16041595        }
    16051596        else    return 0;
     1597    }
    16061598
    16071599    default:
    … …  
    19021894    dprintf(("Win32BaseWindow::SetIcon %x", hIcon));
    19031895    if(OSLibWinSetIcon(OS2HwndFrame, hIcon) == TRUE) {
    1904         SendMessageA(WM_SETICON, hIcon, 0);
     1896//TODO: Wine does't send these. Correct?
     1897//        SendMessageA(WM_SETICON, ICON_BIG, hIcon);
    19051898        return TRUE;
    19061899    }

  • trunk/src/user32/win32wmdichild.cpp

    r1490 r1513  
    1 /* $Id: win32wmdichild.cpp,v 1.8 1999-10-28 12:00:36 sandervl Exp $ */
     1/* $Id: win32wmdichild.cpp,v 1.9 1999-10-30 09:19:46 sandervl Exp $ */
    22/*
    33 * Win32 MDI Child Window Class for OS/2
    … …  
    115115
    116116    case WM_CLOSE:
    117         client->SendMessageA(WM_MDIDESTROY,(WPARAM16)getWindowHandle(), 0L);
     117        client->SendMessageA(WM_MDIDESTROY,(WPARAM)getWindowHandle(), 0L);
    118118        return 0;
    119119

  • trunk/src/user32/win32wmdiclient.cpp

    r1490 r1513  
    1 /* $Id: win32wmdiclient.cpp,v 1.11 1999-10-28 12:00:36 sandervl Exp $ */
     1/* $Id: win32wmdiclient.cpp,v 1.12 1999-10-30 09:19:46 sandervl Exp $ */
    22/*
    33 * Win32 MDI Client Window Class for OS/2
    … …  
    365365    }
    366366
    367     dprintf(("childActivate: %x %x", this, child->getWindowHandle()));
     367    dprintf(("childActivate: %x %x", this, (child) ? child->getWindowHandle() : 0));
    368368    activeChild = child;
    369369

  • trunk/src/user32/window.cpp

    r1482 r1513  
    1 /* $Id: window.cpp,v 1.26 1999-10-27 18:25:24 sandervl Exp $ */
     1/* $Id: window.cpp,v 1.27 1999-10-30 09:19:47 sandervl Exp $ */
    22/*
    33 * Win32 window apis for OS/2
    … …  
    4747        return CreateMDIWindowA(className, windowName, style, x, y, width, height, parent, instance, (LPARAM)data);
    4848
     49#if 1
     50    /* Find the class atom */
     51    if (!(classAtom = GlobalFindAtomA(className)))
     52    {
     53       if (!HIWORD(className))
     54           dprintf(("CreateWindowEx32A: bad class name %04x\n",LOWORD(className)));
     55       else
     56           dprintf(("CreateWindowEx32A: bad class name '%s'\n", className));
     57
     58       SetLastError(ERROR_INVALID_PARAMETER);
     59       return 0;
     60    }
     61
     62    if (!HIWORD(className))
     63    {
     64      sprintf(tmpClass,"#%d", (int) className);
     65      className = tmpClass;
     66    }
     67#else
    4968    /* Find the class atom */
    5069    if (!HIWORD(className) || !(classAtom = GlobalFindAtomA(className)))
    … …  
    6786        }
    6887    }
    69 
     88#endif
    7089    /* Create the window */
    7190    cs.lpCreateParams = data;

  • trunk/src/user32/windowmsg.cpp

    r949 r1513  
    1 /* $Id: windowmsg.cpp,v 1.1 1999-09-15 23:19:02 sandervl Exp $ */
     1/* $Id: windowmsg.cpp,v 1.2 1999-10-30 09:19:47 sandervl Exp $ */
    22/*
    33 * Win32 window message APIs for OS/2
    … …  
    55 * Copyright 1999 Sander van Leeuwen
    66 *
    7  * Parts based on Wine Windows code (windows\message.c)
     7 * Parts based on Wine Windows code (windows\message.c) 990508
    88 *
    99 * Copyright 1993, 1994 Alexandre Julliard
    … …  
    1818#include <win.h>
    1919#include <hooks.h>
     20#include <heapstring.h>
    2021#include "oslibwin.h"
    2122#include "oslibmsg.h"
    … …  
    249250    FreeAsciiString(astring);
    250251    return rc;
    251 }
    252 //******************************************************************************
    253 //******************************************************************************
    254 LRESULT WIN32API CallWindowProcA(WNDPROC wndprcPrev,
    255                                  HWND       arg2,
    256                                  UINT       arg3,
    257                                  WPARAM     arg4,
    258                                  LPARAM     arg5)
    259 {
    260 #ifdef DEBUG
    261 ////    WriteLog("USER32:  CallWindowProcA %X hwnd=%X, msg = %X\n", wndprcPrev, arg2, arg3);
    262 #endif
    263 
    264     return wndprcPrev(arg2, arg3, arg4, arg5);   //win32 callback (__stdcall)
    265 }
    266 //******************************************************************************
    267 //******************************************************************************
    268 LRESULT WIN32API CallWindowProcW(WNDPROC arg1,
    269                                  HWND       arg2,
    270                                  UINT       arg3,
    271                                  WPARAM     arg4,
    272                                  LPARAM     arg5)
    273 {
    274   dprintf(("USER32:  CallWindowProcW(%08xh,%08xh,%08xh,%08xh,%08xh) not properly implemented.\n",
    275            arg1,
    276            arg2,
    277            arg3,
    278            arg4,
    279            arg5));
    280 
    281   return CallWindowProcA(arg1,
    282                             arg2,
    283                             arg3,
    284                             arg4,
    285                             arg5);
    286252}
    287253//******************************************************************************
    … …  
    468434//******************************************************************************
    469435//******************************************************************************
     436/**********************************************************************
     437 *           WINPROC_TestCBForStr
     438 *
     439 * Return TRUE if the lparam is a string
     440 */
     441BOOL WINPROC_TestCBForStr ( HWND hwnd )
     442{
     443    BOOL retvalue;
     444    DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE); 
     445    retvalue = ( !(LOWORD(dwStyle) & (CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE)) ||
     446              (LOWORD(dwStyle) & CBS_HASSTRINGS) );
     447    return retvalue;
     448}
     449/**********************************************************************
     450 *           WINPROC_TestLBForStr
     451 *
     452 * Return TRUE if the lparam is a string
     453 */
     454BOOL WINPROC_TestLBForStr ( HWND hwnd )
     455{
     456    BOOL retvalue;
     457    DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE); 
     458    retvalue = ( !(LOWORD(dwStyle) & (LBS_OWNERDRAWFIXED | LBS_OWNERDRAWVARIABLE)) ||
     459            (LOWORD(dwStyle) & LBS_HASSTRINGS) );
     460    return retvalue;
     461}
     462
     463/**********************************************************************
     464 *           WINPROC_MapMsg32ATo32W
     465 *
     466 * Map a message from Ansi to Unicode.
     467 * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
     468 *
     469 * FIXME:
     470 *  WM_CHAR, WM_CHARTOITEM, WM_DEADCHAR, WM_MENUCHAR, WM_SYSCHAR, WM_SYSDEADCHAR
     471 *
     472 * FIXME:
     473 *  WM_GETTEXT/WM_SETTEXT and static control with SS_ICON style:
     474 *  the first four bytes are the handle of the icon
     475 *  when the WM_SETTEXT message has been used to set the icon
     476 */
     477INT WINPROC_MapMsg32ATo32W( HWND hwnd, UINT msg, WPARAM wParam, LPARAM *plparam )
     478{
     479    switch(msg)
     480    {
     481    case WM_GETTEXT:
     482        {
     483            LPARAM *ptr = (LPARAM *)HeapAlloc( GetProcessHeap(), 0,
     484                                     wParam * sizeof(WCHAR) + sizeof(LPARAM) );
     485            if (!ptr) return -1;
     486            *ptr++ = *plparam;  /* Store previous lParam */
     487            *plparam = (LPARAM)ptr;
     488        }
     489        return 1;
     490    /* lparam is string (0-terminated) */
     491    case WM_SETTEXT:
     492    case WM_WININICHANGE:
     493    case CB_DIR:
     494    case CB_FINDSTRING:
     495    case CB_FINDSTRINGEXACT:
     496    case CB_SELECTSTRING:
     497    case LB_DIR:
     498    case LB_ADDFILE:
     499    case LB_FINDSTRING:
     500    case LB_SELECTSTRING:
     501    case EM_REPLACESEL:
     502        *plparam = (LPARAM)HEAP_strdupAtoW( GetProcessHeap(), 0, (LPCSTR)*plparam );
     503        return (*plparam ? 1 : -1);
     504
     505    case WM_NCCREATE:
     506    case WM_CREATE:
     507        {
     508            CREATESTRUCTW *cs = (CREATESTRUCTW *)HeapAlloc( GetProcessHeap(), 0,
     509                                                            sizeof(*cs) );
     510            if (!cs) return -1;
     511            *cs = *(CREATESTRUCTW *)*plparam;
     512            if (HIWORD(cs->lpszName))
     513                cs->lpszName = HEAP_strdupAtoW( GetProcessHeap(), 0,
     514                                                (LPCSTR)cs->lpszName );
     515            if (HIWORD(cs->lpszClass))
     516                cs->lpszClass = HEAP_strdupAtoW( GetProcessHeap(), 0,
     517                                                 (LPCSTR)cs->lpszClass );
     518            *plparam = (LPARAM)cs;
     519        }
     520        return 1;
     521    case WM_MDICREATE:
     522        {
     523            MDICREATESTRUCTW *cs =
     524                (MDICREATESTRUCTW *)HeapAlloc( GetProcessHeap(), 0, sizeof(*cs) );
     525            if (!cs) return -1;
     526            *cs = *(MDICREATESTRUCTW *)*plparam;
     527            if (HIWORD(cs->szClass))
     528                cs->szClass = HEAP_strdupAtoW( GetProcessHeap(), 0,
     529                                               (LPCSTR)cs->szClass );
     530            if (HIWORD(cs->szTitle))
     531                cs->szTitle = HEAP_strdupAtoW( GetProcessHeap(), 0,
     532                                               (LPCSTR)cs->szTitle );
     533            *plparam = (LPARAM)cs;
     534        }
     535        return 1;
     536
     537/* Listbox */
     538    case LB_ADDSTRING:
     539    case LB_INSERTSTRING:
     540        if ( WINPROC_TestLBForStr( hwnd ))
     541          *plparam = (LPARAM)HEAP_strdupAtoW( GetProcessHeap(), 0, (LPCSTR)*plparam );
     542        return (*plparam ? 1 : -1);
     543
     544    case LB_GETTEXT:                /* fixme: fixed sized buffer */
     545        { if ( WINPROC_TestLBForStr( hwnd ))
     546          { LPARAM *ptr = (LPARAM *)HeapAlloc( GetProcessHeap(), 0, 256 * sizeof(WCHAR) + sizeof(LPARAM) );
     547            if (!ptr) return -1;
     548            *ptr++ = *plparam;  /* Store previous lParam */
     549            *plparam = (LPARAM)ptr;
     550          }
     551        }
     552        return 1;
     553
     554/* Combobox */
     555    case CB_ADDSTRING:
     556    case CB_INSERTSTRING:
     557        if ( WINPROC_TestCBForStr( hwnd ))
     558          *plparam = (LPARAM)HEAP_strdupAtoW( GetProcessHeap(), 0, (LPCSTR)*plparam );
     559        return (*plparam ? 1 : -1);
     560
     561    case CB_GETLBTEXT:    /* fixme: fixed sized buffer */
     562        { if ( WINPROC_TestCBForStr( hwnd ))
     563          { LPARAM *ptr = (LPARAM *)HeapAlloc( GetProcessHeap(), 0, 256 * sizeof(WCHAR) + sizeof(LPARAM) );
     564            if (!ptr) return -1;
     565            *ptr++ = *plparam;  /* Store previous lParam */
     566            *plparam = (LPARAM)ptr;
     567          }
     568        }
     569        return 1;
     570
     571/* Multiline edit */
     572    case EM_GETLINE:
     573        { WORD len = (WORD)*plparam;
     574          LPARAM *ptr = (LPARAM *) HEAP_xalloc( GetProcessHeap(), 0, sizeof(LPARAM) + sizeof (WORD) + len*sizeof(WCHAR) );
     575          if (!ptr) return -1;
     576          *ptr++ = *plparam;  /* Store previous lParam */
     577          *((WORD *) ptr) = len;   /* Store the length */
     578          *plparam = (LPARAM)ptr;
     579        }
     580        return 1;
     581
     582    case WM_ASKCBFORMATNAME:
     583    case WM_DEVMODECHANGE:
     584    case WM_PAINTCLIPBOARD:
     585    case WM_SIZECLIPBOARD:
     586    case EM_SETPASSWORDCHAR:
     587        // FIXME_(msg)("message %s (0x%x) needs translation, please report\n", SPY_GetMsgName(msg), msg );
     588        return -1;
     589    default:  /* No translation needed */
     590        return 0;
     591    }
     592}
     593
     594
     595/**********************************************************************
     596 *           WINPROC_UnmapMsg32ATo32W
     597 *
     598 * Unmap a message that was mapped from Ansi to Unicode.
     599 */
     600void WINPROC_UnmapMsg32ATo32W( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
     601{
     602    switch(msg)
     603    {
     604    case WM_GETTEXT:
     605        {
     606            LPARAM *ptr = (LPARAM *)lParam - 1;
     607            lstrcpynWtoA( (LPSTR)*ptr, (LPWSTR)lParam, wParam );
     608            HeapFree( GetProcessHeap(), 0, ptr );
     609        }
     610        break;
     611
     612    case WM_NCCREATE:
     613    case WM_CREATE:
     614        {
     615            CREATESTRUCTW *cs = (CREATESTRUCTW *)lParam;
     616            if (HIWORD(cs->lpszName))
     617                HeapFree( GetProcessHeap(), 0, (LPVOID)cs->lpszName );
     618            if (HIWORD(cs->lpszClass))
     619                HeapFree( GetProcessHeap(), 0, (LPVOID)cs->lpszClass );
     620            HeapFree( GetProcessHeap(), 0, cs );
     621        }
     622        break;
     623
     624    case WM_MDICREATE:
     625        {
     626            MDICREATESTRUCTW *cs = (MDICREATESTRUCTW *)lParam;
     627            if (HIWORD(cs->szTitle))
     628                HeapFree( GetProcessHeap(), 0, (LPVOID)cs->szTitle );
     629            if (HIWORD(cs->szClass))
     630                HeapFree( GetProcessHeap(), 0, (LPVOID)cs->szClass );
     631            HeapFree( GetProcessHeap(), 0, cs );
     632        }
     633        break;
     634
     635    case WM_SETTEXT:
     636    case WM_WININICHANGE:
     637    case CB_DIR:
     638    case CB_FINDSTRING:
     639    case CB_FINDSTRINGEXACT:
     640    case CB_SELECTSTRING:
     641    case LB_DIR:
     642    case LB_ADDFILE:
     643    case LB_FINDSTRING:
     644    case LB_SELECTSTRING:
     645    case EM_REPLACESEL:
     646        HeapFree( GetProcessHeap(), 0, (void *)lParam );
     647        break;
     648
     649/* Listbox */
     650    case LB_ADDSTRING:
     651    case LB_INSERTSTRING:
     652        if ( WINPROC_TestLBForStr( hwnd ))
     653          HeapFree( GetProcessHeap(), 0, (void *)lParam );
     654        break;
     655
     656    case LB_GETTEXT:
     657        { if ( WINPROC_TestLBForStr( hwnd ))
     658          { LPARAM *ptr = (LPARAM *)lParam - 1;
     659            lstrcpyWtoA( (LPSTR)*ptr, (LPWSTR)(lParam) );
     660            HeapFree( GetProcessHeap(), 0, ptr );
     661          }
     662        }
     663        break;
     664
     665/* Combobox */
     666    case CB_ADDSTRING:
     667    case CB_INSERTSTRING:
     668        if ( WINPROC_TestCBForStr( hwnd ))
     669          HeapFree( GetProcessHeap(), 0, (void *)lParam );
     670        break;
     671
     672    case CB_GETLBTEXT:
     673        { if ( WINPROC_TestCBForStr( hwnd ))
     674          { LPARAM *ptr = (LPARAM *)lParam - 1;
     675            lstrcpyWtoA( (LPSTR)*ptr, (LPWSTR)(lParam) );
     676            HeapFree( GetProcessHeap(), 0, ptr );
     677          }
     678        }
     679        break;
     680
     681/* Multiline edit */
     682    case EM_GETLINE:
     683        { LPARAM * ptr = (LPARAM *)lParam - 1;  /* get the old lParam */
     684          WORD len = *(WORD *) lParam;
     685          lstrcpynWtoA( (LPSTR)*ptr , (LPWSTR)lParam, len );
     686          HeapFree( GetProcessHeap(), 0, ptr );
     687        }
     688        break;
     689    }
     690}
     691
     692
     693/**********************************************************************
     694 *           WINPROC_MapMsg32WTo32A
     695 *
     696 * Map a message from Unicode to Ansi.
     697 * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
     698 */
     699INT WINPROC_MapMsg32WTo32A( HWND hwnd, UINT msg, WPARAM wParam, LPARAM *plparam)
     700{   switch(msg)
     701    {
     702    case WM_GETTEXT:
     703        {
     704            LPARAM *ptr = (LPARAM *)HeapAlloc( GetProcessHeap(), 0,
     705                                               wParam + sizeof(LPARAM) );
     706            if (!ptr) return -1;
     707            *ptr++ = *plparam;  /* Store previous lParam */
     708            *plparam = (LPARAM)ptr;
     709        }
     710        return 1;
     711
     712    case WM_SETTEXT:
     713    case WM_WININICHANGE:
     714    case CB_DIR:
     715    case CB_FINDSTRING:
     716    case CB_FINDSTRINGEXACT:
     717    case CB_SELECTSTRING:
     718    case LB_DIR:
     719    case LB_ADDFILE:
     720    case LB_FINDSTRING:
     721    case LB_SELECTSTRING:
     722    case EM_REPLACESEL:
     723        *plparam = (LPARAM)HEAP_strdupWtoA( GetProcessHeap(), 0, (LPCWSTR)*plparam );
     724        return (*plparam ? 1 : -1);
     725
     726    case WM_NCCREATE:
     727    case WM_CREATE:
     728        {
     729            CREATESTRUCTA *cs = (CREATESTRUCTA *)HeapAlloc( GetProcessHeap(), 0,
     730                                                            sizeof(*cs) );
     731            if (!cs) return -1;
     732            *cs = *(CREATESTRUCTA *)*plparam;
     733            if (HIWORD(cs->lpszName))
     734                cs->lpszName  = HEAP_strdupWtoA( GetProcessHeap(), 0,
     735                                                 (LPCWSTR)cs->lpszName );
     736            if (HIWORD(cs->lpszClass))
     737                cs->lpszClass = HEAP_strdupWtoA( GetProcessHeap(), 0,
     738                                                 (LPCWSTR)cs->lpszClass);
     739            *plparam = (LPARAM)cs;
     740        }
     741        return 1;
     742    case WM_MDICREATE:
     743        {
     744            MDICREATESTRUCTA *cs =
     745                (MDICREATESTRUCTA *)HeapAlloc( GetProcessHeap(), 0, sizeof(*cs) );
     746
     747            if (!cs) return -1;
     748            *cs = *(MDICREATESTRUCTA *)*plparam;
     749            if (HIWORD(cs->szTitle))
     750                cs->szTitle = HEAP_strdupWtoA( GetProcessHeap(), 0,
     751                                               (LPCWSTR)cs->szTitle );
     752            if (HIWORD(cs->szClass))
     753                cs->szClass = HEAP_strdupWtoA( GetProcessHeap(), 0,
     754                                               (LPCWSTR)cs->szClass );
     755            *plparam = (LPARAM)cs;
     756        }
     757        return 1;
     758
     759/* Listbox */
     760    case LB_ADDSTRING:
     761    case LB_INSERTSTRING:
     762        if ( WINPROC_TestLBForStr( hwnd ))
     763          *plparam = (LPARAM)HEAP_strdupWtoA( GetProcessHeap(), 0, (LPCWSTR)*plparam );
     764        return (*plparam ? 1 : -1);
     765
     766    case LB_GETTEXT:                    /* fixme: fixed sized buffer */
     767        { if ( WINPROC_TestLBForStr( hwnd ))
     768          { LPARAM *ptr = (LPARAM *)HeapAlloc( GetProcessHeap(), 0, 256 + sizeof(LPARAM) );
     769            if (!ptr) return -1;
     770            *ptr++ = *plparam;  /* Store previous lParam */
     771            *plparam = (LPARAM)ptr;
     772          }
     773        }
     774        return 1;
     775
     776/* Combobox */
     777    case CB_ADDSTRING:
     778    case CB_INSERTSTRING:
     779        if ( WINPROC_TestCBForStr( hwnd ))
     780          *plparam = (LPARAM)HEAP_strdupWtoA( GetProcessHeap(), 0, (LPCWSTR)*plparam );
     781        return (*plparam ? 1 : -1);
     782
     783    case CB_GETLBTEXT:          /* fixme: fixed sized buffer */
     784        { if ( WINPROC_TestCBForStr( hwnd ))
     785          { LPARAM *ptr = (LPARAM *)HeapAlloc( GetProcessHeap(), 0, 256 + sizeof(LPARAM) );
     786            if (!ptr) return -1;
     787            *ptr++ = *plparam;  /* Store previous lParam */
     788            *plparam = (LPARAM)ptr;
     789          }
     790        }
     791        return 1;
     792
     793/* Multiline edit */
     794    case EM_GETLINE:
     795        { WORD len = (WORD)*plparam;
     796          LPARAM *ptr = (LPARAM *) HEAP_xalloc( GetProcessHeap(), 0, sizeof(LPARAM) + sizeof (WORD) + len*sizeof(CHAR) );
     797          if (!ptr) return -1;
     798          *ptr++ = *plparam;  /* Store previous lParam */
     799          *((WORD *) ptr) = len;   /* Store the length */
     800          *plparam = (LPARAM)ptr;
     801        }
     802        return 1;
     803
     804    case WM_ASKCBFORMATNAME:
     805    case WM_DEVMODECHANGE:
     806    case WM_PAINTCLIPBOARD:
     807    case WM_SIZECLIPBOARD:
     808    case EM_SETPASSWORDCHAR:
     809        // FIXME_(msg)("message %s (%04x) needs translation, please report\n",SPY_GetMsgName(msg),msg );
     810        return -1;
     811    default:  /* No translation needed */
     812        return 0;
     813    }
     814}
     815
     816
     817/**********************************************************************
     818 *           WINPROC_UnmapMsg32WTo32A
     819 *
     820 * Unmap a message that was mapped from Unicode to Ansi.
     821 */
     822void WINPROC_UnmapMsg32WTo32A( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
     823{
     824    switch(msg)
     825    {
     826    case WM_GETTEXT:
     827        {
     828            LPARAM *ptr = (LPARAM *)lParam - 1;
     829            lstrcpynAtoW( (LPWSTR)*ptr, (LPSTR)lParam, wParam );
     830            HeapFree( GetProcessHeap(), 0, ptr );
     831        }
     832        break;
     833
     834    case WM_SETTEXT:
     835    case WM_WININICHANGE:
     836    case CB_DIR:
     837    case CB_FINDSTRING:
     838    case CB_FINDSTRINGEXACT:
     839    case CB_SELECTSTRING:
     840    case LB_DIR:
     841    case LB_ADDFILE:
     842    case LB_FINDSTRING:
     843    case LB_SELECTSTRING:
     844    case EM_REPLACESEL:
     845        HeapFree( GetProcessHeap(), 0, (void *)lParam );
     846        break;
     847
     848    case WM_NCCREATE:
     849    case WM_CREATE:
     850        {
     851            CREATESTRUCTA *cs = (CREATESTRUCTA *)lParam;
     852            if (HIWORD(cs->lpszName))
     853                HeapFree( GetProcessHeap(), 0, (LPVOID)cs->lpszName );
     854            if (HIWORD(cs->lpszClass))
     855                HeapFree( GetProcessHeap(), 0, (LPVOID)cs->lpszClass );
     856            HeapFree( GetProcessHeap(), 0, cs );
     857        }
     858        break;
     859
     860    case WM_MDICREATE:
     861        {
     862            MDICREATESTRUCTA *cs = (MDICREATESTRUCTA *)lParam;
     863            if (HIWORD(cs->szTitle))
     864                HeapFree( GetProcessHeap(), 0, (LPVOID)cs->szTitle );
     865            if (HIWORD(cs->szClass))
     866                HeapFree( GetProcessHeap(), 0, (LPVOID)cs->szClass );
     867            HeapFree( GetProcessHeap(), 0, cs );
     868        }
     869        break;
     870
     871/* Listbox */
     872    case LB_ADDSTRING:
     873    case LB_INSERTSTRING:
     874        if ( WINPROC_TestLBForStr( hwnd ))
     875          HeapFree( GetProcessHeap(), 0, (void *)lParam );
     876        break;
     877
     878    case LB_GETTEXT:
     879        { if ( WINPROC_TestLBForStr( hwnd ))
     880          { LPARAM *ptr = (LPARAM *)lParam - 1;
     881            lstrcpyAtoW( (LPWSTR)*ptr, (LPSTR)(lParam) );
     882            HeapFree(GetProcessHeap(), 0, ptr );
     883          }
     884        }
     885        break;
     886
     887/* Combobox */
     888    case CB_ADDSTRING:
     889    case CB_INSERTSTRING:
     890        if ( WINPROC_TestCBForStr( hwnd ))
     891          HeapFree( GetProcessHeap(), 0, (void *)lParam );
     892        break;
     893
     894    case CB_GETLBTEXT:
     895        { if ( WINPROC_TestCBForStr( hwnd ))
     896          { LPARAM *ptr = (LPARAM *)lParam - 1;
     897            lstrcpyAtoW( (LPWSTR)*ptr, (LPSTR)(lParam) );
     898            HeapFree( GetProcessHeap(), 0, ptr );
     899          }
     900        }
     901        break;
     902
     903/* Multiline edit */
     904    case EM_GETLINE:
     905        { LPARAM * ptr = (LPARAM *)lParam - 1;  /* get the old lparam */
     906          WORD len = *(WORD *)ptr;
     907          lstrcpynAtoW( (LPWSTR) *ptr, (LPSTR)lParam, len );
     908          HeapFree( GetProcessHeap(), 0, ptr );
     909        }
     910        break;
     911    }
     912}
     913
     914/**********************************************************************
     915 *           WINPROC_CallProc32ATo32W
     916 *
     917 * Call a window procedure, translating args from Ansi to Unicode.
     918 */
     919static LRESULT WINPROC_CallProc32ATo32W( WNDPROC func, HWND hwnd,
     920                                         UINT msg, WPARAM wParam,
     921                                         LPARAM lParam )
     922{
     923    LRESULT result;
     924
     925    if (WINPROC_MapMsg32ATo32W( hwnd, msg, wParam, &lParam ) == -1) return 0;
     926    result = func( hwnd, msg, wParam, lParam );
     927    WINPROC_UnmapMsg32ATo32W( hwnd, msg, wParam, lParam );
     928    return result;
     929}
     930
     931/**********************************************************************
     932 *           WINPROC_CallProc32WTo32A
     933 *
     934 * Call a window procedure, translating args from Unicode to Ansi.
     935 */
     936static LRESULT WINPROC_CallProc32WTo32A( WNDPROC func, HWND hwnd,
     937                                         UINT msg, WPARAM wParam,
     938                                         LPARAM lParam )
     939{
     940    LRESULT result;
     941
     942    if (WINPROC_MapMsg32WTo32A( hwnd, msg, wParam, &lParam ) == -1) return 0;
     943
     944    result = func( hwnd, msg, wParam, lParam );
     945    WINPROC_UnmapMsg32WTo32A( hwnd, msg, wParam, lParam );
     946    return result;
     947}
     948/**********************************************************************
     949 *           CallWindowProc32A   
     950 */
     951LRESULT WIN32API CallWindowProcA(
     952    WNDPROC func, /* window procedure */
     953    HWND hwnd, /* target window */
     954    UINT msg,  /* message */
     955    WPARAM wParam, /* message dependent parameter */
     956    LPARAM lParam    /* message dependent parameter */
     957)
     958{
     959
     960    Win32BaseWindow *window = Win32BaseWindow::GetWindowFromHandle(hwnd);
     961    if(!window) {
     962        dprintf(("CallWindowProcA, window %x not found", hwnd));
     963        // return func( hwnd, msg, wParam, lParam );
     964        return 0;
     965    }
     966   
     967    dprintf(("CallWindowProcA(wndproc=%p,hwnd=%08x,msg=%08x,wp=%08x,lp=%08lx)",
     968                   func, hwnd, msg, wParam, lParam ));
     969
     970#if testing
     971    return func( hwnd, msg, wParam, lParam );
     972#endif
     973
     974    if(window->IsUnicode())
     975        return WINPROC_CallProc32ATo32W( func, hwnd, msg, wParam, lParam);
     976    else
     977        return func( hwnd, msg, wParam, lParam );
     978}
     979
     980
     981/**********************************************************************
     982 *           CallWindowProc32W    (USER32.19)
     983 */
     984LRESULT WIN32API CallWindowProcW( WNDPROC func, HWND hwnd, UINT msg,
     985                                  WPARAM wParam, LPARAM lParam )
     986{
     987    Win32BaseWindow *window = Win32BaseWindow::GetWindowFromHandle(hwnd);
     988    if(!window) {
     989        dprintf(("CallWindowProcW, window %x not found", hwnd));
     990        // return func( hwnd, msg, wParam, lParam );
     991        return 0;
     992    }
     993   
     994    dprintf(("CallWindowProcW(wndproc=%p,hwnd=%08x,msg=%08x,wp=%08x,lp=%08lx)",
     995             func, hwnd, msg, wParam, lParam ));
     996
     997#if testing
     998    return func( hwnd, msg, wParam, lParam );
     999#endif
     1000
     1001    if(window->IsUnicode())
     1002        return func( hwnd, msg, wParam, lParam );
     1003    else
     1004        return WINPROC_CallProc32WTo32A( func, hwnd, msg, wParam, lParam);
     1005}
Note: See TracChangeset for help on using the changeset viewer.