Retired Document
Important: This sample code may not represent best practices for current development. The project may use deprecated symbols and illustrate technologies and techniques that are no longer recommended.
Relevant replacement documents include:
TWAIN Helper Glue/TWUtilities.c
// =========================================================================== |
// TWUtilities.c TWAIN 1.9 ©1991-2001 TWAIN Working Group |
// =========================================================================== |
// |
// Glue-code utilities. |
#include "TWUtilities.h" |
#include "TWDefs.h" |
static TW_INT16 CopyItems(pTW_UINT8 pSource,pTW_UINT8 pDestin,TW_INT16 ItemType,TW_INT16 NumItems); |
// --------------------------------------------------------------------------- |
// ¥ SetupOneValue |
// --------------------------------------------------------------------------- |
// Fills in a capability struct for sets of one value |
TW_INT16 SetupOneValue(pTW_CAPABILITY pCapability, TW_INT16 ItemType, TW_INT32 Item) |
{ |
pTW_ONEVALUE pOneValue; |
pCapability->ConType=TWON_ONEVALUE; |
pCapability->hContainer=NewHandle(sizeof(TW_ONEVALUE)); |
if (pCapability->hContainer==NULL) |
return(TWERR); |
pOneValue=(pTW_ONEVALUE)(*pCapability->hContainer); |
pOneValue->ItemType=ItemType; |
pOneValue->Item=Item; |
return(OKAY); |
} |
// --------------------------------------------------------------------------- |
// ¥ SetupRange |
// --------------------------------------------------------------------------- |
// Fills in a capability struct for ranges |
TW_INT16 SetupRange(pTW_CAPABILITY pCapability, TW_INT16 ItemType, |
TW_INT32 MinValue, TW_INT32 MaxValue, TW_INT32 StepSize, |
TW_INT32 DefaultValue, TW_INT32 CurrentValue) |
{ |
pTW_RANGE pRange; |
pCapability->ConType=TWON_RANGE; |
pCapability->hContainer=NewHandle(sizeof(TW_RANGE)); |
if (pCapability->hContainer==NULL) |
return(TWERR); |
pRange=(pTW_RANGE)(*pCapability->hContainer); |
pRange->ItemType=ItemType; |
pRange->MinValue=MinValue; |
pRange->MaxValue=MaxValue; |
pRange->StepSize=StepSize; |
pRange->DefaultValue=DefaultValue; |
pRange->CurrentValue=CurrentValue; |
return(OKAY); |
} |
// --------------------------------------------------------------------------- |
// ¥ SetupEnumeration |
// --------------------------------------------------------------------------- |
// Sets up a capability struct for enumeration type negotiation. |
TW_INT16 SetupEnumeration(pTW_CAPABILITY pCapability, TW_INT16 ItemType, |
TW_INT16 NumItems, TW_INT16 CurrentIndex, TW_INT16 DefaultIndex, |
pTW_UINT8 ItemList) |
/* |
** Parameters: |
** pCapability - pointer to TW_CAPABILITY struct |
** ItemType - type of item in range (i.e. TWTY_INT16) |
** NumItems - number of items in enumerated list |
** CurrentIndex- index to current value in list |
** DefaultIndex- index to default value in list |
** ItemList - pointer to enumerated list |
** Globals: None. |
** Operation: |
** Return: |
** OKAY - if successful |
** TWERR - handle allocation failed |
*/ |
{ |
pTW_ENUMERATION pEnumeration; |
pCapability->ConType=TWON_ENUMERATION; |
pCapability->hContainer=NewHandle(sizeof(TW_ENUMERATION)+ |
GetItemSize(ItemType)*NumItems); |
if (pCapability->hContainer==NULL) return(TWERR); |
pEnumeration=(pTW_ENUMERATION)(*pCapability->hContainer); |
pEnumeration->ItemType=ItemType; |
pEnumeration->NumItems=NumItems; |
pEnumeration->CurrentIndex=CurrentIndex; |
pEnumeration->DefaultIndex=DefaultIndex; |
CopyItems(ItemList,pEnumeration->ItemList,ItemType,NumItems); |
return(OKAY); |
} |
// --------------------------------------------------------------------------- |
// ¥ SetupArray |
// --------------------------------------------------------------------------- |
// Sets up a capability struct for array negotiation. |
TW_INT16 SetupArray(pTW_CAPABILITY pCapability, |
TW_INT16 ItemType, |
TW_INT16 NumItems, |
pTW_UINT8 ItemList) |
{ |
pTW_ARRAY pArray; |
pCapability->ConType=TWON_ARRAY; |
pCapability->hContainer=NewHandle(sizeof(TW_ARRAY)+ |
GetItemSize(ItemType)*NumItems); |
pArray=(pTW_ARRAY)(*pCapability->hContainer); |
pArray->ItemType=ItemType; |
pArray->NumItems=NumItems; |
CopyItems(ItemList,pArray->ItemList,ItemType,NumItems); |
return(OKAY); |
} |
// --------------------------------------------------------------------------- |
// ¥ GetOneValue |
// --------------------------------------------------------------------------- |
// Extracts a value from a ONE_VALUE capability struct. |
TW_INT16 GetOneValue(pTW_CAPABILITY pCapability, pTW_INT16 pItemType, pTW_INT32 pItem) |
{ |
pTW_ONEVALUE pOneValue; |
if (pCapability->ConType!=TWON_ONEVALUE) |
return(TWERR); |
pOneValue=(pTW_ONEVALUE)(*pCapability->hContainer); |
if (pItemType!=NULL) |
*pItemType=pOneValue->ItemType; |
if (pItem!=NULL) |
*pItem=pOneValue->Item; |
return(OKAY); |
} |
// --------------------------------------------------------------------------- |
// ¥ GetRange |
// --------------------------------------------------------------------------- |
// Extracts a range of values from a RANGE capability struct. |
TW_INT16 GetRange(pTW_CAPABILITY pCapability, pTW_INT16 pItemType, |
pTW_INT32 pMinValue, pTW_INT32 pMaxValue, pTW_INT32 pStepSize, |
pTW_INT32 pDefaultValue, pTW_INT32 pCurrentValue) |
{ |
pTW_RANGE pRange; |
if (pCapability->ConType!=TWON_RANGE) |
return(TWERR); |
pRange=(pTW_RANGE)(*pCapability->hContainer); |
if (pItemType!=NULL) *pItemType=pRange->ItemType; |
if (pMinValue!=NULL) *pMinValue=pRange->MinValue; |
if (pMaxValue!=NULL) *pMaxValue=pRange->MaxValue; |
if (pStepSize!=NULL) *pStepSize=pRange->StepSize; |
if (pDefaultValue!=NULL) *pDefaultValue=pRange->DefaultValue; |
if (pCurrentValue!=NULL) *pCurrentValue=pRange->CurrentValue; |
return(OKAY); |
} |
// --------------------------------------------------------------------------- |
// ¥ GetEnumeration |
// --------------------------------------------------------------------------- |
// Extracts a list of enumerated items from a capability structure. |
TW_INT16 GetEnumeration(pTW_CAPABILITY pCapability, pTW_INT16 pItemType, |
pTW_INT16 pNumItems, pTW_INT16 pCurrentIndex, pTW_INT16 pDefaultIndex, |
pTW_UINT8 pItemList, TW_INT16 MaxBytes) |
{ |
pTW_ENUMERATION pEnumeration; |
if (pCapability->ConType!=TWON_ENUMERATION) |
return(TWERR); |
pEnumeration=(pTW_ENUMERATION)(*pCapability->hContainer); |
if (pItemType!=NULL) *pItemType=pEnumeration->ItemType; |
if (pNumItems!=NULL) *pNumItems=pEnumeration->NumItems; |
if (pCurrentIndex!=NULL) *pCurrentIndex=pEnumeration->CurrentIndex; |
if (pDefaultIndex!=NULL) *pDefaultIndex=pEnumeration->DefaultIndex; |
if (pItemList!=NULL) |
{ |
if (MaxBytes<(*pNumItems*GetItemSize(*pItemType))) return(TWERR); |
CopyItems(pEnumeration->ItemList,pItemList,*pItemType,*pNumItems); |
} |
return(OKAY); |
} |
// --------------------------------------------------------------------------- |
// ¥ GetArray |
// --------------------------------------------------------------------------- |
// Extracts a list of enumerated items from a capability structure. |
TW_INT16 GetArray( pTW_CAPABILITY pCapability, |
pTW_INT16 pItemType, |
pTW_INT16 pNumItems, |
pTW_UINT8 pItemList, |
TW_INT16 MaxBytes) |
{ |
pTW_ARRAY pArray; |
if (pCapability->ConType!=TWON_ARRAY) |
return(TWERR); |
pArray=(pTW_ARRAY)(*pCapability->hContainer); |
if (pItemType!=NULL) *pItemType=pArray->ItemType; |
if (pNumItems!=NULL) *pNumItems=pArray->NumItems; |
if (pItemList!=NULL) |
{ |
if (MaxBytes<(*pNumItems*GetItemSize(*pItemType))) return(TWERR); |
CopyItems(pArray->ItemList,pItemList,*pItemType,*pNumItems); |
} |
return(OKAY); |
} |
// --------------------------------------------------------------------------- |
// ¥ DumpOneValue |
// --------------------------------------------------------------------------- |
// Extracts contents of one value struct and disposes of the container. |
TW_INT16 DumpOneValue(pTW_CAPABILITY pCapability, pTW_INT16 pItemType, |
pTW_INT32 pItem) |
{ |
TW_INT16 Result=OKAY; |
Result=GetOneValue(pCapability,pItemType,pItem); |
if (Result==OKAY) |
{ |
DisposeHandle(pCapability->hContainer); |
pCapability->hContainer=NULL; |
} |
return(Result); |
} |
// --------------------------------------------------------------------------- |
// ¥ DumpRange |
// --------------------------------------------------------------------------- |
// Extracts contents of range struct and disposes of the container. |
TW_INT16 DumpRange(pTW_CAPABILITY pCapability, pTW_INT16 pItemType, |
pTW_INT32 pMinValue, pTW_INT32 pMaxValue, pTW_INT32 pStepSize, |
pTW_INT32 pDefaultValue, pTW_INT32 pCurrentValue) |
{ |
TW_INT16 Result=OKAY; |
Result=GetRange(pCapability,pItemType,pMinValue,pMaxValue,pStepSize, |
pDefaultValue,pCurrentValue); |
if (Result==OKAY) |
{ |
DisposeHandle(pCapability->hContainer); |
pCapability->hContainer=NULL; |
} |
return(Result); |
} |
// --------------------------------------------------------------------------- |
// ¥ DumpEnumeration |
// --------------------------------------------------------------------------- |
// Extracts contents of enumeration struct and disposes of the container. |
TW_INT16 DumpEnumeration(pTW_CAPABILITY pCapability, pTW_INT16 pItemType, |
pTW_INT16 pNumItems, pTW_INT16 pCurrentIndex, pTW_INT16 pDefaultIndex, |
pTW_UINT8 pItemList, TW_INT16 MaxBytes) |
{ |
TW_INT16 Result=OKAY; |
Result=GetEnumeration(pCapability,pItemType,pNumItems, |
pCurrentIndex,pDefaultIndex,pItemList,MaxBytes); |
if (Result==OKAY) |
{ |
DisposeHandle(pCapability->hContainer); |
pCapability->hContainer=NULL; |
} |
return(Result); |
} |
// --------------------------------------------------------------------------- |
// ¥ DumpArray |
// --------------------------------------------------------------------------- |
// Extracts contents of enumeration struct and disposes of the container. |
TW_INT16 DumpArray( pTW_CAPABILITY pCapability, |
pTW_INT16 pItemType, |
pTW_INT16 pNumItems, |
pTW_UINT8 pItemList, |
TW_INT16 MaxBytes) |
{ |
TW_INT16 Result=OKAY; |
Result=GetArray(pCapability,pItemType,pNumItems,pItemList,MaxBytes); |
DisposeHandle(pCapability->hContainer); |
pCapability->hContainer=NULL; |
return(Result); |
} |
// --------------------------------------------------------------------------- |
// ¥ GetItemSize |
// --------------------------------------------------------------------------- |
// Returns the size of an item in bytes. |
TW_INT16 GetItemSize(TW_INT16 ItemType) |
{ |
TW_INT16 size = 0; |
switch (ItemType) |
{ |
case TWTY_INT8: |
case TWTY_UINT8: |
size = 1; |
break; |
case TWTY_INT16: |
case TWTY_UINT16: |
case TWTY_BOOL: |
size = 2; |
break; |
case TWTY_INT32: |
case TWTY_UINT32: |
case TWTY_FIX32: |
size = 4; |
break; |
case TWTY_STR32: |
size = 32; |
break; |
case TWTY_STR64: |
size = 64; |
break; |
case TWTY_STR128: |
size = 128; |
break; |
case TWTY_STR255: |
size = 256; |
break; |
default: |
break; |
} |
return size; |
} |
// --------------------------------------------------------------------------- |
// ¥ CopyItems |
// --------------------------------------------------------------------------- |
// Copies numItems from the source to the destination list |
TW_INT16 CopyItems(pTW_UINT8 pSource,pTW_UINT8 pDestin,TW_INT16 ItemType,TW_INT16 numItems ) |
{ |
TW_INT16 i; |
TW_INT16 ItemSize; |
TW_INT32 Length; |
ItemSize=GetItemSize(ItemType); |
Length=(TW_INT32)ItemSize*(TW_INT32)numItems; |
for (i=0;i<Length;i++) |
pDestin[i]=pSource[i]; |
return(OKAY); |
} |
Copyright © 2003 Apple Computer, Inc. All Rights Reserved. Terms of Use | Privacy Policy | Updated: 2003-07-10