layer.h

Go to the documentation of this file.

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

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

#ifndef __SYNFIG_LAYER_H
#define __SYNFIG_LAYER_H

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

#include <map>
#include <ETL/handle>
#include "real.h"
#include "string.h"
#include <sigc++/signal.h>
#include <sigc++/connection.h>
#include "node.h"
#include "time.h"
#include "guid.h"
#include "interpolation.h"
#include "target.h" // for RenderMethod. TODO: put RenderMethod apart

#include "cairo.h"
#include "rendermethod.h"

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

// This macros should be removed when rendering optimization complete
#define RENDER_TRANSFORMED_IF_NEED(file, line) \
    if (!renddesc.get_transformation_matrix().is_identity()) \
        return render_transformed(this, context, surface, quality, renddesc, cb, file, line);


#define SYNFIG_LAYER_MODULE_EXT                                                         \
    public:                                                                             \
    static const char name__[], version__[], cvs_id__[], local_name__[], category__[];  \
    static Layer *create();

#define SYNFIG_LAYER_SET_NAME(class,x)                                                  \
    const char class::name__[]=x

#define SYNFIG_LAYER_SET_LOCAL_NAME(class,x)                                            \
    const char class::local_name__[]=x;

#define SYNFIG_LAYER_SET_CATEGORY(class,x)                                              \
    const char class::category__[]=x

#define SYNFIG_LAYER_SET_VERSION(class,x)                                               \
    const char class::version__[]=x

#define SYNFIG_LAYER_SET_CVS_ID(class,x)                                                \
    const char class::cvs_id__[]=x

#define SYNFIG_LAYER_INIT(class)                                                        \
    synfig::Layer* class::create()                                                      \
    {                                                                                   \
        return new class();                                                             \
    }

#define IMPORT_VALUE(x)                                                         \
    if (#x=="param_"+param && x.get_type()==value.get_type())                   \
    {                                                                           \
        x=value;                                                                \
        return true;                                                            \
    }

#define IMPORT_VALUE_PLUS_BEGIN(x)                                              \
    if (#x=="param_"+param && x.get_type()==value.get_type())                   \
    {                                                                           \
        x=value;                                                                \
        {
#define IMPORT_VALUE_PLUS_END                                                   \
        }                                                                       \
        return true;                                                            \
    }
#define IMPORT_VALUE_PLUS(x,y)                                                  \
        IMPORT_VALUE_PLUS_BEGIN(x)                                              \
            y;                                                                  \
        IMPORT_VALUE_PLUS_END

#define EXPORT_VALUE(x)                                                         \
    if (#x=="param_"+param)                                                     \
    {                                                                           \
        synfig::ValueBase ret;                  \
        ret.copy(x);                            \
        return ret;                         \
    }

#define EXPORT_NAME()                                                                   \
    if (param=="Name" || param=="name" || param=="name__")                              \
        return name__;                                                                  \
    else if (param=="local_name__")                                                     \
        return dgettext("synfig",local_name__);

#define EXPORT_VERSION()                                                                \
    if (param=="Version" || param=="version" || param=="version__")                     \
        return version__;

#define CATEGORY_DO_NOT_USE "Do Not Use"

#define SET_INTERPOLATION_DEFAULTS()                                           \
{                                                                              \
    Vocab vocab(get_param_vocab());                                            \
    Vocab::const_iterator viter;                                               \
    for(viter=vocab.begin();viter!=vocab.end();viter++)                        \
    {                                                                          \
        ValueBase v=get_param(viter->get_name());                              \
        v.set_interpolation(viter->get_interpolation());                       \
        set_param(viter->get_name(), v);                                       \
    }                                                                          \
}                                                                              \


#define SET_STATIC_DEFAULTS()                                                  \
{                                                                              \
    Vocab vocab(get_param_vocab());                                            \
    Vocab::const_iterator viter;                                               \
    for(viter=vocab.begin();viter!=vocab.end();viter++)                        \
    {                                                                          \
        ValueBase v=get_param(viter->get_name());                              \
        v.set_static(viter->get_static());                                     \
        set_param(viter->get_name(), v);                                       \
    }                                                                          \
}                                                                              \

/* === 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 Canvas;
class Vector;
typedef Vector Point;
class Canvas;
class ParamDesc;
class ParamVocab;
class ValueNode;
class ValueBase;
class Time;
class Surface;
class CairoSurface;
class RendDesc;
class ProgressCallback;
class IndependentContext;
class Context;
class Color;
class CairoColor;
class Transform;
class Rect;
class GUID;


class Layer : public Node
{
    friend class ValueNode;
    friend class IndependentContext;
    friend class Context;

    /*
 -- ** -- T Y P E S -----------------------------------------------------------
    */

public:


    typedef Layer* (*Factory)();

    struct BookEntry
    {
        Factory factory;
        String name;
        String local_name;
        String category;
        String cvs_id;
        String version;
        BookEntry(): factory() { }
        BookEntry(Factory        factory,
                  const String  &name,
                  const String  &local_name,
                  const String  &category,
                  const String  &cvs_id,
                  const String  &version):
            factory(factory),
            name(name),
            local_name(local_name),
            category(category),
            cvs_id(cvs_id),
            version(version) { }
    };


    typedef std::map<String,BookEntry> Book;

    static void register_in_book(const BookEntry &);

    static Book& book();


    static bool subsys_init();

    static bool subsys_stop();

    typedef std::map<String,ValueBase> ParamList;

    typedef etl::handle<Layer> Handle;

    typedef etl::loose_handle<Layer> LooseHandle;

    typedef etl::handle<const Layer> ConstHandle;

    typedef std::map<String,etl::rhandle<ValueNode> > DynamicParamList;


    typedef ParamVocab Vocab;

    /*
 -- ** -- D A T A -------------------------------------------------------------
    */

private:

    bool active_;

    bool optimized_;

    bool exclude_from_rendering_;

    etl::loose_handle<Canvas> canvas_;

    DynamicParamList dynamic_param_list_;

    String description_;

    ValueBase param_z_depth;

    mutable Time dirty_time_;

    String group_;

    sigc::connection parent_death_connect_;

    /*
 -- ** -- S I G N A L S -------------------------------------------------------
    */

private:

    sigc::signal<void> signal_status_changed_;

    sigc::signal<void,String> signal_param_changed_;

    sigc::signal<void> signal_description_changed_;

    sigc::signal<void, int, etl::handle<Canvas> > signal_moved_;

    sigc::signal<void, String> signal_added_to_group_;

    sigc::signal<void, String> signal_removed_from_group_;

    /*
 -- ** -- S I G N A L   I N T E R F A C E -------------------------------------
    */

public:

    sigc::signal<void>& signal_status_changed() { return signal_status_changed_; }

    sigc::signal<void,String>& signal_param_changed() { return signal_param_changed_; }

    sigc::signal<void>& signal_description_changed() { return signal_description_changed_;}

    sigc::signal<void, int, etl::handle<Canvas> >& signal_moved() { return signal_moved_; }

    sigc::signal<void, String>& signal_added_to_group() { return signal_added_to_group_; }

    sigc::signal<void, String>& signal_removed_from_group() { return signal_removed_from_group_; }

    /*
 -- ** -- C O N S T R U C T O R S ---------------------------------------------
    */

protected:

    Layer();

public:
    virtual ~Layer();

    /*
 -- ** -- M E M B E R   F U N C T I O N S -------------------------------------
    */

public:

    virtual void on_canvas_set();

    void add_to_group(const String&);

    void remove_from_group(const String&);

    void remove_from_all_groups();

    String get_group()const;

    const DynamicParamList &dynamic_param_list()const { return dynamic_param_list_; }

    void enable() { set_active(true); }


    void disable() { set_active(false); }


    void set_active(bool x);

    bool active()const { return active_; }

    bool optimized()const { return optimized_; }

    void set_optimized(bool x) { optimized_ = x; }


    void set_exclude_from_rendering(bool x);

    bool get_exclude_from_rendering()const { return exclude_from_rendering_; }


    int get_depth()const;

    float get_z_depth()const { return param_z_depth.get(Real()); }

    float get_z_depth(const synfig::Time& t)const;

    float get_true_z_depth(const synfig::Time& t=Time(0))const;

    void set_z_depth(float x) { param_z_depth=ValueBase(Real(x)); }

    void set_canvas(etl::loose_handle<Canvas> canvas);

    etl::loose_handle<Canvas> get_canvas()const;

    const String& get_description()const { return description_; }


    String get_string()const;

    void set_description(const String& x);

    const String get_non_empty_description()const { return get_description().empty() ? get_local_name() : get_description(); }

    const String get_param_local_name(const String &param_name)const;


    Layer::LooseHandle get_parent_paste_canvas_layer()const;

    /*
 -- ** -- V I R T U A L   F U N C T I O N S -----------------------------------
    */

public:
    virtual Rect get_bounding_rect()const;

    virtual Rect get_full_bounding_rect(Context context)const;

    virtual String get_name()const;

    virtual String get_local_name()const;

    virtual Vocab get_param_vocab()const;

    virtual String get_version()const;

    virtual etl::handle<Transform> get_transform()const;


    virtual bool set_version(const String &ver);


    virtual void reset_version();


    virtual bool set_param(const String &param, const ValueBase &value);

    virtual bool set_param_list(const ParamList &);


    virtual ValueBase get_param(const String &param)const;

    virtual ParamList get_param_list()const;


    virtual void set_time(IndependentContext context, Time time)const;


    virtual void set_time(IndependentContext context, Time time, const Point &point)const;


    virtual Color get_color(Context context, const Point &pos)const;
    virtual CairoColor get_cairocolor(Context context, const Point &pos)const;

    virtual void set_render_method(Context context, RenderMethod x);
    
    // Temporary function to render transformed layer for leyers which yet not suppurt transformed rendering
    static bool render_transformed(const Layer *layer, Context context,Surface *surface,int quality, const RendDesc &renddesc, ProgressCallback *cb, const char *file, int line);


    virtual bool accelerated_render(Context context,Surface *surface,int quality, const RendDesc &renddesc, ProgressCallback *cb)const;
    virtual bool accelerated_cairorender(Context context, cairo_t* cr, int quality, const RendDesc &renddesc, ProgressCallback *cb)const;


    virtual Handle hit_check(Context context, const Point &point)const;

    virtual Handle clone(etl::loose_handle<Canvas> canvas, const GUID& deriv_guid=GUID())const;


    virtual bool reads_context()const;

    virtual Handle simple_clone()const;

    virtual bool connect_dynamic_param(const String& param, etl::loose_handle<ValueNode>);

    virtual bool disconnect_dynamic_param(const String& param);

    Real get_parent_canvas_grow_value()const;

    virtual void fill_sound_processor(SoundProcessor &soundProcessor) const;

protected:

    virtual void on_changed();

    virtual void get_times_vfunc(Node::time_set &set) const;

    /*
 -- ** -- S T A T I C  F U N C T I O N S --------------------------------------
    */

public:


    static Layer::LooseHandle create(const String &type);

}; // END of class Layer

}; // END of namespace synfig


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

#endif