TeXView.hh

Go to the documentation of this file.

 
#pragma once
 
#include "GtkCompat.hh"
 
#ifndef USE_GTK4
#include <gtkmm/eventbox.h>
#endif
#include <gtkmm/box.h>
#include <gtkmm/drawingarea.h>
#if GTKMM_MAJOR_VERSION>3 || (GTKMM_MAJOR_VERSION==3 && GTKMM_MINOR_VERSION>=10)
#include <gtkmm/revealer.h>
#endif
 
#include "Config.hh"
#include "DataCell.hh"
#include "../common/TeXEngine.hh"
 
// MicroTeX
#include "microtex.h"
#include "utils/utf.h"
 
namespace cadabra {
 
    //
 
#ifdef USE_GTK4
    using TeXViewBase = Gtk::Box;
#else
    using TeXViewBase = Gtk::EventBox;
#endif
 
    class TeXView : public TeXViewBase {
        public:
            TeXView(TeXEngine&, DTree::iterator, int hmargin=25);
            virtual ~TeXView();
 
            std::shared_ptr<TeXEngine::TeXRequest> content;
 
            sigc::signal<bool(DTree::iterator)>   show_hide_requested;
 
            sigc::signal<void()>                    select_requested;
 
            void set_is_error(bool);
                    
            DTree::iterator           datacell;
            Gtk::Revealer             rbox;
            Gtk::Box                  vbox;
            Gtk::Box                  hbox;
 
            int                       window_width=0;
 
            class TeXArea : public Gtk::DrawingArea {
                public:
                    TeXArea(TeXView *owner_);
                    ~TeXArea();
 
                    bool draw_impl(const Cairo::RefPtr<Cairo::Context>& cr);
#ifdef USE_GTK4
                    void draw(const Cairo::RefPtr<Cairo::Context>& cr, int width, int height);
#else
                    virtual bool on_draw(const Cairo::RefPtr<Cairo::Context>& cr) override;
#endif
 
 
                    void update_image(std::shared_ptr<TeXEngine::TeXRequest>);
 
                    float                     _text_size;
 
                    void set_latex(const std::string& latex);
 
                    void layout_latex() const;
 
                    int need_height(int width) const;
                protected:
                    Gtk::SizeRequestMode get_request_mode_vfunc() const override;
 
                    void measure_height_for_width(int width, int& minimum_height,
                                                           int& natural_height) const;
                    void relayout_for_allocation(int width, int height);
 
#ifdef USE_GTK4
                    void measure_vfunc(Gtk::Orientation orientation, int for_size,
                                             int& minimum, int& natural,
                                             int& minimum_baseline, int& natural_baseline) const override;
                    void size_allocate_vfunc(int width, int height, int baseline) override;
#else
                    void get_preferred_height_for_width_vfunc(int width, int& minimum_height,
                                                                            int& natural_height) const  override;
                    void get_preferred_width_for_height_vfunc(int height, int& minimum_width,
                                                                            int& natural_width) const  override;
                    void on_size_allocate(Gtk::Allocation& allocation) override;
#endif
 
                private:
                    TeXView        *owner;
                    mutable int     rendering_width;
                    int             padding_x, padding_y;
 
                    // MicroTeX
                    mutable microtex::Render* _render;
                    std::string               unfixed, fixed;
 
                    // What _render was built from, so that layout_latex() can
                    // skip a re-parse when nothing has changed. These are
                    // exactly the arguments MicroTeX::parse() varies over, so
                    // they capture the whole of its input.
                    mutable std::string       _laid_out_text;
                    mutable int               _laid_out_width = -1;
                    mutable float             _laid_out_text_size = -1.f;
 
                    // Return a string in which backslashes, curly braces,
                    // underscores and tildes are properly backslashed, so they
                    // typeset as if we are in a verbatim environment.
                    std::string verbatimise(const std::string&) const;
                };
 
            TeXArea                   image;
 
            void update_image();
 
 
            void dim(bool);
 
            sigc::signal<bool(std::string)> tex_error;
            sigc::signal<bool()>              signal_on_copy_as_latex;
            
        protected:
#ifdef USE_GTK4
            // See the comment on the definition: GTK4 never emits ::show for
            // these cells, so the initial conversion hangs off ::map instead.
            void on_map() override;
#else
            virtual void on_show() override;
#endif
 
            void on_button_pressed(int n_press, double x, double y);
            void on_button_released(int n_press, double x, double y);
 
            void convert();
 
            void on_copy_as_latex() const;
 
        private:
            TeXEngine& engine;
            bool is_error;
            
            cdb::ContextMenu context_menu;
 
            Glib::RefPtr<cdb::ClickGesture>     click_gesture;
 
            float text_size() const;
        };
 
    }