graphics.h

// Copyright (c) 2009-2025 Avanquest Software. All rights reserved.
 
#ifndef PDFSDK_CXX_GRAPHICS_H_INCLUDED_
#define PDFSDK_CXX_GRAPHICS_H_INCLUDED_
 
#include <cstdint>
#include <filesystem>
#include <format>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
#include <pdfsdk/cxx/bytes.h>
#include <pdfsdk/cxx/callback.h>
#include <pdfsdk/cxx/helpers.h>
#include <pdfsdk/cxx/math.h>
#include <pdfsdk/cxx/read_stream.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(std::span<const Byte> data, uint32_t frame_index = 0, uint32_t* ptotal_frames = nullptr) {
        Bitmap bitmap;
        auto ec = GXCreateBitmapFromMemoryFrame(data.data(), 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, std::format("Failed to save the bitmap to {}", path.string()));
    }
 
#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 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 SystemFont : public detail::RefCountedHandle<GXSysFont> {
public:
    std::wstring GetFamilyName() const {
        return detail::GetWstringProperty(GXSysFontGetFamilyName, m_handle);
    }
 
    std::wstring GetPostScriptName() const {
        return detail::GetWstringProperty(GXSysFontGetPostScriptName, m_handle);
    }
 
    std::wstring GetFontName() const {
        return detail::GetWstringProperty(GXSysFontGetFontName, m_handle);
    }
 
    GXFontStyle GetStyle() const {
        GXFontStyle style = kGXFontStyleRegular;
        PDF_CHECK_SUCCESS_X(GXSysFontGetStyle(m_handle, &style));
        return style;
    }
 
    GXFontFlags GetFontFlags() const {
        GXFontFlags flags = 0;
        PDF_CHECK_SUCCESS_X(GXSysFontGetFontFlags(m_handle, &flags));
        return flags;
    }
 
    std::vector<GXUnicodeRange> GetUnicodeRanges() const {
        size_t num_ranges = 0;
        auto ec = GXSysFontGetUnicodeRanges(m_handle, nullptr, 0, &num_ranges);
        if (ec == kPDErrSuccess)
            return {};
        if (ec != kPDErrBufferTooSmall)
            PDF_CHECK_SUCCESS_X(ec);
        std::vector<GXUnicodeRange> ranges(num_ranges);
        PDF_CHECK_SUCCESS_X(GXSysFontGetUnicodeRanges(m_handle, ranges.data(), num_ranges, &num_ranges));
        return ranges;
    }
 
    PDF_CXX_CORE_WRAPPER_DEFINE_MEMBERS_(SystemFont, GXSysFont)
};
 
inline std::vector<SystemFont> ListSystemFonts() {
    std::vector<SystemFont> fonts;
    auto ec = GXEnumSysFonts(
            [](void* userdata, GXSysFont sysfont) -> PDErrCode {
                PDFSDK_CALLBACK_BEGIN
                    auto fonts = static_cast<std::vector<SystemFont>*>(userdata);
                    fonts->emplace_back(sysfont);
                    return kPDErrSuccess;
                PDFSDK_CALLBACK_END
            },
            &fonts);
    PDF_CHECK_SUCCESS_X(ec);
    return fonts;
}
 
inline SystemFont FindSystemFont(const GXSysFontQuery& query) {
    SystemFont sysfont;
    auto ec = GXFindSysFont(&query, &sysfont);
    if (ec == kPDErrNotFound)
        return nullptr;
 
    PDF_CHECK_SUCCESS_X(ec);
    return sysfont;
}
 
inline SystemFont FindSystemFont(const std::wstring& family, GXFontStyle style = kGXFontStyleRegular) {
    GXSysFontQuery query = {};
    query.matchFlags = kGXSysFontQueryMatchFamily | kGXSysFontQueryMatchWeight | kGXSysFontQueryMatchItalic;
    query.family = family.c_str();
    query.style = style;
    return FindSystemFont(query);
}

constexpr uint32_t MakeOpenTypeTag(std::string_view tag) {
    auto result = uint32_t(0);
    for (int i = 0; i < 4; ++i) {
        const char c = static_cast<size_t>(i) < tag.size() ? tag[i] : ' ';
        result = (result << 8) | static_cast<uint8_t>(c);
    }
    return result;
}

struct FontVariationAxisValue {
    uint32_t tag;  
    float value;   
};

struct FontVariationAxisInfo {
    uint32_t tag;        
    float minValue;      
    float defaultValue;  
    float maxValue;      
    std::wstring name;   
};

struct FontVariationInstanceInfo {
    std::wstring name;                               
    std::vector<FontVariationAxisValue> axisValues;  
};

class FontFace : public detail::RefCountedHandle<GXFontFace> {
public:
    static FontFace FromSystemFont(const SystemFont& sysfont) {
        FontFace fontface;
        auto ec = GXCreateFontFaceFromSysFont(sysfont.get(), &fontface);
        if (ec == kPDErrNotFound)
            return nullptr;
        PDF_CHECK_SUCCESS(ec, "Failed to create a font face");
        return fontface;
    }
 
    static FontFace FromSystemFont(const std::wstring& family, GXFontStyle style = kGXFontStyleRegular) {
        auto sysfont = FindSystemFont(family, style);
        return FromSystemFont(sysfont);
    }
 
    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(std::span<const Byte> data, bool copyData = true, uint32_t faceindex = 0, uint32_t* ptotalfaces = nullptr) {
        FontFace fontface;
        auto ec = GXCreateFontFaceFromMemory(data.data(), data.size(), copyData, faceindex, ptotalfaces, &fontface);
        PDF_CHECK_SUCCESS(ec, "Failed to load a bitmap from memory");
        return fontface;
    }
 
    std::wstring GetFamilyName() const {
        return detail::GetWstringProperty(GXFontFaceGetFamilyName, m_handle);
    }
 
    std::wstring GetPostScriptName() const {
        return detail::GetWstringProperty(GXFontFaceGetPostScriptName, m_handle);
    }
 
    std::wstring GetFontName() const {
        return detail::GetWstringProperty(GXFontFaceGetFontName, m_handle);
    }
 
    GXFontStyle GetStyle() const {
        GXFontStyle style = kGXFontStyleRegular;
        PDF_CHECK_SUCCESS_X(GXFontFaceGetStyle(m_handle, &style));
        return style;
    }
 
    GXFontFlags GetFontFlags() const {
        GXFontFlags flags = 0;
        PDF_CHECK_SUCCESS_X(GXFontFaceGetFontFlags(m_handle, &flags));
        return flags;
    }
 
    std::vector<GXUnicodeRange> GetUnicodeRanges() const {
        size_t num_ranges = 0;
        auto ec = GXFontFaceGetUnicodeRanges(m_handle, nullptr, 0, &num_ranges);
        if (ec == kPDErrSuccess)
            return {};
        if (ec != kPDErrBufferTooSmall)
            PDF_CHECK_SUCCESS_X(ec);
        std::vector<GXUnicodeRange> ranges(num_ranges);
        PDF_CHECK_SUCCESS_X(GXFontFaceGetUnicodeRanges(m_handle, ranges.data(), num_ranges, &num_ranges));
        return ranges;
    }
 
    GXFontMetrics GetMetrics() const {
        GXFontMetrics metrics;
        auto ec = GXFontFaceGetMetrics(m_handle, &metrics);
        PDF_CHECK_SUCCESS(ec, "Failed to get the font metrics");
        return metrics;
    }
 
    uint32_t GetGlyphIndex(uint32_t unicode) const {
        uint32_t gid = 0;
        auto ec = GXFontFaceGetGlyphIndex(m_handle, unicode, &gid);
        PDF_CHECK_SUCCESS(ec, "Failed to get the glyph index");
        return gid;
    }
 
    bool HasGlyph(uint32_t unicode) const {
        return GetGlyphIndex(unicode) != 0;
    }
 
    uint32_t GetGlyphAdvance(uint32_t glyphIndex) const {
        uint32_t advance = 0;
        auto ec = GXFontFaceGetGlyphAdvance(m_handle, glyphIndex, &advance);
        PDF_CHECK_SUCCESS(ec, "Failed to get the glyph advance");
        return advance;
    }

    void RenderGlyphOutline(uint32_t glyphIndex, Geometry geometry, const Matrix& transform = Matrix()) const {
        auto ec = GXFontFaceRenderGlyphOutline(m_handle, glyphIndex, &transform, geometry.get());
        PDF_CHECK_SUCCESS(ec, "Failed to render the glyph outline");
    }
 
    /*
     * Opens a stream for reading a specific table in the font.
     * @param tableTag The tag of the table to open. If 0, the entire font data is returned.
     * @return A read stream for the table data.
     */
    ReadStream OpenFontStream(uint32_t tableTag = 0) const {
        ReadStream stream;
        auto ec = GXFontFaceOpenFontStream(m_handle, tableTag, &stream);
        PDF_CHECK_SUCCESS(ec, "Failed to open the font table stream");
        return stream;
    }

    std::vector<FontVariationAxisInfo> GetVariationAxes() const {
        size_t numAxes = 0;
        PDF_CHECK_SUCCESS_X(GXFontFaceGetNumVariationAxes(m_handle, &numAxes));
 
        std::vector<FontVariationAxisInfo> axes;
        axes.reserve(numAxes);
        for (size_t i = 0; i < numAxes; ++i) {
            GXFontVariationAxisInfo info = {};
            PDF_CHECK_SUCCESS_X(GXFontFaceGetVariationAxis(m_handle, i, &info));
 
            FontVariationAxisInfo axis{info.tag, info.minValue, info.defaultValue, info.maxValue, {}};
 
            size_t nameSize = 0;
            auto ec = GXFontFaceGetVariationAxisName(m_handle, info.tag, nullptr, 0, &nameSize);
            if (ec != kPDErrSuccess && ec != kPDErrBufferTooSmall)
                PDF_CHECK_SUCCESS_X(ec);
            if (ec == kPDErrBufferTooSmall) {
                axis.name.resize(nameSize);
                PDF_CHECK_SUCCESS_X(GXFontFaceGetVariationAxisName(m_handle, info.tag, axis.name.data(), nameSize, &nameSize));
            }
 
            axes.push_back(std::move(axis));
        }
        return axes;
    }

    std::vector<FontVariationInstanceInfo> GetVariationInstances() const {
        size_t numInstances = 0;
        PDF_CHECK_SUCCESS_X(GXFontFaceGetNumVariationInstances(m_handle, &numInstances));
 
        std::vector<FontVariationInstanceInfo> instances;
        instances.reserve(numInstances);
        for (size_t i = 0; i < numInstances; ++i) {
            FontVariationInstanceInfo instance;
 
            size_t nameSize = 0;
            auto ec = GXFontFaceGetVariationInstanceName(m_handle, i, nullptr, 0, &nameSize);
            if (ec != kPDErrSuccess && ec != kPDErrBufferTooSmall)
                PDF_CHECK_SUCCESS_X(ec);
            if (ec == kPDErrBufferTooSmall) {
                instance.name.resize(nameSize);
                PDF_CHECK_SUCCESS_X(GXFontFaceGetVariationInstanceName(m_handle, i, instance.name.data(), nameSize, &nameSize));
            }
 
            size_t numAxisValues = 0;
            ec = GXFontFaceGetVariationInstanceAxisValues(m_handle, i, nullptr, 0, &numAxisValues);
            if (ec != kPDErrSuccess && ec != kPDErrBufferTooSmall)
                PDF_CHECK_SUCCESS_X(ec);
            if (ec == kPDErrBufferTooSmall) {
                std::vector<GXFontVariationAxisValue> axisValues(numAxisValues);
                PDF_CHECK_SUCCESS_X(GXFontFaceGetVariationInstanceAxisValues(m_handle, i, axisValues.data(), numAxisValues, &numAxisValues));
 
                instance.axisValues.reserve(numAxisValues);
                for (const auto& axisValue : axisValues)
                    instance.axisValues.push_back({axisValue.tag, axisValue.value});
            }
 
            instances.push_back(std::move(instance));
        }
        return instances;
    }

    std::vector<FontVariationAxisValue> GetVariation() const {
        size_t numValues = 0;
        auto ec = GXFontFaceGetVariation(m_handle, nullptr, 0, &numValues);
        if (ec == kPDErrSuccess)
            return {};
        if (ec != kPDErrBufferTooSmall)
            PDF_CHECK_SUCCESS_X(ec);
 
        std::vector<GXFontVariationAxisValue> values(numValues);
        PDF_CHECK_SUCCESS_X(GXFontFaceGetVariation(m_handle, values.data(), numValues, &numValues));
 
        std::vector<FontVariationAxisValue> result;
        result.reserve(numValues);
        for (const auto& value : values)
            result.push_back({value.tag, value.value});
        return result;
    }

    void SetVariation(std::span<const FontVariationAxisValue> axisValues) const {
        std::vector<GXFontVariationAxisValue> values;
        values.reserve(axisValues.size());
        for (const FontVariationAxisValue& axisValue : axisValues)
            values.push_back({axisValue.tag, axisValue.value});
 
        auto ec = GXFontFaceSetVariation(m_handle, values.data(), values.size());
        PDF_CHECK_SUCCESS(ec, "Failed to set the font variation");
    }

    void SelectVariationInstance(std::wstring_view instanceName) const {
        for (const FontVariationInstanceInfo& instance : GetVariationInstances()) {
            if (instance.name == instanceName) {
                SetVariation(instance.axisValues);
                return;
            }
        }
        PDF_THROW(kPDErrNotFound, "No such named instance");
    }
 
    PDF_CXX_CORE_WRAPPER_DEFINE_MEMBERS_(FontFace, GXFontFace)
};

class SystemFontsHandler {
public:
    virtual ~SystemFontsHandler() = default;

    class FontEntry {
    public:
        virtual ~FontEntry() = default;
        virtual std::wstring GetFamilyName() = 0;
        virtual std::wstring GetPostScriptName() = 0;
        virtual std::wstring GetFontName() = 0;
        virtual GXFontStyle GetStyle() = 0;
        virtual GXFontFlags GetFontFlags() = 0;
        virtual std::vector<GXUnicodeRange> GetUnicodeRanges() = 0;
        virtual FontFace LoadFontFace() = 0;
    };
 
    using FontEntryPtr = std::shared_ptr<FontEntry>;

    virtual std::vector<FontEntryPtr> ListFonts() = 0;
};
 
namespace details {
 
inline const GXSysFontsHandler& GetGXSysFontsHandler() {
 
    struct GXSysFontsHandlerFontData {
        std::shared_ptr<SystemFontsHandler> handler;
        SystemFontsHandler::FontEntryPtr font;
    };
 
    static const GXSysFontsHandler sysFontsHandler = {
            .enumFonts = [](void* handlerData, GXSysFontCustomEnumProc proc, void* userdata) -> PDErrCode {
                PDFSDK_CALLBACK_BEGIN
                    auto handler = *static_cast<std::shared_ptr<SystemFontsHandler>*>(handlerData);
                    for (SystemFontsHandler::FontEntryPtr& font : handler->ListFonts()) {
                        if (!font)
                            continue;
                        auto fontData = std::make_unique<GXSysFontsHandlerFontData>(handler, std::move(font));
                        auto ec = proc(userdata, fontData.get());
                        if (ec != kPDErrSuccess)
                            return ec;
                        fontData.release();  // handed over to the SDK, which frees it via freeFontData
                    }
                    return kPDErrSuccess;
                PDFSDK_CALLBACK_END
            },
            .getFamilyName = [](void* fontData, wchar_t* buffer, size_t bufsize, size_t* psize) -> PDErrCode {
                PDFSDK_CALLBACK_BEGIN
                    const auto& font = static_cast<GXSysFontsHandlerFontData*>(fontData)->font;
                    return CopyDataToBuffer(font->GetFamilyName(), buffer, bufsize, psize);
                PDFSDK_CALLBACK_END
            },
            .getPostScriptName = [](void* fontData, wchar_t* buffer, size_t bufsize, size_t* psize) -> PDErrCode {
                PDFSDK_CALLBACK_BEGIN
                    const auto& font = static_cast<GXSysFontsHandlerFontData*>(fontData)->font;
                    return CopyDataToBuffer(font->GetPostScriptName(), buffer, bufsize, psize);
                PDFSDK_CALLBACK_END
            },
            .getFontName = [](void* fontData, wchar_t* buffer, size_t bufsize, size_t* psize) -> PDErrCode {
                PDFSDK_CALLBACK_BEGIN
                    const auto& font = static_cast<GXSysFontsHandlerFontData*>(fontData)->font;
                    return CopyDataToBuffer(font->GetFontName(), buffer, bufsize, psize);
                PDFSDK_CALLBACK_END
            },
            .getStyle = [](void* fontData, GXFontStyle* pStyle) -> PDErrCode {
                PDFSDK_CALLBACK_BEGIN
                    const auto& font = static_cast<GXSysFontsHandlerFontData*>(fontData)->font;
                    *pStyle = font->GetStyle();
                    return kPDErrSuccess;
                PDFSDK_CALLBACK_END
            },
            .getFontFlags = [](void* fontData, GXFontFlags* pFlags) -> PDErrCode {
                PDFSDK_CALLBACK_BEGIN
                    const auto& font = static_cast<GXSysFontsHandlerFontData*>(fontData)->font;
                    *pFlags = font->GetFontFlags();
                    return kPDErrSuccess;
                PDFSDK_CALLBACK_END
            },
            .getUnicodeRanges = [](void* fontData, GXUnicodeRange* buffer, size_t bufsize, size_t* psize) -> PDErrCode {
                PDFSDK_CALLBACK_BEGIN
                    const auto& font = static_cast<GXSysFontsHandlerFontData*>(fontData)->font;
                    return CopyDataToBuffer(font->GetUnicodeRanges(), buffer, bufsize, psize);
                PDFSDK_CALLBACK_END
            },
            .loadFontFace = [](void* fontData, GXFontFace* pFontFace) -> PDErrCode {
                PDFSDK_CALLBACK_BEGIN
                    const auto& font = static_cast<GXSysFontsHandlerFontData*>(fontData)->font;
                    *pFontFace = font->LoadFontFace().detach();
                    return kPDErrSuccess;
                PDFSDK_CALLBACK_END
            },
            .freeFontData = [](void* fontData) {
                delete static_cast<GXSysFontsHandlerFontData*>(fontData);
            },
            .freeHandlerData = [](void* handlerData) {
                delete static_cast<std::shared_ptr<SystemFontsHandler>*>(handlerData);
            }};
    return sysFontsHandler;
}
 
}  // namespace details

inline GXSysFontsHandlerID AddSystemFontsHandler(std::shared_ptr<SystemFontsHandler> handler) {
    PDF_CHECK(handler, kPDErrBadParam, "handler cannot be null");
    auto handlerData = std::make_unique<std::shared_ptr<SystemFontsHandler>>(std::move(handler));
    GXSysFontsHandlerID handlerId = 0;
    auto ec = GXAddCustomSysFontsHandler(&details::GetGXSysFontsHandler(), handlerData.get(), &handlerId);
    PDF_CHECK_SUCCESS(ec, "Failed to add a system fonts handler");
    handlerData.release();
    return handlerId;
}

inline GXSysFontsHandlerID AddSystemFontsDirectory(const std::filesystem::path& directory) {
    auto directory_string = directory.wstring();
    GXSysFontsHandlerID handlerId = 0;
    auto ec = GXAddDirectorySysFontsHandler(directory_string.c_str(), &handlerId);
    PDF_CHECK_SUCCESS(ec, "Failed to add a system fonts directory");
    return handlerId;
}

inline void SetSystemFontsHandler(std::shared_ptr<SystemFontsHandler> handler) {
    PDF_CHECK(handler, kPDErrBadParam, "handler cannot be null");
    auto handlerData = std::make_unique<std::shared_ptr<SystemFontsHandler>>(std::move(handler));
    auto ec = GXSetCustomSysFontsHandler(&details::GetGXSysFontsHandler(), handlerData.get());
    PDF_CHECK_SUCCESS(ec, "Failed to set the system fonts handler");
    handlerData.release();
}

inline void SetSystemFontsDirectory(const std::filesystem::path& directory) {
    auto directory_string = directory.wstring();
    auto ec = GXSetDirectorySysFontsHandler(directory_string.c_str());
    PDF_CHECK_SUCCESS(ec, "Failed to set the system fonts directory");
}

inline bool RemoveSystemFontsHandler(GXSysFontsHandlerID handlerId) {
    auto ec = GXRemoveSysFontsHandler(handlerId);
    if (ec == kPDErrNotFound)
        return false;
 
    PDF_CHECK_SUCCESS(ec, "Failed to remove the system fonts handler");
    return true;
}

inline void ResetSystemFontsHandlers() {
    auto ec = GXResetSysFontsHandlers();
    PDF_CHECK_SUCCESS(ec, "Failed to reset the system fonts handlers");
}

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(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) {
        Region result;
        auto ec = GXRegionCombine(m_handle, region.get(), mode, &result);
        PDF_CHECK_SUCCESS(ec, "Failed to combine the regions");
        *this = std::move(result);
    }
 
    void Combine(GXCombineMode mode, const RectI& rect) {
        Region result;
        auto ec = GXRegionCombineRect(m_handle, &rect, mode, &result);
        PDF_CHECK_SUCCESS(ec, "Failed to combine the regions");
        *this = std::move(result);
    }
 
    using RectEnumFunc = std::function<bool(const RectI&)>;
 
    void EnumRects(RectEnumFunc func) const {
        auto enumProc = [](void* userdata, const PDRectI* rect) -> PDErrCode {
            PDFSDK_CALLBACK_BEGIN
                auto& func = *reinterpret_cast<RectEnumFunc*>(userdata);
                return func(*rect) ? kPDErrSuccess : kPDErrCanceled;
            PDFSDK_CALLBACK_END
        };
        auto ec = GXRegionEnumRects(m_handle, enumProc, &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
 
    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");
    }
 
    void EndPaint() {
        auto ec = GXRenderTargetEndPaint(m_handle);
        PDF_CHECK_SUCCESS(ec, "Failed to paint the render target");
    }
 
    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;
    }
 
    float GetDpiX() const {
        float dpiX = 96.0f;
        auto ec = GXRenderTargetGetDpiX(m_handle, &dpiX);
        PDF_CHECK_SUCCESS(ec, "Failed to get the render target DPI X");
        return dpiX;
    }
 
    float GetDpiY() const {
        float dpiY = 96.0f;
        auto ec = GXRenderTargetGetDpiY(m_handle, &dpiY);
        PDF_CHECK_SUCCESS(ec, "Failed to get the render target DPI Y");
        return dpiY;
    }
 
    PDF_CXX_CORE_WRAPPER_DEFINE_MEMBERS_(RenderTarget, GXRenderTarget)
};
 
}  // namespace Graphics
}  // namespace PDF
 
#endif  // PDFSDK_CXX_GRAPHICS_H_INCLUDED_