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