337 lines
12 KiB
C
337 lines
12 KiB
C
|
|
|
|
/*max@home*/
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#ifdef NOTE
|
|
ConvertOneValue2Enum() potrebbe essere fonte di errore se
|
|
DCItemSize[one_value.ItemType] >
|
|
DCItemSize[TW_INT8] e si utilizzano i bit piu significativi di one_value
|
|
.Item
|
|
ConvertEnumeration2Range() potrebbe restituire valori di StepSize non
|
|
appropriati se enumeration.ItemType e TW_FIX32 potrebbe
|
|
restituire valori MinValue non corretti se DCItemSize[xxx.ItemType] >
|
|
DCItemSize[TW_INT8] e si utilizzano i bit piu significativi di xxx.Item
|
|
ConvertEnum2OneValue ritorna(ovviamente) solo il valore corrente
|
|
#endif
|
|
|
|
#include <assert.h>
|
|
#include <string.h>
|
|
|
|
#include "ttwain_capability.h"
|
|
#include "ttwain_conversion.h"
|
|
#include "ttwain_error.h"
|
|
#include "ttwain_state.h"
|
|
|
|
#include "ttwain_global_def.h"
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
static const size_t DCItemSize[13] = {
|
|
sizeof(TW_INT8), sizeof(TW_INT16), sizeof(TW_INT32), sizeof(TW_UINT8),
|
|
sizeof(TW_UINT16), sizeof(TW_UINT32), sizeof(TW_BOOL), sizeof(TW_FIX32),
|
|
sizeof(TW_FRAME), sizeof(TW_STR32), sizeof(TW_STR64), sizeof(TW_STR128),
|
|
sizeof(TW_STR255),
|
|
}; /* see twain.h */
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
#define TWON_TWON(TYPE1, TYPE2) (((TYPE1) << 8) | (TYPE2))
|
|
/*---------------------------------------------------------------------------*/
|
|
static int ConvertOneValue2Range(TW_ONEVALUE one_value, TW_RANGE *range);
|
|
static int ConvertEnumeration2Range(TW_ENUMERATION enumeration,
|
|
TW_RANGE *range);
|
|
static int ConvertOneValue2Enum(TW_ONEVALUE one_value, TW_ENUMERATION *tw_enum);
|
|
static int ConvertEnum2OneValue(TW_ENUMERATION tw_enum, TW_ONEVALUE *one_value);
|
|
static int ConvertEnum2Array(TW_ENUMERATION tw_enum, TW_ARRAY *array);
|
|
|
|
static TUINT32 GetContainerSize(int nFormat, unsigned twty, TW_UINT32 nItems);
|
|
static int TTWAIN_GetCapability(TW_INT16 msgType, TW_UINT16 cap_id,
|
|
TW_UINT16 conType, void *data,
|
|
TUINT32 *cont_size);
|
|
/*------------------------------------------------------------------------*/
|
|
int TTWAIN_GetCap(TW_UINT16 cap_id, TW_UINT16 conType, void *data,
|
|
TUINT32 *cont_size) {
|
|
return TTWAIN_GetCapability(MSG_GET, cap_id, conType, data, cont_size);
|
|
}
|
|
/*------------------------------------------------------------------------*/
|
|
int TTWAIN_GetCapCurrent(TW_UINT16 cap_id, TW_UINT16 conType, void *data,
|
|
TUINT32 *cont_size) {
|
|
return TTWAIN_GetCapability(MSG_GETCURRENT, cap_id, conType, data, cont_size);
|
|
}
|
|
/*------------------------------------------------------------------------*/
|
|
int TTWAIN_GetCapQuery(TW_UINT16 cap_id, TW_UINT16 *pattern) {
|
|
int rc;
|
|
TW_ONEVALUE data;
|
|
rc = TTWAIN_GetCapability(MSG_QUERYSUPPORT, cap_id, TWON_ONEVALUE, &data, 0);
|
|
if (!rc) return FALSE;
|
|
*pattern = (TW_UINT16)data.Item;
|
|
return TRUE;
|
|
}
|
|
/*------------------------------------------------------------------------*/
|
|
static int TTWAIN_GetCapability(TW_INT16 msgType, TW_UINT16 cap_id,
|
|
TW_UINT16 conType, void *data,
|
|
TUINT32 *cont_size) {
|
|
TW_CAPABILITY cap;
|
|
void *pv;
|
|
TW_ENUMERATION *my_enum;
|
|
TW_ARRAY *my_array;
|
|
TW_ONEVALUE *my_one;
|
|
TW_RANGE *my_range;
|
|
TUINT32 size = 0;
|
|
|
|
if (!data && !cont_size) return FALSE;
|
|
|
|
if (TTWAIN_GetState() < TWAIN_SOURCE_OPEN) {
|
|
TTWAIN_ErrorBox("Attempt to get capability value below State 4.");
|
|
return FALSE;
|
|
}
|
|
/* Fill in capability structure */
|
|
cap.Cap = cap_id; /* capability id */
|
|
cap.ConType =
|
|
TWON_DONTCARE16; /* favorite type of container (should be ignored...) */
|
|
cap.hContainer = NULL;
|
|
|
|
if (TTWAIN_DS(DG_CONTROL, DAT_CAPABILITY, msgType, (TW_MEMREF)&cap) !=
|
|
TWRC_SUCCESS)
|
|
return FALSE;
|
|
|
|
if (!cap.hContainer) return FALSE;
|
|
|
|
if (msgType == MSG_QUERYSUPPORT) {
|
|
}
|
|
|
|
pv = GLOBAL_LOCK(cap.hContainer);
|
|
my_enum = (TW_ENUMERATION *)pv;
|
|
my_array = (TW_ARRAY *)pv;
|
|
my_one = (TW_ONEVALUE *)pv;
|
|
my_range = (TW_RANGE *)pv;
|
|
|
|
if (cont_size) {
|
|
switch (TWON_TWON(cap.ConType, conType)) {
|
|
case TWON_TWON(TWON_ENUMERATION, TWON_ENUMERATION):
|
|
*cont_size = GetContainerSize(TWON_ENUMERATION, my_enum->ItemType,
|
|
my_enum->NumItems);
|
|
break;
|
|
case TWON_TWON(TWON_ONEVALUE, TWON_ENUMERATION):
|
|
*cont_size = GetContainerSize(TWON_ENUMERATION, my_one->ItemType, 1);
|
|
break;
|
|
case TWON_TWON(TWON_ARRAY, TWON_ARRAY):
|
|
*cont_size =
|
|
GetContainerSize(TWON_ARRAY, my_array->ItemType, my_array->NumItems);
|
|
break;
|
|
case TWON_TWON(TWON_ONEVALUE, TWON_ONEVALUE):
|
|
*cont_size = GetContainerSize(TWON_ONEVALUE, my_one->ItemType, 1);
|
|
break;
|
|
case TWON_TWON(TWON_ENUMERATION, TWON_ARRAY):
|
|
*cont_size =
|
|
GetContainerSize(TWON_ARRAY, my_enum->ItemType, my_enum->NumItems);
|
|
break;
|
|
default:
|
|
/* tmsg_error("Unable to convert type %d to %d (cap 0x%x)\n",
|
|
* cap.ConType, conType,cap_id);*/
|
|
assert(0);
|
|
GLOBAL_UNLOCK(cap.hContainer);
|
|
GLOBAL_FREE(cap.hContainer);
|
|
return FALSE;
|
|
}
|
|
GLOBAL_UNLOCK(cap.hContainer);
|
|
GLOBAL_FREE(cap.hContainer);
|
|
return TRUE;
|
|
}
|
|
|
|
switch (TWON_TWON(cap.ConType, conType)) {
|
|
case TWON_TWON(TWON_ENUMERATION, TWON_ENUMERATION):
|
|
size = GetContainerSize(cap.ConType, my_enum->ItemType, my_enum->NumItems);
|
|
memcpy(data, my_enum, size);
|
|
break;
|
|
case TWON_TWON(TWON_ENUMERATION, TWON_RANGE):
|
|
ConvertEnumeration2Range(*my_enum, (TW_RANGE *)data);
|
|
break;
|
|
case TWON_TWON(TWON_ENUMERATION, TWON_ONEVALUE):
|
|
ConvertEnum2OneValue(*my_enum, (TW_ONEVALUE *)data);
|
|
break;
|
|
case TWON_TWON(TWON_ARRAY, TWON_ARRAY):
|
|
size =
|
|
GetContainerSize(cap.ConType, my_array->ItemType, my_array->NumItems);
|
|
memcpy(data, my_array, size);
|
|
break;
|
|
case TWON_TWON(TWON_ONEVALUE, TWON_ONEVALUE):
|
|
memcpy(data, my_one, sizeof(TW_ONEVALUE));
|
|
break;
|
|
case TWON_TWON(TWON_ONEVALUE, TWON_RANGE):
|
|
ConvertOneValue2Range(*my_one, (TW_RANGE *)data);
|
|
break;
|
|
case TWON_TWON(TWON_ONEVALUE, TWON_ENUMERATION):
|
|
ConvertOneValue2Enum(*my_one, (TW_ENUMERATION *)data);
|
|
break;
|
|
case TWON_TWON(TWON_RANGE, TWON_RANGE):
|
|
memcpy(data, my_range, sizeof(TW_RANGE));
|
|
break;
|
|
case TWON_TWON(TWON_ENUMERATION, TWON_ARRAY):
|
|
ConvertEnum2Array(*my_enum, (TW_ARRAY *)data);
|
|
break;
|
|
default:
|
|
assert(0);
|
|
GLOBAL_UNLOCK(cap.hContainer);
|
|
GLOBAL_FREE(cap.hContainer);
|
|
return FALSE;
|
|
}
|
|
GLOBAL_UNLOCK(cap.hContainer);
|
|
GLOBAL_FREE(cap.hContainer);
|
|
return TRUE;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
/*---------------------------------------------------------------------------*/
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
static int ConvertOneValue2Range(TW_ONEVALUE one_value, TW_RANGE *range) {
|
|
range->ItemType = one_value.ItemType;
|
|
range->MinValue = one_value.Item;
|
|
range->MaxValue = one_value.Item;
|
|
range->StepSize = 0;
|
|
range->DefaultValue = one_value.Item;
|
|
range->CurrentValue = one_value.Item;
|
|
return TRUE;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
static int ConvertEnumeration2Range(TW_ENUMERATION enumeration,
|
|
TW_RANGE *range) {
|
|
range->ItemType = enumeration.ItemType;
|
|
range->MinValue = enumeration.ItemList[0];
|
|
range->MaxValue = enumeration.ItemList[enumeration.NumItems - 1];
|
|
range->StepSize = (range->MaxValue - range->MinValue) / enumeration.NumItems;
|
|
if (range->MaxValue < range->MinValue) {
|
|
range->MaxValue = range->MinValue;
|
|
range->StepSize = 0;
|
|
}
|
|
range->DefaultValue = enumeration.ItemList[enumeration.DefaultIndex];
|
|
range->CurrentValue = enumeration.ItemList[enumeration.CurrentIndex];
|
|
return TRUE;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
static int ConvertOneValue2Enum(TW_ONEVALUE one_value,
|
|
TW_ENUMERATION *tw_enum) {
|
|
tw_enum->ItemType = one_value.ItemType;
|
|
tw_enum->NumItems = 1;
|
|
tw_enum->CurrentIndex = 0; /* Current value is in ItemList[CurrentIndex] */
|
|
tw_enum->DefaultIndex = 0; /* Powerup value is in ItemList[DefaultIndex] */
|
|
tw_enum->ItemList[0] = (TW_UINT8)one_value.Item;
|
|
return TRUE;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
static int ConvertEnum2OneValue(TW_ENUMERATION tw_enum,
|
|
TW_ONEVALUE *one_value) {
|
|
unsigned char *base;
|
|
TW_UINT32 ofs;
|
|
TW_UINT32 itemSize;
|
|
|
|
itemSize = DCItemSize[tw_enum.ItemType];
|
|
base = tw_enum.ItemList;
|
|
ofs = tw_enum.CurrentIndex * itemSize;
|
|
|
|
one_value->ItemType = tw_enum.ItemType;
|
|
one_value->Item = 0;
|
|
memcpy(&(one_value->Item), &(base[ofs]), itemSize);
|
|
return TRUE;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
static int ConvertEnum2Array(TW_ENUMERATION tw_enum, TW_ARRAY *array) {
|
|
TW_UINT32 itemSize;
|
|
TW_UINT32 listSize;
|
|
|
|
itemSize = DCItemSize[tw_enum.ItemType];
|
|
listSize = itemSize * tw_enum.NumItems;
|
|
array->ItemType = tw_enum.ItemType;
|
|
array->NumItems = tw_enum.NumItems;
|
|
memcpy(&(array->ItemList), &(tw_enum.ItemList), listSize);
|
|
return TRUE;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
/*---------------------------------------------------------------------------*/
|
|
/*---------------------------------------------------------------------------*/
|
|
/* SET CAP */
|
|
/*---------------------------------------------------------------------------*/
|
|
int TTWAIN_SetCap(TW_UINT16 cap_id, TW_UINT16 conType, TW_UINT16 itemType,
|
|
TW_UINT32 *value) {
|
|
int rc = FALSE;
|
|
TUINT32 size;
|
|
TW_CAPABILITY *capability = 0;
|
|
TW_HANDLE capabilityH = 0;
|
|
TW_ONEVALUE *container = 0;
|
|
TW_HANDLE containerH = 0;
|
|
|
|
size = GetContainerSize(conType, itemType, 1);
|
|
containerH = GLOBAL_ALLOC(GMEM_FIXED, size);
|
|
if (!containerH) goto done;
|
|
container = (TW_ONEVALUE *)GLOBAL_LOCK(containerH);
|
|
|
|
container->ItemType = itemType;
|
|
container->Item = *value;
|
|
capabilityH = GLOBAL_ALLOC(GMEM_FIXED, sizeof(TW_CAPABILITY));
|
|
if (!capabilityH) {
|
|
GLOBAL_UNLOCK(containerH);
|
|
GLOBAL_FREE(containerH);
|
|
containerH = NULL;
|
|
goto done;
|
|
}
|
|
|
|
capability = (TW_CAPABILITY *)GLOBAL_LOCK(capabilityH);
|
|
capability->ConType = conType;
|
|
capability->hContainer = containerH;
|
|
|
|
if (TTWAIN_GetState() < TWAIN_SOURCE_OPEN) {
|
|
/*TTWAIN_ErrorBox("Setting capability in State < 4.");*/
|
|
TTWAIN_OpenSourceManager(0); /* Bring up to state 4 */
|
|
/*goto done;*/
|
|
}
|
|
|
|
capability->Cap = cap_id; /* capability id */
|
|
|
|
rc = (TTWAIN_DS(DG_CONTROL, DAT_CAPABILITY, MSG_SET, (TW_MEMREF)capability) ==
|
|
TWRC_SUCCESS);
|
|
|
|
done:
|
|
if (containerH) {
|
|
GLOBAL_UNLOCK(containerH);
|
|
GLOBAL_FREE(containerH);
|
|
}
|
|
|
|
if (capabilityH) {
|
|
GLOBAL_UNLOCK(capabilityH);
|
|
GLOBAL_FREE(capabilityH);
|
|
}
|
|
return rc;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
static TUINT32 GetContainerSize(int nFormat, unsigned twty, TW_UINT32 nItems) {
|
|
TUINT32 size;
|
|
switch (nFormat) {
|
|
case TWON_ONEVALUE:
|
|
size = sizeof(TW_ONEVALUE);
|
|
if (DCItemSize[twty] > sizeof(TW_UINT32)) {
|
|
size += DCItemSize[twty] - sizeof(TW_UINT32);
|
|
}
|
|
break;
|
|
case TWON_RANGE:
|
|
size = sizeof(TW_RANGE);
|
|
break;
|
|
case TWON_ENUMERATION:
|
|
size =
|
|
sizeof(TW_ENUMERATION) + DCItemSize[twty] * nItems - sizeof(TW_UINT8);
|
|
break;
|
|
case TWON_ARRAY:
|
|
size = sizeof(TW_ARRAY) + DCItemSize[twty] * nItems - sizeof(TW_UINT8);
|
|
break;
|
|
default:
|
|
size = 0;
|
|
break;
|
|
} /* switch */
|
|
return size;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|