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