git.oblomov.eu Git - wine/blob - dlls/imm32/memory.c

   1 /*
   2  *      This file implements 'moveable' memory block.
   3  *
   4  *      Copyright 2000 Hidenori Takeshima
   5  */
   6
   7 #include "config.h"
   8
   9 #include "winbase.h"
  10 #include "windef.h"
  11 #include "wingdi.h"
  12 #include "winuser.h"
  13 #include "winerror.h"
  14 #include "immddk.h"
  15 #include "debugtools.h"
  16 DEFAULT_DEBUG_CHANNEL(imm);
  17
  18 #include "imm_private.h"
  19
  20 #define IMM32_MOVEABLEMEM_LOCK_MAX      ((DWORD)0xffffffff)
  21
  22 struct IMM32_tagMOVEABLEMEM
  23 {
  24         DWORD                           dwLockCount;
  25         DWORD                           dwSize;
  26         LPVOID                          lpvMem;
  27 };
  28
  29 IMM32_MOVEABLEMEM* IMM32_MoveableAlloc( DWORD dwHeapFlags, DWORD dwHeapSize )
  30 {
  31         IMM32_MOVEABLEMEM*      lpMoveable;
  32
  33         lpMoveable = (IMM32_MOVEABLEMEM*)
  34                 IMM32_HeapAlloc( 0, sizeof( IMM32_MOVEABLEMEM ) );
  35         if ( lpMoveable != NULL )
  36         {
  37                 lpMoveable->dwLockCount = 0;
  38                 lpMoveable->dwSize = dwHeapSize;
  39                 lpMoveable->lpvMem = NULL;
  40
  41                 if ( dwHeapSize > 0 )
  42                 {
  43                         lpMoveable->lpvMem =
  44                                 IMM32_HeapAlloc( dwHeapFlags, dwHeapSize );
  45                         if ( lpMoveable->lpvMem == NULL )
  46                         {
  47                                 IMM32_HeapFree( lpMoveable );
  48                                 lpMoveable = NULL;
  49                         }
  50                 }
  51         }
  52
  53         return lpMoveable;
  54 }
  55
  56 void IMM32_MoveableFree( IMM32_MOVEABLEMEM* lpMoveable )
  57 {
  58         IMM32_HeapFree( lpMoveable->lpvMem );
  59         IMM32_HeapFree( lpMoveable );
  60 }
  61
  62 BOOL IMM32_MoveableReAlloc( IMM32_MOVEABLEMEM* lpMoveable,
  63                             DWORD dwHeapFlags, DWORD dwHeapSize )
  64 {
  65         LPVOID  lpv;
  66
  67         if ( dwHeapSize > 0 )
  68         {
  69                 if ( lpMoveable->dwLockCount > 0 )
  70                         dwHeapFlags |= HEAP_REALLOC_IN_PLACE_ONLY;
  71                 lpv = IMM32_HeapReAlloc( dwHeapFlags,
  72                                          lpMoveable->lpvMem, dwHeapSize );
  73                 if ( lpv == NULL )
  74                         return FALSE;
  75         }
  76         else
  77         {
  78                 IMM32_HeapFree( lpMoveable->lpvMem );
  79                 lpv = NULL;
  80         }
  81
  82         lpMoveable->dwSize = dwHeapSize;
  83         lpMoveable->lpvMem = lpv;
  84
  85         return TRUE;
  86 }
  87
  88 LPVOID IMM32_MoveableLock( IMM32_MOVEABLEMEM* lpMoveable )
  89 {
  90         if ( lpMoveable->dwLockCount == IMM32_MOVEABLEMEM_LOCK_MAX )
  91         {
  92                 ERR( "lock count is 0xffffffff\n" );
  93         }
  94         else
  95         {
  96                 lpMoveable->dwLockCount ++;
  97         }
  98
  99         return lpMoveable->lpvMem;
 100 }
 101
 102 BOOL IMM32_MoveableUnlock( IMM32_MOVEABLEMEM* lpMoveable )
 103 {
 104         if ( lpMoveable->dwLockCount == 0 )
 105                 return FALSE;
 106
 107         if ( --lpMoveable->dwLockCount > 0 )
 108                 return TRUE;
 109
 110         return FALSE;
 111 }
 112
 113 DWORD IMM32_MoveableGetLockCount( IMM32_MOVEABLEMEM* lpMoveable )
 114 {
 115         return lpMoveable->dwLockCount;
 116 }
 117
 118 DWORD IMM32_MoveableGetSize( IMM32_MOVEABLEMEM* lpMoveable )
 119 {
 120         return lpMoveable->dwSize;
 121 }
 122
 123
 124
 125 /***********************************************************************
 126  *              ImmCreateIMCC (IMM32.@)
 127  *
 128  * Create IMCC(IMC Component).
 129  */
 130 HIMCC WINAPI ImmCreateIMCC(DWORD dwSize)
 131 {
 132         IMM32_MOVEABLEMEM* lpMoveable;
 133
 134         TRACE("(%lu)\n", dwSize);
 135
 136         lpMoveable = IMM32_MoveableAlloc( HEAP_ZERO_MEMORY, dwSize );
 137         if ( lpMoveable == NULL )
 138         {
 139                 SetLastError(ERROR_OUTOFMEMORY);
 140                 return (HIMCC)NULL;
 141         }
 142
 143         return (HIMCC)lpMoveable;
 144 }
 145
 146 /***********************************************************************
 147  *              ImmDestroyIMCC (IMM32.@)
 148  *
 149  * Destroy IMCC(IMC Component).
 150  */
 151 HIMCC WINAPI ImmDestroyIMCC(HIMCC hIMCC)
 152 {
 153         TRACE("(0x%08x)\n", (unsigned)hIMCC);
 154
 155         IMM32_MoveableFree( (IMM32_MOVEABLEMEM*)hIMCC );
 156         return (HIMCC)NULL;
 157 }
 158
 159 /***********************************************************************
 160  *              ImmLockIMCC (IMM32.@)
 161  */
 162 LPVOID WINAPI ImmLockIMCC(HIMCC hIMCC)
 163 {
 164         TRACE("(0x%08x)\n", (unsigned)hIMCC);
 165
 166         return IMM32_MoveableLock( (IMM32_MOVEABLEMEM*)hIMCC );
 167 }
 168
 169 /***********************************************************************
 170  *              ImmUnlockIMCC (IMM32.@)
 171  */
 172 BOOL WINAPI ImmUnlockIMCC(HIMCC hIMCC)
 173 {
 174         TRACE("(0x%08x)\n", (unsigned)hIMCC);
 175
 176         return IMM32_MoveableUnlock( (IMM32_MOVEABLEMEM*)hIMCC );
 177 }
 178
 179 /***********************************************************************
 180  *              ImmGetIMCCLockCount (IMM32.@)
 181  */
 182 DWORD WINAPI ImmGetIMCCLockCount(HIMCC hIMCC)
 183 {
 184         TRACE("(0x%08x)\n", (unsigned)hIMCC);
 185
 186         return IMM32_MoveableGetLockCount( (IMM32_MOVEABLEMEM*)hIMCC );
 187 }
 188
 189 /***********************************************************************
 190  *              ImmReSizeIMCC (IMM32.@)
 191  */
 192 HIMCC WINAPI ImmReSizeIMCC(HIMCC hIMCC, DWORD dwSize)
 193 {
 194         TRACE("(0x%08x,%lu)\n", (unsigned)hIMCC, dwSize);
 195
 196         if ( !IMM32_MoveableReAlloc( (IMM32_MOVEABLEMEM*)hIMCC,
 197                                      HEAP_ZERO_MEMORY, dwSize ) )
 198         {
 199                 SetLastError(ERROR_OUTOFMEMORY);
 200                 return (HIMCC)NULL;
 201         }
 202
 203         return hIMCC;
 204 }
 205
 206 /***********************************************************************
 207  *              ImmGetIMCCSize (IMM32.@)
 208  */
 209 DWORD WINAPI ImmGetIMCCSize(HIMCC hIMCC)
 210 {
 211         TRACE("(0x%08x)\n", (unsigned)hIMCC);
 212
 213         return IMM32_MoveableGetSize( (IMM32_MOVEABLEMEM*)hIMCC );
 214 }
 215
 216