synfig-core/trunk/src/synfig/loadcanvas.cpp

   1 /* === S Y N F I G ========================================================= */
   2 /*!     \file loadcanvas.cpp
   3 **      \brief writeme
   4 **
   5 **      $Id$
   6 **
   7 **      \legal
   8 **      Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
   9 **      Copyright (c) 2007, 2008 Chris Moore
  10 **
  11 **      This package is free software; you can redistribute it and/or
  12 **      modify it under the terms of the GNU General Public License as
  13 **      published by the Free Software Foundation; either version 2 of
  14 **      the License, or (at your option) any later version.
  15 **
  16 **      This package is distributed in the hope that it will be useful,
  17 **      but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 **      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  19 **      General Public License for more details.
  20 **      \endlegal
  21 */
  22 /* ========================================================================= */
  23
  24 /* === H E A D E R S ======================================================= */
  25
  26 #ifdef USING_PCH
  27 #       include "pch.h"
  28 #else
  29 #ifdef HAVE_CONFIG_H
  30 #       include <config.h>
  31 #endif
  32
  33 #include <cstdlib>
  34 #include <cstdio>
  35 #include <cstring>
  36 #include <ETL/stringf>
  37 #include <libxml++/libxml++.h>
  38 #include <vector>
  39 #include <stdexcept>
  40 #include <iostream>
  41
  42 #include "loadcanvas.h"
  43 #include "valuenode.h"
  44 #include "valuenode_subtract.h"
  45 #include "valuenode_animated.h"
  46 #include "valuenode_composite.h"
  47 #include "valuenode_const.h"
  48 #include "valuenode_linear.h"
  49 #include "valuenode_dynamiclist.h"
  50 #include "valuenode_reference.h"
  51 #include "valuenode_scale.h"
  52 #include "valuenode_timedswap.h"
  53 #include "valuenode_twotone.h"
  54 #include "valuenode_stripes.h"
  55 #include "valuenode_segcalctangent.h"
  56 #include "valuenode_segcalcvertex.h"
  57 #include "valuenode_bline.h"
  58
  59 #include "layer.h"
  60 #include "string.h"
  61
  62 #include "exception.h"
  63
  64 #include "gradient.h"
  65
  66 #include <map>
  67 #include <sigc++/bind.h>
  68
  69 #endif
  70
  71 /* === U S I N G =========================================================== */
  72
  73 using namespace std;
  74 using namespace synfig;
  75 using namespace etl;
  76
  77 /*
  78 class test_class {
  79 static int bleh;
  80 public:
  81         test_class() { assert(!bleh); bleh++; synfig::info("test_class: initi: %d",bleh); }
  82         ~test_class() { assert(bleh); synfig::info("test_class: uninit: %d",bleh); bleh--; }
  83 };
  84 int test_class::bleh(0);
  85
  86 test_class test_class_instance;
  87 */
  88
  89 /* === M A C R O S ========================================================= */
  90
  91 #define VALUENODE_COMPATIBILITY_URL "http://synfig.org/Convert#Compatibility"
  92
  93 inline bool is_whitespace(char x) { return ((x)=='\n' || (x)=='\t' || (x)==' '); }
  94
  95 /* === P R O C E D U R E S ================================================= */
  96
  97 static std::map<String, Canvas::LooseHandle>* open_canvas_map_(0);
  98
  99 std::map<synfig::String, etl::loose_handle<Canvas> >& synfig::get_open_canvas_map()
 100 {
 101         if(!open_canvas_map_)
 102                 open_canvas_map_=new std::map<String, Canvas::LooseHandle>;
 103         return *open_canvas_map_;
 104 }
 105
 106 static void _remove_from_open_canvas_map(Canvas *x) { get_open_canvas_map().erase(etl::absolute_path(x->get_file_name())); }
 107
 108 static void _canvas_file_name_changed(Canvas *x)
 109 {
 110         std::map<synfig::String, etl::loose_handle<Canvas> >::iterator iter;
 111
 112         for(iter=get_open_canvas_map().begin();iter!=get_open_canvas_map().end();++iter)
 113                 if(iter->second==x)
 114                         break;
 115         assert(iter!=get_open_canvas_map().end());
 116         if(iter==get_open_canvas_map().end())
 117                 return;
 118         get_open_canvas_map().erase(iter->first);
 119         get_open_canvas_map()[etl::absolute_path(x->get_file_name())]=x;
 120
 121 }
 122
 123 Canvas::Handle
 124 synfig::open_canvas(const String &filename,String &errors)
 125 {
 126         return open_canvas_as(filename, filename, errors);
 127 }
 128
 129 Canvas::Handle
 130 synfig::open_canvas_as(const String &filename,const String &as,String &errors)
 131 {
 132         CanvasParser parser;
 133
 134         parser.set_allow_errors(true);
 135
 136         Canvas::Handle canvas=parser.parse_from_file_as(filename,as,errors);
 137
 138         if(parser.error_count())
 139         {
 140                 errors = parser.get_errors_text();
 141                 return Canvas::Handle();
 142         }
 143
 144         return canvas;
 145 }
 146
 147 /* === M E T H O D S ======================================================= */
 148
 149 void
 150 CanvasParser::error_unexpected_element(xmlpp::Node *element,const String &got, const String &expected)
 151 {
 152         error(element,strprintf(_("Unexpected element <%s>, Expected <%s>"),got.c_str(),expected.c_str()));
 153 }
 154
 155 void
 156 CanvasParser::error_unexpected_element(xmlpp::Node *element,const String &got)
 157 {
 158         error(element,strprintf(_("Unexpected element <%s>"),got.c_str()));
 159 }
 160
 161 void
 162 CanvasParser::warning(xmlpp::Node *element, const String &text)
 163 {
 164         string str=strprintf("%s:<%s>:%d: warning: ",filename.c_str(),element->get_name().c_str(),element->get_line())+text;
 165         //synfig::warning(str);
 166         cerr<<str<<endl;
 167         total_warnings_++;
 168         if(total_warnings_>=max_warnings_)
 169                 fatal_error(element, _("Too many warnings"));
 170 }
 171
 172 void
 173 CanvasParser::error(xmlpp::Node *element, const String &text)
 174 {
 175         string str=strprintf("%s:<%s>:%d: error: ",filename.c_str(),element->get_name().c_str(),element->get_line())+text;
 176         total_errors_++;
 177         errors_text += "  " + str + "\n";
 178         if(!allow_errors_)
 179                 throw runtime_error(str);
 180         cerr<<str<<endl;
 181         //      synfig::error(str);
 182 }
 183
 184 void
 185 CanvasParser::fatal_error(xmlpp::Node *element, const String &text)
 186 {
 187         string str=strprintf("%s:<%s>:%d:",filename.c_str(),element->get_name().c_str(),element->get_line())+text;
 188         throw runtime_error(str);
 189 }
 190
 191
 192
 193 Keyframe
 194 CanvasParser::parse_keyframe(xmlpp::Element *element,Canvas::Handle canvas)
 195 {
 196         assert(element->get_name()=="keyframe");
 197
 198         if(!element->get_attribute("time"))
 199         {
 200                 error(element,strprintf(_("<%s> is missing \"%s\" attribute"),"real","time"));
 201                 return Keyframe();
 202         }
 203
 204         Keyframe ret(Time(element->get_attribute("time")->get_value(),canvas->rend_desc().get_frame_rate()));
 205
 206
 207         if(element->get_children().empty())
 208                 return ret;
 209
 210         if(element->get_child_text()->get_content().empty())
 211                 return ret;
 212
 213         ret.set_description(element->get_child_text()->get_content());
 214
 215         return ret;
 216 }
 217
 218
 219 Real
 220 CanvasParser::parse_real(xmlpp::Element *element)
 221 {
 222         assert(element->get_name()=="real");
 223
 224         if(!element->get_children().empty())
 225                 warning(element, strprintf(_("<%s> should not contain anything"),"real"));
 226
 227         if(!element->get_attribute("value"))
 228         {
 229                 error(element,strprintf(_("<%s> is missing \"value\" attribute"),"real"));
 230                 return false;
 231         }
 232
 233         string val=element->get_attribute("value")->get_value();
 234
 235         return atof(val.c_str());
 236 }
 237
 238 Time
 239 CanvasParser::parse_time(xmlpp::Element *element,Canvas::Handle canvas)
 240 {
 241         assert(element->get_name()=="time");
 242
 243         if(!element->get_children().empty())
 244                 warning(element, strprintf(_("<%s> should not contain anything"),"time"));
 245
 246         if(!element->get_attribute("value"))
 247         {
 248                 error(element,strprintf(_("<%s> is missing \"value\" attribute"),"time"));
 249                 return false;
 250         }
 251
 252         string val=element->get_attribute("value")->get_value();
 253
 254         return Time(val,canvas->rend_desc().get_frame_rate());
 255 }
 256
 257 int
 258 CanvasParser::parse_integer(xmlpp::Element *element)
 259 {
 260         assert(element->get_name()=="integer");
 261
 262         if(!element->get_children().empty())
 263                 warning(element, strprintf(_("<%s> should not contain anything"),"integer"));
 264
 265         if(!element->get_attribute("value"))
 266         {
 267                 error(element,strprintf(_("<%s> is missing \"value\" attribute"),"integer"));
 268                 return false;
 269         }
 270
 271         string val=element->get_attribute("value")->get_value();
 272
 273         return atoi(val.c_str());
 274 }
 275
 276 // see 'minor hack' at the end of parse_vector() below
 277 // making this 'static' to give it file local scope
 278 // stops it working (where working means working around
 279 // bug #1509627)
 280 Vector &canvas_parser_vector_id(Vector &vector)
 281 {
 282         return vector;
 283 }
 284
 285 Vector
 286 CanvasParser::parse_vector(xmlpp::Element *element)
 287 {
 288         assert(element->get_name()=="vector");
 289
 290         if(element->get_children().empty())
 291         {
 292                 error(element, "Undefined value in <vector>");
 293                 return Vector();
 294         }
 295
 296         Vector vect;
 297
 298         xmlpp::Element::NodeList list = element->get_children();
 299         for(xmlpp::Element::NodeList::iterator iter = list.begin(); iter != list.end(); ++iter)
 300         {
 301                 xmlpp::Element *child=dynamic_cast<xmlpp::Element*>((xmlpp::Node*)*iter);
 302                 if(!child)
 303                         continue;
 304                 else
 305                 if(child->get_name()=="x")
 306                 {
 307                         if(child->get_children().empty())
 308                         {
 309                                 error(element, "Undefined value in <x>");
 310                                 return Vector();
 311                         }
 312                         vect[0]=atof(child->get_child_text()->get_content().c_str());
 313                 }
 314                 else
 315                 if(child->get_name()=="y")
 316                 {
 317                         if(child->get_children().empty())
 318                         {
 319                                 error(element, "Undefined value in <y>");
 320                                 return Vector();
 321                         }
 322                         vect[1]=atof(child->get_child_text()->get_content().c_str());
 323                 }
 324                 else
 325                         error_unexpected_element(child,child->get_name());
 326         }
 327         // Minor hack - gcc 4.1.2 and earlier think that we're not using
 328         // 'vect' and optimize it out at -O2 and higher.  This convinces
 329         // them that we are really using it.
 330         return canvas_parser_vector_id(vect);
 331         // When the bug is fixed, we can just do this instead:
 332         // return vect;
 333 }
 334
 335 Color
 336 CanvasParser::parse_color(xmlpp::Element *element)
 337 {
 338         assert(element->get_name()=="color");
 339
 340         if(element->get_children().empty())
 341         {
 342                 error(element, "Undefined value in <color>");
 343                 return Color();
 344         }
 345
 346         Color color(0);
 347
 348         xmlpp::Element::NodeList list = element->get_children();
 349         for(xmlpp::Element::NodeList::iterator iter = list.begin(); iter != list.end(); ++iter)
 350         {
 351                 xmlpp::Element *child(dynamic_cast<xmlpp::Element*>(*iter));
 352                 if(!child)
 353                         continue;
 354                 else
 355                 if(child->get_name()=="r")
 356                 {
 357                         if(child->get_children().empty())
 358                         {
 359                                 error(element, "Undefined value in <r>");
 360                                 return Color();
 361                         }
 362                         color.set_r(atof(child->get_child_text()->get_content().c_str()));
 363                 }
 364                 else
 365                 if(child->get_name()=="g")
 366                 {
 367                         if(child->get_children().empty())
 368                         {
 369                                 error(element, "Undefined value in <g>");
 370                                 return Color();
 371                         }
 372                         color.set_g(atof(child->get_child_text()->get_content().c_str()));
 373                 }
 374                 else
 375                 if(child->get_name()=="b")
 376                 {
 377                         if(child->get_children().empty())
 378                         {
 379                                 error(element, "Undefined value in <b>");
 380                                 return Color();
 381                         }
 382                         color.set_b(atof(child->get_child_text()->get_content().c_str()));
 383                 }
 384                 else
 385                 if(child->get_name()=="a")
 386                 {
 387                         if(child->get_children().empty())
 388                         {
 389                                 error(element, "Undefined value in <a>");
 390                                 return Color();
 391                         }
 392                         color.set_a(atof(child->get_child_text()->get_content().c_str()));
 393                 }
 394                 else
 395                         error_unexpected_element(child,child->get_name());
 396         }
 397
 398         return color;
 399 }
 400
 401 synfig::String
 402 CanvasParser::parse_string(xmlpp::Element *element)
 403 {
 404         assert(element->get_name()=="string");
 405
 406         if(element->get_children().empty())
 407         {
 408                 warning(element, "Undefined value in <string>");
 409                 return synfig::String();
 410         }
 411
 412         if(element->get_child_text()->get_content().empty())
 413         {
 414                 warning(element, "Content element of <string> appears to be empty");
 415                 return synfig::String();
 416         }
 417
 418         return element->get_child_text()->get_content();
 419 }
 420
 421 bool
 422 CanvasParser::parse_bool(xmlpp::Element *element)
 423 {
 424         assert(element->get_name()=="bool");
 425
 426         if(!element->get_children().empty())
 427                 warning(element, strprintf(_("<%s> should not contain anything"),"bool"));
 428
 429         if(!element->get_attribute("value"))
 430         {
 431                 error(element,strprintf(_("<%s> is missing \"value\" attribute"),"bool"));
 432                 return false;
 433         }
 434
 435         string val=element->get_attribute("value")->get_value();
 436
 437         if(val=="true" || val=="1")
 438                 return true;
 439         if(val=="false" || val=="0")
 440                 return false;
 441
 442         error(element,strprintf(_("Bad value \"%s\" in <%s>"),val.c_str(),"bool"));
 443
 444         return false;
 445 }
 446
 447 Gradient
 448 CanvasParser::parse_gradient(xmlpp::Element *node)
 449 {
 450         assert(node->get_name()=="gradient");
 451         Gradient ret;
 452
 453         xmlpp::Element::NodeList list = node->get_children();
 454         for(xmlpp::Element::NodeList::iterator iter = list.begin(); iter != list.end(); ++iter)
 455         {
 456                 xmlpp::Element *child(dynamic_cast<xmlpp::Element*>(*iter));
 457                 if(!child)
 458                         continue;
 459                 else
 460                 {
 461                         Gradient::CPoint cpoint;
 462                         cpoint.color=parse_color(child);
 463
 464                         if(!child->get_attribute("pos"))
 465                         {
 466                                 error(child,strprintf(_("<%s> is missing \"pos\" attribute"),"gradient"));
 467                                 return Gradient();
 468                         }
 469
 470                         cpoint.pos=atof(child->get_attribute("pos")->get_value().c_str());
 471
 472                         ret.push_back(cpoint);
 473                 }
 474         }
 475         ret.sort();
 476         return ret;
 477 }
 478
 479 ValueBase
 480 CanvasParser::parse_list(xmlpp::Element *element,Canvas::Handle canvas)
 481 {
 482         vector<ValueBase> value_list;
 483
 484         xmlpp::Element::NodeList list = element->get_children();
 485         for(xmlpp::Element::NodeList::iterator iter = list.begin(); iter != list.end(); ++iter)
 486         {
 487                 xmlpp::Element *child(dynamic_cast<xmlpp::Element*>(*iter));
 488                 if(!child)
 489                         continue;
 490                 else
 491                 {
 492                         value_list.push_back(parse_value(child,canvas));
 493                         if(!value_list.back().is_valid())
 494                         {
 495                                 value_list.pop_back();
 496                                 error(child,"Bad ValueBase");
 497                                 continue;
 498                         }
 499                 }
 500         }
 501         return value_list;
 502 }
 503
 504 Segment
 505 CanvasParser::parse_segment(xmlpp::Element *element)
 506 {
 507         assert(element->get_name()=="segment");
 508
 509         if(element->get_children().empty())
 510         {
 511                 error(element, "Undefined value in <segment>");
 512                 return Segment();
 513         }
 514
 515         Segment seg;
 516
 517         xmlpp::Element::NodeList list = element->get_children();
 518         for(xmlpp::Element::NodeList::iterator iter = list.begin(); iter != list.end(); ++iter)
 519         {
 520                 xmlpp::Element *child(dynamic_cast<xmlpp::Element*>(*iter));
 521                 if(!child)
 522                         continue;
 523                 else
 524                 if(child->get_name()=="p1")
 525                 {
 526                         xmlpp::Element::NodeList list = child->get_children();
 527                         xmlpp::Element::NodeList::iterator iter;
 528
 529                         // Search for the first non-text XML element
 530                         for(iter = list.begin(); iter != list.end(); ++iter)
 531                                 if(dynamic_cast<xmlpp::Element*>(*iter)) break;
 532
 533                         if(iter==list.end())
 534                         {
 535                                 error(element, "Undefined value in <p1>");
 536                                 continue;
 537                         }
 538
 539                         if((*iter)->get_name()!="vector")
 540                         {
 541                                 error_unexpected_element((*iter),(*iter)->get_name(),"vector");
 542                                 continue;
 543                         }
 544
 545                         seg.p1=parse_vector(dynamic_cast<xmlpp::Element*>(*iter));
 546                 }
 547                 else
 548                 if(child->get_name()=="t1")
 549                 {
 550                         xmlpp::Element::NodeList list = child->get_children();
 551                         xmlpp::Element::NodeList::iterator iter;
 552
 553                         // Search for the first non-text XML element
 554                         for(iter = list.begin(); iter != list.end(); ++iter)
 555                                 if(dynamic_cast<xmlpp::Element*>(*iter)) break;
 556
 557                         if(iter==list.end())
 558                         {
 559                                 error(element, "Undefined value in <t1>");
 560                                 continue;
 561                         }
 562
 563                         if((*iter)->get_name()!="vector")
 564                         {
 565                                 error_unexpected_element((*iter),(*iter)->get_name(),"vector");
 566                                 continue;
 567                         }
 568
 569                         seg.t1=parse_vector(dynamic_cast<xmlpp::Element*>(*iter));
 570                 }
 571                 else
 572                 if(child->get_name()=="p2")
 573                 {
 574                         xmlpp::Element::NodeList list = child->get_children();
 575                         xmlpp::Element::NodeList::iterator iter;
 576
 577                         // Search for the first non-text XML element
 578                         for(iter = list.begin(); iter != list.end(); ++iter)
 579                                 if(dynamic_cast<xmlpp::Element*>(*iter)) break;
 580
 581                         if(iter==list.end())
 582                         {
 583                                 error(element, "Undefined value in <p2>");
 584                                 continue;
 585                         }
 586
 587                         if((*iter)->get_name()!="vector")
 588                         {
 589                                 error_unexpected_element((*iter),(*iter)->get_name(),"vector");
 590                                 continue;
 591                         }
 592
 593                         seg.p2=parse_vector(dynamic_cast<xmlpp::Element*>(*iter));
 594                 }
 595                 else
 596                 if(child->get_name()=="t2")
 597                 {
 598                         xmlpp::Element::NodeList list = child->get_children();
 599                         xmlpp::Element::NodeList::iterator iter;
 600
 601                         // Search for the first non-text XML element
 602                         for(iter = list.begin(); iter != list.end(); ++iter)
 603                                 if(dynamic_cast<xmlpp::Element*>(*iter)) break;
 604
 605                         if(iter==list.end())
 606                         {
 607                                 error(element, "Undefined value in <t2>");
 608                                 continue;
 609                         }
 610
 611                         if((*iter)->get_name()!="vector")
 612                         {
 613                                 error_unexpected_element((*iter),(*iter)->get_name(),"vector");
 614                                 continue;
 615                         }
 616
 617                         seg.t2=parse_vector(dynamic_cast<xmlpp::Element*>(*iter));
 618                 }
 619                 else
 620                         error_unexpected_element(child,child->get_name());
 621         }
 622         return seg;
 623 }
 624
 625 BLinePoint
 626 CanvasParser::parse_bline_point(xmlpp::Element *element)
 627 {
 628         assert(element->get_name()=="bline_point");
 629         if(element->get_children().empty())
 630         {
 631                 error(element, "Undefined value in <bline_point>");
 632                 return BLinePoint();
 633         }
 634
 635         BLinePoint ret;
 636         ret.set_split_tangent_flag(false);
 637
 638         xmlpp::Element::NodeList list = element->get_children();
 639         for(xmlpp::Element::NodeList::iterator iter = list.begin(); iter != list.end(); ++iter)
 640         {
 641                 xmlpp::Element *child(dynamic_cast<xmlpp::Element*>(*iter));
 642                 if(!child)
 643                         continue;
 644                 else
 645                 // Vertex
 646                 if(child->get_name()[0]=='v' || child->get_name()=="p1")
 647                 {
 648                         xmlpp::Element::NodeList list = child->get_children();
 649                         xmlpp::Element::NodeList::iterator iter;
 650
 651                         // Search for the first non-text XML element
 652                         for(iter = list.begin(); iter != list.end(); ++iter)
 653                                 if(dynamic_cast<xmlpp::Element*>(*iter)) break;
 654
 655                         if(iter==list.end())
 656                         {
 657                                 error(element, "Undefined value in <vertex>");
 658                                 continue;
 659                         }
 660
 661                         if((*iter)->get_name()!="vector")
 662                         {
 663                                 error_unexpected_element((*iter),(*iter)->get_name(),"vector");
 664                                 continue;
 665                         }
 666
 667                         ret.set_vertex(parse_vector(dynamic_cast<xmlpp::Element*>(*iter)));
 668                 }
 669                 else
 670                 // Tangent 1
 671                 if(child->get_name()=="t1" || child->get_name()=="tangent")
 672                 {
 673                         xmlpp::Element::NodeList list = child->get_children();
 674                         xmlpp::Element::NodeList::iterator iter;
 675
 676                         // Search for the first non-text XML element
 677                         for(iter = list.begin(); iter != list.end(); ++iter)
 678                                 if(dynamic_cast<xmlpp::Element*>(*iter)) break;
 679
 680                         if(iter==list.end())
 681                         {
 682                                 error(element, "Undefined value in <t1>");
 683                                 continue;
 684                         }
 685
 686                         if((*iter)->get_name()!="vector")
 687                         {
 688                                 error_unexpected_element((*iter),(*iter)->get_name(),"vector");
 689                                 continue;
 690                         }
 691
 692                         ret.set_tangent1(parse_vector(dynamic_cast<xmlpp::Element*>(*iter)));
 693                 }
 694                 else
 695                 // Tangent 2
 696                 if(child->get_name()=="t2")
 697                 {
 698                         xmlpp::Element::NodeList list = child->get_children();
 699                         xmlpp::Element::NodeList::iterator iter;
 700
 701                         // Search for the first non-text XML element
 702                         for(iter = list.begin(); iter != list.end(); ++iter)
 703                                 if(dynamic_cast<xmlpp::Element*>(*iter)) break;
 704
 705                         if(iter==list.end())
 706                         {
 707                                 error(element, "Undefined value in <t2>");
 708                                 continue;
 709                         }
 710
 711                         if((*iter)->get_name()!="vector")
 712                         {
 713                                 error_unexpected_element((*iter),(*iter)->get_name(),"vector");
 714                                 continue;
 715                         }
 716
 717                         ret.set_tangent2(parse_vector(dynamic_cast<xmlpp::Element*>(*iter)));
 718                         ret.set_split_tangent_flag(true);
 719                 }
 720                 else
 721                 // width
 722                 if(child->get_name()=="width")
 723                 {
 724                         xmlpp::Element::NodeList list = child->get_children();
 725                         xmlpp::Element::NodeList::iterator iter;
 726
 727                         // Search for the first non-text XML element
 728                         for(iter = list.begin(); iter != list.end(); ++iter)
 729                                 if(dynamic_cast<xmlpp::Element*>(*iter)) break;
 730
 731                         if(iter==list.end())
 732                         {
 733                                 error(element, "Undefined value in <width>");
 734                                 continue;
 735                         }
 736
 737                         if((*iter)->get_name()!="real")
 738                         {
 739                                 error_unexpected_element((*iter),(*iter)->get_name(),"real");
 740                                 continue;
 741                         }
 742
 743                         ret.set_width(parse_real(dynamic_cast<xmlpp::Element*>(*iter)));
 744                 }
 745                 else
 746                 // origin
 747                 if(child->get_name()=="origin")
 748                 {
 749                         xmlpp::Element::NodeList list = child->get_children();
 750                         xmlpp::Element::NodeList::iterator iter;
 751
 752                         // Search for the first non-text XML element
 753                         for(iter = list.begin(); iter != list.end(); ++iter)
 754                                 if(dynamic_cast<xmlpp::Element*>(*iter)) break;
 755
 756                         if(iter==list.end())
 757                         {
 758                                 error(element, "Undefined value in <origin>");
 759                                 continue;
 760                         }
 761
 762                         if((*iter)->get_name()!="real")
 763                         {
 764                                 error_unexpected_element((*iter),(*iter)->get_name(),"real");
 765                                 continue;
 766                         }
 767
 768                         ret.set_origin(parse_real(dynamic_cast<xmlpp::Element*>(*iter)));
 769                 }
 770                 else
 771                         error_unexpected_element(child,child->get_name());
 772         }
 773         return ret;
 774 }
 775
 776 Angle
 777 CanvasParser::parse_angle(xmlpp::Element *element)
 778 {
 779         assert(element->get_name()=="angle");
 780
 781         if(!element->get_children().empty())
 782                 warning(element, strprintf(_("<%s> should not contain anything"),"angle"));
 783
 784         if(!element->get_attribute("value"))
 785         {
 786                 error(element,strprintf(_("<%s> is missing \"value\" attribute"),"angle"));
 787                 return Angle();
 788         }
 789
 790         string val=element->get_attribute("value")->get_value();
 791
 792         return Angle::deg(atof(val.c_str()));
 793 }
 794
 795 ValueBase
 796 CanvasParser::parse_value(xmlpp::Element *element,Canvas::Handle canvas)
 797 {
 798         if(element->get_name()=="real")
 799                 return parse_real(element);
 800         else
 801         if(element->get_name()=="time")
 802                 return parse_time(element,canvas);
 803         else
 804         if(element->get_name()=="integer")
 805                 return parse_integer(element);
 806         else
 807         if(element->get_name()=="string")
 808                 return parse_string(element);
 809         else
 810         if(element->get_name()=="vector")
 811                 return parse_vector(element);
 812         else
 813         if(element->get_name()=="color")
 814                 return parse_color(element);
 815         else
 816         if(element->get_name()=="segment")
 817                 return parse_segment(element);
 818         else
 819         if(element->get_name()=="list")
 820                 return parse_list(element,canvas);
 821         else
 822         if(element->get_name()=="gradient")
 823                 return parse_gradient(element);
 824         else
 825         if(element->get_name()=="bool")
 826                 return parse_bool(element);
 827         else
 828         //if(element->get_name()=="canvas")
 829         //      return parse_canvas(element,canvas,true);       // inline canvas
 830         //else
 831         if(element->get_name()=="angle" || element->get_name()=="degrees" || element->get_name()=="radians" || element->get_name()=="rotations")
 832                 return parse_angle(element);
 833         else
 834         if(element->get_name()=="bline_point")
 835                 return parse_bline_point(element);
 836         else
 837         if(element->get_name()=="canvas")
 838                 return ValueBase(parse_canvas(element,canvas,true));
 839         else
 840         {
 841                 error_unexpected_element(element,element->get_name());
 842         }
 843
 844         return ValueBase();
 845 }
 846
 847
 848
 849
 850 ValueNode_Animated::Handle
 851 CanvasParser::parse_animated(xmlpp::Element *element,Canvas::Handle canvas)
 852 {
 853         assert(element->get_name()=="hermite" || element->get_name()=="animated");
 854
 855         if(!element->get_attribute("type"))
 856         {
 857                 error(element,"Missing attribute \"type\" in <animated>");
 858                 return ValueNode_Animated::Handle();
 859         }
 860
 861         ValueBase::Type type=ValueBase::ident_type(element->get_attribute("type")->get_value());
 862
 863         if(!type)
 864         {
 865                 error(element,"Bad type in <animated>");
 866                 return ValueNode_Animated::Handle();
 867         }
 868
 869         ValueNode_Animated::Handle value_node=ValueNode_Animated::create(type);
 870
 871         if(!value_node)
 872         {
 873                 error(element,strprintf(_("Unable to create <animated> with type \"%s\""),ValueBase::type_local_name(type).c_str()));
 874                 return ValueNode_Animated::Handle();
 875         }
 876
 877         value_node->set_root_canvas(canvas->get_root());
 878
 879         xmlpp::Element::NodeList list = element->get_children();
 880         for(xmlpp::Element::NodeList::iterator iter = list.begin(); iter != list.end(); ++iter)
 881         {
 882                 xmlpp::Element *child(dynamic_cast<xmlpp::Element*>(*iter));
 883                 if(!child)
 884                         continue;
 885                 else
 886                 if(child->get_name()=="waypoint")
 887                 {
 888                         if(!child->get_attribute("time"))
 889                         {
 890                                 error(child,_("<waypoint> is missing attribute \"time\""));
 891                                 continue;
 892                         }
 893
 894                         Time time(child->get_attribute("time")->get_value(),canvas->rend_desc().get_frame_rate());
 895
 896
 897                         ValueNode::Handle waypoint_value_node;
 898                         xmlpp::Element::NodeList list = child->get_children();
 899
 900                         if(child->get_attribute("use"))
 901                         {
 902                                 if(!list.empty())
 903                                         warning(child,_("Found \"use\" attribute for <waypoint>, but it wasn't empty. Ignoring contents..."));
 904
 905                                 // the waypoint might look like this, in which case we won't find "mycanvas" in the list of valuenodes, 'cos it's a canvas
 906                                 //
 907                                 //      <animated type="canvas">
 908                                 //        <waypoint time="0s" use="mycanvas"/>
 909                                 //      </animated>
 910                                 if (type==ValueBase::TYPE_CANVAS)
 911                                         waypoint_value_node=ValueNode_Const::create(canvas->surefind_canvas(child->get_attribute("use")->get_value()));
 912                                 else
 913                                         waypoint_value_node=canvas->surefind_value_node(child->get_attribute("use")->get_value());
 914                         }
 915                         else
 916                         {
 917                                 if(child->get_children().empty())
 918                                 {
 919                                         error(child, strprintf(_("<%s> is missing its data"),"waypoint"));
 920                                         continue;
 921                                 }
 922
 923                                 xmlpp::Element::NodeList::iterator iter;
 924
 925                                 // Search for the first non-text XML element
 926                                 for(iter = list.begin(); iter != list.end(); ++iter)
 927                                         if(dynamic_cast<xmlpp::Element*>(*iter)) break;
 928
 929                                 if(iter==list.end())
 930                                 {
 931                                         error(child, strprintf(_("<%s> is missing its data"),"waypoint"));
 932                                         continue;
 933                                 }
 934
 935                                 waypoint_value_node=parse_value_node(dynamic_cast<xmlpp::Element*>(*iter),canvas);
 936
 937                                 /*
 938                                 ValueBase data=parse_value(dynamic_cast<xmlpp::Element*>(*iter),canvas);
 939
 940                                 if(!data.is_valid())
 941                                 {
 942                                         error(child,_("Bad data for <waypoint>"));
 943                                         continue;
 944                                 }
 945                                 */
 946                                 if(!waypoint_value_node)
 947                                 {
 948                                         error(child,_("Bad data for <waypoint>"));
 949                                         continue;
 950                                 }
 951
 952                                 /*! HACK -- This is a temporary fix to help repair some
 953                                 **      weirdness that is currently going on (10-21-2004).
 954                                 **      This short circuits the linking of waypoints,
 955                                 **      a feature which is so obscure that we can get
 956                                 **      away with something like this pretty easily.
 957                                 */
 958                                 waypoint_value_node=waypoint_value_node->clone();
 959
 960                                 // Warn if there is trash after the param value
 961                                 for(iter++; iter != list.end(); ++iter)
 962                                         if(dynamic_cast<xmlpp::Element*>(*iter))
 963                                                 warning((*iter),strprintf(_("Unexpected element <%s> after <waypoint> data, ignoring..."),(*iter)->get_name().c_str()));
 964                         }
 965
 966
 967                         try {
 968                                 ValueNode_Animated::WaypointList::iterator waypoint=value_node->new_waypoint(time,waypoint_value_node);
 969
 970                         if(child->get_attribute("tension"))
 971                         {
 972                                 synfig::String str(child->get_attribute("tension")->get_value());
 973                                 waypoint->set_tension(atof(str.c_str()));
 974                         }
 975                         if(child->get_attribute("temporal-tension"))
 976                         {
 977                                 synfig::String str(child->get_attribute("temporal-tension")->get_value());
 978                                 waypoint->set_temporal_tension(atof(str.c_str()));
 979                         }
 980                         if(child->get_attribute("continuity"))
 981                         {
 982                                 synfig::String str(child->get_attribute("continuity")->get_value());
 983                                 waypoint->set_continuity(atof(str.c_str()));
 984                         }
 985                         if(child->get_attribute("bias"))
 986                         {
 987                                 synfig::String str(child->get_attribute("bias")->get_value());
 988                                 waypoint->set_bias(atof(str.c_str()));
 989                         }
 990
 991                         if(child->get_attribute("before"))
 992                         {
 993                                 string val=child->get_attribute("before")->get_value();
 994                                 if(val=="halt")
 995                                         waypoint->set_before(INTERPOLATION_HALT);
 996                                 else if(val=="constant")
 997                                         waypoint->set_before(INTERPOLATION_CONSTANT);
 998                                 else if(val=="linear")
 999                                         waypoint->set_before(INTERPOLATION_LINEAR);
1000                                 else if(val=="manual")
1001                                         waypoint->set_before(INTERPOLATION_MANUAL);
1002                                 else if(val=="auto")
1003                                         waypoint->set_before(INTERPOLATION_TCB);
1004                                 else
1005                                         error(child,strprintf(_("\"%s\" not a valid value for attribute \"%s\" in <%s>"),val.c_str(),"before","waypoint"));
1006                         }
1007
1008                         if(child->get_attribute("after"))
1009                         {
1010                                 string val=child->get_attribute("after")->get_value();
1011                                 if(val=="halt")
1012                                         waypoint->set_after(INTERPOLATION_HALT);
1013                                 else if(val=="constant")
1014                                         waypoint->set_after(INTERPOLATION_CONSTANT);
1015                                 else if(val=="linear")
1016                                         waypoint->set_after(INTERPOLATION_LINEAR);
1017                                 else if(val=="manual")
1018                                         waypoint->set_after(INTERPOLATION_MANUAL);
1019                                 else if(val=="auto")
1020                                         waypoint->set_after(INTERPOLATION_TCB);
1021                                 else
1022                                         error(child,strprintf(_("\"%s\" not a valid value for attribute \"%s\" in <%s>"),val.c_str(),"before","waypoint"));
1023                         }
1024                         }
1025                         catch(Exception::BadTime x)
1026                         {
1027                                 warning(child,x.what());
1028                         }
1029                         continue;
1030
1031                 }
1032                 else
1033                         error_unexpected_element(child,child->get_name());
1034         }
1035
1036         // in canvas version 0.1, angles used to wrap, so to get from -179
1037         // degrees to 180 degrees meant a 1 degree change
1038         // in canvas version 0.2 they don't, so that's a 359 degree change
1039
1040         // when loading a version 0.1 canvas, modify constant angle
1041         // waypoints to that they are within 180 degrees of the previous
1042         // waypoint's value
1043         if (type == ValueBase::TYPE_ANGLE)
1044         {
1045                 if (canvas->get_version() == "0.1")
1046                 {
1047                         bool first = true;
1048                         Real angle, prev = 0;
1049                         WaypointList &wl = value_node->waypoint_list();
1050                         for (WaypointList::iterator iter = wl.begin(); iter != wl.end(); iter++)
1051                         {
1052                                 angle = Angle::deg(iter->get_value(iter->get_time()).get(Angle())).get();
1053                                 if (first)
1054                                         first = false;
1055                                 else if (iter->get_value_node()->get_name() == "constant")
1056                                 {
1057                                         if (angle - prev > 180)
1058                                         {
1059                                                 while (angle - prev > 180) angle -= 360;
1060                                                 iter->set_value(Angle::deg(angle));
1061                                         }
1062                                         else if (prev - angle > 180)
1063                                         {
1064                                                 while (prev - angle > 180) angle += 360;
1065                                                 iter->set_value(Angle::deg(angle));
1066                                         }
1067                                 }
1068                                 prev = angle;
1069                         }
1070                 }
1071         }
1072
1073         value_node->changed();
1074         return value_node;
1075 }
1076
1077 etl::handle<LinkableValueNode>
1078 CanvasParser::parse_linkable_value_node(xmlpp::Element *element,Canvas::Handle canvas)
1079 {
1080         // Determine the type
1081         if(!element->get_attribute("type"))
1082         {
1083                 error(element, strprintf(_("Missing attribute \"type\" in <%s>"), element->get_name().c_str()));
1084                 return 0;
1085         }
1086
1087         ValueBase::Type type=ValueBase::ident_type(element->get_attribute("type")->get_value());
1088
1089         if(!type)
1090         {
1091                 error(element, strprintf(_("Bad type in <%s>"), element->get_name().c_str()));
1092                 return 0;
1093         }
1094
1095         handle<LinkableValueNode> value_node=LinkableValueNode::create(element->get_name(),type);
1096         handle<ValueNode> c[value_node->link_count()];
1097
1098         if(!value_node)
1099         {
1100                 error(element, strprintf(_("Error creating ValueNode <%s> with type '%s'.  Refer to '%s'"),
1101                                                                  element->get_name().c_str(),
1102                                                                  ValueBase::type_local_name(type).c_str(),
1103                                                                  VALUENODE_COMPATIBILITY_URL));
1104                 return 0;
1105         }
1106
1107         if(value_node->get_type()!=type)
1108         {
1109                 error(element, strprintf(_("<%s> did not accept type '%s'"),
1110                                                                  element->get_name().c_str(),
1111                                                                  ValueBase::type_local_name(type).c_str()));
1112                 return 0;
1113         }
1114
1115         value_node->set_root_canvas(canvas->get_root());
1116
1117         // handle exported valuenodes
1118         {
1119                 int index;
1120                 String id, name;
1121                 xmlpp::Element::AttributeList attrib_list(element->get_attributes());
1122                 for(xmlpp::Element::AttributeList::iterator iter = attrib_list.begin(); iter != attrib_list.end(); iter++)
1123                 {
1124                         name = (*iter)->get_name();
1125                         id = (*iter)->get_value();
1126
1127                         if (name == "guid" || name == "id" || name == "type")
1128                                 continue;
1129
1130                         try {
1131                                 index = value_node->get_link_index_from_name(name);
1132
1133                                 if(c[index])
1134                                 {
1135                                         error(element,strprintf(_("'%s' was already defined in <%s>"),
1136                                                                                         name.c_str(),
1137                                                                                         element->get_name().c_str()));
1138                                         continue;
1139                                 }
1140
1141                                 c[index] = canvas->surefind_value_node(id);
1142
1143                                 if (!c[index])
1144                                 {
1145                                         error(element, strprintf(_("'%s' attribute in <%s> references unknown ID '%s'"),
1146                                                                                          name.c_str(),
1147                                                                                          element->get_name().c_str(),
1148                                                                                          id.c_str()));
1149                                         continue;
1150                                 }
1151
1152                                 if(!value_node->set_link(index, c[index]))
1153                                 {
1154                                         error(element, strprintf(_("Unable to set link '\"%s\" to ValueNode \"%s\" (link #%d in \"%s\")"),
1155                                                                                          value_node->link_name(index).c_str(),
1156                                                                                          id.c_str(),
1157                                                                                          index,
1158                                                                                          element->get_name().c_str()));
1159                                         continue;
1160                                 }
1161
1162                                 // printf("  <%s> set link %d (%s) using exported value\n", element->get_name().c_str(), index, name.c_str());
1163                         }
1164                         catch (Exception::BadLinkName)
1165                         {
1166                                 warning(element, strprintf("Bad link name '%s'", name.c_str()));
1167                         }
1168                         catch(Exception::IDNotFound)
1169                         {
1170                                 error(element,"Unable to resolve " + id);
1171                         }
1172                         catch(Exception::FileNotFound)
1173                         {
1174                                 error(element,"Unable to open file referenced in " + id);
1175                         }
1176                         catch(...)
1177                         {
1178                                 error(element,strprintf(_("Unknown Exception thrown when referencing ValueNode \"%s\""), id.c_str()));
1179                                 throw;
1180                         }
1181                 }
1182         }
1183
1184         // handle inline valuenodes
1185         {
1186                 int index;
1187                 String child_name;
1188                 xmlpp::Element::NodeList list = element->get_children();
1189                 for(xmlpp::Element::NodeList::iterator iter = list.begin(); iter != list.end(); ++iter)
1190                 {
1191                         xmlpp::Element *child(dynamic_cast<xmlpp::Element*>(*iter));
1192                         try
1193                         {
1194                                 if(!child)
1195                                         continue;
1196
1197                                 child_name = child->get_name();
1198
1199                                 index = value_node->get_link_index_from_name(child_name);
1200
1201                                 if(c[index])
1202                                 {
1203                                         error(child, strprintf(_("'%s' was already defined in <%s>"),
1204                                                                                    child_name.c_str(),
1205                                                                                    element->get_name().c_str()));
1206                                         break;
1207                                 }
1208
1209                                 xmlpp::Element::NodeList list = child->get_children();
1210                                 xmlpp::Element::NodeList::iterator iter;
1211
1212                                 // Search for the first non-text XML element
1213                                 for(iter = list.begin(); iter != list.end(); ++iter)
1214                                         if(dynamic_cast<xmlpp::Element*>(*iter)) break;
1215
1216                                 if(iter==list.end())
1217                                 {
1218                                         error(child,strprintf(_("element <%s> is missing its contents"),
1219                                                                                   child_name.c_str()));
1220                                         continue;
1221                                 }
1222
1223                                 c[index]=parse_value_node(dynamic_cast<xmlpp::Element*>(*iter),canvas);
1224
1225                                 if(!c[index])
1226                                 {
1227                                         error((*iter),strprintf(_("Parse of '%s' failed"),
1228                                                                                         child_name.c_str()));
1229                                         continue;
1230                                 }
1231
1232                                 if(!value_node->set_link(index,c[index]))
1233                                 {
1234                                         error(child,strprintf(_("Unable to connect value node ('%s' of type '%s') to link %d (%s)"),
1235                                                                                   c[index]->get_name().c_str(),
1236                                                                                   ValueBase::type_local_name(c[index]->get_type()).c_str(),
1237                                                                                   index,
1238                                                                                   value_node->link_name(index).c_str()));
1239                                         continue;
1240                                 }
1241
1242                                 // \todo do a search for more elements and warn if they are found
1243
1244                                 // printf("  <%s> set link %d (%s) using inline value\n", element->get_name().c_str(), index, child_name.c_str());
1245                         }
1246                         catch(Exception::BadLinkName)
1247                         {
1248                                 warning(child, strprintf("Bad link name for <%s>", element->get_name().c_str()));
1249                         }
1250                         catch(...)
1251                         {
1252                                 error(child, strprintf(_("Unknown Exception thrown when working on element \"%s\""),child_name.c_str()));
1253                                 throw;
1254                         }
1255                 }
1256         }
1257
1258         String version(canvas->get_version());
1259         for (int i = 0; i < value_node->link_count(); i++)
1260         {
1261                 if (!c[i])
1262                 {
1263                         // the 'width' parameter of <stripes> wasn't always present in version 0.1 canvases
1264                         if (version == "0.1" && element->get_name() == "stripes" && value_node->link_name(i) == "width")
1265                                 continue;
1266
1267                         // these 3 blinecalctangent parameters didn't appear until canvas version 0.5
1268                         if ((version == "0.1" || version == "0.2" || version == "0.3" || version == "0.4") &&
1269                                 element->get_name() == "blinecalctangent" &&
1270                                 (value_node->link_name(i) == "offset" ||
1271                                  value_node->link_name(i) == "scale" ||
1272                                  value_node->link_name(i) == "fixed_length"))
1273                                 continue;
1274
1275                         // 'scale' was added while canvas version 0.5 was in use
1276                         if ((version == "0.3" || version == "0.4" || version == "0.5") &&
1277                                 element->get_name() == "blinecalcwidth" &&
1278                                 value_node->link_name(i) == "scale")
1279                                 continue;
1280
1281                         // 'loop' was added while canvas version 0.5 was in use, as was the 'gradientcolor' node type
1282                         if (version == "0.5" &&
1283                                 element->get_name() == "gradientcolor" &&
1284                                 value_node->link_name(i) == "loop")
1285                                 continue;
1286
1287                         error(element, strprintf(_("<%s> is missing link %d (%s)"),
1288                                                                          element->get_name().c_str(),
1289                                                                          i,
1290                                                                          value_node->link_name(i).c_str()));
1291                         return 0;
1292                 }
1293         }
1294
1295         // pre 0.4 canvases had *calctangent outputs scaled down by 0.5 for some reason
1296         if (element->get_name() == "blinecalctangent" || element->get_name() == "segcalctangent")
1297         {
1298                 if (version == "0.1" || version == "0.2" || version == "0.3")
1299                 {
1300                         handle<LinkableValueNode> scale_value_node=LinkableValueNode::create("scale",type);
1301                         scale_value_node->set_link(scale_value_node->get_link_index_from_name("link"), value_node);
1302                         scale_value_node->set_link(scale_value_node->get_link_index_from_name("scalar"), ValueNode_Const::create(Real(0.5)));
1303                         value_node = scale_value_node;
1304                 }
1305         }
1306
1307         return value_node;
1308 }
1309
1310 // This will also parse a bline
1311 handle<ValueNode_DynamicList>
1312 CanvasParser::parse_dynamic_list(xmlpp::Element *element,Canvas::Handle canvas)
1313 {
1314         assert(element->get_name()=="dynamic_list" || element->get_name()=="bline");
1315
1316         const float fps(canvas?canvas->rend_desc().get_frame_rate():0);
1317
1318         if(!element->get_attribute("type"))
1319         {
1320                 error(element,"Missing attribute \"type\" in <dynamic_list>");
1321                 return handle<ValueNode_DynamicList>();
1322         }
1323
1324         ValueBase::Type type=ValueBase::ident_type(element->get_attribute("type")->get_value());
1325
1326         if(!type)
1327         {
1328                 error(element,"Bad type in <dynamic_list>");
1329                 return handle<ValueNode_DynamicList>();
1330         }
1331
1332         handle<ValueNode_DynamicList> value_node;
1333         handle<ValueNode_BLine> bline_value_node;
1334
1335         if(element->get_name()=="bline")
1336         {
1337                 value_node=bline_value_node=ValueNode_BLine::create();
1338                 if(element->get_attribute("loop"))
1339                 {
1340                         String loop=element->get_attribute("loop")->get_value();
1341                         if(loop=="true" || loop=="1" || loop=="TRUE" || loop=="True")
1342                                 bline_value_node->set_loop(true);
1343                         else
1344                                 bline_value_node->set_loop(false);
1345                 }
1346
1347         }
1348         else
1349                 value_node=ValueNode_DynamicList::create(type);
1350
1351         if(!value_node)
1352         {
1353                 error(element,strprintf(_("Unable to create <dynamic_list>")));
1354                 return handle<ValueNode_DynamicList>();
1355         }
1356
1357         value_node->set_root_canvas(canvas->get_root());
1358
1359         xmlpp::Element::NodeList list = element->get_children();
1360         for(xmlpp::Element::NodeList::iterator iter = list.begin(); iter != list.end(); ++iter)
1361         {
1362                 xmlpp::Element *child(dynamic_cast<xmlpp::Element*>(*iter));
1363                 if(!child)
1364                         continue;
1365                 else
1366                 if(child->get_name()=="entry")
1367                 {
1368                         ValueNode_DynamicList::ListEntry list_entry;
1369
1370                         // Parse begin/end waypoints
1371                         {
1372                                 typedef synfig::ValueNode_DynamicList::ListEntry::Activepoint Activepoint;
1373                                 typedef synfig::ValueNode_DynamicList::ListEntry::ActivepointList ActivepointList;
1374
1375                                 String begin_sequence;
1376                                 String end_sequence;
1377
1378                                 ActivepointList &timing_info(list_entry.timing_info);
1379
1380                                 if(child->get_attribute("begin"))
1381                                         begin_sequence=child->get_attribute("begin")->get_value();
1382
1383                                 if(child->get_attribute("on"))
1384                                         begin_sequence=child->get_attribute("on")->get_value();
1385
1386                                 if(child->get_attribute("end"))
1387                                         end_sequence=child->get_attribute("end")->get_value();
1388
1389                                 if(child->get_attribute("off"))
1390                                         end_sequence=child->get_attribute("off")->get_value();
1391
1392                                 // clear out any auto-start
1393                                 if(!begin_sequence.empty())
1394                                         timing_info.clear();
1395
1396                                 //! \optimize
1397                                 while(!begin_sequence.empty())
1398                                 {
1399                                         String::iterator iter(find(begin_sequence.begin(),begin_sequence.end(),','));
1400                                         String timecode(begin_sequence.begin(), iter);
1401                                         int priority=0;
1402
1403                                         // skip whitespace before checking for a priority
1404                                         while (isspace(timecode[0]))
1405                                                 timecode=timecode.substr(1);
1406
1407                                         // If there is a priority, then grab it and remove
1408                                         // it from the timecode
1409                                         if(timecode[0]=='p')
1410                                         {
1411                                                 //priority=timecode[1]-'0';
1412                                                 //timecode=String(timecode.begin()+3,timecode.end());
1413                                                 int space=timecode.find_first_of(' ');
1414                                                 priority=atoi(String(timecode,1,space-1).c_str());
1415                                                 timecode=String(timecode.begin()+space+1,timecode.end());
1416                                                 //synfig::info("priority: %d      timecode: %s",priority,timecode.c_str());
1417                                         }
1418
1419                                         timing_info.push_back(
1420                                                 Activepoint(
1421                                                         Time(
1422                                                                 timecode,
1423                                                                 fps
1424                                                         ),
1425                                                         true,   // Mark as a "on" activepoint
1426                                                         priority
1427                                                 )
1428                                         );
1429
1430                                         if(iter==begin_sequence.end())
1431                                                 begin_sequence.clear();
1432                                         else
1433                                                 begin_sequence=String(iter+1,begin_sequence.end());
1434                                 }
1435
1436                                 //! \optimize
1437                                 while(!end_sequence.empty())
1438                                 {
1439                                         String::iterator iter(find(end_sequence.begin(),end_sequence.end(),','));
1440                                         String timecode(end_sequence.begin(),   iter);
1441                                         int priority=0;
1442
1443                                         // skip whitespace before checking for a priority
1444                                         while (isspace(timecode[0]))
1445                                                 timecode=timecode.substr(1);
1446
1447                                         // If there is a priority, then grab it and remove
1448                                         // it from the timecode
1449                                         if(timecode[0]=='p')
1450                                         {
1451                                                 //priority=timecode[1]-'0';
1452                                                 //timecode=String(timecode.begin()+3,timecode.end());
1453                                                 int space=timecode.find_first_of(' ');
1454                                                 priority=atoi(String(timecode,1,space-1).c_str());
1455                                                 timecode=String(timecode.begin()+space+1,timecode.end());
1456                                                 //synfig::info("priority: %d      timecode: %s",priority,timecode.c_str());
1457                                         }
1458
1459                                         timing_info.push_back(
1460                                                 Activepoint(
1461                                                         Time(
1462                                                                 timecode,
1463                                                                 fps
1464                                                         ),
1465                                                         false,  // Mark as a "off" activepoint
1466                                                         priority
1467                                                 )
1468                                         );
1469                                         if(iter==end_sequence.end())
1470                                                 end_sequence.clear();
1471                                         else
1472                                                 end_sequence=String(iter+1,end_sequence.end());
1473                                 }
1474
1475                                 timing_info.sort();
1476                         }
1477
1478                         if(child->get_attribute("use"))
1479                         {
1480                                 // \todo does this need to be able to read 'use="canvas"', like waypoints can now?  (see 'surefind_canvas' in this file)
1481                                 string id=child->get_attribute("use")->get_value();
1482                                 try
1483                                 {
1484                                         list_entry.value_node=canvas->surefind_value_node(id);
1485                                 }
1486                                 catch(Exception::IDNotFound)
1487                                 {
1488                                         error(child,"\"use\" attribute in <entry> references unknown ID -- "+id);
1489                                         continue;
1490                                 }
1491                         }
1492                         else
1493                         {
1494                                 xmlpp::Element::NodeList list = child->get_children();
1495                                 xmlpp::Element::NodeList::iterator iter;
1496
1497                                 // Search for the first non-text XML element
1498                                 for(iter = list.begin(); iter != list.end(); ++iter)
1499                                         if(dynamic_cast<xmlpp::Element*>(*iter)) break;
1500
1501                                 if(iter==list.end())
1502                                 {
1503                                         error(child,strprintf(_("<entry> is missing its contents or missing \"use\" element")));
1504                                         continue;
1505                                 }
1506
1507                                 list_entry.value_node=parse_value_node(dynamic_cast<xmlpp::Element*>(*iter),canvas);
1508
1509                                 if(!list_entry.value_node)
1510                                         error((*iter),"Parse of ValueNode failed");
1511
1512                                 // \todo do a search for more elements and warn if they are found
1513
1514                         }
1515
1516                         value_node->add(list_entry);
1517                         value_node->set_link(value_node->link_count()-1,list_entry.value_node);
1518                 }
1519                 else
1520                         error_unexpected_element(child,child->get_name());
1521         }
1522         return value_node;
1523 }
1524
1525 handle<ValueNode>
1526 CanvasParser::parse_value_node(xmlpp::Element *element,Canvas::Handle canvas)
1527 {
1528         handle<ValueNode> value_node;
1529         assert(element);
1530
1531         GUID guid;
1532
1533         if(element->get_attribute("guid"))
1534         {
1535                 guid=GUID(element->get_attribute("guid")->get_value())^canvas->get_root()->get_guid();
1536                 value_node=guid_cast<ValueNode>(guid);
1537                 if(value_node)
1538                         return value_node;
1539         }
1540
1541         // If ValueBase::ident_type() recognizes the name, then we know it's a ValueBase
1542         if(element->get_name()!="canvas" && ValueBase::ident_type(element->get_name()))
1543         {
1544                 ValueBase data=parse_value(element,canvas);
1545
1546                 if(!data.is_valid())
1547                 {
1548                         error(element,strprintf(_("Bad data in <%s>"),element->get_name().c_str()));
1549                         return value_node;
1550                 }
1551
1552                 // We want to convert this ValueBase into a
1553                 // ValueNode_Const. That way, we can treat the
1554                 // ID like any other Datanode. Think of this
1555                 // as a shorthand for creating constant ValueNodes.
1556
1557                 value_node=ValueNode_Const::create(data);
1558         }
1559         else
1560         if(element->get_name()=="hermite" || element->get_name()=="animated")
1561                 value_node=parse_animated(element,canvas);
1562         else
1563         if(element->get_name()=="dynamic_list")
1564                 value_node=parse_dynamic_list(element,canvas);
1565         else
1566         if(element->get_name()=="bline") // This is not a typo. The dynamic list parser will parse a bline.
1567                 value_node=parse_dynamic_list(element,canvas);
1568         else
1569         if(LinkableValueNode::book().count(element->get_name()))
1570         {
1571                 value_node=parse_linkable_value_node(element,canvas);
1572                 if (!value_node) value_node = PlaceholderValueNode::create();
1573         }
1574         else
1575         if(element->get_name()=="canvas")
1576                 value_node=ValueNode_Const::create(parse_canvas(element,canvas,true));
1577         else
1578         {
1579                 error_unexpected_element(element,element->get_name());
1580                 error(element, strprintf(_("Expected a ValueNode.  Refer to '%s'"),
1581                                                                  VALUENODE_COMPATIBILITY_URL));
1582                 value_node=PlaceholderValueNode::create();
1583         }
1584
1585         value_node->set_root_canvas(canvas->get_root());
1586
1587         // If we were successful, and our element has
1588         // an ID attribute, go ahead and add it to the
1589         // value_node list
1590         if(value_node && element->get_attribute("id"))
1591         {
1592                 string id=element->get_attribute("id")->get_value();
1593
1594                 //value_node->set_id(id);
1595
1596                 // If there is already a value_node in the list
1597                 // with the same ID, then that is an error
1598                 try { canvas->add_value_node(value_node,id); }
1599                 catch(Exception::BadLinkName)
1600                 {
1601                         warning(element,strprintf(_("Bad ID \"%s\""),id.c_str()));
1602                         return value_node;
1603                 }
1604                 catch(Exception::IDAlreadyExists)
1605                 {
1606                         error(element,strprintf(_("Duplicate ID \"%s\""),id.c_str()));
1607                         return value_node;
1608                 }
1609                 catch(...)
1610                 {
1611                         error(element,strprintf(_("Unknown Exception thrown when adding ValueNode \"%s\""),id.c_str()));
1612                         throw;
1613                 }
1614         }
1615         value_node->set_guid(guid);
1616         return value_node;
1617 }
1618
1619 void
1620 CanvasParser::parse_canvas_defs(xmlpp::Element *element,Canvas::Handle canvas)
1621 {
1622         assert(element->get_name()=="defs");
1623         xmlpp::Element::NodeList list = element->get_children();
1624         for(xmlpp::Element::NodeList::iterator iter = list.begin(); iter != list.end(); ++iter)
1625         {
1626                 xmlpp::Element *child(dynamic_cast<xmlpp::Element*>(*iter));
1627                 if(!child)
1628                         continue;
1629                 else
1630                 if(child->get_name()=="canvas")
1631                         parse_canvas(child, canvas);
1632                 else
1633                         parse_value_node(child,canvas);
1634         }
1635 }
1636
1637 Layer::Handle
1638 CanvasParser::parse_layer(xmlpp::Element *element,Canvas::Handle canvas)
1639 {
1640
1641         assert(element->get_name()=="layer");
1642         Layer::Handle layer;
1643
1644         if(!element->get_attribute("type"))
1645         {
1646                 error(element,_("Missing \"type\" attribute to \"layer\" element"));
1647                 return Layer::Handle();
1648         }
1649
1650         layer=Layer::create(element->get_attribute("type")->get_value());
1651         layer->set_canvas(canvas);
1652
1653         if(element->get_attribute("group"))
1654         {
1655                 layer->add_to_group(
1656                         element->get_attribute("group")->get_value()
1657                 );
1658         }
1659
1660         // Handle the version attribute
1661         if(element->get_attribute("version"))
1662         {
1663                 String version(element->get_attribute("version")->get_value());
1664                 if(version>layer->get_version())
1665                         warning(element,_("Installed layer version is smaller than layer version in file"));
1666                 if(version!=layer->get_version())
1667                         layer->set_version(version);
1668         }
1669
1670         // Handle the description
1671         if(element->get_attribute("desc"))
1672                 layer->set_description(element->get_attribute("desc")->get_value());
1673
1674         if(element->get_attribute("active"))
1675                 layer->set_active(element->get_attribute("active")->get_value()=="false"?false:true);
1676
1677         xmlpp::Element::NodeList list = element->get_children();
1678         for(xmlpp::Element::NodeList::iterator iter = list.begin(); iter != list.end(); ++iter)
1679         {
1680                 xmlpp::Element *child(dynamic_cast<xmlpp::Element*>(*iter));
1681                 if(!child)
1682                         continue;
1683                 else
1684                 if(child->get_name()=="name")
1685                         warning(child,_("<name> entry for <layer> is not yet supported. Ignoring..."));
1686                 else
1687                 if(child->get_name()=="desc")
1688                         warning(child,_("<desc> entry for <layer> is not yet supported. Ignoring..."));
1689                 else
1690                 if(child->get_name()=="param")
1691                 {
1692                         xmlpp::Element::NodeList list = child->get_children();
1693
1694                         if(!child->get_attribute("name"))
1695                         {
1696                                 error(child,_("Missing \"name\" attribute for <param>."));
1697                                 continue;
1698                         }
1699
1700                         String param_name=child->get_attribute("name")->get_value();
1701
1702                         // SVN r2013 and r2014 renamed all 'pos' and 'offset' parameters to 'origin'
1703                         // 'pos' and 'offset' will appear in old .sif files; handle them correctly
1704                         if (param_name == "pos" || param_name == "offset")
1705                                 param_name = "origin";
1706
1707                         if(child->get_attribute("use"))
1708                         {
1709                                 // If the "use" attribute is used, then the
1710                                 // element should be empty. Warn the user if
1711                                 // we find otherwise.
1712                                 if(!list.empty())
1713                                         warning(child,_("Found \"use\" attribute for <param>, but it wasn't empty. Ignoring contents..."));
1714
1715                                 String str=     child->get_attribute("use")->get_value();
1716
1717                                 if (str.empty())
1718                                         error(child,_("Empty use=\"\" value in <param>"));
1719                                 else if(layer->get_param(param_name).get_type()==ValueBase::TYPE_CANVAS)
1720                                 {
1721                                         if(!layer->set_param(param_name,canvas->surefind_canvas(str)))
1722                                                 error((*iter),_("Layer rejected canvas link"));
1723                                 }
1724                                 else
1725                                 try
1726                                 {
1727                                         handle<ValueNode> value_node=canvas->surefind_value_node(str);
1728
1729                                         // Assign the value_node to the dynamic parameter list
1730                                         if (param_name == "segment_list" && (layer->get_name() == "region" || layer->get_name() == "outline"))
1731                                         {
1732                                                 synfig::warning("%s: Updated valuenode connection to use the \"bline\" parameter instead of \"segment_list\".",
1733                                                                                 layer->get_name().c_str());
1734                                                 param_name = "bline";
1735                                         }
1736                                         layer->connect_dynamic_param(param_name,value_node);
1737                         }
1738                                 catch(Exception::IDNotFound)
1739                                 {
1740                                         error(child,strprintf(_("Unknown ID (%s) referenced in <param>"),str.c_str()));
1741                                 }
1742
1743                                 continue;
1744                         }
1745
1746                         xmlpp::Element::NodeList::iterator iter;
1747
1748                         // Search for the first non-text XML element
1749                         for(iter = list.begin(); iter != list.end(); ++iter)
1750                                 if(dynamic_cast<xmlpp::Element*>(*iter))
1751                                         break;
1752                                 //if(!(!dynamic_cast<xmlpp::Element*>(*iter) && (*iter)->get_name()=="text"||(*iter)->get_name()=="comment"   )) break;
1753
1754                         if(iter==list.end())
1755                         {
1756                                 error(child,_("<param> is either missing its contents, or missing a \"use\" attribute."));
1757                                 continue;
1758                         }
1759
1760                         // If we recognize the element name as a
1761                         // ValueBase, then treat is at one
1762                         if(/*(*iter)->get_name()!="canvas" && */ValueBase::ident_type((*iter)->get_name()) && !dynamic_cast<xmlpp::Element*>(*iter)->get_attribute("guid"))
1763                         {
1764                                 ValueBase data=parse_value(dynamic_cast<xmlpp::Element*>(*iter),canvas);
1765
1766                                 if(!data.is_valid())
1767                                 {
1768                                         error((*iter),_("Bad data for <param>"));
1769                                         continue;
1770                                 }
1771
1772                                 // Set the layer's parameter, and make sure that
1773                                 // the layer liked it
1774                                 if(!layer->set_param(param_name,data))
1775                                 {
1776                                         warning((*iter),strprintf(_("Layer '%s' rejected value for parameter '%s'"),
1777                                                                                           element->get_attribute("type")->get_value().c_str(),
1778                                                                                           param_name.c_str()));
1779                                         continue;
1780                                 }
1781                         }
1782                         else    // ... otherwise, we assume that it is a ValueNode
1783                         {
1784                                 handle<ValueNode> value_node=parse_value_node(dynamic_cast<xmlpp::Element*>(*iter),canvas);
1785
1786                                 if(!value_node)
1787                                 {
1788                                         error((*iter),_("Bad data for <param>"));
1789                                         continue;
1790                                 }
1791
1792                                 // Assign the value_node to the dynamic parameter list
1793                                 layer->connect_dynamic_param(param_name,value_node);
1794                         }
1795
1796                         // Warn if there is trash after the param value
1797                         for(iter++; iter != list.end(); ++iter)
1798                                 if(dynamic_cast<xmlpp::Element*>(*iter))
1799                                         warning((*iter),strprintf(_("Unexpected element <%s> after <param> data, ignoring..."),(*iter)->get_name().c_str()));
1800                         continue;
1801                 }
1802                 else
1803                         error_unexpected_element(child,child->get_name());
1804         }
1805
1806         layer->reset_version();
1807         return layer;
1808 }
1809
1810 Canvas::Handle
1811 CanvasParser::parse_canvas(xmlpp::Element *element,Canvas::Handle parent,bool inline_, String filename)
1812 {
1813
1814         if(element->get_name()!="canvas")
1815         {
1816                 error_unexpected_element(element,element->get_name(),"canvas");
1817                 return Canvas::Handle();
1818         }
1819         Canvas::Handle canvas;
1820
1821
1822
1823         if(parent && (element->get_attribute("id") || inline_))
1824         {
1825                 if(inline_)
1826                 {
1827                         canvas=Canvas::create_inline(parent);
1828                 }
1829                 else
1830                 {
1831                         try
1832                         {
1833                                 canvas=parent->find_canvas(element->get_attribute("id")->get_value());
1834                         }
1835                         catch(...)
1836                         {
1837                                 canvas=parent->new_child_canvas(element->get_attribute("id")->get_value());
1838                         }
1839                 }
1840                 canvas->rend_desc().clear_flags();
1841         }
1842         else
1843         {
1844                 canvas=Canvas::create();
1845                 if(filename=="/dev/stdin")
1846                         canvas->set_file_name("./stdin.sif");
1847                 else
1848                         canvas->set_file_name(filename);
1849                 canvas->rend_desc().clear_flags();
1850         }
1851
1852         if(element->get_attribute("guid"))
1853         {
1854                 GUID guid(element->get_attribute("guid")->get_value());
1855                 if(guid_cast<Canvas>(guid))
1856                         return guid_cast<Canvas>(guid);
1857                 else
1858                         canvas->set_guid(guid);
1859         }
1860
1861         if(element->get_attribute("version"))
1862                 canvas->set_version(element->get_attribute("version")->get_value());
1863         else if(parent)
1864                 canvas->set_version(parent->get_version());
1865
1866         if(element->get_attribute("width"))
1867         {
1868                 int width = atoi(element->get_attribute("width")->get_value().c_str());
1869                 if (width < 1)
1870                         fatal_error(element, _("Canvas with width or height less than one is not allowed"));
1871                 canvas->rend_desc().set_w(width);
1872         }
1873
1874         if(element->get_attribute("height"))
1875         {
1876                 int height = atoi(element->get_attribute("height")->get_value().c_str());
1877                 if (height < 1)
1878                         fatal_error(element, _("Canvas with width or height less than one is not allowed"));
1879                 canvas->rend_desc().set_h(height);
1880         }
1881
1882         if(element->get_attribute("xres"))
1883                 canvas->rend_desc().set_x_res(atof(element->get_attribute("xres")->get_value().c_str()));
1884
1885         if(element->get_attribute("yres"))
1886                 canvas->rend_desc().set_y_res(atof(element->get_attribute("yres")->get_value().c_str()));
1887
1888
1889         if(element->get_attribute("fps"))
1890                 canvas->rend_desc().set_frame_rate(atof(element->get_attribute("fps")->get_value().c_str()));
1891
1892         if(element->get_attribute("start-time"))
1893                 canvas->rend_desc().set_time_start(Time(element->get_attribute("start-time")->get_value(),canvas->rend_desc().get_frame_rate()));
1894
1895         if(element->get_attribute("begin-time"))
1896                 canvas->rend_desc().set_time_start(Time(element->get_attribute("begin-time")->get_value(),canvas->rend_desc().get_frame_rate()));
1897
1898         if(element->get_attribute("end-time"))
1899                 canvas->rend_desc().set_time_end(Time(element->get_attribute("end-time")->get_value(),canvas->rend_desc().get_frame_rate()));
1900
1901         if(element->get_attribute("antialias"))
1902                 canvas->rend_desc().set_antialias(atoi(element->get_attribute("antialias")->get_value().c_str()));
1903
1904         if(element->get_attribute("view-box"))
1905         {
1906                 string values=element->get_attribute("view-box")->get_value();
1907                 Vector
1908                         tl,
1909                         br;
1910                 tl[0]=atof(string(values.data(),values.find(' ')).c_str());
1911                 values=string(values.begin()+values.find(' ')+1,values.end());
1912                 tl[1]=atof(string(values.data(),values.find(' ')).c_str());
1913                 values=string(values.begin()+values.find(' ')+1,values.end());
1914                 br[0]=atof(string(values.data(),values.find(' ')).c_str());
1915                 values=string(values.begin()+values.find(' ')+1,values.end());
1916                 br[1]=atof(values.c_str());
1917
1918                 canvas->rend_desc().set_tl(tl);
1919                 canvas->rend_desc().set_br(br);
1920         }
1921
1922         if(element->get_attribute("bgcolor"))
1923         {
1924                 string values=element->get_attribute("bgcolor")->get_value();
1925                 Color bg;
1926
1927                 bg.set_r(atof(string(values.data(),values.find(' ')).c_str()));
1928                 values=string(values.begin()+values.find(' ')+1,values.end());
1929
1930                 bg.set_g(atof(string(values.data(),values.find(' ')).c_str()));
1931                 values=string(values.begin()+values.find(' ')+1,values.end());
1932
1933                 bg.set_b(atof(string(values.data(),values.find(' ')).c_str()));
1934                 values=string(values.begin()+values.find(' ')+1,values.end());
1935
1936                 bg.set_a(atof(values.c_str()));
1937
1938                 canvas->rend_desc().set_bg_color(bg);
1939         }
1940
1941         if(element->get_attribute("focus"))
1942         {
1943                 string values=element->get_attribute("focus")->get_value();
1944                 Vector focus;
1945
1946                 focus[0]=atof(string(values.data(),values.find(' ')).c_str());
1947                 values=string(values.begin()+values.find(' ')+1,values.end());
1948                 focus[1]=atof(values.c_str());
1949
1950                 canvas->rend_desc().set_focus(focus);
1951         }
1952
1953         canvas->rend_desc().set_flags(RendDesc::PX_ASPECT|RendDesc::IM_SPAN);
1954
1955         xmlpp::Element::NodeList list = element->get_children();
1956         for(xmlpp::Element::NodeList::iterator iter = list.begin(); iter != list.end(); ++iter)
1957         {
1958                 xmlpp::Element *child(dynamic_cast<xmlpp::Element*>(*iter));
1959                 if(child)
1960                 {
1961                         if(child->get_name()=="defs")
1962                         {
1963                                 if(canvas->is_inline())
1964                                         error(child,_("Inline canvas cannot have a <defs> section"));
1965                                 parse_canvas_defs(child, canvas);
1966                         }
1967                         else
1968                         if(child->get_name()=="keyframe")
1969                         {
1970                                 if(canvas->is_inline())
1971                                 {
1972                                         warning(child,_("Inline canvas cannot have keyframes"));
1973                                         continue;
1974                                 }
1975
1976                                 canvas->keyframe_list().add(parse_keyframe(child,canvas));
1977                                 canvas->keyframe_list().sync();
1978                         }
1979                         else
1980                         if(child->get_name()=="meta")
1981                         {
1982                                 if(canvas->is_inline())
1983                                 {
1984                                         warning(child,_("Inline canvases cannot have metadata"));
1985                                         continue;
1986                                 }
1987
1988                                 String name,content;
1989
1990                                 if(!child->get_attribute("name"))
1991                                 {
1992                                         warning(child,_("<meta> must have a name"));
1993                                         continue;
1994                                 }
1995
1996                                 if(!child->get_attribute("content"))
1997                                 {
1998                                         warning(child,_("<meta> must have content"));
1999                                         continue;
2000                                 }
2001
2002                                 canvas->set_meta_data(child->get_attribute("name")->get_value(),child->get_attribute("content")->get_value());
2003                         }
2004                         else if(child->get_name()=="name")
2005                         {
2006                                 xmlpp::Element::NodeList list = child->get_children();
2007
2008                                 // If we don't have any name, warn
2009                                 if(list.empty())
2010                                         warning(child,_("blank \"name\" entity"));
2011
2012                                 string tmp;
2013                                 for(xmlpp::Element::NodeList::iterator iter = list.begin(); iter != list.end(); ++iter)
2014                                         if(dynamic_cast<xmlpp::TextNode*>(*iter))tmp+=dynamic_cast<xmlpp::TextNode*>(*iter)->get_content();
2015                                 canvas->set_name(tmp);
2016                         }
2017                         else
2018                         if(child->get_name()=="desc")
2019                         {
2020
2021                                 xmlpp::Element::NodeList list = child->get_children();
2022
2023                                 // If we don't have any description, warn
2024                                 if(list.empty())
2025                                         warning(child,_("blank \"desc\" entity"));
2026
2027                                 string tmp;
2028                                 for(xmlpp::Element::NodeList::iterator iter = list.begin(); iter != list.end(); ++iter)
2029                                         if(dynamic_cast<xmlpp::TextNode*>(*iter))tmp+=dynamic_cast<xmlpp::TextNode*>(*iter)->get_content();
2030                                 canvas->set_description(tmp);
2031                         }
2032                         else
2033                         if(child->get_name()=="author")
2034                         {
2035
2036                                 xmlpp::Element::NodeList list = child->get_children();
2037
2038                                 // If we don't have any description, warn
2039                                 if(list.empty())
2040                                         warning(child,_("blank \"author\" entity"));
2041
2042                                 string tmp;
2043                                 for(xmlpp::Element::NodeList::iterator iter = list.begin(); iter != list.end(); ++iter)
2044                                         if(dynamic_cast<xmlpp::TextNode*>(*iter))tmp+=dynamic_cast<xmlpp::TextNode*>(*iter)->get_content();
2045                                 canvas->set_author(tmp);
2046                         }
2047                         else
2048                         if(child->get_name()=="layer")
2049                         {
2050                                 //if(canvas->is_inline())
2051                                 //      canvas->push_front(parse_layer(child,canvas->parent()));
2052                                 //else
2053                                         canvas->push_front(parse_layer(child,canvas));
2054                         }
2055                         else
2056                                 error_unexpected_element(child,child->get_name());
2057                 }
2058 //              else
2059 //              if((child->get_name()=="text"||child->get_name()=="comment") && child->has_child_text())
2060 //                      continue;
2061         }
2062
2063         if(canvas->value_node_list().placeholder_count())
2064         {
2065                 String nodes;
2066                 for (ValueNodeList::const_iterator iter = canvas->value_node_list().begin(); iter != canvas->value_node_list().end(); iter++)
2067                         if(PlaceholderValueNode::Handle::cast_dynamic(*iter))
2068                         {
2069                                 if (nodes != "") nodes += ", ";
2070                                 nodes += "'" + (*iter)->get_id() + "'";
2071                         }
2072                 error(element,strprintf(_("Canvas '%s' has undefined %s: %s"),
2073                                                                 canvas->get_id().c_str(),
2074                                                                 canvas->value_node_list().placeholder_count() == 1 ? _("ValueNode") : _("ValueNodes"),
2075                                                                 nodes.c_str()));
2076         }
2077
2078         canvas->set_version(CURRENT_CANVAS_VERSION);
2079         return canvas;
2080 }
2081
2082 Canvas::Handle
2083 CanvasParser::parse_from_file_as(const String &file_,const String &as_,String &errors)
2084 {
2085         try
2086         {
2087         ChangeLocale change_locale(LC_NUMERIC, "C");
2088                 String file(unix_to_local_path(file_));
2089                 String as(unix_to_local_path(as_));
2090
2091                 if(get_open_canvas_map().count(etl::absolute_path(as)))
2092                         return get_open_canvas_map()[etl::absolute_path(as)];
2093
2094                 filename=as;
2095                 total_warnings_=0;
2096                 xmlpp::DomParser parser(file);
2097                 if(parser)
2098                 {
2099                         Canvas::Handle canvas(parse_canvas(parser.get_document()->get_root_node(),0,false,as));
2100                         get_open_canvas_map()[etl::absolute_path(as)]=canvas;
2101                         canvas->signal_deleted().connect(sigc::bind(sigc::ptr_fun(_remove_from_open_canvas_map),canvas.get()));
2102                         canvas->signal_file_name_changed().connect(sigc::bind(sigc::ptr_fun(_canvas_file_name_changed),canvas.get()));
2103
2104                         const ValueNodeList& value_node_list(canvas->value_node_list());
2105
2106                         again:
2107                         ValueNodeList::const_iterator iter;
2108                         for(iter=value_node_list.begin();iter!=value_node_list.end();++iter)
2109                         {
2110                                 ValueNode::Handle value_node(*iter);
2111                                 if(value_node->is_exported() && value_node->get_id().find("Unnamed")==0)
2112                                 {
2113                                         canvas->remove_value_node(value_node);
2114                                         goto again;
2115                                 }
2116                         }
2117
2118                         return canvas;
2119                 }
2120         }
2121         catch(Exception::BadLinkName) { synfig::error("BadLinkName Thrown"); }
2122         catch(Exception::BadType) { synfig::error("BadType Thrown"); }
2123         catch(Exception::FileNotFound) { synfig::error("FileNotFound Thrown"); }
2124         catch(Exception::IDNotFound) { synfig::error("IDNotFound Thrown"); }
2125         catch(Exception::IDAlreadyExists) { synfig::error("IDAlreadyExists Thrown"); }
2126         catch(const std::exception& ex)
2127         {
2128                 synfig::error("Standard Exception: "+String(ex.what()));
2129                 errors = ex.what();
2130                 return Canvas::Handle();
2131         }
2132         catch(const String& str)
2133         {
2134                 cerr<<str<<endl;
2135                 //      synfig::error(str);
2136                 errors = str;
2137                 return Canvas::Handle();
2138         }
2139         return Canvas::Handle();
2140 }