combo.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_COMBO_H
#define EGT_COMBO_H
 
#include <egt/detail/meta.h>
#include <egt/list.h>
#include <egt/popup.h>
#include <egt/signal.h>
#include <egt/string.h>
#include <egt/widget.h>
#include <memory>
#include <string>
#include <vector>
 
namespace egt
{
inline namespace v1
{
class ComboBox;
class Serializer;
 
namespace detail
{
class ComboBoxPopup;
}
 
class EGT_API ComboBox : public Widget
{
public:
 
    Signal<> on_selected_changed;
    using ItemArray = std::vector<std::shared_ptr<StringItem>>;
 
    explicit ComboBox(const ItemArray& items = ItemArray()) noexcept;
 
    explicit ComboBox(const Rect& rect) noexcept;
 
    ComboBox(const ItemArray& items, const Rect& rect) noexcept;
 
    explicit ComboBox(Frame& parent,
                      const ItemArray& items = {},
                      const Rect& rect = {}) noexcept;
 
    explicit ComboBox(Serializer::Properties& props) noexcept
        : ComboBox(props, false)
    {
    }
 
protected:
 
    explicit ComboBox(Serializer::Properties& props, bool is_derived) noexcept;
 
public:
 
    void handle(Event& event) override;
 
    void resize(const Size& s) override;
 
    void move(const Point& point) override;
 
    void draw(Painter& painter, const Rect& rect) override;
 
    static Size default_size();
 
    static void default_size(const Size& size);
 
    using Widget::min_size_hint;
 
    EGT_NODISCARD Size min_size_hint() const override;
 
    static void default_draw(ComboBox& widget, Painter& painter, const Rect& rect);
 
    void selected(size_t index);
 
    EGT_NODISCARD ssize_t selected() const { return m_list.selected(); }
 
    void add_item(const std::shared_ptr<StringItem>& item);
 
    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 remove_item(StringItem* item);
 
    EGT_NODISCARD std::shared_ptr<StringItem> item_at(size_t index) const
    {
        return m_list.item_at(index);
    }
 
    EGT_NODISCARD size_t item_count() const
    {
        return m_list.item_count();
    }
 
    void show_popup() const;
 
    void hide_popup() const;
 
    void clear();
 
    void serialize(Serializer& serializer) const override;
 
protected:
 
    void set_parent(Widget* parent) override;
 
    ListBox m_list;
 
    std::shared_ptr<detail::ComboBoxPopup> m_popup;
 
    friend class detail::ComboBoxPopup;
 
private:
 
    static Size default_combobox_size_value;
    static Signal<>::RegisterHandle default_combobox_size_handle;
    static void register_handler();
    static void unregister_handler();
 
    void initialize(bool init_inherited_properties = true);
 
    void deserialize(Serializer::Properties& props);
};
 
}
}
 
#endif