combobox.h

//
// combobox.h - combobox widget interface
//
// lecui user interface library, part of the liblec library
// Copyright (c) 2019 Alec Musasa (alecmus at live dot com)
//
// Released under the MIT license. For full details see the
// file LICENSE.txt
//
 
#pragma once
 
#if defined(LECUI_EXPORTS)
#include "widget.h"
#else
#include <liblec/lecui/widgets/widget.h>
#endif
 
namespace liblec {
    namespace lecui {
        namespace widgets {
            class lecui_api combobox : public widget {
            public:
                struct combobox_item {
                    std::string label;              
                    std::string font = "Segoe UI";  
                    float font_size = 9.f;          
                };
 
            private:
                bool _editable = false;
                color _color_fill_editable;
                color _color_caret;
                color _color_border;
                color _color_dropdown;
                color _color_dropdown_hot;
                color _color_dropdown_arrow;
                color _color_dropdown_arrow_hot;
                float _border = .5f;
                float _corner_radius_x = 2.f;
                float _corner_radius_y = 2.f;
                std::vector<combobox_item> _items;
                image_quality _quality = image_quality::high;
                sort_options _sort = sort_options::ascending;
                bool _force_numerical_sort = false;
                std::string _selected;
 
            public:
                combobox() {
                    _rect.size({ 200.f, 25.f });
                }
 
                struct combobox_events : basic_events {
                    std::function<void(const std::string&)> selection = nullptr;
                };
 
                combobox_events& events() {
                    return _combobox_events;
                }
 
                bool operator==(const combobox& param);
 
                bool operator!=(const combobox& param);
 
                // generic widget
 
                std::string& text() override;
 
                combobox& text(const std::string& text);
 
                std::string& tooltip() override;
 
                combobox& tooltip(const std::string& tooltip);
 
                lecui::rect& rect() override;
 
                combobox& rect(const lecui::rect& rect);
 
                resize_params& on_resize() override;
 
                combobox& on_resize(const resize_params& on_resize);
 
                cursor_type& cursor() override;
 
                combobox& cursor(const cursor_type cursor);
 
                std::string& font() override;
 
                combobox& font(const std::string& font);
 
                float& font_size() override;
 
                combobox& font_size(const float& font_size);
 
                color& color_text() override;
 
                combobox& color_text(const color& color_text);
 
                color& color_fill() override;
 
                combobox& color_fill(const color& color_fill);
 
                color& color_hot() override;
 
                combobox& color_hot(const color& color_hot);
 
                color& color_selected() override;
 
                combobox& color_selected(const color& color_selected);
 
                color& color_disabled() override;
 
                combobox& color_disabled(const color& color_disabled);
 
                // widget specific widget
 
                float& border();
 
                combobox& border(const float& border);
 
                color& color_border();
 
                combobox& color_border(const color& color_border);
 
                float& corner_radius_x();
 
                combobox& corner_radius_x(const float& corner_radius_x);
 
                float& corner_radius_y();
 
                combobox& corner_radius_y(const float& corner_radius_y);
 
                bool& editable();
 
                combobox& editable(const bool& editable);
 
                color& color_fill_editable();
 
                combobox& color_fill_editable(const color& color_fill_editable);
 
                color& color_caret();
 
                combobox& color_caret(const color& color_caret);
 
                color& color_dropdown();
 
                combobox& color_dropdown(const color& color_dropdown);
 
                color& color_dropdown_hot();
 
                combobox& color_dropdown_hot(const color& color_dropdown_hot);
 
                color& color_dropdown_arrow();
 
                combobox& color_dropdown_arrow(const color& color_dropdown_arrow);
 
                color& color_dropdown_arrow_hot();
 
                combobox& color_dropdown_arrow_hot(const color& color_dropdown_arrow_hot);
 
                std::vector<combobox_item>& items();
 
                combobox& items(const std::vector<combobox_item>& items);
 
                image_quality& quality();
 
                combobox& quality(const image_quality& quality);
 
                sort_options& sort() { return _sort; }
 
                combobox& sort(const sort_options& sort);
 
                bool& force_numerical_sort();
 
                combobox& force_numerical_sort(const bool& force_numerical_sort);
 
                std::string& selected();
 
                combobox& selected(const std::string& selected);
 
            public:
                [[nodiscard]]
                static combobox& add(containers::page& page, const std::string& alias = std::string());
 
                [[nodiscard]]
                static combobox& get(form& fm, const std::string& path);
 
            private:
                combobox_events _combobox_events;
            };
        }
    }
}
 
#if defined(lecui_helper)
#define get_combobox(path) liblec::lecui::widgets::combobox::get(*this, path)
#endif