source: libpipi/trunk/win32/gdiplus/include/GdiplusFlat.h @ 3072

Last change on this file since 3072 was 3072, checked in by Sam Hocevar, 12 years ago

Import the GDI+ runtime to ease Win32 cross-compilation.

File size: 85.4 KB
Line 
1/**************************************************************************\
2*
3* Copyright (c) 1998-2000, Microsoft Corp.  All Rights Reserved.
4*
5* Module Name:
6*
7*   GdiplusFlat.h
8*
9* Abstract:
10*
11*   Flat GDI+ API wrappers - header file
12*
13\**************************************************************************/
14
15// TODO: this file style needs to be made internally consistent with the way
16//       it handles breaking the long argument lists across multiple lines
17
18#ifndef _FLATAPI_H
19#define _FLATAPI_H
20
21#define WINGDIPAPI __stdcall
22
23// currently, only C++ wrapper API's force const.
24
25#define GDIPCONST const
26
27#ifdef __cplusplus
28extern "C" {
29#endif
30
31#ifndef DCR_USE_NEW_175866
32
33VOID
34WINGDIPAPI
35GdipDisplayPaletteWindowNotify(WindowNotifyEnum notify);
36
37#endif
38
39//----------------------------------------------------------------------------
40// GraphicsPath methods
41//----------------------------------------------------------------------------
42
43GpStatus WINGDIPAPI
44GdipCreatePath(GpFillMode brushMode, GpPath **path);
45
46GpStatus WINGDIPAPI
47GdipCreatePath2(GDIPCONST GpPointF*, GDIPCONST BYTE*, INT, GpFillMode,
48                                    GpPath **path);
49
50GpStatus WINGDIPAPI
51GdipCreatePath2I(GDIPCONST GpPoint*, GDIPCONST BYTE*, INT, GpFillMode,
52                                     GpPath **path);
53
54GpStatus WINGDIPAPI
55GdipClonePath(GpPath* path, GpPath **clonePath);
56
57GpStatus WINGDIPAPI
58GdipDeletePath(GpPath* path);
59
60GpStatus WINGDIPAPI
61GdipResetPath(GpPath* path);
62
63GpStatus WINGDIPAPI
64GdipGetPointCount(GpPath* path, INT* count);
65
66GpStatus WINGDIPAPI
67GdipGetPathTypes(GpPath* path, BYTE* types, INT count);
68
69GpStatus WINGDIPAPI
70GdipGetPathPoints(GpPath*, GpPointF* points, INT count);
71
72GpStatus WINGDIPAPI
73GdipGetPathPointsI(GpPath*, GpPoint* points, INT count);
74
75GpStatus WINGDIPAPI
76GdipGetPathFillMode(GpPath *path, GpFillMode *fillmode);
77
78GpStatus WINGDIPAPI
79GdipSetPathFillMode(GpPath *path, GpFillMode fillmode);
80
81GpStatus WINGDIPAPI
82GdipGetPathData(GpPath *path, GpPathData* pathData);
83
84GpStatus WINGDIPAPI
85GdipStartPathFigure(GpPath *path);
86
87GpStatus WINGDIPAPI
88GdipClosePathFigure(GpPath *path);
89
90GpStatus WINGDIPAPI
91GdipClosePathFigures(GpPath *path);
92
93GpStatus WINGDIPAPI
94GdipSetPathMarker(GpPath* path);
95
96GpStatus WINGDIPAPI
97GdipClearPathMarkers(GpPath* path);
98
99GpStatus WINGDIPAPI
100GdipReversePath(GpPath* path);
101
102GpStatus WINGDIPAPI
103GdipGetPathLastPoint(GpPath* path, GpPointF* lastPoint);
104
105GpStatus WINGDIPAPI
106GdipAddPathLine(GpPath *path, REAL x1, REAL y1, REAL x2, REAL y2);
107
108GpStatus WINGDIPAPI
109GdipAddPathLine2(GpPath *path, GDIPCONST GpPointF *points, INT count);
110
111GpStatus WINGDIPAPI
112GdipAddPathArc(GpPath *path, REAL x, REAL y, REAL width, REAL height,
113                        REAL startAngle, REAL sweepAngle);
114
115GpStatus WINGDIPAPI
116GdipAddPathBezier(GpPath *path, REAL x1, REAL y1, REAL x2, REAL y2,
117                           REAL x3, REAL y3, REAL x4, REAL y4);
118
119GpStatus WINGDIPAPI
120GdipAddPathBeziers(GpPath *path, GDIPCONST GpPointF *points, INT count);
121
122GpStatus WINGDIPAPI
123GdipAddPathCurve(GpPath *path, GDIPCONST GpPointF *points, INT count);
124
125GpStatus WINGDIPAPI
126GdipAddPathCurve2(GpPath *path, GDIPCONST GpPointF *points, INT count,
127                           REAL tension);
128
129GpStatus WINGDIPAPI
130GdipAddPathCurve3(GpPath *path, GDIPCONST GpPointF *points, INT count,
131                           INT offset, INT numberOfSegments, REAL tension);
132
133GpStatus WINGDIPAPI
134GdipAddPathClosedCurve(GpPath *path, GDIPCONST GpPointF *points, INT count);
135
136GpStatus WINGDIPAPI
137GdipAddPathClosedCurve2(GpPath *path, GDIPCONST GpPointF *points, INT count,
138                                 REAL tension);
139
140GpStatus WINGDIPAPI
141GdipAddPathRectangle(GpPath *path, REAL x, REAL y, REAL width, REAL height);
142
143GpStatus WINGDIPAPI
144GdipAddPathRectangles(GpPath *path, GDIPCONST GpRectF *rects, INT count);
145
146GpStatus WINGDIPAPI
147GdipAddPathEllipse(GpPath *path, REAL x, REAL y, REAL width,
148                            REAL height);
149
150GpStatus WINGDIPAPI
151GdipAddPathPie(GpPath *path, REAL x, REAL y, REAL width, REAL height,
152                        REAL startAngle, REAL sweepAngle);
153
154GpStatus WINGDIPAPI
155GdipAddPathPolygon(GpPath *path, GDIPCONST GpPointF *points, INT count);
156
157GpStatus WINGDIPAPI
158GdipAddPathPath(GpPath *path, GDIPCONST GpPath* addingPath, BOOL connect);
159
160GpStatus WINGDIPAPI
161GdipAddPathString(GpPath *path, GDIPCONST WCHAR *string,
162                        INT length, GDIPCONST GpFontFamily *family, INT style,
163                        REAL emSize, GDIPCONST RectF *layoutRect,
164                        GDIPCONST GpStringFormat *format);
165
166GpStatus WINGDIPAPI
167GdipAddPathStringI(GpPath *path, GDIPCONST WCHAR *string,
168                        INT length, GDIPCONST GpFontFamily *family, INT style,
169                        REAL emSize, GDIPCONST Rect *layoutRect,
170                        GDIPCONST GpStringFormat *format);
171
172GpStatus WINGDIPAPI
173GdipAddPathLineI(GpPath *path, INT x1, INT y1, INT x2, INT y2);
174
175GpStatus WINGDIPAPI
176GdipAddPathLine2I(GpPath *path, GDIPCONST GpPoint *points, INT count);
177
178GpStatus WINGDIPAPI
179GdipAddPathArcI(GpPath *path, INT x, INT y, INT width, INT height,
180                        REAL startAngle, REAL sweepAngle);
181
182GpStatus WINGDIPAPI
183GdipAddPathBezierI(GpPath *path, INT x1, INT y1, INT x2, INT y2,
184                           INT x3, INT y3, INT x4, INT y4);
185
186GpStatus WINGDIPAPI
187GdipAddPathBeziersI(GpPath *path, GDIPCONST GpPoint *points, INT count);
188
189GpStatus WINGDIPAPI
190GdipAddPathCurveI(GpPath *path, GDIPCONST GpPoint *points, INT count);
191
192GpStatus WINGDIPAPI
193GdipAddPathCurve2I(GpPath *path, GDIPCONST GpPoint *points, INT count,
194                           REAL tension);
195
196GpStatus WINGDIPAPI
197GdipAddPathCurve3I(GpPath *path, GDIPCONST GpPoint *points, INT count,
198                           INT offset, INT numberOfSegments, REAL tension);
199
200GpStatus WINGDIPAPI
201GdipAddPathClosedCurveI(GpPath *path, GDIPCONST GpPoint *points, INT count);
202
203GpStatus WINGDIPAPI
204GdipAddPathClosedCurve2I(GpPath *path, GDIPCONST GpPoint *points, INT count,
205                                 REAL tension);
206
207GpStatus WINGDIPAPI
208GdipAddPathRectangleI(GpPath *path, INT x, INT y, INT width, INT height);
209
210GpStatus WINGDIPAPI
211GdipAddPathRectanglesI(GpPath *path, GDIPCONST GpRect *rects, INT count);
212
213GpStatus WINGDIPAPI
214GdipAddPathEllipseI(GpPath *path, INT x, INT y, INT width, INT height);
215
216GpStatus WINGDIPAPI
217GdipAddPathPieI(GpPath *path, INT x, INT y, INT width, INT height,
218                        REAL startAngle, REAL sweepAngle);
219
220GpStatus WINGDIPAPI
221GdipAddPathPolygonI(GpPath *path, GDIPCONST GpPoint *points, INT count);
222
223GpStatus WINGDIPAPI
224GdipFlattenPath(GpPath *path, GpMatrix* matrix, REAL flatness);
225
226GpStatus WINGDIPAPI
227GdipWindingModeOutline(
228    GpPath *path,
229    GpMatrix *matrix,
230    REAL flatness
231);
232
233
234#ifdef DCR_USE_NEW_202903
235
236GpStatus WINGDIPAPI
237GdipWidenPath(
238    GpPath *nativePath,
239    GpPen *pen,
240    GpMatrix *matrix,
241    REAL flatness
242);
243
244#else
245
246GpStatus WINGDIPAPI
247GdipWidenPathWithMinimumResolutions(GpPath *path, GpPen *pen, REAL minXres,
248            REAL minYres, GpMatrix *matrix, BOOL removeSelftIntersects);
249
250#endif
251
252GpStatus WINGDIPAPI
253GdipWarpPath(GpPath *path, GpMatrix* matrix,
254            GDIPCONST GpPointF *points, INT count,
255            REAL srcx, REAL srcy, REAL srcwidth, REAL srcheight,
256            WarpMode warpMode, REAL flatness);
257
258GpStatus WINGDIPAPI
259GdipTransformPath(GpPath* path, GpMatrix* matrix);
260
261GpStatus WINGDIPAPI
262GdipGetPathWorldBounds(GpPath* path, GpRectF* bounds, GDIPCONST GpMatrix *matrix,
263                  GDIPCONST GpPen *pen);
264
265GpStatus WINGDIPAPI
266GdipGetPathWorldBoundsI(GpPath* path, GpRect* bounds, GDIPCONST GpMatrix *matrix,
267                   GDIPCONST GpPen *pen);
268
269GpStatus WINGDIPAPI
270GdipIsVisiblePathPoint(GpPath* path, REAL x, REAL y,
271                       GpGraphics *graphics, BOOL *result);
272
273GpStatus WINGDIPAPI
274GdipIsVisiblePathPointI(GpPath* path, INT x, INT y,
275                        GpGraphics *graphics, BOOL *result);
276
277GpStatus WINGDIPAPI
278GdipIsOutlineVisiblePathPoint(GpPath* path, REAL x, REAL y, GpPen *pen,
279                              GpGraphics *graphics, BOOL *result);
280
281GpStatus WINGDIPAPI
282GdipIsOutlineVisiblePathPointI(GpPath* path, INT x, INT y, GpPen *pen,
283                               GpGraphics *graphics, BOOL *result);
284
285
286//----------------------------------------------------------------------------
287// Path Enumeration methods
288//----------------------------------------------------------------------------
289
290GpStatus WINGDIPAPI
291GdipCreatePathIter(GpPathIterator **iterator, GpPath* path);
292
293GpStatus WINGDIPAPI
294GdipDeletePathIter(GpPathIterator *iterator);
295
296GpStatus WINGDIPAPI
297GdipPathIterNextSubpath(GpPathIterator* iterator, INT *resultCount,
298        INT* startIndex, INT* endIndex, BOOL* isClosed);
299
300GpStatus WINGDIPAPI
301GdipPathIterNextSubpathPath(GpPathIterator* iterator, INT* resultCount,
302        GpPath* path, BOOL* isClosed);
303
304GpStatus WINGDIPAPI
305GdipPathIterNextPathType(GpPathIterator* iterator, INT* resultCount,
306        BYTE* pathType, INT* startIndex, INT* endIndex);
307
308GpStatus WINGDIPAPI
309GdipPathIterNextMarker(GpPathIterator* iterator, INT *resultCount,
310        INT* startIndex, INT* endIndex);
311
312GpStatus WINGDIPAPI
313GdipPathIterNextMarkerPath(GpPathIterator* iterator, INT* resultCount,
314        GpPath* path);
315
316GpStatus WINGDIPAPI
317GdipPathIterGetCount(GpPathIterator* iterator, INT* count);
318
319GpStatus WINGDIPAPI
320GdipPathIterGetSubpathCount(GpPathIterator* iterator, INT* count);
321
322GpStatus WINGDIPAPI
323GdipPathIterIsValid(GpPathIterator* iterator, BOOL* valid);
324
325GpStatus WINGDIPAPI
326GdipPathIterHasCurve(GpPathIterator* iterator, BOOL* hasCurve);
327
328GpStatus WINGDIPAPI
329GdipPathIterRewind(GpPathIterator* iterator);
330
331GpStatus WINGDIPAPI
332GdipPathIterEnumerate(GpPathIterator* iterator, INT* resultCount,
333    GpPointF *points, BYTE *types, INT count);
334
335GpStatus WINGDIPAPI
336GdipPathIterCopyData(GpPathIterator* iterator, INT* resultCount,
337    GpPointF* points, BYTE* types, INT startIndex, INT endIndex);
338
339//----------------------------------------------------------------------------
340// Matrix methods
341//----------------------------------------------------------------------------
342
343GpStatus WINGDIPAPI
344GdipCreateMatrix(GpMatrix **matrix);
345
346GpStatus WINGDIPAPI
347GdipCreateMatrix2(REAL m11, REAL m12, REAL m21, REAL m22, REAL dx,
348                                      REAL dy, GpMatrix **matrix);
349
350GpStatus WINGDIPAPI
351GdipCreateMatrix3(GDIPCONST GpRectF *rect, GDIPCONST GpPointF *dstplg,
352                                      GpMatrix **matrix);
353
354GpStatus WINGDIPAPI
355GdipCreateMatrix3I(GDIPCONST GpRect *rect, GDIPCONST GpPoint *dstplg,
356                                       GpMatrix **matrix);
357
358GpStatus WINGDIPAPI
359GdipCloneMatrix(GpMatrix *matrix, GpMatrix **cloneMatrix);
360
361GpStatus WINGDIPAPI
362GdipDeleteMatrix(GpMatrix *matrix);
363
364GpStatus WINGDIPAPI
365GdipSetMatrixElements(GpMatrix *matrix, REAL m11, REAL m12, REAL m21, REAL m22,
366                      REAL dx, REAL dy);
367
368GpStatus WINGDIPAPI
369GdipMultiplyMatrix(GpMatrix *matrix, GpMatrix* matrix2,
370                            GpMatrixOrder order);
371
372GpStatus WINGDIPAPI
373GdipTranslateMatrix(GpMatrix *matrix, REAL offsetX, REAL offsetY,
374                    GpMatrixOrder order);
375
376GpStatus WINGDIPAPI
377GdipScaleMatrix(GpMatrix *matrix, REAL scaleX, REAL scaleY,
378                GpMatrixOrder order);
379
380GpStatus WINGDIPAPI
381GdipRotateMatrix(GpMatrix *matrix, REAL angle, GpMatrixOrder order);
382
383GpStatus WINGDIPAPI
384GdipShearMatrix(GpMatrix *matrix, REAL shearX, REAL shearY,
385                GpMatrixOrder order);
386
387GpStatus WINGDIPAPI
388GdipInvertMatrix(GpMatrix *matrix);
389
390GpStatus WINGDIPAPI
391GdipTransformMatrixPoints(GpMatrix *matrix, GpPointF *pts, INT count);
392
393GpStatus WINGDIPAPI
394GdipTransformMatrixPointsI(GpMatrix *matrix, GpPoint *pts, INT count);
395
396GpStatus WINGDIPAPI
397GdipVectorTransformMatrixPoints(GpMatrix *matrix, GpPointF *pts,
398                                         INT count);
399
400GpStatus WINGDIPAPI
401GdipVectorTransformMatrixPointsI(GpMatrix *matrix, GpPoint *pts,
402                                         INT count);
403
404GpStatus WINGDIPAPI
405GdipGetMatrixElements(GDIPCONST GpMatrix *matrix, REAL *matrixOut);
406
407GpStatus WINGDIPAPI
408GdipIsMatrixInvertible(GDIPCONST GpMatrix *matrix, BOOL *result);
409
410GpStatus WINGDIPAPI
411GdipIsMatrixIdentity(GDIPCONST GpMatrix *matrix, BOOL *result);
412
413GpStatus WINGDIPAPI
414GdipIsMatrixEqual(GDIPCONST GpMatrix *matrix, GDIPCONST GpMatrix *matrix2, BOOL *result);
415
416//----------------------------------------------------------------------------
417// Region methods
418//----------------------------------------------------------------------------
419
420GpStatus WINGDIPAPI
421GdipCreateRegion(GpRegion **region);
422
423GpStatus WINGDIPAPI
424GdipCreateRegionRect(GDIPCONST GpRectF *rect, GpRegion **region);
425
426GpStatus WINGDIPAPI
427GdipCreateRegionRectI(GDIPCONST GpRect *rect, GpRegion **region);
428
429GpStatus WINGDIPAPI
430GdipCreateRegionPath(GpPath *path, GpRegion **region);
431
432GpStatus WINGDIPAPI
433GdipCreateRegionRgnData(GDIPCONST BYTE *regionData, INT size, GpRegion **region);
434
435GpStatus WINGDIPAPI
436GdipCreateRegionHrgn(HRGN hRgn, GpRegion **region);
437
438GpStatus WINGDIPAPI
439GdipCloneRegion(GpRegion *region, GpRegion **cloneRegion);
440
441GpStatus WINGDIPAPI
442GdipDeleteRegion(GpRegion *region);
443
444GpStatus WINGDIPAPI
445GdipSetInfinite(GpRegion *region);
446
447GpStatus WINGDIPAPI
448GdipSetEmpty(GpRegion *region);
449
450GpStatus WINGDIPAPI
451GdipCombineRegionRect(GpRegion *region, GDIPCONST GpRectF *rect,
452                      CombineMode combineMode);
453
454GpStatus WINGDIPAPI
455GdipCombineRegionRectI(GpRegion *region, GDIPCONST GpRect *rect,
456                       CombineMode combineMode);
457
458GpStatus WINGDIPAPI
459GdipCombineRegionPath(GpRegion *region, GpPath *path, CombineMode combineMode);
460
461GpStatus WINGDIPAPI
462GdipCombineRegionRegion(GpRegion *region,  GpRegion *region2,
463                        CombineMode combineMode);
464
465GpStatus WINGDIPAPI
466GdipTranslateRegion(GpRegion *region, REAL dx, REAL dy);
467
468GpStatus WINGDIPAPI
469GdipTranslateRegionI(GpRegion *region, INT dx, INT dy);
470
471GpStatus WINGDIPAPI
472GdipTransformRegion(GpRegion *region, GpMatrix *matrix);
473
474GpStatus WINGDIPAPI
475GdipGetRegionBounds(GpRegion *region, GpGraphics *graphics,
476                             GpRectF *rect);
477
478GpStatus WINGDIPAPI
479GdipGetRegionBoundsI(GpRegion *region, GpGraphics *graphics,
480                             GpRect *rect);
481
482GpStatus WINGDIPAPI
483GdipGetRegionHRgn(GpRegion *region, GpGraphics *graphics, HRGN *hRgn);
484
485GpStatus WINGDIPAPI
486GdipIsEmptyRegion(GpRegion *region, GpGraphics *graphics,
487                           BOOL *result);
488
489GpStatus WINGDIPAPI
490GdipIsInfiniteRegion(GpRegion *region, GpGraphics *graphics,
491                              BOOL *result);
492
493GpStatus WINGDIPAPI
494GdipIsEqualRegion(GpRegion *region, GpRegion *region2,
495                           GpGraphics *graphics, BOOL *result);
496
497GpStatus WINGDIPAPI
498GdipGetRegionDataSize(GpRegion *region, UINT * bufferSize);
499
500GpStatus WINGDIPAPI
501GdipGetRegionData(GpRegion *region, BYTE * buffer, UINT bufferSize, UINT * sizeFilled);
502
503GpStatus WINGDIPAPI
504GdipIsVisibleRegionPoint(GpRegion *region, REAL x, REAL y,
505                                  GpGraphics *graphics, BOOL *result);
506
507GpStatus WINGDIPAPI
508GdipIsVisibleRegionPointI(GpRegion *region, INT x, INT y,
509                                  GpGraphics *graphics, BOOL *result);
510
511GpStatus WINGDIPAPI
512GdipIsVisibleRegionRect(GpRegion *region, REAL x, REAL y, REAL width,
513                        REAL height, GpGraphics *graphics, BOOL *result);
514
515GpStatus WINGDIPAPI
516GdipIsVisibleRegionRectI(GpRegion *region, INT x, INT y, INT width,
517                         INT height, GpGraphics *graphics, BOOL *result);
518
519GpStatus WINGDIPAPI
520GdipGetRegionScansCount(GpRegion *region, UINT* count, GpMatrix* matrix);
521
522GpStatus WINGDIPAPI
523GdipGetRegionScans(GpRegion *region, GpRectF* rects, INT* count, GpMatrix* matrix);
524
525GpStatus WINGDIPAPI
526GdipGetRegionScansI(GpRegion *region, GpRect* rects, INT* count, GpMatrix* matrix);
527
528//----------------------------------------------------------------------------
529// Brush methods
530//----------------------------------------------------------------------------
531
532GpStatus WINGDIPAPI
533GdipCloneBrush(GpBrush *brush, GpBrush **cloneBrush);
534
535GpStatus WINGDIPAPI
536GdipDeleteBrush(GpBrush *brush);
537
538GpStatus WINGDIPAPI
539GdipGetBrushType(GpBrush *brush, GpBrushType *type);
540
541//----------------------------------------------------------------------------
542// Hatch Brush methods
543//----------------------------------------------------------------------------
544
545GpStatus WINGDIPAPI
546GdipCreateHatchBrush(GpHatchStyle hatchstyle, ARGB forecol,
547                              ARGB backcol, GpHatch **brush);
548
549GpStatus WINGDIPAPI
550GdipGetHatchStyle(GpHatch *brush, GpHatchStyle *hatchstyle);
551
552GpStatus WINGDIPAPI
553GdipGetHatchForegroundColor(GpHatch *brush, ARGB* forecol);
554
555GpStatus WINGDIPAPI
556GdipGetHatchBackgroundColor(GpHatch *brush, ARGB* backcol);
557
558//----------------------------------------------------------------------------
559// Texture Brush methods
560//----------------------------------------------------------------------------
561
562GpStatus WINGDIPAPI
563GdipCreateTexture(GpImage *image, GpWrapMode wrapmode,
564                           GpTexture **texture);
565
566GpStatus WINGDIPAPI
567GdipCreateTexture2(GpImage *image, GpWrapMode wrapmode, REAL x,
568                   REAL y, REAL width, REAL height, GpTexture **texture);
569
570GpStatus WINGDIPAPI
571GdipCreateTextureIA(GpImage *image, GDIPCONST GpImageAttributes *imageAttributes,
572                    REAL x, REAL y, REAL width, REAL height,
573                    GpTexture **texture);
574
575GpStatus WINGDIPAPI
576GdipCreateTexture2I(GpImage *image, GpWrapMode wrapmode, INT x,
577                    INT y, INT width, INT height, GpTexture **texture);
578
579GpStatus WINGDIPAPI
580GdipCreateTextureIAI(GpImage *image, GDIPCONST GpImageAttributes *imageAttributes,
581                     INT x, INT y, INT width, INT height,
582                     GpTexture **texture);
583
584
585GpStatus WINGDIPAPI
586GdipGetTextureTransform(GpTexture *brush, GpMatrix *matrix);
587
588GpStatus WINGDIPAPI
589GdipSetTextureTransform(GpTexture *brush, GDIPCONST GpMatrix *matrix);
590
591GpStatus WINGDIPAPI
592GdipResetTextureTransform(GpTexture* brush);
593
594GpStatus WINGDIPAPI
595GdipMultiplyTextureTransform(GpTexture* brush, GDIPCONST GpMatrix *matrix,
596                            GpMatrixOrder order);
597
598GpStatus WINGDIPAPI
599GdipTranslateTextureTransform(GpTexture* brush, REAL dx, REAL dy,
600                            GpMatrixOrder order);
601
602GpStatus WINGDIPAPI
603GdipScaleTextureTransform(GpTexture* brush, REAL sx, REAL sy,
604                            GpMatrixOrder order);
605
606GpStatus WINGDIPAPI
607GdipRotateTextureTransform(GpTexture* brush, REAL angle, GpMatrixOrder order);
608
609GpStatus WINGDIPAPI
610GdipSetTextureWrapMode(GpTexture *brush, GpWrapMode wrapmode);
611
612GpStatus WINGDIPAPI
613GdipGetTextureWrapMode(GpTexture *brush, GpWrapMode *wrapmode);
614
615GpStatus WINGDIPAPI
616GdipGetTextureImage(GpTexture *brush, GpImage **image);
617
618//----------------------------------------------------------------------------
619// Solid Brush methods
620//----------------------------------------------------------------------------
621
622GpStatus WINGDIPAPI
623GdipCreateSolidFill(ARGB color, GpSolidFill **brush);
624
625GpStatus WINGDIPAPI
626GdipSetSolidFillColor(GpSolidFill *brush, ARGB color);
627
628GpStatus WINGDIPAPI
629GdipGetSolidFillColor(GpSolidFill *brush, ARGB *color);
630
631//----------------------------------------------------------------------------
632// LineBrush methods
633//----------------------------------------------------------------------------
634
635GpStatus WINGDIPAPI
636GdipCreateLineBrush(GDIPCONST GpPointF* point1,
637                    GDIPCONST GpPointF* point2,
638                    ARGB color1, ARGB color2,
639                    GpWrapMode wrapMode,
640                    GpLineGradient **lineGradient);
641
642GpStatus WINGDIPAPI
643GdipCreateLineBrushI(GDIPCONST GpPoint* point1,
644                     GDIPCONST GpPoint* point2,
645                     ARGB color1, ARGB color2,
646                     GpWrapMode wrapMode,
647                     GpLineGradient **lineGradient);
648
649GpStatus WINGDIPAPI
650GdipCreateLineBrushFromRect(GDIPCONST GpRectF* rect,
651                            ARGB color1, ARGB color2,
652                            LinearGradientMode mode,
653                            GpWrapMode wrapMode,
654                            GpLineGradient **lineGradient);
655
656GpStatus WINGDIPAPI
657GdipCreateLineBrushFromRectI(GDIPCONST GpRect* rect,
658                             ARGB color1, ARGB color2,
659                             LinearGradientMode mode,
660                             GpWrapMode wrapMode,
661                             GpLineGradient **lineGradient);
662
663GpStatus WINGDIPAPI
664GdipCreateLineBrushFromRectWithAngle(GDIPCONST GpRectF* rect,
665                                     ARGB color1, ARGB color2,
666                                     REAL angle,
667                                     BOOL isAngleScalable,
668                                     GpWrapMode wrapMode,
669                                     GpLineGradient **lineGradient);
670
671GpStatus WINGDIPAPI
672GdipCreateLineBrushFromRectWithAngleI(GDIPCONST GpRect* rect,
673                                     ARGB color1, ARGB color2,
674                                     REAL angle,
675                                     BOOL isAngleScalable,
676                                     GpWrapMode wrapMode,
677                                     GpLineGradient **lineGradient);
678
679GpStatus WINGDIPAPI
680GdipSetLinePoints(GpLineGradient *brush,
681                  GDIPCONST GpPointF* point1,
682                  GDIPCONST GpPointF* point2);
683
684GpStatus WINGDIPAPI
685GdipSetLinePointsI(GpLineGradient *brush,
686                   GDIPCONST GpPoint* point1,
687                   GDIPCONST GpPoint* point2);
688
689GpStatus WINGDIPAPI
690GdipGetLinePoints(GpLineGradient *brush, GpPointF* points);
691
692GpStatus WINGDIPAPI
693GdipGetLinePointsI(GpLineGradient *brush, GpPoint* points);
694
695GpStatus WINGDIPAPI
696GdipSetLineColors(GpLineGradient *brush, ARGB color1, ARGB color2);
697
698GpStatus WINGDIPAPI
699GdipGetLineColors(GpLineGradient *brush, ARGB* colors);
700
701GpStatus WINGDIPAPI
702GdipGetLineRect(GpLineGradient *brush, GpRectF *rect);
703
704GpStatus WINGDIPAPI
705GdipGetLineRectI(GpLineGradient *brush, GpRect *rect);
706
707GpStatus WINGDIPAPI
708GdipSetLineGammaCorrection(GpLineGradient *brush, BOOL useGammaCorrection);
709
710GpStatus WINGDIPAPI
711GdipGetLineGammaCorrection(GpLineGradient *brush, BOOL *useGammaCorrection);
712
713GpStatus WINGDIPAPI
714GdipGetLineBlendCount(GpLineGradient *brush, INT *count);
715
716GpStatus WINGDIPAPI
717GdipGetLineBlend(GpLineGradient *brush, REAL *blend, REAL* positions,
718                 INT count);
719
720GpStatus WINGDIPAPI
721GdipSetLineBlend(GpLineGradient *brush, GDIPCONST REAL *blend,
722                 GDIPCONST REAL* positions, INT count);
723
724GpStatus WINGDIPAPI
725GdipGetLinePresetBlendCount(GpLineGradient *brush, INT *count);
726
727GpStatus WINGDIPAPI
728GdipGetLinePresetBlend(GpLineGradient *brush, ARGB *blend,
729                                           REAL* positions, INT count);
730
731GpStatus WINGDIPAPI
732GdipSetLinePresetBlend(GpLineGradient *brush, GDIPCONST ARGB *blend,
733                       GDIPCONST REAL* positions, INT count);
734
735GpStatus WINGDIPAPI
736GdipSetLineSigmaBlend(GpLineGradient *brush, REAL focus, REAL scale);
737
738GpStatus WINGDIPAPI
739GdipSetLineLinearBlend(GpLineGradient *brush, REAL focus, REAL scale);
740
741GpStatus WINGDIPAPI
742GdipSetLineWrapMode(GpLineGradient *brush, GpWrapMode wrapmode);
743
744GpStatus WINGDIPAPI
745GdipGetLineWrapMode(GpLineGradient *brush, GpWrapMode *wrapmode);
746
747GpStatus WINGDIPAPI
748GdipGetLineTransform(GpLineGradient *brush, GpMatrix *matrix);
749
750GpStatus WINGDIPAPI
751GdipSetLineTransform(GpLineGradient *brush, GDIPCONST GpMatrix *matrix);
752
753GpStatus WINGDIPAPI
754GdipResetLineTransform(GpLineGradient* brush);
755
756GpStatus WINGDIPAPI
757GdipMultiplyLineTransform(GpLineGradient* brush, GDIPCONST GpMatrix *matrix,
758                            GpMatrixOrder order);
759
760GpStatus WINGDIPAPI
761GdipTranslateLineTransform(GpLineGradient* brush, REAL dx, REAL dy,
762                            GpMatrixOrder order);
763
764GpStatus WINGDIPAPI
765GdipScaleLineTransform(GpLineGradient* brush, REAL sx, REAL sy,
766                            GpMatrixOrder order);
767
768GpStatus WINGDIPAPI
769GdipRotateLineTransform(GpLineGradient* brush, REAL angle, GpMatrixOrder order);
770
771//----------------------------------------------------------------------------
772// PathGradient Brush
773//----------------------------------------------------------------------------
774
775GpStatus WINGDIPAPI
776GdipCreatePathGradient(GDIPCONST GpPointF* points,
777                                    INT count,
778                                    GpWrapMode wrapMode,
779                                    GpPathGradient **polyGradient);
780
781GpStatus WINGDIPAPI
782GdipCreatePathGradientI(GDIPCONST GpPoint* points,
783                                    INT count,
784                                    GpWrapMode wrapMode,
785                                    GpPathGradient **polyGradient);
786
787GpStatus WINGDIPAPI
788GdipCreatePathGradientFromPath(GDIPCONST GpPath* path,
789                                    GpPathGradient **polyGradient);
790
791GpStatus WINGDIPAPI
792GdipGetPathGradientCenterColor(
793                        GpPathGradient *brush, ARGB* colors);
794
795GpStatus WINGDIPAPI
796GdipSetPathGradientCenterColor(
797                        GpPathGradient *brush, ARGB colors);
798
799GpStatus WINGDIPAPI
800GdipGetPathGradientSurroundColorsWithCount(
801                        GpPathGradient *brush, ARGB* color, INT* count);
802
803GpStatus WINGDIPAPI
804GdipSetPathGradientSurroundColorsWithCount(
805                        GpPathGradient *brush,
806                        GDIPCONST ARGB* color, INT* count);
807
808GpStatus WINGDIPAPI
809GdipGetPathGradientPath(GpPathGradient *brush, GpPath *path);
810
811GpStatus WINGDIPAPI
812GdipSetPathGradientPath(GpPathGradient *brush, GDIPCONST GpPath *path);
813
814GpStatus WINGDIPAPI
815GdipGetPathGradientCenterPoint(
816                        GpPathGradient *brush, GpPointF* points);
817
818GpStatus WINGDIPAPI
819GdipGetPathGradientCenterPointI(
820                        GpPathGradient *brush, GpPoint* points);
821
822GpStatus WINGDIPAPI
823GdipSetPathGradientCenterPoint(
824                        GpPathGradient *brush, GDIPCONST GpPointF* points);
825
826GpStatus WINGDIPAPI
827GdipSetPathGradientCenterPointI(
828                        GpPathGradient *brush, GDIPCONST GpPoint* points);
829
830GpStatus WINGDIPAPI
831GdipGetPathGradientRect(GpPathGradient *brush, GpRectF *rect);
832
833GpStatus WINGDIPAPI
834GdipGetPathGradientRectI(GpPathGradient *brush, GpRect *rect);
835
836GpStatus WINGDIPAPI
837GdipGetPathGradientPointCount(GpPathGradient *brush, INT* count);
838
839GpStatus WINGDIPAPI
840GdipGetPathGradientSurroundColorCount(GpPathGradient *brush, INT* count);
841
842GpStatus WINGDIPAPI
843GdipSetPathGradientGammaCorrection(GpPathGradient *brush, BOOL useGammaCorrection);
844
845GpStatus WINGDIPAPI
846GdipGetPathGradientGammaCorrection(GpPathGradient *brush, BOOL *useGammaCorrection);
847
848GpStatus WINGDIPAPI
849GdipGetPathGradientBlendCount(GpPathGradient *brush,
850                                             INT *count);
851
852GpStatus WINGDIPAPI
853GdipGetPathGradientBlend(GpPathGradient *brush,
854                                    REAL *blend, REAL *positions, INT count);
855
856GpStatus WINGDIPAPI
857GdipSetPathGradientBlend(GpPathGradient *brush,
858                GDIPCONST REAL *blend, GDIPCONST REAL *positions, INT count);
859
860GpStatus WINGDIPAPI
861GdipGetPathGradientPresetBlendCount(GpPathGradient *brush, INT *count);
862
863GpStatus WINGDIPAPI
864GdipGetPathGradientPresetBlend(GpPathGradient *brush, ARGB *blend,
865                                                REAL* positions, INT count);
866
867GpStatus WINGDIPAPI
868GdipSetPathGradientPresetBlend(GpPathGradient *brush, GDIPCONST ARGB *blend,
869                                        GDIPCONST REAL* positions, INT count);
870
871GpStatus WINGDIPAPI
872GdipSetPathGradientSigmaBlend(GpPathGradient *brush, REAL focus, REAL scale);
873
874GpStatus WINGDIPAPI
875GdipSetPathGradientLinearBlend(GpPathGradient *brush, REAL focus, REAL scale);
876
877GpStatus WINGDIPAPI
878GdipGetPathGradientWrapMode(GpPathGradient *brush,
879                                         GpWrapMode *wrapmode);
880
881GpStatus WINGDIPAPI
882GdipSetPathGradientWrapMode(GpPathGradient *brush,
883                                         GpWrapMode wrapmode);
884
885GpStatus WINGDIPAPI
886GdipGetPathGradientTransform(GpPathGradient *brush,
887                                          GpMatrix *matrix);
888
889GpStatus WINGDIPAPI
890GdipSetPathGradientTransform(GpPathGradient *brush,
891                                          GpMatrix *matrix);
892
893GpStatus WINGDIPAPI
894GdipResetPathGradientTransform(GpPathGradient* brush);
895
896GpStatus WINGDIPAPI
897GdipMultiplyPathGradientTransform(GpPathGradient* brush, GDIPCONST GpMatrix *matrix,
898                            GpMatrixOrder order);
899
900GpStatus WINGDIPAPI
901GdipTranslatePathGradientTransform(GpPathGradient* brush, REAL dx, REAL dy,
902                            GpMatrixOrder order);
903
904GpStatus WINGDIPAPI
905GdipScalePathGradientTransform(GpPathGradient* brush, REAL sx, REAL sy,
906                            GpMatrixOrder order);
907
908GpStatus WINGDIPAPI
909GdipRotatePathGradientTransform(GpPathGradient* brush, REAL angle,
910                            GpMatrixOrder order);
911
912GpStatus WINGDIPAPI
913GdipGetPathGradientFocusScales(GpPathGradient *brush, REAL* xScale, REAL* yScale);
914
915GpStatus WINGDIPAPI
916GdipSetPathGradientFocusScales(GpPathGradient *brush, REAL xScale, REAL yScale);
917
918//----------------------------------------------------------------------------
919// Pen methods
920//----------------------------------------------------------------------------
921
922GpStatus WINGDIPAPI
923GdipCreatePen1(ARGB color, REAL width, GpUnit unit, GpPen **pen);
924
925GpStatus WINGDIPAPI
926GdipCreatePen2(GpBrush *brush, REAL width, GpUnit unit,
927                        GpPen **pen);
928
929GpStatus WINGDIPAPI
930GdipClonePen(GpPen *pen, GpPen **clonepen);
931
932GpStatus WINGDIPAPI
933GdipDeletePen(GpPen *pen);
934
935GpStatus WINGDIPAPI
936GdipSetPenWidth(GpPen *pen, REAL width);
937
938GpStatus WINGDIPAPI
939GdipGetPenWidth(GpPen *pen, REAL *width);
940
941GpStatus WINGDIPAPI
942GdipSetPenUnit(GpPen *pen, GpUnit unit);
943
944GpStatus WINGDIPAPI
945GdipGetPenUnit(GpPen *pen, GpUnit *unit);
946
947#ifdef DCR_USE_NEW_197819
948GpStatus WINGDIPAPI
949GdipSetPenLineCap197819(GpPen *pen, GpLineCap startCap, GpLineCap endCap,
950                  GpDashCap dashCap);
951#else
952GpStatus WINGDIPAPI
953GdipSetPenLineCap(GpPen *pen, GpLineCap startCap, GpLineCap endCap,
954                  GpLineCap dashCap);
955#endif // DCR_USE_NEW_197819
956
957
958GpStatus WINGDIPAPI
959GdipSetPenStartCap(GpPen *pen, GpLineCap startCap);
960
961GpStatus WINGDIPAPI
962GdipSetPenEndCap(GpPen *pen, GpLineCap endCap);
963
964#ifdef DCR_USE_NEW_197819
965GpStatus WINGDIPAPI
966GdipSetPenDashCap197819(GpPen *pen, GpDashCap dashCap);
967#else
968GpStatus WINGDIPAPI
969GdipSetPenDashCap(GpPen *pen, GpLineCap dashCap);
970#endif // DCR_USE_NEW_197819
971
972GpStatus WINGDIPAPI
973GdipGetPenStartCap(GpPen *pen, GpLineCap *startCap);
974
975GpStatus WINGDIPAPI
976GdipGetPenEndCap(GpPen *pen, GpLineCap *endCap);
977
978#ifdef DCR_USE_NEW_197819
979GpStatus WINGDIPAPI
980GdipGetPenDashCap197819(GpPen *pen, GpDashCap *dashCap);
981#else
982GpStatus WINGDIPAPI
983GdipGetPenDashCap(GpPen *pen, GpLineCap *dashCap);
984#endif // DCR_USE_NEW_197819
985
986GpStatus WINGDIPAPI
987GdipSetPenLineJoin(GpPen *pen, GpLineJoin lineJoin);
988
989GpStatus WINGDIPAPI
990GdipGetPenLineJoin(GpPen *pen, GpLineJoin *lineJoin);
991
992GpStatus WINGDIPAPI
993GdipSetPenCustomStartCap(GpPen *pen, GpCustomLineCap* customCap);
994
995GpStatus WINGDIPAPI
996GdipGetPenCustomStartCap(GpPen *pen, GpCustomLineCap** customCap);
997
998GpStatus WINGDIPAPI
999GdipSetPenCustomEndCap(GpPen *pen, GpCustomLineCap* customCap);
1000
1001GpStatus WINGDIPAPI
1002GdipGetPenCustomEndCap(GpPen *pen, GpCustomLineCap** customCap);
1003
1004GpStatus WINGDIPAPI
1005GdipSetPenMiterLimit(GpPen *pen, REAL miterLimit);
1006
1007GpStatus WINGDIPAPI
1008GdipGetPenMiterLimit(GpPen *pen, REAL *miterLimit);
1009
1010GpStatus WINGDIPAPI
1011GdipSetPenMode(GpPen *pen, GpPenAlignment penMode);
1012
1013GpStatus WINGDIPAPI
1014GdipGetPenMode(GpPen *pen, GpPenAlignment *penMode);
1015
1016GpStatus WINGDIPAPI
1017GdipSetPenTransform(GpPen *pen, GpMatrix *matrix);
1018
1019GpStatus WINGDIPAPI
1020GdipGetPenTransform(GpPen *pen, GpMatrix *matrix);
1021
1022GpStatus WINGDIPAPI
1023GdipResetPenTransform(GpPen *pen);
1024
1025GpStatus WINGDIPAPI
1026GdipMultiplyPenTransform(GpPen *pen, GDIPCONST GpMatrix *matrix,
1027                           GpMatrixOrder order);
1028
1029GpStatus WINGDIPAPI
1030GdipTranslatePenTransform(GpPen *pen, REAL dx, REAL dy,
1031                            GpMatrixOrder order);
1032
1033GpStatus WINGDIPAPI
1034GdipScalePenTransform(GpPen *pen, REAL sx, REAL sy,
1035                            GpMatrixOrder order);
1036
1037GpStatus WINGDIPAPI
1038GdipRotatePenTransform(GpPen *pen, REAL angle, GpMatrixOrder order);
1039
1040GpStatus WINGDIPAPI
1041GdipSetPenColor(GpPen *pen, ARGB argb);
1042
1043GpStatus WINGDIPAPI
1044GdipGetPenColor(GpPen *pen, ARGB *argb);
1045
1046GpStatus WINGDIPAPI
1047GdipSetPenBrushFill(GpPen *pen, GpBrush *brush);
1048
1049GpStatus WINGDIPAPI
1050GdipGetPenBrushFill(GpPen *pen, GpBrush **brush);
1051
1052GpStatus WINGDIPAPI
1053GdipGetPenFillType(GpPen *pen, GpPenType* type);
1054
1055GpStatus WINGDIPAPI
1056GdipGetPenDashStyle(GpPen *pen, GpDashStyle *dashstyle);
1057
1058GpStatus WINGDIPAPI
1059GdipSetPenDashStyle(GpPen *pen, GpDashStyle dashstyle);
1060
1061GpStatus WINGDIPAPI
1062GdipGetPenDashOffset(GpPen *pen, REAL *offset);
1063
1064GpStatus WINGDIPAPI
1065GdipSetPenDashOffset(GpPen *pen, REAL offset);
1066
1067GpStatus WINGDIPAPI
1068GdipGetPenDashCount(GpPen *pen, INT *count);
1069
1070GpStatus WINGDIPAPI
1071GdipSetPenDashArray(GpPen *pen, GDIPCONST REAL *dash, INT count);
1072
1073GpStatus WINGDIPAPI
1074GdipGetPenDashArray(GpPen *pen, REAL *dash, INT count);
1075
1076GpStatus WINGDIPAPI
1077GdipGetPenCompoundCount(GpPen *pen, INT *count);
1078
1079GpStatus WINGDIPAPI
1080GdipSetPenCompoundArray(GpPen *pen, GDIPCONST REAL *dash, INT count);
1081
1082GpStatus WINGDIPAPI
1083GdipGetPenCompoundArray(GpPen *pen, REAL *dash, INT count);
1084
1085//----------------------------------------------------------------------------
1086// CustomLineCap methods
1087//----------------------------------------------------------------------------
1088
1089GpStatus WINGDIPAPI
1090GdipCreateCustomLineCap(GpPath* fillPath, GpPath* strokePath,
1091   GpLineCap baseCap, REAL baseInset, GpCustomLineCap **customCap);
1092
1093GpStatus WINGDIPAPI
1094GdipDeleteCustomLineCap(GpCustomLineCap* customCap);
1095
1096GpStatus WINGDIPAPI
1097GdipCloneCustomLineCap(GpCustomLineCap* customCap,
1098                       GpCustomLineCap** clonedCap);
1099
1100GpStatus WINGDIPAPI
1101GdipGetCustomLineCapType(GpCustomLineCap* customCap,
1102                       CustomLineCapType* capType);
1103
1104GpStatus WINGDIPAPI
1105GdipSetCustomLineCapStrokeCaps(GpCustomLineCap* customCap,
1106                               GpLineCap startCap, GpLineCap endCap);
1107
1108GpStatus WINGDIPAPI
1109GdipGetCustomLineCapStrokeCaps(GpCustomLineCap* customCap,
1110                               GpLineCap* startCap, GpLineCap* endCap);
1111
1112GpStatus WINGDIPAPI
1113GdipSetCustomLineCapStrokeJoin(GpCustomLineCap* customCap, GpLineJoin lineJoin);
1114
1115GpStatus WINGDIPAPI
1116GdipGetCustomLineCapStrokeJoin(GpCustomLineCap* customCap, GpLineJoin* lineJoin);
1117
1118GpStatus WINGDIPAPI
1119GdipSetCustomLineCapBaseCap(GpCustomLineCap* customCap, GpLineCap baseCap);
1120
1121GpStatus WINGDIPAPI
1122GdipGetCustomLineCapBaseCap(GpCustomLineCap* customCap, GpLineCap* baseCap);
1123
1124GpStatus WINGDIPAPI
1125GdipSetCustomLineCapBaseInset(GpCustomLineCap* customCap, REAL inset);
1126
1127GpStatus WINGDIPAPI
1128GdipGetCustomLineCapBaseInset(GpCustomLineCap* customCap, REAL* inset);
1129
1130GpStatus WINGDIPAPI
1131GdipSetCustomLineCapWidthScale(GpCustomLineCap* customCap, REAL widthScale);
1132
1133GpStatus WINGDIPAPI
1134GdipGetCustomLineCapWidthScale(GpCustomLineCap* customCap, REAL* widthScale);
1135
1136//----------------------------------------------------------------------------
1137// AdjustableArrowCap methods
1138//----------------------------------------------------------------------------
1139
1140GpStatus WINGDIPAPI
1141GdipCreateAdjustableArrowCap(REAL height, REAL width, BOOL isFilled,
1142                             GpAdjustableArrowCap **cap);
1143
1144GpStatus WINGDIPAPI
1145GdipSetAdjustableArrowCapHeight(GpAdjustableArrowCap* cap, REAL height);
1146
1147GpStatus WINGDIPAPI
1148GdipGetAdjustableArrowCapHeight(GpAdjustableArrowCap* cap, REAL* height);
1149
1150GpStatus WINGDIPAPI
1151GdipSetAdjustableArrowCapWidth(GpAdjustableArrowCap* cap, REAL width);
1152
1153GpStatus WINGDIPAPI
1154GdipGetAdjustableArrowCapWidth(GpAdjustableArrowCap* cap, REAL* width);
1155
1156GpStatus WINGDIPAPI
1157GdipSetAdjustableArrowCapMiddleInset(GpAdjustableArrowCap* cap, REAL middleInset);
1158
1159GpStatus WINGDIPAPI
1160GdipGetAdjustableArrowCapMiddleInset(GpAdjustableArrowCap* cap, REAL* middleInset);
1161
1162GpStatus WINGDIPAPI
1163GdipSetAdjustableArrowCapFillState(GpAdjustableArrowCap* cap, BOOL fillState);
1164
1165GpStatus WINGDIPAPI
1166GdipGetAdjustableArrowCapFillState(GpAdjustableArrowCap* cap, BOOL* fillState);
1167
1168//----------------------------------------------------------------------------
1169// Image methods
1170//----------------------------------------------------------------------------
1171
1172GpStatus WINGDIPAPI
1173GdipLoadImageFromStream(IStream* stream, GpImage **image);
1174
1175GpStatus WINGDIPAPI
1176GdipLoadImageFromFile(GDIPCONST WCHAR* filename, GpImage **image);
1177
1178GpStatus WINGDIPAPI
1179GdipLoadImageFromStreamICM(IStream* stream, GpImage **image);
1180
1181GpStatus WINGDIPAPI
1182GdipLoadImageFromFileICM(GDIPCONST WCHAR* filename, GpImage **image);
1183
1184GpStatus WINGDIPAPI
1185GdipCloneImage(GpImage *image, GpImage **cloneImage);
1186
1187GpStatus WINGDIPAPI
1188GdipDisposeImage(GpImage *image);
1189
1190GpStatus WINGDIPAPI
1191GdipSaveImageToFile(GpImage *image, GDIPCONST WCHAR* filename,
1192                    GDIPCONST CLSID* clsidEncoder, GDIPCONST EncoderParameters* encoderParams);
1193
1194GpStatus WINGDIPAPI
1195GdipSaveImageToStream(GpImage *image, IStream* stream,
1196                      GDIPCONST CLSID* clsidEncoder, GDIPCONST EncoderParameters* encoderParams);
1197
1198GpStatus WINGDIPAPI
1199GdipSaveAdd(GpImage *image, GDIPCONST EncoderParameters* encoderParams);
1200
1201GpStatus WINGDIPAPI
1202GdipSaveAddImage(GpImage *image, GpImage* newImage,
1203                 GDIPCONST EncoderParameters* encoderParams);
1204
1205GpStatus WINGDIPAPI
1206GdipGetImageGraphicsContext(GpImage *image, GpGraphics **graphics);
1207
1208GpStatus WINGDIPAPI
1209GdipGetImageBounds(GpImage *image, GpRectF *srcRect, GpUnit *srcUnit);
1210
1211GpStatus WINGDIPAPI
1212GdipGetImageDimension(GpImage *image, REAL *width, REAL *height);
1213
1214GpStatus WINGDIPAPI
1215GdipGetImageType(GpImage *image, ImageType *type);
1216
1217GpStatus WINGDIPAPI
1218GdipGetImageWidth(GpImage *image, UINT *width);
1219
1220GpStatus WINGDIPAPI
1221GdipGetImageHeight(GpImage *image, UINT *height);
1222
1223GpStatus WINGDIPAPI
1224GdipGetImageHorizontalResolution(GpImage *image, REAL *resolution);
1225
1226GpStatus WINGDIPAPI
1227GdipGetImageVerticalResolution(GpImage *image, REAL *resolution);
1228
1229GpStatus WINGDIPAPI
1230GdipGetImageFlags(GpImage *image, UINT *flags);
1231
1232GpStatus WINGDIPAPI
1233GdipGetImageRawFormat(GpImage *image, GUID *format);
1234
1235GpStatus WINGDIPAPI
1236GdipGetImagePixelFormat(GpImage *image, PixelFormat *format);
1237
1238GpStatus WINGDIPAPI
1239GdipGetImageThumbnail(GpImage *image, UINT thumbWidth, UINT thumbHeight,
1240                      GpImage **thumbImage,
1241                      GetThumbnailImageAbort callback, VOID * callbackData);
1242
1243GpStatus WINGDIPAPI
1244GdipGetEncoderParameterListSize(GpImage *image, GDIPCONST CLSID* clsidEncoder,
1245                                UINT* size);
1246
1247GpStatus WINGDIPAPI
1248GdipGetEncoderParameterList(GpImage *image, GDIPCONST CLSID* clsidEncoder,
1249                            UINT size, EncoderParameters* buffer);
1250
1251GpStatus WINGDIPAPI
1252GdipImageGetFrameDimensionsCount(GpImage* image, UINT* count);
1253
1254GpStatus WINGDIPAPI
1255GdipImageGetFrameDimensionsList(GpImage* image, GUID* dimensionIDs, UINT count);
1256
1257GpStatus WINGDIPAPI
1258GdipImageGetFrameCount(GpImage *image, GDIPCONST GUID* dimensionID, UINT* count);
1259
1260GpStatus WINGDIPAPI
1261GdipImageSelectActiveFrame(GpImage *image, GDIPCONST GUID* dimensionID,
1262                           UINT frameIndex);
1263
1264GpStatus WINGDIPAPI
1265GdipImageRotateFlip(GpImage *image, RotateFlipType rfType);
1266
1267GpStatus WINGDIPAPI
1268GdipGetImagePalette(GpImage *image, ColorPalette *palette, INT size);
1269
1270GpStatus WINGDIPAPI
1271GdipSetImagePalette(GpImage *image, GDIPCONST ColorPalette *palette);
1272
1273GpStatus WINGDIPAPI
1274GdipGetImagePaletteSize(GpImage *image, INT *size);
1275
1276GpStatus WINGDIPAPI
1277GdipGetPropertyCount(GpImage *image, UINT* numOfProperty);
1278
1279GpStatus WINGDIPAPI
1280GdipGetPropertyIdList(GpImage *image, UINT numOfProperty, PROPID* list);
1281
1282GpStatus WINGDIPAPI
1283GdipGetPropertyItemSize(GpImage *image, PROPID propId, UINT* size);
1284
1285GpStatus WINGDIPAPI
1286GdipGetPropertyItem(GpImage *image, PROPID propId,UINT propSize,
1287                    PropertyItem* buffer);
1288
1289GpStatus WINGDIPAPI
1290GdipGetPropertySize(GpImage *image, UINT* totalBufferSize, UINT* numProperties);
1291
1292GpStatus WINGDIPAPI
1293GdipGetAllPropertyItems(GpImage *image, UINT totalBufferSize,
1294                        UINT numProperties, PropertyItem* allItems);
1295
1296GpStatus WINGDIPAPI
1297GdipRemovePropertyItem(GpImage *image, PROPID propId);
1298
1299GpStatus WINGDIPAPI
1300GdipSetPropertyItem(GpImage *image, GDIPCONST PropertyItem* item);
1301
1302GpStatus WINGDIPAPI
1303GdipImageForceValidation(GpImage *image);
1304
1305GpStatus WINGDIPAPI
1306GdipGetImageLayout(GpImage *image, ImageLayout* layout);
1307
1308GpStatus WINGDIPAPI
1309GdipSetImageLayout(GpImage *image, GDIPCONST ImageLayout layout);
1310
1311//----------------------------------------------------------------------------
1312// Bitmap methods
1313//----------------------------------------------------------------------------
1314
1315GpStatus WINGDIPAPI
1316GdipCreateBitmapFromStream(IStream* stream, GpBitmap **bitmap);
1317
1318GpStatus WINGDIPAPI
1319GdipCreateBitmapFromFile(GDIPCONST WCHAR* filename, GpBitmap **bitmap);
1320
1321GpStatus WINGDIPAPI
1322GdipCreateBitmapFromStreamICM(IStream* stream, GpBitmap **bitmap);
1323
1324GpStatus WINGDIPAPI
1325GdipCreateBitmapFromFileICM(GDIPCONST WCHAR* filename, GpBitmap **bitmap);
1326
1327GpStatus WINGDIPAPI
1328GdipCreateBitmapFromScan0(INT width,
1329                          INT height,
1330                          INT stride,
1331                          PixelFormat format,
1332                          BYTE* scan0,
1333                          GpBitmap** bitmap);
1334
1335GpStatus WINGDIPAPI
1336GdipCreateBitmapFromGraphics(INT width,
1337                             INT height,
1338                             GpGraphics* target,
1339                             GpBitmap** bitmap);
1340
1341GpStatus WINGDIPAPI
1342GdipCreateBitmapFromDirectDrawSurface(IDirectDrawSurface7* surface,
1343                                      GpBitmap** bitmap);
1344
1345GpStatus WINGDIPAPI
1346GdipCreateBitmapFromGdiDib(GDIPCONST BITMAPINFO* gdiBitmapInfo,
1347                           VOID* gdiBitmapData,
1348                           GpBitmap** bitmap);
1349
1350GpStatus WINGDIPAPI
1351GdipCreateBitmapFromHBITMAP(HBITMAP hbm,
1352                            HPALETTE hpal,
1353                            GpBitmap** bitmap);
1354
1355GpStatus WINGDIPAPI
1356GdipCreateHBITMAPFromBitmap(GpBitmap* bitmap,
1357                            HBITMAP* hbmReturn,
1358                            ARGB background);
1359
1360GpStatus WINGDIPAPI
1361GdipCreateBitmapFromHICON(HICON hicon,
1362                          GpBitmap** bitmap);
1363
1364GpStatus WINGDIPAPI
1365GdipCreateHICONFromBitmap(GpBitmap* bitmap,
1366                          HICON* hbmReturn);
1367
1368GpStatus WINGDIPAPI
1369GdipCreateBitmapFromResource(HINSTANCE hInstance,
1370                             GDIPCONST WCHAR* lpBitmapName,
1371                             GpBitmap** bitmap);
1372
1373GpStatus WINGDIPAPI
1374GdipCloneBitmapArea(REAL x, REAL y, REAL width, REAL height,
1375                            PixelFormat format,
1376                            GpBitmap *srcBitmap,
1377                            GpBitmap **dstBitmap);
1378
1379GpStatus WINGDIPAPI
1380GdipCloneBitmapAreaI(INT x,
1381                     INT y,
1382                     INT width,
1383                     INT height,
1384                     PixelFormat format,
1385                     GpBitmap *srcBitmap,
1386                     GpBitmap **dstBitmap);
1387
1388GpStatus WINGDIPAPI
1389GdipBitmapLockBits(GpBitmap* bitmap,
1390                   GDIPCONST GpRect* rect,
1391                   UINT flags,
1392                   PixelFormat format,
1393                   BitmapData* lockedBitmapData);
1394
1395GpStatus WINGDIPAPI
1396GdipBitmapUnlockBits(GpBitmap* bitmap,
1397                     BitmapData* lockedBitmapData);
1398
1399GpStatus WINGDIPAPI
1400GdipBitmapGetPixel(GpBitmap* bitmap, INT x, INT y, ARGB *color);
1401
1402GpStatus WINGDIPAPI
1403GdipBitmapSetPixel(GpBitmap* bitmap, INT x, INT y, ARGB color);
1404
1405GpStatus WINGDIPAPI
1406GdipBitmapSetResolution(GpBitmap* bitmap, REAL xdpi, REAL ydpi);
1407
1408//----------------------------------------------------------------------------
1409// ImageAttributes methods
1410//----------------------------------------------------------------------------
1411
1412GpStatus WINGDIPAPI
1413GdipCreateImageAttributes(GpImageAttributes **imageattr);
1414
1415GpStatus WINGDIPAPI
1416GdipCloneImageAttributes(GDIPCONST GpImageAttributes *imageattr,
1417                         GpImageAttributes **cloneImageattr);
1418
1419GpStatus WINGDIPAPI
1420GdipDisposeImageAttributes(GpImageAttributes *imageattr);
1421
1422GpStatus WINGDIPAPI
1423GdipSetImageAttributesToIdentity(GpImageAttributes *imageattr,
1424                                 ColorAdjustType type);
1425GpStatus WINGDIPAPI
1426GdipResetImageAttributes(GpImageAttributes *imageattr,
1427                         ColorAdjustType type);
1428
1429GpStatus WINGDIPAPI
1430GdipSetImageAttributesColorMatrix(GpImageAttributes *imageattr,
1431                               ColorAdjustType type,
1432                               BOOL enableFlag,
1433                               GDIPCONST ColorMatrix* colorMatrix,
1434                               GDIPCONST ColorMatrix* grayMatrix,
1435                               ColorMatrixFlags flags);
1436
1437GpStatus WINGDIPAPI
1438GdipSetImageAttributesThreshold(GpImageAttributes *imageattr,
1439                                ColorAdjustType type,
1440                                BOOL enableFlag,
1441                                REAL threshold);
1442
1443GpStatus WINGDIPAPI
1444GdipSetImageAttributesGamma(GpImageAttributes *imageattr,
1445                            ColorAdjustType type,
1446                            BOOL enableFlag,
1447                            REAL gamma);
1448
1449GpStatus WINGDIPAPI
1450GdipSetImageAttributesNoOp(GpImageAttributes *imageattr,
1451                           ColorAdjustType type,
1452                           BOOL enableFlag);
1453
1454GpStatus WINGDIPAPI
1455GdipSetImageAttributesColorKeys(GpImageAttributes *imageattr,
1456                                ColorAdjustType type,
1457                                BOOL enableFlag,
1458                                ARGB colorLow,
1459                                ARGB colorHigh);
1460
1461GpStatus WINGDIPAPI
1462GdipSetImageAttributesOutputChannel(GpImageAttributes *imageattr,
1463                                    ColorAdjustType type,
1464                                    BOOL enableFlag,
1465                                    ColorChannelFlags channelFlags);
1466
1467GpStatus WINGDIPAPI
1468GdipSetImageAttributesOutputChannelColorProfile(GpImageAttributes *imageattr,
1469                                                ColorAdjustType type,
1470                                                BOOL enableFlag,
1471                                                GDIPCONST WCHAR *colorProfileFilename);
1472
1473GpStatus WINGDIPAPI
1474GdipSetImageAttributesRemapTable(GpImageAttributes *imageattr,
1475                                 ColorAdjustType type,
1476                                 BOOL enableFlag,
1477                                 UINT mapSize,
1478                                 GDIPCONST ColorMap *map);
1479GpStatus WINGDIPAPI
1480GdipSetImageAttributesWrapMode(
1481    GpImageAttributes *imageAttr,
1482    WrapMode wrap,
1483    ARGB argb,
1484    BOOL clamp
1485);
1486
1487GpStatus WINGDIPAPI
1488GdipSetImageAttributesICMMode(
1489    GpImageAttributes *imageAttr,
1490    BOOL on
1491);
1492
1493GpStatus WINGDIPAPI
1494GdipGetImageAttributesAdjustedPalette(
1495    GpImageAttributes *imageAttr,
1496    ColorPalette * colorPalette,
1497    ColorAdjustType colorAdjustType
1498);
1499
1500//----------------------------------------------------------------------------
1501// Graphics methods
1502//----------------------------------------------------------------------------
1503
1504GpStatus WINGDIPAPI
1505GdipFlush(GpGraphics *graphics, GpFlushIntention intention);
1506
1507GpStatus WINGDIPAPI
1508GdipCreateFromHDC(HDC hdc, GpGraphics **graphics);
1509
1510GpStatus WINGDIPAPI
1511GdipCreateFromHDC2(HDC hdc, HANDLE hDevice, GpGraphics **graphics);
1512
1513GpStatus WINGDIPAPI
1514GdipCreateFromHWND(HWND hwnd, GpGraphics **graphics);
1515
1516GpStatus WINGDIPAPI
1517GdipCreateFromHWNDICM(HWND hwnd, GpGraphics **graphics);
1518
1519GpStatus WINGDIPAPI
1520GdipDeleteGraphics(GpGraphics *graphics);
1521
1522GpStatus WINGDIPAPI
1523GdipGetDC(GpGraphics* graphics, HDC * hdc);
1524
1525GpStatus WINGDIPAPI
1526GdipReleaseDC(GpGraphics* graphics, HDC hdc);
1527
1528GpStatus WINGDIPAPI
1529GdipSetCompositingMode(GpGraphics *graphics, CompositingMode compositingMode);
1530
1531GpStatus WINGDIPAPI
1532GdipGetCompositingMode(GpGraphics *graphics, CompositingMode *compositingMode);
1533
1534GpStatus WINGDIPAPI
1535GdipSetRenderingOrigin(GpGraphics *graphics, INT x, INT y);
1536
1537GpStatus WINGDIPAPI
1538GdipGetRenderingOrigin(GpGraphics *graphics, INT *x, INT *y);
1539
1540GpStatus WINGDIPAPI
1541GdipSetCompositingQuality(GpGraphics *graphics, CompositingQuality compositingQuality);
1542
1543GpStatus WINGDIPAPI
1544GdipGetCompositingQuality(GpGraphics *graphics, CompositingQuality *compositingQuality);
1545
1546GpStatus WINGDIPAPI
1547GdipSetSmoothingMode(GpGraphics *graphics, SmoothingMode smoothingMode);
1548
1549GpStatus WINGDIPAPI
1550GdipGetSmoothingMode(GpGraphics *graphics, SmoothingMode *smoothingMode);
1551
1552GpStatus WINGDIPAPI
1553GdipSetPixelOffsetMode(GpGraphics* graphics, PixelOffsetMode pixelOffsetMode);
1554
1555GpStatus WINGDIPAPI
1556GdipGetPixelOffsetMode(GpGraphics *graphics, PixelOffsetMode *pixelOffsetMode);
1557
1558GpStatus WINGDIPAPI
1559GdipSetTextRenderingHint(GpGraphics *graphics, TextRenderingHint mode);
1560
1561GpStatus WINGDIPAPI
1562GdipGetTextRenderingHint(GpGraphics *graphics, TextRenderingHint *mode);
1563
1564#ifdef DCR_USE_NEW_188922
1565GpStatus  WINGDIPAPI
1566GdipSetTextContrast(GpGraphics *graphics, UINT contrast);
1567
1568GpStatus  WINGDIPAPI
1569GdipGetTextContrast(GpGraphics *graphics, UINT * contrast);
1570#else
1571GpStatus  WINGDIPAPI
1572GdipSetTextGammaValue(GpGraphics *graphics, UINT gammaValue);
1573
1574GpStatus  WINGDIPAPI
1575GdipGetTextGammaValue(GpGraphics *graphics, UINT * gammaValue);
1576#endif // DCR_USE_NEW_188922
1577
1578
1579GpStatus WINGDIPAPI
1580GdipSetInterpolationMode(GpGraphics *graphics, InterpolationMode interpolationMode);
1581
1582GpStatus WINGDIPAPI
1583GdipGetInterpolationMode(GpGraphics *graphics, InterpolationMode *interpolationMode);
1584
1585GpStatus WINGDIPAPI
1586GdipSetWorldTransform(GpGraphics *graphics, GpMatrix *matrix);
1587
1588GpStatus WINGDIPAPI
1589GdipResetWorldTransform(GpGraphics *graphics);
1590
1591GpStatus WINGDIPAPI
1592GdipMultiplyWorldTransform(GpGraphics *graphics, GDIPCONST GpMatrix *matrix,
1593                           GpMatrixOrder order);
1594
1595GpStatus WINGDIPAPI
1596GdipTranslateWorldTransform(GpGraphics *graphics, REAL dx, REAL dy,
1597                            GpMatrixOrder order);
1598
1599GpStatus WINGDIPAPI
1600GdipScaleWorldTransform(GpGraphics *graphics, REAL sx, REAL sy,
1601                        GpMatrixOrder order);
1602
1603GpStatus WINGDIPAPI
1604GdipRotateWorldTransform(GpGraphics *graphics, REAL angle, GpMatrixOrder order);
1605
1606GpStatus WINGDIPAPI
1607GdipGetWorldTransform(GpGraphics *graphics, GpMatrix *matrix);
1608
1609GpStatus WINGDIPAPI
1610GdipResetPageTransform(GpGraphics *graphics);
1611
1612GpStatus WINGDIPAPI
1613GdipGetPageUnit(GpGraphics *graphics, GpUnit *unit);
1614
1615GpStatus WINGDIPAPI
1616GdipGetPageScale(GpGraphics *graphics, REAL *scale);
1617
1618GpStatus WINGDIPAPI
1619GdipSetPageUnit(GpGraphics *graphics, GpUnit unit);
1620
1621GpStatus WINGDIPAPI
1622GdipSetPageScale(GpGraphics *graphics, REAL scale);
1623
1624GpStatus WINGDIPAPI
1625GdipGetDpiX(GpGraphics *graphics, REAL* dpi);
1626
1627GpStatus WINGDIPAPI
1628GdipGetDpiY(GpGraphics *graphics, REAL* dpi);
1629
1630GpStatus WINGDIPAPI
1631GdipTransformPoints(GpGraphics *graphics, GpCoordinateSpace destSpace,
1632                             GpCoordinateSpace srcSpace, GpPointF *points,
1633                             INT count);
1634
1635GpStatus WINGDIPAPI
1636GdipTransformPointsI(GpGraphics *graphics, GpCoordinateSpace destSpace,
1637                             GpCoordinateSpace srcSpace, GpPoint *points,
1638                             INT count);
1639
1640GpStatus WINGDIPAPI
1641GdipGetNearestColor(GpGraphics *graphics, ARGB* argb);
1642
1643// Create the Win9x Halftone Palette (even on NT) with correct Desktop colors
1644HPALETTE WINGDIPAPI
1645GdipCreateHalftonePalette();
1646
1647GpStatus WINGDIPAPI
1648GdipDrawLine(GpGraphics *graphics, GpPen *pen, REAL x1, REAL y1,
1649                      REAL x2, REAL y2);
1650
1651GpStatus WINGDIPAPI
1652GdipDrawLineI(GpGraphics *graphics, GpPen *pen, INT x1, INT y1,
1653                      INT x2, INT y2);
1654
1655GpStatus WINGDIPAPI
1656GdipDrawLines(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPointF *points,
1657                       INT count);
1658
1659GpStatus WINGDIPAPI
1660GdipDrawLinesI(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPoint *points,
1661                       INT count);
1662
1663GpStatus WINGDIPAPI
1664GdipDrawArc(GpGraphics *graphics, GpPen *pen, REAL x, REAL y,
1665            REAL width, REAL height, REAL startAngle, REAL sweepAngle);
1666
1667GpStatus WINGDIPAPI
1668GdipDrawArcI(GpGraphics *graphics, GpPen *pen, INT x, INT y,
1669                     INT width, INT height, REAL startAngle, REAL sweepAngle);
1670
1671GpStatus WINGDIPAPI
1672GdipDrawBezier(GpGraphics *graphics, GpPen *pen, REAL x1, REAL y1,
1673                        REAL x2, REAL y2, REAL x3, REAL y3, REAL x4, REAL y4);
1674
1675GpStatus WINGDIPAPI
1676GdipDrawBezierI(GpGraphics *graphics, GpPen *pen, INT x1, INT y1,
1677                        INT x2, INT y2, INT x3, INT y3, INT x4, INT y4);
1678
1679GpStatus WINGDIPAPI
1680GdipDrawBeziers(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPointF *points,
1681                         INT count);
1682
1683GpStatus WINGDIPAPI
1684GdipDrawBeziersI(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPoint *points,
1685                         INT count);
1686
1687GpStatus WINGDIPAPI
1688GdipDrawRectangle(GpGraphics *graphics, GpPen *pen, REAL x, REAL y,
1689                      REAL width, REAL height);
1690
1691GpStatus WINGDIPAPI
1692GdipDrawRectangleI(GpGraphics *graphics, GpPen *pen, INT x, INT y,
1693                      INT width, INT height);
1694
1695GpStatus WINGDIPAPI
1696GdipDrawRectangles(GpGraphics *graphics, GpPen *pen, GDIPCONST GpRectF *rects,
1697                       INT count);
1698
1699GpStatus WINGDIPAPI
1700GdipDrawRectanglesI(GpGraphics *graphics, GpPen *pen, GDIPCONST GpRect *rects,
1701                       INT count);
1702
1703GpStatus WINGDIPAPI
1704GdipDrawEllipse(GpGraphics *graphics, GpPen *pen, REAL x, REAL y,
1705                         REAL width, REAL height);
1706
1707GpStatus WINGDIPAPI
1708GdipDrawEllipseI(GpGraphics *graphics, GpPen *pen, INT x, INT y,
1709                         INT width, INT height);
1710
1711GpStatus WINGDIPAPI
1712GdipDrawPie(GpGraphics *graphics, GpPen *pen, REAL x, REAL y,
1713                     REAL width, REAL height, REAL startAngle, REAL sweepAngle);
1714
1715GpStatus WINGDIPAPI
1716GdipDrawPieI(GpGraphics *graphics, GpPen *pen, INT x, INT y,
1717                     INT width, INT height, REAL startAngle, REAL sweepAngle);
1718
1719GpStatus WINGDIPAPI
1720GdipDrawPolygon(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPointF *points,
1721                         INT count);
1722
1723GpStatus WINGDIPAPI
1724GdipDrawPolygonI(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPoint *points,
1725                         INT count);
1726
1727GpStatus WINGDIPAPI
1728GdipDrawPath(GpGraphics *graphics, GpPen *pen, GpPath *path);
1729
1730GpStatus WINGDIPAPI
1731GdipDrawCurve(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPointF *points,
1732                       INT count);
1733
1734GpStatus WINGDIPAPI
1735GdipDrawCurveI(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPoint *points,
1736                       INT count);
1737
1738GpStatus WINGDIPAPI
1739GdipDrawCurve2(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPointF *points,
1740                       INT count, REAL tension);
1741
1742GpStatus WINGDIPAPI
1743GdipDrawCurve2I(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPoint *points,
1744                       INT count, REAL tension);
1745
1746GpStatus WINGDIPAPI
1747GdipDrawCurve3(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPointF *points,
1748               INT count, INT offset, INT numberOfSegments, REAL tension);
1749
1750GpStatus WINGDIPAPI
1751GdipDrawCurve3I(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPoint *points,
1752                INT count, INT offset, INT numberOfSegments, REAL tension);
1753
1754GpStatus WINGDIPAPI
1755GdipDrawClosedCurve(GpGraphics *graphics, GpPen *pen,
1756                    GDIPCONST GpPointF *points, INT count);
1757
1758GpStatus WINGDIPAPI
1759GdipDrawClosedCurveI(GpGraphics *graphics, GpPen *pen,
1760                     GDIPCONST GpPoint *points, INT count);
1761
1762GpStatus WINGDIPAPI
1763GdipDrawClosedCurve2(GpGraphics *graphics, GpPen *pen,
1764                     GDIPCONST GpPointF *points, INT count, REAL tension);
1765
1766GpStatus WINGDIPAPI
1767GdipDrawClosedCurve2I(GpGraphics *graphics, GpPen *pen,
1768                      GDIPCONST GpPoint *points, INT count, REAL tension);
1769
1770GpStatus WINGDIPAPI
1771GdipGraphicsClear(GpGraphics *graphics, ARGB color);
1772
1773GpStatus WINGDIPAPI
1774GdipFillRectangle(GpGraphics *graphics, GpBrush *brush, REAL x, REAL y,
1775                  REAL width, REAL height);
1776
1777GpStatus WINGDIPAPI
1778GdipFillRectangleI(GpGraphics *graphics, GpBrush *brush, INT x, INT y,
1779                   INT width, INT height);
1780
1781GpStatus WINGDIPAPI
1782GdipFillRectangles(GpGraphics *graphics, GpBrush *brush,
1783                   GDIPCONST GpRectF *rects, INT count);
1784
1785GpStatus WINGDIPAPI
1786GdipFillRectanglesI(GpGraphics *graphics, GpBrush *brush,
1787                    GDIPCONST GpRect *rects, INT count);
1788
1789GpStatus WINGDIPAPI
1790GdipFillPolygon(GpGraphics *graphics, GpBrush *brush,
1791                GDIPCONST GpPointF *points, INT count, GpFillMode fillMode);
1792
1793GpStatus WINGDIPAPI
1794GdipFillPolygonI(GpGraphics *graphics, GpBrush *brush,
1795                 GDIPCONST GpPoint *points, INT count, GpFillMode fillMode);
1796
1797GpStatus WINGDIPAPI
1798GdipFillPolygon2(GpGraphics *graphics, GpBrush *brush,
1799                 GDIPCONST GpPointF *points, INT count);
1800
1801GpStatus WINGDIPAPI
1802GdipFillPolygon2I(GpGraphics *graphics, GpBrush *brush,
1803                  GDIPCONST GpPoint *points, INT count);
1804
1805GpStatus WINGDIPAPI
1806GdipFillEllipse(GpGraphics *graphics, GpBrush *brush, REAL x, REAL y,
1807                REAL width, REAL height);
1808
1809GpStatus WINGDIPAPI
1810GdipFillEllipseI(GpGraphics *graphics, GpBrush *brush, INT x, INT y,
1811                 INT width, INT height);
1812
1813GpStatus WINGDIPAPI
1814GdipFillPie(GpGraphics *graphics, GpBrush *brush, REAL x, REAL y,
1815            REAL width, REAL height, REAL startAngle, REAL sweepAngle);
1816
1817GpStatus WINGDIPAPI
1818GdipFillPieI(GpGraphics *graphics, GpBrush *brush, INT x, INT y,
1819             INT width, INT height, REAL startAngle, REAL sweepAngle);
1820
1821GpStatus WINGDIPAPI
1822GdipFillPath(GpGraphics *graphics, GpBrush *brush, GpPath *path);
1823
1824GpStatus WINGDIPAPI
1825GdipFillClosedCurve(GpGraphics *graphics, GpBrush *brush,
1826                              GDIPCONST GpPointF *points, INT count);
1827
1828GpStatus WINGDIPAPI
1829GdipFillClosedCurveI(GpGraphics *graphics, GpBrush *brush,
1830                              GDIPCONST GpPoint *points, INT count);
1831
1832GpStatus WINGDIPAPI
1833GdipFillClosedCurve2(GpGraphics *graphics, GpBrush *brush,
1834                              GDIPCONST GpPointF *points, INT count,
1835                              REAL tension, GpFillMode fillMode);
1836
1837GpStatus WINGDIPAPI
1838GdipFillClosedCurve2I(GpGraphics *graphics, GpBrush *brush,
1839                              GDIPCONST GpPoint *points, INT count,
1840                              REAL tension, GpFillMode fillMode);
1841
1842GpStatus WINGDIPAPI
1843GdipFillRegion(GpGraphics *graphics, GpBrush *brush,
1844                        GpRegion *region);
1845
1846GpStatus WINGDIPAPI
1847GdipDrawImage(GpGraphics *graphics, GpImage *image, REAL x, REAL y);
1848
1849GpStatus WINGDIPAPI
1850GdipDrawImageI(GpGraphics *graphics, GpImage *image, INT x, INT y);
1851
1852GpStatus WINGDIPAPI
1853GdipDrawImageRect(GpGraphics *graphics, GpImage *image, REAL x, REAL y,
1854                           REAL width, REAL height);
1855
1856GpStatus WINGDIPAPI
1857GdipDrawImageRectI(GpGraphics *graphics, GpImage *image, INT x, INT y,
1858                           INT width, INT height);
1859
1860GpStatus WINGDIPAPI
1861GdipDrawImagePoints(GpGraphics *graphics, GpImage *image,
1862                             GDIPCONST GpPointF *dstpoints, INT count);
1863
1864GpStatus WINGDIPAPI
1865GdipDrawImagePointsI(GpGraphics *graphics, GpImage *image,
1866                             GDIPCONST GpPoint *dstpoints, INT count);
1867
1868GpStatus WINGDIPAPI
1869GdipDrawImagePointRect(GpGraphics *graphics, GpImage *image, REAL x,
1870                                REAL y, REAL srcx, REAL srcy, REAL srcwidth,
1871                                REAL srcheight, GpUnit srcUnit);
1872
1873GpStatus WINGDIPAPI
1874GdipDrawImagePointRectI(GpGraphics *graphics, GpImage *image, INT x,
1875                                INT y, INT srcx, INT srcy, INT srcwidth,
1876                                INT srcheight, GpUnit srcUnit);
1877
1878GpStatus WINGDIPAPI
1879GdipDrawImageRectRect(GpGraphics *graphics, GpImage *image, REAL dstx,
1880                      REAL dsty, REAL dstwidth, REAL dstheight,
1881                      REAL srcx, REAL srcy, REAL srcwidth, REAL srcheight,
1882                      GpUnit srcUnit,
1883                      GDIPCONST GpImageAttributes* imageAttributes,
1884                      DrawImageAbort callback, VOID * callbackData);
1885
1886GpStatus WINGDIPAPI
1887GdipDrawImageRectRectI(GpGraphics *graphics, GpImage *image, INT dstx,
1888                       INT dsty, INT dstwidth, INT dstheight,
1889                       INT srcx, INT srcy, INT srcwidth, INT srcheight,
1890                       GpUnit srcUnit,
1891                       GDIPCONST GpImageAttributes* imageAttributes,
1892                       DrawImageAbort callback, VOID * callbackData);
1893
1894GpStatus WINGDIPAPI
1895GdipDrawImagePointsRect(GpGraphics *graphics, GpImage *image,
1896                        GDIPCONST GpPointF *points, INT count, REAL srcx,
1897                        REAL srcy, REAL srcwidth, REAL srcheight,
1898                        GpUnit srcUnit,
1899                        GDIPCONST GpImageAttributes* imageAttributes,
1900                        DrawImageAbort callback, VOID * callbackData);
1901
1902GpStatus WINGDIPAPI
1903GdipDrawImagePointsRectI(GpGraphics *graphics, GpImage *image,
1904                         GDIPCONST GpPoint *points, INT count, INT srcx,
1905                         INT srcy, INT srcwidth, INT srcheight,
1906                         GpUnit srcUnit,
1907                         GDIPCONST GpImageAttributes* imageAttributes,
1908                         DrawImageAbort callback, VOID * callbackData);
1909
1910GpStatus WINGDIPAPI
1911GdipEnumerateMetafileDestPoint(
1912    GpGraphics *            graphics,
1913    GDIPCONST GpMetafile *  metafile,
1914    GDIPCONST PointF &      destPoint,
1915    EnumerateMetafileProc   callback,
1916    VOID *                  callbackData,
1917    GDIPCONST GpImageAttributes *     imageAttributes
1918    );
1919
1920GpStatus WINGDIPAPI
1921GdipEnumerateMetafileDestPointI(
1922    GpGraphics *            graphics,
1923    GDIPCONST GpMetafile *  metafile,
1924    GDIPCONST Point &       destPoint,
1925    EnumerateMetafileProc   callback,
1926    VOID *                  callbackData,
1927    GDIPCONST GpImageAttributes *     imageAttributes
1928    );
1929
1930GpStatus WINGDIPAPI
1931GdipEnumerateMetafileDestRect(
1932    GpGraphics *            graphics,
1933    GDIPCONST GpMetafile *  metafile,
1934    GDIPCONST RectF &       destRect,
1935    EnumerateMetafileProc   callback,
1936    VOID *                  callbackData,
1937    GDIPCONST GpImageAttributes *     imageAttributes
1938    );
1939
1940GpStatus WINGDIPAPI
1941GdipEnumerateMetafileDestRectI(
1942    GpGraphics *            graphics,
1943    GDIPCONST GpMetafile *  metafile,
1944    GDIPCONST Rect &        destRect,
1945    EnumerateMetafileProc   callback,
1946    VOID *                  callbackData,
1947    GDIPCONST GpImageAttributes *     imageAttributes
1948    );
1949
1950GpStatus WINGDIPAPI
1951GdipEnumerateMetafileDestPoints(
1952    GpGraphics *            graphics,
1953    GDIPCONST GpMetafile *  metafile,
1954    GDIPCONST PointF *      destPoints,
1955    INT                     count,
1956    EnumerateMetafileProc   callback,
1957    VOID *                  callbackData,
1958    GDIPCONST GpImageAttributes *     imageAttributes
1959    );
1960
1961GpStatus WINGDIPAPI
1962GdipEnumerateMetafileDestPointsI(
1963    GpGraphics *            graphics,
1964    GDIPCONST GpMetafile *  metafile,
1965    GDIPCONST Point *       destPoints,
1966    INT                     count,
1967    EnumerateMetafileProc   callback,
1968    VOID *                  callbackData,
1969    GDIPCONST GpImageAttributes *     imageAttributes
1970    );
1971
1972GpStatus WINGDIPAPI
1973GdipEnumerateMetafileSrcRectDestPoint(
1974    GpGraphics *            graphics,
1975    GDIPCONST GpMetafile *  metafile,
1976    GDIPCONST PointF &      destPoint,
1977    GDIPCONST RectF &       srcRect,
1978    Unit                    srcUnit,
1979    EnumerateMetafileProc   callback,
1980    VOID *                  callbackData,
1981    GDIPCONST GpImageAttributes *     imageAttributes
1982    );
1983
1984GpStatus WINGDIPAPI
1985GdipEnumerateMetafileSrcRectDestPointI(
1986    GpGraphics *            graphics,
1987    GDIPCONST GpMetafile *  metafile,
1988    GDIPCONST Point &       destPoint,
1989    GDIPCONST Rect &        srcRect,
1990    Unit                    srcUnit,
1991    EnumerateMetafileProc   callback,
1992    VOID *                  callbackData,
1993    GDIPCONST GpImageAttributes *     imageAttributes
1994    );
1995
1996GpStatus WINGDIPAPI
1997GdipEnumerateMetafileSrcRectDestRect(
1998    GpGraphics *            graphics,
1999    GDIPCONST GpMetafile *  metafile,
2000    GDIPCONST RectF &       destRect,
2001    GDIPCONST RectF &       srcRect,
2002    Unit                    srcUnit,
2003    EnumerateMetafileProc   callback,
2004    VOID *                  callbackData,
2005    GDIPCONST GpImageAttributes *     imageAttributes
2006    );
2007
2008GpStatus WINGDIPAPI
2009GdipEnumerateMetafileSrcRectDestRectI(
2010    GpGraphics *            graphics,
2011    GDIPCONST GpMetafile *  metafile,
2012    GDIPCONST Rect &        destRect,
2013    GDIPCONST Rect &        srcRect,
2014    Unit                    srcUnit,
2015    EnumerateMetafileProc   callback,
2016    VOID *                  callbackData,
2017    GDIPCONST GpImageAttributes *     imageAttributes
2018    );
2019
2020GpStatus WINGDIPAPI
2021GdipEnumerateMetafileSrcRectDestPoints(
2022    GpGraphics *            graphics,
2023    GDIPCONST GpMetafile *  metafile,
2024    GDIPCONST PointF *      destPoints,
2025    INT                     count,
2026    GDIPCONST RectF &       srcRect,
2027    Unit                    srcUnit,
2028    EnumerateMetafileProc   callback,
2029    VOID *                  callbackData,
2030    GDIPCONST GpImageAttributes *     imageAttributes
2031    );
2032
2033GpStatus WINGDIPAPI
2034GdipEnumerateMetafileSrcRectDestPointsI(
2035    GpGraphics *            graphics,
2036    GDIPCONST GpMetafile *  metafile,
2037    GDIPCONST Point *       destPoints,
2038    INT                     count,
2039    GDIPCONST Rect &        srcRect,
2040    Unit                    srcUnit,
2041    EnumerateMetafileProc   callback,
2042    VOID *                  callbackData,
2043    GDIPCONST GpImageAttributes *     imageAttributes
2044    );
2045
2046GpStatus WINGDIPAPI
2047GdipPlayMetafileRecord(
2048    GDIPCONST GpMetafile *  metafile,
2049    EmfPlusRecordType       recordType,
2050    UINT                    flags,
2051    UINT                    dataSize,
2052    GDIPCONST BYTE *        data
2053    );
2054
2055GpStatus WINGDIPAPI
2056GdipSetClipGraphics(GpGraphics *graphics, GpGraphics *srcgraphics,
2057                    CombineMode combineMode);
2058
2059GpStatus WINGDIPAPI
2060GdipSetClipRect(GpGraphics *graphics, REAL x, REAL y,
2061                         REAL width, REAL height, CombineMode combineMode);
2062
2063GpStatus WINGDIPAPI
2064GdipSetClipRectI(GpGraphics *graphics, INT x, INT y,
2065                         INT width, INT height, CombineMode combineMode);
2066
2067GpStatus WINGDIPAPI
2068GdipSetClipPath(GpGraphics *graphics, GpPath *path, CombineMode combineMode);
2069
2070GpStatus WINGDIPAPI
2071GdipSetClipRegion(GpGraphics *graphics, GpRegion *region,
2072                  CombineMode combineMode);
2073
2074GpStatus WINGDIPAPI
2075GdipSetClipHrgn(GpGraphics *graphics, HRGN hRgn, CombineMode combineMode);
2076
2077GpStatus WINGDIPAPI
2078GdipResetClip(GpGraphics *graphics);
2079
2080GpStatus WINGDIPAPI
2081GdipTranslateClip(GpGraphics *graphics, REAL dx, REAL dy);
2082
2083GpStatus WINGDIPAPI
2084GdipTranslateClipI(GpGraphics *graphics, INT dx, INT dy);
2085
2086GpStatus WINGDIPAPI
2087GdipGetClip(GpGraphics *graphics, GpRegion *region);
2088
2089GpStatus WINGDIPAPI
2090GdipGetClipBounds(GpGraphics *graphics, GpRectF *rect);
2091
2092GpStatus WINGDIPAPI
2093GdipGetClipBoundsI(GpGraphics *graphics, GpRect *rect);
2094
2095GpStatus WINGDIPAPI
2096GdipIsClipEmpty(GpGraphics *graphics, BOOL *result);
2097
2098GpStatus WINGDIPAPI
2099GdipGetVisibleClipBounds(GpGraphics *graphics, GpRectF *rect);
2100
2101GpStatus WINGDIPAPI
2102GdipGetVisibleClipBoundsI(GpGraphics *graphics, GpRect *rect);
2103
2104GpStatus WINGDIPAPI
2105GdipIsVisibleClipEmpty(GpGraphics *graphics, BOOL *result);
2106
2107GpStatus WINGDIPAPI
2108GdipIsVisiblePoint(GpGraphics *graphics, REAL x, REAL y,
2109                           BOOL *result);
2110
2111GpStatus WINGDIPAPI
2112GdipIsVisiblePointI(GpGraphics *graphics, INT x, INT y,
2113                           BOOL *result);
2114
2115GpStatus WINGDIPAPI
2116GdipIsVisibleRect(GpGraphics *graphics, REAL x, REAL y,
2117                           REAL width, REAL height, BOOL *result);
2118
2119GpStatus WINGDIPAPI
2120GdipIsVisibleRectI(GpGraphics *graphics, INT x, INT y,
2121                           INT width, INT height, BOOL *result);
2122
2123GpStatus WINGDIPAPI
2124GdipSaveGraphics(GpGraphics *graphics, GraphicsState *state);
2125
2126GpStatus WINGDIPAPI
2127GdipRestoreGraphics(GpGraphics *graphics, GraphicsState state);
2128
2129GpStatus WINGDIPAPI
2130GdipBeginContainer(GpGraphics *graphics, GDIPCONST GpRectF* dstrect,
2131                   GDIPCONST GpRectF *srcrect, GpUnit unit, GraphicsContainer *state);
2132
2133GpStatus WINGDIPAPI
2134GdipBeginContainerI(GpGraphics *graphics, GDIPCONST GpRect* dstrect,
2135                    GDIPCONST GpRect *srcrect, GpUnit unit, GraphicsContainer *state);
2136
2137GpStatus WINGDIPAPI
2138GdipBeginContainer2(GpGraphics *graphics, GraphicsContainer* state);
2139
2140GpStatus WINGDIPAPI
2141GdipEndContainer(GpGraphics *graphics, GraphicsContainer state);
2142
2143GpStatus
2144GdipGetMetafileHeaderFromWmf(
2145    HMETAFILE           hWmf,
2146    GDIPCONST APMFileHeader *     apmFileHeader,
2147    MetafileHeader *    header
2148    );
2149
2150GpStatus
2151WINGDIPAPI
2152GdipGetMetafileHeaderFromEmf(
2153    HENHMETAFILE        hEmf,
2154    MetafileHeader *    header
2155    );
2156
2157GpStatus
2158WINGDIPAPI
2159GdipGetMetafileHeaderFromFile(
2160    GDIPCONST WCHAR*        filename,
2161    MetafileHeader *    header
2162    );
2163
2164GpStatus
2165WINGDIPAPI
2166GdipGetMetafileHeaderFromStream(
2167    IStream *           stream,
2168    MetafileHeader *    header
2169    );
2170
2171GpStatus
2172WINGDIPAPI
2173GdipGetMetafileHeaderFromMetafile(
2174    GpMetafile *        metafile,
2175    MetafileHeader *    header
2176    );
2177
2178GpStatus
2179WINGDIPAPI
2180GdipGetHemfFromMetafile(
2181    GpMetafile *        metafile,
2182    HENHMETAFILE *      hEmf
2183    );
2184
2185GpStatus WINGDIPAPI
2186GdipCreateStreamOnFile(GDIPCONST WCHAR * filename, UINT access, IStream **stream);
2187
2188GpStatus WINGDIPAPI
2189GdipCreateMetafileFromWmf(HMETAFILE hWmf, BOOL deleteWmf,
2190                          GDIPCONST APMFileHeader * apmFileHeader, GpMetafile **metafile);
2191
2192GpStatus WINGDIPAPI
2193GdipCreateMetafileFromEmf(HENHMETAFILE hEmf, BOOL deleteEmf,
2194                          GpMetafile **metafile);
2195
2196GpStatus WINGDIPAPI
2197GdipCreateMetafileFromFile(GDIPCONST WCHAR* file, GpMetafile **metafile);
2198
2199GpStatus WINGDIPAPI
2200GdipCreateMetafileFromWmfFile(GDIPCONST WCHAR* file, GDIPCONST APMFileHeader * apmFileHeader, GpMetafile **metafile);
2201
2202GpStatus WINGDIPAPI
2203GdipCreateMetafileFromStream(IStream * stream, GpMetafile **metafile);
2204
2205GpStatus WINGDIPAPI
2206GdipRecordMetafile(
2207    HDC                 referenceHdc,
2208    EmfType             type,
2209    GDIPCONST GpRectF * frameRect,
2210    MetafileFrameUnit   frameUnit,
2211    GDIPCONST WCHAR *   description,
2212    GpMetafile **       metafile
2213    );
2214
2215GpStatus WINGDIPAPI
2216GdipRecordMetafileI(
2217    HDC                 referenceHdc,
2218    EmfType             type,
2219    GDIPCONST GpRect *  frameRect,
2220    MetafileFrameUnit   frameUnit,
2221    GDIPCONST WCHAR *   description,
2222    GpMetafile **       metafile
2223    );
2224
2225GpStatus WINGDIPAPI
2226GdipRecordMetafileFileName(
2227    GDIPCONST WCHAR*    fileName,
2228    HDC                 referenceHdc,
2229    EmfType             type,
2230    GDIPCONST GpRectF * frameRect,
2231    MetafileFrameUnit   frameUnit,
2232    GDIPCONST WCHAR *   description,
2233    GpMetafile **       metafile
2234    );
2235
2236GpStatus WINGDIPAPI
2237GdipRecordMetafileFileNameI(
2238    GDIPCONST WCHAR*    fileName,
2239    HDC                 referenceHdc,
2240    EmfType             type,
2241    GDIPCONST GpRect *  frameRect,
2242    MetafileFrameUnit   frameUnit,
2243    GDIPCONST WCHAR *   description,
2244    GpMetafile **       metafile
2245    );
2246
2247GpStatus WINGDIPAPI
2248GdipRecordMetafileStream(
2249    IStream *           stream,
2250    HDC                 referenceHdc,
2251    EmfType             type,
2252    GDIPCONST GpRectF * frameRect,
2253    MetafileFrameUnit   frameUnit,
2254    GDIPCONST WCHAR *   description,
2255    GpMetafile **       metafile
2256    );
2257
2258GpStatus WINGDIPAPI
2259GdipRecordMetafileStreamI(
2260    IStream *           stream,
2261    HDC                 referenceHdc,
2262    EmfType             type,
2263    GDIPCONST GpRect *  frameRect,
2264    MetafileFrameUnit   frameUnit,
2265    GDIPCONST WCHAR *   description,
2266    GpMetafile **       metafile
2267    );
2268
2269GpStatus WINGDIPAPI
2270GdipSetMetafileDownLevelRasterizationLimit(
2271    GpMetafile *            metafile,
2272    UINT                    metafileRasterizationLimitDpi
2273    );
2274
2275GpStatus WINGDIPAPI
2276GdipGetMetafileDownLevelRasterizationLimit(
2277    GDIPCONST GpMetafile *  metafile,
2278    UINT *                  metafileRasterizationLimitDpi
2279    );
2280
2281GpStatus WINGDIPAPI
2282GdipGetImageDecodersSize(UINT *numDecoders, UINT *size);
2283
2284GpStatus WINGDIPAPI
2285GdipGetImageDecoders(UINT numDecoders,
2286                     UINT size,
2287                     ImageCodecInfo *decoders);
2288
2289GpStatus WINGDIPAPI
2290GdipGetImageEncodersSize(UINT *numEncoders, UINT *size);
2291
2292GpStatus WINGDIPAPI
2293GdipGetImageEncoders(UINT numEncoders,
2294                     UINT size,
2295                     ImageCodecInfo *encoders);
2296
2297GpStatus WINGDIPAPI
2298GdipAddImageCodec(GDIPCONST ImageCodecInfo *codec);
2299
2300GpStatus WINGDIPAPI
2301GdipRemoveImageCodec(GDIPCONST ImageCodecInfo *codec);
2302
2303#ifndef DCR_USE_NEW_186091
2304GpStatus WINGDIPAPI
2305GdipGetGraphicsPixel(GpGraphics* graphics, REAL x, REAL y, ARGB* argb);
2306#endif
2307
2308GpStatus WINGDIPAPI
2309GdipComment(GpGraphics* graphics, UINT sizeData, GDIPCONST BYTE * data);
2310
2311GpStatus WINGDIPAPI
2312GdipGetGraphicsLayout(GpGraphics* graphics, GraphicsLayout* layout);
2313
2314GpStatus WINGDIPAPI
2315GdipSetGraphicsLayout(GpGraphics* graphics, GDIPCONST GraphicsLayout layout);
2316
2317//----------------------------------------------------------------------------
2318// FontFamily
2319//----------------------------------------------------------------------------
2320
2321GpStatus WINGDIPAPI
2322GdipCreateFontFamilyFromName(GDIPCONST WCHAR *name,
2323                             GpFontCollection *fontCollection,
2324                             GpFontFamily **FontFamily);
2325
2326GpStatus WINGDIPAPI
2327GdipDeleteFontFamily(GpFontFamily *FontFamily);
2328
2329GpStatus WINGDIPAPI
2330GdipCloneFontFamily(GpFontFamily *FontFamily, GpFontFamily **clonedFontFamily);
2331
2332GpStatus WINGDIPAPI
2333GdipGetGenericFontFamilySansSerif(GpFontFamily **nativeFamily);
2334
2335GpStatus WINGDIPAPI
2336GdipGetGenericFontFamilySerif(GpFontFamily **nativeFamily);
2337
2338GpStatus WINGDIPAPI
2339GdipGetGenericFontFamilyMonospace(GpFontFamily **nativeFamily);
2340
2341
2342GpStatus WINGDIPAPI
2343GdipGetFamilyName(
2344    GDIPCONST GpFontFamily  *family,
2345    WCHAR                name[LF_FACESIZE],
2346    LANGID               language
2347);
2348
2349GpStatus   WINGDIPAPI
2350GdipIsStyleAvailable(GDIPCONST GpFontFamily *family, INT style, BOOL * IsStyleAvailable);
2351
2352GpStatus WINGDIPAPI
2353GdipFontCollectionEnumerable(
2354    GpFontCollection* fontCollection,
2355    GpGraphics* graphics,
2356    INT *       numFound
2357);
2358
2359GpStatus WINGDIPAPI GdipFontCollectionEnumerate(
2360    GpFontCollection* fontCollection,
2361    INT             numSought,
2362    GpFontFamily*   gpfamilies[],
2363    INT*            numFound,
2364    GpGraphics*     graphics
2365);
2366
2367//-----------------------------------
2368// New API
2369//-----------------------------------
2370
2371GpStatus WINGDIPAPI
2372GdipGetEmHeight(GDIPCONST GpFontFamily *family, INT style, UINT16 * EmHeight);
2373
2374GpStatus WINGDIPAPI
2375GdipGetCellAscent(GDIPCONST GpFontFamily *family, INT style, UINT16 * CellAscent);
2376
2377GpStatus WINGDIPAPI
2378GdipGetCellDescent(GDIPCONST GpFontFamily *family, INT style, UINT16 * CellDescent);
2379
2380GpStatus WINGDIPAPI
2381GdipGetLineSpacing(GDIPCONST GpFontFamily *family, INT style, UINT16 * LineSpacing);
2382
2383
2384//----------------------------------------------------------------------------
2385// Font
2386//----------------------------------------------------------------------------
2387
2388GpStatus WINGDIPAPI
2389GdipCreateFontFromDC(
2390    HDC        hdc,
2391    GpFont   **font
2392);
2393
2394GpStatus WINGDIPAPI
2395GdipCreateFontFromLogfontA(
2396    HDC        hdc,
2397    GDIPCONST LOGFONTA  *logfont,
2398    GpFont   **font
2399);
2400
2401GpStatus WINGDIPAPI
2402GdipCreateFontFromLogfontW(
2403    HDC        hdc,
2404    GDIPCONST LOGFONTW  *logfont,
2405    GpFont   **font
2406);
2407
2408GpStatus WINGDIPAPI
2409GdipCreateFont(
2410    GDIPCONST GpFontFamily  *fontFamily,
2411    REAL                 emSize,
2412    INT                  style,
2413    Unit                 unit,
2414    GpFont             **font
2415);
2416
2417GpStatus WINGDIPAPI
2418GdipCloneFont(GpFont* font, GpFont** cloneFont);
2419
2420GpStatus WINGDIPAPI
2421GdipDeleteFont(GpFont* font);
2422
2423GpStatus WINGDIPAPI
2424GdipGetFamily(GpFont *font, GpFontFamily **family);
2425
2426GpStatus WINGDIPAPI
2427GdipGetFontStyle(GpFont *font, INT *style);
2428
2429GpStatus WINGDIPAPI
2430GdipGetFontSize(GpFont *font, REAL *size);
2431
2432GpStatus WINGDIPAPI
2433GdipGetFontUnit(GpFont *font, Unit *unit);
2434
2435GpStatus WINGDIPAPI
2436GdipGetFontHeight(GDIPCONST GpFont *font, GDIPCONST GpGraphics *graphics, REAL *height);
2437
2438#ifdef DCR_USE_NEW_125467
2439GpStatus WINGDIPAPI
2440GdipGetFontHeightGivenDPI(GDIPCONST GpFont *font, REAL dpi, REAL *height);
2441#endif
2442
2443GpStatus WINGDIPAPI
2444GdipGetLogFontA(GpFont * font, GpGraphics *graphics, LOGFONTA * logfontA);
2445
2446GpStatus WINGDIPAPI
2447GdipGetLogFontW(GpFont * font, GpGraphics *graphics, LOGFONTW * logfontW);
2448
2449// FontCollection
2450
2451GpStatus WINGDIPAPI
2452GdipNewInstalledFontCollection(GpFontCollection** fontCollection);
2453
2454GpStatus WINGDIPAPI
2455GdipNewPrivateFontCollection(GpFontCollection** fontCollection);
2456
2457GpStatus WINGDIPAPI
2458GdipDeletePrivateFontCollection(GpFontCollection** fontCollection);
2459
2460GpStatus WINGDIPAPI
2461GdipGetFontCollectionFamilyCount(
2462    GpFontCollection* fontCollection,
2463    INT *       numFound
2464);
2465
2466GpStatus WINGDIPAPI
2467GdipGetFontCollectionFamilyList(
2468    GpFontCollection* fontCollection,
2469    INT             numSought,
2470    GpFontFamily*   gpfamilies[],
2471    INT*            numFound
2472);
2473
2474#ifndef DCR_USE_NEW_235072
2475GpStatus WINGDIPAPI
2476GdipInstallFontFile(
2477    GpFontCollection* fontCollection,
2478    GDIPCONST WCHAR* filename
2479);
2480
2481GpStatus WINGDIPAPI
2482GdipUninstallFontFile(
2483    GpFontCollection* fontCollection,
2484    GDIPCONST WCHAR* filename
2485);
2486#endif
2487
2488GpStatus WINGDIPAPI
2489GdipPrivateAddFontFile(
2490    GpFontCollection* fontCollection,
2491    GDIPCONST WCHAR* filename
2492);
2493
2494GpStatus WINGDIPAPI
2495GdipPrivateAddMemoryFont(
2496    GpFontCollection* fontCollection,
2497    GDIPCONST void* memory,
2498    INT length
2499);
2500
2501//----------------------------------------------------------------------------
2502// Text
2503//----------------------------------------------------------------------------
2504
2505GpStatus WINGDIPAPI
2506GdipDrawString(
2507    GpGraphics               *graphics,
2508    GDIPCONST WCHAR          *string,
2509    INT                       length,
2510    GDIPCONST GpFont         *font,
2511    GDIPCONST RectF          *layoutRect,
2512    GDIPCONST GpStringFormat *stringFormat,
2513    GDIPCONST GpBrush        *brush
2514);
2515
2516GpStatus WINGDIPAPI
2517GdipMeasureString(
2518    GpGraphics               *graphics,
2519    GDIPCONST WCHAR          *string,
2520    INT                       length,
2521    GDIPCONST GpFont         *font,
2522    GDIPCONST RectF          *layoutRect,
2523    GDIPCONST GpStringFormat *stringFormat,
2524    RectF                    *boundingBox,
2525    INT                      *codepointsFitted,
2526    INT                      *linesFilled
2527);
2528
2529#ifndef DCR_USE_NEW_174340
2530GpStatus WINGDIPAPI
2531GdipMeasureStringRegion(
2532    GpGraphics               *graphics,
2533    GDIPCONST WCHAR          *string,
2534    INT                       length,
2535    GDIPCONST GpFont         *font,
2536    GDIPCONST RectF          &layoutRect,
2537    GDIPCONST GpStringFormat *stringFormat,
2538    INT                       firstCharacterIndex,
2539    INT                       characterCount,
2540    GpRegion                 *region
2541);
2542#endif
2543
2544#ifdef DCR_USE_NEW_174340
2545GpStatus
2546WINGDIPAPI
2547GdipMeasureCharacterRanges(
2548    GpGraphics               *graphics,
2549    GDIPCONST WCHAR          *string,
2550    INT                       length,
2551    GDIPCONST GpFont         *font,
2552    GDIPCONST RectF          &layoutRect,
2553    GDIPCONST GpStringFormat *stringFormat,
2554    INT                       regionCount,
2555    GpRegion                **regions
2556);
2557#endif
2558
2559GpStatus WINGDIPAPI
2560GdipDrawDriverString(
2561    GpGraphics *graphics,
2562    GDIPCONST UINT16 *text,
2563    INT length,
2564    GDIPCONST GpFont *font,
2565    GDIPCONST GpBrush *brush,
2566    GDIPCONST PointF *positions,
2567    INT flags,
2568    GDIPCONST GpMatrix *matrix
2569);
2570
2571GpStatus WINGDIPAPI
2572GdipMeasureDriverString(
2573    GpGraphics *graphics,
2574    GDIPCONST UINT16 *text,
2575    INT length,
2576    GDIPCONST GpFont *font,
2577    GDIPCONST PointF *positions,
2578    INT flags,
2579    GDIPCONST GpMatrix *matrix,
2580    RectF *boundingBox
2581);
2582
2583#ifndef DCR_USE_NEW_168772
2584GpStatus WINGDIPAPI
2585GdipDriverStringPointToCodepoint(
2586    GpGraphics *graphics,
2587    GDIPCONST UINT16 *text,
2588    INT length,
2589    GDIPCONST GpFont *font,
2590    GDIPCONST PointF *positions,
2591    INT flags,
2592    GpMatrix *matrix,
2593    GDIPCONST PointF *hit,
2594    INT *index,
2595    BOOL *rightEdge,
2596    REAL *distance
2597);
2598#endif
2599
2600//----------------------------------------------------------------------------
2601// String format APIs
2602//----------------------------------------------------------------------------
2603
2604GpStatus WINGDIPAPI
2605GdipCreateStringFormat(
2606    INT               formatAttributes,
2607    LANGID            language,
2608    GpStringFormat  **format
2609);
2610
2611GpStatus WINGDIPAPI
2612GdipStringFormatGetGenericDefault(GpStringFormat **format);
2613
2614GpStatus WINGDIPAPI
2615GdipStringFormatGetGenericTypographic(GpStringFormat **format);
2616
2617GpStatus WINGDIPAPI
2618GdipDeleteStringFormat(GpStringFormat *format);
2619
2620GpStatus WINGDIPAPI
2621GdipCloneStringFormat(GDIPCONST GpStringFormat *format, GpStringFormat **newFormat);
2622
2623GpStatus WINGDIPAPI
2624GdipSetStringFormatFlags(GpStringFormat *format, INT flags);
2625
2626GpStatus WINGDIPAPI GdipGetStringFormatFlags(GDIPCONST GpStringFormat *format, INT *flags);
2627
2628#ifndef DCR_USE_NEW_152154
2629GpStatus WINGDIPAPI
2630GdipSetStringFormatLineSpacing(GpStringFormat *format, REAL amount,
2631                               LineSpacing method);
2632
2633GpStatus WINGDIPAPI
2634GdipGetStringFormatLineSpacingAmount(GDIPCONST GpStringFormat *format, REAL *amount);
2635GpStatus WINGDIPAPI
2636GdipGetStringFormatLineSpacingMethod(GDIPCONST GpStringFormat *format, LineSpacing *method);
2637#endif
2638
2639GpStatus WINGDIPAPI
2640GdipSetStringFormatAlign(GpStringFormat *format, StringAlignment align);
2641
2642GpStatus WINGDIPAPI
2643GdipGetStringFormatAlign(GDIPCONST GpStringFormat *format, StringAlignment *align);
2644
2645GpStatus WINGDIPAPI
2646GdipSetStringFormatLineAlign(GpStringFormat *format,
2647                             StringAlignment align);
2648
2649GpStatus WINGDIPAPI
2650GdipGetStringFormatLineAlign(GDIPCONST GpStringFormat *format,
2651                             StringAlignment *align);
2652
2653GpStatus WINGDIPAPI
2654GdipSetStringFormatTrimming(
2655    GpStringFormat  *format,
2656    StringTrimming   trimming
2657);
2658
2659GpStatus WINGDIPAPI
2660GdipGetStringFormatTrimming(
2661    GDIPCONST GpStringFormat *format,
2662    StringTrimming       *trimming
2663);
2664
2665GpStatus WINGDIPAPI
2666GdipSetStringFormatHotkeyPrefix(GpStringFormat *format, INT hotkeyPrefix);
2667
2668GpStatus WINGDIPAPI
2669GdipGetStringFormatHotkeyPrefix(GDIPCONST GpStringFormat *format, INT *hotkeyPrefix);
2670
2671GpStatus WINGDIPAPI
2672GdipSetStringFormatTabStops(GpStringFormat *format, REAL firstTabOffset, INT count, GDIPCONST REAL *tabStops);
2673
2674GpStatus WINGDIPAPI
2675GdipGetStringFormatTabStops(GDIPCONST GpStringFormat *format, INT count, REAL *firstTabOffset, REAL *tabStops);
2676
2677GpStatus WINGDIPAPI
2678GdipGetStringFormatTabStopCount(GDIPCONST GpStringFormat *format, INT * count);
2679
2680#ifdef DCR_USE_NEW_146933
2681GpStatus WINGDIPAPI
2682GdipSetStringFormatDigitSubstitution(GpStringFormat *format, LANGID language,
2683                                     StringDigitSubstitute substitute);
2684
2685GpStatus WINGDIPAPI
2686GdipGetStringFormatDigitSubstitution(GDIPCONST GpStringFormat *format, LANGID *language,
2687                                     StringDigitSubstitute *substitute);
2688#endif // DCR_USE_NEW_146933
2689
2690#ifdef DCR_USE_NEW_174340
2691GpStatus WINGDIPAPI
2692GdipGetStringFormatMeasurableCharacterRangeCount(
2693    GDIPCONST GpStringFormat    *format,
2694    INT                         *count
2695);
2696
2697GpStatus WINGDIPAPI
2698GdipSetStringFormatMeasurableCharacterRanges(
2699    GpStringFormat              *format,
2700    INT                         rangeCount,
2701    GDIPCONST CharacterRange    *ranges
2702);
2703#endif
2704
2705//----------------------------------------------------------------------------
2706// Cached Bitmap APIs
2707//----------------------------------------------------------------------------
2708
2709GpStatus WINGDIPAPI
2710GdipCreateCachedBitmap(
2711    GpBitmap *bitmap,
2712    GpGraphics *graphics,
2713    GpCachedBitmap **cachedBitmap
2714);
2715
2716GpStatus WINGDIPAPI
2717GdipDeleteCachedBitmap(GpCachedBitmap *cachedBitmap);
2718
2719GpStatus WINGDIPAPI
2720GdipDrawCachedBitmap(
2721    GpGraphics *graphics,
2722    GpCachedBitmap *cachedBitmap,
2723    INT x,
2724    INT y
2725);
2726
2727UINT WINGDIPAPI
2728GdipEmfToWmfBits(
2729    HENHMETAFILE hemf,
2730    UINT         cbData16,
2731    LPBYTE       pData16,
2732    INT          iMapMode,
2733    INT          eFlags
2734);
2735
2736#ifdef __cplusplus
2737}
2738#endif
2739
2740#endif // !_FLATAPI_H
Note: See TracBrowser for help on using the repository browser.