dlls/imm32/main.c

   1 /*
   2  *      The entry point of IMM32.DLL.
   3  *
   4  *      Copyright 2000 Hidenori Takeshima
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include "winbase.h"
  24 #include "windef.h"
  25 #include "wingdi.h"
  26 #include "winuser.h"
  27 #include "winerror.h"
  28 #include "immddk.h"
  29
  30 #include "wine/debug.h"
  31 WINE_DEFAULT_DEBUG_CHANNEL(imm);
  32
  33 #include "imm_private.h"
  34
  35 static HANDLE                   IMM32_hHeap;
  36 static DWORD                    IMM32_dwTLSIndex;
  37 static CRITICAL_SECTION         IMM32_csIMM;
  38
  39 static BOOL IMM32_InitProcessMem( void );
  40 static void IMM32_CleanupProcessMem( void );
  41 static void IMM32_InitThreadData( void );
  42 static void IMM32_CleanupThreadData( void );
  43
  44
  45 /***********************************************************************
  46  *              IMM32_DllMain
  47  */
  48 BOOL WINAPI IMM32_DllMain(
  49         HINSTANCE hInstDLL,
  50         DWORD fdwReason,
  51         LPVOID lpvReserved )
  52 {
  53         switch ( fdwReason )
  54         {
  55         case DLL_PROCESS_ATTACH:
  56                 IMM32_InitProcessMem();
  57                 IMM32_RegisterIMEWndClass( hInstDLL );
  58                 break;
  59         case DLL_PROCESS_DETACH:
  60                 IMM32_UnloadAllIMEs();
  61                 IMM32_UnregisterIMEWndClass( hInstDLL );
  62                 IMM32_CleanupProcessMem();
  63                 break;
  64         case DLL_THREAD_ATTACH:
  65                 IMM32_InitThreadData();
  66                 break;
  67         case DLL_THREAD_DETACH:
  68                 IMM32_CleanupThreadData();
  69                 break;
  70         }
  71
  72         return TRUE;
  73 }
  74
  75 static BOOL IMM32_InitProcessMem( void )
  76 {
  77         IMM32_hHeap = (HANDLE)NULL;
  78         IMM32_dwTLSIndex = (DWORD)0xffffffff;
  79
  80         IMM32_hHeap = HeapCreate( 0, 0x10000, 0 );
  81         if ( IMM32_hHeap == (HANDLE)NULL )
  82         {
  83                 ERR( "cannot allocate heap for IMM32.\n" );
  84                 return FALSE;
  85         }
  86
  87         IMM32_dwTLSIndex = TlsAlloc();
  88         if ( IMM32_dwTLSIndex == (DWORD)0xffffffff )
  89         {
  90                 ERR( "cannot allocate a TLS for IMM.\n" );
  91                 return FALSE;
  92         }
  93
  94         InitializeCriticalSection( &IMM32_csIMM );
  95
  96         return TRUE;
  97 }
  98
  99 static void IMM32_CleanupProcessMem( void )
 100 {
 101         DeleteCriticalSection( &IMM32_csIMM );
 102
 103         if ( IMM32_dwTLSIndex != (DWORD)0xffffffff )
 104         {
 105                 TlsFree( IMM32_dwTLSIndex );
 106                 IMM32_dwTLSIndex = (DWORD)0xffffffff;
 107         }
 108
 109         if ( IMM32_hHeap != (HANDLE)NULL )
 110         {
 111                 (void)HeapDestroy( IMM32_hHeap );
 112                 IMM32_hHeap = (HANDLE)NULL;
 113         }
 114 }
 115
 116 LPVOID IMM32_HeapAlloc( DWORD dwFlags, DWORD dwSize )
 117 {
 118         return HeapAlloc( IMM32_hHeap, dwFlags, dwSize );
 119 }
 120
 121 LPVOID IMM32_HeapReAlloc( DWORD dwFlags, LPVOID lpv, DWORD dwSize )
 122 {
 123         return HeapReAlloc( IMM32_hHeap, dwFlags, lpv, dwSize );
 124 }
 125
 126 void IMM32_HeapFree( LPVOID lpv )
 127 {
 128         if ( lpv != NULL )
 129                 HeapFree( IMM32_hHeap, 0, lpv );
 130 }
 131
 132
 133 static void IMM32_InitThreadData( void )
 134 {
 135         TlsSetValue( IMM32_dwTLSIndex, NULL );
 136 }
 137
 138 static void IMM32_CleanupThreadData( void )
 139 {
 140         IMM32_THREADDATA*       pData;
 141
 142         pData = (IMM32_THREADDATA*)TlsGetValue( IMM32_dwTLSIndex );
 143         if ( pData != NULL )
 144         {
 145                 /* Destroy Thread-local Data. */
 146                 if ( pData->hwndIME != (HWND)NULL )
 147                         DestroyWindow( pData->hwndIME );
 148                 if ( pData->hIMC != NULLIMC )
 149                         ImmDestroyContext( pData->hIMC );
 150
 151                 IMM32_HeapFree( pData );
 152                 TlsSetValue( IMM32_dwTLSIndex, NULL );
 153         }
 154 }
 155
 156 IMM32_THREADDATA* IMM32_GetThreadData( void )
 157 {
 158         IMM32_THREADDATA*       pData;
 159
 160         pData = (IMM32_THREADDATA*)TlsGetValue( IMM32_dwTLSIndex );
 161         if ( pData != NULL )
 162                 return pData;
 163
 164         pData = (IMM32_THREADDATA*)
 165                         IMM32_HeapAlloc( 0, sizeof(IMM32_THREADDATA) );
 166         if ( pData == NULL )
 167                 return NULL;
 168
 169         /* Initialize Thread-local Data. */
 170         pData->hwndIME = (HWND)NULL;
 171         pData->hIMC = NULLIMC;
 172
 173         TlsSetValue( IMM32_dwTLSIndex, pData );
 174
 175         return pData;
 176 }
 177
 178 HIMC IMM32_GetDefaultContext( void )
 179 {
 180         IMM32_THREADDATA*       pData;
 181
 182         pData = IMM32_GetThreadData();
 183         if ( pData == NULL )
 184                 return NULLIMC;
 185         if ( pData->hIMC == NULLIMC )
 186                 pData->hIMC = ImmCreateContext();
 187
 188         return pData->hIMC;
 189 }
 190
 191 HWND IMM32_GetDefaultIMEWnd( void )
 192 {
 193         IMM32_THREADDATA*       pData;
 194
 195         pData = IMM32_GetThreadData();
 196         if ( pData == NULL )
 197                 return NULLIMC;
 198         if ( pData->hwndIME == (HWND)NULL )
 199                 pData->hwndIME = IMM32_CreateDefaultIMEWnd();
 200
 201         return pData->hwndIME;
 202 }
 203
 204
 205 void IMM32_Lock( void )
 206 {
 207         EnterCriticalSection( &IMM32_csIMM );
 208 }
 209
 210 void IMM32_Unlock( void )
 211 {
 212         LeaveCriticalSection( &IMM32_csIMM );
 213 }