TeXEngine.hh

Go to the documentation of this file.

 
#pragma once
 
#include <stdexcept>
#include <vector>
#include <set>
#include <string>
#include <memory>
 
namespace cadabra {
 
 
    class TeXEngine {
        public:
            class TeXException : public std::logic_error {
                public:
                    TeXException(const std::string&);
                };
 
            class TeXRequest {
                public:
                    TeXRequest();
                    friend class TeXEngine;
 
                    unsigned  width() const;
                    unsigned  height() const;
                    const std::vector<unsigned char>& image() const;
 
                    std::string latex() const;
                    
                private:
                    std::string                latex_string;
                    std::string                start_wrap, end_wrap;
                    bool                       needs_generating;
                    bool                       has_error; // currently set, but never re-set, and unused.
                    std::vector<unsigned char> image_;
                    unsigned                   width_, height_;
                };
 
            TeXEngine();
            ~TeXEngine();
 
            // Set the width and font size for all images to be generated.
            void set_geometry(int horizontal_pixels);
 
            // Get the width.
            int get_geometry() const;
 
            // Set the scale factor for generating bitmaps. The total scale is
            // the product of HiDPI scale and any text-scaling factor on top of
            // that, so that it represents the total scale at which text renders.
            // The device_scale is just the HiDPI factor; we need to generate
            // bitmaps at the width times this size.
            void set_scale(double total_scale, double device_scale);
            double get_scale() const;
            double get_device_scale() const;
            void set_font_size(int font_size);
            int  get_font_size() const;
            std::vector<std::string> latex_packages;
 
            // All checkin/checkout conversion routines. TeXEngine keeps
            // track of all TeXRequests in order to be able to convert
            // all of them in one shot (with one LaTeX run), which you can
            // do with 'convert_all'.
 
            // You can share the result in a TeXRequest in multiple
            // widgets, but you need to call checkout if a widget no
            // longer needs it. TeXEngine will then run a cleanup on all
            // TeXRequests that are no longer referenced except by
            // itself.
 
            std::shared_ptr<TeXRequest> checkin(const std::string&,
                                                const std::string& startwrap, const std::string& endwrap);
            std::shared_ptr<TeXRequest> modify(std::shared_ptr<TeXRequest>, const std::string&);
 
            void                        convert_all();
 
            void                        invalidate_all();
 
            void                        checkout(std::shared_ptr<TeXRequest>);
            void                        checkout_all();
 
        private:
            std::string convert_unicode_to_tex(const std::string&) const;
 
            static double millimeter_per_inch;
 
            std::set<std::shared_ptr<TeXRequest> > requests;
 
            std::string            preamble_string;
            int                    horizontal_pixels_;
            int                    font_size_;
            double                 total_scale_, device_scale_;
 
            void erase_file(const std::string&) const;
            void convert_one(std::shared_ptr<TeXRequest>);
            void convert_set(std::set<std::shared_ptr<TeXRequest> >&);
 
            std::string handle_latex_errors(const std::string&, int exit_code) const;
        };
 
    }