X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;f=synfig-studio%2Ftrunk%2Fsrc%2Fgtkmm%2Fduckmatic.cpp;h=fec7061aaccdc59ba85435ce3fcd810862301277;hb=9f44faaf8a4b3c513aad5e2ac4d195c28b0fe567;hp=20d0745345641e482129215bdd988564ac59362a;hpb=02252941b29de64037116f4d37991a38d9ff0d94;p=synfig.git

diff --git a/synfig-studio/trunk/src/gtkmm/duckmatic.cpp b/synfig-studio/trunk/src/gtkmm/duckmatic.cpp
index 20d0745..fec7061 100644
--- a/synfig-studio/trunk/src/gtkmm/duckmatic.cpp
+++ b/synfig-studio/trunk/src/gtkmm/duckmatic.cpp
@@ -2,19 +2,21 @@
 /*!	\file duckmatic.cpp
 **	\brief Template File
 **
-**	$Id: duckmatic.cpp,v 1.1.1.1 2005/01/07 03:34:36 darco Exp $
+**	$Id$
 **
 **	\legal
-**	Copyright (c) 2002 Robert B. Quattlebaum Jr.
+**	Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
+**	Copyright (c) 2007 Chris Moore
 **
-**	This software and associated documentation
-**	are CONFIDENTIAL and PROPRIETARY property of
-**	the above-mentioned copyright holder.
+**	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.
 **
-**	You may not copy, print, publish, or in any
-**	other way distribute this software without
-**	a prior written agreement with
-**	the copyright holder.
+**	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
 */
 /* ========================================================================= */
@@ -54,6 +56,8 @@
 
 #include "onemoment.h"
 
+#include "general.h"
+
 #endif
 
 /* === U S I N G =========================================================== */
@@ -65,6 +69,13 @@ 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
+
 /* === G L O B A L S ======================================================= */
 
 /* === P R O C E D U R E S ================================================= */
@@ -78,7 +89,7 @@ Duckmatic::Duckmatic():
 	grid_snap(false),
 	guide_snap(false),
 	grid_size(1.0/4.0,1.0/4.0),
-	show_persistant_strokes(true)
+	show_persistent_strokes(true)
 {
 	axis_lock=false;
 	drag_offset_=Point(0,0);
@@ -101,8 +112,8 @@ Duckmatic::clear_ducks()
 	bezier_list_.clear();
 	stroke_list_.clear();
 
-	if(show_persistant_strokes)
-		stroke_list_=persistant_stroke_list_;
+	if(show_persistent_strokes)
+		stroke_list_=persistent_stroke_list_;
 }
 
 //! Returns \a true if the given duck is currently selected
@@ -142,8 +153,6 @@ Duckmatic::set_guide_snap(bool x)
 	}
 }
 
-
-
 Duckmatic::GuideList::iterator
 Duckmatic::find_guide_x(synfig::Point pos, float radius)
 {
@@ -205,7 +214,7 @@ Duckmatic::refresh_selected_ducks()
 		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));
@@ -218,7 +227,7 @@ Duckmatic::refresh_selected_ducks()
 */
 	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)
@@ -248,11 +257,8 @@ Duckmatic::is_duck_group_selectable(const etl::handle<Duck>& x)const
 			layer_name=="curve_gradient"
 		)
 			return false;
-		if(
-			(layer_name=="PasteCanvas"||
-			layer_name=="paste_canvas")
-			&& !layer->get_param("children_lock").get(bool())
-		)
+		if((layer_name=="PasteCanvas"|| layer_name=="paste_canvas") &&
+		   !layer->get_param("children_lock").get(bool()))
 			return false;
 	}
 	return true;
@@ -261,13 +267,32 @@ Duckmatic::is_duck_group_selectable(const etl::handle<Duck>& x)const
 void
 Duckmatic::select_all_ducks()
 {
-	DuckMap::const_iterator iter;	
+	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);
 }
 
 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;
@@ -277,8 +302,8 @@ Duckmatic::select_ducks_in_box(const synfig::Vector& tl,const synfig::Vector& br
 	vmax[1]=std::max(tl[1],br[1]);
 
 //	Type type(get_type_mask());
-	
-	DuckMap::const_iterator iter;	
+
+	DuckMap::const_iterator iter;
 	for(iter=duck_map.begin();iter!=duck_map.end();++iter)
 	{
 		Point p(iter->second->get_trans_point());
@@ -312,14 +337,14 @@ 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;
 
@@ -357,7 +382,6 @@ Duckmatic::toggle_select_duck(const etl::handle<Duck> &duck)
 		select_duck(duck);
 }
 
-
 void
 Duckmatic::translate_selected_ducks(const synfig::Vector& vector)
 {
@@ -390,7 +414,7 @@ Duckmatic::snap_point_to_grid(const Point& x, float radius)const
 
 	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;
@@ -419,7 +443,7 @@ Duckmatic::snap_point_to_grid(const Point& x, float radius)const
 		if(has_guide_y)
 			ret[1]=*guide_y;
 	}
-	
+
 	if(axis_lock)
 	{
 		ret-=drag_offset_;
@@ -429,7 +453,7 @@ Duckmatic::snap_point_to_grid(const Point& x, float radius)const
 			ret[1]=0;
 		ret+=drag_offset_;
 	}
-	
+
 	return ret;
 }
 
@@ -442,10 +466,10 @@ DuckDrag_Translate::begin_duck_drag(Duckmatic* duckmatic, const synfig::Vector&
 
 		snap=Vector(0,0);
 	}
-	
+
 	const DuckList selected_ducks(duckmatic->get_selected_ducks());
 	DuckList::const_iterator iter;
-	
+
 	positions.clear();
 	for(iter=selected_ducks.begin();iter!=selected_ducks.end();++iter)
 	{
@@ -477,29 +501,24 @@ DuckDrag_Translate::duck_drag(Duckmatic* duckmatic, const synfig::Vector& vector
 
 	synfig::Vector vect(duckmatic->snap_point_to_grid(vector)-drag_offset_);
 	int i;
-	
+
 	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)continue;
+		if((*iter)->get_type()!=Duck::TYPE_VERTEX &&
+		   (*iter)->get_type()!=Duck::TYPE_POSITION)
+			continue;
 		(*iter)->set_trans_point(positions[i]+vect);
 	}
 	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)continue;
+		if((*iter)->get_type()==Duck::TYPE_VERTEX ||
+		   (*iter)->get_type()==Duck::TYPE_POSITION)
+			continue;
 		(*iter)->set_trans_point(positions[i]+vect);
 	}
 	last_translate_=vect;
 }
 
-
-
-
-
-
-
-
-
-
 void
 Duckmatic::signal_edited_selected_ducks()
 {
@@ -507,18 +526,29 @@ Duckmatic::signal_edited_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();
-		
+
 	// Go ahead and call everyone's signals
 	for(iter=ducks.begin();iter!=ducks.end();++iter)
 	{
-		if(!(*iter)->signal_edited()((*iter)->get_point()))
+		if ((*iter)->get_type() == Duck::TYPE_ANGLE)
 		{
-			selected_ducks=old_set;
-			throw String("Bad edit");
+			if(!(*iter)->signal_edited_angle()((*iter)->get_rotations()))
+			{
+				selected_ducks=old_set;
+				throw String("Bad edit");
+			}
+		}
+		else
+		{
+			if(!(*iter)->signal_edited()((*iter)->get_point()))
+			{
+				selected_ducks=old_set;
+				throw String("Bad edit");
+			}
 		}
 	}
 	selected_ducks=old_set;
@@ -536,10 +566,6 @@ Duckmatic::signal_user_click_selected_ducks(int button)
 	}
 }
 
-
-
-
-
 void
 Duckmatic::add_duck(const etl::handle<Duck> &duck)
 {
@@ -555,7 +581,7 @@ Duckmatic::add_duck(const etl::handle<Duck> &duck)
 			duck->set_shared_point(point);
 			duck_data_share_map[duck->get_data_guid()]=point;
 		}
-		
+
 		duck_map.insert(duck);
 	}
 
@@ -586,30 +612,30 @@ Duckmatic::add_stroke(etl::smart_ptr<std::list<synfig::Point> > stroke_point_lis
 	stroke->stroke_data=stroke_point_list;
 	stroke->color=color;
 
-	stroke_list_.push_back(stroke);	
+	stroke_list_.push_back(stroke);
 }
 
 void
-Duckmatic::add_persistant_stroke(etl::smart_ptr<std::list<synfig::Point> > stroke_point_list, const synfig::Color& color)
+Duckmatic::add_persistent_stroke(etl::smart_ptr<std::list<synfig::Point> > stroke_point_list, const synfig::Color& color)
 {
 	add_stroke(stroke_point_list,color);
-	persistant_stroke_list_.push_back(stroke_list_.back());
+	persistent_stroke_list_.push_back(stroke_list_.back());
 }
 
 void
-Duckmatic::clear_persistant_strokes()
+Duckmatic::clear_persistent_strokes()
 {
-	persistant_stroke_list_.clear();
+	persistent_stroke_list_.clear();
 }
 
 void
-Duckmatic::set_show_persistant_strokes(bool x)
+Duckmatic::set_show_persistent_strokes(bool x)
 {
-	if(x!=show_persistant_strokes)
+	if(x!=show_persistent_strokes)
 	{
-		show_persistant_strokes=x;
+		show_persistent_strokes=x;
 		if(x)
-			stroke_list_=persistant_stroke_list_;
+			stroke_list_=persistent_stroke_list_;
 		else
 			stroke_list_.clear();
 	}
@@ -618,7 +644,7 @@ Duckmatic::set_show_persistant_strokes(bool x)
 void
 Duckmatic::erase_duck(const etl::handle<Duck> &duck)
 {
-	duck_map.erase(duck->get_guid());	
+	duck_map.erase(duck->get_guid());
 }
 
 etl::handle<Duckmatic::Duck>
@@ -628,7 +654,7 @@ Duckmatic::find_similar_duck(etl::handle<Duck> duck)
 	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)
@@ -686,15 +712,14 @@ 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;
 
@@ -703,7 +728,7 @@ Duckmatic::find_duck(synfig::Point point, synfig::Real radius, Duck::Type type)
 	for(iter=duck_map.begin();iter!=duck_map.end();++iter)
 	{
 		const Duck::Handle& duck(iter->second);
-		
+
 		if(!duck->get_editable())
 			continue;
 		Real dist((duck->get_trans_point()-point).mag_squared());
@@ -729,22 +754,22 @@ Duckmatic::find_duck(synfig::Point point, synfig::Real radius, Duck::Type type)
 etl::handle<Duckmatic::Bezier>
 Duckmatic::find_bezier(synfig::Point point, synfig::Real radius,float* location)
 {
-	return find_bezier(point,radius,radius,location);	
+	return find_bezier(point,radius,radius,location);
 }
 
-etl::handle<Duckmatic::Bezier> 
+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();
@@ -752,21 +777,21 @@ Duckmatic::find_bezier(synfig::Point pos, synfig::Real scale, synfig::Real radiu
 		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		
+#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		
-		
+		step = min(step,0.1); //10 is minimum
+
 		d = find_closest(curve,pos,step,&closest,&time);
 #endif
 
@@ -775,21 +800,19 @@ Duckmatic::find_bezier(synfig::Point pos, synfig::Real scale, synfig::Real radiu
 			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;	
-}
-
 
+	return 0;
+}
 
 bool
 Duckmatic::save_sketch(const synfig::String& filename)const
@@ -799,10 +822,10 @@ Duckmatic::save_sketch(const synfig::String& filename)const
 	if(!file)return false;
 
 	file<<"SKETCH"<<endl;
-	
+
 	std::list<etl::handle<Stroke> >::const_iterator iter;
-	
-	for(iter=persistant_stroke_list_.begin();iter!=persistant_stroke_list_.end();++iter)
+
+	for(iter=persistent_stroke_list_.begin();iter!=persistent_stroke_list_.end();++iter)
 	{
 		file<<"C "
 			<<(*iter)->color.get_r()<<' '
@@ -828,7 +851,7 @@ bool
 Duckmatic::load_sketch(const synfig::String& filename)
 {
 	std::ifstream file(filename.c_str());
-			
+
 	if(!file)
 		return false;
 
@@ -841,16 +864,15 @@ Duckmatic::load_sketch(const synfig::String& filename)
 		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':
@@ -863,7 +885,7 @@ Duckmatic::load_sketch(const synfig::String& filename)
 					synfig::warning("Bad color line \"%s\"",line.c_str());
 					r=0;g=0;b=0;
 				}
-				add_persistant_stroke(stroke_data, synfig::Color(r,g,b));
+				add_persistent_stroke(stroke_data, synfig::Color(r,g,b));
 			}
 			break;
 		case 'V':
@@ -871,7 +893,7 @@ Duckmatic::load_sketch(const synfig::String& filename)
 			if(!stroke_data)
 			{
 				stroke_data.spawn();
-				add_persistant_stroke(stroke_data, synfig::Color(0,0,0));
+				add_persistent_stroke(stroke_data, synfig::Color(0,0,0));
 			}
 			float x,y;
 			if(!strscanf(line,"V %f %f",&x, &y))
@@ -884,23 +906,16 @@ Duckmatic::load_sketch(const synfig::String& filename)
 			break;
 		}
 	}
-	
+
 	sketch_filename_=filename;
 	return true;
 }
 
-
-
-
-
-
-
-
 Duckmatic::Push::Push(Duckmatic *duckmatic_):
 	duckmatic_(duckmatic_)
 {
-	duck_map=duckmatic_->duck_map;	
-	bezier_list_=duckmatic_->bezier_list_;	
+	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_;
@@ -916,26 +931,18 @@ Duckmatic::Push::~Push()
 void
 Duckmatic::Push::restore()
 {
-	duckmatic_->duck_map=duck_map;	
-	duckmatic_->bezier_list_=bezier_list_;	
+	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 String guid_string(const synfigapp::ValueDesc& x)
 {
 	if(x.parent_is_layer_param())
-		return strprintf("%s",x.get_layer()->get_guid().get_string().c_str())+x.get_param_name();		
+		return strprintf("%s",x.get_layer()->get_guid().get_string().c_str())+x.get_param_name();
 	//if(x.is_value_node())
 		return strprintf("%s",x.get_value_node()->get_guid().get_string().c_str());
 }
@@ -943,7 +950,7 @@ inline String guid_string(const synfigapp::ValueDesc& x)
 inline GUID calc_duck_guid(const synfigapp::ValueDesc& x,const synfig::TransformStack& transform_stack)
 {
 	GUID ret(0);
-	
+
 	if(x.parent_is_layer_param())
 	{
 		ret=x.get_layer()->get_guid()^GUID::hasher(x.get_param_name());
@@ -954,7 +961,7 @@ inline GUID calc_duck_guid(const synfigapp::ValueDesc& x,const synfig::Transform
 	}
 
 	ret^=transform_stack.get_guid();
-	return ret;	
+	return ret;
 }
 
 /*
@@ -963,7 +970,7 @@ Duckmatic::create_duck_from(const synfigapp::ValueDesc& value_desc,etl::handle<C
 {
 	GUID duck_guid(calc_duck_guid(value_desc,transform_stack)^GUID::hasher(modifier));
 	etl::handle<Duck> duck=new Duck();
-	
+
 	return duck;
 }
 */
@@ -972,11 +979,11 @@ bool
 Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<CanvasView> canvas_view, const synfig::TransformStack& transform_stack, synfig::ParamDesc *param_desc, int multiple)
 {
 	ValueBase::Type type=value_desc.get_value_type();
-#define REAL_COOKIE		reinterpret_cast<synfig::ParamDesc*>(28)		
+#define REAL_COOKIE		reinterpret_cast<synfig::ParamDesc*>(28)
 	switch(type)
 	{
 	case ValueBase::TYPE_REAL:
-		
+
 		if(!param_desc || param_desc==REAL_COOKIE || !param_desc->get_origin().empty())
 		{
 			etl::handle<Duck> duck=new Duck();
@@ -996,7 +1003,7 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 			{
 				duck->set_editable(true);
 			}
-			
+
 			if(param_desc && param_desc!=REAL_COOKIE)
 			{
 				if(!param_desc->get_origin().empty())
@@ -1011,7 +1018,7 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 				duck->set_scalar(param_desc->get_scalar());
 			}
 
-			duck->signal_edited().clear();
+			duck->signal_edited().clear(); // value_desc.get_value_type() == ValueBase::TYPE_REAL:
 			duck->signal_edited().connect(
 				sigc::bind(
 					sigc::mem_fun(
@@ -1033,11 +1040,11 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 						0.0f
 					),
 					value_desc
-				)	
+				)
 			);
 
 			duck->set_guid(calc_duck_guid(value_desc,transform_stack)^GUID::hasher(multiple));
-			
+
 			add_duck(duck);
 
 			return true;
@@ -1045,14 +1052,14 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 		break;
 
 	case ValueBase::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);
 			duck->set_transform_stack(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()));
 			duck->set_name(guid_string(value_desc));
@@ -1060,7 +1067,7 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 			{
 				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()));
@@ -1072,7 +1079,7 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 				//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())
@@ -1087,12 +1094,13 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 				duck->set_scalar(param_desc->get_scalar());
 			}
 
-			duck->signal_edited().clear();
-			duck->signal_edited().connect(
+			duck->signal_edited().clear(); // value_desc.get_value_type() == ValueBase::TYPE_ANGLE:
+			duck->signal_edited_angle().clear();
+			duck->signal_edited_angle().connect(
 				sigc::bind(
 					sigc::mem_fun(
 						*canvas_view,
-						&studio::CanvasView::on_duck_changed
+						&studio::CanvasView::on_duck_angle_changed
 					),
 					value_desc
 				)
@@ -1109,7 +1117,7 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 						0.0f
 					),
 					value_desc
-				)	
+				)
 			);
 			duck->set_guid(calc_duck_guid(value_desc,transform_stack)^GUID::hasher(multiple));
 
@@ -1118,18 +1126,18 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 			return true;
 		}
 		break;
-		
+
 	case ValueBase::TYPE_VECTOR:
 		{
 			etl::handle<Duck> duck=new Duck();
 			duck->set_transform_stack(transform_stack);
-			
+
 			duck->set_point(value_desc.get_value(get_time()).get(Point()));
 			duck->set_name(guid_string(value_desc));
 			if(value_desc.is_value_node())
 			{
 				//duck->set_name(strprintf("%x",value_desc.get_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()));
@@ -1140,7 +1148,7 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 				//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)
 			{
@@ -1165,7 +1173,7 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 					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())
 				{
@@ -1179,14 +1187,13 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 				}
 				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();
+			duck->signal_edited().clear(); // value_desc.get_value_type() == ValueBase::TYPE_VECTOR:
 			duck->signal_edited().connect(
 				sigc::bind(
 					sigc::mem_fun(
@@ -1220,7 +1227,7 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 		{
 			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()))
 			)
@@ -1231,23 +1238,22 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 				bezier->p1->set_type(Duck::TYPE_VERTEX);
 				if(!add_to_ducks(synfigapp::ValueDesc(value_node,1),canvas_view,transform_stack))
 					return false;
-				bezier->c1=last_duck();				
+				bezier->c1=last_duck();
 				bezier->c1->set_type(Duck::TYPE_TANGENT);
 				bezier->c1->set_origin(bezier->p1);
-				bezier->c1->set_scalar(0.33333333333333333);
+				bezier->c1->set_scalar(TANGENT_BEZIER_SCALE);
 				bezier->c1->set_tangent(true);
 
-				
 				if(!add_to_ducks(synfigapp::ValueDesc(value_node,2),canvas_view,transform_stack))
 					return false;
 				bezier->p2=last_duck();
 				bezier->p2->set_type(Duck::TYPE_VERTEX);
 				if(!add_to_ducks(synfigapp::ValueDesc(value_node,3),canvas_view,transform_stack))
 					return false;
-				bezier->c2=last_duck();				
+				bezier->c2=last_duck();
 				bezier->c2->set_type(Duck::TYPE_TANGENT);
 				bezier->c2->set_origin(bezier->p2);
-				bezier->c2->set_scalar(-0.33333333333333333);
+				bezier->c2->set_scalar(-TANGENT_BEZIER_SCALE);
 				bezier->c2->set_tangent(true);
 
 				bezier->signal_user_click(2).connect(
@@ -1259,7 +1265,7 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 						value_desc
 					)
 				);
-				
+
 				add_bezier(bezier);
 			}
 			else if(value_desc.get_value().is_valid())
@@ -1276,47 +1282,47 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 					name=guid_string(value_desc);
 				}
 
-				duck_p=new class Duck(segment.p1);		
-				duck_p->set_name(name+".P1");					
+				duck_p=new class Duck(segment.p1);
+				duck_p->set_name(name+".P1");
 				duck_p->set_type(Duck::TYPE_VERTEX);
-				add_duck(duck_p);						
+				add_duck(duck_p);
 
-				duck_c=new class Duck(segment.t1);		
-				duck_c->set_name(name+".T1");					
+				duck_c=new class Duck(segment.t1);
+				duck_c->set_name(name+".T1");
 				duck_c->set_type(Duck::TYPE_TANGENT);
-				add_duck(duck_c);						
+				add_duck(duck_c);
 				duck_c->set_origin(duck_p);
-				duck_c->set_scalar(0.33333333333333333);
+				duck_c->set_scalar(TANGENT_HANDLE_SCALE);
 				duck_c->set_tangent(true);
 
 				bezier->p1=duck_p;
 				bezier->c1=duck_c;
 
-				duck_p=new class Duck(segment.p2);		
-				duck_p->set_name(name+".P2");					
+				duck_p=new class Duck(segment.p2);
+				duck_p->set_name(name+".P2");
 				duck_p->set_type(Duck::TYPE_VERTEX);
-				add_duck(duck_p);						
+				add_duck(duck_p);
 
-				duck_c=new class Duck(segment.t2);		
+				duck_c=new class Duck(segment.t2);
 				duck_c->set_type(Duck::TYPE_TANGENT);
-				duck_c->set_name(name+".T2");					
-				add_duck(duck_c);						
+				duck_c->set_name(name+".T2");
+				add_duck(duck_c);
 				duck_c->set_origin(duck_p);
-				duck_c->set_scalar(-0.33333333333333333);
+				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;
 		}
 		break;
 */
 	case ValueBase::TYPE_BLINEPOINT:
 	{
-			
+
 		if(value_desc.is_value_node() &&
 			ValueNode_Composite::Handle::cast_dynamic(value_desc.get_value_node())
 		)
@@ -1324,7 +1330,6 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 			ValueNode_Composite::Handle value_node;
 			value_node=ValueNode_Composite::Handle::cast_dynamic(value_desc.get_value_node());
 
-			
 			if(!add_to_ducks(synfigapp::ValueDesc(value_node,0),canvas_view,transform_stack))
 				return false;
 			etl::handle<Duck> vertex_duck(last_duck());
@@ -1332,13 +1337,13 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 			if(!add_to_ducks(synfigapp::ValueDesc(value_node,4),canvas_view,transform_stack))
 				return false;
 			etl::handle<Duck> t1_duck(last_duck());
-			
+
 			t1_duck->set_origin(vertex_duck);
-			t1_duck->set_scalar(-0.33333333333333333);
+			t1_duck->set_scalar(-TANGENT_HANDLE_SCALE);
 			t1_duck->set_tangent(true);
-			
+
 			etl::handle<Duck> t2_duck;
-			
+
 			// If the tangents are split
 			if((*value_node->get_link("split"))(get_time()).get(bool()))
 			{
@@ -1346,7 +1351,7 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 					return false;
 				t2_duck=last_duck();
 				t2_duck->set_origin(vertex_duck);
-				t2_duck->set_scalar(0.33333333333333333);
+				t2_duck->set_scalar(TANGENT_HANDLE_SCALE);
 				t2_duck->set_tangent(true);
 			}
 			else
@@ -1355,12 +1360,12 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 					return false;
 				t2_duck=last_duck();
 				t2_duck->set_origin(vertex_duck);
-				t2_duck->set_scalar(0.33333333333333333);
+				t2_duck->set_scalar(TANGENT_HANDLE_SCALE);
 				t2_duck->set_tangent(true);
 			}
 			return true;
 		}
-		
+
 	}
 	break;
 	case ValueBase::TYPE_LIST:
@@ -1372,28 +1377,28 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 		{
 			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;
 			etl::handle<Duck> duck, tduck;
-			
+
 			for(i=0;i<value_node->link_count();i++)
 			{
 				float amount(value_node->list[i].amount_at_time(get_time()));
 				if(amount<0.9999f)
 					continue;
 				if(first==-1)first=i;
-					
+
 				BLinePoint bline_point((*value_node->get_link(i))(get_time()));
-				
+
 				ValueNode_Composite::Handle vertex_value_node(
 					ValueNode_Composite::Handle::cast_dynamic(
 						value_node->get_link(i)
 					)
 				);
-								
+
 				// Add the vertex duck
 				if(vertex_value_node)
 				{
@@ -1418,7 +1423,7 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 							)
 						);
 						duck->set_value_desc(synfigapp::ValueDesc(value_node,i));
-			
+
 						if(param_desc)
 						{
 							if(!param_desc->get_origin().empty())
@@ -1428,7 +1433,7 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 								duck->set_origin(last_duck());
 /*
 								ValueBase value(synfigapp::ValueDesc(value_desc.get_layer(),param_desc->get_origin()).get_value(get_time()));
-								if(value.same_as(synfig::Point()))
+								if(value.same_type_as(synfig::Point()))
 									duck->set_origin(value.get(synfig::Point()));
 */
 							}
@@ -1444,7 +1449,7 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 						first_duck=duck;
 					duck->set_transform_stack(transform_stack);
 					duck->set_editable(false);
-					//duck->set_name(strprintf("%x-vertex",value_node->get_link(i).get()));			
+					//duck->set_name(strprintf("%x-vertex",value_node->get_link(i).get()));
 					duck->set_name(guid_string(synfigapp::ValueDesc(value_node,i))+".v");
 
 					duck->set_type(Duck::TYPE_VERTEX);
@@ -1457,14 +1462,14 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 								duck->set_origin(last_duck());
 /*
 								ValueBase value(synfigapp::ValueDesc(value_desc.get_layer(),param_desc->get_origin()).get_value(get_time()));
-								if(value.same_as(synfig::Point()))
+								if(value.same_type_as(synfig::Point()))
 									duck->set_origin(value.get(synfig::Point()));
 */
 						}
 					}
 					duck->set_guid(calc_duck_guid(synfigapp::ValueDesc(value_node,i),transform_stack)^GUID::hasher(".v"));
 					duck=add_similar_duck(duck);
-//					add_duck(duck);			
+//					add_duck(duck);
 				}
 
 				// Add the width duck only if we have a hint of scale
@@ -1479,14 +1484,14 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 						width->set_name(guid_string(synfigapp::ValueDesc(value_node,i))+".w");
 						{
 							ValueBase value(synfigapp::ValueDesc(value_desc.get_layer(),param_desc->get_hint()).get_value(get_time()));
-							if(value.same_as(synfig::Real()))
+							if(value.same_type_as(synfig::Real()))
 								width->set_scalar(value.get(synfig::Real())*0.5f);
 						}
 					}
 					else
 						synfig::error("Unable to add width duck!");
 				}
-				
+
 				if(bezier)
 				{
 					// Add the tangent1 duck
@@ -1502,16 +1507,16 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 						tduck->set_transform_stack(transform_stack);
 						tduck->set_editable(false);
 						tduck->set_name(guid_string(synfigapp::ValueDesc(value_node,i))+".t1");
-//						tduck->set_name(strprintf("%x-tangent1",value_node->get_link(i).get()));			
+//						tduck->set_name(strprintf("%x-tangent1",value_node->get_link(i).get()));
 						tduck->set_guid(calc_duck_guid(synfigapp::ValueDesc(value_node,i),transform_stack)^GUID::hasher(".t1"));
 						tduck=add_similar_duck(tduck);
 //						add_duck(duck);
 					}
 
 					tduck->set_origin(duck);
-					tduck->set_scalar(-0.33333333333333333);
+					tduck->set_scalar(-TANGENT_BEZIER_SCALE);
 					tduck->set_tangent(true);
-					
+
 					bezier->p2=duck;
 					bezier->c2=tduck;
 
@@ -1543,12 +1548,12 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 					add_bezier(bezier);
 					bezier=0;
 				}
-				
+
 				if(i+1>=value_node->link_count() && !value_node->get_loop())
 					continue;
-				
+
 				bezier=new Bezier();
-				
+
 				// Add the tangent2 duck
 				if(vertex_value_node)
 				{
@@ -1563,7 +1568,7 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 					{
 						tduck=new Duck(bline_point.get_tangent2());
 						tduck->set_transform_stack(transform_stack);
-						//tduck->set_name(strprintf("%x-tangent2",value_node->get_link(i).get()));			
+						//tduck->set_name(strprintf("%x-tangent2",value_node->get_link(i).get()));
 						tduck->set_name(guid_string(synfigapp::ValueDesc(value_node,i))+".t2");
 						tduck->set_guid(calc_duck_guid(synfigapp::ValueDesc(value_node,i),transform_stack)^GUID::hasher(".t2"));
 					}
@@ -1571,7 +1576,7 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 					{
 						tduck=new Duck(bline_point.get_tangent1());
 						tduck->set_transform_stack(transform_stack);
-						//tduck->set_name(strprintf("%x-tangent1",value_node->get_link(i).get()));			
+						//tduck->set_name(strprintf("%x-tangent1",value_node->get_link(i).get()));
 						tduck->set_name(guid_string(synfigapp::ValueDesc(value_node,i))+".t1");
 						tduck->set_guid(calc_duck_guid(synfigapp::ValueDesc(value_node,i),transform_stack)^GUID::hasher(".t1"));
 					}
@@ -1585,7 +1590,7 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 								duck->set_origin(last_duck());
 /*
 								ValueBase value(synfigapp::ValueDesc(value_desc.get_layer(),param_desc->get_origin()).get_value(get_time()));
-								if(value.same_as(synfig::Point()))
+								if(value.same_type_as(synfig::Point()))
 									duck->set_origin(value.get(synfig::Point()));
 */
 //						if(!param_desc->get_origin().empty())
@@ -1609,24 +1614,24 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 				}
 
 				tduck->set_origin(duck);
-				tduck->set_scalar(0.33333333333333333);
+				tduck->set_scalar(TANGENT_BEZIER_SCALE);
 				tduck->set_tangent(true);
-				
+
 				bezier->p1=duck;
 				bezier->c1=tduck;
-				
+
 			}
 			// Loop if necessary
 			if(bezier && value_node->get_loop())
 			{
 				BLinePoint bline_point((*value_node->get_link(first))(get_time()));
-				
+
 				ValueNode_Composite::Handle vertex_value_node(
 					ValueNode_Composite::Handle::cast_dynamic(
 						value_node->get_link(first)
 					)
 				);
-				
+
 				// Add the vertex duck
 				duck=first_duck;
 				/*
@@ -1652,12 +1657,12 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 							duck->set_origin(value_desc.get_layer()->get_param(param_desc->get_origin()).get(synfig::Point()));
 					}
 					duck->set_editable(false);
-					duck->set_name(strprintf("%x-vertex",value_node->get_link(first).get()));			
+					duck->set_name(strprintf("%x-vertex",value_node->get_link(first).get()));
 					duck->set_type(Duck::TYPE_VERTEX);
 					duck=add_similar_duck(duck);
 				}
 				*/
-				
+
 					// Add the tangent1 duck
 					if(vertex_value_node)
 					{
@@ -1671,16 +1676,16 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 						tduck->set_transform_stack(transform_stack);
 						tduck->set_editable(false);
 						tduck->set_name(guid_string(synfigapp::ValueDesc(value_node,first))+".t1");
-						//tduck->set_name(strprintf("%x-tangent1",value_node->get_link(first).get()));			
+						//tduck->set_name(strprintf("%x-tangent1",value_node->get_link(first).get()));
 						tduck=add_similar_duck(tduck);
 						tduck->set_guid(calc_duck_guid(synfigapp::ValueDesc(value_node,i),transform_stack)^GUID::hasher(".t1"));
 						//add_duck(duck);
 					}
 
 					tduck->set_origin(duck);
-					tduck->set_scalar(-0.33333333333333333);
+					tduck->set_scalar(-TANGENT_BEZIER_SCALE);
 					tduck->set_tangent(true);
-					
+
 					bezier->p2=duck;
 					bezier->c2=tduck;
 					bezier->signal_user_click(2).connect(
@@ -1709,11 +1714,11 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 
 					add_bezier(bezier);
 					bezier=0;
-				
+
 			}
 			return true;
 		}
-		else // Check for DynamicList		
+		else // Check for DynamicList
 		if(value_desc.is_value_node() &&
 			ValueNode_DynamicList::Handle::cast_dynamic(value_desc.get_value_node())
 		)
@@ -1721,18 +1726,18 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 			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()==ValueBase::TYPE_VECTOR)
 			{
 				Bezier bezier;
 				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;
 					etl::handle<Duck> duck(last_duck());
-					
+
 					if(param_desc)
 					{
 								synfigapp::ValueDesc value_desc_origin(value_desc.get_layer(),param_desc->get_origin());
@@ -1740,7 +1745,7 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 								duck->set_origin(last_duck());
 /*
 								ValueBase value(synfigapp::ValueDesc(value_desc.get_layer(),param_desc->get_origin()).get_value(get_time()));
-								if(value.same_as(synfig::Point()))
+								if(value.same_type_as(synfig::Point()))
 									duck->set_origin(value.get(synfig::Point()));
 */
 //						if(!param_desc->get_origin().empty())
@@ -1788,11 +1793,10 @@ Duckmatic::add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<Canva
 		{
 			// WRITEME
 		}
-		
+
 		return true;
 	}
 
-
 	break;
 	default:
 		break;