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 <egt/detail/meta.h>
#include <egt/geometry.h>
#include <egt/painter.h>
#include <egt/serialize.h>
#include <egt/surface.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, bool is_cached = false);
 
    Image(const std::string& uri, float hscale, float vscale, bool is_cached = false);
 
    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, bool is_cached = false);
 
    // cppcheck-suppress noExplicitConstructor
    // NOLINTNEXTLINE(hicpp-explicit-conversions, google-explicit-constructor)
    Image(std::shared_ptr<Surface> surface);
 
    Image(Surface&& surface);
 
    void scale(float hscale, float vscale, bool approximate = false, bool is_cached = false);
 
    inline void scale(float scale, bool approximate = false, bool is_cached = false)
    {
        this->scale(scale, scale, approximate, is_cached);
    }
 
    void resize(const Size& size, bool is_cached = false)
    {
        if (!m_orig_size.empty() && 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, false, is_cached);
        }
    }
 
    EGT_NODISCARD float hscale() const { return m_hscale; }
 
    EGT_NODISCARD float vscale() const { return m_vscale; }
 
    EGT_NODISCARD Size size() const;
 
    EGT_NODISCARD DefaultDim width() const
    {
        return size().width();
    }
 
    EGT_NODISCARD DefaultDim height() const
    {
        return size().height();
    }
 
    EGT_NODISCARD bool empty() const;
 
    EGT_NODISCARD const std::shared_ptr<Surface>& surface() const
    {
        return m_surface;
    }
 
    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;
    }
 
    EGT_NODISCARD std::string uri() const
    {
        return m_uri;
    }
 
    void uri(const std::string& uri, bool is_cached = false) { load(uri, m_hscale, m_vscale, false, is_cached); }
 
    void reset_uri() { uri({}); }
 
    Image crop(const Rect& rect) const;
 
    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};
 
    std::shared_ptr<Surface> m_surface;
 
    Size m_orig_size;
 
    bool m_keep_image_ratio{true};
 
private:
    Image(Surface&& surface, const std::string& uri)
        : Image(std::move(surface))
    {
        m_uri = uri;
    }
 
    friend class SvgImage;
};
 
static_assert(detail::rule_of_5<Image>(), "must fulfill rule of 5");
 
}
}
 
#endif