novasvg.h

Go to the documentation of this file.

/*
 * MIT License
 *
 * Copyright (c) 2023-present Mohammad Raziei
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
*/
 
 
#ifndef NOVASVG_H
#define NOVASVG_H
#pragma once
 
#include <cstdint>
#include <memory>
#include <string>
#include <cctype>
#include <vector>
 
// True header-only linkage: every function/method defined in the detail/
// implementation headers is marked NOVASVG_INLINE (plain `inline`), so
// this whole library -- including its rendering backend -- can safely be
// #included from any number of translation units with no separate
// "#define NOVASVG_IMPLEMENTATION in exactly one .cpp" step required.
#ifndef NOVASVG_INLINE
#define NOVASVG_INLINE inline
#endif
 
// NovaSVG is header-only: every function is NOVASVG_INLINE, so the default
// linkage must NOT be dllimport/dllexport. On MSVC, __declspec(dllimport) on
// an inline-defined function suppresses the inline body and produces LNK2019
// unresolved externals. Shared-library decoration is therefore opt-in via
// NOVASVG_BUILD_SHARED.
#if defined(NOVASVG_BUILD_STATIC) || !defined(NOVASVG_BUILD_SHARED)
#define NOVASVG_EXPORT
#define NOVASVG_IMPORT
#elif (defined(_WIN32) || defined(__CYGWIN__))
#define NOVASVG_EXPORT __declspec(dllexport)
#define NOVASVG_IMPORT __declspec(dllimport)
#elif defined(__GNUC__) && (__GNUC__ >= 4)
#define NOVASVG_EXPORT __attribute__((__visibility__("default")))
#define NOVASVG_IMPORT
#else
#define NOVASVG_EXPORT
#define NOVASVG_IMPORT
#endif
 
#ifdef NOVASVG_BUILD
#define NOVASVG_API NOVASVG_EXPORT
#else
#define NOVASVG_API NOVASVG_IMPORT
#endif
 
// Plain ternary macros instead of std::max/std::min. A uniquely-prefixed
// macro can never collide with anything, which a bare `std::max`/
// `std::min` call genuinely can: <windows.h> (pulled in transitively by
// Python.h and friends on a Windows build) `#define`s `max`/`min` as
// object-like macros unless NOMINMAX is defined first, and since that's
// a build-system concern novasvg can't force on every consumer of a
// header-only library, this codebase calls these instead of std::max/
// std::min directly wherever it needs a two-argument max/min. Same
// pattern the vendored FreeType rasterizer already uses for its own
// internals (PVG_FT_MIN/PVG_FT_MAX in detail/render/vendor/), just
// under this project's own prefix for general-purpose call sites.
// ponytail: no protection against double-evaluating a/b if either has
// side effects -- fine for every current call site (plain variable/
// member reads), just don't reach for these with e.g. `x++` as an
// argument.
#ifndef NOVASVG_MAX
#define NOVASVG_MAX(a, b) ((a) > (b) ? (a) : (b))
#endif
#ifndef NOVASVG_MIN
#define NOVASVG_MIN(a, b) ((a) < (b) ? (a) : (b))
#endif
 
#define NOVASVG_VERSION_MAJOR 0
#define NOVASVG_VERSION_MINOR 10
#define NOVASVG_VERSION_PATCH 0
 
#define NOVASVG_VERSION_ENCODE(major, minor, patch) (((major) * 10000) + ((minor) * 100) + ((patch) * 1))
#define NOVASVG_VERSION NOVASVG_VERSION_ENCODE(NOVASVG_VERSION_MAJOR, NOVASVG_VERSION_MINOR, NOVASVG_VERSION_PATCH)
 
#define NOVASVG_VERSION_XSTRINGIZE(major, minor, patch) #major"."#minor"."#patch
#define NOVASVG_VERSION_STRINGIZE(major, minor, patch) NOVASVG_VERSION_XSTRINGIZE(major, minor, patch)
#define NOVASVG_VERSION_STRING NOVASVG_VERSION_STRINGIZE(NOVASVG_VERSION_MAJOR, NOVASVG_VERSION_MINOR, NOVASVG_VERSION_PATCH)
 
#include "detail/color.h"
 
namespace novasvg {
namespace render {
struct surface;
struct matrix;
using surface_t = surface;
using matrix_t = matrix;
} // namespace render
} // namespace novasvg
 
typedef void (*novasvg_destroy_func_t)(void* closure);
 
typedef void (*novasvg_write_func_t)(void* closure, void* data, int size);
 
 
namespace novasvg {
using namespace render;
 
int version();
 
std::string versionString();
 
} // namespace novasvg
 
#include "detail/font.h"
 
#include "detail/bitmap.h"
 
namespace novasvg {
using namespace render;
 
class Rect;
class Matrix;
 
class NOVASVG_API Box {
public:
    Box() = default;
 
    Box(float x, float y, float w, float h);
 
    Box(const Rect& rect);
 
    Box& transform(const Matrix& matrix);
 
    Box transformed(const Matrix& matrix) const;
 
    float x{0}; 
    float y{0}; 
    float w{0}; 
    float h{0}; 
};
 
class Transform;
 
class NOVASVG_API Matrix {
public:
    Matrix() = default;
 
    Matrix(float a, float b, float c, float d, float e, float f);
 
    Matrix(const matrix_t& matrix);
 
    Matrix(const Transform& transform);
 
    Matrix operator*(const Matrix& matrix) const;
 
    Matrix& operator*=(const Matrix& matrix);
 
    Matrix& multiply(const Matrix& matrix);
 
    Matrix& translate(float tx, float ty);
 
    Matrix& scale(float sx, float sy);
 
    Matrix& rotate(float angle, float cx = 0.f, float cy = 0.f);
 
    Matrix& shear(float shx, float shy);
 
    Matrix& invert();
 
    Matrix inverse() const;
 
    void reset();
 
    static Matrix translated(float tx, float ty);
 
    static Matrix scaled(float sx, float sy);
 
    static Matrix rotated(float angle, float cx = 0.f, float cy = 0.f);
 
    static Matrix sheared(float shx, float shy);
 
    float a{1}; 
    float b{0}; 
    float c{0}; 
    float d{1}; 
    float e{0}; 
    float f{0}; 
};
 
class SVGNode;
class SVGTextNode;
class SVGElement;
 
class Element;
class TextNode;
 
class NOVASVG_API Node {
public:
    Node() = default;
 
    bool isTextNode() const;
 
    bool isElement() const;
 
    TextNode toTextNode() const;
 
    Element toElement() const;
 
    Element parentElement() const;
 
    bool isNull() const { return m_node == nullptr; }
 
    operator bool() const { return !isNull(); }
 
    bool operator==(const Node& node) const { return m_node == node.m_node; }
 
    bool operator!=(const Node& node) const { return m_node != node.m_node; }
 
protected:
    Node(SVGNode* node);
    SVGNode* node() const { return m_node; }
    SVGNode* m_node{nullptr};
    friend class Element;
};
 
using NodeList = std::vector<Node>;
 
class NOVASVG_API TextNode : public Node {
public:
    TextNode() = default;
 
    const std::string& data() const;
 
    void setData(const std::string& data);
 
private:
    TextNode(SVGTextNode* text);
    SVGTextNode* text() const;
    friend class Node;
};
 
class NOVASVG_API Element : public Node {
public:
    Element() = default;
 
    bool hasAttribute(const std::string& name) const;
 
    const std::string& getAttribute(const std::string& name) const;
 
    void setAttribute(const std::string& name, const std::string& value);
 
    void render(Bitmap& bitmap, const Matrix& matrix = Matrix()) const;
 
    Bitmap renderToBitmap(int width = -1, int height = -1, const Color& backgroundColor = Color(0, 0, 0, 0)) const;
 
    Matrix getLocalMatrix() const;
 
    Matrix getGlobalMatrix() const;
 
    Box getLocalBoundingBox() const;
 
    Box getGlobalBoundingBox() const;
 
    Box getBoundingBox() const;
 
    NodeList children() const;
 
private:
    Element(SVGElement* element);
    SVGElement* element(bool layoutIfNeeded = false) const;
    friend class Node;
    friend class Document;
};
 
using ElementList = std::vector<Element>;
 
class SVGRootElement;
 
class NOVASVG_API Document {
public:
    static std::unique_ptr<Document> loadFromFile(const std::string& filename);
 
    static std::unique_ptr<Document> loadFromData(const std::string& string);
 
    static std::unique_ptr<Document> loadFromData(const char* data);
 
    static std::unique_ptr<Document> loadFromData(const char* data, size_t length);
 
    void applyStyleSheet(const std::string& content);
 
    ElementList querySelectorAll(const std::string& content) const;
 
    float width() const;
 
    float height() const;
 
    Box boundingBox() const;
 
    void updateLayout();
 
    void forceLayout();
 
    void render(Bitmap& bitmap, const Matrix& matrix = Matrix()) const;
 
    Bitmap renderToBitmap(int width = -1, int height = -1, const Color& backgroundColor = Color(0, 0, 0, 0)) const;
 
    Element elementFromPoint(float x, float y) const;
 
    Element getElementById(const std::string& id) const;
 
    Element documentElement() const;
 
    Document(Document&&);
    Document& operator=(Document&&);
    ~Document();
 
private:
    Document();
    Document(const Document&) = delete;
    Document& operator=(const Document&) = delete;
    SVGRootElement* rootElement(bool layoutIfNeeded = false) const;
    bool parse(const char* data, size_t length);
    std::unique_ptr<SVGRootElement> m_rootElement;
    friend class SVGURIReference;
    friend class SVGNode;
};
 
} // namespace novasvg
 
// Always included -- see the NOVASVG_INLINE note above. Defining
// NOVASVG_IMPLEMENTATION is no longer required and has no effect; it is
// kept as a harmless no-op purely so existing code that still defines it
// keeps compiling unchanged.
//
// This used to be a separate "detail/novasvg_impl.h" file, but that file
// did nothing except forward this exact list of includes to the one
// place (here) that used it, so it's inlined directly instead.
//
// The render/ layer's own extern "C" wrapper is gone too: it's pure,
// header-only C++ (NOVASVG_INLINE / internal-linkage everywhere), nothing
// in this project links against it from actual C code, and the vendored
// STB headers already manage their own extern "C" internally when
// compiled as C++.
 
#include <cstring>
#include <fstream>
#include <cmath>
 
#include "detail/canvas.h"
#include "detail/svgelement.h"
#include "detail/svgparser.hpp"
 
namespace novasvg {
using namespace render;
 
// ---------------------------------------------------------------
// Implementation (formerly detail/novasvg.hpp -- merged in since
// this header is fully NOVASVG_INLINE now, there's no reason left
// to keep the public declarations and their definitions apart).
// ---------------------------------------------------------------
 
using namespace render; // render/ layer (novasvg::render), the former plutovg
 
NOVASVG_INLINE int version()
{
    return NOVASVG_VERSION;
}
 
NOVASVG_INLINE std::string versionString()
{
    return NOVASVG_VERSION_STRING;
}
 
 
NOVASVG_INLINE Box::Box(float x, float y, float w, float h)
    : x(x), y(y), w(w), h(h)
{
}
 
NOVASVG_INLINE Box::Box(const Rect& rect)
    : x(rect.x), y(rect.y), w(rect.w), h(rect.h)
{
}
 
NOVASVG_INLINE Box& Box::transform(const Matrix &matrix)
{
    *this = transformed(matrix);
    return *this;
}
 
NOVASVG_INLINE Box Box::transformed(const Matrix& matrix) const
{
    return Transform(matrix).mapRect(*this);
}
 
NOVASVG_INLINE Rect::Rect(const Box& box)
    : x(box.x), y(box.y), w(box.w), h(box.h)
{
}
 
NOVASVG_INLINE Matrix::Matrix(float a, float b, float c, float d, float e, float f)
    : a(a), b(b), c(c), d(d), e(e), f(f)
{
}
 
NOVASVG_INLINE Matrix::Matrix(const matrix_t& matrix)
    : a(matrix.a), b(matrix.b), c(matrix.c), d(matrix.d), e(matrix.e), f(matrix.f)
{
}
 
NOVASVG_INLINE Matrix::Matrix(const Transform& transform)
    : Matrix(transform.matrix())
{
}
 
NOVASVG_INLINE Matrix Matrix::operator*(const Matrix& matrix) const
{
    return Transform(*this) * Transform(matrix);
}
 
NOVASVG_INLINE Transform::Transform(const Matrix& matrix)
    : Transform(matrix.a, matrix.b, matrix.c, matrix.d, matrix.e, matrix.f)
{
}
 
NOVASVG_INLINE Matrix& Matrix::operator*=(const Matrix &matrix)
{
    return (*this = *this * matrix);
}
 
NOVASVG_INLINE Matrix& Matrix::multiply(const Matrix& matrix)
{
    return (*this *= matrix);
}
 
NOVASVG_INLINE Matrix& Matrix::scale(float sx, float sy)
{
    return multiply(scaled(sx, sy));
}
 
NOVASVG_INLINE Matrix& Matrix::translate(float tx, float ty)
{
    return multiply(translated(tx, ty));
}
 
NOVASVG_INLINE Matrix& Matrix::rotate(float angle, float cx, float cy)
{
    return multiply(rotated(angle, cx, cy));
}
 
NOVASVG_INLINE Matrix& Matrix::shear(float shx, float shy)
{
    return multiply(sheared(shx, shy));
}
 
NOVASVG_INLINE Matrix Matrix::inverse() const
{
    return Transform(*this).inverse();
}
 
NOVASVG_INLINE Matrix& Matrix::invert()
{
    return (*this = inverse());
}
 
NOVASVG_INLINE void Matrix::reset()
{
    *this = Matrix(1, 0, 0, 1, 0, 0);
}
 
NOVASVG_INLINE Matrix Matrix::translated(float tx, float ty)
{
    return Transform::translated(tx, ty);
}
 
NOVASVG_INLINE Matrix Matrix::scaled(float sx, float sy)
{
    return Transform::scaled(sx, sy);
}
 
NOVASVG_INLINE Matrix Matrix::rotated(float angle, float cx, float cy)
{
    return Transform::rotated(angle, cx, cy);
}
 
NOVASVG_INLINE Matrix Matrix::sheared(float shx, float shy)
{
    return Transform::sheared(shx, shy);
}
 
NOVASVG_INLINE Node::Node(SVGNode* node)
    : m_node(node)
{
}
 
NOVASVG_INLINE bool Node::isTextNode() const
{
    return m_node && m_node->isTextNode();
}
 
NOVASVG_INLINE bool Node::isElement() const
{
    return m_node && m_node->isElement();
}
 
NOVASVG_INLINE TextNode Node::toTextNode() const
{
    if(m_node && m_node->isTextNode())
        return static_cast<SVGTextNode*>(m_node);
    return TextNode();
}
 
NOVASVG_INLINE Element Node::toElement() const
{
    if(m_node && m_node->isElement())
        return static_cast<SVGElement*>(m_node);
    return Element();
}
 
NOVASVG_INLINE Element Node::parentElement() const
{
    if(m_node)
        return m_node->parentElement();
    return Element();
}
 
NOVASVG_INLINE TextNode::TextNode(SVGTextNode* text)
    : Node(text)
{
}
 
NOVASVG_INLINE const std::string& TextNode::data() const
{
    if(m_node)
        return text()->data();
    return emptyString;
}
 
NOVASVG_INLINE void TextNode::setData(const std::string& data)
{
    if(m_node) {
        text()->setData(data);
    }
}
 
NOVASVG_INLINE SVGTextNode* TextNode::text() const
{
    return static_cast<SVGTextNode*>(m_node);
}
 
NOVASVG_INLINE Element::Element(SVGElement* element)
    : Node(element)
{
}
 
NOVASVG_INLINE bool Element::hasAttribute(const std::string& name) const
{
    if(m_node)
        return element()->hasAttribute(name);
    return false;
}
 
NOVASVG_INLINE const std::string& Element::getAttribute(const std::string& name) const
{
    if(m_node)
        return element()->getAttribute(name);
    return emptyString;
}
 
NOVASVG_INLINE void Element::setAttribute(const std::string& name, const std::string& value)
{
    if(m_node) {
        element()->setAttribute(name, value);
    }
}
 
NOVASVG_INLINE void Element::render(Bitmap& bitmap, const Matrix& matrix) const
{
    if(m_node == nullptr || bitmap.isNull())
        return;
    auto canvas = Canvas::create(bitmap);
    SVGRenderState state(nullptr, nullptr, matrix, SVGRenderMode::Painting, canvas);
    element(true)->render(state);
}
 
NOVASVG_INLINE Bitmap Element::renderToBitmap(int width, int height, const Color& backgroundColor) const
{
    if(m_node == nullptr)
        return Bitmap();
    auto elementBounds = element(true)->localTransform().mapRect(element()->paintBoundingBox());
    if(elementBounds.isEmpty())
        return Bitmap();
    if(width <= 0 && height <= 0) {
        width = static_cast<int>(std::ceil(elementBounds.w));
        height = static_cast<int>(std::ceil(elementBounds.h));
    } else if(width > 0 && height <= 0) {
        height = static_cast<int>(std::ceil(width * elementBounds.h / elementBounds.w));
    } else if(height > 0 && width <= 0) {
        width = static_cast<int>(std::ceil(height * elementBounds.w / elementBounds.h));
    }
 
    auto xScale = width / elementBounds.w;
    auto yScale = height / elementBounds.h;
 
    Matrix matrix(xScale, 0, 0, yScale, -elementBounds.x * xScale, -elementBounds.y * yScale);
    Bitmap bitmap(width, height);
    if(backgroundColor.value()) bitmap.clear(backgroundColor);
    render(bitmap, matrix);
    return bitmap;
}
 
NOVASVG_INLINE Matrix Element::getLocalMatrix() const
{
    if(m_node)
        return element(true)->localTransform();
    return Matrix();
}
 
NOVASVG_INLINE Matrix Element::getGlobalMatrix() const
{
    if(m_node == nullptr)
        return Matrix();
    auto transform = element(true)->localTransform();
    for(auto parent = element()->parentElement(); parent; parent = parent->parentElement())
        transform.postMultiply(parent->localTransform());
    return transform;
}
 
NOVASVG_INLINE Box Element::getLocalBoundingBox() const
{
    return getBoundingBox().transformed(getLocalMatrix());
}
 
NOVASVG_INLINE Box Element::getGlobalBoundingBox() const
{
    return getBoundingBox().transformed(getGlobalMatrix());
}
 
NOVASVG_INLINE Box Element::getBoundingBox() const
{
    if(m_node)
        return element(true)->paintBoundingBox();
    return Box();
}
 
NOVASVG_INLINE NodeList Element::children() const
{
    if(m_node == nullptr)
        return NodeList();
    NodeList children;
    for(const auto& child : element()->children())
        children.push_back(child.get());
    return children;
}
 
NOVASVG_INLINE SVGElement* Element::element(bool layoutIfNeeded) const
{
    auto element = static_cast<SVGElement*>(m_node);
    if(element && layoutIfNeeded)
        element->rootElement()->layoutIfNeeded();
    return element;
}
 
NOVASVG_INLINE std::unique_ptr<Document> Document::loadFromFile(const std::string& filename)
{
    std::ifstream fs;
    fs.open(filename);
    if(!fs.is_open())
        return nullptr;
    std::string content;
    std::getline(fs, content, '\0');
    fs.close();
    return loadFromData(content);
}
 
NOVASVG_INLINE std::unique_ptr<Document> Document::loadFromData(const std::string& string)
{
    return loadFromData(string.data(), string.size());
}
 
NOVASVG_INLINE std::unique_ptr<Document> Document::loadFromData(const char* data)
{
    return loadFromData(data, std::strlen(data));
}
 
NOVASVG_INLINE std::unique_ptr<Document> Document::loadFromData(const char* data, size_t length)
{
    std::unique_ptr<Document> document(new Document);
    if(!document->parse(data, length))
        return nullptr;
    return document;
}
 
NOVASVG_INLINE float Document::width() const
{
    return rootElement(true)->intrinsicWidth();
}
 
NOVASVG_INLINE float Document::height() const
{
    return rootElement(true)->intrinsicHeight();
}
 
NOVASVG_INLINE Box Document::boundingBox() const
{
    return rootElement(true)->localTransform().mapRect(rootElement()->paintBoundingBox());
}
 
NOVASVG_INLINE void Document::updateLayout()
{
    m_rootElement->layoutIfNeeded();
}
 
NOVASVG_INLINE void Document::forceLayout()
{
    m_rootElement->forceLayout();
}
 
NOVASVG_INLINE void Document::render(Bitmap& bitmap, const Matrix& matrix) const
{
    if(bitmap.isNull())
        return;
 
    // A `background-color` in the root <svg>'s own inline style isn't a
    // real SVG presentation property -- it's a CSS box-model property
    // that only means something when an SVG is displayed as a standalone
    // document/replaced element (which is exactly how a browser navigated
    // straight to a .svg file treats it, painting that color behind
    // everything). Most pure-vector SVG renderers ignore it entirely, but
    // since generated SVGs (Mermaid in particular) rely on it for a
    // correct-looking standalone render, honor it here the same way:
    // clear the bitmap to it before any content paints, so it sits under
    // everything and behind any transparency in the content itself. Takes
    // priority over renderToBitmap()'s own `backgroundColor` argument
    // (this runs after that clear) since that argument means "what to
    // show through transparent content", and content here isn't actually
    // transparent -- it explicitly asked for this color.
    // A `background-color` in the root <svg>'s own style isn't a real SVG
    // presentation property -- it's a CSS box-model property that only
    // means something when an SVG is displayed as a standalone
    // document/replaced element (exactly how a browser navigated straight
    // to a .svg file treats it, painting that color behind everything).
    // Most pure-vector SVG renderers ignore it entirely, but since
    // generated SVGs (Mermaid in particular) rely on it for a
    // correct-looking standalone render, honor it here the same way:
    // clear the bitmap to it before any content paints, so it sits under
    // everything and behind any transparency in the content itself. Takes
    // priority over renderToBitmap()'s own `backgroundColor` argument
    // (this runs after that clear) since that argument means "what to
    // show through transparent content", and content here isn't actually
    // transparent -- it explicitly asked for this color.
    if(const auto& bg = rootElement(true)->getAttribute(PropertyID::Background_Color); !bg.empty()) {
        color_t color;
        if(color_parse(&color, bg.data(), static_cast<int>(bg.length())) > 0) {
            auto argb = color_to_argb32(&color);
            bitmap.clear(Color((argb >> 16) & 0xff, (argb >> 8) & 0xff, argb & 0xff, (argb >> 24) & 0xff));
        }
    }
 
    auto canvas = Canvas::create(bitmap);
    SVGRenderState state(nullptr, nullptr, matrix, SVGRenderMode::Painting, canvas);
    rootElement(true)->render(state);
}
 
NOVASVG_INLINE Bitmap Document::renderToBitmap(int width, int height, const Color& backgroundColor) const
{
    auto intrinsicWidth = rootElement(true)->intrinsicWidth();
    auto intrinsicHeight = rootElement()->intrinsicHeight();
    if(intrinsicWidth == 0.f || intrinsicHeight == 0.f)
        return Bitmap();
    if(width <= 0 && height <= 0) {
        width = static_cast<int>(std::ceil(intrinsicWidth));
        height = static_cast<int>(std::ceil(intrinsicHeight));
    } else if(width > 0 && height <= 0) {
        height = static_cast<int>(std::ceil(width * intrinsicHeight / intrinsicWidth));
    } else if(height > 0 && width <= 0) {
        width = static_cast<int>(std::ceil(height * intrinsicWidth / intrinsicHeight));
    }
 
    auto xScale = width / intrinsicWidth;
    auto yScale = height / intrinsicHeight;
 
    Matrix matrix(xScale, 0, 0, yScale, 0, 0);
    Bitmap bitmap(width, height);
    if(backgroundColor.value()) bitmap.clear(backgroundColor);
    render(bitmap, matrix);
    return bitmap;
}
 
NOVASVG_INLINE Element Document::elementFromPoint(float x, float y) const
{
    return rootElement(true)->elementFromPoint(x, y);
}
 
NOVASVG_INLINE Element Document::getElementById(const std::string& id) const
{
    return m_rootElement->getElementById(id);
}
 
NOVASVG_INLINE Element Document::documentElement() const
{
    return m_rootElement.get();
}
 
NOVASVG_INLINE SVGRootElement* Document::rootElement(bool layoutIfNeeded) const
{
    if(layoutIfNeeded)
        m_rootElement->layoutIfNeeded();
    return m_rootElement.get();
}
 
NOVASVG_INLINE Document::Document(Document&&) = default;
NOVASVG_INLINE Document& Document::operator=(Document&&) = default;
 
NOVASVG_INLINE Document::Document() = default;
NOVASVG_INLINE Document::~Document() = default;
 
} // namespace novasvg
 
#endif // NOVASVG_H