imageholder.h

/*
 * Copyright (C) 2021 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_IMAGE_HOLDER_H
#define EGT_IMAGE_HOLDER_H
 
#include "egt/detail/alignment.h"
#include <egt/detail/meta.h>
#include <egt/frame.h>
#include <egt/geometry.h>
#include <egt/image.h>
#include <egt/painter.h>
#include "egt/serialize.h"
#include <egt/text.h>
#include <egt/textwidget.h>
#include <egt/widget.h>
 
namespace egt
{
inline namespace v1
{
 
template<class T,
         Palette::ColorId id_bg,
         Palette::ColorId id_border,
         Palette::ColorId id_text>
class EGT_API ImageHolder : public T
{
public:
    explicit ImageHolder(const std::string& text = {},
                         const AlignFlags& text_align = T::default_text_align()) noexcept
        : ImageHolder(Image(), text, text_align)
    {}
 
    explicit ImageHolder(const Image& image,
                         const std::string& text = {},
                         const AlignFlags& text_align = T::default_text_align()) noexcept
        : ImageHolder(image, text, {}, text_align)
    {}
 
    explicit ImageHolder(const Image& image,
                         const std::string& text,
                         const Rect& rect,
                         const AlignFlags& text_align = T::default_text_align()) noexcept
        : T(text, rect, text_align)
    {
        this->name(type() + std::to_string(this->m_widgetid));
 
        if (text.empty())
        {
            show_label(false);
            image_align(AlignFlag::center | AlignFlag::expand);
        }
        do_set_image(image);
    }
 
    explicit ImageHolder(Frame& parent,
                         const Image& image = {},
                         const std::string& text = {},
                         const AlignFlags& text_align = T::default_text_align()) noexcept
        : ImageHolder(image, text, text_align)
    {
        parent.add(*this);
    }
 
    ImageHolder(Frame& parent,
                const Image& image,
                const std::string& text,
                const Rect& rect,
                const AlignFlags& text_align = T::default_text_align()) noexcept
        : ImageHolder(image, text, rect, text_align)
    {
        parent.add(*this);
    }
 
    explicit ImageHolder(Serializer::Properties& props) noexcept
        : ImageHolder(props, false)
    {}
 
    ImageHolder(const ImageHolder&) noexcept = delete;
    ImageHolder& operator=(const ImageHolder&) noexcept = delete;
    ImageHolder(ImageHolder&&) noexcept = default;
    ImageHolder& operator=(ImageHolder&&) noexcept = default;
 
    virtual ~ImageHolder() = default;
 
    EGT_NODISCARD std::string type() const override
    {
        auto t = detail::demangle(typeid(T).name());
        return std::string("Image") + detail::replace_all(t, "egt::v1::", {});
    }
 
    EGT_NODISCARD std::string uri() const
    {
        return m_image.uri();
    }
 
    void uri(const std::string& uri)
    {
        m_image.uri(uri);
        refresh();
    }
 
    void reset_uri()
    {
        m_image.reset_uri();
        refresh();
    }
 
    EGT_NODISCARD float hscale() const { return m_image.hscale(); }
 
    void hscale(float hscale)
    {
        m_image.scale(hscale, m_image.vscale());
        refresh();
    }
 
    EGT_NODISCARD float vscale() const { return m_image.vscale(); }
 
    void vscale(float vscale)
    {
        m_image.scale(m_image.hscale(), vscale);
        refresh();
    }
 
    void image_scale(float scale)
    {
        m_image.scale(scale);
        refresh();
    }
 
    void image_scale(const SizeF& scale)
    {
        m_image.scale(scale.width(), scale.height());
        refresh();
    }
 
    EGT_NODISCARD SizeF image_scale() const { return SizeF(hscale(), vscale()); }
 
    void image(const Image& image)
    {
        do_set_image(image);
    }
 
    void scale_image(float hscale, float vscale,
                     bool approximate = false)
    {
        m_image.scale(hscale, vscale, approximate);
        this->parent_layout();
    }
 
    void scale_image(float scale, bool approximate = false)
    {
        scale_image(scale, scale, approximate);
    }
 
    void auto_scale_image(bool enable)
    {
        if (enable)
            m_image_align.set(AlignFlag::expand);
        else
            m_image_align.clear(AlignFlag::expand);
        refresh();
    }
 
    bool auto_scale_image() const
    {
        return m_image_align.is_set(AlignFlag::expand);
    }
 
    void keep_image_ratio(bool enable)
    {
        image().keep_image_ratio(enable);
        refresh();
    }
 
    bool keep_image_ratio() const
    {
        return image().keep_image_ratio();
    }
 
    EGT_NODISCARD const Image& image() const { return m_image; }
 
    Image& image() { return m_image; }
 
    void image_align(const AlignFlags& align)
    {
        if (detail::change_if_diff<>(m_image_align, align))
            this->damage();
    }
 
    EGT_NODISCARD AlignFlags image_align() const { return m_image_align; }
 
    void show_label(bool value)
    {
        if (detail::change_if_diff<>(m_show_label, value))
            refresh();
    }
 
    EGT_NODISCARD bool show_label() const { return m_show_label; }
 
    void draw(Painter& painter, const Rect& rect) override
    {
        Drawer<ImageHolder>::draw(*this, painter, rect);
    }
 
    static void default_draw(ImageHolder& widget, Painter& painter, const Rect& rect)
    {
        detail::ignoreparam(rect);
 
        widget.draw_box(painter, id_bg, id_border);
 
        if (widget.show_label())
        {
            const std::string& text = widget.text();
 
            if (!widget.image().empty())
            {
                detail::draw_text(painter,
                                  widget.content_area(),
                                  text,
                                  widget.font(),
                                  TextBox::TextFlags({TextBox::TextFlag::multiline, TextBox::TextFlag::word_wrap}),
                                  widget.text_align(),
                                  Justification::middle,
                                  widget.color(id_text),
                                  widget.image_align(),
                                  widget.image());
            }
            else
            {
                detail::draw_text(painter,
                                  widget.content_area(),
                                  text,
                                  widget.font(),
                                  TextBox::TextFlags({TextBox::TextFlag::multiline, TextBox::TextFlag::word_wrap}),
                                  widget.text_align(),
                                  Justification::middle,
                                  widget.color(id_text));
            }
        }
        else if (!widget.image().empty())
        {
            auto target = widget.image().align(widget.content_area(), widget.image_align());
            painter.draw(target.point());
            painter.draw(widget.image());
        }
    }
 
protected:
    explicit ImageHolder(Serializer::Properties& props, bool is_derived) noexcept
        : T(props, true)
    {
        deserialize(props);
 
        if (!is_derived)
            this->deserialize_leaf(props);
    }
 
    void refresh()
    {
        this->damage();
        this->layout();
    }
 
    void do_set_image(const Image& image)
    {
        if (this->size().empty() && !image.empty())
            this->resize(image.size() + Size(this->moat() * 2, this->moat() * 2));
 
        m_image = image;
        this->damage();
    }
 
public:
    using T::min_size_hint;
 
    EGT_NODISCARD Size min_size_hint() const override
    {
        if (!this->m_min_size.empty())
            return this->m_min_size;
 
        Size min_size_constraint;
        if (this->show_label() && !this->text().empty())
            min_size_constraint = T::min_size_hint();
        else
            min_size_constraint = Widget::min_size_hint();
 
        if (!show_label() && auto_scale_image())
            return min_size_constraint;
 
        Rect size = min_size_constraint - Size(this->moat() * 2, this->moat() * 2);
 
        if (!m_image.size().empty())
        {
            if (image_align().is_set(AlignFlag::left) ||
                image_align().is_set(AlignFlag::right))
            {
                size += Size(m_image.width(), 0);
            }
            else if (image_align().is_set(AlignFlag::top) ||
                     image_align().is_set(AlignFlag::bottom))
            {
                size += Size(0, m_image.height());
            }
 
            size = Rect::merge(size, m_image.size());
        }
 
        auto res = size.size() + Size(this->moat() * 2, this->moat() * 2);
        return res;
    }
 
    void serialize(Serializer& serializer) const override
    {
        T::serialize(serializer);
 
        serializer.add_property("showlabel", show_label());
        if (!m_image.empty())
            m_image.serialize("image", serializer);
        if (!image_align().empty())
            serializer.add_property("image_align", image_align());
    }
 
protected:
    void deserialize(Serializer::Properties& props)
    {
        // TODO proper loading of all image properties
        m_image_align.clear();
        props.erase(std::remove_if(props.begin(), props.end(), [&](auto & p)
        {
            switch (detail::hash(std::get<0>(p)))
            {
            case detail::hash("showlabel"):
                show_label(egt::detail::from_string(std::get<1>(p)));
                break;
            case detail::hash("image"):
                m_image.deserialize(std::get<0>(p), std::get<1>(p), std::get<2>(p));
                break;
            case detail::hash("image_align"):
                image_align(AlignFlags(std::get<1>(p)));
                break;
            default:
                return false;
            }
            return true;
        }), props.end());
    }
 
    Image m_image;
 
    bool m_show_label{true};
 
    AlignFlags m_image_align{AlignFlag::left | AlignFlag::expand};
};
 
}
}
 
#endif