693 lines
15 KiB
C
693 lines
15 KiB
C
/*
|
|
* IME Keyboard Layout
|
|
*
|
|
* Copyright 2000 Hidenori Takeshima
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <string.h>
|
|
#include "winbase.h"
|
|
#include "windef.h"
|
|
#include "wingdi.h"
|
|
#include "winuser.h"
|
|
#include "winerror.h"
|
|
#include "winnls.h"
|
|
#include "winreg.h"
|
|
#include "immddk.h"
|
|
|
|
#include "wine/debug.h"
|
|
WINE_DEFAULT_DEBUG_CHANNEL(imm);
|
|
|
|
#include "imm_private.h"
|
|
|
|
static const char IMM32_szRegKL[] =
|
|
"System\\CurrentControlSet\\Control\\keyboard layouts";
|
|
static const char IMM32_szIME_File[] = "IME file";
|
|
static const char IMM32_szLayout_File[] = "layout file";
|
|
|
|
static IMM32_IMEKL* IMM32_pklFirst = NULL;
|
|
|
|
|
|
static LONG IMM32_RegOpenKey( HKL hkl, PHKEY phkRet )
|
|
{
|
|
CHAR szRegPath[ sizeof(IMM32_szRegKL)+16 ];
|
|
|
|
wsprintfA( szRegPath, "%s\\%08x", IMM32_szRegKL, (unsigned)hkl );
|
|
return RegOpenKeyExA( HKEY_LOCAL_MACHINE, szRegPath,
|
|
0, KEY_READ, phkRet );
|
|
}
|
|
|
|
static LONG IMM32_RegCreateKey( HKL hkl, PHKEY phkRet,
|
|
LPDWORD lpdwDisposition )
|
|
{
|
|
CHAR szRegPath[ sizeof(IMM32_szRegKL)+16 ];
|
|
|
|
wsprintfA( szRegPath, "%s\\%08x", IMM32_szRegKL, (unsigned)hkl );
|
|
return RegCreateKeyExA( HKEY_LOCAL_MACHINE, szRegPath,
|
|
0, "REG_SZ",
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_ALL_ACCESS, NULL,
|
|
phkRet, lpdwDisposition );
|
|
}
|
|
|
|
static DWORD IMM32_GetIMEFileName( HKL hkl, LPSTR lpBuf, INT nBufLen )
|
|
{
|
|
HKEY hkey;
|
|
LONG nError;
|
|
DWORD dwType;
|
|
DWORD cbData;
|
|
CHAR szValueName[ sizeof(IMM32_szIME_File) ];
|
|
|
|
TRACE( "hkl = %08x\n", (unsigned)hkl );
|
|
|
|
nError = IMM32_RegOpenKey( hkl, &hkey );
|
|
if ( nError != ERROR_SUCCESS )
|
|
{
|
|
SetLastError( nError );
|
|
return 0;
|
|
}
|
|
memcpy( szValueName, IMM32_szIME_File, sizeof(IMM32_szIME_File) );
|
|
|
|
nError = RegQueryValueExA( hkey, szValueName, NULL,
|
|
&dwType, NULL, &cbData );
|
|
if ( nError == ERROR_SUCCESS && dwType != REG_SZ )
|
|
nError = ERROR_FILE_NOT_FOUND; /* FIXME? */
|
|
if ( nError == ERROR_SUCCESS && lpBuf != NULL && nBufLen != 0 )
|
|
{
|
|
if ( nBufLen < (INT)cbData )
|
|
nError = ERROR_INSUFFICIENT_BUFFER;
|
|
else
|
|
nError = RegQueryValueExA( hkey, szValueName, NULL,
|
|
&dwType, lpBuf, &cbData );
|
|
}
|
|
|
|
RegCloseKey( hkey );
|
|
|
|
if ( nError != ERROR_SUCCESS )
|
|
{
|
|
SetLastError( nError );
|
|
return 0;
|
|
}
|
|
|
|
return cbData;
|
|
}
|
|
|
|
|
|
static
|
|
BOOL IMM32_GetIMEHandlersA( HINSTANCE hInstIME,
|
|
struct IMM32_IME_EXPORTED_HANDLERS* phandlers )
|
|
{
|
|
BOOL fError;
|
|
|
|
#define FE(name) \
|
|
phandlers->p##name = (IMM32_p##name) \
|
|
GetProcAddress(hInstIME,#name); \
|
|
if ( phandlers->p##name == NULL ) fError = TRUE;
|
|
#define FE_(name) \
|
|
phandlers->p##name.A = (IMM32_p##name##A) \
|
|
GetProcAddress(hInstIME,#name); \
|
|
if ( phandlers->p##name.A == NULL ) fError = TRUE;
|
|
|
|
fError = FALSE;
|
|
|
|
FE_(ImeInquire)
|
|
FE_(ImeConfigure)
|
|
FE_(ImeConversionList)
|
|
FE(ImeDestroy)
|
|
FE_(ImeEnumRegisterWord)
|
|
FE_(ImeGetRegisterWordStyle)
|
|
FE_(ImeEscape)
|
|
FE(ImeProcessKey)
|
|
FE_(ImeRegisterWord)
|
|
FE(ImeSelect)
|
|
FE(ImeSetActiveContext)
|
|
FE_(ImeSetCompositionString)
|
|
FE(ImeToAsciiEx)
|
|
FE_(ImeUnregisterWord)
|
|
FE(NotifyIME)
|
|
|
|
if ( fError )
|
|
return FALSE;
|
|
|
|
FE_(ImeGetImeMenuItems)
|
|
|
|
#undef FE
|
|
#undef FE_
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static
|
|
BOOL IMM32_GetIMEHandlersW( HINSTANCE hInstIME,
|
|
struct IMM32_IME_EXPORTED_HANDLERS* phandlers )
|
|
{
|
|
BOOL fError;
|
|
|
|
#define FE(name) \
|
|
phandlers->p##name = (IMM32_p##name) \
|
|
GetProcAddress(hInstIME,#name); \
|
|
if ( phandlers->p##name == NULL ) fError = TRUE;
|
|
#define FE_(name) \
|
|
phandlers->p##name.W = (IMM32_p##name##W) \
|
|
GetProcAddress(hInstIME,#name); \
|
|
if ( phandlers->p##name.W == NULL ) fError = TRUE;
|
|
|
|
fError = FALSE;
|
|
|
|
FE_(ImeInquire)
|
|
FE_(ImeConfigure)
|
|
FE_(ImeConversionList)
|
|
FE(ImeDestroy)
|
|
FE_(ImeEnumRegisterWord)
|
|
FE_(ImeGetRegisterWordStyle)
|
|
FE_(ImeEscape)
|
|
FE(ImeProcessKey)
|
|
FE_(ImeRegisterWord)
|
|
FE(ImeSelect)
|
|
FE(ImeSetActiveContext)
|
|
FE_(ImeSetCompositionString)
|
|
FE(ImeToAsciiEx)
|
|
FE_(ImeUnregisterWord)
|
|
FE(NotifyIME)
|
|
|
|
if ( fError )
|
|
return FALSE;
|
|
|
|
FE_(ImeGetImeMenuItems)
|
|
|
|
#undef FE
|
|
#undef FE_
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static IMM32_IMEKL* IMM32_LoadIME( HKL hkl )
|
|
{
|
|
IMM32_IMEKL* pkl = NULL;
|
|
BOOL fInitialized = FALSE;
|
|
CHAR* pszFileName = NULL;
|
|
DWORD dwBufLen;
|
|
IMM32_pImeInquireA pImeInquire;
|
|
IMM32_pImeDestroy pImeDestroy = NULL;
|
|
CHAR szUIClassName[ (IMM32_UICLASSNAME_MAX+1)*sizeof(WCHAR) ];
|
|
|
|
dwBufLen = IMM32_GetIMEFileName( hkl, NULL, 0 );
|
|
if ( dwBufLen == 0 )
|
|
goto err;
|
|
pszFileName = (CHAR*)IMM32_HeapAlloc( 0, sizeof(CHAR)*(dwBufLen+1) );
|
|
if ( pszFileName == NULL )
|
|
{
|
|
SetLastError( ERROR_OUTOFMEMORY );
|
|
goto err;
|
|
}
|
|
if ( !IMM32_GetIMEFileName( hkl, pszFileName, dwBufLen + 1 ) )
|
|
goto err;
|
|
|
|
pkl = (IMM32_IMEKL*)
|
|
IMM32_HeapAlloc( HEAP_ZERO_MEMORY, sizeof(IMM32_IMEKL) );
|
|
if ( pkl == NULL )
|
|
{
|
|
SetLastError( ERROR_OUTOFMEMORY );
|
|
goto err;
|
|
}
|
|
|
|
pkl->pNext = NULL;
|
|
pkl->hkl = hkl;
|
|
pkl->hInstIME = LoadLibraryA( pszFileName );
|
|
if ( pkl->hInstIME == (HINSTANCE)NULL )
|
|
goto err;
|
|
|
|
pImeInquire = (IMM32_pImeInquireA)GetProcAddress
|
|
( pkl->hInstIME, "ImeInquire" );
|
|
pImeDestroy = (IMM32_pImeDestroy)GetProcAddress
|
|
( pkl->hInstIME, "ImeDestroy" );
|
|
if ( pImeInquire == NULL || pImeDestroy == NULL )
|
|
goto err;
|
|
|
|
if ( !pImeInquire( &(pkl->imeinfo), szUIClassName, NULL ) )
|
|
{
|
|
SetLastError( ERROR_DLL_INIT_FAILED ); /* FIXME? */
|
|
goto err;
|
|
}
|
|
fInitialized = TRUE;
|
|
|
|
/* FIXME: Is this correct??? */
|
|
if ( pkl->imeinfo.fdwProperty & IME_PROP_UNICODE )
|
|
pkl->fUnicode = TRUE;
|
|
else
|
|
pkl->fUnicode = FALSE;
|
|
|
|
if ( pkl->fUnicode )
|
|
{
|
|
if ( !IMM32_GetIMEHandlersW( pkl->hInstIME, &pkl->handlers ) )
|
|
goto err;
|
|
memcpy( pkl->UIClassName.W, szUIClassName,
|
|
IMM32_UICLASSNAME_MAX*sizeof(WCHAR) );
|
|
TRACE( "UI class name(Unicode): %s\n",
|
|
debugstr_w(pkl->UIClassName.W) );
|
|
}
|
|
else
|
|
{
|
|
if ( !IMM32_GetIMEHandlersA( pkl->hInstIME, &pkl->handlers ) )
|
|
goto err;
|
|
memcpy( pkl->UIClassName.A, szUIClassName,
|
|
IMM32_UICLASSNAME_MAX*sizeof(CHAR) );
|
|
TRACE( "UI class name(ASCII): %s\n",
|
|
debugstr_a(pkl->UIClassName.A) );
|
|
}
|
|
|
|
/* The IME is loaded successfully. */
|
|
pkl->pszIMEFileName = pszFileName; pszFileName = NULL;
|
|
return pkl;
|
|
|
|
err:
|
|
IMM32_HeapFree( pszFileName );
|
|
if ( pkl != NULL )
|
|
{
|
|
if ( pkl->hInstIME != (HINSTANCE)NULL )
|
|
{
|
|
if ( fInitialized )
|
|
(void)pImeDestroy(0);
|
|
FreeLibrary( pkl->hInstIME );
|
|
}
|
|
IMM32_HeapFree( pkl );
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
const IMM32_IMEKL* IMM32_GetIME( HKL hkl )
|
|
{
|
|
IMM32_IMEKL* pkl;
|
|
|
|
IMM32_Lock();
|
|
|
|
pkl = IMM32_pklFirst;
|
|
while ( pkl != NULL )
|
|
{
|
|
if ( pkl->hkl == hkl )
|
|
goto end;
|
|
pkl = pkl->pNext;
|
|
}
|
|
|
|
pkl = IMM32_LoadIME( hkl );
|
|
if ( pkl != NULL )
|
|
{
|
|
pkl->pNext = IMM32_pklFirst;
|
|
IMM32_pklFirst = pkl;
|
|
}
|
|
|
|
end:
|
|
IMM32_Unlock();
|
|
|
|
return pkl;
|
|
}
|
|
|
|
void IMM32_UnloadAllIMEs( void )
|
|
{
|
|
IMM32_IMEKL* pkl;
|
|
IMM32_IMEKL* pklNext;
|
|
|
|
IMM32_Lock();
|
|
|
|
pkl = IMM32_pklFirst;
|
|
while ( pkl != NULL )
|
|
{
|
|
TRACE( "hkl = %08x\n", (unsigned)pkl->hkl );
|
|
|
|
pklNext = pkl->pNext;
|
|
(void)pkl->handlers.pImeDestroy(0);
|
|
FreeLibrary( pkl->hInstIME );
|
|
IMM32_HeapFree( pkl->pszIMEFileName );
|
|
IMM32_HeapFree( pkl );
|
|
pkl = pklNext;
|
|
}
|
|
IMM32_pklFirst = NULL;
|
|
|
|
IMM32_Unlock();
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
* ImmInstallIMEA (IMM32.@)
|
|
*/
|
|
HKL WINAPI ImmInstallIMEA(
|
|
LPCSTR lpszIMEFileName, LPCSTR lpszLayoutText)
|
|
{
|
|
HKL hkl;
|
|
DWORD dwLCID;
|
|
DWORD dwTryCount;
|
|
LONG nError;
|
|
HKEY hkey;
|
|
DWORD dwDisposition;
|
|
DWORD cbData;
|
|
CHAR szValueName[ sizeof(IMM32_szIME_File) ];
|
|
|
|
TRACE("(%s, %s)\n",
|
|
debugstr_a(lpszIMEFileName), debugstr_a(lpszLayoutText) );
|
|
|
|
dwLCID = (DWORD)GetThreadLocale();
|
|
dwTryCount = 0;
|
|
|
|
FIXME( "IMEs don't work correctly now since\n"
|
|
"wine/windows/input.c doesn't handle HKL correctly.\n" );
|
|
|
|
while ( 1 )
|
|
{
|
|
hkl = (HKL)(((0xe000|dwTryCount)<<16) | (dwLCID));
|
|
|
|
nError = IMM32_RegCreateKey( hkl, &hkey, &dwDisposition );
|
|
if ( nError != ERROR_SUCCESS )
|
|
break;
|
|
|
|
memcpy( szValueName, IMM32_szIME_File,
|
|
sizeof(IMM32_szIME_File) );
|
|
|
|
nError = RegQueryValueExA( hkey, szValueName, NULL,
|
|
NULL, NULL, &cbData );
|
|
if ( nError == ERROR_SUCCESS && cbData > 0 )
|
|
{
|
|
RegCloseKey( hkey );
|
|
|
|
/* try to assign an other HKL. */
|
|
dwTryCount ++;
|
|
if ( dwTryCount >= 0x100 )
|
|
{
|
|
nError = ERROR_ACCESS_DENIED; /* FIXME */
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
nError = RegSetValueExA( hkey, IMM32_szIME_File, 0,
|
|
REG_SZ, lpszIMEFileName,
|
|
strlen(lpszIMEFileName)+1 );
|
|
if ( nError == ERROR_SUCCESS )
|
|
nError = RegSetValueExA( hkey, IMM32_szLayout_File, 0,
|
|
REG_SZ, lpszLayoutText,
|
|
strlen(lpszLayoutText)+1 );
|
|
RegCloseKey( hkey );
|
|
break;
|
|
}
|
|
|
|
if ( nError != ERROR_SUCCESS )
|
|
{
|
|
SetLastError( nError );
|
|
return (HKL)NULL;
|
|
}
|
|
|
|
return hkl;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ImmInstallIMEW (IMM32.@)
|
|
*/
|
|
HKL WINAPI ImmInstallIMEW(
|
|
LPCWSTR lpszIMEFileName, LPCWSTR lpszLayoutText)
|
|
{
|
|
LPSTR lpszParam1;
|
|
LPSTR lpszParam2;
|
|
HKL hkl;
|
|
|
|
TRACE("(%s, %s)\n",
|
|
debugstr_w(lpszIMEFileName), debugstr_w(lpszLayoutText) );
|
|
|
|
lpszParam1 = IMM32_strdupWtoA( lpszIMEFileName );
|
|
lpszParam2 = IMM32_strdupWtoA( lpszLayoutText );
|
|
if ( ( lpszParam1 == NULL ) || ( lpszParam2 == NULL ) )
|
|
{
|
|
SetLastError( ERROR_OUTOFMEMORY );
|
|
hkl = (HKL)NULL;
|
|
}
|
|
else
|
|
{
|
|
hkl = ImmInstallIMEA( lpszParam1, lpszParam2 );
|
|
}
|
|
IMM32_HeapFree( lpszParam1 );
|
|
IMM32_HeapFree( lpszParam2 );
|
|
|
|
return hkl;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* ImmIsIME (IMM32.@)
|
|
*/
|
|
BOOL WINAPI ImmIsIME(HKL hkl)
|
|
{
|
|
const IMM32_IMEKL* pkl;
|
|
|
|
TRACE("(0x%08x)\n", hkl);
|
|
|
|
pkl = IMM32_GetIME( hkl );
|
|
if ( pkl == NULL )
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* ImmGetIMEFileNameA (IMM32.@)
|
|
*/
|
|
UINT WINAPI ImmGetIMEFileNameA(HKL hkl, LPSTR lpszFileName, UINT uBufLen)
|
|
{
|
|
const IMM32_IMEKL* pkl;
|
|
UINT uIMEFileNameLen;
|
|
|
|
TRACE("(%08x,%p,%u)\n",hkl,lpszFileName,uBufLen);
|
|
|
|
pkl = IMM32_GetIME( hkl );
|
|
if ( pkl == NULL )
|
|
return 0;
|
|
|
|
uIMEFileNameLen = strlen(pkl->pszIMEFileName);
|
|
if ( uBufLen == 0 )
|
|
return uIMEFileNameLen;
|
|
if ( uBufLen <= uIMEFileNameLen )
|
|
{
|
|
SetLastError(ERROR_INSUFFICIENT_BUFFER);
|
|
return 0;
|
|
}
|
|
memcpy( lpszFileName, pkl->pszIMEFileName,
|
|
sizeof(CHAR)*(uIMEFileNameLen+1) );
|
|
|
|
return uIMEFileNameLen;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ImmGetIMEFileNameW (IMM32.@)
|
|
*/
|
|
UINT WINAPI ImmGetIMEFileNameW(HKL hkl, LPWSTR lpszFileName, UINT uBufLen)
|
|
{
|
|
const IMM32_IMEKL* pkl;
|
|
UINT uIMEFileNameLen;
|
|
|
|
TRACE("(%08x,%p,%u)\n",hkl,lpszFileName,uBufLen);
|
|
|
|
pkl = IMM32_GetIME( hkl );
|
|
if ( pkl == NULL )
|
|
return 0;
|
|
|
|
uIMEFileNameLen = IMM32_strlenAtoW(pkl->pszIMEFileName);
|
|
if ( uBufLen == 0 )
|
|
return uIMEFileNameLen;
|
|
if ( uBufLen <= uIMEFileNameLen )
|
|
{
|
|
SetLastError(ERROR_INSUFFICIENT_BUFFER);
|
|
return 0;
|
|
}
|
|
IMM32_strncpyAtoW( lpszFileName, pkl->pszIMEFileName, uBufLen );
|
|
|
|
return uIMEFileNameLen;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ImmGetProperty (IMM32.@)
|
|
*/
|
|
DWORD WINAPI ImmGetProperty(HKL hkl, DWORD fdwIndex)
|
|
{
|
|
const IMM32_IMEKL* pkl;
|
|
DWORD dwRet;
|
|
|
|
TRACE("(0x%08x, %ld)\n", hkl, fdwIndex);
|
|
|
|
pkl = IMM32_GetIME( hkl );
|
|
if ( pkl == NULL )
|
|
return 0;
|
|
|
|
switch ( fdwIndex )
|
|
{
|
|
case IGP_GETIMEVERSION:
|
|
dwRet = IMEVER_0400;
|
|
break;
|
|
case IGP_PROPERTY:
|
|
dwRet = pkl->imeinfo.fdwProperty;
|
|
break;
|
|
case IGP_CONVERSION:
|
|
dwRet = pkl->imeinfo.fdwConversionCaps;
|
|
break;
|
|
case IGP_SENTENCE:
|
|
dwRet = pkl->imeinfo.fdwSentenceCaps;
|
|
break;
|
|
case IGP_UI:
|
|
dwRet = pkl->imeinfo.fdwUICaps;
|
|
break;
|
|
case IGP_SETCOMPSTR:
|
|
dwRet = pkl->imeinfo.fdwSCSCaps;
|
|
break;
|
|
case IGP_SELECT:
|
|
dwRet = pkl->imeinfo.fdwSelectCaps;
|
|
break;
|
|
default:
|
|
FIXME("(0x%08x, %ld): invalid/unknown property.\n",
|
|
hkl, fdwIndex);
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
dwRet = 0;
|
|
}
|
|
|
|
return dwRet;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* ImmEnumRegisterWordA (IMM32.@)
|
|
*/
|
|
UINT WINAPI ImmEnumRegisterWordA(
|
|
HKL hkl, REGISTERWORDENUMPROCA lpfnEnumProc,
|
|
LPCSTR lpszReading, DWORD dwStyle,
|
|
LPCSTR lpszRegister, LPVOID lpData)
|
|
{
|
|
const IMM32_IMEKL* pkl;
|
|
|
|
TRACE("(0x%08x, %p, %s, %ld, %s, %p)\n",
|
|
hkl, lpfnEnumProc,
|
|
debugstr_a(lpszReading), dwStyle,
|
|
debugstr_a(lpszRegister), lpData);
|
|
|
|
pkl = IMM32_GetIME( hkl );
|
|
if ( pkl == NULL )
|
|
return 0;
|
|
|
|
if ( pkl->fUnicode )
|
|
{
|
|
FIXME( "please implement UNICODE->ANSI\n" );
|
|
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
return pkl->handlers.pImeEnumRegisterWord.A
|
|
( lpfnEnumProc, lpszReading, dwStyle,
|
|
lpszRegister, lpData );
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ImmEnumRegisterWordW (IMM32.@)
|
|
*/
|
|
UINT WINAPI ImmEnumRegisterWordW(
|
|
HKL hkl, REGISTERWORDENUMPROCW lpfnEnumProc,
|
|
LPCWSTR lpszReading, DWORD dwStyle,
|
|
LPCWSTR lpszRegister, LPVOID lpData)
|
|
{
|
|
const IMM32_IMEKL* pkl;
|
|
|
|
TRACE("(0x%08x, %p, %s, %ld, %s, %p): stub\n",
|
|
hkl, lpfnEnumProc,
|
|
debugstr_w(lpszReading), dwStyle,
|
|
debugstr_w(lpszRegister), lpData);
|
|
|
|
pkl = IMM32_GetIME( hkl );
|
|
if ( pkl == NULL )
|
|
return 0;
|
|
|
|
if ( pkl->fUnicode )
|
|
{
|
|
return pkl->handlers.pImeEnumRegisterWord.W
|
|
( lpfnEnumProc, lpszReading, dwStyle,
|
|
lpszRegister, lpData );
|
|
}
|
|
else
|
|
{
|
|
FIXME( "please implement ANSI->UNICODE\n" );
|
|
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* ImmGetRegisterWordStyleA (IMM32.@)
|
|
*/
|
|
UINT WINAPI ImmGetRegisterWordStyleA(
|
|
HKL hkl, UINT nItem, LPSTYLEBUFA lpStyleBuf)
|
|
{
|
|
const IMM32_IMEKL* pkl;
|
|
|
|
TRACE("(0x%08x, %d, %p)\n", hkl, nItem, lpStyleBuf);
|
|
|
|
pkl = IMM32_GetIME( hkl );
|
|
if ( pkl == NULL )
|
|
return 0;
|
|
|
|
if ( pkl->fUnicode )
|
|
{
|
|
FIXME( "please implement UNICODE->ANSI\n" );
|
|
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
return pkl->handlers.pImeGetRegisterWordStyle.A
|
|
( nItem, lpStyleBuf );
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ImmGetRegisterWordStyleW (IMM32.@)
|
|
*/
|
|
UINT WINAPI ImmGetRegisterWordStyleW(
|
|
HKL hkl, UINT nItem, LPSTYLEBUFW lpStyleBuf)
|
|
{
|
|
const IMM32_IMEKL* pkl;
|
|
|
|
TRACE("(0x%08x, %d, %p)\n", hkl, nItem, lpStyleBuf);
|
|
|
|
pkl = IMM32_GetIME( hkl );
|
|
if ( pkl == NULL )
|
|
return 0;
|
|
|
|
if ( pkl->fUnicode )
|
|
{
|
|
return pkl->handlers.pImeGetRegisterWordStyle.W
|
|
( nItem, lpStyleBuf );
|
|
}
|
|
else
|
|
{
|
|
FIXME( "please implement ANSI->UNICODE\n" );
|
|
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
|