painter.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_PAINTER_H
#define EGT_PAINTER_H
 
#include <cairo.h>
#include <egt/color.h>
#include <egt/detail/meta.h>
#include <egt/flags.h>
#include <egt/font.h>
#include <egt/geometry.h>
#include <egt/pattern.h>
#include <egt/types.h>
#include <string>
 
namespace egt
{
inline namespace v1
{
 
class Image;
 
class EGT_API Painter
{
public:
 
    struct AutoSaveRestore
    {
        explicit AutoSaveRestore(Painter& painter)
            : m_painter(painter)
        {
            m_painter.save();
        }
 
        AutoSaveRestore(const AutoSaveRestore&) = delete;
        AutoSaveRestore& operator=(const AutoSaveRestore&) = delete;
        AutoSaveRestore(AutoSaveRestore&&) = delete;
        AutoSaveRestore& operator=(AutoSaveRestore&&) = delete;
 
        ~AutoSaveRestore()
        {
            m_painter.restore();
        }
 
        Painter& m_painter;
    };
 
    struct AutoGroup
    {
        explicit AutoGroup(Painter& painter)
            : m_painter(painter)
        {
            m_painter.push_group();
        }
 
        AutoGroup(const AutoGroup&) = delete;
        AutoGroup& operator=(const AutoGroup&) = delete;
        AutoGroup(AutoGroup&&) = delete;
        AutoGroup& operator=(AutoGroup&&) = delete;
 
        ~AutoGroup()
        {
            m_painter.pop_group();
        }
 
        Painter& m_painter;
    };
 
    Painter() = delete;
 
    explicit Painter(shared_cairo_t cr) noexcept;
 
    void save();
 
    void restore();
 
    void push_group();
 
    void pop_group();
 
    Painter& set(const Pattern& pattern);
 
    Painter& set(const Font& font);
 
    Painter& line_width(float width);
 
    template<class T>
    Painter& draw(const PointType<T, detail::Compatible::normal>& point)
    {
        cairo_move_to(m_cr.get(), point.x(), point.y());
 
        return *this;
    }
 
    template<class T>
    Painter& line(const PointType<T, detail::Compatible::normal>& point)
    {
        cairo_line_to(m_cr.get(), point.x(), point.y());
 
        return *this;
    }
 
    template<class T>
    Painter& draw(const T& start, const T& end)
    {
        cairo_move_to(m_cr.get(), start.x(), start.y());
        cairo_line_to(m_cr.get(), end.x(), end.y());
 
        return *this;
    }
 
    template<class T>
    Painter& draw(const LineType<T>& line)
    {
        cairo_move_to(m_cr.get(), line.start().x(), line.start().y());
        cairo_line_to(m_cr.get(), line.end().x(), line.end().y());
 
        return *this;
    }
 
    template<class T>
    Painter& draw(const RectType<T>& rect)
    {
        if (rect.empty())
            return *this;
 
        cairo_rectangle(m_cr.get(),
                        rect.x(),
                        rect.y(),
                        rect.width(),
                        rect.height());
 
        return *this;
    }
 
    template<class T>
    Painter& draw(const ArcType<T>& arc)
    {
        if (arc.empty())
            return *this;
 
        cairo_arc(m_cr.get(), arc.center().x(), arc.center().y(),
                  arc.radius(), arc.angle1(), arc.angle2());
 
        return *this;
    }
 
    template<class T>
    Painter& draw(const CircleType<T>& arc)
    {
        if (arc.empty())
            return *this;
 
        cairo_arc(m_cr.get(), arc.center().x(), arc.center().y(),
                  arc.radius(), arc.angle1(), arc.angle2());
 
        return *this;
    }
 
    Painter& draw(const Image& image);
 
    Painter& mask(const Image& image, const Point& point = {});
 
    Painter& draw(const Rect& rect,
                  const Image& image);
 
    enum class TextDrawFlag : uint32_t
    {
        shadow = detail::bit(0),
    };
 
    using TextDrawFlags = Flags<TextDrawFlag>;
 
    Painter& draw(const std::string& str, const TextDrawFlags& flags = {});
 
    Painter& clip();
 
    Painter& fill();
 
    Painter& paint();
 
    Painter& paint(float alpha);
 
    Painter& stroke();
 
    Painter& translate(const PointF& point);
 
    Painter& translate(const Point& point);
 
    Painter& rotate(float angle);
 
    Size text_size(const std::string& text);
 
    void color_at(const Point& point, const Color& color) noexcept;
    static void color_at(cairo_surface_t* image, const Point& point, const Color& color) noexcept;
    Color color_at(const Point& point) noexcept;
    static Color color_at(cairo_surface_t* image, const Point& point) noexcept;
 
    Painter& flood(const Point& point, const Color& color);
 
    static void flood(cairo_surface_t* image,
                      const Point& point, const Color& color);
 
    EGT_NODISCARD inline shared_cairo_t context() const
    {
        return m_cr;
    }
 
    static inline Size surface_to_size(const shared_cairo_surface_t& surface)
    {
        return {cairo_image_surface_get_width(surface.get()),
                cairo_image_surface_get_height(surface.get())};
    }
 
    static inline Size surface_to_size(cairo_surface_t* surface)
    {
        return {cairo_image_surface_get_width(surface),
                cairo_image_surface_get_height(surface)};
    }
 
protected:
 
    shared_cairo_t m_cr;
};
 
}
}
 
#endif