Console.hh

Go to the documentation of this file.

#pragma once
 
#include <queue>
#include <list>
#include <gtkmm.h>
#include "nlohmann/json.hpp"
#include "../common/TeXEngine.hh"
#include "DataCell.hh"
 
namespace cadabra {
    class Console;
 
    // Interactive Console for Cadabra. Deived from Gtk::Box so can be packed into most
    // other widgets.
    class Console : public Gtk::Box {
        public:
            enum class Position : int {
                Hidden,
                DockedH,
                DockedV,
                Floating
            };
 
            // run_slot is the callback which should be run when the console sends input to
            // be run. This callback should call console.grab_input to get a line of input,
            // process it and then send the output block back to the console.
            Console(sigc::slot<void> run_slot);
 
            // Display welcome message and first prompt
            void initialize();
 
            // Process a line of code, either creating a new prompt asking for
            // more input or adding a string to the run_queue and calling the run_slot callback
            void send_input(const std::string& code);
 
            // Grab a line of input, this should only be called fom the run_slot callback.
            // The id parameter will be set to a unique id which should be the parent_id of the
            // block when it is sent back to the console
            std::string grab_input(uint64_t& id);
 
            // Add a message to the console's message queue and ask it to process the message queue
            void signal_message(const nlohmann::json& msg);
 
            // Scroll the console to the latest output
            void scroll_to_bottom();
 
        private:
            // Hidden proxy TextView which stores the user input by intercepting key press
            // events from the main console TextView
            class TextViewProxy : public Gtk::TextView {
            public:
                TextViewProxy(Console& parent);
                bool on_key_press_event(GdkEventKey* key_event) override;
                size_t history_max_length;
 
            private:
                Console& parent;
                std::string temp_in;
                std::list<std::string> history;
                std::list<std::string>::iterator history_ptr;
            };
 
            // Set the current prompt to particular text
            void set_input(const Glib::ustring& line, size_t range_start = std::string::npos, size_t range_end = std::string::npos);
 
            // Create a new prompt
            void prompt(bool continuation, bool newline = false);
 
            // Allocate a mark to a cell
            void create_cell(uint64_t parent_id, uint64_t cell_id);
 
            // Return the current server cell (pseudo-input cell for inputs received from the server) or
            // create one and return it if none exist
            uint64_t get_server_cell();
 
            void insert_text(uint64_t cell_id, const std::string& text, const Glib::RefPtr<Gtk::TextTag>& tag);
            void insert_graphic(uint64_t cell_id, const std::string& bytes);
            void insert_tex(uint64_t cell_id, const std::shared_ptr<TeXEngine::TeXRequest>& content);
 
            // Handle current incoming messages
            void process_message_queue();
 
            virtual bool on_configure_event(GdkEventConfigure* cfg) override;
 
            Glib::Dispatcher dispatch_message; // callback attached to process_message_queue
            Glib::Dispatcher run; // initialized by run_slot, callback when cell needs running
 
            bool needs_focus; // True if console should grab focus on output
            Glib::RefPtr<Gtk::TextBuffer> buffer; // Reference to tv.get_buffer()
            std::string collect; // Collected input if prompt is in continuation mode
            std::queue<nlohmann::json> message_queue; // Current messages needing processing
            std::queue<std::pair<std::string, Glib::RefPtr<Gtk::TextMark>>> run_queue; // Cells waiting to be run, .first is input string and .second is the input cell
            TeXEngine tex_engine; // Engine for compiling TeX outputs
            std::map<uint64_t, Glib::RefPtr<Gtk::TextMark>> cells; // Storage of currently displayed cells
            uint64_t server_cell_id; // ID of current server cell, or 0 if invalidated
            Glib::RefPtr<Gtk::TextMark> input_begin; // Beginning of input
            Glib::RefPtr<Gtk::TextMark> prompt_begin; // Beginning of input prompt
            Glib::RefPtr<Gtk::TextTag> prompt_tag, input_tag, output_tag, warning_tag, error_tag;
            TextViewProxy input; // Input prompt
            Gtk::TextView tv; // Main view
            Gtk::ScrolledWindow win; // Main window
        };
 
    }