table_view.h

//
// table_view.h - table view 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 table_view : public widget {
                float _border = .5f;
                float _grid_line = .5f;
                color _color_border;
                float _corner_radius_x = 2.f;
                float _corner_radius_y = 2.f;
                color _color_text_selected;
                color _color_grid;
                color _color_text_header;
                color _color_text_header_hot;
                color _color_fill_header;
                color _color_fill_alternate;
                color _color_row_hot;
                color _color_row_selected;
                std::vector<table_column> _columns;
                std::vector<table_row> _data;
                std::vector<long> _selected;
                bool _user_sort = false;
                bool _fixed_number_column = false;
                std::string _fixed_number_column_name = "#";
                void* _p_special_pane = nullptr;
 
            public:
                table_view() {
                    _rect.size({ 200.f, 200.f });
                }
 
                struct table_view_events : basic_events {
                    std::function<void(
                        const std::vector<table_row>& rows)>
                        selection = nullptr;
 
                    std::function<void(
                        const std::vector<table_row>& rows)>
                        context_menu = nullptr;
                };
 
                table_view_events& events() {
                    return _table_events;
                }
 
                bool operator==(const table_view& param);
 
                bool operator!=(const table_view& param);
 
                table_view& operator=(const table_view& param);
 
                table_view(const table_view& param);
 
                // generic widget
 
                std::string& text() override;
 
                table_view& text(const std::string& text);
 
                std::string& tooltip() override;
 
                table_view& tooltip(const std::string& tooltip);
 
                lecui::rect& rect() override;
 
                table_view& rect(const lecui::rect& rect);
 
                resize_params& on_resize() override;
 
                table_view& on_resize(const resize_params& on_resize);
 
                cursor_type& cursor() override;
 
                table_view& cursor(const cursor_type cursor);
 
                std::string& font() override;
 
                table_view& font(const std::string& font);
 
                float& font_size() override;
 
                table_view& font_size(const float& font_size);
 
                color& color_text() override;
 
                table_view& color_text(const color& color_text);
 
                color& color_fill() override;
 
                table_view& color_fill(const color& color_fill);
 
                color& color_hot() override;
 
                table_view& color_hot(const color& color_hot);
 
                color& color_selected() override;
 
                table_view& color_selected(const color& color_selected);
 
                color& color_disabled() override;
 
                table_view& color_disabled(const color& color_disabled);
 
                // widget specific widget
 
                float& border();
 
                table_view& border(const float& border);
 
                float& grid_line();
 
                table_view& grid_line(const float& grid_line);
 
                color& color_border();
 
                table_view& color_border(const color& color_border);
 
                float& corner_radius_x();
 
                table_view& corner_radius_x(const float& corner_radius_x);
 
                float& corner_radius_y();
 
                table_view& corner_radius_y(const float& corner_radius_y);
 
                color& color_text_selected();
 
                table_view& color_text_selected(const color& color_text_selected);
 
                color& color_grid();
 
                table_view& color_grid(const color& color_grid);
 
                color& color_text_header();
 
                table_view& color_text_header(const color& color_text_header);
 
                color& color_text_header_hot();
 
                table_view& color_text_header_hot(const color& color_text_header_hot);
 
                color& color_fill_header();
 
                table_view& color_fill_header(const color& color_fill_header);
 
                color& color_fill_alternate();
 
                table_view& color_fill_alternate(const color& color_fill_alternate);
 
                color& color_row_hot();
 
                table_view& color_row_hot(const color& color_row_hot);
 
                color& color_row_selected();
 
                table_view& color_row_selected(const color& color_row_selected);
 
                std::vector<table_column>& columns();
 
                table_view& columns(const std::vector<table_column>& columns);
 
                std::vector<table_row>& data();
 
                table_view& data(const std::vector<table_row>& data);
 
                std::vector<long>& selected();
 
                table_view& selected(const std::vector<long>& selected);
 
                bool& user_sort();
 
                table_view& user_sort(const bool& user_sort);
 
                bool& fixed_number_column();
 
                table_view& fixed_number_column(const bool& fixed_number_column);
 
                std::string& fixed_number_column_name();
 
                table_view& fixed_number_column_name(const std::string& fixed_number_column_name);
 
            public:
                [[nodiscard]]
                static table_view& add(containers::page& page, const std::string& alias = std::string());
 
                [[nodiscard]]
                static table_view& get(form& fm, const std::string& path);
 
                void scroll_vertically(const float& amount);
 
                void scroll_horizontally(const float& amount);
 
            private:
                table_view_events _table_events;
 
#if defined(LECUI_EXPORTS)
                friend class form;
#endif
            };
        }
    }
}
 
#if defined(lecui_helper)
#define get_table_view(path) liblec::lecui::widgets::table_view::get(*this, path)
#endif