Actions.hh

Go to the documentation of this file.

 
#pragma once
 
#include "DataCell.hh"
#include "DocumentThread.hh"
 
#include <memory>
 
namespace cadabra {
 
    class DocumentThread;
    class GUIBase;

 
 
    class ActionBase {
        public:
            ActionBase(DataCell::id_t ref_id);

 
            virtual void execute(DocumentThread&, GUIBase&);

 
            virtual void revert(DocumentThread&, GUIBase&)=0;

            virtual bool undoable() const;

            DataCell::id_t ref_cell_id() const;
 
            DataCell::id_t  ref_id;

            std::function<void()> callback;
            
        protected:
            DTree::iterator ref;
        };

 
    class ActionAddCell : public ActionBase {
        public:
            enum class Position { before, after, child };
 
            ActionAddCell(DataCell, DataCell::id_t  ref_, Position pos_, bool activate=false);
            virtual ~ActionAddCell() {};
 
            virtual void execute(DocumentThread&, GUIBase&) override;
            virtual void revert(DocumentThread&,  GUIBase&) override;

            virtual bool undoable() const override;
        private:
            // Keep track of the location where this cell is inserted into
            // the notebook.
 
            DataCell          newcell;
            DTree::iterator   newref;
            Position          pos;
            int               child_num;
            bool              activate;
 
            // If we are replacing a cell, keep track of that so we
            // report that we are not undoable.
            bool              is_replacement;
 
            // For input-form cells, we want no undo, as they will go
            // when the owner cell will be reverted.
            bool              is_input_form;
        };
 

 
    class ActionPositionCursor : public ActionBase {
        public:
            enum class Position { in, next, previous };
 
            ActionPositionCursor(DataCell::id_t ref_id_, Position pos_);
            virtual ~ActionPositionCursor() {};
 
            virtual void execute(DocumentThread&, GUIBase&) override;
            virtual void revert(DocumentThread&,  GUIBase&) override;
 
        private:
            uint64_t          needed_new_cell_with_id;
            DTree::iterator   newref;
            Position          pos;
        };

 
    class ActionSetRunStatus : public ActionBase {
        public:
            ActionSetRunStatus(DataCell::id_t ref_id_, bool running);
            virtual ~ActionSetRunStatus() {};
 
            virtual void execute(DocumentThread&, GUIBase&) override;
            virtual void revert(DocumentThread&,  GUIBase&) override;
 
            virtual bool undoable() const override;
        private:
            DTree::iterator this_cell;
            bool            was_running_, new_running_;
        };

 
    class ActionSetVariableList : public ActionBase {
        public:
            ActionSetVariableList(DataCell::id_t ref_id_, std::set<std::string>);
            virtual ~ActionSetVariableList() {};
 
            virtual void execute(DocumentThread&, GUIBase&) override;
            virtual void revert(DocumentThread&,  GUIBase&) override;
 
            virtual bool undoable() const override;
        private:
            DTree::iterator this_cell;
            std::set<std::string> new_variables_;
        };
 

 
    class ActionRemoveCell : public ActionBase {
        public:
            ActionRemoveCell(DataCell::id_t ref_id_);
            virtual ~ActionRemoveCell();
 
            virtual void execute(DocumentThread&, GUIBase&) override;
            virtual void revert(DocumentThread&,  GUIBase&) override;
 
        private:
            // Keep track of the location where this cell (and its child
            // cells) was in the notebook.  We keep a reference to the
            // parent cell and the index of the current cell as child of
            // that parent.
 
            DTree             removed_tree;
            DTree::iterator   reference_parent_cell;
            size_t            reference_child_index;
        };

 
    class ActionReplaceCell : public ActionBase {
        public:
            ActionReplaceCell(DataCell::id_t ref_id_);
            virtual ~ActionReplaceCell();
 
            virtual void execute(DocumentThread&, GUIBase&) override;
            virtual void revert(DocumentThread&,  GUIBase&) override;
 
            virtual bool undoable() const override;
        private:
        };
    
 
    class ActionSplitCell : public ActionBase {
        public:
            ActionSplitCell(DataCell::id_t ref_id);
            virtual ~ActionSplitCell();
 
            virtual void execute(DocumentThread&, GUIBase&) override;
            virtual void revert(DocumentThread&,  GUIBase&) override;
 
        private:
            DTree::iterator newref; // the newly created cell
        };
 

 
    class ActionRunCell : public ActionBase {
        public:
            // Run a particular cell.
            ActionRunCell(DataCell::id_t ref_id);
            // Run all cells.
            ActionRunCell();
            
            virtual ~ActionRunCell();
            
            virtual void execute(DocumentThread&, GUIBase&) override;
            virtual void revert(DocumentThread&,  GUIBase&) override;
            
            virtual bool undoable() const override;
        private:
            bool run_all_cells;
    };

 
    class ActionOpen : public ActionBase {
        public:
            ActionOpen(const std::string&);
            virtual ~ActionOpen();
            
            virtual void execute(DocumentThread&, GUIBase&) override;
            virtual void revert(DocumentThread&,  GUIBase&) override;
            
            virtual bool undoable() const override;
        private:
            std::string notebook_name;
    };
 

 
    class ActionInsertText : public ActionBase {
        public:
            ActionInsertText(DataCell::id_t ref_id, int pos, const std::string&);
            virtual ~ActionInsertText() {};
 
            virtual void execute(DocumentThread&, GUIBase&) override;
            virtual void revert(DocumentThread&,  GUIBase&) override;
 
        private:
            DTree::iterator   this_cell;
            int         insert_pos;
            std::string text;
        };

 
    class ActionCompleteText : public ActionBase {
        public:
            ActionCompleteText(DataCell::id_t ref_id, int pos, const std::string&, int alternative);
            virtual ~ActionCompleteText() {};
 
            virtual void execute(DocumentThread&, GUIBase&) override;
            virtual void revert(DocumentThread&,  GUIBase&) override;
 
            int length() const;
            int alternative() const;
            
        private:
            DTree::iterator   this_cell;
            int         insert_pos;
            std::string text;
            int         alternative_; // in case there is more than one completion alternative
        };

 
    class ActionEraseText : public ActionBase {
        public:
            ActionEraseText(DataCell::id_t ref_id, int, int);
            virtual ~ActionEraseText() {};
 
            virtual void execute(DocumentThread&, GUIBase&) override;
            virtual void revert(DocumentThread&,  GUIBase&) override;
 
        private:
            DTree::iterator   this_cell;
            int from_pos, to_pos;
            std::string removed_text;
        };
 
    }
 
 
//
//       class ActionMergeCells