image.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_IMAGE_H
#define EGT_IMAGE_H
 
#include <cairo.h>
#include <egt/detail/meta.h>
#include <egt/geometry.h>
#include <egt/painter.h>
#include <egt/serialize.h>
#include <map>
#include <string>
 
namespace egt
{
inline namespace v1
{
 
class SvgImage;
 
class EGT_API Image
{
public:
 
    // cppcheck-suppress noExplicitConstructor
    // NOLINTNEXTLINE(hicpp-explicit-conversions, google-explicit-constructor)
    Image(const std::string& uri = {}, float scale = 1.0);
 
    Image(const std::string& uri, float hscale, float vscale);
 
    Image(const unsigned char* data, size_t len);
 
    void load(const std::string& uri, float hscale = 1.0, float vscale = 1.0, bool approx = false);
 
    // cppcheck-suppress noExplicitConstructor
    // NOLINTNEXTLINE(hicpp-explicit-conversions, google-explicit-constructor)
    Image(shared_cairo_surface_t surface);
 
    // cppcheck-suppress noExplicitConstructor
    // NOLINTNEXTLINE(hicpp-explicit-conversions, google-explicit-constructor)
    Image(cairo_surface_t* surface);
 
    void scale(float hscale, float vscale, bool approximate = false);
 
    inline void scale(float scale, bool approximate = false)
    {
        this->scale(scale, scale, approximate);
    }
 
    void resize(const Size& size)
    {
        if (this->size() != size)
        {
            float hs = static_cast<float>(size.width()) / static_cast<float>(m_orig_size.width());
            float vs = static_cast<float>(size.height()) / static_cast<float>(m_orig_size.height());
            scale(hs, vs);
        }
    }
 
    EGT_NODISCARD float hscale() const { return m_hscale; }
 
    EGT_NODISCARD float vscale() const { return m_vscale; }
 
    EGT_NODISCARD Size size() const
    {
        if (empty())
            return {};
 
        return {cairo_image_surface_get_width(surface().get()),
                cairo_image_surface_get_height(surface().get())};
    }
 
    EGT_NODISCARD DefaultDim width() const
    {
        return size().width();
    }
 
    EGT_NODISCARD DefaultDim height() const
    {
        return size().height();
    }
 
    EGT_NODISCARD bool empty() const
    {
        return !surface();
    }
 
    EGT_NODISCARD shared_cairo_surface_t surface() const
    {
        if (m_surface_local.get())
            return m_surface_local;
        return m_surface;
    }
 
    EGT_NODISCARD cairo_pattern_t* pattern() const
    {
        if (!m_pattern)
            m_pattern.reset(cairo_pattern_create_for_surface(surface().get()),
                            cairo_pattern_destroy);
        assert(m_pattern.get());
        return m_pattern.get();
    }
 
    EGT_NODISCARD Size size_orig() const { return m_orig_size; }
 
    EGT_NODISCARD Rect align(const Rect& bounding, const AlignFlags& align);
 
    void keep_image_ratio(bool enable)
    {
        m_keep_image_ratio = enable;
    }
 
    bool keep_image_ratio() const
    {
        return m_keep_image_ratio;
    }
 
    void copy();
 
    EGT_NODISCARD std::string uri() const
    {
        return m_uri;
    }
 
    void uri(const std::string& uri) { load(uri, m_hscale, m_vscale); }
 
    void reset_uri() { uri({}); }
 
    Image crop(const RectF& rect);
 
    Image crop(const Rect& rect)
    {
        return crop(RectF(rect.x(), rect.y(), rect.width(), rect.height()));
    }
 
    void serialize(const std::string& name, Serializer& serializer) const;
 
    void deserialize(const std::string& name, const std::string& value,
                     const Serializer::Attributes& attrs);
 
protected:
    void handle_surface_changed();
 
    std::string m_uri;
 
    float m_hscale{1.0};
 
    float m_vscale{1.0};
 
    shared_cairo_surface_t m_surface;
 
    shared_cairo_surface_t m_surface_local;
 
    Size m_orig_size;
 
    bool m_keep_image_ratio{true};
 
    mutable shared_cairo_pattern_t m_pattern;
 
private:
    Image(shared_cairo_surface_t surface, const std::string& uri)
        : Image(surface)
    {
        m_uri = uri;
    }
 
    friend class SvgImage;
};
 
static_assert(detail::rule_of_5<Image>(), "must fulfill rule of 5");
 
}
}
 
#endif