valuenode.h

Go to the documentation of this file.

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

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

#ifndef __SYNFIG_VALUENODE_H
#define __SYNFIG_VALUENODE_H

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

#include "vector.h"
#include "value.h"
#include "string.h"
#include "releases.h"
#include <ETL/handle>
#include <ETL/stringf>
#include "exception.h"
#include <map>
#include <sigc++/signal.h>
#include "guid.h"
#include <ETL/angle>
#include "paramdesc.h"
#include "interpolation.h"

#include "node.h"

#include <set>

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

#define VALUENODE_CHECK_TYPE(type)                                      \
    /* I don't think this ever happens - maybe remove this code? */     \
    if (get_type() == type_nil) {                                       \
        warning("%s:%d get_type() IS nil sometimes!",                   \
                __FILE__, __LINE__);                                    \
        return false;                                                   \
    }                                                                   \
    if (get_type() != type_nil &&                                       \
        !(ValueBase::can_copy(value->get_type(), type)) &&              \
        !PlaceholderValueNode::Handle::cast_dynamic(value)) {           \
        error(_("%s:%d wrong type for %s: need %s but got %s"),         \
              __FILE__, __LINE__,                                       \
              link_local_name(i).c_str(),                               \
              type.description.local_name.c_str(),                      \
              value->get_type().description.local_name.c_str() );       \
        return false;                                                   \
    }

#define VALUENODE_SET_VALUE(variable)                                   \
    variable = value;                                                   \
    signal_child_changed()(i);                                          \
    signal_value_changed()();                                           \
    return true

#define CHECK_TYPE_AND_SET_VALUE(variable, type)                        \
    VALUENODE_CHECK_TYPE(type)                                          \
    VALUENODE_SET_VALUE(variable)

/* === 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 LinkableValueNode;
class Layer;
class ParamVocab;

class ValueNode : public synfig::Node
{
    friend class Layer;
    friend class LinkableValueNode;

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

public:

    typedef etl::handle<ValueNode> Handle;

    typedef etl::loose_handle<ValueNode> LooseHandle;

    typedef etl::handle<const ValueNode> ConstHandle;

    typedef etl::rhandle<ValueNode> RHandle;

    static bool subsys_init();
    static bool subsys_stop();

    static void breakpoint();

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

private:
    Type *type;
    String name;
    etl::loose_handle<Canvas> canvas_;
    etl::loose_handle<Canvas> root_canvas_;

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

private:

    sigc::signal<void> signal_value_changed_;

    sigc::signal<void,int*> signal_children_reordered_;

    sigc::signal<void,int> signal_child_changed_;

    sigc::signal<void,int> signal_child_removed_;

    sigc::signal<void,int> signal_child_inserted_;

    sigc::signal<void> signal_id_changed_;

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

public:

    sigc::signal<void>& signal_value_changed() { return signal_value_changed_; }

    sigc::signal<void,int*>& signal_children_reordered() { return signal_children_reordered_; }

    sigc::signal<void,int>& signal_child_changed() { return signal_child_changed_; }

    sigc::signal<void,int>& signal_child_removed() { return signal_child_removed_; }

    sigc::signal<void,int>& signal_child_inserted() { return signal_child_inserted_; }

    sigc::signal<void>& signal_id_changed() { return signal_id_changed_; }

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

protected:

    ValueNode(Type &type=type_nil);

public:

    virtual ~ValueNode();

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

public:

    virtual ValueBase operator()(Time /*t*/)const
        { return ValueBase(); }

    void set_id(const String &x);


    const String &get_id()const { return name; }

    virtual String get_name()const=0;

    virtual String get_local_name()const=0;

    virtual String get_description(bool show_exported_name = true)const;

    String get_string()const;

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

    bool is_exported()const { return !get_id().empty(); }

    bool is_descendant(ValueNode::Handle value_node_dest);

    Type& get_type()const { return *type; }

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

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

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

    void set_parent_canvas(etl::loose_handle<Canvas> x);

    virtual void set_root_canvas(etl::loose_handle<Canvas> x);

    String get_relative_id(etl::loose_handle<const Canvas> x)const;

    int replace(etl::handle<ValueNode> x);
    
    virtual Interpolation get_interpolation()const { return INTERPOLATION_UNDEFINED; }
    virtual void set_interpolation(Interpolation /* i*/) { }

protected:
    void set_type(Type &t) { type=&t; }

    virtual void on_changed();
}; // END of class ValueNode

class PlaceholderValueNode : public ValueNode
{
public:
    typedef etl::handle<PlaceholderValueNode> Handle;
    typedef etl::loose_handle<PlaceholderValueNode> LooseHandle;
    typedef etl::handle<const PlaceholderValueNode> ConstHandle;
    typedef etl::rhandle<PlaceholderValueNode> RHandle;

private:

    PlaceholderValueNode(Type &type=type_nil);

public:

    virtual ValueBase operator()(Time t)const;

    virtual String get_name()const;

    virtual String get_local_name()const;

    String get_string()const;

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

    static Handle create(Type &type=type_nil);

protected:
    virtual void get_times_vfunc(Node::time_set &/*set*/) const {}
}; // END of class PlaceholderValueNode


class LinkableValueNode : public ValueNode
{
    friend class ValueNode;
public:

    typedef etl::handle<LinkableValueNode> Handle;

    typedef etl::loose_handle<LinkableValueNode> LooseHandle;

    typedef etl::handle<const LinkableValueNode> ConstHandle;

    typedef etl::rhandle<LinkableValueNode> RHandle;



    typedef LinkableValueNode* (*Factory)(const ValueBase&, etl::loose_handle<Canvas> canvas);


    typedef bool (*CheckType)(Type &type);

    struct BookEntry
    {
        String local_name;
        Factory factory;
        CheckType check_type;
        ReleaseVersion release_version; // which version of synfig introduced this valuenode type
    };


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


    typedef ParamVocab Vocab;

    static Book& book();

    static Handle create(const String &name, const ValueBase& x, etl::loose_handle<Canvas> canvas /* = 0 */);

    static bool check_type(const String &name, Type &x);

public:
    LinkableValueNode(Type &type=type_nil):
        ValueNode(type) { }

protected:
    virtual bool set_link_vfunc(int i,ValueNode::Handle x)=0;

    void unlink_all();

public:

    virtual int link_count()const;

    virtual String link_local_name(int i)const;

    virtual String link_name(int i)const;

    virtual int get_link_index_from_name(const String &name)const;

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

    bool set_link(int i,ValueNode::Handle x);
    bool set_link(const String &name,ValueNode::Handle x) { return set_link(get_link_index_from_name(name),x);  }

    ValueNode::LooseHandle get_link(int i)const;
    ValueNode::LooseHandle get_link(const String &name)const { return get_link(get_link_index_from_name(name)); }
    String get_description(int index = -1, bool show_exported_name = true)const;
    String get_description(bool show_exported_name = true)const;

    virtual Vocab get_children_vocab()const;

    virtual void set_root_canvas(etl::loose_handle<Canvas> x);

protected:
    Vocab children_vocab;
    void set_type(Type &t) { ValueNode::set_type(t); }

    virtual ValueNode::LooseHandle get_link_vfunc(int i)const=0;

    virtual LinkableValueNode* create_new()const=0;

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

    virtual Vocab get_children_vocab_vfunc()const=0;

    virtual void set_children_vocab(const Vocab& rvocab);
}; // END of class LinkableValueNode

class ValueNodeList : public std::list<ValueNode::RHandle>
{
    int placeholder_count_;
public:
    ValueNodeList();


    ValueNode::Handle find(const String &name, bool might_fail);


    ValueNode::ConstHandle find(const String &name, bool might_fail)const;

    bool erase(ValueNode::Handle value_node);

    bool add(ValueNode::Handle value_node);

    bool count(const String &id)const;

    ValueNode::Handle surefind(const String &name);

    void audit();

    int placeholder_count()const { return placeholder_count_; }
};

ValueNode::LooseHandle find_value_node(const GUID& guid);

}; // END of namespace synfig

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

#endif