comctl32: header: Draw the drag image and hot dividers while dragging an item.
[wine] / dlls / gphoto2.ds / capability.c
1 /*
2  * Copyright 2000 Corel Corporation
3  * Copyright 2006 Marcus Meissner
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2.1 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18  */
19
20 #define NONAMELESSUNION
21 #define NONAMELESSSTRUCT
22
23 #include "config.h"
24
25 #include <stdarg.h>
26
27 #include "windef.h"
28 #include "winbase.h"
29 #include "twain.h"
30 #include "gphoto2_i.h"
31 #include "wine/debug.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(twain);
34
35 static TW_UINT16 GPHOTO2_ICAPXferMech (pTW_CAPABILITY,TW_UINT16);
36 static TW_UINT16 GPHOTO2_ICAPPixelType (pTW_CAPABILITY,TW_UINT16);
37 static TW_UINT16 GPHOTO2_ICAPPixelFlavor (pTW_CAPABILITY,TW_UINT16);
38 static TW_UINT16 GPHOTO2_ICAPBitDepth (pTW_CAPABILITY,TW_UINT16);
39 static TW_UINT16 GPHOTO2_ICAPUnits (pTW_CAPABILITY,TW_UINT16);
40
41 TW_UINT16 GPHOTO2_SaneCapability (pTW_CAPABILITY pCapability, TW_UINT16 action)
42 {
43     TW_UINT16 twCC = TWCC_SUCCESS;
44
45     TRACE("capability=%d action=%d\n", pCapability->Cap, action);
46
47     switch (pCapability->Cap)
48     {
49         case CAP_DEVICEEVENT:
50         case CAP_ALARMS:
51         case CAP_ALARMVOLUME:
52         case ACAP_AUDIOFILEFORMAT:
53         case ACAP_XFERMECH:
54         case ICAP_AUTOMATICBORDERDETECTION:
55         case ICAP_AUTOMATICDESKEW:
56         case ICAP_AUTODISCARDBLANKPAGES:
57         case ICAP_AUTOMATICROTATE:
58         case ICAP_FLIPROTATION:
59         case CAP_AUTOMATICCAPTURE:
60         case CAP_TIMEBEFOREFIRSTCAPTURE:
61         case CAP_TIMEBETWEENCAPTURES:
62         case CAP_AUTOSCAN:
63         case CAP_CLEARBUFFERS:
64         case CAP_MAXBATCHBUFFERS:
65         case ICAP_BARCODEDETECTIONENABLED:
66         case ICAP_SUPPORTEDBARCODETYPES:
67         case ICAP_BARCODEMAXSEARCHPRIORITIES:
68         case ICAP_BARCODESEARCHPRIORITIES:
69         case ICAP_BARCODESEARCHMODE:
70         case ICAP_BARCODEMAXRETRIES:
71         case ICAP_BARCODETIMEOUT:
72         case CAP_EXTENDEDCAPS:
73         case CAP_SUPPORTEDCAPS:
74         case ICAP_FILTER:
75         case ICAP_GAMMA:
76         case ICAP_PLANARCHUNKY:
77         case ICAP_BITORDERCODES:
78         case ICAP_CCITTKFACTOR:
79         case ICAP_JPEGPIXELTYPE:
80         /*case ICAP_JPEGQUALITY:*/
81         case ICAP_PIXELFLAVORCODES:
82         case ICAP_TIMEFILL:
83         case CAP_DEVICEONLINE:
84         case CAP_DEVICETIMEDATE:
85         case CAP_SERIALNUMBER:
86         case ICAP_EXPOSURETIME:
87         case ICAP_FLASHUSED2:
88         case ICAP_IMAGEFILTER:
89         case ICAP_LAMPSTATE:
90         case ICAP_LIGHTPATH:
91         case ICAP_NOISEFILTER:
92         case ICAP_OVERSCAN:
93         case ICAP_PHYSICALHEIGHT:
94         case ICAP_PHYSICALWIDTH:
95         case ICAP_ZOOMFACTOR:
96         case CAP_PRINTER:
97         case CAP_PRINTERENABLED:
98         case CAP_PRINTERINDEX:
99         case CAP_PRINTERMODE:
100         case CAP_PRINTERSTRING:
101         case CAP_PRINTERSUFFIX:
102         case CAP_AUTHOR:
103         case CAP_CAPTION:
104         case CAP_TIMEDATE:
105         case ICAP_AUTOBRIGHT:
106         case ICAP_BRIGHTNESS:
107         case ICAP_CONTRAST:
108         case ICAP_HIGHLIGHT:
109         case ICAP_ORIENTATION:
110         case ICAP_ROTATION:
111         case ICAP_SHADOW:
112         case ICAP_XSCALING:
113         case ICAP_YSCALING:
114         case ICAP_BITDEPTHREDUCTION:
115         case ICAP_BITORDER:
116         case ICAP_CUSTHALFTONE:
117         case ICAP_HALFTONES:
118         case ICAP_THRESHOLD:
119         case CAP_LANGUAGE:
120         case ICAP_FRAMES:
121         case ICAP_MAXFRAMES:
122         case ICAP_SUPPORTEDSIZES:
123         case CAP_AUTOFEED:
124         case CAP_CLEARPAGE:
125         case CAP_FEEDERALIGNMENT:
126         case CAP_FEEDERENABLED:
127         case CAP_FEEDERLOADED:
128         case CAP_FEEDERORDER:
129         case CAP_FEEDPAGE:
130         case CAP_PAPERBINDING:
131         case CAP_PAPERDETECTABLE:
132         case CAP_REACQUIREALLOWED:
133         case CAP_REWINDPAGE:
134         case ICAP_PATCHCODEDETECTIONENABLED:
135         case ICAP_SUPPORTEDPATCHCODETYPES:
136         case ICAP_PATCHCODEMAXSEARCHPRIORITIES:
137         case ICAP_PATCHCODESEARCHPRIORITIES:
138         case ICAP_PATCHCODESEARCHMODE:
139         case ICAP_PATCHCODEMAXRETRIES:
140         case ICAP_PATCHCODETIMEOUT:
141         case CAP_BATTERYMINUTES:
142         case CAP_BATTERYPERCENTAGE:
143         case CAP_POWERDOWNTIME:
144         case CAP_POWERSUPPLY:
145         case ICAP_XNATIVERESOLUTION:
146         case ICAP_XRESOLUTION:
147         case ICAP_YNATIVERESOLUTION:
148         case ICAP_YRESOLUTION:
149             twCC = TWCC_CAPUNSUPPORTED;
150             break;
151         case CAP_XFERCOUNT:
152             /* This is a required capability that every source need to
153                support but we haven't implemented yet. */
154             twCC = TWCC_SUCCESS;
155             break;
156         /*case ICAP_COMPRESSION:*/
157         case ICAP_IMAGEFILEFORMAT:
158         case ICAP_TILES:
159             twCC = TWCC_CAPUNSUPPORTED;
160             break;
161         case ICAP_XFERMECH:
162             twCC = GPHOTO2_ICAPXferMech (pCapability, action);
163             break;
164         case ICAP_PIXELTYPE:
165             twCC = GPHOTO2_ICAPPixelType (pCapability, action);
166             break;
167         case ICAP_PIXELFLAVOR:
168             twCC = GPHOTO2_ICAPPixelFlavor (pCapability, action);
169             break;
170         case ICAP_BITDEPTH:
171             twCC = GPHOTO2_ICAPBitDepth (pCapability, action);
172             break;
173         case ICAP_UNITS:
174             twCC = GPHOTO2_ICAPUnits (pCapability, action);
175             break;
176         case ICAP_UNDEFINEDIMAGESIZE:
177         case CAP_CAMERAPREVIEWUI:
178         case CAP_ENABLEDSUIONLY:
179         case CAP_INDICATORS:
180         case CAP_UICONTROLLABLE:
181             twCC = TWCC_CAPUNSUPPORTED;
182             break;
183
184         case ICAP_COMPRESSION:
185             twCC = TWCC_SUCCESS;
186             break;
187         default:
188             twCC = TWRC_FAILURE;
189             break;
190     }
191     return twCC;
192 }
193
194 static TW_BOOL GPHOTO2_OneValueSet32 (pTW_CAPABILITY pCapability, TW_UINT32 value)
195 {
196     pCapability->hContainer = (TW_HANDLE)GlobalAlloc (0, sizeof(TW_ONEVALUE));
197
198     TRACE("-> %ld\n", value);
199
200     if (pCapability->hContainer)
201     {
202         pTW_ONEVALUE pVal = GlobalLock ((HGLOBAL) pCapability->hContainer);
203         pVal->ItemType = TWTY_UINT32;
204         pVal->Item = value;
205         GlobalUnlock ((HGLOBAL) pCapability->hContainer);
206         pCapability->ConType = TWON_ONEVALUE;
207         return TRUE;
208     }
209     else
210         return FALSE;
211 }
212
213 static TW_BOOL GPHOTO2_OneValueSet16 (pTW_CAPABILITY pCapability, TW_UINT16 value)
214 {
215     pCapability->hContainer = (TW_HANDLE)GlobalAlloc (0, sizeof(TW_ONEVALUE));
216
217     TRACE("-> %d\n", value);
218
219     if (pCapability->hContainer)
220     {
221         pTW_ONEVALUE pVal = GlobalLock ((HGLOBAL) pCapability->hContainer);
222         pVal->ItemType = TWTY_UINT16;
223         pVal->Item = value;
224         GlobalUnlock ((HGLOBAL) pCapability->hContainer);
225         pCapability->ConType = TWON_ONEVALUE;
226         return TRUE;
227     }
228     else
229         return FALSE;
230 }
231
232 static TW_BOOL GPHOTO2_EnumSet16 (pTW_CAPABILITY pCapability, int nrofvalues, TW_UINT16 *values, int current, int def)
233 {
234     pTW_ENUMERATION pVal;
235     pCapability->hContainer = (TW_HANDLE)GlobalAlloc (0, sizeof(TW_ENUMERATION) + nrofvalues * sizeof(TW_UINT16));
236
237     if (!pCapability->hContainer)
238         return FALSE;
239
240     pVal = GlobalLock ((HGLOBAL) pCapability->hContainer);
241     pVal->ItemType = TWTY_UINT16;
242     pVal->NumItems = nrofvalues;
243     memcpy(pVal->ItemList, values, sizeof(TW_UINT16)*nrofvalues);
244     pVal->CurrentIndex = current;
245     pVal->DefaultIndex = def;
246     pCapability->ConType = TWON_ENUMERATION;
247     GlobalUnlock ((HGLOBAL) pCapability->hContainer);
248     return TRUE;
249 }
250
251 static TW_BOOL GPHOTO2_EnumGet16 (pTW_CAPABILITY pCapability, int *nrofvalues, TW_UINT16 **values)
252 {
253     pTW_ENUMERATION pVal = GlobalLock ((HGLOBAL) pCapability->hContainer);
254
255     if (!pVal)
256         return FALSE;
257     *nrofvalues = pVal->NumItems;
258     *values = HeapAlloc( GetProcessHeap(), 0, sizeof(TW_UINT16)*pVal->NumItems);
259     memcpy (*values, pVal->ItemList, sizeof(TW_UINT16)*(*nrofvalues));
260     FIXME("Current Index %ld, Default Index %ld\n", pVal->CurrentIndex, pVal->DefaultIndex);
261     GlobalUnlock ((HGLOBAL) pCapability->hContainer);
262     return TRUE;
263 }
264
265 static TW_BOOL GPHOTO2_OneValueGet32 (pTW_CAPABILITY pCapability, TW_UINT32 *pValue)
266 {
267     pTW_ONEVALUE pVal = GlobalLock ((HGLOBAL) pCapability->hContainer);
268
269     if (pVal)
270     {
271         *pValue = pVal->Item;
272         GlobalUnlock ((HGLOBAL) pCapability->hContainer);
273         return TRUE;
274     }
275     else
276         return FALSE;
277 }
278
279 static TW_BOOL GPHOTO2_OneValueGet16 (pTW_CAPABILITY pCapability, TW_UINT16 *pValue)
280 {
281     pTW_ONEVALUE pVal = GlobalLock ((HGLOBAL) pCapability->hContainer);
282
283     if (pVal)
284     {
285         *pValue = pVal->Item;
286         GlobalUnlock ((HGLOBAL) pCapability->hContainer);
287         return TRUE;
288     }
289     else
290         return FALSE;
291 }
292
293 /* ICAP_XFERMECH */
294 static TW_UINT16 GPHOTO2_ICAPXferMech (pTW_CAPABILITY pCapability, TW_UINT16 action)
295 {
296     TRACE("ICAP_XFERMECH, action %d\n", action);
297
298     switch (action)
299     {
300         case MSG_GET:
301             if (!GPHOTO2_OneValueSet32 (pCapability, activeDS.capXferMech))
302                 return TWCC_LOWMEMORY;
303             return TWCC_SUCCESS;
304         case MSG_SET:
305             if (pCapability->ConType == TWON_ONEVALUE)
306             {
307                 TW_UINT32 xfermechtemp = 0;
308
309                 if (!GPHOTO2_OneValueGet32 (pCapability, &xfermechtemp))
310                     return TWCC_LOWMEMORY;
311                 activeDS.capXferMech = xfermechtemp;
312                 TRACE("xfermech is %ld\n", xfermechtemp);
313                 return TWCC_SUCCESS;
314             }
315             else if (pCapability->ConType == TWON_ENUMERATION)
316             {
317
318             }
319             FIXME("GET FAILED\n");
320             break;
321         case MSG_GETCURRENT:
322             if (!GPHOTO2_OneValueSet32 (pCapability, activeDS.capXferMech))
323                 return TWCC_LOWMEMORY;
324             break;
325         case MSG_GETDEFAULT:
326             if (!GPHOTO2_OneValueSet32 (pCapability, TWSX_NATIVE))
327                 return TWCC_LOWMEMORY;
328             break;
329         case MSG_RESET:
330             activeDS.capXferMech = TWSX_NATIVE;
331             break;
332     }
333     return TWCC_SUCCESS;
334 }
335
336 /* ICAP_PIXELTYPE */
337 static TW_UINT16 GPHOTO2_ICAPPixelType (pTW_CAPABILITY pCapability, TW_UINT16 action)
338 {
339     TRACE("Action %d\n", action);
340
341     switch (action)
342     {
343         case MSG_GET:
344             if ((pCapability->ConType == TWON_DONTCARE16) ||
345                 (pCapability->ConType == TWON_ONEVALUE)
346             ) {
347                 if (!GPHOTO2_OneValueSet16 (pCapability, activeDS.pixeltype))
348                     return TWCC_LOWMEMORY;
349                 return TWCC_SUCCESS;
350             }
351             FIXME("Unknown container type %x in MSG_GET\n", pCapability->ConType);
352             return TWCC_CAPBADOPERATION;
353         case MSG_SET:
354             if (pCapability->ConType == TWON_ONEVALUE)
355             {
356                 TW_UINT16 pixeltype = 0;
357
358                 if (!GPHOTO2_OneValueGet16 (pCapability, &pixeltype))
359                     return TWCC_LOWMEMORY;
360                 activeDS.pixeltype = pixeltype;
361                 FIXME("pixeltype changed to %d!\n", pixeltype);
362                 return TWCC_SUCCESS;
363             }
364             FIXME("set not done\n");
365             if (pCapability->ConType == TWON_ENUMERATION) {
366                 TW_UINT16       *values = NULL;
367                 int i, nrofvalues = 0;
368                 
369                 if (!GPHOTO2_EnumGet16 (pCapability, &nrofvalues, &values))
370                     return TWCC_LOWMEMORY;
371                 for (i=0;i<nrofvalues;i++)
372                     FIXME("SET PixelType %d:%d\n", i, values[i]);
373                 HeapFree (GetProcessHeap(), 0, values);
374             }
375             break;
376         case MSG_GETCURRENT:
377             if (!GPHOTO2_OneValueSet16 (pCapability, activeDS.pixeltype)) {
378                 FIXME("Failed one value set in GETCURRENT, contype %d!\n", pCapability->ConType);
379                 return TWCC_LOWMEMORY;
380             }
381             break;
382         case MSG_GETDEFAULT:
383             if (!GPHOTO2_OneValueSet16 (pCapability, TWPT_RGB)) {
384                 FIXME("Failed onevalue set in GETDEFAULT!\n");
385                 return TWCC_LOWMEMORY;
386             }
387             break;
388         case MSG_RESET:
389             activeDS.pixeltype = TWPT_RGB;
390             break;
391     }
392     return TWCC_SUCCESS;
393 }
394
395 /* ICAP_PIXELFLAVOR */
396 static TW_UINT16 GPHOTO2_ICAPPixelFlavor (pTW_CAPABILITY pCapability, TW_UINT16 action)
397 {
398     TRACE("Action %d\n", action);
399
400     switch (action)
401     {
402         case MSG_GET:
403             if ((pCapability->ConType == TWON_DONTCARE16)       ||
404                 (pCapability->ConType == TWON_ONEVALUE)
405             ) {
406                 if (!GPHOTO2_OneValueSet16 (pCapability, TWPF_CHOCOLATE))
407                     return TWCC_LOWMEMORY;
408                 return TWCC_SUCCESS;
409             }
410             if (!pCapability->ConType) {
411                 TW_UINT16 arr[2];
412                 arr[0] = TWPF_CHOCOLATE;
413                 arr[1] = TWPF_VANILLA;
414
415                 if (!GPHOTO2_EnumSet16 (pCapability, 2, arr, 1, 1))
416                     return TWCC_LOWMEMORY;
417                 return TWCC_SUCCESS;
418             }
419             FIXME("MSG_GET container type %x unhandled\n", pCapability->ConType);
420             return TWCC_BADVALUE;
421         case MSG_SET:
422             if (pCapability->ConType == TWON_ONEVALUE)
423             {
424                 TW_UINT16 pixelflavor = 0;
425
426                 if (!GPHOTO2_OneValueGet16 (pCapability, &pixelflavor))
427                     return TWCC_LOWMEMORY;
428                 activeDS.pixelflavor = pixelflavor;
429                 FIXME("pixelflavor is %d\n", pixelflavor);
430             }
431             break;
432         case MSG_GETCURRENT:
433             if (!GPHOTO2_OneValueSet16 (pCapability, activeDS.pixelflavor))
434                 return TWCC_LOWMEMORY;
435             break;
436         case MSG_GETDEFAULT:
437             if (!GPHOTO2_OneValueSet16 (pCapability, TWPF_CHOCOLATE))
438                 return TWCC_LOWMEMORY;
439             break;
440         case MSG_RESET:
441             break;
442     }
443     return TWCC_SUCCESS;
444 }
445
446 /* ICAP_BITDEPTH */
447 static TW_UINT16 GPHOTO2_ICAPBitDepth (pTW_CAPABILITY pCapability, TW_UINT16 action)
448 {
449     TRACE("Action %d\n", action);
450
451     switch (action)
452     {
453         case MSG_GET:
454             if ((pCapability->ConType == TWON_DONTCARE16) ||
455                 (pCapability->ConType == TWON_ONEVALUE)
456             ) {
457                 if (!GPHOTO2_OneValueSet16 (pCapability, 24))
458                     return TWCC_LOWMEMORY;
459                 return TWCC_SUCCESS;
460             }
461             FIXME("MSG_GET container type %x unhandled\n", pCapability->ConType);
462             return TWCC_SUCCESS;
463         case MSG_SET:
464             if (pCapability->ConType == TWON_ONEVALUE) {
465                 TW_UINT16 bitdepth = 0;
466
467                 if (!GPHOTO2_OneValueGet16 (pCapability, &bitdepth))
468                     return TWCC_LOWMEMORY;
469                 if (bitdepth != 24)
470                     return TWCC_BADVALUE;
471                 return TWCC_SUCCESS;
472             }
473             if (pCapability->ConType == TWON_ENUMERATION)
474             {
475                 int i, nrofvalues = 0;
476                 TW_UINT16 *values = NULL;
477
478                 if (!GPHOTO2_EnumGet16 (pCapability, &nrofvalues, &values))
479                     return TWCC_LOWMEMORY;
480                 for (i=0;i<nrofvalues;i++)
481                     FIXME("SET: enum element %d = %d\n", i, values[i]);
482                 HeapFree (GetProcessHeap(), 0, values);
483                 return TWCC_SUCCESS;
484             }
485             FIXME("Unhandled container type %d in MSG_SET\n", pCapability->ConType);
486             break;
487         case MSG_GETCURRENT:
488             if (!GPHOTO2_OneValueSet16 (pCapability, 24))
489                 return TWCC_LOWMEMORY;
490             break;
491         case MSG_GETDEFAULT:
492             if (!GPHOTO2_OneValueSet16 (pCapability, 24))
493                 return TWCC_LOWMEMORY;
494             break;
495         case MSG_RESET:
496             break;
497     }
498     return TWCC_SUCCESS;
499 }
500
501 /* ICAP_UNITS */
502 static TW_UINT16 GPHOTO2_ICAPUnits (pTW_CAPABILITY pCapability, TW_UINT16 action)
503 {
504     TRACE("Action %d\n", action);
505
506     switch (action)
507     {
508         case MSG_GET:
509             if ((pCapability->ConType == TWON_DONTCARE16) ||
510                 (pCapability->ConType == TWON_ONEVALUE)
511             ) {
512                 if (!GPHOTO2_OneValueSet16 (pCapability, TWUN_PIXELS))
513                     return TWCC_LOWMEMORY;
514                 return TWCC_SUCCESS;
515             }
516             FIXME("MSG_GET container type %x unhandled\n", pCapability->ConType);
517             return TWCC_SUCCESS;
518         case MSG_SET:
519             if (pCapability->ConType == TWON_ONEVALUE) {
520                 TW_UINT16 units = 0;
521
522                 if (!GPHOTO2_OneValueGet16 (pCapability, &units))
523                     return TWCC_LOWMEMORY;
524                 FIXME("SET to type %d, stub.\n", units);
525                 return TWCC_SUCCESS;
526             }
527             if (pCapability->ConType == TWON_ENUMERATION)
528             {
529                 int i, nrofvalues = 0;
530                 TW_UINT16 *values = NULL;
531
532                 if (!GPHOTO2_EnumGet16 (pCapability, &nrofvalues, &values))
533                     return TWCC_LOWMEMORY;
534                 for (i=0;i<nrofvalues;i++)
535                     FIXME("SET: enum element %d = %d\n", i, values[i]);
536                 HeapFree (GetProcessHeap(), 0, values);
537                 return TWCC_SUCCESS;
538             }
539             FIXME("Unhandled container type %d in MSG_SET\n", pCapability->ConType);
540             break;
541         case MSG_GETCURRENT:
542             if (!GPHOTO2_OneValueSet16 (pCapability, TWUN_INCHES))
543                 return TWCC_LOWMEMORY;
544             break;
545         case MSG_GETDEFAULT:
546             if (!GPHOTO2_OneValueSet16 (pCapability, TWUN_PIXELS))
547                 return TWCC_LOWMEMORY;
548             break;
549         case MSG_RESET:
550             break;
551     }
552     return TWCC_SUCCESS;
553 }