#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></stdlib.h>

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

#include <stdio.h></stdio.h>

#include <assert.h></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)

	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;