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