list.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_LIST_H
#define EGT_LIST_H
 
#include <egt/detail/meta.h>
#include <egt/label.h>
#include <egt/signal.h>
#include <egt/sizer.h>
#include <egt/string.h>
#include <egt/view.h>
#include <egt/widget.h>
#include <list>
#include <string>
 
namespace egt
{
inline namespace v1
{
 
class EGT_API ListBoxBase : public Widget
{
public:
 
    Signal<> on_selected_changed;
 
    Signal<> on_items_changed;
    using ItemArray = std::vector<std::shared_ptr<StringItem>>;
 
protected:
 
    explicit ListBoxBase(const ItemArray& items = ItemArray()) noexcept;
 
    explicit ListBoxBase(const Rect& rect) noexcept;
 
    ListBoxBase(const ItemArray& items, const Rect& rect) noexcept;
 
    explicit ListBoxBase(Frame& parent, const ItemArray& items = {}, const Rect& rect = {}) noexcept;
 
    explicit ListBoxBase(Serializer::Properties& props) noexcept;
 
public:
 
    virtual ~ListBoxBase() = default;
 
    void resize(const Size& s) override
    {
        if (s != size())
        {
            Widget::resize(s);
            auto carea = content_area();
            if (!carea.empty())
            {
                m_view.box(to_subordinate(carea));
                m_sizer.resize(carea.size());
            }
        }
    }
 
    virtual void selected(size_t index) = 0;
 
    EGT_NODISCARD size_t item_count() const { return m_sizer.count_children(); }
 
    void add_item(const std::shared_ptr<StringItem>& item);
 
    void add_item_at(const std::shared_ptr<StringItem>& item, size_t pos);
 
    void add_item(StringItem& item)
    {
        // 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 i = std::shared_ptr<StringItem>(&item, [](StringItem*) {});
        add_item(i);
    }
 
    void add_item_at(StringItem& item, 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 i = std::shared_ptr<StringItem>(&item, [](StringItem*) {});
        add_item_at(i, pos);
    }
 
    EGT_NODISCARD std::shared_ptr<StringItem> item_at(size_t index) const;
 
    void remove_item(StringItem* item);
 
    void remove_item_at(size_t pos);
 
    void clear();
 
    void scroll_top();
 
    void scroll_bottom();
 
    void scroll_beginning();
 
    void scroll_end();
 
    void scroll_offset(int offset);
 
    void orient(Orientation orient);
 
    EGT_NODISCARD Orientation orient() const
    {
        return m_orient;
    }
 
    void serialize(Serializer& serializer) const override;
 
protected:
 
    ScrolledView m_view;
 
    BoxSizer m_sizer;
 
    Orientation m_orient{Orientation::vertical};
 
private:
 
    void add_item_private(const std::shared_ptr<StringItem>& item, ssize_t pos = -1);
 
    void deserialize(Serializer::Properties& props);
};
 
class EGT_API ListBox : public ListBoxBase
{
public:
 
    Signal<size_t> on_selected;
    explicit ListBox(const ItemArray& items = ItemArray()) noexcept
        : ListBoxBase(items)
    {
    }
 
    explicit ListBox(const Rect& rect) noexcept
        : ListBoxBase(rect)
    {
    }
 
    ListBox(const ItemArray& items, const Rect& rect) noexcept
        : ListBoxBase(items, rect)
    {
    }
 
    explicit ListBox(Frame& parent, const ItemArray& items = {}, const Rect& rect = {}) noexcept
        : ListBoxBase(parent, items, rect)
    {
    }
 
    explicit ListBox(Serializer::Properties& props) noexcept
        : ListBox(props, false)
    {
    }
 
protected:
 
    explicit ListBox(Serializer::Properties& props, bool is_derived) noexcept;
 
public:
 
    void handle(Event& event) override;
 
    void selected(size_t index) override;
 
    EGT_NODISCARD ssize_t selected() const;
};
 
class EGT_API ListBoxMulti : public ListBoxBase
{
public:
 
    Signal<std::list<size_t>> on_selected;
 
    Signal<std::list<size_t>> on_deselected;
    explicit ListBoxMulti(const ItemArray& items = ItemArray()) noexcept;
 
    explicit ListBoxMulti(const Rect& rect) noexcept;
 
    ListBoxMulti(const ItemArray& items, const Rect& rect) noexcept;
 
    explicit ListBoxMulti(Frame& parent, const ItemArray& items = {}, const Rect& rect = {}) noexcept;
 
    explicit ListBoxMulti(Serializer::Properties& props) noexcept
        : ListBoxMulti(props, false)
    {
    }
 
protected:
 
    explicit ListBoxMulti(Serializer::Properties& props, bool is_derived) noexcept;
 
public:
 
    void handle(Event& event) override;
 
    void selected(size_t index) override;
 
    void selected(const std::list<size_t>& indexes);
 
    void selected(size_t start_index, size_t end_index);
 
    void deselected(size_t index);
 
    void deselected(const std::list<size_t>& indexes);
 
    void deselected(size_t start_index, size_t end_index);
 
    void select(size_t index);
 
    void select(const std::list<size_t>& indexes);
 
    void select(size_t start_index, size_t end_index);
 
    void select_all();
 
    void deselect(size_t index);
 
    void deselect(const std::list<size_t>& indexes);
 
    void deselect(size_t start_index, size_t end_index);
 
    void deselect_all();
 
    void toggle(size_t index);
 
    void toggle(const std::list<size_t>& indexes);
 
    void toggle(size_t start_index, size_t end_index);
 
    void toggle_all();
 
    EGT_NODISCARD std::list<size_t> selected() const;
 
    EGT_NODISCARD std::list<size_t> deselected() const;
 
protected:
 
    bool selected(const std::list<size_t>& indexes,
                  bool selected,
                  std::list<size_t>& selected_update,
                  std::list<size_t>& deselected_update);
    bool select(const std::list<size_t>& indexes,
                bool selected,
                std::list<size_t>& selected_update,
                std::list<size_t>& deselected_update);
};
 
}
}
 
#endif