gempyre.h

Go to the documentation of this file.

#ifndef GEMPYRE_H
#define GEMPYRE_H
 
#include <string>
#include <unordered_map>
#include <functional>
#include <memory>
#include <chrono>
#include <any>
#include <optional>
#include <vector>
#include <tuple>
#include <string_view>
#include <sstream>
#include <gempyre_types.h>
 
using namespace std::chrono_literals;
 
 
namespace Gempyre {
 
    class Ui;
    class Server;
    class Semaphore;
    class TimerMgr;
    class GempyreInternal;
    enum class CloseStatus;
    enum class WindowType;
    template <class T> class EventQueue;
    template <class T> class IdList;
    template <class K, class T> class EventMap;
 
    GEMPYRE_EX void set_debug(bool isDebug = true);
   
    GEMPYRE_EX void setJNIENV(void* env, void* obj);
    GEMPYRE_EX std::tuple<int, int, int> version();
 
    struct Event;
    class Element;
 
    class GEMPYRE_EX HtmlStream : public std::ostringstream {
        public:
            ~HtmlStream();
            HtmlStream& flush();
 
    #ifdef AUTO_UINT8_STREAM // obviously works, but gives warnings
        template<typename T>
        HtmlStream& operator<<(T&& value) { 
            if constexpr (std::is_same_v<std::decay_t<T>, int8_t>) {
                static_cast<std::ostringstream&>(*this) << static_cast<int>(value);
            } else if constexpr (std::is_same_v<std::decay_t<T>, uint8_t>) {
                static_cast<std::ostringstream&>(*this) << static_cast<unsigned int>(value);
            } else {
                static_cast<std::ostringstream&>(*this) << std::forward<T>(value);
            }
            return *this;
        }  
    #endif
 
        private:
            using FlushFunction = std::function<void (HtmlStream&)>; 
            friend Element;
            HtmlStream(const FlushFunction& flush);    
            const FlushFunction m_flush;
    };
 
    class GEMPYRE_EX Element {
    public:
        using Attributes = std::unordered_map<std::string, std::string>;
        using Values = std::unordered_map<std::string, std::string>;
        using Elements = std::vector<Element>;
        using SubscribeFunction = std::function<void(const Event&)>;
        using Rect = Gempyre::Rect;
 
    public:
        Element(const Element& other) = default;
        Element(Element&& other) = default;
        Element& operator=(const Element& other) {m_ui = other.m_ui; m_id = other.m_id; return *this;}
        Element& operator=(Element&& other) {m_ui = other.m_ui; m_id = std::move(other.m_id); return *this;}
 
        Element(Ui& ui, std::string_view id);
        Element(Ui& ui, std::string_view id, std::string_view htmlElement, const Element& parent);
        Element(Ui& ui, std::string_view htmlElement, const Element& parent);
        virtual ~Element();
        [[nodiscard]] const Ui& ui() const { return *m_ui; }
        [[nodiscard]] Ui& ui() { return *m_ui;}
        [[nodiscard]] std::string id() const {return m_id;}
        Element& subscribe(std::string_view name, const SubscribeFunction& handler, const std::vector<std::string>& properties = {}, const std::chrono::milliseconds& throttle = 0ms);
        Element& set_html(std::string_view htmlText);
        HtmlStream html_stream();
        Element& set_attribute(std::string_view attr, std::string_view value);
        Element& set_attribute(std::string_view attr);
        std::optional<Attributes> attributes() const;
        Element& set_style(std::string_view style, std::string_view value);
        Element& remove_attribute(std::string_view attr);
        [[nodiscard]] std::optional<Values> styles(const std::vector<std::string>& keys) const;
        [[nodiscard]] std::optional<Elements> children() const;
        [[nodiscard]] std::optional<Values> values() const;
        [[nodiscard]] std::optional<std::string> html() const;
        void remove();
        [[nodiscard]] std::optional<std::string> type() const;
        [[nodiscard]] std::optional<Rect> rect() const;
        [[nodiscard]] std::optional<Element> parent() const; 
    protected:
        const GempyreInternal& ref() const;
        GempyreInternal& ref();
        static const std::string generateId(std::string_view prefix);
    protected:
        Ui* m_ui;
        std::string m_id;
    private:   
        friend class GempyreInternal;
    };
 
    struct Event {
        static constexpr auto MOUSE_MOVE = "mousemove";
        static constexpr auto  MOUSE_UP = "mouseup";
        static constexpr auto  MOUSE_DOWN = "mousedown";
        static constexpr auto  MOUSE_CLICK = "click";
        static constexpr auto  MOUSE_DBLCLICK = "dblclick";
        static constexpr auto  KEY_UP = "keyup";
        static constexpr auto  KEY_PRESS = "keypress";
        static constexpr auto  KEY_DOWN = "keydown";
        static constexpr auto  SCROLL = "scroll";
        static constexpr auto  CLICK = "click";
        static constexpr auto  CHANGE = "change";
        static constexpr auto  SELECT = "select";
        static constexpr auto  FOCUS = "focus";
        static constexpr auto  BLUR = "blur";
        static constexpr auto  FOCUS_IN = "focusin";
        static constexpr auto  FOCUS_OUT = "focusout";
        static constexpr auto  LOAD = "load";
        static constexpr auto  RESIZE = "resize"; 
        static constexpr auto  REMOVED = "element_removed";
       
        Element element;
        std::unordered_map<std::string, std::string> properties;
    };
 
    class GEMPYRE_EX Ui {
    public:
        enum UiFlags : unsigned {
            NoResize = 0x1,
            FullScreen = 0x2,
            Hidden = 0x4,
            Frameless = 0x8,
            Minimized = 0x10,
            OnTop = 0x20,
            ConfirmClose = 0x40,
            TextSelect = 0x80,
            EasyDrag = 0x100,
            Transparent = 0x200
        };
        
        using FileMap = std::vector<std::pair<std::string, std::string>>;
 
        using TimerId = int;
        static constexpr unsigned short UseDefaultPort = 0; //zero means default port
        static constexpr auto UseDefaultRoot = "";   //zero means default root
        
        Ui(const FileMap& filemap, std::string_view indexHtml, unsigned short port = UseDefaultPort, std::string_view root = UseDefaultRoot);
 
        Ui(const FileMap& filemap, std::string_view indexHtml, std::string_view browser,  std::string_view browser_params, unsigned short port = UseDefaultPort, std::string_view root = UseDefaultRoot);
 
        Ui(const FileMap& filemap, std::string_view indexHtml, std::string_view title,  int width, int height, unsigned flags = 0,
            const std::unordered_map<std::string, std::string>& ui_params = {}, unsigned short port = UseDefaultPort, std::string_view root = UseDefaultRoot);
 
        ~Ui();
        Ui(const Ui& other) = delete;
        Ui(Ui&& other) = delete;
 
        void exit();
        [[deprecated("Prefer exit")]] void close();
 
        using ExitFunction = std::function<void ()>;
        using ReloadFunction = std::function<void ()>;
        using OpenFunction = std::function<void ()>;
        using ErrorFunction = std::function<void (const std::string& element, const std::string& info)>;
 
 
        ExitFunction on_exit(const ExitFunction& onExitFunction);
 
        ReloadFunction on_reload(const ReloadFunction& onReloadFunction);
 
        OpenFunction on_open(const OpenFunction& onOpenFunction);
        ErrorFunction on_error(const ErrorFunction& onErrorFunction);
 
        void run();
 
        void set_logging(bool logging);
        void eval(std::string_view eval);
        void debug(std::string_view msg);
        void alert(std::string_view msg);
        void open(std::string_view url, std::string_view name = "");
 
        TimerId start_periodic(const std::chrono::milliseconds& ms, const std::function<void (TimerId id)>& timerFunc);
        TimerId start_periodic(const std::chrono::milliseconds& ms, const std::function<void ()>& timerFunc);
 
        TimerId after(const std::chrono::milliseconds& ms, const std::function<void (TimerId id)>& timerFunc);
 
        TimerId after(const std::chrono::milliseconds& ms, const std::function<void ()>& timerFunc);
 
        bool cancel_timer(TimerId timerId);
 
 
        [[nodiscard]] Element root() const;
        
        [[nodiscard]] std::string address_of(std::string_view filepath) const;
        
        [[nodiscard]] std::optional<Element::Elements> by_class(std::string_view className) const;
        
        [[nodiscard]] std::optional<Element::Elements> by_name(std::string_view className) const;
        
        [[nodiscard]] std::optional<std::pair<std::chrono::microseconds, std::chrono::microseconds>> ping() const;
        
        // do extension call - document upon request
        void extension_call(std::string_view callId, const std::unordered_map<std::string, std::any>& parameters);
        // get value from extension - document upon request
        [[nodiscard]] std::optional<std::any> extension_get(std::string_view callId, const std::unordered_map<std::string, std::any>& parameters);
 
        [[nodiscard]] std::optional<std::vector<uint8_t>> resource(std::string_view url) const;
        
        bool add_file(std::string_view url, std::string_view file);
 
        std::optional<std::string> add_file(std::string_view file);
 
        bool add_data(std::string_view url, const std::vector<uint8_t>& data);
        
        static std::optional<std::string> add_file(FileMap& map, std::string_view filename);
        
        void begin_batch();
        
        void end_batch();
        
        void set_timer_on_hold(bool on_hold);
        
        [[nodiscard]] bool is_timer_on_hold() const;
        
        [[nodiscard]] std::optional<double> device_pixel_ratio() const;
        
        void set_application_icon(const uint8_t* data, size_t dataLen, std::string_view type);
        
        void resize(int width, int height);
        
        void set_title(std::string_view name);
        
        static Ui::FileMap to_file_map(const std::vector<std::string>& filenames);
 
        void flush();
 
        bool available(std::string_view id) const; 
 
 
        // for testing
        void resume();
        // for testing
        void suspend();
        // for testing 
        bool ui_available() const;
 
    private:
        Ui(const FileMap& filemap, std::string_view indexHtml,
            unsigned short port, std::string_view root,
            const std::unordered_map<std::string, std::string>& parameters, WindowType windowType);
        const GempyreInternal& ref() const;
        GempyreInternal& ref();
    private:
        friend class Element;
        std::unique_ptr<GempyreInternal> m_ui;
    };
}
 
#endif // GEMPYRE_H