RADUi.h

Go to the documentation of this file.

#ifndef RADUI_H
#define RADUI_H
 
#pragma once
 
#include <RADCore/RADCore.h>
 
#include <chrono>
#include <filesystem>
#include <functional>
#include <memory>
#include <mutex>
#include <set>
#include <stdexcept>
#include <string>
#include <thread>
#include <vector>
 
#include <RADUi/RADDesktopShell.h>
 
namespace RADUi {
 
    class Binding {
    public:
        Binding() = default;
        explicit Binding(std::shared_ptr<RADCore::RADObject> owner);
 
        void disconnect();
        bool isConnected() const;
 
    private:
        std::shared_ptr<RADCore::RADObject> owner_;
    };
 
    class Backend {
    public:
        virtual ~Backend() = default;
 
        virtual void run() = 0;
        virtual void quit() = 0;
        virtual void postToUi(std::function<void()> task) = 0;
        virtual bool isUiThread() const = 0;
    };
 
    void setBackend(std::shared_ptr<Backend> backend);
    bool hasBackend();
    Backend& backend();
 
    void run();
    void quit();
    void postToUi(std::function<void()> task);
    bool isUiThread();
 
    class FrameScheduler {
    public:
        explicit FrameScheduler(double framesPerSecond = 60.0);
        ~FrameScheduler();
 
        FrameScheduler(const FrameScheduler&) = delete;
        FrameScheduler& operator=(const FrameScheduler&) = delete;
 
        void requestUpdate(std::function<void()> task);
 
    private:
        struct Impl;
        std::shared_ptr<Impl> pImpl_;
    };
 
    enum class DirectoryBrowserEntryKind {
        Parent,
        Folder,
        Project,
        Midi,
        Audio,
        Application,
        File
    };
 
    struct DirectoryBrowserEntry {
        std::filesystem::path path;
        std::string name;
        std::string subtitle;
        std::string icon;
        int depth = 0;
        bool isDirectory = false;
        bool expandable = false;
        bool expanded = false;
        bool isApplication = false;
        DirectoryBrowserEntryKind kind = DirectoryBrowserEntryKind::File;
    };
 
    struct DirectoryBrowserOptions {
        bool includeFiles = true;
        bool includeHidden = false;
        bool includeParentEntry = true;
        int maxDepth = 8;
        std::vector<std::string> allowedExtensions;
    };
 
    class DirectoryBrowserModel {
    public:
        static std::filesystem::path stablePath(const std::filesystem::path& path);
        static bool extensionAllowed(const std::filesystem::path& path, const DirectoryBrowserOptions& options);
        static DirectoryBrowserEntryKind classify(const std::filesystem::directory_entry& entry);
        static std::string iconForKind(DirectoryBrowserEntryKind kind);
        static std::vector<DirectoryBrowserEntry> snapshot(const std::filesystem::path& root,
            const std::set<std::filesystem::path>& expandedDirectories,
            const DirectoryBrowserOptions& options = {});
    };
 
    template<typename F>
    void postToRad(RADCore::EventLoop& loop, F&& task) {
        loop.post(std::forward<F>(task));
    }
 
} // namespace RADUi
 
#endif