source: trunk/contrib/gdiplus/include/GdiplusPen.h @ 980

Last change on this file since 980 was 980, checked in by sam, 11 years ago

contrib: add GDI+ headers and static library for Linux cross-compilation.

  • Property svn:keywords set to Id
File size: 12.9 KB
Line 
1/**************************************************************************\
2*
3* Copyright (c) 1998-2001, Microsoft Corp.  All Rights Reserved.
4*
5* Module Name:
6*
7*   GdiplusPen.h
8*
9* Abstract:
10*
11*   GDI+ Pen class
12*
13\**************************************************************************/
14#ifndef _GDIPLUSPEN_H
15#define _GDIPLUSPEN_H
16
17//--------------------------------------------------------------------------
18// Pen class
19//--------------------------------------------------------------------------
20
21class Pen : public GdiplusBase
22{
23public:
24    friend class GraphicsPath;
25    friend class Graphics;
26
27    Pen(IN const Color& color,
28        IN REAL width = 1.0f)
29    {
30        Unit unit = UnitWorld;
31        nativePen = NULL;
32        lastResult = DllExports::GdipCreatePen1(color.GetValue(),
33                                    width, unit, &nativePen);
34    }
35
36    Pen(IN const Brush* brush,
37        IN REAL width = 1.0f)
38    {
39        Unit unit = UnitWorld;
40        nativePen = NULL;
41        lastResult = DllExports::GdipCreatePen2(brush->nativeBrush,
42                                    width, unit, &nativePen);
43    }
44
45    ~Pen()
46    {
47        DllExports::GdipDeletePen(nativePen);
48    }
49
50    Pen* Clone() const
51    {
52        GpPen *clonePen = NULL;
53
54        lastResult = DllExports::GdipClonePen(nativePen, &clonePen);
55   
56        return new Pen(clonePen, lastResult);
57    }
58
59    Status SetWidth(IN REAL width)
60    {
61        return SetStatus(DllExports::GdipSetPenWidth(nativePen, width));
62    }
63
64    REAL GetWidth() const
65    {
66        REAL width;
67
68        SetStatus(DllExports::GdipGetPenWidth(nativePen, &width));
69       
70        return width;
71    }
72   
73    // Set/get line caps: start, end, and dash
74
75    // Line cap and join APIs by using LineCap and LineJoin enums.
76
77    Status SetLineCap(IN LineCap startCap,
78                      IN LineCap endCap,
79                      IN DashCap dashCap)
80    {
81        return SetStatus(DllExports::GdipSetPenLineCap197819(nativePen,
82                                   startCap, endCap, dashCap));
83    }
84
85    Status SetStartCap(IN LineCap startCap)
86    {
87        return SetStatus(DllExports::GdipSetPenStartCap(nativePen, startCap));
88    }
89
90    Status SetEndCap(IN LineCap endCap)
91    {
92        return SetStatus(DllExports::GdipSetPenEndCap(nativePen, endCap));
93    }
94
95    Status SetDashCap(IN DashCap dashCap)
96    {
97        return SetStatus(DllExports::GdipSetPenDashCap197819(nativePen,
98                                   dashCap));
99    }
100
101    LineCap GetStartCap() const
102    {
103        LineCap startCap;
104
105        SetStatus(DllExports::GdipGetPenStartCap(nativePen, &startCap));
106       
107        return startCap;
108    }
109
110    LineCap GetEndCap() const
111    {
112        LineCap endCap;
113
114        SetStatus(DllExports::GdipGetPenEndCap(nativePen, &endCap));
115
116        return endCap;
117    }
118
119    DashCap GetDashCap() const
120    {
121        DashCap dashCap;
122
123        SetStatus(DllExports::GdipGetPenDashCap197819(nativePen,
124                            &dashCap));
125
126        return dashCap;
127    }
128
129    Status SetLineJoin(IN LineJoin lineJoin)
130    {
131        return SetStatus(DllExports::GdipSetPenLineJoin(nativePen, lineJoin));
132    }
133
134    LineJoin GetLineJoin() const
135    {
136        LineJoin lineJoin;
137       
138        SetStatus(DllExports::GdipGetPenLineJoin(nativePen, &lineJoin));
139       
140        return lineJoin;
141    }
142
143    Status SetCustomStartCap(IN const CustomLineCap* customCap)
144    {
145        GpCustomLineCap* nativeCap = NULL;
146        if(customCap)
147            nativeCap = customCap->nativeCap;
148
149        return SetStatus(DllExports::GdipSetPenCustomStartCap(nativePen,
150                                                              nativeCap));
151    }
152
153    Status GetCustomStartCap(OUT CustomLineCap* customCap) const
154    {
155        if(!customCap)
156            return SetStatus(InvalidParameter);
157
158        return SetStatus(DllExports::GdipGetPenCustomStartCap(nativePen,
159                                                    &(customCap->nativeCap)));
160    }
161
162    Status SetCustomEndCap(IN const CustomLineCap* customCap)
163    {
164        GpCustomLineCap* nativeCap = NULL;
165        if(customCap)
166            nativeCap = customCap->nativeCap;
167
168        return SetStatus(DllExports::GdipSetPenCustomEndCap(nativePen,
169                                                            nativeCap));
170    }
171
172    Status GetCustomEndCap(OUT CustomLineCap* customCap) const
173    {
174        if(!customCap)
175            return SetStatus(InvalidParameter);
176
177        return SetStatus(DllExports::GdipGetPenCustomEndCap(nativePen,
178                                                    &(customCap->nativeCap)));
179    }
180
181    Status SetMiterLimit(IN REAL miterLimit)
182    {
183        return SetStatus(DllExports::GdipSetPenMiterLimit(nativePen,
184                                                    miterLimit));
185    }
186
187    REAL GetMiterLimit() const
188    {
189        REAL miterLimit;
190
191        SetStatus(DllExports::GdipGetPenMiterLimit(nativePen, &miterLimit));
192
193        return miterLimit;
194    }
195
196    Status SetAlignment(IN PenAlignment penAlignment)
197    {
198        return SetStatus(DllExports::GdipSetPenMode(nativePen, penAlignment));
199    }
200
201    PenAlignment GetAlignment() const
202    {
203        PenAlignment penAlignment;
204       
205        SetStatus(DllExports::GdipGetPenMode(nativePen, &penAlignment));
206       
207        return penAlignment;
208    }
209   
210    Status SetTransform(IN const Matrix* matrix)
211    {
212        return SetStatus(DllExports::GdipSetPenTransform(nativePen,
213                                                       matrix->nativeMatrix));
214    }
215
216    Status GetTransform(OUT Matrix* matrix) const
217    {
218        return SetStatus(DllExports::GdipGetPenTransform(nativePen,
219                                                         matrix->nativeMatrix));
220    }
221
222    Status ResetTransform()
223    {
224        return SetStatus(DllExports::GdipResetPenTransform(nativePen));
225    }
226
227    Status MultiplyTransform(IN const Matrix* matrix,
228                             IN MatrixOrder order = MatrixOrderPrepend)
229    {
230        return SetStatus(DllExports::GdipMultiplyPenTransform(nativePen,
231                                                         matrix->nativeMatrix,
232                                                         order));
233    }
234
235    Status TranslateTransform(IN REAL dx,
236                              IN REAL dy,
237                              IN MatrixOrder order = MatrixOrderPrepend)
238    {
239        return SetStatus(DllExports::GdipTranslatePenTransform(nativePen,
240                                                               dx,
241                                                               dy,
242                                                               order));
243    }
244
245    Status ScaleTransform(IN REAL sx,
246                          IN REAL sy,
247                          IN MatrixOrder order = MatrixOrderPrepend)
248    {
249        return SetStatus(DllExports::GdipScalePenTransform(nativePen,
250                                                           sx,
251                                                           sy,
252                                                           order));
253    }
254
255    Status RotateTransform(IN REAL angle,
256                           IN MatrixOrder order = MatrixOrderPrepend)
257    {
258        return SetStatus(DllExports::GdipRotatePenTransform(nativePen,
259                                                            angle,
260                                                            order));
261    }
262
263    PenType GetPenType() const
264    {
265       PenType type;
266       SetStatus(DllExports::GdipGetPenFillType(nativePen, &type));
267
268       return type;
269    }
270
271    Status SetColor(IN const Color& color)
272    {
273        return SetStatus(DllExports::GdipSetPenColor(nativePen,
274                                                     color.GetValue()));
275    }
276
277    Status SetBrush(IN const Brush* brush)
278    {
279        return SetStatus(DllExports::GdipSetPenBrushFill(nativePen,
280                                       brush->nativeBrush));
281    }
282
283    Status GetColor(OUT Color* color) const
284    {
285        if (color == NULL)
286        {
287            return SetStatus(InvalidParameter);
288        }
289       
290        PenType type = GetPenType();
291
292        if (type != PenTypeSolidColor)
293        {
294            return WrongState;
295        }
296       
297        ARGB argb;
298       
299        SetStatus(DllExports::GdipGetPenColor(nativePen,
300                                              &argb));
301        if (lastResult == Ok)
302        {
303            color->SetValue(argb);
304        }
305       
306        return lastResult;
307    }
308
309    Brush* GetBrush() const
310    {
311       PenType type = GetPenType();
312
313       Brush* brush = NULL;
314
315       switch(type)
316       {
317       case PenTypeSolidColor:
318           brush = new SolidBrush();
319           break;
320
321       case PenTypeHatchFill:
322           brush = new HatchBrush();
323           break;
324
325       case PenTypeTextureFill:
326           brush = new TextureBrush();
327           break;
328
329       case PenTypePathGradient:
330           brush = new Brush();
331           break;
332
333       case PenTypeLinearGradient:
334           brush = new LinearGradientBrush();
335           break;
336
337       default:
338           break;
339       }
340
341       if(brush)
342       {
343           GpBrush* nativeBrush;
344
345           SetStatus(DllExports::GdipGetPenBrushFill(nativePen,
346                                                     &nativeBrush));
347           brush->SetNativeBrush(nativeBrush);
348       }
349
350       return brush;
351    }
352
353    DashStyle GetDashStyle() const
354    {
355        DashStyle dashStyle;
356
357        SetStatus(DllExports::GdipGetPenDashStyle(nativePen, &dashStyle));
358
359        return dashStyle;
360    }
361
362    Status SetDashStyle(IN DashStyle dashStyle)
363    {
364        return SetStatus(DllExports::GdipSetPenDashStyle(nativePen,
365                                                         dashStyle));
366    }
367
368    REAL GetDashOffset() const
369    {
370        REAL dashOffset;
371
372        SetStatus(DllExports::GdipGetPenDashOffset(nativePen, &dashOffset));
373
374        return dashOffset;
375    }
376
377    Status SetDashOffset(IN REAL dashOffset)
378    {
379        return SetStatus(DllExports::GdipSetPenDashOffset(nativePen,
380                                                          dashOffset));
381    }
382   
383    Status SetDashPattern(IN const REAL* dashArray, IN INT count)
384    {
385        return SetStatus(DllExports::GdipSetPenDashArray(nativePen,
386                                                         dashArray,
387                                                         count));
388    }
389   
390    INT GetDashPatternCount() const
391    {
392        INT count = 0;
393       
394        SetStatus(DllExports::GdipGetPenDashCount(nativePen, &count));
395       
396        return count;
397    }
398
399    Status GetDashPattern(OUT REAL* dashArray,
400                          IN INT count) const
401    {
402        if (dashArray == NULL || count <= 0)
403            return SetStatus(InvalidParameter);
404       
405        return SetStatus(DllExports::GdipGetPenDashArray(nativePen,
406                                                         dashArray,
407                                                         count));
408    }
409
410    Status SetCompoundArray(IN const REAL* compoundArray,
411                            IN INT count)
412    {
413        return SetStatus(DllExports::GdipSetPenCompoundArray(nativePen,
414                                                             compoundArray,
415                                                             count));
416    }
417
418    INT GetCompoundArrayCount() const
419    {
420        INT count = 0;
421       
422        SetStatus(DllExports::GdipGetPenCompoundCount(nativePen, &count));
423       
424        return count;
425    }
426
427    Status GetCompoundArray(OUT REAL* compoundArray,
428                            IN INT count) const
429    {
430        if (compoundArray == NULL || count <= 0)
431            return SetStatus(InvalidParameter);
432       
433        return SetStatus(DllExports::GdipGetPenCompoundArray(nativePen,
434                                                             compoundArray,
435                                                             count));
436    }
437
438    Status GetLastStatus() const
439    {
440        Status lastStatus = lastResult;
441        lastResult = Ok;
442
443        return lastStatus;
444    }
445
446private:
447    Pen(const Pen &);
448    Pen& operator=(const Pen &);
449
450protected:
451    Pen(GpPen* nativePen, Status status)
452    {
453        lastResult = status;
454        SetNativePen(nativePen);
455    }
456
457    VOID SetNativePen(GpPen* nativePen)
458    {
459        this->nativePen = nativePen;
460    }
461   
462    Status SetStatus(Status status) const
463    {
464        if (status != Ok)
465            return (lastResult = status);
466        else
467            return status;
468    }
469
470protected:
471    GpPen* nativePen;
472    mutable Status lastResult;
473};
474
475#endif
Note: See TracBrowser for help on using the repository browser.