634 lines
17 KiB
C++
634 lines
17 KiB
C++
/***************************************************************************
|
|
* Copyright ?2007 TWAIN Working Group:
|
|
* Adobe Systems Incorporated, AnyDoc Software Inc., Eastman Kodak Company,
|
|
* Fujitsu Computer Products of America, JFL Peripheral Solutions Inc.,
|
|
* Ricoh Corporation, and Xerox Corporation.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of the TWAIN Working Group nor the
|
|
* names of its contributors may be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY TWAIN Working Group ``AS IS'' AND ANY
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL TWAIN Working Group BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
***************************************************************************/
|
|
|
|
/**
|
|
* @file CommonTWAIN.cpp
|
|
* Utilities functions used by TWAIN Data Sources
|
|
*
|
|
* @author TWAIN Working Group
|
|
* @date October 2007
|
|
*/
|
|
|
|
#include "stdafx.h"
|
|
#include "CommonTWAIN.h"
|
|
|
|
extern TW_HANDLE _DSM_Alloc(TW_UINT32 _size);
|
|
extern TW_MEMREF _DSM_LockMemory(TW_HANDLE _hMemory);
|
|
extern void _DSM_UnlockMemory(TW_HANDLE _hMemory);
|
|
extern void _DSM_Free(TW_HANDLE _hMemory);
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
TW_FIX32 FloatToFIX32 (float floater)
|
|
{
|
|
TW_FIX32 Fix32_value;
|
|
TW_BOOL sign = (floater < 0)?TRUE:FALSE;
|
|
TW_INT32 value = (TW_INT32) (floater * 65536.0 + (sign?(-0.5):0.5));
|
|
Fix32_value.Whole = (TW_UINT16)(value >> 16);
|
|
Fix32_value.Frac = (TW_UINT16)(value & 0x0000ffffL);
|
|
return (Fix32_value);
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
float FIX32ToFloat(const TW_FIX32& _fix32)
|
|
{
|
|
return float(_fix32.Whole) + float(_fix32.Frac / 65536.0);
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
bool getCurrent(TW_CAPABILITY *pCap, TW_UINT32& val)
|
|
{
|
|
bool bret = false;
|
|
|
|
if(0 != pCap->hContainer)
|
|
{
|
|
if(TWON_ENUMERATION == pCap->ConType)
|
|
{
|
|
pTW_ENUMERATION pCapPT = (pTW_ENUMERATION)_DSM_LockMemory(pCap->hContainer);
|
|
switch(pCapPT->ItemType)
|
|
{
|
|
case TWTY_INT32:
|
|
val = (TW_INT32)((pTW_INT32)(&pCapPT->ItemList))[pCapPT->CurrentIndex];
|
|
bret = true;
|
|
break;
|
|
|
|
case TWTY_UINT32:
|
|
val = (TW_INT32)((pTW_UINT32)(&pCapPT->ItemList))[pCapPT->CurrentIndex];
|
|
bret = true;
|
|
break;
|
|
|
|
case TWTY_INT16:
|
|
val = (TW_INT32)((pTW_INT16)(&pCapPT->ItemList))[pCapPT->CurrentIndex];
|
|
bret = true;
|
|
break;
|
|
|
|
case TWTY_UINT16:
|
|
val = (TW_INT32)((pTW_UINT16)(&pCapPT->ItemList))[pCapPT->CurrentIndex];
|
|
bret = true;
|
|
break;
|
|
|
|
case TWTY_INT8:
|
|
val = (TW_INT32)((pTW_INT8)(&pCapPT->ItemList))[pCapPT->CurrentIndex];
|
|
bret = true;
|
|
break;
|
|
|
|
case TWTY_UINT8:
|
|
val = (TW_INT32)((pTW_UINT8)(&pCapPT->ItemList))[pCapPT->CurrentIndex];
|
|
bret = true;
|
|
break;
|
|
|
|
case TWTY_BOOL:
|
|
val = (TW_INT32)((pTW_BOOL)(&pCapPT->ItemList))[pCapPT->CurrentIndex];
|
|
bret = true;
|
|
break;
|
|
|
|
}
|
|
_DSM_UnlockMemory(pCap->hContainer);
|
|
}
|
|
else if(TWON_ONEVALUE == pCap->ConType)
|
|
{
|
|
pTW_ONEVALUE pCapPT = (pTW_ONEVALUE)_DSM_LockMemory(pCap->hContainer);
|
|
if(pCapPT->ItemType < TWTY_FIX32)
|
|
{
|
|
val = pCapPT->Item;
|
|
bret = true;
|
|
}
|
|
_DSM_UnlockMemory(pCap->hContainer);
|
|
}
|
|
else if(TWON_RANGE == pCap->ConType)
|
|
{
|
|
pTW_RANGE pCapPT = (pTW_RANGE)_DSM_LockMemory(pCap->hContainer);
|
|
if(pCapPT->ItemType < TWTY_FIX32)
|
|
{
|
|
val = pCapPT->CurrentValue;
|
|
bret = true;
|
|
}
|
|
_DSM_UnlockMemory(pCap->hContainer);
|
|
}
|
|
}
|
|
|
|
return bret;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
bool getCurrent(TW_CAPABILITY *pCap, string& val)
|
|
{
|
|
bool bret = false;
|
|
|
|
if(0 != pCap->hContainer)
|
|
{
|
|
if(TWON_ENUMERATION == pCap->ConType)
|
|
{
|
|
pTW_ENUMERATION pCapPT = (pTW_ENUMERATION)_DSM_LockMemory(pCap->hContainer);
|
|
switch(pCapPT->ItemType)
|
|
{
|
|
case TWTY_STR32:
|
|
{
|
|
pTW_STR32 pStr = &((pTW_STR32)(&pCapPT->ItemList))[pCapPT->CurrentIndex];
|
|
// In case the Capability is not null terminated
|
|
pStr[32] = 0;
|
|
val = pStr;
|
|
bret = true;
|
|
}
|
|
break;
|
|
|
|
case TWTY_STR64:
|
|
{
|
|
pTW_STR64 pStr = &((pTW_STR64)(&pCapPT->ItemList))[pCapPT->CurrentIndex];
|
|
// In case the Capability is not null terminated
|
|
pStr[64] = 0;
|
|
val = pStr;
|
|
bret = true;
|
|
}
|
|
break;
|
|
|
|
case TWTY_STR128:
|
|
{
|
|
pTW_STR128 pStr = &((pTW_STR128)(&pCapPT->ItemList))[pCapPT->CurrentIndex];
|
|
// In case the Capability is not null terminated
|
|
pStr[128] = 0;
|
|
val = pStr;
|
|
bret = true;
|
|
}
|
|
break;
|
|
|
|
case TWTY_STR255:
|
|
{
|
|
pTW_STR255 pStr = &((pTW_STR255)(&pCapPT->ItemList))[pCapPT->CurrentIndex];
|
|
// In case the Capability is not null terminated
|
|
pStr[255] = 0;
|
|
val = pStr;
|
|
bret = true;
|
|
}
|
|
break;
|
|
}
|
|
_DSM_UnlockMemory(pCap->hContainer);
|
|
}
|
|
else if(TWON_ONEVALUE == pCap->ConType)
|
|
{
|
|
pTW_ONEVALUE pCapPT = (pTW_ONEVALUE)_DSM_LockMemory(pCap->hContainer);
|
|
|
|
switch(pCapPT->ItemType)
|
|
{
|
|
case TWTY_STR32:
|
|
{
|
|
pTW_STR32 pStr = ((pTW_STR32)(&pCapPT->Item));
|
|
// In case the Capability is not null terminated
|
|
pStr[32] = 0;
|
|
val = pStr;
|
|
bret = true;
|
|
}
|
|
break;
|
|
|
|
case TWTY_STR64:
|
|
{
|
|
pTW_STR64 pStr = ((pTW_STR64)(&pCapPT->Item));
|
|
// In case the Capability is not null terminated
|
|
pStr[64] = 0;
|
|
val = pStr;
|
|
bret = true;
|
|
}
|
|
break;
|
|
|
|
case TWTY_STR128:
|
|
{
|
|
pTW_STR128 pStr = ((pTW_STR128)(&pCapPT->Item));
|
|
// In case the Capability is not null terminated
|
|
pStr[128] = 0;
|
|
val = pStr;
|
|
bret = true;
|
|
}
|
|
break;
|
|
|
|
case TWTY_STR255:
|
|
{
|
|
pTW_STR255 pStr = ((pTW_STR255)(&pCapPT->Item));
|
|
// In case the Capability is not null terminated
|
|
pStr[255] = 0;
|
|
val = pStr;
|
|
bret = true;
|
|
}
|
|
break;
|
|
}
|
|
_DSM_UnlockMemory(pCap->hContainer);
|
|
}
|
|
}
|
|
|
|
return bret;
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
bool getCurrent(TW_CAPABILITY *pCap, TW_FIX32& val)
|
|
{
|
|
bool bret = false;
|
|
|
|
if(0 != pCap->hContainer)
|
|
{
|
|
if(TWON_ENUMERATION == pCap->ConType)
|
|
{
|
|
pTW_ENUMERATION_FIX32 pCapPT = (pTW_ENUMERATION_FIX32)_DSM_LockMemory(pCap->hContainer);
|
|
|
|
if(TWTY_FIX32 == pCapPT->ItemType)
|
|
{
|
|
val = pCapPT->ItemList[pCapPT->CurrentIndex];
|
|
bret = true;
|
|
}
|
|
_DSM_UnlockMemory(pCap->hContainer);
|
|
}
|
|
else if(TWON_ONEVALUE == pCap->ConType)
|
|
{
|
|
pTW_ONEVALUE_FIX32 pCapPT = (pTW_ONEVALUE_FIX32)_DSM_LockMemory(pCap->hContainer);
|
|
|
|
if(TWTY_FIX32 == pCapPT->ItemType)
|
|
{
|
|
val = pCapPT->Item;
|
|
bret = true;
|
|
}
|
|
_DSM_UnlockMemory(pCap->hContainer);
|
|
}
|
|
else if(TWON_RANGE == pCap->ConType)
|
|
{
|
|
pTW_RANGE pCapPT = (pTW_RANGE)_DSM_LockMemory(pCap->hContainer);
|
|
if(TWTY_FIX32 == pCapPT->ItemType)
|
|
{
|
|
val = *(TW_FIX32*)&pCapPT->CurrentValue;
|
|
bret = true;
|
|
}
|
|
_DSM_UnlockMemory(pCap->hContainer);
|
|
}
|
|
}
|
|
|
|
return bret;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
bool getCurrent(TW_CAPABILITY *pCap, TW_FRAME& frame)
|
|
{
|
|
bool bret = false;
|
|
|
|
if(0 != pCap->hContainer)
|
|
{
|
|
if(TWON_ENUMERATION == pCap->ConType)
|
|
{
|
|
pTW_ENUMERATION_FRAME pCapPT = (pTW_ENUMERATION_FRAME)_DSM_LockMemory(pCap->hContainer);
|
|
|
|
if(TWTY_FRAME == pCapPT->ItemType)
|
|
{
|
|
frame = pCapPT->ItemList[pCapPT->CurrentIndex];
|
|
bret = true;
|
|
}
|
|
_DSM_UnlockMemory(pCap->hContainer);
|
|
}
|
|
else if(TWON_ONEVALUE == pCap->ConType)
|
|
{
|
|
pTW_ONEVALUE_FRAME pCapPT = (pTW_ONEVALUE_FRAME)_DSM_LockMemory(pCap->hContainer);
|
|
|
|
if(TWTY_FRAME == pCapPT->ItemType)
|
|
{
|
|
frame = pCapPT->Item;
|
|
bret = true;
|
|
}
|
|
_DSM_UnlockMemory(pCap->hContainer);
|
|
}
|
|
}
|
|
|
|
return bret;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
bool GetItem(TW_CAPABILITY *pCap, TW_UINT32 item, TW_UINT32& val)
|
|
{
|
|
bool bret = false;
|
|
|
|
if(0 != pCap && 0 != pCap->hContainer)
|
|
{
|
|
if( TWON_ARRAY == pCap->ConType
|
|
|| TWON_ENUMERATION == pCap->ConType )
|
|
{
|
|
TW_UINT8 *pData = NULL;
|
|
unsigned int Count = 0;
|
|
TW_UINT16 Type = 0;
|
|
|
|
if( TWON_ARRAY == pCap->ConType )
|
|
{
|
|
pTW_ARRAY pArray = (pTW_ARRAY)_DSM_LockMemory(pCap->hContainer);
|
|
Count = pArray->NumItems;
|
|
Type = pArray->ItemType;
|
|
pData = &pArray->ItemList[0];
|
|
}
|
|
|
|
if( TWON_ENUMERATION == pCap->ConType )
|
|
{
|
|
pTW_ENUMERATION pEnumeration = (pTW_ENUMERATION)_DSM_LockMemory(pCap->hContainer);
|
|
Count = pEnumeration->NumItems;
|
|
Type = pEnumeration->ItemType;
|
|
pData = &pEnumeration->ItemList[0];
|
|
}
|
|
|
|
if(item < Count)
|
|
{
|
|
switch(Type)
|
|
{
|
|
case TWTY_INT32:
|
|
val = (int)((pTW_INT32)(pData))[item];
|
|
bret = true;
|
|
break;
|
|
|
|
case TWTY_UINT32:
|
|
val = (int)((pTW_UINT32)(pData))[item];
|
|
bret = true;
|
|
break;
|
|
|
|
case TWTY_INT16:
|
|
val = (int)((pTW_INT16)(pData))[item];
|
|
bret = true;
|
|
break;
|
|
|
|
case TWTY_UINT16:
|
|
val = (int)((pTW_UINT16)(pData))[item];
|
|
bret = true;
|
|
break;
|
|
|
|
case TWTY_INT8:
|
|
val = (int)((pTW_INT8)(pData))[item];
|
|
bret = true;
|
|
break;
|
|
|
|
case TWTY_UINT8:
|
|
val = (int)((pTW_UINT8)(pData))[item];
|
|
bret = true;
|
|
break;
|
|
|
|
case TWTY_BOOL:
|
|
val = (int)((pTW_BOOL)(pData))[item];
|
|
bret = true;
|
|
break;
|
|
|
|
}
|
|
}
|
|
_DSM_UnlockMemory(pCap->hContainer);
|
|
}
|
|
}
|
|
|
|
return bret;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
bool GetItem(TW_CAPABILITY *pCap, TW_UINT32 item, string& val)
|
|
{
|
|
bool bret = false;
|
|
|
|
if(0 != pCap && 0 != pCap->hContainer)
|
|
{
|
|
if( TWON_ARRAY == pCap->ConType
|
|
|| TWON_ENUMERATION == pCap->ConType )
|
|
{
|
|
TW_UINT8 *pData = NULL;
|
|
unsigned int Count = 0;
|
|
TW_UINT16 Type = 0;
|
|
|
|
if( TWON_ARRAY == pCap->ConType )
|
|
{
|
|
pTW_ARRAY pArray = (pTW_ARRAY)_DSM_LockMemory(pCap->hContainer);
|
|
Count = pArray->NumItems;
|
|
Type = pArray->ItemType;
|
|
pData = &pArray->ItemList[0];
|
|
}
|
|
|
|
if( TWON_ENUMERATION == pCap->ConType )
|
|
{
|
|
pTW_ENUMERATION pEnumeration = (pTW_ENUMERATION)_DSM_LockMemory(pCap->hContainer);
|
|
Count = pEnumeration->NumItems;
|
|
Type = pEnumeration->ItemType;
|
|
pData = &pEnumeration->ItemList[0];
|
|
}
|
|
|
|
if(item < Count)
|
|
{
|
|
switch(Type)
|
|
{
|
|
case TWTY_STR32:
|
|
{
|
|
pTW_STR32 pStr = &((pTW_STR32)(pData))[item];
|
|
// In case the Capability is not null terminated
|
|
pStr[32] = 0;
|
|
val = pStr;
|
|
bret = true;
|
|
}
|
|
break;
|
|
|
|
case TWTY_STR64:
|
|
{
|
|
pTW_STR64 pStr = &((pTW_STR64)(pData))[item];
|
|
// In case the Capability is not null terminated
|
|
pStr[64] = 0;
|
|
val = pStr;
|
|
bret = true;
|
|
}
|
|
break;
|
|
|
|
case TWTY_STR128:
|
|
{
|
|
pTW_STR128 pStr = &((pTW_STR128)(pData))[item];
|
|
// In case the Capability is not null terminated
|
|
pStr[128] = 0;
|
|
val = pStr;
|
|
bret = true;
|
|
}
|
|
break;
|
|
|
|
case TWTY_STR255:
|
|
{
|
|
pTW_STR255 pStr = &((pTW_STR255)(pData))[item];
|
|
// In case the Capability is not null terminated
|
|
pStr[255] = 0;
|
|
val = pStr;
|
|
bret = true;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
_DSM_UnlockMemory(pCap->hContainer);
|
|
}
|
|
}
|
|
|
|
return bret;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
bool GetItem(TW_CAPABILITY *pCap, TW_UINT32 item, TW_FIX32& val)
|
|
{
|
|
bool bret = false;
|
|
|
|
if(0 != pCap && 0 != pCap->hContainer)
|
|
{
|
|
if( TWON_ARRAY == pCap->ConType
|
|
|| TWON_ENUMERATION == pCap->ConType )
|
|
{
|
|
TW_FIX32 *pData = NULL;
|
|
unsigned int Count = 0;
|
|
TW_UINT16 Type = 0;
|
|
|
|
if( TWON_ARRAY == pCap->ConType )
|
|
{
|
|
pTW_ARRAY_FIX32 pArray = (pTW_ARRAY_FIX32)_DSM_LockMemory(pCap->hContainer);
|
|
Count = pArray->NumItems;
|
|
Type = pArray->ItemType;
|
|
pData = &pArray->ItemList[0];
|
|
}
|
|
|
|
if( TWON_ENUMERATION == pCap->ConType )
|
|
{
|
|
pTW_ENUMERATION_FIX32 pEnumeration = (pTW_ENUMERATION_FIX32)_DSM_LockMemory(pCap->hContainer);
|
|
Count = pEnumeration->NumItems;
|
|
Type = pEnumeration->ItemType;
|
|
pData = &pEnumeration->ItemList[0];
|
|
}
|
|
|
|
if(item < Count && Type == TWTY_FIX32)
|
|
{
|
|
val = pData[item];
|
|
bret = true;
|
|
}
|
|
_DSM_UnlockMemory(pCap->hContainer);
|
|
}
|
|
}
|
|
|
|
return bret;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
bool GetItem(TW_CAPABILITY *pCap, TW_UINT32 item, TW_FRAME& val)
|
|
{
|
|
bool bret = false;
|
|
|
|
if(0 != pCap && 0 != pCap->hContainer)
|
|
{
|
|
if( TWON_ARRAY == pCap->ConType
|
|
|| TWON_ENUMERATION == pCap->ConType )
|
|
{
|
|
TW_FRAME *pData = NULL;
|
|
unsigned int Count = 0;
|
|
TW_UINT16 Type = 0;
|
|
|
|
if( TWON_ARRAY == pCap->ConType )
|
|
{
|
|
pTW_ARRAY_FRAME pArray = (pTW_ARRAY_FRAME)_DSM_LockMemory(pCap->hContainer);
|
|
Count = pArray->NumItems;
|
|
Type = pArray->ItemType;
|
|
pData = &pArray->ItemList[0];
|
|
}
|
|
|
|
if( TWON_ENUMERATION == pCap->ConType )
|
|
{
|
|
pTW_ENUMERATION_FRAME pEnumeration = (pTW_ENUMERATION_FRAME)_DSM_LockMemory(pCap->hContainer);
|
|
Count = pEnumeration->NumItems;
|
|
Type = pEnumeration->ItemType;
|
|
pData = &pEnumeration->ItemList[0];
|
|
}
|
|
|
|
if(item < Count && Type == TWTY_FRAME)
|
|
{
|
|
val = pData[item];
|
|
bret = true;
|
|
}
|
|
_DSM_UnlockMemory(pCap->hContainer);
|
|
}
|
|
}
|
|
|
|
return bret;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
int getTWTYsize(TW_UINT16 ItemType)
|
|
{
|
|
int TypeSize = 0;
|
|
|
|
switch(ItemType)
|
|
{
|
|
case TWTY_INT8:
|
|
TypeSize = sizeof(TW_INT8);
|
|
break;
|
|
case TWTY_INT16:
|
|
TypeSize = sizeof(TW_INT16);
|
|
break;
|
|
case TWTY_INT32:
|
|
TypeSize = sizeof(TW_INT32);
|
|
break;
|
|
case TWTY_UINT8:
|
|
TypeSize = sizeof(TW_UINT8);
|
|
break;
|
|
case TWTY_UINT16:
|
|
TypeSize = sizeof(TW_UINT16);
|
|
break;
|
|
case TWTY_UINT32:
|
|
TypeSize = sizeof(TW_UINT32);
|
|
break;
|
|
case TWTY_BOOL:
|
|
TypeSize = sizeof(TW_BOOL);
|
|
break;
|
|
case TWTY_FIX32:
|
|
TypeSize = sizeof(TW_FIX32);
|
|
break;
|
|
case TWTY_FRAME:
|
|
TypeSize = sizeof(TW_FRAME);
|
|
break;
|
|
case TWTY_STR32:
|
|
TypeSize = sizeof(TW_STR32);
|
|
break;
|
|
case TWTY_STR64:
|
|
TypeSize = sizeof(TW_STR64);
|
|
break;
|
|
case TWTY_STR128:
|
|
TypeSize = sizeof(TW_STR128);
|
|
break;
|
|
case TWTY_STR255:
|
|
TypeSize = sizeof(TW_STR255);
|
|
break;
|
|
case TWTY_STR1024:
|
|
TypeSize = sizeof(TW_STR1024);
|
|
break;
|
|
case TWTY_UNI512:
|
|
TypeSize = sizeof(TW_UNI512);
|
|
break;
|
|
case TWTY_HANDLE:
|
|
TypeSize = sizeof(TW_HANDLE);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return TypeSize;
|
|
} |