/* === S Y N F I G ========================================================= */
/*!	\file duckmatic.cpp
**	\brief Template File
**
**	$Id$
**
**	\legal
**	Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
**	Copyright (c) 2007, 2008 Chris Moore
**	Copyright (c) 2009, 2011 Nikita Kitaev
**  Copyright (c) 2011 Carlos López
**  Copyright (c) 2015 Blanchi Jérôme
**
**	This package is free software; you can redistribute it and/or
**	modify it under the terms of the GNU General Public License as
**	published by the Free Software Foundation; either version 2 of
**	the License, or (at your option) any later version.
**
**	This package is distributed in the hope that it will be useful,
**	but WITHOUT ANY WARRANTY; without even the implied warranty of
**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
**	General Public License for more details.
**	\endlegal
*/
/* ========================================================================= */

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

#ifdef USING_PCH
#	include "pch.h"
#else
#ifdef HAVE_CONFIG_H
#	include <config.h>
#endif
#include <fstream>
#include <iostream>
#include <algorithm>

#include <ETL/hermite>

#include <synfig/general.h>

#include "duckmatic.h"
#include "ducktransform_scale.h"
#include "ducktransform_translate.h"
#include "ducktransform_rotate.h"
#include <synfigapp/value_desc.h>
#include <synfigapp/canvasinterface.h>
#include <synfig/paramdesc.h>
#include <synfig/valuenodes/valuenode_timedswap.h>
#include <synfig/valuenodes/valuenode_animated.h>
#include <synfig/valuenodes/valuenode_composite.h>
#include <synfig/valuenodes/valuenode_range.h>
#include <synfig/valuenodes/valuenode_scale.h>
#include <synfig/valuenodes/valuenode_bline.h>
#include <synfig/valuenodes/valuenode_wplist.h>
#include <synfig/valuenodes/valuenode_blinecalctangent.h>
#include <synfig/valuenodes/valuenode_blinecalcvertex.h>
#include <synfig/valuenodes/valuenode_blinecalcwidth.h>
#include <synfig/valuenodes/valuenode_staticlist.h>
#include <synfig/valuenodes/valuenode_bone.h>
#include <synfig/valuenodes/valuenode_boneinfluence.h>
#include <synfig/valuenodes/valuenode_boneweightpair.h>
#include <synfig/segment.h>
#include <synfig/pair.h>

#include <synfig/curve_helper.h>

#include <synfig/context.h>
#include <synfig/layers/layer_pastecanvas.h>
#include <synfig/layers/layer_filtergroup.h>

#include "ducktransform_matrix.h"
#include "ducktransform_rotate.h"
#include "ducktransform_translate.h"
#include "ducktransform_scale.h"
#include "ducktransform_origin.h"
#include "canvasview.h"

#include "onemoment.h"

#include <gui/localization.h>

#endif

/* === U S I N G =========================================================== */

using namespace std;
using namespace etl;
using namespace synfig;
using namespace studio;

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

/* 0.33333333333333333 makes for nice short tangent handles,
   1.0 makes them draw as their real length */
#define TANGENT_HANDLE_SCALE 0.33333333333333333

/* leave this alone or the bezier won't lie on top of the bline */
#define TANGENT_BEZIER_SCALE 0.33333333333333333

/* === I N L I N E ======================================================= */
synfig::GUID calc_duck_guid(const synfigapp::ValueDesc& value_desc, const synfig::TransformStack& transform_stack);
void set_duck_value_desc(Duck& duck, const synfigapp::ValueDesc& value_desc, const synfig::TransformStack& transform_stack);
void set_duck_value_desc(Duck& duck, const synfigapp::ValueDesc& value_desc, const synfig::String& sub_name, const synfig::TransformStack& transform_stack);

/* === P R O C E D U R E S ================================================= */

/* === M E T H O D S ======================================================= */

/* === E N T R Y P O I N T ================================================= */

Duckmatic::Duckmatic(etl::loose_handle<synfigapp::CanvasInterface> canvas_interface):
	canvas_interface(canvas_interface),
	type_mask(Type(
		Duck::TYPE_ALL
	  & ~( Duck::TYPE_WIDTH
		 | Duck::TYPE_BONE_RECURSIVE
		 | Duck::TYPE_WIDTHPOINT_POSITION ))),
	type_mask_state(Duck::TYPE_NONE),
	alternative_mode_(false),
	lock_animation_mode_(false),
	grid_snap(false),
	guide_snap(false),
	grid_size(1.0/4.0,1.0/4.0),
	grid_color(synfig::Color(159.0/255.0,159.0/255.0,159.0/255.0)),
	guides_color(synfig::Color(111.0/255.0,111.0/255.0,1.0)),
	zoom(1.0),
	prev_zoom(1.0),
	show_persistent_strokes(true),
	axis_lock(false),
	drag_offset_(0, 0)
{
	clear_duck_dragger();
	clear_bezier_dragger();
}

Duckmatic::~Duckmatic()
{
	clear_ducks();

	if (getenv("SYNFIG_DEBUG_DESTRUCTORS"))
		synfig::info("Duckmatic::~Duckmatic(): Deleted");
}

void
Duckmatic::clear_ducks()
{
	for(;!duck_changed_connections.empty();duck_changed_connections.pop_back())duck_changed_connections.back().disconnect();

	duck_data_share_map.clear();
	duck_map.clear();

	//duck_list_.clear();
	bezier_list_.clear();
	stroke_list_.clear();

	if(show_persistent_strokes)
		stroke_list_=persistent_stroke_list_;
}


/*
-- ** -- D U C K  M A N I P U L A T I O N  M E T H O D S-----------------------
*/

bool
Duckmatic::duck_is_selected(const etl::handle<Duck> &duck)const
{
    return duck && selected_ducks.count(duck->get_guid());
}

void
Duckmatic::clear_selected_ducks()
{
	selected_ducks.clear();
	signal_duck_selection_changed_();
}

etl::handle<Duckmatic::Duck>
Duckmatic::get_selected_duck()const
{
	if(selected_ducks.empty() || duck_map.empty())
		return 0;
	return duck_map.find(*selected_ducks.begin())->second;
}

etl::handle<Duckmatic::Bezier>
Duckmatic::get_selected_bezier()const
{
	return selected_bezier;
}

void
Duckmatic::refresh_selected_ducks()
{
/*
	std::set<etl::handle<Duck> >::iterator iter;
	std::set<etl::handle<Duck> > new_set;
	if(duck_list().empty())
	{
		selected_duck_list.clear();
		signal_duck_selection_changed_();
		return;
	}

	for(iter=selected_duck_list.begin();iter!=selected_duck_list.end();++iter)
	{
		etl::handle<Duck> similar(find_similar_duck(*iter));
		if(similar)
		{
			new_set.insert(similar);
		}
	}
	selected_duck_list=new_set;
*/
	GUIDSet old_set(selected_ducks);
	GUIDSet::const_iterator iter;

	for(iter=old_set.begin();iter!=old_set.end();++iter)
	{
		if(duck_map.count(*iter)==0)
			selected_ducks.erase(*iter);
	}

	signal_duck_selection_changed_();
}

bool
Duckmatic::is_duck_group_selectable(const etl::handle<Duck>& x)const
{
	const Type type(get_type_mask());

	if (((x->get_type() && (!(type & x->get_type()))) ||
		 !x->get_editable()))
		return false;

	synfigapp::ValueDesc value_desc(x->get_value_desc());
	if(value_desc.parent_is_layer() && (type & Duck::TYPE_POSITION))
	{
		Layer::Handle layer(value_desc.get_layer());
		String layer_name(layer->get_name());

		if (layer_name == "outline" || layer_name == "region" || layer_name == "plant" ||
			layer_name == "polygon" || layer_name == "curve_gradient" || layer_name == "advanced_outline")
			return false;

		if(etl::handle<Layer_PasteCanvas>::cast_dynamic(layer) &&
		   !layer->get_param("children_lock").get(bool()))
			return false;
	}
	else if (value_desc.parent_is_value_node())
	{
		if (ValueNode_BLineCalcVertex::Handle::cast_dynamic(value_desc.get_value_node()))
			return false;
		if (value_desc.parent_is_linkable_value_node())
		{
			ValueNode::Handle parent_value_node(value_desc.get_parent_value_node());
			if (ValueNode_Composite::Handle composite = ValueNode_Composite::Handle::cast_dynamic(parent_value_node))
			{
				if (parent_value_node->get_type() == type_bline_point &&
					ValueNode_BLineCalcVertex::Handle::cast_dynamic(
							composite->get_link("point")))
					return false;
				// widths ducks of the widthpoints
				// Do not avoid selection of the width ducks from widthpoints
				//if (parent_value_node->get_type() == type_width_point)
				//	return false;
			}
			else if (ValueNode_BLine::Handle::cast_dynamic(parent_value_node))
			{
				ValueNode_Composite::Handle composite(ValueNode_Composite::Handle::cast_dynamic(
														  value_desc.get_value_node()));
				if (composite &&
					ValueNode_BLineCalcVertex::Handle::cast_dynamic(composite->get_link("point")))
					return false;
			}
			// position ducks of the widthpoints
			else if (ValueNode_WPList::Handle::cast_dynamic(parent_value_node))
				return false;

		}
	}
	return true;
}

void
Duckmatic::select_all_ducks()
{
	DuckMap::const_iterator iter;
	for(iter=duck_map.begin();iter!=duck_map.end();++iter)
		if(is_duck_group_selectable(iter->second))
			select_duck(iter->second);
		else
			unselect_duck(iter->second);
}

void
Duckmatic::unselect_all_ducks()
{
	DuckMap::const_iterator iter;
	for(iter=duck_map.begin();iter!=duck_map.end();++iter)
		unselect_duck(iter->second);
}

void
Duckmatic::toggle_select_ducks_in_box(const synfig::Vector& tl,const synfig::Vector& br)
{
	Vector vmin, vmax;
	vmin[0]=std::min(tl[0],br[0]);
	vmin[1]=std::min(tl[1],br[1]);
	vmax[0]=std::max(tl[0],br[0]);
	vmax[1]=std::max(tl[1],br[1]);

	{
	    DuckMap::const_iterator iter;
        for(iter=duck_map.begin();iter!=duck_map.end();++iter)
        {
            Point p(iter->second->get_trans_point());
            if(p[0]<=vmax[0] && p[0]>=vmin[0] && p[1]<=vmax[1] && p[1]>=vmin[1] &&
               is_duck_group_selectable(iter->second))
                toggle_select_duck(iter->second);
        }
	}
}

void
Duckmatic::select_ducks_in_box(const synfig::Vector& tl,const synfig::Vector& br)
{
	Vector vmin, vmax;
	vmin[0]=std::min(tl[0],br[0]);
	vmin[1]=std::min(tl[1],br[1]);
	vmax[0]=std::max(tl[0],br[0]);
	vmax[1]=std::max(tl[1],br[1]);

//	Type type(get_type_mask());

	DuckMap::const_iterator iter;
	for(iter=duck_map.begin();iter!=duck_map.end();++iter)
	{
		Point p(iter->second->get_trans_point());
		if(p[0]<=vmax[0] && p[0]>=vmin[0] && p[1]<=vmax[1] && p[1]>=vmin[1])
		{
			if(is_duck_group_selectable(iter->second))
				select_duck(iter->second);
		}
	}
}

int
Duckmatic::count_selected_ducks()const
{
	return selected_ducks.size();
}

void
Duckmatic::select_duck(const etl::handle<Duck> &duck)
{
	if(duck)
	{
		selected_ducks.insert(duck->get_guid());
		signal_duck_selection_changed_();

		if(selected_ducks.size() == 1)
		{
		    signal_duck_selection_single_(duck);
		}
	}
}

DuckList
Duckmatic::get_selected_ducks()const
{
	DuckList ret;
	GUIDSet::const_iterator iter;
	const Type type(get_type_mask());

	for(iter=selected_ducks.begin();iter!=selected_ducks.end();++iter)
	{
		const DuckMap::const_iterator d_iter(duck_map.find(*iter));

		if(d_iter==duck_map.end())
			continue;

		if(( d_iter->second->get_type() && (!(type & d_iter->second->get_type())) ) )
			continue;

		ret.push_back(d_iter->second);
	}
	return ret;
}


DuckList
Duckmatic::get_ducks_in_box(const synfig::Vector& tl,const synfig::Vector& br)const
{
    Vector vmin, vmax;
    vmin[0]=std::min(tl[0],br[0]);
    vmin[1]=std::min(tl[1],br[1]);
    vmax[0]=std::max(tl[0],br[0]);
    vmax[1]=std::max(tl[1],br[1]);

    DuckList ret;

//  Type type(get_type_mask());

    DuckMap::const_iterator iter;
    for(iter=duck_map.begin();iter!=duck_map.end();++iter)
    {
        Point p(iter->second->get_trans_point());
        if(p[0]<=vmax[0] && p[0]>=vmin[0] && p[1]<=vmax[1] && p[1]>=vmin[1])
        {
          //  if(is_duck_group_selectable(iter->second))
            ret.push_back(iter->second);
        }
    }
    return ret;
}

DuckList
Duckmatic::get_duck_list()const
{
	DuckList ret;
	DuckMap::const_iterator iter;
	for(iter=duck_map.begin();iter!=duck_map.end();++iter) if (iter->second->get_type()&Duck::TYPE_POSITION) ret.push_back(iter->second);
	for(iter=duck_map.begin();iter!=duck_map.end();++iter) if (iter->second->get_type()&Duck::TYPE_VERTEX  ) ret.push_back(iter->second);
	for(iter=duck_map.begin();iter!=duck_map.end();++iter) if (iter->second->get_type()&Duck::TYPE_TANGENT ) ret.push_back(iter->second);
	for(iter=duck_map.begin();iter!=duck_map.end();++iter)
		if (!(iter->second->get_type()&Duck::TYPE_POSITION) &&
			!(iter->second->get_type()&Duck::TYPE_VERTEX) &&
			!(iter->second->get_type()&Duck::TYPE_TANGENT))
			ret.push_back(iter->second);
	return ret;
}

void
Duckmatic::unselect_duck(const etl::handle<Duck> &duck)
{
	if(duck && selected_ducks.count(duck->get_guid()))
	{
		selected_ducks.erase(duck->get_guid());
		signal_duck_selection_changed_();
	}
}

void
Duckmatic::toggle_select_duck(const etl::handle<Duck> &duck)
{
	if(duck_is_selected(duck))
		unselect_duck(duck);
	else
		select_duck(duck);
}

void
Duckmatic::translate_selected_ducks(const synfig::Vector& vector)
{
	if(duck_dragger_)
		duck_dragger_->duck_drag(this,vector);
}

void
Duckmatic::start_duck_drag(const synfig::Vector& offset)
{
	if(duck_dragger_)
		duck_dragger_->begin_duck_drag(this,offset);

	//drag_offset_=offset;
	drag_offset_=find_duck(offset)->get_trans_point();
}

bool
Duckmatic::end_duck_drag()
{
    if(duck_dragger_)
        return duck_dragger_->end_duck_drag(this);
    return false;
}

void
Duckmatic::update_ducks()
{
	Time time(get_time());
	DuckList duck_list(get_duck_list());
	const DuckList selected_ducks(get_selected_ducks());
	DuckList::const_iterator selected_iter;
	if(get_selected_bezier())
	{
		etl::handle<Duck> c1(get_selected_bezier()->c1);
		etl::handle<Duck> c2(get_selected_bezier()->c2);
		if(c1->get_value_desc().parent_is_linkable_value_node())
		{
			ValueNode_Composite::Handle composite(ValueNode_Composite::Handle::cast_dynamic(c1->get_value_desc().get_parent_value_node()));
			LinkableValueNode::Handle duck_value_node(LinkableValueNode::Handle::cast_dynamic(c1->get_value_desc().get_value_node()));
			// it belongs to a composite and it is a BLinePoint
			if(composite && composite->get_type() == type_bline_point && duck_value_node)
			{
				int index(c1->get_value_desc().get_index());
				etl::handle<Duck> origin_duck=c1->get_origin_duck();
				// Search all the rest of ducks
				DuckList::iterator iter;
				for (iter=duck_list.begin(); iter!=duck_list.end(); iter++)
					// if the other duck has the same origin and it is tangent type
					if ( (*iter)->get_origin_duck()==origin_duck && (*iter)->get_type() == Duck::TYPE_TANGENT)
					{
						ValueNode_Composite::Handle iter_composite;
						iter_composite=ValueNode_Composite::Handle::cast_dynamic((*iter)->get_value_desc().get_parent_value_node());
						// and their parent valuenode are the same
						if(iter_composite.get() == composite.get())
						{
							BLinePoint bp=(*composite)(time).get(BLinePoint());
							int t1_index=composite->get_link_index_from_name("t1");
							int t2_index=composite->get_link_index_from_name("t2");
							if(index==t1_index && (*iter)->get_value_desc().get_index()!=t1_index)
							{
								bp.set_tangent1(c1->get_point());
								Vector t2(bp.get_tangent2());
								(*iter)->set_point(Point(t2));
							}
							else if(index==t2_index && (*iter)->get_value_desc().get_index()!=t2_index)
							{
								// Create a new BLinePoint
								BLinePoint nbp;
								// Terporary set the flags for the new BLinePoint to all split
								nbp.set_split_tangent_both(true);
								// Now we can set the tangents. Tangent2 won't be modified by tangent1
								nbp.set_tangent1(c1->get_point());
								nbp.set_tangent2(bp.get_tangent1());
								// Now update the flags
								nbp.set_split_tangent_radius(bp.get_split_tangent_radius());
								nbp.set_split_tangent_angle(bp.get_split_tangent_angle());
								// Now retrieve the updated tangent2 (which will be stored as t1, see below)
								Vector t1(nbp.get_tangent2());
								(*iter)->set_point(Point(t1));
							}
						}
					}
			}
		}
		if(c2->get_value_desc().parent_is_linkable_value_node())
		{
			ValueNode_Composite::Handle composite(ValueNode_Composite::Handle::cast_dynamic(c2->get_value_desc().get_parent_value_node()));
			LinkableValueNode::Handle duck_value_node(LinkableValueNode::Handle::cast_dynamic(c2->get_value_desc().get_value_node()));
			// it belongs to a composite and it is a BLinePoint
			if(composite && composite->get_type() == type_bline_point && duck_value_node)
			{
				int index(c2->get_value_desc().get_index());
				etl::handle<Duck> origin_duck=c2->get_origin_duck();
				// Search all the rest of ducks
				DuckList::iterator iter;
				for (iter=duck_list.begin(); iter!=duck_list.end(); iter++)
					// if the other duck has the same origin and it is tangent type
					if ( (*iter)->get_origin_duck()==origin_duck && (*iter)->get_type() == Duck::TYPE_TANGENT)
					{
						ValueNode_Composite::Handle iter_composite;
						iter_composite=ValueNode_Composite::Handle::cast_dynamic((*iter)->get_value_desc().get_parent_value_node());
						// and their parent valuenode are the same
						if(iter_composite.get() == composite.get())
						{
							BLinePoint bp=(*composite)(time).get(BLinePoint());
							int t1_index=composite->get_link_index_from_name("t1");
							int t2_index=composite->get_link_index_from_name("t2");
							if(index==t1_index && (*iter)->get_value_desc().get_index()!=t1_index)
							{
								bp.set_tangent1(c2->get_point());
								Vector t2(bp.get_tangent2());
								(*iter)->set_point(Point(t2));
							}
							else if(index==t2_index && (*iter)->get_value_desc().get_index()!=t2_index)
							{
								// Create a new BLinePoint
								BLinePoint nbp;
								// Terporary set the flags for the new BLinePoint to all split
								nbp.set_split_tangent_both(true);
								// Now we can set the tangents. Tangent2 won't be modified by tangent1
								nbp.set_tangent1(c2->get_point());
								nbp.set_tangent2(bp.get_tangent1());
								// Now update the flags
								nbp.set_split_tangent_radius(bp.get_split_tangent_radius());
								nbp.set_split_tangent_angle(bp.get_split_tangent_angle());
								// Now retrieve the updated tangent2 (which will be stored as t1, see below)
								Vector t1(nbp.get_tangent2());
								(*iter)->set_point(Point(t1));
							}
						}
					}
			}
		}
	}
	for (selected_iter=selected_ducks.begin(); selected_iter!=selected_ducks.end(); ++selected_iter)
	{
		etl::handle<Duck> duck(*selected_iter);
		if(!duck)
			return;
		if (duck->get_type() == Duck::TYPE_VERTEX || duck->get_type() == Duck::TYPE_POSITION)
		{
			ValueNode_BLineCalcVertex::Handle bline_vertex =
				ValueNode_BLineCalcVertex::Handle::cast_dynamic(duck->get_value_desc().get_value_node());
			if (!bline_vertex && duck->get_value_desc().parent_is_value_desc()) {
				ValueNode_Composite::Handle composite =
					ValueNode_Composite::Handle::cast_dynamic(duck->get_value_desc().get_value_node());
				if (composite)
					bline_vertex =
						ValueNode_BLineCalcVertex::Handle::cast_dynamic(
							composite->get_link(
								duck->get_value_desc().get_sub_name() ));
			}

			if (bline_vertex)
			{
				synfig::Real radius = 0.0;
				synfig::Point point(0.0, 0.0);
				ValueNode_BLine::Handle bline(ValueNode_BLine::Handle::cast_dynamic(bline_vertex->get_link("bline")));
				Real amount = synfig::find_closest_point((*bline)(time), duck->get_point(), radius, bline->get_loop(), &point);
				bool homogeneous((*(bline_vertex->get_link("homogeneous")))(time).get(bool()));
				if(homogeneous)
					amount=std_to_hom((*bline)(time), amount, ((*(bline_vertex->get_link("loop")))(time).get(bool())), bline->get_loop() );
				ValueNode::Handle vertex_amount_value_node(bline_vertex->get_link("amount"));
				duck->set_point(point);

				DuckList::iterator iter;
				for (iter=duck_list.begin(); iter!=duck_list.end(); iter++)
				{
					if ( (*iter)->get_origin_duck()==duck /*&& !duck_is_selected(*iter)*/ )
					{
						ValueNode::Handle duck_value_node = (*iter)->get_value_desc().get_value_node();
						if (duck_value_node)
						{
							ValueNode_Composite::Handle duck_value_node_composite = ValueNode_Composite::Handle::cast_dynamic(duck_value_node);
							ValueNode::Handle sub_duck_value_node =
									duck_value_node_composite && (*iter)->get_value_desc().parent_is_value_desc()
								  ? ValueNode::Handle(duck_value_node_composite->get_link( (*iter)->get_value_desc().get_sub_name() ))
								  : duck_value_node;
							if (sub_duck_value_node)
							{
								if ( ValueNode_BLineCalcTangent::Handle bline_tangent =
										ValueNode_BLineCalcTangent::Handle::cast_dynamic(sub_duck_value_node) )
								{
									if (bline_tangent->get_link("amount") == vertex_amount_value_node)
									{
										synfig::Type &type(bline_tangent->get_type());
										if (type == type_angle)
										{
											Angle angle((*bline_tangent)(time, amount).get(Angle()));
											(*iter)->set_point(Point(Angle::cos(angle).get(), Angle::sin(angle).get()));
											(*iter)->set_rotations(Angle::deg(0)); //hack: rotations are a relative value
										}
										else
										if (type == type_real)
											(*iter)->set_point(Point((*bline_tangent)(time, amount).get(Real()), 0));
										else
										if (type == type_vector)
											(*iter)->set_point((*bline_tangent)(time, amount).get(Vector()));
									}
								} else
								if ( ValueNode_BLineCalcWidth::Handle bline_width =
										ValueNode_BLineCalcWidth::Handle::cast_dynamic(sub_duck_value_node) )
								{
									if (bline_width->get_link("amount") == vertex_amount_value_node)
										(*iter)->set_point(Point((*bline_width)(time, amount).get(Real()), 0));
								}
							}
						}
					}
				}
			}
		}
		// We are moving a tangent handle
		else
		if(duck->get_type() == Duck::TYPE_TANGENT)
		{
			if (duck->get_value_desc().parent_is_value_desc()
			 && duck->get_value_desc().is_value_node() )
			{
				ValueNode_Composite::Handle composite(ValueNode_Composite::Handle::cast_dynamic(duck->get_value_desc().get_value_node()));
				if (composite && composite->get_type() == type_bline_point)
				{
					ValueNode::Handle duck_value_node(composite->get_link(duck->get_value_desc().get_sub_name()));
					// it belongs to a composite and it is a BLinePoint
					if (duck_value_node)
					{
						int index(duck->get_value_desc().get_index());
						etl::handle<Duck> origin_duck=duck->get_origin_duck();
						// Search all the rest of ducks
						DuckList::iterator iter;
						for (iter=duck_list.begin(); iter!=duck_list.end(); iter++)
						{
							// if the other duck has the same origin and it is tangent type
							if ( (*iter)->get_origin_duck()==origin_duck && (*iter)->get_type() == Duck::TYPE_TANGENT)
							{
								ValueNode_Composite::Handle iter_composite;
								iter_composite=ValueNode_Composite::Handle::cast_dynamic((*iter)->get_value_desc().get_parent_value_node());
								// and their parent valuenode are the same
								if(iter_composite.get() == composite.get())
								{
									// Check if the other tangent is also selected, in that case
									// it is going to be moved itself so don't update it.
									bool selected=false;
									DuckList::const_iterator iter2;
									for(iter2=selected_ducks.begin(); iter2!=selected_ducks.end(); ++iter2)
										if(*iter == *iter2)
											selected=true;
									if(!selected)
									{
										BLinePoint bp=(*composite)(time).get(BLinePoint());
										int t1_index=composite->get_link_index_from_name("t1");
										int t2_index=composite->get_link_index_from_name("t2");
										if(index==t1_index && (*iter)->get_value_desc().get_index()!=t1_index)
										{
											bp.set_tangent1(duck->get_point());
											Vector t2(bp.get_tangent2());
											(*iter)->set_point(Point(t2));
										}
										else if(index==t2_index && (*iter)->get_value_desc().get_index()!=t2_index)
										{
											// Create a new BLinePoint
											BLinePoint nbp;
											// Terporary set the flags for the new BLinePoint to all split
											nbp.set_split_tangent_both(true);
											// Now we can set the tangents. Tangent2 won't be modified by tangent1
											nbp.set_tangent1(duck->get_point());
											nbp.set_tangent2(bp.get_tangent1());
											// Now update the flags
											nbp.set_split_tangent_radius(bp.get_split_tangent_radius());
											nbp.set_split_tangent_angle(bp.get_split_tangent_angle());
											// Now retrieve the updated tangent2 (which will be stored as t1, see below)
											Vector t1(nbp.get_tangent2());
											(*iter)->set_point(Point(t1));
										}
									}
								}
							}
						}
					}
				}
			}
		}
	}
}


void
Duckmatic::start_bezier_drag(const synfig::Vector& offset, float bezier_click_pos)
{
	if(bezier_dragger_)
		bezier_dragger_->begin_bezier_drag(this,offset,bezier_click_pos);
}

void
Duckmatic::translate_selected_bezier(const synfig::Vector& vector)
{
	if(bezier_dragger_)
		bezier_dragger_->bezier_drag(this,vector);
}

bool
Duckmatic::end_bezier_drag()
{
	if(bezier_dragger_)
		return bezier_dragger_->end_bezier_drag(this);
	return false;
}

/*
-- ** -- grid and guide M E T H O D S----------------------------
*/

void
Duckmatic::set_grid_size(const synfig::Vector &s)
{
    if(grid_size!=s)
    {
        grid_size=s;
        signal_grid_changed();
    }
}

void
Duckmatic::set_grid_color(const synfig::Color &c)
{
    if(grid_color!=c)
    {
        grid_color=c;
        signal_grid_changed();
    }
}

void
Duckmatic::set_grid_snap(bool x)
{
    if(grid_snap!=x)
    {
        grid_snap=x;
        signal_grid_changed();
    }
}

void
Duckmatic::set_guide_snap(bool x)
{
    if(guide_snap!=x)
    {
        guide_snap=x;
        signal_grid_changed();
    }
}

void
Duckmatic::set_guides_color(const synfig::Color &c)
{
    if(guides_color!=c)
    {
        guides_color=c;
        signal_grid_changed();
    }
}

Duckmatic::GuideList::iterator
Duckmatic::find_guide_x(synfig::Point pos, float radius)
{
    GuideList::iterator iter,best(guide_list_x_.end());
    float dist(radius);
    for(iter=guide_list_x_.begin();iter!=guide_list_x_.end();++iter)
    {
        float amount(abs(*iter-pos[0]));
        if(amount<dist)
        {
            dist=amount;
            best=iter;
        }
    }
    return best;
}

Duckmatic::GuideList::iterator
Duckmatic::find_guide_y(synfig::Point pos, float radius)
{
    GuideList::iterator iter,best(guide_list_y_.end());
    float dist(radius);
    for(iter=guide_list_y_.begin();iter!=guide_list_y_.end();++iter)
    {
        float amount(abs(*iter-pos[1]));
        if(amount<=dist)
        {
            dist=amount;
            best=iter;
        }
    }
    return best;
}

Point
Duckmatic::snap_point_to_grid(const synfig::Point& x)const
{
	Point ret(x);
	float radius(0.1/zoom);

	GuideList::const_iterator guide_x,guide_y;
	bool has_guide_x(false), has_guide_y(false);

	guide_x=find_guide_x(ret,radius);
	if(guide_x!=guide_list_x_.end())
		has_guide_x=true;

	guide_y=find_guide_y(ret,radius);
	if(guide_y!=guide_list_y_.end())
		has_guide_y=true;

	if(get_grid_snap())
	{
		Point snap(
			floor(ret[0]/get_grid_size()[0]+0.5)*get_grid_size()[0],
			floor(ret[1]/get_grid_size()[1]+0.5)*get_grid_size()[1]);

		if(abs(snap[0]-ret[0])<=radius && (!has_guide_x || abs(snap[0]-ret[0])<=abs(*guide_x-ret[0])))
			ret[0]=snap[0],has_guide_x=false;
		if(abs(snap[1]-ret[1])<=radius && (!has_guide_y || abs(snap[1]-ret[1])<=abs(*guide_y-ret[1])))
			ret[1]=snap[1],has_guide_y=false;
	}

	if(guide_snap)
	{
		if(has_guide_x)
			ret[0]=*guide_x;
		if(has_guide_y)
			ret[1]=*guide_y;
	}

	if(axis_lock)
	{
		ret-=drag_offset_;
		if(abs(ret[0])<abs(ret[1]))
			ret[0]=0;
		else
			ret[1]=0;
		ret+=drag_offset_;
	}

	return ret;
}

/*
-- ** -- S I G N A L S  M E T H O D S----------------------------
*/
void
Duckmatic::signal_user_click_selected_ducks(int button)
{
    const DuckList ducks(get_selected_ducks());
    DuckList::const_iterator iter;

    for(iter=ducks.begin();iter!=ducks.end();++iter)
    {
        (*iter)->signal_user_click(button)();
    }
}

void
Duckmatic::signal_edited_duck(const etl::handle<Duck> &duck, bool moving)
{
    if (moving && !duck->get_edit_immediatelly()) return;

    if (duck->get_type() == Duck::TYPE_ANGLE)
    {
        if(!duck->signal_edited()(*duck))
        {
            throw String("Bad edit");
        }
    }
    else if (App::restrict_radius_ducks &&
             duck->is_radius())
    {
        Point point(duck->get_point());
        bool changed = false;

        if (point[0] < 0)
        {
            point[0] = 0;
            changed = true;
        }
        if (point[1] < 0)
        {
            point[1] = 0;
            changed = true;
        }

        if (changed) duck->set_point(point);

        if(!duck->signal_edited()(*duck))
        {
            throw String("Bad edit");
        }
    }
    else
    {
        if(!duck->signal_edited()(*duck))
        {
            throw String("Bad edit");
        }
    }
}


void
Duckmatic::signal_edited_selected_ducks(bool moving)
{
    const DuckList ducks(get_selected_ducks());
    DuckList::const_iterator iter;

    synfig::GUIDSet old_set(selected_ducks);

    // If we have more than 20 things to move, then display
    // something to explain that it may take a moment
    //smart_ptr<OneMoment> wait; if(ducks.size()>20)wait.spawn();
    for(iter=ducks.begin();iter!=ducks.end();++iter)
    {
        try
        {
            if (!moving || (*iter)->get_edit_immediatelly())
                signal_edited_duck(*iter);
        }
        catch (const String&)
        {
            selected_ducks=old_set;
            synfig::warning("signals must not throw exceptions");
            // signals must not throw exceptions!!!
            //throw;
        }
    }
    selected_ducks=old_set;
}

bool
Duckmatic::on_duck_changed(const studio::Duck &duck,const synfigapp::ValueDesc& value_desc)
{
    bool lock_animation = get_lock_animation_mode();
    synfig::Point value=duck.get_point();
    synfig::Type &type(value_desc.get_value_type());
    if (type == type_real)
    {
        if (value_desc.parent_is_value_node())
        {
            etl::handle<ValueNode_Bone> bone_node =
                etl::handle<ValueNode_Bone>::cast_dynamic(
                    value_desc.get_parent_value_node());
            if (bone_node)
            {
                int index1 = bone_node->get_link_index_from_name("scalex");
                int index2 = bone_node->get_link_index_from_name("scalelx");
                int angleIndex = bone_node->get_link_index_from_name("angle");
                if (value_desc.get_index() == index1
                 || value_desc.get_index() == index2)
                {
                    //Bone bone((*bone_node)(get_time()).get(Bone()));
                    //Real prev_duck_length = bone.get_length() * bone.get_scalex() * bone.get_scalex();
                    //Real duck_length = duck.get_point().mag();
                    //Real prev_length = value_desc.get_value(get_time()).get(Real());
                    //Real new_length = prev_length == 0.f || prev_duck_length == 0.f
                    //                ? duck_length
                    //                : prev_length * duck_length / prev_duck_length;
                    Real new_length = duck.get_point().mag();
                    Angle angle = (*bone_node->get_link(angleIndex))(get_time()).get(Angle());
                    angle += duck.get_rotations();
                    return canvas_interface->change_value(synfigapp::ValueDesc(bone_node, angleIndex, value_desc.get_parent_desc()), angle, lock_animation)
                        && canvas_interface->change_value(value_desc, new_length, lock_animation);
                }
            }
        }

        // Zoom duck value (PasteCanvas and Zoom layers) should be
        // converted back from exponent to normal
        if( duck.get_exponential() ) {
            return canvas_interface->change_value(value_desc,log(value.mag()),lock_animation);
        } else {
            return canvas_interface->change_value(value_desc,value.mag(),lock_animation);
        }
    }
    else
    if (type == type_angle)
        //return canvas_interface->change_value(value_desc,Angle::tan(value[1],value[0]),lock_animation);
        return canvas_interface->change_value(value_desc, value_desc.get_value(get_time()).get(Angle()) + duck.get_rotations(),lock_animation);
    else
    if (type == type_transformation)
    {
        if ( duck.get_move_origin()
		  && duck.get_origin_duck()
		  && duck.get_value_desc().is_valid()
		  && duck.get_value_desc().parent_is_layer()
		  && etl::handle<Layer_PasteCanvas>::cast_dynamic(duck.get_value_desc().get_layer())
		  && duck.get_value_desc().get_param_name() == "origin" )
        {
            Point origin = duck.get_value_desc().get_value(get_time()).get(Point());
            Transformation transformation = duck.get_origin_duck()->get_value_desc().get_value(get_time()).get(Transformation());
            Point delta_offset = duck.get_origin_duck()->get_point() - transformation.offset;
            Point delta_origin = transformation.back_transform(delta_offset, false);
            transformation.offset += delta_offset;
            origin += delta_origin;
            return canvas_interface->change_value(duck.get_value_desc(), origin, lock_animation)
                && canvas_interface->change_value(duck.get_origin_duck()->get_value_desc(), transformation, lock_animation);
        }
        else
        {
            Transformation transformation = value_desc.get_value(get_time()).get(Transformation());
            Point axis_x_one(1, transformation.angle);
            Point axis_y_one(1, transformation.angle + Angle::deg(90.f) + transformation.skew_angle);

            switch(duck.get_type()) {
            case Duck::TYPE_POSITION:
                transformation.offset = value;
                break;
            case Duck::TYPE_ANGLE:
                transformation.angle += duck.get_rotations();
                break;
            case Duck::TYPE_SKEW:
                transformation.skew_angle += duck.get_rotations();
                break;
            case Duck::TYPE_SCALE:
                transformation.scale = transformation.scale.multiply_coords(duck.get_point());
                break;
            case Duck::TYPE_SCALE_X:
                transformation.scale[0] *= duck.get_point()[0];
                break;
            case Duck::TYPE_SCALE_Y:
                transformation.scale[1] *= duck.get_point()[0];
                break;
            default:
                break;
            }

            return canvas_interface->change_value(value_desc, transformation, lock_animation);
        }
        return false;
    }
    else
    if (type == type_bline_point)
    {
        BLinePoint point = value_desc.get_value(get_time()).get(BLinePoint());
        switch(duck.get_type()) {
        case Duck::TYPE_VERTEX:
            point.set_vertex(duck.get_point());
            break;
        case Duck::TYPE_WIDTH:
            point.set_width(duck.get_point().mag());
            break;
        case Duck::TYPE_TANGENT:
            if (duck.get_scalar() < 0.f)
                point.set_tangent1(duck.get_point());
            else
            if (point.get_merge_tangent_both())
                point.set_tangent1(duck.get_point());
            else
            if (point.get_split_tangent_both())
                point.set_tangent2(duck.get_point());
            else
            if (point.get_split_tangent_angle())
            {
                point.set_tangent1( Point(duck.get_point().mag(), point.get_tangent1().angle()) );
                point.set_tangent2(duck.get_point());
            }
            else
            {
                point.set_tangent1( Point(point.get_tangent1().mag(), duck.get_point().angle()) );
                point.set_tangent2(duck.get_point());
            }
            break;
        default:
            break;
        }

        return canvas_interface->change_value(value_desc, point, lock_animation);
    }
    
    return canvas_interface->change_value(value_desc,value,lock_animation);
}

void
Duckmatic::connect_signals(const Duck::Handle &duck, const synfigapp::ValueDesc& value_desc, CanvasView &canvas_view)
{
    duck->signal_edited().connect(
        sigc::bind(
            sigc::mem_fun(
                *this,
                &studio::Duckmatic::on_duck_changed),
            value_desc));
    duck->signal_user_click(2).connect(
        sigc::bind(
            sigc::bind(
                sigc::bind(
                    sigc::mem_fun(
                        canvas_view,
                        &studio::CanvasView::popup_param_menu),
                    false),
                1.0f),
            value_desc));
}

/*
-- ** -- DUCK BEZIER STOKE ADD/ERASE/FIND...  M E T H O D S----------------------------
*/
void
Duckmatic::add_duck(const etl::handle<Duck> &duck)
{
    //if(!duck_map.count(duck->get_guid()))
    {
        if(duck_data_share_map.count(duck->get_data_guid()))
        {
            duck->set_shared_point(duck_data_share_map[duck->get_data_guid()]);
        }
        else
        {
            etl::smart_ptr<synfig::Point> point(new Point(duck->get_point()));
            duck->set_shared_point(point);
            duck_data_share_map[duck->get_data_guid()]=point;
        }

        duck_map.insert(duck);
    }

    last_duck_guid=duck->get_guid();
}

void
Duckmatic::add_bezier(const etl::handle<Bezier> &bezier)
{
    bezier_list_.push_back(bezier);
}

void
Duckmatic::add_stroke(etl::smart_ptr<std::list<synfig::Point> > stroke_point_list, const synfig::Color& color)
{
    assert(stroke_point_list);

    std::list<etl::handle<Stroke> >::iterator iter;

    for(iter=stroke_list_.begin();iter!=stroke_list_.end();++iter)
    {
        if((*iter)->stroke_data==stroke_point_list)
            return;
    }

    etl::handle<Stroke> stroke(new Stroke());

    stroke->stroke_data=stroke_point_list;
    stroke->color=color;

    stroke_list_.push_back(stroke);
}

void
Duckmatic::add_persistent_stroke(etl::smart_ptr<std::list<synfig::Point> > stroke_point_list, const synfig::Color& color)
{
    add_stroke(stroke_point_list,color);
    persistent_stroke_list_.push_back(stroke_list_.back());
}

void
Duckmatic::clear_persistent_strokes()
{
    persistent_stroke_list_.clear();
}

void
Duckmatic::set_show_persistent_strokes(bool x)
{
    if(x!=show_persistent_strokes)
    {
        show_persistent_strokes=x;
        if(x)
            stroke_list_=persistent_stroke_list_;
        else
            stroke_list_.clear();
    }
}

void
Duckmatic::erase_duck(const etl::handle<Duck> &duck)
{
    duck_map.erase(duck->get_guid());
}

etl::handle<Duckmatic::Duck>
Duckmatic::find_similar_duck(etl::handle<Duck> duck)
{
    DuckMap::const_iterator iter(duck_map.find(duck->get_guid()));
    if(iter!=duck_map.end())
        return iter->second;
    return 0;

/*  std::list<handle<Duck> >::reverse_iterator iter;

    for(iter=duck_list_.rbegin();iter!=duck_list_.rend();++iter)
    {
        if(*iter!=duck && **iter==*duck)
        {
            //synfig::info("Found similar duck! (iter:%08x vs. duck:%08x)",iter->get(), duck.get());
            return *iter;
        }
    }
    return 0;
*/
}

etl::handle<Duckmatic::Duck>
Duckmatic::add_similar_duck(etl::handle<Duck> duck)
{
    etl::handle<Duck> similar(find_similar_duck(duck));
    if(!similar)
    {
        add_duck(duck);
        return duck;
    }
    return similar;
}

void
Duckmatic::erase_bezier(const etl::handle<Bezier> &bezier)
{
    std::list<handle<Bezier> >::iterator iter;

    for(iter=bezier_list_.begin();iter!=bezier_list_.end();++iter)
    {
        if(*iter==bezier)
        {
            bezier_list_.erase(iter);
            return;
        }
    }
    synfig::warning("Unable to find bezier to erase!");
}

etl::handle<Duckmatic::Duck>
Duckmatic::last_duck()const
{
    DuckMap::const_iterator iter(duck_map.find(last_duck_guid));
    if(iter!=duck_map.end())
        return iter->second;
    return 0;
}

etl::handle<Duckmatic::Bezier>
Duckmatic::last_bezier()const
{
    return bezier_list_.back();
}

etl::handle<Duckmatic::Duck>
Duckmatic::find_duck(synfig::Point point, synfig::Real radius, Duck::Type type)
{
    if(radius==0)radius=10000000;

    if(type==Duck::TYPE_DEFAULT)
        type=get_type_mask();

    Real closest(10000000);
    etl::handle<Duck> ret;
    std::vector< etl::handle<Duck> > ret_vector;

    DuckMap::const_iterator iter;

    for(iter=duck_map.begin();iter!=duck_map.end();++iter)
    {
        const Duck::Handle& duck(iter->second);

        if(duck->get_ignore() ||
           (duck->get_type() && !(type & duck->get_type())))
            continue;

        Real dist((duck->get_trans_point()-point).mag_squared());

        bool equal;
        equal=fabs(dist-closest)<0.0000001?true:false;
        if(dist<closest || equal)
        {
            // if there are two ducks at the "same" position, keep track of them
            if(equal)
            {
                // if we haven't any duck stored keep track of last found
                if(!ret_vector.size())
                    ret_vector.push_back(ret);
                // and also keep track of the one on the same place
                ret_vector.push_back(duck);
            }
            // we have another closer duck then discard the stored
            else if (ret_vector.size())
                ret_vector.clear();
            closest=dist;
            ret=duck;
        }
    }

    // Priorization of duck selection when are in the same place.
    bool found(false);
    if(ret_vector.size())
    {
        unsigned int i;
        for(i=0; i<ret_vector.size();i++)
            if(ret_vector[i]->get_type() & Duck::TYPE_WIDTHPOINT_POSITION)
            {
                ret=ret_vector[i];
                found=true;
                break;
            }
        if(!found)
            for(i=0; i<ret_vector.size();i++)
                if(ret_vector[i]->get_type() & Duck::TYPE_WIDTH)
                {
                    ret=ret_vector[i];
                    found=true;
                    break;
                }
        if(!found)
            for(i=0; i<ret_vector.size();i++)
                if(ret_vector[i]->get_type() & Duck::TYPE_RADIUS)
                {
                    ret=ret_vector[i];
                    found=true;
                    break;
                }
        if(!found)
            for(i=0; i<ret_vector.size();i++)
                if(ret_vector[i]->get_type() & Duck::TYPE_VERTEX)
                {
                    ret=ret_vector[i];
                    found=true;
                    break;
                }
        if(!found)
            for(i=0; i<ret_vector.size();i++)
                if(ret_vector[i]->get_type() & Duck::TYPE_TANGENT)
                {
                    ret=ret_vector[i];
                    found=true;
                    break;
                }
        if(!found)
            for(i=0; i<ret_vector.size();i++)
                if(ret_vector[i]->get_type() & Duck::TYPE_POSITION)
                {
                    ret=ret_vector[i];
                    found=true;
                    break;
                }
    }
    if(radius==0 || closest<radius*radius)
        return ret;

    return 0;
}

etl::handle<Duckmatic::Bezier>
Duckmatic::find_bezier(synfig::Point point, synfig::Real radius,float* location)
{
    return find_bezier(point,radius,radius,location);
}

etl::handle<Duckmatic::Bezier>
Duckmatic::find_bezier(synfig::Point pos, synfig::Real scale, synfig::Real radius, float* location)
{
    if(radius==0)radius=10000000;
    Real closest(10000000);
    etl::handle<Bezier> ret;

    bezier<Point>   curve;

    Real    d,step;
    float   time = 0;
    float   best_time = 0;

    for(std::list<handle<Bezier> >::const_iterator iter=bezier_list().begin();iter!=bezier_list().end();++iter)
    {
        curve[0] = (*iter)->p1->get_trans_point();
        curve[1] = (*iter)->c1->get_trans_point();
        curve[2] = (*iter)->c2->get_trans_point();
        curve[3] = (*iter)->p2->get_trans_point();
        curve.sync();

#if 0
        // I don't know why this doesn't work
        time=curve.find_closest(pos,6);
        d=((curve(time)-pos).mag_squared());

#else
        //set the step size based on the size of the picture
        d = (curve[1] - curve[0]).mag() + (curve[2]-curve[1]).mag() + (curve[3]-curve[2]).mag();

        step = d/(2*scale); //want to make the distance between lines happy

        step = max(step,0.01); //100 samples should be plenty
        step = min(step,0.1); //10 is minimum

        d = find_closest(curve,pos,step,&closest,&time);
#endif

        if(d < closest)
        {
            closest = d;
            ret = *iter;
            best_time=time;
        }
    }

    if(closest < radius*radius)
    {
        if(location)
            *location = best_time;  // We need to square-root this because we were dealing with squared distances

        return ret;
    }

    return 0;
}


/*
-- ** -- Duckmatic sketch M E T H O D S----------------------------
*/
bool
Duckmatic::save_sketch(const synfig::String& filename)const
{
    ChangeLocale change_locale(LC_NUMERIC, "C");
    std::ofstream file(filename.c_str());

    if(!file)return false;

    file<<"SKETCH"<<endl;

    std::list<etl::handle<Stroke> >::const_iterator iter;

    for(iter=persistent_stroke_list_.begin();iter!=persistent_stroke_list_.end();++iter)
    {
        file<<"C "
            <<(*iter)->color.get_r()<<' '
            <<(*iter)->color.get_g()<<' '
            <<(*iter)->color.get_b()
        <<endl;
        std::list<synfig::Point>::const_iterator viter;
        for(viter=(*iter)->stroke_data->begin();viter!=(*iter)->stroke_data->end();++viter)
        {
            file<<"V "
                <<(*viter)[0]<<' '
                <<(*viter)[1]
            <<endl;
        }
    }
    if(!file)return false;
    sketch_filename_=filename;
    signal_sketch_saved_();
    return true;
}

bool
Duckmatic::load_sketch(const synfig::String& filename)
{
    ChangeLocale change_locale(LC_NUMERIC, "C");
    std::ifstream file(filename.c_str());

    if(!file)
        return false;

    std::string line;
    getline(file,line);

    if(line!="SKETCH")
    {
        synfig::error("Not a sketch");
        return false;
    }

    etl::smart_ptr<std::list<synfig::Point> > stroke_data;

    while(file)
    {
        getline(file,line);

        if(line.empty())
            continue;

        switch(line[0])
        {
        case 'C':
        case 'c':
            {
                stroke_data.spawn();
                float r,g,b;
                if(!strscanf(line,"C %f %f %f",&r, &g, &b))
                {
                    synfig::warning("Bad color line \"%s\"",line.c_str());
                    r=0;g=0;b=0;
                }
                add_persistent_stroke(stroke_data, synfig::Color(r,g,b));
            }
            break;
        case 'V':
        case 'v':
            if(!stroke_data)
            {
                stroke_data.spawn();
                add_persistent_stroke(stroke_data, synfig::Color(0,0,0));
            }
            float x,y;
            if(!strscanf(line,"V %f %f",&x, &y))
                synfig::warning("Bad vertex \"%s\"",line.c_str());
            else
                stroke_data->push_back(synfig::Vector(x,y));
            break;
        default:
            synfig::warning("Unexpected sketch token '%c'",line[0]);
            break;
        }
    }

    sketch_filename_=filename;
    return true;
}


void
Duckmatic::add_ducks_layers(synfig::Canvas::Handle canvas, std::set<synfig::Layer::Handle>& selected_layer_set, etl::handle<CanvasView> canvas_view, synfig::TransformStack& transform_stack, int *out_transform_count)
{
    int transforms(0);
    String layer_name;

#define QUEUE_REBUILD_DUCKS     sigc::mem_fun(*canvas_view,&CanvasView::queue_rebuild_ducks)

    if(!canvas)
    {
        synfig::warning("Duckmatic::add_ducks_layers(): Layer doesn't have canvas set");
        return;
    }
    for(Canvas::iterator iter(canvas->begin());iter!=canvas->end();++iter)
    {
        Layer::Handle layer(*iter);

        if(selected_layer_set.count(layer))
        {
            if(!curr_transform_stack_set)
            {
                curr_transform_stack_set=true;
                curr_transform_stack=transform_stack;
            }

            // This layer is currently selected.
            duck_changed_connections.push_back(layer->signal_changed().connect(QUEUE_REBUILD_DUCKS));

            // do the bounding box thing
            synfig::Rect& bbox = canvas_view->get_bbox();

            // special calculations for Layer_PasteCanvas
            etl::handle<Layer_PasteCanvas> layer_pastecanvas( etl::handle<Layer_PasteCanvas>::cast_dynamic(layer) );
            synfig::Rect layer_bounds = layer_pastecanvas
                                      ? layer_pastecanvas->get_bounding_rect_context_dependent(canvas_view->get_context_params())
                                      : layer->get_bounding_rect();

            bbox|=transform_stack.perform(layer_bounds);

            // Grab the layer's list of parameters
            Layer::ParamList paramlist(layer->get_param_list());

            // Grab the layer vocabulary
            Layer::Vocab vocab=layer->get_param_vocab();
            Layer::Vocab::iterator iter;

            for(iter=vocab.begin();iter!=vocab.end();iter++)
            {
                if(!iter->get_hidden() && !iter->get_invisible_duck())
                {
                    synfigapp::ValueDesc value_desc(layer,iter->get_name());
                    add_to_ducks(value_desc,canvas_view,transform_stack,&*iter);
                    if(value_desc.is_value_node())
                        duck_changed_connections.push_back(value_desc.get_value_node()->signal_changed().connect(QUEUE_REBUILD_DUCKS));
                }
            }
        }

        layer_name=layer->get_name();

        if(layer->active())
        {
            Transform::Handle trans(layer->get_transform());
            if(trans)
            {
                transform_stack.push(trans);
                transforms++;
            }
        }

        // If this is a paste canvas layer, then we need to
        // descend into it
        if(etl::handle<Layer_PasteCanvas> layer_pastecanvas = etl::handle<Layer_PasteCanvas>::cast_dynamic(layer))
        {
            transform_stack.push_back(
                new Transform_Matrix(
                    layer->get_guid(),
                    layer_pastecanvas->get_summary_transformation().get_matrix()
                )
            );

            Canvas::Handle child_canvas(layer->get_param("canvas").get(Canvas::Handle()));

            // keep stack
            if ( etl::handle<Layer_FilterGroup>::cast_dynamic(layer_pastecanvas)
              && layer_pastecanvas->get_amount() > 0.5 )
            {
            	transforms++;
                add_ducks_layers(child_canvas,selected_layer_set,canvas_view,transform_stack, &transforms);
            }
            else
            {
                add_ducks_layers(child_canvas,selected_layer_set,canvas_view,transform_stack);
            	transform_stack.pop();
            }
        }
    }

    if (out_transform_count)
    {
    	// keep stack and return count transforms ...
    	*out_transform_count += transforms;
    }
    else
    {
        // ... or remove all of the transforms we have added
    	while(transforms--) { transform_stack.pop(); }
    }

#undef QUEUE_REBUILD_DUCKS
}

/*
-- ** -- add_to_ducks GIANT  M E T H O D S-------------------------------------
-- ** -- -----------------------------------------------------------------------
-- ** -- S H O U L D  B E  S I M P L I F  I E D---------------------------------
-- ** -- -----------------------------------------------------------------------
---**-----------------------TODO-Must be simplified!(1500 lines length)-------
-- ** -- -----------------------------------------------------------------------
*/
bool
Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<CanvasView> canvas_view, const synfig::TransformStack& transform_stack, synfig::ParamDesc *param_desc)
{
    synfig::Type &type=value_desc.get_value_type();
#define REAL_COOKIE     reinterpret_cast<synfig::ParamDesc*>(28)

    if (type == type_real)
    {
        if(!param_desc || param_desc==REAL_COOKIE || !param_desc->get_origin().empty())
        {
            etl::handle<Duck> duck=new Duck();
            set_duck_value_desc(*duck, value_desc, transform_stack);
            duck->set_radius(true);
            duck->set_type(Duck::TYPE_RADIUS);

            // put the duck on the right hand side of the center
            // Zoom parameter value (PasteCanvas and Zoom layers)
            // should be represented as exponent
            if ( param_desc && param_desc!=REAL_COOKIE && param_desc->get_exponential() )
            {
                duck->set_point(Point(exp(value_desc.get_value(get_time()).get(Real())), 0));
                duck->set_exponential(param_desc->get_exponential());
            } else {
                duck->set_point(Point(value_desc.get_value(get_time()).get(Real()), 0));
                duck->set_exponential(false);
            }

            if(value_desc.is_value_node())
            {
                // If the ValueNode can be directly manipulated,
                // then set it as so.
                duck->set_editable(synfigapp::is_editable(value_desc.get_value_node()));
            }
            else
            {
                duck->set_editable(true);
            }

            if(param_desc && param_desc!=REAL_COOKIE)
            {
                if(!param_desc->get_origin().empty())
                {
                    synfigapp::ValueDesc value_desc_origin(value_desc.get_layer(),param_desc->get_origin());
                    /*
                    duck->set_origin(value_desc_origin.get_value(get_time()).get(synfig::Point()));
                    */
                    add_to_ducks(value_desc_origin,canvas_view, transform_stack);

                    Layer::Handle layer=value_desc.get_layer();
                    if(etl::handle<Layer_PasteCanvas>::cast_dynamic(layer))
                    {
                        Vector focus(layer->get_param("focus").get(Vector()));
                        duck->set_origin(last_duck()->get_point() + focus);
                    }
                    else
                        duck->set_origin(last_duck());
                }
                duck->set_scalar(param_desc->get_scalar());
            }

            duck->signal_edited().clear(); // value_desc.get_value_type() == type_real:
            duck->signal_edited().connect(
                sigc::bind(
                    sigc::mem_fun(
                        *this,
                        &studio::Duckmatic::on_duck_changed),
                    value_desc));

            duck->signal_user_click(2).connect(
                sigc::bind(
                    sigc::bind(
                        sigc::bind(
                            sigc::mem_fun(
                                *canvas_view,
                                &studio::CanvasView::popup_param_menu),
                            false),
                        0.0f),
                    value_desc));

            add_duck(duck);

            return true;
        }
    }
    else
    if (type == type_angle)
    {
        if(!param_desc || param_desc==REAL_COOKIE || !param_desc->get_origin().empty())
        {
            etl::handle<Duck> duck=new Duck();
            duck->set_type(Duck::TYPE_ANGLE);
            set_duck_value_desc(*duck, value_desc, transform_stack);
            synfig::Angle angle;

            angle=value_desc.get_value(get_time()).get(Angle());
            duck->set_point(Point(Angle::cos(angle).get(),Angle::sin(angle).get()));
            if(value_desc.is_value_node())
            {
                ValueNode::Handle value_node=value_desc.get_value_node();
                //duck->set_name(strprintf("%x",value_node.get()));

                // If the ValueNode can be directly manipulated,
                // then set it as so.
                duck->set_editable(synfigapp::is_editable(value_desc.get_value_node()));
            }
            else
            {
                //angle=(value_desc.get_value().get(Angle()));
                //duck->set_point(Point(Angle::cos(angle).get(),Angle::sin(angle).get()));
                //duck->set_name(strprintf("%x",value_desc.get_layer().get())+value_desc.get_param_name());
                duck->set_editable(true);
            }

            if(param_desc && param_desc!=REAL_COOKIE)
            {
                if(!param_desc->get_origin().empty())
                {
                    synfigapp::ValueDesc value_desc_origin(value_desc.get_layer(),param_desc->get_origin());
                    /*
                    duck->set_origin(value_desc_origin.get_value(get_time()).get(synfig::Point()));
                    */
                    add_to_ducks(value_desc_origin,canvas_view, transform_stack);
                    duck->set_origin(last_duck());
                }
                duck->set_scalar(param_desc->get_scalar());
            }

            duck->signal_edited().clear(); // value_desc.get_value_type() == type_angle:
            duck->signal_edited().connect(
                sigc::bind(
                    sigc::mem_fun(
                        *this,
                        &studio::Duckmatic::on_duck_changed),
                    value_desc));

            duck->signal_user_click(2).connect(
                sigc::bind(
                    sigc::bind(
                        sigc::bind(
                            sigc::mem_fun(
                                *canvas_view,
                                &studio::CanvasView::popup_param_menu),
                            false),
                        0.0f),
                    value_desc));

            add_duck(duck);

            return true;
        }
    }
    else
    if (type == type_vector)
    {
        etl::handle<Layer_PasteCanvas> layer;
        if (value_desc.parent_is_layer())
            layer = etl::handle<Layer_PasteCanvas>::cast_dynamic(value_desc.get_layer());
        if (!layer) {
            etl::handle<Duck> duck=new Duck();
            set_duck_value_desc(*duck, value_desc, transform_stack);
            ValueNode_Composite::Handle blinepoint_value_node;
            int index;
            bool done(false);
            if(value_desc.parent_is_linkable_value_node()
               &&
               value_desc.get_parent_value_node()->get_type() == type_bline_point)
            {
                blinepoint_value_node=ValueNode_Composite::Handle::cast_dynamic(value_desc.get_parent_value_node());
                if(blinepoint_value_node)
                {
                    index=blinepoint_value_node->get_link_index_from_name("t2");
                    if(index==value_desc.get_index())
                    {
                        BLinePoint bp=(*blinepoint_value_node)(get_time()).get(BLinePoint());
                        Vector t2=bp.get_tangent2();
                        duck->set_point(t2);
                        done=true;
                    }
                }
            }
            if(!done)
                duck->set_point(value_desc.get_value(get_time()).get(Point()));

            if(value_desc.is_value_node())
            {
                // if the vertex is converted to 'bone influence', add the bones' ducks
                if (ValueNode_BoneInfluence::Handle bone_influence_vertex_value_node =
                    ValueNode_BoneInfluence::Handle::cast_dynamic(value_desc.get_value_node()))
                    add_to_ducks(synfigapp::ValueDesc(bone_influence_vertex_value_node,
                                                      bone_influence_vertex_value_node->get_link_index_from_name("bone_weight_list")),
                                 canvas_view, transform_stack);

                // If the ValueNode can be directly manipulated,
                // then set it as so.
                duck->set_editable(synfigapp::is_editable(value_desc.get_value_node()));
            }
            else
            {
                //duck->set_point(value_desc.get_value().get(Point()));
                //duck->set_name(strprintf("%x",value_desc.get_layer().get())+value_desc.get_param_name());
                duck->set_editable(true);
            }

            // If we were passed a parameter description
            if(param_desc)
            {
                if(!param_desc->get_connect().empty())
                {
                    synfigapp::ValueDesc value_desc_origin(value_desc.get_layer(),param_desc->get_connect());
                    Duck::Handle connect_duck;
                    if(duck_map.find(calc_duck_guid(value_desc_origin, transform_stack))!=duck_map.end())
                    {
                        connect_duck=duck_map[calc_duck_guid(value_desc_origin, transform_stack)];
                    }
                    else
                    {
                        add_to_ducks(value_desc_origin,canvas_view, transform_stack);
                        connect_duck=last_duck();
                    }
                    duck->set_connect_duck(connect_duck);
                }
                if(!param_desc->get_box().empty())
                {
                    synfigapp::ValueDesc value_desc_origin(value_desc.get_layer(),param_desc->get_box());
                    add_to_ducks(value_desc_origin,canvas_view, transform_stack);
                    duck->set_box_duck(last_duck());
                }

                // If we have an origin
                if(!param_desc->get_origin().empty())
                {
                    synfigapp::ValueDesc value_desc_origin(value_desc.get_layer(),param_desc->get_origin());
                    /*
                    duck->set_origin(value_desc_origin.get_value(get_time()).get(synfig::Point()));
                    */
                    add_to_ducks(value_desc_origin,canvas_view, transform_stack);
                    duck->set_origin(last_duck());
                    duck->set_type(Duck::TYPE_VERTEX);
                }
                else
                    duck->set_type(Duck::TYPE_POSITION);

                duck->set_scalar(param_desc->get_scalar());
            }
            else
                duck->set_type(Duck::TYPE_POSITION);

            duck->signal_edited().clear(); // value_desc.get_value_type() == type_vector:
            duck->signal_edited().connect(
                sigc::bind(
                    sigc::mem_fun(
                        *this,
                        &studio::Duckmatic::on_duck_changed),
                    value_desc));

            duck->signal_user_click(2).connect(
                sigc::bind(
                    sigc::bind(
                        sigc::bind(
                            sigc::mem_fun(
                                *canvas_view,
                                &studio::CanvasView::popup_param_menu),
                            false),
                        1.0f),
                    value_desc));

            add_duck(duck);

            return true;
        }
    }
    else
    if (type == type_transformation)
    {
        if (value_desc.parent_is_layer() && param_desc != NULL)
        {
            etl::handle<Layer_PasteCanvas> layer = etl::handle<Layer_PasteCanvas>::cast_dynamic(value_desc.get_layer());
            if (layer)
            {
                synfigapp::ValueDesc origin_value_desc(value_desc.get_layer(), "origin");
                Transformation transformation = value_desc.get_value(get_time()).get(Transformation());

                bool editable = !value_desc.is_value_node()
                    || synfigapp::is_editable(value_desc.get_value_node());
                bool origin_editable = !origin_value_desc.is_value_node()
                    || synfigapp::is_editable(origin_value_desc.get_value_node());
                origin_editable = origin_editable && editable;
                Point axis_x(1, transformation.angle);
                Point axis_y(1, transformation.angle + Angle::deg(90.f) + transformation.skew_angle);

                Point screen_offset = transform_stack.perform(transformation.offset);
                Point screen_axis_x = transform_stack.perform(transformation.offset + axis_x) - screen_offset;
                Point screen_axis_y = transform_stack.perform(transformation.offset + axis_y) - screen_offset;
                Real scalar_x = screen_axis_x.mag();
                if (scalar_x > 0.0) scalar_x = 1.0/scalar_x;
                Real scalar_y = screen_axis_y.mag();
                if (scalar_y > 0.0) scalar_y = 1.0/scalar_y;
                scalar_x /= zoom;
                scalar_y /= zoom;
                Real pw = canvas_interface->get_canvas()->rend_desc().get_pw();
                Real ph = canvas_interface->get_canvas()->rend_desc().get_ph();
                scalar_x *= 75.0 * fabs(pw);
                scalar_y *= 75.0 * fabs(ph);

                Duck::Handle duck;

                // add offset duck
                duck=new Duck();
                set_duck_value_desc(*duck, value_desc, "offset", transform_stack);
                duck->set_point(transformation.offset);
                duck->set_editable(editable);
                duck->set_type(Duck::TYPE_POSITION);
                connect_signals(duck, duck->get_value_desc(), *canvas_view);
                add_duck(duck);

                etl::handle<Duck> origin_duck = duck;

                // add angle duck
                duck=new Duck();
                duck->set_type(Duck::TYPE_ANGLE);
                set_duck_value_desc(*duck, value_desc, "angle", transform_stack);
                duck->set_point(Point(0.8,transformation.angle));
                duck->set_scalar(scalar_x);
                duck->set_editable(editable);
                duck->set_origin(origin_duck);
                connect_signals(duck, duck->get_value_desc(), *canvas_view);
                add_duck(duck);

                etl::handle<Duck> angle_duck = duck;

                // add skew duck
                duck=new Duck();
                duck->set_type(Duck::TYPE_SKEW);
                set_duck_value_desc(*duck, value_desc, "skew_angle", transform_stack);
                duck->set_point(Point(0.8,transformation.skew_angle));
                duck->set_scalar(scalar_y);
                duck->set_editable(editable);
                duck->set_origin(origin_duck);
                duck->set_axis_x_angle(angle_duck, Angle::deg(90));
                duck->set_axis_y_angle(angle_duck, Angle::deg(180));
                connect_signals(duck, duck->get_value_desc(), *canvas_view);
                add_duck(duck);

                etl::handle<Duck> skew_duck = duck;

                // add scale-x duck
                duck=new Duck();
                duck->set_type(Duck::TYPE_SCALE_X);
                set_duck_value_desc(*duck, value_desc.get_sub_value("scale").get_sub_value("x"), transform_stack);
                duck->set_point(Point(1,0));
                duck->set_scalar(scalar_x);
                duck->set_editable(editable);
                duck->set_origin(origin_duck);
                duck->set_linear(true, angle_duck);
                connect_signals(duck, duck->get_value_desc(), *canvas_view);
                add_duck(duck);

                etl::handle<Duck> scale_x_duck = duck;

                // add scale-y duck
                duck=new Duck();
                duck->set_type(Duck::TYPE_SCALE_Y);
                set_duck_value_desc(*duck, value_desc.get_sub_value("scale").get_sub_value("y"), transform_stack);
                duck->set_point(Point(1,0));
                duck->set_scalar(scalar_y);
                duck->set_editable(editable);
                duck->set_origin(origin_duck);
                duck->set_linear(true, skew_duck);
                connect_signals(duck, duck->get_value_desc(), *canvas_view);
                add_duck(duck);

                etl::handle<Duck> scale_y_duck = duck;

                // add scale duck
                duck=new Duck();
                duck->set_type(Duck::TYPE_SCALE);
                set_duck_value_desc(*duck, value_desc, "scale", transform_stack);
                duck->set_point(Point(1,1));
                duck->set_lock_aspect(true);
                duck->set_editable(editable);
                duck->set_origin(origin_duck);
                duck->set_axis_x_angle(scale_x_duck);
                duck->set_axis_x_mag(scale_x_duck);
                duck->set_axis_y_angle(scale_y_duck);
                duck->set_axis_y_mag(scale_y_duck);
                duck->set_track_axes(true);
                connect_signals(duck, duck->get_value_desc(), *canvas_view);
                add_duck(duck);

                // add move-origin duck
				if (origin_editable) {
					duck=new Duck();
					set_duck_value_desc(*duck, origin_value_desc, transform_stack);
					duck->set_point(Point(0, -0.2));
					duck->set_editable(origin_editable);
					duck->set_type(Duck::TYPE_POSITION);
					duck->set_origin(origin_duck);
					duck->set_move_origin(true);
					duck->set_scalar(scalar_y);
					duck->set_axis_y_angle(scale_y_duck);
					duck->set_track_axes(true);
					connect_signals(duck, duck->get_origin_duck()->get_value_desc(), *canvas_view);
					add_duck(duck);
				}

                return true;
            }
        }
    }
    else
    if (type == type_segment)
    {
        int index;
        etl::handle<Bezier> bezier(new Bezier());
        ValueNode_Composite::Handle value_node;

        if(value_desc.is_value_node() &&
            (value_node=ValueNode_Composite::Handle::cast_dynamic(value_desc.get_value_node())))
        {
            index=value_node->get_link_index_from_name("p1");
            if(!add_to_ducks(synfigapp::ValueDesc(value_node,index),canvas_view,transform_stack))
                return false;
            bezier->p1=last_duck();
            bezier->p1->set_type(Duck::TYPE_VERTEX);

            index=value_node->get_link_index_from_name("t1");
            if(!add_to_ducks(synfigapp::ValueDesc(value_node,index),canvas_view,transform_stack))
                return false;
            bezier->c1=last_duck();
            bezier->c1->set_type(Duck::TYPE_TANGENT);
            bezier->c1->set_origin(bezier->p1);
            bezier->c1->set_scalar(TANGENT_BEZIER_SCALE);
            bezier->c1->set_tangent(true);

            index=value_node->get_link_index_from_name("p2");
            if(!add_to_ducks(synfigapp::ValueDesc(value_node,index),canvas_view,transform_stack))
                return false;
            bezier->p2=last_duck();
            bezier->p2->set_type(Duck::TYPE_VERTEX);

            index=value_node->get_link_index_from_name("t2");
            if(!add_to_ducks(synfigapp::ValueDesc(value_node,index),canvas_view,transform_stack))
                return false;
            bezier->c2=last_duck();
            bezier->c2->set_type(Duck::TYPE_TANGENT);
            bezier->c2->set_origin(bezier->p2);
            bezier->c2->set_scalar(-TANGENT_BEZIER_SCALE);
            bezier->c2->set_tangent(true);

            bezier->signal_user_click(2).connect(
                sigc::bind(
                    sigc::mem_fun(
                        *canvas_view,
                        &studio::CanvasView::popup_param_menu_bezier),
                    value_desc));

            add_bezier(bezier);
        }
        else if(value_desc.get_value().is_valid())
        {
            Segment segment=value_desc.get_value().get(Segment());
            etl::handle<Duck> duck_p,duck_c;
            synfig::String name;
            if(param_desc)
                name=param_desc->get_local_name();
            else
                name=value_desc.get_guid_string();

            duck_p=new Duck(segment.p1);
            duck_p->set_name(name+".P1");
            duck_p->set_type(Duck::TYPE_VERTEX);
            add_duck(duck_p);

            duck_c=new Duck(segment.t1);
            duck_c->set_name(name+".T1");
            duck_c->set_type(Duck::TYPE_TANGENT);
            add_duck(duck_c);
            duck_c->set_origin(duck_p);
            duck_c->set_scalar(TANGENT_HANDLE_SCALE);
            duck_c->set_tangent(true);

            bezier->p1=duck_p;
            bezier->c1=duck_c;

            duck_p=new Duck(segment.p2);
            duck_p->set_name(name+".P2");
            duck_p->set_type(Duck::TYPE_VERTEX);
            add_duck(duck_p);

            duck_c=new Duck(segment.t2);
            duck_c->set_type(Duck::TYPE_TANGENT);
            duck_c->set_name(name+".T2");
            add_duck(duck_c);
            duck_c->set_origin(duck_p);
            duck_c->set_scalar(-TANGENT_HANDLE_SCALE);
            duck_c->set_tangent(true);

            bezier->p2=duck_p;
            bezier->c2=duck_c;
            add_bezier(bezier);
        }

        return true;
    }
    else
    if (type == type_bline_point)
    {
        bool editable = !value_desc.is_value_node() || synfigapp::is_editable(value_desc.get_value_node());
        BLinePoint point = value_desc.get_value(get_time()).get(BLinePoint());

        Duck::Handle duck;

        // add vertex duck
        duck=new Duck();
        set_duck_value_desc(*duck, value_desc, "point", transform_stack);
        duck->set_point(point.get_vertex());
        duck->set_editable(editable);
        duck->set_type(Duck::TYPE_VERTEX);
        connect_signals(duck, duck->get_value_desc(), *canvas_view);
        add_duck(duck);

        etl::handle<Duck> vertex_duck = duck;

        // add tangent1 duck
        duck=new Duck();
        duck->set_type(Duck::TYPE_TANGENT);
        set_duck_value_desc(*duck, value_desc, "t1", transform_stack);
        duck->set_point(point.get_tangent1());
        duck->set_editable(editable);
        duck->set_origin(vertex_duck);
        connect_signals(duck, duck->get_value_desc(), *canvas_view);
        add_duck(duck);

        // add tangent2 duck
        duck=new Duck();
        duck->set_type(Duck::TYPE_TANGENT);
        set_duck_value_desc(*duck, value_desc, "t2", transform_stack);
        duck->set_point(point.get_tangent2());
        duck->set_editable(editable);
        duck->set_origin(vertex_duck);
        duck->set_scalar(-1);
        connect_signals(duck, duck->get_value_desc(), *canvas_view);
        add_duck(duck);

        return true;
    }
    else
    if (type == type_list)
    {
        // Check for BLine
        if (value_desc.is_value_node() &&
            ValueNode_BLine::Handle::cast_dynamic(value_desc.get_value_node()))
        {
            ValueNode_BLine::Handle value_node;
            value_node=ValueNode_BLine::Handle::cast_dynamic(value_desc.get_value_node());

            int i,first=-1;

            etl::handle<Bezier> bezier;
            etl::handle<Duck> first_duck, first_tangent2_duck;

            for (i = 0; i < value_node->link_count(); i++)
            {
                float amount(value_node->list[i].amount_at_time(get_time()));

                // skip vertices that aren't fully on
                if (amount < 0.9999f)
                    continue;

                // remember the index of the first vertex we didn't skip
                if (first == -1)
                    first = i;

                ValueNode::Handle sub_node = value_node->get_link(i);
                bool editable = synfigapp::is_editable(sub_node);
                BLinePoint bline_point((*value_node->get_link(i))(get_time()).get(BLinePoint()));
                synfigapp::ValueDesc sub_value_desc(value_node, i, value_desc);

                // Now add the ducks:

                Duck::Handle duck;

                // ----Vertex Duck

                duck=new Duck(bline_point.get_vertex());
                set_duck_value_desc(*duck, sub_value_desc, "point", transform_stack);
                duck->set_editable(editable);
                duck->set_type(Duck::TYPE_VERTEX);
                if(param_desc)
                {
                    if(!param_desc->get_origin().empty())
                    {
                        synfigapp::ValueDesc value_desc_origin(value_desc.get_layer(),param_desc->get_origin());
                        add_to_ducks(value_desc_origin,canvas_view, transform_stack);
                        duck->set_origin(last_duck());
                    }
                }
                duck=add_similar_duck(duck);
                if(i==first) first_duck=duck;
                connect_signals(duck, duck->get_value_desc(), *canvas_view);

                Duck::Handle vertex_duck = duck;

                // ----Width duck

                Duck::Handle width;

                // Add the width duck if it is a parameter with a hint (ie. "width") or if it isn't a parameter
                //if (!   ((param_desc && !param_desc->get_hint().empty()) || !param_desc)   )
                if (param_desc && param_desc->get_hint().empty())
                {
                    // if it's a parameter without a hint, then don't add the width duck
                    // (This prevents width ducks from being added to region layers, and possibly other cases)
                }
                else
                {
                    // add width duck

                    duck=new Duck();
                    set_duck_value_desc(*duck, sub_value_desc, "width", transform_stack);
                    duck->set_radius(true);
                    duck->set_point(Point(bline_point.get_width(), 0));
                    duck->set_editable(editable);
                    duck->set_type(Duck::TYPE_WIDTH);
                    duck->set_origin(vertex_duck);
                    connect_signals(duck, duck->get_value_desc(), *canvas_view);

                    // if the bline is a layer's parameter, scale the width duck by the layer's "width" parameter
                    if (param_desc)
                    {
                        ValueBase value(synfigapp::ValueDesc(value_desc.get_layer(),param_desc->get_hint()).get_value(get_time()));
                        Real gv(value_desc.get_layer()->get_outline_grow_mark());
                        if(value.same_type_as(synfig::Real()))
                            duck->set_scalar(exp(gv)*value.get(synfig::Real())*0.5f);
                        // if it doesn't have a "width" parameter, scale by 0.5f instead
                        else
                            duck->set_scalar(0.5f);
                    }
                    // otherwise just present the raw unscaled width
                    else
                        duck->set_scalar(0.5f);

                    add_duck(duck);
                    width = duck;
                }

                // each bezier uses t2 of one point and t1 of the next
                // the first time through this loop we won't have the t2 duck from the previous vertex
                // and so we don't make a bezier.  instead we skip on to t2 for this point
                Duck::Handle tangent1_duck;
                if(bezier)
                {
                    // Add the tangent1 duck
                    duck=new Duck(bline_point.get_tangent1());
                    set_duck_value_desc(*duck, sub_value_desc, "t1", transform_stack);
                    duck->set_editable(editable);
                    duck=add_similar_duck(duck);

                    duck->set_origin(vertex_duck);
                    duck->set_scalar(-TANGENT_BEZIER_SCALE);
                    duck->set_tangent(true);
                    duck->set_shared_point(etl::smart_ptr<Point>());
                    duck->set_shared_angle(etl::smart_ptr<Angle>());
                    duck->set_shared_mag(etl::smart_ptr<Real>());
                    connect_signals(duck, duck->get_value_desc(), *canvas_view);

                    // each bezier uses t2 of one point and t1 of the next
                    // we should already have a bezier, so add the t1 of this point to it

                    bezier->p2=vertex_duck;
                    bezier->c2=duck;

                    bezier->signal_user_click(2).connect(
                        sigc::bind(
                            sigc::mem_fun(
                                *canvas_view,
                                &studio::CanvasView::popup_param_menu_bezier),
                            synfigapp::ValueDesc(value_node,i)));

                    add_bezier(bezier);
                    bezier=0;
                    tangent1_duck = duck;
                }

                // don't start a new bezier for the last point in the line if we're not looped
                if ((i+1>=value_node->link_count() && !value_node->get_loop()))
                    continue;

                bezier=new Bezier();

                // Add the tangent2 duck
                Duck::Handle tangent2_duck;
                duck=new Duck(bline_point.get_tangent2());
                set_duck_value_desc(*duck, sub_value_desc, "t2", transform_stack);
                duck->set_editable(editable);

                duck=add_similar_duck(duck);
                duck->set_origin(vertex_duck);
                duck->set_scalar(TANGENT_BEZIER_SCALE);
                duck->set_tangent(true);
                duck->set_shared_point(etl::smart_ptr<Point>());
                duck->set_shared_angle(etl::smart_ptr<Angle>());
                duck->set_shared_mag(etl::smart_ptr<Real>());
                connect_signals(duck, duck->get_value_desc(), *canvas_view);

                bezier->p1=vertex_duck;
                bezier->c1=duck;
                tangent2_duck = duck;
                if (i == first) first_tangent2_duck = tangent2_duck;

                // link tangents
                if (tangent1_duck && tangent2_duck && !bline_point.get_split_tangent_both()) {
                    if (bline_point.get_merge_tangent_both())
                    {
                        etl::smart_ptr<synfig::Point> point(new Point(tangent1_duck->get_point()));
                        tangent1_duck->set_shared_point(point);
                        tangent2_duck->set_shared_point(point);
                    }
                    else
                    if (!bline_point.get_split_tangent_angle())
                    {
                        etl::smart_ptr<synfig::Angle> angle(new Angle(
                            approximate_zero( tangent1_duck->get_point().mag() )
                          ? tangent2_duck->get_point().angle()
                          : tangent1_duck->get_point().angle() ));
                        tangent1_duck->set_shared_angle(angle);
                        tangent2_duck->set_shared_angle(angle);
                    }
                    else
                    if (!bline_point.get_split_tangent_radius())
                    {
                        etl::smart_ptr<synfig::Real> mag(new Real(tangent1_duck->get_point().mag()));
                        tangent1_duck->set_shared_mag(mag);
                        tangent2_duck->set_shared_mag(mag);
                    }
                }
            }

            // Loop if necessary
            if(bezier && value_node->get_loop())
            {
                ValueNode::Handle sub_node = value_node->get_link(first);
                bool editable = synfigapp::is_editable(sub_node);
                bool is_bline_point = sub_node->get_type() == type_bline_point;
                BLinePoint bline_point;
                if (is_bline_point) bline_point = (*sub_node)(get_time()).get(BLinePoint());

                ValueNode_BoneInfluence::Handle bone_influence_vertex_value_node(
                    ValueNode_BoneInfluence::Handle::cast_dynamic(value_node->get_link(first)));
                ValueNode_Composite::Handle composite_bone_link_value_node;
                synfig::TransformStack bone_transform_stack(transform_stack);
                if (bone_influence_vertex_value_node)
                {
                    // apply bones transformation to the ducks
                    composite_bone_link_value_node = ValueNode_Composite::Handle::cast_dynamic(
                        bone_influence_vertex_value_node->get_link("link") );

                    if(param_desc)
                    {
                        if(!param_desc->get_origin().empty())
                        {
                            synfigapp::ValueDesc value_desc_origin(value_desc.get_layer(),param_desc->get_origin());
                            add_to_ducks(value_desc_origin, canvas_view, transform_stack);
                            synfig::GUID guid(calc_duck_guid(value_desc_origin, transform_stack));
                            bone_transform_stack.push(new Transform_Origin(guid^synfig::GUID::hasher("origin"), last_duck()));
                        }
                    }

                    Matrix transform(bone_influence_vertex_value_node->calculate_transform(get_time()));
                    synfig::GUID guid(bone_influence_vertex_value_node->get_link("bone_weight_list")->get_guid());

                    bone_transform_stack.push(new Transform_Matrix(guid, transform));
                }

                // Add the vertex duck
                Duck::Handle duck;
                Duck::Handle vertex_duck(first_duck);
                Duck::Handle tangent2_duck(first_tangent2_duck);
                synfigapp::ValueDesc sub_value_desc(value_node,first,value_desc);

                // Add the tangent1 duck
                duck=new Duck(bline_point.get_tangent1());
                set_duck_value_desc(*duck, sub_value_desc, "t1", transform_stack);
                duck->set_editable(editable);

                duck=add_similar_duck(duck);
                duck->set_origin(vertex_duck);
                duck->set_scalar(-TANGENT_BEZIER_SCALE);
                duck->set_tangent(true);
                duck->set_shared_point(etl::smart_ptr<Point>());
                duck->set_shared_angle(etl::smart_ptr<Angle>());
                duck->set_shared_mag(etl::smart_ptr<Real>());
                connect_signals(duck, duck->get_value_desc(), *canvas_view);

                bezier->p2=vertex_duck;
                bezier->c2=duck;

                bezier->signal_user_click(2).connect(
                    sigc::bind(
                        sigc::mem_fun(
                            *canvas_view,
                            &studio::CanvasView::popup_param_menu_bezier),
                        synfigapp::ValueDesc(value_node,first)));

                add_bezier(bezier);
                bezier=0;
                Duck::Handle tangent1_duck = duck;

                // link tangents
                if (tangent1_duck && tangent2_duck && !bline_point.get_split_tangent_both()) {
                    if (bline_point.get_merge_tangent_both())
                    {
                        etl::smart_ptr<synfig::Point> point(new Point(tangent1_duck->get_point()));
                        tangent1_duck->set_shared_point(point);
                        tangent2_duck->set_shared_point(point);
                    }
                    else
                    if (!bline_point.get_split_tangent_angle())
                    {
                        etl::smart_ptr<synfig::Angle> angle(new Angle(
                            approximate_zero( tangent1_duck->get_point().mag() )
                          ? tangent2_duck->get_point().angle()
                          : tangent1_duck->get_point().angle() ));
                        tangent1_duck->set_shared_angle(angle);
                        tangent2_duck->set_shared_angle(angle);
                    }
                    else
                    if (!bline_point.get_split_tangent_radius())
                    {
                        etl::smart_ptr<synfig::Real> mag(new Real(tangent1_duck->get_point().mag()));
                        tangent1_duck->set_shared_mag(mag);
                        tangent2_duck->set_shared_mag(mag);
                    }
                }
            }
            return true;
        }

        else // Check for StaticList
        if(value_desc.is_value_node() &&
            ValueNode_StaticList::Handle::cast_dynamic(value_desc.get_value_node()))
        {
            ValueNode_StaticList::Handle value_node;
            value_node=ValueNode_StaticList::Handle::cast_dynamic(value_desc.get_value_node());
            int i;

            synfig::Type &contained_type(value_node->get_contained_type());
            if (contained_type == type_vector)
            {
                Bezier bezier;
                etl::handle<Duck> first_duck, duck;
                int first = -1;
                for(i=0;i<value_node->link_count();i++)
                {
                    if(!add_to_ducks(synfigapp::ValueDesc(value_node,i),canvas_view,transform_stack))
                        return false;
                    duck = last_duck();

                    // remember the index of the first vertex we didn't skip
                    if (first == -1)
                    {
                        first = i;
                        first_duck = duck;
                    }

                    if(param_desc && !param_desc->get_origin().empty())
                    {
                        synfigapp::ValueDesc value_desc_origin(value_desc.get_layer(),param_desc->get_origin());
                        add_to_ducks(value_desc_origin,canvas_view, transform_stack);
                        duck->set_origin(last_duck());
/*
                        ValueBase value(synfigapp::ValueDesc(value_desc.get_layer(),param_desc->get_origin()).get_value(get_time()));
                        if(value.same_type_as(synfig::Point()))
                            duck->set_origin(value.get(synfig::Point()));
*/
//                      if(!param_desc->get_origin().empty())
//                          last_duck()->set_origin(synfigapp::ValueDesc(value_desc.get_layer(),param_desc->get_origin()).get_value(get_time()).get(synfig::Point()));
                    }
                    duck->set_type(Duck::TYPE_VERTEX);
                    bezier.p1=bezier.p2;bezier.c1=bezier.c2;
                    bezier.p2=bezier.c2=duck;

                    if (first != i)
                    {
                        handle<Bezier> bezier_(new Bezier());
                        bezier_->p1=bezier.p1;
                        bezier_->c1=bezier.c1;
                        bezier_->p2=bezier.p2;
                        bezier_->c2=bezier.c2;
                        add_bezier(bezier_);
                        last_bezier()->signal_user_click(2).connect(
                            sigc::bind(
                                sigc::mem_fun(
                                    *canvas_view,
                                    &studio::CanvasView::popup_param_menu_bezier),
                                synfigapp::ValueDesc(value_node,i)));
                    }
                }

                if (value_node->get_loop() && first != -1 && first_duck != duck)
                {
                    duck = first_duck;

                    bezier.p1=bezier.p2;bezier.c1=bezier.c2;
                    bezier.p2=bezier.c2=duck;

                    handle<Bezier> bezier_(new Bezier());
                    bezier_->p1=bezier.p1;
                    bezier_->c1=bezier.c1;
                    bezier_->p2=bezier.p2;
                    bezier_->c2=bezier.c2;
                    add_bezier(bezier_);
                    last_bezier()->signal_user_click(2).connect(
                        sigc::bind(
                            sigc::mem_fun(
                                *canvas_view,
                                &studio::CanvasView::popup_param_menu_bezier),
                            synfigapp::ValueDesc(value_node,first)));
                }
            }
            else
            if (contained_type == type_segment)
            {
                for(i=0;i<value_node->link_count();i++)
                {
                    if(!add_to_ducks(synfigapp::ValueDesc(value_node,i),canvas_view,transform_stack))
                        return false;
                }
            }
            else
            if (contained_type == type_bone_object)
            {
                for(i=0;i<value_node->link_count();i++)
                    if(!add_to_ducks(synfigapp::ValueDesc(value_node,i,value_desc),canvas_view,transform_stack))
                        return false;
            }
            else
            if (contained_type == type_bone_weight_pair)
            {
                for(i=0;i<value_node->link_count();i++)
                    if(!add_to_ducks(synfigapp::ValueDesc(value_node,i),canvas_view,transform_stack))
                        return false;
            }
            else
            if (value_node->get_contained_type() == types_namespace::TypePair<Bone, Bone>::instance)
            {
                bool edit_second = value_desc.parent_is_layer() && value_desc.get_layer()->active();
                for(i=0;i<value_node->link_count();i++)
                {
                    ValueNode_Composite::Handle value_node_composite =
                        ValueNode_Composite::Handle::cast_dynamic(
                            value_node->get_link(i) );
                    if (value_node_composite)
                    {
                        if (!add_to_ducks(
                            synfigapp::ValueDesc(
                                value_node_composite,
                                value_node_composite->get_link_index_from_name(edit_second ? "second" : "first"),
                                synfigapp::ValueDesc(value_node,i,value_desc) ),
                            canvas_view,
                            transform_stack ))
                                    return false;
                    }
                }
            }
            else
                return false;
        }

        else // Check for WPList
        if(value_desc.is_value_node() &&
            ValueNode_WPList::Handle::cast_dynamic(value_desc.get_value_node()))
        {
            ValueNode_WPList::Handle value_node;
            bool homogeneous=true; // if we have an exported WPList without a layer consider it homogeneous
            value_node=ValueNode_WPList::Handle::cast_dynamic(value_desc.get_value_node());
            if(!value_node)
            {
                error("expected a ValueNode_WPList");
                assert(0);
            }
            ValueNode::Handle bline(value_node->get_bline());
            // it is not possible to place any widthpoint's duck if there is
            // not associated bline.
            if(!bline)
                return false;
            // Retrieve the homogeneous layer parameter
            Layer::Handle layer_parent;
            if(value_desc.parent_is_layer())
                layer_parent=value_desc.get_layer();
            if(layer_parent)
                {
                    String layer_name(layer_parent->get_name());
                    if(layer_name=="advanced_outline")
                        homogeneous=layer_parent->get_param("homogeneous").get(bool());
                }
            int i;
            for (i = 0; i < value_node->link_count(); i++)
            {
                float amount(value_node->list[i].amount_at_time(get_time()));
                // skip width points that aren't fully on
                if (amount < 0.9999f)
                    continue;
                WidthPoint width_point((*value_node->get_link(i))(get_time()).get(WidthPoint()));
                // try casting the width point to Composite - this tells us whether it is composite or not
                ValueNode_Composite::Handle composite_width_point_value_node(
                    ValueNode_Composite::Handle::cast_dynamic(value_node->get_link(i)));
                if(composite_width_point_value_node) // Add the position
                {
                    etl::handle<Duck> pduck=new Duck();
                    synfigapp::ValueDesc wpoint_value_desc(value_node, i); // The i-widthpoint on WPList
                    pduck->set_type(Duck::TYPE_WIDTHPOINT_POSITION);
                    set_duck_value_desc(*pduck, wpoint_value_desc, transform_stack);
                    // This is a quick hack to obtain the ducks position.
                    // The position by amount and the amount by position
                    // has to be written considering the bline length too
                    // optionally
                    ValueNode_BLineCalcVertex::Handle bline_calc_vertex(ValueNode_BLineCalcVertex::create(Vector(0,0)));
                    bline_calc_vertex->set_link("bline", bline);
                    bline_calc_vertex->set_link("loop", ValueNode_Const::create(false));
                    bline_calc_vertex->set_link("amount", ValueNode_Const::create(width_point.get_norm_position(value_node->get_loop())));
                    bline_calc_vertex->set_link("homogeneous", ValueNode_Const::create(homogeneous));
                    pduck->set_point((*bline_calc_vertex)(get_time()).get(Vector()));
                    // hack end
                    pduck->set_editable(synfigapp::is_editable(wpoint_value_desc.get_value_node()));
                    pduck->signal_edited().clear();
                    pduck->signal_edited().connect(sigc::bind(sigc::mem_fun(*this, &studio::Duckmatic::on_duck_changed), wpoint_value_desc));
                    pduck->signal_user_click(2).clear();
                    pduck->signal_user_click(2).connect(
                        sigc::bind(
                            sigc::bind(
                                sigc::bind(
                                    sigc::mem_fun(
                                        *canvas_view,
                                        &studio::CanvasView::popup_param_menu),
                                    false),
                                1.0f),
                            wpoint_value_desc));
                    add_duck(pduck);
                    if(param_desc)
                    {
                        if(!param_desc->get_origin().empty())
                        {
                            synfigapp::ValueDesc value_desc_origin(value_desc.get_layer(),param_desc->get_origin());
                            add_to_ducks(value_desc_origin,canvas_view, transform_stack);
                            pduck->set_origin(last_duck());
                        }
                    }
                    // add the width duck
                    int index=composite_width_point_value_node->get_link_index_from_name("width");
                    if (add_to_ducks(synfigapp::ValueDesc(composite_width_point_value_node,index),canvas_view,transform_stack))
                    {
                        etl::handle<Duck> wduck;
                        wduck=last_duck();
                        wduck->set_origin(pduck);
                        wduck->set_type(Duck::TYPE_WIDTH);
                        // if the composite comes from a layer get the layer's "width" parameter and scale the
                        // duck by that value.
                        if (param_desc)
                        {
                            ValueBase value(synfigapp::ValueDesc(value_desc.get_layer(),"width").get_value(get_time()));
                            Real gv(value_desc.get_layer()->get_outline_grow_mark());
                            if(value.same_type_as(synfig::Real()))
                                wduck->set_scalar(exp(gv)*(value.get(synfig::Real())*0.5f));
                            // if it doesn't have a "width" parameter, scale by 0.5f instead
                            else
                                wduck->set_scalar(0.5f);
                        }
                        // otherwise just present the raw unscaled width
                        else
                            wduck->set_scalar(0.5f);
                    }
                    else
                        return false;
                }
            }
            return true;
        }
        else // Check for DynamicList
        if(value_desc.is_value_node() &&
            ValueNode_DynamicList::Handle::cast_dynamic(value_desc.get_value_node()))
        {
            ValueNode_DynamicList::Handle value_node;
            value_node=ValueNode_DynamicList::Handle::cast_dynamic(value_desc.get_value_node());
            int i;

            if(value_node->get_contained_type()==type_vector)
            {
                Bezier bezier;
                etl::handle<Duck> first_duck, duck;
                int first = -1;
                for(i=0;i<value_node->link_count();i++)
                {
                    if(!value_node->list[i].status_at_time(get_time()))
                        continue;
                    if(!add_to_ducks(synfigapp::ValueDesc(value_node,i),canvas_view,transform_stack))
                        return false;
                    duck = last_duck();

                    // remember the index of the first vertex we didn't skip
                    if (first == -1)
                    {
                        first = i;
                        first_duck = duck;
                    }

                    if(param_desc && !param_desc->get_origin().empty())
                    {
                        synfigapp::ValueDesc value_desc_origin(value_desc.get_layer(),param_desc->get_origin());
                        add_to_ducks(value_desc_origin,canvas_view, transform_stack);
                        duck->set_origin(last_duck());
/*
                        ValueBase value(synfigapp::ValueDesc(value_desc.get_layer(),param_desc->get_origin()).get_value(get_time()));
                        if(value.same_type_as(synfig::Point()))
                            duck->set_origin(value.get(synfig::Point()));
*/
//                      if(!param_desc->get_origin().empty())
//                          last_duck()->set_origin(synfigapp::ValueDesc(value_desc.get_layer(),param_desc->get_origin()).get_value(get_time()).get(synfig::Point()));
                    }
                    duck->set_type(Duck::TYPE_VERTEX);
                    bezier.p1 = bezier.p2;
                    bezier.c1 = bezier.c2;
                    bezier.p2 = duck;
                    bezier.c2 = duck;

                    if (first != i)
                    {
                        handle<Bezier> bezier_(new Bezier());
                        bezier_->p1=bezier.p1;
                        bezier_->c1=bezier.c1;
                        bezier_->p2=bezier.p2;
                        bezier_->c2=bezier.c2;
                        add_bezier(bezier_);
                        last_bezier()->signal_user_click(2).connect(
                            sigc::bind(
                                sigc::mem_fun(
                                    *canvas_view,
                                    &studio::CanvasView::popup_param_menu_bezier),
                                synfigapp::ValueDesc(value_node,i)));
                    }
                }

                if (value_node->get_loop() && first != -1 && first_duck != duck)
                {
                    duck = first_duck;

                    bezier.p1 = bezier.p2;
                    bezier.c1 = bezier.c2;
                    bezier.p2 = duck;
                    bezier.c2 = duck;

                    handle<Bezier> bezier_(new Bezier());
                    bezier_->p1 = bezier.p1;
                    bezier_->c1 = bezier.c1;
                    bezier_->p2 = bezier.p2;
                    bezier_->c2 = bezier.c2;
                    add_bezier(bezier_);
                    last_bezier()->signal_user_click(2).connect(
                        sigc::bind(
                            sigc::mem_fun(
                                *canvas_view,
                                &studio::CanvasView::popup_param_menu_bezier),
                            synfigapp::ValueDesc(value_node,first)));
                }
            }
            else if(value_node->get_contained_type()==type_segment)
            {
                for(i=0;i<value_node->link_count();i++)
                {
                    if(!value_node->list[i].status_at_time(get_time()))
                        continue;
                    if(!add_to_ducks(synfigapp::ValueDesc(value_node,i),canvas_view,transform_stack))
                        return false;
                }
            }
            else
                return false;
        }
        else
        {
            // WRITEME
        }

        return true;
    }
    else
    if (type == type_bone_object
     || type == type_bone_valuenode)
    {
        const synfigapp::ValueDesc &orig_value_desc = value_desc;
        ValueNode::Handle value_node(value_desc.get_value_node());

        if (type == type_bone_valuenode)
        {
            assert(value_desc.parent_is_value_node());
            value_node = (*value_node)(get_time()).get(ValueNode_Bone::Handle());
        }
        else
            assert(value_desc.parent_is_linkable_value_node() || value_desc.parent_is_canvas());

        Duck::Handle fake_duck;
        Duck::Handle tip_duck;
        synfig::TransformStack origin_transform_stack(transform_stack), bone_transform_stack;
        bool recursive(get_type_mask() & Duck::TYPE_BONE_RECURSIVE);

        ValueNode_Bone::Handle bone_value_node;
        if (!(bone_value_node = ValueNode_Bone::Handle::cast_dynamic(value_node)))
        {
            error("expected a ValueNode_Bone");
            assert(0);
			return false;
        }

        synfig::GUID guid(bone_value_node->get_guid());
        Time time(get_time());
        Bone bone((*bone_value_node)(time).get(Bone()));
        bool invertible(true);
        Angle angle;
        Angle::deg parent_angle(0);

        {
            Matrix transform;
            bool has_parent(!bone.is_root());
            if (has_parent)
            {
                Bone parent_bone((*bone.get_parent())(time).get(Bone()));

                // add the parent's ducks too
                add_to_ducks(synfigapp::ValueDesc(bone_value_node, bone_value_node->get_link_index_from_name("parent"), value_desc),canvas_view,transform_stack);

                transform = parent_bone.get_animated_matrix();
                origin_transform_stack.push(new Transform_Matrix(guid, transform));
                bone_transform_stack = origin_transform_stack;
                invertible = transform.is_invertible();

                Vector scale(parent_bone.get_local_scale());
                bone_transform_stack.push(new Transform_Translate(guid, Point((scale[0])*bone.get_origin()[0],
                                                                              (scale[1])*bone.get_origin()[1])));
                origin_transform_stack.push(new Transform_Scale(guid, scale));

#ifdef TRY_TO_ALIGN_WIDTH_DUCKS
                // this stuff doesn't work very well - we can find out
                // the cumulative angle and so place the duck on the
                // right of the circle, but recursive scales in the
                // parent can cause the radius to look wrong, and the
                // duck to appear off-center
                printf("%s:%d bone %s:\n", __FILE__, __LINE__, bone.get_name().c_str());
                while (true) {
                    printf("%s:%d parent_angle = %5.2f + %5.2f = %5.2f\n", __FILE__, __LINE__,
                           Angle::deg(parent_angle).get(), Angle::deg(parent_bone.get_angle()).get(),
                           Angle::deg(parent_angle + (parent_bone.get_angle())).get());
                    parent_angle += parent_bone.get_angle();
                    if (parent_bone.is_root()) break;
                    parent_bone = (*parent_bone.get_parent())(time).get(Bone());
                }
                printf("%s:%d finally %5.2f\n\n", __FILE__, __LINE__, Angle::deg(parent_angle).get());
#endif
            }
            else
            {
                bone_transform_stack = origin_transform_stack;
                bone_transform_stack.push(new Transform_Translate(guid, bone.get_origin()));
            }
        }

        bone_transform_stack.push(new Transform_Rotate(guid, bone.get_angle()));

        // origin
        {
            synfigapp::ValueDesc value_desc(bone_value_node, bone_value_node->get_link_index_from_name("origin"), orig_value_desc);

            etl::handle<Duck> duck=new Duck();
            duck->set_type(Duck::TYPE_POSITION);
            set_duck_value_desc(*duck, value_desc, origin_transform_stack);
            duck->set_point(value_desc.get_value(time).get(Point()));

            // if the ValueNode can be directly manipulated, then set it as so
            duck->set_editable(!invertible ? false :
                               !value_desc.is_value_node() ? true :
                               synfigapp::is_editable(value_desc.get_value_node()));

            duck->signal_edited().clear();
            duck->signal_edited().connect(sigc::bind(sigc::mem_fun(*this, &studio::Duckmatic::on_duck_changed), value_desc));
            duck->signal_user_click(2).connect(sigc::bind(sigc::bind(sigc::bind(sigc::mem_fun(*canvas_view,
                                                                                              &studio::CanvasView::popup_param_menu),
                                                                                false), // bezier
                                                                     0.0f),             // location
                                                          value_desc));                 // value_desc
            add_duck(duck);
        }

        // fake
        {
            synfigapp::ValueDesc value_desc(bone_value_node, bone_value_node->get_link_index_from_name("name"), orig_value_desc);

            etl::handle<Duck> duck=new Duck();
            duck->set_type(Duck::TYPE_NONE);
            set_duck_value_desc(*duck, value_desc, bone_transform_stack);
            duck->set_point(Point(0, 0));

            duck->set_ignore(true);
            add_duck(duck);
            fake_duck = last_duck();
        }

        // angle
        {
            synfigapp::ValueDesc value_desc(bone_value_node, bone_value_node->get_link_index_from_name("angle"), orig_value_desc);

            etl::handle<Duck> duck=new Duck();
            duck->set_type(Duck::TYPE_ANGLE);
            set_duck_value_desc(*duck, value_desc, bone_transform_stack);

            angle = value_desc.get_value(time).get(Angle());
            Real length(bone.get_length() * (bone.get_scalex() * bone.get_scalelx()));
            duck->set_point(Point(length*0.9, 0));

            // if the ValueNode can be directly manipulated, then set it as so
            duck->set_editable(!value_desc.is_value_node() ? true :
                               synfigapp::is_editable(value_desc.get_value_node()));

            duck->signal_edited().clear();
            duck->signal_edited().connect(sigc::bind(sigc::mem_fun(*this, &studio::Duckmatic::on_duck_changed), value_desc));
            duck->signal_user_click(2).connect(sigc::bind(sigc::bind(sigc::bind(sigc::mem_fun(*canvas_view,
                                                                                              &studio::CanvasView::popup_param_menu),
                                                                                false), // bezier
                                                                     0.0f),             // location
                                                          value_desc));                 // value_desc
            duck->set_origin(fake_duck);
            add_duck(duck);
        }

        // tip
        {
            synfigapp::ValueDesc value_desc(bone_value_node, bone_value_node->get_link_index_from_name(recursive ? "scalex" : "scalelx"), orig_value_desc);

            etl::handle<Duck> duck=new Duck();
            duck->set_type(Duck::TYPE_VERTEX);
            set_duck_value_desc(*duck, value_desc, bone_transform_stack);
            //Real length = bone.get_length()*bone.get_scalex()*bone.get_scalelx();
            Real length = value_desc.get_value(time).get(Real());
            duck->set_point(Vector(length, 0.0));

            // if the ValueNode can be directly manipulated, then set it as so
            duck->set_editable(!invertible ? false :
                               !value_desc.is_value_node() ? true :
                               synfigapp::is_editable(value_desc.get_value_node()));

            duck->signal_edited().clear();
            duck->signal_edited().connect(sigc::bind(sigc::mem_fun(*this, &studio::Duckmatic::on_duck_changed), value_desc));
            duck->signal_user_click(2).connect(
                sigc::bind(
                    sigc::bind(
                        sigc::bind(
                            sigc::mem_fun(
                                *canvas_view,
                                &studio::CanvasView::popup_param_menu
                            ),
                            false // bezier
                        ),
                        0.0f // location
                    ),
                    value_desc
                )
            );
            duck->set_origin(fake_duck);
            add_duck(duck);
            tip_duck = last_duck();
        }

        // origin width
        {

            synfigapp::ValueDesc value_desc(bone_value_node, bone_value_node->get_link_index_from_name("width"), orig_value_desc);

            etl::handle<Duck> duck=new Duck();
            duck->set_type(Duck::TYPE_WIDTH);
            set_duck_value_desc(*duck, value_desc, bone_transform_stack);
            duck->set_radius(true);
            duck->set_scalar(1);
            duck->set_point(Point(0, value_desc.get_value(time).get(Real())));

            // if the ValueNode can be directly manipulated, then set it as so
            duck->set_editable(!invertible ? false :
                               !value_desc.is_value_node() ? true :
                               synfigapp::is_editable(value_desc.get_value_node()));

            duck->signal_edited().clear();
            duck->signal_edited().connect(sigc::bind(sigc::mem_fun(*this, &studio::Duckmatic::on_duck_changed), value_desc));
            duck->signal_user_click(2).connect(sigc::bind(sigc::bind(sigc::bind(sigc::mem_fun(*canvas_view,
                            &studio::CanvasView::popup_param_menu),
                        false), // bezier
                    0.0f),              // location
                value_desc));                   // value_desc
            duck->set_origin(fake_duck);
            add_duck(duck);
        }

        // tip width
        {

            synfigapp::ValueDesc value_desc(bone_value_node, bone_value_node->get_link_index_from_name("tipwidth"), orig_value_desc);

            etl::handle<Duck> duck=new Duck();
            duck->set_type(Duck::TYPE_WIDTH);
            set_duck_value_desc(*duck, value_desc, bone_transform_stack);
            duck->set_radius(true);
            duck->set_scalar(1);
            duck->set_point(Point(0, value_desc.get_value(time).get(Real())));

            // if the ValueNode can be directly manipulated, then set it as so
            duck->set_editable(!invertible ? false :
                               !value_desc.is_value_node() ? true :
                               synfigapp::is_editable(value_desc.get_value_node()));

            duck->signal_edited().clear();
            duck->signal_edited().connect(sigc::bind(sigc::mem_fun(*this, &studio::Duckmatic::on_duck_changed), value_desc));
            duck->signal_user_click(2).connect(sigc::bind(sigc::bind(sigc::bind(sigc::mem_fun(*canvas_view,
                            &studio::CanvasView::popup_param_menu),
                        false), // bezier
                    0.0f),              // location
                value_desc));                   // value_desc
            duck->set_origin(tip_duck);
            add_duck(duck);
        }

        return true;
    }
    else
    if (type == type_bone_weight_pair)
    {
        ValueNode_BoneWeightPair::Handle value_node;
        if(value_desc.is_value_node() &&
           (value_node=ValueNode_BoneWeightPair::Handle::cast_dynamic(value_desc.get_value_node())))
            add_to_ducks(synfigapp::ValueDesc(value_node, value_node->get_link_index_from_name("bone"), value_desc), canvas_view, transform_stack);
    }

    return false;
}


/*
-- ** -- DuckDrag_Translate M E T H O D S----------------------------
*/
void
DuckDrag_Translate::begin_duck_drag(Duckmatic* duckmatic, const synfig::Vector& offset)
{
	is_moving = false;

	Duck::Handle duck = duckmatic->find_duck(offset);
	assert(duck);
	Duck::Handle origin_duck = duck;
	while(origin_duck->get_move_origin() && origin_duck->get_origin_duck())
		origin_duck = origin_duck->get_origin_duck();
	
	last_translate_ = Vector(0, 0);
	drag_offset_ = duck->get_trans_point();
	snap_offset_ = origin_duck->get_trans_point() - drag_offset_;

	const DuckList selected_ducks(duckmatic->get_selected_ducks());
	DuckList::const_iterator iter;

	positions.clear();
	for(iter=selected_ducks.begin();iter!=selected_ducks.end();++iter)
	{
		Point p((*iter)->get_trans_point());
		positions.push_back(p);
	}
}

bool
DuckDrag_Translate::end_duck_drag(Duckmatic* duckmatic)
{
	if(is_moving)
	{
		duckmatic->signal_edited_selected_ducks();
		return true;
	}
	else
	{
		duckmatic->signal_user_click_selected_ducks(0);
		return false;
	}
}

void
DuckDrag_Translate::duck_drag(Duckmatic* duckmatic, const synfig::Vector& vector)
{
	const DuckList selected_ducks(duckmatic->get_selected_ducks());
	DuckList::const_iterator iter;

	synfig::Vector offset =
		  duckmatic->snap_point_to_grid(vector + snap_offset_)
		- snap_offset_
		- drag_offset_;
	int i;
	Time time(duckmatic->get_time());

	// drag the vertex and position ducks first
	for (i=0,iter=selected_ducks.begin(); iter!=selected_ducks.end(); ++iter,i++)
		if((*iter)->get_type() == Duck::TYPE_VERTEX || (*iter)->get_type() == Duck::TYPE_POSITION)
			(*iter)->set_trans_point(positions[i] + offset, time);

	// then drag the others
	for (i=0,iter=selected_ducks.begin(); iter!=selected_ducks.end(); ++iter,i++)
		if ((*iter)->get_type() != Duck::TYPE_VERTEX && (*iter)->get_type() != Duck::TYPE_POSITION)
			(*iter)->set_trans_point(positions[i] + offset, time);

	last_translate_ = offset;

	if(last_translate_.mag()>0.0001)
		is_moving = true;

	if (is_moving)
		duckmatic->signal_edited_selected_ducks(true);

	// then patch up the tangents for the vertices we've moved
	duckmatic->update_ducks();
}

/*
-- ** -- BezierDrag_Default M E T H O D S----------------------------
*/
void
BezierDrag_Default::begin_bezier_drag(Duckmatic* duckmatic, const synfig::Vector& offset, float bezier_click_pos)
{
	is_moving = false;
	drag_offset_=offset;
	click_pos_=bezier_click_pos;

	etl::handle<Duck> c1(duckmatic->get_selected_bezier()->c1);
	etl::handle<Duck> c2(duckmatic->get_selected_bezier()->c2);

	c1_initial = c1->get_trans_point();
	c2_initial = c2->get_trans_point();
	last_translate_ = synfig::Vector(0,0);

	if (c1 == duckmatic->get_selected_bezier()->p1
		&& c2 == duckmatic->get_selected_bezier()->p2)
	{
		// This is a polygon segment
		// We can't bend the curve, so drag it instead
		c1_ratio = 1.0;
		c2_ratio = 1.0;

	}
	else
	{
		// This is a bline segment, so we can bend the curve

		// Magic Bezier Drag Equations follow! (stolen from Inkscape)
		// "weight" describes how the influence of the drag should be
		// distributed among the handles;
		// 0 = front handle only, 1 = back handle only.

		float t = bezier_click_pos;
		float weight;
		if (t <= 1.0/6.0 ) weight=0;
		else if (t <= 0.5 ) weight = (pow((6 * t - 1) / 2.0, 3)) / 2;
		else if (t <= 5.0 / 6.0) weight = (1 - pow((6 * (1-t) - 1) / 2.0, 3)) / 2 + 0.5;
		else weight = 1;

		c1_ratio = (1-weight)/(3*t*(1-t)*(1-t));
		c2_ratio = weight/(3*t*t*(1-t));
	}
}

void
BezierDrag_Default::bezier_drag(Duckmatic* duckmatic, const synfig::Vector& vector)
{
	synfig::Vector vect(duckmatic->snap_point_to_grid(vector)-drag_offset_);
	Time time(duckmatic->get_time());

	synfig::Vector c1_offset(vect[0]*c1_ratio, vect[1]*c1_ratio);
	synfig::Vector c2_offset(vect[0]*c2_ratio, vect[1]*c2_ratio);

	etl::handle<Duck> c1(duckmatic->get_selected_bezier()->c1);
	etl::handle<Duck> c2(duckmatic->get_selected_bezier()->c2);

	c1->set_trans_point(c1_initial+c1_offset, time);
	c2->set_trans_point(c2_initial+c2_offset, time);

	last_translate_=vect;
	if(last_translate_.mag()>0.0001)
		is_moving = true;

	if (is_moving) {
		duckmatic->signal_edited_duck(c1, true);
		duckmatic->signal_edited_duck(c2, true);
	}

	duckmatic->update_ducks();
}

bool
BezierDrag_Default::end_bezier_drag(Duckmatic* duckmatic)
{
	if(is_moving)
	{
		etl::handle<Duck> c1(duckmatic->get_selected_bezier()->c1);
		etl::handle<Duck> c2(duckmatic->get_selected_bezier()->c2);

		duckmatic->signal_edited_duck(c1);
		duckmatic->signal_edited_duck(c2);

		return true;
	}
	else
	{
		return false;
	}
}

/*
-- ** -- Duckmatic::Push M E T H O D S----------------------------
*/
Duckmatic::Push::Push(Duckmatic *duckmatic_):
	duckmatic_(duckmatic_)
{
	duck_map=duckmatic_->duck_map;
	bezier_list_=duckmatic_->bezier_list_;
	duck_data_share_map=duckmatic_->duck_data_share_map;
	stroke_list_=duckmatic_->stroke_list_;
	duck_dragger_=duckmatic_->duck_dragger_;
	needs_restore=true;
}

Duckmatic::Push::~Push()
{
	if(needs_restore)
		restore();
}

void
Duckmatic::Push::restore()
{
	duckmatic_->duck_map=duck_map;
	duckmatic_->bezier_list_=bezier_list_;
	duckmatic_->duck_data_share_map=duck_data_share_map;
	duckmatic_->stroke_list_=stroke_list_;
	duckmatic_->duck_dragger_=duck_dragger_;
	needs_restore=false;
}

/*
-- ** -- inline M E T H O D S----------------------------
*/
inline synfig::GUID calc_duck_guid(const synfigapp::ValueDesc& value_desc, const synfig::TransformStack& transform_stack)
{
	return value_desc.get_guid() % transform_stack.get_guid();
}

//! sets duck name, value_desc, transform_stack and GUID
inline void set_duck_value_desc(Duck& duck, const synfigapp::ValueDesc& value_desc, const synfig::TransformStack& transform_stack)
{
	duck.set_name(value_desc.get_guid_string());
	duck.set_value_desc(value_desc);
	duck.set_transform_stack(transform_stack);
	duck.set_guid(calc_duck_guid(value_desc, transform_stack));
}

//! sets duck name, value_desc and GUID
inline void set_duck_value_desc(Duck& duck, const synfigapp::ValueDesc& value_desc, const synfig::String& sub_name, const synfig::TransformStack& transform_stack)
{
	set_duck_value_desc(duck, value_desc.get_sub_value(sub_name), transform_stack);
}
