graphics.h

// Copyright (c) 2009-2025 Avanquest Software. All rights reserved.
 
#ifndef PDFSDK_CXX_GRAPHICS_H_INCLUDED_
#define PDFSDK_CXX_GRAPHICS_H_INCLUDED_
 
#include <filesystem>
#include <functional>
#include <optional>
#include <string>
 
#include <pdfsdk/cxx/exception.h>
#include <pdfsdk/cxx/math.h>
#include <pdfsdk/graphics.h>
 
#include "wrapper_base.h"
 
namespace PDF {
namespace Graphics {
 
class Palette : public detail::RefCountedHandle<GXPalette> {
public:
    static Palette New(const GXColorValue* colors, size_t num_colors) {
        Palette palette;
        auto ec = GXCreatePalette(colors, num_colors, &palette);
        PDF_CHECK_SUCCESS(ec, "Failed to create a palette");
        return palette;
    }
 
    const GXColorValue* GetColorsPtr() const {
        const GXColorValue* colors = nullptr;
        auto ec = GXPaletteGetColors(m_handle, &colors);
        PDF_CHECK_SUCCESS(ec, "Failed to get palette colors");
        return colors;
    }
 
    size_t GetNumColors() const {
        size_t num_colors = 0;
        auto ec = GXPaletteGetNumColors(m_handle, &num_colors);
        PDF_CHECK_SUCCESS(ec, "Failed to get the number of palette colors");
        return num_colors;
    }
 
    GXColorValue GetColor(size_t index) const {
        GXColorValue color = 0;
        auto ec = GXPaletteGetColor(m_handle, index, &color);
        PDF_CHECK_SUCCESS(ec, "Failed to get palette color by index");
        return color;
    }
 
    PDF_CXX_CORE_WRAPPER_DEFINE_MEMBERS_(Palette, GXPalette)
};
 
class Bitmap : public detail::RefCountedHandle<GXBitmap> {
public:
    static Bitmap New(const SizeI& size, GXPixelFormat format, float dpiX = 96, float dpiY = 96) {
        Bitmap bitmap;
        GXBitmapAttrs attrs = {size, format, dpiX, dpiY};
        auto ec = GXCreateBitmap(&attrs, &bitmap);
        PDF_CHECK_SUCCESS(ec, "Failed to create a bitmap");
        return bitmap;
    }
 
    static Bitmap LoadFromFile(const std::filesystem::path& path, uint32_t frame_index = 0, uint32_t* ptotal_frames = nullptr) {
        Bitmap bitmap;
        auto path_string = path.wstring();
        auto ec = GXCreateBitmapFromFileFrame(path_string.c_str(), frame_index, ptotal_frames, &bitmap);
        PDF_CHECK_SUCCESS(ec, "Failed to load a bitmap from file");
        return bitmap;
    }
 
    static Bitmap LoadFromMemory(const void* data, size_t size, uint32_t frame_index = 0, uint32_t* ptotal_frames = nullptr) {
        Bitmap bitmap;
        auto ec = GXCreateBitmapFromMemoryFrame(data, size, frame_index, ptotal_frames, &bitmap);
        PDF_CHECK_SUCCESS(ec, "Failed to load a bitmap from memory");
        return bitmap;
    }
 
#if defined(WIN32)
    static Bitmap NewFromHBITMAP(void* hbitmap) {
        Bitmap bitmap;
        auto ec = GXCreateBitmapFromHBITMAP(hbitmap, &bitmap);
        PDF_CHECK_SUCCESS(ec, "Failed to create a bitmap from HBITMAP");
        return bitmap;
    }
#endif
 
    void SaveToFile(const std::filesystem::path& path) const {
        auto path_string = path.wstring();
        auto ec = GXBitmapSaveToFile(m_handle, path_string.c_str());
        PDF_CHECK_SUCCESS(ec, "Failed to save the bitmap to file");
    }
 
#if defined(WIN32)
    void* SaveToHBITMAP() const {
        void* hbitmap = NULL;
        auto ec = GXBitmapSaveToHBITMAP(m_handle, &hbitmap);
        PDF_CHECK_SUCCESS(ec, "Failed to save the bitmap to HBITMAP");
        return hbitmap;
    }
#endif
 
    GXPixelFormat GetPixelFormat() const {
        GXPixelFormat format = kGXPixelFormatUnknown;
        auto ec = GXBitmapGetPixelFormat(m_handle, &format);
        PDF_CHECK_SUCCESS(ec, "Failed to get the bitmap pixel format");
        return format;
    }
 
    SizeI GetSize() const {
        SizeI size;
        auto ec = GXBitmapGetSize(m_handle, &size);
        PDF_CHECK_SUCCESS(ec, "Failed to get the bitmap size");
        return size;
    }
 
    float GetDpiX() const {
        float dpix = 0.f;
        auto ec = GXBitmapGetDpiX(m_handle, &dpix);
        PDF_CHECK_SUCCESS(ec, "Failed to get the bitmap horz dpi");
        return dpix;
    }
 
    float GetDpiY() const {
        float dpiy = 0.f;
        auto ec = GXBitmapGetDpiY(m_handle, &dpiy);
        PDF_CHECK_SUCCESS(ec, "Failed to get the bitmap vert dpi");
        return dpiy;
    }
 
    int GetBitsPerPixel() const {
        GXPixelFormat format = GetPixelFormat();
 
        switch (format) {
            case kGXPixelFormatRGB8:
                return 24;
 
            case kGXPixelFormatARGB8p:
            case kGXPixelFormatARGB8:
            case kGXPixelFormatXRGB8:
                return 32;
 
            case kGXPixelFormatA8:
            case kGXPixelFormatP8:
            case kGXPixelFormatL8:
                return 8;
 
            case kGXPixelFormatA1:
            case kGXPixelFormatP1:
            case kGXPixelFormatL1:
                return 1;
 
            default:
                return 32;
        }
    }
 
    void SetPalette(const Palette& palette) {
        auto ec = GXBitmapSetPalette(m_handle, palette.get());
        PDF_CHECK_SUCCESS(ec, "Failed to set the bitmap palette");
    }
 
    Palette GetPalette() const {
        Palette palette;
        auto ec = GXBitmapGetPalette(m_handle, &palette);
        PDF_CHECK_SUCCESS(ec, "Failed to get the bitmap palette");
        return palette;
    }
 
    GXLockedData Lock(GXLockMode mode, const RectI* rect = nullptr) {
        GXLockedData lockdata;
        auto ec = GXBitmapLock(m_handle, rect, mode, &lockdata);
        PDF_CHECK_SUCCESS(ec, "Failed to lock the bitmap");
        return lockdata;
    }
 
    void Unlock() {
        auto ec = GXBitmapUnlock(m_handle);
        PDF_CHECK_SUCCESS(ec, "Failed to unlock the bitmap");
    }
 
    void CopyFromBitmap(const Bitmap& source, const RectI* source_rect = nullptr, const PointI* dest_point = nullptr) {
        auto ec = GXBitmapCopyFromBitmap(m_handle, dest_point, source.get(), source_rect);
        PDF_CHECK_SUCCESS(ec, "Failed to copy the bitmap");
    }
 
    void CopyFromMemory(const GXLockedData& memory, const RectI* dest_rect = nullptr) {
        auto ec = GXBitmapCopyFromMemory(m_handle, dest_rect, &memory);
        PDF_CHECK_SUCCESS(ec, "Failed to copy the bitmap");
    }
 
    void CopyToMemory(const GXLockedData& memory, const RectI* source_rect = nullptr) const {
        auto ec = GXBitmapCopyToMemory(m_handle, source_rect, &memory);
        PDF_CHECK_SUCCESS(ec, "Failed to copy the bitmap");
    }
 
    void ColorFill(GXColorValue color, const RectI* fill_rect = nullptr) {
        auto ec = GXBitmapColorFill(m_handle, fill_rect, color);
        PDF_CHECK_SUCCESS(ec, "Failed to fill the bitmap");
    }
 
    void NotifyChanged() {
        auto ec = GXBitmapNotifyChanged(m_handle);
        PDF_CHECK_SUCCESS(ec, "Failed to notify the bitmap change");
    }
 
    void SetOffscreenPainting(bool offscreen) {
        auto ec = GXBitmapSetOffscreenPainting(m_handle, offscreen);
        PDF_CHECK_SUCCESS(ec, "Failed to set the bitmap offscreen");
    }
 
    PDF_CXX_CORE_WRAPPER_DEFINE_MEMBERS_(Bitmap, GXBitmap)
};
 
struct BitmapScopedLock {
    BitmapScopedLock(const Bitmap& bm, GXLockMode mode = kGXLockModeRead, const PDF::RectI* rectp = nullptr)
            : bitmap(bm) {
        data = bitmap.Lock(mode, rectp);
    }
    ~BitmapScopedLock() {
        try {
            bitmap.Unlock();
        } catch (...) {
            /* ignore */
        }
    }
    Bitmap bitmap;
    GXLockedData data;
};
 
class FontFace : public detail::RefCountedHandle<GXFontFace> {
public:
    static FontFace New(const std::wstring& family, GXFontStyle style) {
        FontFace fontface;
        auto ec = GXCreateSystemFontFace(family.c_str(), style, &fontface);
        PDF_CHECK_SUCCESS(ec, "Failed to create a font face");
        return fontface;
    }
 
    static FontFace LoadFromFile(const std::filesystem::path& path, uint32_t faceindex = 0, uint32_t* ptotalfaces = nullptr) {
        FontFace fontface;
        auto path_string = path.wstring();
        auto ec = GXCreateFontFaceFromFile(path_string.c_str(), faceindex, ptotalfaces, &fontface);
        PDF_CHECK_SUCCESS(ec, "Failed to load a bitmap from file");
        return fontface;
    }
 
    static FontFace LoadFromMemory(const void* data, size_t size, bool copyData = true, uint32_t faceindex = 0, uint32_t* ptotalfaces = nullptr) {
        FontFace fontface;
        auto ec = GXCreateFontFaceFromMemory(data, size, copyData, faceindex, ptotalfaces, &fontface);
        PDF_CHECK_SUCCESS(ec, "Failed to load a bitmap from memory");
        return fontface;
    }
 
    SizeF CalculateTextBound(float fontSize, const std::wstring& text) const {
        SizeF bound;
        auto ec = GXFontFaceCalculateTextBound(m_handle, fontSize, text.c_str(), &bound);
        PDF_CHECK_SUCCESS(ec, "Failed to calculate the text bound");
        return bound;
    }
 
    PDF_CXX_CORE_WRAPPER_DEFINE_MEMBERS_(FontFace, GXFontFace)
};
 
class Geometry : public detail::RefCountedHandle<GXGeometry> {
public:
    static Geometry New() {
        Geometry geom;
        auto ec = GXCreateGeometry(&geom);
        PDF_CHECK_SUCCESS(ec, "Failed to create a geometry");
        return geom;
    }
 
    static Geometry NewFromRectangle(const PDF::RectF& rect) {
        Geometry geom = New();
        geom.Rectangle(rect);
        return geom;
    }
 
    void SetFillRule(GXFillRule fillrule) {
        auto ec = GXGeometrySetFillRule(m_handle, fillrule);
        PDF_CHECK_SUCCESS(ec, "Failed to set the geometry fill rule");
    }
 
    GXFillRule GetFillRule() const {
        GXFillRule fillrule = kGXFillRuleNonZero;
        auto ec = GXGeometryGetFillRule(m_handle, &fillrule);
        PDF_CHECK_SUCCESS(ec, "Failed to get the geometry fill rule");
        return fillrule;
    }
 
    bool IsPointsEmpty() const {
        bool empty = false;
        auto ec = GXGeometryEmpty(m_handle, &empty);
        PDF_CHECK_SUCCESS(ec, "Failed to check the geometry points");
        return empty;
    }
 
    bool IsPointsEqual(const Geometry& rhs) const {
        bool empty = false;
        auto ec = GXGeometryPointsEqual(m_handle, rhs.get(), &empty);
        PDF_CHECK_SUCCESS(ec, "Failed to check the geometry points");
        return empty;
    }
 
    bool GetCurrentPoint(PointF* presult) const {
        auto ec = GXGeometryGetCurrentPoint(m_handle, presult);
        if (ec == kPDErrNotFound)
            return false;
        PDF_CHECK_SUCCESS(ec, "Failed to get the geometry points");
        return true;
    }
 
    RectF GetBound(const Matrix* xform = nullptr) const {
        RectF bound;
        auto ec = GXGeometryGetBound(m_handle, xform, &bound);
        PDF_CHECK_SUCCESS(ec, "Failed to get the geometry bound");
        return bound;
    }
 
    RectF GetWidenBound(float lineWidth, const GXStrokeParams& params, const Matrix* xform = nullptr, float flatness = 0.75f) const {
        if (Math::FloatEq(lineWidth, 0.0f))
            lineWidth = flatness;
        auto widenGeometry = Widen(lineWidth, params);
        return widenGeometry.GetBound(xform);
    }
 
    void BeginFigure(const PointF& point) {
        auto ec = GXGeometryBeginFigure(m_handle, &point);
        PDF_CHECK_SUCCESS(ec, "Failed to begin figure");
    }
 
    void EndFigure() {
        auto ec = GXGeometryEndFigure(m_handle);
        PDF_CHECK_SUCCESS(ec, "Failed to end figure");
    }
 
    void EndFigureClose() {
        auto ec = GXGeometryEndFigureClose(m_handle);
        PDF_CHECK_SUCCESS(ec, "Failed to close figure");
    }
 
    void LineTo(const PointF& to) {
        auto ec = GXGeometryLineTo(m_handle, &to);
        PDF_CHECK_SUCCESS(ec, "Failed to add points to the geometry");
    }
 
    void CurveTo(const PointF& c, const PointF& to) {
        auto ec = GXGeometryConicCurveTo(m_handle, &c, &to);
        PDF_CHECK_SUCCESS(ec, "Failed to add points to the geometry");
    }
 
    void CurveTo(const PointF& c0, const PointF& c1, const PointF& to) {
        auto ec = GXGeometryCubicCurveTo(m_handle, &c0, &c1, &to);
        PDF_CHECK_SUCCESS(ec, "Failed to add points to the geometry");
    }
 
    void Rectangle(const RectF& rect) {
        auto ec = GXGeometryRectangle(m_handle, &rect);
        PDF_CHECK_SUCCESS(ec, "Failed to add points to the geometry");
    }
 
    void Ellipse(const RectF& bound) {
        auto ec = GXGeometryEllipse(m_handle, &bound);
        PDF_CHECK_SUCCESS(ec, "Failed to add points to the geometry");
    }
 
    void RoundRectangle(const RectF& rect, float xradii, float yradii) {
        auto ec = GXGeometryRoundRectangle(m_handle, &rect, xradii, yradii);
        PDF_CHECK_SUCCESS(ec, "Failed to add points to the geometry");
    }
 
    Geometry Copy() const {
        Geometry copy;
        auto ec = GXGeometryCopy(m_handle, &copy);
        PDF_CHECK_SUCCESS(ec, "Failed to copy the geometry");
        return copy;
    }
 
    Geometry Transform(const Matrix& xform) const {
        Geometry result;
        auto ec = GXGeometryTransform(m_handle, &xform, &result);
        PDF_CHECK_SUCCESS(ec, "Failed to transform the geometry");
        return result;
    }
 
    Geometry Widen(float width, const GXStrokeParams& params, float flatness = 0.75) const {
        Geometry result;
        auto ec = GXGeometryWiden(m_handle, width, &params, flatness, &result);
        PDF_CHECK_SUCCESS(ec, "Failed to widen the geometry");
        return result;
    }
 
    Geometry Combine(GXCombineMode mode,
                     const Geometry& rhs,
                     const Matrix* xform = nullptr,
                     float flatness = 0.75) const {
        Geometry result;
        auto ec = GXGeometryCombine(m_handle, rhs.get(), xform, mode, flatness, &result);
        PDF_CHECK_SUCCESS(ec, "Failed to combine the geometries");
        return result;
    }
 
    bool HitTest(const PointF& point) const {
        bool hit = false;
        auto ec = GXGeometryHitTest(m_handle, &point, &hit);
        PDF_CHECK_SUCCESS(ec, "Failed to hit test the geometry");
        return hit;
    }
 
    Geometry Simplify(float flatness = 0.75) const {
        Geometry result;
        auto ec = GXGeometrySimplify(m_handle, flatness, &result);
        PDF_CHECK_SUCCESS(ec, "Failed to simplify the geometries");
        return result;
    }
 
    std::optional<RectF> IsRectangle(const Matrix& xform = Matrix{}) const {
        bool isrectangle = false;
        RectF rectangle;
        auto ec = GXGeometryIsRectangle(m_handle, &xform, &isrectangle, &rectangle);
        PDF_CHECK_SUCCESS(ec, "Failed to get the geometry rectangle");
        if (!isrectangle)
            return std::nullopt;
        return rectangle;
    }
 
    bool IsSingleLine() const {
        if (GetNumFigures() > 1)
            return false;
 
        if (GetFigureNumPoints(0) != 2)
            return false;
 
        return true;
    }
 
    size_t GetNumFigures() const {
        size_t numfigures = 0;
        auto ec = GXGeometryGetNumFigures(m_handle, &numfigures);
        PDF_CHECK_SUCCESS(ec, "Failed to get the geometry figures");
        return numfigures;
    }
 
    size_t GetFigureNumSegments(size_t figureindex) const {
        size_t numsegs = 0;
        auto ec = GXGeometryGetFigureNumSegments(m_handle, figureindex, &numsegs);
        PDF_CHECK_SUCCESS(ec, "Failed to get the geometry figure segments");
        return numsegs;
    }
 
    size_t GetFigureNumPoints(size_t figureindex) const {
        size_t numpoints = 0;
        auto ec = GXGeometryGetFigureNumPoints(m_handle, figureindex, &numpoints);
        PDF_CHECK_SUCCESS(ec, "Failed to get the geometry figure points");
        return numpoints;
    }
 
    const PointF* GetFigurePointsPtr(size_t figureindex) const {
        const PDPointF* points = nullptr;
        auto ec = GXGeometryGetFigurePointsPtr(m_handle, figureindex, &points);
        PDF_CHECK_SUCCESS(ec, "Failed to get the geometry figure start point");
        static_assert(sizeof(PointF) == sizeof(PDPointF), "Size of PointF and PDPointF must be equal");
        return reinterpret_cast<const PointF*>(points);
    }
 
    bool IsFigureSegmentCurve(size_t figureindex, size_t segindex) const {
        bool iscurve = false;
        auto ec = GXGeometryIsFigureSegmentCurve(m_handle, figureindex, segindex, &iscurve);
        PDF_CHECK_SUCCESS(ec, "Failed to get the geometry figure segment points");
        return iscurve;
    }
 
    size_t GetFigureSegmentPointsIndex(size_t figureindex, size_t segindex) const {
        size_t pointsindex = 0;
        auto ec = GXGeometryGetFigureSegmentPointsIndex(m_handle, figureindex, segindex, &pointsindex);
        PDF_CHECK_SUCCESS(ec, "Failed to get the geometry figure segment points");
        return pointsindex;
    }
 
    bool IsFigureClosed(size_t figureindex) const {
        bool isclosed = false;
        auto ec = GXGeometryIsFigureClosed(m_handle, figureindex, &isclosed);
        PDF_CHECK_SUCCESS(ec, "Failed to get the geometry figure closed");
        return isclosed;
    }
 
    PDF_CXX_CORE_WRAPPER_DEFINE_MEMBERS_(Geometry, GXGeometry)
};
 
class Gradient : public detail::RefCountedHandle<GXGradient> {
public:
    static Gradient NewLinearGradient(const GXLinearGradientAttrs& attrs) {
        Gradient gradient;
        auto ec = GXCreateGradientLinear(&attrs, &gradient);
        PDF_CHECK_SUCCESS(ec, "Failed to create a gradient");
        return gradient;
    }
 
    static Gradient NewRadialGradient(const GXRadialGradientAttrs& attrs) {
        Gradient gradient;
        auto ec = GXCreateGradientRadial(&attrs, &gradient);
        PDF_CHECK_SUCCESS(ec, "Failed to create a gradient");
        return gradient;
    }
 
    static Gradient NewTriMeshGradient(const GXMeshVertex* vertices, size_t num_vertices, GXColorValue bgcolor) {
        Gradient gradient;
        auto ec = GXCreateGradientTriMesh(vertices, num_vertices, bgcolor, &gradient);
        PDF_CHECK_SUCCESS(ec, "Failed to create a gradient");
        return gradient;
    }
 
    PDF_CXX_CORE_WRAPPER_DEFINE_MEMBERS_(Gradient, GXGradient)
};
 
class Brush : public detail::RefCountedHandle<GXBrush> {
public:
    static Brush NewSolidBrush(const GXColor& color) {
        Brush brush;
        auto ec = GXCreateBrushSolid(&color, &brush);
        PDF_CHECK_SUCCESS(ec, "Failed to create a brush");
        return brush;
    }
 
    static Brush NewSolidBrush(GXColorValue argb) {
        Brush brush;
        auto ec = GXCreateBrushSolidARGB(argb, &brush);
        PDF_CHECK_SUCCESS(ec, "Failed to create a brush");
        return brush;
    }
 
    static Brush NewBitmapBrush(const Bitmap& bitmap,
                                const GXBitmapBrushAttrs& attrs,
                                float opacity = 1,
                                const Matrix* xform = nullptr) {
        Brush brush;
        auto ec = GXCreateBrushBitmap(bitmap.get(), opacity, &attrs, xform, &brush);
        PDF_CHECK_SUCCESS(ec, "Failed to create a brush");
        return brush;
    }
 
    static Brush NewGradientBrush(const Gradient& gradient, float opacity = 1, const Matrix* xform = nullptr) {
        Brush brush;
        auto ec = GXCreateBrushGradient(gradient.get(), opacity, xform, &brush);
        PDF_CHECK_SUCCESS(ec, "Failed to create a brush");
        return brush;
    }
 
    PDF_CXX_CORE_WRAPPER_DEFINE_MEMBERS_(Brush, GXBrush)
};
 
class Region : public detail::RefCountedHandle<GXRegion> {
public:
    static Region New() {
        Region region;
        auto ec = GXCreateRegion(&region);
        PDF_CHECK_SUCCESS(ec, "Failed to create a region");
        return region;
    }
 
    static Region NewFromRect(const RectI& rect) {
        Region region;
        auto ec = GXCreateRegionFromRect(&rect, &region);
        PDF_CHECK_SUCCESS(ec, "Failed to create a region");
        return region;
    }
 
    bool IsAreaEmpty() const {
        bool empty = false;
        auto ec = GXRegionIsAreaEmpty(m_handle, &empty);
        PDF_CHECK_SUCCESS(ec, "Failed to check the region area");
        return empty;
    }
 
    RectI GetBound() const {
        RectI bound;
        auto ec = GXRegionGetBound(m_handle, &bound);
        PDF_CHECK_SUCCESS(ec, "Failed to get the region bound");
        return bound;
    }
 
    bool Contains(const PointI& point) const {
        bool contains = false;
        auto ec = GXRegionContainsPoint(m_handle, &point, &contains);
        PDF_CHECK_SUCCESS(ec, "Failed to hit test the region");
        return contains;
    }
 
    bool Contains(const RectI& rect) const {
        bool contains = false;
        auto ec = GXRegionContainsRect(m_handle, &rect, &contains);
        PDF_CHECK_SUCCESS(ec, "Failed to hit test the region");
        return contains;
    }
 
    bool Contains(const Region& region) const {
        bool contains = false;
        auto ec = GXRegionContains(m_handle, region.get(), &contains);
        PDF_CHECK_SUCCESS(ec, "Failed to hit test the region");
        return contains;
    }
 
    bool HasIntersection(const RectI& rect) const {
        bool isects = false;
        auto ec = GXRegionHasIntersectionWithRect(m_handle, &rect, &isects);
        PDF_CHECK_SUCCESS(ec, "Failed to check the regions intersection");
        return isects;
    }
 
    bool HasIntersection(const Region& region) const {
        bool isects = false;
        auto ec = GXRegionHasIntersection(m_handle, region.get(), &isects);
        PDF_CHECK_SUCCESS(ec, "Failed to check the regions intersection");
        return isects;
    }
 
    void Offset(int dx, int dy) {
        auto ec = GXRegionOffset(m_handle, dx, dy);
        PDF_CHECK_SUCCESS(ec, "Failed to offset the region");
    }
 
    void Combine(GXCombineMode mode, const Region& region) {
        GXRegion result = nullptr;
        auto ec = GXRegionCombine(m_handle, region.get(), mode, &result);
        PDF_CHECK_SUCCESS(ec, "Failed to combine the regions");
        reset(result, true);
    }
 
    void Combine(GXCombineMode mode, const RectI& rect) {
        GXRegion result = nullptr;
        auto ec = GXRegionCombineRect(m_handle, &rect, mode, &result);
        PDF_CHECK_SUCCESS(ec, "Failed to combine the regions");
        reset(result, true);
    }
 
    using RectEnumFunc = std::function<bool(const RectI&)>;
 
    static PDErrCode PDFSDK_CALLCONV RectEnumProc_(void* userdata, const PDRectI* rect) {
        auto& func = *reinterpret_cast<RectEnumFunc*>(userdata);
        return func(*rect) ? kPDErrSuccess : kPDErrCanceled;
    }
 
    void EnumRects(RectEnumFunc func) const {
        auto ec = GXRegionEnumRects(m_handle, RectEnumProc_, &func);
        if (ec != kPDErrCanceled)
            PDF_CHECK_SUCCESS(ec, "Failed to enum the region rects");
    }
 
    PDF_CXX_CORE_WRAPPER_DEFINE_MEMBERS_(Region, GXRegion)
};
 
class RenderTarget : public detail::RefCountedHandle<GXRenderTarget> {
public:
    static RenderTarget NewBitmapRenderTarget(const Bitmap& bitmap) {
        RenderTarget target;
        auto ec = GXCreateRenderTargetBitmap(bitmap.get(), &target);
        PDF_CHECK_SUCCESS(ec, "Failed to create the render target");
        return target;
    }
 
    static RenderTarget NewExtBufRenderTarget(void* pixels,
                                              int stride,
                                              const SizeI& size,
                                              GXPixelFormat format,
                                              float dpiX = 96,
                                              float dpiY = 96) {
        RenderTarget target;
        GXBitmapAttrs attrs = {size, format, dpiX, dpiY};
        auto ec = GXCreateRenderTargetExtBuf(pixels, stride, &attrs, &target);
        PDF_CHECK_SUCCESS(ec, "Failed to create the render target");
        return target;
    }
 
#ifdef _WIN32
 
    static RenderTarget NewHwndRenderTarget(void* hwnd, GXRuntimeMode mode = kGXRuntimeModeHardware) {
        RenderTarget target;
        auto ec = GXCreateRenderTargetHWND(hwnd, mode, &target);
        PDF_CHECK_SUCCESS(ec, "Failed to create the render target");
        return target;
    }
 
    static RenderTarget NewPrintRenderTarget(void* hdc) {
        RenderTarget target;
        auto ec = GXCreateRenderTargetPrintDC(hdc, &target);
        PDF_CHECK_SUCCESS(ec, "Failed to create the render target");
        return target;
    }
 
    static RenderTarget NewHdcRenderTarget(void* hdc, const RectI* rect = nullptr) {
        RenderTarget target;
        auto ec = GXCreateRenderTargetHDC(hdc, rect, &target);
        PDF_CHECK_SUCCESS(ec, "Failed to create the render target");
        return target;
    }
 
#endif  // _WIN32
 
#ifdef __APPLE__
 
    static RenderTarget NewNSViewRenderTarget(void* nsview, GXRuntimeMode mode = kGXXRuntimeModeHardware) {
        RenderTarget target;
        auto ec = GXCreateRenderTargetNSView(nsview, mode, &target);
        PDF_CHECK_SUCCESS(ec, "Failed to create the render target");
        return target;
    }
 
#endif  // __APPLE__
 
    GXPixelFormat GetPixelFormat() {
        GXPixelFormat format = kGXPixelFormatUnknown;
        auto ec = GXRenderTargetGetPixelFormat(m_handle, &format);
        PDF_CHECK_SUCCESS(ec, "Failed to get the render target pixel format");
        return format;
    }
 
    SizeI GetSize() {
        SizeI size;
        auto ec = GXRenderTargetGetSize(m_handle, &size);
        PDF_CHECK_SUCCESS(ec, "Failed to get the render target size");
        return size;
    }
 
    void Clear(GXColorValue clrcolor) {
        auto ec = GXRenderTargetClear(m_handle, clrcolor);
        PDF_CHECK_SUCCESS(ec, "Failed to clear the render target");
    }
 
    class PaintScope {
    public:
        PaintScope(RenderTarget& target)
                : m_target(target) {
            m_target.BeginPaint();
        }
 
        ~PaintScope() {
            try {
                m_target.EndPaint();
            } catch (...) {
            }
        }
 
        PaintScope(const PaintScope&) = delete;
        PaintScope& operator=(const PaintScope&) = delete;
 
    private:
        RenderTarget& m_target;
    };
 
    void BeginPaint() {
        auto ec = GXRenderTargetBeginPaint(m_handle);
        PDF_CHECK_SUCCESS(ec, "Failed to paint the render target");
    }
 
    bool EndPaint() {
        auto ec = GXRenderTargetEndPaint(m_handle);
        PDF_CHECK_SUCCESS(ec, "Failed to paint the render target");
        return true;
    }
 
    class StateScope {
    public:
        StateScope(RenderTarget& target)
                : m_target(target) {
            m_target.PushState();
        }
 
        ~StateScope() {
            try {
                m_target.PopState();
            } catch (...) {
            }
        }
 
        StateScope(const StateScope&) = delete;
        StateScope& operator=(const StateScope&) = delete;
 
    private:
        RenderTarget& m_target;
    };
 
    void PushState() {
        auto ec = GXRenderTargetPushState(m_handle);
        PDF_CHECK_SUCCESS(ec, "Failed to push the render target state");
    }
 
    void PopState() {
        auto ec = GXRenderTargetPopState(m_handle);
        PDF_CHECK_SUCCESS(ec, "Failed to pop the render target state");
    }
 
    class CTMScope {
    public:
        CTMScope(RenderTarget& target)
                : m_target(target) {
            m_ctm = m_target.GetCTM();
        }
 
        ~CTMScope() {
            try {
                m_target.SetCTM(m_ctm);
            } catch (...) {
            }
        }
 
        CTMScope(const CTMScope&) = delete;
        CTMScope& operator=(const CTMScope&) = delete;
 
    private:
        RenderTarget& m_target;
        Matrix m_ctm;
    };
 
    Matrix GetCTM() const {
        Matrix ctm;
        auto ec = GXRenderTargetGetCTM(m_handle, &ctm);
        PDF_CHECK_SUCCESS(ec, "Failed to get the render target CTM");
        return ctm;
    }
 
    void SetCTM(const Matrix& ctm) {
        auto ec = GXRenderTargetSetCTM(m_handle, &ctm);
        PDF_CHECK_SUCCESS(ec, "Failed to modify the render target CTM");
    }
 
    void ConcatCTM(const Matrix& xform) {
        auto ec = GXRenderTargetConcatCTM(m_handle, &xform);
        PDF_CHECK_SUCCESS(ec, "Failed to modify the render target CTM");
    }
 
    void RotateCTM(float radians) {
        auto ec = GXRenderTargetRotateCTM(m_handle, radians);
        PDF_CHECK_SUCCESS(ec, "Failed to modify the render target CTM");
    }
 
    void ScaleCTM(float scale) {
        auto ec = GXRenderTargetScaleCTM(m_handle, scale, scale);
        PDF_CHECK_SUCCESS(ec, "Failed to modify the render target CTM");
    }
 
    void ScaleCTM(float sx, float sy) {
        auto ec = GXRenderTargetScaleCTM(m_handle, sx, sy);
        PDF_CHECK_SUCCESS(ec, "Failed to modify the render target CTM");
    }
 
    void ScaleCTM(const SizeF& scale) {
        auto ec = GXRenderTargetScaleCTM(m_handle, scale.width, scale.height);
        PDF_CHECK_SUCCESS(ec, "Failed to modify the render target CTM");
    }
 
    void TranslateCTM(float dx, float dy) {
        auto ec = GXRenderTargetTranslateCTM(m_handle, dx, dy);
        PDF_CHECK_SUCCESS(ec, "Failed to modify the render target CTM");
    }
 
    void TranslateCTM(const PointF& delta) {
        auto ec = GXRenderTargetTranslateCTM(m_handle, delta.x, delta.y);
        PDF_CHECK_SUCCESS(ec, "Failed to modify the render target CTM");
    }
 
    void SetBlendMode(GXBlendMode mode) {
        auto ec = GXRenderTargetSetBlendMode(m_handle, mode);
        PDF_CHECK_SUCCESS(ec, "Failed to set the render target blend mode");
    }
 
    void SetStrokeAdjustment(bool adjust) {
        auto ec = GXRenderTargetSetStrokeAdjustment(m_handle, adjust);
        PDF_CHECK_SUCCESS(ec, "Failed to set the render target stroke adjust");
    }
 
    bool GetStrokeAdjustment() const {
        bool adjust = false;
        auto ec = GXRenderTargetGetStrokeAdjustment(m_handle, &adjust);
        PDF_CHECK_SUCCESS(ec, "Failed to get the render target stroke adjust");
        return adjust;
    }
 
    void SetOpacityMask(GXMaskMode mode, const Brush& mask) {
        auto ec = GXRenderTargetSetOpacityMask(m_handle, mode, mask.get());
        PDF_CHECK_SUCCESS(ec, "Failed to set the render target mask");
    }
 
    void SetShapeMask(GXMaskMode mode, const Brush& mask) {
        auto ec = GXRenderTargetSetShapeMask(m_handle, mode, mask.get());
        PDF_CHECK_SUCCESS(ec, "Failed to set the render target mask");
    }
 
    void BeginLayer(const GXLayerParams& params) {
        auto ec = GXRenderTargetBeginLayer(m_handle, &params);
        PDF_CHECK_SUCCESS(ec, "Failed to paint the render target");
    }
 
    void EndLayer() {
        auto ec = GXRenderTargetEndLayer(m_handle);
        PDF_CHECK_SUCCESS(ec, "Failed to paint the render target");
    }
 
    void FillGeometry(const Geometry& geom, const Brush& brush) {
        auto ec = GXRenderTargetFillGeometry(m_handle, geom.get(), brush.get());
        PDF_CHECK_SUCCESS(ec, "Failed to paint the render target");
    }
 
    void FillTextGeometry(const Geometry& geom, const Brush& brush) {
        auto ec = GXRenderTargetFillTextGeometry(m_handle, geom.get(), brush.get());
        PDF_CHECK_SUCCESS(ec, "Failed to paint the render target");
    }
 
    void FillRect(const RectF& rect, const Brush& brush) {
        auto ec = GXRenderTargetFillRect(m_handle, &rect, brush.get());
        PDF_CHECK_SUCCESS(ec, "Failed to paint the render target");
    }
 
    void FillEllipse(const RectF& bound, const Brush& brush) {
        auto ec = GXRenderTargetFillEllipse(m_handle, &bound, brush.get());
        PDF_CHECK_SUCCESS(ec, "Failed to paint the render target");
    }
 
    void StrokeGeometry(const Geometry& geom, const Brush& brush, float width, const GXStrokeParams* params = nullptr) {
        auto ec = GXRenderTargetStrokeGeometry(m_handle, geom.get(), brush.get(), width, params);
        PDF_CHECK_SUCCESS(ec, "Failed to paint the render target");
    }
 
    void StrokeLine(const PointF& start,
                    const PointF& end,
                    const Brush& brush,
                    float width,
                    const GXStrokeParams* params = nullptr) {
        auto ec = GXRenderTargetStrokeLine(m_handle, &start, &end, brush.get(), width, params);
        PDF_CHECK_SUCCESS(ec, "Failed to paint the render target");
    }
 
    void StrokeRect(const RectF& rect, const Brush& brush, float width, const GXStrokeParams* params = nullptr) {
        auto ec = GXRenderTargetStrokeRect(m_handle, &rect, brush.get(), width, params);
        PDF_CHECK_SUCCESS(ec, "Failed to paint the render target");
    }
 
    void StrokeEllipse(const RectF& bound, const Brush& brush, float width, const GXStrokeParams* params = nullptr) {
        auto ec = GXRenderTargetStrokeEllipse(m_handle, &bound, brush.get(), width, params);
        PDF_CHECK_SUCCESS(ec, "Failed to paint the render target");
    }
 
    void ClipGeometry(const Geometry& geom) {
        auto ec = GXRenderTargetClipGeometry(m_handle, geom.get());
        PDF_CHECK_SUCCESS(ec, "Failed to paint the render target");
    }
 
    void ClipRect(const RectF& rect) {
        auto ec = GXRenderTargetClipRect(m_handle, &rect);
        PDF_CHECK_SUCCESS(ec, "Failed to paint the render target");
    }
 
    void ClipEllipse(const RectF& bound) {
        auto ec = GXRenderTargetClipEllipse(m_handle, &bound);
        PDF_CHECK_SUCCESS(ec, "Failed to paint the render target");
    }
 
    void DrawBitmap(const Bitmap& bitmap,
                    float opacity = 1,
                    GXInterpolationMode imode = kGXInterpolationModeAreaAverage) {
        auto ec = GXRenderTargetDrawBitmap(m_handle, bitmap.get(), opacity, imode);
        PDF_CHECK_SUCCESS(ec, "Failed to paint the render target");
    }
 
    void StretchBitmap(const Bitmap& bitmap,
                       const RectF& target_rect,
                       float opacity = 1,
                       GXInterpolationMode imode = kGXInterpolationModeAreaAverage) {
        auto ec = GXRenderTargetStretchBitmap(m_handle, bitmap.get(), &target_rect, opacity, imode);
        PDF_CHECK_SUCCESS(ec, "Failed to paint the render target");
    }
 
    void DrawGradient(const Gradient& gradient, float opacity) {
        auto ec = GXRenderTargetDrawGradient(m_handle, gradient.get(), opacity);
        PDF_CHECK_SUCCESS(ec, "Failed to paint the render target");
    }
 
    void FillMask(const Bitmap& mask,
                  const Brush& brush,
                  GXInterpolationMode imode = kGXInterpolationModeAreaAverage) {
        auto ec = GXRenderTargetFillMask(m_handle, mask.get(), brush.get(), imode);
        PDF_CHECK_SUCCESS(ec, "Failed to paint the render target");
    }
 
    void InvertRect(const RectF& rect) {
        auto ec = GXRenderTargetInvertRect(m_handle, &rect);
        PDF_CHECK_SUCCESS(ec, "Failed to paint the render target");
    }
 
    void InvertLine(const PointI& start, const PointI& end) {
        auto ec = GXRenderTargetInvertLine(m_handle, &start, &end);
        PDF_CHECK_SUCCESS(ec, "Failed to paint the render target");
    }
 
    void FillText(const FontFace& font, float fontSize, const std::wstring& text, const Brush& brush) {
        auto ec = GXRenderTargetFillText(m_handle, font.get(), fontSize, text.c_str(), brush.get());
        PDF_CHECK_SUCCESS(ec, "Failed to paint the render target");
    }
 
    RectI GetDrawBounds() {
        RectI bounds;
        auto ec = GXRenderTargetGetDrawBounds(m_handle, &bounds);
        PDF_CHECK_SUCCESS(ec, "Failed to get the render target draw bounds");
        return bounds;
    }
 
    PDF_CXX_CORE_WRAPPER_DEFINE_MEMBERS_(RenderTarget, GXRenderTarget)
};
 
}  // namespace Graphics
}  // namespace PDF
 
#endif  // PDFSDK_CXX_GRAPHICS_H_INCLUDED_