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

EB's unicode changes + seticon + mdi fixes

File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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.