urlmon: Use wine lists to store namespaces and MIME filters.
[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_flags = 0;
236     (*metafile)->image.palette_count = 0;
237     (*metafile)->image.palette_size = 0;
238     (*metafile)->image.palette_entries = NULL;
239     (*metafile)->bounds = *frameRect;
240     (*metafile)->unit = frameUnit;
241     (*metafile)->metafile_type = type;
242     (*metafile)->record_dc = record_dc;
243     (*metafile)->comment_data = NULL;
244     (*metafile)->comment_data_size = 0;
245     (*metafile)->comment_data_length = 0;
246     (*metafile)->hemf = NULL;
247
248     stat = METAFILE_WriteHeader(*metafile, hdc);
249
250     if (stat != Ok)
251     {
252         DeleteEnhMetaFile(CloseEnhMetaFile(record_dc));
253         GdipFree(*metafile);
254         *metafile = NULL;
255         return OutOfMemory;
256     }
257
258     return stat;
259 }
260
261 /*****************************************************************************
262  * GdipRecordMetafileI [GDIPLUS.@]
263  */
264 GpStatus WINGDIPAPI GdipRecordMetafileI(HDC hdc, EmfType type, GDIPCONST GpRect *frameRect,
265                                         MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
266 {
267     GpRectF frameRectF, *pFrameRectF;
268
269     TRACE("(%p %d %p %d %p %p)\n", hdc, type, frameRect, frameUnit, desc, metafile);
270
271     if (frameRect)
272     {
273         frameRectF.X = frameRect->X;
274         frameRectF.Y = frameRect->Y;
275         frameRectF.Width = frameRect->Width;
276         frameRectF.Height = frameRect->Height;
277         pFrameRectF = &frameRectF;
278     }
279     else
280         pFrameRectF = NULL;
281
282     return GdipRecordMetafile(hdc, type, pFrameRectF, frameUnit, desc, metafile);
283 }
284
285 GpStatus METAFILE_GetGraphicsContext(GpMetafile* metafile, GpGraphics **result)
286 {
287     GpStatus stat;
288
289     if (!metafile->record_dc || metafile->record_graphics)
290         return InvalidParameter;
291
292     stat = graphics_from_image((GpImage*)metafile, &metafile->record_graphics);
293
294     if (stat == Ok)
295         *result = metafile->record_graphics;
296
297     return stat;
298 }
299
300 GpStatus METAFILE_GetDC(GpMetafile* metafile, HDC *hdc)
301 {
302     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
303     {
304         EmfPlusRecordHeader *record;
305         GpStatus stat;
306
307         stat = METAFILE_AllocateRecord(metafile, sizeof(EmfPlusRecordHeader), (void**)&record);
308         if (stat != Ok)
309             return stat;
310
311         record->Type = EmfPlusRecordTypeGetDC;
312         record->Flags = 0;
313
314         METAFILE_WriteRecords(metafile);
315     }
316
317     *hdc = metafile->record_dc;
318
319     return Ok;
320 }
321
322 GpStatus METAFILE_ReleaseDC(GpMetafile* metafile, HDC hdc)
323 {
324     if (hdc != metafile->record_dc)
325         return InvalidParameter;
326
327     return Ok;
328 }
329
330 GpStatus METAFILE_GraphicsDeleted(GpMetafile* metafile)
331 {
332     GpStatus stat;
333
334     stat = METAFILE_WriteEndOfFile(metafile);
335     metafile->record_graphics = NULL;
336
337     metafile->hemf = CloseEnhMetaFile(metafile->record_dc);
338     metafile->record_dc = NULL;
339
340     GdipFree(metafile->comment_data);
341     metafile->comment_data = NULL;
342     metafile->comment_data_size = 0;
343
344     return stat;
345 }
346
347 GpStatus WINGDIPAPI GdipGetHemfFromMetafile(GpMetafile *metafile, HENHMETAFILE *hEmf)
348 {
349     TRACE("(%p,%p)\n", metafile, hEmf);
350
351     if (!metafile || !hEmf || !metafile->hemf)
352         return InvalidParameter;
353
354     *hEmf = metafile->hemf;
355     metafile->hemf = NULL;
356
357     return Ok;
358 }
359
360 static GpStatus METAFILE_PlaybackGetDC(GpMetafile *metafile)
361 {
362     GpStatus stat = Ok;
363
364     stat = GdipGetDC(metafile->playback_graphics, &metafile->playback_dc);
365
366     if (stat == Ok)
367     {
368         /* The result of GdipGetDC always expects device co-ordinates, but the
369          * device co-ordinates of the source metafile do not correspond to
370          * device co-ordinates of the destination. Therefore, we set up the DC
371          * so that the metafile's bounds map to the destination points where we
372          * are drawing this metafile. */
373         SetMapMode(metafile->playback_dc, MM_ANISOTROPIC);
374
375         SetWindowOrgEx(metafile->playback_dc, metafile->bounds.X, metafile->bounds.Y, NULL);
376         SetWindowExtEx(metafile->playback_dc, metafile->bounds.Width, metafile->bounds.Height, NULL);
377
378         SetViewportOrgEx(metafile->playback_dc, metafile->playback_points[0].X, metafile->playback_points[0].Y, NULL);
379         SetViewportExtEx(metafile->playback_dc,
380             metafile->playback_points[1].X - metafile->playback_points[0].X,
381             metafile->playback_points[2].Y - metafile->playback_points[0].Y, NULL);
382     }
383
384     return stat;
385 }
386
387 static void METAFILE_PlaybackReleaseDC(GpMetafile *metafile)
388 {
389     if (metafile->playback_dc)
390     {
391         GdipReleaseDC(metafile->playback_graphics, metafile->playback_dc);
392         metafile->playback_dc = NULL;
393     }
394 }
395
396 GpStatus WINGDIPAPI GdipPlayMetafileRecord(GDIPCONST GpMetafile *metafile,
397     EmfPlusRecordType recordType, UINT flags, UINT dataSize, GDIPCONST BYTE *data)
398 {
399     TRACE("(%p,%x,%x,%d,%p)\n", metafile, recordType, flags, dataSize, data);
400
401     if (!metafile || (dataSize && !data) || !metafile->playback_graphics)
402         return InvalidParameter;
403
404     if (recordType >= 1 && recordType <= 0x7a)
405     {
406         /* regular EMF record */
407         if (metafile->playback_dc)
408         {
409             ENHMETARECORD *record;
410
411             record = GdipAlloc(dataSize + 8);
412
413             if (record)
414             {
415                 record->iType = recordType;
416                 record->nSize = dataSize;
417                 memcpy(record->dParm, data, dataSize);
418
419                 PlayEnhMetaFileRecord(metafile->playback_dc, metafile->handle_table,
420                     record, metafile->handle_count);
421
422                 GdipFree(record);
423             }
424             else
425                 return OutOfMemory;
426         }
427     }
428     else
429     {
430         METAFILE_PlaybackReleaseDC((GpMetafile*)metafile);
431
432         switch(recordType)
433         {
434         case EmfPlusRecordTypeHeader:
435         case EmfPlusRecordTypeEndOfFile:
436             break;
437         case EmfPlusRecordTypeGetDC:
438             METAFILE_PlaybackGetDC((GpMetafile*)metafile);
439             break;
440         default:
441             FIXME("Not implemented for record type %x\n", recordType);
442             return NotImplemented;
443         }
444     }
445
446     return Ok;
447 }
448
449 struct enum_metafile_data
450 {
451     EnumerateMetafileProc callback;
452     void *callback_data;
453     GpMetafile *metafile;
454 };
455
456 static int CALLBACK enum_metafile_proc(HDC hDC, HANDLETABLE *lpHTable, const ENHMETARECORD *lpEMFR,
457     int nObj, LPARAM lpData)
458 {
459     BOOL ret;
460     struct enum_metafile_data *data = (struct enum_metafile_data*)lpData;
461     const BYTE* pStr;
462
463     data->metafile->handle_table = lpHTable;
464     data->metafile->handle_count = nObj;
465
466     /* First check for an EMF+ record. */
467     if (lpEMFR->iType == EMR_GDICOMMENT)
468     {
469         const EMRGDICOMMENT *comment = (const EMRGDICOMMENT*)lpEMFR;
470
471         if (comment->cbData >= 4 && memcmp(comment->Data, "EMF+", 4) == 0)
472         {
473             int offset = 4;
474
475             while (offset + sizeof(EmfPlusRecordHeader) <= comment->cbData)
476             {
477                 const EmfPlusRecordHeader *record = (const EmfPlusRecordHeader*)&comment->Data[offset];
478
479                 if (record->DataSize)
480                     pStr = (const BYTE*)(record+1);
481                 else
482                     pStr = NULL;
483
484                 ret = data->callback(record->Type, record->Flags, record->DataSize,
485                     pStr, data->callback_data);
486
487                 if (!ret)
488                     return 0;
489
490                 offset += record->Size;
491             }
492
493             return 1;
494         }
495     }
496
497     if (lpEMFR->nSize != 8)
498         pStr = (const BYTE*)lpEMFR->dParm;
499     else
500         pStr = NULL;
501
502     return data->callback(lpEMFR->iType, 0, lpEMFR->nSize-8,
503         pStr, data->callback_data);
504 }
505
506 GpStatus WINGDIPAPI GdipEnumerateMetafileSrcRectDestPoints(GpGraphics *graphics,
507     GDIPCONST GpMetafile *metafile, GDIPCONST GpPointF *destPoints, INT count,
508     GDIPCONST GpRectF *srcRect, Unit srcUnit, EnumerateMetafileProc callback,
509     VOID *callbackData, GDIPCONST GpImageAttributes *imageAttributes)
510 {
511     struct enum_metafile_data data;
512     GpStatus stat;
513     GpMetafile *real_metafile = (GpMetafile*)metafile; /* whoever made this const was joking */
514
515     TRACE("(%p,%p,%p,%i,%p,%i,%p,%p,%p)\n", graphics, metafile,
516         destPoints, count, srcRect, srcUnit, callback, callbackData,
517         imageAttributes);
518
519     if (!graphics || !metafile || !destPoints || count != 3 || !srcRect)
520         return InvalidParameter;
521
522     if (!metafile->hemf)
523         return InvalidParameter;
524
525     if (metafile->playback_graphics)
526         return ObjectBusy;
527
528     TRACE("%s %i -> %s %s %s\n", debugstr_rectf(srcRect), srcUnit,
529         debugstr_pointf(&destPoints[0]), debugstr_pointf(&destPoints[1]),
530         debugstr_pointf(&destPoints[2]));
531
532     data.callback = callback;
533     data.callback_data = callbackData;
534     data.metafile = real_metafile;
535
536     real_metafile->playback_graphics = graphics;
537     real_metafile->playback_dc = NULL;
538
539     memcpy(real_metafile->playback_points, destPoints, sizeof(PointF) * 3);
540     stat = GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, real_metafile->playback_points, 3);
541
542     if (stat == Ok && metafile->metafile_type == MetafileTypeEmf)
543         stat = METAFILE_PlaybackGetDC((GpMetafile*)metafile);
544
545     if (stat == Ok)
546         EnumEnhMetaFile(0, metafile->hemf, enum_metafile_proc, &data, NULL);
547
548     METAFILE_PlaybackReleaseDC((GpMetafile*)metafile);
549
550     real_metafile->playback_graphics = NULL;
551
552     return stat;
553 }