Use an enumeration type rather than unnamed integers to specify the different types...
[synfig.git] / synfig-core / trunk / src / synfig / savecanvas.cpp
1 /* === S Y N F I G ========================================================= */
2 /*!     \file savecanvas.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 Chris Moore
10 **
11 **      This package is free software; you can redistribute it and/or
12 **      modify it under the terms of the GNU General Public License as
13 **      published by the Free Software Foundation; either version 2 of
14 **      the License, or (at your option) any later version.
15 **
16 **      This package is distributed in the hope that it will be useful,
17 **      but WITHOUT ANY WARRANTY; without even the implied warranty of
18 **      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 **      General Public License for more details.
20 **      \endlegal
21 */
22 /* ========================================================================= */
23
24 /* === H E A D E R S ======================================================= */
25
26 #ifdef USING_PCH
27 #       include "pch.h"
28 #else
29 #ifdef HAVE_CONFIG_H
30 #       include <config.h>
31 #endif
32
33 #ifdef HAVE_SYS_ERRNO_H
34 #       include <sys/errno.h>
35 #endif
36
37 #include "savecanvas.h"
38 #include "general.h"
39 #include "valuenode.h"
40 #include "valuenode_subtract.h"
41 #include "valuenode_animated.h"
42 #include "valuenode_composite.h"
43 #include "valuenode_const.h"
44 #include "valuenode_linear.h"
45 #include "valuenode_dynamiclist.h"
46 #include "valuenode_reference.h"
47 #include "valuenode_segcalctangent.h"
48 #include "valuenode_segcalcvertex.h"
49 #include "valuenode_bline.h"
50 #include "time.h"
51 #include "keyframe.h"
52 #include "layer.h"
53 #include "string.h"
54 #include "paramdesc.h"
55
56 #include <libxml++/libxml++.h>
57 #include <ETL/stringf>
58 #include "gradient.h"
59 #include <errno.h>
60
61 extern "C" {
62 #include <libxml/tree.h>
63 }
64
65 #endif
66
67 /* === U S I N G =========================================================== */
68
69 using namespace std;
70 using namespace etl;
71 using namespace synfig;
72
73 /* === M A C R O S ========================================================= */
74
75 #define COLOR_VALUE_TYPE_FORMAT         "%f"
76 #define VECTOR_VALUE_TYPE_FORMAT        "%0.10f"
77 #define TIME_TYPE_FORMAT                        "%0.3f"
78 #define VIEW_BOX_FORMAT                         "%f %f %f %f"
79
80 /* === G L O B A L S ======================================================= */
81
82 /* === P R O C E D U R E S ================================================= */
83
84 xmlpp::Element* encode_canvas(xmlpp::Element* root,Canvas::ConstHandle canvas);
85 xmlpp::Element* encode_value_node(xmlpp::Element* root,ValueNode::ConstHandle value_node,Canvas::ConstHandle canvas);
86
87 xmlpp::Element* encode_keyframe(xmlpp::Element* root,const Keyframe &kf, float fps)
88 {
89         root->set_name("keyframe");
90         root->set_attribute("time",kf.get_time().get_string(fps));
91         if(!kf.get_description().empty())
92                 root->set_child_text(kf.get_description());
93         return root;
94 }
95
96
97 xmlpp::Element* encode_real(xmlpp::Element* root,Real v)
98 {
99         root->set_name("real");
100         root->set_attribute("value",strprintf(VECTOR_VALUE_TYPE_FORMAT,v));
101         return root;
102 }
103
104 xmlpp::Element* encode_time(xmlpp::Element* root,Time t, float /*fps*/=0)
105 {
106         root->set_name("time");
107         //root->set_attribute("value",t.get_string(fps));
108         root->set_attribute("value",t.get_string());
109         return root;
110 }
111
112 xmlpp::Element* encode_integer(xmlpp::Element* root,int i)
113 {
114         root->set_name("integer");
115         root->set_attribute("value",strprintf("%i",i));
116         return root;
117 }
118
119 xmlpp::Element* encode_bool(xmlpp::Element* root,bool b)
120 {
121         root->set_name("bool");
122         root->set_attribute("value",b?"true":"false");
123         return root;
124 }
125
126 xmlpp::Element* encode_string(xmlpp::Element* root,const String &str)
127 {
128         root->set_name("string");
129         root->set_child_text(str);
130         return root;
131 }
132
133 xmlpp::Element* encode_vector(xmlpp::Element* root,Vector vect)
134 {
135         root->set_name("vector");
136         root->add_child("x")->set_child_text(strprintf(VECTOR_VALUE_TYPE_FORMAT,(float)vect[0]));
137         root->add_child("y")->set_child_text(strprintf(VECTOR_VALUE_TYPE_FORMAT,(float)vect[1]));
138         return root;
139 }
140
141 xmlpp::Element* encode_color(xmlpp::Element* root,Color color)
142 {
143         root->set_name("color");
144         root->add_child("r")->set_child_text(strprintf(COLOR_VALUE_TYPE_FORMAT,(float)color.get_r()));
145         root->add_child("g")->set_child_text(strprintf(COLOR_VALUE_TYPE_FORMAT,(float)color.get_g()));
146         root->add_child("b")->set_child_text(strprintf(COLOR_VALUE_TYPE_FORMAT,(float)color.get_b()));
147         root->add_child("a")->set_child_text(strprintf(COLOR_VALUE_TYPE_FORMAT,(float)color.get_a()));
148         return root;
149 }
150
151 xmlpp::Element* encode_angle(xmlpp::Element* root,Angle theta)
152 {
153         root->set_name("angle");
154         root->set_attribute("value",strprintf("%f",(float)Angle::deg(theta).get()));
155         return root;
156 }
157
158 xmlpp::Element* encode_segment(xmlpp::Element* root,Segment seg)
159 {
160         root->set_name("segment");
161         encode_vector(root->add_child("p1")->add_child("vector"),seg.p1);
162         encode_vector(root->add_child("t1")->add_child("vector"),seg.t1);
163         encode_vector(root->add_child("p2")->add_child("vector"),seg.p2);
164         encode_vector(root->add_child("t2")->add_child("vector"),seg.t2);
165         return root;
166 }
167
168 xmlpp::Element* encode_bline_point(xmlpp::Element* root,BLinePoint bline_point)
169 {
170         root->set_name(ValueBase::type_name(ValueBase::TYPE_BLINEPOINT));
171
172         encode_vector(root->add_child("vertex")->add_child("vector"),bline_point.get_vertex());
173         encode_vector(root->add_child("t1")->add_child("vector"),bline_point.get_tangent1());
174
175         if(bline_point.get_split_tangent_flag())
176                 encode_vector(root->add_child("t2")->add_child("vector"),bline_point.get_tangent2());
177
178         encode_real(root->add_child("width")->add_child("real"),bline_point.get_width());
179         encode_real(root->add_child("origin")->add_child("real"),bline_point.get_origin());
180         return root;
181 }
182
183 xmlpp::Element* encode_gradient(xmlpp::Element* root,Gradient x)
184 {
185         root->set_name("gradient");
186
187         Gradient::const_iterator iter;
188         x.sort();
189         for(iter=x.begin();iter!=x.end();iter++)
190         {
191                 xmlpp::Element *cpoint(encode_color(root->add_child("color"),iter->color));
192                 cpoint->set_attribute("pos",strprintf("%f",iter->pos));
193         }
194         return root;
195 }
196
197
198 xmlpp::Element* encode_value(xmlpp::Element* root,const ValueBase &data,Canvas::ConstHandle canvas=0);
199
200 xmlpp::Element* encode_list(xmlpp::Element* root,std::list<ValueBase> list, Canvas::ConstHandle canvas=0)
201 {
202         root->set_name("list");
203
204         while(!list.empty())
205         {
206                 encode_value(root->add_child("value"),list.front(),canvas);
207                 list.pop_front();
208         }
209
210         return root;
211 }
212
213 xmlpp::Element* encode_value(xmlpp::Element* root,const ValueBase &data,Canvas::ConstHandle canvas)
214 {
215         switch(data.get_type())
216         {
217         case ValueBase::TYPE_REAL:
218                 return encode_real(root,data.get(Real()));
219         case ValueBase::TYPE_TIME:
220                 if(canvas)
221                         return encode_time(root,data.get(Time()),canvas->rend_desc().get_frame_rate());
222                 else
223                         return encode_time(root,data.get(Time()));
224         case ValueBase::TYPE_INTEGER:
225                 return encode_integer(root,data.get(int()));
226         case ValueBase::TYPE_COLOR:
227                 return encode_color(root,data.get(Color()));
228         case ValueBase::TYPE_VECTOR:
229                 return encode_vector(root,data.get(Vector()));
230         case ValueBase::TYPE_ANGLE:
231                 return encode_angle(root,data.get(Angle()));
232         case ValueBase::TYPE_BOOL:
233                 return encode_bool(root,data.get(bool()));
234         case ValueBase::TYPE_STRING:
235                 return encode_string(root,data.get(String()));
236         case ValueBase::TYPE_SEGMENT:
237                 return encode_segment(root,data.get(Segment()));
238         case ValueBase::TYPE_BLINEPOINT:
239                 return encode_bline_point(root,data.get(BLinePoint()));
240         case ValueBase::TYPE_GRADIENT:
241                 return encode_gradient(root,data.get(Gradient()));
242         case ValueBase::TYPE_LIST:
243                 return encode_list(root,data,canvas);
244         case ValueBase::TYPE_CANVAS:
245                 return encode_canvas(root,data.get(Canvas::Handle()).get());
246         case ValueBase::TYPE_NIL:
247                 synfig::error("Encountered NIL ValueBase");
248                 root->set_name("nil");
249                 return root;
250         default:
251                 synfig::error(strprintf("Unknown value(%s), cannot create XML representation!",ValueBase::type_name(data.get_type()).c_str()));
252                 root->set_name("nil");
253                 return root;
254         }
255 }
256
257 xmlpp::Element* encode_animated(xmlpp::Element* root,ValueNode_Animated::ConstHandle value_node,Canvas::ConstHandle canvas=0)
258 {
259         assert(value_node);
260         root->set_name("animated");
261
262         root->set_attribute("type",ValueBase::type_name(value_node->get_type()));
263
264         const ValueNode_Animated::WaypointList &waypoint_list=value_node->waypoint_list();
265         ValueNode_Animated::WaypointList::const_iterator iter;
266
267         for(iter=waypoint_list.begin();iter!=waypoint_list.end();++iter)
268         {
269                 xmlpp::Element *waypoint_node=root->add_child("waypoint");
270                 //waypoint_node->set_attribute("time",iter->get_time().get_string(canvas->rend_desc().get_frame_rate()));
271                 waypoint_node->set_attribute("time",iter->get_time().get_string());
272
273                 //waypoint_node->add_child(encode_value(iter->get_value(),canvas));
274                 if(iter->get_value_node()->is_exported())
275                         waypoint_node->set_attribute("use",iter->get_value_node()->get_relative_id(canvas));
276                 else {
277                         ValueNode::ConstHandle value_node = iter->get_value_node();
278                         if(ValueNode_Const::ConstHandle::cast_dynamic(value_node)) {
279                                 const ValueBase data = ValueNode_Const::ConstHandle::cast_dynamic(value_node)->get_value();
280                                 if (data.get_type() == ValueBase::TYPE_CANVAS)
281                                         waypoint_node->set_attribute("use",data.get(Canvas::Handle()).get()->get_relative_id(canvas));
282                                 else
283                                         encode_value_node(waypoint_node->add_child("value_node"),iter->get_value_node(),canvas);
284                         }
285                         else
286                                 encode_value_node(waypoint_node->add_child("value_node"),iter->get_value_node(),canvas);
287                 }
288
289                 switch(iter->get_before())
290                 {
291                 case INTERPOLATION_HALT:
292                         waypoint_node->set_attribute("before","halt");
293                         break;
294                 case INTERPOLATION_LINEAR:
295                         // This is the default value for angles, so don't add a new attribute for them
296                         if (value_node->get_type() != ValueBase::TYPE_ANGLE)
297                                 waypoint_node->set_attribute("before","linear");
298                         break;
299                 case INTERPOLATION_MANUAL:
300                         waypoint_node->set_attribute("before","manual");
301                         break;
302                 case INTERPOLATION_CONSTANT:
303                         waypoint_node->set_attribute("before","constant");
304                         break;
305                 case INTERPOLATION_TCB:
306                         // This is the default value, so don't add a new attribute (unless it's an angle - they default to linear)
307                         if (value_node->get_type() == ValueBase::TYPE_ANGLE)
308                                 waypoint_node->set_attribute("before","auto");
309                         break;
310                 default:
311                         error("Unknown waypoint type for \"before\" attribute");
312                 }
313
314                 switch(iter->get_after())
315                 {
316                 case INTERPOLATION_HALT:
317                         waypoint_node->set_attribute("after","halt");
318                         break;
319                 case INTERPOLATION_LINEAR:
320                         // This is the default value for angles, so don't add a new attribute for them
321                         if (value_node->get_type() != ValueBase::TYPE_ANGLE)
322                                 waypoint_node->set_attribute("after","linear");
323                         break;
324                 case INTERPOLATION_MANUAL:
325                         waypoint_node->set_attribute("after","manual");
326                         break;
327                 case INTERPOLATION_CONSTANT:
328                         waypoint_node->set_attribute("after","constant");
329                         break;
330                 case INTERPOLATION_TCB:
331                         // This is the default value, so don't add a new attribute (unless it's an angle - they default to linear)
332                         if (value_node->get_type() == ValueBase::TYPE_ANGLE)
333                                 waypoint_node->set_attribute("after","auto");
334                         break;
335                 default:
336                         error("Unknown waypoint type for \"after\" attribute");
337                 }
338
339                 if(iter->get_tension()!=0.0)
340                         waypoint_node->set_attribute("tension",strprintf("%f",iter->get_tension()));
341                 if(iter->get_time_tension()!=0.0)
342                         waypoint_node->set_attribute("temporal-tension",strprintf("%f",iter->get_time_tension()));
343                 if(iter->get_continuity()!=0.0)
344                         waypoint_node->set_attribute("continuity",strprintf("%f",iter->get_continuity()));
345                 if(iter->get_bias()!=0.0)
346                         waypoint_node->set_attribute("bias",strprintf("%f",iter->get_bias()));
347
348         }
349
350         return root;
351 }
352
353 xmlpp::Element* encode_composite(xmlpp::Element* root,ValueNode_Composite::ConstHandle value_node,Canvas::ConstHandle canvas=0)
354 {
355         assert(value_node);
356         root->set_name("composite");
357
358         root->set_attribute("type",ValueBase::type_name(value_node->get_type()));
359
360         int i;
361         for(i=0;i<value_node->link_count();i++)
362         {
363                 string name(strprintf("c%d",i+1));
364                 assert(value_node->get_link(i));
365                 if(value_node->get_link(i)->is_exported())
366                         root->set_attribute(name,value_node->get_link(i)->get_relative_id(canvas));
367                 else
368                         encode_value_node(root->add_child(name)->add_child("value_node"),value_node->get_link(i).constant(),canvas);
369         }
370
371         return root;
372 }
373
374 xmlpp::Element* encode_subtract(xmlpp::Element* root,ValueNode_Subtract::ConstHandle value_node,Canvas::ConstHandle canvas=0)
375 {
376         assert(value_node);
377         root->set_name("subtract");
378
379         ValueNode::ConstHandle lhs=value_node->get_lhs();
380         ValueNode::ConstHandle rhs=value_node->get_rhs();
381         ValueNode::ConstHandle scalar=value_node->get_scalar();
382
383         assert(lhs);
384         assert(rhs);
385
386         root->set_attribute("type",ValueBase::type_name(value_node->get_type()));
387
388         if(lhs==rhs)
389                 warning("LHS is equal to RHS, this <subtract> will always be zero!");
390
391         //if(value_node->get_scalar()!=1)
392         //      root->set_attribute("scalar",strprintf(VECTOR_VALUE_TYPE_FORMAT,value_node->get_scalar()));
393
394         if(!scalar->get_id().empty())
395                 root->set_attribute("scalar",scalar->get_relative_id(canvas));
396         else
397                 encode_value_node(root->add_child("scalar")->add_child("value_node"),scalar,canvas);
398
399         if(!lhs->get_id().empty())
400                 root->set_attribute("lhs",lhs->get_relative_id(canvas));
401         else
402                 encode_value_node(root->add_child("lhs")->add_child("value_node"),lhs,canvas);
403
404         if(!rhs->get_id().empty())
405                 root->set_attribute("rhs",rhs->get_relative_id(canvas));
406         else
407                 encode_value_node(root->add_child("rhs")->add_child("value_node"),rhs,canvas);
408
409         return root;
410 }
411
412 xmlpp::Element* encode_dynamic_list(xmlpp::Element* root,ValueNode_DynamicList::ConstHandle value_node,Canvas::ConstHandle canvas=0)
413 {
414         assert(value_node);
415         const float fps(canvas?canvas->rend_desc().get_frame_rate():0);
416
417         root->set_name(value_node->get_name());
418
419         root->set_attribute("type",ValueBase::type_name(value_node->get_contained_type()));
420
421         vector<ValueNode_DynamicList::ListEntry>::const_iterator iter;
422
423         ValueNode_BLine::ConstHandle bline_value_node(ValueNode_BLine::ConstHandle::cast_dynamic(value_node));
424
425         if(bline_value_node)
426         {
427                 if(bline_value_node->get_loop())
428                         root->set_attribute("loop","true");
429                 else
430                         root->set_attribute("loop","false");
431         }
432
433         for(iter=value_node->list.begin();iter!=value_node->list.end();++iter)
434         {
435                 xmlpp::Element  *entry_node=root->add_child("entry");
436                 assert(iter->value_node);
437                 if(!iter->value_node->get_id().empty())
438                         entry_node->set_attribute("use",iter->value_node->get_relative_id(canvas));
439                 else
440                         encode_value_node(entry_node->add_child("value_node"),iter->value_node,canvas);
441
442                 // process waypoints
443                 {
444                         typedef synfig::ValueNode_DynamicList::ListEntry::Activepoint Activepoint;
445                         typedef synfig::ValueNode_DynamicList::ListEntry::ActivepointList ActivepointList;
446                         String begin_sequence;
447                         String end_sequence;
448
449                         const ActivepointList& timing_info(iter->timing_info);
450                         ActivepointList::const_iterator entry_iter;
451
452                         for(entry_iter=timing_info.begin();entry_iter!=timing_info.end();++entry_iter)
453                                 if(entry_iter->state==true)
454                                 {
455                                         if(entry_iter->priority)
456                                         {
457                                                 printf("begin priority is %d\n", entry_iter->priority);
458                                                 begin_sequence+=strprintf("p%d ",entry_iter->priority);
459                                         }
460                                         begin_sequence+=entry_iter->time.get_string(fps)+", ";
461                                 }
462                                 else
463                                 {
464                                         if(entry_iter->priority)
465                                         {
466                                                 printf("end priority is %d\n", entry_iter->priority);
467                                                 end_sequence+=strprintf("p%d ",entry_iter->priority);
468                                         }
469                                         end_sequence+=entry_iter->time.get_string(fps)+", ";
470                                 }
471
472                         // If this is just a plane-jane vanilla entry,
473                         // then don't bother with begins and ends
474                         if(end_sequence.empty() && begin_sequence=="SOT, ")
475                                 begin_sequence.clear();
476
477                         if(!begin_sequence.empty())
478                         {
479                                 // Remove the last ", " stuff
480                                 begin_sequence=String(begin_sequence.begin(),begin_sequence.end()-2);
481                                 // Add the attribute
482                                 entry_node->set_attribute("on",begin_sequence);
483                         }
484
485                         if(!end_sequence.empty())
486                         {
487                                 // Remove the last ", " stuff
488                                 end_sequence=String(end_sequence.begin(),end_sequence.end()-2);
489                                 // Add the attribute
490                                 entry_node->set_attribute("off",end_sequence);
491                         }
492                 }
493         }
494
495         return root;
496 }
497
498 // Generic linkable data node entry
499 xmlpp::Element* encode_linkable_value_node(xmlpp::Element* root,LinkableValueNode::ConstHandle value_node,Canvas::ConstHandle canvas=0)
500 {
501         assert(value_node);
502         root->set_name(value_node->get_name());
503
504         root->set_attribute("type",ValueBase::type_name(value_node->get_type()));
505
506         int i;
507         for(i=0;i<value_node->link_count();i++)
508         {
509                 ValueNode::ConstHandle link=value_node->get_link(i).constant();
510                 if(!link)
511                         throw runtime_error("Bad link");
512                 if(link->is_exported())
513                         root->set_attribute(value_node->link_name(i),link->get_relative_id(canvas));
514                 else
515                         encode_value_node(root->add_child(value_node->link_name(i))->add_child("value_node"),link,canvas);
516         }
517
518         return root;
519 }
520
521 xmlpp::Element* encode_value_node(xmlpp::Element* root,ValueNode::ConstHandle value_node,Canvas::ConstHandle canvas)
522 {
523         assert(value_node);
524
525         if(ValueNode_Animated::ConstHandle::cast_dynamic(value_node))
526                 encode_animated(root,ValueNode_Animated::ConstHandle::cast_dynamic(value_node),canvas);
527         else
528         if(ValueNode_Composite::ConstHandle::cast_dynamic(value_node))
529                 encode_composite(root,ValueNode_Composite::ConstHandle::cast_dynamic(value_node),canvas);
530         else
531         if(ValueNode_Subtract::ConstHandle::cast_dynamic(value_node))
532                 encode_subtract(root,ValueNode_Subtract::ConstHandle::cast_dynamic(value_node),canvas);
533         else
534         if(ValueNode_DynamicList::ConstHandle::cast_dynamic(value_node))
535                 encode_dynamic_list(root,ValueNode_DynamicList::ConstHandle::cast_dynamic(value_node),canvas);
536         else if(ValueNode_Const::ConstHandle::cast_dynamic(value_node))
537         {
538                 encode_value(root,ValueNode_Const::ConstHandle::cast_dynamic(value_node)->get_value(),canvas);
539         }
540         else
541         if(LinkableValueNode::ConstHandle::cast_dynamic(value_node))
542                 encode_linkable_value_node(root,LinkableValueNode::ConstHandle::cast_dynamic(value_node),canvas);
543         else
544         {
545                 error(_("Unknown ValueNode Type (%s), cannot create an XML representation"),value_node->get_local_name().c_str());
546                 root->set_name("nil");
547         }
548
549         assert(root);
550
551         if(!value_node->get_id().empty())
552                 root->set_attribute("id",value_node->get_id());
553
554         if(value_node->rcount()>1)
555                 root->set_attribute("guid",(value_node->get_guid()^canvas->get_root()->get_guid()).get_string());
556
557         return root;
558 }
559
560 xmlpp::Element* encode_layer(xmlpp::Element* root,Layer::ConstHandle layer)
561 {
562         root->set_name("layer");
563
564         root->set_attribute("type",layer->get_name());
565         root->set_attribute("active",layer->active()?"true":"false");
566
567         if(!layer->get_version().empty())
568                 root->set_attribute("version",layer->get_version());
569         if(!layer->get_description().empty())
570                 root->set_attribute("desc",layer->get_description());
571         if(!layer->get_group().empty())
572                 root->set_attribute("group",layer->get_group());
573
574         Layer::Vocab vocab(layer->get_param_vocab());
575         Layer::Vocab::const_iterator iter;
576
577         const Layer::DynamicParamList &dynamic_param_list=layer->dynamic_param_list();
578
579         for(iter=vocab.begin();iter!=vocab.end();++iter)
580         {
581                 // Handle dynamic parameters
582                 if(dynamic_param_list.count(iter->get_name()))
583                 {
584                         xmlpp::Element *node=root->add_child("param");
585                         node->set_attribute("name",iter->get_name());
586
587                         handle<const ValueNode> value_node=dynamic_param_list.find(iter->get_name())->second;
588
589                         // If the valuenode has no ID, then it must be defined in-place
590                         if(value_node->get_id().empty())
591                         {
592                                 encode_value_node(node->add_child("value_node"),value_node,layer->get_canvas().constant());
593                         }
594                         else
595                         {
596                                 node->set_attribute("use",value_node->get_relative_id(layer->get_canvas()));
597                         }
598                 }
599                 else  // Handle normal parameters
600                 if(iter->get_critical())
601                 {
602                         ValueBase value=layer->get_param(iter->get_name());
603                         if(!value.is_valid())
604                         {
605                                 error("Layer doesn't know its own vocabulary -- "+iter->get_name());
606                                 continue;
607                         }
608
609                         if(value.get_type()==ValueBase::TYPE_CANVAS)
610                         {
611                                 // the ->is_inline() below was crashing if the canvas
612                                 // contained a PasteCanvas with the default <No Image
613                                 // Selected> Canvas setting;  this avoids the crash
614                                 if (!value.get(Canvas::LooseHandle()))
615                                         continue;
616
617                                 if (!value.get(Canvas::LooseHandle())->is_inline())
618                                 {
619                                         Canvas::Handle child(value.get(Canvas::LooseHandle()));
620
621                                         if(!value.get(Canvas::Handle()))
622                                                 continue;
623                                         xmlpp::Element *node=root->add_child("param");
624                                         node->set_attribute("name",iter->get_name());
625                                         node->set_attribute("use",child->get_relative_id(layer->get_canvas()));
626                                         continue;
627                                 }
628                         }
629                         xmlpp::Element *node=root->add_child("param");
630                         node->set_attribute("name",iter->get_name());
631
632                         encode_value(node->add_child("value"),value,layer->get_canvas().constant());
633                 }
634         }
635
636
637         return root;
638 }
639
640 xmlpp::Element* encode_canvas(xmlpp::Element* root,Canvas::ConstHandle canvas)
641 {
642         assert(canvas);
643         const RendDesc &rend_desc=canvas->rend_desc();
644         root->set_name("canvas");
645
646         if(canvas->is_root())
647                 root->set_attribute("version","0.1");
648
649         if(!canvas->get_id().empty() && !canvas->is_root() && !canvas->is_inline())
650                 root->set_attribute("id",canvas->get_id());
651
652         if(!canvas->parent() || canvas->parent()->rend_desc().get_w()!=canvas->rend_desc().get_w())
653                 root->set_attribute("width",strprintf("%d",rend_desc.get_w()));
654
655         if(!canvas->parent() || canvas->parent()->rend_desc().get_h()!=canvas->rend_desc().get_h())
656                 root->set_attribute("height",strprintf("%d",rend_desc.get_h()));
657
658         if(!canvas->parent() || canvas->parent()->rend_desc().get_x_res()!=canvas->rend_desc().get_x_res())
659                 root->set_attribute("xres",strprintf("%f",rend_desc.get_x_res()));
660
661         if(!canvas->parent() || canvas->parent()->rend_desc().get_y_res()!=canvas->rend_desc().get_y_res())
662                 root->set_attribute("yres",strprintf("%f",rend_desc.get_y_res()));
663
664
665         if(!canvas->parent() ||
666                 canvas->parent()->rend_desc().get_tl()!=canvas->rend_desc().get_tl() ||
667                 canvas->parent()->rend_desc().get_br()!=canvas->rend_desc().get_br())
668         root->set_attribute("view-box",strprintf(VIEW_BOX_FORMAT,
669                 rend_desc.get_tl()[0],
670                 rend_desc.get_tl()[1],
671                 rend_desc.get_br()[0],
672                 rend_desc.get_br()[1])
673         );
674
675         if(!canvas->parent() || canvas->parent()->rend_desc().get_antialias()!=canvas->rend_desc().get_antialias())
676                 root->set_attribute("antialias",strprintf("%d",rend_desc.get_antialias()));
677
678         if(!canvas->parent())
679                 root->set_attribute("fps",strprintf(TIME_TYPE_FORMAT,rend_desc.get_frame_rate()));
680
681         if(!canvas->parent() || canvas->parent()->rend_desc().get_time_start()!=canvas->rend_desc().get_time_start())
682                 root->set_attribute("begin-time",rend_desc.get_time_start().get_string(rend_desc.get_frame_rate()));
683
684         if(!canvas->parent() || canvas->parent()->rend_desc().get_time_end()!=canvas->rend_desc().get_time_end())
685                 root->set_attribute("end-time",rend_desc.get_time_end().get_string(rend_desc.get_frame_rate()));
686
687         if(!canvas->is_inline())
688         {
689                 root->set_attribute("bgcolor",strprintf(VIEW_BOX_FORMAT,
690                         rend_desc.get_bg_color().get_r(),
691                         rend_desc.get_bg_color().get_g(),
692                         rend_desc.get_bg_color().get_b(),
693                         rend_desc.get_bg_color().get_a())
694                 );
695
696                 if(!canvas->get_name().empty())
697                         root->add_child("name")->set_child_text(canvas->get_name());
698                 if(!canvas->get_description().empty())
699                         root->add_child("desc")->set_child_text(canvas->get_description());
700                 if(!canvas->get_author().empty())
701                         root->add_child("author")->set_child_text(canvas->get_description());
702
703                 std::list<String> meta_keys(canvas->get_meta_data_keys());
704                 while(!meta_keys.empty())
705                 {
706                         xmlpp::Element* meta_element(root->add_child("meta"));
707                         meta_element->set_attribute("name",meta_keys.front());
708                         meta_element->set_attribute("content",canvas->get_meta_data(meta_keys.front()));
709                         meta_keys.pop_front();
710                 }
711                 for(KeyframeList::const_iterator iter=canvas->keyframe_list().begin();iter!=canvas->keyframe_list().end();++iter)
712                         encode_keyframe(root->add_child("keyframe"),*iter,canvas->rend_desc().get_frame_rate());
713         }
714
715         // Output the <defs> section
716         if(!canvas->is_inline() && !canvas->value_node_list().empty() || !canvas->children().empty())
717         {
718                 xmlpp::Element *node=root->add_child("defs");
719                 const ValueNodeList &value_node_list(canvas->value_node_list());
720
721                 for(ValueNodeList::const_iterator iter=value_node_list.begin();iter!=value_node_list.end();++iter)
722                 {
723                         // If the value_node is a constant, then use the shorthand
724                         if(handle<ValueNode_Const>::cast_dynamic(*iter))
725                         {
726                                 ValueNode_Const::Handle value_node(ValueNode_Const::Handle::cast_dynamic(*iter));
727                                 reinterpret_cast<xmlpp::Element*>(encode_value(node->add_child("value"),value_node->get_value()))->set_attribute("id",value_node->get_id());
728                                 continue;
729                         }
730                         encode_value_node(node->add_child("value_node"),*iter,canvas);
731                         // writeme
732                 }
733
734                 for(Canvas::Children::const_iterator iter=canvas->children().begin();iter!=canvas->children().end();++iter)
735                 {
736                         encode_canvas(node->add_child("canvas"),*iter);
737                 }
738         }
739
740         Canvas::const_reverse_iterator iter;
741
742         for(iter=canvas->rbegin();iter!=canvas->rend();++iter)
743                 encode_layer(root->add_child("layer"),*iter);
744
745         return root;
746 }
747
748 bool
749 synfig::save_canvas(const String &filename, Canvas::ConstHandle canvas)
750 {
751     ChangeLocale change_locale(LC_NUMERIC, "C");
752
753         synfig::String tmp_filename(filename+".TMP");
754
755         if (String(filename.begin() + filename.find_last_of('.')+1, filename.end()) == "sifz")
756                 xmlSetCompressMode(9);
757         else
758                 xmlSetCompressMode(0);
759
760         try
761         {
762                 assert(canvas);
763                 xmlpp::Document document;
764
765                 encode_canvas(document.create_root_node("canvas"),canvas);
766
767                 document.write_to_file_formatted(tmp_filename);
768         }
769         catch(...) { synfig::error("synfig::save_canvas(): Caught unknown exception"); return false; }
770
771
772 #ifdef _WIN32
773         // On Win32 platforms, rename() has bad behavior. work around it.
774         char old_file[80]="sif.XXXXXXXX";
775         mktemp(old_file);
776         rename(filename.c_str(),old_file);
777         if(rename(tmp_filename.c_str(),filename.c_str())!=0)
778         {
779                 rename(old_file,tmp_filename.c_str());
780                 synfig::error("synfig::save_canvas(): Unable to rename file to correct filename, errno=%d",errno);
781                 return false;
782         }
783         remove(old_file);
784 #else
785         if(rename(tmp_filename.c_str(),filename.c_str())!=0)
786         {
787                 synfig::error("synfig::save_canvas(): Unable to rename file to correct filename, errno=%d",errno);
788                 return false;
789         }
790 #endif
791
792         return true;
793 }
794
795 String
796 synfig::canvas_to_string(Canvas::ConstHandle canvas)
797 {
798     ChangeLocale change_locale(LC_NUMERIC, "C");
799         assert(canvas);
800
801         xmlpp::Document document;
802
803         encode_canvas(document.create_root_node("canvas"),canvas);
804
805         return document.write_to_string_formatted();
806 }