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

    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;

  }

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