widget.h

//
// widget.h - 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 "../form.h"
#include "../containers/page.h"
#else
#include <liblec/lecui/form.h>
#endif
 
namespace liblec {
    namespace lecui {
        namespace widgets {
            class lecui_api widget {
            public:
                enum class cursor_type {
                    arrow,
 
                    hand,
 
                    caret,
                };
 
            protected:
                std::string _text;                                      
                std::string _tooltip;                                   
                lecui::rect _rect;                                      
                resize_params _on_resize = { 0.f, 0.f, 0.f, 0.f };      
                cursor_type _cursor = cursor_type::arrow;               
                std::string _font = "Segoe UI";                         
                float _font_size = 9.f;                                 
                color _color_text = { 0, 0, 0, 255 };                   
                color _color_fill = { 0, 120, 170, 255 };               
                color _color_hot = { 0, 120, 170, 255 };                
                color _color_selected = { 0, 120, 170, 30 };            
                color _color_disabled = { 180, 180, 180, 255 };         
 
            public:
                widget() {};
 
                virtual ~widget() {};
 
                bool operator==(const widget& param);
 
                bool operator!=(const widget& param);
 
                struct basic_events {
                    std::function<void()> action = nullptr;
 
                    std::function<void()> click = nullptr;
 
                    std::function<void()> right_click = nullptr;
 
                    std::function<void()> mouse_enter = nullptr;
 
                    std::function<void()> mouse_leave = nullptr;
                };
 
                virtual std::string& text() = 0;
 
                virtual std::string& tooltip() = 0;
 
                virtual lecui::rect& rect() = 0;
 
                virtual resize_params& on_resize() = 0;
 
                virtual cursor_type& cursor() = 0;
 
                virtual std::string& font() = 0;
 
                virtual float& font_size() = 0;
 
                virtual color& color_text() = 0;
 
                virtual color& color_fill() = 0;
 
                virtual color& color_hot() = 0;
 
                virtual color& color_selected() = 0;
 
                virtual color& color_disabled() = 0;
 
                basic_events& events() { return _events; }
 
                const std::string& alias() { return _alias; }
 
            private:
                basic_events _events;
                std::string _alias;
 
                void alias(const std::string alias) {
                    _alias = alias;
                }
 
#if defined(LECUI_EXPORTS)
                friend class containers::page;
 
                // implementation classes for widgets that use special panes ... they need access to private variables for redirection
                friend class table_view_impl;
                friend class tree_view_impl;
                friend class html_editor_impl;
                friend class time_impl;
                friend class date_impl;
                friend class icon_impl;
#endif
            };
 
            class lecui_api badge_specs {
            public:
                enum class badge_position {
                    top_left,
 
                    top_right,
 
                    bottom_left,
 
                    bottom_right,
                };
 
            protected:
                std::string _text;                                          
                std::string _font = "Segoe UI";                             
                float _font_size = 8.f;                                     
                float _border = .5f;                                        
                color _color = { 255, 0, 0, 180 };                          
                color _color_border = { 255, 255, 255, 180 };               
                color _color_text = { 255, 255, 255, 255 };                 
                badge_position _position = badge_position::bottom_right;    
 
            public:
                bool operator==(const badge_specs& param);
 
                bool operator!=(const badge_specs& param);
 
                std::string& text();
 
                badge_specs& text(const std::string& text);
 
                std::string& font();
 
                badge_specs& font(const std::string& font);
 
                float& font_size();
 
                badge_specs& font_size(const float& font_size);
 
                float& border();
 
                badge_specs& border(const float& border);
 
                lecui::color& color();
 
                badge_specs& color(const lecui::color& color);
 
                lecui::color& color_border();
 
                badge_specs& color_border(const lecui::color& color_border);
 
                lecui::color& color_text();
 
                badge_specs& color_text(const lecui::color& color_text);
 
                badge_position& position();
 
                badge_specs& position(const badge_position& position);
            };
 
            class lecui_api badge_widget {
            protected:
                badge_specs _badge; 
 
            public:
                bool operator==(const badge_widget& param);
 
                bool operator!=(const badge_widget& param);
 
                virtual badge_specs& badge() = 0;
            };
        }
 
        class lecui_api widget_manager {
        public:
            widget_manager(form& fm);
 
            ~widget_manager();
 
            bool enable(const std::string& path, std::string& error);
 
            bool disable(const std::string& path, std::string& error);
 
            bool show(const std::string& path, std::string& error);
 
            bool hide(const std::string& path, std::string& error);
 
            void close(const std::string& path);
 
            void select(const std::string& path);
 
            bool refresh(const std::string& path, std::string& error);
 
        private:
            class impl;
            impl& _d;
 
            // Default constructor and copying an object of this class are not allowed
            widget_manager() = delete;
            widget_manager(const widget_manager&) = delete;
            widget_manager& operator=(const widget_manager&) = delete;
        };
    }
}