#ifdef _WIN32
#pragma warning(disable : 4996)
#endif

#ifdef NOTE
here
/*
TTWAIN_Get???Value (TW_RANGE range) restituisce sempre un float e (ovviamente)
funziona solo con gli item il cui sizeof() e' <= sizeof (float) (unica eccezione
TW_FIX32)

USA_LE_QUERY: -> non definito!
Le query dovrebbero essere un modo per capire le azioni che sono permesse
su una determinata capability, questo sta scritto in twainSpec1.8:
nessun DS ha ritornato valori sensati, per cui non vengono usate.
*/
#endif

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#include <assert.h>

#include "ttwain_util.h"
#include "ttwain_utilP.h"
#include "ttwain_utilPD.h"
#include "ttwainP.h"
#include "ttwain.h"
#include "ttwain_state.h"
#include "ttwain_capability.h"
#include "ttwain_conversion.h"
#include "ttwain_error.h"

#include "ttwain_global_def.h"

/*
Scommentare MACOSX_NO_PARAMS, per evitare che l'applicazione abbia il controllo
dei parametri (Caps supportate, ImageLayout, XferCount)
Utile sotto MACOSX per evitare che i DS della HP si aprano alla richiesta, 
e rimangano li.... in attesa di una scansione (tutto continua a funzionare,
alla prima scansione il DS si chiude correttamente e l'applicazione ottiene
l'immagine)
*/
/*
#define MACOSX_NO_PARAMS
*/

#ifdef __cplusplus
	extern "C"
{
#endif

	/*#define USA_LE_QUERY*/
	/* local  */
	static int TTWAIN_GetPhysicalWidth(float *width);
	static int TTWAIN_GetPhysicalHeight(float *height);

	static int TTWAIN_GetMinimumWidth(float *width);
	static int TTWAIN_GetMinimumHeight(float *height);

	static int TTWAIN_IsCapSupported(void *cap);
	static int TTWAIN_IsCapSupportedTW_INT16(TW_INT16 cap);

	/* MISC AUX FUNCTIONS */
	static float TTWAIN_GetMinValue(TW_RANGE range);
	static float TTWAIN_GetMaxValue(TW_RANGE range);
	static float TTWAIN_GetDefValue(TW_RANGE range);
	static float TTWAIN_GetStepValue(TW_RANGE range);
	static int TTWAIN_IsItemInList(void *list, void *item, TUINT32 list_count, TUINT32 item_size);

	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 FLAVOR_UNUSED (0xffff)

#define CASE \
	break;   \
	case
#define __OR case
#define DEFAULT \
	break;      \
	default
	struct TTWAIN_PIXELTYPEP {
		TW_UINT16 type;
		TW_UINT16 flavor;
		TW_UINT16 bitDepth;
	};
	static struct TTWAIN_PIXELTYPEP PixType[TTWAIN_PIXTYPE_HOWMANY] = {
		{TWPT_BW, TWPF_CHOCOLATE, 1},  /* BW    */
		{TWPT_BW, TWPF_VANILLA, 1},	/* WB    */
		{TWPT_GRAY, FLAVOR_UNUSED, 8}, /* GRAY8 */
		{TWPT_RGB, FLAVOR_UNUSED, 24}  /* RGB24 */
	};
	/*---------------------------------------------------------------------------*/
	/*    GET CAPABILITIES				                                               */
	/*---------------------------------------------------------------------------*/
	int TTWAIN_GetResolution(float *min, float *max, float *step, float *def)
	{
		TW_RANGE range_data;
		int rc;

		if (!(min && max && step && def))
			return FALSE;
		rc = TTWAIN_GetCap(ICAP_XRESOLUTION, TWON_RANGE, (void *)&range_data, 0);
		if (!rc)
			return FALSE;
		*min = TTWAIN_GetMinValue(range_data);
		*max = TTWAIN_GetMaxValue(range_data);
		*step = TTWAIN_GetStepValue(range_data);
		*def = TTWAIN_GetDefValue(range_data);
		return rc;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_GetOpticalResolution(float *min, float *max, float *step, float *def)
	{
		TW_RANGE range_data;
		int rc;

		if (!(min && max && step && def))
			return FALSE;
		rc = TTWAIN_GetCap(ICAP_XNATIVERESOLUTION, TWON_RANGE, (void *)&range_data, 0);
		if (!rc)
			return FALSE;
		*min = TTWAIN_GetMinValue(range_data);
		*max = TTWAIN_GetMaxValue(range_data);
		*step = TTWAIN_GetStepValue(range_data);
		*def = TTWAIN_GetDefValue(range_data);
		return rc;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_GetBrightness(float *min, float *max, float *step, float *def)
	{
		TW_RANGE range_data;
		int rc;

		assert(min && max && step && def);

		rc = TTWAIN_GetCap(ICAP_BRIGHTNESS, TWON_RANGE, (void *)&range_data, 0);
		if (!rc)
			return FALSE;
		*min = TTWAIN_GetMinValue(range_data);
		*max = TTWAIN_GetMaxValue(range_data);
		*step = TTWAIN_GetStepValue(range_data);
		*def = TTWAIN_GetDefValue(range_data);
		return rc;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_GetContrast(float *min, float *max, float *step, float *def)
	{
		TW_RANGE range_data;
		int rc;

		assert(min && max && step && def);

		rc = TTWAIN_GetCap(ICAP_CONTRAST, TWON_RANGE, (void *)&range_data, 0);
		if (!rc)
			return FALSE;
		*min = TTWAIN_GetMinValue(range_data);
		*max = TTWAIN_GetMaxValue(range_data);
		*step = TTWAIN_GetStepValue(range_data);
		*def = TTWAIN_GetDefValue(range_data);
		return rc;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_GetThreshold(float *min, float *max, float *step, float *def)
	{
		TW_RANGE range_data;
		int rc;

		assert(min && max && step && def);

		rc = TTWAIN_GetCap(ICAP_THRESHOLD, TWON_RANGE, (void *)&range_data, 0);
		if (!rc)
			return FALSE;
		*min = TTWAIN_GetMinValue(range_data);
		*max = TTWAIN_GetMaxValue(range_data);
		*step = TTWAIN_GetStepValue(range_data);
		*def = TTWAIN_GetDefValue(range_data);
		return rc;
	}
	/*---------------------------------------------------------------------------*/
	static int TTWAIN_GetPhysicalWidth(float *width)
	{
		TW_ONEVALUE width_data;
		if (TTWAIN_GetCap(ICAP_PHYSICALWIDTH, TWON_ONEVALUE, (void *)&width_data, 0)) {
			*width = TTWAIN_Fix32ToFloat(*(TW_FIX32 *)&width_data.Item);
			return TRUE;
		} else
			return FALSE;
	}
	/*---------------------------------------------------------------------------*/
	static int TTWAIN_GetPhysicalHeight(float *height)
	{
		TW_ONEVALUE height_data;
		if (TTWAIN_GetCap(ICAP_PHYSICALHEIGHT, TWON_ONEVALUE, (void *)&height_data, 0)) {
			*height = TTWAIN_Fix32ToFloat(*(TW_FIX32 *)&height_data.Item);
			return TRUE;
		} else
			return FALSE;
	}
	/*---------------------------------------------------------------------------*/
	static int TTWAIN_GetMinimumWidth(float *width)
	{
		TW_ONEVALUE width_data;
		if (TTWAIN_GetCap(ICAP_MINIMUMWIDTH, TWON_ONEVALUE, (void *)&width_data, 0)) {
			*width = TTWAIN_Fix32ToFloat(*(TW_FIX32 *)&width_data.Item);
			return TRUE;
		} else
			return FALSE;
	}
	/*---------------------------------------------------------------------------*/
	static int TTWAIN_GetMinimumHeight(float *height)
	{
		TW_ONEVALUE height_data;
		if (TTWAIN_GetCap(ICAP_MINIMUMHEIGHT, TWON_ONEVALUE, (void *)&height_data, 0)) {
			*height = TTWAIN_Fix32ToFloat(*(TW_FIX32 *)&height_data.Item);
			return TRUE;
		} else
			return FALSE;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_GetPhysicalWidthWAdf(float *width)
	{
		int rc = FALSE;
		int feeder_status;

		if (TTWAIN_SupportsFeeder()) {
			feeder_status = TTWAIN_GetFeeder();
			rc = TTWAIN_SetFeeder(TRUE);
			if (rc)
				rc = TTWAIN_GetPhysicalWidth(width);
			TTWAIN_SetFeeder(feeder_status);
		}
		return rc;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_GetPhysicalHeightWAdf(float *height)
	{
		int rc = FALSE;
		int feeder_status;

		if (TTWAIN_SupportsFeeder()) {
			feeder_status = TTWAIN_GetFeeder();
			rc = TTWAIN_SetFeeder(TRUE);
			if (rc)
				rc = TTWAIN_GetPhysicalHeight(height);
			TTWAIN_SetFeeder(feeder_status);
		}
		return rc;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_GetMinimumWidthWAdf(float *width)
	{
		int rc = FALSE;
		int feeder_status;

		if (TTWAIN_SupportsFeeder()) {
			feeder_status = TTWAIN_GetFeeder();
			rc = TTWAIN_SetFeeder(TRUE);
			if (rc)
				rc = TTWAIN_GetMinimumWidth(width);
			TTWAIN_SetFeeder(feeder_status);
		}
		return rc;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_GetMinimumHeightWAdf(float *height)
	{
		int rc = FALSE;
		int feeder_status;

		if (TTWAIN_SupportsFeeder()) {
			feeder_status = TTWAIN_GetFeeder();
			rc = TTWAIN_SetFeeder(TRUE);
			if (rc)
				rc = TTWAIN_GetMinimumHeight(height);
			TTWAIN_SetFeeder(feeder_status);
		}
		return rc;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_GetPhysicalWidthWoAdf(float *width)
	{
		int rc = FALSE;
		int feeder_status = FALSE;

		if (TTWAIN_SupportsFeeder()) {
			feeder_status = TTWAIN_GetFeeder();
			rc = TTWAIN_SetFeeder(FALSE);
		}
		rc = TTWAIN_GetPhysicalWidth(width);
		if (TTWAIN_SupportsFeeder())
			TTWAIN_SetFeeder(feeder_status);
		return rc;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_GetPhysicalHeightWoAdf(float *height)
	{
		int rc = FALSE;
		int feeder_status = FALSE;

		if (TTWAIN_SupportsFeeder()) {
			feeder_status = TTWAIN_GetFeeder();
			rc = TTWAIN_SetFeeder(TRUE);
		}
		rc = TTWAIN_GetPhysicalHeight(height);
		if (TTWAIN_SupportsFeeder())
			TTWAIN_SetFeeder(feeder_status);
		return rc;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_GetMinimumWidthWoAdf(float *width)
	{
		int rc = FALSE;
		int feeder_status = FALSE;

		if (TTWAIN_SupportsFeeder()) {
			feeder_status = TTWAIN_GetFeeder();
			rc = TTWAIN_SetFeeder(FALSE);
		}
		rc = TTWAIN_GetMinimumWidth(width);
		if (TTWAIN_SupportsFeeder())
			TTWAIN_SetFeeder(feeder_status);
		return rc;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_GetMinimumHeightWoAdf(float *height)
	{
		int rc = FALSE;
		int feeder_status = FALSE;

		if (TTWAIN_SupportsFeeder()) {
			feeder_status = TTWAIN_GetFeeder();
			rc = TTWAIN_SetFeeder(TRUE);
		}
		rc = TTWAIN_GetMinimumHeight(height);
		if (TTWAIN_SupportsFeeder())
			TTWAIN_SetFeeder(feeder_status);
		return rc;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_SupportsPixelType(TTWAIN_PIXTYPE pix_type)
	{
		TW_HANDLE handle;
		TW_ENUMERATION *container;
		int rc, found = FALSE;
		TUINT32 size4data;
		TW_UINT16 twPix;

		twPix = PixType[pix_type].type;
		rc = TTWAIN_GetCap(ICAP_PIXELTYPE, TWON_ENUMERATION, (void *)0, &size4data);
		if (!rc)
			return FALSE;
		if (!size4data)
			return FALSE;
		handle = GLOBAL_ALLOC(GMEM_FIXED, size4data);
		if (!handle)
			return FALSE;

		container = (TW_ENUMERATION *)GLOBAL_LOCK(handle);
		rc = TTWAIN_GetCap(ICAP_PIXELTYPE, TWON_ENUMERATION, (void *)container, 0);

		if (!rc)
			goto done;
		found = TTWAIN_IsItemInList(container->ItemList, &twPix,
									container->NumItems, DCItemSize[container->ItemType]);

	done:
		GLOBAL_UNLOCK(handle);
		GLOBAL_FREE(handle);
		return found;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_SupportsCompressionType(TW_UINT16 comprType)
	{
		int rc;
		TUINT32 size;
		int found = FALSE;
		TW_ENUMERATION *container = 0;
		TW_HANDLE handle = 0;

		if (!TTWAIN_IsCapCompressionSupported())
			return FALSE;
		rc = TTWAIN_GetCap(ICAP_COMPRESSION, TWON_ENUMERATION, (void *)0, &size);
		if (!rc || !size)
			return FALSE;

		handle = GLOBAL_ALLOC(GMEM_FIXED, size);
		if (!handle)
			return FALSE;

		container = (TW_ENUMERATION *)GLOBAL_LOCK(handle);

		rc = TTWAIN_GetCap(ICAP_COMPRESSION, TWON_ENUMERATION, (void *)container, 0);

		if (!rc)
			goto done;
		found = TTWAIN_IsItemInList(container->ItemList, &comprType,
									container->NumItems, DCItemSize[container->ItemType]);
		found = TRUE;
	done:
		if (handle) {
			GLOBAL_UNLOCK(handle);
			GLOBAL_FREE(handle);
		}
		return found;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_SupportsFeeder(void)
	{
		TW_ONEVALUE feeder;
		int rc;
		feeder.Item = 0;
		rc = TTWAIN_GetCap(CAP_FEEDERENABLED, TWON_ONEVALUE, (void *)&feeder, 0);
		return rc;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_GetFeeder(void)/* TRUE->enabled */
	{
		TW_ONEVALUE feeder;
		int rc;
		feeder.Item = 0;
		rc = TTWAIN_GetCap(CAP_FEEDERENABLED, TWON_ONEVALUE, (void *)&feeder, 0);
		return feeder.Item && rc;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_IsFeederLoaded(void)/* TRUE->loaded */
	{
		TW_ONEVALUE feeder;
		int rc;

#ifdef MACOSX_NO_PARAMS
		printf("%s always returns false (disabled at compile time)\n", __FUNCTION__);
		return FALSE;
#endif

		feeder.Item = 0;
		rc = TTWAIN_GetCap(CAP_FEEDERLOADED, TWON_ONEVALUE, (void *)&feeder, 0);
		return feeder.Item && rc;
	}
	/*---------------------------------------------------------------------------*/
	char *TTWAIN_GetManufacturer(void)
	{
#ifdef MACOSX
		static char msg[1024];
		strncpy(msg, (const char *)&TTwainData.sourceId.Manufacturer[1], *TTwainData.sourceId.Manufacturer);
		return msg;
#else
	return (char *)TTwainData.sourceId.Manufacturer;
#endif
	}
	/*---------------------------------------------------------------------------*/
	char *TTWAIN_GetProductFamily(void)
	{
#ifdef MACOSX
		static char msg[1024];
		strncpy(msg, (const char *)&TTwainData.sourceId.ProductFamily[1], *TTwainData.sourceId.ProductFamily);
		return msg;
#else
	return (char *)TTwainData.sourceId.ProductFamily;
#endif
	}
	/*---------------------------------------------------------------------------*/
	char *TTWAIN_GetProductName(void)
	{
#ifdef MACOSX
		static char msg[1024];
		strncpy(msg, (const char *)&TTwainData.sourceId.ProductName[1], *TTwainData.sourceId.ProductName);
		return msg;
#else
	return (char *)TTwainData.sourceId.ProductName;
#endif
	}
	/*---------------------------------------------------------------------------*/
	char *TTWAIN_GetVersion(void)
	{
		static char version[5 + 1 + 5 + 1 + 32 + 1];
		sprintf(version, "%d.", TTwainData.sourceId.Version.MajorNum);
		sprintf(&version[strlen(version)], "%d ", TTwainData.sourceId.Version.MinorNum);
		strcat(version, (char *)TTwainData.sourceId.Version.Info);
		return version;
	}
	/*---------------------------------------------------------------------------*/
	char *TTWAIN_GetTwainVersion(void)
	{
		static char version[5 + 1 + 5 + 1];
		sprintf(version, "%d.%d", TTwainData.sourceId.ProtocolMajor,
				TTwainData.sourceId.ProtocolMinor);
		return version;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_GetSupportedCaps(void)
	{
		TW_ARRAY *container;
		TW_HANDLE handle = 0;
		int rc;
		TUINT32 size4data;

		TTwainData.isSupportedCapsSupported = FALSE;

#ifdef MACOSX_NO_PARAMS
		printf("%s always returns false (disabled at compile time)\n", __FUNCTION__);
		return FALSE;
/* PER ora su mac sono disabilitate! */
/*return FALSE;*/
#endif

		rc = TTWAIN_GetCap(CAP_SUPPORTEDCAPS, TWON_ARRAY, (void *)0, &size4data);
		if (!rc)
			return FALSE;
		if (!size4data)
			return FALSE;
		handle = GLOBAL_ALLOC(GMEM_FIXED, size4data);
		if (!handle)
			return FALSE;
		container = (TW_ARRAY *)GLOBAL_LOCK(handle);
		rc = TTWAIN_GetCap(CAP_SUPPORTEDCAPS, TWON_ARRAY, (void *)container, 0);
		if (rc) {
			/*
  MEMORY LEAK !!! ma per ora va bene cosi'...
  if (TTwainData.supportedCaps)
    GLOBAL_FREE(TTwainData.supportedCaps);
  */
			TTwainData.supportedCaps = container;
		}
		TTwainData.isSupportedCapsSupported = TRUE;
		return rc;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_GetCurrentPixelType(TTWAIN_PIXTYPE * pixType)
	{
		int rc1, rc2;
		TW_ONEVALUE pixelType, pixelFlavor;
		int i;
		rc1 = TTWAIN_GetCapCurrent(ICAP_PIXELTYPE, TWON_ONEVALUE, &pixelType, 0);
		if (!rc1)
			return FALSE;
		*pixType = TTWAIN_PIXUNKNOWN;
		if (pixelType.Item == TWPT_BW) {
			rc2 = TTWAIN_GetCapCurrent(ICAP_PIXELFLAVOR, TWON_ONEVALUE, &pixelFlavor, 0);
			if (!rc2)
				pixelFlavor.Item = TWPF_CHOCOLATE; /*this is the default */
		} else {
			pixelFlavor.Item = FLAVOR_UNUSED;
		}

		for (i = 0; i < TTWAIN_PIXTYPE_HOWMANY; i++) {
			if ((PixType[i].type == pixelType.Item) &&
				(PixType[i].flavor == pixelFlavor.Item)) {
				*pixType = (TTWAIN_PIXTYPE)i;
				return TRUE;
			}
		}
		return FALSE;
	}

	/*---------------------------------------------------------------------------*/
	/*    SUPPORTED CAPABILITIES                                                 */
	/*---------------------------------------------------------------------------*/
	static int TTWAIN_IsCapSupported(void *cap)
	{
#ifdef USA_LE_QUERY
		int queryRc;
		TW_UINT16 pattern;
		int et;
		queryRc = TTWAIN_GetCapQuery(*((TW_INT16 *)cap), &pattern);

		et = pattern & (TWQC_SET | TWQC_GET);
		return (TTwainData.isSupportedCapsSupported && queryRc && et) ||
			   (TTwainData.supportedCaps &&
				TTWAIN_IsItemInList(TTwainData.supportedCaps, cap,
									TTwainData.supportedCaps->NumItems,
									DCItemSize[TTwainData.supportedCaps->ItemType])) ||
			   (queryRc && et);
#else
	return TTwainData.isSupportedCapsSupported &&
		   (TTwainData.supportedCaps &&
			TTWAIN_IsItemInList(TTwainData.supportedCaps, cap,
								TTwainData.supportedCaps->NumItems,
								DCItemSize[TTwainData.supportedCaps->ItemType]));
#endif
	}
	/*---------------------------------------------------------------------------*/
	static int TTWAIN_IsCapSupportedTW_INT16(TW_INT16 cap)
	{
		return TTWAIN_IsCapSupported(&cap);
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_IsCapResolutionSupported(void)
	{
		TW_UINT16 cap = ICAP_XRESOLUTION;
		return TTWAIN_IsCapSupported(&cap);
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_IsCapOpticalResolutionSupported(void)
	{
		TW_UINT16 cap = ICAP_XNATIVERESOLUTION;
		return TTWAIN_IsCapSupported(&cap);
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_IsCapBrightnessSupported(void)
	{
		TW_UINT16 cap = ICAP_BRIGHTNESS;
		return TTWAIN_IsCapSupported(&cap);
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_IsCapContrastSupported(void)
	{
		TW_UINT16 cap = ICAP_CONTRAST;
		return TTWAIN_IsCapSupported(&cap);
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_IsCapThresholdSupported(void)
	{
		TW_UINT16 cap = ICAP_THRESHOLD;
		return TTWAIN_IsCapSupported(&cap);
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_IsCapPhysicalWidthSupported(void)
	{
		TW_UINT16 cap = ICAP_PHYSICALWIDTH;
		return TTWAIN_IsCapSupported(&cap);
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_IsCapPhysicalHeightSupported(void)
	{
		TW_UINT16 cap = ICAP_PHYSICALHEIGHT;
		return TTWAIN_IsCapSupported(&cap);
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_IsCapMinimumWidthSupported(void)
	{
		TW_UINT16 cap = ICAP_MINIMUMWIDTH;
		return TTWAIN_IsCapSupported(&cap);
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_IsCapMinimumHeightSupported(void)
	{
		TW_UINT16 cap = ICAP_MINIMUMHEIGHT;
		return TTWAIN_IsCapSupported(&cap);
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_IsCapPixelTypeSupported(void)
	{
		TW_UINT16 cap = ICAP_PIXELTYPE;
		return TTWAIN_IsCapSupported(&cap);
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_IsCapFeederSupported(void)
	{
		TW_UINT16 cap = CAP_FEEDERENABLED;
		return TTWAIN_IsCapSupported(&cap);
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_IsCapImageLayoutSupported(void)
	{
		/*assert(0);*/
		return TRUE;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_IsCapOrientationSupported(void)
	{
		TW_UINT16 cap = ICAP_ORIENTATION;
		return TTWAIN_IsCapSupported(&cap);
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_IsCapDeviceOnLineSupported(void)
	{
		TW_UINT16 cap = CAP_DEVICEONLINE;
		return TTWAIN_IsCapSupported(&cap);
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_IsCapBitDepthSupported(void)
	{
		TW_UINT16 cap = ICAP_BITDEPTH;
		return TTWAIN_IsCapSupported(&cap);
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_IsCapBitOrderSupported(void)
	{
		TW_UINT16 cap = ICAP_BITORDER;
		return TTWAIN_IsCapSupported(&cap);
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_IsCapCompressionSupported(void)
	{
		TW_UINT16 cap = ICAP_COMPRESSION;
		return TTWAIN_IsCapSupported(&cap);
	}
	/*---------------------------------------------------------------------------*/
	/*    SET CAPABILITIES				                             */
	/*---------------------------------------------------------------------------*/
	int TTWAIN_SetContrast(float contrast)
	{
		TW_FIX32 twfix = TTWAIN_FloatToFix32(contrast);
		return TTWAIN_SetCap(ICAP_CONTRAST, TWON_ONEVALUE, TWTY_FIX32, (TW_UINT32 *)&twfix);
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_SetBrightness(float brightness)
	{
		TW_FIX32 twfix = TTWAIN_FloatToFix32(brightness);
		return TTWAIN_SetCap(ICAP_BRIGHTNESS, TWON_ONEVALUE, TWTY_FIX32, (TW_UINT32 *)&twfix);
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_SetThreshold(float threshold)
	{
		TW_FIX32 twfix = TTWAIN_FloatToFix32(threshold);
		return TTWAIN_SetCap(ICAP_THRESHOLD, TWON_ONEVALUE, TWTY_FIX32, (TW_UINT32 *)&twfix);
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_SetResolution(float resolution)
	{
		int rc1, rc2;
		TW_FIX32 twfix = TTWAIN_FloatToFix32(resolution);
		rc1 = TTWAIN_SetCap(ICAP_XRESOLUTION, TWON_ONEVALUE, TWTY_FIX32, (TW_UINT32 *)&twfix);
		rc2 = TTWAIN_SetCap(ICAP_YRESOLUTION, TWON_ONEVALUE, TWTY_FIX32, (TW_UINT32 *)&twfix);
		return (rc1 & rc2);
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_SetXScaling(float scale)
	{
		int rc;
		TW_FIX32 twfix = TTWAIN_FloatToFix32(scale);
		rc = TTWAIN_SetCap(ICAP_XSCALING, TWON_ONEVALUE, TWTY_FIX32, (TW_UINT32 *)&twfix);
		return rc;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_SetYScaling(float scale)
	{
		int rc;
		TW_FIX32 twfix = TTWAIN_FloatToFix32(scale);
		rc = TTWAIN_SetCap(ICAP_YSCALING, TWON_ONEVALUE, TWTY_FIX32, (TW_UINT32 *)&twfix);
		return rc;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_SetPixelType(TTWAIN_PIXTYPE pixtype)
	{
		TUINT32 twPix;
		int rc, rc2, rc3, rc4, rc5, bdRc;
		TW_ENUMERATION *container = 0;
		TW_HANDLE handle = 0;

		TW_UINT16 twFlavor, twBitDepth;
		int found;
		TUINT32 size;

		twPix = PixType[pixtype].type;
		twFlavor = PixType[pixtype].flavor;
		twBitDepth = PixType[pixtype].bitDepth;
		/*the default in twain specs is chocolate*/
		TTwainData.transferInfo.nextImageNeedsToBeInverted = ((twFlavor !=
															   TWPF_CHOCOLATE) &&
															  (twFlavor !=
															   FLAVOR_UNUSED));

		rc = TTWAIN_SetCap(ICAP_PIXELTYPE, TWON_ONEVALUE, TWTY_UINT16, (TW_UINT32 *)&twPix);
		if (TTWAIN_IsCapBitDepthSupported())
			bdRc = TTWAIN_SetBitDepth(twBitDepth);

		if (rc) {
			if (twFlavor != FLAVOR_UNUSED) {
				rc2 = TTWAIN_GetCap(ICAP_PIXELFLAVOR, TWON_ENUMERATION, (void *)0, &size);
				if (rc2 && size) {
					handle = GLOBAL_ALLOC(GMEM_FIXED, size);
					if (!handle)
						return TRUE; /*non sono semplicamente riuscito a prendere info riguardo
	               il pixelFlavor, ma setPixelType e' andato a buon fine */
#ifdef _WIN32
					container = (TW_ENUMERATION *)handle;
#else
				container = (TW_ENUMERATION *)GLOBAL_LOCK(handle);
#endif
					rc3 = TTWAIN_GetCap(ICAP_PIXELFLAVOR, TWON_ENUMERATION, (void *)container, 0);
					if (rc3) {
						found = TTWAIN_IsItemInList(container->ItemList, &twFlavor,
													container->NumItems,
													DCItemSize[container->ItemType]);
						/*let's try to set....*/
						if (found) {
							rc4 = TTWAIN_SetCap(ICAP_PIXELFLAVOR, TWON_ONEVALUE, TWTY_UINT16, (TW_UINT32 *)&twFlavor);
							if (rc4) {
								TW_UINT16 current, *itemList;
								/*check if it's properly set...*/
								rc5 = TTWAIN_GetCap(ICAP_PIXELFLAVOR, TWON_ENUMERATION, (void *)container, 0);
								if (rc5) {
									itemList = (TW_UINT16 *)container->ItemList;
									current = itemList[container->CurrentIndex];
									if (current == twFlavor) {
										TTwainData.transferInfo.nextImageNeedsToBeInverted = FALSE;
									}
								}
							}
						}
					}
				}
			}
		}
		if (handle) {
			GLOBAL_UNLOCK(handle);
			GLOBAL_FREE(handle);
		}
		return rc;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_SetBitDepth(USHORT bitDepth)
	{
		TUINT32 bd = bitDepth;
		int rc;

		rc = TTWAIN_SetCap(ICAP_BITDEPTH, TWON_ONEVALUE, TWTY_UINT16, (TW_UINT32 *)&bd);
		return rc;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_SetBitOrder(TTWAIN_BITORDER bitOrder)
	{
		TUINT32 bo = bitOrder;
		int rc;

		rc = TTWAIN_SetCap(ICAP_BITORDER, TWON_ONEVALUE, TWTY_UINT16, (TW_UINT32 *)&bo);
		return rc;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_SetImageLayout(float L, float T, float R, float B)
	{
		TW_IMAGELAYOUT layout;
		TW_IMAGELAYOUT layout2;
		int rc;
		int rc2;

#ifdef MACOSX_NO_PARAMS
		printf("%s always returns true (disabled at compile time)\n", __FUNCTION__);
		return TRUE;
#endif
		/*
if (TTWAIN_GetState() != TWAIN_SOURCE_OPEN) 
  {
  TTWAIN_RecordError();
  return FALSE;
  }
*/
		layout.Frame.Left = TTWAIN_FloatToFix32(L);
		layout.Frame.Top = TTWAIN_FloatToFix32(T);
		layout.Frame.Right = TTWAIN_FloatToFix32(R);
		layout.Frame.Bottom = TTWAIN_FloatToFix32(B);

		layout.DocumentNumber = TWON_DONTCARE32;
		layout.PageNumber = TWON_DONTCARE32;
		layout.FrameNumber = TWON_DONTCARE32;
		rc = (TTWAIN_DS(DG_IMAGE, DAT_IMAGELAYOUT, MSG_SET, &layout) == TWRC_SUCCESS);
		rc2 = (TTWAIN_DS(DG_IMAGE, DAT_IMAGELAYOUT, MSG_GET, &layout2) == TWRC_SUCCESS);
		return rc;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_NegotiateXferCount(TUINT32 nXfers)
	{
#ifdef MACOSX_NO_PARAMS
		printf("%s always returns true (disabled at compile time)\n", __FUNCTION__);
		return TRUE;
#endif
		return TTWAIN_SetCap(CAP_XFERCOUNT, TWON_ONEVALUE, TWTY_INT16, (TW_UINT32 *)&nXfers);
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_SetXferMech(TTWAIN_TRANSFER_MECH mech, void *ptr, TUINT32 size,
						   int preferredLx, int preferredLy, TUINT32 numberOfImages)
	{
		TW_UINT32 theMech = mech;

		TTwainData.transferInfo.preferredLx = preferredLx;
		TTwainData.transferInfo.preferredLy = preferredLy;
		if (mech == TTWAIN_TRANSFERMODE_NATIVE) {
			/*assert(!ptr);*/
			/*invalidate mem  & len*/
			TTwainData.transferInfo.memorySize = -1;
			TTwainData.transferInfo.memoryBuffer = 0;
		} else {
			/*assert(ptr);*/
			/*store*/
			assert(!ptr); /* questo va rivisto, comunque NON si puo' fornire il buffer! */
			TTwainData.transferInfo.memorySize = size;
			TTwainData.transferInfo.memoryBuffer = (UCHAR *)ptr;
		}

		if (TTWAIN_SetCap(ICAP_XFERMECH, TWON_ONEVALUE, TWTY_UINT16, (TW_UINT32 *)&theMech)) {
			if (numberOfImages != -1)
				TTWAIN_NegotiateXferCount(numberOfImages);
			TTwainData.transferInfo.transferMech = mech;
			return TRUE;
		} else
			return FALSE;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_SetFeeder(int status) /* TRUE->enabled */
	{
		int rc;
		rc = TTWAIN_SetCap(CAP_FEEDERENABLED, TWON_ONEVALUE, TWTY_BOOL, (TW_UINT32 *)&status);
		/*
if (TTwainData.transferInfo.usageMode == TTWAIN_MODE_UNLEASHED)
  TTwainData.transferInfo.multiTransfer = status;
*/
		return rc;
	}
	/*---------------------------------------------------------------------------*/
	/*    USER INTERFACE							                                           */
	/*---------------------------------------------------------------------------*/
	int TTWAIN_HasControllableUI(void)
	{
		TW_ONEVALUE onevalue_data;
		int rc;
		rc = TTWAIN_GetCap(CAP_UICONTROLLABLE, TWON_ONEVALUE, (void *)&onevalue_data, 0);
		if (!rc)
			return FALSE;
		return (int)onevalue_data.Item;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_GetUIStatus(void)
	{
		return TTwainData.UIStatus;
	}
	/*---------------------------------------------------------------------------*/
	void TTWAIN_SetUIStatus(int status)
	{
		TTwainData.UIStatus = status;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_GetModalStatus(void)
	{
		return TTwainData.modalStatus;
	}
	/*---------------------------------------------------------------------------*/
	int TTWAIN_IsDeviceOnLine(void)/* -1 unknown, 0 no, 1 yes */
	{
		TW_ONEVALUE onevalue_data;
		int rc;
		rc = TTWAIN_GetCap(CAP_DEVICEONLINE, TWON_ONEVALUE, (void *)&onevalue_data, 0);
		if (!rc)
			return -1;
		return (int)onevalue_data.Item;
	}
	/*---------------------------------------------------------------------------*/
	/*    TWAIN AVAILABILITY					                                           */
	/*---------------------------------------------------------------------------*/
	int TTWAIN_IsAvailable(void)
	{
		TTWAIN_InitVar();
		if (TTWAIN_DSM_HasEntryPoint())
			return TRUE;

		if (TTwainData.twainAvailable == AVAIABLE_DONTKNOW)
			if (TTWAIN_LoadSourceManager())
				TTWAIN_UnloadSourceManager();
			else
				TTwainData.twainAvailable = AVAIABLE_NO;

		return (TTwainData.twainAvailable == AVAIABLE_YES);
	}
	/*---------------------------------------------------------------------------*/
	void TTWAIN_SetAvailable(TWAINAVAILABLE status)
	{
		TTwainData.twainAvailable = status;
	}
	/*---------------------------------------------------------------------------*/

	/*---------------------------------------------------------------------------*/
	/*    MISC AUX FUNCTIONS					                                           */
	/*---------------------------------------------------------------------------*/

	static float TTWAIN_GetMinValue(TW_RANGE range)
	{
		switch (range.ItemType) {
		case TWTY_INT8:
			__OR TWTY_INT16 : __OR TWTY_INT32 : __OR TWTY_UINT8 : __OR TWTY_UINT16 : return (float)range.MinValue;

			CASE TWTY_FIX32:
			{
				TW_FIX32 *fix32 = (TW_FIX32 *)&range.MinValue;
				return (float)TTWAIN_Fix32ToFloat(*fix32);
			}

		DEFAULT:
			/*
  TWTY_UINT32  
  TWTY_BOOL    
  TWTY_FRAME   
  TWTY_STR32   
  TWTY_STR64   
  TWTY_STR128  
  TWTY_STR255  
  */
			assert(!"Invalid type!!!");
			return 0;
		}
		return 0;
	}
	/*---------------------------------------------------------------------------*/
	static float TTWAIN_GetMaxValue(TW_RANGE range)
	{
		switch (range.ItemType) {
		case TWTY_INT8:
			__OR TWTY_INT16 : __OR TWTY_INT32 : __OR TWTY_UINT8 : __OR TWTY_UINT16 : return (float)range.MaxValue;

			CASE TWTY_FIX32:
			{
				TW_FIX32 *fix32 = (TW_FIX32 *)&range.MaxValue;
				return (float)TTWAIN_Fix32ToFloat(*fix32);
			}

		DEFAULT:
			/*
  TWTY_UINT32  
  TWTY_BOOL    
  TWTY_FRAME   
  TWTY_STR32   
  TWTY_STR64   
  TWTY_STR128  
  TWTY_STR255  
  */
			assert(!"Invalid type!!");
			return 0;
		}
		return 0;
	}
	/*---------------------------------------------------------------------------*/
	static float TTWAIN_GetDefValue(TW_RANGE range)
	{
		switch (range.ItemType) {
		case TWTY_INT8:
			__OR TWTY_INT16 : __OR TWTY_INT32 : __OR TWTY_UINT8 : __OR TWTY_UINT16 : return (float)range.DefaultValue;

			CASE TWTY_FIX32:
			{
				TW_FIX32 *fix32 = (TW_FIX32 *)&range.DefaultValue;
				return (float)TTWAIN_Fix32ToFloat(*fix32);
			}

		DEFAULT:
			/*
  TWTY_UINT32  
  TWTY_BOOL    
  TWTY_FRAME   
  TWTY_STR32   
  TWTY_STR64   
  TWTY_STR128  
  TWTY_STR255  
  */
			assert(!"Invalid type!!");
			return 0;
		}
		return 0;
	}
	/*---------------------------------------------------------------------------*/
	static float TTWAIN_GetStepValue(TW_RANGE range)
	{
		switch (range.ItemType) {
		case TWTY_INT8:
			__OR TWTY_INT16 : __OR TWTY_INT32 : __OR TWTY_UINT8 : __OR TWTY_UINT16 : return (float)range.StepSize;

			CASE TWTY_FIX32:
			{
				TW_FIX32 *fix32 = (TW_FIX32 *)&range.StepSize;
				return (float)TTWAIN_Fix32ToFloat(*fix32);
			}

		DEFAULT:
			/*
  TWTY_UINT32  
  TWTY_BOOL    
  TWTY_FRAME   
  TWTY_STR32   
  TWTY_STR64   
  TWTY_STR128  
  TWTY_STR255  
  */
			assert(!"Invalid type!!");
			return 0;
		}
		return 0;
	}
	/*---------------------------------------------------------------------------*/
	/*---------------------------------------------------------------------------*/
	/*---------------------------------------------------------------------------*/
	int TTWAIN_Native2Raster(void *handle, void *the_ras, int *lx, int *ly)
	{
		return TTWAIN_Native2RasterPD(handle, the_ras, lx, ly);
	}
	/*---------------------------------------------------------------------------*/
	static int TTWAIN_IsItemInList(void *list, void *item, TUINT32 list_count,
								   TUINT32 item_size)
	{
		int found = FALSE;
		TUINT32 count = list_count;
		UCHAR *pList = (UCHAR *)list;
		UCHAR *pItem = (UCHAR *)item;

		if (!list || !item)
			return FALSE;
		while (count--) {
			if (memcmp(pList, pItem, item_size) == 0) {
				found = TRUE;
				break;
			}
			pList += item_size;
		}
		return found;
	}
	/*---------------------------------------------------------------------------*/
	void TTWAIN_DumpCapabilities(void (*trace_fun)(const char *fmt, ...))
	{
		if (!trace_fun)
			return;
		trace_fun("list of supported (exported) capabilities\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_XFERCOUNT))
			trace_fun("CAP_XFERCOUNT");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_COMPRESSION))
			trace_fun("ICAP_COMPRESSION\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_PIXELTYPE))
			trace_fun("ICAP_PIXELTYPE\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_UNITS))
			trace_fun("ICAP_UNITS\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_XFERMECH))
			trace_fun("ICAP_XFERMECH\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_AUTHOR))
			trace_fun("CAP_AUTHOR\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_CAPTION))
			trace_fun("CAP_CAPTION\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_FEEDERENABLED))
			trace_fun("CAP_FEEDERENABLED\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_FEEDERLOADED))
			trace_fun("CAP_FEEDERLOADED\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_TIMEDATE))
			trace_fun("CAP_TIMEDATE\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_SUPPORTEDCAPS))
			trace_fun("CAP_SUPPORTEDCAPS\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_EXTENDEDCAPS))
			trace_fun("CAP_EXTENDEDCAPS\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_AUTOFEED))
			trace_fun("CAP_AUTOFEED\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_CLEARPAGE))
			trace_fun("CAP_CLEARPAGE\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_FEEDPAGE))
			trace_fun("CAP_FEEDPAGE\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_REWINDPAGE))
			trace_fun("CAP_REWINDPAGE\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_INDICATORS))
			trace_fun("CAP_INDICATORS\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_SUPPORTEDCAPSEXT))
			trace_fun("CAP_SUPPORTEDCAPSEXT\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_PAPERDETECTABLE))
			trace_fun("CAP_PAPERDETECTABLE\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_UICONTROLLABLE))
			trace_fun("CAP_UICONTROLLABLE\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_DEVICEONLINE))
			trace_fun("CAP_DEVICEONLINE\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_AUTOSCAN))
			trace_fun("CAP_AUTOSCAN\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_THUMBNAILSENABLED))
			trace_fun("CAP_THUMBNAILSENABLED\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_DUPLEX))
			trace_fun("CAP_DUPLEX\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_DUPLEXENABLED))
			trace_fun("CAP_DUPLEXENABLED\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_ENABLEDSUIONLY))
			trace_fun("CAP_ENABLEDSUIONLY\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_CUSTOMDSDATA))
			trace_fun("CAP_CUSTOMDSDATA\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_ENDORSER))
			trace_fun("CAP_ENDORSER\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_JOBCONTROL))
			trace_fun("CAP_JOBCONTROL\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_ALARMS))
			trace_fun("CAP_ALARMS\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_ALARMVOLUME))
			trace_fun("CAP_ALARMVOLUME\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_AUTOMATICCAPTURE))
			trace_fun("CAP_AUTOMATICCAPTURE\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_TIMEBEFOREFIRSTCAPTURE))
			trace_fun("CAP_TIMEBEFOREFIRSTCAPTURE\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_TIMEBETWEENCAPTURES))
			trace_fun("CAP_TIMEBETWEENCAPTURES\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_CLEARBUFFERS))
			trace_fun("CAP_CLEARBUFFERS\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_MAXBATCHBUFFERS))
			trace_fun("CAP_MAXBATCHBUFFERS\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_DEVICETIMEDATE))
			trace_fun("CAP_DEVICETIMEDATE\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_POWERSUPPLY))
			trace_fun("CAP_POWERSUPPLY\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_CAMERAPREVIEWUI))
			trace_fun("CAP_CAMERAPREVIEWUI\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_DEVICEEVENT))
			trace_fun("CAP_DEVICEEVENT\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_SERIALNUMBER))
			trace_fun("CAP_SERIALNUMBER\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_PRINTER))
			trace_fun("CAP_PRINTER\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_PRINTERENABLED))
			trace_fun("CAP_PRINTERENABLED\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_PRINTERINDEX))
			trace_fun("CAP_PRINTERINDEX\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_PRINTERMODE))
			trace_fun("CAP_PRINTERMODE\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_PRINTERSTRING))
			trace_fun("CAP_PRINTERSTRING\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_PRINTERSUFFIX))
			trace_fun("CAP_PRINTERSUFFIX\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_LANGUAGE))
			trace_fun("CAP_LANGUAGE\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_FEEDERALIGNMENT))
			trace_fun("CAP_FEEDERALIGNMENT\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_FEEDERORDER))
			trace_fun("CAP_FEEDERORDER\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_REACQUIREALLOWED))
			trace_fun("CAP_REACQUIREALLOWED\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_BATTERYMINUTES))
			trace_fun("CAP_BATTERYMINUTES\n");
		if (TTWAIN_IsCapSupportedTW_INT16(CAP_BATTERYPERCENTAGE))
			trace_fun("CAP_BATTERYPERCENTAGE\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_AUTOBRIGHT))
			trace_fun("ICAP_AUTOBRIGHT\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_BRIGHTNESS))
			trace_fun("ICAP_BRIGHTNESS\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_CONTRAST))
			trace_fun("ICAP_CONTRAST\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_CUSTHALFTONE))
			trace_fun("ICAP_CUSTHALFTONE\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_EXPOSURETIME))
			trace_fun("ICAP_EXPOSURETIME\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_FILTER))
			trace_fun("ICAP_FILTER\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_FLASHUSED))
			trace_fun("ICAP_FLASHUSED\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_GAMMA))
			trace_fun("ICAP_GAMMA\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_HALFTONES))
			trace_fun("ICAP_HALFTONES\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_HIGHLIGHT))
			trace_fun("ICAP_HIGHLIGHT\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_IMAGEFILEFORMAT))
			trace_fun("ICAP_IMAGEFILEFORMAT\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_LAMPSTATE))
			trace_fun("ICAP_LAMPSTATE\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_LIGHTSOURCE))
			trace_fun("ICAP_LIGHTSOURCE\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_ORIENTATION))
			trace_fun("ICAP_ORIENTATION\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_PHYSICALWIDTH))
			trace_fun("ICAP_PHYSICALWIDTH\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_PHYSICALHEIGHT))
			trace_fun("ICAP_PHYSICALHEIGHT\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_SHADOW))
			trace_fun("ICAP_SHADOW\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_FRAMES))
			trace_fun("ICAP_FRAMES\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_XNATIVERESOLUTION))
			trace_fun("ICAP_XNATIVERESOLUTION\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_YNATIVERESOLUTION))
			trace_fun("ICAP_YNATIVERESOLUTION\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_XRESOLUTION))
			trace_fun("ICAP_XRESOLUTION\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_YRESOLUTION))
			trace_fun("ICAP_YRESOLUTION\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_MAXFRAMES))
			trace_fun("ICAP_MAXFRAMES\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_TILES))
			trace_fun("ICAP_TILES\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_BITORDER))
			trace_fun("ICAP_BITORDER\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_CCITTKFACTOR))
			trace_fun("ICAP_CCITTKFACTOR\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_LIGHTPATH))
			trace_fun("ICAP_LIGHTPATH\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_PIXELFLAVOR))
			trace_fun("ICAP_PIXELFLAVOR\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_PLANARCHUNKY))
			trace_fun("ICAP_PLANARCHUNKY\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_ROTATION))
			trace_fun("ICAP_ROTATION\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_SUPPORTEDSIZES))
			trace_fun("ICAP_SUPPORTEDSIZES\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_THRESHOLD))
			trace_fun("ICAP_THRESHOLD\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_XSCALING))
			trace_fun("ICAP_XSCALING\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_YSCALING))
			trace_fun("ICAP_YSCALING\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_BITORDERCODES))
			trace_fun("ICAP_BITORDERCODES\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_PIXELFLAVORCODES))
			trace_fun("ICAP_PIXELFLAVORCODES\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_JPEGPIXELTYPE))
			trace_fun("ICAP_JPEGPIXELTYPE\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_TIMEFILL))
			trace_fun("ICAP_TIMEFILL\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_BITDEPTH))
			trace_fun("ICAP_BITDEPTH\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_BITDEPTHREDUCTION))
			trace_fun("ICAP_BITDEPTHREDUCTION\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_UNDEFINEDIMAGESIZE))
			trace_fun("ICAP_UNDEFINEDIMAGESIZE\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_IMAGEDATASET))
			trace_fun("ICAP_IMAGEDATASET\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_EXTIMAGEINFO))
			trace_fun("ICAP_EXTIMAGEINFO\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_MINIMUMHEIGHT))
			trace_fun("ICAP_MINIMUMHEIGHT\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_MINIMUMWIDTH))
			trace_fun("ICAP_MINIMUMWIDTH\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_FLIPROTATION))
			trace_fun("ICAP_FLIPROTATION\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_BARCODEDETECTIONENABLED))
			trace_fun("ICAP_BARCODEDETECTIONENABLED\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_SUPPORTEDBARCODETYPES))
			trace_fun("ICAP_SUPPORTEDBARCODETYPES\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_BARCODEMAXSEARCHPRIORITIES))
			trace_fun("ICAP_BARCODEMAXSEARCHPRIORITIES\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_BARCODESEARCHPRIORITIES))
			trace_fun("ICAP_BARCODESEARCHPRIORITIES\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_BARCODESEARCHMODE))
			trace_fun("ICAP_BARCODESEARCHMODE\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_BARCODEMAXRETRIES))
			trace_fun("ICAP_BARCODEMAXRETRIES\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_BARCODETIMEOUT))
			trace_fun("ICAP_BARCODETIMEOUT\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_ZOOMFACTOR))
			trace_fun("ICAP_ZOOMFACTOR\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_PATCHCODEDETECTIONENABLED))
			trace_fun("ICAP_PATCHCODEDETECTIONENABLED\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_SUPPORTEDPATCHCODETYPES))
			trace_fun("ICAP_SUPPORTEDPATCHCODETYPES\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_PATCHCODEMAXSEARCHPRIORITIES))
			trace_fun("ICAP_PATCHCODEMAXSEARCHPRIORITIES\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_PATCHCODESEARCHPRIORITIES))
			trace_fun("ICAP_PATCHCODESEARCHPRIORITIES\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_PATCHCODESEARCHMODE))
			trace_fun("ICAP_PATCHCODESEARCHMODE\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_PATCHCODEMAXRETRIES))
			trace_fun("ICAP_PATCHCODEMAXRETRIES\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_PATCHCODETIMEOUT))
			trace_fun("ICAP_PATCHCODETIMEOUT\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_FLASHUSED2))
			trace_fun("ICAP_FLASHUSED2\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_IMAGEFILTER))
			trace_fun("ICAP_IMAGEFILTER\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_NOISEFILTER))
			trace_fun("ICAP_NOISEFILTER\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_OVERSCAN))
			trace_fun("ICAP_OVERSCAN\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_AUTOMATICBORDERDETECTION))
			trace_fun("ICAP_AUTOMATICBORDERDETECTION\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_AUTOMATICDESKEW))
			trace_fun("ICAP_AUTOMATICDESKEW\n");
		if (TTWAIN_IsCapSupportedTW_INT16(ICAP_AUTOMATICROTATE))
			trace_fun("ICAP_AUTOMATICROTATE\n");
		trace_fun("end-of-list\n");
	}
	/*---------------------------------------------------------------------------*/
	/*---------------------------------------------------------------------------*/
	void TTWAIN_SetTwainUsage(TTWAIN_USAGE_MODE um)
	{
		TTwainData.transferInfo.usageMode = um;
	}
	/*---------------------------------------------------------------------------*/
	extern void registerTwainCallback();

	void TTWAIN_SetOnDoneCallback(TTWAIN_ONDONE_CB * proc, void *arg)
	{
		TTwainData.callback.onDoneCb = proc;
		TTwainData.callback.onDoneArg = arg;
#ifdef MACOSX
		registerTwainCallback();
#endif
	}
	/*---------------------------------------------------------------------------*/
	void TTWAIN_SetOnErrorCallback(TTWAIN_ONERROR_CB * proc, void *arg)
	{
		TTwainData.callback.onErrorCb = proc;
		TTwainData.callback.onErrorArg = arg;
	}
/*---------------------------------------------------------------------------*/

#ifdef __cplusplus
}
#endif