Changeset 10607 for trunk/src


Ignore:
Timestamp:
May 24, 2004, 11:02:01 AM (21 years ago)
Author:
sandervl
Message:

KOM: Updates

Location:
trunk/src/user32
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/user32/Makefile

    r10578 r10607  
    1 # $Id: Makefile,v 1.110 2004-04-13 14:16:41 sandervl Exp $
     1# $Id: Makefile,v 1.111 2004-05-24 09:01:57 sandervl Exp $
    22
    33#
    … …  
    130130$(ODIN32_LIB)/libuls.lib \
    131131$(ODIN32_LIB)/$(ODINCRT).lib \
     132$(ODIN32_LIB)/imm32.lib \
    132133OS2386.LIB \
    133134$(RTLLIB_O)

  • trunk/src/user32/edit.c

    r10479 r10607  
    3131#include "ctrlconf.h"
    3232#include <heapstring.h>
     33#include <imm.h>
    3334#endif
    3435
    … …  
    128129    HLOCAL hloc32A;     /* alias for ANSI control receiving EM_GETHANDLE
    129130                   or EM_SETHANDLE */
     131#ifdef __WIN32OS2__
     132    LPWSTR  compStr;
     133    INT     compStrLen;
     134    BOOL    moveCaret;
     135    DWORD   sentenceMode;
     136#endif
    130137} EDITSTATE;
    131138
    … …  
    11111118        else
    11121119        {
    1113             // always DBCS char
    11141120            CHAR charA[ 2 ];
    1115 
    1116             charA[ 0 ] = ( CHAR )( wParam >> 8 );
    1117             charA[ 1 ] = ( CHAR )wParam;
    1118 
    1119             MultiByteToWideChar( CP_ACP, 0, ( LPSTR )charA, 2, ( LPWSTR )&charW, 1);
     1121            INT  lenA = 1;
     1122
     1123            if( IsDBCSLeadByte(( CHAR )( wParam >> 8 )))
     1124            {
     1125                charA[ 0 ] = ( CHAR )( wParam >> 8 );
     1126                charA[ 1 ] = ( CHAR )wParam;
     1127                lenA = 2;
     1128            }
     1129            else
     1130                charA[ 0 ] = ( CHAR )wParam;
     1131
     1132            MultiByteToWideChar( CP_ACP, 0, ( LPSTR )charA, lenA, ( LPWSTR )&charW, 1);
    11201133        }
    11211134
    … …  
    11231136        break;
    11241137    }
     1138
     1139    case WM_IME_COMPOSITION:
     1140    {
     1141        HIMC    himc;
     1142        LONG    bufSize;
     1143        INT     i;
     1144        BOOL    passToDefWnd = FALSE;
     1145#ifdef DEBUG
     1146        LPSTR   strA;
     1147        INT     lenA;
     1148#endif
     1149
     1150        DPRINTF_EDIT_MSG32("WM_IME_COMPOSITION");
     1151
     1152        himc = ImmGetContext( hwnd );
     1153
     1154        if( es->sentenceMode )
     1155            passToDefWnd = TRUE;
     1156        else if( lParam & GCS_RESULTSTR )
     1157        {
     1158            LPWSTR  resultStr = NULL;
     1159            INT     resultStrLen = 0;
     1160
     1161            dprintf(("WM_IME_COMPOSITION : GCS_RESULTSTR"));
     1162
     1163            bufSize = ImmGetCompositionStringW( himc, GCS_RESULTSTR, NULL, 0 );
     1164            if( bufSize > 0 )
     1165            {
     1166                INT i;
     1167
     1168                resultStrLen = bufSize / sizeof( WCHAR );
     1169                resultStr = malloc( bufSize + sizeof( WCHAR ));
     1170                resultStr[ resultStrLen ] = 0;
     1171
     1172                ImmGetCompositionStringW( himc, GCS_RESULTSTR, resultStr, bufSize );
     1173
     1174#ifdef DEBUG
     1175                lenA = WideCharToMultiByte( CP_ACP, 0, resultStr, resultStrLen, 0, 0, 0, 0 );
     1176                strA = malloc( lenA + 1 );
     1177                WideCharToMultiByte( CP_ACP, 0, resultStr, resultStrLen, strA, lenA, 0, 0 );
     1178                strA[ lenA ] = 0;
     1179                dprintf(("Result String : '%s'", strA ));
     1180                free( strA );
     1181                dprintf(("Composition Len %d", es->compStrLen ));
     1182#endif
     1183                DestroyCaret();
     1184                if( es->compStrLen > 0 )
     1185                {
     1186                    EDIT_EM_SetSel(hwnd, es, (UINT)-1, 0, FALSE);
     1187                    for( i = 0; i < es->compStrLen; i++ )
     1188                        EDIT_MoveForward(hwnd, es, TRUE);
     1189                    EDIT_WM_Clear(hwnd, es);
     1190                }
     1191
     1192                EDIT_EM_ReplaceSel(hwnd, es, TRUE, resultStr, TRUE);
     1193
     1194                CreateCaret(hwnd, 0, 2, es->line_height);
     1195                EDIT_SetCaretPos(hwnd, es, es->selection_end, es->flags & EF_AFTER_WRAP);
     1196                ShowCaret(hwnd);
     1197
     1198                free( resultStr );
     1199
     1200            }
     1201
     1202            if( es->compStr )
     1203                free( es->compStr );
     1204
     1205            es->compStr = NULL;
     1206            es->compStrLen = 0;
     1207        }
     1208        else if( lParam & GCS_COMPSTR )
     1209        {
     1210            INT prevLen = es->compStrLen;
     1211
     1212            dprintf(("WM_IME_COMPOSITION : GCS_COMPSTR"));
     1213
     1214            if( es->compStr )
     1215                free( es->compStr );
     1216
     1217            es->compStr = NULL;
     1218            es->compStrLen = 0;
     1219
     1220            bufSize = ImmGetCompositionStringW( himc, GCS_COMPSTR, NULL, 0 );
     1221            if( bufSize > 0 )
     1222            {
     1223                HDC     hdc;
     1224                SIZE    size;
     1225                BOOL    oldMoveCaret;
     1226
     1227                es->compStrLen = bufSize / sizeof( WCHAR );
     1228                es->compStr = malloc( bufSize + sizeof( WCHAR ));
     1229                es->compStr[ es->compStrLen ] = 0;
     1230
     1231                ImmGetCompositionStringW( himc, GCS_COMPSTR, es->compStr, bufSize );
     1232
     1233#ifdef DEBUG
     1234                lenA = WideCharToMultiByte( CP_ACP, 0, es->compStr, es->compStrLen, 0, 0, 0, 0 );
     1235                strA = malloc( lenA + 1 );
     1236                WideCharToMultiByte( CP_ACP, 0, es->compStr, es->compStrLen, strA, lenA, 0, 0  );
     1237                strA[ lenA ] = 0;
     1238                dprintf(("Composition String : '%s'", strA ));
     1239                free( strA );
     1240#endif
     1241                hdc = GetDC( hwnd );
     1242                GetTextExtentPoint32W( hdc, es->compStr, es->compStrLen, &size);
     1243                ReleaseDC( hwnd, hdc );
     1244
     1245                oldMoveCaret = es->moveCaret;
     1246
     1247                es->moveCaret = FALSE; // to prevent cursor from flashing too many
     1248
     1249                if( prevLen > 0 )
     1250                {
     1251                    EDIT_EM_SetSel(hwnd, es, (UINT)-1, 0, FALSE);
     1252                    for( i = 0; i < prevLen; i++ )
     1253                        EDIT_MoveForward(hwnd, es, TRUE);
     1254                    EDIT_WM_Clear(hwnd, es);
     1255                }
     1256
     1257                EDIT_EM_ReplaceSel(hwnd, es, TRUE, es->compStr, TRUE);
     1258
     1259                for( i = 0; i < es->compStrLen; i++ )
     1260                    EDIT_MoveBackward(hwnd, es, FALSE);
     1261
     1262                es->moveCaret = oldMoveCaret;
     1263
     1264                CreateCaret(hwnd, 0, size.cx, es->line_height);
     1265                EDIT_SetCaretPos(hwnd, es, es->selection_end, es->flags & EF_AFTER_WRAP);
     1266                ShowCaret(hwnd);
     1267            }
     1268        }
     1269        else
     1270            passToDefWnd = TRUE;
     1271
     1272        ImmReleaseContext( hwnd, himc );
     1273
     1274        if( passToDefWnd )
     1275        {
     1276            if( unicode )
     1277                result = DefWindowProcW( hwnd, msg, wParam, lParam );
     1278            else
     1279                result = DefWindowProcA( hwnd, msg, wParam, lParam );
     1280        }
     1281        break;
     1282    }
     1283
     1284    case WM_IME_COMPOSITIONFULL:
     1285        DPRINTF_EDIT_MSG32("WM_IME_COMPOSITIONFULL");
     1286        if( unicode )
     1287            result = DefWindowProcW( hwnd, msg, wParam, lParam );
     1288        else
     1289            result = DefWindowProcA( hwnd, msg, wParam, lParam );
     1290        break;
     1291
     1292    case WM_IME_CONTROL:
     1293        DPRINTF_EDIT_MSG32("WM_IME_CONTROL");
     1294        if( unicode )
     1295            result = DefWindowProcW( hwnd, msg, wParam, lParam );
     1296        else
     1297            result = DefWindowProcA( hwnd, msg, wParam, lParam );
     1298        break;
     1299
     1300    case WM_IME_ENDCOMPOSITION:
     1301        DPRINTF_EDIT_MSG32("WM_IME_ENDCOMPOSITION");
     1302
     1303        if( es->compStr )
     1304        {
     1305            INT i;
     1306
     1307            DestroyCaret();
     1308
     1309            EDIT_EM_SetSel(hwnd, es, (UINT)-1, 0, FALSE);
     1310            for( i = 0; i < es->compStrLen; i++ )
     1311                EDIT_MoveForward(hwnd, es, TRUE);
     1312            EDIT_WM_Clear(hwnd, es);
     1313
     1314            CreateCaret(hwnd, 0, 2, es->line_height);
     1315            EDIT_SetCaretPos(hwnd, es, es->selection_end, es->flags & EF_AFTER_WRAP);
     1316            ShowCaret(hwnd);
     1317
     1318            free( es->compStr );
     1319        }
     1320
     1321        es->compStr = NULL;
     1322        es->compStrLen = 0;
     1323
     1324        if( unicode )
     1325            result = DefWindowProcW( hwnd, msg, wParam, lParam );
     1326        else
     1327            result = DefWindowProcA( hwnd, msg, wParam, lParam );
     1328        break;
     1329
     1330    case WM_IME_NOTIFY:
     1331        DPRINTF_EDIT_MSG32("WM_IME_NOTIFY");
     1332
     1333        if( wParam == IMN_SETSENTENCEMODE )
     1334        {
     1335            HIMC  himc;
     1336            DWORD conversionMode;
     1337
     1338            himc = ImmGetContext( hwnd );
     1339
     1340            ImmGetConversionStatus( himc, &conversionMode, &es->sentenceMode );
     1341
     1342            ImmReleaseContext( hwnd, himc );
     1343        }
     1344
     1345        if( unicode )
     1346            result = DefWindowProcW( hwnd, msg, wParam, lParam );
     1347        else
     1348            result = DefWindowProcA( hwnd, msg, wParam, lParam );
     1349        break;
     1350
     1351    case WM_IME_REQUEST:
     1352        DPRINTF_EDIT_MSG32("WM_IME_REQUEST");
     1353        if( unicode )
     1354            result = DefWindowProcW( hwnd, msg, wParam, lParam );
     1355        else
     1356            result = DefWindowProcA( hwnd, msg, wParam, lParam );
     1357        break;
     1358
     1359    case WM_IME_SELECT:
     1360        DPRINTF_EDIT_MSG32("WM_IME_SELECT");
     1361        if( unicode )
     1362            result = DefWindowProcW( hwnd, msg, wParam, lParam );
     1363        else
     1364            result = DefWindowProcA( hwnd, msg, wParam, lParam );
     1365        break;
     1366
     1367    case WM_IME_SETCONTEXT:
     1368        DPRINTF_EDIT_MSG32("WM_IME_SETCONTEXT");
     1369
     1370        dprintf(("ImmGetProperty %08lx", ImmGetProperty( 0, IGP_CONVERSION )));
     1371
     1372        if( unicode )
     1373            result = DefWindowProcW( hwnd, msg, wParam, lParam );
     1374        else
     1375            result = DefWindowProcA( hwnd, msg, wParam, lParam );
     1376        break;
     1377
     1378    case WM_IME_STARTCOMPOSITION:
     1379        DPRINTF_EDIT_MSG32("WM_IME_STARTCOMPOSITION");
     1380
     1381        es->compStr = NULL;
     1382        es->compStrLen = 0;
     1383
     1384        if( unicode )
     1385            result = DefWindowProcW( hwnd, msg, wParam, lParam );
     1386        else
     1387            result = DefWindowProcA( hwnd, msg, wParam, lParam );
     1388        break;
     1389
     1390    case EM_GETIMESTATUS:
     1391        DPRINTF_EDIT_MSG32("EM_GETIMESTATUS");
     1392        if( unicode )
     1393            result = DefWindowProcW( hwnd, msg, wParam, lParam );
     1394        else
     1395            result = DefWindowProcA( hwnd, msg, wParam, lParam );
     1396        break;
     1397
     1398    case EM_SETIMESTATUS:
     1399        DPRINTF_EDIT_MSG32("EM_SETIMESTATUS");
     1400        if( unicode )
     1401            result = DefWindowProcW( hwnd, msg, wParam, lParam );
     1402        else
     1403            result = DefWindowProcA( hwnd, msg, wParam, lParam );
     1404        break;
    11251405#endif
    11261406
    … …  
    24402720{
    24412721    LRESULT res = EDIT_EM_PosFromChar(hwnd, es, pos, after_wrap);
     2722
     2723#ifdef __WIN32OS2__
     2724    if( es->moveCaret )
     2725    {
     2726        HIMC            himc;
     2727        CANDIDATEFORM   candForm;
     2728
     2729        himc = ImmGetContext( hwnd );
     2730
     2731#endif
    24422732    SetCaretPos(SLOWORD(res), SHIWORD(res));
     2733
     2734#ifdef __WIN32OS2__
     2735        if( es->sentenceMode )
     2736        {
     2737            COMPOSITIONFORM cf;
     2738
     2739            cf.dwStyle = CFS_POINT;
     2740            cf.ptCurrentPos.x = SLOWORD( res );
     2741            cf.ptCurrentPos.y = SHIWORD( res );
     2742
     2743            ImmSetCompositionWindow( himc, &cf );
     2744        }
     2745
     2746        candForm.dwIndex = 0;
     2747        candForm.dwStyle = CFS_CANDIDATEPOS;
     2748        candForm.ptCurrentPos.x = SLOWORD( res );
     2749        candForm.ptCurrentPos.y = SHIWORD( res ) + es->line_height;
     2750
     2751        ImmSetCandidateWindow( himc, &candForm );
     2752
     2753        ImmReleaseContext( hwnd, himc );
     2754    }
     2755#endif
    24432756}
    24442757
    … …  
    47735086    }
    47745087
     5088#ifdef __WIN32OS2__
     5089    es->compStr = NULL;
     5090    es->compStrLen = 0;
     5091    es->moveCaret = TRUE;
     5092    {
     5093        HIMC  himc;
     5094        DWORD conversionMode;
     5095
     5096        himc = ImmGetContext( hwnd );
     5097
     5098        ImmGetConversionStatus( himc, &conversionMode, &es->sentenceMode );
     5099
     5100        ImmReleaseContext( hwnd, himc );
     5101    }
     5102#endif
     5103
    47755104    return TRUE;
    47765105}
    … …  
    49095238    es->line_height = tm.tmHeight;
    49105239    es->char_width = tm.tmAveCharWidth;
     5240#ifdef __WIN32OS2__
     5241    // todo : set font of IME window
     5242#endif
    49115243    if (font)
    49125244        SelectObject(dc, old_font);

  • trunk/src/user32/listbox.c

    r10352 r10607  
    30263026        else
    30273027        {
    3028             // always DBCS char
    30293028            CHAR charA[ 2 ];
    3030 
    3031             charA[ 0 ] = ( CHAR )( wParam >> 8 );
    3032             charA[ 1 ] = ( CHAR )wParam;
    3033 
    3034             MultiByteToWideChar( CP_ACP, 0, ( LPSTR )charA, 2, ( LPWSTR )&charW, 1);
     3029            INT  lenA = 1;
     3030
     3031            if( IsDBCSLeadByte(( CHAR )( wParam >> 8 )))
     3032            {
     3033                charA[ 0 ] = ( CHAR )( wParam >> 8 );
     3034                charA[ 1 ] = ( CHAR )wParam;
     3035                lenA = 2;
     3036            }
     3037            else
     3038                charA[ 0 ] = ( CHAR )wParam;
     3039
     3040            MultiByteToWideChar( CP_ACP, 0, ( LPSTR )charA, lenA, ( LPWSTR )&charW, 1);
    30353041        }
    30363042        return LISTBOX_HandleChar( hwnd, descr, charW );

  • trunk/src/user32/oslibmsgtranslate.cpp

    r10595 r10607  
    1 /* $Id: oslibmsgtranslate.cpp,v 1.124 2004-05-03 12:09:01 sandervl Exp $ */
     1/* $Id: oslibmsgtranslate.cpp,v 1.125 2004-05-24 09:01:59 sandervl Exp $ */
    22/*
    33 * Window message translation functions for OS/2
    … …  
    1515 *
    1616 */
     17#define  INCL_NLS
     18#define  INCL_GPI
    1719#define  INCL_WIN
    1820#define  INCL_PM
    … …  
    4244#include "user32api.h"
    4345
     46#include <os2im.h>
     47#include <im32.h>
    4448
    4549#define DBG_LOCALLOG    DBG_oslibmsgtranslate
    … …  
    4852static BOOL fGenerateDoubleClick = FALSE;
    4953static MSG  doubleClickMsg = {0};
     54
     55extern UINT WINAPI GetACP(void); // from winnls.h
    5056
    5157//For wheel mouse translation
    … …  
    753759        if( scanCode != 0 )
    754760        {
    755             KeyTranslatePMScanToWinVKey(usPMScanCode,
    756                                         FALSE,
    757                                         &bWinVKey,
    758                                         &wWinScan,
    759                                         &fWinExtended);
     761            switch( SHORT2FROMMP( os2Msg->mp2 ))
     762            {
     763                // for Korean
     764                case VK_DBE_HANJA :
     765                    bWinVKey = 0x19;
     766                    break;
     767
     768                case VK_DBE_HANGEUL :
     769                    bWinVKey = 0x15;
     770                    break;
     771
     772                case VK_DBE_JAMO :
     773                    bWinVKey = 0;
     774                    break;
     775
     776                // for Japan
     777                case VK_DBE_KATAKANA :
     778                    bWinVKey = 0;
     779                    break;
     780
     781                case VK_DBE_HIRAGANA :
     782                    bWinVKey = 0;
     783                    break;
     784
     785                case VK_DBE_SBCSCHAR :
     786                    bWinVKey = 0;
     787                    break;
     788
     789                case VK_DBE_DBCSCHAR :
     790                    bWinVKey = 0;
     791                    break;
     792
     793                case VK_DBE_SBCSDBCSCHAR :
     794                    bWinVKey = 0;
     795                    break;
     796
     797                case VK_DBE_ROMAN :
     798                    bWinVKey = 0;
     799                    break;
     800
     801                // for PRC-Chinese
     802                case VK_DBE_HANZI :
     803                    bWinVKey = 0;
     804                    break;
     805
     806                // for Taiwan
     807                case VK_DBE_TSANGJYE :
     808                    bWinVKey = 0;
     809                    break;
     810
     811                case VK_DBE_PHONETIC :
     812                    bWinVKey = 0;
     813                    break;
     814
     815                case VK_DBE_CONV :
     816                    bWinVKey = 0;
     817                    break;
     818
     819                case VK_DBE_NOCONV :
     820                    bWinVKey = 0;
     821                    break;
     822
     823                case VK_DBE_ALPHANUMERIC :
     824                    switch( GetACP())
     825                    {
     826                        case 949 :  // Korea
     827                        case 1361 :
     828                            bWinVKey = 0x15;
     829                            break;
     830
     831                        case 932 :  // Japan
     832                        case 942 :
     833                        case 943 :
     834
     835                        case 936 :  // PRC
     836                        case 1381 :
     837
     838                        case 950 :  // Taiwan
     839                        default :
     840                            bWinVKey = 0;
     841                    }
     842                    break;
     843
     844                default :
     845                    KeyTranslatePMScanToWinVKey(usPMScanCode,
     846                                                FALSE,
     847                                                &bWinVKey,
     848                                                &wWinScan,
     849                                                &fWinExtended);
     850            }
     851
    760852            winMsg->wParam = bWinVKey;
    761853        }
    … …  
    10121104    case WM_RENDERFMT:
    10131105        winMsg->message = WINWM_RENDERFORMAT;
    1014         extern UINT WIN32API clipboardPMToOdinFormat(ULONG ulPMFormat);
    1015         winMsg->wParam  = (UINT)clipboardPMToOdinFormat((ULONG)os2Msg->mp1);
    1016         if (!winMsg->wParam)
    1017         {
    1018             dprintf(("WM_RENDERFMT: failed to convert clipboard format (%d)!!!\n", os2Msg->mp1));
    1019             DebugInt3();
    1020         }
     1106        winMsg->wParam  = (UINT) os2Msg->mp1;
    10211107        break;
    10221108
    … …  
    10791165        break;
    10801166
     1167    case WM_IMENOTIFY:
     1168        dprintf(("WM_IMENOTIFY"));
     1169
     1170        winMsg->wParam = 0;
     1171        winMsg->lParam = 0;
     1172
     1173        switch(( ULONG )os2Msg->mp1 )
     1174        {
     1175            case IMN_STARTCONVERSION :
     1176                winMsg->message = WM_IME_STARTCOMPOSITION_W;
     1177                break;
     1178
     1179            case IMN_ENDCONVERSION :
     1180                winMsg->message = WM_IME_ENDCOMPOSITION_W;
     1181                break;
     1182
     1183            case IMN_CONVERSIONFULL :
     1184                winMsg->message = WM_IME_COMPOSITIONFULL_W;
     1185                break;
     1186
     1187            case IMN_IMECHANGED :
     1188                winMsg->message = WM_IME_SELECT_W;
     1189                // todo
     1190                // fall through
     1191
     1192            default :
     1193                goto dummymessage;
     1194
     1195        }
     1196        break;
     1197
     1198    case WM_IMEREQUEST:
     1199        winMsg->wParam = 0;
     1200        winMsg->lParam = 0;
     1201
     1202        switch(( ULONG )os2Msg->mp1 )
     1203        {
     1204            case IMR_INSTANCEACTIVATE :
     1205            {
     1206                USHORT usIMR_IA = LOUSHORT( os2Msg->mp2 );
     1207
     1208                winMsg->message = WM_IME_SETCONTEXT_W;
     1209                winMsg->wParam = HIUSHORT( os2Msg->mp2 );
     1210
     1211                if( usIMR_IA & IMR_IA_STATUS )
     1212                    winMsg->lParam |= ISC_SHOWUIGUIDELINE_W;
     1213
     1214                if( usIMR_IA & IMR_IA_CONVERSION )
     1215                    winMsg->lParam |= ISC_SHOWUICOMPOSITIONWINDOW_W;
     1216
     1217                if( usIMR_IA & IMR_IA_CANDIDATE )
     1218                    winMsg->lParam |= ISC_SHOWUIALLCANDIDATEWINDOW_W;
     1219
     1220                if( usIMR_IA & IMR_IA_INFOMSG )
     1221                    winMsg->lParam |= 0; // todo
     1222
     1223                if( usIMR_IA & IMR_IA_REGWORD )
     1224                    winMsg->lParam |= 0; // todo
     1225                break;
     1226            }
     1227
     1228            case IMR_STATUS :
     1229                winMsg->message = WM_IME_NOTIFY_W;
     1230
     1231                switch(( ULONG )os2Msg->mp2 )
     1232                {
     1233                    case IMR_STATUS_SHOW :
     1234                        winMsg->wParam = IMN_OPENSTATUSWINDOW_W;
     1235                        break;
     1236
     1237                    case IMR_STATUS_HIDE :
     1238                        winMsg->wParam = IMN_CLOSESTATUSWINDOW_W;
     1239                        break;
     1240
     1241                    case IMR_STATUS_INPUTMODE : // IMN_SETOPENSTATUS followed by IMN_SETCONVERSIONMODE
     1242                        winMsg->wParam = IMN_SETOPENSTATUS_W;
     1243                        break;
     1244
     1245                    case IMR_STATUS_CONVERSIONMODE :
     1246                        winMsg->wParam = IMN_SETSENTENCEMODE_W;
     1247                        break;
     1248
     1249                    case IMR_STATUS_STATUSPOS :
     1250                        winMsg->wParam = IMN_SETSTATUSWINDOWPOS_W;
     1251                        break;
     1252
     1253                    case IMR_STATUS_STRING :
     1254                    case IMR_STATUS_STRINGATTR :
     1255                    case IMR_STATUS_CURSORPOS :
     1256                    case IMR_STATUS_CURSORATTR :
     1257
     1258                    default :
     1259                        // todo
     1260                        goto dummymessage;
     1261
     1262                }
     1263                break;
     1264
     1265            case IMR_CONVRESULT :
     1266            {
     1267                ULONG ulIMR = ( ULONG )os2Msg->mp2;
     1268
     1269                winMsg->message = WM_IME_COMPOSITION_W;
     1270                winMsg->wParam = 0; // todo : current DBCS char
     1271
     1272                if( ulIMR & IMR_CONV_CONVERSIONSTRING )
     1273                    winMsg->lParam |= GCS_COMPSTR_W;
     1274
     1275                if( ulIMR & IMR_CONV_CONVERSIONATTR )
     1276                    winMsg->lParam |= GCS_COMPATTR_W;
     1277
     1278                if( ulIMR & IMR_CONV_CONVERSIONCLAUSE )
     1279                    winMsg->lParam |= GCS_COMPCLAUSE_W;
     1280
     1281                if( ulIMR & IMR_CONV_READINGSTRING )
     1282                    winMsg->lParam |= GCS_COMPREADSTR_W;
     1283
     1284                if( ulIMR & IMR_CONV_READINGATTR )
     1285                    winMsg->lParam |= GCS_COMPREADATTR_W;
     1286
     1287                if( ulIMR & IMR_CONV_READINGCLAUSE )
     1288                    winMsg->lParam |= GCS_COMPREADCLAUSE_W;
     1289
     1290                if( ulIMR & IMR_CONV_CURSORPOS )
     1291                    winMsg->lParam |= GCS_CURSORPOS_W;
     1292
     1293                if( ulIMR & IMR_CONV_CURSORATTR )
     1294                    winMsg->lParam |= 0; // todo
     1295
     1296                if( ulIMR & IMR_CONV_CHANGESTART )
     1297                    winMsg->lParam |= GCS_DELTASTART_W;
     1298
     1299                if( ulIMR & IMR_CONV_INSERTCHAR )
     1300                    winMsg->lParam |= CS_INSERTCHAR_W;
     1301
     1302                if( ulIMR & IMR_CONV_NOMOVECARET )
     1303                    winMsg->lParam |= CS_NOMOVECARET_W;
     1304
     1305                if( ulIMR & IMR_CONV_CONVERSIONFONT )
     1306                    winMsg->lParam |= 0; // todo
     1307
     1308                if( ulIMR & IMR_CONV_CONVERSIONPOS )
     1309                    winMsg->lParam |= 0; // todo
     1310
     1311                if( ulIMR & IMR_RESULT_RESULTSTRING )
     1312                    winMsg->lParam = GCS_RESULTSTR_W; // clear all composition info
     1313
     1314                if( ulIMR & IMR_RESULT_RESULTATTR )
     1315                    winMsg->lParam |= 0; // todo
     1316
     1317                if( ulIMR & IMR_RESULT_RESULTCLAUSE )
     1318                    winMsg->lParam |= GCS_RESULTCLAUSE_W;
     1319
     1320                if( ulIMR & IMR_RESULT_READINGSTRING )
     1321                    winMsg->lParam |= GCS_RESULTREADSTR_W;
     1322
     1323                if( ulIMR & IMR_RESULT_READINGATTR )
     1324                    winMsg->lParam |= 0; // todo
     1325
     1326                if( ulIMR & IMR_RESULT_READINGCLAUSE )
     1327                    winMsg->lParam |= GCS_RESULTREADCLAUSE_W;
     1328
     1329                if( ulIMR && ( winMsg->lParam == 0 ))
     1330                    goto dummymessage;
     1331                break;
     1332            }
     1333
     1334            case IMR_CANDIDATE :
     1335                winMsg->message = WM_IME_NOTIFY_W;
     1336                switch(( ULONG )os2Msg->mp2 )
     1337                {
     1338                    case IMR_CANDIDATE_SHOW :
     1339                    case IMR_CANDIDATE_HIDE :
     1340                    case IMR_CANDIDATE_SELECT :
     1341                    case IMR_CANDIDATE_CHANGE :
     1342                    case IMR_CANDIDATE_CANDIDATEPOS :
     1343                    default :
     1344                        // todo
     1345                        goto dummymessage;
     1346                }
     1347                break;
     1348
     1349            case IMR_INFOMSG :
     1350                winMsg->message = WM_IME_NOTIFY_W;
     1351                winMsg->wParam = IMN_GUIDELINE_W;
     1352                break;
     1353
     1354            case IMR_REGWORD :
     1355                goto dummymessage;
     1356
     1357            case IMR_IMECHANGE :
     1358                winMsg->message = WM_IME_SELECT_W;
     1359                // todo
     1360                goto dummymessage;
     1361
     1362            case IMR_CONFIG :
     1363                // todo
     1364                goto dummymessage;
     1365
     1366            case IMR_DICTIONARY :
     1367                // todo
     1368                goto dummymessage;
     1369
     1370            case IMR_OTHERINFO :
     1371                // todo
     1372                goto dummymessage;
     1373        }
     1374        break;
     1375
     1376#if 0 // application cannot receive this message
     1377    case WM_IMECONTROL:
     1378#endif
    10811379    case WM_INITMENU:
    10821380    case WM_MENUSELECT:

  • trunk/src/user32/pmwindow.cpp

    r10515 r10607  
    1 /* $Id: pmwindow.cpp,v 1.229 2004-03-12 18:19:50 sandervl Exp $ */
     1/* $Id: pmwindow.cpp,v 1.230 2004-05-24 09:01:59 sandervl Exp $ */
    22/*
    33 * Win32 Window Managment Code for OS/2
    … …  
    6161#include "user32api.h"
    6262#include <kbdhook.h>
     63#include <heapstring.h>
     64
     65#include <os2im.h>
     66#include <im32.h>
    6367
    6468#define DBG_LOCALLOG    DBG_pmwindow
    … …  
    140144#endif
    141145
     146extern "C" ULONG OSLibImSetMsgQueueProperty( ULONG, ULONG );
     147
    142148//******************************************************************************
    143149// Initialize PM; create hab, message queue and register special Win32 window classes
    … …  
    194200    BOOL rc = WinSetCp(hmq, GetDisplayCodepage());
    195201    dprintf(("InitPM: WinSetCP was %sOK", rc ? "" : "not "));
     202
     203    /* IM instace is created per message queue, that is, thread */
     204    if( IsDBCSEnv())
     205        OSLibImSetMsgQueueProperty( hmq, MQP_INSTANCE_PERMQ );
    196206
    197207    //CD polling window class
    … …  
    10061016        break;
    10071017
     1018    case WM_IMEREQUEST:
     1019    case WM_IMECONTROL:
     1020    case WM_IMENOTIFY:
     1021        if( pWinMsg->message )
     1022        {
     1023            win32wnd->DispatchMsgA( pWinMsg );
     1024
     1025            if(( pWinMsg->message = WM_IME_NOTIFY_W ) &&
     1026               ( pWinMsg->wParam == IMN_SETOPENSTATUS_W ))
     1027            {
     1028                MSG m;
     1029
     1030                m.message = WM_IME_NOTIFY_W;
     1031                m.wParam = IMN_SETCONVERSIONMODE_W;
     1032                m.lParam = 0;
     1033
     1034                win32wnd->DispatchMsgA( &m );
     1035            }
     1036        }
     1037        else
     1038            goto RunDefWndProc;
     1039        break;
     1040
    10081041    case DM_DRAGOVER:
    10091042    {
    … …  
    10161049
    10171050        if(fDragDropDisabled) {
    1018                 rc = (MRFROM2SHORT (DOR_NEVERDROP, 0));
     1051            rc = (MRFROM2SHORT (DOR_NEVERDROP, 0));
    10191052            break;
    10201053        }
    … …  
    10221055        //does this window accept dropped files?
    10231056        if(!DragDropAccept(win32wnd->getWindowHandle())) {
    1024                 rc = (MRFROM2SHORT (DOR_NEVERDROP, 0));
     1057            rc = (MRFROM2SHORT (DOR_NEVERDROP, 0));
    10251058            break;
    10261059        }
    10271060
    10281061        if(PMDragValidate(pDragInfo) == FALSE) {
    1029                 rc = (MRFROM2SHORT (DOR_NEVERDROP, 0));
     1062            rc = (MRFROM2SHORT (DOR_NEVERDROP, 0));
    10301063            break;
    10311064        }
    … …  
    22102243        break;
    22112244
     2245    case WM_IMEREQUEST:
     2246    case WM_IMECONTROL:
     2247    case WM_IMENOTIFY:
     2248        if( pWinMsg->message )
     2249        {
     2250            dprintf(("Frame window received IME message"));
     2251            win32wnd->DispatchMsgA( pWinMsg );
     2252
     2253            if(( pWinMsg->message = WM_IME_NOTIFY_W ) &&
     2254               ( pWinMsg->wParam == IMN_SETOPENSTATUS_W ))
     2255            {
     2256                MSG m;
     2257
     2258                m.message = WM_IME_NOTIFY_W;
     2259                m.wParam = IMN_SETCONVERSIONMODE_W;
     2260                m.lParam = 0;
     2261
     2262                win32wnd->DispatchMsgA( &m );
     2263            }
     2264        }
     2265        else
     2266            goto RunDefWndProc;
     2267        break;
     2268
    22122269#ifdef DEBUG
    22132270    case WM_DDE_INITIATE:
    … …  
    23262383// Parameters
    23272384//
    2328 //     HWND hwndOS2             - PM handle of fake window
     2385//     HWND hwndOS2     - PM handle of fake window
    23292386//
    23302387// Returns
    2331 //     NULL                     - Failure
     2388//     NULL         - Failure
    23322389//     else                     - Old PM window procedure
    23332390//

  • trunk/src/user32/win32wbase.cpp

    r10587 r10607  
    1 /* $Id: win32wbase.cpp,v 1.389 2004-04-20 10:11:43 sandervl Exp $ */
     1/* $Id: win32wbase.cpp,v 1.390 2004-05-24 09:02:00 sandervl Exp $ */
    22/*
    33 * Win32 Window Base Class for OS/2
    … …  
    7070#include "callwrap.h"
    7171
     72#include <imm.h>
     73
    7274#define DBG_LOCALLOG    DBG_win32wbase
    7375#include "dbglocal.h"
    … …  
    21232125
    21242126    case WM_IME_CHAR:
    2125         if( wParam & 0xFF00 ) // DBCS ?
     2127        if( IsDBCSLeadByte(( CHAR )( wParam >> 8 )))
    21262128            SendMessageA( getWindowHandle(), WM_CHAR, ( WPARAM )( BYTE )( wParam >> 8 ), lParam );
    21272129        SendMessageA( getWindowHandle(), WM_CHAR, ( WPARAM )( BYTE )( wParam & 0xFF ), lParam );
    21282130        break;
     2131
     2132    case WM_IME_KEYDOWN:
     2133        return SendMessageA( getWindowHandle(), WM_KEYDOWN, wParam, lParam );
     2134
     2135    case WM_IME_KEYUP:
     2136        return SendMessageA( getWindowHandle(), WM_KEYUP, wParam, lParam );
     2137
     2138    case WM_IME_COMPOSITION:
     2139    case WM_IME_COMPOSITIONFULL:
     2140    case WM_IME_CONTROL:
     2141    case WM_IME_ENDCOMPOSITION:
     2142    case WM_IME_NOTIFY:
     2143    case WM_IME_REQUEST:
     2144    case WM_IME_SELECT:
     2145    case WM_IME_SETCONTEXT:
     2146    case WM_IME_STARTCOMPOSITION:
     2147    {
     2148        HWND hwndIME = ImmGetDefaultIMEWnd( getWindowHandle());
     2149
     2150        if( hwndIME )
     2151        {
     2152            BOOL result = ImmIsUIMessageA( hwndIME, Msg, wParam, lParam );
     2153
     2154            switch( Msg )
     2155            {
     2156                case WM_IME_SETCONTEXT :
     2157                    return result;
     2158
     2159                case WM_IME_CONTROL :
     2160                    // todo : IMC_GETSTATUSWINDOWPOS return POINTS structure
     2161                    return !result;
     2162
     2163                case WM_IME_REQUEST :
     2164                    // todo
     2165                    return 0;
     2166            }
     2167        }
     2168        break;
     2169    }
    21292170
    21302171    default:
    … …  
    22062247        SendMessageW( getWindowHandle(), WM_CHAR, wParam, lParam );
    22072248        return 0;
     2249
     2250    case WM_IME_KEYDOWN:
     2251        return SendMessageW( getWindowHandle(), WM_KEYDOWN, wParam, lParam );
     2252
     2253    case WM_IME_KEYUP:
     2254        return SendMessageW( getWindowHandle(), WM_KEYUP, wParam, lParam );
     2255
     2256    case WM_IME_COMPOSITION:
     2257    case WM_IME_COMPOSITIONFULL:
     2258    case WM_IME_CONTROL:
     2259    case WM_IME_ENDCOMPOSITION:
     2260    case WM_IME_NOTIFY:
     2261    case WM_IME_REQUEST:
     2262    case WM_IME_SELECT:
     2263    case WM_IME_SETCONTEXT:
     2264    case WM_IME_STARTCOMPOSITION:
     2265    {
     2266        HWND hwndIME = ImmGetDefaultIMEWnd( getWindowHandle());
     2267
     2268        if( hwndIME )
     2269        {
     2270            BOOL result = ImmIsUIMessageW( hwndIME, Msg, wParam, lParam );
     2271
     2272            switch( Msg )
     2273            {
     2274                case WM_IME_SETCONTEXT :
     2275                    return result;
     2276
     2277                case WM_IME_CONTROL :
     2278                    // todo : IMC_GETSTATUSWINDOWPOS return POINTS structure
     2279                    return !result;
     2280
     2281                case WM_IME_REQUEST :
     2282                    // todo
     2283                    return 0;
     2284            }
     2285        }
     2286        return 0;
     2287    }
    22082288
    22092289    default:

  • trunk/src/user32/windowmsg.cpp

    r10602 r10607  
    1 /* $Id: windowmsg.cpp,v 1.50 2004-05-11 09:08:20 sandervl Exp $ */
     1/* $Id: windowmsg.cpp,v 1.51 2004-05-24 09:02:01 sandervl Exp $ */
    22/*
    33 * Win32 window message APIs for OS/2
    … …  
    3434#define INCL_TIMERWIN32
    3535#include "timer.h"
    36 #include "callwrap.h"
    3736
    3837#define DBG_LOCALLOG    DBG_windowmsg
    … …  
    327326 * @author  knut st. osmundsen <bird-srcspam@anduin.net>
    328327 * @remark  One cannot attach a threads input queue to it self.
    329  * @remark  This implemenation requires the thread which input is 'forwarded' to
    330  *          process it's message queue. Window (and wine) will not bother that thread
    331  *          at all with the messages. (DEADLOCK WARNING)
    332328 * @todo    Not sure if all this is 100% ok according to the windows reality.
    333329 *          I'm sure some error cases aren't caught.
    … …  
    566562    case WM_IME_CHAR:
    567563    {
    568         // always DBCS char
    569564        CHAR charA[ 2 ];
    570 
    571         charA[ 0 ] = ( CHAR )( *pwparam >> 8 );
    572         charA[ 1 ] = ( CHAR )*pwparam;
    573 
    574         MultiByteToWideChar( CP_ACP, 0, ( LPSTR )charA, 2, ( LPWSTR )pwparam, 1);
     565        INT  lenA = 1;
     566
     567        if( IsDBCSLeadByte(( CHAR )( *pwparam >> 8 )))
     568        {
     569            charA[ 0 ] = ( CHAR )( *pwparam >> 8 );
     570            charA[ 1 ] = ( CHAR )*pwparam;
     571            lenA = 2;
     572        }
     573        else
     574            charA[ 0 ] = ( CHAR )*pwparam;
     575
     576        MultiByteToWideChar( CP_ACP, 0, ( LPSTR )charA, lenA, ( LPWSTR )pwparam, 1);
    575577
    576578        return 0;
    … …  
    857859#ifdef __WIN32OS2__
    858860    case WM_IME_CHAR:
    859     {   // always DBCS char
     861    {
    860862        CHAR charA[ 2 ];
    861 
    862         WideCharToMultiByte( CP_ACP, 0, ( LPWSTR )pwparam, 1, ( LPSTR )charA, 2, 0, 0 );
    863         *pwparam = ( charA[ 0 ] << 8 ) | charA[ 1 ];
     863        INT  lenA;
     864
     865        lenA = WideCharToMultiByte( CP_ACP, 0, ( LPWSTR )pwparam, 1, ( LPSTR )charA, 2, 0, 0 );
     866        if( lenA > 1 )
     867            *pwparam = ( charA[ 0 ] << 8 ) | charA[ 1 ];
     868        else
     869            *pwparam = charA[ 0 ];
    864870
    865871        return 0;
    … …  
    10031009{
    10041010    LRESULT result;
     1011    LPARAM old = lParam;
    10051012
    10061013    if (WINPROC_MapMsg32ATo32W( hwnd, msg, &wParam, &lParam ) == -1) return 0;
    10071014
    1008     result = WrapCallback4(func, hwnd, msg, wParam, lParam );
     1015    result = func( hwnd, msg, wParam, lParam );
    10091016    WINPROC_UnmapMsg32ATo32W( hwnd, msg, wParam, lParam );
    10101017
    … …  
    10171024        {
    10181025            LPWSTR ustr = ( LPWSTR )HeapAlloc( GetProcessHeap(), 0, ( result + 1 ) * sizeof( WCHAR ));
    1019             result = WrapCallback4(func, hwnd, WM_GETTEXT, ( WPARAM )( result + 1 ), ( LPARAM )ustr );
     1026            result = func( hwnd, WM_GETTEXT, ( WPARAM )( result + 1 ), ( LPARAM )ustr );
    10201027            result = lstrlenWtoA( ustr, result );
    10211028            HeapFree( GetProcessHeap(), 0, ustr );
    … …  
    10261033        {
    10271034            LPWSTR ustr = ( LPWSTR )HeapAlloc( GetProcessHeap(), 0, ( result + 1 ) * sizeof( WCHAR ));
    1028             result = WrapCallback4(func, hwnd, LB_GETTEXT, wParam, ( LPARAM )ustr );
     1035            result = func( hwnd, LB_GETTEXT, wParam, ( LPARAM )ustr );
    10291036            if( result != LB_ERR )
    10301037                result = lstrlenWtoA( ustr, result );
    … …  
    10381045        {
    10391046            LPWSTR ustr = ( LPWSTR )HeapAlloc( GetProcessHeap(), 0, ( result + 1 ) * sizeof( WCHAR ));
    1040             result = WrapCallback4(func, hwnd, CB_GETLBTEXT, wParam, ( LPARAM )ustr );
     1047            result = func( hwnd, CB_GETLBTEXT, wParam, ( LPARAM )ustr );
    10411048            if( result != CB_ERR )
    10421049                result = lstrlenWtoA( ustr, result );
    … …  
    10641071    if (WINPROC_MapMsg32WTo32A( hwnd, msg, &wParam, &lParam ) == -1) return 0;
    10651072
    1066     result = WrapCallback4(func, hwnd, msg, wParam, lParam );
     1073    result = func( hwnd, msg, wParam, lParam );
    10671074    WINPROC_UnmapMsg32WTo32A( hwnd, msg, wParam, lParam );
    10681075
    … …  
    10751082        {
    10761083            LPSTR astr = ( LPSTR )HeapAlloc( GetProcessHeap(), 0, result + 1 );
    1077             result = WrapCallback4(func, hwnd, WM_GETTEXT, ( WPARAM )( result + 1 ), ( LPARAM )astr );
     1084            result = func( hwnd, WM_GETTEXT, ( WPARAM )( result + 1 ), ( LPARAM )astr );
    10781085            result = lstrlenAtoW( astr, result );
    10791086            HeapFree( GetProcessHeap(), 0, astr );
    … …  
    10841091        {
    10851092            LPSTR astr = ( LPSTR )HeapAlloc( GetProcessHeap(), 0, result + 1 );
    1086             result = WrapCallback4(func, hwnd, LB_GETTEXT, wParam, ( LPARAM )astr );
     1093            result = func( hwnd, LB_GETTEXT, wParam, ( LPARAM )astr );
    10871094            if( result != LB_ERR )
    10881095                result = lstrlenAtoW( astr, result );
    … …  
    10961103        {
    10971104            LPSTR astr = ( LPSTR )HeapAlloc( GetProcessHeap(), 0, result + 1 );
    1098             result = WrapCallback4(func, hwnd, CB_GETLBTEXT, wParam, ( LPARAM )astr );
     1105            result = func( hwnd, CB_GETLBTEXT, wParam, ( LPARAM )astr );
    10991106            if( result != CB_ERR )
    11001107                result = lstrlenAtoW( astr, result );
Note: See TracChangeset for help on using the changeset viewer.