dlls/sane.ds/capability.c

   1 /*
   2  * Copyright 2000 Corel Corporation
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define NONAMELESSUNION
  20 #define NONAMELESSSTRUCT
  21
  22 #include "config.h"
  23
  24 #include <stdarg.h>
  25 #include <stdio.h>
  26 #include <math.h>
  27
  28 #include "sane_i.h"
  29 #include "winnls.h"
  30 #include "wine/debug.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(twain);
  33
  34 #ifndef SANE_VALUE_SCAN_MODE_COLOR
  35 #define SANE_VALUE_SCAN_MODE_COLOR              SANE_I18N("Color")
  36 #endif
  37 #ifndef SANE_VALUE_SCAN_MODE_GRAY
  38 #define SANE_VALUE_SCAN_MODE_GRAY               SANE_I18N("Gray")
  39 #endif
  40 #ifndef SANE_VALUE_SCAN_MODE_LINEART
  41 #define SANE_VALUE_SCAN_MODE_LINEART            SANE_I18N("Lineart")
  42 #endif
  43
  44 static TW_UINT16 get_onevalue(pTW_CAPABILITY pCapability, TW_UINT16 *type, TW_UINT32 *value)
  45 {
  46     if (pCapability->hContainer)
  47     {
  48         pTW_ONEVALUE pVal = GlobalLock (pCapability->hContainer);
  49         if (pVal)
  50         {
  51             *value = pVal->Item;
  52             if (type)
  53                 *type = pVal->ItemType;
  54             GlobalUnlock (pCapability->hContainer);
  55             return TWCC_SUCCESS;
  56         }
  57     }
  58     return TWCC_BUMMER;
  59 }
  60
  61
  62 static TW_UINT16 set_onevalue(pTW_CAPABILITY pCapability, TW_UINT16 type, TW_UINT32 value)
  63 {
  64     pCapability->hContainer = GlobalAlloc (0, sizeof(TW_ONEVALUE));
  65
  66     if (pCapability->hContainer)
  67     {
  68         pTW_ONEVALUE pVal = GlobalLock (pCapability->hContainer);
  69         if (pVal)
  70         {
  71             pCapability->ConType = TWON_ONEVALUE;
  72             pVal->ItemType = type;
  73             pVal->Item = value;
  74             GlobalUnlock (pCapability->hContainer);
  75             return TWCC_SUCCESS;
  76         }
  77     }
  78    return TWCC_LOWMEMORY;
  79 }
  80
  81 static TW_UINT16 msg_set(pTW_CAPABILITY pCapability, TW_UINT32 *val)
  82 {
  83     if (pCapability->ConType == TWON_ONEVALUE)
  84         return get_onevalue(pCapability, NULL, val);
  85
  86     FIXME("Partial Stub:  MSG_SET only supports TW_ONEVALUE\n");
  87     return TWCC_BADCAP;
  88 }
  89
  90
  91 static TW_UINT16 msg_get_enum(pTW_CAPABILITY pCapability, const TW_UINT32 *values, int value_count,
  92                               TW_UINT16 type, TW_UINT32 current, TW_UINT32 default_value)
  93 {
  94     TW_ENUMERATION *enumv = NULL;
  95     TW_UINT32 *p32;
  96     TW_UINT16 *p16;
  97     int i;
  98
  99     pCapability->ConType = TWON_ENUMERATION;
 100     pCapability->hContainer = 0;
 101
 102     if (type == TWTY_INT16 || type == TWTY_UINT16)
 103         pCapability->hContainer = GlobalAlloc (0, FIELD_OFFSET( TW_ENUMERATION, ItemList[value_count * sizeof(TW_UINT16)]));
 104
 105     if (type == TWTY_INT32 || type == TWTY_UINT32)
 106         pCapability->hContainer = GlobalAlloc (0, FIELD_OFFSET( TW_ENUMERATION, ItemList[value_count * sizeof(TW_UINT32)]));
 107
 108     if (pCapability->hContainer)
 109         enumv = GlobalLock(pCapability->hContainer);
 110
 111     if (! enumv)
 112         return TWCC_LOWMEMORY;
 113
 114     enumv->ItemType = type;
 115     enumv->NumItems = value_count;
 116
 117     p16 = (TW_UINT16 *) enumv->ItemList;
 118     p32 = (TW_UINT32 *) enumv->ItemList;
 119     for (i = 0; i < value_count; i++)
 120     {
 121         if (values[i] == current)
 122             enumv->CurrentIndex = i;
 123         if (values[i] == default_value)
 124             enumv->DefaultIndex = i;
 125         if (type == TWTY_INT16 || type == TWTY_UINT16)
 126             p16[i] = values[i];
 127         if (type == TWTY_INT32 || type == TWTY_UINT32)
 128             p32[i] = values[i];
 129     }
 130
 131     GlobalUnlock(pCapability->hContainer);
 132     return TWCC_SUCCESS;
 133 }
 134
 135 #ifdef SONAME_LIBSANE
 136 static TW_UINT16 msg_get_range(pTW_CAPABILITY pCapability, TW_UINT16 type,
 137             TW_UINT32 minval, TW_UINT32 maxval, TW_UINT32 step, TW_UINT32 def,  TW_UINT32 current)
 138 {
 139     TW_RANGE *range = NULL;
 140
 141     pCapability->ConType = TWON_RANGE;
 142     pCapability->hContainer = 0;
 143
 144     pCapability->hContainer = GlobalAlloc (0, sizeof(*range));
 145     if (pCapability->hContainer)
 146         range = GlobalLock(pCapability->hContainer);
 147
 148     if (! range)
 149         return TWCC_LOWMEMORY;
 150
 151     range->ItemType = type;
 152     range->MinValue = minval;
 153     range->MaxValue = maxval;
 154     range->StepSize = step;
 155     range->DefaultValue = def;
 156     range->CurrentValue = current;
 157
 158     GlobalUnlock(pCapability->hContainer);
 159     return TWCC_SUCCESS;
 160 }
 161 #endif
 162
 163 static TW_UINT16 TWAIN_GetSupportedCaps(pTW_CAPABILITY pCapability)
 164 {
 165     TW_ARRAY *a;
 166     static const UINT16 supported_caps[] = { CAP_SUPPORTEDCAPS, CAP_XFERCOUNT, CAP_UICONTROLLABLE,
 167                     CAP_AUTOFEED, CAP_FEEDERENABLED,
 168                     ICAP_XFERMECH, ICAP_PIXELTYPE, ICAP_UNITS, ICAP_BITDEPTH, ICAP_COMPRESSION, ICAP_PIXELFLAVOR,
 169                     ICAP_XRESOLUTION, ICAP_YRESOLUTION, ICAP_PHYSICALHEIGHT, ICAP_PHYSICALWIDTH, ICAP_SUPPORTEDSIZES };
 170
 171     pCapability->hContainer = GlobalAlloc (0, FIELD_OFFSET( TW_ARRAY, ItemList[sizeof(supported_caps)] ));
 172     pCapability->ConType = TWON_ARRAY;
 173
 174     if (pCapability->hContainer)
 175     {
 176         UINT16 *u;
 177         int i;
 178         a = GlobalLock (pCapability->hContainer);
 179         a->ItemType = TWTY_UINT16;
 180         a->NumItems = sizeof(supported_caps) / sizeof(supported_caps[0]);
 181         u = (UINT16 *) a->ItemList;
 182         for (i = 0; i < a->NumItems; i++)
 183             u[i] = supported_caps[i];
 184         GlobalUnlock (pCapability->hContainer);
 185         return TWCC_SUCCESS;
 186     }
 187     else
 188         return TWCC_LOWMEMORY;
 189 }
 190
 191
 192 /* ICAP_XFERMECH */
 193 static TW_UINT16 SANE_ICAPXferMech (pTW_CAPABILITY pCapability, TW_UINT16 action)
 194 {
 195     static const TW_UINT32 possible_values[] = { TWSX_NATIVE, TWSX_MEMORY };
 196     TW_UINT32 val;
 197     TW_UINT16 twCC = TWCC_BADCAP;
 198
 199     TRACE("ICAP_XFERMECH\n");
 200
 201     switch (action)
 202     {
 203         case MSG_QUERYSUPPORT:
 204             twCC = set_onevalue(pCapability, TWTY_INT32,
 205                     TWQC_GET | TWQC_SET | TWQC_GETDEFAULT | TWQC_GETCURRENT | TWQC_RESET );
 206             break;
 207
 208         case MSG_GET:
 209             twCC = msg_get_enum(pCapability, possible_values, sizeof(possible_values) / sizeof(possible_values[0]),
 210                     TWTY_UINT16, activeDS.capXferMech, TWSX_NATIVE);
 211             break;
 212
 213         case MSG_SET:
 214             twCC = msg_set(pCapability, &val);
 215             if (twCC == TWCC_SUCCESS)
 216             {
 217                activeDS.capXferMech = (TW_UINT16) val;
 218                FIXME("Partial Stub:  XFERMECH set to %d, but ignored\n", val);
 219             }
 220             break;
 221
 222         case MSG_GETDEFAULT:
 223             twCC = set_onevalue(pCapability, TWTY_UINT16, TWSX_NATIVE);
 224             break;
 225
 226         case MSG_RESET:
 227             activeDS.capXferMech = TWSX_NATIVE;
 228             /* .. fall through intentional .. */
 229
 230         case MSG_GETCURRENT:
 231             twCC = set_onevalue(pCapability, TWTY_UINT16, activeDS.capXferMech);
 232             FIXME("Partial Stub:  XFERMECH of %d not actually used\n", activeDS.capXferMech);
 233             break;
 234     }
 235     return twCC;
 236 }
 237
 238
 239 /* CAP_XFERCOUNT */
 240 static TW_UINT16 SANE_CAPXferCount (pTW_CAPABILITY pCapability, TW_UINT16 action)
 241 {
 242     TW_UINT32 val;
 243     TW_UINT16 twCC = TWCC_BADCAP;
 244
 245     TRACE("CAP_XFERCOUNT\n");
 246
 247     switch (action)
 248     {
 249         case MSG_QUERYSUPPORT:
 250             twCC = set_onevalue(pCapability, TWTY_INT32,
 251                     TWQC_GET | TWQC_SET | TWQC_GETDEFAULT | TWQC_GETCURRENT | TWQC_RESET );
 252             break;
 253
 254         case MSG_GET:
 255             twCC = set_onevalue(pCapability, TWTY_INT16, -1);
 256             FIXME("Partial Stub:  Reporting only support for transfer all\n");
 257             break;
 258
 259         case MSG_SET:
 260             twCC = msg_set(pCapability, &val);
 261             if (twCC == TWCC_SUCCESS)
 262                FIXME("Partial Stub:  XFERCOUNT set to %d, but ignored\n", val);
 263             break;
 264
 265         case MSG_GETDEFAULT:
 266             twCC = set_onevalue(pCapability, TWTY_INT16, -1);
 267             break;
 268
 269         case MSG_RESET:
 270             /* .. fall through intentional .. */
 271
 272         case MSG_GETCURRENT:
 273             twCC = set_onevalue(pCapability, TWTY_INT16, -1);
 274             break;
 275     }
 276     return twCC;
 277 }
 278
 279 #ifdef SONAME_LIBSANE
 280 static BOOL pixeltype_to_sane_mode(TW_UINT16 pixeltype, SANE_String mode, int len)
 281 {
 282     SANE_String_Const m = NULL;
 283     switch (pixeltype)
 284     {
 285         case TWPT_GRAY:
 286             m = SANE_VALUE_SCAN_MODE_GRAY;
 287             break;
 288         case TWPT_RGB:
 289             m = SANE_VALUE_SCAN_MODE_COLOR;
 290             break;
 291         case TWPT_BW:
 292             m = SANE_VALUE_SCAN_MODE_LINEART;
 293             break;
 294     }
 295     if (! m)
 296         return FALSE;
 297     if (strlen(m) >= len)
 298         return FALSE;
 299     strcpy(mode, m);
 300     return TRUE;
 301 }
 302 static BOOL sane_mode_to_pixeltype(SANE_String_Const mode, TW_UINT16 *pixeltype)
 303 {
 304     if (strcmp(mode, SANE_VALUE_SCAN_MODE_LINEART) == 0)
 305         *pixeltype = TWPT_BW;
 306     else if (memcmp(mode, SANE_VALUE_SCAN_MODE_GRAY, strlen(SANE_VALUE_SCAN_MODE_GRAY)) == 0)
 307         *pixeltype = TWPT_GRAY;
 308     else if (strcmp(mode, SANE_VALUE_SCAN_MODE_COLOR) == 0)
 309         *pixeltype = TWPT_RGB;
 310     else
 311         return FALSE;
 312
 313     return TRUE;
 314 }
 315 #endif
 316
 317 /* ICAP_PIXELTYPE */
 318 static TW_UINT16 SANE_ICAPPixelType (pTW_CAPABILITY pCapability, TW_UINT16 action)
 319 {
 320     TW_UINT16 twCC = TWCC_BADCAP;
 321 #ifdef SONAME_LIBSANE
 322     TW_UINT32 possible_values[3];
 323     int possible_value_count;
 324     TW_UINT32 val;
 325     SANE_Status rc;
 326     SANE_Int status;
 327     SANE_String_Const *choices;
 328     char current_mode[64];
 329     TW_UINT16 current_pixeltype = TWPT_BW;
 330     SANE_Char mode[64];
 331
 332     TRACE("ICAP_PIXELTYPE\n");
 333
 334     rc = sane_option_probe_mode(activeDS.deviceHandle, &choices, current_mode, sizeof(current_mode));
 335     if (rc != SANE_STATUS_GOOD)
 336     {
 337         ERR("Unable to retrieve mode from sane, ICAP_PIXELTYPE unsupported\n");
 338         return twCC;
 339     }
 340
 341     sane_mode_to_pixeltype(current_mode, &current_pixeltype);
 342
 343     /* Sane does not support a concept of a default mode, so we simply cache
 344      *   the first mode we find */
 345     if (! activeDS.PixelTypeSet)
 346     {
 347         activeDS.PixelTypeSet = TRUE;
 348         activeDS.defaultPixelType = current_pixeltype;
 349     }
 350
 351     switch (action)
 352     {
 353         case MSG_QUERYSUPPORT:
 354             twCC = set_onevalue(pCapability, TWTY_INT32,
 355                     TWQC_GET | TWQC_SET | TWQC_GETDEFAULT | TWQC_GETCURRENT | TWQC_RESET );
 356             break;
 357
 358         case MSG_GET:
 359             for (possible_value_count = 0; choices && *choices && possible_value_count < 3; choices++)
 360             {
 361                 TW_UINT16 pix;
 362                 if (sane_mode_to_pixeltype(*choices, &pix))
 363                     possible_values[possible_value_count++] = pix;
 364             }
 365             twCC = msg_get_enum(pCapability, possible_values, possible_value_count,
 366                     TWTY_UINT16, current_pixeltype, activeDS.defaultPixelType);
 367             break;
 368
 369         case MSG_SET:
 370             twCC = msg_set(pCapability, &val);
 371             if (twCC == TWCC_SUCCESS)
 372             {
 373                 TRACE("Setting pixeltype to %d\n", val);
 374                 if (! pixeltype_to_sane_mode(val, mode, sizeof(mode)))
 375                     return TWCC_BADVALUE;
 376
 377                 status = 0;
 378                 rc = sane_option_set_str(activeDS.deviceHandle, "mode", mode, &status);
 379                 /* Some SANE devices use 'Grayscale' instead of the standard 'Gray' */
 380                 if (rc == SANE_STATUS_INVAL && strcmp(mode, SANE_VALUE_SCAN_MODE_GRAY) == 0)
 381                 {
 382                     strcpy(mode, "Grayscale");
 383                     rc = sane_option_set_str(activeDS.deviceHandle, "mode", mode, &status);
 384                 }
 385                 if (rc != SANE_STATUS_GOOD)
 386                     return sane_status_to_twcc(rc);
 387                 if (status & SANE_INFO_RELOAD_PARAMS)
 388                     psane_get_parameters (activeDS.deviceHandle, &activeDS.sane_param);
 389             }
 390             break;
 391
 392         case MSG_GETDEFAULT:
 393             twCC = set_onevalue(pCapability, TWTY_UINT16, activeDS.defaultPixelType);
 394             break;
 395
 396         case MSG_RESET:
 397             current_pixeltype = activeDS.defaultPixelType;
 398             if (! pixeltype_to_sane_mode(current_pixeltype, mode, sizeof(mode)))
 399                 return TWCC_BADVALUE;
 400
 401             status = 0;
 402             rc = sane_option_set_str(activeDS.deviceHandle, "mode", mode, &status);
 403             /* Some SANE devices use 'Grayscale' instead of the standard 'Gray' */
 404             if (rc == SANE_STATUS_INVAL && strcmp(mode, SANE_VALUE_SCAN_MODE_GRAY) == 0)
 405             {
 406                 strcpy(mode, "Grayscale");
 407                 rc = sane_option_set_str(activeDS.deviceHandle, "mode", mode, &status);
 408             }
 409             if (rc != SANE_STATUS_GOOD)
 410                 return sane_status_to_twcc(rc);
 411             if (status & SANE_INFO_RELOAD_PARAMS)
 412                 psane_get_parameters (activeDS.deviceHandle, &activeDS.sane_param);
 413
 414             /* .. fall through intentional .. */
 415
 416         case MSG_GETCURRENT:
 417             twCC = set_onevalue(pCapability, TWTY_UINT16, current_pixeltype);
 418             TRACE("Returning current pixeltype of %d\n", current_pixeltype);
 419             break;
 420     }
 421
 422 #endif
 423     return twCC;
 424 }
 425
 426 /* ICAP_UNITS */
 427 static TW_UINT16 SANE_ICAPUnits (pTW_CAPABILITY pCapability, TW_UINT16 action)
 428 {
 429     TW_UINT32 val;
 430     TW_UINT16 twCC = TWCC_BADCAP;
 431
 432     TRACE("ICAP_UNITS\n");
 433
 434     switch (action)
 435     {
 436         case MSG_QUERYSUPPORT:
 437             twCC = set_onevalue(pCapability, TWTY_INT32,
 438                     TWQC_GET | TWQC_SET | TWQC_GETDEFAULT | TWQC_GETCURRENT | TWQC_RESET );
 439             break;
 440
 441         case MSG_GET:
 442             twCC = set_onevalue(pCapability, TWTY_UINT16, TWUN_INCHES);
 443             break;
 444
 445         case MSG_SET:
 446             twCC = msg_set(pCapability, &val);
 447             if (twCC == TWCC_SUCCESS)
 448             {
 449                 if  (val != TWUN_INCHES)
 450                 {
 451                     ERR("Sane supports only SANE_UNIT_DPI\n");
 452                     twCC = TWCC_BADVALUE;
 453                 }
 454             }
 455             break;
 456
 457         case MSG_GETDEFAULT:
 458         case MSG_RESET:
 459             /* .. fall through intentional .. */
 460
 461         case MSG_GETCURRENT:
 462             twCC = set_onevalue(pCapability, TWTY_UINT16, TWUN_INCHES);
 463             break;
 464     }
 465
 466     return twCC;
 467 }
 468
 469 /* ICAP_BITDEPTH */
 470 static TW_UINT16 SANE_ICAPBitDepth(pTW_CAPABILITY pCapability, TW_UINT16 action)
 471 {
 472     TW_UINT16 twCC = TWCC_BADCAP;
 473 #ifdef SONAME_LIBSANE
 474     TW_UINT32 possible_values[1];
 475
 476     TRACE("ICAP_BITDEPTH\n");
 477
 478     possible_values[0] = activeDS.sane_param.depth;
 479
 480     switch (action)
 481     {
 482         case MSG_QUERYSUPPORT:
 483             twCC = set_onevalue(pCapability, TWTY_INT32,
 484                     TWQC_GET | TWQC_GETDEFAULT | TWQC_GETCURRENT  );
 485             break;
 486
 487         case MSG_GET:
 488             twCC = msg_get_enum(pCapability, possible_values, sizeof(possible_values) / sizeof(possible_values[0]),
 489                     TWTY_UINT16, activeDS.sane_param.depth, activeDS.sane_param.depth);
 490             break;
 491
 492         case MSG_GETDEFAULT:
 493             /* .. Fall through intentional .. */
 494
 495         case MSG_GETCURRENT:
 496             TRACE("Returning current bitdepth of %d\n", activeDS.sane_param.depth);
 497             twCC = set_onevalue(pCapability, TWTY_UINT16, activeDS.sane_param.depth);
 498             break;
 499     }
 500 #endif
 501     return twCC;
 502 }
 503
 504 /* CAP_UICONTROLLABLE */
 505 static TW_UINT16 SANE_CAPUiControllable(pTW_CAPABILITY pCapability, TW_UINT16 action)
 506 {
 507     TW_UINT16 twCC = TWCC_BADCAP;
 508
 509     TRACE("CAP_UICONTROLLABLE\n");
 510
 511     switch (action)
 512     {
 513         case MSG_QUERYSUPPORT:
 514             twCC = set_onevalue(pCapability, TWTY_INT32, TWQC_GET);
 515             break;
 516
 517         case MSG_GET:
 518             twCC = set_onevalue(pCapability, TWTY_BOOL, TRUE);
 519             break;
 520
 521     }
 522     return twCC;
 523 }
 524
 525 /* ICAP_COMPRESSION */
 526 static TW_UINT16 SANE_ICAPCompression (pTW_CAPABILITY pCapability, TW_UINT16 action)
 527 {
 528     static const TW_UINT32 possible_values[] = { TWCP_NONE };
 529     TW_UINT32 val;
 530     TW_UINT16 twCC = TWCC_BADCAP;
 531
 532     TRACE("ICAP_COMPRESSION\n");
 533
 534     switch (action)
 535     {
 536         case MSG_QUERYSUPPORT:
 537             twCC = set_onevalue(pCapability, TWTY_INT32,
 538                     TWQC_GET | TWQC_SET | TWQC_GETDEFAULT | TWQC_GETCURRENT | TWQC_RESET );
 539             break;
 540
 541         case MSG_GET:
 542             twCC = msg_get_enum(pCapability, possible_values, sizeof(possible_values) / sizeof(possible_values[0]),
 543                     TWTY_UINT16, TWCP_NONE, TWCP_NONE);
 544             FIXME("Partial stub:  We don't attempt to support compression\n");
 545             break;
 546
 547         case MSG_SET:
 548             twCC = msg_set(pCapability, &val);
 549             if (twCC == TWCC_SUCCESS)
 550                FIXME("Partial Stub:  COMPRESSION set to %d, but ignored\n", val);
 551             break;
 552
 553         case MSG_GETDEFAULT:
 554             twCC = set_onevalue(pCapability, TWTY_UINT16, TWCP_NONE);
 555             break;
 556
 557         case MSG_RESET:
 558             /* .. fall through intentional .. */
 559
 560         case MSG_GETCURRENT:
 561             twCC = set_onevalue(pCapability, TWTY_UINT16, TWCP_NONE);
 562             break;
 563     }
 564     return twCC;
 565 }
 566
 567 /* ICAP_XRESOLUTION, ICAP_YRESOLUTION  */
 568 static TW_UINT16 SANE_ICAPResolution (pTW_CAPABILITY pCapability, TW_UINT16 action,  TW_UINT16 cap)
 569 {
 570     TW_UINT16 twCC = TWCC_BADCAP;
 571 #ifdef SONAME_LIBSANE
 572     TW_UINT32 val;
 573     SANE_Int current_resolution;
 574     TW_FIX32 *default_res;
 575     const char *best_option_name;
 576     SANE_Int minval, maxval, quantval;
 577     SANE_Status sane_rc;
 578     SANE_Int set_status;
 579
 580     TRACE("ICAP_%cRESOLUTION\n", cap == ICAP_XRESOLUTION ? 'X' : 'Y');
 581
 582     /* Some scanners support 'x-resolution', most seem to just support 'resolution' */
 583     if (cap == ICAP_XRESOLUTION)
 584     {
 585         best_option_name = "x-resolution";
 586         default_res = &activeDS.defaultXResolution;
 587     }
 588     else
 589     {
 590         best_option_name = "y-resolution";
 591         default_res = &activeDS.defaultYResolution;
 592     }
 593     if (sane_option_get_int(activeDS.deviceHandle, best_option_name, &current_resolution) != SANE_STATUS_GOOD)
 594     {
 595         best_option_name = "resolution";
 596         if (sane_option_get_int(activeDS.deviceHandle, best_option_name, &current_resolution) != SANE_STATUS_GOOD)
 597             return TWCC_BADCAP;
 598     }
 599
 600     /* Sane does not support a concept of 'default' resolution, so we have to
 601      *   cache the resolution the very first time we load the scanner, and use that
 602      *   as the default */
 603     if (cap == ICAP_XRESOLUTION && ! activeDS.XResolutionSet)
 604     {
 605         default_res->Whole = current_resolution;
 606         default_res->Frac = 0;
 607         activeDS.XResolutionSet = TRUE;
 608     }
 609
 610     if (cap == ICAP_YRESOLUTION && ! activeDS.YResolutionSet)
 611     {
 612         default_res->Whole = current_resolution;
 613         default_res->Frac = 0;
 614         activeDS.YResolutionSet = TRUE;
 615     }
 616
 617     switch (action)
 618     {
 619         case MSG_QUERYSUPPORT:
 620             twCC = set_onevalue(pCapability, TWTY_INT32,
 621                     TWQC_GET | TWQC_SET | TWQC_GETDEFAULT | TWQC_GETCURRENT | TWQC_RESET );
 622             break;
 623
 624         case MSG_GET:
 625             sane_rc = sane_option_probe_resolution(activeDS.deviceHandle, best_option_name, &minval, &maxval, &quantval);
 626             if (sane_rc != SANE_STATUS_GOOD)
 627                 twCC = TWCC_BADCAP;
 628             else
 629                 twCC = msg_get_range(pCapability, TWTY_FIX32,
 630                                 minval, maxval, quantval == 0 ? 1 : quantval, default_res->Whole, current_resolution);
 631             break;
 632
 633         case MSG_SET:
 634             twCC = msg_set(pCapability, &val);
 635             if (twCC == TWCC_SUCCESS)
 636             {
 637                 TW_FIX32 f32;
 638                 memcpy(&f32, &val, sizeof(f32));
 639                 sane_rc = sane_option_set_int(activeDS.deviceHandle, best_option_name, f32.Whole, &set_status);
 640                 if (sane_rc != SANE_STATUS_GOOD)
 641                 {
 642                     FIXME("Status of %d not expected or handled\n", sane_rc);
 643                     twCC = TWCC_BADCAP;
 644                 }
 645                 else if (set_status == SANE_INFO_INEXACT)
 646                     twCC = TWCC_CHECKSTATUS;
 647             }
 648             break;
 649
 650         case MSG_GETDEFAULT:
 651             twCC = set_onevalue(pCapability, TWTY_FIX32, default_res->Whole);
 652             break;
 653
 654         case MSG_RESET:
 655             sane_rc = sane_option_set_int(activeDS.deviceHandle, best_option_name, default_res->Whole, NULL);
 656             if (sane_rc != SANE_STATUS_GOOD)
 657                 return TWCC_BADCAP;
 658
 659             /* .. fall through intentional .. */
 660
 661         case MSG_GETCURRENT:
 662             twCC = set_onevalue(pCapability, TWTY_FIX32, current_resolution);
 663             break;
 664     }
 665 #endif
 666     return twCC;
 667 }
 668
 669 /* ICAP_PHYSICALHEIGHT, ICAP_PHYSICALWIDTH */
 670 static TW_UINT16 SANE_ICAPPhysical (pTW_CAPABILITY pCapability, TW_UINT16 action,  TW_UINT16 cap)
 671 {
 672     TW_UINT16 twCC = TWCC_BADCAP;
 673 #ifdef SONAME_LIBSANE
 674     TW_FIX32 res;
 675     char option_name[64];
 676     SANE_Fixed lower, upper;
 677     SANE_Unit lowerunit, upperunit;
 678     SANE_Status status;
 679
 680     TRACE("ICAP_PHYSICAL%s\n", cap == ICAP_PHYSICALHEIGHT? "HEIGHT" : "WIDTH");
 681
 682     sprintf(option_name, "tl-%c", cap == ICAP_PHYSICALHEIGHT ? 'y' : 'x');
 683     status = sane_option_probe_scan_area(activeDS.deviceHandle, option_name, NULL, &lowerunit, &lower, NULL, NULL);
 684     if (status != SANE_STATUS_GOOD)
 685         return sane_status_to_twcc(status);
 686
 687     sprintf(option_name, "br-%c", cap == ICAP_PHYSICALHEIGHT ? 'y' : 'x');
 688     status = sane_option_probe_scan_area(activeDS.deviceHandle, option_name, NULL, &upperunit, NULL, &upper, NULL);
 689     if (status != SANE_STATUS_GOOD)
 690         return sane_status_to_twcc(status);
 691
 692     if (upperunit != lowerunit)
 693         return TWCC_BADCAP;
 694
 695     if (! convert_sane_res_to_twain(SANE_UNFIX(upper) - SANE_UNFIX(lower), upperunit, &res, TWUN_INCHES))
 696         return TWCC_BADCAP;
 697
 698     switch (action)
 699     {
 700         case MSG_QUERYSUPPORT:
 701             twCC = set_onevalue(pCapability, TWTY_INT32,
 702                     TWQC_GET | TWQC_GETDEFAULT | TWQC_GETCURRENT );
 703             break;
 704
 705         case MSG_GET:
 706         case MSG_GETDEFAULT:
 707
 708             /* .. fall through intentional .. */
 709
 710         case MSG_GETCURRENT:
 711             twCC = set_onevalue(pCapability, TWTY_FIX32, res.Whole | (res.Frac << 16));
 712             break;
 713     }
 714 #endif
 715     return twCC;
 716 }
 717
 718 /* ICAP_PIXELFLAVOR */
 719 static TW_UINT16 SANE_ICAPPixelFlavor (pTW_CAPABILITY pCapability, TW_UINT16 action)
 720 {
 721     TW_UINT16 twCC = TWCC_BADCAP;
 722 #ifdef SONAME_LIBSANE
 723     static const TW_UINT32 possible_values[] = { TWPF_CHOCOLATE, TWPF_VANILLA };
 724     TW_UINT32 val;
 725     TW_UINT32 flavor = activeDS.sane_param.depth == 1 ? TWPF_VANILLA : TWPF_CHOCOLATE;
 726
 727     TRACE("ICAP_PIXELFLAVOR\n");
 728
 729     switch (action)
 730     {
 731         case MSG_QUERYSUPPORT:
 732             twCC = set_onevalue(pCapability, TWTY_INT32,
 733                     TWQC_GET | TWQC_SET | TWQC_GETDEFAULT | TWQC_GETCURRENT | TWQC_RESET );
 734             break;
 735
 736         case MSG_GET:
 737             twCC = msg_get_enum(pCapability, possible_values, sizeof(possible_values) / sizeof(possible_values[0]),
 738                     TWTY_UINT16, flavor, flavor);
 739             break;
 740
 741         case MSG_SET:
 742             twCC = msg_set(pCapability, &val);
 743             if (twCC == TWCC_SUCCESS)
 744             {
 745                FIXME("Stub:  PIXELFLAVOR set to %d, but ignored\n", val);
 746             }
 747             break;
 748
 749         case MSG_GETDEFAULT:
 750             twCC = set_onevalue(pCapability, TWTY_UINT16, flavor);
 751             break;
 752
 753         case MSG_RESET:
 754             /* .. fall through intentional .. */
 755
 756         case MSG_GETCURRENT:
 757             twCC = set_onevalue(pCapability, TWTY_UINT16, flavor);
 758             break;
 759     }
 760 #endif
 761     return twCC;
 762 }
 763
 764 #ifdef SONAME_LIBSANE
 765 static TW_UINT16 get_width_height(double *width, double *height, BOOL max)
 766 {
 767     SANE_Status status;
 768
 769     SANE_Fixed tlx_current, tlx_min, tlx_max;
 770     SANE_Fixed tly_current, tly_min, tly_max;
 771     SANE_Fixed brx_current, brx_min, brx_max;
 772     SANE_Fixed bry_current, bry_min, bry_max;
 773
 774     status = sane_option_probe_scan_area(activeDS.deviceHandle, "tl-x", &tlx_current, NULL, &tlx_min, &tlx_max, NULL);
 775     if (status != SANE_STATUS_GOOD)
 776         return sane_status_to_twcc(status);
 777
 778     status = sane_option_probe_scan_area(activeDS.deviceHandle, "tl-y", &tly_current, NULL, &tly_min, &tly_max, NULL);
 779     if (status != SANE_STATUS_GOOD)
 780         return sane_status_to_twcc(status);
 781
 782     status = sane_option_probe_scan_area(activeDS.deviceHandle, "br-x", &brx_current, NULL, &brx_min, &brx_max, NULL);
 783     if (status != SANE_STATUS_GOOD)
 784         return sane_status_to_twcc(status);
 785
 786     status = sane_option_probe_scan_area(activeDS.deviceHandle, "br-y", &bry_current, NULL, &bry_min, &bry_max, NULL);
 787     if (status != SANE_STATUS_GOOD)
 788         return sane_status_to_twcc(status);
 789
 790     if (max)
 791         *width = SANE_UNFIX(brx_max) - SANE_UNFIX(tlx_min);
 792     else
 793         *width = SANE_UNFIX(brx_current) - SANE_UNFIX(tlx_current);
 794
 795     if (max)
 796         *height = SANE_UNFIX(bry_max) - SANE_UNFIX(tly_min);
 797     else
 798         *height = SANE_UNFIX(bry_current) - SANE_UNFIX(tly_current);
 799
 800     return(TWCC_SUCCESS);
 801 }
 802
 803 static TW_UINT16 set_one_coord(const char *name, double coord)
 804 {
 805     SANE_Status status;
 806     status = sane_option_set_fixed(activeDS.deviceHandle, name, SANE_FIX(coord), NULL);
 807     if (status != SANE_STATUS_GOOD)
 808         return sane_status_to_twcc(status);
 809     return TWCC_SUCCESS;
 810 }
 811
 812 static TW_UINT16 set_width_height(double width, double height)
 813 {
 814     TW_UINT16 rc = TWCC_SUCCESS;
 815     rc = set_one_coord("tl-x", 0);
 816     if (rc != TWCC_SUCCESS)
 817         return rc;
 818     rc = set_one_coord("br-x", width);
 819     if (rc != TWCC_SUCCESS)
 820         return rc;
 821     rc = set_one_coord("tl-y", 0);
 822     if (rc != TWCC_SUCCESS)
 823         return rc;
 824     rc = set_one_coord("br-y", height);
 825
 826     return rc;
 827 }
 828
 829 typedef struct
 830 {
 831     TW_UINT32 size;
 832     double x;
 833     double y;
 834 } supported_size_t;
 835
 836 static const supported_size_t supported_sizes[] =
 837 {
 838     { TWSS_NONE,        0,      0       },
 839     { TWSS_A4,          210,    297     },
 840     { TWSS_JISB5,       182,    257     },
 841     { TWSS_USLETTER,    215.9,  279.4   },
 842     { TWSS_USLEGAL,     215.9,  355.6   },
 843     { TWSS_A5,          148,    210     },
 844     { TWSS_B4,          250,    353     },
 845     { TWSS_B6,          125,    176     },
 846     { TWSS_USLEDGER,    215.9,  431.8   },
 847     { TWSS_USEXECUTIVE, 184.15, 266.7   },
 848     { TWSS_A3,          297,    420     },
 849 };
 850 #define SUPPORTED_SIZE_COUNT (sizeof(supported_sizes) / sizeof(supported_sizes[0]))
 851
 852 static TW_UINT16 get_default_paper_size(const supported_size_t *s, int n)
 853 {
 854     DWORD paper;
 855     int rc;
 856     int defsize = -1;
 857     double width, height;
 858     int i;
 859     rc = GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_IPAPERSIZE | LOCALE_RETURN_NUMBER, (void *) &paper, sizeof(paper));
 860     if (rc > 0)
 861         switch (paper)
 862         {
 863             case 1:
 864                 defsize = TWSS_USLETTER;
 865                 break;
 866             case 5:
 867                 defsize = TWSS_USLEGAL;
 868                 break;
 869             case 8:
 870                 defsize = TWSS_A3;
 871                 break;
 872             case 9:
 873                 defsize = TWSS_A4;
 874                 break;
 875         }
 876
 877     if (defsize == -1)
 878         return TWSS_NONE;
 879
 880     if (get_width_height(&width, &height, TRUE) != TWCC_SUCCESS)
 881         return TWSS_NONE;
 882
 883     for (i = 0; i < n; i++)
 884         if (s[i].size == defsize)
 885         {
 886             /* Sane's use of integers to store floats is a hair lossy; deal with it */
 887             if (s[i].x > (width + .01) || s[i].y > (height + 0.01))
 888                 return TWSS_NONE;
 889             else
 890                 return s[i].size;
 891         }
 892
 893     return TWSS_NONE;
 894 }
 895
 896 static TW_UINT16 get_current_paper_size(const supported_size_t *s, int n)
 897 {
 898     int i;
 899     double width, height;
 900     double xdelta, ydelta;
 901
 902     if (get_width_height(&width, &height, FALSE) != TWCC_SUCCESS)
 903         return TWSS_NONE;
 904
 905     for (i = 0; i < n; i++)
 906     {
 907         /* Sane's use of integers to store floats results
 908          * in a very small error; cope with that */
 909         xdelta = s[i].x - width;
 910         ydelta = s[i].y - height;
 911         if (xdelta < 0.01 && xdelta > -0.01 &&
 912             ydelta < 0.01 && ydelta > -0.01)
 913             return s[i].size;
 914     }
 915
 916     return TWSS_NONE;
 917 }
 918 #endif
 919
 920 /* ICAP_SUPPORTEDSIZES */
 921 static TW_UINT16 SANE_ICAPSupportedSizes (pTW_CAPABILITY pCapability, TW_UINT16 action)
 922 {
 923     TW_UINT16 twCC = TWCC_BADCAP;
 924 #ifdef SONAME_LIBSANE
 925
 926     static TW_UINT32 possible_values[SUPPORTED_SIZE_COUNT];
 927     int i;
 928     TW_UINT32 val;
 929     TW_UINT16 default_size = get_default_paper_size(supported_sizes, SUPPORTED_SIZE_COUNT);
 930     TW_UINT16 current_size = get_current_paper_size(supported_sizes, SUPPORTED_SIZE_COUNT);
 931
 932     TRACE("ICAP_SUPPORTEDSIZES\n");
 933
 934     switch (action)
 935     {
 936         case MSG_QUERYSUPPORT:
 937             twCC = set_onevalue(pCapability, TWTY_INT32,
 938                     TWQC_GET | TWQC_SET | TWQC_GETDEFAULT | TWQC_GETCURRENT | TWQC_RESET );
 939             break;
 940
 941         case MSG_GET:
 942             for (i = 0; i < sizeof(supported_sizes) / sizeof(supported_sizes[0]); i++)
 943                 possible_values[i] = supported_sizes[i].size;
 944             twCC = msg_get_enum(pCapability, possible_values, sizeof(possible_values) / sizeof(possible_values[0]),
 945                     TWTY_UINT16, current_size, default_size);
 946             WARN("Partial Stub:  our supported size selection is a bit thin.\n");
 947             break;
 948
 949         case MSG_SET:
 950             twCC = msg_set(pCapability, &val);
 951             if (twCC == TWCC_SUCCESS)
 952                 for (i = 1; i < SUPPORTED_SIZE_COUNT; i++)
 953                     if (supported_sizes[i].size == val)
 954                         return set_width_height(supported_sizes[i].x, supported_sizes[i].y);
 955
 956             ERR("Unsupported size %d\n", val);
 957             twCC = TWCC_BADCAP;
 958             break;
 959
 960         case MSG_GETDEFAULT:
 961             twCC = set_onevalue(pCapability, TWTY_UINT16, default_size);
 962             break;
 963
 964         case MSG_RESET:
 965             twCC = TWCC_BADCAP;
 966             for (i = 1; i < SUPPORTED_SIZE_COUNT; i++)
 967                 if (supported_sizes[i].size == default_size)
 968                 {
 969                     twCC = set_width_height(supported_sizes[i].x, supported_sizes[i].y);
 970                     break;
 971                 }
 972             if (twCC != TWCC_SUCCESS)
 973                 return twCC;
 974
 975             /* .. fall through intentional .. */
 976
 977         case MSG_GETCURRENT:
 978             twCC = set_onevalue(pCapability, TWTY_UINT16, current_size);
 979             break;
 980     }
 981
 982 #undef SUPPORTED_SIZE_COUNT
 983 #endif
 984     return twCC;
 985 }
 986
 987 /* CAP_AUTOFEED */
 988 static TW_UINT16 SANE_CAPAutofeed (pTW_CAPABILITY pCapability, TW_UINT16 action)
 989 {
 990     TW_UINT16 twCC = TWCC_BADCAP;
 991 #ifdef SONAME_LIBSANE
 992     TW_UINT32 val;
 993     SANE_Bool autofeed;
 994     SANE_Status status;
 995
 996     TRACE("CAP_AUTOFEED\n");
 997
 998     if (sane_option_get_bool(activeDS.deviceHandle, "batch-scan", &autofeed, NULL) != SANE_STATUS_GOOD)
 999         return TWCC_BADCAP;
1000
1001     switch (action)
1002     {
1003         case MSG_QUERYSUPPORT:
1004             twCC = set_onevalue(pCapability, TWTY_INT32,
1005                     TWQC_GET | TWQC_SET | TWQC_GETDEFAULT | TWQC_GETCURRENT | TWQC_RESET );
1006             break;
1007
1008         case MSG_GET:
1009             twCC = set_onevalue(pCapability, TWTY_BOOL, autofeed);
1010             break;
1011
1012         case MSG_SET:
1013             twCC = msg_set(pCapability, &val);
1014             if (twCC == TWCC_SUCCESS)
1015             {
1016                 if (val)
1017                     autofeed = SANE_TRUE;
1018                 else
1019                     autofeed = SANE_FALSE;
1020
1021                 status = sane_option_set_bool(activeDS.deviceHandle, "batch-scan", autofeed, NULL);
1022                 if (status != SANE_STATUS_GOOD)
1023                 {
1024                     ERR("Error %s: Could not set batch-scan to %d\n", psane_strstatus(status), autofeed);
1025                     return sane_status_to_twcc(status);
1026                 }
1027             }
1028             break;
1029
1030         case MSG_GETDEFAULT:
1031             twCC = set_onevalue(pCapability, TWTY_BOOL, SANE_TRUE);
1032             break;
1033
1034         case MSG_RESET:
1035             autofeed = SANE_TRUE;
1036             status = sane_option_set_bool(activeDS.deviceHandle, "batch-scan", autofeed, NULL);
1037             if (status != SANE_STATUS_GOOD)
1038             {
1039                 ERR("Error %s: Could not reset batch-scan to SANE_TRUE\n", psane_strstatus(status));
1040                 return sane_status_to_twcc(status);
1041             }
1042             /* .. fall through intentional .. */
1043
1044         case MSG_GETCURRENT:
1045             twCC = set_onevalue(pCapability, TWTY_BOOL, autofeed);
1046             break;
1047     }
1048 #endif
1049     return twCC;
1050 }
1051
1052 /* CAP_FEEDERENABLED */
1053 static TW_UINT16 SANE_CAPFeederEnabled (pTW_CAPABILITY pCapability, TW_UINT16 action)
1054 {
1055     TW_UINT16 twCC = TWCC_BADCAP;
1056 #ifdef SONAME_LIBSANE
1057     TW_UINT32 val;
1058     TW_BOOL enabled;
1059     SANE_Status status;
1060     SANE_Char source[64];
1061
1062     TRACE("CAP_FEEDERENABLED\n");
1063
1064     if (sane_option_get_str(activeDS.deviceHandle, SANE_NAME_SCAN_SOURCE, source, sizeof(source), NULL) != SANE_STATUS_GOOD)
1065         return TWCC_BADCAP;
1066
1067     if (strcmp(source, "Auto") == 0 || strcmp(source, "ADF") == 0)
1068         enabled = TRUE;
1069     else
1070         enabled = FALSE;
1071
1072     switch (action)
1073     {
1074         case MSG_QUERYSUPPORT:
1075             twCC = set_onevalue(pCapability, TWTY_INT32,
1076                     TWQC_GET | TWQC_SET | TWQC_GETDEFAULT | TWQC_GETCURRENT | TWQC_RESET );
1077             break;
1078
1079         case MSG_GET:
1080             twCC = set_onevalue(pCapability, TWTY_BOOL, enabled);
1081             break;
1082
1083         case MSG_SET:
1084             twCC = msg_set(pCapability, &val);
1085             if (twCC == TWCC_SUCCESS)
1086             {
1087                 if (val)
1088                     enabled = TRUE;
1089                 else
1090                     enabled = FALSE;
1091
1092                 strcpy(source, "ADF");
1093                 status = sane_option_set_str(activeDS.deviceHandle, SANE_NAME_SCAN_SOURCE, source, NULL);
1094                 if (status != SANE_STATUS_GOOD)
1095                 {
1096                     strcpy(source, "Auto");
1097                     status = sane_option_set_str(activeDS.deviceHandle, SANE_NAME_SCAN_SOURCE, source, NULL);
1098                 }
1099                 if (status != SANE_STATUS_GOOD)
1100                 {
1101                     ERR("Error %s: Could not set source to either ADF or Auto\n", psane_strstatus(status));
1102                     return sane_status_to_twcc(status);
1103                 }
1104             }
1105             break;
1106
1107         case MSG_GETDEFAULT:
1108             twCC = set_onevalue(pCapability, TWTY_BOOL, TRUE);
1109             break;
1110
1111         case MSG_RESET:
1112             strcpy(source, "Auto");
1113             if (sane_option_set_str(activeDS.deviceHandle, SANE_NAME_SCAN_SOURCE, source, NULL) == SANE_STATUS_GOOD)
1114                 enabled = TRUE;
1115             twCC = TWCC_SUCCESS;
1116             /* .. fall through intentional .. */
1117
1118         case MSG_GETCURRENT:
1119             twCC = set_onevalue(pCapability, TWTY_BOOL, enabled);
1120             break;
1121     }
1122 #endif
1123     return twCC;
1124 }
1125
1126
1127
1128 TW_UINT16 SANE_SaneCapability (pTW_CAPABILITY pCapability, TW_UINT16 action)
1129 {
1130     TW_UINT16 twCC = TWCC_CAPUNSUPPORTED;
1131
1132     TRACE("capability=%d action=%d\n", pCapability->Cap, action);
1133
1134     switch (pCapability->Cap)
1135     {
1136         case CAP_SUPPORTEDCAPS:
1137             if (action == MSG_GET)
1138                 twCC = TWAIN_GetSupportedCaps(pCapability);
1139             else
1140                 twCC = TWCC_BADVALUE;
1141             break;
1142
1143         case CAP_XFERCOUNT:
1144             twCC = SANE_CAPXferCount (pCapability, action);
1145             break;
1146
1147         case CAP_UICONTROLLABLE:
1148             twCC = SANE_CAPUiControllable (pCapability, action);
1149             break;
1150
1151         case CAP_AUTOFEED:
1152             twCC = SANE_CAPAutofeed (pCapability, action);
1153             break;
1154
1155         case CAP_FEEDERENABLED:
1156             twCC = SANE_CAPFeederEnabled (pCapability, action);
1157             break;
1158
1159         case ICAP_PIXELTYPE:
1160             twCC = SANE_ICAPPixelType (pCapability, action);
1161             break;
1162
1163         case ICAP_UNITS:
1164             twCC = SANE_ICAPUnits (pCapability, action);
1165             break;
1166
1167         case ICAP_BITDEPTH:
1168             twCC = SANE_ICAPBitDepth(pCapability, action);
1169             break;
1170
1171         case ICAP_XFERMECH:
1172             twCC = SANE_ICAPXferMech (pCapability, action);
1173             break;
1174
1175         case ICAP_PIXELFLAVOR:
1176             twCC = SANE_ICAPPixelFlavor (pCapability, action);
1177             break;
1178
1179         case ICAP_COMPRESSION:
1180             twCC = SANE_ICAPCompression(pCapability, action);
1181             break;
1182
1183         case ICAP_XRESOLUTION:
1184             twCC = SANE_ICAPResolution(pCapability, action, pCapability->Cap);
1185             break;
1186
1187         case ICAP_YRESOLUTION:
1188             twCC = SANE_ICAPResolution(pCapability, action, pCapability->Cap);
1189             break;
1190
1191         case ICAP_PHYSICALHEIGHT:
1192             twCC = SANE_ICAPPhysical(pCapability, action, pCapability->Cap);
1193             break;
1194
1195         case ICAP_PHYSICALWIDTH:
1196             twCC = SANE_ICAPPhysical(pCapability, action, pCapability->Cap);
1197             break;
1198
1199         case ICAP_SUPPORTEDSIZES:
1200             twCC = SANE_ICAPSupportedSizes (pCapability, action);
1201             break;
1202
1203         case ICAP_PLANARCHUNKY:
1204             FIXME("ICAP_PLANARCHUNKY not implemented\n");
1205             break;
1206
1207         case ICAP_BITORDER:
1208             FIXME("ICAP_BITORDER not implemented\n");
1209             break;
1210
1211     }
1212
1213     /* Twain specifies that you should return a 0 in response to QUERYSUPPORT,
1214      *   even if you don't formally support the capability */
1215     if (twCC == TWCC_CAPUNSUPPORTED && action == MSG_QUERYSUPPORT)
1216         twCC = set_onevalue(pCapability, 0, TWTY_INT32);
1217
1218     if (twCC == TWCC_CAPUNSUPPORTED)
1219         TRACE("capability 0x%x/action=%d being reported as unsupported\n", pCapability->Cap, action);
1220
1221     return twCC;
1222 }
1223
1224 TW_UINT16 SANE_SaneSetDefaults (void)
1225 {
1226     TW_CAPABILITY cap;
1227
1228     memset(&cap, 0, sizeof(cap));
1229     cap.Cap = CAP_AUTOFEED;
1230     cap.ConType = TWON_DONTCARE16;
1231
1232     if (SANE_SaneCapability(&cap, MSG_RESET) == TWCC_SUCCESS)
1233         GlobalFree(cap.hContainer);
1234
1235     memset(&cap, 0, sizeof(cap));
1236     cap.Cap = CAP_FEEDERENABLED;
1237     cap.ConType = TWON_DONTCARE16;
1238
1239     if (SANE_SaneCapability(&cap, MSG_RESET) == TWCC_SUCCESS)
1240         GlobalFree(cap.hContainer);
1241
1242     memset(&cap, 0, sizeof(cap));
1243     cap.Cap = ICAP_SUPPORTEDSIZES;
1244     cap.ConType = TWON_DONTCARE16;
1245
1246     if (SANE_SaneCapability(&cap, MSG_RESET) == TWCC_SUCCESS)
1247         GlobalFree(cap.hContainer);
1248
1249    return TWCC_SUCCESS;
1250 }