/*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></assert.h>

#include <string.h></string.h>

#include "ttwain_capability.h"

#include "ttwain_conversion.h"

#include "ttwain_error.h"

#include "ttwain_state.h"

#include "ttwain_global_def.h"

#define CASE \

	break;   \

	case

#define DEFAULT \

	break;      \

	default

																																						   /*---------------------------------------------------------------------------*/

																																						   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);

			CASE TWON_TWON(TWON_ONEVALUE, TWON_ENUMERATION) :

																  *cont_size = GetContainerSize(TWON_ENUMERATION, my_one->ItemType, 1);

			CASE TWON_TWON(TWON_ARRAY, TWON_ARRAY) :

														 *cont_size = GetContainerSize(TWON_ARRAY, my_array->ItemType, my_array->NumItems);

			CASE TWON_TWON(TWON_ONEVALUE, TWON_ONEVALUE) :

															   *cont_size = GetContainerSize(TWON_ONEVALUE, my_one->ItemType, 1);

			CASE TWON_TWON(TWON_ENUMERATION, TWON_ARRAY) :

															   *cont_size = GetContainerSize(TWON_ARRAY, my_enum->ItemType, my_enum->NumItems);

		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);

		CASE TWON_TWON(TWON_ENUMERATION, TWON_RANGE) : ConvertEnumeration2Range(*my_enum, (TW_RANGE *)data);

		CASE TWON_TWON(TWON_ENUMERATION, TWON_ONEVALUE) : ConvertEnum2OneValue(*my_enum, (TW_ONEVALUE *)data);

		CASE TWON_TWON(TWON_ARRAY, TWON_ARRAY) : size = GetContainerSize(cap.ConType, my_array->ItemType, my_array->NumItems);

		memcpy(data, my_array, size);

		CASE TWON_TWON(TWON_ONEVALUE, TWON_ONEVALUE) : memcpy(data, my_one, sizeof(TW_ONEVALUE));

		CASE TWON_TWON(TWON_ONEVALUE, TWON_RANGE) : ConvertOneValue2Range(*my_one, (TW_RANGE *)data);

		CASE TWON_TWON(TWON_ONEVALUE, TWON_ENUMERATION) : ConvertOneValue2Enum(*my_one, (TW_ENUMERATION *)data);

		CASE TWON_TWON(TWON_RANGE, TWON_RANGE) : memcpy(data, my_range, sizeof(TW_RANGE));

		CASE TWON_TWON(TWON_ENUMERATION, TWON_ARRAY) : ConvertEnum2Array(*my_enum, (TW_ARRAY *)data);

	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);

		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