extension.h

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Authors:
 *   Ted Gould <ted@gould.cx>
 *
 * Copyright (C) 2002-2005 Authors
 *
 * Released under GNU GPL v2+, read the file 'COPYING' for more information.
 */
 
#ifndef INK_EXTENSION_H
#define INK_EXTENSION_H
 
#include <cstdint>
#include <list>
#include <memory>
#include <string>
#include <vector>
 
#include <glibmm/ustring.h>
#include <sigc++/signal.h>
 
#include "util/hybrid-pointer.h"
 
// Push color headers to all extensions
#include "colors/color.h"
 
namespace Glib {
class ustring;
} // namespace Glib
 
namespace Gtk {
class Grid;
class Box;
class Widget;
} // namespace Gtk
 
#define SP_MODULE_KEY_AUTODETECT "autodetect"
#define SP_MODULE_KEY_INPUT_SVG "org.inkscape.input.svg"
#define SP_MODULE_KEY_INPUT_SVGZ "org.inkscape.input.svgz"
#define SP_MODULE_KEY_INPUT_DEFAULT SP_MODULE_KEY_AUTODETECT
#define SP_MODULE_KEY_OUTPUT_SVG "org.inkscape.output.svg.plain"
#define SP_MODULE_KEY_OUTPUT_SVGZ "org.inkscape.output.svgz.plain"
#define SP_MODULE_KEY_OUTPUT_SVG_INKSCAPE "org.inkscape.output.svg.inkscape"
#define SP_MODULE_KEY_OUTPUT_SVGZ_INKSCAPE "org.inkscape.output.svgz.inkscape"
#define SP_MODULE_KEY_OUTPUT_DEFAULT SP_MODULE_KEY_AUTODETECT
 
#define SP_MODULE_KEY_RASTER_PNG "org.inkscape.output.png.inkscape"
 
#define SP_MODULE_KEY_PRINT_PS    "org.inkscape.print.ps"
#define SP_MODULE_KEY_PRINT_CAIRO_PS    "org.inkscape.print.ps.cairo"
#define SP_MODULE_KEY_PRINT_CAIRO_EPS    "org.inkscape.print.eps.cairo"
#define SP_MODULE_KEY_PRINT_PDF    "org.inkscape.print.pdf"
#define SP_MODULE_KEY_PRINT_CAIRO_PDF    "org.inkscape.print.pdf.cairo"
#define SP_MODULE_KEY_PRINT_LATEX    "org.inkscape.print.latex"
#define SP_MODULE_KEY_PRINT_GNOME "org.inkscape.print.gnome"
 
#define MIME_SVG "image/svg+xml"
 
#define EXTENSION_ERROR_LOG_FILENAME  "extension-errors.log"
 
 
#define INKSCAPE_EXTENSION_URI   "http://www.inkscape.org/namespace/inkscape/extension"
#define INKSCAPE_EXTENSION_NS_NC "extension"
#define INKSCAPE_EXTENSION_NS    "extension:"
 
enum ModuleImpType
{
    MODULE_EXTENSION,   // implementation/script.h python extensions
    MODULE_XSLT,        // implementation/xslt.h xml transform extensions
    MODULE_PLUGIN,      // plugins/*/*.h C++ extensions
    MODULE_UNKNOWN_IMP  // No implementation, so nothing created.
};
 
enum ModuleFuncType
{
    MODULE_TEMPLATE,
    MODULE_INPUT,
    MODULE_OUTPUT,
    MODULE_FILTER,
    MODULE_PRINT,
    MODULE_PATH_EFFECT,
    MODULE_UNKNOWN_FUNC
};
 
class SPDocument;
 
namespace Inkscape {
 
namespace XML {
class Node;
} // namespace XML
 
namespace Extension {
 
class ExecutionEnv;
class Dependency;
class ProcessingAction;
class ExpirationTimer;
class ExpirationTimer;
class InxParameter;
class InxWidget;
 
namespace Implementation {
class Implementation;
} // namespace Implementation
 
class Extension {
public:
    enum state_t {
        STATE_LOADED,      
        STATE_UNLOADED,    
        STATE_DEACTIVATED  
    };
    using ImplementationHolder = Util::HybridPointer<Implementation::Implementation>;
 
private:
    std::string _id  ;                         
    std::string _name;                         
    state_t    _state = STATE_UNLOADED;        
    int _priority = 0;                         
    std::vector<std::unique_ptr<Dependency>> _deps; 
    static FILE *error_file;                   
    std::string _error_reason;                 
    bool _gui = true;
 
    std::vector<ProcessingAction> _actions;    
protected:
    Inkscape::XML::Node *repr;                 
    ImplementationHolder imp;
    std::string _base_directory;               
    std::unique_ptr<ExpirationTimer> timer;    
    bool _translation_enabled = true;          
private:
    char const *_translationdomain = nullptr;  
    std::string _gettext_catalog_dir;          
    void lookup_translation_catalog();
 
public:
    Extension(Inkscape::XML::Node *in_repr, ImplementationHolder implementation, std::string *base_directory);
    virtual ~Extension();
 
    void          set_state    (state_t in_state);
    state_t       get_state    ();
    bool          loaded       ();
    virtual bool  check        ();
    virtual bool prefs();
    Inkscape::XML::Node *get_repr();
    char const   *get_id       () const;
    char const   *get_name     () const;
    virtual void  deactivate   ();
    bool          deactivated  ();
    void          printFailure (Glib::ustring const &reason);
    std::string const &getErrorReason() { return _error_reason; };
    Implementation::Implementation *get_imp() { return imp.get(); }
    auto const   &get_base_directory() const { return _base_directory; };
    void          set_base_directory(std::string const &base_directory) { _base_directory = base_directory; };
    std::string   get_dependency_location(char const *name);
    char const   *get_translation(char const *msgid, char const *msgctxt = nullptr) const;
    void          set_environment(SPDocument const *doc = nullptr);
    ModuleImpType get_implementation_type();
 
    int get_sort_priority() const { return _priority; }
    void set_sort_priority(int priority) { _priority = priority; }
 
    void run_processing_actions(SPDocument *doc);
 
    /* Parameter Stuff */
private:
    std::vector<std::unique_ptr<InxWidget>> _widgets; 
public:
    unsigned int widget_visible_count() const;
 
    class param_not_exist {};
 
    class extension_no_id{};
 
    class extension_no_name{};
 
    class extension_not_compatible{};
 
    class no_implementation_for_extension : public std::exception {};
 
    class no_overwrite {};
 
private:
    void             make_param       (Inkscape::XML::Node * paramrepr);
 
     InxParameter *get_param(char const *name);
 
     InxParameter const *get_param(char const *name) const;
 
public:
    bool        get_param_bool          (char const *name) const;
    bool        get_param_bool          (char const *name, bool alt) const;
    int         get_param_int           (char const *name) const;
    int         get_param_int           (char const *name, int alt) const;
    double      get_param_float         (char const *name) const;
    double      get_param_float         (char const *name, double alt) const;
    char const *get_param_string        (char const *name, char const *alt) const;
    char const *get_param_string        (char const *name) const;
    char const *get_param_optiongroup   (char const *name, char const *alt) const;
    char const *get_param_optiongroup   (char const *name) const;
 
    Colors::Color get_param_color(char const *name) const;
 
    bool get_param_optiongroup_contains (char const *name, char const   *value) const;
    bool get_param_optiongroup_is(char const *name, std::string_view value, bool alt = false) const;
 
    bool        set_param_bool          (char const *name, bool    value);
    int         set_param_int           (char const *name, int     value);
    double      set_param_float         (char const *name, double  value);
    char const *set_param_string        (char const *name, char const   *value);
    char const *set_param_optiongroup   (char const *name, char const   *value);
    void        set_param_color         (char const *name, Colors::Color const &color);
    void set_param_any(char const *name, std::string const &value);
    void set_param_hidden(char const *name, bool hidden);
 
    /* Error file handling */
    static void      error_file_open ();
    static void      error_file_close();
    static void      error_file_write(Glib::ustring const &text);
 
    Gtk::Widget *autogui (SPDocument *doc, Inkscape::XML::Node *node, sigc::signal<void ()> *changeSignal = nullptr);
    void paramListString(std::list<std::string> &retlist) const;
    void set_gui(bool s) { _gui = s; }
    bool get_gui() const { return _gui; }
 
    /* Extension editor dialog stuff */
    Gtk::Box *get_info_widget();
    Gtk::Box *get_params_widget();
 
protected:
    inline static void add_val(Glib::ustring const &labelstr, Glib::ustring const &valuestr,
                               Gtk::Grid * table, int * row);
};
 
/*
This is a prototype for how collections should work.  Whoever gets
around to implementing this gets to decide what a 'folder' and an
'item' really is.  That is the joy of implementing it, eh?
 
class Collection : public Extension {
 
public:
    folder  get_root (void);
    int     get_count (folder);
    thumbnail get_thumbnail(item);
    item[]  get_items(folder);
    folder[]  get_folders(folder);
    metadata get_metadata(item);
    image   get_image(item);
 
};
*/
 
} // namespace Extension
} // namespace Inkscape
 
#endif // INK_EXTENSION_H
 
/*
  Local Variables:
  mode:c++
  c-file-style:"stroustrup"
  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
  indent-tabs-mode:nil
  fill-column:99
  End:
*/
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :