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 <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 <functional>
#include <iosfwd>
#include <memory>
#include <string>
 
namespace egt
{
inline namespace v1
{
 
namespace detail
{
class InternalContext;
}
 
class Image;
class Surface;
class Widget;
 
class EGT_API Painter
{
public:
 
    enum class AntiAlias
    {
        system, // default
        none,
        gray,
        subpixel,
        fast,
        good,
        best,
    };
 
    enum class LineCap
    {
        butt,
        round,
        square,
    };
 
    using SubordinateFilter = std::function<bool(const Widget&)>;
 
    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(Surface& surface) noexcept;
    ~Painter();
 
    void save();
 
    void restore();
 
    void low_fidelity();
 
    void high_fidelity();
 
    EGT_NODISCARD bool filter_subordinate(const Widget& subordinate) const;
 
    SubordinateFilter set_subordinate_filter(const SubordinateFilter& subordinate_filter);
 
    void restore_subordinate_filter(SubordinateFilter&& subordinate_filter);
 
    void push_group();
 
    void pop_group();
 
    Painter& set(const Pattern& pattern);
 
    Painter& set(const Font& font);
 
    Painter& line_width(float width);
 
    Painter& line_cap(Painter::LineCap value);
 
    EGT_NODISCARD Painter::LineCap line_cap() const;
 
    Painter& set_dash(const double* dashes, size_t num_dashes, double offset);
 
    Painter& antialias(Painter::AntiAlias value);
 
    EGT_NODISCARD Painter::AntiAlias antialias() const;
 
    Painter& alpha_blending(bool enabled);
 
    EGT_NODISCARD bool alpha_blending() const;
 
    template<class T>
    Painter& draw(const PointType<T, detail::Compatible::normal>& point)
    {
        return move_to(point);
    }
 
    template<class T>
    Painter& line(const PointType<T, detail::Compatible::normal>& point)
    {
        return line_to(point);
    }
 
    template<class T>
    Painter& draw(const T& start, const T& end)
    {
        return move_to(start).line_to(end);
    }
 
    template<class T>
    Painter& draw(const LineType<T>& line)
    {
        return move_to(line.start()).line_to(line.end());
    }
 
    template<class T>
    Painter& draw(const RectType<T>& rect)
    {
        return rectangle(rect);
    }
 
    template<class T>
    Painter& draw(const ArcType<T>& arc)
    {
        return this->arc(arc);
    }
 
    Painter& draw(const Image& image);
 
    Painter& source(const Pattern& pattern);
 
    Painter& source(const Color& color);
 
    Painter& source(const Surface& surface, const PointF& point = {});
 
    Painter& source(const Image& image, const PointF& point = {});
 
    Painter& mask(const Surface& surface, const PointF& point = {});
 
    Painter& mask(const Image& image, const Point& point = {});
 
    Painter& draw(const Color& color, const RectF& rect = {}, bool preserve = false);
 
    Painter& draw(const Pattern& pattern, const RectF& rect = {}, bool preserve = false);
 
    Painter& draw(const Surface& surface, const PointF& point, const RectF& rect = {});
 
    Painter& draw(const Image& image, const PointF& point, const RectF& rect = {});
 
    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& fill_preserve();
 
    Painter& paint();
 
    Painter& paint(float alpha);
 
    Painter& stroke();
 
    Painter& move_to(const PointF& point);
 
    Painter& line_to(const PointF& point);
 
    Painter& rectangle(const RectF& rect);
 
    Painter& arc(const ArcF& arc);
 
    Painter& translate(const PointF& point);
 
    Painter& translate(const Point& point);
 
    Painter& scale(float sx, float sy);
 
    Painter& rotate(float angle);
 
    Painter& show_text(const char* utf8);
 
    Painter& show_text(const std::string& str) { return show_text(str.c_str()); }
 
    EGT_NODISCARD Font::FontExtents extents() const;
 
    EGT_NODISCARD Font::TextExtents extents(const std::string& text) const;
 
    Size text_size(const std::string& text);
 
    void color_at(const Point& point, const Color& color) noexcept;
    Color color_at(const Point& point) noexcept;
 
    Painter& flood(const Point& point, const Color& color);
 
    EGT_NODISCARD const detail::InternalContext& context() const { return *m_cr; }
 
    EGT_NODISCARD const Surface& target() const { return m_surface; }
 
    EGT_NODISCARD Surface& target() { return m_surface; }
 
    void sync_for_cpu(bool skip_source = false) const;
 
protected:
 
    SubordinateFilter m_subordinate_filter;
 
    std::unique_ptr<detail::InternalContext> m_cr;
 
    Surface& m_surface;
};
 
EGT_API std::ostream& operator<<(std::ostream& os, const Painter::LineCap& cap);
 
EGT_API std::ostream& operator<<(std::ostream& os, const Painter::AntiAlias& antialias);
 
}
}
 
#endif