gdiplus: Don't leak a device context when GdipCreateFromHWND fails.
[wine] / dlls / gdiplus / pen.c
1 /*
2  * Copyright (C) 2007 Google (Evan Stade)
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
21 #include "windef.h"
22 #include "winbase.h"
23 #include "wingdi.h"
24
25 #include "objbase.h"
26
27 #include "gdiplus.h"
28 #include "gdiplus_private.h"
29 #include "wine/debug.h"
30
31 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
32
33 static DWORD gdip_to_gdi_dash(GpDashStyle dash)
34 {
35     switch(dash){
36         case DashStyleSolid:
37             return PS_SOLID;
38         case DashStyleDash:
39             return PS_DASH;
40         case DashStyleDot:
41             return PS_DOT;
42         case DashStyleDashDot:
43             return PS_DASHDOT;
44         case DashStyleDashDotDot:
45             return PS_DASHDOTDOT;
46         case DashStyleCustom:
47             return PS_USERSTYLE;
48         default:
49             ERR("Not a member of GpDashStyle enumeration\n");
50             return 0;
51     }
52 }
53
54 static DWORD gdip_to_gdi_join(GpLineJoin join)
55 {
56     switch(join){
57         case LineJoinRound:
58             return PS_JOIN_ROUND;
59         case LineJoinBevel:
60             return PS_JOIN_BEVEL;
61         case LineJoinMiter:
62         case LineJoinMiterClipped:
63             return PS_JOIN_MITER;
64         default:
65             ERR("Not a member of GpLineJoin enumeration\n");
66             return 0;
67     }
68 }
69
70 static GpPenType bt_to_pt(GpBrushType bt)
71 {
72     switch(bt){
73         case BrushTypeSolidColor:
74             return PenTypeSolidColor;
75         case BrushTypeHatchFill:
76             return PenTypeHatchFill;
77         case BrushTypeTextureFill:
78             return PenTypeTextureFill;
79         case BrushTypePathGradient:
80             return PenTypePathGradient;
81         case BrushTypeLinearGradient:
82             return PenTypeLinearGradient;
83         default:
84             return PenTypeUnknown;
85     }
86 }
87
88 GpStatus WINGDIPAPI GdipClonePen(GpPen *pen, GpPen **clonepen)
89 {
90     TRACE("(%p, %p)\n", pen, clonepen);
91
92     if(!pen || !clonepen)
93         return InvalidParameter;
94
95     *clonepen = GdipAlloc(sizeof(GpPen));
96     if(!*clonepen)  return OutOfMemory;
97
98     **clonepen = *pen;
99
100     GdipCloneCustomLineCap(pen->customstart, &(*clonepen)->customstart);
101     GdipCloneCustomLineCap(pen->customend, &(*clonepen)->customend);
102     GdipCloneBrush(pen->brush, &(*clonepen)->brush);
103
104     return Ok;
105 }
106
107 GpStatus WINGDIPAPI GdipCreatePen1(ARGB color, REAL width, GpUnit unit,
108     GpPen **pen)
109 {
110     GpBrush *brush;
111     GpStatus status;
112
113     TRACE("(%x, %.2f, %d, %p)\n", color, width, unit, pen);
114
115     GdipCreateSolidFill(color, (GpSolidFill **)(&brush));
116     status = GdipCreatePen2(brush, width, unit, pen);
117     GdipDeleteBrush(brush);
118     return status;
119 }
120
121 GpStatus WINGDIPAPI GdipCreatePen2(GpBrush *brush, REAL width, GpUnit unit,
122     GpPen **pen)
123 {
124     GpPen *gp_pen;
125     GpBrush *clone_brush;
126
127     TRACE("(%p, %.2f, %d, %p)\n", brush, width, unit, pen);
128
129     if(!pen || !brush)
130         return InvalidParameter;
131
132     gp_pen = GdipAlloc(sizeof(GpPen));
133     if(!gp_pen)    return OutOfMemory;
134
135     gp_pen->style = GP_DEFAULT_PENSTYLE;
136     gp_pen->width = width;
137     gp_pen->unit = unit;
138     gp_pen->endcap = LineCapFlat;
139     gp_pen->join = LineJoinMiter;
140     gp_pen->miterlimit = 10.0;
141     gp_pen->dash = DashStyleSolid;
142     gp_pen->offset = 0.0;
143     gp_pen->customstart = NULL;
144     gp_pen->customend = NULL;
145
146     if(!((gp_pen->unit == UnitWorld) || (gp_pen->unit == UnitPixel))) {
147         FIXME("UnitWorld, UnitPixel only supported units\n");
148         GdipFree(gp_pen);
149         return NotImplemented;
150     }
151
152     GdipCloneBrush(brush, &clone_brush);
153     gp_pen->brush = clone_brush;
154
155     *pen = gp_pen;
156
157     return Ok;
158 }
159
160 GpStatus WINGDIPAPI GdipDeletePen(GpPen *pen)
161 {
162     TRACE("(%p)\n", pen);
163
164     if(!pen)    return InvalidParameter;
165
166     GdipDeleteBrush(pen->brush);
167     GdipDeleteCustomLineCap(pen->customstart);
168     GdipDeleteCustomLineCap(pen->customend);
169     GdipFree(pen->dashes);
170     GdipFree(pen);
171
172     return Ok;
173 }
174
175 GpStatus WINGDIPAPI GdipGetPenBrushFill(GpPen *pen, GpBrush **brush)
176 {
177     TRACE("(%p, %p)\n", pen, brush);
178
179     if(!pen || !brush)
180         return InvalidParameter;
181
182     return GdipCloneBrush(pen->brush, brush);
183 }
184
185 GpStatus WINGDIPAPI GdipGetPenColor(GpPen *pen, ARGB *argb)
186 {
187     TRACE("(%p, %p)\n", pen, argb);
188
189     if(!pen || !argb)
190         return InvalidParameter;
191
192     if(pen->brush->bt != BrushTypeSolidColor)
193         return NotImplemented;
194
195     return GdipGetSolidFillColor(((GpSolidFill*)pen->brush), argb);
196 }
197
198 GpStatus WINGDIPAPI GdipGetPenCustomEndCap(GpPen *pen, GpCustomLineCap** customCap)
199 {
200     TRACE("(%p, %p)\n", pen, customCap);
201
202     if(!pen || !customCap)
203         return InvalidParameter;
204
205     if(!pen->customend){
206         *customCap = NULL;
207         return Ok;
208     }
209
210     return GdipCloneCustomLineCap(pen->customend, customCap);
211 }
212
213 GpStatus WINGDIPAPI GdipGetPenCustomStartCap(GpPen *pen, GpCustomLineCap** customCap)
214 {
215     TRACE("(%p, %p)\n", pen, customCap);
216
217     if(!pen || !customCap)
218         return InvalidParameter;
219
220     if(!pen->customstart){
221         *customCap = NULL;
222         return Ok;
223     }
224
225     return GdipCloneCustomLineCap(pen->customstart, customCap);
226 }
227
228 GpStatus WINGDIPAPI GdipGetPenDashArray(GpPen *pen, REAL *dash, INT count)
229 {
230     TRACE("(%p, %p, %d)\n", pen, dash, count);
231
232     if(!pen || !dash || count > pen->numdashes)
233         return InvalidParameter;
234
235     /* note: if you pass a negative value for count, it crashes native gdiplus. */
236     if(count < 0)
237         return GenericError;
238
239     memcpy(dash, pen->dashes, count * sizeof(REAL));
240
241     return Ok;
242 }
243
244 GpStatus WINGDIPAPI GdipGetPenDashCap197819(GpPen *pen, GpDashCap *dashCap)
245 {
246     TRACE("(%p, %p)\n", pen, dashCap);
247
248     if(!pen || !dashCap)
249         return InvalidParameter;
250
251     *dashCap = pen->dashcap;
252
253     return Ok;
254 }
255
256 GpStatus WINGDIPAPI GdipGetPenDashCount(GpPen *pen, INT *count)
257 {
258     TRACE("(%p, %p)\n", pen, count);
259
260     if(!pen || !count)
261         return InvalidParameter;
262
263     *count = pen->numdashes;
264
265     return Ok;
266 }
267
268 GpStatus WINGDIPAPI GdipGetPenDashOffset(GpPen *pen, REAL *offset)
269 {
270     TRACE("(%p, %p)\n", pen, offset);
271
272     if(!pen || !offset)
273         return InvalidParameter;
274
275     *offset = pen->offset;
276
277     return Ok;
278 }
279
280 GpStatus WINGDIPAPI GdipGetPenDashStyle(GpPen *pen, GpDashStyle *dash)
281 {
282     TRACE("(%p, %p)\n", pen, dash);
283
284     if(!pen || !dash)
285         return InvalidParameter;
286
287     *dash = pen->dash;
288
289     return Ok;
290 }
291
292 GpStatus WINGDIPAPI GdipGetPenEndCap(GpPen *pen, GpLineCap *endCap)
293 {
294     TRACE("(%p, %p)\n", pen, endCap);
295
296     if(!pen || !endCap)
297         return InvalidParameter;
298
299     *endCap = pen->endcap;
300
301     return Ok;
302 }
303
304 GpStatus WINGDIPAPI GdipGetPenFillType(GpPen *pen, GpPenType* type)
305 {
306     TRACE("(%p, %p)\n", pen, type);
307
308     if(!pen || !type)
309         return InvalidParameter;
310
311     *type = bt_to_pt(pen->brush->bt);
312
313     return Ok;
314 }
315
316 GpStatus WINGDIPAPI GdipGetPenLineJoin(GpPen *pen, GpLineJoin *lineJoin)
317 {
318     TRACE("(%p, %p)\n", pen, lineJoin);
319
320     if(!pen || !lineJoin)
321         return InvalidParameter;
322
323     *lineJoin = pen->join;
324
325     return Ok;
326 }
327
328 GpStatus WINGDIPAPI GdipGetPenMode(GpPen *pen, GpPenAlignment *mode)
329 {
330     TRACE("(%p, %p)\n", pen, mode);
331
332     if(!pen || !mode)
333         return InvalidParameter;
334
335     *mode = pen->align;
336
337     return Ok;
338 }
339
340 GpStatus WINGDIPAPI GdipGetPenMiterLimit(GpPen *pen, REAL *miterLimit)
341 {
342     TRACE("(%p, %p)\n", pen, miterLimit);
343
344     if(!pen || !miterLimit)
345         return InvalidParameter;
346
347     *miterLimit = pen->miterlimit;
348
349     return Ok;
350 }
351
352 GpStatus WINGDIPAPI GdipGetPenStartCap(GpPen *pen, GpLineCap *startCap)
353 {
354     TRACE("(%p, %p)\n", pen, startCap);
355
356     if(!pen || !startCap)
357         return InvalidParameter;
358
359     *startCap = pen->startcap;
360
361     return Ok;
362 }
363
364 GpStatus WINGDIPAPI GdipGetPenUnit(GpPen *pen, GpUnit *unit)
365 {
366     TRACE("(%p, %p)\n", pen, unit);
367
368     if(!pen || !unit)
369         return InvalidParameter;
370
371     *unit = pen->unit;
372
373     return Ok;
374 }
375
376 GpStatus WINGDIPAPI GdipGetPenWidth(GpPen *pen, REAL *width)
377 {
378     TRACE("(%p, %p)\n", pen, width);
379
380     if(!pen || !width)
381         return InvalidParameter;
382
383     *width = pen->width;
384
385     return Ok;
386 }
387
388 GpStatus WINGDIPAPI GdipResetPenTransform(GpPen *pen)
389 {
390     static int calls;
391
392     if(!pen)
393         return InvalidParameter;
394
395     if(!(calls++))
396         FIXME("(%p) stub\n", pen);
397
398     return NotImplemented;
399 }
400
401 GpStatus WINGDIPAPI GdipScalePenTransform(GpPen *pen, REAL sx, REAL sy, GpMatrixOrder order)
402 {
403     static int calls;
404
405     if(!pen)
406         return InvalidParameter;
407
408     if(!(calls++))
409         FIXME("(%p, %.2f, %.2f, %d) stub\n", pen, sx, sy, order);
410
411     return NotImplemented;
412 }
413
414 GpStatus WINGDIPAPI GdipSetPenBrushFill(GpPen *pen, GpBrush *brush)
415 {
416     TRACE("(%p, %p)\n", pen, brush);
417
418     if(!pen || !brush)
419         return InvalidParameter;
420
421     GdipDeleteBrush(pen->brush);
422     return GdipCloneBrush(brush, &pen->brush);
423 }
424
425 GpStatus WINGDIPAPI GdipSetPenColor(GpPen *pen, ARGB argb)
426 {
427     TRACE("(%p, %x)\n", pen, argb);
428
429     if(!pen)
430         return InvalidParameter;
431
432     if(pen->brush->bt != BrushTypeSolidColor)
433         return NotImplemented;
434
435     return GdipSetSolidFillColor(((GpSolidFill*)pen->brush), argb);
436 }
437
438 GpStatus WINGDIPAPI GdipSetPenCompoundArray(GpPen *pen, GDIPCONST REAL *dash,
439     INT count)
440 {
441     FIXME("(%p, %p, %i): stub\n", pen, dash, count);
442
443     if (!pen || !dash || count < 2 || count%2 == 1)
444         return InvalidParameter;
445
446     return NotImplemented;
447 }
448
449 GpStatus WINGDIPAPI GdipSetPenCustomEndCap(GpPen *pen, GpCustomLineCap* customCap)
450 {
451     GpCustomLineCap * cap;
452     GpStatus ret;
453
454     TRACE("(%p, %p)\n", pen, customCap);
455
456     /* native crashes on pen == NULL, customCap != NULL */
457     if(!customCap) return InvalidParameter;
458
459     if((ret = GdipCloneCustomLineCap(customCap, &cap)) == Ok){
460         GdipDeleteCustomLineCap(pen->customend);
461         pen->endcap = LineCapCustom;
462         pen->customend = cap;
463     }
464
465     return ret;
466 }
467
468 GpStatus WINGDIPAPI GdipSetPenCustomStartCap(GpPen *pen, GpCustomLineCap* customCap)
469 {
470     GpCustomLineCap * cap;
471     GpStatus ret;
472
473     TRACE("(%p, %p)\n", pen, customCap);
474
475     /* native crashes on pen == NULL, customCap != NULL */
476     if(!customCap) return InvalidParameter;
477
478     if((ret = GdipCloneCustomLineCap(customCap, &cap)) == Ok){
479         GdipDeleteCustomLineCap(pen->customstart);
480         pen->startcap = LineCapCustom;
481         pen->customstart = cap;
482     }
483
484     return ret;
485 }
486
487 GpStatus WINGDIPAPI GdipSetPenDashArray(GpPen *pen, GDIPCONST REAL *dash,
488     INT count)
489 {
490     INT i;
491     REAL sum = 0;
492
493     TRACE("(%p, %p, %d)\n", pen, dash, count);
494
495     if(!pen || !dash)
496         return InvalidParameter;
497
498     if(count <= 0)
499         return OutOfMemory;
500
501     for(i = 0; i < count; i++){
502         sum += dash[i];
503         if(dash[i] < 0.0)
504             return InvalidParameter;
505     }
506
507     if(sum == 0.0 && count)
508         return InvalidParameter;
509
510     GdipFree(pen->dashes);
511     pen->dashes = NULL;
512
513     if(count > 0)
514         pen->dashes = GdipAlloc(count * sizeof(REAL));
515     if(!pen->dashes){
516         pen->numdashes = 0;
517         return OutOfMemory;
518     }
519
520     GdipSetPenDashStyle(pen, DashStyleCustom);
521     memcpy(pen->dashes, dash, count * sizeof(REAL));
522     pen->numdashes = count;
523
524     return Ok;
525 }
526
527 GpStatus WINGDIPAPI GdipSetPenDashCap197819(GpPen *pen, GpDashCap dashCap)
528 {
529     TRACE("(%p, %d)\n", pen, dashCap);
530
531     if(!pen)
532         return InvalidParameter;
533
534     pen->dashcap = dashCap;
535
536     return Ok;
537 }
538
539 /* FIXME: dash offset not used */
540 GpStatus WINGDIPAPI GdipSetPenDashOffset(GpPen *pen, REAL offset)
541 {
542     TRACE("(%p, %.2f)\n", pen, offset);
543
544     if(!pen)
545         return InvalidParameter;
546
547     pen->offset = offset;
548
549     return Ok;
550 }
551
552 GpStatus WINGDIPAPI GdipSetPenDashStyle(GpPen *pen, GpDashStyle dash)
553 {
554     TRACE("(%p, %d)\n", pen, dash);
555
556     if(!pen)
557         return InvalidParameter;
558
559     if(dash != DashStyleCustom){
560         GdipFree(pen->dashes);
561         pen->dashes = NULL;
562         pen->numdashes = 0;
563     }
564
565     pen->dash = dash;
566     pen->style &= ~(PS_ALTERNATE | PS_SOLID | PS_DASH | PS_DOT | PS_DASHDOT |
567                     PS_DASHDOTDOT | PS_NULL | PS_USERSTYLE | PS_INSIDEFRAME);
568     pen->style |= gdip_to_gdi_dash(dash);
569
570     return Ok;
571 }
572
573 GpStatus WINGDIPAPI GdipSetPenEndCap(GpPen *pen, GpLineCap cap)
574 {
575     TRACE("(%p, %d)\n", pen, cap);
576
577     if(!pen)    return InvalidParameter;
578
579     /* The old custom cap gets deleted even if the new style is LineCapCustom. */
580     GdipDeleteCustomLineCap(pen->customend);
581     pen->customend = NULL;
582     pen->endcap = cap;
583
584     return Ok;
585 }
586
587 /* FIXME: startcap, dashcap not used. */
588 GpStatus WINGDIPAPI GdipSetPenLineCap197819(GpPen *pen, GpLineCap start,
589     GpLineCap end, GpDashCap dash)
590 {
591     TRACE("%p, %d, %d, %d)\n", pen, start, end, dash);
592
593     if(!pen)
594         return InvalidParameter;
595
596     GdipDeleteCustomLineCap(pen->customend);
597     GdipDeleteCustomLineCap(pen->customstart);
598     pen->customend = NULL;
599     pen->customstart = NULL;
600
601     pen->startcap = start;
602     pen->endcap = end;
603     pen->dashcap = dash;
604
605     return Ok;
606 }
607
608 /* FIXME: Miter line joins behave a bit differently than they do in windows.
609  * Both kinds of miter joins clip if the angle is less than 11 degrees. */
610 GpStatus WINGDIPAPI GdipSetPenLineJoin(GpPen *pen, GpLineJoin join)
611 {
612     TRACE("(%p, %d)\n", pen, join);
613
614     if(!pen)    return InvalidParameter;
615
616     pen->join = join;
617     pen->style &= ~(PS_JOIN_ROUND | PS_JOIN_BEVEL | PS_JOIN_MITER);
618     pen->style |= gdip_to_gdi_join(join);
619
620     return Ok;
621 }
622
623 GpStatus WINGDIPAPI GdipSetPenMiterLimit(GpPen *pen, REAL limit)
624 {
625     TRACE("(%p, %.2f)\n", pen, limit);
626
627     if(!pen)
628         return InvalidParameter;
629
630     pen->miterlimit = limit;
631
632     return Ok;
633 }
634
635 GpStatus WINGDIPAPI GdipSetPenStartCap(GpPen *pen, GpLineCap cap)
636 {
637     TRACE("(%p, %d)\n", pen, cap);
638
639     if(!pen)    return InvalidParameter;
640
641     GdipDeleteCustomLineCap(pen->customstart);
642     pen->customstart = NULL;
643     pen->startcap = cap;
644
645     return Ok;
646 }
647
648 GpStatus WINGDIPAPI GdipSetPenWidth(GpPen *pen, REAL width)
649 {
650     TRACE("(%p, %.2f)\n", pen, width);
651
652     if(!pen)    return InvalidParameter;
653
654     pen->width = width;
655
656     return Ok;
657 }
658
659 GpStatus WINGDIPAPI GdipSetPenMode(GpPen *pen, GpPenAlignment mode)
660 {
661     TRACE("(%p, %d)\n", pen, mode);
662
663     if(!pen)    return InvalidParameter;
664
665     pen->align = mode;
666
667     return Ok;
668 }