RADWidgets.h

Go to the documentation of this file.

#ifndef RADWIDGETS_H
#define RADWIDGETS_H
 
#pragma once
 
#include <RADUi/RADUi.h>
 
#include <cstddef>
#include <map>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace RADUi {
 
    class Action : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, ());
            RAD_EVENT(triggered, ());
 
        Action() = default;
        explicit Action(std::string text);
 
        const std::string& text() const;
        void setText(std::string text);
 
        bool isEnabled() const;
        void setEnabled(bool enabled);
 
        bool isCheckable() const;
        void setCheckable(bool checkable);
 
        bool isChecked() const;
        void setChecked(bool checked);
 
        void trigger();
 
    private:
        std::string text_;
        bool enabled_ = true;
        bool checkable_ = false;
        bool checked_ = false;
    };
 
    struct MenuItem {
        std::string id;
        std::string text;
        bool enabled = true;
        bool checkable = false;
        bool checked = false;
        bool separator = false;
    };
 
    struct Menu {
        std::string text;
        std::vector<MenuItem> items;
    };
 
    class MenuBarModel : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, ());
            RAD_EVENT(itemTriggered, (std::string));
 
        const std::vector<Menu>& menus() const;
        void setMenus(std::vector<Menu> menus);
 
        std::optional<size_t> activeMenuIndex() const;
        void openMenu(size_t index);
        void toggleMenu(size_t index);
        void close();
 
        bool triggerItem(size_t menuIndex, size_t itemIndex);
        bool setItemChecked(const std::string& id, bool checked);
 
    private:
        std::vector<Menu> menus_;
        std::optional<size_t> activeMenuIndex_;
    };
 
    class StringListModel : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, ());
 
        size_t rowCount() const;
        bool empty() const;
        const std::string& at(size_t index) const;
        std::vector<std::string> values() const;
 
        void append(std::string value);
        void set(size_t index, std::string value);
        void remove(size_t index);
        void clear();
 
    private:
        std::vector<std::string> values_;
    };
 
    class ButtonModel : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, ());
            RAD_EVENT(clicked, ());
 
        explicit ButtonModel(std::string text = {});
        const std::string& text() const;
        void setText(std::string text);
        bool isEnabled() const;
        void setEnabled(bool enabled);
        void click();
 
    private:
        std::string text_;
        bool enabled_ = true;
    };
 
    class ToggleModel : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, ());
 
        bool isChecked() const;
        void setChecked(bool checked);
        void toggle();
 
    private:
        bool checked_ = false;
    };
 
    class SliderModel : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, (double));
 
        SliderModel(double minimum = 0.0, double maximum = 1.0, double value = 0.0);
        double minimum() const;
        double maximum() const;
        double value() const;
        void setRange(double minimum, double maximum);
        void setValue(double value);
 
    private:
        double minimum_ = 0.0;
        double maximum_ = 1.0;
        double value_ = 0.0;
    };
 
    class TextInputModel : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, ());
 
        const std::string& text() const;
        void setText(std::string text);
        const std::string& placeholder() const;
        void setPlaceholder(std::string placeholder);
        bool isReadOnly() const;
        void setReadOnly(bool readOnly);
 
    private:
        std::string text_;
        std::string placeholder_;
        bool readOnly_ = false;
    };
 
    class TextDocumentModel : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, ());
 
        const std::string& text() const;
        void setText(std::string text);
        const std::string& fileName() const;
        bool isModified() const;
        bool loadFromFile(const std::string& fileName);
        bool save();
        bool saveAs(const std::string& fileName);
        void clear();
 
    private:
        std::string text_;
        std::string fileName_;
        bool modified_ = false;
    };
 
    class TextEditorModel : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, ());
 
        const std::string& text() const;
        void setText(std::string text);
        void setEditorText(std::string text);
        size_t insertText(size_t byteOffset, std::string_view text);
 
        const std::string& displayText() const;
        const std::string& lineNumberText() const;
        size_t lineCount() const;
 
        bool showLineNumbers() const;
        void setShowLineNumbers(bool show);
 
        bool showWhitespace() const;
        void setShowWhitespace(bool show);
 
        double scrollY() const;
        void setScrollY(double scrollY);
        double slintViewportY() const;
        void setSlintViewportY(double viewportY);
        void setViewportHeight(double viewportHeight);
        double viewportHeight() const;
        void ensureLineVisible(size_t line, double lineHeight = 19.0, double padding = 12.0);
        void scrollToLastLine(double lineHeight = 19.0, double padding = 12.0);
 
        static std::string makeWhitespaceVisible(std::string_view text);
        static std::string decodeVisibleWhitespace(std::string_view text);
        static size_t countLines(std::string_view text);
        static std::string makeLineNumberText(size_t lineCount);
 
    private:
        void refreshDerived();
 
        std::string text_;
        std::string displayText_;
        std::string lineNumberText_ = "1";
        size_t lineCount_ = 1;
        bool showLineNumbers_ = true;
        bool showWhitespace_ = false;
        double scrollY_ = 0.0;
        double viewportHeight_ = 0.0;
    };
 
    class SelectionModel : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, ());
 
        std::optional<size_t> currentIndex() const;
        void setCurrentIndex(std::optional<size_t> index);
        void clear();
 
    private:
        std::optional<size_t> currentIndex_;
    };
 
    class TableModel : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, ());
 
        size_t rowCount() const;
        size_t columnCount() const;
        std::string value(size_t row, size_t column) const;
        void setColumnCount(size_t columns);
        void appendRow(std::vector<std::string> row);
        void setValue(size_t row, size_t column, std::string value);
        void clear();
 
    private:
        size_t columns_ = 0;
        std::vector<std::vector<std::string>> rows_;
    };
 
    struct TreeNode {
        std::string text;
        std::vector<TreeNode> children;
    };
 
    class TreeModel : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, ());
 
        const std::vector<TreeNode>& roots() const;
        void setRoots(std::vector<TreeNode> roots);
        void clear();
 
    private:
        std::vector<TreeNode> roots_;
    };
 
    enum class DialogResult {
        None,
        Accepted,
        Rejected
    };
 
    enum class MessageBoxIcon {
        Information,
        Warning,
        Error,
        Question
    };
 
    enum class FilePickerMode {
        OpenFile,
        SaveFile,
        SelectDirectory
    };
 
    struct ToolButton {
        std::string id;
        std::string text;
        std::string icon;
        bool enabled = true;
        bool separator = false;
    };
 
    struct StatusItem {
        std::string id;
        std::string text;
    };
 
    struct PreferenceField {
        std::string id;
        std::string label;
        std::string value;
        std::vector<std::string> options;
        bool isToggle = false;
    };
 
    class DialogModel : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, ());
            RAD_EVENT(finished, (RADUi::DialogResult));
 
        const std::string& title() const;
        void setTitle(std::string title);
        bool isOpen() const;
        DialogResult result() const;
        void open();
        void accept();
        void reject();
 
    private:
        std::string title_;
        bool open_ = false;
        DialogResult result_ = DialogResult::None;
    };
 
    class MessageBoxModel : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, ());
            RAD_EVENT(finished, (RADUi::DialogResult));
 
        void configure(std::string title, std::string text, MessageBoxIcon icon = MessageBoxIcon::Information);
        const std::string& title() const;
        const std::string& text() const;
        MessageBoxIcon icon() const;
        bool isOpen() const;
        void open();
        void accept();
        void reject();
 
    private:
        std::string title_;
        std::string text_;
        MessageBoxIcon icon_ = MessageBoxIcon::Information;
        bool open_ = false;
    };
 
    class FilePickerModel : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, ());
            RAD_EVENT(accepted, (std::string));
            RAD_EVENT(rejected, ());
 
        void setMode(FilePickerMode mode);
        FilePickerMode mode() const;
        void setDirectory(std::string directory);
        const std::string& directory() const;
        void setSelectedPath(std::string path);
        const std::string& selectedPath() const;
        const std::vector<std::string>& filters() const;
        void setFilters(std::vector<std::string> filters);
        bool isOpen() const;
        void open();
        void accept();
        void reject();
 
    private:
        FilePickerMode mode_ = FilePickerMode::OpenFile;
        std::string directory_;
        std::string selectedPath_;
        std::vector<std::string> filters_;
        bool open_ = false;
    };
 
    class ToolBarModel : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, ());
            RAD_EVENT(triggered, (std::string));
 
        const std::vector<ToolButton>& buttons() const;
        void setButtons(std::vector<ToolButton> buttons);
        bool setEnabled(const std::string& id, bool enabled);
        bool trigger(const std::string& id);
 
    private:
        std::vector<ToolButton> buttons_;
    };
 
    class StatusBarModel : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, ());
 
        const std::vector<StatusItem>& items() const;
        void setItems(std::vector<StatusItem> items);
        void setText(std::string id, std::string text);
        std::string text(std::string id) const;
 
    private:
        std::vector<StatusItem> items_;
    };
 
    class PreferencesModel : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, ());
            RAD_EVENT(valueChanged, (std::string, std::string));
 
        const std::vector<PreferenceField>& fields() const;
        void setFields(std::vector<PreferenceField> fields);
        bool setValue(const std::string& id, std::string value);
        std::string value(const std::string& id) const;
        std::map<std::string, std::string> values() const;
 
    private:
        std::vector<PreferenceField> fields_;
    };
 
    struct LayoutItem {
        std::string id;
        int row = 0;
        int column = 0;
        int rowSpan = 1;
        int columnSpan = 1;
    };
 
    class LayoutModel : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, ());
 
        const std::vector<LayoutItem>& items() const;
        void setItems(std::vector<LayoutItem> items);
        void clear();
 
    private:
        std::vector<LayoutItem> items_;
    };
 
} // namespace RADUi
 
#endif