RADAppKit.h

Go to the documentation of this file.

#ifndef RADAPPKIT_H
#define RADAPPKIT_H
 
#pragma once
 
#include <RADCore/RADCore.h>
#include <RADUi/RADWidgets.h>
 
#include <cstdint>
#include <map>
#include <optional>
#include <string>
#include <vector>
 
namespace RADUi {
 
    enum class DockArea {
        Left,
        Right,
        Bottom,
        Floating
    };
 
    struct DockPanel {
        std::string id;
        std::string title;
        DockArea area = DockArea::Left;
        bool visible = true;
        bool selected = false;
        double size = 240.0;
    };
 
    class DockLayoutModel : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, ());
 
        const std::vector<DockPanel>& panels() const;
        void setPanels(std::vector<DockPanel> panels);
        void addPanel(DockPanel panel);
        bool setVisible(const std::string& id, bool visible);
        bool select(const std::string& id);
        bool setSize(const std::string& id, double size);
        RADCore::RADJsonValue toJson() const;
        void fromJson(const RADCore::RADJsonValue& value);
 
    private:
        std::vector<DockPanel> panels_;
    };
 
    struct DocumentTab {
        std::string id;
        std::string title;
        std::string fileName;
        bool modified = false;
        bool closeable = true;
    };
 
    class DocumentWorkspaceModel : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, ());
            RAD_EVENT(closeRequested, (std::string));
 
        const std::vector<DocumentTab>& tabs() const;
        const std::string& activeId() const;
        void upsertTab(DocumentTab tab);
        bool setActive(std::string id);
        bool removeTab(const std::string& id);
        bool setModified(const std::string& id, bool modified);
        bool requestClose(const std::string& id);
        bool hasModifiedTabs() const;
        void clear();
 
    private:
        std::vector<DocumentTab> tabs_;
        std::string activeId_;
    };
 
    struct Command {
        std::string id;
        std::string title;
        std::string category;
        std::string shortcut;
        bool enabled = true;
    };
 
    class CommandPaletteModel : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, ());
            RAD_EVENT(triggered, (std::string));
 
        const std::vector<Command>& commands() const;
        void setCommands(std::vector<Command> commands);
        void setFilter(std::string filter);
        const std::string& filter() const;
        std::vector<Command> filteredCommands() const;
        bool trigger(const std::string& id);
 
    private:
        std::vector<Command> commands_;
        std::string filter_;
    };
 
    enum class NotificationSeverity {
        Info,
        Success,
        Warning,
        Error
    };
 
    struct Notification {
        uint64_t id = 0;
        NotificationSeverity severity = NotificationSeverity::Info;
        std::string title;
        std::string message;
        std::string actionId;
        int timeoutMs = 4000;
    };
 
    class NotificationModel : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, ());
            RAD_EVENT(actionTriggered, (uint64_t, std::string));
 
        uint64_t push(Notification notification);
        bool dismiss(uint64_t id);
        void clear();
        const std::vector<Notification>& notifications() const;
        bool triggerAction(uint64_t id);
 
    private:
        uint64_t nextId_ = 1;
        std::vector<Notification> notifications_;
    };
 
    struct TableColumn {
        std::string id;
        std::string title;
        double width = 120.0;
        bool sortable = true;
    };
 
    class VirtualTableModel : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, ());
            RAD_EVENT(rowActivated, (size_t));
 
        void setColumns(std::vector<TableColumn> columns);
        const std::vector<TableColumn>& columns() const;
        void setRows(std::vector<std::vector<std::string>> rows);
        void appendRow(std::vector<std::string> row);
        size_t rowCount() const;
        size_t columnCount() const;
        std::vector<size_t> filteredIndexes() const;
        std::string value(size_t row, size_t column) const;
        void setFilter(std::string filter);
        const std::string& filter() const;
        void setSelectedRow(std::optional<size_t> row);
        std::optional<size_t> selectedRow() const;
        bool activateRow(size_t row);
        void clear();
 
    private:
        std::vector<TableColumn> columns_;
        std::vector<std::vector<std::string>> rows_;
        std::string filter_;
        std::optional<size_t> selectedRow_;
    };
 
    struct FileBrowserEntry {
        std::string name;
        std::string path;
        bool directory = false;
        uintmax_t size = 0;
    };
 
    class FileBrowserModel : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, ());
            RAD_EVENT(fileActivated, (std::string));
 
        bool setDirectory(std::string directory);
        const std::string& directory() const;
        bool refresh();
        bool goUp();
        void setShowHidden(bool showHidden);
        bool showHidden() const;
        const std::vector<FileBrowserEntry>& entries() const;
        bool activate(size_t index);
        void setSelectedIndex(std::optional<size_t> index);
        std::optional<size_t> selectedIndex() const;
 
    private:
        std::string directory_;
        bool showHidden_ = false;
        std::vector<FileBrowserEntry> entries_;
        std::optional<size_t> selectedIndex_;
    };
 
    enum class LogLevel {
        Trace,
        Debug,
        Info,
        Warning,
        Error
    };
 
    struct LogEntry {
        LogLevel level = LogLevel::Info;
        std::string category;
        std::string message;
        int64_t unixMs = 0;
    };
 
    class LogViewModel : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, ());
 
        void append(LogEntry entry);
        void setMaxEntries(size_t maxEntries);
        void setFilter(std::string filter);
        const std::string& filter() const;
        std::vector<LogEntry> filteredEntries() const;
        const std::vector<LogEntry>& entries() const;
        void clear();
 
    private:
        std::vector<LogEntry> entries_;
        size_t maxEntries_ = 5000;
        std::string filter_;
    };
 
    class SearchBoxModel : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, ());
 
        void setQuery(std::string query);
        const std::string& query() const;
        void setCaseSensitive(bool caseSensitive);
        bool caseSensitive() const;
 
    private:
        std::string query_;
        bool caseSensitive_ = false;
    };
 
    class ProgressModel : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, ());
 
        void setRange(double minimum, double maximum);
        void setValue(double value);
        void setBusy(bool busy);
        double minimum() const;
        double maximum() const;
        double value() const;
        bool busy() const;
        double normalized() const;
 
    private:
        double minimum_ = 0.0;
        double maximum_ = 1.0;
        double value_ = 0.0;
        bool busy_ = false;
    };
 
    class AppShellModel : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, ());
 
        MenuBarModel& menuBar();
        ToolBarModel& toolBar();
        StatusBarModel& statusBar();
        DockLayoutModel& dockLayout();
        DocumentWorkspaceModel& workspace();
        CommandPaletteModel& commandPalette();
        NotificationModel& notifications();
        void setTitle(std::string title);
        const std::string& title() const;
 
    private:
        std::string title_;
        MenuBarModel menuBar_;
        ToolBarModel toolBar_;
        StatusBarModel statusBar_;
        DockLayoutModel dockLayout_;
        DocumentWorkspaceModel workspace_;
        CommandPaletteModel commandPalette_;
        NotificationModel notifications_;
    };
 
} // namespace RADUi
 
#endif