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