Using mutexes around accesses to refcounts seems to make the Windows build much less...
[synfig.git] / synfig-core / trunk / src / synfig / layer.cpp
1 /* === S Y N F I G ========================================================= */
2 /*!     \file layer.cpp
3 **      \brief Layer class implementation
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 #define SYNFIG_NO_ANGLE
27
28 #ifdef USING_PCH
29 #       include "pch.h"
30 #else
31 #ifdef HAVE_CONFIG_H
32 #       include <config.h>
33 #endif
34
35 #include "canvas.h"
36 #include "layer.h"
37 #include "render.h"
38 #include "value.h"
39 #include "layer_bitmap.h"
40 #include "layer_mime.h"
41 #include "context.h"
42 #include "paramdesc.h"
43
44 #include "layer_solidcolor.h"
45 #include "layer_polygon.h"
46 #include "layer_pastecanvas.h"
47 #include "layer_motionblur.h"
48 #include "layer_duplicate.h"
49
50 #include "valuenode_const.h"
51
52 #include "transform.h"
53 #include "rect.h"
54 #include "guid.h"
55
56 #include <sigc++/adaptors/bind.h>
57 #endif
58
59 /* === U S I N G =========================================================== */
60
61 using namespace etl;
62 using namespace std;
63 using namespace synfig;
64
65 /* === G L O B A L S ======================================================= */
66
67 static Layer::Book* _layer_book;
68
69 struct _LayerCounter
70 {
71         static int counter;
72         ~_LayerCounter()
73         {
74                 if(counter)
75                         synfig::error("%d layers not yet deleted!",counter);
76         }
77 } _layer_counter;
78
79 int _LayerCounter::counter(0);
80
81 /* === P R O C E D U R E S ================================================= */
82
83 Layer::Book&
84 Layer::book()
85 {
86         return *_layer_book;
87 }
88
89 void
90 Layer::register_in_book(const BookEntry &entry)
91 {
92         book()[entry.name]=entry;
93 }
94
95 bool
96 Layer::subsys_init()
97 {
98         _layer_book=new Book();
99
100 #define INCLUDE_LAYER(class)                                                                    \
101         synfig::Layer::book() [synfig::String(class::name__)] =         \
102                 BookEntry(class::create,                                                                \
103                                   class::name__,                                                                \
104                                   dgettext("synfig", class::local_name__),              \
105                                   class::category__,                                                    \
106                                   class::cvs_id__,                                                              \
107                                   class::version__)
108
109 #define LAYER_ALIAS(class,alias)                                                                \
110         synfig::Layer::book()[synfig::String(alias)] =                          \
111                 BookEntry(class::create,                                                                \
112                                   alias,                                                                                \
113                                   alias,                                                                                \
114                                   CATEGORY_DO_NOT_USE,                                                  \
115                                   class::cvs_id__,                                                              \
116                                   class::version__)
117
118         INCLUDE_LAYER(Layer_SolidColor);        LAYER_ALIAS(Layer_SolidColor,   "solid_color");
119         INCLUDE_LAYER(Layer_PasteCanvas);       LAYER_ALIAS(Layer_PasteCanvas,  "paste_canvas");
120         INCLUDE_LAYER(Layer_Polygon);           LAYER_ALIAS(Layer_Polygon,              "Polygon");
121         INCLUDE_LAYER(Layer_MotionBlur);        LAYER_ALIAS(Layer_MotionBlur,   "motion_blur");
122         INCLUDE_LAYER(Layer_Duplicate);
123
124 #undef INCLUDE_LAYER
125
126         return true;
127 }
128
129 bool
130 Layer::subsys_stop()
131 {
132         delete _layer_book;
133         return true;
134 }
135
136 /* === M E T H O D S ======================================================= */
137
138 Layer::Layer():
139         active_(true),
140         z_depth_(0.0f),
141         dirty_time_(Time::end())
142 {
143         _LayerCounter::counter++;
144 }
145
146 Layer::LooseHandle
147 synfig::Layer::create(const String &name)
148 {
149         if(!book().count(name))
150         {
151                 return Layer::LooseHandle(new Layer_Mime(name));
152         }
153
154         Layer* layer(book()[name].factory());
155         return Layer::LooseHandle(layer);
156 }
157
158 synfig::Layer::~Layer()
159 {
160         _LayerCounter::counter--;
161         while(!dynamic_param_list_.empty())
162         {
163                 remove_child(dynamic_param_list_.begin()->second.get());
164                 dynamic_param_list_.erase(dynamic_param_list_.begin());
165         }
166
167         remove_from_all_groups();
168
169         parent_death_connect_.disconnect();
170         begin_delete();
171 }
172
173 void
174 synfig::Layer::set_canvas(etl::loose_handle<Canvas> x)
175 {
176         if(canvas_!=x)
177         {
178                 parent_death_connect_.disconnect();
179                 canvas_=x;
180                 if(x)
181                 {
182                         parent_death_connect_=x->signal_deleted().connect(
183                                 sigc::bind(
184                                         sigc::mem_fun(
185                                                 *this,
186                                                 &Layer::set_canvas
187                                         ),
188                                         etl::loose_handle<synfig::Canvas>(0)
189                                 )
190                         );
191                 }
192                 on_canvas_set();
193         }
194 }
195
196 void
197 synfig::Layer::on_canvas_set()
198 {
199 }
200
201 etl::loose_handle<synfig::Canvas>
202 synfig::Layer::get_canvas()const
203 {
204         return canvas_;
205 }
206
207 int
208 Layer::get_depth()const
209 {
210         if(!get_canvas())
211                 return -1;
212         return get_canvas()->get_depth(const_cast<synfig::Layer*>(this));
213 }
214
215 void
216 Layer::set_active(bool x)
217 {
218         if(active_!=x)
219         {
220                 active_=x;
221
222                 Node::on_changed();
223                 signal_status_changed_();
224         }
225 }
226
227 void
228 Layer::set_description(const String& x)
229 {
230         if(description_!=x)
231         {
232                 description_=x;
233                 signal_description_changed_();
234         }
235 }
236
237 bool
238 Layer::connect_dynamic_param(const String& param, etl::loose_handle<ValueNode> value_node)
239 {
240         ValueNode::Handle previous(dynamic_param_list_[param]);
241
242         if(previous==value_node)
243                 return true;
244
245         dynamic_param_list_[param]=ValueNode::Handle(value_node);
246
247         if(previous)
248                 remove_child(previous.get());
249
250         add_child(value_node.get());
251
252         if(!value_node->is_exported() && get_canvas())
253         {
254                 value_node->set_parent_canvas(get_canvas());
255         }
256
257         changed();
258         return true;
259 }
260
261 bool
262 Layer::disconnect_dynamic_param(const String& param)
263 {
264         ValueNode::Handle previous(dynamic_param_list_[param]);
265
266         if(previous)
267         {
268                 dynamic_param_list_.erase(param);
269                 remove_child(previous.get());
270                 changed();
271         }
272         return true;
273 }
274
275 void
276 Layer::on_changed()
277 {
278         dirty_time_=Time::end();
279         if(active())
280                 Node::on_changed();
281 }
282
283 bool
284 Layer::set_param(const String &param, const ValueBase &value)
285 {
286         if(param=="z_depth" && value.same_type_as(z_depth_))
287         {
288                 z_depth_=value.get(z_depth_);
289                 return true;
290         }
291         return false;
292 }
293
294 etl::handle<Transform>
295 Layer::get_transform()const
296 {
297         return 0;
298 }
299
300 float
301 Layer::get_z_depth(const synfig::Time& t)const
302 {
303         if(!dynamic_param_list().count("z_depth"))
304                 return z_depth_;
305         return (*dynamic_param_list().find("z_depth")->second)(t).get(Real());
306 }
307
308 #ifdef THIS_CODE_IS_NOT_USED
309 Layer*
310 Layer::simple_clone()const
311 {
312         if(!book().count(get_name())) return 0;
313         Layer *ret = create(get_name()).get();
314         ret->set_canvas(get_canvas());
315         ret->set_description(get_description());
316         ret->set_param_list(get_param_list());
317         return ret;
318 }
319 #endif /* THIS_CODE_IS_NOT_USED */
320
321 Layer::Handle
322 Layer::clone(const GUID& deriv_guid) const
323 {
324         if(!book().count(get_name())) return 0;
325
326         //Layer *ret = book()[get_name()].factory();//create(get_name()).get();
327         Handle ret = create(get_name()).get();
328
329         ret->group_=group_;
330         //ret->set_canvas(get_canvas());
331         ret->set_description(get_description());
332         ret->set_active(active());
333         ret->set_guid(get_guid()^deriv_guid);
334
335         //ret->set_param_list(get_param_list());
336         // Process the parameter list so that
337         // we can duplicate any inline canvases
338         ParamList param_list(get_param_list());
339         for(ParamList::const_iterator iter(param_list.begin()); iter != param_list.end(); ++iter)
340         {
341                 if(dynamic_param_list().count(iter->first)==0 && iter->second.get_type()==ValueBase::TYPE_CANVAS)
342                 {
343                         // This parameter is a canvas.  We need a close look.
344                         Canvas::Handle canvas(iter->second.get(Canvas::Handle()));
345                         if(canvas && canvas->is_inline())
346                         {
347                                 // This parameter is an inline canvas! we need to clone it
348                                 // before we set it as a parameter.
349                                 Canvas::Handle new_canvas(canvas->clone(deriv_guid));
350                                 ValueBase value(new_canvas);
351                                 ret->set_param(iter->first, value);
352                                 continue;
353                         }
354                 }
355
356                 // This is a normal parameter,go ahead and set it.
357                 ret->set_param(iter->first, iter->second);
358         }
359
360         // Duplicate the dynamic paramlist, but only the exported data nodes
361         DynamicParamList::const_iterator iter;
362         for(iter=dynamic_param_list().begin();iter!=dynamic_param_list().end();++iter)
363         {
364                 // Make sure we clone inline canvases
365                 if(iter->second->get_type()==ValueBase::TYPE_CANVAS)
366                 {
367                         Canvas::Handle canvas((*iter->second)(0).get(Canvas::Handle()));
368                         if(canvas->is_inline())
369                         {
370                                 Canvas::Handle new_canvas(canvas->clone(deriv_guid));
371                                 ValueBase value(new_canvas);
372                                 ret->connect_dynamic_param(iter->first,ValueNode_Const::create(value));
373                                 continue;
374                         }
375                 }
376
377                 if(iter->second->is_exported())
378                         ret->connect_dynamic_param(iter->first,iter->second);
379                 else
380                         ret->connect_dynamic_param(iter->first,iter->second->clone(deriv_guid));
381         }
382
383         //ret->set_canvas(0);
384
385         return ret;
386 }
387
388 bool
389 Layer::reads_context() const
390 {
391         return false;
392 }
393
394 Rect
395 Layer::get_full_bounding_rect(Context context)const
396 {
397         if(active())
398                 return context.get_full_bounding_rect()|get_bounding_rect();
399         return context.get_full_bounding_rect();
400 }
401
402 Rect
403 Layer::get_bounding_rect()const
404 {
405         return Rect::full_plane();
406 }
407
408 bool
409 Layer::set_param_list(const ParamList &list)
410 {
411         bool ret=true;
412         if(!list.size())
413                 return false;
414         ParamList::const_iterator iter(list.begin());
415         for(;iter!=list.end();++iter)
416         {
417                 if(!set_param(iter->first, iter->second))ret=false;
418         }
419         return ret;
420 }
421
422 Layer::ParamList
423 Layer::get_param_list()const
424 {
425         ParamList ret;
426
427         Vocab vocab(get_param_vocab());
428
429         Vocab::const_iterator iter=vocab.begin();
430         for(;iter!=vocab.end();++iter)
431         {
432                 ret[iter->get_name()]=get_param(iter->get_name());
433         }
434         return ret;
435 }
436
437 ValueBase
438 Layer::get_param(const String & param)const
439 {
440         if(param=="z_depth")
441                 return get_z_depth();
442
443         return ValueBase();
444 }
445
446 String
447 Layer::get_version()const
448 {
449         return get_param("version__").get(String());
450 }
451
452 bool
453 Layer::set_version(const String &/*ver*/)
454 {
455         return false;
456 }
457
458 void
459 Layer::reset_version()
460 {
461 }
462
463
464 void
465 Layer::set_time(Context context, Time time)const
466 {
467         context.set_time(time);
468         dirty_time_=time;
469 }
470
471 void
472 Layer::set_time(Context context, Time time, const Point &pos)const
473 {
474         context.set_time(time,pos);
475         dirty_time_=time;
476 }
477
478 Color
479 Layer::get_color(Context context, const Point &pos)const
480 {
481         return context.get_color(pos);
482 }
483
484 synfig::Layer::Handle
485 Layer::hit_check(synfig::Context context, const synfig::Point &pos)const
486 {
487         return context.hit_check(pos);
488 }
489
490 /*      The default accelerated renderer
491 **      is anything but accelerated...
492 */
493 bool
494 Layer::accelerated_render(Context context,Surface *surface,int /*quality*/, const RendDesc &renddesc, ProgressCallback *cb)  const
495 {
496         handle<Target> target=surface_target(surface);
497         if(!target)
498         {
499                 if(cb)cb->error(_("Unable to create surface target"));
500                 return false;
501         }
502         RendDesc desc=renddesc;
503         target->set_rend_desc(&desc);
504
505         // When we render, we want to
506         // make sure that we are rendered too...
507         // Since the context iterator is for
508         // the layer after us, we need to back up.
509         // This could be considered a hack, as
510         // it is a possibility that we are indeed
511         // not the previous layer.
512         --context;
513
514         return render(context,target,desc,cb);
515         //return render_threaded(context,target,desc,cb,2);
516 }
517
518 String
519 Layer::get_name()const
520 {
521         return get_param("name__").get(String());
522 }
523
524 String
525 Layer::get_local_name()const
526 {
527         return get_param("local_name__").get(String());
528 }
529
530
531 Layer::Vocab
532 Layer::get_param_vocab()const
533 {
534         Layer::Vocab ret;
535
536         ret.push_back(ParamDesc(z_depth_,"z_depth")
537                 .set_local_name(_("Z Depth"))
538                 .set_animation_only(true)
539         );
540
541         return ret;
542 }
543
544 void
545 Layer::get_times_vfunc(Node::time_set &set) const
546 {
547         DynamicParamList::const_iterator        i = dynamic_param_list_.begin(),
548                                                                                 end = dynamic_param_list_.end();
549
550         for(; i != end; ++i)
551         {
552                 const Node::time_set &tset = i->second->get_times();
553                 set.insert(tset.begin(),tset.end());
554         }
555 }
556
557
558 void
559 Layer::add_to_group(const String&x)
560 {
561         if(x==group_)
562                 return;
563         if(!group_.empty())
564                 remove_from_all_groups();
565         group_=x;
566         signal_added_to_group()(group_);
567 }
568
569 void
570 Layer::remove_from_group(const String&x)
571 {
572         if(group_==x)
573                 remove_from_all_groups();
574 }
575
576 void
577 Layer::remove_from_all_groups()
578 {
579         if(group_.empty())
580                 return;
581         signal_removed_from_group()(group_);
582         group_.clear();
583 }
584
585 String
586 Layer::get_group()const
587 {
588         return group_;
589 }
590
591 const String
592 Layer::get_param_local_name(const String &param_name)const
593 {
594         ParamVocab vocab = get_param_vocab();
595         // loop to find the parameter in the parameter vocab - this gives us its local name
596         for (ParamVocab::iterator iter = vocab.begin(); iter != vocab.end(); iter++)
597                 if (iter->get_name() == param_name)
598                         return iter->get_local_name();
599         return String();
600 }