grid.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_GRID_H
#define EGT_GRID_H
 
#include <egt/detail/meta.h>
#include <egt/frame.h>
#include <egt/widget.h>
#include <memory>
#include <vector>
 
namespace egt
{
inline namespace v1
{
 
class EGT_API StaticGrid : public Frame
{
public:
 
    enum class GridFlag
    {
        show_border = detail::bit(0),
    };
 
    using GridFlags = egt::Flags<GridFlag>;
 
    using GridSize = SizeType<size_t, detail::Compatible::grid>;
 
    using GridPoint = PointType<size_t, detail::Compatible::grid>;
 
    explicit StaticGrid(const GridSize& size = GridSize(1, 1));
 
    explicit StaticGrid(const Rect& rect,
                        const GridSize& size = GridSize(1, 1));
 
    StaticGrid(Frame& parent, const Rect& rect,
               const GridSize& size = GridSize(1, 1));
 
    explicit StaticGrid(Frame& parent,
                        const GridSize& size = GridSize(1, 1));
 
    explicit StaticGrid(Serializer::Properties& props)
        : StaticGrid(props, false)
    {
    }
 
protected:
 
    explicit StaticGrid(Serializer::Properties& props, bool is_derived);
 
public:
 
    using Frame::add;
 
    void add(const std::shared_ptr<Widget>& widget) override;
 
    virtual void add(const std::shared_ptr<Widget>& widget, size_t column, size_t row);
 
    virtual void add(Widget& widget, size_t column, size_t row)
    {
        // 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, column, row);
    }
 
    virtual void add(const std::shared_ptr<Widget>& widget, const GridPoint& point)
    {
        add(widget, point.x(), point.y());
    }
 
    virtual void add(Widget& widget, const GridPoint& point)
    {
        // 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, point);
    }
 
    void add_at(const std::shared_ptr<Widget>& widget, size_t pos) override;
 
    Widget* get(const GridPoint& point);
 
    void remove(Widget* widget) override;
 
    void remove_at(size_t pos) override;
 
    void layout() override;
 
    EGT_NODISCARD int last_add_column() const
    {
        return m_last_add_column;
    }
 
    EGT_NODISCARD int last_add_row() const
    {
        return m_last_add_row;
    }
 
    EGT_NODISCARD bool column_priority() const { return m_column_priority; }
 
    void column_priority(bool value) { m_column_priority = value; }
 
    EGT_NODISCARD size_t n_col() const
    {
        return m_grid_size.width();
    }
 
    EGT_NODISCARD size_t n_row() const
    {
        return m_grid_size.height();
    }
 
    EGT_NODISCARD GridSize grid_size() const
    {
        return m_grid_size;
    }
 
    void grid_size(const GridSize size)
    {
        if (detail::change_if_diff<>(m_grid_size, size))
        {
            reallocate(size);
            reposition();
        }
    }
 
    void horizontal_space(DefaultDim space)
    {
        if (detail::change_if_diff<>(m_horizontal_space, space))
        {
            layout();
            damage();
        }
    }
 
    EGT_NODISCARD DefaultDim horizontal_space() const
    {
        return m_horizontal_space;
    }
 
    void vertical_space(DefaultDim space)
    {
        if (detail::change_if_diff<>(m_vertical_space, space))
        {
            layout();
            damage();
        }
    }
 
    EGT_NODISCARD DefaultDim vertical_space() const
    {
        return m_vertical_space;
    }
 
    void serialize(Serializer& serializer) const override;
 
    void serialize_children(Serializer& serializer) const override;
 
    void deserialize_children(const Deserializer& deserializer) override;
 
protected:
 
    void reallocate(const GridSize& size);
 
    void reposition();
 
    using CellArray = std::vector<std::vector<std::weak_ptr<Widget>>>;
 
    CellArray m_cells;
 
    int m_last_add_column{-1};
    int m_last_add_row{-1};
    bool m_column_priority{false};
    GridSize m_grid_size{};
    DefaultDim m_horizontal_space{};
    DefaultDim m_vertical_space{};
 
private:
 
    void deserialize(Serializer::Properties& props);
};
 
// NOLINTNEXTLINE(cppcoreguidelines-special-member-functions)
class EGT_API SelectableGrid : public StaticGrid
{
public:
 
    Signal<> on_selected_changed;
    explicit SelectableGrid(const GridSize& size = GridSize(1, 1));
 
    explicit SelectableGrid(const Rect& rect,
                            const GridSize& size = GridSize(1, 1));
 
    SelectableGrid(Frame& parent, const Rect& rect,
                   const GridSize& size = GridSize(1, 1));
 
    explicit SelectableGrid(Frame& parent,
                            const GridSize& size = GridSize(1, 1));
    explicit SelectableGrid(Serializer::Properties& props)
        : SelectableGrid(props, false)
    {
    }
 
    void draw(Painter& painter, const Rect& rect) override;
 
    EGT_NODISCARD GridPoint selected() const
    {
        return {m_selected_column, m_selected_row};
    }
 
    void handle(Event& event) override;
 
    void selected(size_t column, size_t row);
 
    void selection_highlight(DefaultDim highlight)
    {
        if (detail::change_if_diff<>(m_selection_highlight, highlight))
        {
            layout();
            damage();
        }
    }
 
    EGT_NODISCARD DefaultDim selection_highlight() const
    {
        return m_selection_highlight;
    }
 
    void serialize(Serializer& serializer) const override;
 
protected:
    size_t m_selected_column{0};
    size_t m_selected_row{0};
    DefaultDim m_selection_highlight{5};
 
    explicit SelectableGrid(Serializer::Properties& props, bool is_derived);
 
private:
 
    void deserialize(Serializer::Properties& props);
};
 
}
}
 
#endif