icon.h

//
// icon.h - icon 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 icon : public widget, public badge_widget {
            public:
                enum class icon_text_position {
                    right,  
                    left,   
                    top,    
                    bottom, 
                };
 
            private:
                float _border = .5f;
                color _color_border;
                float _corner_radius_x = 3.f;
                float _corner_radius_y = 3.f;
                float _max_image_size = 48.f;
                color _color_text_description;
                float _font_size_description = 8.5f;
                int _png_resource = 0;
                std::string _file;
                image_quality _quality = image_quality::high;
                std::string _description;
                icon_text_position _text_position = icon_text_position::right;
                float _gap = 5.f;
                float _padding = 5.f;
                float _opacity = 100.f;
                void* _p_special_pane_specs = nullptr;
                void* _p_image_specs = nullptr;
 
            public:
                icon() {
                    _rect.size({ 160.f, 58.f });
                    _font_size = 11.f;
                };
 
                bool operator==(const icon& param);
 
                bool operator!=(const icon& param);
 
                // generic widget
 
                std::string& text() override;
 
                icon& text(const std::string& text);
 
                std::string& tooltip() override;
 
                icon& tooltip(const std::string& tooltip);
 
                badge_specs& badge() override;
 
                icon& badge(const badge_specs& badge);
 
                lecui::rect& rect() override;
 
                icon& rect(const lecui::rect& rect);
 
                resize_params& on_resize() override;
 
                icon& on_resize(const resize_params& on_resize);
 
                cursor_type& cursor() override;
 
                icon& cursor(const cursor_type cursor);
 
                std::string& font() override;
 
                icon& font(const std::string& font);
 
                float& font_size() override;
 
                icon& font_size(const float& font_size);
 
                color& color_text() override;
 
                icon& color_text(const color& color_text);
 
                color& color_fill() override;
 
                icon& color_fill(const color& color_fill);
 
                color& color_hot() override;
 
                icon& color_hot(const color& color_hot);
 
                color& color_selected() override;
 
                icon& color_selected(const color& color_selected);
 
                color& color_disabled() override;
 
                icon& color_disabled(const color& color_disabled);
 
                // widget specific widget
 
                float& border();
 
                icon& border(const float& border);
 
                color& color_border();
 
                icon& color_border(const color& color_border);
 
                float& corner_radius_x();
 
                icon& corner_radius_x(const float& corner_radius_x);
 
                float& corner_radius_y();
 
                icon& corner_radius_y(const float& corner_radius_y);
 
                float& max_image_size();
 
                icon& max_image_size(const float& max_image_size);
 
                color& color_text_description();
 
                icon& color_text_description(const color& color_text_description);
 
                float& font_size_description();
 
                icon& font_size_description(const float& font_size_description);
 
                int& png_resource();
 
                icon& png_resource(const int& png_resource);
 
                std::string& file();
 
                icon& file(const std::string& file);
 
                image_quality& quality();
 
                icon& quality(const image_quality& quality);
 
                std::string& description();
 
                icon& description(const std::string& description);
 
                icon_text_position& text_position();
 
                icon& text_position(const icon_text_position& text_position);
 
                float& gap();
 
                icon& gap(const float& gap);
 
                float& padding();
 
                icon& padding(const float& padding);
 
                float& opacity();
 
                icon& opacity(const float& opacity);
 
            public:
                [[nodiscard]]
                static icon& add(containers::page& page, const std::string& alias = std::string());
 
                [[nodiscard]]
                static icon& get(form& fm, const std::string& path);
 
            private:
#if defined(LECUI_EXPORTS)
                friend class form;
#endif
            };
        }
    }
}
 
#if defined(lecui_helper)
#define get_icon(path) liblec::lecui::widgets::icon::get(*this, path)
#endif