reactos/sdk/include/psdk/gdipluspen.h

/*
 * GdiPlusPen.h
 *
 * Windows GDI+
 *
 * This file is part of the w32api package.
 *
 * THIS SOFTWARE IS NOT COPYRIGHTED
 *
 * This source code is offered for use in the public domain. You may
 * use, modify or distribute it freely.
 *
 * This code is distributed in the hope that it will be useful but
 * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
 * DISCLAIMED. This includes but is not limited to warranties of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 */

#ifndef _GDIPLUSPEN_H
#define _GDIPLUSPEN_H

class CustomLineCap;

class Pen : public GdiplusBase
{
    friend class Graphics;

  public:
    Pen(const Brush *brush, REAL width = 1.0f)
    {
    }

    Pen(const Color &color, REAL width = 1.0f)
    {
        Unit unit = UnitWorld;
        pen = NULL;
        status = DllExports::GdipCreatePen1(color.GetValue(), width, unit, &pen);
    }

    Pen *Clone(VOID)
    {
        return NULL;
    }

    PenAlignment GetAlignment(VOID)
    {
        PenAlignment penAlignment;
        SetStatus(DllExports::GdipGetPenMode(pen, &penAlignment));
        return penAlignment;
    }

    Brush *GetBrush(VOID)
    {
        return NULL;
    }

    Status
    GetColor(Color *color)
    {
        ARGB argb;
        Status status = SetStatus(DllExports::GdipGetPenColor(pen, &argb));
        if (color)
            color->SetValue(argb);
        return status;
    }

    Status
    GetCompoundArray(REAL *compoundArray, INT count)
    {
        return NotImplemented; // FIXME: not available: SetStatus(DllExports::GdipGetPenCompoundArray(pen, count));
    }

    INT GetCompoundArrayCount(VOID)
    {
        INT count;
        SetStatus(DllExports::GdipGetPenCompoundCount(pen, &count));
        return count;
    }

    Status
    GetCustomEndCap(CustomLineCap *customCap)
    {
        return NotImplemented;
    }

    Status
    GetCustomStartCap(CustomLineCap *customCap)
    {
        return NotImplemented;
    }

    DashCap GetDashCap(VOID)
    {
        DashCap dashCap;
        SetStatus(DllExports::GdipGetPenDashCap197819(pen, &dashCap));
        return dashCap;
    }

    REAL GetDashOffset(VOID)
    {
        REAL offset;
        SetStatus(DllExports::GdipGetPenDashOffset(pen, &offset));
        return offset;
    }

    Status
    GetDashPattern(REAL *dashArray, INT count)
    {
        return SetStatus(DllExports::GdipGetPenDashArray(pen, dashArray, count));
    }

    INT GetDashPatternCount(VOID)
    {
        INT count;
        SetStatus(DllExports::GdipGetPenDashCount(pen, &count));
        return count;
    }

    DashStyle GetDashStyle(VOID)
    {
        DashStyle dashStyle;
        SetStatus(DllExports::GdipGetPenDashStyle(pen, &dashStyle));
        return dashStyle;
    }

    LineCap GetEndCap(VOID)
    {
        LineCap endCap;
        SetStatus(DllExports::GdipGetPenEndCap(pen, &endCap));
        return endCap;
    }

    Status GetLastStatus(VOID)
    {
        return status;
    }

    LineJoin GetLineJoin(VOID)
    {
        LineJoin lineJoin;
        SetStatus(DllExports::GdipGetPenLineJoin(pen, &lineJoin));
        return lineJoin;
    }

    REAL GetMiterLimit(VOID)
    {
        REAL miterLimit;
        SetStatus(DllExports::GdipGetPenMiterLimit(pen, &miterLimit));
        return miterLimit;
    }

    PenType GetPenType(VOID)
    {
        PenType type;
        SetStatus(DllExports::GdipGetPenFillType(pen, &type));
        return type;
    }

    LineCap GetStartCap(VOID)
    {
        LineCap startCap;
        SetStatus(DllExports::GdipGetPenStartCap(pen, &startCap));
        return startCap;
    }

    Status
    GetTransform(Matrix *matrix)
    {
        return NotImplemented;
    }

    REAL GetWidth(VOID)
    {
        REAL width;
        SetStatus(DllExports::GdipGetPenWidth(pen, &width));
        return width;
    }

    Status
    MultiplyTransform(Matrix *matrix, MatrixOrder order)
    {
        return NotImplemented; // FIXME: not available: SetStatus(DllExports::GdipMultiplyPenTransform(pen, matrix ?
                               // matrix->nativeMatrix : NULL, order));
    }

    Status ResetTransform(VOID)
    {
        return SetStatus(DllExports::GdipResetPenTransform(pen));
    }

    Status
    RotateTransform(REAL angle, MatrixOrder order)
    {
        return NotImplemented; // FIXME: not available: SetStatus(DllExports::GdipRotatePenTransform(pen, angle,
                               // order));
    }

    Status
    ScaleTransform(REAL sx, REAL sy, MatrixOrder order)
    {
        return SetStatus(DllExports::GdipScalePenTransform(pen, sx, sy, order));
    }

    Status
    SetAlignment(PenAlignment penAlignment)
    {
        return SetStatus(DllExports::GdipSetPenMode(pen, penAlignment));
    }

    Status
    SetBrush(const Brush *brush)
    {
        return SetStatus(DllExports::GdipSetPenBrushFill(pen, brush ? brush->nativeBrush : NULL));
    }

    Status
    SetColor(const Color &color)
    {
        return SetStatus(DllExports::GdipSetPenColor(pen, color.GetValue()));
    }

    Status
    SetCompoundArray(const REAL *compoundArray, INT count)
    {
        return SetStatus(DllExports::GdipSetPenCompoundArray(pen, compoundArray, count));
    }

    Status
    SetCustomEndCap(const CustomLineCap *customCap)
    {
        return NotImplemented;
    }

    Status
    SetCustomStartCap(const CustomLineCap *customCap)
    {
        return NotImplemented;
    }

    Status
    SetDashCap(DashCap dashCap)
    {
        return SetStatus(DllExports::GdipSetPenDashCap197819(pen, dashCap));
    }

    Status
    SetDashOffset(REAL dashOffset)
    {
        return SetStatus(DllExports::GdipSetPenDashOffset(pen, dashOffset));
    }

    Status
    SetDashPattern(const REAL *dashArray, INT count)
    {
        return SetStatus(DllExports::GdipSetPenDashArray(pen, dashArray, count));
    }

    Status
    SetDashStyle(DashStyle dashStyle)
    {
        return SetStatus(DllExports::GdipSetPenDashStyle(pen, dashStyle));
    }

    Status
    SetEndCap(LineCap endCap)
    {
        return SetStatus(DllExports::GdipSetPenEndCap(pen, endCap));
    }

    Status
    SetLineCap(LineCap startCap, LineCap endCap, DashCap dashCap)
    {
        return SetStatus(DllExports::GdipSetPenLineCap197819(pen, startCap, endCap, dashCap));
    }

    Status
    SetLineJoin(LineJoin lineJoin)
    {
        return SetStatus(DllExports::GdipSetPenLineJoin(pen, lineJoin));
    }

    Status
    SetMiterLimit(REAL miterLimit)
    {
        return SetStatus(DllExports::GdipSetPenMiterLimit(pen, miterLimit));
    }

    Status
    SetStartCap(LineCap startCap)
    {
        return SetStatus(DllExports::GdipSetPenStartCap(pen, startCap));
    }

    Status
    SetTransform(const Matrix *matrix)
    {
        return SetStatus(DllExports::GdipSetPenTransform(pen, matrix ? matrix->nativeMatrix : NULL));
    }

    Status
    SetWidth(REAL width)
    {
        return SetStatus(DllExports::GdipSetPenWidth(pen, width));
    }

  private:
    GpPen *pen;

  private:
    mutable Status status;

    Status
    SetStatus(Status status) const
    {
        if (status == Ok)
            return status;
        this->status = status;
        return status;
    }
};

#endif /* _GDIPLUSPEN_H */