wine/dlls/imm32/memory.c
Alexandre Julliard 0799c1a780 Added LGPL standard comment, and copyright notices where necessary.
Global replacement of debugtools.h by wine/debug.h.
2002-03-09 23:29:33 +00:00

231 lines
5.0 KiB
C

/*
* This file implements 'moveable' memory block.
*
* 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 "winbase.h"
#include "windef.h"
#include "wingdi.h"
#include "winuser.h"
#include "winerror.h"
#include "immddk.h"
#include "wine/debug.h"
WINE_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\n" );
}
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 );
}