mirror of
https://github.com/reactos/wine.git
synced 2024-12-06 02:37:17 +00:00
0799c1a780
Global replacement of debugtools.h by wine/debug.h.
231 lines
5.0 KiB
C
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 );
|
|
}
|
|
|
|
|