canvas.h

Go to the documentation of this file.

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

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

#ifndef __SYNFIG_CANVAS_H
#define __SYNFIG_CANVAS_H

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

#include <map>
#include <list>
#include <ETL/handle>
#include <sigc++/signal.h>
#include <sigc++/connection.h>

#include "vector.h"
#include "string.h"
#include "canvasbase.h"
#include "valuenode.h"
#include "keyframe.h"
#include "renddesc.h"
#include "node.h"
#include "guid.h"
#include "filesystem.h"

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

/* version change history:
 *
 * 0.1: the original version
 *
 *      if a waypoint goes from -179 to 179 degrees, that is a 2
 *      degree change.  there's no way to express a 720 degree
 *      rotation with a single pair of waypoints
 *
 * 0.2: svn r1227
 *
 *      angles no longer wrap at -180 degrees back to 180 degrees; if
 *      a waypoint goes from -179 to 179 degrees, that is a rotation
 *      of 358 degrees.  loading a version 0.1 canvas will modify
 *      constant angle waypoints to that they are within 180 degrees
 *      of the previous waypoint's value
 *
 *      the 'straight' blend method didn't used to work properly.  it
 *      didn't work at all on transparent pixels in layers other than
 *      the PasteCanvas layer.  for example, the examples/japan.sifz
 *      file has a red circle (straight, amount=1.0) on top of a
 *      striped conical gradient.  if 'straight' was working, the
 *      conical gradient would be entirely obscured by the circle
 *      layer (even by its transparent pixels)
 *
 * 0.3: svn r1422
 *
 *      the 'straight' blend method was fixed.  loading a version 0.2
 *      or older canvas will replace the 'straight' blend method in
 *      non-pastecanvas layers with 'composite', unless they're
 *      completely transparent, in which case it will replace them
 *      with an  'alpha over' blend instead.  Images like
 *      examples/logo.sifz use transparent straight blends to do
 *      masking, which no longer works now that 'straight' blending is
 *      fixed.
 *
 *      Tangent lengths calculated by the "Segment Tangent" and "BLine
 *      Tangent" ValueNodes were scaled by a factor of 0.5.
 *
 * 0.4: svn r1856
 *
 *      Stop scaling tangents by 0.5.
 *
 * 0.5: svn r1863
 *
 *      Added "offset", "scale", and "fixed_length" links to the
 *      "BLine Tangent" ValueNode.
 *
 * 0.6: svn r2067
 *
 *      Added "scale" link to the "BLine Width" ValueNode in svn r1872.
 *
 *      Added "loop" link to the "Gradient Color" ValueNode in svn r1901.
 *
 * 0.7: svn r2315
 *
 *      Added "loop" link to the "Random" ValueNode in svn r2315.
 *
 * 0.8: git 82baee2702a65a9866f3dc4a28ef163dcf43795a
 *
 *      Added "homogenous" link to "BLineCalcVertex", "BLineCalcTangent"
 *      and "BLineCalcWidth" valuenodes.
 *
 * 0.9: git 6922776b8129fdae6cb42953b2715decc810786c
 *
 *      Added "split_radius" and "split_angle" to BLinePoint Composite
 *      Value Node
 *
 * 1.0 git
 *
 *      Added a canvas component called
 */

#define CURRENT_CANVAS_VERSION "1.0"

/* === 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 IndependentContext;
class ContextParams;
class Context;
class GUID;
class Canvas;
class SoundProcessor;

typedef        etl::handle<Canvas>     CanvasHandle;

void optimize_layers(Time, Context, CanvasHandle, bool seen_motion_blur=false);

class Canvas : public CanvasBase, public Node
{
    /*
 -- ** -- T Y P E S -----------------------------------------------------------
    */

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

    typedef std::list<Handle> Children;

    friend void synfig::optimize_layers(Time, Context, Canvas::Handle, bool seen_motion_blur);

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

private:


    String id_;


    String name_;


    String description_;


    String version_;


    String author_;


    String email_;


    String file_name_;


    FileSystem::Identifier identifier_;


    std::map<String, String> meta_data_;


    ValueNodeList value_node_list_;


    KeyframeList keyframe_list_;


    LooseHandle parent_;


    Children children_;


    RendDesc desc_;

    Time cur_time_;

    mutable std::map<String,Handle> externals_;

    bool is_inline_;

    mutable bool is_dirty_;

    bool op_flag_;

    std::map<String,std::set<etl::handle<Layer> > > group_db_;

    std::map<etl::loose_handle<Layer>,std::vector<sigc::connection> > connections_;


    Real grow_value;


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

private:

    sigc::signal<void,String> signal_group_added_;

    sigc::signal<void,String> signal_group_removed_;

    sigc::signal<void,String> signal_group_changed_;

    sigc::signal<void,String,etl::handle<synfig::Layer> > signal_group_pair_added_;
    sigc::signal<void,String,etl::handle<synfig::Layer> > signal_group_pair_removed_;

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

    sigc::signal<void> signal_rend_desc_changed_;

    sigc::signal<void> signal_id_changed_;

    //sigc::signal<void> signal_dirty_;

    sigc::signal<void> signal_file_name_changed_;

    sigc::signal<void, String> signal_meta_data_changed_;

    std::map<String, sigc::signal<void> > signal_map_meta_data_changed_;


    sigc::signal<void, etl::handle<ValueNode> > signal_value_node_changed_;
    sigc::signal<void, etl::handle<ValueNode> > signal_value_node_renamed_;
    sigc::signal<void, etl::handle<ValueNode>, etl::handle<ValueNode> > signal_value_node_child_added_;
    sigc::signal<void, etl::handle<ValueNode>, etl::handle<ValueNode> > signal_value_node_child_removed_;

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

public:

    sigc::signal<void,String,etl::handle<synfig::Layer> >& signal_group_pair_added() { return signal_group_pair_added_; }
    sigc::signal<void,String,etl::handle<synfig::Layer> >& signal_group_pair_removed() { return signal_group_pair_removed_; }

    sigc::signal<void,String>& signal_group_added() { return signal_group_added_; }

    sigc::signal<void,String>& signal_group_removed() { return signal_group_removed_; }

    sigc::signal<void,String>& signal_group_changed() { return signal_group_changed_; }

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

    sigc::signal<void>& signal_rend_desc_changed() { return signal_rend_desc_changed_; }

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

    sigc::signal<void>& signal_file_name_changed();

    sigc::signal<void, String>& signal_meta_data_changed() { return signal_meta_data_changed_; }

    sigc::signal<void>& signal_meta_data_changed(const String& key) { return signal_map_meta_data_changed_[key]; }

    sigc::signal<void, etl::handle<ValueNode> >& signal_value_node_changed() { return signal_value_node_changed_; }
    sigc::signal<void, etl::handle<ValueNode> >& signal_value_node_renamed() { return signal_value_node_renamed_; }

    sigc::signal<void>& signal_dirty() { return signal_changed();   }

    sigc::signal<void, etl::handle<ValueNode>, etl::handle<ValueNode> >& signal_value_node_child_added() { return signal_value_node_child_added_; }

    sigc::signal<void, etl::handle<ValueNode>, etl::handle<ValueNode> >& signal_value_node_child_removed() { return signal_value_node_child_removed_; }

    void invoke_signal_value_node_child_removed(etl::handle<ValueNode>, etl::handle<ValueNode>);

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

protected:
    Canvas(const String &name);

public:

    ~Canvas();

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

public:

    std::set<etl::handle<Layer> > get_layers_in_group(const String&group);

    std::set<String> get_groups()const;

    int get_group_count()const;

    void rename_group(const String&old_name,const String&new_name);

    bool is_inline()const { return is_inline_; }

    RendDesc &rend_desc() { return desc_; }

    const RendDesc &rend_desc()const { return desc_; }

    const String & get_name()const { return name_; }

    void set_name(const String &x);

    const String get_version()const { return version_; }

    void set_version(const String &x) { version_ = x; }

    const String & get_author()const { return author_; }

    void set_author(const String &x);

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

    String get_string()const;

    void set_description(const String &x);

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

    void set_id(const String &x);

    String get_meta_data(const String& key)const;

    std::list<String> get_meta_data_keys()const;

    void set_meta_data(const String& key, const String& data);

    void erase_meta_data(const String& key);

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

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

    bool is_root()const { return !parent_; }


    LooseHandle parent()const { return parent_; }

    LooseHandle get_root()const;

    LooseHandle get_non_inline_ancestor()const;

    std::list<Handle> &children() { return children_; }

    const std::list<Handle> &children()const { return children_; }

    //Color get_color(const Point &pos)const;

    void set_time(Time t)const;

    Time get_time()const { return cur_time_; }

    int size()const;

    void clear();

    bool empty()const;

    // ValueNodeList &value_node_list() { return value_node_list_; }

    const ValueNodeList &value_node_list()const;

    KeyframeList &keyframe_list();

    const KeyframeList &keyframe_list()const;


    ValueNode::Handle find_value_node(const String &id, bool might_fail);

    ValueNode::Handle surefind_value_node(const String &id);


    ValueNode::ConstHandle find_value_node(const String &id, bool might_fail)const;



    void add_value_node(ValueNode::Handle x, const String &id);

    //void rename_value_node(ValueNode::Handle x, const String &id);

    void remove_value_node(ValueNode::Handle x, bool might_fail);

    void remove_value_node(const String &id, bool might_fail) { remove_value_node(find_value_node(id, might_fail), might_fail); }


    Handle surefind_canvas(const String &id,String &warnings);


    Handle find_canvas(const String &id, String &warnings);


    ConstHandle find_canvas(const String &id, String &warnings)const;

    //void set_file_path(const String &);

    String get_file_path()const;

    void set_file_name(const String &);

    String get_file_name()const;

    void set_identifier(const FileSystem::Identifier &);

    const FileSystem::Identifier& get_identifier()const;

    Handle new_child_canvas();

    Handle new_child_canvas(const String &id);

    Handle add_child_canvas(Handle child_canvas, const String &id);

    void remove_child_canvas(Handle child_canvas);

    etl::handle<Layer> find_layer(const ContextParams &context_params, const Point &pos);

    int get_depth(etl::handle<Layer>)const;

    IndependentContext get_independent_context()const;

    Context get_context(const ContextParams &params)const;

    Context get_context(const Context &parent_context)const;


    iterator end();

    const_iterator end()const;

    reverse_iterator rbegin();

    const_reverse_iterator rbegin()const;
    etl::handle<Layer> &back();
    const etl::handle<Layer> &back()const;
    void push_back(etl::handle<Layer> x);
    void push_front(etl::handle<Layer> x);
    void push_back_simple(etl::handle<Layer> x);
    void insert(iterator iter,etl::handle<Layer> x);
    void erase(iterator iter);
    void set_inline(LooseHandle parent);
    static Handle create();
    static Handle create_inline(Handle parent);

    Handle clone(const GUID& deriv_guid=GUID(), bool for_export=false)const;

    void register_external_canvas(String file, Handle canvas);
    Real get_grow_value()const;
    void set_grow_value(Real x);

#if 0
    void show_canvas_ancestry(String file, int line, String note)const;
    void show_canvas_ancestry()const;
#endif

#ifdef _DEBUG
    void show_externals(String file, int line, String text) const;
    void show_structure(int i) const;
#endif  // _DEBUG

private:
    void add_group_pair(String group, etl::handle<Layer> layer);
    void remove_group_pair(String group, etl::handle<Layer> layer);
    void add_connection(etl::loose_handle<Layer> layer, sigc::connection connection);
    void disconnect_connections(etl::loose_handle<Layer> layer);

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

public:
    void fill_sound_processor(SoundProcessor &soundProcessor) const;
}; // END of class Canvas

}; // END of namespace synfig

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

#endif