diff --git a/dlls/Makefile.in b/dlls/Makefile.in index 5561cffa846..fbaa45cfc17 100644 --- a/dlls/Makefile.in +++ b/dlls/Makefile.in @@ -407,7 +407,7 @@ dsound/libdsound.@LIBEXT@: libwinmm.@LIBEXT@ libkernel32.@LIBEXT@ libntdll.@LIBE gdi/libgdi32.@LIBEXT@: libadvapi32.@LIBEXT@ libkernel32.@LIBEXT@ libntdll.@LIBEXT@ icmp/libicmp.@LIBEXT@: libkernel32.@LIBEXT@ libntdll.@LIBEXT@ imagehlp/libimagehlp.@LIBEXT@: libkernel32.@LIBEXT@ libntdll.@LIBEXT@ -imm32/libimm32.@LIBEXT@: libkernel32.@LIBEXT@ libntdll.@LIBEXT@ +imm32/libimm32.@LIBEXT@: libuser32.@LIBEXT@ libgdi32.@LIBEXT@ libkernel32.@LIBEXT@ libntdll.@LIBEXT@ kernel/libkernel32.@LIBEXT@: libntdll.@LIBEXT@ lzexpand/liblz32.@LIBEXT@: libkernel32.@LIBEXT@ libntdll.@LIBEXT@ mpr/libmpr.@LIBEXT@: libkernel32.@LIBEXT@ libntdll.@LIBEXT@ diff --git a/dlls/imm32/Makefile.in b/dlls/imm32/Makefile.in index 37daf1574bf..ea08e6f3e4c 100644 --- a/dlls/imm32/Makefile.in +++ b/dlls/imm32/Makefile.in @@ -9,7 +9,10 @@ LDDLLFLAGS = @LDDLLFLAGS@ SYMBOLFILE = $(MODULE).tmp.o C_SRCS = \ - imm.c + imm.c \ + main.c \ + memory.c \ + string.c @MAKE_DLL_RULES@ diff --git a/dlls/imm32/imm.c b/dlls/imm32/imm.c index 9fdfa05f4df..a2850dc4500 100644 --- a/dlls/imm32/imm.c +++ b/dlls/imm32/imm.c @@ -1,5 +1,5 @@ /* - * IMM32 library + * IMM32 stubs - please implement! * * Copyright 1998 Patrik Stridvall */ @@ -9,14 +9,9 @@ #include "wingdi.h" #include "winuser.h" #include "winerror.h" +#include "immddk.h" + #include "debugtools.h" -#include "imm.h" - -typedef struct INPUTCONTEXT -{ - int dummy; -} *LPINPUTCONTEXT; - DEFAULT_DEBUG_CHANNEL(imm); /*********************************************************************** @@ -769,76 +764,6 @@ DWORD WINAPI ImmGetIMCLockCount(HIMC hIMC) return 0; } -/*********************************************************************** - * ImmCreateIMCC (IMM32.@) - */ -HIMCC WINAPI ImmCreateIMCC(DWORD dwSize) -{ - FIXME("(%lu): stub\n", dwSize); - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return (HIMCC)NULL; -} - -/*********************************************************************** - * ImmDestroyIMCC (IMM32.@) - */ -HIMCC WINAPI ImmDestroyIMCC(HIMCC hIMCC) -{ - FIXME("(0x%08x): stub\n", (unsigned)hIMCC); - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return (HIMCC)hIMCC; -} - -/*********************************************************************** - * ImmLockIMCC (IMM32.@) - */ -LPVOID WINAPI ImmLockIMCC(HIMCC hIMCC) -{ - FIXME("(0x%08x): stub\n", (unsigned)hIMCC); - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return NULL; -} - -/*********************************************************************** - * ImmUnlockIMCC (IMM32.@) - */ -BOOL WINAPI ImmUnlockIMCC(HIMCC hIMCC) -{ - FIXME("(0x%08x): stub\n", (unsigned)hIMCC); - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return FALSE; -} - -/*********************************************************************** - * ImmGetIMCCLockCount (IMM32.@) - */ -DWORD WINAPI ImmGetIMCCLockCount(HIMCC hIMCC) -{ - FIXME("(0x%08x): stub\n", (unsigned)hIMCC); - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; -} - -/*********************************************************************** - * ImmReSizeIMCC (IMM32.@) - */ -HIMCC WINAPI ImmReSizeIMCC(HIMCC hIMCC, DWORD dwSize) -{ - FIXME("(0x%08x,%lu): stub\n", (unsigned)hIMCC, dwSize); - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return (HIMCC)NULL; -} - -/*********************************************************************** - * ImmGetIMCCSize (IMM32.@) - */ -DWORD WINAPI ImmGetIMCCSize(HIMCC hIMCC) -{ - FIXME("(0x%08x): stub\n", (unsigned)hIMCC); - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; -} - /*********************************************************************** * ImmCreateSoftKeyboard (IMM32.@) */ diff --git a/dlls/imm32/imm32.spec b/dlls/imm32/imm32.spec index 62696605b5e..71bef20bc97 100644 --- a/dlls/imm32/imm32.spec +++ b/dlls/imm32/imm32.spec @@ -1,6 +1,10 @@ name imm32 type win32 +init IMM32_DllMain +import user32.dll +# NOTE: gdi32.dll will be required for implementing IME global class. +import gdi32.dll import kernel32.dll import ntdll.dll diff --git a/dlls/imm32/imm_private.h b/dlls/imm32/imm_private.h new file mode 100644 index 00000000000..73233d05ff1 --- /dev/null +++ b/dlls/imm32/imm_private.h @@ -0,0 +1,148 @@ +/* + * private header for implementing IMM. + * + * Copyright 2000 Hidenori Takeshima + */ + +typedef struct IMM32_tagTHREADDATA IMM32_THREADDATA; + +struct IMM32_tagTHREADDATA +{ + HWND hwndIME; + HIMC hIMC; +}; + +typedef struct IMM32_tagMOVEABLEMEM IMM32_MOVEABLEMEM; + +/* IME APIs */ + +typedef BOOL (WINAPI* IMM32_pImeInquireA)(LPIMEINFO, LPSTR, LPCSTR); +typedef BOOL (WINAPI* IMM32_pImeInquireW)(LPIMEINFO, LPWSTR, LPCWSTR); + +typedef BOOL (WINAPI* IMM32_pImeConfigureA)(HKL, HWND, DWORD, LPVOID); +typedef BOOL (WINAPI* IMM32_pImeConfigureW)(HKL, HWND, DWORD, LPVOID); +typedef DWORD (WINAPI* IMM32_pImeConversionListA) + (HIMC, LPCSTR, LPCANDIDATELIST, DWORD, UINT); +typedef DWORD (WINAPI* IMM32_pImeConversionListW) + (HIMC, LPCWSTR, LPCANDIDATELIST, DWORD, UINT); +typedef BOOL (WINAPI* IMM32_pImeDestroy)(UINT); +typedef UINT (WINAPI* IMM32_pImeEnumRegisterWordA) + (REGISTERWORDENUMPROCA, LPCSTR, DWORD, LPCSTR, LPVOID); +typedef UINT (WINAPI* IMM32_pImeEnumRegisterWordW) + (REGISTERWORDENUMPROCW, LPCWSTR, DWORD, LPCWSTR, LPVOID); +typedef UINT (WINAPI* IMM32_pImeGetRegisterWordStyleA)(UINT, LPSTYLEBUFA); +typedef UINT (WINAPI* IMM32_pImeGetRegisterWordStyleW)(UINT, LPSTYLEBUFW); +typedef LRESULT (WINAPI* IMM32_pImeEscapeA)(HIMC, UINT, LPVOID); +typedef LRESULT (WINAPI* IMM32_pImeEscapeW)(HIMC, UINT, LPVOID); +typedef BOOL (WINAPI* IMM32_pImeProcessKey)(HIMC, UINT, LPARAM, CONST LPBYTE); +typedef BOOL (WINAPI* IMM32_pImeRegisterWordA)(LPCSTR, DWORD, LPCSTR); +typedef BOOL (WINAPI* IMM32_pImeRegisterWordW)(LPCWSTR, DWORD, LPCWSTR); +typedef BOOL (WINAPI* IMM32_pImeSelect)(HIMC, BOOL); +typedef BOOL (WINAPI* IMM32_pImeSetActiveContext)(HIMC, BOOL); +typedef BOOL (WINAPI* IMM32_pImeSetCompositionStringA) + (HIMC, DWORD, LPCVOID, DWORD, LPCVOID, DWORD); +typedef BOOL (WINAPI* IMM32_pImeSetCompositionStringW) + (HIMC, DWORD, LPCVOID, DWORD, LPCVOID, DWORD); +typedef UINT (WINAPI* IMM32_pImeToAsciiEx) + (UINT, UINT, CONST LPBYTE, LPDWORD, UINT, HIMC); +typedef BOOL (WINAPI* IMM32_pImeUnregisterWordA)(LPCSTR, DWORD, LPCSTR); +typedef BOOL (WINAPI* IMM32_pImeUnregisterWordW)(LPCWSTR, DWORD, LPCWSTR); +typedef BOOL (WINAPI* IMM32_pNotifyIME)(HIMC, DWORD, DWORD, DWORD); + +/* for Win98 and later */ +typedef DWORD (WINAPI* IMM32_pImeGetImeMenuItemsA) + (HIMC, DWORD, DWORD, LPIMEMENUITEMINFOA, LPIMEMENUITEMINFOA, DWORD); +typedef DWORD (WINAPI* IMM32_pImeGetImeMenuItemsW) + (HIMC, DWORD, DWORD, LPIMEMENUITEMINFOW, LPIMEMENUITEMINFOW, DWORD); + +struct IMM32_IME_EXPORTED_HANDLERS +{ + union + { + IMM32_pImeInquireA A; + IMM32_pImeInquireW W; + } pImeInquire; + + union + { + IMM32_pImeConfigureA A; + IMM32_pImeConfigureW W; + } pImeConfigure; + union + { + IMM32_pImeConversionListA A; + IMM32_pImeConversionListW W; + } pImeConversionList; + IMM32_pImeDestroy pImeDestroy; + union + { + IMM32_pImeEnumRegisterWordA A; + IMM32_pImeEnumRegisterWordW W; + } pImeEnumRegisterWord; + union + { + IMM32_pImeGetRegisterWordStyleA A; + IMM32_pImeGetRegisterWordStyleW W; + } pImeGetRegisterWordStyle; + union + { + IMM32_pImeEscapeA A; + IMM32_pImeEscapeW W; + } pImeEscape; + IMM32_pImeProcessKey pImeProcessKey; + union + { + IMM32_pImeRegisterWordA A; + IMM32_pImeRegisterWordW W; + } pImeRegisterWord; + IMM32_pImeSelect pImeSelect; + IMM32_pImeSetActiveContext pImeSetActiveContext; + union + { + IMM32_pImeSetCompositionStringA A; + IMM32_pImeSetCompositionStringW W; + } pImeSetCompositionString; + IMM32_pImeToAsciiEx pImeToAsciiEx; + union + { + IMM32_pImeUnregisterWordA A; + IMM32_pImeUnregisterWordW W; + } pImeUnregisterWord; + IMM32_pNotifyIME pNotifyIME; + + /* for Win98 and later */ + union + { + IMM32_pImeGetImeMenuItemsA A; + IMM32_pImeGetImeMenuItemsW W; + } pImeGetImeMenuItems; +}; + + + + +/* imm_main.c */ +LPVOID IMM32_HeapAlloc( DWORD dwFlags, DWORD dwSize ); +LPVOID IMM32_HeapReAlloc( DWORD dwFlags, LPVOID lpv, DWORD dwSize ); +void IMM32_HeapFree( LPVOID lpv ); +IMM32_THREADDATA* IMM32_GetThreadData( void ); + +/* imm_memory.c */ +IMM32_MOVEABLEMEM* IMM32_MoveableAlloc( DWORD dwHeapFlags, DWORD dwHeapSize ); +void IMM32_MoveableFree( IMM32_MOVEABLEMEM* lpMoveable ); +BOOL IMM32_MoveableReAlloc( IMM32_MOVEABLEMEM* lpMoveable, + DWORD dwHeapFlags, DWORD dwHeapSize ); +LPVOID IMM32_MoveableLock( IMM32_MOVEABLEMEM* lpMoveable ); +BOOL IMM32_MoveableUnlock( IMM32_MOVEABLEMEM* lpMoveable ); +DWORD IMM32_MoveableGetLockCount( IMM32_MOVEABLEMEM* lpMoveable ); +DWORD IMM32_MoveableGetSize( IMM32_MOVEABLEMEM* lpMoveable ); + +/* imm_string.c */ +INT IMM32_strlenAtoW( LPCSTR lpstr ); +INT IMM32_strlenWtoA( LPCWSTR lpwstr ); +LPWSTR IMM32_strncpyAtoW( LPWSTR lpwstr, LPCSTR lpstr, INT wbuflen ); +LPSTR IMM32_strncpyWtoA( LPSTR lpstr, LPCWSTR lpwstr, INT abuflen ); +LPWSTR IMM32_strdupAtoW( LPCSTR lpstr ); +LPSTR IMM32_strdupWtoA( LPCWSTR lpwstr ); + + diff --git a/dlls/imm32/immddk.h b/dlls/imm32/immddk.h new file mode 100644 index 00000000000..9377d66455f --- /dev/null +++ b/dlls/imm32/immddk.h @@ -0,0 +1,154 @@ +/* DDK version of imm.h - imm.h for IMM and IME. */ + +#ifndef __WINE_IMMDDK_H +#define __WINE_IMMDDK_H + +#include "imm.h" + +#define NULLIMC ((HIMC)0) + +/* offsets for WndExtra */ +#define IMMGWL_IMC 0 +#define IMMGWL_PRIVATE (sizeof(LONG)) + +/* INPUTCONTEXT.fdwInit */ +#define INIT_STATUSWNDPOS 0x00000001 +#define INIT_CONVERSION 0x00000002 +#define INIT_SENTENCE 0x00000004 +#define INIT_LOGFONT 0x00000008 +#define INIT_COMPFORM 0x00000010 +#define INIT_SOFTKBDPOS 0x00000020 + +/* IMEINFO.fdwProperty (low-order word) */ +#define IME_PROP_END_UNLOAD 0x00000001 +#define IME_PROP_KBD_CHAR_FIRST 0x00000002 +#define IME_PROP_IGNORE_UPKEYS 0x00000004 +#define IME_PROP_NEED_ALTKEY 0x00000008 +#define IME_PROP_NO_KEYS_ON_CLOSE 0x00000010 +/* IMEINFO.fdwProperty (high-order word) */ +#define IME_PROP_AT_CARET 0x00010000 +#define IME_PROP_SPECIAL_UI 0x00020000 +#define IME_PROP_CANDLIST_START_FROM_1 0x00040000 +#define IME_PROP_UNICODE 0x00080000 +#define IME_PROP_COMPLETE_ON_UNSELECT 0x00100000 + + +/*** IMM and IME Structures ***/ + +typedef struct tagINPUTCONTEXT { + HWND hWnd; + BOOL fOpen; + POINT ptStatusWndPos; + POINT ptSoftKbdPos; + DWORD fdwConversion; + DWORD fdwSentence; + union { + LOGFONTA A; + LOGFONTW W; + } lfFont; + COMPOSITIONFORM cfCompForm; + CANDIDATEFORM cfCandForm[4]; + HIMCC hCompStr; + HIMCC hCandInfo; + HIMCC hGuideLine; + HIMCC hPrivate; + DWORD dwNumMsgBuf; + HIMCC hMsgBuf; + DWORD fdwInit; + DWORD dwReserve[3]; +} INPUTCONTEXT, * LPINPUTCONTEXT; + +typedef struct tagCOMPOSITIONSTRING +{ + DWORD dwSize; + DWORD dwCompReadAttrLen; + DWORD dwCompReadAttrOffset; + DWORD dwCompReadClauseLen; + DWORD dwCompReadClauseOffset; + DWORD dwCompReadStrLen; + DWORD dwCompReadStrOffset; + DWORD dwCompAttrLen; + DWORD dwCompAttrOffset; + DWORD dwCompClauseLen; + DWORD dwCompClauseOffset; + DWORD dwCompStrLen; + DWORD dwCompStrOffset; + DWORD dwCursorPos; + DWORD dwDeltaStart; + DWORD dwResultReadClauseLen; + DWORD dwResultReadClauseOffset; + DWORD dwResultReadStrLen; + DWORD dwResultReadStrOffset; + DWORD dwResultClauseLen; + DWORD dwResultClauseOffset; + DWORD dwResultStrLen; + DWORD dwResultStrOffset; + DWORD dwPrivateSize; + DWORD dwPrivateOffset; +} COMPOSITIONSTRING, * LPCOMPOSITIONSTRING; + +typedef struct tagCANDIDATEINFO +{ + DWORD dwSize; + DWORD dwCount; + DWORD dwOffset[32]; + DWORD dwPrivateSize; + DWORD dwPrivateOffset; +} CANDIDATEINFO, * LPCANDIDATEINFO; + +typedef struct tagGUIDELINE +{ + DWORD dwSize; + DWORD dwLevel; + DWORD dwIndex; + DWORD dwStrLen; + DWORD dwStrOffset; + DWORD dwPrivateSize; + DWORD dwPrivateOffset; +} GUIDELINE, * LPGUIDELINE; + + + +/*** IME Management Structures ***/ + +typedef struct tagIMEINFO +{ + DWORD dwPrivateDataSize; + DWORD fdwProperty; + DWORD fdwConversionCaps; + DWORD fdwSentenceCaps; + DWORD fdwUICaps; + DWORD fdwSCSCaps; + DWORD fdwSelectCaps; +} IMEINFO, * LPIMEINFO; + + +/*** IME Communication Structures ***/ + +typedef struct tagSOFTKBDDATA +{ + UINT uCount; + WORD wCode[1][256]; +} SOFTKBDDATA, * LPSOFTKBDDATA; + + +/*** IMM DDK APIs ***/ + +HWND WINAPI ImmCreateSoftKeyboard(UINT uType, HWND hwndOwner, int x, int y); +BOOL WINAPI ImmDestroySoftKeyboard(HWND hwndSoftKeyboard); +BOOL WINAPI ImmShowSoftKeyboard(HWND hwndSoftKeyboard, int nCmdShow); + +LPINPUTCONTEXT WINAPI ImmLockIMC(HIMC hIMC); +BOOL WINAPI ImmUnlockIMC(HIMC hIMC); +DWORD WINAPI ImmGetIMCLockCount(HIMC hIMC); + +HIMCC WINAPI ImmCreateIMCC(DWORD dwSize); +HIMCC WINAPI ImmDestroyIMCC(HIMCC hIMCC); +LPVOID WINAPI ImmLockIMCC(HIMCC hIMCC); +BOOL WINAPI ImmUnlockIMCC(HIMCC hIMCC); +DWORD WINAPI ImmGetIMCCLockCount(HIMCC hIMCC); +HIMCC WINAPI ImmReSizeIMCC(HIMCC hIMCC, DWORD dwSize); +DWORD WINAPI ImmGetIMCCSize(HIMCC hIMCC); + + +#endif /* __WINE_IMMDDK_H */ diff --git a/dlls/imm32/main.c b/dlls/imm32/main.c new file mode 100644 index 00000000000..4b8f4af507b --- /dev/null +++ b/dlls/imm32/main.c @@ -0,0 +1,173 @@ +/* + * The entry point of IMM32.DLL. + * + * Copyright 2000 Hidenori Takeshima + */ + +#include "config.h" + +#include "winbase.h" +#include "windef.h" +#include "wingdi.h" +#include "winuser.h" +#include "winerror.h" +#include "immddk.h" + +#include "debugtools.h" +DEFAULT_DEBUG_CHANNEL(imm); + +#include "imm_private.h" + +static DWORD IMM32_dwProcessAttached = 0; +static HANDLE IMM32_hHeap; +static DWORD IMM32_dwTLSIndex; +static CRITICAL_SECTION IMM32_csIMM; + +static BOOL IMM32_InitProcessMem( void ); +static void IMM32_CleanupProcessMem( void ); +static void IMM32_InitThreadData( void ); +static void IMM32_CleanupThreadData( void ); + + +/*********************************************************************** + * IMM32_DllMain + */ +BOOL WINAPI IMM32_DllMain( + HINSTANCE hInstDLL, + DWORD fdwReason, + LPVOID lpvReserved ) +{ + switch ( fdwReason ) + { + case DLL_PROCESS_ATTACH: + if ( IMM32_dwProcessAttached > 0 ) + { + ERR( "cannot attach to two or more processes.\n" ); + return FALSE; + } + IMM32_dwProcessAttached ++; + + IMM32_InitProcessMem(); + /*IMM32_RegisterIMEWndClass( hInstDLL );*/ + break; + case DLL_PROCESS_DETACH: + /*IMM32_UnloadAllIMEs();*/ + /*IMM32_UnregisterIMEWndClass( hInstDLL );*/ + IMM32_CleanupProcessMem(); + + IMM32_dwProcessAttached --; + break; + case DLL_THREAD_ATTACH: + IMM32_InitThreadData(); + break; + case DLL_THREAD_DETACH: + IMM32_CleanupThreadData(); + break; + } + + return TRUE; +} + +static BOOL IMM32_InitProcessMem( void ) +{ + IMM32_hHeap = (HANDLE)NULL; + IMM32_dwTLSIndex = (DWORD)0xffffffff; + + IMM32_hHeap = HeapCreate( 0, 0x10000, 0 ); + if ( IMM32_hHeap == (HANDLE)NULL ) + { + ERR( "cannot allocate heap for IMM32.\n" ); + return FALSE; + } + + IMM32_dwTLSIndex = TlsAlloc(); + if ( IMM32_dwTLSIndex == (DWORD)0xffffffff ) + { + ERR( "cannot allocate a TLS for IMM.\n" ); + return FALSE; + } + + InitializeCriticalSection( &IMM32_csIMM ); + + return TRUE; +} + +static void IMM32_CleanupProcessMem( void ) +{ + DeleteCriticalSection( &IMM32_csIMM ); + + if ( IMM32_dwTLSIndex != (DWORD)0xffffffff ) + { + TlsFree( IMM32_dwTLSIndex ); + IMM32_dwTLSIndex = (DWORD)0xffffffff; + } + + if ( IMM32_hHeap != (HANDLE)NULL ) + { + (void)HeapDestroy( IMM32_hHeap ); + IMM32_hHeap = (HANDLE)NULL; + } +} + +LPVOID IMM32_HeapAlloc( DWORD dwFlags, DWORD dwSize ) +{ + return HeapAlloc( IMM32_hHeap, dwFlags, dwSize ); +} + +LPVOID IMM32_HeapReAlloc( DWORD dwFlags, LPVOID lpv, DWORD dwSize ) +{ + return HeapReAlloc( IMM32_hHeap, dwFlags, lpv, dwSize ); +} + +void IMM32_HeapFree( LPVOID lpv ) +{ + if ( lpv != NULL ) + HeapFree( IMM32_hHeap, 0, lpv ); +} + + +static void IMM32_InitThreadData( void ) +{ + TlsSetValue( IMM32_dwTLSIndex, NULL ); +} + +static void IMM32_CleanupThreadData( void ) +{ + IMM32_THREADDATA* pData; + + pData = (IMM32_THREADDATA*)TlsGetValue( IMM32_dwTLSIndex ); + if ( pData != NULL ) + { + /* Destroy Thread-local Data. */ + if ( pData->hwndIME != (HWND)NULL ) + DestroyWindow( pData->hwndIME ); + if ( pData->hIMC != NULLIMC ) + ImmDestroyContext( pData->hIMC ); + + IMM32_HeapFree( pData ); + TlsSetValue( IMM32_dwTLSIndex, NULL ); + } +} + +IMM32_THREADDATA* IMM32_GetThreadData( void ) +{ + IMM32_THREADDATA* pData; + + pData = (IMM32_THREADDATA*)TlsGetValue( IMM32_dwTLSIndex ); + if ( pData != NULL ) + return pData; + + pData = (IMM32_THREADDATA*) + IMM32_HeapAlloc( 0, sizeof(IMM32_THREADDATA) ); + if ( pData == NULL ) + return NULL; + + /* Initialize Thread-local Data. */ + pData->hwndIME = (HWND)NULL; + pData->hIMC = NULLIMC; + + TlsSetValue( IMM32_dwTLSIndex, pData ); + + return pData; +} + diff --git a/dlls/imm32/memory.c b/dlls/imm32/memory.c new file mode 100644 index 00000000000..991aeaf240d --- /dev/null +++ b/dlls/imm32/memory.c @@ -0,0 +1,216 @@ +/* + * This file implements 'moveable' memory block. + * + * Copyright 2000 Hidenori Takeshima + */ + +#include "config.h" + +#include "winbase.h" +#include "windef.h" +#include "wingdi.h" +#include "winuser.h" +#include "winerror.h" +#include "immddk.h" +#include "debugtools.h" +DEFAULT_DEBUG_CHANNEL(imm); + +#include "imm_private.h" + +#define IMM32_MOVEABLEMEM_LOCK_MAX ((DWORD)0xffffffff) + +struct IMM32_tagMOVEABLEMEM +{ + DWORD dwLockCount; + DWORD dwSize; + LPVOID lpvMem; +}; + +IMM32_MOVEABLEMEM* IMM32_MoveableAlloc( DWORD dwHeapFlags, DWORD dwHeapSize ) +{ + IMM32_MOVEABLEMEM* lpMoveable; + + lpMoveable = (IMM32_MOVEABLEMEM*) + IMM32_HeapAlloc( 0, sizeof( IMM32_MOVEABLEMEM ) ); + if ( lpMoveable != NULL ) + { + lpMoveable->dwLockCount = 0; + lpMoveable->dwSize = dwHeapSize; + lpMoveable->lpvMem = NULL; + + if ( dwHeapSize > 0 ) + { + lpMoveable->lpvMem = + IMM32_HeapAlloc( dwHeapFlags, dwHeapSize ); + if ( lpMoveable->lpvMem == NULL ) + { + IMM32_HeapFree( lpMoveable ); + lpMoveable = NULL; + } + } + } + + return lpMoveable; +} + +void IMM32_MoveableFree( IMM32_MOVEABLEMEM* lpMoveable ) +{ + IMM32_HeapFree( lpMoveable->lpvMem ); + IMM32_HeapFree( lpMoveable ); +} + +BOOL IMM32_MoveableReAlloc( IMM32_MOVEABLEMEM* lpMoveable, + DWORD dwHeapFlags, DWORD dwHeapSize ) +{ + LPVOID lpv; + + if ( dwHeapSize > 0 ) + { + if ( lpMoveable->dwLockCount > 0 ) + dwHeapFlags |= HEAP_REALLOC_IN_PLACE_ONLY; + lpv = IMM32_HeapReAlloc( dwHeapFlags, + lpMoveable->lpvMem, dwHeapSize ); + if ( lpv == NULL ) + return FALSE; + } + else + { + IMM32_HeapFree( lpMoveable->lpvMem ); + lpv = NULL; + } + + lpMoveable->dwSize = dwHeapSize; + lpMoveable->lpvMem = lpv; + + return TRUE; +} + +LPVOID IMM32_MoveableLock( IMM32_MOVEABLEMEM* lpMoveable ) +{ + if ( lpMoveable->dwLockCount == IMM32_MOVEABLEMEM_LOCK_MAX ) + { + ERR( "lock count is 0xffffffff." ); + } + else + { + lpMoveable->dwLockCount ++; + } + + return lpMoveable->lpvMem; +} + +BOOL IMM32_MoveableUnlock( IMM32_MOVEABLEMEM* lpMoveable ) +{ + if ( lpMoveable->dwLockCount == 0 ) + return FALSE; + + if ( --lpMoveable->dwLockCount > 0 ) + return TRUE; + + return FALSE; +} + +DWORD IMM32_MoveableGetLockCount( IMM32_MOVEABLEMEM* lpMoveable ) +{ + return lpMoveable->dwLockCount; +} + +DWORD IMM32_MoveableGetSize( IMM32_MOVEABLEMEM* lpMoveable ) +{ + return lpMoveable->dwSize; +} + + + +/*********************************************************************** + * ImmCreateIMCC (IMM32.@) + * + * Create IMCC(IMC Component). + */ +HIMCC WINAPI ImmCreateIMCC(DWORD dwSize) +{ + IMM32_MOVEABLEMEM* lpMoveable; + + TRACE("(%lu)\n", dwSize); + + lpMoveable = IMM32_MoveableAlloc( HEAP_ZERO_MEMORY, dwSize ); + if ( lpMoveable == NULL ) + { + SetLastError(ERROR_OUTOFMEMORY); + return (HIMCC)NULL; + } + + return (HIMCC)lpMoveable; +} + +/*********************************************************************** + * ImmDestroyIMCC (IMM32.@) + * + * Destroy IMCC(IMC Component). + */ +HIMCC WINAPI ImmDestroyIMCC(HIMCC hIMCC) +{ + TRACE("(0x%08x)\n", (unsigned)hIMCC); + + IMM32_MoveableFree( (IMM32_MOVEABLEMEM*)hIMCC ); + return (HIMCC)NULL; +} + +/*********************************************************************** + * ImmLockIMCC (IMM32.@) + */ +LPVOID WINAPI ImmLockIMCC(HIMCC hIMCC) +{ + TRACE("(0x%08x)\n", (unsigned)hIMCC); + + return IMM32_MoveableLock( (IMM32_MOVEABLEMEM*)hIMCC ); +} + +/*********************************************************************** + * ImmUnlockIMCC (IMM32.@) + */ +BOOL WINAPI ImmUnlockIMCC(HIMCC hIMCC) +{ + TRACE("(0x%08x)\n", (unsigned)hIMCC); + + return IMM32_MoveableUnlock( (IMM32_MOVEABLEMEM*)hIMCC ); +} + +/*********************************************************************** + * ImmGetIMCCLockCount (IMM32.@) + */ +DWORD WINAPI ImmGetIMCCLockCount(HIMCC hIMCC) +{ + TRACE("(0x%08x)\n", (unsigned)hIMCC); + + return IMM32_MoveableGetLockCount( (IMM32_MOVEABLEMEM*)hIMCC ); +} + +/*********************************************************************** + * ImmReSizeIMCC (IMM32.@) + */ +HIMCC WINAPI ImmReSizeIMCC(HIMCC hIMCC, DWORD dwSize) +{ + TRACE("(0x%08x,%lu)\n", (unsigned)hIMCC, dwSize); + + if ( !IMM32_MoveableReAlloc( (IMM32_MOVEABLEMEM*)hIMCC, + HEAP_ZERO_MEMORY, dwSize ) ) + { + SetLastError(ERROR_OUTOFMEMORY); + return (HIMCC)NULL; + } + + return hIMCC; +} + +/*********************************************************************** + * ImmGetIMCCSize (IMM32.@) + */ +DWORD WINAPI ImmGetIMCCSize(HIMCC hIMCC) +{ + TRACE("(0x%08x)\n", (unsigned)hIMCC); + + return IMM32_MoveableGetSize( (IMM32_MOVEABLEMEM*)hIMCC ); +} + + diff --git a/dlls/imm32/string.c b/dlls/imm32/string.c new file mode 100644 index 00000000000..8abc91a1b0b --- /dev/null +++ b/dlls/imm32/string.c @@ -0,0 +1,90 @@ +/* + * Helper functions for ANSI<->UNICODE string conversion + * + * Copyright 2000 Hidenori Takeshima + */ + +#include "config.h" + +#include "winbase.h" +#include "windef.h" +#include "wingdi.h" +#include "winuser.h" +#include "winerror.h" +#include "winnls.h" +#include "immddk.h" +#include "debugtools.h" +DEFAULT_DEBUG_CHANNEL(imm); + +#include "imm_private.h" + + +INT IMM32_strlenAtoW( LPCSTR lpstr ) +{ + INT len; + + len = MultiByteToWideChar( CP_ACP, 0, lpstr, -1, NULL, 0 ); + return ( len > 0 ) ? (len-1) : 0; +} + +INT IMM32_strlenWtoA( LPCWSTR lpwstr ) +{ + INT len; + + len = WideCharToMultiByte( CP_ACP, 0, lpwstr, -1, + NULL, 0, NULL, NULL ); + return ( len > 0 ) ? (len-1) : 0; +} + +LPWSTR IMM32_strncpyAtoW( LPWSTR lpwstr, LPCSTR lpstr, INT wbuflen ) +{ + INT len; + + len = MultiByteToWideChar( CP_ACP, 0, lpstr, -1, lpwstr, wbuflen ); + if ( len == 0 ) + *lpwstr = 0; + return lpwstr; +} + +LPSTR IMM32_strncpyWtoA( LPSTR lpstr, LPCWSTR lpwstr, INT abuflen ) +{ + INT len; + + len = WideCharToMultiByte( CP_ACP, 0, lpwstr, -1, + lpstr, abuflen, NULL, NULL ); + if ( len == 0 ) + *lpstr = 0; + return lpstr; +} + +LPWSTR IMM32_strdupAtoW( LPCSTR lpstr ) +{ + INT len; + LPWSTR lpwstr = NULL; + + len = IMM32_strlenAtoW( lpstr ); + if ( len > 0 ) + { + lpwstr = (LPWSTR)IMM32_HeapAlloc( 0, sizeof(WCHAR)*(len+1) ); + if ( lpwstr != NULL ) + (void)IMM32_strncpyAtoW( lpwstr, lpstr, len+1 ); + } + + return lpwstr; +} + +LPSTR IMM32_strdupWtoA( LPCWSTR lpwstr ) +{ + INT len; + LPSTR lpstr = NULL; + + len = IMM32_strlenWtoA( lpwstr ); + if ( len > 0 ) + { + lpstr = (LPSTR)IMM32_HeapAlloc( 0, sizeof(CHAR)*(len+1) ); + if ( lpstr != NULL ) + (void)IMM32_strncpyWtoA( lpstr, lpwstr, len+1 ); + } + + return lpstr; +}