X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;f=synfig-core%2Ftrunk%2Fsrc%2Fsynfig%2Floadcanvas.cpp;h=433eeb006d520bffcea5fe581f6bd07c7e364e98;hb=4ba22fb51d97f1ecce04dcc5e40569a4354c1bae;hp=220c7a4abc012d813a85834c74cc79eda65799e9;hpb=9b6bc352c4932cbfe1acc81b69c896a29d474904;p=synfig.git

diff --git a/synfig-core/trunk/src/synfig/loadcanvas.cpp b/synfig-core/trunk/src/synfig/loadcanvas.cpp
index 220c7a4..433eeb0 100644
--- a/synfig-core/trunk/src/synfig/loadcanvas.cpp
+++ b/synfig-core/trunk/src/synfig/loadcanvas.cpp
@@ -6,6 +6,7 @@
 **
 **	\legal
 **	Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
+**	Copyright (c) 2007, 2008 Chris Moore
 **
 **	This package is free software; you can redistribute it and/or
 **	modify it under the terms of the GNU General Public License as
@@ -38,6 +39,7 @@
 #include <stdexcept>
 #include <iostream>
 
+#include "layer_pastecanvas.h"
 #include "loadcanvas.h"
 #include "valuenode.h"
 #include "valuenode_subtract.h"
@@ -87,8 +89,12 @@ test_class test_class_instance;
 
 /* === M A C R O S ========================================================= */
 
+#define VALUENODE_COMPATIBILITY_URL "http://synfig.org/Convert#Compatibility"
+
 inline bool is_whitespace(char x) { return ((x)=='\n' || (x)=='\t' || (x)==' '); }
 
+std::set<String> CanvasParser::loading_;
+
 /* === P R O C E D U R E S ================================================= */
 
 static std::map<String, Canvas::LooseHandle>* open_canvas_map_(0);
@@ -118,46 +124,50 @@ static void _canvas_file_name_changed(Canvas *x)
 }
 
 Canvas::Handle
-synfig::open_canvas(const String &filename)
+synfig::open_canvas(const String &filename,String &errors,String &warnings)
 {
-	CanvasParser parser;
-
-	parser.set_allow_errors(true);
-
-	Canvas::Handle canvas=parser.parse_from_file(filename);
-
-	if(parser.error_count())
-		return Canvas::Handle();
-
-	return canvas;
+	return open_canvas_as(filename, filename, errors, warnings);
 }
 
 Canvas::Handle
-synfig::open_canvas_as(const String &filename,const String &as)
+synfig::open_canvas_as(const String &filename,const String &as,String &errors,String &warnings)
 {
-	CanvasParser parser;
-
-	parser.set_allow_errors(true);
-
-	Canvas::Handle canvas=parser.parse_from_file_as(filename,as);
-
-	if(parser.error_count())
-		return Canvas::Handle();
-
-	return canvas;
-}
+	if (CanvasParser::loading_.count(filename))
+	{
+		String warning(strprintf(_("cannot load '%s' recursively"), filename.c_str()));
+		synfig::warning(warning);
+		warnings = "  * " + warning + "\n";
+		Canvas::Handle canvas(Canvas::create());
+		canvas->set_file_name(filename);
+		Layer::Handle paste(Layer_PasteCanvas::create());
+		canvas->push_back(paste);
+		paste->set_description(warning);
+		return canvas;
+	}
 
-Canvas::Handle
-synfig::string_to_canvas(const String &data)
-{
+	Canvas::Handle canvas;
 	CanvasParser parser;
-
 	parser.set_allow_errors(true);
 
-	Canvas::Handle canvas=parser.parse_from_string(data);
+	try
+	{
+		CanvasParser::loading_.insert(filename);
+		canvas=parser.parse_from_file_as(filename,as,errors);
+	}
+	catch (...)
+	{
+		CanvasParser::loading_.erase(filename);
+		throw;
+	}
+	CanvasParser::loading_.erase(filename);
+
+	warnings = parser.get_warnings_text();
 
 	if(parser.error_count())
+	{
+		errors = parser.get_errors_text();
 		return Canvas::Handle();
+	}
 
 	return canvas;
 }
@@ -179,10 +189,13 @@ CanvasParser::error_unexpected_element(xmlpp::Node *element,const String &got)
 void
 CanvasParser::warning(xmlpp::Node *element, const String &text)
 {
-	string str=strprintf("%s:<%s>:%d: warning: ",filename.c_str(),element->get_name().c_str(),element->get_line())+text;
-	//synfig::warning(str);
-	cerr<<str<<endl;
+	string str=strprintf("%s:<%s>:%d: ",filename.c_str(),element->get_name().c_str(),element->get_line())+text;
+
+	synfig::warning(str);
+	// cerr<<str<<endl;
+
 	total_warnings_++;
+	warnings_text += "  * " + str + "\n";
 	if(total_warnings_>=max_warnings_)
 		fatal_error(element, _("Too many warnings"));
 }
@@ -192,6 +205,7 @@ CanvasParser::error(xmlpp::Node *element, const String &text)
 {
 	string str=strprintf("%s:<%s>:%d: error: ",filename.c_str(),element->get_name().c_str(),element->get_line())+text;
 	total_errors_++;
+	errors_text += "  * " + str + "\n";
 	if(!allow_errors_)
 		throw runtime_error(str);
 	cerr<<str<<endl;
@@ -234,7 +248,7 @@ CanvasParser::parse_keyframe(xmlpp::Element *element,Canvas::Handle canvas)
 
 
 Real
-CanvasParser::parse_real(xmlpp::Element *element,Canvas::Handle canvas)
+CanvasParser::parse_real(xmlpp::Element *element)
 {
 	assert(element->get_name()=="real");
 
@@ -272,7 +286,7 @@ CanvasParser::parse_time(xmlpp::Element *element,Canvas::Handle canvas)
 }
 
 int
-CanvasParser::parse_integer(xmlpp::Element *element,Canvas::Handle canvas)
+CanvasParser::parse_integer(xmlpp::Element *element)
 {
 	assert(element->get_name()=="integer");
 
@@ -290,8 +304,17 @@ CanvasParser::parse_integer(xmlpp::Element *element,Canvas::Handle canvas)
 	return atoi(val.c_str());
 }
 
+// see 'minor hack' at the end of parse_vector() below
+// making this 'static' to give it file local scope
+// stops it working (where working means working around
+// bug #1509627)
+Vector &canvas_parser_vector_id(Vector &vector)
+{
+	return vector;
+}
+
 Vector
-CanvasParser::parse_vector(xmlpp::Element *element,Canvas::Handle canvas)
+CanvasParser::parse_vector(xmlpp::Element *element)
 {
 	assert(element->get_name()=="vector");
 
@@ -332,11 +355,16 @@ CanvasParser::parse_vector(xmlpp::Element *element,Canvas::Handle canvas)
 		else
 			error_unexpected_element(child,child->get_name());
 	}
-	return vect;
+	// Minor hack - gcc 4.1.2 and earlier think that we're not using
+	// 'vect' and optimize it out at -O2 and higher.  This convinces
+	// them that we are really using it.
+	return canvas_parser_vector_id(vect);
+	// When the bug is fixed, we can just do this instead:
+	// return vect;
 }
 
 Color
-CanvasParser::parse_color(xmlpp::Element *element,Canvas::Handle canvas)
+CanvasParser::parse_color(xmlpp::Element *element)
 {
 	assert(element->get_name()=="color");
 
@@ -346,7 +374,7 @@ CanvasParser::parse_color(xmlpp::Element *element,Canvas::Handle canvas)
 		return Color();
 	}
 
-	Color color;
+	Color color(0);
 
 	xmlpp::Element::NodeList list = element->get_children();
 	for(xmlpp::Element::NodeList::iterator iter = list.begin(); iter != list.end(); ++iter)
@@ -402,7 +430,7 @@ CanvasParser::parse_color(xmlpp::Element *element,Canvas::Handle canvas)
 }
 
 synfig::String
-CanvasParser::parse_string(xmlpp::Element *element,Canvas::Handle canvas)
+CanvasParser::parse_string(xmlpp::Element *element)
 {
 	assert(element->get_name()=="string");
 
@@ -422,7 +450,7 @@ CanvasParser::parse_string(xmlpp::Element *element,Canvas::Handle canvas)
 }
 
 bool
-CanvasParser::parse_bool(xmlpp::Element *element,Canvas::Handle canvas)
+CanvasParser::parse_bool(xmlpp::Element *element)
 {
 	assert(element->get_name()=="bool");
 
@@ -448,7 +476,7 @@ CanvasParser::parse_bool(xmlpp::Element *element,Canvas::Handle canvas)
 }
 
 Gradient
-CanvasParser::parse_gradient(xmlpp::Element *node,Canvas::Handle canvas)
+CanvasParser::parse_gradient(xmlpp::Element *node)
 {
 	assert(node->get_name()=="gradient");
 	Gradient ret;
@@ -462,7 +490,7 @@ CanvasParser::parse_gradient(xmlpp::Element *node,Canvas::Handle canvas)
 		else
 		{
 			Gradient::CPoint cpoint;
-			cpoint.color=parse_color(child,canvas);
+			cpoint.color=parse_color(child);
 
 			if(!child->get_attribute("pos"))
 			{
@@ -505,7 +533,7 @@ CanvasParser::parse_list(xmlpp::Element *element,Canvas::Handle canvas)
 }
 
 Segment
-CanvasParser::parse_segment(xmlpp::Element *element,Canvas::Handle canvas)
+CanvasParser::parse_segment(xmlpp::Element *element)
 {
 	assert(element->get_name()=="segment");
 
@@ -545,7 +573,7 @@ CanvasParser::parse_segment(xmlpp::Element *element,Canvas::Handle canvas)
 				continue;
 			}
 
-			seg.p1=parse_vector(dynamic_cast<xmlpp::Element*>(*iter),canvas);
+			seg.p1=parse_vector(dynamic_cast<xmlpp::Element*>(*iter));
 		}
 		else
 		if(child->get_name()=="t1")
@@ -569,7 +597,7 @@ CanvasParser::parse_segment(xmlpp::Element *element,Canvas::Handle canvas)
 				continue;
 			}
 
-			seg.t1=parse_vector(dynamic_cast<xmlpp::Element*>(*iter),canvas);
+			seg.t1=parse_vector(dynamic_cast<xmlpp::Element*>(*iter));
 		}
 		else
 		if(child->get_name()=="p2")
@@ -593,7 +621,7 @@ CanvasParser::parse_segment(xmlpp::Element *element,Canvas::Handle canvas)
 				continue;
 			}
 
-			seg.p2=parse_vector(dynamic_cast<xmlpp::Element*>(*iter),canvas);
+			seg.p2=parse_vector(dynamic_cast<xmlpp::Element*>(*iter));
 		}
 		else
 		if(child->get_name()=="t2")
@@ -617,7 +645,7 @@ CanvasParser::parse_segment(xmlpp::Element *element,Canvas::Handle canvas)
 				continue;
 			}
 
-			seg.t2=parse_vector(dynamic_cast<xmlpp::Element*>(*iter),canvas);
+			seg.t2=parse_vector(dynamic_cast<xmlpp::Element*>(*iter));
 		}
 		else
 			error_unexpected_element(child,child->get_name());
@@ -626,7 +654,7 @@ CanvasParser::parse_segment(xmlpp::Element *element,Canvas::Handle canvas)
 }
 
 BLinePoint
-CanvasParser::parse_bline_point(xmlpp::Element *element,Canvas::Handle canvas)
+CanvasParser::parse_bline_point(xmlpp::Element *element)
 {
 	assert(element->get_name()=="bline_point");
 	if(element->get_children().empty())
@@ -667,7 +695,7 @@ CanvasParser::parse_bline_point(xmlpp::Element *element,Canvas::Handle canvas)
 				continue;
 			}
 
-			ret.set_vertex(parse_vector(dynamic_cast<xmlpp::Element*>(*iter),canvas));
+			ret.set_vertex(parse_vector(dynamic_cast<xmlpp::Element*>(*iter)));
 		}
 		else
 		// Tangent 1
@@ -692,7 +720,7 @@ CanvasParser::parse_bline_point(xmlpp::Element *element,Canvas::Handle canvas)
 				continue;
 			}
 
-			ret.set_tangent1(parse_vector(dynamic_cast<xmlpp::Element*>(*iter),canvas));
+			ret.set_tangent1(parse_vector(dynamic_cast<xmlpp::Element*>(*iter)));
 		}
 		else
 		// Tangent 2
@@ -717,7 +745,7 @@ CanvasParser::parse_bline_point(xmlpp::Element *element,Canvas::Handle canvas)
 				continue;
 			}
 
-			ret.set_tangent2(parse_vector(dynamic_cast<xmlpp::Element*>(*iter),canvas));
+			ret.set_tangent2(parse_vector(dynamic_cast<xmlpp::Element*>(*iter)));
 			ret.set_split_tangent_flag(true);
 		}
 		else
@@ -743,7 +771,7 @@ CanvasParser::parse_bline_point(xmlpp::Element *element,Canvas::Handle canvas)
 				continue;
 			}
 
-			ret.set_width(parse_real(dynamic_cast<xmlpp::Element*>(*iter),canvas));
+			ret.set_width(parse_real(dynamic_cast<xmlpp::Element*>(*iter)));
 		}
 		else
 		// origin
@@ -768,7 +796,7 @@ CanvasParser::parse_bline_point(xmlpp::Element *element,Canvas::Handle canvas)
 				continue;
 			}
 
-			ret.set_origin(parse_real(dynamic_cast<xmlpp::Element*>(*iter),canvas));
+			ret.set_origin(parse_real(dynamic_cast<xmlpp::Element*>(*iter)));
 		}
 		else
 			error_unexpected_element(child,child->get_name());
@@ -777,7 +805,7 @@ CanvasParser::parse_bline_point(xmlpp::Element *element,Canvas::Handle canvas)
 }
 
 Angle
-CanvasParser::parse_angle(xmlpp::Element *element,Canvas::Handle canvas)
+CanvasParser::parse_angle(xmlpp::Element *element)
 {
 	assert(element->get_name()=="angle");
 
@@ -799,51 +827,48 @@ ValueBase
 CanvasParser::parse_value(xmlpp::Element *element,Canvas::Handle canvas)
 {
 	if(element->get_name()=="real")
-		return parse_real(element,canvas);
+		return parse_real(element);
 	else
 	if(element->get_name()=="time")
 		return parse_time(element,canvas);
 	else
 	if(element->get_name()=="integer")
-		return parse_integer(element,canvas);
+		return parse_integer(element);
 	else
 	if(element->get_name()=="string")
-		return parse_string(element,canvas);
+		return parse_string(element);
 	else
 	if(element->get_name()=="vector")
-	{
-		return parse_vector(element,canvas);
-	}
+		return parse_vector(element);
 	else
 	if(element->get_name()=="color")
-		return parse_color(element,canvas);
+		return parse_color(element);
 	else
 	if(element->get_name()=="segment")
-		return parse_segment(element,canvas);
+		return parse_segment(element);
 	else
 	if(element->get_name()=="list")
 		return parse_list(element,canvas);
 	else
 	if(element->get_name()=="gradient")
-		return parse_gradient(element,canvas);
+		return parse_gradient(element);
 	else
 	if(element->get_name()=="bool")
-		return parse_bool(element,canvas);
+		return parse_bool(element);
 	else
 	//if(element->get_name()=="canvas")
 	//	return parse_canvas(element,canvas,true);	// inline canvas
 	//else
 	if(element->get_name()=="angle" || element->get_name()=="degrees" || element->get_name()=="radians" || element->get_name()=="rotations")
-		return parse_angle(element,canvas);
+		return parse_angle(element);
 	else
 	if(element->get_name()=="bline_point")
-		return parse_bline_point(element,canvas);
+		return parse_bline_point(element);
 	else
 	if(element->get_name()=="canvas")
 		return ValueBase(parse_canvas(element,canvas,true));
 	else
 	{
-		DEBUGPOINT();
 		error_unexpected_element(element,element->get_name());
 	}
 
@@ -876,7 +901,7 @@ CanvasParser::parse_animated(xmlpp::Element *element,Canvas::Handle canvas)
 
 	if(!value_node)
 	{
-		error(element,strprintf(_("Unable to create <animated> with type \"%s\""),ValueBase::type_name(type).c_str()));
+		error(element,strprintf(_("Unable to create <animated> with type \"%s\""),ValueBase::type_local_name(type).c_str()));
 		return ValueNode_Animated::Handle();
 	}
 
@@ -914,7 +939,11 @@ CanvasParser::parse_animated(xmlpp::Element *element,Canvas::Handle canvas)
 				//        <waypoint time="0s" use="mycanvas"/>
 				//      </animated>
 				if (type==ValueBase::TYPE_CANVAS)
-					waypoint_value_node=ValueNode_Const::create(canvas->surefind_canvas(child->get_attribute("use")->get_value()));
+				{
+					String warnings;
+					waypoint_value_node=ValueNode_Const::create(canvas->surefind_canvas(child->get_attribute("use")->get_value(), warnings));
+					warnings_text += warnings;
+				}
 				else
 					waypoint_value_node=canvas->surefind_value_node(child->get_attribute("use")->get_value());
 			}
@@ -981,7 +1010,7 @@ CanvasParser::parse_animated(xmlpp::Element *element,Canvas::Handle canvas)
 			if(child->get_attribute("temporal-tension"))
 			{
 				synfig::String str(child->get_attribute("temporal-tension")->get_value());
-				waypoint->set_time_tension(atof(str.c_str()));
+				waypoint->set_temporal_tension(atof(str.c_str()));
 			}
 			if(child->get_attribute("continuity"))
 			{
@@ -1038,390 +1067,177 @@ CanvasParser::parse_animated(xmlpp::Element *element,Canvas::Handle canvas)
 		else
 			error_unexpected_element(child,child->get_name());
 	}
-	value_node->changed();
-	return value_node;
-}
-
-handle<ValueNode_Subtract>
-CanvasParser::parse_subtract(xmlpp::Element *element,Canvas::Handle canvas)
-{
-	assert(element->get_name()=="subtract");
-
-	handle<ValueNode_Subtract> value_node;
-	handle<ValueNode> lhs,rhs,scalar;
-
-	if(element->get_attribute("type"))
-	{
-		ValueBase::Type type=ValueBase::ident_type(element->get_attribute("type")->get_value());
-
-		if(!type)
-		{
-			error(element,"Bad type in <subtract>");
-			return ValueNode_Subtract::Handle();
-		}
-		value_node=ValueNode_Subtract::create(type);
-	}
-	else
-		value_node=ValueNode_Subtract::create();
-
-	if(!value_node)
-	{
-		error(element,strprintf(_("Unable to create <subtract>")));
-		return handle<ValueNode_Subtract>();
-	}
 
-	//if(element->get_attribute("scalar"))
-	//{
-	//	value_node->set_scalar(atof(element->get_attribute("scalar")->get_value().c_str()));
-	//}
+	// in canvas version 0.1, angles used to wrap, so to get from -179
+	// degrees to 180 degrees meant a 1 degree change
+	// in canvas version 0.2 they don't, so that's a 359 degree change
 
-	try
+	// when loading a version 0.1 canvas, modify constant angle
+	// waypoints to that they are within 180 degrees of the previous
+	// waypoint's value
+	if (type == ValueBase::TYPE_ANGLE)
 	{
-		if(element->get_attribute("scalar"))
-		{
-			// This is for compatibility with older versions of the file format
-			String value(element->get_attribute("scalar")->get_value());
-			if((value[0]<='9' && value[0]>='0')	 || value[0]=='-')
-			{
-				warning(element, _("Use of a real value where the ID should be is deprecated"));
-				value_node->set_scalar(atof(value.c_str()));
-			}
-			else
-				value_node->set_scalar(canvas->surefind_value_node(value));
-			scalar=value_node->get_scalar();
-		}
-
-		if(element->get_attribute("lhs"))
+		if (canvas->get_version() == "0.1")
 		{
-			lhs=canvas->surefind_value_node(element->get_attribute("lhs")->get_value());
-			value_node->set_lhs(lhs);
-		}
-
-		if(element->get_attribute("rhs"))
-		{
-			rhs=canvas->surefind_value_node(element->get_attribute("rhs")->get_value());
-			value_node->set_rhs(rhs);
-		}
-	}
-	catch (Exception::IDNotFound)
-	{
-		error(element,"attribute in <subtract> references unknown ID");
-	}
-	catch (Exception::FileNotFound)
-	{
-		error(element,"Unable to open external file referenced in ID");
-	}
-
-	xmlpp::Element::NodeList list = element->get_children();
-	for(xmlpp::Element::NodeList::iterator iter = list.begin(); iter != list.end(); ++iter)
-	{
-		xmlpp::Element *child(dynamic_cast<xmlpp::Element*>(*iter));
-		if(!child)
-			continue;
-		else
-		if(child->get_name()=="lhs")
-		{
-			if(lhs)
-			{
-				error(child,"LHS component of <subtract> already defined!");
-				continue;
-			}
-
-			xmlpp::Element::NodeList list = child->get_children();
-			xmlpp::Element::NodeList::iterator iter;
-
-			// Search for the first non-text XML element
-			for(iter = list.begin(); iter != list.end(); ++iter)
-				if(dynamic_cast<xmlpp::Element*>(*iter)) break;
-
-			if(iter==list.end())
-			{
-				error(child,_("<lhs> is missing its contents"));
-				continue;
-			}
-
-			lhs=parse_value_node(dynamic_cast<xmlpp::Element*>(*iter),canvas);
-
-			if(lhs)
-				value_node->set_lhs(lhs);
-			else
-			{
-				error((*iter),"Parse of LHS ValueNode failed");
-			}
-
-			// \todo do a search for more elements and warn if they are found
-		}
-		else
-		if(child->get_name()=="rhs")
-		{
-			if(rhs)
-			{
-				error(child,"RHS component of <subtract> already defined!");
-				continue;
-			}
-
-			xmlpp::Element::NodeList list = child->get_children();
-			xmlpp::Element::NodeList::iterator iter;
-
-			// Search for the first non-text XML element
-			for(iter = list.begin(); iter != list.end(); ++iter)
-				if(dynamic_cast<xmlpp::Element*>(*iter)) break;
-
-			if(iter==list.end())
-			{
-				error(child,_("<rhs> is missing its contents"));
-				continue;
-			}
-
-			rhs=parse_value_node(dynamic_cast<xmlpp::Element*>(*iter),canvas);
-
-			if(rhs)
-				value_node->set_rhs(rhs);
-			else
-			{
-				error((*iter),"Parse of RHS ValueNode failed");
-			}
-
-			// \todo do a search for more elements and warn if they are found
-		}
-		else
-		if(child->get_name()=="scalar")
-		{
-			if(scalar)
-			{
-				error(child,"scalar component of <subtract> already defined!");
-				continue;
-			}
-
-			xmlpp::Element::NodeList list = child->get_children();
-			xmlpp::Element::NodeList::iterator iter;
-
-			// Search for the first non-text XML element
-			for(iter = list.begin(); iter != list.end(); ++iter)
-				if(dynamic_cast<xmlpp::Element*>(*iter)) break;
-
-			if(iter==list.end())
-			{
-				error(child,_("<scalar> is missing its contents"));
-				continue;
-			}
-
-			scalar=parse_value_node(dynamic_cast<xmlpp::Element*>(*iter),canvas);
-
-			if(scalar)
-				value_node->set_scalar(scalar);
-			else
-			{
-				error((*iter),"Parse of scalar ValueNode failed");
+			bool first = true;
+			Real angle, prev = 0;
+			WaypointList &wl = value_node->waypoint_list();
+			for (WaypointList::iterator iter = wl.begin(); iter != wl.end(); iter++)
+			{
+				angle = Angle::deg(iter->get_value(iter->get_time()).get(Angle())).get();
+				if (first)
+					first = false;
+				else if (iter->get_value_node()->get_name() == "constant")
+				{
+					if (angle - prev > 180)
+					{
+						while (angle - prev > 180) angle -= 360;
+						iter->set_value(Angle::deg(angle));
+					}
+					else if (prev - angle > 180)
+					{
+						while (prev - angle > 180) angle += 360;
+						iter->set_value(Angle::deg(angle));
+					}
+				}
+				prev = angle;
 			}
-
-			// \todo do a search for more elements and warn if they are found
 		}
-		else
-			error_unexpected_element(child,child->get_name());
 	}
 
-	if(!value_node->get_rhs() || !value_node->get_lhs() || !value_node->get_scalar())
-		error(element,"<subtract> is missing LHS, RHS, or SCALAR");
-
-	if(value_node->get_rhs() == value_node->get_lhs())
-		warning(element,"LHS is equal to RHS in <subtract>, so this value_node will always be zero!");
-
+	value_node->changed();
 	return value_node;
 }
 
 etl::handle<LinkableValueNode>
 CanvasParser::parse_linkable_value_node(xmlpp::Element *element,Canvas::Handle canvas)
 {
-	handle<LinkableValueNode> value_node;
-	ValueBase::Type type;
-
 	// Determine the type
-	if(element->get_attribute("type"))
+	if(!element->get_attribute("type"))
 	{
-		type=ValueBase::ident_type(element->get_attribute("type")->get_value());
-
-		if(!type)
-		{
-			error(element,"Bad type in ValueNode");
-			return 0;
-		}
+		error(element, strprintf(_("Missing attribute \"type\" in <%s>"), element->get_name().c_str()));
+		return 0;
 	}
-	else
+
+	ValueBase::Type type=ValueBase::ident_type(element->get_attribute("type")->get_value());
+
+	if(!type)
 	{
-		error(element,"Missing type in ValueNode");
+		error(element, strprintf(_("Bad type in <%s>"), element->get_name().c_str()));
 		return 0;
 	}
 
-	value_node=LinkableValueNode::create(element->get_name(),type);
+	handle<LinkableValueNode> value_node=LinkableValueNode::create(element->get_name(),type);
+ 	handle<ValueNode> c[value_node->link_count()];
 
 	if(!value_node)
 	{
-		error(element,"Unknown ValueNode type "+element->get_name());
+		error(element, strprintf(_("Error creating ValueNode <%s> with type '%s'.  Refer to '%s'"),
+								 element->get_name().c_str(),
+								 ValueBase::type_local_name(type).c_str(),
+								 VALUENODE_COMPATIBILITY_URL));
 		return 0;
 	}
 
 	if(value_node->get_type()!=type)
 	{
-		error(element,"ValueNode did not accept type");
+		error(element, strprintf(_("<%s> did not accept type '%s'"),
+								 element->get_name().c_str(),
+								 ValueBase::type_local_name(type).c_str()));
 		return 0;
 	}
 
 	value_node->set_root_canvas(canvas->get_root());
 
-	int i;
-	for(i=0;i<value_node->link_count();i++)
+	// handle exported valuenodes
 	{
-		if(element->get_attribute(value_node->link_name(i)))
-		try {
-			String id(element->get_attribute(value_node->link_name(i))->get_value());
-
-			if(!value_node->set_link(i,
-					canvas->surefind_value_node(
-						id
-					)
-				)
-			) error(element,strprintf(_("Unable to set link \"%s\" to ValueNode \"%s\" (link #%d in \"%s\")"),value_node->link_name(i).c_str(),id.c_str(),i,value_node->get_name().c_str()));
-		}
-		catch(Exception::IDNotFound)
+		int index;
+		String id, name;
+		xmlpp::Element::AttributeList attrib_list(element->get_attributes());
+		for(xmlpp::Element::AttributeList::iterator iter = attrib_list.begin(); iter != attrib_list.end(); iter++)
 		{
-			error(element,"Unable to resolve "+element->get_attribute(value_node->link_name(i))->get_value());
-		}
-		catch(Exception::FileNotFound)
-		{
-			error(element,"Unable to open file referenced in "+element->get_attribute(value_node->link_name(i))->get_value());
-		}
-		catch(...)
-		{
-			error(element,strprintf(_("Unknown Exception thrown when referencing ValueNode \"%s\""),
-				element->get_attribute(value_node->link_name(i))->get_value().c_str()));
-			throw;
-		}
-	}
+			name = (*iter)->get_name();
+			id = (*iter)->get_value();
 
+			if (name == "guid" || name == "id" || name == "type")
+				continue;
 
+			try {
+				index = value_node->get_link_index_from_name(name);
 
-	xmlpp::Element::NodeList list = element->get_children();
-	for(xmlpp::Element::NodeList::iterator iter = list.begin(); iter != list.end(); ++iter)
-	{
-		xmlpp::Element *child(dynamic_cast<xmlpp::Element*>(*iter));
-		try
-		{
-			if(!child)
-				continue;
-			int index=value_node->get_link_index_from_name(child->get_name());
+				if(c[index])
+				{
+					error(element,strprintf(_("'%s' was already defined in <%s>"),
+											name.c_str(),
+											element->get_name().c_str()));
+					continue;
+				}
 
-			xmlpp::Element::NodeList list = child->get_children();
-			xmlpp::Element::NodeList::iterator iter;
+				c[index] = canvas->surefind_value_node(id);
 
-			// Search for the first non-text XML element
-			for(iter = list.begin(); iter != list.end(); ++iter)
-				if(dynamic_cast<xmlpp::Element*>(*iter)) break;
+				if (!c[index])
+				{
+					error(element, strprintf(_("'%s' attribute in <%s> references unknown ID '%s'"),
+											 name.c_str(),
+											 element->get_name().c_str(),
+											 id.c_str()));
+					continue;
+				}
 
-			if(iter==list.end())
+				if(!value_node->set_link(index, c[index]))
+				{
+					error(element, strprintf(_("Unable to set link '\"%s\" to ValueNode \"%s\" (link #%d in \"%s\")"),
+											 value_node->link_name(index).c_str(),
+											 id.c_str(),
+											 index,
+											 element->get_name().c_str()));
+					continue;
+				}
+
+				// printf("  <%s> set link %d (%s) using exported value\n", element->get_name().c_str(), index, name.c_str());
+			}
+			catch (Exception::BadLinkName)
 			{
-				error(child,_("element is missing its contents"));
-				continue;
+				warning(element, strprintf("Bad link name '%s'", name.c_str()));
 			}
-
-			ValueNode::Handle link=parse_value_node(dynamic_cast<xmlpp::Element*>(*iter),canvas);
-
-			if(!link)
+			catch(Exception::IDNotFound)
 			{
-				error((*iter),"Parse of ValueNode failed");
+				error(element,"Unable to resolve " + id);
 			}
-			else
-			if(!value_node->set_link(index,link))
+			catch(Exception::FileNotFound)
 			{
-				//error(dynamic_cast<xmlpp::Element*>(*iter),strprintf("Unable to connect value node ('%s' of type '%s') to link %d",link->get_name().c_str(),ValueBase::type_name(link->get_type()).c_str(),index));
-				error(element,strprintf("Unable to connect value node ('%s' of type '%s') to link %d",link->get_name().c_str(),ValueBase::type_name(link->get_type()).c_str(),index));
+				error(element,"Unable to open file referenced in " + id);
 			}
-
-			// \todo do a search for more elements and warn if they are found
-
-		}
-		catch(Exception::BadLinkName)
-		{
-			error_unexpected_element(child,child->get_name());
-		}
-		catch(...)
-		{
-			error(child,strprintf(_("Unknown Exception thrown when working on element \"%s\""),child->get_name().c_str()));
-			throw;
-		}
-	}
-
-	return value_node;
-}
-
-handle<ValueNode_Composite>
-CanvasParser::parse_composite(xmlpp::Element *element,Canvas::Handle canvas)
-{
-	assert(element->get_name()=="composite");
-
-	if(!element->get_attribute("type"))
-	{
-		error(element,"Missing attribute \"type\" in <composite>");
-		return handle<ValueNode_Composite>();
-	}
-
-	ValueBase::Type type=ValueBase::ident_type(element->get_attribute("type")->get_value());
-
-	if(!type)
-	{
-		error(element,"Bad type in <composite>");
-		return handle<ValueNode_Composite>();
-	}
-
-	handle<ValueNode_Composite> value_node=ValueNode_Composite::create(type);
-	handle<ValueNode> c[6];
-
-	if(!value_node)
-	{
-		error(element,strprintf(_("Unable to create <composite>")));
-		return handle<ValueNode_Composite>();
-	}
-
-	int i;
-
-	for(i=0;i<value_node->link_count();i++)
-	{
-		string name=strprintf("c%d",i+1);
-		if(c[i])
-		{
-			error(element,name+" was already defined in <composite>");
-			continue;
-		}
-		if(element->get_attribute(name))
-		{
-			c[i]=canvas->surefind_value_node(element->get_attribute(name)->get_value());
-			if(c[i])
+			catch(...)
 			{
-				if(!value_node->set_link(i,c[i]))
-				{
-					error(element,'"'+name+"\" attribute in <composite> has bad type");
-				}
+				error(element,strprintf(_("Unknown Exception thrown when referencing ValueNode \"%s\""), id.c_str()));
+				throw;
 			}
-			else
-				error(element,'"'+name+"\" attribute in <composite> references unknown ID");
 		}
 	}
 
-	xmlpp::Element::NodeList list = element->get_children();
-	for(xmlpp::Element::NodeList::iterator iter = list.begin(); iter != list.end(); ++iter)
+	// handle inline valuenodes
 	{
-		xmlpp::Element *child(dynamic_cast<xmlpp::Element*>(*iter));
-		if(!child)
-			continue;
-		else
-		for(i=0;i<value_node->link_count();i++)
+		int index;
+		String child_name;
+		xmlpp::Element::NodeList list = element->get_children();
+		for(xmlpp::Element::NodeList::iterator iter = list.begin(); iter != list.end(); ++iter)
 		{
-			string name=strprintf("c%d",i+1);
-			if(child->get_name()==name)
+			xmlpp::Element *child(dynamic_cast<xmlpp::Element*>(*iter));
+			try
 			{
-				if(c[i])
+				if(!child)
+					continue;
+
+				child_name = child->get_name();
+
+				index = value_node->get_link_index_from_name(child_name);
+
+				if(c[index])
 				{
-					error(child,name+" was already defined in <composite>");
+					error(child, strprintf(_("'%s' was already defined in <%s>"),
+										   child_name.c_str(),
+										   element->get_name().c_str()));
 					break;
 				}
 
@@ -1434,63 +1250,101 @@ CanvasParser::parse_composite(xmlpp::Element *element,Canvas::Handle canvas)
 
 				if(iter==list.end())
 				{
-					error(child,strprintf(_("<%s> is missing its contents"),name.c_str()));
-					break;
+					error(child,strprintf(_("element <%s> is missing its contents"),
+										  child_name.c_str()));
+					continue;
 				}
 
-				c[i]=parse_value_node(dynamic_cast<xmlpp::Element*>(*iter),canvas);
+				c[index]=parse_value_node(dynamic_cast<xmlpp::Element*>(*iter),canvas);
 
-				if(!c[i])
+				if(!c[index])
 				{
-					error((*iter),"Parse of "+name+" ValueNode failed");
-					break;
+					error((*iter),strprintf(_("Parse of '%s' failed"),
+											child_name.c_str()));
+					continue;
 				}
 
-				if(!value_node->set_link(i,c[i]))
+				if(!value_node->set_link(index,c[index]))
 				{
-					error(child,strprintf(_("<%s> has a bad value"),name.c_str()));
-					break;
+					error(child,strprintf(_("Unable to connect value node ('%s' of type '%s') to link %d (%s)"),
+										  c[index]->get_name().c_str(),
+										  ValueBase::type_local_name(c[index]->get_type()).c_str(),
+										  index,
+										  value_node->link_name(index).c_str()));
+					continue;
 				}
 
 				// \todo do a search for more elements and warn if they are found
-				break;
+
+				// printf("  <%s> set link %d (%s) using inline value\n", element->get_name().c_str(), index, child_name.c_str());
+			}
+			catch(Exception::BadLinkName)
+			{
+				warning(child, strprintf("Bad link name for <%s>", element->get_name().c_str()));
+			}
+			catch(...)
+			{
+				error(child, strprintf(_("Unknown Exception thrown when working on element \"%s\""),child_name.c_str()));
+				throw;
 			}
 		}
-		// somewhat of a hack, but it works
-		if(i==value_node->link_count()) error_unexpected_element(child,child->get_name());
 	}
 
-	switch(value_node->link_count())
+	String version(canvas->get_version());
+	for (int i = 0; i < value_node->link_count(); i++)
 	{
-	case 1:
-		if(!value_node->get_link(0))
-		{
-			error(element,"<composite> is missing parameters");
-			return handle<ValueNode_Composite>();
-		}
-		break;
-	case 2:
-		if(!value_node->get_link(0) ||!value_node->get_link(1))
-		{
-			error(element,"<composite> is missing parameters");
-			return handle<ValueNode_Composite>();
-		}
-		break;
-	case 3:
-		if(!value_node->get_link(0) ||!value_node->get_link(1) ||!value_node->get_link(2))
+		if (!c[i])
 		{
-			error(element,"<composite> is missing parameters");
-			return handle<ValueNode_Composite>();
+			// the 'width' parameter of <stripes> wasn't always present in version 0.1 canvases
+			if (version == "0.1" && element->get_name() == "stripes" && value_node->link_name(i) == "width")
+				continue;
+
+			// these 3 blinecalctangent parameters didn't appear until canvas version 0.5
+			if ((version == "0.1" || version == "0.2" || version == "0.3" || version == "0.4") &&
+				element->get_name() == "blinecalctangent" &&
+				(value_node->link_name(i) == "offset" ||
+				 value_node->link_name(i) == "scale" ||
+				 value_node->link_name(i) == "fixed_length"))
+				continue;
+
+			// 'scale' was added while canvas version 0.5 was in use
+			if ((version == "0.3" || version == "0.4" || version == "0.5") &&
+				element->get_name() == "blinecalcwidth" &&
+				value_node->link_name(i) == "scale")
+				continue;
+
+			// 'loop' was added while canvas version 0.5 was in use, as was the 'gradientcolor' node type
+			if (version == "0.5" &&
+				element->get_name() == "gradientcolor" &&
+				value_node->link_name(i) == "loop")
+				continue;
+
+			// 'loop' was added while canvas version 0.6 was in use; the 'random' node was added back when 0.1 was in use
+			if ((version == "0.1" || version == "0.2" || version == "0.3" || version == "0.4" || version == "0.5" || version == "0.6") &&
+				element->get_name() == "random" &&
+				value_node->link_name(i) == "loop")
+				continue;
+
+			error(element, strprintf(_("<%s> is missing link %d (%s)"),
+									 element->get_name().c_str(),
+									 i,
+									 value_node->link_name(i).c_str()));
+ 			return 0;
 		}
-		break;
-	case 4:
-		if(!value_node->get_link(0) ||!value_node->get_link(1) ||!value_node->get_link(2) ||!value_node->get_link(3))
+	}
+
+	// pre 0.4 canvases had *calctangent outputs scaled down by 0.5 for some reason
+	if (element->get_name() == "blinecalctangent" || element->get_name() == "segcalctangent")
+	{
+		if (version == "0.1" || version == "0.2" || version == "0.3")
 		{
-			error(element,"<composite> is missing parameters");
-			return handle<ValueNode_Composite>();
+			handle<LinkableValueNode> scale_value_node=LinkableValueNode::create("scale",type);
+			scale_value_node->set_link(scale_value_node->get_link_index_from_name("link"), value_node);
+			scale_value_node->set_link(scale_value_node->get_link_index_from_name("scalar"), ValueNode_Const::create(Real(0.5)));
+			value_node = scale_value_node;
 		}
-		break;
-    }
+	}
+
 	return value_node;
 }
 
@@ -1725,7 +1579,7 @@ CanvasParser::parse_value_node(xmlpp::Element *element,Canvas::Handle canvas)
 			return value_node;
 	}
 
-	// If ValueBase::ident_type() recognises the name, then we know it's a ValueBase
+	// If ValueBase::ident_type() recognizes the name, then we know it's a ValueBase
 	if(element->get_name()!="canvas" && ValueBase::ident_type(element->get_name()))
 	{
 		ValueBase data=parse_value(element,canvas);
@@ -1747,12 +1601,6 @@ CanvasParser::parse_value_node(xmlpp::Element *element,Canvas::Handle canvas)
 	if(element->get_name()=="hermite" || element->get_name()=="animated")
 		value_node=parse_animated(element,canvas);
 	else
-	if(element->get_name()=="subtract")
-		value_node=parse_subtract(element,canvas);
-	else
-	if(element->get_name()=="composite")
-		value_node=parse_composite(element,canvas);
-	else
 	if(element->get_name()=="dynamic_list")
 		value_node=parse_dynamic_list(element,canvas);
 	else
@@ -1760,20 +1608,23 @@ CanvasParser::parse_value_node(xmlpp::Element *element,Canvas::Handle canvas)
 		value_node=parse_dynamic_list(element,canvas);
 	else
 	if(LinkableValueNode::book().count(element->get_name()))
+	{
 		value_node=parse_linkable_value_node(element,canvas);
+		if (!value_node) value_node = PlaceholderValueNode::create();
+	}
 	else
 	if(element->get_name()=="canvas")
 		value_node=ValueNode_Const::create(parse_canvas(element,canvas,true));
 	else
 	{
 		error_unexpected_element(element,element->get_name());
-		error(element, "Expected a ValueNode");
+		error(element, strprintf(_("Expected a ValueNode.  Refer to '%s'"),
+								 VALUENODE_COMPATIBILITY_URL));
+		value_node=PlaceholderValueNode::create();
 	}
 
-
 	value_node->set_root_canvas(canvas->get_root());
 
-
 	// If we were successful, and our element has
 	// an ID attribute, go ahead and add it to the
 	// value_node list
@@ -1852,7 +1703,7 @@ CanvasParser::parse_layer(xmlpp::Element *element,Canvas::Handle canvas)
 	{
 		String version(element->get_attribute("version")->get_value());
 		if(version>layer->get_version())
-			warning(element,_("Installed layer version is larger than layer version in file"));
+			warning(element,_("Installed layer version is smaller than layer version in file"));
 		if(version!=layer->get_version())
 			layer->set_version(version);
 	}
@@ -1889,6 +1740,11 @@ CanvasParser::parse_layer(xmlpp::Element *element,Canvas::Handle canvas)
 
 			String param_name=child->get_attribute("name")->get_value();
 
+			// SVN r2013 and r2014 renamed all 'pos' and 'offset' parameters to 'origin'
+			// 'pos' and 'offset' will appear in old .sif files; handle them correctly
+			if (param_name == "pos" || param_name == "offset")
+				param_name = "origin";
+
 			if(child->get_attribute("use"))
 			{
 				// If the "use" attribute is used, then the
@@ -1899,9 +1755,15 @@ CanvasParser::parse_layer(xmlpp::Element *element,Canvas::Handle canvas)
 
 				String str=	child->get_attribute("use")->get_value();
 
-				if(layer->get_param(param_name).get_type()==ValueBase::TYPE_CANVAS)
+				if (str.empty())
+					error(child,_("Empty use=\"\" value in <param>"));
+				else if(layer->get_param(param_name).get_type()==ValueBase::TYPE_CANVAS)
 				{
-					if(!layer->set_param(param_name,canvas->surefind_canvas(str)))
+					String warnings;
+					Canvas::Handle c(canvas->surefind_canvas(str, warnings));
+					warnings_text += warnings;
+					if(!c) error((*iter),strprintf(_("Failed to load subcanvas '%s'"), str.c_str()));
+					if(!layer->set_param(param_name,c))
 						error((*iter),_("Layer rejected canvas link"));
 				}
 				else
@@ -1910,6 +1772,12 @@ CanvasParser::parse_layer(xmlpp::Element *element,Canvas::Handle canvas)
 					handle<ValueNode> value_node=canvas->surefind_value_node(str);
 
 					// Assign the value_node to the dynamic parameter list
+					if (param_name == "segment_list" && (layer->get_name() == "region" || layer->get_name() == "outline"))
+					{
+						synfig::warning("%s: Updated valuenode connection to use the \"bline\" parameter instead of \"segment_list\".",
+										layer->get_name().c_str());
+						param_name = "bline";
+					}
 					layer->connect_dynamic_param(param_name,value_node);
     			}
 				catch(Exception::IDNotFound)
@@ -1934,7 +1802,7 @@ CanvasParser::parse_layer(xmlpp::Element *element,Canvas::Handle canvas)
 				continue;
 			}
 
-			// If we recognise the element name as a
+			// If we recognize the element name as a
 			// ValueBase, then treat is at one
 			if(/*(*iter)->get_name()!="canvas" && */ValueBase::ident_type((*iter)->get_name()) && !dynamic_cast<xmlpp::Element*>(*iter)->get_attribute("guid"))
 			{
@@ -1950,7 +1818,9 @@ CanvasParser::parse_layer(xmlpp::Element *element,Canvas::Handle canvas)
 				// the layer liked it
 				if(!layer->set_param(param_name,data))
 				{
-					warning((*iter),_("Layer rejected value for <param>"));
+					warning((*iter),strprintf(_("Layer '%s' rejected value for parameter '%s'"),
+											  element->get_attribute("type")->get_value().c_str(),
+											  param_name.c_str()));
 					continue;
 				}
 			}
@@ -2005,7 +1875,9 @@ CanvasParser::parse_canvas(xmlpp::Element *element,Canvas::Handle parent,bool in
 		{
 			try
 			{
-				canvas=parent->find_canvas(element->get_attribute("id")->get_value());
+				String warnings;
+				canvas=parent->find_canvas(element->get_attribute("id")->get_value(), warnings);
+				warnings_text += warnings;
 			}
 			catch(...)
 			{
@@ -2033,11 +1905,26 @@ CanvasParser::parse_canvas(xmlpp::Element *element,Canvas::Handle parent,bool in
 			canvas->set_guid(guid);
 	}
 
+	if(element->get_attribute("version"))
+		canvas->set_version(element->get_attribute("version")->get_value());
+	else if(parent)
+		canvas->set_version(parent->get_version());
+
 	if(element->get_attribute("width"))
-		canvas->rend_desc().set_w(atoi(element->get_attribute("width")->get_value().c_str()));
+	{
+		int width = atoi(element->get_attribute("width")->get_value().c_str());
+		if (width < 1)
+			fatal_error(element, _("Canvas with width or height less than one is not allowed"));
+		canvas->rend_desc().set_w(width);
+	}
 
 	if(element->get_attribute("height"))
-		canvas->rend_desc().set_h(atoi(element->get_attribute("height")->get_value().c_str()));
+	{
+		int height = atoi(element->get_attribute("height")->get_value().c_str());
+		if (height < 1)
+			fatal_error(element, _("Canvas with width or height less than one is not allowed"));
+		canvas->rend_desc().set_h(height);
+	}
 
 	if(element->get_attribute("xres"))
 		canvas->rend_desc().set_x_res(atof(element->get_attribute("xres")->get_value().c_str()));
@@ -2167,7 +2054,7 @@ CanvasParser::parse_canvas(xmlpp::Element *element,Canvas::Handle parent,bool in
 
 				// If we don't have any name, warn
 				if(list.empty())
-					warning(child,_("blank \"name\" entitity"));
+					warning(child,_("blank \"name\" entity"));
 
 				string tmp;
 				for(xmlpp::Element::NodeList::iterator iter = list.begin(); iter != list.end(); ++iter)
@@ -2182,7 +2069,7 @@ CanvasParser::parse_canvas(xmlpp::Element *element,Canvas::Handle parent,bool in
 
 				// If we don't have any description, warn
 				if(list.empty())
-					warning(child,_("blank \"desc\" entitity"));
+					warning(child,_("blank \"desc\" entity"));
 
 				string tmp;
 				for(xmlpp::Element::NodeList::iterator iter = list.begin(); iter != list.end(); ++iter)
@@ -2197,7 +2084,7 @@ CanvasParser::parse_canvas(xmlpp::Element *element,Canvas::Handle parent,bool in
 
 				// If we don't have any description, warn
 				if(list.empty())
-					warning(child,_("blank \"author\" entitity"));
+					warning(child,_("blank \"author\" entity"));
 
 				string tmp;
 				for(xmlpp::Element::NodeList::iterator iter = list.begin(); iter != list.end(); ++iter)
@@ -2222,28 +2109,58 @@ CanvasParser::parse_canvas(xmlpp::Element *element,Canvas::Handle parent,bool in
 
 	if(canvas->value_node_list().placeholder_count())
 	{
-		error(element,strprintf(_("Canvas %s has undefined ValueNodes"),canvas->get_id().c_str()));
+		String nodes;
+		for (ValueNodeList::const_iterator iter = canvas->value_node_list().begin(); iter != canvas->value_node_list().end(); iter++)
+			if(PlaceholderValueNode::Handle::cast_dynamic(*iter))
+			{
+				if (nodes != "") nodes += ", ";
+				nodes += "'" + (*iter)->get_id() + "'";
+			}
+		error(element,strprintf(_("Canvas '%s' has undefined %s: %s"),
+								canvas->get_id().c_str(),
+								canvas->value_node_list().placeholder_count() == 1 ? _("ValueNode") : _("ValueNodes"),
+								nodes.c_str()));
 	}
 
+	canvas->set_version(CURRENT_CANVAS_VERSION);
 	return canvas;
 }
 
-Canvas::Handle
-CanvasParser::parse_from_file(const String &file)
+void
+CanvasParser::register_canvas_in_map(Canvas::Handle canvas, String as)
 {
-	return parse_from_file_as(file,file);
+	get_open_canvas_map()[etl::absolute_path(as)]=canvas;
+	canvas->signal_deleted().connect(sigc::bind(sigc::ptr_fun(_remove_from_open_canvas_map),canvas.get()));
+	canvas->signal_file_name_changed().connect(sigc::bind(sigc::ptr_fun(_canvas_file_name_changed),canvas.get()));
+}
+
+#ifdef _DEBUG
+void
+CanvasParser::show_canvas_map(String file, int line, String text)
+{
+	return;
+	printf("  .-----\n  |  %s:%d %s\n", file.c_str(), line, text.c_str());
+	std::map<synfig::String, etl::loose_handle<Canvas> > canvas_map(synfig::get_open_canvas_map());
+	std::map<synfig::String, etl::loose_handle<Canvas> >::iterator iter;
+	for (iter = canvas_map.begin(); iter != canvas_map.end(); iter++)
+	{
+		synfig::String first(iter->first);
+		etl::loose_handle<Canvas> second(iter->second);
+		printf("  |    %40s : %lx (%d)\n", first.c_str(), ulong(&*second), second->count());
+	}
+	printf("  `-----\n\n");
 }
+#endif	// _DEBUG
 
 Canvas::Handle
-CanvasParser::parse_from_file_as(const String &file_,const String &as_)
+CanvasParser::parse_from_file_as(const String &file_,const String &as_,String &errors)
 {
-	CHECK_EXPIRE_TIME();
+	ChangeLocale change_locale(LC_NUMERIC, "C");
+	String file(unix_to_local_path(file_));
+	String as(unix_to_local_path(as_));
+
 	try
 	{
-        ChangeLocale change_locale(LC_NUMERIC, "C");
-		String file(unix_to_local_path(file_));
-		String as(unix_to_local_path(as_));
-
 		if(get_open_canvas_map().count(etl::absolute_path(as)))
 			return get_open_canvas_map()[etl::absolute_path(as)];
 
@@ -2253,11 +2170,8 @@ CanvasParser::parse_from_file_as(const String &file_,const String &as_)
 		if(parser)
 		{
 			Canvas::Handle canvas(parse_canvas(parser.get_document()->get_root_node(),0,false,as));
-			get_open_canvas_map()[etl::absolute_path(as)]=canvas;
-			canvas->signal_deleted().connect(sigc::bind(sigc::ptr_fun(_remove_from_open_canvas_map),canvas.get()));
-			canvas->signal_file_name_changed().connect(sigc::bind(sigc::ptr_fun(_canvas_file_name_changed),canvas.get()));
-
-
+			if (!canvas) return canvas;
+			register_canvas_in_map(canvas, as);
 
 			const ValueNodeList& value_node_list(canvas->value_node_list());
 
@@ -2281,69 +2195,23 @@ CanvasParser::parse_from_file_as(const String &file_,const String &as_)
 	catch(Exception::FileNotFound) { synfig::error("FileNotFound Thrown"); }
 	catch(Exception::IDNotFound) { synfig::error("IDNotFound Thrown"); }
 	catch(Exception::IDAlreadyExists) { synfig::error("IDAlreadyExists Thrown"); }
-	catch(const std::exception& ex)
-	{
-		synfig::error("Standard Exception: "+String(ex.what()));
-		return Canvas::Handle();
-	}
-	catch(const String& str)
+	catch(xmlpp::internal_error x)
 	{
-		cerr<<str<<endl;
-		//	synfig::error(str);
-		return Canvas::Handle();
-	}
-	return Canvas::Handle();
-}
-
-Canvas::Handle
-CanvasParser::parse_from_string(const String &data)
-{
-	CHECK_EXPIRE_TIME();
-
-	try
-	{
-        ChangeLocale change_locale(LC_NUMERIC, "C");
-		filename=_("<INTERNAL>");
-		total_warnings_=0;
-		xmlpp::DomParser parser;
-		parser.parse_memory(data);
-		xmlpp::Element *root=parser.get_document()->get_root_node();
-		if(parser)
-		{
-			Canvas::Handle canvas(parse_canvas(root));
-			canvas->signal_deleted().connect(sigc::bind(sigc::ptr_fun(_remove_from_open_canvas_map),canvas.get()));
-			canvas->signal_file_name_changed().connect(sigc::bind(sigc::ptr_fun(_canvas_file_name_changed),canvas.get()));
-
-			const ValueNodeList& value_node_list(canvas->value_node_list());
-			again:
-			ValueNodeList::const_iterator iter;
-			for(iter=value_node_list.begin();iter!=value_node_list.end();++iter)
-			{
-				ValueNode::Handle value_node(*iter);
-				if(value_node->is_exported() && value_node->get_id().find("Unnamed")==0)
-				{
-					canvas->remove_value_node(value_node);
-					goto again;
-				}
-			}
-
-			return canvas;
-		}
+		if (!strcmp(x.what(), "Couldn't create parsing context"))
+			throw runtime_error(String("  * ") + _("Can't open file") + " \"" + file + "\"");
+		throw;
 	}
-	catch(Exception::BadLinkName) { synfig::error("BadLinkName Thrown"); }
-	catch(Exception::BadType) { synfig::error("BadType Thrown"); }
-	catch(Exception::FileNotFound) { synfig::error("FileNotFound Thrown"); }
-	catch(Exception::IDNotFound) { synfig::error("IDNotFound Thrown"); }
-	catch(Exception::IDAlreadyExists) { synfig::error("IDAlreadyExists Thrown"); }
 	catch(const std::exception& ex)
 	{
 		synfig::error("Standard Exception: "+String(ex.what()));
+		errors = ex.what();
 		return Canvas::Handle();
 	}
 	catch(const String& str)
 	{
 		cerr<<str<<endl;
 		//	synfig::error(str);
+		errors = str;
 		return Canvas::Handle();
 	}
 	return Canvas::Handle();