DocumentThread.hh

Go to the documentation of this file.

 
#pragma once
 
#include <queue>
#include <mutex>
#include <stack>
#include <map>
#include <thread>
 
#include "DataCell.hh"
#include "tree.hh"
 
namespace cadabra {
 
    class ActionBase;
    class ActionAddCell;
    class ActionPositionCursor;
    class ActionRemoveCell;
    class ActionSetRunStatus;
    class ActionSplitCell;
    class ActionInsertText;
    class ActionCompleteText;
    class ActionEraseText;
    class ComputeThread;
    class GUIBase;
 
 
 
    class DocumentThread {
        public:
            DocumentThread(GUIBase *);
 
 
            DocumentThread(const DocumentThread&)=delete;
 
 
            virtual void set_compute_thread(ComputeThread *);
 
 
            void build_visual_representation();
 
 
            void queue_action(std::shared_ptr<ActionBase>);
 
 
            void run_all_cells();
            
 
            void run_cell(DTree::iterator, bool shift_pressed);
            
 
            void run_cells_referencing_variable(std::string variable, double value);
            
 
            void new_document();
 
 
            virtual void load_from_string(const std::string&);
 
            virtual void on_interactive_output(const nlohmann::json& msg);
 
            virtual void set_progress(const std::string& msg, int cur_step, int total_steps);
 
            void undo();
 
            void redo();
 
            std::pair<DTree::iterator, size_t> find_string(DTree::iterator start_it, size_t start_pos, const std::string& f, bool case_ins) const;
 
            
            friend ActionBase;
            friend ActionAddCell;
            friend ActionPositionCursor;
            friend ActionRemoveCell;
            friend ActionSplitCell;
            friend ActionSetRunStatus;
            friend ActionInsertText;
            friend ActionCompleteText;          
            friend ActionEraseText;
 
            class Prefs {
                public:
                    using ColorMap = std::map<std::string, std::string>;
                    Prefs(bool use_defaults = false);
                    void save();
                    int font_step;
                    bool highlight;
                    bool is_registered;
                    bool is_anonymous;
                    std::map<std::string, ColorMap> colours;
                    std::string git_path;
                    std::string python_path;
                    bool move_into_new_cell;
                    bool tab_completion;
                    bool microtex;
                    bool auto_close_latex;
                private:
                    nlohmann::json data;
                    std::string    config_path;
                };
            Prefs prefs;
 
 
            void set_user_details(const std::string& name, const std::string& email, const std::string& affiliation);
 
            std::thread::id main_thread_id;
            
        protected:
            GUIBase       *gui;
            ComputeThread *compute;
 
 
            DTree          doc;
 
            
            DTree::iterator current_cell;
 
            bool            follow_mode;
            DTree::iterator follow_cell, follow_last_cell;
            
 
            std::mutex                                       stack_mutex;
            typedef std::stack<std::shared_ptr<ActionBase> > ActionStack;
            ActionStack                                      undo_stack, redo_stack;
            std::queue<std::shared_ptr<ActionBase> >         pending_actions;
            bool                                             disable_stacks;
 
 
            void         process_action_queue();
            virtual bool on_unhandled_error(const std::exception& err);
 
 
 
            enum class help_t { algorithm, property, latex, none };
            bool help_type_and_topic(const std::string& before, const std::string& after,
                                     help_t& help_type, std::string& help_topic) const;
 
        };
 
    }