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