Embed:
(wiki syntax)
Show/hide line numbers
gdipluspath.h
00001 /* 00002 * gdipluspath.h 00003 * 00004 * GDI+ GraphicsPath class 00005 * 00006 * This file is part of the w32api package. 00007 * 00008 * Contributors: 00009 * Created by Markus Koenig <markus@stber-koenig.de> 00010 * 00011 * THIS SOFTWARE IS NOT COPYRIGHTED 00012 * 00013 * This source code is offered for use in the public domain. You may 00014 * use, modify or distribute it freely. 00015 * 00016 * This code is distributed in the hope that it will be useful but 00017 * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY 00018 * DISCLAIMED. This includes but is not limited to warranties of 00019 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 00020 * 00021 */ 00022 00023 #ifndef __GDIPLUS_PATH_H 00024 #define __GDIPLUS_PATH_H 00025 #if __GNUC__ >=3 00026 #pragma GCC system_header 00027 #endif 00028 00029 #ifndef __cplusplus 00030 #error "A C++ compiler is required to include gdipluspath.h." 00031 #endif 00032 00033 // Note that some methods of GraphicsPath are implemented in gdiplusimpl.h. 00034 // This avoids a cyclic dependency on Graphics and Pen. 00035 00036 class GraphicsPath: public GdiplusBase 00037 { 00038 friend class CustomLineCap; 00039 friend class Graphics; 00040 friend class GraphicsPathIterator; 00041 friend class PathGradientBrush; 00042 friend class Region; 00043 00044 public: 00045 GraphicsPath(FillMode fillMode = FillModeAlternate): 00046 nativePath(NULL), lastStatus(Ok) 00047 { 00048 lastStatus = DllExports::GdipCreatePath(fillMode, &nativePath); 00049 } 00050 GraphicsPath(const PointF *points, const BYTE *types, INT count, 00051 FillMode fillMode = FillModeAlternate): 00052 nativePath(NULL), lastStatus(Ok) 00053 { 00054 lastStatus = DllExports::GdipCreatePath2( 00055 points, types, count, fillMode, &nativePath); 00056 } 00057 GraphicsPath(const Point *points, const BYTE *types, INT count, 00058 FillMode fillMode = FillModeAlternate): 00059 nativePath(NULL), lastStatus(Ok) 00060 { 00061 lastStatus = DllExports::GdipCreatePath2I( 00062 points, types, count, fillMode, &nativePath); 00063 } 00064 ~GraphicsPath() 00065 { 00066 DllExports::GdipDeletePath(nativePath); 00067 } 00068 GraphicsPath* Clone() const 00069 { 00070 GpPath *clonePath = NULL; 00071 Status status = updateStatus(DllExports::GdipClonePath( 00072 nativePath, &clonePath)); 00073 if (status == Ok) { 00074 GraphicsPath *result = new GraphicsPath(clonePath, lastStatus); 00075 if (!result) { 00076 DllExports::GdipDeletePath(clonePath); 00077 lastStatus = OutOfMemory; 00078 } 00079 return result; 00080 } else { 00081 return NULL; 00082 } 00083 } 00084 00085 Status AddArc(REAL x, REAL y, REAL width, REAL height, 00086 REAL startAngle, REAL sweepAngle) 00087 { 00088 return updateStatus(DllExports::GdipAddPathArc(nativePath, 00089 x, y, width, height, startAngle, sweepAngle)); 00090 } 00091 Status AddArc(INT x, INT y, INT width, INT height, 00092 REAL startAngle, REAL sweepAngle) 00093 { 00094 return updateStatus(DllExports::GdipAddPathArcI(nativePath, 00095 x, y, width, height, startAngle, sweepAngle)); 00096 } 00097 Status AddArc(const RectF& rect, REAL startAngle, REAL sweepAngle) 00098 { 00099 return updateStatus(DllExports::GdipAddPathArc(nativePath, 00100 rect.X, rect.Y, rect.Width, rect.Height, 00101 startAngle, sweepAngle)); 00102 } 00103 Status AddArc(const Rect& rect, REAL startAngle, REAL sweepAngle) 00104 { 00105 return updateStatus(DllExports::GdipAddPathArcI(nativePath, 00106 rect.X, rect.Y, rect.Width, rect.Height, 00107 startAngle, sweepAngle)); 00108 } 00109 Status AddBezier(REAL x1, REAL y1, REAL x2, REAL y2, 00110 REAL x3, REAL y3, REAL x4, REAL y4) 00111 { 00112 return updateStatus(DllExports::GdipAddPathBezier(nativePath, 00113 x1, y1, x2, y2, x3, y3, x4, y4)); 00114 } 00115 Status AddBezier(INT x1, INT y1, INT x2, INT y2, 00116 INT x3, INT y3, INT x4, INT y4) 00117 { 00118 return updateStatus(DllExports::GdipAddPathBezierI(nativePath, 00119 x1, y1, x2, y2, x3, y3, x4, y4)); 00120 } 00121 Status AddBezier(const PointF& pt1, const PointF& pt2, 00122 const PointF& pt3, const PointF& pt4) 00123 { 00124 return updateStatus(DllExports::GdipAddPathBezier(nativePath, 00125 pt1.X, pt1.Y, pt2.X, pt2.Y, 00126 pt3.X, pt3.Y, pt4.X, pt4.Y)); 00127 } 00128 Status AddBezier(const Point& pt1, const Point& pt2, 00129 const Point& pt3, const Point& pt4) 00130 { 00131 return updateStatus(DllExports::GdipAddPathBezierI(nativePath, 00132 pt1.X, pt1.Y, pt2.X, pt2.Y, 00133 pt3.X, pt3.Y, pt4.X, pt4.Y)); 00134 } 00135 Status AddBeziers(const PointF *points, INT count) 00136 { 00137 return updateStatus(DllExports::GdipAddPathBeziers( 00138 nativePath, points, count)); 00139 } 00140 Status AddBeziers(const Point *points, INT count) 00141 { 00142 return updateStatus(DllExports::GdipAddPathBeziersI( 00143 nativePath, points, count)); 00144 } 00145 Status AddClosedCurve(const PointF *points, INT count) 00146 { 00147 return updateStatus(DllExports::GdipAddPathClosedCurve( 00148 nativePath, points, count)); 00149 } 00150 Status AddClosedCurve(const Point *points, INT count) 00151 { 00152 return updateStatus(DllExports::GdipAddPathClosedCurveI( 00153 nativePath, points, count)); 00154 } 00155 Status AddClosedCurve(const PointF *points, INT count, REAL tension) 00156 { 00157 return updateStatus(DllExports::GdipAddPathClosedCurve2( 00158 nativePath, points, count, tension)); 00159 } 00160 Status AddClosedCurve(const Point *points, INT count, REAL tension) 00161 { 00162 return updateStatus(DllExports::GdipAddPathClosedCurve2I( 00163 nativePath, points, count, tension)); 00164 } 00165 Status AddCurve(const PointF *points, INT count) 00166 { 00167 return updateStatus(DllExports::GdipAddPathCurve( 00168 nativePath, points, count)); 00169 } 00170 Status AddCurve(const Point *points, INT count) 00171 { 00172 return updateStatus(DllExports::GdipAddPathCurveI( 00173 nativePath, points, count)); 00174 } 00175 Status AddCurve(const PointF *points, INT count, REAL tension) 00176 { 00177 return updateStatus(DllExports::GdipAddPathCurve2( 00178 nativePath, points, count, tension)); 00179 } 00180 Status AddCurve(const Point *points, INT count, REAL tension) 00181 { 00182 return updateStatus(DllExports::GdipAddPathCurve2I( 00183 nativePath, points, count, tension)); 00184 } 00185 Status AddCurve(const PointF *points, INT count, INT offset, 00186 INT numberOfSegments, REAL tension) 00187 { 00188 return updateStatus(DllExports::GdipAddPathCurve3( 00189 nativePath, points, count, 00190 offset, numberOfSegments, tension)); 00191 } 00192 Status AddCurve(const Point *points, INT count, INT offset, 00193 INT numberOfSegments, REAL tension) 00194 { 00195 return updateStatus(DllExports::GdipAddPathCurve3I( 00196 nativePath, points, count, 00197 offset, numberOfSegments, tension)); 00198 } 00199 Status AddEllipse(REAL x, REAL y, REAL width, REAL height) 00200 { 00201 return updateStatus(DllExports::GdipAddPathEllipse(nativePath, 00202 x, y, width, height)); 00203 } 00204 Status AddEllipse(INT x, INT y, INT width, INT height) 00205 { 00206 return updateStatus(DllExports::GdipAddPathEllipseI(nativePath, 00207 x, y, width, height)); 00208 } 00209 Status AddEllipse(const RectF& rect) 00210 { 00211 return updateStatus(DllExports::GdipAddPathEllipse(nativePath, 00212 rect.X, rect.Y, rect.Width, rect.Height)); 00213 } 00214 Status AddEllipse(const Rect& rect) 00215 { 00216 return updateStatus(DllExports::GdipAddPathEllipseI(nativePath, 00217 rect.X, rect.Y, rect.Width, rect.Height)); 00218 } 00219 Status AddLine(REAL x1, REAL y1, REAL x2, REAL y2) 00220 { 00221 return updateStatus(DllExports::GdipAddPathLine(nativePath, 00222 x1, y1, x2, y2)); 00223 } 00224 Status AddLine(INT x1, INT y1, INT x2, INT y2) 00225 { 00226 return updateStatus(DllExports::GdipAddPathLineI(nativePath, 00227 x1, y1, x2, y2)); 00228 } 00229 Status AddLine(const PointF& pt1, const PointF& pt2) 00230 { 00231 return updateStatus(DllExports::GdipAddPathLine(nativePath, 00232 pt1.X, pt1.Y, pt2.X, pt2.Y)); 00233 } 00234 Status AddLine(const Point& pt1, const Point& pt2) 00235 { 00236 return updateStatus(DllExports::GdipAddPathLineI(nativePath, 00237 pt1.X, pt1.Y, pt2.X, pt2.Y)); 00238 } 00239 Status AddLines(const PointF *points, INT count) 00240 { 00241 return updateStatus(DllExports::GdipAddPathLine2(nativePath, 00242 points, count)); 00243 } 00244 Status AddLines(const Point *points, INT count) 00245 { 00246 return updateStatus(DllExports::GdipAddPathLine2I(nativePath, 00247 points, count)); 00248 } 00249 Status AddPath(const GraphicsPath *addingPath, BOOL connect) 00250 { 00251 return updateStatus(DllExports::GdipAddPathPath(nativePath, 00252 addingPath ? addingPath->nativePath : NULL, 00253 connect)); 00254 } 00255 Status AddPie(REAL x, REAL y, REAL width, REAL height, 00256 REAL startAngle, REAL sweepAngle) 00257 { 00258 return updateStatus(DllExports::GdipAddPathPie(nativePath, 00259 x, y, width, height, startAngle, sweepAngle)); 00260 } 00261 Status AddPie(INT x, INT y, INT width, INT height, 00262 REAL startAngle, REAL sweepAngle) 00263 { 00264 return updateStatus(DllExports::GdipAddPathPieI(nativePath, 00265 x, y, width, height, startAngle, sweepAngle)); 00266 } 00267 Status AddPie(const RectF& rect, REAL startAngle, REAL sweepAngle) 00268 { 00269 return updateStatus(DllExports::GdipAddPathPie(nativePath, 00270 rect.X, rect.Y, rect.Width, rect.Height, 00271 startAngle, sweepAngle)); 00272 } 00273 Status AddPie(const Rect& rect, REAL startAngle, REAL sweepAngle) 00274 { 00275 return updateStatus(DllExports::GdipAddPathPieI(nativePath, 00276 rect.X, rect.Y, rect.Width, rect.Height, 00277 startAngle, sweepAngle)); 00278 } 00279 Status AddPolygon(const PointF *points, INT count) 00280 { 00281 return updateStatus(DllExports::GdipAddPathPolygon(nativePath, 00282 points, count)); 00283 } 00284 Status AddPolygon(const Point *points, INT count) 00285 { 00286 return updateStatus(DllExports::GdipAddPathPolygonI(nativePath, 00287 points, count)); 00288 } 00289 Status AddRectangle(const RectF& rect) 00290 { 00291 return updateStatus(DllExports::GdipAddPathRectangle(nativePath, 00292 rect.X, rect.Y, rect.Width, rect.Height)); 00293 } 00294 Status AddRectangle(const Rect& rect) 00295 { 00296 return updateStatus(DllExports::GdipAddPathRectangleI( 00297 nativePath, 00298 rect.X, rect.Y, rect.Width, rect.Height)); 00299 } 00300 Status AddRectangles(const RectF *rects, INT count) 00301 { 00302 return updateStatus(DllExports::GdipAddPathRectangles( 00303 nativePath, rects, count)); 00304 } 00305 Status AddRectangles(const Rect *rects, INT count) 00306 { 00307 return updateStatus(DllExports::GdipAddPathRectanglesI( 00308 nativePath, rects, count)); 00309 } 00310 Status AddString(const WCHAR *string, INT length, 00311 const FontFamily *family, INT style, REAL emSize, 00312 const PointF& origin, const StringFormat *format) 00313 { 00314 RectF layoutRect(origin, SizeF(0.0f, 0.0f)); 00315 return updateStatus(DllExports::GdipAddPathString(nativePath, 00316 string, length, 00317 family ? family->nativeFontFamily : NULL, 00318 style, emSize, &layoutRect, 00319 format ? format->nativeStringFormat : NULL)); 00320 } 00321 Status AddString(const WCHAR *string, INT length, 00322 const FontFamily *family, INT style, REAL emSize, 00323 const Point& origin, const StringFormat *format) 00324 { 00325 Rect layoutRect(origin, Size(0, 0)); 00326 return updateStatus(DllExports::GdipAddPathStringI(nativePath, 00327 string, length, 00328 family ? family->nativeFontFamily : NULL, 00329 style, emSize, &layoutRect, 00330 format ? format->nativeStringFormat : NULL)); 00331 } 00332 Status AddString(const WCHAR *string, INT length, 00333 const FontFamily *family, INT style, REAL emSize, 00334 const RectF& layoutRect, const StringFormat *format) 00335 { 00336 return updateStatus(DllExports::GdipAddPathString(nativePath, 00337 string, length, 00338 family ? family->nativeFontFamily : NULL, 00339 style, emSize, &layoutRect, 00340 format ? format->nativeStringFormat : NULL)); 00341 } 00342 Status AddString(const WCHAR *string, INT length, 00343 const FontFamily *family, INT style, REAL emSize, 00344 const Rect& layoutRect, const StringFormat *format) 00345 { 00346 return updateStatus(DllExports::GdipAddPathStringI(nativePath, 00347 string, length, 00348 family ? family->nativeFontFamily : NULL, 00349 style, emSize, &layoutRect, 00350 format ? format->nativeStringFormat : NULL)); 00351 } 00352 Status ClearMarkers() 00353 { 00354 return updateStatus(DllExports::GdipClearPathMarkers( 00355 nativePath)); 00356 } 00357 Status CloseAllFigures() 00358 { 00359 return updateStatus(DllExports::GdipClosePathFigures( 00360 nativePath)); 00361 } 00362 Status CloseFigure() 00363 { 00364 return updateStatus(DllExports::GdipClosePathFigure( 00365 nativePath)); 00366 } 00367 Status Flatten(const Matrix *matrix = NULL, 00368 REAL flatness = FlatnessDefault) 00369 { 00370 return updateStatus(DllExports::GdipFlattenPath(nativePath, 00371 matrix ? matrix->nativeMatrix : NULL, 00372 flatness)); 00373 } 00374 Status GetBounds(RectF *bounds, const Matrix *matrix = NULL, 00375 const Pen *pen = NULL) const 00376 { 00377 return updateStatus(DllExports::GdipGetPathWorldBounds( 00378 nativePath, bounds, 00379 matrix ? matrix->nativeMatrix : NULL, 00380 pen ? pen->nativePen : NULL)); 00381 } 00382 Status GetBounds(Rect *bounds, const Matrix *matrix = NULL, 00383 const Pen *pen = NULL) const 00384 { 00385 return updateStatus(DllExports::GdipGetPathWorldBoundsI( 00386 nativePath, bounds, 00387 matrix ? matrix->nativeMatrix : NULL, 00388 pen ? pen->nativePen : NULL)); 00389 } 00390 FillMode GetFillMode() const 00391 { 00392 FillMode result = FillModeAlternate; 00393 updateStatus(DllExports::GdipGetPathFillMode(nativePath, 00394 &result)); 00395 return result; 00396 } 00397 Status GetLastPoint(PointF *lastPoint) const 00398 { 00399 return updateStatus(DllExports::GdipGetPathLastPoint( 00400 nativePath, lastPoint)); 00401 } 00402 Status GetLastStatus() const 00403 { 00404 Status result = lastStatus; 00405 lastStatus = Ok; 00406 return result; 00407 } 00408 Status GetPathData(PathData *pathData) const 00409 { 00410 if (!pathData) return lastStatus = InvalidParameter; 00411 00412 Status status; 00413 INT count; 00414 00415 status = updateStatus(DllExports::GdipGetPointCount( 00416 nativePath, &count)); 00417 if (status != Ok) return status; 00418 00419 status = updateStatus(pathData->AllocateArrays(count)); 00420 if (status != Ok) return status; 00421 00422 return updateStatus(DllExports::GdipGetPathData( 00423 nativePath, (GpPathData*) pathData)); 00424 } 00425 Status GetPathPoints(PointF *points, INT count) const 00426 { 00427 return updateStatus(DllExports::GdipGetPathPoints(nativePath, 00428 points, count)); 00429 } 00430 Status GetPathPoints(Point *points, INT count) const 00431 { 00432 return updateStatus(DllExports::GdipGetPathPointsI(nativePath, 00433 points, count)); 00434 } 00435 Status GetPathTypes(BYTE *types, INT count) const 00436 { 00437 return updateStatus(DllExports::GdipGetPathTypes(nativePath, 00438 types, count)); 00439 } 00440 INT GetPointCount() const 00441 { 00442 INT result = 0; 00443 updateStatus(DllExports::GdipGetPointCount(nativePath, 00444 &result)); 00445 return result; 00446 } 00447 BOOL IsOutlineVisible(REAL x, REAL y, const Pen *pen, 00448 const Graphics *g = NULL) const; 00449 BOOL IsOutlineVisible(INT x, INT y, const Pen *pen, 00450 const Graphics *g = NULL) const; 00451 BOOL IsOutlineVisible(const PointF& point, const Pen *pen, 00452 const Graphics *g = NULL) const; 00453 BOOL IsOutlineVisible(const Point& point, const Pen *pen, 00454 const Graphics *g = NULL) const; 00455 BOOL IsVisible(REAL x, REAL y, const Graphics *g = NULL) const; 00456 BOOL IsVisible(INT x, INT y, const Graphics *g = NULL) const; 00457 BOOL IsVisible(const PointF& point, const Graphics *g = NULL) const; 00458 BOOL IsVisible(const Point& point, const Graphics *g = NULL) const; 00459 Status Outline(const Matrix *matrix = NULL, 00460 REAL flatness = FlatnessDefault) 00461 { 00462 return updateStatus(DllExports::GdipWindingModeOutline( 00463 nativePath, 00464 matrix ? matrix->nativeMatrix : NULL, 00465 flatness)); 00466 } 00467 Status Reset() 00468 { 00469 return updateStatus(DllExports::GdipResetPath(nativePath)); 00470 } 00471 Status Reverse() 00472 { 00473 return updateStatus(DllExports::GdipReversePath(nativePath)); 00474 } 00475 Status SetFillMode(FillMode fillMode) 00476 { 00477 return updateStatus(DllExports::GdipSetPathFillMode( 00478 nativePath, fillMode)); 00479 } 00480 Status SetMarker() 00481 { 00482 return updateStatus(DllExports::GdipSetPathMarker(nativePath)); 00483 } 00484 Status StartFigure() 00485 { 00486 return updateStatus(DllExports::GdipStartPathFigure( 00487 nativePath)); 00488 } 00489 Status Transform(const Matrix *matrix) 00490 { 00491 return updateStatus(DllExports::GdipTransformPath( 00492 nativePath, 00493 matrix ? matrix->nativeMatrix : NULL)); 00494 } 00495 Status Warp(const PointF *destPoints, INT count, const RectF& srcRect, 00496 const Matrix *matrix = NULL, 00497 WarpMode warpMode = WarpModePerspective, 00498 REAL flatness = FlatnessDefault) 00499 { 00500 return updateStatus(DllExports::GdipWarpPath(nativePath, 00501 matrix ? matrix->nativeMatrix : NULL, 00502 destPoints, count, 00503 srcRect.X, srcRect.Y, 00504 srcRect.Width, srcRect.Height, 00505 warpMode, flatness)); 00506 } 00507 Status Widen(const Pen *pen, const Matrix *matrix = NULL, 00508 REAL flatness = FlatnessDefault) 00509 { 00510 return updateStatus(DllExports::GdipWidenPath(nativePath, 00511 pen ? pen->nativePen : NULL, 00512 matrix ? matrix->nativeMatrix : NULL, 00513 flatness)); 00514 } 00515 00516 private: 00517 GraphicsPath(GpPath *path, Status status): 00518 nativePath(path), lastStatus(status) {} 00519 GraphicsPath(const GraphicsPath&); 00520 GraphicsPath& operator=(const GraphicsPath&); 00521 00522 Status updateStatus(Status newStatus) const 00523 { 00524 if (newStatus != Ok) lastStatus = newStatus; 00525 return newStatus; 00526 } 00527 00528 GpPath *nativePath; 00529 mutable Status lastStatus; 00530 }; 00531 00532 class GraphicsPathIterator: public GdiplusBase 00533 { 00534 public: 00535 GraphicsPathIterator(GraphicsPath *path): 00536 nativePathIterator(NULL), lastStatus(Ok) 00537 { 00538 lastStatus = DllExports::GdipCreatePathIter( 00539 &nativePathIterator, 00540 path ? path->nativePath : NULL); 00541 } 00542 ~GraphicsPathIterator() 00543 { 00544 DllExports::GdipDeletePathIter(nativePathIterator); 00545 } 00546 00547 INT CopyData(PointF *points, BYTE *types, INT startIndex, INT endIndex) 00548 { 00549 INT result = 0; 00550 updateStatus(DllExports::GdipPathIterCopyData( 00551 nativePathIterator, &result, 00552 points, types, startIndex, endIndex)); 00553 return result; 00554 } 00555 INT Enumerate(PointF *points, BYTE *types, INT count) 00556 { 00557 INT result = 0; 00558 updateStatus(DllExports::GdipPathIterEnumerate( 00559 nativePathIterator, &result, 00560 points, types, count)); 00561 return result; 00562 } 00563 INT GetCount() const 00564 { 00565 INT result = 0; 00566 updateStatus(DllExports::GdipPathIterGetCount( 00567 nativePathIterator, &result)); 00568 return result; 00569 } 00570 Status GetLastStatus() const 00571 { 00572 Status result = lastStatus; 00573 lastStatus = Ok; 00574 return result; 00575 } 00576 INT GetSubpathCount() const 00577 { 00578 INT result = 0; 00579 updateStatus(DllExports::GdipPathIterGetSubpathCount( 00580 nativePathIterator, &result)); 00581 return result; 00582 } 00583 BOOL HasCurve() const 00584 { 00585 BOOL result = FALSE; 00586 updateStatus(DllExports::GdipPathIterHasCurve( 00587 nativePathIterator, &result)); 00588 return result; 00589 } 00590 INT NextMarker(INT *startIndex, INT *endIndex) 00591 { 00592 INT result = 0; 00593 updateStatus(DllExports::GdipPathIterNextMarker( 00594 nativePathIterator, &result, 00595 startIndex, endIndex)); 00596 return result; 00597 } 00598 INT NextMarker(GraphicsPath *path) 00599 { 00600 INT result = 0; 00601 updateStatus(DllExports::GdipPathIterNextMarkerPath( 00602 nativePathIterator, &result, 00603 path ? path->nativePath : NULL)); 00604 return result; 00605 } 00606 INT NextPathType(BYTE *pathType, INT *startIndex, INT *endIndex) 00607 { 00608 INT result = 0; 00609 updateStatus(DllExports::GdipPathIterNextPathType( 00610 nativePathIterator, &result, 00611 pathType, startIndex, endIndex)); 00612 return result; 00613 } 00614 INT NextSubpath(INT *startIndex, INT *endIndex, BOOL *isClosed) 00615 { 00616 INT result = 0; 00617 updateStatus(DllExports::GdipPathIterNextSubpath( 00618 nativePathIterator, &result, 00619 startIndex, endIndex, isClosed)); 00620 return result; 00621 } 00622 INT NextSubpath(GraphicsPath *path, BOOL *isClosed) 00623 { 00624 INT result = 0; 00625 updateStatus(DllExports::GdipPathIterNextSubpathPath( 00626 nativePathIterator, &result, 00627 path ? path->nativePath : NULL, isClosed)); 00628 return result; 00629 } 00630 VOID Rewind() 00631 { 00632 updateStatus(DllExports::GdipPathIterRewind( 00633 nativePathIterator)); 00634 } 00635 00636 private: 00637 GraphicsPathIterator(GpPathIterator *pathIterator, Status status): 00638 nativePathIterator(pathIterator), lastStatus(status) {} 00639 GraphicsPathIterator(const GraphicsPathIterator&); 00640 GraphicsPathIterator& operator=(const GraphicsPathIterator&); 00641 00642 Status updateStatus(Status newStatus) const 00643 { 00644 if (newStatus != Ok) lastStatus = newStatus; 00645 return newStatus; 00646 } 00647 00648 GpPathIterator *nativePathIterator; 00649 mutable Status lastStatus; 00650 }; 00651 00652 class PathGradientBrush: public Brush 00653 { 00654 public: 00655 PathGradientBrush(const PointF *points, INT count, 00656 WrapMode wrapMode = WrapModeClamp) 00657 { 00658 GpPathGradient *nativePathGradient = NULL; 00659 lastStatus = DllExports::GdipCreatePathGradient( 00660 points, count, wrapMode, &nativePathGradient); 00661 nativeBrush = nativePathGradient; 00662 } 00663 PathGradientBrush(const Point *points, INT count, 00664 WrapMode wrapMode = WrapModeClamp) 00665 { 00666 GpPathGradient *nativePathGradient = NULL; 00667 lastStatus = DllExports::GdipCreatePathGradientI( 00668 points, count, wrapMode, &nativePathGradient); 00669 nativeBrush = nativePathGradient; 00670 } 00671 PathGradientBrush(const GraphicsPath *path) 00672 { 00673 GpPathGradient *nativePathGradient = NULL; 00674 lastStatus = DllExports::GdipCreatePathGradientFromPath( 00675 path ? path->nativePath : NULL, 00676 &nativePathGradient); 00677 nativeBrush = nativePathGradient; 00678 } 00679 virtual PathGradientBrush *Clone() const 00680 { 00681 GpBrush *cloneBrush = NULL; 00682 Status status = updateStatus(DllExports::GdipCloneBrush( 00683 nativeBrush, &cloneBrush)); 00684 if (status == Ok) { 00685 PathGradientBrush *result = 00686 new PathGradientBrush(cloneBrush, lastStatus); 00687 if (!result) { 00688 DllExports::GdipDeleteBrush(cloneBrush); 00689 updateStatus(OutOfMemory); 00690 } 00691 return result; 00692 } else { 00693 return NULL; 00694 } 00695 } 00696 00697 Status GetBlend(REAL *blendFactors, REAL *blendPositions, 00698 INT count) const 00699 { 00700 return updateStatus(DllExports::GdipGetPathGradientBlend( 00701 (GpPathGradient*) nativeBrush, 00702 blendFactors, blendPositions, count)); 00703 } 00704 INT GetBlendCount() const 00705 { 00706 INT result = 0; 00707 updateStatus(DllExports::GdipGetPathGradientBlendCount( 00708 (GpPathGradient*) nativeBrush, &result)); 00709 return result; 00710 } 00711 Status GetCenterColor(Color *color) const 00712 { 00713 return updateStatus(DllExports::GdipGetPathGradientCenterColor( 00714 (GpPathGradient*) nativeBrush, 00715 color ? &color->Value : NULL)); 00716 } 00717 Status GetCenterPoint(PointF *point) const 00718 { 00719 return updateStatus(DllExports::GdipGetPathGradientCenterPoint( 00720 (GpPathGradient*) nativeBrush, point)); 00721 } 00722 Status GetCenterPoint(Point *point) const 00723 { 00724 return updateStatus(DllExports::GdipGetPathGradientCenterPointI( 00725 (GpPathGradient*) nativeBrush, point)); 00726 } 00727 Status GetFocusScales(REAL *xScale, REAL *yScale) const 00728 { 00729 return updateStatus(DllExports::GdipGetPathGradientFocusScales( 00730 (GpPathGradient*) nativeBrush, xScale, yScale)); 00731 } 00732 BOOL GetGammaCorrection() const 00733 { 00734 BOOL result = FALSE; 00735 updateStatus(DllExports::GdipGetPathGradientGammaCorrection( 00736 (GpPathGradient*) nativeBrush, &result)); 00737 return result; 00738 } 00739 //Status GetGraphicsPath(GraphicsPath *path) const 00740 //{ 00741 // // TODO: implement PathGradientBrush::GetGraphicsPath 00742 // return updateStatus(NotImplemented); 00743 //} 00744 INT GetInterpolationColorCount() const 00745 { 00746 INT result = 0; 00747 updateStatus(DllExports::GdipGetPathGradientPresetBlendCount( 00748 (GpPathGradient*) nativeBrush, &result)); 00749 return result; 00750 } 00751 Status GetInterpolationColors(Color *presetColors, 00752 REAL *blendPositions, INT count) const 00753 { 00754 if (!presetColors || count <= 0) 00755 return lastStatus = InvalidParameter; 00756 00757 ARGB *presetArgb = 00758 (ARGB*) DllExports::GdipAlloc(count * sizeof(ARGB)); 00759 if (!presetArgb) 00760 return lastStatus = OutOfMemory; 00761 00762 Status status = updateStatus(DllExports::GdipGetPathGradientPresetBlend( 00763 (GpPathGradient*) nativeBrush, 00764 presetArgb, blendPositions, count)); 00765 for (INT i = 0; i < count; ++i) { 00766 presetColors[i].SetValue(presetArgb[i]); 00767 } 00768 DllExports::GdipFree((void*) presetArgb); 00769 return status; 00770 } 00771 INT GetPointCount() const 00772 { 00773 INT result = 0; 00774 updateStatus(DllExports::GdipGetPathGradientPointCount( 00775 (GpPathGradient*) nativeBrush, &result)); 00776 return result; 00777 } 00778 Status GetRectangle(RectF *rect) const 00779 { 00780 return updateStatus(DllExports::GdipGetPathGradientRect( 00781 (GpPathGradient*) nativeBrush, rect)); 00782 } 00783 Status GetRectangle(Rect *rect) const 00784 { 00785 return updateStatus(DllExports::GdipGetPathGradientRectI( 00786 (GpPathGradient*) nativeBrush, rect)); 00787 } 00788 INT GetSurroundColorCount() const 00789 { 00790 INT result = 0; 00791 updateStatus(DllExports::GdipGetPathGradientSurroundColorCount( 00792 (GpPathGradient*) nativeBrush, &result)); 00793 return result; 00794 } 00795 Status GetSurroundColors(Color *colors, INT *count) 00796 { 00797 if (!colors || !count || *count <= 0) 00798 return lastStatus = InvalidParameter; 00799 00800 ARGB *colorsArgb = 00801 (ARGB*) DllExports::GdipAlloc(*count * sizeof(ARGB)); 00802 if (!colorsArgb) 00803 return lastStatus = OutOfMemory; 00804 00805 Status status = updateStatus(DllExports::GdipGetPathGradientSurroundColorsWithCount( 00806 (GpPathGradient*) nativeBrush, 00807 colorsArgb, count)); 00808 for (INT i = 0; i < *count; ++i) { 00809 colors[i].SetValue(colorsArgb[i]); 00810 } 00811 DllExports::GdipFree((void*) colorsArgb); 00812 return status; 00813 } 00814 Status GetTransform(Matrix *matrix) const 00815 { 00816 return updateStatus(DllExports::GdipGetPathGradientTransform( 00817 (GpPathGradient*) nativeBrush, 00818 matrix ? matrix->nativeMatrix : NULL)); 00819 } 00820 WrapMode GetWrapMode() const 00821 { 00822 WrapMode result = WrapModeTile; 00823 updateStatus(DllExports::GdipGetPathGradientWrapMode( 00824 (GpPathGradient*) nativeBrush, &result)); 00825 return result; 00826 } 00827 Status MultiplyTransform(const Matrix *matrix, 00828 MatrixOrder order = MatrixOrderPrepend) 00829 { 00830 return updateStatus(DllExports::GdipMultiplyPathGradientTransform( 00831 (GpPathGradient*) nativeBrush, 00832 matrix ? matrix->nativeMatrix : NULL, order)); 00833 } 00834 Status ResetTransform() 00835 { 00836 return updateStatus(DllExports::GdipResetPathGradientTransform( 00837 (GpPathGradient*) nativeBrush)); 00838 } 00839 Status RotateTransform(REAL angle, 00840 MatrixOrder order = MatrixOrderPrepend) 00841 { 00842 return updateStatus(DllExports::GdipRotatePathGradientTransform( 00843 (GpPathGradient*) nativeBrush, angle, order)); 00844 } 00845 Status ScaleTransform(REAL sx, REAL sy, 00846 MatrixOrder order = MatrixOrderPrepend) 00847 { 00848 return updateStatus(DllExports::GdipScalePathGradientTransform( 00849 (GpPathGradient*) nativeBrush, sx, sy, order)); 00850 } 00851 Status SetBlend(REAL *blendFactors, REAL *blendPositions, INT count) 00852 { 00853 return updateStatus(DllExports::GdipSetPathGradientBlend( 00854 (GpPathGradient*) nativeBrush, 00855 blendFactors, blendPositions, count)); 00856 } 00857 Status SetBlendBellShape(REAL focus, REAL scale = 1.0f) 00858 { 00859 return updateStatus(DllExports::GdipSetPathGradientSigmaBlend( 00860 (GpPathGradient*) nativeBrush, focus, scale)); 00861 } 00862 Status SetBlendTriangularShape(REAL focus, REAL scale = 1.0f) 00863 { 00864 return updateStatus(DllExports::GdipSetPathGradientLinearBlend( 00865 (GpPathGradient*) nativeBrush, focus, scale)); 00866 } 00867 Status SetCenterColor(const Color& color) 00868 { 00869 return updateStatus(DllExports::GdipSetPathGradientCenterColor( 00870 (GpPathGradient*) nativeBrush, 00871 color.GetValue())); 00872 } 00873 Status SetCenterPoint(const PointF& point) 00874 { 00875 return updateStatus(DllExports::GdipSetPathGradientCenterPoint( 00876 (GpPathGradient*) nativeBrush, &point)); 00877 } 00878 Status SetCenterPoint(const Point& point) 00879 { 00880 return updateStatus(DllExports::GdipSetPathGradientCenterPointI( 00881 (GpPathGradient*) nativeBrush, &point)); 00882 } 00883 Status SetFocusScales(REAL xScale, REAL yScale) 00884 { 00885 return updateStatus(DllExports::GdipSetPathGradientFocusScales( 00886 (GpPathGradient*) nativeBrush, xScale, yScale)); 00887 } 00888 Status SetGammaCorrection(BOOL useGammaCorrection) 00889 { 00890 return updateStatus(DllExports::GdipSetPathGradientGammaCorrection( 00891 (GpPathGradient*) nativeBrush, 00892 useGammaCorrection)); 00893 } 00894 //Status SetGraphicsPath(const GraphicsPath *path) 00895 //{ 00896 // // TODO: implement PathGradientBrush::SetGraphicsPath 00897 // return updateStatus(NotImplemented); 00898 //} 00899 Status SetInterpolationColors(const Color *presetColors, 00900 REAL *blendPositions, INT count) 00901 { 00902 if (!presetColors || count <= 0) 00903 return lastStatus = InvalidParameter; 00904 00905 ARGB *presetArgb = 00906 (ARGB*) DllExports::GdipAlloc(count * sizeof(ARGB)); 00907 if (!presetArgb) 00908 return lastStatus = OutOfMemory; 00909 for (INT i = 0; i < count; ++i) { 00910 presetArgb[i] = presetColors[i].GetValue(); 00911 } 00912 00913 Status status = updateStatus(DllExports::GdipSetPathGradientPresetBlend( 00914 (GpPathGradient*) nativeBrush, 00915 presetArgb, blendPositions, count)); 00916 DllExports::GdipFree((void*) presetArgb); 00917 return status; 00918 } 00919 Status SetSurroundColors(const Color *colors, INT *count) 00920 { 00921 if (!colors || !count || *count <= 0) 00922 return lastStatus = InvalidParameter; 00923 00924 ARGB *colorsArgb = 00925 (ARGB*) DllExports::GdipAlloc(*count * sizeof(ARGB)); 00926 if (!colorsArgb) 00927 return lastStatus = OutOfMemory; 00928 for (INT i = 0; i < *count; ++i) { 00929 colorsArgb[i] = colors[i].GetValue(); 00930 } 00931 00932 Status status = updateStatus(DllExports::GdipSetPathGradientSurroundColorsWithCount( 00933 (GpPathGradient*) nativeBrush, 00934 colorsArgb, count)); 00935 DllExports::GdipFree((void*) colorsArgb); 00936 return status; 00937 } 00938 Status SetTransform(const Matrix *matrix) 00939 { 00940 return updateStatus(DllExports::GdipSetPathGradientTransform( 00941 (GpPathGradient*) nativeBrush, 00942 matrix ? matrix->nativeMatrix : NULL)); 00943 } 00944 Status SetWrapMode(WrapMode wrapMode) 00945 { 00946 return updateStatus(DllExports::GdipSetPathGradientWrapMode( 00947 (GpPathGradient*) nativeBrush, wrapMode)); 00948 } 00949 Status TranslateTransform(REAL dx, REAL dy, 00950 MatrixOrder order = MatrixOrderPrepend) 00951 { 00952 return updateStatus(DllExports::GdipTranslatePathGradientTransform( 00953 (GpPathGradient*) nativeBrush, dx, dy, order)); 00954 } 00955 00956 private: 00957 PathGradientBrush(GpBrush *brush, Status status): Brush(brush, status) {} 00958 PathGradientBrush(const PathGradientBrush&); 00959 PathGradientBrush& operator=(const PathGradientBrush&); 00960 }; 00961 00962 00963 00964 #endif /* __GDIPLUS_PATH_H */
Generated on Tue Jul 12 2022 19:59:54 by
1.7.2