dlls/sane.ds/sane_main.c

   1 /*
   2  * SANE.DS functions
   3  *
   4  * Copyright 2000 Shi Quan He <shiquan@cyberdude.com>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22 #include <stdio.h>
  23
  24 #include "sane_i.h"
  25 #include "wine/debug.h"
  26
  27 WINE_DEFAULT_DEBUG_CHANNEL(twain);
  28
  29 struct tagActiveDS activeDS;
  30
  31 DSMENTRYPROC SANE_dsmentry;
  32 HINSTANCE SANE_instance;
  33 unixlib_handle_t sane_handle = 0;
  34
  35 BOOL WINAPI DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
  36 {
  37     TRACE("%p,%lx,%p\n", hinstDLL, fdwReason, lpvReserved);
  38
  39     switch (fdwReason)
  40     {
  41         case DLL_PROCESS_ATTACH: {
  42             SANE_instance = hinstDLL;
  43             DisableThreadLibraryCalls(hinstDLL);
  44             if (NtQueryVirtualMemory( GetCurrentProcess(), hinstDLL, MemoryWineUnixFuncs,
  45                                       &sane_handle, sizeof(sane_handle), NULL )) return FALSE;
  46             SANE_CALL( process_attach, NULL );
  47             break;
  48         }
  49         case DLL_PROCESS_DETACH:
  50             if (lpvReserved) break;
  51             SANE_CALL( process_detach, NULL );
  52             break;
  53     }
  54
  55     return TRUE;
  56 }
  57
  58 static TW_UINT16 SANE_OpenDS( pTW_IDENTITY pOrigin, pTW_IDENTITY self)
  59 {
  60     if (SANE_dsmentry == NULL)
  61     {
  62         HMODULE moddsm = GetModuleHandleW(L"twain_32");
  63
  64         if (moddsm)
  65             SANE_dsmentry = (void*)GetProcAddress(moddsm, "DSM_Entry");
  66
  67         if (!SANE_dsmentry)
  68         {
  69             ERR("can't find DSM entry point\n");
  70             return TWRC_FAILURE;
  71         }
  72     }
  73
  74     if (SANE_CALL( open_ds, self )) return TWRC_FAILURE;
  75
  76     activeDS.twCC = SANE_SaneSetDefaults();
  77     if (activeDS.twCC == TWCC_SUCCESS)
  78     {
  79         activeDS.currentState = 4;
  80         activeDS.identity.Id = self->Id;
  81         activeDS.appIdentity = *pOrigin;
  82         return TWRC_SUCCESS;
  83     }
  84     SANE_CALL( close_ds, NULL );
  85     return TWRC_FAILURE;
  86 }
  87
  88 static TW_UINT16 SANE_SetEntryPoint (pTW_IDENTITY pOrigin, TW_MEMREF pData);
  89
  90 static TW_UINT16 SANE_SourceControlHandler (
  91            pTW_IDENTITY pOrigin,
  92            TW_UINT16    DAT,
  93            TW_UINT16    MSG,
  94            TW_MEMREF    pData)
  95 {
  96     TW_UINT16 twRC = TWRC_SUCCESS;
  97
  98     switch (DAT)
  99     {
 100         case DAT_IDENTITY:
 101             switch (MSG)
 102             {
 103                 case MSG_CLOSEDS:
 104                     SANE_CALL( close_ds, NULL );
 105                     break;
 106                 case MSG_OPENDS:
 107                      twRC = SANE_OpenDS( pOrigin, (pTW_IDENTITY)pData);
 108                      break;
 109                 case MSG_GET:
 110                 {
 111                     if (SANE_CALL( get_identity, pData ))
 112                     {
 113                         activeDS.twCC = TWCC_CAPUNSUPPORTED;
 114                         twRC = TWRC_FAILURE;
 115                     }
 116                     break;
 117                 }
 118             }
 119             break;
 120         case DAT_CAPABILITY:
 121             switch (MSG)
 122             {
 123                 case MSG_GET:
 124                     twRC = SANE_CapabilityGet (pOrigin, pData);
 125                     break;
 126                 case MSG_GETCURRENT:
 127                     twRC = SANE_CapabilityGetCurrent (pOrigin, pData);
 128                     break;
 129                 case MSG_GETDEFAULT:
 130                     twRC = SANE_CapabilityGetDefault (pOrigin, pData);
 131                     break;
 132                 case MSG_QUERYSUPPORT:
 133                     twRC = SANE_CapabilityQuerySupport (pOrigin, pData);
 134                     break;
 135                 case MSG_RESET:
 136                     twRC = SANE_CapabilityReset (pOrigin, pData);
 137                     break;
 138                 case MSG_SET:
 139                     twRC = SANE_CapabilitySet (pOrigin, pData);
 140                     break;
 141                 default:
 142                     twRC = TWRC_FAILURE;
 143                     activeDS.twCC = TWCC_CAPBADOPERATION;
 144                     FIXME("unrecognized operation triplet\n");
 145                     break;
 146             }
 147             break;
 148
 149         case DAT_ENTRYPOINT:
 150             if (MSG == MSG_SET)
 151                 twRC = SANE_SetEntryPoint (pOrigin, pData);
 152             else
 153             {
 154                 twRC = TWRC_FAILURE;
 155                 activeDS.twCC = TWCC_CAPBADOPERATION;
 156                 FIXME("unrecognized operation triplet\n");
 157             }
 158             break;
 159
 160         case DAT_EVENT:
 161             if (MSG == MSG_PROCESSEVENT)
 162                 twRC = SANE_ProcessEvent (pOrigin, pData);
 163             else
 164             {
 165                 activeDS.twCC = TWCC_CAPBADOPERATION;
 166                 twRC = TWRC_FAILURE;
 167             }
 168             break;
 169
 170         case DAT_PENDINGXFERS:
 171             switch (MSG)
 172             {
 173                 case MSG_ENDXFER:
 174                     twRC = SANE_PendingXfersEndXfer (pOrigin, pData);
 175                     break;
 176                 case MSG_GET:
 177                     twRC = SANE_PendingXfersGet (pOrigin, pData);
 178                     break;
 179                 case MSG_RESET:
 180                     twRC = SANE_PendingXfersReset (pOrigin, pData);
 181                     break;
 182                 default:
 183                     activeDS.twCC = TWCC_CAPBADOPERATION;
 184                     twRC = TWRC_FAILURE;
 185             }
 186             break;
 187
 188         case DAT_SETUPMEMXFER:
 189             if (MSG == MSG_GET)
 190                 twRC = SANE_SetupMemXferGet (pOrigin, pData);
 191             else
 192             {
 193                 activeDS.twCC = TWCC_CAPBADOPERATION;
 194                 twRC = TWRC_FAILURE;
 195             }
 196             break;
 197
 198         case DAT_STATUS:
 199             if (MSG == MSG_GET)
 200                 twRC = SANE_GetDSStatus (pOrigin, pData);
 201             else
 202             {
 203                 activeDS.twCC = TWCC_CAPBADOPERATION;
 204                 twRC = TWRC_FAILURE;
 205             }
 206             break;
 207
 208         case DAT_USERINTERFACE:
 209             switch (MSG)
 210             {
 211                 case MSG_DISABLEDS:
 212                     twRC = SANE_DisableDSUserInterface (pOrigin, pData);
 213                     break;
 214                 case MSG_ENABLEDS:
 215                     twRC = SANE_EnableDSUserInterface (pOrigin, pData);
 216                     break;
 217                 case MSG_ENABLEDSUIONLY:
 218                     twRC = SANE_EnableDSUIOnly (pOrigin, pData);
 219                     break;
 220                 default:
 221                     activeDS.twCC = TWCC_CAPBADOPERATION;
 222                     twRC = TWRC_FAILURE;
 223                     break;
 224             }
 225             break;
 226
 227         case DAT_XFERGROUP:
 228             switch (MSG)
 229             {
 230                 case MSG_GET:
 231                     twRC = SANE_XferGroupGet (pOrigin, pData);
 232                     break;
 233                 case MSG_SET:
 234                     twRC = SANE_XferGroupSet (pOrigin, pData);
 235                     break;
 236                 default:
 237                     activeDS.twCC = TWCC_CAPBADOPERATION;
 238                     twRC = TWRC_FAILURE;
 239                     break;
 240             }
 241             break;
 242
 243         default:
 244             WARN("code unsupported: %d\n", DAT);
 245             activeDS.twCC = TWCC_CAPUNSUPPORTED;
 246             twRC = TWRC_FAILURE;
 247             break;
 248     }
 249
 250     return twRC;
 251 }
 252
 253
 254 static TW_UINT16 SANE_ImageGroupHandler (
 255            pTW_IDENTITY pOrigin,
 256            TW_UINT16    DAT,
 257            TW_UINT16    MSG,
 258            TW_MEMREF    pData)
 259 {
 260     TW_UINT16 twRC = TWRC_SUCCESS;
 261
 262     switch (DAT)
 263     {
 264         case DAT_IMAGEINFO:
 265             if (MSG == MSG_GET)
 266                 twRC = SANE_ImageInfoGet (pOrigin, pData);
 267             else
 268             {
 269                 activeDS.twCC = TWCC_CAPBADOPERATION;
 270                 twRC = TWRC_FAILURE;
 271             }
 272             break;
 273
 274         case DAT_IMAGELAYOUT:
 275             switch (MSG)
 276             {
 277                 case MSG_GET:
 278                     twRC = SANE_ImageLayoutGet (pOrigin, pData);
 279                     break;
 280                 case MSG_GETDEFAULT:
 281                     twRC = SANE_ImageLayoutGetDefault (pOrigin, pData);
 282                     break;
 283                 case MSG_RESET:
 284                     twRC = SANE_ImageLayoutReset (pOrigin, pData);
 285                     break;
 286                 case MSG_SET:
 287                     twRC = SANE_ImageLayoutSet (pOrigin, pData);
 288                     break;
 289                 default:
 290                     twRC = TWRC_FAILURE;
 291                     activeDS.twCC = TWCC_CAPBADOPERATION;
 292                     ERR("unrecognized operation triplet\n");
 293                     break;
 294             }
 295             break;
 296
 297         case DAT_IMAGEMEMXFER:
 298             if (MSG == MSG_GET)
 299                 twRC = SANE_ImageMemXferGet (pOrigin, pData);
 300             else
 301             {
 302                 activeDS.twCC = TWCC_CAPBADOPERATION;
 303                 twRC = TWRC_FAILURE;
 304             }
 305             break;
 306
 307         case DAT_IMAGENATIVEXFER:
 308             if (MSG == MSG_GET)
 309                 twRC = SANE_ImageNativeXferGet (pOrigin, pData);
 310             else
 311             {
 312                 activeDS.twCC = TWCC_CAPBADOPERATION;
 313                 twRC = TWRC_FAILURE;
 314             }
 315             break;
 316
 317         default:
 318             twRC = TWRC_FAILURE;
 319             activeDS.twCC = TWCC_CAPUNSUPPORTED;
 320             WARN("unsupported DG type %d\n", DAT);
 321             break;
 322     }
 323     return twRC;
 324 }
 325
 326 /* Main entry point for the TWAIN library */
 327 TW_UINT16 WINAPI
 328 DS_Entry ( pTW_IDENTITY pOrigin,
 329            TW_UINT32    DG,
 330            TW_UINT16    DAT,
 331            TW_UINT16    MSG,
 332            TW_MEMREF    pData)
 333 {
 334     TW_UINT16 twRC = TWRC_SUCCESS;  /* Return Code */
 335
 336     TRACE("(DG=%ld DAT=%d MSG=%d)\n", DG, DAT, MSG);
 337
 338     switch (DG)
 339     {
 340         case DG_CONTROL:
 341             twRC = SANE_SourceControlHandler (pOrigin,DAT,MSG,pData);
 342             break;
 343         case DG_IMAGE:
 344             twRC = SANE_ImageGroupHandler (pOrigin,DAT,MSG,pData);
 345             break;
 346         case DG_AUDIO:
 347             WARN("Audio group of controls not implemented yet.\n");
 348             twRC = TWRC_FAILURE;
 349             activeDS.twCC = TWCC_CAPUNSUPPORTED;
 350             break;
 351         default:
 352             activeDS.twCC = TWCC_BADPROTOCOL;
 353             twRC = TWRC_FAILURE;
 354     }
 355
 356     return twRC;
 357 }
 358
 359 void SANE_Notify (TW_UINT16 message)
 360 {
 361     SANE_dsmentry (&activeDS.identity, &activeDS.appIdentity, DG_CONTROL, DAT_NULL, message, NULL);
 362 }
 363
 364 /* DG_CONTROL/DAT_ENTRYPOINT/MSG_SET */
 365 TW_UINT16 SANE_SetEntryPoint (pTW_IDENTITY pOrigin, TW_MEMREF pData)
 366 {
 367     TW_ENTRYPOINT *entry = (TW_ENTRYPOINT*)pData;
 368
 369     SANE_dsmentry = entry->DSM_Entry;
 370
 371     return TWRC_SUCCESS;
 372 }