slider.h

//
// slider.h - slider 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 slider : public widget {
            public:
                struct slider_range {
                    float minimum = 0.f;
 
                    float maximum = 100.f;
                };
 
            private:
                float _border = 1.f;
                color _color_border;
                color _color_knob;
                color _color_knob_hot;
                color _color_knob_border;
                color _color_tick;
                bool _snap_to_ticks = true;
                bool _show_tick_marks = true;
                bool _show_tick_labels = true;
                slider_range _range;
                float _knob_radius = 8.f;
                float _slide_thickness = 6.f;
                float _major_tick_unit = 25.f;
                long _minor_tick_count = 4;
                float _value = 0.f;
 
            public:
                slider() {
                    _cursor = cursor_type::hand;
                    _rect.size({ 200.f, 35.f });
                }
 
                struct slider_events : basic_events {
                    std::function<void(float value)> slider = nullptr;
                };
 
                slider_events& events() {
                    return _slider_events;
                }
 
                bool operator==(const slider& param);
 
                bool operator!=(const slider& param);
 
                // generic widget
 
                std::string& text() override;
 
                slider& text(const std::string& text);
 
                std::string& tooltip() override;
 
                slider& tooltip(const std::string& tooltip);
 
                lecui::rect& rect() override;
 
                slider& rect(const lecui::rect& rect);
 
                resize_params& on_resize() override;
 
                slider& on_resize(const resize_params& on_resize);
 
                cursor_type& cursor() override;
 
                slider& cursor(const cursor_type cursor);
 
                std::string& font() override;
 
                slider& font(const std::string& font);
 
                float& font_size() override;
 
                slider& font_size(const float& font_size);
 
                color& color_text() override;
 
                slider& color_text(const color& color_text);
 
                color& color_fill() override;
 
                slider& color_fill(const color& color_fill);
 
                color& color_hot() override;
 
                slider& color_hot(const color& color_hot);
 
                color& color_selected() override;
 
                slider& color_selected(const color& color_selected);
 
                color& color_disabled() override;
 
                slider& color_disabled(const color& color_disabled);
 
                // widget specific widget
 
                float& border();
 
                slider& border(const float& border);
 
                color& color_border();
 
                slider& color_border(const color& color_border);
 
                color& color_knob();
 
                slider& color_knob(const color& color_knob);
 
                color& color_knob_hot();
 
                slider& color_knob_hot(const color& color_knob_hot);
 
                color& color_knob_border();
 
                slider& color_knob_border(const color& color_knob_border);
 
                color& color_tick();
 
                slider& color_tick(const color& color_tick);
 
                bool& snap_to_ticks();
 
                slider& snap_to_ticks(const bool& snap_to_ticks);
 
                bool& show_tick_marks();
 
                slider& show_tick_marks(const bool& show_tick_marks);
 
                bool& show_tick_labels();
 
                slider& show_tick_labels(const bool& show_tick_labels);
 
                slider_range& range();
 
                slider& range(const slider_range& range);
 
                float& knob_radius();
 
                slider& knob_radius(const float& knob_radius);
 
                float& slide_thickness();
 
                slider& slide_thickness(const float& slide_thickness);
 
                float& major_tick_unit();
 
                slider& major_tick_unit(const float& major_tick_unit);
 
                long& minor_tick_count();
 
                slider& minor_tick_count(const long& minor_tick_count);
 
                float& value();
 
                slider& value(const float& value);
 
            public:
                [[nodiscard]]
                static slider& add(containers::page& page, const std::string& alias = std::string());
 
                [[nodiscard]]
                static slider& get(form& fm, const std::string& path);
 
            private:
                slider_events _slider_events;
            };
        }
    }
}
 
#if defined(lecui_helper)
#define get_slider(path) liblec::lecui::widgets::slider::get(*this, path)
#endif