1 
2 
3 #ifdef _MSC_VER
4 #pragma warning(disable : 4996)
5 #endif
6 
7 #ifdef NOTE
8 here
9 /*
10 TTWAIN_Get???Value (TW_RANGE range) restituisce sempre un float e (ovviamente)
11 funziona solo con gli item il cui sizeof() e' <= sizeof (float) (unica eccezione
12 TW_FIX32)
13 
14 USA_LE_QUERY: -> non definito!
15 Le query dovrebbero essere un modo per capire le azioni che sono permesse
16 su una determinata capability, questo sta scritto in twainSpec1.8:
17 nessun DS ha ritornato valori sensati, per cui non vengono usate.
18 */
19 #endif
20 
21 #include <stdlib.h>
22 #include <string.h>
23 #include <stdio.h>
24 
25 #include <assert.h>
26 
27 #include "ttwain_util.h"
28 #include "ttwain_utilP.h"
29 #include "ttwain_utilPD.h"
30 #include "ttwainP.h"
31 #include "ttwain.h"
32 #include "ttwain_state.h"
33 #include "ttwain_capability.h"
34 #include "ttwain_conversion.h"
35 #include "ttwain_error.h"
36 
37 #include "ttwain_global_def.h"
38 
39 /*
40 Scommentare MACOSX_NO_PARAMS, per evitare che l'applicazione abbia il controllo
41 dei parametri (Caps supportate, ImageLayout, XferCount)
42 Utile sotto MACOSX per evitare che i DS della HP si aprano alla richiesta,
43 e rimangano li.... in attesa di una scansione (tutto continua a funzionare,
44 alla prima scansione il DS si chiude correttamente e l'applicazione ottiene
45 l'immagine)
46 */
47 /*
48 #define MACOSX_NO_PARAMS
49 */
50 
51 #ifdef __cplusplus
52     extern "C" {
53 #endif
54 
55   /*#define USA_LE_QUERY*/
56   /* local  */
57   static int TTWAIN_GetPhysicalWidth(float *width);
58   static int TTWAIN_GetPhysicalHeight(float *height);
59 
60   static int TTWAIN_GetMinimumWidth(float *width);
61   static int TTWAIN_GetMinimumHeight(float *height);
62 
63   static int TTWAIN_IsCapSupported(void *cap);
64   static int TTWAIN_IsCapSupportedTW_INT16(TW_INT16 cap);
65 
66   /* MISC AUX FUNCTIONS */
67   static float TTWAIN_GetMinValue(TW_RANGE range);
68   static float TTWAIN_GetMaxValue(TW_RANGE range);
69   static float TTWAIN_GetDefValue(TW_RANGE range);
70   static float TTWAIN_GetStepValue(TW_RANGE range);
71   static int TTWAIN_IsItemInList(void *list, void *item, TUINT32 list_count,
72                                  TUINT32 item_size);
73 
74   static const size_t DCItemSize[13] = {
75       sizeof(TW_INT8),   sizeof(TW_INT16),  sizeof(TW_INT32), sizeof(TW_UINT8),
76       sizeof(TW_UINT16), sizeof(TW_UINT32), sizeof(TW_BOOL),  sizeof(TW_FIX32),
77       sizeof(TW_FRAME),  sizeof(TW_STR32),  sizeof(TW_STR64), sizeof(TW_STR128),
78       sizeof(TW_STR255),
79   }; /* see twain.h */
80 
81 #define FLAVOR_UNUSED (0xffff)
82 
83   struct TTWAIN_PIXELTYPEP {
84     TW_UINT16 type;
85     TW_UINT16 flavor;
86     TW_UINT16 bitDepth;
87   };
88   static struct TTWAIN_PIXELTYPEP PixType[TTWAIN_PIXTYPE_HOWMANY] = {
89       {TWPT_BW, TWPF_CHOCOLATE, 1},  /* BW    */
90       {TWPT_BW, TWPF_VANILLA, 1},    /* WB    */
91       {TWPT_GRAY, FLAVOR_UNUSED, 8}, /* GRAY8 */
92       {TWPT_RGB, FLAVOR_UNUSED, 24}  /* RGB24 */
93   };
94   /*---------------------------------------------------------------------------*/
95   /*    GET CAPABILITIES */
96   /*---------------------------------------------------------------------------*/
TTWAIN_GetResolution(float * min,float * max,float * step,float * def)97   int TTWAIN_GetResolution(float *min, float *max, float *step, float *def) {
98     TW_RANGE range_data;
99     int rc;
100 
101     if (!(min && max && step && def)) return FALSE;
102     rc = TTWAIN_GetCap(ICAP_XRESOLUTION, TWON_RANGE, (void *)&range_data, 0);
103     if (!rc) return FALSE;
104     *min  = TTWAIN_GetMinValue(range_data);
105     *max  = TTWAIN_GetMaxValue(range_data);
106     *step = TTWAIN_GetStepValue(range_data);
107     *def  = TTWAIN_GetDefValue(range_data);
108     return rc;
109   }
110   /*---------------------------------------------------------------------------*/
TTWAIN_GetOpticalResolution(float * min,float * max,float * step,float * def)111   int TTWAIN_GetOpticalResolution(float *min, float *max, float *step,
112                                   float *def) {
113     TW_RANGE range_data;
114     int rc;
115 
116     if (!(min && max && step && def)) return FALSE;
117     rc = TTWAIN_GetCap(ICAP_XNATIVERESOLUTION, TWON_RANGE, (void *)&range_data,
118                        0);
119     if (!rc) return FALSE;
120     *min  = TTWAIN_GetMinValue(range_data);
121     *max  = TTWAIN_GetMaxValue(range_data);
122     *step = TTWAIN_GetStepValue(range_data);
123     *def  = TTWAIN_GetDefValue(range_data);
124     return rc;
125   }
126   /*---------------------------------------------------------------------------*/
TTWAIN_GetBrightness(float * min,float * max,float * step,float * def)127   int TTWAIN_GetBrightness(float *min, float *max, float *step, float *def) {
128     TW_RANGE range_data;
129     int rc;
130 
131     assert(min && max && step && def);
132 
133     rc = TTWAIN_GetCap(ICAP_BRIGHTNESS, TWON_RANGE, (void *)&range_data, 0);
134     if (!rc) return FALSE;
135     *min  = TTWAIN_GetMinValue(range_data);
136     *max  = TTWAIN_GetMaxValue(range_data);
137     *step = TTWAIN_GetStepValue(range_data);
138     *def  = TTWAIN_GetDefValue(range_data);
139     return rc;
140   }
141   /*---------------------------------------------------------------------------*/
TTWAIN_GetContrast(float * min,float * max,float * step,float * def)142   int TTWAIN_GetContrast(float *min, float *max, float *step, float *def) {
143     TW_RANGE range_data;
144     int rc;
145 
146     assert(min && max && step && def);
147 
148     rc = TTWAIN_GetCap(ICAP_CONTRAST, TWON_RANGE, (void *)&range_data, 0);
149     if (!rc) return FALSE;
150     *min  = TTWAIN_GetMinValue(range_data);
151     *max  = TTWAIN_GetMaxValue(range_data);
152     *step = TTWAIN_GetStepValue(range_data);
153     *def  = TTWAIN_GetDefValue(range_data);
154     return rc;
155   }
156   /*---------------------------------------------------------------------------*/
TTWAIN_GetThreshold(float * min,float * max,float * step,float * def)157   int TTWAIN_GetThreshold(float *min, float *max, float *step, float *def) {
158     TW_RANGE range_data;
159     int rc;
160 
161     assert(min && max && step && def);
162 
163     rc = TTWAIN_GetCap(ICAP_THRESHOLD, TWON_RANGE, (void *)&range_data, 0);
164     if (!rc) return FALSE;
165     *min  = TTWAIN_GetMinValue(range_data);
166     *max  = TTWAIN_GetMaxValue(range_data);
167     *step = TTWAIN_GetStepValue(range_data);
168     *def  = TTWAIN_GetDefValue(range_data);
169     return rc;
170   }
171   /*---------------------------------------------------------------------------*/
TTWAIN_GetPhysicalWidth(float * width)172   static int TTWAIN_GetPhysicalWidth(float *width) {
173     TW_ONEVALUE width_data;
174     if (TTWAIN_GetCap(ICAP_PHYSICALWIDTH, TWON_ONEVALUE, (void *)&width_data,
175                       0)) {
176       *width = TTWAIN_Fix32ToFloat(*(TW_FIX32 *)&width_data.Item);
177       return TRUE;
178     } else
179       return FALSE;
180   }
181   /*---------------------------------------------------------------------------*/
TTWAIN_GetPhysicalHeight(float * height)182   static int TTWAIN_GetPhysicalHeight(float *height) {
183     TW_ONEVALUE height_data;
184     if (TTWAIN_GetCap(ICAP_PHYSICALHEIGHT, TWON_ONEVALUE, (void *)&height_data,
185                       0)) {
186       *height = TTWAIN_Fix32ToFloat(*(TW_FIX32 *)&height_data.Item);
187       return TRUE;
188     } else
189       return FALSE;
190   }
191   /*---------------------------------------------------------------------------*/
TTWAIN_GetMinimumWidth(float * width)192   static int TTWAIN_GetMinimumWidth(float *width) {
193     TW_ONEVALUE width_data;
194     if (TTWAIN_GetCap(ICAP_MINIMUMWIDTH, TWON_ONEVALUE, (void *)&width_data,
195                       0)) {
196       *width = TTWAIN_Fix32ToFloat(*(TW_FIX32 *)&width_data.Item);
197       return TRUE;
198     } else
199       return FALSE;
200   }
201   /*---------------------------------------------------------------------------*/
TTWAIN_GetMinimumHeight(float * height)202   static int TTWAIN_GetMinimumHeight(float *height) {
203     TW_ONEVALUE height_data;
204     if (TTWAIN_GetCap(ICAP_MINIMUMHEIGHT, TWON_ONEVALUE, (void *)&height_data,
205                       0)) {
206       *height = TTWAIN_Fix32ToFloat(*(TW_FIX32 *)&height_data.Item);
207       return TRUE;
208     } else
209       return FALSE;
210   }
211   /*---------------------------------------------------------------------------*/
TTWAIN_GetPhysicalWidthWAdf(float * width)212   int TTWAIN_GetPhysicalWidthWAdf(float *width) {
213     int rc = FALSE;
214     int feeder_status;
215 
216     if (TTWAIN_SupportsFeeder()) {
217       feeder_status = TTWAIN_GetFeeder();
218       rc            = TTWAIN_SetFeeder(TRUE);
219       if (rc) rc    = TTWAIN_GetPhysicalWidth(width);
220       TTWAIN_SetFeeder(feeder_status);
221     }
222     return rc;
223   }
224   /*---------------------------------------------------------------------------*/
TTWAIN_GetPhysicalHeightWAdf(float * height)225   int TTWAIN_GetPhysicalHeightWAdf(float *height) {
226     int rc = FALSE;
227     int feeder_status;
228 
229     if (TTWAIN_SupportsFeeder()) {
230       feeder_status = TTWAIN_GetFeeder();
231       rc            = TTWAIN_SetFeeder(TRUE);
232       if (rc) rc    = TTWAIN_GetPhysicalHeight(height);
233       TTWAIN_SetFeeder(feeder_status);
234     }
235     return rc;
236   }
237   /*---------------------------------------------------------------------------*/
TTWAIN_GetMinimumWidthWAdf(float * width)238   int TTWAIN_GetMinimumWidthWAdf(float *width) {
239     int rc = FALSE;
240     int feeder_status;
241 
242     if (TTWAIN_SupportsFeeder()) {
243       feeder_status = TTWAIN_GetFeeder();
244       rc            = TTWAIN_SetFeeder(TRUE);
245       if (rc) rc    = TTWAIN_GetMinimumWidth(width);
246       TTWAIN_SetFeeder(feeder_status);
247     }
248     return rc;
249   }
250   /*---------------------------------------------------------------------------*/
TTWAIN_GetMinimumHeightWAdf(float * height)251   int TTWAIN_GetMinimumHeightWAdf(float *height) {
252     int rc = FALSE;
253     int feeder_status;
254 
255     if (TTWAIN_SupportsFeeder()) {
256       feeder_status = TTWAIN_GetFeeder();
257       rc            = TTWAIN_SetFeeder(TRUE);
258       if (rc) rc    = TTWAIN_GetMinimumHeight(height);
259       TTWAIN_SetFeeder(feeder_status);
260     }
261     return rc;
262   }
263   /*---------------------------------------------------------------------------*/
TTWAIN_GetPhysicalWidthWoAdf(float * width)264   int TTWAIN_GetPhysicalWidthWoAdf(float *width) {
265     int rc            = FALSE;
266     int feeder_status = FALSE;
267 
268     if (TTWAIN_SupportsFeeder()) {
269       feeder_status = TTWAIN_GetFeeder();
270       rc            = TTWAIN_SetFeeder(FALSE);
271     }
272     rc = TTWAIN_GetPhysicalWidth(width);
273     if (TTWAIN_SupportsFeeder()) TTWAIN_SetFeeder(feeder_status);
274     return rc;
275   }
276   /*---------------------------------------------------------------------------*/
TTWAIN_GetPhysicalHeightWoAdf(float * height)277   int TTWAIN_GetPhysicalHeightWoAdf(float *height) {
278     int rc            = FALSE;
279     int feeder_status = FALSE;
280 
281     if (TTWAIN_SupportsFeeder()) {
282       feeder_status = TTWAIN_GetFeeder();
283       rc            = TTWAIN_SetFeeder(TRUE);
284     }
285     rc = TTWAIN_GetPhysicalHeight(height);
286     if (TTWAIN_SupportsFeeder()) TTWAIN_SetFeeder(feeder_status);
287     return rc;
288   }
289   /*---------------------------------------------------------------------------*/
TTWAIN_GetMinimumWidthWoAdf(float * width)290   int TTWAIN_GetMinimumWidthWoAdf(float *width) {
291     int rc            = FALSE;
292     int feeder_status = FALSE;
293 
294     if (TTWAIN_SupportsFeeder()) {
295       feeder_status = TTWAIN_GetFeeder();
296       rc            = TTWAIN_SetFeeder(FALSE);
297     }
298     rc = TTWAIN_GetMinimumWidth(width);
299     if (TTWAIN_SupportsFeeder()) TTWAIN_SetFeeder(feeder_status);
300     return rc;
301   }
302   /*---------------------------------------------------------------------------*/
TTWAIN_GetMinimumHeightWoAdf(float * height)303   int TTWAIN_GetMinimumHeightWoAdf(float *height) {
304     int rc            = FALSE;
305     int feeder_status = FALSE;
306 
307     if (TTWAIN_SupportsFeeder()) {
308       feeder_status = TTWAIN_GetFeeder();
309       rc            = TTWAIN_SetFeeder(TRUE);
310     }
311     rc = TTWAIN_GetMinimumHeight(height);
312     if (TTWAIN_SupportsFeeder()) TTWAIN_SetFeeder(feeder_status);
313     return rc;
314   }
315   /*---------------------------------------------------------------------------*/
TTWAIN_SupportsPixelType(TTWAIN_PIXTYPE pix_type)316   int TTWAIN_SupportsPixelType(TTWAIN_PIXTYPE pix_type) {
317     TW_HANDLE handle;
318     TW_ENUMERATION *container;
319     int rc, found = FALSE;
320     TUINT32 size4data;
321     TW_UINT16 twPix;
322 
323     twPix = PixType[pix_type].type;
324     rc = TTWAIN_GetCap(ICAP_PIXELTYPE, TWON_ENUMERATION, (void *)0, &size4data);
325     if (!rc) return FALSE;
326     if (!size4data) return FALSE;
327     handle = GLOBAL_ALLOC(GMEM_FIXED, size4data);
328     if (!handle) return FALSE;
329 
330     container = (TW_ENUMERATION *)GLOBAL_LOCK(handle);
331     rc = TTWAIN_GetCap(ICAP_PIXELTYPE, TWON_ENUMERATION, (void *)container, 0);
332 
333     if (!rc) goto done;
334     found =
335         TTWAIN_IsItemInList(container->ItemList, &twPix, container->NumItems,
336                             DCItemSize[container->ItemType]);
337 
338   done:
339     GLOBAL_UNLOCK(handle);
340     GLOBAL_FREE(handle);
341     return found;
342   }
343   /*---------------------------------------------------------------------------*/
TTWAIN_SupportsCompressionType(TW_UINT16 comprType)344   int TTWAIN_SupportsCompressionType(TW_UINT16 comprType) {
345     int rc;
346     TUINT32 size;
347     int found                 = FALSE;
348     TW_ENUMERATION *container = 0;
349     TW_HANDLE handle          = 0;
350 
351     if (!TTWAIN_IsCapCompressionSupported()) return FALSE;
352     rc = TTWAIN_GetCap(ICAP_COMPRESSION, TWON_ENUMERATION, (void *)0, &size);
353     if (!rc || !size) return FALSE;
354 
355     handle = GLOBAL_ALLOC(GMEM_FIXED, size);
356     if (!handle) return FALSE;
357 
358     container = (TW_ENUMERATION *)GLOBAL_LOCK(handle);
359 
360     rc =
361         TTWAIN_GetCap(ICAP_COMPRESSION, TWON_ENUMERATION, (void *)container, 0);
362 
363     if (!rc) goto done;
364     found = TTWAIN_IsItemInList(container->ItemList, &comprType,
365                                 container->NumItems,
366                                 DCItemSize[container->ItemType]);
367     found = TRUE;
368   done:
369     if (handle) {
370       GLOBAL_UNLOCK(handle);
371       GLOBAL_FREE(handle);
372     }
373     return found;
374   }
375   /*---------------------------------------------------------------------------*/
TTWAIN_SupportsFeeder(void)376   int TTWAIN_SupportsFeeder(void) {
377     TW_ONEVALUE feeder;
378     int rc;
379     feeder.Item = 0;
380     rc = TTWAIN_GetCap(CAP_FEEDERENABLED, TWON_ONEVALUE, (void *)&feeder, 0);
381     return rc;
382   }
383   /*---------------------------------------------------------------------------*/
TTWAIN_GetFeeder(void)384   int TTWAIN_GetFeeder(void) /* TRUE->enabled */
385   {
386     TW_ONEVALUE feeder;
387     int rc;
388     feeder.Item = 0;
389     rc = TTWAIN_GetCap(CAP_FEEDERENABLED, TWON_ONEVALUE, (void *)&feeder, 0);
390     return feeder.Item && rc;
391   }
392   /*---------------------------------------------------------------------------*/
TTWAIN_IsFeederLoaded(void)393   int TTWAIN_IsFeederLoaded(void) /* TRUE->loaded */
394   {
395     TW_ONEVALUE feeder;
396     int rc;
397 
398 #ifdef MACOSX_NO_PARAMS
399     printf("%s always returns false (disabled at compile time)\n",
400            __FUNCTION__);
401     return FALSE;
402 #endif
403 
404     feeder.Item = 0;
405     rc = TTWAIN_GetCap(CAP_FEEDERLOADED, TWON_ONEVALUE, (void *)&feeder, 0);
406     return feeder.Item && rc;
407   }
408   /*---------------------------------------------------------------------------*/
TTWAIN_GetManufacturer(void)409   char *TTWAIN_GetManufacturer(void) {
410 #ifdef MACOSX
411     static char msg[1024];
412     strncpy(msg, (const char *)&TTwainData.sourceId.Manufacturer[1],
413             *TTwainData.sourceId.Manufacturer);
414     return msg;
415 #else
416   return (char *)TTwainData.sourceId.Manufacturer;
417 #endif
418   }
419   /*---------------------------------------------------------------------------*/
TTWAIN_GetProductFamily(void)420   char *TTWAIN_GetProductFamily(void) {
421 #ifdef MACOSX
422     static char msg[1024];
423     strncpy(msg, (const char *)&TTwainData.sourceId.ProductFamily[1],
424             *TTwainData.sourceId.ProductFamily);
425     return msg;
426 #else
427   return (char *)TTwainData.sourceId.ProductFamily;
428 #endif
429   }
430   /*---------------------------------------------------------------------------*/
TTWAIN_GetProductName(void)431   char *TTWAIN_GetProductName(void) {
432 #ifdef MACOSX
433     static char msg[1024];
434     strncpy(msg, (const char *)&TTwainData.sourceId.ProductName[1],
435             *TTwainData.sourceId.ProductName);
436     return msg;
437 #else
438   return (char *)TTwainData.sourceId.ProductName;
439 #endif
440   }
441   /*---------------------------------------------------------------------------*/
TTWAIN_GetVersion(void)442   char *TTWAIN_GetVersion(void) {
443     static char version[5 + 1 + 5 + 1 + 32 + 1];
444     snprintf(version, sizeof(version), "%d.%d %s",
445              TTwainData.sourceId.Version.MajorNum,
446 	     TTwainData.sourceId.Version.MinorNum,
447 	     (char *)TTwainData.sourceId.Version.Info);
448     return version;
449   }
450   /*---------------------------------------------------------------------------*/
TTWAIN_GetTwainVersion(void)451   char *TTWAIN_GetTwainVersion(void) {
452     static char version[5 + 1 + 5 + 1];
453     snprintf(version, sizeof(version), "%d.%d",
454              TTwainData.sourceId.ProtocolMajor,
455              TTwainData.sourceId.ProtocolMinor);
456     return version;
457   }
458   /*---------------------------------------------------------------------------*/
TTWAIN_GetSupportedCaps(void)459   int TTWAIN_GetSupportedCaps(void) {
460     TW_ARRAY *container;
461     TW_HANDLE handle = 0;
462     int rc;
463     TUINT32 size4data;
464 
465     TTwainData.isSupportedCapsSupported = FALSE;
466 
467 #ifdef MACOSX_NO_PARAMS
468     printf("%s always returns false (disabled at compile time)\n",
469            __FUNCTION__);
470     return FALSE;
471 /* PER ora su mac sono disabilitate! */
472 /*return FALSE;*/
473 #endif
474 
475     rc = TTWAIN_GetCap(CAP_SUPPORTEDCAPS, TWON_ARRAY, (void *)0, &size4data);
476     if (!rc) return FALSE;
477     if (!size4data) return FALSE;
478     handle = GLOBAL_ALLOC(GMEM_FIXED, size4data);
479     if (!handle) return FALSE;
480     container = (TW_ARRAY *)GLOBAL_LOCK(handle);
481     rc = TTWAIN_GetCap(CAP_SUPPORTEDCAPS, TWON_ARRAY, (void *)container, 0);
482     if (rc) {
483       /*
484 MEMORY LEAK !!! ma per ora va bene cosi'...
485 if (TTwainData.supportedCaps)
486 GLOBAL_FREE(TTwainData.supportedCaps);
487 */
488       TTwainData.supportedCaps = container;
489     }
490     TTwainData.isSupportedCapsSupported = TRUE;
491     return rc;
492   }
493   /*---------------------------------------------------------------------------*/
TTWAIN_GetCurrentPixelType(TTWAIN_PIXTYPE * pixType)494   int TTWAIN_GetCurrentPixelType(TTWAIN_PIXTYPE * pixType) {
495     int rc1, rc2;
496     TW_ONEVALUE pixelType, pixelFlavor;
497     int i;
498     rc1 = TTWAIN_GetCapCurrent(ICAP_PIXELTYPE, TWON_ONEVALUE, &pixelType, 0);
499     if (!rc1) return FALSE;
500     *pixType = TTWAIN_PIXUNKNOWN;
501     if (pixelType.Item == TWPT_BW) {
502       rc2 = TTWAIN_GetCapCurrent(ICAP_PIXELFLAVOR, TWON_ONEVALUE, &pixelFlavor,
503                                  0);
504       if (!rc2) pixelFlavor.Item = TWPF_CHOCOLATE; /*this is the default */
505     } else {
506       pixelFlavor.Item = FLAVOR_UNUSED;
507     }
508 
509     for (i = 0; i < TTWAIN_PIXTYPE_HOWMANY; i++) {
510       if ((PixType[i].type == pixelType.Item) &&
511           (PixType[i].flavor == pixelFlavor.Item)) {
512         *pixType = (TTWAIN_PIXTYPE)i;
513         return TRUE;
514       }
515     }
516     return FALSE;
517   }
518 
519   /*---------------------------------------------------------------------------*/
520   /*    SUPPORTED CAPABILITIES */
521   /*---------------------------------------------------------------------------*/
TTWAIN_IsCapSupported(void * cap)522   static int TTWAIN_IsCapSupported(void *cap) {
523 #ifdef USA_LE_QUERY
524     int queryRc;
525     TW_UINT16 pattern;
526     int et;
527     queryRc = TTWAIN_GetCapQuery(*((TW_INT16 *)cap), &pattern);
528 
529     et = pattern & (TWQC_SET | TWQC_GET);
530     return (TTwainData.isSupportedCapsSupported && queryRc && et) ||
531            (TTwainData.supportedCaps &&
532             TTWAIN_IsItemInList(
533                 TTwainData.supportedCaps, cap,
534                 TTwainData.supportedCaps->NumItems,
535                 DCItemSize[TTwainData.supportedCaps->ItemType])) ||
536            (queryRc && et);
537 #else
538   return TTwainData.isSupportedCapsSupported &&
539          (TTwainData.supportedCaps &&
540           TTWAIN_IsItemInList(TTwainData.supportedCaps, cap,
541                               TTwainData.supportedCaps->NumItems,
542                               DCItemSize[TTwainData.supportedCaps->ItemType]));
543 #endif
544   }
545   /*---------------------------------------------------------------------------*/
TTWAIN_IsCapSupportedTW_INT16(TW_INT16 cap)546   static int TTWAIN_IsCapSupportedTW_INT16(TW_INT16 cap) {
547     return TTWAIN_IsCapSupported(&cap);
548   }
549   /*---------------------------------------------------------------------------*/
TTWAIN_IsCapResolutionSupported(void)550   int TTWAIN_IsCapResolutionSupported(void) {
551     TW_UINT16 cap = ICAP_XRESOLUTION;
552     return TTWAIN_IsCapSupported(&cap);
553   }
554   /*---------------------------------------------------------------------------*/
TTWAIN_IsCapOpticalResolutionSupported(void)555   int TTWAIN_IsCapOpticalResolutionSupported(void) {
556     TW_UINT16 cap = ICAP_XNATIVERESOLUTION;
557     return TTWAIN_IsCapSupported(&cap);
558   }
559   /*---------------------------------------------------------------------------*/
TTWAIN_IsCapBrightnessSupported(void)560   int TTWAIN_IsCapBrightnessSupported(void) {
561     TW_UINT16 cap = ICAP_BRIGHTNESS;
562     return TTWAIN_IsCapSupported(&cap);
563   }
564   /*---------------------------------------------------------------------------*/
TTWAIN_IsCapContrastSupported(void)565   int TTWAIN_IsCapContrastSupported(void) {
566     TW_UINT16 cap = ICAP_CONTRAST;
567     return TTWAIN_IsCapSupported(&cap);
568   }
569   /*---------------------------------------------------------------------------*/
TTWAIN_IsCapThresholdSupported(void)570   int TTWAIN_IsCapThresholdSupported(void) {
571     TW_UINT16 cap = ICAP_THRESHOLD;
572     return TTWAIN_IsCapSupported(&cap);
573   }
574   /*---------------------------------------------------------------------------*/
TTWAIN_IsCapPhysicalWidthSupported(void)575   int TTWAIN_IsCapPhysicalWidthSupported(void) {
576     TW_UINT16 cap = ICAP_PHYSICALWIDTH;
577     return TTWAIN_IsCapSupported(&cap);
578   }
579   /*---------------------------------------------------------------------------*/
TTWAIN_IsCapPhysicalHeightSupported(void)580   int TTWAIN_IsCapPhysicalHeightSupported(void) {
581     TW_UINT16 cap = ICAP_PHYSICALHEIGHT;
582     return TTWAIN_IsCapSupported(&cap);
583   }
584   /*---------------------------------------------------------------------------*/
TTWAIN_IsCapMinimumWidthSupported(void)585   int TTWAIN_IsCapMinimumWidthSupported(void) {
586     TW_UINT16 cap = ICAP_MINIMUMWIDTH;
587     return TTWAIN_IsCapSupported(&cap);
588   }
589   /*---------------------------------------------------------------------------*/
TTWAIN_IsCapMinimumHeightSupported(void)590   int TTWAIN_IsCapMinimumHeightSupported(void) {
591     TW_UINT16 cap = ICAP_MINIMUMHEIGHT;
592     return TTWAIN_IsCapSupported(&cap);
593   }
594   /*---------------------------------------------------------------------------*/
TTWAIN_IsCapPixelTypeSupported(void)595   int TTWAIN_IsCapPixelTypeSupported(void) {
596     TW_UINT16 cap = ICAP_PIXELTYPE;
597     return TTWAIN_IsCapSupported(&cap);
598   }
599   /*---------------------------------------------------------------------------*/
TTWAIN_IsCapFeederSupported(void)600   int TTWAIN_IsCapFeederSupported(void) {
601     TW_UINT16 cap = CAP_FEEDERENABLED;
602     return TTWAIN_IsCapSupported(&cap);
603   }
604   /*---------------------------------------------------------------------------*/
TTWAIN_IsCapImageLayoutSupported(void)605   int TTWAIN_IsCapImageLayoutSupported(void) {
606     /*assert(0);*/
607     return TRUE;
608   }
609   /*---------------------------------------------------------------------------*/
TTWAIN_IsCapOrientationSupported(void)610   int TTWAIN_IsCapOrientationSupported(void) {
611     TW_UINT16 cap = ICAP_ORIENTATION;
612     return TTWAIN_IsCapSupported(&cap);
613   }
614   /*---------------------------------------------------------------------------*/
TTWAIN_IsCapDeviceOnLineSupported(void)615   int TTWAIN_IsCapDeviceOnLineSupported(void) {
616     TW_UINT16 cap = CAP_DEVICEONLINE;
617     return TTWAIN_IsCapSupported(&cap);
618   }
619   /*---------------------------------------------------------------------------*/
TTWAIN_IsCapBitDepthSupported(void)620   int TTWAIN_IsCapBitDepthSupported(void) {
621     TW_UINT16 cap = ICAP_BITDEPTH;
622     return TTWAIN_IsCapSupported(&cap);
623   }
624   /*---------------------------------------------------------------------------*/
TTWAIN_IsCapBitOrderSupported(void)625   int TTWAIN_IsCapBitOrderSupported(void) {
626     TW_UINT16 cap = ICAP_BITORDER;
627     return TTWAIN_IsCapSupported(&cap);
628   }
629   /*---------------------------------------------------------------------------*/
TTWAIN_IsCapCompressionSupported(void)630   int TTWAIN_IsCapCompressionSupported(void) {
631     TW_UINT16 cap = ICAP_COMPRESSION;
632     return TTWAIN_IsCapSupported(&cap);
633   }
634   /*---------------------------------------------------------------------------*/
635   /*    SET CAPABILITIES */
636   /*---------------------------------------------------------------------------*/
TTWAIN_SetContrast(float contrast)637   int TTWAIN_SetContrast(float contrast) {
638     TW_FIX32 twfix = TTWAIN_FloatToFix32(contrast);
639     return TTWAIN_SetCap(ICAP_CONTRAST, TWON_ONEVALUE, TWTY_FIX32,
640                          (TW_UINT32 *)&twfix);
641   }
642   /*---------------------------------------------------------------------------*/
TTWAIN_SetBrightness(float brightness)643   int TTWAIN_SetBrightness(float brightness) {
644     TW_FIX32 twfix = TTWAIN_FloatToFix32(brightness);
645     return TTWAIN_SetCap(ICAP_BRIGHTNESS, TWON_ONEVALUE, TWTY_FIX32,
646                          (TW_UINT32 *)&twfix);
647   }
648   /*---------------------------------------------------------------------------*/
TTWAIN_SetThreshold(float threshold)649   int TTWAIN_SetThreshold(float threshold) {
650     TW_FIX32 twfix = TTWAIN_FloatToFix32(threshold);
651     return TTWAIN_SetCap(ICAP_THRESHOLD, TWON_ONEVALUE, TWTY_FIX32,
652                          (TW_UINT32 *)&twfix);
653   }
654   /*---------------------------------------------------------------------------*/
TTWAIN_SetResolution(float resolution)655   int TTWAIN_SetResolution(float resolution) {
656     int rc1, rc2;
657     TW_FIX32 twfix = TTWAIN_FloatToFix32(resolution);
658     rc1            = TTWAIN_SetCap(ICAP_XRESOLUTION, TWON_ONEVALUE, TWTY_FIX32,
659                         (TW_UINT32 *)&twfix);
660     rc2 = TTWAIN_SetCap(ICAP_YRESOLUTION, TWON_ONEVALUE, TWTY_FIX32,
661                         (TW_UINT32 *)&twfix);
662     return (rc1 & rc2);
663   }
664   /*---------------------------------------------------------------------------*/
TTWAIN_SetXScaling(float scale)665   int TTWAIN_SetXScaling(float scale) {
666     int rc;
667     TW_FIX32 twfix = TTWAIN_FloatToFix32(scale);
668     rc             = TTWAIN_SetCap(ICAP_XSCALING, TWON_ONEVALUE, TWTY_FIX32,
669                        (TW_UINT32 *)&twfix);
670     return rc;
671   }
672   /*---------------------------------------------------------------------------*/
TTWAIN_SetYScaling(float scale)673   int TTWAIN_SetYScaling(float scale) {
674     int rc;
675     TW_FIX32 twfix = TTWAIN_FloatToFix32(scale);
676     rc             = TTWAIN_SetCap(ICAP_YSCALING, TWON_ONEVALUE, TWTY_FIX32,
677                        (TW_UINT32 *)&twfix);
678     return rc;
679   }
680   /*---------------------------------------------------------------------------*/
TTWAIN_SetPixelType(TTWAIN_PIXTYPE pixtype)681   int TTWAIN_SetPixelType(TTWAIN_PIXTYPE pixtype) {
682     TUINT32 twPix;
683     int rc, rc2, rc3, rc4, rc5, bdRc;
684     TW_ENUMERATION *container = 0;
685     TW_HANDLE handle          = 0;
686 
687     TW_UINT16 twFlavor, twBitDepth;
688     int found;
689     TUINT32 size;
690 
691     twPix      = PixType[pixtype].type;
692     twFlavor   = PixType[pixtype].flavor;
693     twBitDepth = PixType[pixtype].bitDepth;
694     /*the default in twain specs is chocolate*/
695     TTwainData.transferInfo.nextImageNeedsToBeInverted =
696         ((twFlavor != TWPF_CHOCOLATE) && (twFlavor != FLAVOR_UNUSED));
697 
698     rc = TTWAIN_SetCap(ICAP_PIXELTYPE, TWON_ONEVALUE, TWTY_UINT16,
699                        (TW_UINT32 *)&twPix);
700     if (TTWAIN_IsCapBitDepthSupported()) bdRc = TTWAIN_SetBitDepth(twBitDepth);
701 
702     if (rc) {
703       if (twFlavor != FLAVOR_UNUSED) {
704         rc2 =
705             TTWAIN_GetCap(ICAP_PIXELFLAVOR, TWON_ENUMERATION, (void *)0, &size);
706         if (rc2 && size) {
707           handle = GLOBAL_ALLOC(GMEM_FIXED, size);
708           if (!handle)
709             return TRUE; /*non sono semplicamente riuscito a prendere info
710 riguardo
711 il pixelFlavor, ma setPixelType e' andato a buon fine */
712 #ifdef _WIN32
713           container = (TW_ENUMERATION *)handle;
714 #else
715         container = (TW_ENUMERATION *)GLOBAL_LOCK(handle);
716 #endif
717           rc3 = TTWAIN_GetCap(ICAP_PIXELFLAVOR, TWON_ENUMERATION,
718                               (void *)container, 0);
719           if (rc3) {
720             found = TTWAIN_IsItemInList(container->ItemList, &twFlavor,
721                                         container->NumItems,
722                                         DCItemSize[container->ItemType]);
723             /*let's try to set....*/
724             if (found) {
725               rc4 = TTWAIN_SetCap(ICAP_PIXELFLAVOR, TWON_ONEVALUE, TWTY_UINT16,
726                                   (TW_UINT32 *)&twFlavor);
727               if (rc4) {
728                 TW_UINT16 current, *itemList;
729                 /*check if it's properly set...*/
730                 rc5 = TTWAIN_GetCap(ICAP_PIXELFLAVOR, TWON_ENUMERATION,
731                                     (void *)container, 0);
732                 if (rc5) {
733                   itemList = (TW_UINT16 *)container->ItemList;
734                   current  = itemList[container->CurrentIndex];
735                   if (current == twFlavor) {
736                     TTwainData.transferInfo.nextImageNeedsToBeInverted = FALSE;
737                   }
738                 }
739               }
740             }
741           }
742         }
743       }
744     }
745     if (handle) {
746       GLOBAL_UNLOCK(handle);
747       GLOBAL_FREE(handle);
748     }
749     return rc;
750   }
751   /*---------------------------------------------------------------------------*/
TTWAIN_SetBitDepth(USHORT bitDepth)752   int TTWAIN_SetBitDepth(USHORT bitDepth) {
753     TUINT32 bd = bitDepth;
754     int rc;
755 
756     rc = TTWAIN_SetCap(ICAP_BITDEPTH, TWON_ONEVALUE, TWTY_UINT16,
757                        (TW_UINT32 *)&bd);
758     return rc;
759   }
760   /*---------------------------------------------------------------------------*/
TTWAIN_SetBitOrder(TTWAIN_BITORDER bitOrder)761   int TTWAIN_SetBitOrder(TTWAIN_BITORDER bitOrder) {
762     TUINT32 bo = bitOrder;
763     int rc;
764 
765     rc = TTWAIN_SetCap(ICAP_BITORDER, TWON_ONEVALUE, TWTY_UINT16,
766                        (TW_UINT32 *)&bo);
767     return rc;
768   }
769   /*---------------------------------------------------------------------------*/
TTWAIN_SetImageLayout(float L,float T,float R,float B)770   int TTWAIN_SetImageLayout(float L, float T, float R, float B) {
771     TW_IMAGELAYOUT layout;
772     TW_IMAGELAYOUT layout2;
773     int rc;
774     int rc2;
775 
776 #ifdef MACOSX_NO_PARAMS
777     printf("%s always returns true (disabled at compile time)\n", __FUNCTION__);
778     return TRUE;
779 #endif
780     /*
781 if (TTWAIN_GetState() != TWAIN_SOURCE_OPEN)
782 {
783 TTWAIN_RecordError();
784 return FALSE;
785 }
786 */
787     layout.Frame.Left   = TTWAIN_FloatToFix32(L);
788     layout.Frame.Top    = TTWAIN_FloatToFix32(T);
789     layout.Frame.Right  = TTWAIN_FloatToFix32(R);
790     layout.Frame.Bottom = TTWAIN_FloatToFix32(B);
791 
792     layout.DocumentNumber = TWON_DONTCARE32;
793     layout.PageNumber     = TWON_DONTCARE32;
794     layout.FrameNumber    = TWON_DONTCARE32;
795     rc = (TTWAIN_DS(DG_IMAGE, DAT_IMAGELAYOUT, MSG_SET, &layout) ==
796           TWRC_SUCCESS);
797     rc2 = (TTWAIN_DS(DG_IMAGE, DAT_IMAGELAYOUT, MSG_GET, &layout2) ==
798            TWRC_SUCCESS);
799     return rc;
800   }
801   /*---------------------------------------------------------------------------*/
TTWAIN_NegotiateXferCount(TUINT32 nXfers)802   int TTWAIN_NegotiateXferCount(TUINT32 nXfers) {
803 #ifdef MACOSX_NO_PARAMS
804     printf("%s always returns true (disabled at compile time)\n", __FUNCTION__);
805     return TRUE;
806 #endif
807     return TTWAIN_SetCap(CAP_XFERCOUNT, TWON_ONEVALUE, TWTY_INT16,
808                          (TW_UINT32 *)&nXfers);
809   }
810   /*---------------------------------------------------------------------------*/
TTWAIN_SetXferMech(TTWAIN_TRANSFER_MECH mech,void * ptr,TUINT32 size,int preferredLx,int preferredLy,TUINT32 numberOfImages)811   int TTWAIN_SetXferMech(TTWAIN_TRANSFER_MECH mech, void *ptr, TUINT32 size,
812                          int preferredLx, int preferredLy,
813                          TUINT32 numberOfImages) {
814     TW_UINT32 theMech = mech;
815 
816     TTwainData.transferInfo.preferredLx = preferredLx;
817     TTwainData.transferInfo.preferredLy = preferredLy;
818     if (mech == TTWAIN_TRANSFERMODE_NATIVE) {
819       /*assert(!ptr);*/
820       /*invalidate mem  & len*/
821       TTwainData.transferInfo.memorySize   = -1;
822       TTwainData.transferInfo.memoryBuffer = 0;
823     } else {
824       /*assert(ptr);*/
825       /*store*/
826       assert(!ptr); /* questo va rivisto, comunque NON si puo' fornire il
827                        buffer! */
828       TTwainData.transferInfo.memorySize   = size;
829       TTwainData.transferInfo.memoryBuffer = (UCHAR *)ptr;
830     }
831 
832     if (TTWAIN_SetCap(ICAP_XFERMECH, TWON_ONEVALUE, TWTY_UINT16,
833                       (TW_UINT32 *)&theMech)) {
834       if (numberOfImages != -1) TTWAIN_NegotiateXferCount(numberOfImages);
835       TTwainData.transferInfo.transferMech = mech;
836       return TRUE;
837     } else
838       return FALSE;
839   }
840   /*---------------------------------------------------------------------------*/
TTWAIN_SetFeeder(int status)841   int TTWAIN_SetFeeder(int status) /* TRUE->enabled */
842   {
843     int rc;
844     rc = TTWAIN_SetCap(CAP_FEEDERENABLED, TWON_ONEVALUE, TWTY_BOOL,
845                        (TW_UINT32 *)&status);
846     /*
847 if (TTwainData.transferInfo.usageMode == TTWAIN_MODE_UNLEASHED)
848 TTwainData.transferInfo.multiTransfer = status;
849 */
850     return rc;
851   }
852   /*---------------------------------------------------------------------------*/
853   /*    USER INTERFACE */
854   /*---------------------------------------------------------------------------*/
TTWAIN_HasControllableUI(void)855   int TTWAIN_HasControllableUI(void) {
856     TW_ONEVALUE onevalue_data;
857     int rc;
858     rc = TTWAIN_GetCap(CAP_UICONTROLLABLE, TWON_ONEVALUE,
859                        (void *)&onevalue_data, 0);
860     if (!rc) return FALSE;
861     return (int)onevalue_data.Item;
862   }
863   /*---------------------------------------------------------------------------*/
TTWAIN_GetUIStatus(void)864   int TTWAIN_GetUIStatus(void) { return TTwainData.UIStatus; }
865   /*---------------------------------------------------------------------------*/
TTWAIN_SetUIStatus(int status)866   void TTWAIN_SetUIStatus(int status) { TTwainData.UIStatus = status; }
867   /*---------------------------------------------------------------------------*/
TTWAIN_GetModalStatus(void)868   int TTWAIN_GetModalStatus(void) { return TTwainData.modalStatus; }
869   /*---------------------------------------------------------------------------*/
TTWAIN_IsDeviceOnLine(void)870   int TTWAIN_IsDeviceOnLine(void) /* -1 unknown, 0 no, 1 yes */
871   {
872     TW_ONEVALUE onevalue_data;
873     int rc;
874     rc = TTWAIN_GetCap(CAP_DEVICEONLINE, TWON_ONEVALUE, (void *)&onevalue_data,
875                        0);
876     if (!rc) return -1;
877     return (int)onevalue_data.Item;
878   }
879   /*---------------------------------------------------------------------------*/
880   /*    TWAIN AVAILABILITY */
881   /*---------------------------------------------------------------------------*/
TTWAIN_IsAvailable(void)882   int TTWAIN_IsAvailable(void) {
883     TTWAIN_InitVar();
884     if (TTWAIN_DSM_HasEntryPoint()) return TRUE;
885 
886     if (TTwainData.twainAvailable == AVAIABLE_DONTKNOW) {
887       if (TTWAIN_LoadSourceManager()) {
888         TTWAIN_UnloadSourceManager();
889       } else {
890         TTwainData.twainAvailable = AVAIABLE_NO;
891       }
892     }
893 
894     return (TTwainData.twainAvailable == AVAIABLE_YES);
895   }
896   /*---------------------------------------------------------------------------*/
TTWAIN_SetAvailable(TWAINAVAILABLE status)897   void TTWAIN_SetAvailable(TWAINAVAILABLE status) {
898     TTwainData.twainAvailable = status;
899   }
900   /*---------------------------------------------------------------------------*/
901 
902   /*---------------------------------------------------------------------------*/
903   /*    MISC AUX FUNCTIONS */
904   /*---------------------------------------------------------------------------*/
905 
TTWAIN_GetMinValue(TW_RANGE range)906   static float TTWAIN_GetMinValue(TW_RANGE range) {
907     switch (range.ItemType) {
908     case TWTY_INT8:
909     case TWTY_INT16:
910     case TWTY_INT32:
911     case TWTY_UINT8:
912     case TWTY_UINT16:
913       return (float)range.MinValue;
914 
915     case TWTY_FIX32: {
916       TW_FIX32 *fix32 = (TW_FIX32 *)&range.MinValue;
917       return (float)TTWAIN_Fix32ToFloat(*fix32);
918     }
919 
920     default:
921       // TWTY_UINT32
922       // TWTY_BOOL
923       // TWTY_FRAME
924       // TWTY_STR32
925       // TWTY_STR64
926       // TWTY_STR128
927       // TWTY_STR255
928       assert(!"Invalid type!!!");
929       return 0;
930     }
931     return 0;
932   }
933   /*---------------------------------------------------------------------------*/
TTWAIN_GetMaxValue(TW_RANGE range)934   static float TTWAIN_GetMaxValue(TW_RANGE range) {
935     switch (range.ItemType) {
936     case TWTY_INT8:
937     case TWTY_INT16:
938     case TWTY_INT32:
939     case TWTY_UINT8:
940     case TWTY_UINT16:
941       return (float)range.MaxValue;
942 
943     case TWTY_FIX32: {
944       TW_FIX32 *fix32 = (TW_FIX32 *)&range.MaxValue;
945       return (float)TTWAIN_Fix32ToFloat(*fix32);
946     }
947 
948     default:
949       // TWTY_UINT32
950       // TWTY_BOOL
951       // TWTY_FRAME
952       // TWTY_STR32
953       // TWTY_STR64
954       // TWTY_STR128
955       // TWTY_STR255
956       assert(!"Invalid type!!");
957       return 0;
958     }
959     return 0;
960   }
961   /*---------------------------------------------------------------------------*/
TTWAIN_GetDefValue(TW_RANGE range)962   static float TTWAIN_GetDefValue(TW_RANGE range) {
963     switch (range.ItemType) {
964     case TWTY_INT8:
965     case TWTY_INT16:
966     case TWTY_INT32:
967     case TWTY_UINT8:
968     case TWTY_UINT16:
969       return (float)range.DefaultValue;
970 
971     case TWTY_FIX32: {
972       TW_FIX32 *fix32 = (TW_FIX32 *)&range.DefaultValue;
973       return (float)TTWAIN_Fix32ToFloat(*fix32);
974     }
975 
976     default:
977       // TWTY_UINT32
978       // TWTY_BOOL
979       // TWTY_FRAME
980       // TWTY_STR32
981       // TWTY_STR64
982       // TWTY_STR128
983       // TWTY_STR255
984       assert(!"Invalid type!!");
985       return 0;
986     }
987     return 0;
988   }
989   /*---------------------------------------------------------------------------*/
TTWAIN_GetStepValue(TW_RANGE range)990   static float TTWAIN_GetStepValue(TW_RANGE range) {
991     switch (range.ItemType) {
992     case TWTY_INT8:
993     case TWTY_INT16:
994     case TWTY_INT32:
995     case TWTY_UINT8:
996     case TWTY_UINT16:
997       return (float)range.StepSize;
998 
999     case TWTY_FIX32: {
1000       TW_FIX32 *fix32 = (TW_FIX32 *)&range.StepSize;
1001       return (float)TTWAIN_Fix32ToFloat(*fix32);
1002     }
1003 
1004     default:
1005       // TWTY_UINT32
1006       // TWTY_BOOL
1007       // TWTY_FRAME
1008       // TWTY_STR32
1009       // TWTY_STR64
1010       // TWTY_STR128
1011       // TWTY_STR255
1012       assert(!"Invalid type!!");
1013       return 0;
1014     }
1015     return 0;
1016   }
1017   /*---------------------------------------------------------------------------*/
1018   /*---------------------------------------------------------------------------*/
1019   /*---------------------------------------------------------------------------*/
TTWAIN_Native2Raster(void * handle,void * the_ras,int * lx,int * ly)1020   int TTWAIN_Native2Raster(void *handle, void *the_ras, int *lx, int *ly) {
1021     return TTWAIN_Native2RasterPD(handle, the_ras, lx, ly);
1022   }
1023   /*---------------------------------------------------------------------------*/
TTWAIN_IsItemInList(void * list,void * item,TUINT32 list_count,TUINT32 item_size)1024   static int TTWAIN_IsItemInList(void *list, void *item, TUINT32 list_count,
1025                                  TUINT32 item_size) {
1026     int found     = FALSE;
1027     TUINT32 count = list_count;
1028     UCHAR *pList  = (UCHAR *)list;
1029     UCHAR *pItem  = (UCHAR *)item;
1030 
1031     if (!list || !item) return FALSE;
1032     while (count--) {
1033       if (memcmp(pList, pItem, item_size) == 0) {
1034         found = TRUE;
1035         break;
1036       }
1037       pList += item_size;
1038     }
1039     return found;
1040   }
1041   /*---------------------------------------------------------------------------*/
TTWAIN_DumpCapabilities(void (* trace_fun)(const char * fmt,...))1042   void TTWAIN_DumpCapabilities(void (*trace_fun)(const char *fmt, ...)) {
1043     if (!trace_fun) return;
1044     trace_fun("list of supported (exported) capabilities\n");
1045     if (TTWAIN_IsCapSupportedTW_INT16(CAP_XFERCOUNT))
1046       trace_fun("CAP_XFERCOUNT");
1047     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_COMPRESSION))
1048       trace_fun("ICAP_COMPRESSION\n");
1049     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_PIXELTYPE))
1050       trace_fun("ICAP_PIXELTYPE\n");
1051     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_UNITS)) trace_fun("ICAP_UNITS\n");
1052     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_XFERMECH))
1053       trace_fun("ICAP_XFERMECH\n");
1054     if (TTWAIN_IsCapSupportedTW_INT16(CAP_AUTHOR)) trace_fun("CAP_AUTHOR\n");
1055     if (TTWAIN_IsCapSupportedTW_INT16(CAP_CAPTION)) trace_fun("CAP_CAPTION\n");
1056     if (TTWAIN_IsCapSupportedTW_INT16(CAP_FEEDERENABLED))
1057       trace_fun("CAP_FEEDERENABLED\n");
1058     if (TTWAIN_IsCapSupportedTW_INT16(CAP_FEEDERLOADED))
1059       trace_fun("CAP_FEEDERLOADED\n");
1060     if (TTWAIN_IsCapSupportedTW_INT16(CAP_TIMEDATE))
1061       trace_fun("CAP_TIMEDATE\n");
1062     if (TTWAIN_IsCapSupportedTW_INT16(CAP_SUPPORTEDCAPS))
1063       trace_fun("CAP_SUPPORTEDCAPS\n");
1064     if (TTWAIN_IsCapSupportedTW_INT16(CAP_EXTENDEDCAPS))
1065       trace_fun("CAP_EXTENDEDCAPS\n");
1066     if (TTWAIN_IsCapSupportedTW_INT16(CAP_AUTOFEED))
1067       trace_fun("CAP_AUTOFEED\n");
1068     if (TTWAIN_IsCapSupportedTW_INT16(CAP_CLEARPAGE))
1069       trace_fun("CAP_CLEARPAGE\n");
1070     if (TTWAIN_IsCapSupportedTW_INT16(CAP_FEEDPAGE))
1071       trace_fun("CAP_FEEDPAGE\n");
1072     if (TTWAIN_IsCapSupportedTW_INT16(CAP_REWINDPAGE))
1073       trace_fun("CAP_REWINDPAGE\n");
1074     if (TTWAIN_IsCapSupportedTW_INT16(CAP_INDICATORS))
1075       trace_fun("CAP_INDICATORS\n");
1076     if (TTWAIN_IsCapSupportedTW_INT16(CAP_SUPPORTEDCAPSEXT))
1077       trace_fun("CAP_SUPPORTEDCAPSEXT\n");
1078     if (TTWAIN_IsCapSupportedTW_INT16(CAP_PAPERDETECTABLE))
1079       trace_fun("CAP_PAPERDETECTABLE\n");
1080     if (TTWAIN_IsCapSupportedTW_INT16(CAP_UICONTROLLABLE))
1081       trace_fun("CAP_UICONTROLLABLE\n");
1082     if (TTWAIN_IsCapSupportedTW_INT16(CAP_DEVICEONLINE))
1083       trace_fun("CAP_DEVICEONLINE\n");
1084     if (TTWAIN_IsCapSupportedTW_INT16(CAP_AUTOSCAN))
1085       trace_fun("CAP_AUTOSCAN\n");
1086     if (TTWAIN_IsCapSupportedTW_INT16(CAP_THUMBNAILSENABLED))
1087       trace_fun("CAP_THUMBNAILSENABLED\n");
1088     if (TTWAIN_IsCapSupportedTW_INT16(CAP_DUPLEX)) trace_fun("CAP_DUPLEX\n");
1089     if (TTWAIN_IsCapSupportedTW_INT16(CAP_DUPLEXENABLED))
1090       trace_fun("CAP_DUPLEXENABLED\n");
1091     if (TTWAIN_IsCapSupportedTW_INT16(CAP_ENABLEDSUIONLY))
1092       trace_fun("CAP_ENABLEDSUIONLY\n");
1093     if (TTWAIN_IsCapSupportedTW_INT16(CAP_CUSTOMDSDATA))
1094       trace_fun("CAP_CUSTOMDSDATA\n");
1095     if (TTWAIN_IsCapSupportedTW_INT16(CAP_ENDORSER))
1096       trace_fun("CAP_ENDORSER\n");
1097     if (TTWAIN_IsCapSupportedTW_INT16(CAP_JOBCONTROL))
1098       trace_fun("CAP_JOBCONTROL\n");
1099     if (TTWAIN_IsCapSupportedTW_INT16(CAP_ALARMS)) trace_fun("CAP_ALARMS\n");
1100     if (TTWAIN_IsCapSupportedTW_INT16(CAP_ALARMVOLUME))
1101       trace_fun("CAP_ALARMVOLUME\n");
1102     if (TTWAIN_IsCapSupportedTW_INT16(CAP_AUTOMATICCAPTURE))
1103       trace_fun("CAP_AUTOMATICCAPTURE\n");
1104     if (TTWAIN_IsCapSupportedTW_INT16(CAP_TIMEBEFOREFIRSTCAPTURE))
1105       trace_fun("CAP_TIMEBEFOREFIRSTCAPTURE\n");
1106     if (TTWAIN_IsCapSupportedTW_INT16(CAP_TIMEBETWEENCAPTURES))
1107       trace_fun("CAP_TIMEBETWEENCAPTURES\n");
1108     if (TTWAIN_IsCapSupportedTW_INT16(CAP_CLEARBUFFERS))
1109       trace_fun("CAP_CLEARBUFFERS\n");
1110     if (TTWAIN_IsCapSupportedTW_INT16(CAP_MAXBATCHBUFFERS))
1111       trace_fun("CAP_MAXBATCHBUFFERS\n");
1112     if (TTWAIN_IsCapSupportedTW_INT16(CAP_DEVICETIMEDATE))
1113       trace_fun("CAP_DEVICETIMEDATE\n");
1114     if (TTWAIN_IsCapSupportedTW_INT16(CAP_POWERSUPPLY))
1115       trace_fun("CAP_POWERSUPPLY\n");
1116     if (TTWAIN_IsCapSupportedTW_INT16(CAP_CAMERAPREVIEWUI))
1117       trace_fun("CAP_CAMERAPREVIEWUI\n");
1118     if (TTWAIN_IsCapSupportedTW_INT16(CAP_DEVICEEVENT))
1119       trace_fun("CAP_DEVICEEVENT\n");
1120     if (TTWAIN_IsCapSupportedTW_INT16(CAP_SERIALNUMBER))
1121       trace_fun("CAP_SERIALNUMBER\n");
1122     if (TTWAIN_IsCapSupportedTW_INT16(CAP_PRINTER)) trace_fun("CAP_PRINTER\n");
1123     if (TTWAIN_IsCapSupportedTW_INT16(CAP_PRINTERENABLED))
1124       trace_fun("CAP_PRINTERENABLED\n");
1125     if (TTWAIN_IsCapSupportedTW_INT16(CAP_PRINTERINDEX))
1126       trace_fun("CAP_PRINTERINDEX\n");
1127     if (TTWAIN_IsCapSupportedTW_INT16(CAP_PRINTERMODE))
1128       trace_fun("CAP_PRINTERMODE\n");
1129     if (TTWAIN_IsCapSupportedTW_INT16(CAP_PRINTERSTRING))
1130       trace_fun("CAP_PRINTERSTRING\n");
1131     if (TTWAIN_IsCapSupportedTW_INT16(CAP_PRINTERSUFFIX))
1132       trace_fun("CAP_PRINTERSUFFIX\n");
1133     if (TTWAIN_IsCapSupportedTW_INT16(CAP_LANGUAGE))
1134       trace_fun("CAP_LANGUAGE\n");
1135     if (TTWAIN_IsCapSupportedTW_INT16(CAP_FEEDERALIGNMENT))
1136       trace_fun("CAP_FEEDERALIGNMENT\n");
1137     if (TTWAIN_IsCapSupportedTW_INT16(CAP_FEEDERORDER))
1138       trace_fun("CAP_FEEDERORDER\n");
1139     if (TTWAIN_IsCapSupportedTW_INT16(CAP_REACQUIREALLOWED))
1140       trace_fun("CAP_REACQUIREALLOWED\n");
1141     if (TTWAIN_IsCapSupportedTW_INT16(CAP_BATTERYMINUTES))
1142       trace_fun("CAP_BATTERYMINUTES\n");
1143     if (TTWAIN_IsCapSupportedTW_INT16(CAP_BATTERYPERCENTAGE))
1144       trace_fun("CAP_BATTERYPERCENTAGE\n");
1145     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_AUTOBRIGHT))
1146       trace_fun("ICAP_AUTOBRIGHT\n");
1147     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_BRIGHTNESS))
1148       trace_fun("ICAP_BRIGHTNESS\n");
1149     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_CONTRAST))
1150       trace_fun("ICAP_CONTRAST\n");
1151     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_CUSTHALFTONE))
1152       trace_fun("ICAP_CUSTHALFTONE\n");
1153     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_EXPOSURETIME))
1154       trace_fun("ICAP_EXPOSURETIME\n");
1155     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_FILTER)) trace_fun("ICAP_FILTER\n");
1156     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_FLASHUSED))
1157       trace_fun("ICAP_FLASHUSED\n");
1158     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_GAMMA)) trace_fun("ICAP_GAMMA\n");
1159     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_HALFTONES))
1160       trace_fun("ICAP_HALFTONES\n");
1161     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_HIGHLIGHT))
1162       trace_fun("ICAP_HIGHLIGHT\n");
1163     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_IMAGEFILEFORMAT))
1164       trace_fun("ICAP_IMAGEFILEFORMAT\n");
1165     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_LAMPSTATE))
1166       trace_fun("ICAP_LAMPSTATE\n");
1167     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_LIGHTSOURCE))
1168       trace_fun("ICAP_LIGHTSOURCE\n");
1169     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_ORIENTATION))
1170       trace_fun("ICAP_ORIENTATION\n");
1171     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_PHYSICALWIDTH))
1172       trace_fun("ICAP_PHYSICALWIDTH\n");
1173     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_PHYSICALHEIGHT))
1174       trace_fun("ICAP_PHYSICALHEIGHT\n");
1175     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_SHADOW)) trace_fun("ICAP_SHADOW\n");
1176     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_FRAMES)) trace_fun("ICAP_FRAMES\n");
1177     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_XNATIVERESOLUTION))
1178       trace_fun("ICAP_XNATIVERESOLUTION\n");
1179     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_YNATIVERESOLUTION))
1180       trace_fun("ICAP_YNATIVERESOLUTION\n");
1181     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_XRESOLUTION))
1182       trace_fun("ICAP_XRESOLUTION\n");
1183     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_YRESOLUTION))
1184       trace_fun("ICAP_YRESOLUTION\n");
1185     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_MAXFRAMES))
1186       trace_fun("ICAP_MAXFRAMES\n");
1187     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_TILES)) trace_fun("ICAP_TILES\n");
1188     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_BITORDER))
1189       trace_fun("ICAP_BITORDER\n");
1190     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_CCITTKFACTOR))
1191       trace_fun("ICAP_CCITTKFACTOR\n");
1192     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_LIGHTPATH))
1193       trace_fun("ICAP_LIGHTPATH\n");
1194     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_PIXELFLAVOR))
1195       trace_fun("ICAP_PIXELFLAVOR\n");
1196     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_PLANARCHUNKY))
1197       trace_fun("ICAP_PLANARCHUNKY\n");
1198     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_ROTATION))
1199       trace_fun("ICAP_ROTATION\n");
1200     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_SUPPORTEDSIZES))
1201       trace_fun("ICAP_SUPPORTEDSIZES\n");
1202     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_THRESHOLD))
1203       trace_fun("ICAP_THRESHOLD\n");
1204     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_XSCALING))
1205       trace_fun("ICAP_XSCALING\n");
1206     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_YSCALING))
1207       trace_fun("ICAP_YSCALING\n");
1208     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_BITORDERCODES))
1209       trace_fun("ICAP_BITORDERCODES\n");
1210     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_PIXELFLAVORCODES))
1211       trace_fun("ICAP_PIXELFLAVORCODES\n");
1212     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_JPEGPIXELTYPE))
1213       trace_fun("ICAP_JPEGPIXELTYPE\n");
1214     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_TIMEFILL))
1215       trace_fun("ICAP_TIMEFILL\n");
1216     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_BITDEPTH))
1217       trace_fun("ICAP_BITDEPTH\n");
1218     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_BITDEPTHREDUCTION))
1219       trace_fun("ICAP_BITDEPTHREDUCTION\n");
1220     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_UNDEFINEDIMAGESIZE))
1221       trace_fun("ICAP_UNDEFINEDIMAGESIZE\n");
1222     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_IMAGEDATASET))
1223       trace_fun("ICAP_IMAGEDATASET\n");
1224     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_EXTIMAGEINFO))
1225       trace_fun("ICAP_EXTIMAGEINFO\n");
1226     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_MINIMUMHEIGHT))
1227       trace_fun("ICAP_MINIMUMHEIGHT\n");
1228     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_MINIMUMWIDTH))
1229       trace_fun("ICAP_MINIMUMWIDTH\n");
1230     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_FLIPROTATION))
1231       trace_fun("ICAP_FLIPROTATION\n");
1232     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_BARCODEDETECTIONENABLED))
1233       trace_fun("ICAP_BARCODEDETECTIONENABLED\n");
1234     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_SUPPORTEDBARCODETYPES))
1235       trace_fun("ICAP_SUPPORTEDBARCODETYPES\n");
1236     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_BARCODEMAXSEARCHPRIORITIES))
1237       trace_fun("ICAP_BARCODEMAXSEARCHPRIORITIES\n");
1238     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_BARCODESEARCHPRIORITIES))
1239       trace_fun("ICAP_BARCODESEARCHPRIORITIES\n");
1240     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_BARCODESEARCHMODE))
1241       trace_fun("ICAP_BARCODESEARCHMODE\n");
1242     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_BARCODEMAXRETRIES))
1243       trace_fun("ICAP_BARCODEMAXRETRIES\n");
1244     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_BARCODETIMEOUT))
1245       trace_fun("ICAP_BARCODETIMEOUT\n");
1246     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_ZOOMFACTOR))
1247       trace_fun("ICAP_ZOOMFACTOR\n");
1248     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_PATCHCODEDETECTIONENABLED))
1249       trace_fun("ICAP_PATCHCODEDETECTIONENABLED\n");
1250     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_SUPPORTEDPATCHCODETYPES))
1251       trace_fun("ICAP_SUPPORTEDPATCHCODETYPES\n");
1252     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_PATCHCODEMAXSEARCHPRIORITIES))
1253       trace_fun("ICAP_PATCHCODEMAXSEARCHPRIORITIES\n");
1254     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_PATCHCODESEARCHPRIORITIES))
1255       trace_fun("ICAP_PATCHCODESEARCHPRIORITIES\n");
1256     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_PATCHCODESEARCHMODE))
1257       trace_fun("ICAP_PATCHCODESEARCHMODE\n");
1258     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_PATCHCODEMAXRETRIES))
1259       trace_fun("ICAP_PATCHCODEMAXRETRIES\n");
1260     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_PATCHCODETIMEOUT))
1261       trace_fun("ICAP_PATCHCODETIMEOUT\n");
1262     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_FLASHUSED2))
1263       trace_fun("ICAP_FLASHUSED2\n");
1264     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_IMAGEFILTER))
1265       trace_fun("ICAP_IMAGEFILTER\n");
1266     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_NOISEFILTER))
1267       trace_fun("ICAP_NOISEFILTER\n");
1268     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_OVERSCAN))
1269       trace_fun("ICAP_OVERSCAN\n");
1270     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_AUTOMATICBORDERDETECTION))
1271       trace_fun("ICAP_AUTOMATICBORDERDETECTION\n");
1272     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_AUTOMATICDESKEW))
1273       trace_fun("ICAP_AUTOMATICDESKEW\n");
1274     if (TTWAIN_IsCapSupportedTW_INT16(ICAP_AUTOMATICROTATE))
1275       trace_fun("ICAP_AUTOMATICROTATE\n");
1276     trace_fun("end-of-list\n");
1277   }
1278   /*---------------------------------------------------------------------------*/
1279   /*---------------------------------------------------------------------------*/
TTWAIN_SetTwainUsage(TTWAIN_USAGE_MODE um)1280   void TTWAIN_SetTwainUsage(TTWAIN_USAGE_MODE um) {
1281     TTwainData.transferInfo.usageMode = um;
1282   }
1283   /*---------------------------------------------------------------------------*/
1284   extern void registerTwainCallback();
1285 
TTWAIN_SetOnDoneCallback(TTWAIN_ONDONE_CB * proc,void * arg)1286   void TTWAIN_SetOnDoneCallback(TTWAIN_ONDONE_CB * proc, void *arg) {
1287     TTwainData.callback.onDoneCb  = proc;
1288     TTwainData.callback.onDoneArg = arg;
1289 #ifdef MACOSX
1290     registerTwainCallback();
1291 #endif
1292   }
1293   /*---------------------------------------------------------------------------*/
TTWAIN_SetOnErrorCallback(TTWAIN_ONERROR_CB * proc,void * arg)1294   void TTWAIN_SetOnErrorCallback(TTWAIN_ONERROR_CB * proc, void *arg) {
1295     TTwainData.callback.onErrorCb  = proc;
1296     TTwainData.callback.onErrorArg = arg;
1297   }
1298 /*---------------------------------------------------------------------------*/
1299 
1300 #ifdef __cplusplus
1301 }
1302 #endif
1303