| /**************************************************************************\ | |
| * | |
| * Copyright (c) 1998-2000, Microsoft Corp. All Rights Reserved. | |
| * | |
| * Module Name: | |
| * | |
| * GdiplusPen.h | |
| * | |
| * Abstract: | |
| * | |
| * Pen API related declarations | |
| * | |
| \**************************************************************************/ | |
| #ifndef _GDIPLUSPEN_H | |
| #define _GDIPLUSPEN_H | |
| //-------------------------------------------------------------------------- | |
| // class for various pen types | |
| //-------------------------------------------------------------------------- | |
| class Pen : public GdiplusBase | |
| { | |
| public: | |
| friend class GraphicsPath; | |
| friend class Graphics; | |
| // abstract Clone() can't be implemented here because it can't | |
| // new an object with pure virtual functions | |
| // Constructors | |
| Pen(IN const Color& color, | |
| IN REAL width = 1.0f) | |
| { | |
| Unit unit = UnitWorld; | |
| nativePen = NULL; | |
| lastResult = DllExports::GdipCreatePen1(color.GetValue(), | |
| width, unit, &nativePen); | |
| } | |
| Pen(IN const Brush* brush, | |
| IN REAL width = 1.0f) | |
| { | |
| Unit unit = UnitWorld; | |
| nativePen = NULL; | |
| lastResult = DllExports::GdipCreatePen2(brush->nativeBrush, | |
| width, unit, &nativePen); | |
| } | |
| ~Pen() | |
| { | |
| DllExports::GdipDeletePen(nativePen); | |
| } | |
| Pen* Clone() const | |
| { | |
| GpPen *clonePen = NULL; | |
| lastResult = DllExports::GdipClonePen(nativePen, &clonePen); | |
| return new Pen(clonePen, lastResult); | |
| } | |
| Status SetWidth(IN REAL width) | |
| { | |
| return SetStatus(DllExports::GdipSetPenWidth(nativePen, width)); | |
| } | |
| REAL GetWidth() const | |
| { | |
| REAL width; | |
| SetStatus(DllExports::GdipGetPenWidth(nativePen, &width)); | |
| return width; | |
| } | |
| // Set/get line caps: start, end, and dash | |
| // Line cap and join APIs by using LineCap and LineJoin enums. | |
| #ifdef DCR_USE_NEW_197819 | |
| Status SetLineCap(IN LineCap startCap, | |
| IN LineCap endCap, | |
| IN DashCap dashCap) | |
| { | |
| return SetStatus(DllExports::GdipSetPenLineCap197819(nativePen, | |
| startCap, endCap, dashCap)); | |
| } | |
| #else | |
| Status SetLineCap(IN LineCap startCap, | |
| IN LineCap endCap, | |
| IN LineCap dashCap) | |
| { | |
| return SetStatus(DllExports::GdipSetPenLineCap(nativePen, | |
| startCap, endCap, dashCap)); | |
| } | |
| #endif // DCR_USE_NEW_197819 | |
| Status SetStartCap(IN LineCap startCap) | |
| { | |
| return SetStatus(DllExports::GdipSetPenStartCap(nativePen, startCap)); | |
| } | |
| Status SetEndCap(IN LineCap endCap) | |
| { | |
| return SetStatus(DllExports::GdipSetPenEndCap(nativePen, endCap)); | |
| } | |
| #ifdef DCR_USE_NEW_197819 | |
| Status SetDashCap(IN DashCap dashCap) | |
| { | |
| return SetStatus(DllExports::GdipSetPenDashCap197819(nativePen, | |
| dashCap)); | |
| } | |
| #else | |
| Status SetDashCap(IN LineCap dashCap) | |
| { | |
| return SetStatus(DllExports::GdipSetPenDashCap(nativePen, dashCap)); | |
| } | |
| #endif // DCR_USE_NEW_197819 | |
| LineCap GetStartCap() const | |
| { | |
| LineCap startCap; | |
| SetStatus(DllExports::GdipGetPenStartCap(nativePen, &startCap)); | |
| return startCap; | |
| } | |
| LineCap GetEndCap() const | |
| { | |
| LineCap endCap; | |
| SetStatus(DllExports::GdipGetPenEndCap(nativePen, &endCap)); | |
| return endCap; | |
| } | |
| #ifdef DCR_USE_NEW_197819 | |
| DashCap GetDashCap() const | |
| { | |
| DashCap dashCap; | |
| SetStatus(DllExports::GdipGetPenDashCap197819(nativePen, | |
| &dashCap)); | |
| return dashCap; | |
| } | |
| #else | |
| LineCap GetDashCap() const | |
| { | |
| LineCap dashCap; | |
| SetStatus(DllExports::GdipGetPenDashCap(nativePen, &dashCap)); | |
| return dashCap; | |
| } | |
| #endif // DCR_USE_NEW_197819 | |
| // Set/get line join | |
| Status SetLineJoin(IN LineJoin lineJoin) | |
| { | |
| return SetStatus(DllExports::GdipSetPenLineJoin(nativePen, lineJoin)); | |
| } | |
| LineJoin GetLineJoin() const | |
| { | |
| LineJoin lineJoin; | |
| SetStatus(DllExports::GdipGetPenLineJoin(nativePen, &lineJoin)); | |
| return lineJoin; | |
| } | |
| Status SetCustomStartCap(IN const CustomLineCap* customCap) | |
| { | |
| GpCustomLineCap* nativeCap = NULL; | |
| if(customCap) | |
| nativeCap = customCap->nativeCap; | |
| return SetStatus(DllExports::GdipSetPenCustomStartCap(nativePen, nativeCap)); | |
| } | |
| Status GetCustomStartCap(OUT CustomLineCap* customCap) const | |
| { | |
| if(!customCap) | |
| return SetStatus(InvalidParameter); | |
| return SetStatus(DllExports::GdipGetPenCustomStartCap(nativePen, &(customCap->nativeCap))); | |
| } | |
| Status SetCustomEndCap(IN const CustomLineCap* customCap) | |
| { | |
| GpCustomLineCap* nativeCap = NULL; | |
| if(customCap) | |
| nativeCap = customCap->nativeCap; | |
| return SetStatus(DllExports::GdipSetPenCustomEndCap(nativePen, nativeCap)); | |
| } | |
| Status GetCustomEndCap(OUT CustomLineCap* customCap) const | |
| { | |
| if(!customCap) | |
| return SetStatus(InvalidParameter); | |
| return SetStatus(DllExports::GdipGetPenCustomEndCap(nativePen, &(customCap->nativeCap))); | |
| } | |
| Status SetMiterLimit(IN REAL miterLimit) | |
| { | |
| return SetStatus(DllExports::GdipSetPenMiterLimit(nativePen, miterLimit)); | |
| } | |
| REAL GetMiterLimit() const | |
| { | |
| REAL miterLimit; | |
| SetStatus(DllExports::GdipGetPenMiterLimit(nativePen, &miterLimit)); | |
| return miterLimit; | |
| } | |
| // Set/get pen mode | |
| Status SetAlignment(IN PenAlignment penAlignment) | |
| { | |
| return SetStatus(DllExports::GdipSetPenMode(nativePen, penAlignment)); | |
| } | |
| PenAlignment GetAlignment() const | |
| { | |
| PenAlignment penAlignment; | |
| SetStatus(DllExports::GdipGetPenMode(nativePen, &penAlignment)); | |
| return penAlignment; | |
| } | |
| // Set/get pen transform | |
| Status SetTransform(IN const Matrix* matrix) | |
| { | |
| return SetStatus(DllExports::GdipSetPenTransform(nativePen, | |
| matrix->nativeMatrix)); | |
| } | |
| Status GetTransform(OUT Matrix* matrix) const | |
| { | |
| return SetStatus(DllExports::GdipGetPenTransform(nativePen, matrix->nativeMatrix)); | |
| } | |
| Status ResetTransform() | |
| { | |
| return SetStatus(DllExports::GdipResetPenTransform(nativePen)); | |
| } | |
| Status MultiplyTransform(IN const Matrix* matrix, | |
| IN MatrixOrder order = MatrixOrderPrepend) | |
| { | |
| return SetStatus(DllExports::GdipMultiplyPenTransform(nativePen, | |
| matrix->nativeMatrix, | |
| order)); | |
| } | |
| Status TranslateTransform(IN REAL dx, | |
| IN REAL dy, | |
| IN MatrixOrder order = MatrixOrderPrepend) | |
| { | |
| return SetStatus(DllExports::GdipTranslatePenTransform(nativePen, | |
| dx, dy, order)); | |
| } | |
| Status ScaleTransform(IN REAL sx, | |
| IN REAL sy, | |
| IN MatrixOrder order = MatrixOrderPrepend) | |
| { | |
| return SetStatus(DllExports::GdipScalePenTransform(nativePen, | |
| sx, sy, order)); | |
| } | |
| Status RotateTransform(IN REAL angle, | |
| IN MatrixOrder order = MatrixOrderPrepend) | |
| { | |
| return SetStatus(DllExports::GdipRotatePenTransform(nativePen, | |
| angle, order)); | |
| } | |
| PenType GetPenType() const | |
| { | |
| PenType type; | |
| SetStatus(DllExports::GdipGetPenFillType(nativePen, &type)); | |
| return type; | |
| } | |
| Status SetColor(IN const Color& color) | |
| { | |
| return SetStatus(DllExports::GdipSetPenColor(nativePen, | |
| color.GetValue())); | |
| } | |
| Status SetBrush(IN const Brush* brush) | |
| { | |
| return SetStatus(DllExports::GdipSetPenBrushFill(nativePen, | |
| brush->nativeBrush)); | |
| } | |
| Status GetColor(OUT Color* color) const | |
| { | |
| if (color == NULL) | |
| { | |
| return SetStatus(InvalidParameter); | |
| } | |
| PenType type = GetPenType(); | |
| if (type != PenTypeSolidColor) | |
| { | |
| return WrongState; | |
| } | |
| ARGB argb; | |
| SetStatus(DllExports::GdipGetPenColor(nativePen, | |
| &argb)); | |
| if (lastResult == Ok) | |
| { | |
| color->SetValue(argb); | |
| } | |
| return lastResult; | |
| } | |
| Brush* GetBrush() const | |
| { | |
| PenType type = GetPenType(); | |
| Brush* brush = NULL; | |
| switch(type) | |
| { | |
| case PenTypeSolidColor: | |
| brush = new SolidBrush(); | |
| break; | |
| case PenTypeHatchFill: | |
| brush = new HatchBrush(); | |
| break; | |
| case PenTypeTextureFill: | |
| brush = new TextureBrush(); | |
| break; | |
| case PenTypePathGradient: | |
| brush = new Brush(); | |
| break; | |
| case PenTypeLinearGradient: | |
| brush = new LinearGradientBrush(); | |
| break; | |
| default: | |
| break; | |
| } | |
| if(brush) | |
| { | |
| GpBrush* nativeBrush; | |
| SetStatus(DllExports::GdipGetPenBrushFill(nativePen, &nativeBrush)); | |
| brush->SetNativeBrush(nativeBrush); | |
| } | |
| return brush; | |
| } | |
| DashStyle GetDashStyle() const | |
| { | |
| DashStyle dashStyle; | |
| SetStatus(DllExports::GdipGetPenDashStyle(nativePen, &dashStyle)); | |
| return dashStyle; | |
| } | |
| Status SetDashStyle(IN DashStyle dashStyle) | |
| { | |
| return SetStatus(DllExports::GdipSetPenDashStyle(nativePen, dashStyle)); | |
| } | |
| REAL GetDashOffset() const | |
| { | |
| REAL dashOffset; | |
| SetStatus(DllExports::GdipGetPenDashOffset(nativePen, &dashOffset)); | |
| return dashOffset; | |
| } | |
| Status SetDashOffset(IN REAL dashOffset) | |
| { | |
| return SetStatus(DllExports::GdipSetPenDashOffset(nativePen, dashOffset)); | |
| } | |
| Status SetDashPattern(IN const REAL* dashArray, IN INT count) | |
| { | |
| return SetStatus(DllExports::GdipSetPenDashArray(nativePen, dashArray, | |
| count)); | |
| } | |
| INT GetDashPatternCount() const | |
| { | |
| INT count = 0; | |
| SetStatus(DllExports::GdipGetPenDashCount(nativePen, &count)); | |
| return count; | |
| } | |
| Status GetDashPattern(OUT REAL* dashArray, | |
| IN INT count) const | |
| { | |
| if (dashArray == NULL || count <= 0) | |
| return SetStatus(InvalidParameter); | |
| return SetStatus(DllExports::GdipGetPenDashArray(nativePen, | |
| dashArray, | |
| count)); | |
| } | |
| Status SetCompoundArray(IN const REAL* compoundArray, | |
| IN INT count) | |
| { | |
| return SetStatus(DllExports::GdipSetPenCompoundArray(nativePen, compoundArray, | |
| count)); | |
| } | |
| INT GetCompoundArrayCount() const | |
| { | |
| INT count = 0; | |
| SetStatus(DllExports::GdipGetPenCompoundCount(nativePen, &count)); | |
| return count; | |
| } | |
| Status GetCompoundArray(OUT REAL* compoundArray, | |
| IN INT count) const | |
| { | |
| if (compoundArray == NULL || count <= 0) | |
| return SetStatus(InvalidParameter); | |
| return SetStatus(DllExports::GdipGetPenCompoundArray(nativePen, | |
| compoundArray, | |
| count)); | |
| } | |
| Status GetLastStatus() const | |
| { | |
| Status lastStatus = lastResult; | |
| lastResult = Ok; | |
| return lastStatus; | |
| } | |
| protected: | |
| #ifdef DCR_USE_NEW_250932 | |
| private: | |
| Pen(const Pen &); | |
| Pen& operator=(const Pen &); | |
| protected: | |
| #else | |
| Pen(const Pen& pen) | |
| { | |
| pen; | |
| SetStatus(NotImplemented); | |
| SetNativePen(NULL); | |
| } | |
| Pen& operator=(const Pen& pen) | |
| { | |
| pen; | |
| SetStatus(NotImplemented); | |
| return *this; | |
| } | |
| #endif | |
| Pen(GpPen* nativePen, Status status) | |
| { | |
| lastResult = status; | |
| SetNativePen(nativePen); | |
| } | |
| VOID SetNativePen(GpPen* nativePen) | |
| { | |
| this->nativePen = nativePen; | |
| } | |
| Status SetStatus(Status status) const | |
| { | |
| if (status != Ok) | |
| return (lastResult = status); | |
| else | |
| return status; | |
| } | |
| protected: | |
| GpPen* nativePen; | |
| mutable Status lastResult; | |
| }; | |
| #endif |