CodeInput.hh

Go to the documentation of this file.

 
#pragma once
 
#include "GtkCompat.hh"
#include "DataCell.hh"
#include "DocumentThread.hh"
#include <gtkmm/box.h>
#include <gtkmm/textview.h>
#include <gtkmm/separator.h>
#ifdef USE_GTK4
#include <gtkmm/snapshot.h>
#include <gtkmm/eventcontrollerkey.h>
#include <gtkmm/eventcontrollerfocus.h>
#include <gtkmm/eventcontrollermotion.h>
#endif
 
namespace cadabra {
 
 
    class CodeInput : public Gtk::Box {
        public:
            using Prefs = cadabra::DocumentThread::Prefs;
 
            CodeInput(DTree::iterator, Glib::RefPtr<Gtk::TextBuffer>, double scale, double display_scale, const Prefs& prefs,
                         Glib::RefPtr<Gtk::Adjustment>);
 
 
            CodeInput(DTree::iterator, const std::string&, double scale, double display_scale, const Prefs& prefs,
                         Glib::RefPtr<Gtk::Adjustment>);
 
 
#ifndef USE_GTK4
            // Chains to the base class only; not needed under GTK4.
            virtual void on_size_allocate(Gtk::Allocation& allocation) override;
#endif
 
 
            class exp_input_tv : public Gtk::TextView {
                public:
                    exp_input_tv(DTree::iterator, Glib::RefPtr<Gtk::TextBuffer>,
                                     double scale,
                                     double display_scale,
                                     Glib::RefPtr<Gtk::Adjustment>);
                    virtual void on_show() override;
 
                    bool handle_key_press(guint keyval, Gdk::ModifierType state);
 
                    void on_focus_entered();
                    void on_focus_left();
                    void on_pointer_motion();
 
#ifndef USE_GTK4
                    virtual bool on_key_press_event(GdkEventKey*) override;
                    virtual bool on_focus_in_event(GdkEventFocus *) override;
                    virtual bool on_focus_out_event(GdkEventFocus *) override;
                    virtual bool on_motion_notify_event(GdkEventMotion *event) override;
#endif
 
                    virtual Gtk::SizeRequestMode get_request_mode_vfunc() const override;
 
                    void draw_gutter(const Cairo::RefPtr<Cairo::Context>& cr, int height);
 
                    bool measure_width_for_height(int& minimum_width, int& natural_width) const;
 
#ifdef USE_GTK4
                    void snapshot_vfunc(const Glib::RefPtr<Gtk::Snapshot>& snapshot) override;
                    void measure_vfunc(Gtk::Orientation orientation, int for_size,
                                             int& minimum, int& natural,
                                             int& minimum_baseline, int& natural_baseline) const override;
#else
                    virtual bool on_draw(const Cairo::RefPtr<Cairo::Context>&) override;
                    virtual void get_preferred_width_for_height_vfunc(int height, int& minimum_width, int& natural_width) const  override;
                    virtual void on_size_allocate(Gtk::Allocation& allocation) override;
#endif
 
                    void         shift_enter_pressed();
                    void         on_textbuf_change();
 
                    sigc::signal<bool(DTree::iterator)>                   content_execute;
                    sigc::signal<bool(DTree::iterator)>                   content_changed;
                    sigc::signal<bool(std::string, int, DTree::iterator)> content_insert;
                    sigc::signal<bool(int, int, DTree::iterator)>         content_erase;
                    sigc::signal<bool(DTree::iterator)>                   cell_got_focus;
                    sigc::signal<bool(DTree::iterator, int)>              complete_request;
 
                    friend CodeInput;
 
                    int                           window_width = 100;
                private:
                    double                        scale_, display_scale_;
                    DTree::iterator               datacell;
                    Glib::RefPtr<Gtk::Adjustment> vadjustment;
                    double                        previous_value = -99.0;
#ifdef USE_GTK4
                    Glib::RefPtr<Gtk::EventControllerKey>    key_controller;
                    Glib::RefPtr<Gtk::EventControllerFocus>  focus_controller;
                    Glib::RefPtr<Gtk::EventControllerMotion> motion_controller;
#endif
                };
 
 
            void enable_highlighting(DataCell::CellType cell_type, const Prefs& prefs);
            void disable_highlighting();
 
            void relay_cursor_pos(std::function<void(int, int)> callback);
 
 
            void handle_middle_click(double x, double y);
#ifndef USE_GTK4
            bool handle_button_press(GdkEventButton *);
#endif
 
 
            void handle_insert(const Gtk::TextIter& pos, const Glib::ustring& text, int bytes);
 
 
            void handle_erase(const Gtk::TextIter& start, const Gtk::TextIter& end);
 
 
            void update_buffer();
 
 
            void slice_cell(std::string& before, std::string& after);
 
 
            Glib::RefPtr<Gtk::TextBuffer> buffer;
 
            exp_input_tv                  edit;
 
        private:
#ifdef USE_GTK4
            Glib::RefPtr<cdb::ClickGesture> paste_gesture;
#endif
 
            void init(const Prefs& prefs, double display_scale);
 
            void highlight_python();
            void highlight_latex();
 
            sigc::connection hl_conn; // Connection holding the syntax highlighting signal
        };
 
    }