tab_pane.h

//
// tab_pane.h - tab pane 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 "../widgets/widget.h"
#else
#include <liblec/lecui/widgets/widget.h>
#endif
 
namespace liblec {
    namespace lecui {
        namespace containers {
#if defined(LECUI_EXPORTS)
            class tab_pane_builder;
            class tab_builder;
#endif
 
            class lecui_api tab_pane : public widgets::widget {
            public:
                enum class side {
                    left,   
                    right,  
                    top,    
                    bottom, 
                };
 
                enum class orientation {
                    horizontal, 
                    vertical,   
                };
 
            private:
                float _border = .5f;
                color _color_border;
                float _corner_radius_x = 5.f;
                float _corner_radius_y = 5.f;
                side _tab_side = side::top;
                std::vector<std::string> _caption_reserve;
                orientation _caption_orientation = orientation::horizontal;
                color _color_tabs;
                color _color_tabs_border;
                float _tabs_border = .5f;
                std::string _selected;
                containers::page* _p_page = nullptr;
 
#if defined(LECUI_EXPORTS)
                friend class tab_pane_builder;
                friend class tab_builder;
#endif
            public:
                tab_pane() {}
                
                bool operator==(const tab_pane& param);
 
                bool operator!=(const tab_pane& param);
 
                // generic widget
 
                std::string& text() override;
 
                tab_pane& text(const std::string& text);
 
                std::string& tooltip() override;
 
                tab_pane& tooltip(const std::string& tooltip);
 
                lecui::rect& rect() override;
 
                tab_pane& rect(const lecui::rect& rect);
 
                resize_params& on_resize() override;
 
                tab_pane& on_resize(const resize_params& on_resize);
 
                cursor_type& cursor() override;
 
                tab_pane& cursor(const cursor_type cursor);
 
                std::string& font() override;
 
                tab_pane& font(const std::string& font);
 
                float& font_size() override;
 
                tab_pane& font_size(const float& font_size);
 
                color& color_text() override;
 
                tab_pane& color_text(const color& color_text);
 
                color& color_fill() override;
 
                tab_pane& color_fill(const color& color_fill);
 
                color& color_hot() override;
 
                tab_pane& color_hot(const color& color_hot);
 
                color& color_selected() override;
 
                tab_pane& color_selected(const color& color_selected);
 
                color& color_disabled() override;
 
                tab_pane& color_disabled(const color& color_disabled);
 
                // widget specific widget
 
                float& border();
 
                tab_pane& border(const float& border);
 
                color& color_border();
 
                tab_pane& color_border(const color& color_border);
 
                float& corner_radius_x();
 
                tab_pane& corner_radius_x(const float& corner_radius_x);
 
                float& corner_radius_y();
 
                tab_pane& corner_radius_y(const float& corner_radius_y);
 
                side& tab_side();
 
                tab_pane& tab_side(const side& tab_side);
 
                std::vector<std::string>& caption_reserve();
 
                tab_pane& caption_reserve(const std::vector<std::string>& caption_reserve);
 
                orientation& caption_orientation();
 
                tab_pane& caption_orientation(const orientation& caption_orientation);
 
                color& color_tabs();
 
                tab_pane& color_tabs(const color& color_tabs);
 
                color& color_tabs_border();
 
                tab_pane& color_tabs_border(const color& color_tabs_border);
 
                float& tabs_border();
 
                tab_pane& tabs_border(const float& tabs_border);
 
                std::string& selected();
 
                tab_pane& selected(const std::string& selected);
 
            public:
                [[nodiscard]]
                static tab_pane& add(containers::page& page, const std::string& alias = std::string(), const float& content_margin = 10.f);
 
                [[nodiscard]]
                static tab_pane& get(form& fm, const std::string& path);
            };
 
            class lecui_api tab : public containers::page, public widgets::badge_widget {
            public:
                tab(form& fm, const std::string& tab_name);
 
                bool operator==(const tab& param);
 
                bool operator!=(const tab& param);
 
                widgets::badge_specs& badge() override;
 
                tab& badge(const widgets::badge_specs& badge);
 
                [[nodiscard]] const lecui::size size();
 
                [[nodiscard]]
                static tab& add(containers::tab_pane& tp, const std::string& tab_name);
 
                [[nodiscard]]
                static tab& get(form& fm, const std::string& path);
 
            private:
                // Default constructor and copying an object of this class are not allowed
                tab() = delete;
                tab(const tab&) = delete;
                tab& operator=(const tab&) = delete;
 
                friend class tab_builder;
            };
        }
    }
}
 
#if defined(lecui_helper)
#define get_tab_pane(path) liblec::lecui::containers::tab_pane::get(*this, path)
 
#define get_tab(path) liblec::lecui::containers::tab::get(*this, path)
#endif