git.oblomov.eu Git - wine/blob - dlls/sane.ds/ds_ctrl.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 #include "config.h"
  20
  21 #ifdef HAVE_UNISTD_H
  22 # include <unistd.h>
  23 #endif
  24 #include <stdlib.h>
  25 #include "sane_i.h"
  26 #include "wine/debug.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(twain);
  29
  30 /* DG_CONTROL/DAT_CAPABILITY/MSG_GET */
  31 TW_UINT16 SANE_CapabilityGet (pTW_IDENTITY pOrigin, TW_MEMREF pData)
  32 {
  33     TW_UINT16 twRC = TWRC_SUCCESS, twCC = TWCC_SUCCESS;
  34     pTW_CAPABILITY pCapability = (pTW_CAPABILITY) pData;
  35
  36     TRACE("DG_CONTROL/DAT_CAPABILITY/MSG_GET\n");
  37
  38     if (activeDS.currentState < 4 || activeDS.currentState > 7)
  39     {
  40         twRC = TWRC_FAILURE;
  41         activeDS.twCC = TWCC_SEQERROR;
  42     }
  43     else
  44     {
  45         twCC = SANE_SaneCapability (pCapability, MSG_GET);
  46         twRC = (twCC == TWCC_SUCCESS)?TWRC_SUCCESS:TWRC_FAILURE;
  47         activeDS.twCC = twCC;
  48     }
  49
  50     return twRC;
  51 }
  52
  53 /* DG_CONTROL/DAT_CAPABILITY/MSG_GETCURRENT */
  54 TW_UINT16 SANE_CapabilityGetCurrent (pTW_IDENTITY pOrigin, TW_MEMREF pData)
  55 {
  56     TW_UINT16 twRC = TWRC_SUCCESS, twCC = TWCC_SUCCESS;
  57     pTW_CAPABILITY pCapability = (pTW_CAPABILITY) pData;
  58
  59     TRACE("DG_CONTROL/DAT_CAPABILITY/MSG_GETCURRENT\n");
  60
  61     if (activeDS.currentState < 4 || activeDS.currentState > 7)
  62     {
  63         twRC = TWRC_FAILURE;
  64         activeDS.twCC = TWCC_SEQERROR;
  65     }
  66     else
  67     {
  68         twCC = SANE_SaneCapability (pCapability, MSG_GETCURRENT);
  69         twRC = (twCC == TWCC_SUCCESS)?TWRC_SUCCESS:TWRC_FAILURE;
  70         activeDS.twCC = twCC;
  71     }
  72
  73     return twRC;
  74 }
  75
  76 /* DG_CONTROL/DAT_CAPABILITY/MSG_GETDEFAULT */
  77 TW_UINT16 SANE_CapabilityGetDefault (pTW_IDENTITY pOrigin, TW_MEMREF pData)
  78 {
  79     TW_UINT16 twRC = TWRC_SUCCESS, twCC = TWCC_SUCCESS;
  80     pTW_CAPABILITY pCapability = (pTW_CAPABILITY) pData;
  81
  82     TRACE("DG_CONTROL/DAT_CAPABILITY/MSG_GETDEFAULT\n");
  83
  84     if (activeDS.currentState < 4 || activeDS.currentState > 7)
  85     {
  86         twRC = TWRC_FAILURE;
  87         activeDS.twCC = TWCC_SEQERROR;
  88     }
  89     else
  90     {
  91         twCC = SANE_SaneCapability (pCapability, MSG_GETDEFAULT);
  92         twRC = (twCC == TWCC_SUCCESS)?TWRC_SUCCESS:TWRC_FAILURE;
  93         activeDS.twCC = twCC;
  94     }
  95
  96     return twRC;
  97 }
  98
  99 /* DG_CONTROL/DAT_CAPABILITY/MSG_QUERYSUPPORT */
 100 TW_UINT16 SANE_CapabilityQuerySupport (pTW_IDENTITY pOrigin,
 101                                         TW_MEMREF pData)
 102 {
 103     TW_UINT16 twRC = TWRC_SUCCESS, twCC = TWCC_SUCCESS;
 104     pTW_CAPABILITY pCapability = (pTW_CAPABILITY) pData;
 105
 106     TRACE("DG_CONTROL/DAT_CAPABILITY/MSG_QUERYSUPPORT\n");
 107
 108     if (activeDS.currentState < 4 || activeDS.currentState > 7)
 109     {
 110         twRC = TWRC_FAILURE;
 111         activeDS.twCC = TWCC_SEQERROR;
 112     }
 113     else
 114     {
 115         twCC = SANE_SaneCapability (pCapability, MSG_QUERYSUPPORT);
 116         twRC = (twCC == TWCC_SUCCESS)?TWRC_SUCCESS:TWRC_FAILURE;
 117         activeDS.twCC = twCC;
 118     }
 119
 120     return twRC;
 121 }
 122
 123 /* DG_CONTROL/DAT_CAPABILITY/MSG_RESET */
 124 TW_UINT16 SANE_CapabilityReset (pTW_IDENTITY pOrigin,
 125                                  TW_MEMREF pData)
 126 {
 127     TW_UINT16 twRC = TWRC_SUCCESS, twCC = TWCC_SUCCESS;
 128     pTW_CAPABILITY pCapability = (pTW_CAPABILITY) pData;
 129
 130     TRACE("DG_CONTROL/DAT_CAPABILITY/MSG_RESET\n");
 131
 132     if (activeDS.currentState < 4 || activeDS.currentState > 7)
 133     {
 134         twRC = TWRC_FAILURE;
 135         activeDS.twCC = TWCC_SEQERROR;
 136     }
 137     else
 138     {
 139         twCC = SANE_SaneCapability (pCapability, MSG_RESET);
 140         twRC = (twCC == TWCC_SUCCESS)?TWRC_SUCCESS:TWRC_FAILURE;
 141         activeDS.twCC = twCC;
 142     }
 143
 144     return twRC;
 145 }
 146
 147 /* DG_CONTROL/DAT_CAPABILITY/MSG_SET */
 148 TW_UINT16 SANE_CapabilitySet (pTW_IDENTITY pOrigin,
 149                                TW_MEMREF pData)
 150 {
 151     TW_UINT16 twRC = TWRC_SUCCESS, twCC = TWCC_SUCCESS;
 152     pTW_CAPABILITY pCapability = (pTW_CAPABILITY) pData;
 153
 154     TRACE ("DG_CONTROL/DAT_CAPABILITY/MSG_SET\n");
 155
 156     if (activeDS.currentState != 4)
 157     {
 158         twRC = TWRC_FAILURE;
 159         activeDS.twCC = TWCC_SEQERROR;
 160     }
 161     else
 162     {
 163         twCC = SANE_SaneCapability (pCapability, MSG_SET);
 164         if (twCC == TWCC_CHECKSTATUS)
 165         {
 166             twCC = TWCC_SUCCESS;
 167             twRC = TWRC_CHECKSTATUS;
 168         }
 169         else
 170             twRC = (twCC == TWCC_SUCCESS)?TWRC_SUCCESS:TWRC_FAILURE;
 171         activeDS.twCC = twCC;
 172     }
 173     return twRC;
 174 }
 175
 176 /* DG_CONTROL/DAT_EVENT/MSG_PROCESSEVENT */
 177 TW_UINT16 SANE_ProcessEvent (pTW_IDENTITY pOrigin,
 178                               TW_MEMREF pData)
 179 {
 180     TW_UINT16 twRC = TWRC_NOTDSEVENT;
 181     pTW_EVENT pEvent = (pTW_EVENT) pData;
 182     MSG *pMsg = pEvent->pEvent;
 183
 184     TRACE("DG_CONTROL/DAT_EVENT/MSG_PROCESSEVENT  msg 0x%x, wParam 0x%lx\n", pMsg->message, pMsg->wParam);
 185
 186     activeDS.twCC = TWCC_SUCCESS;
 187     if (pMsg->message == activeDS.windowMessage && activeDS.windowMessage)
 188     {
 189         twRC = TWRC_DSEVENT;
 190         pEvent->TWMessage = pMsg->wParam;
 191     }
 192     else
 193         pEvent->TWMessage = MSG_NULL;  /* no message to the application */
 194
 195     if (activeDS.currentState < 5 || activeDS.currentState > 7)
 196     {
 197         twRC = TWRC_FAILURE;
 198         activeDS.twCC = TWCC_SEQERROR;
 199     }
 200
 201     return twRC;
 202 }
 203
 204 /* DG_CONTROL/DAT_PENDINGXFERS/MSG_ENDXFER */
 205 TW_UINT16 SANE_PendingXfersEndXfer (pTW_IDENTITY pOrigin,
 206                                      TW_MEMREF pData)
 207 {
 208 #ifndef SONAME_LIBSANE
 209     return TWRC_FAILURE;
 210 #else
 211     TW_UINT16 twRC = TWRC_SUCCESS;
 212     pTW_PENDINGXFERS pPendingXfers = (pTW_PENDINGXFERS) pData;
 213     SANE_Status status;
 214
 215     TRACE("DG_CONTROL/DAT_PENDINGXFERS/MSG_ENDXFER\n");
 216
 217     if (activeDS.currentState != 6 && activeDS.currentState != 7)
 218     {
 219         twRC = TWRC_FAILURE;
 220         activeDS.twCC = TWCC_SEQERROR;
 221     }
 222     else
 223     {
 224         pPendingXfers->Count = -1;
 225         activeDS.currentState = 6;
 226         if (! activeDS.sane_started)
 227         {
 228             status = psane_start (activeDS.deviceHandle);
 229             if (status != SANE_STATUS_GOOD)
 230             {
 231                 TRACE("PENDINGXFERS/MSG_ENDXFER sane_start returns %s\n", psane_strstatus(status));
 232                 pPendingXfers->Count = 0;
 233                 activeDS.currentState = 5;
 234                 /* Notify the application that it can close the data source */
 235                 if (activeDS.windowMessage)
 236                     PostMessageA(activeDS.hwndOwner, activeDS.windowMessage, MSG_CLOSEDSREQ, 0);
 237             }
 238             else
 239                 activeDS.sane_started = TRUE;
 240         }
 241         twRC = TWRC_SUCCESS;
 242         activeDS.twCC = TWCC_SUCCESS;
 243     }
 244
 245     return twRC;
 246 #endif
 247 }
 248
 249 /* DG_CONTROL/DAT_PENDINGXFERS/MSG_GET */
 250 TW_UINT16 SANE_PendingXfersGet (pTW_IDENTITY pOrigin,
 251                                  TW_MEMREF pData)
 252 {
 253 #ifndef SONAME_LIBSANE
 254     return TWRC_FAILURE;
 255 #else
 256     TW_UINT16 twRC = TWRC_SUCCESS;
 257     pTW_PENDINGXFERS pPendingXfers = (pTW_PENDINGXFERS) pData;
 258     SANE_Status status;
 259
 260     TRACE("DG_CONTROL/DAT_PENDINGXFERS/MSG_GET\n");
 261
 262     if (activeDS.currentState < 4 || activeDS.currentState > 7)
 263     {
 264         twRC = TWRC_FAILURE;
 265         activeDS.twCC = TWCC_SEQERROR;
 266     }
 267     else
 268     {
 269         pPendingXfers->Count = -1;
 270         if (! activeDS.sane_started)
 271         {
 272             status = psane_start (activeDS.deviceHandle);
 273             if (status != SANE_STATUS_GOOD)
 274             {
 275                 TRACE("PENDINGXFERS/MSG_GET sane_start returns %s\n", psane_strstatus(status));
 276                 pPendingXfers->Count = 0;
 277             }
 278             else
 279                 activeDS.sane_started = TRUE;
 280         }
 281         twRC = TWRC_SUCCESS;
 282         activeDS.twCC = TWCC_SUCCESS;
 283     }
 284
 285     return twRC;
 286 #endif
 287 }
 288
 289 /* DG_CONTROL/DAT_PENDINGXFERS/MSG_RESET */
 290 TW_UINT16 SANE_PendingXfersReset (pTW_IDENTITY pOrigin,
 291                                    TW_MEMREF pData)
 292 {
 293 #ifndef SONAME_LIBSANE
 294     return TWRC_FAILURE;
 295 #else
 296     TW_UINT16 twRC = TWRC_SUCCESS;
 297     pTW_PENDINGXFERS pPendingXfers = (pTW_PENDINGXFERS) pData;
 298
 299     TRACE("DG_CONTROL/DAT_PENDINGXFERS/MSG_RESET\n");
 300
 301     if (activeDS.currentState != 6)
 302     {
 303         twRC = TWRC_FAILURE;
 304         activeDS.twCC = TWCC_SEQERROR;
 305     }
 306     else
 307     {
 308         pPendingXfers->Count = 0;
 309         activeDS.currentState = 5;
 310         twRC = TWRC_SUCCESS;
 311         activeDS.twCC = TWCC_SUCCESS;
 312
 313         if (activeDS.sane_started)
 314         {
 315             psane_cancel (activeDS.deviceHandle);
 316             activeDS.sane_started = FALSE;
 317         }
 318     }
 319
 320     return twRC;
 321 #endif
 322 }
 323
 324 /* DG_CONTROL/DAT_SETUPMEMXFER/MSG_GET */
 325 TW_UINT16 SANE_SetupMemXferGet (pTW_IDENTITY pOrigin,
 326                                   TW_MEMREF pData)
 327 {
 328 #ifndef SONAME_LIBSANE
 329     return TWRC_FAILURE;
 330 #else
 331     pTW_SETUPMEMXFER  pSetupMemXfer = (pTW_SETUPMEMXFER)pData;
 332
 333     TRACE("DG_CONTROL/DAT_SETUPMEMXFER/MSG_GET\n");
 334     if (activeDS.sane_param_valid)
 335     {
 336         pSetupMemXfer->MinBufSize = activeDS.sane_param.bytes_per_line;
 337         pSetupMemXfer->MaxBufSize = activeDS.sane_param.bytes_per_line * 8;
 338         pSetupMemXfer->Preferred = activeDS.sane_param.bytes_per_line * 2;
 339     }
 340     else
 341     {
 342         /* Guessing */
 343         pSetupMemXfer->MinBufSize = 2000;
 344         pSetupMemXfer->MaxBufSize = 8000;
 345         pSetupMemXfer->Preferred = 4000;
 346     }
 347
 348     return TWRC_SUCCESS;
 349 #endif
 350 }
 351
 352 /* DG_CONTROL/DAT_STATUS/MSG_GET */
 353 TW_UINT16 SANE_GetDSStatus (pTW_IDENTITY pOrigin,
 354                              TW_MEMREF pData)
 355 {
 356     pTW_STATUS pSourceStatus = (pTW_STATUS) pData;
 357
 358     TRACE ("DG_CONTROL/DAT_STATUS/MSG_GET\n");
 359     pSourceStatus->ConditionCode = activeDS.twCC;
 360     /* Reset the condition code */
 361     activeDS.twCC = TWCC_SUCCESS;
 362     return TWRC_SUCCESS;
 363 }
 364
 365 /* DG_CONTROL/DAT_USERINTERFACE/MSG_DISABLEDS */
 366 TW_UINT16 SANE_DisableDSUserInterface (pTW_IDENTITY pOrigin,
 367                                         TW_MEMREF pData)
 368 {
 369     TW_UINT16 twRC = TWRC_SUCCESS;
 370
 371     TRACE ("DG_CONTROL/DAT_USERINTERFACE/MSG_DISABLEDS\n");
 372
 373     if (activeDS.currentState != 5)
 374     {
 375         twRC = TWRC_FAILURE;
 376         activeDS.twCC = TWCC_SEQERROR;
 377     }
 378     else
 379     {
 380         activeDS.currentState = 4;
 381         twRC = TWRC_SUCCESS;
 382         activeDS.twCC = TWCC_SUCCESS;
 383     }
 384
 385     return twRC;
 386 }
 387
 388 /* DG_CONTROL/DAT_USERINTERFACE/MSG_ENABLEDS */
 389 TW_UINT16 SANE_EnableDSUserInterface (pTW_IDENTITY pOrigin,
 390                                        TW_MEMREF pData)
 391 {
 392     TW_UINT16 twRC = TWRC_SUCCESS;
 393     pTW_USERINTERFACE pUserInterface = (pTW_USERINTERFACE) pData;
 394
 395     TRACE ("DG_CONTROL/DAT_USERINTERFACE/MSG_ENABLEDS\n");
 396
 397     if (activeDS.currentState != 4)
 398     {
 399         twRC = TWRC_FAILURE;
 400         activeDS.twCC = TWCC_SEQERROR;
 401         WARN("sequence error %d\n", activeDS.currentState);
 402     }
 403     else
 404     {
 405         activeDS.hwndOwner = pUserInterface->hParent;
 406         if (! activeDS.windowMessage)
 407             activeDS.windowMessage = RegisterWindowMessageA("SANE.DS ACTIVITY MESSAGE");
 408         if (pUserInterface->ShowUI)
 409         {
 410             BOOL rc;
 411             activeDS.currentState = 5; /* Transitions to state 5 */
 412             rc = DoScannerUI();
 413             pUserInterface->ModalUI = TRUE;
 414             if (!rc)
 415             {
 416                 if (activeDS.windowMessage)
 417                     PostMessageA(activeDS.hwndOwner, activeDS.windowMessage, MSG_CLOSEDSREQ, 0);
 418             }
 419 #ifdef SONAME_LIBSANE
 420             else
 421             {
 422                 psane_get_parameters (activeDS.deviceHandle, &activeDS.sane_param);
 423                 activeDS.sane_param_valid = TRUE;
 424             }
 425 #endif
 426         }
 427         else
 428         {
 429             /* no UI will be displayed, so source is ready to transfer data */
 430             activeDS.currentState = 6; /* Transitions to state 6 directly */
 431             if (activeDS.windowMessage)
 432                 PostMessageA(activeDS.hwndOwner, activeDS.windowMessage, MSG_XFERREADY, 0);
 433         }
 434
 435         twRC = TWRC_SUCCESS;
 436         activeDS.twCC = TWCC_SUCCESS;
 437     }
 438
 439     return twRC;
 440 }
 441
 442 /* DG_CONTROL/DAT_USERINTERFACE/MSG_ENABLEDSUIONLY */
 443 TW_UINT16 SANE_EnableDSUIOnly (pTW_IDENTITY pOrigin,
 444                                 TW_MEMREF pData)
 445 {
 446     TW_UINT16 twRC = TWRC_SUCCESS;
 447
 448     TRACE("DG_CONTROL/DAT_USERINTERFACE/MSG_ENABLEDSUIONLY\n");
 449
 450     if (activeDS.currentState != 4)
 451     {
 452         twRC = TWRC_FAILURE;
 453         activeDS.twCC = TWCC_SEQERROR;
 454     }
 455     else
 456     {
 457         /* FIXME: we should replace xscanimage with our own UI */
 458         system ("xscanimage");
 459         activeDS.currentState = 5;
 460         twRC = TWRC_SUCCESS;
 461         activeDS.twCC = TWCC_SUCCESS;
 462     }
 463
 464     return twRC;
 465 }
 466
 467 /* DG_CONTROL/DAT_XFERGROUP/MSG_GET */
 468 TW_UINT16 SANE_XferGroupGet (pTW_IDENTITY pOrigin,
 469                               TW_MEMREF pData)
 470 {
 471     FIXME ("stub!\n");
 472
 473     return TWRC_FAILURE;
 474 }
 475
 476 /* DG_CONTROL/DAT_XFERGROUP/MSG_SET */
 477 TW_UINT16 SANE_XferGroupSet (pTW_IDENTITY pOrigin,
 478                                   TW_MEMREF pData)
 479 {
 480     FIXME ("stub!\n");
 481
 482     return TWRC_FAILURE;
 483 }