lecui.h

//
// lecui.h - lecui 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)
    #define lecui_api __declspec(dllexport)
#else
    #define lecui_api __declspec(dllimport)
    
    // for helper macros, e.g. get_text_field()
    #define lecui_helper    1
 
    // for visual styles (message box, open file, save file)
    #pragma comment(linker, "\"/manifestdependency:type='win32' \
    name='Microsoft.Windows.Common-Controls' version='6.0.0.0' \
    processorArchitecture='*' publicKeyToken='6595b64144ccf1df' \
    language='*'\"")
 
    #if defined(_WIN64)
        #if defined(_DEBUG)
            #pragma comment(lib, "lecui64d.lib")
        #else
            #pragma comment(lib, "lecui64.lib")
        #endif
    #else
        #if defined(_DEBUG)
            #pragma comment(lib, "lecui32d.lib")
        #else
            #pragma comment(lib, "lecui32.lib")
        #endif
    #endif
#endif
 
#if defined(_MSC_VER)
// Turn off annoying "needs to have dll-interface" warning
#pragma warning(disable:4251)
#endif
 
#include <string>
#include <vector>
#include <map>
#include <any>
 
namespace liblec {
    namespace lecui {
        std::string lecui_api version();
 
        std::string lecui_api unique_string();
 
        std::string lecui_api unique_string_short();
 
        class lecui_api point {
            float _x = 0.f;
            float _y = 0.f;
 
        public:
            point();
 
            point(const float x, const float y);
 
            float& x();
 
            float get_x() const;
 
            point& x(const float& x);
 
            float& y();
 
            float get_y() const;
 
            point& y(const float& y);
        };
 
        class lecui_api size {
            float _width = 0.f;
            float _height = 0.f;
 
        public:
            size();
 
            size(const float width, const float height);
 
            float& width();
 
            float get_width() const;
 
            size& width(const float& width);
 
            float& height();
 
            float get_height() const;
 
            size& height(const float& height);
        };
 
        class lecui_api rect {
            float _left = 0.f;
            float _right = 0.f;
            float _top = 0.f;
            float _bottom = 0.f;
 
        public:
            rect();
 
            rect(const lecui::size size);
 
            rect(const float left, const float right, const float top, const float bottom);
 
            float& left();
 
            float get_left() const;
 
            rect& left(const float& left);
 
            float& right();
 
            float get_right() const;
 
            rect& right(const float& right);
 
            float& top();
 
            float get_top() const;
 
            rect& top(const float& top);
 
            float& bottom();
 
            float get_bottom() const;
 
            rect& bottom(const float& bottom);
 
            [[nodiscard]] float width() const;
 
            [[nodiscard]] float height() const;
 
            [[nodiscard]] size size() const;
 
            rect& width(float width);
 
            rect& height(float height);
 
            rect& size(lecui::size size);
 
            rect& size(float width, float height);
 
            rect& set(float x, float y, float cx, float cy);
 
            rect& move(float x, float y);
 
            rect& place(const rect& rect_reference, const float& perc_h, const float& perc_v);
 
            enum class snap_type {
                bottom_left,
 
                bottom,
 
                bottom_right,
 
                top_left,
 
                top,
 
                top_right,
 
                right_top,
 
                right,
 
                right_bottom,
 
                left_top,
 
                left,
 
                left_bottom,
            };
 
            rect& snap_to(const rect& rect_reference, snap_type type, const float& clearance);
 
            rect& clip_to(const rect& rect_reference, const float& clearance);
 
            bool operator==(const rect& param);
 
            bool operator!=(const rect& param);
        };
 
        class lecui_api resize_params {
            float _x_rate = 0.f;
            float _y_rate = 0.f;
            float _width_rate = 0.f;
            float _height_rate = 0.f;
            float _min_x = 0.f;
            float _min_y = 0.f;
            float _max_x = 0.f;
            float _max_y = 0.f;
            float _min_width = 0.f;
            float _min_height = 0.f;
            float _max_width = 0.f;
            float _max_height = 0.f;
 
        public:
            resize_params();
 
            resize_params(const float x_rate, const float y_rate, const float width_rate, const float height_rate);
 
            float& x_rate();
 
            float get_x_rate() const;
 
            resize_params& x_rate(const float& x_rate);
 
            float& y_rate();
 
            float get_y_rate() const;
 
            resize_params& y_rate(const float& y_rate);
 
            float& width_rate();
 
            float get_width_rate() const;
 
            resize_params& width_rate(const float& width_rate);
 
            float& height_rate();
 
            float get_height_rate() const;
 
            resize_params& height_rate(const float& height_rate);
 
            float& min_x();
 
            const float get_min_x() const;
 
            resize_params& min_x(const float& min_x);
 
            float& min_y();
 
            float get_min_y() const;
 
            resize_params& min_y(const float& min_y);
 
            float& max_x();
 
            float get_max_x() const;
 
            resize_params& max_x(const float& max_x);
 
            float& max_y();
 
            float get_max_y() const;
 
            resize_params& max_y(const float& max_y);
 
            float& min_width();
 
            float get_min_width() const;
 
            resize_params& min_width(const float& min_width);
 
            float& min_height();
 
            float get_min_height() const;
 
            resize_params& min_height(const float& min_height);
 
            float& max_width();
 
            float get_max_width() const;
 
            resize_params& max_width(const float& max_width);
 
            float& max_height();
 
            float get_max_height() const;
 
            resize_params& max_height(const float& max_height);
 
            bool operator==(const resize_params& param);
 
            bool operator!=(const resize_params& param);
        };
 
        class lecui_api color {
            unsigned short _red = 0;
            unsigned short _green = 0;
            unsigned short _blue = 0;
            unsigned short _alpha = 255;
 
        public:
            color();
 
            color(const unsigned short red,
                const unsigned short green,
                const unsigned short blue,
                const unsigned short alpha);
 
            unsigned short& red();
 
            unsigned short get_red() const;
 
            color& red(const unsigned short& red);
            
            unsigned short& green();
 
            unsigned short get_green() const;
 
            color& green(const unsigned short& green);
 
            unsigned short& blue();
 
            unsigned short get_blue() const;
 
            color& blue(const unsigned short& blue);
 
            unsigned short& alpha();
 
            unsigned short get_alpha() const;
 
            color& alpha(const unsigned short& alpha);
 
            color& darken(const float& percentage);
 
            color& lighten(const float& percentage);
 
            bool operator==(const color& param);
 
            bool operator!=(const color& param);
        };
 
        enum class sort_options {
            ascending,
 
            descending,
 
            none,
        };
 
        struct file_type {
            std::string extension = "png";
 
            std::string description = "PNG Image";
        };
 
        class lecui_api open_file_params {
            std::string _title = "Open File";
            std::vector<file_type> _file_types;
            std::string _default_type;
            bool _include_all_supported_types = true;
            bool _allow_multi_select = false;
 
        public:
            std::string& title();
 
            const std::string& get_title() const;
 
            open_file_params& title(const std::string& title);
 
            std::vector<file_type>& file_types();
 
            const std::vector<file_type>& get_file_types() const;
 
            open_file_params& file_types(const std::vector<file_type>& file_types);
 
            std::string& default_type();
 
            const std::string& get_default_type() const;
 
            open_file_params& default_type(const std::string& default_type);
 
            bool& include_all_supported_types();
 
            const bool& get_include_all_supported_types() const;
 
            open_file_params& include_all_supported_types(const bool& include_all_supported_types);
 
            bool& allow_multi_select();
 
            const bool& get_allow_multi_select() const;
 
            open_file_params& allow_multi_select(const bool& allow_multi_select);
        };
 
        class lecui_api save_file_params {
            std::string _title = "Save File";
            std::vector<file_type> _file_types;
            std::string _default_type;
            bool _include_all_files = true;
 
        public:
            std::string& title();
 
            const std::string& get_title() const;
 
            save_file_params& title(const std::string& title);
 
            std::vector<file_type>& file_types();
 
            const std::vector<file_type>& get_file_types() const;
 
            save_file_params& file_types(const std::vector<file_type>& file_types);
 
            std::string& default_type();
 
            const std::string& get_default_type() const;
 
            save_file_params& default_type(const std::string& default_type);
 
            bool& include_all_files();
 
            const bool& get_include_all_files() const;
 
            save_file_params& include_all_files(const bool& include_all_files);
        };
 
        struct table_column {
            std::string name;
 
            unsigned short width = 80;
 
            int precision = 2;
 
            bool operator==(const table_column& param);
 
            bool operator!=(const table_column& param);
        };
 
        using table_row = std::map<std::string, std::any>;
 
        class lecui_api time {
        public:
            unsigned short hour = 0;
 
            unsigned short minute = 0;
 
            unsigned short second = 0;
 
            time();
 
            time(const std::string s);
 
            std::string to_string();
        };
 
        struct date {
            unsigned short day = 1;
 
            unsigned short month = 1;
 
            unsigned short year = 2020;
        };
 
        enum class image_quality {
            low,
 
            medium,
 
            high,
        };
 
        class lecui_api get {
        public:
            static int integer(const std::any& value);
 
            static double real(const std::any& value);
 
            static std::string text(const std::any& value);
        };
 
        enum class text_alignment {
            left,
 
            center,
 
            right,
 
            justified,
        };
 
        enum class paragraph_alignment {
            top,
 
            middle,
 
            bottom,
        };
    }
}