dlls/gphoto2.ds/gphoto2_main.c

   1 /*
   2  * SANE.DS functions
   3  *
   4  * Copyright 2000 Shi Quan He <shiquan@cyberdude.com>
   5  * Copyright 2006 Marcus Meissner
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "config.h"
  23
  24 #include <stdarg.h>
  25 #include <stdio.h>
  26 #ifdef HAVE_UNISTD_H
  27 # include <unistd.h>
  28 #endif
  29 #include <stdlib.h>
  30
  31 #include "gphoto2_i.h"
  32 #include "wine/debug.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(twain);
  35
  36 struct tagActiveDS activeDS;
  37
  38 DSMENTRYPROC GPHOTO2_dsmentry;
  39
  40 #ifdef HAVE_GPHOTO2
  41 static char* GPHOTO2_StrDup(const char* str)
  42 {
  43     char* dst = HeapAlloc(GetProcessHeap(), 0, strlen(str)+1);
  44     strcpy(dst, str);
  45     return dst;
  46 }
  47 #endif
  48
  49 static void
  50 load_filesystem(const char *folder) {
  51 #ifdef HAVE_GPHOTO2
  52     int         i, count, ret;
  53     CameraList  *list;
  54
  55     ret = gp_list_new (&list);
  56     if (ret < GP_OK)
  57         return;
  58     ret = gp_camera_folder_list_files (activeDS.camera, folder, list, activeDS.context);
  59     if (ret < GP_OK) {
  60         gp_list_free (list);
  61         return;
  62     }
  63     count = gp_list_count (list);
  64     if (count < GP_OK) {
  65         gp_list_free (list);
  66         return;
  67     }
  68     for (i = 0; i < count; i++) {
  69         const char *name;
  70         struct gphoto2_file *gpfile;
  71
  72         ret = gp_list_get_name (list, i, &name);
  73         if (ret < GP_OK)
  74             continue;
  75         gpfile = HeapAlloc(GetProcessHeap(), 0, sizeof(struct gphoto2_file)); /* FIXME: Leaked */
  76         if (!gpfile)
  77             continue;
  78         TRACE("adding %s/%s\n", folder, name);
  79         gpfile->folder = GPHOTO2_StrDup(folder);
  80         gpfile->filename = GPHOTO2_StrDup(name);
  81         gpfile->download = FALSE;
  82         list_add_tail( &activeDS.files, &gpfile->entry );
  83     }
  84     gp_list_reset (list);
  85
  86     ret = gp_camera_folder_list_folders (activeDS.camera, folder, list, activeDS.context);
  87     if (ret < GP_OK) {
  88         FIXME("list_folders failed\n");
  89         gp_list_free (list);
  90         return;
  91     }
  92     count = gp_list_count (list);
  93     if (count < GP_OK) {
  94         FIXME("list_folders failed\n");
  95         gp_list_free (list);
  96         return;
  97     }
  98     for (i = 0; i < count; i++) {
  99         const char *name;
 100         char *newfolder;
 101         ret = gp_list_get_name (list, i, &name);
 102         if (ret < GP_OK)
 103             continue;
 104         TRACE("recursing into %s\n", name);
 105         newfolder = HeapAlloc(GetProcessHeap(), 0, strlen(folder)+1+strlen(name)+1);
 106         if (!strcmp(folder,"/"))
 107             sprintf (newfolder, "/%s", name);
 108         else
 109             sprintf (newfolder, "%s/%s", folder, name);
 110         load_filesystem (newfolder); /* recurse ... happily */
 111     }
 112     gp_list_free (list);
 113 #endif
 114 }
 115
 116 /* DG_CONTROL/DAT_CAPABILITY/MSG_GET */
 117 static TW_UINT16 GPHOTO2_CapabilityGet (pTW_IDENTITY pOrigin, TW_MEMREF pData)
 118 {
 119     pTW_CAPABILITY pCapability = (pTW_CAPABILITY) pData;
 120
 121     TRACE("DG_CONTROL/DAT_CAPABILITY/MSG_GET\n");
 122     if (activeDS.currentState < 4 || activeDS.currentState > 7) {
 123         activeDS.twCC = TWCC_SEQERROR;
 124         return TWRC_FAILURE;
 125     }
 126     activeDS.twCC = GPHOTO2_SaneCapability (pCapability, MSG_GET);
 127     return (activeDS.twCC == TWCC_SUCCESS)?TWRC_SUCCESS:TWRC_FAILURE;
 128 }
 129
 130 /* DG_CONTROL/DAT_CAPABILITY/MSG_GETCURRENT */
 131 static TW_UINT16 GPHOTO2_CapabilityGetCurrent (pTW_IDENTITY pOrigin, TW_MEMREF pData)
 132 {
 133     pTW_CAPABILITY pCapability = (pTW_CAPABILITY) pData;
 134
 135     TRACE("DG_CONTROL/DAT_CAPABILITY/MSG_GETCURRENT\n");
 136
 137     if (activeDS.currentState < 4 || activeDS.currentState > 7) {
 138         activeDS.twCC = TWCC_SEQERROR;
 139         return TWRC_FAILURE;
 140     }
 141     activeDS.twCC = GPHOTO2_SaneCapability (pCapability, MSG_GETCURRENT);
 142     return (activeDS.twCC == TWCC_SUCCESS)?TWRC_SUCCESS:TWRC_FAILURE;
 143 }
 144
 145 /* DG_CONTROL/DAT_CAPABILITY/MSG_GETDEFAULT */
 146 static TW_UINT16 GPHOTO2_CapabilityGetDefault (pTW_IDENTITY pOrigin, TW_MEMREF pData)
 147 {
 148     pTW_CAPABILITY pCapability = (pTW_CAPABILITY) pData;
 149
 150     TRACE("DG_CONTROL/DAT_CAPABILITY/MSG_GETDEFAULT\n");
 151     if (activeDS.currentState < 4 || activeDS.currentState > 7) {
 152         activeDS.twCC = TWCC_SEQERROR;
 153         return TWRC_FAILURE;
 154     }
 155     activeDS.twCC = GPHOTO2_SaneCapability (pCapability, MSG_GETDEFAULT);
 156     return (activeDS.twCC == TWCC_SUCCESS)?TWRC_SUCCESS:TWRC_FAILURE;
 157 }
 158
 159 /* DG_CONTROL/DAT_CAPABILITY/MSG_QUERYSUPPORT */
 160 static TW_UINT16 GPHOTO2_CapabilityQuerySupport (pTW_IDENTITY pOrigin,
 161                                         TW_MEMREF pData)
 162 {
 163     FIXME ("stub!\n");
 164
 165     return TWRC_FAILURE;
 166 }
 167
 168 /* DG_CONTROL/DAT_CAPABILITY/MSG_RESET */
 169 static TW_UINT16 GPHOTO2_CapabilityReset (pTW_IDENTITY pOrigin,
 170                                  TW_MEMREF pData)
 171 {
 172     pTW_CAPABILITY pCapability = (pTW_CAPABILITY) pData;
 173
 174     TRACE("DG_CONTROL/DAT_CAPABILITY/MSG_RESET\n");
 175
 176     if (activeDS.currentState < 4 || activeDS.currentState > 7) {
 177         activeDS.twCC = TWCC_SEQERROR;
 178         return TWRC_FAILURE;
 179     }
 180     activeDS.twCC = GPHOTO2_SaneCapability (pCapability, MSG_RESET);
 181     return (activeDS.twCC == TWCC_SUCCESS)?TWRC_SUCCESS:TWRC_FAILURE;
 182 }
 183
 184 /* DG_CONTROL/DAT_CAPABILITY/MSG_SET */
 185 static TW_UINT16 GPHOTO2_CapabilitySet (pTW_IDENTITY pOrigin,
 186                                TW_MEMREF pData)
 187 {
 188     pTW_CAPABILITY pCapability = (pTW_CAPABILITY) pData;
 189
 190     TRACE ("DG_CONTROL/DAT_CAPABILITY/MSG_SET\n");
 191
 192     if (activeDS.currentState != 4) {
 193         activeDS.twCC = TWCC_SEQERROR;
 194         return TWRC_FAILURE;
 195     }
 196     activeDS.twCC = GPHOTO2_SaneCapability (pCapability, MSG_SET);
 197     return (activeDS.twCC == TWCC_SUCCESS)?TWRC_SUCCESS:TWRC_FAILURE;
 198 }
 199
 200 /* DG_CONTROL/DAT_CUSTOMDSDATA/MSG_GET */
 201 static TW_UINT16 GPHOTO2_CustomDSDataGet (pTW_IDENTITY pOrigin,
 202                                 TW_MEMREF pData)
 203 {
 204     FIXME ("stub!\n");
 205
 206     return TWRC_FAILURE;
 207 }
 208
 209 /* DG_CONTROL/DAT_CUSTOMDSDATA/MSG_SET */
 210 static TW_UINT16 GPHOTO2_CustomDSDataSet (pTW_IDENTITY pOrigin,
 211                                  TW_MEMREF pData)
 212 {
 213     FIXME ("stub!\n");
 214
 215     return TWRC_FAILURE;
 216 }
 217
 218 /* DG_CONTROL/DAT_FILESYSTEM/MSG_CHANGEDIRECTORY */
 219 static TW_UINT16 GPHOTO2_ChangeDirectory (pTW_IDENTITY pOrigin,
 220                                  TW_MEMREF pData)
 221 {
 222     FIXME ("stub!\n");
 223
 224     return TWRC_FAILURE;
 225 }
 226
 227 /* DG_CONTROL/DAT_FILESYSTEM/MSG_CREATEDIRECTORY */
 228 static TW_UINT16 GPHOTO2_CreateDirectory (pTW_IDENTITY pOrigin,
 229                                  TW_MEMREF pData)
 230 {
 231     FIXME ("stub!\n");
 232
 233     return TWRC_FAILURE;
 234 }
 235
 236 /* DG_CONTROL/DAT_FILESYSTEM/MSG_DELETE */
 237 static TW_UINT16 GPHOTO2_FileSystemDelete (pTW_IDENTITY pOrigin,
 238                                   TW_MEMREF pData)
 239 {
 240     FIXME ("stub!\n");
 241
 242     return TWRC_FAILURE;
 243 }
 244
 245 /* DG_CONTROL/DAT_FILESYSTEM/MSG_FORMATMEDIA */
 246 static TW_UINT16 GPHOTO2_FormatMedia (pTW_IDENTITY pOrigin,
 247                              TW_MEMREF pData)
 248 {
 249     FIXME ("stub!\n");
 250
 251     return TWRC_FAILURE;
 252 }
 253
 254 /* DG_CONTROL/DAT_FILESYSTEM/MSG_GETCLOSE */
 255 static TW_UINT16 GPHOTO2_FileSystemGetClose (pTW_IDENTITY pOrigin,
 256                                     TW_MEMREF pData)
 257 {
 258     FIXME ("stub!\n");
 259
 260     return TWRC_FAILURE;
 261 }
 262
 263 /* DG_CONTROL/DAT_FILESYSTEM/MSG_GETFIRSTFILE */
 264 static TW_UINT16 GPHOTO2_FileSystemGetFirstFile (pTW_IDENTITY pOrigin,
 265
 266                                         TW_MEMREF pData)
 267 {
 268     FIXME ("stub!\n");
 269
 270     return TWRC_FAILURE;
 271 }
 272
 273 /* DG_CONTROL/DAT_FILESYSTEM/MSG_GETINFO */
 274 static TW_UINT16 GPHOTO2_FileSystemGetInfo (pTW_IDENTITY pOrigin,
 275                                    TW_MEMREF pData)
 276 {
 277     FIXME ("stub!\n");
 278
 279     return TWRC_FAILURE;
 280 }
 281
 282 /* DG_CONTROL/DAT_FILESYSTEM/MSG_GETNEXTFILE */
 283 static TW_UINT16 GPHOTO2_FileSystemGetNextFile (pTW_IDENTITY pOrigin,
 284
 285                                        TW_MEMREF pData)
 286 {
 287     FIXME ("stub!\n");
 288
 289     return TWRC_FAILURE;
 290 }
 291
 292 /* DG_CONTROL/DAT_FILESYSTEM/MSG_RENAME */
 293 static TW_UINT16 GPHOTO2_FileSystemRename (pTW_IDENTITY pOrigin,
 294                                   TW_MEMREF pData)
 295 {
 296     FIXME ("stub!\n");
 297
 298     return TWRC_FAILURE;
 299 }
 300
 301 static void GPHOTO2_Notify (TW_UINT16 message)
 302 {
 303     GPHOTO2_dsmentry (&activeDS.identity, &activeDS.appIdentity, DG_CONTROL, DAT_NULL, message, NULL);
 304 }
 305
 306 /* DG_CONTROL/DAT_ENTRYPOINT/MSG_SET */
 307 static TW_UINT16 GPHOTO2_SetEntryPoint (pTW_IDENTITY pOrigin, TW_MEMREF pData)
 308 {
 309     TW_ENTRYPOINT *entry = (TW_ENTRYPOINT*)pData;
 310
 311     GPHOTO2_dsmentry = entry->DSM_Entry;
 312
 313     return TWRC_SUCCESS;
 314 }
 315
 316 /* DG_CONTROL/DAT_EVENT/MSG_PROCESSEVENT */
 317 static TW_UINT16 GPHOTO2_ProcessEvent (pTW_IDENTITY pOrigin,
 318                               TW_MEMREF pData)
 319 {
 320     pTW_EVENT pEvent = (pTW_EVENT) pData;
 321
 322     TRACE("DG_CONTROL/DAT_EVENT/MSG_PROCESSEVENT\n");
 323
 324     if (activeDS.currentState < 5 || activeDS.currentState > 7) {
 325         activeDS.twCC = TWCC_SEQERROR;
 326         return TWRC_FAILURE;
 327     }
 328
 329     pEvent->TWMessage = MSG_NULL;  /* no message to the application */
 330     activeDS.twCC = TWCC_SUCCESS;
 331     return TWRC_NOTDSEVENT;
 332 }
 333
 334 /* DG_CONTROL/DAT_PASSTHRU/MSG_PASSTHRU */
 335 static TW_UINT16 GPHOTO2_PassThrough (pTW_IDENTITY pOrigin,
 336                              TW_MEMREF pData)
 337 {
 338     FIXME ("stub!\n");
 339
 340     return TWRC_FAILURE;
 341 }
 342
 343 /* DG_CONTROL/DAT_PENDINGXFERS/MSG_ENDXFER */
 344 static TW_UINT16 GPHOTO2_PendingXfersEndXfer (pTW_IDENTITY pOrigin,
 345                                      TW_MEMREF pData)
 346 {
 347     TW_UINT32 count;
 348     pTW_PENDINGXFERS pPendingXfers = (pTW_PENDINGXFERS) pData;
 349     struct gphoto2_file *file;
 350
 351     TRACE("DG_CONTROL/DAT_PENDINGXFERS/MSG_ENDXFER\n");
 352
 353     if (activeDS.currentState != 6 && activeDS.currentState != 7) {
 354         activeDS.twCC = TWCC_SEQERROR;
 355         return TWRC_FAILURE;
 356     }
 357     count = 0;
 358     LIST_FOR_EACH_ENTRY( file, &activeDS.files, struct gphoto2_file, entry ) {
 359         if (file->download)
 360             count++;
 361     }
 362     TRACE("count = %d\n", count);
 363     pPendingXfers->Count = count;
 364     if (pPendingXfers->Count != 0) {
 365         activeDS.currentState = 6;
 366     } else {
 367         activeDS.currentState = 5;
 368         /* Notify the application that it can close the data source */
 369         GPHOTO2_Notify(MSG_CLOSEDSREQ);
 370         /* close any Transferring dialog */
 371         TransferringDialogBox(activeDS.progressWnd,-1);
 372         activeDS.progressWnd = 0;
 373     }
 374     activeDS.twCC = TWCC_SUCCESS;
 375     return TWRC_SUCCESS;
 376 }
 377
 378 /* DG_CONTROL/DAT_PENDINGXFERS/MSG_GET */
 379 static TW_UINT16 GPHOTO2_PendingXfersGet (pTW_IDENTITY pOrigin,
 380                                  TW_MEMREF pData)
 381 {
 382     TW_UINT32 count;
 383     pTW_PENDINGXFERS pPendingXfers = (pTW_PENDINGXFERS) pData;
 384     struct gphoto2_file *file;
 385
 386     TRACE("DG_CONTROL/DAT_PENDINGXFERS/MSG_GET\n");
 387
 388     if (activeDS.currentState < 4 || activeDS.currentState > 7) {
 389         activeDS.twCC = TWCC_SEQERROR;
 390         return TWRC_FAILURE;
 391     }
 392
 393     count = 0;
 394     LIST_FOR_EACH_ENTRY( file, &activeDS.files, struct gphoto2_file, entry ) {
 395         if (file->download)
 396             count++;
 397     }
 398     TRACE("count = %d\n", count);
 399     pPendingXfers->Count = count;
 400     activeDS.twCC = TWCC_SUCCESS;
 401     return TWRC_SUCCESS;
 402 }
 403
 404 /* DG_CONTROL/DAT_PENDINGXFERS/MSG_RESET */
 405 static TW_UINT16 GPHOTO2_PendingXfersReset (pTW_IDENTITY pOrigin,
 406                                    TW_MEMREF pData)
 407 {
 408     pTW_PENDINGXFERS pPendingXfers = (pTW_PENDINGXFERS) pData;
 409
 410     TRACE("DG_CONTROL/DAT_PENDINGXFERS/MSG_RESET\n");
 411
 412     if (activeDS.currentState != 6) {
 413         activeDS.twCC = TWCC_SEQERROR;
 414         return TWRC_FAILURE;
 415     }
 416     pPendingXfers->Count = 0;
 417     activeDS.currentState = 5;
 418     activeDS.twCC = TWCC_SUCCESS;
 419     return TWRC_SUCCESS;
 420 }
 421
 422 /* DG_CONTROL/DAT_SETUPFILEXFER/MSG_GET */
 423 static TW_UINT16 GPHOTO2_SetupFileXferGet (pTW_IDENTITY pOrigin,
 424                                   TW_MEMREF pData)
 425 {
 426     FIXME ("stub!\n");
 427
 428     return TWRC_FAILURE;
 429 }
 430
 431 /* DG_CONTROL/DAT_SETUPXFER/MSG_GETDEFAULT */
 432 static TW_UINT16 GPHOTO2_SetupFileXferGetDefault (pTW_IDENTITY pOrigin,
 433                                          TW_MEMREF pData)
 434 {
 435     FIXME ("stub!\n");
 436
 437     return TWRC_FAILURE;
 438 }
 439
 440
 441 /* DG_CONTROL/DAT_SETUPFILEXFER/MSG_RESET */
 442 static TW_UINT16 GPHOTO2_SetupFileXferReset (pTW_IDENTITY pOrigin,
 443                                     TW_MEMREF pData)
 444 {
 445     FIXME ("stub!\n");
 446
 447     return TWRC_FAILURE;
 448 }
 449
 450 /* DG_CONTROL/DAT_SETUPFILEXFER/MSG_SET */
 451 static TW_UINT16 GPHOTO2_SetupFileXferSet (pTW_IDENTITY pOrigin,
 452                                   TW_MEMREF pData)
 453 {
 454     FIXME ("stub!\n");
 455
 456     return TWRC_FAILURE;
 457 }
 458
 459 /* DG_CONTROL/DAT_SETUPMEMXFER/MSG_GET */
 460 static TW_UINT16 GPHOTO2_SetupMemXferGet (pTW_IDENTITY pOrigin,
 461                                   TW_MEMREF pData)
 462 {
 463     pTW_SETUPMEMXFER  pSetupMemXfer = (pTW_SETUPMEMXFER)pData;
 464
 465     TRACE("DG_CONTROL/DAT_SETUPMEMXFER/MSG_GET\n");
 466     /* Guessing */
 467     pSetupMemXfer->MinBufSize = 20000;
 468     pSetupMemXfer->MaxBufSize = 80000;
 469     pSetupMemXfer->Preferred = 40000;
 470     return TWRC_SUCCESS;
 471 }
 472
 473 /* DG_CONTROL/DAT_STATUS/MSG_GET */
 474 static TW_UINT16 GPHOTO2_GetDSStatus (pTW_IDENTITY pOrigin,
 475                              TW_MEMREF pData)
 476 {
 477     pTW_STATUS pSourceStatus = (pTW_STATUS) pData;
 478
 479     TRACE ("DG_CONTROL/DAT_STATUS/MSG_GET\n");
 480     pSourceStatus->ConditionCode = activeDS.twCC;
 481     /* Reset the condition code */
 482     activeDS.twCC = TWCC_SUCCESS;
 483     return TWRC_SUCCESS;
 484 }
 485
 486 /* DG_CONTROL/DAT_USERINTERFACE/MSG_DISABLEDS */
 487 static TW_UINT16 GPHOTO2_DisableDSUserInterface (pTW_IDENTITY pOrigin,
 488                                         TW_MEMREF pData)
 489 {
 490     TRACE ("DG_CONTROL/DAT_USERINTERFACE/MSG_DISABLEDS\n");
 491
 492     if (activeDS.currentState != 5) {
 493         activeDS.twCC = TWCC_SEQERROR;
 494         return TWRC_FAILURE;
 495     }
 496     activeDS.currentState = 4;
 497     activeDS.twCC = TWCC_SUCCESS;
 498     return TWRC_SUCCESS;
 499 }
 500
 501 /* DG_CONTROL/DAT_USERINTERFACE/MSG_ENABLEDS */
 502 static TW_UINT16 GPHOTO2_EnableDSUserInterface (pTW_IDENTITY pOrigin,
 503                                        TW_MEMREF pData)
 504 {
 505     pTW_USERINTERFACE pUserInterface = (pTW_USERINTERFACE) pData;
 506
 507     load_filesystem("/");
 508
 509     TRACE ("DG_CONTROL/DAT_USERINTERFACE/MSG_ENABLEDS\n");
 510     if (activeDS.currentState != 4) {
 511         FIXME("Sequence error %d\n", activeDS.currentState);
 512         activeDS.twCC = TWCC_SEQERROR;
 513         return TWRC_FAILURE;
 514     }
 515     if (pUserInterface->ShowUI)
 516     {
 517         BOOL rc;
 518         activeDS.currentState = 5; /* Transitions to state 5 */
 519         rc = DoCameraUI();
 520         if (!rc) {
 521             GPHOTO2_Notify(MSG_CLOSEDSREQ);
 522         } else {
 523             /* FIXME: The GUI should have marked the files to download... */
 524             GPHOTO2_Notify(MSG_XFERREADY);
 525             activeDS.currentState = 6; /* Transitions to state 6 directly */
 526         }
 527     } else {
 528         /* no UI will be displayed, so source is ready to transfer data */
 529         GPHOTO2_Notify(MSG_XFERREADY);
 530         activeDS.currentState = 6; /* Transitions to state 6 directly */
 531     }
 532     activeDS.twCC = TWCC_SUCCESS;
 533     return TWRC_SUCCESS;
 534 }
 535
 536 /* DG_CONTROL/DAT_USERINTERFACE/MSG_ENABLEDSUIONLY */
 537 static TW_UINT16 GPHOTO2_EnableDSUIOnly (pTW_IDENTITY pOrigin,
 538                                 TW_MEMREF pData)
 539 {
 540     TRACE("DG_CONTROL/DAT_USERINTERFACE/MSG_ENABLEDSUIONLY\n");
 541
 542     if (activeDS.currentState != 4) {
 543         activeDS.twCC = TWCC_SEQERROR;
 544         return TWRC_FAILURE;
 545     }
 546     /* FIXME: we should replace xscanimage with our own UI */
 547     FIXME ("not implemented!\n");
 548     activeDS.currentState = 5;
 549     activeDS.twCC = TWCC_SUCCESS;
 550     return TWRC_SUCCESS;
 551 }
 552
 553 /* DG_CONTROL/DAT_XFERGROUP/MSG_GET */
 554 static TW_UINT16 GPHOTO2_XferGroupGet (pTW_IDENTITY pOrigin,
 555                               TW_MEMREF pData)
 556 {
 557     FIXME ("stub!\n");
 558     return TWRC_FAILURE;
 559 }
 560
 561 /* DG_CONTROL/DAT_XFERGROUP/MSG_SET */
 562 static TW_UINT16 GPHOTO2_XferGroupSet (pTW_IDENTITY pOrigin,
 563                                   TW_MEMREF pData)
 564 {
 565     FIXME ("stub!\n");
 566     return TWRC_FAILURE;
 567 }
 568
 569 HINSTANCE GPHOTO2_instance;
 570
 571 BOOL WINAPI DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
 572 {
 573     TRACE("%p,%x,%p\n", hinstDLL, fdwReason, lpvReserved);
 574
 575     switch (fdwReason)
 576     {
 577         case DLL_PROCESS_ATTACH:
 578             GPHOTO2_instance = hinstDLL;
 579             DisableThreadLibraryCalls(hinstDLL);
 580 #ifdef HAVE_GPHOTO2
 581             activeDS.context = gp_context_new ();
 582 #endif
 583             break;
 584     }
 585
 586     return TRUE;
 587 }
 588
 589 #if defined(HAVE_GPHOTO2) && defined(HAVE_GPHOTO2_PORT)
 590 static TW_UINT16 GPHOTO2_GetIdentity( pTW_IDENTITY, pTW_IDENTITY);
 591 static TW_UINT16 GPHOTO2_OpenDS( pTW_IDENTITY, pTW_IDENTITY);
 592 #endif
 593
 594 static TW_UINT16 GPHOTO2_SourceControlHandler (
 595    pTW_IDENTITY pOrigin,
 596    TW_UINT16    DAT,
 597    TW_UINT16    MSG,
 598    TW_MEMREF    pData)
 599 {
 600     TW_UINT16 twRC = TWRC_SUCCESS;
 601
 602     switch (DAT)
 603     {
 604         case DAT_IDENTITY:
 605             switch (MSG)
 606             {
 607                 case MSG_CLOSEDS:
 608 #if defined(HAVE_GPHOTO2) && defined(HAVE_GPHOTO2_PORT)
 609                      if (activeDS.camera) {
 610                         gp_camera_free (activeDS.camera);
 611                         activeDS.camera = NULL;
 612                      }
 613 #endif
 614                      break;
 615                 case MSG_GET:
 616 #if defined(HAVE_GPHOTO2) && defined(HAVE_GPHOTO2_PORT)
 617                      twRC = GPHOTO2_GetIdentity(pOrigin,(pTW_IDENTITY)pData);
 618 #else
 619                      twRC = TWRC_FAILURE;
 620 #endif
 621                      break;
 622                 case MSG_OPENDS:
 623 #if defined(HAVE_GPHOTO2) && defined(HAVE_GPHOTO2_PORT)
 624                      twRC = GPHOTO2_OpenDS(pOrigin,(pTW_IDENTITY)pData);
 625 #else
 626                      twRC = TWRC_FAILURE;
 627 #endif
 628                      break;
 629             }
 630             break;
 631         case DAT_CAPABILITY:
 632             switch (MSG)
 633             {
 634                 case MSG_GET:
 635                     twRC = GPHOTO2_CapabilityGet (pOrigin, pData);
 636                     break;
 637                 case MSG_GETCURRENT:
 638                     twRC = GPHOTO2_CapabilityGetCurrent (pOrigin, pData);
 639                     break;
 640                 case MSG_GETDEFAULT:
 641                     twRC = GPHOTO2_CapabilityGetDefault (pOrigin, pData);
 642                     break;
 643                 case MSG_QUERYSUPPORT:
 644                     twRC = GPHOTO2_CapabilityQuerySupport (pOrigin, pData);
 645                     break;
 646                 case MSG_RESET:
 647                     twRC = GPHOTO2_CapabilityReset (pOrigin, pData);
 648                     break;
 649                 case MSG_SET:
 650                     twRC = GPHOTO2_CapabilitySet (pOrigin, pData);
 651                     break;
 652                 default:
 653                     twRC = TWRC_FAILURE;
 654                     FIXME("unrecognized operation triplet\n");
 655             }
 656             break;
 657
 658         case DAT_CUSTOMDSDATA:
 659             switch (MSG)
 660             {
 661                 case MSG_GET:
 662                     twRC = GPHOTO2_CustomDSDataGet (pOrigin, pData);
 663                     break;
 664                 case MSG_SET:
 665                     twRC = GPHOTO2_CustomDSDataSet (pOrigin, pData);
 666                     break;
 667                 default:
 668                     break;
 669             }
 670             break;
 671
 672         case DAT_FILESYSTEM:
 673             switch (MSG)
 674             {
 675                 /*case MSG_AUTOMATICCAPTUREDIRECTORY:
 676                     twRC = GPHOTO2_AutomaticCaptureDirectory
 677                                (pOrigin, pData);
 678                     break;*/
 679                 case MSG_CHANGEDIRECTORY:
 680                     twRC = GPHOTO2_ChangeDirectory (pOrigin, pData);
 681                     break;
 682                 /*case MSG_COPY:
 683                     twRC = GPHOTO2_FileSystemCopy (pOrigin, pData);
 684                     break;*/
 685                 case MSG_CREATEDIRECTORY:
 686                     twRC = GPHOTO2_CreateDirectory (pOrigin, pData);
 687                     break;
 688                 case MSG_DELETE:
 689                     twRC = GPHOTO2_FileSystemDelete (pOrigin, pData);
 690                     break;
 691                 case MSG_FORMATMEDIA:
 692                     twRC = GPHOTO2_FormatMedia (pOrigin, pData);
 693                     break;
 694                 case MSG_GETCLOSE:
 695                     twRC = GPHOTO2_FileSystemGetClose (pOrigin, pData);
 696                     break;
 697                 case MSG_GETFIRSTFILE:
 698                     twRC = GPHOTO2_FileSystemGetFirstFile (pOrigin, pData);
 699                     break;
 700                 case MSG_GETINFO:
 701                     twRC = GPHOTO2_FileSystemGetInfo (pOrigin, pData);
 702                     break;
 703                 case MSG_GETNEXTFILE:
 704                     twRC = GPHOTO2_FileSystemGetNextFile (pOrigin, pData);
 705                     break;
 706                 case MSG_RENAME:
 707                     twRC = GPHOTO2_FileSystemRename (pOrigin, pData);
 708                     break;
 709                 default:
 710                     twRC = TWRC_FAILURE;
 711                     break;
 712             }
 713             break;
 714
 715         case DAT_ENTRYPOINT:
 716             if (MSG == MSG_SET)
 717                 twRC = GPHOTO2_SetEntryPoint (pOrigin, pData);
 718             else
 719                 twRC = TWRC_FAILURE;
 720             break;
 721
 722         case DAT_EVENT:
 723             if (MSG == MSG_PROCESSEVENT)
 724                 twRC = GPHOTO2_ProcessEvent (pOrigin, pData);
 725             else
 726                 twRC = TWRC_FAILURE;
 727             break;
 728
 729         case DAT_PASSTHRU:
 730             if (MSG == MSG_PASSTHRU)
 731                 twRC = GPHOTO2_PassThrough (pOrigin, pData);
 732             else
 733                 twRC = TWRC_FAILURE;
 734             break;
 735
 736         case DAT_PENDINGXFERS:
 737             switch (MSG)
 738             {
 739                 case MSG_ENDXFER:
 740                     twRC = GPHOTO2_PendingXfersEndXfer (pOrigin, pData);
 741                     break;
 742                 case MSG_GET:
 743                     twRC = GPHOTO2_PendingXfersGet (pOrigin, pData);
 744                     break;
 745                 case MSG_RESET:
 746                     twRC = GPHOTO2_PendingXfersReset (pOrigin, pData);
 747                     break;
 748                 /*case MSG_STOPFEEDER:
 749                     twRC = GPHOTO2_PendingXfersStopFeeder (pOrigin, pData);
 750                     break;*/
 751                 default:
 752                     twRC = TWRC_FAILURE;
 753             }
 754             break;
 755
 756         case DAT_SETUPFILEXFER:
 757             switch (MSG)
 758             {
 759                 case MSG_GET:
 760                     twRC = GPHOTO2_SetupFileXferGet (pOrigin, pData);
 761                     break;
 762                 case MSG_GETDEFAULT:
 763                     twRC = GPHOTO2_SetupFileXferGetDefault (pOrigin, pData);
 764                     break;
 765                 case MSG_RESET:
 766                     twRC = GPHOTO2_SetupFileXferReset (pOrigin, pData);
 767                     break;
 768                 case MSG_SET:
 769                     twRC = GPHOTO2_SetupFileXferSet (pOrigin, pData);
 770                     break;
 771                 default:
 772                     twRC = TWRC_FAILURE;
 773                     break;
 774             }
 775             break;
 776
 777         /*case DAT_SETUPFILEXFER2:
 778             switch (MSG)
 779             {
 780                 case MSG_GET:
 781                     twRC = GPHOTO2_SetupFileXfer2Get (pOrigin, pData);
 782                     break;
 783                 case MSG_GETDEFAULT:
 784                     twRC = GPHOTO2_SetupFileXfer2GetDefault (pOrigin, pData);
 785                     break;
 786                 case MSG_RESET:
 787                     twRC = GPHOTO2_SetupFileXfer2Reset (pOrigin, pData);
 788                     break;
 789                 case MSG_SET:
 790                     twRC = GPHOTO2_SetupFileXfer2Set (pOrigin, pData);
 791                     break;
 792             }
 793             break;*/
 794         case DAT_SETUPMEMXFER:
 795             if (MSG == MSG_GET)
 796                 twRC = GPHOTO2_SetupMemXferGet (pOrigin, pData);
 797             else
 798                 twRC = TWRC_FAILURE;
 799             break;
 800
 801         case DAT_STATUS:
 802             if (MSG == MSG_GET)
 803                 twRC = GPHOTO2_GetDSStatus (pOrigin, pData);
 804             else
 805                 twRC = TWRC_FAILURE;
 806             break;
 807
 808         case DAT_USERINTERFACE:
 809             switch (MSG)
 810             {
 811                 case MSG_DISABLEDS:
 812                     twRC = GPHOTO2_DisableDSUserInterface (pOrigin, pData);
 813                     break;
 814                 case MSG_ENABLEDS:
 815                     twRC = GPHOTO2_EnableDSUserInterface (pOrigin, pData);
 816                     break;
 817                 case MSG_ENABLEDSUIONLY:
 818                     twRC = GPHOTO2_EnableDSUIOnly (pOrigin, pData);
 819                     break;
 820                 default:
 821                     twRC = TWRC_FAILURE;
 822                     break;
 823             }
 824             break;
 825
 826         case DAT_XFERGROUP:
 827             switch (MSG)
 828             {
 829                 case MSG_GET:
 830                     twRC = GPHOTO2_XferGroupGet (pOrigin, pData);
 831                     break;
 832                 case MSG_SET:
 833                     twRC = GPHOTO2_XferGroupSet (pOrigin, pData);
 834                     break;
 835                 default:
 836                     twRC = TWRC_FAILURE;
 837                     break;
 838             }
 839             break;
 840
 841         default:
 842             FIXME("code unknown: %d\n", DAT);
 843             twRC = TWRC_FAILURE;
 844             break;
 845     }
 846
 847     return twRC;
 848 }
 849
 850
 851 static TW_UINT16 GPHOTO2_ImageGroupHandler (
 852            pTW_IDENTITY pOrigin,
 853            TW_UINT16    DAT,
 854            TW_UINT16    MSG,
 855            TW_MEMREF    pData)
 856 {
 857     TW_UINT16 twRC = TWRC_SUCCESS;
 858
 859     switch (DAT)
 860     {
 861         case DAT_CIECOLOR:
 862             if (MSG == MSG_GET)
 863                 twRC = GPHOTO2_CIEColorGet (pOrigin, pData);
 864             else
 865                 twRC = TWRC_FAILURE;
 866             break;
 867
 868         case DAT_EXTIMAGEINFO:
 869             if (MSG == MSG_GET)
 870                 twRC = GPHOTO2_ExtImageInfoGet (pOrigin, pData);
 871             else
 872                 twRC = TWRC_FAILURE;
 873             break;
 874
 875         case DAT_GRAYRESPONSE:
 876             switch (MSG)
 877             {
 878                 case MSG_RESET:
 879                     twRC = GPHOTO2_GrayResponseReset (pOrigin, pData);
 880                     break;
 881                 case MSG_SET:
 882                     twRC = GPHOTO2_GrayResponseSet (pOrigin, pData);
 883                     break;
 884                 default:
 885                     twRC = TWRC_FAILURE;
 886                     activeDS.twCC = TWCC_BADPROTOCOL;
 887                     FIXME("unrecognized operation triplet\n");
 888                     break;
 889             }
 890             break;
 891         case DAT_IMAGEFILEXFER:
 892             if (MSG == MSG_GET)
 893                 twRC = GPHOTO2_ImageFileXferGet (pOrigin, pData);
 894             else
 895                 twRC = TWRC_FAILURE;
 896             break;
 897
 898         case DAT_IMAGEINFO:
 899             if (MSG == MSG_GET)
 900                 twRC = GPHOTO2_ImageInfoGet (pOrigin, pData);
 901             else
 902                 twRC = TWRC_FAILURE;
 903             break;
 904
 905         case DAT_IMAGELAYOUT:
 906             switch (MSG)
 907             {
 908                 case MSG_GET:
 909                     twRC = GPHOTO2_ImageLayoutGet (pOrigin, pData);
 910                     break;
 911                 case MSG_GETDEFAULT:
 912                     twRC = GPHOTO2_ImageLayoutGetDefault (pOrigin, pData);
 913                     break;
 914                 case MSG_RESET:
 915                     twRC = GPHOTO2_ImageLayoutReset (pOrigin, pData);
 916                     break;
 917                 case MSG_SET:
 918                     twRC = GPHOTO2_ImageLayoutSet (pOrigin, pData);
 919                     break;
 920                 default:
 921                     twRC = TWRC_FAILURE;
 922                     activeDS.twCC = TWCC_BADPROTOCOL;
 923                     ERR("unrecognized operation triplet\n");
 924                     break;
 925             }
 926             break;
 927
 928         case DAT_IMAGEMEMXFER:
 929             if (MSG == MSG_GET)
 930                 twRC = GPHOTO2_ImageMemXferGet (pOrigin, pData);
 931             else
 932                 twRC = TWRC_FAILURE;
 933             break;
 934
 935         case DAT_IMAGENATIVEXFER:
 936             if (MSG == MSG_GET)
 937                 twRC = GPHOTO2_ImageNativeXferGet (pOrigin, pData);
 938             else
 939                 twRC = TWRC_FAILURE;
 940             break;
 941
 942         case DAT_JPEGCOMPRESSION:
 943             switch (MSG)
 944             {
 945                 case MSG_GET:
 946                     twRC = GPHOTO2_JPEGCompressionGet (pOrigin, pData);
 947                     break;
 948                 case MSG_GETDEFAULT:
 949                     twRC = GPHOTO2_JPEGCompressionGetDefault (pOrigin, pData);
 950                     break;
 951                 case MSG_RESET:
 952                     twRC = GPHOTO2_JPEGCompressionReset (pOrigin, pData);
 953                     break;
 954                 case MSG_SET:
 955                     twRC = GPHOTO2_JPEGCompressionSet (pOrigin, pData);
 956                     break;
 957                 default:
 958                     twRC = TWRC_FAILURE;
 959                     activeDS.twCC = TWCC_BADPROTOCOL;
 960                     WARN("unrecognized operation triplet\n");
 961                     break;
 962             }
 963             break;
 964
 965         case DAT_PALETTE8:
 966             switch (MSG)
 967             {
 968                 case MSG_GET:
 969                     twRC = GPHOTO2_Palette8Get (pOrigin, pData);
 970                     break;
 971                 case MSG_GETDEFAULT:
 972                     twRC = GPHOTO2_Palette8GetDefault (pOrigin, pData);
 973                     break;
 974                 case MSG_RESET:
 975                     twRC = GPHOTO2_Palette8Reset (pOrigin, pData);
 976                     break;
 977                 case MSG_SET:
 978                     twRC = GPHOTO2_Palette8Set (pOrigin, pData);
 979                     break;
 980                 default:
 981                     twRC = TWRC_FAILURE;
 982                     activeDS.twCC = TWCC_BADPROTOCOL;
 983                     WARN("unrecognized operation triplet\n");
 984             }
 985             break;
 986
 987         case DAT_RGBRESPONSE:
 988             switch (MSG)
 989             {
 990                 case MSG_RESET:
 991                     twRC = GPHOTO2_RGBResponseReset (pOrigin, pData);
 992                     break;
 993                 case MSG_SET:
 994                     twRC = GPHOTO2_RGBResponseSet (pOrigin, pData);
 995                     break;
 996                 default:
 997                     twRC = TWRC_FAILURE;
 998                     activeDS.twCC = TWCC_BADPROTOCOL;
 999                     WARN("unrecognized operation triplet\n");
1000                     break;
1001             }
1002             break;
1003
1004         default:
1005             twRC = TWRC_FAILURE;
1006             activeDS.twCC = TWCC_BADPROTOCOL;
1007             FIXME("unrecognized DG type %d\n", DAT);
1008     }
1009     return twRC;
1010 }
1011
1012 /* Main entry point for the TWAIN library */
1013 TW_UINT16 WINAPI
1014 DS_Entry ( pTW_IDENTITY pOrigin,
1015            TW_UINT32    DG,
1016            TW_UINT16    DAT,
1017            TW_UINT16    MSG,
1018            TW_MEMREF    pData)
1019 {
1020     TW_UINT16 twRC = TWRC_SUCCESS;  /* Return Code */
1021
1022     TRACE("(DG=%d DAT=%d MSG=%d)\n", DG, DAT, MSG);
1023
1024     switch (DG)
1025     {
1026         case DG_CONTROL:
1027             twRC = GPHOTO2_SourceControlHandler (pOrigin,DAT,MSG,pData);
1028             break;
1029         case DG_IMAGE:
1030             twRC = GPHOTO2_ImageGroupHandler (pOrigin,DAT,MSG,pData);
1031             break;
1032         case DG_AUDIO:
1033             FIXME("The audio group of entry codes is not implemented.\n");
1034         default:
1035             activeDS.twCC = TWCC_BADPROTOCOL;
1036             twRC = TWRC_FAILURE;
1037     }
1038
1039     return twRC;
1040 }
1041
1042 #if defined(HAVE_GPHOTO2) && defined(HAVE_GPHOTO2_PORT)
1043 static GPPortInfoList *port_list;
1044 static int curcamera;
1045 static CameraList *detected_cameras;
1046 static CameraAbilitiesList *abilities_list;
1047
1048 static TW_UINT16
1049 gphoto2_auto_detect(void) {
1050     int result, count;
1051
1052     if (detected_cameras && (gp_list_count (detected_cameras) == 0)) {
1053         /* Reload if previously no cameras, we might detect new ones. */
1054         TRACE("Reloading portlist trying to detect cameras.\n");
1055         if (port_list) {
1056             gp_port_info_list_free (port_list);
1057             port_list = NULL;
1058         }
1059     }
1060     if (!port_list) {
1061         TRACE("Auto detecting gphoto cameras.\n");
1062         TRACE("Loading ports...\n");
1063         if (gp_port_info_list_new (&port_list) < GP_OK)
1064             return TWRC_FAILURE;
1065         result = gp_port_info_list_load (port_list);
1066         if (result < 0) {
1067             gp_port_info_list_free (port_list);
1068             return TWRC_FAILURE;
1069         }
1070         count = gp_port_info_list_count (port_list);
1071         if (count <= 0)
1072             return TWRC_FAILURE;
1073         if (gp_list_new (&detected_cameras) < GP_OK)
1074             return TWRC_FAILURE;
1075         if (!abilities_list) { /* Load only once per program start */
1076             gp_abilities_list_new (&abilities_list);
1077             TRACE("Loading cameras...\n");
1078             gp_abilities_list_load (abilities_list, NULL);
1079         }
1080         TRACE("Detecting cameras...\n");
1081         gp_abilities_list_detect (abilities_list, port_list, detected_cameras, NULL);
1082         curcamera = 0;
1083         TRACE("%d cameras detected\n", gp_list_count(detected_cameras));
1084     }
1085     return TWRC_SUCCESS;
1086 }
1087
1088 static TW_UINT16
1089 GPHOTO2_GetIdentity( pTW_IDENTITY pOrigin, pTW_IDENTITY self) {
1090     int count;
1091     const char *cname, *pname;
1092
1093     if (TWRC_SUCCESS != gphoto2_auto_detect())
1094         return TWRC_FAILURE;
1095
1096     count = gp_list_count (detected_cameras);
1097     if (count < GP_OK) {
1098         gp_list_free (detected_cameras);
1099         return TWRC_FAILURE;
1100     }
1101     TRACE("%d cameras detected.\n", count);
1102     self->ProtocolMajor = TWON_PROTOCOLMAJOR;
1103     self->ProtocolMinor = TWON_PROTOCOLMINOR;
1104     self->SupportedGroups = DG_CONTROL | DG_IMAGE | DF_DS2;
1105     lstrcpynA (self->Manufacturer, "The Wine Team", sizeof(self->Manufacturer) - 1);
1106     lstrcpynA (self->ProductFamily, "GPhoto2 Camera", sizeof(self->ProductFamily) - 1);
1107
1108     if (!count) { /* No camera detected. But we need to return an IDENTITY anyway. */
1109         lstrcpynA (self->ProductName, "GPhoto2 Camera", sizeof(self->ProductName) - 1);
1110         return TWRC_SUCCESS;
1111     }
1112     gp_list_get_name  (detected_cameras, curcamera, &cname);
1113     gp_list_get_value (detected_cameras, curcamera, &pname);
1114     if (count == 1) /* Normal case, only one camera. */
1115         snprintf (self->ProductName, sizeof(self->ProductName), "%s", cname);
1116     else
1117         snprintf (self->ProductName, sizeof(self->ProductName), "%s@%s", cname, pname);
1118     curcamera = (curcamera+1) % count;
1119     return TWRC_SUCCESS;
1120 }
1121
1122 static TW_UINT16
1123 GPHOTO2_OpenDS( pTW_IDENTITY pOrigin, pTW_IDENTITY self) {
1124     int ret, m, p, count, i;
1125     CameraAbilities a;
1126     GPPortInfo info;
1127     const char  *model, *port;
1128
1129     if (GPHOTO2_dsmentry == NULL)
1130     {
1131         static const WCHAR twain32W[] = {'t','w','a','i','n','_','3','2',0};
1132         HMODULE moddsm = GetModuleHandleW(twain32W);
1133
1134         if (moddsm)
1135             GPHOTO2_dsmentry = (void*)GetProcAddress(moddsm, "DSM_Entry");
1136
1137         if (!GPHOTO2_dsmentry)
1138         {
1139             ERR("can't find DSM entry point\n");
1140             return TWRC_FAILURE;
1141         }
1142     }
1143
1144     if (TWRC_SUCCESS != gphoto2_auto_detect())
1145         return TWRC_FAILURE;
1146
1147     if (lstrcmpA(self->ProductFamily,"GPhoto2 Camera")) {
1148         FIXME("identity passed is not a gphoto camera, but %s!?!\n", self->ProductFamily);
1149         return TWRC_FAILURE;
1150     }
1151     count = gp_list_count (detected_cameras);
1152     if (!count) {
1153         ERR("No camera found by autodetection. Returning failure.\n");
1154         return TWRC_FAILURE;
1155     }
1156
1157     if (!lstrcmpA (self->ProductName, "GPhoto2 Camera")) {
1158         TRACE("Potential undetected camera. Just using the first autodetected one.\n");
1159         i = 0;
1160     } else {
1161         for (i=0;i<count;i++) {
1162             const char *cname, *pname;
1163             TW_STR32    name;
1164
1165             gp_list_get_name  (detected_cameras, i, &cname);
1166             gp_list_get_value (detected_cameras, i, &pname);
1167             if (!lstrcmpA(self->ProductName,cname))
1168                 break;
1169             snprintf(name, sizeof(name), "%s", cname);
1170             if (!lstrcmpA(self->ProductName,name))
1171                 break;
1172             snprintf(name, sizeof(name), "%s@%s", cname, pname);
1173             if (!lstrcmpA(self->ProductName,name))
1174                 break;
1175         }
1176         if (i == count) {
1177             TRACE("Camera %s not found in autodetected list. Using first entry.\n", self->ProductName);
1178             i=0;
1179         }
1180     }
1181     gp_list_get_name  (detected_cameras, i, &model);
1182     gp_list_get_value  (detected_cameras, i, &port);
1183     TRACE("model %s, port %s\n", model, port);
1184     ret = gp_camera_new (&activeDS.camera);
1185     if (ret < GP_OK) {
1186         ERR("gp_camera_new: %d\n", ret);
1187         return TWRC_FAILURE;
1188     }
1189     m = gp_abilities_list_lookup_model (abilities_list, model);
1190     if (m < GP_OK) {
1191         FIXME("Model %s not found, %d!\n", model, m);
1192         return TWRC_FAILURE;
1193     }
1194     ret = gp_abilities_list_get_abilities (abilities_list, m, &a);
1195     if (ret < GP_OK) {
1196         FIXME("gp_camera_list_get_abilities failed? %d\n", ret);
1197         return TWRC_FAILURE;
1198     }
1199     ret = gp_camera_set_abilities (activeDS.camera, a);
1200     if (ret < GP_OK) {
1201         FIXME("gp_camera_set_abilities failed? %d\n", ret);
1202         return TWRC_FAILURE;
1203     }
1204
1205     p = gp_port_info_list_lookup_path (port_list, port);
1206     if (p < GP_OK) {
1207         FIXME("port %s not in portlist?\n", port);
1208         return TWRC_FAILURE;
1209     }
1210     ret = gp_port_info_list_get_info (port_list, p, &info);
1211     if (ret < GP_OK) {
1212         FIXME("could not get portinfo for port %s?\n", port);
1213         return TWRC_FAILURE;
1214     }
1215     ret = gp_camera_set_port_info (activeDS.camera, info);
1216     if (ret < GP_OK) {
1217         FIXME("could not set portinfo for port %s to camera?\n", port);
1218         return TWRC_FAILURE;
1219     }
1220     list_init( &(activeDS.files) );
1221     activeDS.currentState = 4;
1222     activeDS.twCC               = TWRC_SUCCESS;
1223     activeDS.pixelflavor        = TWPF_CHOCOLATE;
1224     activeDS.pixeltype          = TWPT_RGB;
1225     activeDS.capXferMech        = TWSX_MEMORY;
1226     activeDS.identity.Id = self->Id;
1227     activeDS.appIdentity = *pOrigin;
1228     TRACE("OK!\n");
1229     return TWRC_SUCCESS;
1230 }
1231 #endif