Partially fix 1702760: stop compiler warning about trgt_png.cpp.
[synfig.git] / synfig-core / trunk / src / synfig / valuenode.cpp
1 /* === S Y N F I G ========================================================= */
2 /*!     \file valuenode.cpp
3 **      \brief Template File
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 #define SYNFIG_NO_ANGLE
26
27 //#define HAS_HASH_MAP 1
28
29 #ifdef USING_PCH
30 #       include "pch.h"
31 #else
32 #ifdef HAVE_CONFIG_H
33 #       include <config.h>
34 #endif
35
36 #include "valuenode.h"
37 #include "general.h"
38 #include "canvas.h"
39
40 #include "valuenode_const.h"
41 #include "valuenode_linear.h"
42 #include "valuenode_composite.h"
43 #include "valuenode_reference.h"
44 #include "valuenode_scale.h"
45 #include "valuenode_segcalctangent.h"
46 #include "valuenode_segcalcvertex.h"
47 #include "valuenode_stripes.h"
48 #include "valuenode_subtract.h"
49 #include "valuenode_timedswap.h"
50 #include "valuenode_twotone.h"
51 #include "valuenode_bline.h"
52 #include "valuenode_dynamiclist.h"
53 #include "valuenode_radialcomposite.h"
54 #include "valuenode_gradientrotate.h"
55 #include "valuenode_sine.h"
56
57 #include "layer.h"
58
59 #endif
60
61 /* === U S I N G =========================================================== */
62
63 using namespace std;
64 using namespace etl;
65 using namespace synfig;
66
67 /* === M A C R O S ========================================================= */
68
69 /* === G L O B A L S ======================================================= */
70
71 static int value_node_count(0);
72
73 static LinkableValueNode::Book *book_;
74
75
76 ValueNode::LooseHandle
77 synfig::find_value_node(const GUID& guid)
78 {
79         return guid_cast<ValueNode>(guid);
80 }
81
82 /* === P R O C E D U R E S ================================================= */
83
84 /* === M E T H O D S ======================================================= */
85
86 bool
87 ValueNode::subsys_init()
88 {
89         book_=new LinkableValueNode::Book();
90
91 #define ADD_VALUENODE(c,n) (*book_)[n].factory=reinterpret_cast<LinkableValueNode::Factory>(&c::create); (*book_)[n].check_type=&c::check_type;(*book_)[n].local_name=n
92 #define ADD_VALUENODE2(c,n) (*book_)[n].factory=reinterpret_cast<LinkableValueNode::Factory>(&c::create_from); (*book_)[n].check_type=&c::check_type;(*book_)[n].local_name=n
93
94         ADD_VALUENODE(ValueNode_Linear,"linear");
95         ADD_VALUENODE(ValueNode_Composite,"composite");
96         ADD_VALUENODE(ValueNode_RadialComposite,"radial_composite");
97         ADD_VALUENODE(ValueNode_Reference,"reference");
98         ADD_VALUENODE(ValueNode_Scale,"scale");
99         ADD_VALUENODE(ValueNode_SegCalcTangent,"segcalctangent");
100         ADD_VALUENODE(ValueNode_SegCalcVertex,"segcalcvertex");
101         ADD_VALUENODE(ValueNode_Stripes,"stripes");
102         ADD_VALUENODE(ValueNode_Subtract,"subtract");
103         //ADD_VALUENODE(ValueNode_TimedSwap,"timed_swap");
104         ADD_VALUENODE(ValueNode_TwoTone,"twotone");
105         ADD_VALUENODE(ValueNode_BLine,"bline");
106         ADD_VALUENODE2(ValueNode_DynamicList,"dynamic_list");
107         ADD_VALUENODE(ValueNode_GradientRotate,"gradient_rotate");
108         ADD_VALUENODE(ValueNode_Sine,"sine");
109
110 #undef ADD_VALUENODE
111         return true;
112 }
113
114 bool
115 ValueNode::subsys_stop()
116 {
117         delete book_;
118 /*      if(global_value_node_map.size() || value_node_count)
119         {
120                 if(value_node_count)
121                         synfig::error("%d ValueNodes haven't been destroyed yet!",value_node_count);
122
123                 if(global_value_node_map.size()!=value_node_count)
124                         synfig::error("value node count mismatch! map.size()!=value_node_count (%d!=%d)",global_value_node_map.size(),value_node_count);
125
126                 GlobalValueNodeMap::iterator iter;
127                 for(iter=global_value_node_map.begin();iter!=global_value_node_map.end();++iter)
128                 {
129                         if(!iter->second->is_exported())
130                                 synfig::info("%s: count:%d name:%s type:%s",
131                                         iter->first.get_string().c_str(),
132                                         iter->second->count(),
133                                         iter->second->get_name().c_str(),
134                                         ValueBase::type_name(iter->second->get_type()).c_str()
135                                 );
136                         else
137                                 synfig::info("%s: id:%s count:%d name:%s type:%s",
138                                         iter->first.get_string().c_str(),
139                                         iter->second->get_id().c_str(),
140                                         iter->second->count(),
141                                         iter->second->get_name().c_str(),
142                                         ValueBase::type_name(iter->second->get_type()).c_str()
143                                 );
144                 }
145         }
146 */
147         return true;
148 }
149
150 ValueNode::ValueNode(ValueBase::Type type):type(type)
151 {
152         value_node_count++;
153 }
154
155 LinkableValueNode::Book&
156 LinkableValueNode::book()
157 {
158         return *book_;
159 }
160
161 LinkableValueNode::Handle
162 LinkableValueNode::create(const String &name, const ValueBase& x)
163 {
164         if(!book().count(name))
165                 return 0;
166         return book()[name].factory(x);
167 }
168
169 bool
170 LinkableValueNode::check_type(const String &name, ValueBase::Type x)
171 {
172         if(!book().count(name) || !book()[name].check_type)
173                 return false;
174         return book()[name].check_type(x);
175 }
176
177 bool
178 LinkableValueNode::set_link(int i,ValueNode::Handle x)
179 {
180         ValueNode::Handle previous(get_link(i));
181
182         if(set_link_vfunc(i,x))
183         {
184                 if(previous)
185                         remove_child(previous.get());
186                 add_child(x.get());
187
188                 if(!x->is_exported() && get_parent_canvas())
189                 {
190                         x->set_parent_canvas(get_parent_canvas());
191                 }
192                 changed();
193                 return true;
194         }
195         return false;
196 }
197
198 ValueNode::LooseHandle
199 LinkableValueNode::get_link(int i)const
200 {
201         return get_link_vfunc(i);
202 }
203
204 void
205 LinkableValueNode::unlink_all()
206 {
207         for(int i=0;i<link_count();i++)
208         {
209                 ValueNode::LooseHandle value_node(get_link(i));
210                 if(value_node)
211                         value_node->parent_set.erase(this);
212         }
213 }
214
215 ValueNode::~ValueNode()
216 {
217         value_node_count--;
218
219         begin_delete();
220
221         //DEBUGPOINT();
222 }
223
224 void
225 ValueNode::on_changed()
226 {
227         if(get_parent_canvas())
228                 get_parent_canvas()->signal_value_node_changed()(this);
229         else if(get_root_canvas() && get_parent_canvas())
230                 get_root_canvas()->signal_value_node_changed()(this);
231
232         Node::on_changed();
233 }
234
235 int
236 ValueNode::replace(etl::handle<ValueNode> x)
237 {
238         if(x.get()==this)
239                 return 0;
240
241         while(parent_set.size())
242         {
243                 (*parent_set.begin())->add_child(x.get());
244                 (*parent_set.begin())->remove_child(this);
245                 //x->parent_set.insert(*parent_set.begin());
246                 //parent_set.erase(parent_set.begin());
247         }
248         int r(RHandle(this).replace(x));
249         x->changed();
250         return r;
251 }
252
253 void
254 ValueNode::set_id(const String &x)
255 {
256         if(name!=x)
257         {
258                 name=x;
259                 signal_id_changed_();
260         }
261 }
262
263 ValueNodeList::ValueNodeList():
264         placeholder_count_(0)
265 {
266 }
267
268 bool
269 ValueNodeList::count(const String &id)const
270 {
271         const_iterator iter;
272
273         if(id.empty())
274                 return false;
275
276         for(iter=begin();iter!=end() && id!=(*iter)->get_id();++iter);
277
278         if(iter==end())
279                 return false;
280
281         return true;
282 }
283
284 ValueNode::Handle
285 ValueNodeList::find(const String &id)
286 {
287         iterator iter;
288
289         if(id.empty())
290                 throw Exception::IDNotFound("Empty ID");
291
292         for(iter=begin();iter!=end() && id!=(*iter)->get_id();++iter);
293
294         if(iter==end())
295                 throw Exception::IDNotFound("ValueNode in ValueNodeList: "+id);
296
297         return *iter;
298 }
299
300 ValueNode::ConstHandle
301 ValueNodeList::find(const String &id)const
302 {
303         const_iterator iter;
304
305         if(id.empty())
306                 throw Exception::IDNotFound("Empty ID");
307
308         for(iter=begin();iter!=end() && id!=(*iter)->get_id();++iter);
309
310         if(iter==end())
311                 throw Exception::IDNotFound("ValueNode in ValueNodeList: "+id);
312
313         return *iter;
314 }
315
316 ValueNode::Handle
317 ValueNodeList::surefind(const String &id)
318 {
319         if(id.empty())
320                 throw Exception::IDNotFound("Empty ID");
321
322         ValueNode::Handle value_node;
323
324         try
325         {
326                 value_node=find(id);
327         }
328         catch(Exception::IDNotFound)
329         {
330                 value_node=PlaceholderValueNode::create();
331                 value_node->set_id(id);
332                 push_back(value_node);
333                 placeholder_count_++;
334         }
335
336         return value_node;
337 }
338
339 bool
340 ValueNodeList::erase(ValueNode::Handle value_node)
341 {
342         assert(value_node);
343
344         iterator iter;
345
346         for(iter=begin();iter!=end();++iter)
347                 if(value_node.get()==iter->get())
348                 {
349                         std::list<ValueNode::RHandle>::erase(iter);
350                         if(PlaceholderValueNode::Handle::cast_dynamic(value_node))
351                                 placeholder_count_--;
352                         return true;
353                 }
354         return false;
355 }
356
357 bool
358 ValueNodeList::add(ValueNode::Handle value_node)
359 {
360         if(!value_node)
361                 return false;
362         if(value_node->get_id().empty())
363                 return false;
364
365         try
366         {
367                 ValueNode::RHandle other_value_node=find(value_node->get_id());
368                 if(PlaceholderValueNode::Handle::cast_dynamic(other_value_node))
369                 {
370                         other_value_node->replace(value_node);
371                         placeholder_count_--;
372                         return true;
373                 }
374
375                 return false;
376         }
377         catch(Exception::IDNotFound)
378         {
379                 push_back(value_node);
380                 return true;
381         }
382
383         return false;
384 }
385
386 void
387 ValueNodeList::audit()
388 {
389         iterator iter,next;
390
391         for(next=begin(),iter=next++;iter!=end();iter=next++)
392                 if(iter->count()==1)
393                         std::list<ValueNode::RHandle>::erase(iter);
394 }
395
396
397 String
398 PlaceholderValueNode::get_name()const
399 {
400         return "placeholder";
401 }
402
403 String
404 PlaceholderValueNode::get_local_name()const
405 {
406         return _("Placeholder");
407 }
408
409 ValueNode*
410 PlaceholderValueNode::clone(const GUID& deriv_guid)const
411 {
412         ValueNode* ret(new PlaceholderValueNode());
413         ret->set_guid(get_guid()^deriv_guid);
414         return ret;
415 }
416
417 PlaceholderValueNode::Handle
418 PlaceholderValueNode::create(ValueBase::Type type)
419 {
420         return new PlaceholderValueNode(type);
421 }
422
423 ValueBase
424 PlaceholderValueNode::operator()(Time t)const
425 {
426         assert(0);
427         return ValueBase();
428 }
429
430 PlaceholderValueNode::PlaceholderValueNode(ValueBase::Type type):
431         ValueNode(type)
432 {
433 }
434
435 ValueNode*
436 LinkableValueNode::clone(const GUID& deriv_guid)const
437 {
438         { ValueNode* x(find_value_node(get_guid()^deriv_guid).get()); if(x)return x; }
439
440         int i;
441         LinkableValueNode *ret=create_new();
442         ret->set_guid(get_guid()^deriv_guid);
443
444         for(i=0;i<link_count();i++)
445         {
446                 ValueNode::Handle link=get_link_vfunc(i);
447                 if(!link->is_exported())
448                 {
449                         ValueNode::LooseHandle value_node(find_value_node(link->get_guid()^deriv_guid));
450                         if(!value_node)
451                                 value_node=link->clone(deriv_guid);
452                         ret->set_link(i,value_node);
453                 }
454                 else
455                         ret->set_link(i,link);
456         }
457
458         return ret;
459 }
460
461 String
462 ValueNode::get_relative_id(etl::loose_handle<const Canvas> x)const
463 {
464         assert(is_exported());
465         assert(canvas_);
466
467         if(x.get()==canvas_.get())
468                 return get_id();
469
470         return canvas_->_get_relative_id(x)+':'+get_id();
471 }
472
473 void
474 ValueNode::set_parent_canvas(etl::loose_handle<Canvas> x)
475 {
476         canvas_=x; if(x) root_canvas_=x->get_root();
477 }
478
479 void
480 ValueNode::set_root_canvas(etl::loose_handle<Canvas> x)
481 {
482         root_canvas_=x->get_root();
483 }
484
485 void LinkableValueNode::get_times_vfunc(Node::time_set &set) const
486 {
487         ValueNode::LooseHandle  h;
488
489         int size = link_count();
490
491         //just add it to the set...
492         for(int i=0; i < size; ++i)
493         {
494                 h = get_link(i);
495
496                 if(h)
497                 {
498                         const Node::time_set &tset = h->get_times();
499                         set.insert(tset.begin(),tset.end());
500                 }
501         }
502 }