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