Console.hh

Go to the documentation of this file.

#pragma once
 
#include <queue>
#include <list>
#include <gtkmm.h>
#ifdef USE_GTK4
#include <gtkmm/eventcontrollerkey.h>
#endif
#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=0,
                DockedH=1,
                DockedV=2,
                Floating=3
            };
 
            // 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 handle_key_press(guint keyval, Gdk::ModifierType state);
 
                void sync_to_view();
 
#ifndef USE_GTK4
                bool on_key_press_event(GdkEventKey* key_event) override;
#endif
                size_t history_max_length;
 
            private:
                void set_text_quietly(const Glib::ustring& text);
                void remember_partial_input();
 
                Console& parent;
                std::string temp_in;
                std::list<std::string> history;
                std::list<std::string>::iterator history_ptr;
                bool updating_buffer = false;
#ifdef USE_GTK4
                Glib::RefPtr<Gtk::EventControllerKey> key_controller;
#endif
            };
 
            // 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();
 
            Gtk::Widget& focus_widget();
 
#ifdef USE_GTK4
            void size_allocate_vfunc(int width, int height, int baseline) override;
#endif
 
            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
        };
 
    }