winhttp: Use schannel for HTTPS connection by defaul and get rid of OpenSSL dependency.
[wine] / dlls / gdiplus / metafile.c
1 /*
2  * Copyright (C) 2011 Vincent Povirk for CodeWeavers
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17  */
18
19 #include <stdarg.h>
20 #include <math.h>
21
22 #include "windef.h"
23 #include "winbase.h"
24 #include "wingdi.h"
25 #include "wine/unicode.h"
26
27 #define COBJMACROS
28 #include "objbase.h"
29 #include "ocidl.h"
30 #include "olectl.h"
31 #include "ole2.h"
32
33 #include "winreg.h"
34 #include "shlwapi.h"
35
36 #include "gdiplus.h"
37 #include "gdiplus_private.h"
38 #include "wine/debug.h"
39 #include "wine/list.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
42
43 typedef struct EmfPlusRecordHeader
44 {
45     WORD Type;
46     WORD Flags;
47     DWORD Size;
48     DWORD DataSize;
49 } EmfPlusRecordHeader;
50
51 typedef struct EmfPlusHeader
52 {
53     EmfPlusRecordHeader Header;
54     DWORD Version;
55     DWORD EmfPlusFlags;
56     DWORD LogicalDpiX;
57     DWORD LogicalDpiY;
58 } EmfPlusHeader;
59
60 static GpStatus METAFILE_AllocateRecord(GpMetafile *metafile, DWORD size, void **result)
61 {
62     DWORD size_needed;
63     EmfPlusRecordHeader *record;
64
65     if (!metafile->comment_data_size)
66     {
67         DWORD data_size = max(256, size * 2 + 4);
68         metafile->comment_data = GdipAlloc(data_size);
69
70         if (!metafile->comment_data)
71             return OutOfMemory;
72
73         memcpy(metafile->comment_data, "EMF+", 4);
74
75         metafile->comment_data_size = data_size;
76         metafile->comment_data_length = 4;
77     }
78
79     size_needed = size + metafile->comment_data_length;
80
81     if (size_needed > metafile->comment_data_size)
82     {
83         DWORD data_size = size_needed * 2;
84         BYTE *new_data = GdipAlloc(data_size);
85
86         if (!new_data)
87             return OutOfMemory;
88
89         memcpy(new_data, metafile->comment_data, metafile->comment_data_length);
90
91         metafile->comment_data_size = data_size;
92         GdipFree(metafile->comment_data);
93         metafile->comment_data = new_data;
94     }
95
96     *result = metafile->comment_data + metafile->comment_data_length;
97     metafile->comment_data_length += size;
98
99     record = (EmfPlusRecordHeader*)*result;
100     record->Size = size;
101     record->DataSize = size - sizeof(EmfPlusRecordHeader);
102
103     return Ok;
104 }
105
106 static void METAFILE_WriteRecords(GpMetafile *metafile)
107 {
108     if (metafile->comment_data_length > 4)
109     {
110         GdiComment(metafile->record_dc, metafile->comment_data_length, metafile->comment_data);
111         metafile->comment_data_length = 4;
112     }
113 }
114
115 static GpStatus METAFILE_WriteHeader(GpMetafile *metafile, HDC hdc)
116 {
117     GpStatus stat;
118
119     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
120     {
121         EmfPlusHeader *header;
122
123         stat = METAFILE_AllocateRecord(metafile, sizeof(EmfPlusHeader), (void**)&header);
124         if (stat != Ok)
125             return stat;
126
127         header->Header.Type = EmfPlusRecordTypeHeader;
128
129         if (metafile->metafile_type == MetafileTypeEmfPlusDual)
130             header->Header.Flags = 1;
131         else
132             header->Header.Flags = 0;
133
134         header->Version = 0xDBC01002;
135
136         if (GetDeviceCaps(hdc, TECHNOLOGY) == DT_RASDISPLAY)
137             header->EmfPlusFlags = 1;
138         else
139             header->EmfPlusFlags = 0;
140
141         header->LogicalDpiX = GetDeviceCaps(hdc, LOGPIXELSX);
142         header->LogicalDpiY = GetDeviceCaps(hdc, LOGPIXELSY);
143
144         METAFILE_WriteRecords(metafile);
145     }
146
147     return Ok;
148 }
149
150 static GpStatus METAFILE_WriteEndOfFile(GpMetafile *metafile)
151 {
152     GpStatus stat;
153
154     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
155     {
156         EmfPlusRecordHeader *record;
157
158         stat = METAFILE_AllocateRecord(metafile, sizeof(EmfPlusRecordHeader), (void**)&record);
159         if (stat != Ok)
160             return stat;
161
162         record->Type = EmfPlusRecordTypeEndOfFile;
163         record->Flags = 0;
164
165         METAFILE_WriteRecords(metafile);
166     }
167
168     return Ok;
169 }
170
171 GpStatus WINGDIPAPI GdipRecordMetafile(HDC hdc, EmfType type, GDIPCONST GpRectF *frameRect,
172                                        MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
173 {
174     HDC record_dc;
175     REAL framerect_factor_x, framerect_factor_y;
176     RECT rc;
177     GpStatus stat;
178
179     TRACE("(%p %d %p %d %p %p)\n", hdc, type, frameRect, frameUnit, desc, metafile);
180
181     if (!hdc || type < EmfTypeEmfOnly || type > EmfTypeEmfPlusDual || !metafile)
182         return InvalidParameter;
183
184     if (!frameRect)
185     {
186         FIXME("not implemented for NULL rect\n");
187         return NotImplemented;
188     }
189
190     switch (frameUnit)
191     {
192     case MetafileFrameUnitPixel:
193         framerect_factor_x = 2540.0 / GetDeviceCaps(hdc, LOGPIXELSX);
194         framerect_factor_y = 2540.0 / GetDeviceCaps(hdc, LOGPIXELSY);
195         break;
196     case MetafileFrameUnitPoint:
197         framerect_factor_x = framerect_factor_y = 2540.0 / 72.0;
198         break;
199     case MetafileFrameUnitInch:
200         framerect_factor_x = framerect_factor_y = 2540.0;
201         break;
202     case MetafileFrameUnitDocument:
203         framerect_factor_x = framerect_factor_y = 2540.0 / 300.0;
204         break;
205     case MetafileFrameUnitMillimeter:
206         framerect_factor_x = framerect_factor_y = 100.0;
207         break;
208     case MetafileFrameUnitGdi:
209         framerect_factor_x = framerect_factor_y = 1.0;
210         break;
211     default:
212         return InvalidParameter;
213     }
214
215     rc.left = framerect_factor_x * frameRect->X;
216     rc.top = framerect_factor_y * frameRect->Y;
217     rc.right = rc.left + framerect_factor_x * frameRect->Width;
218     rc.bottom = rc.top + framerect_factor_y * frameRect->Height;
219
220     record_dc = CreateEnhMetaFileW(hdc, NULL, &rc, desc);
221
222     if (!record_dc)
223         return GenericError;
224
225     *metafile = GdipAlloc(sizeof(GpMetafile));
226     if(!*metafile)
227     {
228         DeleteEnhMetaFile(CloseEnhMetaFile(record_dc));
229         return OutOfMemory;
230     }
231
232     (*metafile)->image.type = ImageTypeMetafile;
233     (*metafile)->image.picture = NULL;
234     (*metafile)->image.flags   = ImageFlagsNone;
235     (*metafile)->image.palette = NULL;
236     (*metafile)->bounds = *frameRect;
237     (*metafile)->unit = frameUnit;
238     (*metafile)->metafile_type = type;
239     (*metafile)->record_dc = record_dc;
240     (*metafile)->comment_data = NULL;
241     (*metafile)->comment_data_size = 0;
242     (*metafile)->comment_data_length = 0;
243     (*metafile)->hemf = NULL;
244
245     stat = METAFILE_WriteHeader(*metafile, hdc);
246
247     if (stat != Ok)
248     {
249         DeleteEnhMetaFile(CloseEnhMetaFile(record_dc));
250         GdipFree(*metafile);
251         *metafile = NULL;
252         return OutOfMemory;
253     }
254
255     return stat;
256 }
257
258 /*****************************************************************************
259  * GdipRecordMetafileI [GDIPLUS.@]
260  */
261 GpStatus WINGDIPAPI GdipRecordMetafileI(HDC hdc, EmfType type, GDIPCONST GpRect *frameRect,
262                                         MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
263 {
264     GpRectF frameRectF, *pFrameRectF;
265
266     TRACE("(%p %d %p %d %p %p)\n", hdc, type, frameRect, frameUnit, desc, metafile);
267
268     if (frameRect)
269     {
270         frameRectF.X = frameRect->X;
271         frameRectF.Y = frameRect->Y;
272         frameRectF.Width = frameRect->Width;
273         frameRectF.Height = frameRect->Height;
274         pFrameRectF = &frameRectF;
275     }
276     else
277         pFrameRectF = NULL;
278
279     return GdipRecordMetafile(hdc, type, pFrameRectF, frameUnit, desc, metafile);
280 }
281
282 GpStatus METAFILE_GetGraphicsContext(GpMetafile* metafile, GpGraphics **result)
283 {
284     GpStatus stat;
285
286     if (!metafile->record_dc || metafile->record_graphics)
287         return InvalidParameter;
288
289     stat = graphics_from_image((GpImage*)metafile, &metafile->record_graphics);
290
291     if (stat == Ok)
292         *result = metafile->record_graphics;
293
294     return stat;
295 }
296
297 GpStatus METAFILE_GetDC(GpMetafile* metafile, HDC *hdc)
298 {
299     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
300     {
301         EmfPlusRecordHeader *record;
302         GpStatus stat;
303
304         stat = METAFILE_AllocateRecord(metafile, sizeof(EmfPlusRecordHeader), (void**)&record);
305         if (stat != Ok)
306             return stat;
307
308         record->Type = EmfPlusRecordTypeGetDC;
309         record->Flags = 0;
310
311         METAFILE_WriteRecords(metafile);
312     }
313
314     *hdc = metafile->record_dc;
315
316     return Ok;
317 }
318
319 GpStatus METAFILE_ReleaseDC(GpMetafile* metafile, HDC hdc)
320 {
321     if (hdc != metafile->record_dc)
322         return InvalidParameter;
323
324     return Ok;
325 }
326
327 GpStatus METAFILE_GraphicsDeleted(GpMetafile* metafile)
328 {
329     GpStatus stat;
330
331     stat = METAFILE_WriteEndOfFile(metafile);
332     metafile->record_graphics = NULL;
333
334     metafile->hemf = CloseEnhMetaFile(metafile->record_dc);
335     metafile->record_dc = NULL;
336
337     GdipFree(metafile->comment_data);
338     metafile->comment_data = NULL;
339     metafile->comment_data_size = 0;
340
341     return stat;
342 }
343
344 GpStatus WINGDIPAPI GdipGetHemfFromMetafile(GpMetafile *metafile, HENHMETAFILE *hEmf)
345 {
346     TRACE("(%p,%p)\n", metafile, hEmf);
347
348     if (!metafile || !hEmf || !metafile->hemf)
349         return InvalidParameter;
350
351     *hEmf = metafile->hemf;
352     metafile->hemf = NULL;
353
354     return Ok;
355 }
356
357 static GpStatus METAFILE_PlaybackGetDC(GpMetafile *metafile)
358 {
359     GpStatus stat = Ok;
360
361     stat = GdipGetDC(metafile->playback_graphics, &metafile->playback_dc);
362
363     if (stat == Ok)
364     {
365         /* The result of GdipGetDC always expects device co-ordinates, but the
366          * device co-ordinates of the source metafile do not correspond to
367          * device co-ordinates of the destination. Therefore, we set up the DC
368          * so that the metafile's bounds map to the destination points where we
369          * are drawing this metafile. */
370         SetMapMode(metafile->playback_dc, MM_ANISOTROPIC);
371
372         SetWindowOrgEx(metafile->playback_dc, metafile->bounds.X, metafile->bounds.Y, NULL);
373         SetWindowExtEx(metafile->playback_dc, metafile->bounds.Width, metafile->bounds.Height, NULL);
374
375         SetViewportOrgEx(metafile->playback_dc, metafile->playback_points[0].X, metafile->playback_points[0].Y, NULL);
376         SetViewportExtEx(metafile->playback_dc,
377             metafile->playback_points[1].X - metafile->playback_points[0].X,
378             metafile->playback_points[2].Y - metafile->playback_points[0].Y, NULL);
379     }
380
381     return stat;
382 }
383
384 static void METAFILE_PlaybackReleaseDC(GpMetafile *metafile)
385 {
386     if (metafile->playback_dc)
387     {
388         GdipReleaseDC(metafile->playback_graphics, metafile->playback_dc);
389         metafile->playback_dc = NULL;
390     }
391 }
392
393 GpStatus WINGDIPAPI GdipPlayMetafileRecord(GDIPCONST GpMetafile *metafile,
394     EmfPlusRecordType recordType, UINT flags, UINT dataSize, GDIPCONST BYTE *data)
395 {
396     TRACE("(%p,%x,%x,%d,%p)\n", metafile, recordType, flags, dataSize, data);
397
398     if (!metafile || (dataSize && !data) || !metafile->playback_graphics)
399         return InvalidParameter;
400
401     if (recordType >= 1 && recordType <= 0x7a)
402     {
403         /* regular EMF record */
404         if (metafile->playback_dc)
405         {
406             ENHMETARECORD *record;
407
408             record = GdipAlloc(dataSize + 8);
409
410             if (record)
411             {
412                 record->iType = recordType;
413                 record->nSize = dataSize;
414                 memcpy(record->dParm, data, dataSize);
415
416                 PlayEnhMetaFileRecord(metafile->playback_dc, metafile->handle_table,
417                     record, metafile->handle_count);
418
419                 GdipFree(record);
420             }
421             else
422                 return OutOfMemory;
423         }
424     }
425     else
426     {
427         METAFILE_PlaybackReleaseDC((GpMetafile*)metafile);
428
429         switch(recordType)
430         {
431         case EmfPlusRecordTypeHeader:
432         case EmfPlusRecordTypeEndOfFile:
433             break;
434         case EmfPlusRecordTypeGetDC:
435             METAFILE_PlaybackGetDC((GpMetafile*)metafile);
436             break;
437         default:
438             FIXME("Not implemented for record type %x\n", recordType);
439             return NotImplemented;
440         }
441     }
442
443     return Ok;
444 }
445
446 struct enum_metafile_data
447 {
448     EnumerateMetafileProc callback;
449     void *callback_data;
450     GpMetafile *metafile;
451 };
452
453 static int CALLBACK enum_metafile_proc(HDC hDC, HANDLETABLE *lpHTable, const ENHMETARECORD *lpEMFR,
454     int nObj, LPARAM lpData)
455 {
456     BOOL ret;
457     struct enum_metafile_data *data = (struct enum_metafile_data*)lpData;
458     const BYTE* pStr;
459
460     data->metafile->handle_table = lpHTable;
461     data->metafile->handle_count = nObj;
462
463     /* First check for an EMF+ record. */
464     if (lpEMFR->iType == EMR_GDICOMMENT)
465     {
466         const EMRGDICOMMENT *comment = (const EMRGDICOMMENT*)lpEMFR;
467
468         if (comment->cbData >= 4 && memcmp(comment->Data, "EMF+", 4) == 0)
469         {
470             int offset = 4;
471
472             while (offset + sizeof(EmfPlusRecordHeader) <= comment->cbData)
473             {
474                 const EmfPlusRecordHeader *record = (const EmfPlusRecordHeader*)&comment->Data[offset];
475
476                 if (record->DataSize)
477                     pStr = (const BYTE*)(record+1);
478                 else
479                     pStr = NULL;
480
481                 ret = data->callback(record->Type, record->Flags, record->DataSize,
482                     pStr, data->callback_data);
483
484                 if (!ret)
485                     return 0;
486
487                 offset += record->Size;
488             }
489
490             return 1;
491         }
492     }
493
494     if (lpEMFR->nSize != 8)
495         pStr = (const BYTE*)lpEMFR->dParm;
496     else
497         pStr = NULL;
498
499     return data->callback(lpEMFR->iType, 0, lpEMFR->nSize-8,
500         pStr, data->callback_data);
501 }
502
503 GpStatus WINGDIPAPI GdipEnumerateMetafileSrcRectDestPoints(GpGraphics *graphics,
504     GDIPCONST GpMetafile *metafile, GDIPCONST GpPointF *destPoints, INT count,
505     GDIPCONST GpRectF *srcRect, Unit srcUnit, EnumerateMetafileProc callback,
506     VOID *callbackData, GDIPCONST GpImageAttributes *imageAttributes)
507 {
508     struct enum_metafile_data data;
509     GpStatus stat;
510     GpMetafile *real_metafile = (GpMetafile*)metafile; /* whoever made this const was joking */
511
512     TRACE("(%p,%p,%p,%i,%p,%i,%p,%p,%p)\n", graphics, metafile,
513         destPoints, count, srcRect, srcUnit, callback, callbackData,
514         imageAttributes);
515
516     if (!graphics || !metafile || !destPoints || count != 3 || !srcRect)
517         return InvalidParameter;
518
519     if (!metafile->hemf)
520         return InvalidParameter;
521
522     if (metafile->playback_graphics)
523         return ObjectBusy;
524
525     TRACE("%s %i -> %s %s %s\n", debugstr_rectf(srcRect), srcUnit,
526         debugstr_pointf(&destPoints[0]), debugstr_pointf(&destPoints[1]),
527         debugstr_pointf(&destPoints[2]));
528
529     data.callback = callback;
530     data.callback_data = callbackData;
531     data.metafile = real_metafile;
532
533     real_metafile->playback_graphics = graphics;
534     real_metafile->playback_dc = NULL;
535
536     memcpy(real_metafile->playback_points, destPoints, sizeof(PointF) * 3);
537     stat = GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, real_metafile->playback_points, 3);
538
539     if (stat == Ok && metafile->metafile_type == MetafileTypeEmf)
540         stat = METAFILE_PlaybackGetDC((GpMetafile*)metafile);
541
542     if (stat == Ok)
543         EnumEnhMetaFile(0, metafile->hemf, enum_metafile_proc, &data, NULL);
544
545     METAFILE_PlaybackReleaseDC((GpMetafile*)metafile);
546
547     real_metafile->playback_graphics = NULL;
548
549     return stat;
550 }
551
552 static int CALLBACK get_metafile_type_proc(HDC hDC, HANDLETABLE *lpHTable, const ENHMETARECORD *lpEMFR,
553     int nObj, LPARAM lpData)
554 {
555     MetafileType *result = (MetafileType*)lpData;
556
557     if (lpEMFR->iType == EMR_GDICOMMENT)
558     {
559         const EMRGDICOMMENT *comment = (const EMRGDICOMMENT*)lpEMFR;
560
561         if (comment->cbData >= 4 && memcmp(comment->Data, "EMF+", 4) == 0)
562         {
563             const EmfPlusRecordHeader *header = (const EmfPlusRecordHeader*)&comment->Data[4];
564
565             if (4 + sizeof(EmfPlusRecordHeader) <= comment->cbData &&
566                 header->Type == EmfPlusRecordTypeHeader)
567             {
568                 if ((header->Flags & 1) == 1)
569                     *result = MetafileTypeEmfPlusDual;
570                 else
571                     *result = MetafileTypeEmfPlusOnly;
572             }
573         }
574         else
575             *result = MetafileTypeEmf;
576     }
577     else
578         *result = MetafileTypeEmf;
579
580     return FALSE;
581 }
582
583 MetafileType METAFILE_GetEmfType(HENHMETAFILE hemf)
584 {
585     MetafileType result = MetafileTypeInvalid;
586     EnumEnhMetaFile(NULL, hemf, get_metafile_type_proc, &result, NULL);
587     return result;
588 }