module.h

Go to the documentation of this file.

/* === S Y N F I G ========================================================= */
/* ========================================================================= */

/* === S T A R T =========================================================== */

#ifndef __SYNFIG_MODULE_H
#define __SYNFIG_MODULE_H

/* === H E A D E R S ======================================================= */

#include "general.h"
#include <ETL/handle>
#include <map>
#include "string.h"
#include "releases.h"
#include <utility>
#include "vector.h"
#include "color.h"
#include "layer.h"
#include "canvas.h"

//#include "value.h"

/* === M A C R O S ========================================================= */

#define MODULE_DESC_BEGIN(x) struct x##_modclass : public synfig::Module { x##_modclass(synfig::ProgressCallback *callback=NULL);

#define MODULE_NAME(x)          virtual const char * Name() { return x; }

#define MODULE_DESCRIPTION(x)   virtual const char * Desc() { return x; }

#define MODULE_AUTHOR(x)        virtual const char * Author() { return x; }

#define MODULE_VERSION(x)       virtual const char * Version() { return x; }

#define MODULE_COPYRIGHT(x)     virtual const char * Copyright() { return x; }

#define MODULE_CONSTRUCTOR(x)   bool constructor_(synfig::ProgressCallback *cb) { return x(cb); }

#define MODULE_DESTRUCTOR(x)    virtual void destructor_() { return x(); }

#define MODULE_DESC_END };

//#if 0
#ifdef __APPLE__

#define MODULE_INVENTORY_BEGIN(x)  extern "C" {     \
    synfig::Module* _##x##_LTX_new_instance(synfig::ProgressCallback *cb) \
    { if(SYNFIG_CHECK_VERSION()){x##_modclass *mod=new x##_modclass(cb); mod->constructor_(cb); return mod; }\
    if(cb)cb->error(#x": Unable to load module due to version mismatch."); return NULL; } \
    }; x##_modclass::x##_modclass(synfig::ProgressCallback */*cb*/) {
#else

#define MODULE_INVENTORY_BEGIN(x)  extern "C" {     \
    synfig::Module* x##_LTX_new_instance(synfig::ProgressCallback *cb) \
    { if(SYNFIG_CHECK_VERSION()){x##_modclass *mod=new x##_modclass(cb); mod->constructor_(cb); return mod; }\
    if(cb)cb->error(#x": Unable to load module due to version mismatch."); return NULL; } \
    }; x##_modclass::x##_modclass(synfig::ProgressCallback */*cb*/) {
#endif

#define BEGIN_LAYERS {

// Really? ^^ The INCLUDE_LAYER(class) macro is defined in a cpp file and
// is undefined a few lines later. In fact the INCLUDE_LAYER is only
// used in the layer.cpp file and the functionality is the same. Even
// more, I think that we should use register_in_book call because maybe
// the Layer class would like to do something else when register the class.
#define LAYER(class)                                                                            \
    synfig::Layer::register_in_book(                                                            \
        synfig::Layer::BookEntry(class::create,                                                 \
                                 class::name__,                                                 \
                                 dgettext("synfig", class::local_name__),                       \
                                 class::category__,                                             \
                                 class::cvs_id__,                                               \
                                 class::version__));

#define LAYER_ALIAS(class,alias)                                                                \
    synfig::Layer::register_in_book(                                                            \
        synfig::Layer::BookEntry(class::create,                                                 \
                                 alias,                                                         \
                                 alias,                                                         \
                                 CATEGORY_DO_NOT_USE,                                           \
                                 class::cvs_id__,                                               \
                                 class::version__));

#define END_LAYERS }

#define BEGIN_TARGETS {

#define TARGET(x)                                                       \
    synfig::Target::book()[synfig::String(x::name__)].factory =         \
        reinterpret_cast<synfig::Target::Factory> (x::create);          \
    synfig::Target::book()[synfig::String(x::name__)].filename =        \
        synfig::String(x::ext__);                                       \
    synfig::Target::book()[synfig::String(x::name__)].target_param =    \
        synfig::TargetParam();                                                  \
    synfig::Target::ext_book()[synfig::String(x::ext__)]=x::name__;

#define TARGET_EXT(x,y) synfig::Target::ext_book()[synfig::String(y)]=x::name__;

#define END_TARGETS }

#define BEGIN_IMPORTERS {

#define IMPORTER_EXT(x,y) \
        synfig::Importer::book()[synfig::String(y)]=synfig::Importer::BookEntry(x::create, x::supports_file_system_wrapper__);

#define IMPORTER(x) IMPORTER_EXT(x,x::ext__)

#define CAIROIMPORTER_EXT(x,y) \
        synfig::CairoImporter::book()[synfig::String(y)]=synfig::CairoImporter::BookEntry(x::create, x::supports_file_system_wrapper__);

#define CAIROIMPORTER(x) CAIROIMPORTER_EXT(x,x::ext__)

#define END_IMPORTERS }

#define BEGIN_VALUENODES { synfig::LinkableValueNode::Book &book(synfig::LinkableValueNode::book());

#define VALUENODE(class,name,local,version)                                                     \
    book[name].factory=reinterpret_cast<synfig::LinkableValueNode::Factory>(&class::create);    \
    book[name].check_type=&class::check_type;                                                   \
    book[name].local_name=local;                                                                \
    book[name].release_version=version;

#define END_VALUENODES }

#define MODULE_INVENTORY_END    }

/* === T Y P E D E F S ===================================================== */

/* === C L A S S E S & S T R U C T S ======================================= */

namespace synfig {

class ProgressCallback;

class Module : public etl::shared_object
{
public:
    bool constructor_(synfig::ProgressCallback */*cb*/) { return true; }
    virtual void destructor_() { }

    typedef etl::handle<Module> Handle;
    typedef etl::loose_handle<Module> LooseHandle;
    typedef etl::handle<const Module> ConstHandle;

public:
    typedef Module* (*constructor_type)(ProgressCallback *);
    typedef std::map<String, Handle > Book;
private:
    static Book* book_;
public:
    static Book& book();

    static bool subsys_init(const String &prefix);
    static bool subsys_stop();
    static void register_default_modules(ProgressCallback *cb=NULL);

    static void Register(Handle mod);
    static bool Register(const String &module_name, ProgressCallback *cb=NULL);
    static inline void Register(Module *mod) { Register(Handle(mod)); }

    virtual const char * Name() { return " "; }
    virtual const char * Desc() { return " "; }
    virtual const char * Author() { return " "; }
    virtual const char * Version() { return " "; }
    virtual const char * Copyright() { return SYNFIG_COPYRIGHT; }

    virtual ~Module() { destructor_(); }
};

}; // END of namespace synfig

/* === E N D =============================================================== */

#endif