frame.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_FRAME_H
#define EGT_FRAME_H
 
#include <cassert>
#include <egt/detail/alignment.h>
#include <egt/detail/meta.h>
#include <egt/screen.h>
#include <egt/widget.h>
#include <exception>
#include <memory>
#include <string>
#include <vector>
 
namespace egt
{
inline namespace v1
{
class EGT_API Frame : public Widget
{
public:
 
    explicit Frame(const Rect& rect = {},
                   const Flags& flags = {}) noexcept;
 
    Frame(Frame& parent, const Rect& rect,
          const Flags& flags = {}) noexcept;
 
    Frame(Serializer::Properties& props) noexcept
        : Frame(props, false)
    {
    }
 
protected:
 
    Frame(Serializer::Properties& props, bool is_derived) noexcept;
 
public:
 
    Frame(const Frame&) = delete;
    Frame& operator=(const Frame&) = delete;
    Frame(Frame&&) noexcept = default;
    Frame& operator=(Frame&&) noexcept = default;
 
    ~Frame() noexcept override;
 
    virtual void add(const std::shared_ptr<Widget>& widget);
 
    virtual void add_at(const std::shared_ptr<Widget>& widget, size_t pos);
 
    template<class T>
    void add(const std::shared_ptr<T>& widget)
    {
        auto p = std::dynamic_pointer_cast<Widget>(widget);
        add(p);
    }
 
    template<class T>
    void add_at(const std::shared_ptr<T>& widget, size_t pos)
    {
        auto p = std::dynamic_pointer_cast<Widget>(widget);
        add_at(p, pos);
    }
 
    void add(Widget& widget)
    {
        // Nasty, but it gets the job done.  If a widget is passed in as a
        // reference, we don't own it, so create a "pointless" shared_ptr that
        // will not delete it.
        auto w = std::shared_ptr<Widget>(&widget, [](Widget*) {});
        add(w);
    }
 
    void add_at(Widget& widget, size_t pos)
    {
        // Nasty, but it gets the job done.  If a widget is passed in as a
        // reference, we don't own it, so create a "pointless" shared_ptr that
        // will not delete it.
        auto w = std::shared_ptr<Widget>(&widget, [](Widget*) {});
        add_at(w, pos);
    }
 
    bool is_child(Widget* widget) const;
 
    EGT_NODISCARD virtual Point to_child(const Point& p) const
    {
        return Widget::to_subordinate(p);
    }
 
    EGT_NODISCARD Rect to_child(Rect rect) const
    {
        return Widget::to_subordinate(rect);
    }
 
    virtual void remove(Widget* widget);
 
    virtual void remove_at(size_t pos);
 
    void remove_all();
 
    using Widget::children;
 
    EGT_NODISCARD size_t count_children() const { return children().size(); }
 
    EGT_NODISCARD std::shared_ptr<Widget> child_at(size_t index) const
    {
        if (index >= children().size())
            return nullptr;
        else
            return *std::next(children().begin(), index);
    }
 
    EGT_NODISCARD bool top_level() const override
    {
        return !m_parent;
    }
 
    template <class T>
    std::shared_ptr<T> find_child(const std::string& name)
    {
        if (name.empty())
            return nullptr;
 
        auto i = std::find_if(children().begin(), children().end(),
                              [&name](const auto & obj)
        {
            return obj->name() == name;
        });
 
        // just return first one
        if (i != children().end())
            return std::dynamic_pointer_cast<T>(*i);
 
        i = std::find_if(children().begin(), children().end(),
                         [](const auto & obj)
        {
            return obj->frame();
        });
 
        for (; i != children().end(); ++i)
        {
            auto frame = dynamic_cast<Frame*>((*i).get());
            if (frame)
            {
                auto w = frame->find_child<T>(name);
                if (w)
                    return w;
            }
        }
 
        return nullptr;
    }
 
    void walk(const WalkCallback& callback, int level = 0) override;
 
    void paint_children_to_file();
 
    using Widget::zorder;
    using Widget::zorder_down;
    using Widget::zorder_up;
    using Widget::zorder_bottom;
    using Widget::zorder_top;
 
    void show() override
    {
        if (visible())
            return;
 
        Widget::show();
        layout();
    }
 
    Widget* hit_test(const DisplayPoint& point);
 
    template<typename T, typename... Args>
    std::shared_ptr<T> spawn(Args&& ... args)
    {
        auto w = std::make_shared<T>(std::forward<Args>(args)...);
        add(w);
        return w;
    }
 
    using Widget::special_child_draw_callback;
 
    void serialize(Serializer& serializer) const override;
 
    void serialize_children(Serializer& serializer) const override;
 
    void deserialize_children(const Deserializer& deserializer) override;
 
    void on_screen_resized() override;
 
private:
 
 
    void add_private(const std::shared_ptr<Widget>& widget, ssize_t pos = -1);
    void remove_all_basic();
};
 
}
}
 
#endif