#ifdef _MSC_VER #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 #include #include #include #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; } /*---------------------------------------------------------------------------*/ /* 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: case TWTY_INT16: case TWTY_INT32: case TWTY_UINT8: case 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: case TWTY_INT16: case TWTY_INT32: case TWTY_UINT8: case 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: case TWTY_INT16: case TWTY_INT32: case TWTY_UINT8: case 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: case TWTY_INT16: case TWTY_INT32: case TWTY_UINT8: case 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