1 // Generated by gmmproc 2.40.0 -- DO NOT MODIFY!
2
3 #define CLUTTER_DISABLE_DEPRECATION_WARNINGS 1
4
5
6 #include <glibmm.h>
7
8 #include <cluttermm/timeline.h>
9 #include <cluttermm/private/timeline_p.h>
10
11
12 /* Copyright (C) 2007 The cluttermm Development Team
13 *
14 * This library is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU Lesser General Public
16 * License as published by the Free Software Foundation; either
17 * version 2.1 of the License, or (at your option) any later version.
18 *
19 * This library is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 * Lesser General Public License for more details.
23 *
24 * You should have received a copy of the GNU Lesser General Public
25 * License along with this library; if not, write to the Free
26 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 */
28
29 #include <clutter/clutter.h>
30
31 namespace Clutter
32 {
33
Timeline(guint msecs)34 Timeline::Timeline(guint msecs)
35 :
36 // Mark this class as non-derived to allow C++ vfuncs to be skipped.
37 Glib::ObjectBase(0),
38 Glib::Object(Glib::ConstructParams(timeline_class_.init(), "duration",msecs, static_cast<char*>(0)))
39 {}
40
list_markers(gint frame_num) const41 std::vector<Glib::ustring> Timeline::list_markers(gint frame_num) const
42 {
43 gsize n_markers = 0;
44 gchar** const markers = clutter_timeline_list_markers(const_cast<ClutterTimeline*>(gobj()),
45 frame_num, &n_markers);
46 std::vector<Glib::ustring> markerVec;
47 markerVec.reserve(n_markers);
48
49 for(gsize i = 0; i < n_markers; ++i)
50 {
51 markerVec.push_back(Glib::ustring(markers[i]));
52 }
53
54 return markerVec;
55 }
56
57 } // namespace Clutter
58
59 namespace
60 {
61
62
63 static const Glib::SignalProxyInfo Timeline_signal_completed_info =
64 {
65 "completed",
66 (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
67 (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
68 };
69
70
Timeline_signal_new_frame_callback(ClutterTimeline * self,gint p0,void * data)71 static void Timeline_signal_new_frame_callback(ClutterTimeline* self, gint p0,void* data)
72 {
73 using namespace Clutter;
74 typedef sigc::slot< void,int > SlotType;
75
76 // Do not try to call a signal on a disassociated wrapper.
77 if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
78 {
79 #ifdef GLIBMM_EXCEPTIONS_ENABLED
80 try
81 {
82 #endif //GLIBMM_EXCEPTIONS_ENABLED
83 if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
84 (*static_cast<SlotType*>(slot))(p0
85 );
86 #ifdef GLIBMM_EXCEPTIONS_ENABLED
87 }
88 catch(...)
89 {
90 Glib::exception_handlers_invoke();
91 }
92 #endif //GLIBMM_EXCEPTIONS_ENABLED
93 }
94 }
95
96 static const Glib::SignalProxyInfo Timeline_signal_new_frame_info =
97 {
98 "new-frame",
99 (GCallback) &Timeline_signal_new_frame_callback,
100 (GCallback) &Timeline_signal_new_frame_callback
101 };
102
103
104 static const Glib::SignalProxyInfo Timeline_signal_paused_info =
105 {
106 "paused",
107 (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
108 (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
109 };
110
111
112 static const Glib::SignalProxyInfo Timeline_signal_started_info =
113 {
114 "started",
115 (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
116 (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
117 };
118
119
Timeline_signal_marker_reached_callback(ClutterTimeline * self,const gchar * p0,gint p1,void * data)120 static void Timeline_signal_marker_reached_callback(ClutterTimeline* self, const gchar* p0,gint p1,void* data)
121 {
122 using namespace Clutter;
123 typedef sigc::slot< void,const Glib::ustring&,int > SlotType;
124
125 // Do not try to call a signal on a disassociated wrapper.
126 if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
127 {
128 #ifdef GLIBMM_EXCEPTIONS_ENABLED
129 try
130 {
131 #endif //GLIBMM_EXCEPTIONS_ENABLED
132 if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
133 (*static_cast<SlotType*>(slot))(Glib::convert_const_gchar_ptr_to_ustring(p0)
134 , p1
135 );
136 #ifdef GLIBMM_EXCEPTIONS_ENABLED
137 }
138 catch(...)
139 {
140 Glib::exception_handlers_invoke();
141 }
142 #endif //GLIBMM_EXCEPTIONS_ENABLED
143 }
144 }
145
146 static const Glib::SignalProxyInfo Timeline_signal_marker_reached_info =
147 {
148 "marker-reached",
149 (GCallback) &Timeline_signal_marker_reached_callback,
150 (GCallback) &Timeline_signal_marker_reached_callback
151 };
152
153
154 } // anonymous namespace
155
156 // static
value_type()157 GType Glib::Value<Clutter::TimelineDirection>::value_type()
158 {
159 return clutter_timeline_direction_get_type();
160 }
161
162
163 namespace Glib
164 {
165
wrap(ClutterTimeline * object,bool take_copy)166 Glib::RefPtr<Clutter::Timeline> wrap(ClutterTimeline* object, bool take_copy)
167 {
168 return Glib::RefPtr<Clutter::Timeline>( dynamic_cast<Clutter::Timeline*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
169 //We use dynamic_cast<> in case of multiple inheritance.
170 }
171
172 } /* namespace Glib */
173
174
175 namespace Clutter
176 {
177
178
179 /* The *_Class implementation: */
180
init()181 const Glib::Class& Timeline_Class::init()
182 {
183 if(!gtype_) // create the GType if necessary
184 {
185 // Glib::Class has to know the class init function to clone custom types.
186 class_init_func_ = &Timeline_Class::class_init_function;
187
188 // This is actually just optimized away, apparently with no harm.
189 // Make sure that the parent type has been created.
190 //CppClassParent::CppObjectType::get_type();
191
192 // Create the wrapper type, with the same class/instance size as the base type.
193 register_derived_type(clutter_timeline_get_type());
194
195 // Add derived versions of interfaces, if the C type implements any interfaces:
196
197 }
198
199 return *this;
200 }
201
202
class_init_function(void * g_class,void * class_data)203 void Timeline_Class::class_init_function(void* g_class, void* class_data)
204 {
205 BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
206 CppClassParent::class_init_function(klass, class_data);
207
208
209 klass->completed = &completed_callback;
210 klass->new_frame = &new_frame_callback;
211 klass->paused = &paused_callback;
212 klass->started = &started_callback;
213 klass->marker_reached = &marker_reached_callback;
214 }
215
216
completed_callback(ClutterTimeline * self)217 void Timeline_Class::completed_callback(ClutterTimeline* self)
218 {
219 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
220 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
221
222 // Non-gtkmmproc-generated custom classes implicitly call the default
223 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
224 // generated classes can use this optimisation, which avoids the unnecessary
225 // parameter conversions if there is no possibility of the virtual function
226 // being overridden:
227 if(obj_base && obj_base->is_derived_())
228 {
229 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
230 if(obj) // This can be NULL during destruction.
231 {
232 #ifdef GLIBMM_EXCEPTIONS_ENABLED
233 try // Trap C++ exceptions which would normally be lost because this is a C callback.
234 {
235 #endif //GLIBMM_EXCEPTIONS_ENABLED
236 // Call the virtual member method, which derived classes might override.
237 obj->on_completed();
238 return;
239 #ifdef GLIBMM_EXCEPTIONS_ENABLED
240 }
241 catch(...)
242 {
243 Glib::exception_handlers_invoke();
244 }
245 #endif //GLIBMM_EXCEPTIONS_ENABLED
246 }
247 }
248
249 BaseClassType *const base = static_cast<BaseClassType*>(
250 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
251 );
252
253 // Call the original underlying C function:
254 if(base && base->completed)
255 (*base->completed)(self);
256 }
new_frame_callback(ClutterTimeline * self,gint p0)257 void Timeline_Class::new_frame_callback(ClutterTimeline* self, gint p0)
258 {
259 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
260 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
261
262 // Non-gtkmmproc-generated custom classes implicitly call the default
263 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
264 // generated classes can use this optimisation, which avoids the unnecessary
265 // parameter conversions if there is no possibility of the virtual function
266 // being overridden:
267 if(obj_base && obj_base->is_derived_())
268 {
269 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
270 if(obj) // This can be NULL during destruction.
271 {
272 #ifdef GLIBMM_EXCEPTIONS_ENABLED
273 try // Trap C++ exceptions which would normally be lost because this is a C callback.
274 {
275 #endif //GLIBMM_EXCEPTIONS_ENABLED
276 // Call the virtual member method, which derived classes might override.
277 obj->on_new_frame(p0
278 );
279 return;
280 #ifdef GLIBMM_EXCEPTIONS_ENABLED
281 }
282 catch(...)
283 {
284 Glib::exception_handlers_invoke();
285 }
286 #endif //GLIBMM_EXCEPTIONS_ENABLED
287 }
288 }
289
290 BaseClassType *const base = static_cast<BaseClassType*>(
291 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
292 );
293
294 // Call the original underlying C function:
295 if(base && base->new_frame)
296 (*base->new_frame)(self, p0);
297 }
paused_callback(ClutterTimeline * self)298 void Timeline_Class::paused_callback(ClutterTimeline* self)
299 {
300 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
301 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
302
303 // Non-gtkmmproc-generated custom classes implicitly call the default
304 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
305 // generated classes can use this optimisation, which avoids the unnecessary
306 // parameter conversions if there is no possibility of the virtual function
307 // being overridden:
308 if(obj_base && obj_base->is_derived_())
309 {
310 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
311 if(obj) // This can be NULL during destruction.
312 {
313 #ifdef GLIBMM_EXCEPTIONS_ENABLED
314 try // Trap C++ exceptions which would normally be lost because this is a C callback.
315 {
316 #endif //GLIBMM_EXCEPTIONS_ENABLED
317 // Call the virtual member method, which derived classes might override.
318 obj->on_paused();
319 return;
320 #ifdef GLIBMM_EXCEPTIONS_ENABLED
321 }
322 catch(...)
323 {
324 Glib::exception_handlers_invoke();
325 }
326 #endif //GLIBMM_EXCEPTIONS_ENABLED
327 }
328 }
329
330 BaseClassType *const base = static_cast<BaseClassType*>(
331 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
332 );
333
334 // Call the original underlying C function:
335 if(base && base->paused)
336 (*base->paused)(self);
337 }
started_callback(ClutterTimeline * self)338 void Timeline_Class::started_callback(ClutterTimeline* self)
339 {
340 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
341 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
342
343 // Non-gtkmmproc-generated custom classes implicitly call the default
344 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
345 // generated classes can use this optimisation, which avoids the unnecessary
346 // parameter conversions if there is no possibility of the virtual function
347 // being overridden:
348 if(obj_base && obj_base->is_derived_())
349 {
350 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
351 if(obj) // This can be NULL during destruction.
352 {
353 #ifdef GLIBMM_EXCEPTIONS_ENABLED
354 try // Trap C++ exceptions which would normally be lost because this is a C callback.
355 {
356 #endif //GLIBMM_EXCEPTIONS_ENABLED
357 // Call the virtual member method, which derived classes might override.
358 obj->on_started();
359 return;
360 #ifdef GLIBMM_EXCEPTIONS_ENABLED
361 }
362 catch(...)
363 {
364 Glib::exception_handlers_invoke();
365 }
366 #endif //GLIBMM_EXCEPTIONS_ENABLED
367 }
368 }
369
370 BaseClassType *const base = static_cast<BaseClassType*>(
371 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
372 );
373
374 // Call the original underlying C function:
375 if(base && base->started)
376 (*base->started)(self);
377 }
marker_reached_callback(ClutterTimeline * self,const gchar * p0,gint p1)378 void Timeline_Class::marker_reached_callback(ClutterTimeline* self, const gchar* p0, gint p1)
379 {
380 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
381 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
382
383 // Non-gtkmmproc-generated custom classes implicitly call the default
384 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
385 // generated classes can use this optimisation, which avoids the unnecessary
386 // parameter conversions if there is no possibility of the virtual function
387 // being overridden:
388 if(obj_base && obj_base->is_derived_())
389 {
390 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
391 if(obj) // This can be NULL during destruction.
392 {
393 #ifdef GLIBMM_EXCEPTIONS_ENABLED
394 try // Trap C++ exceptions which would normally be lost because this is a C callback.
395 {
396 #endif //GLIBMM_EXCEPTIONS_ENABLED
397 // Call the virtual member method, which derived classes might override.
398 obj->on_marker_reached(Glib::convert_const_gchar_ptr_to_ustring(p0)
399 , p1
400 );
401 return;
402 #ifdef GLIBMM_EXCEPTIONS_ENABLED
403 }
404 catch(...)
405 {
406 Glib::exception_handlers_invoke();
407 }
408 #endif //GLIBMM_EXCEPTIONS_ENABLED
409 }
410 }
411
412 BaseClassType *const base = static_cast<BaseClassType*>(
413 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
414 );
415
416 // Call the original underlying C function:
417 if(base && base->marker_reached)
418 (*base->marker_reached)(self, p0, p1);
419 }
420
421
wrap_new(GObject * object)422 Glib::ObjectBase* Timeline_Class::wrap_new(GObject* object)
423 {
424 return new Timeline((ClutterTimeline*)object);
425 }
426
427
428 /* The implementation: */
429
gobj_copy()430 ClutterTimeline* Timeline::gobj_copy()
431 {
432 reference();
433 return gobj();
434 }
435
Timeline(const Glib::ConstructParams & construct_params)436 Timeline::Timeline(const Glib::ConstructParams& construct_params)
437 :
438 Glib::Object(construct_params)
439 {
440
441 }
442
Timeline(ClutterTimeline * castitem)443 Timeline::Timeline(ClutterTimeline* castitem)
444 :
445 Glib::Object((GObject*)(castitem))
446 {}
447
448
~Timeline()449 Timeline::~Timeline()
450 {}
451
452
453 Timeline::CppClassType Timeline::timeline_class_; // initialize static member
454
get_type()455 GType Timeline::get_type()
456 {
457 return timeline_class_.init().get_type();
458 }
459
460
get_base_type()461 GType Timeline::get_base_type()
462 {
463 return clutter_timeline_get_type();
464 }
465
466
create(guint msecs)467 Glib::RefPtr<Timeline> Timeline::create(guint msecs)
468 {
469 return Glib::RefPtr<Timeline>( new Timeline(msecs) );
470 }
471
472 #ifndef CLUTTERMM_DISABLE_DEPRECATED
473
clone() const474 Glib::RefPtr<Timeline> Timeline::clone() const
475 {
476 return Glib::wrap(clutter_timeline_clone(const_cast<ClutterTimeline*>(gobj())));
477 }
478
479 #endif // CLUTTERMM_DISABLE_DEPRECATED
480
set_duration(guint msecs)481 void Timeline::set_duration(guint msecs)
482 {
483 clutter_timeline_set_duration(gobj(), msecs);
484 }
485
get_duration() const486 guint Timeline::get_duration() const
487 {
488 return clutter_timeline_get_duration(const_cast<ClutterTimeline*>(gobj()));
489 }
490
start()491 void Timeline::start()
492 {
493 clutter_timeline_start(gobj());
494 }
495
pause()496 void Timeline::pause()
497 {
498 clutter_timeline_pause(gobj());
499 }
500
stop()501 void Timeline::stop()
502 {
503 clutter_timeline_stop(gobj());
504 }
505
set_auto_reverse(bool reverse)506 void Timeline::set_auto_reverse(bool reverse)
507 {
508 clutter_timeline_set_auto_reverse(gobj(), static_cast<int>(reverse));
509 }
510
get_auto_reverse() const511 bool Timeline::get_auto_reverse() const
512 {
513 return clutter_timeline_get_auto_reverse(const_cast<ClutterTimeline*>(gobj()));
514 }
515
set_repeat_count(int count)516 void Timeline::set_repeat_count(int count)
517 {
518 clutter_timeline_set_repeat_count(gobj(), count);
519 }
520
get_repeat_count() const521 int Timeline::get_repeat_count() const
522 {
523 return clutter_timeline_get_repeat_count(const_cast<ClutterTimeline*>(gobj()));
524 }
525
rewind()526 void Timeline::rewind()
527 {
528 clutter_timeline_rewind(gobj());
529 }
530
531 #ifndef CLUTTERMM_DISABLE_DEPRECATED
532
set_loop(bool loop)533 void Timeline::set_loop(bool loop)
534 {
535 clutter_timeline_set_loop(gobj(), static_cast<int>(loop));
536 }
537
538 #endif // CLUTTERMM_DISABLE_DEPRECATED
539
540 #ifndef CLUTTERMM_DISABLE_DEPRECATED
541
get_loop() const542 bool Timeline::get_loop() const
543 {
544 return clutter_timeline_get_loop(const_cast<ClutterTimeline*>(gobj()));
545 }
546
547 #endif // CLUTTERMM_DISABLE_DEPRECATED
548
skip(guint n_frames)549 void Timeline::skip(guint n_frames)
550 {
551 clutter_timeline_skip(gobj(), n_frames);
552 }
553
advance(guint frame_num)554 void Timeline::advance(guint frame_num)
555 {
556 clutter_timeline_advance(gobj(), frame_num);
557 }
558
get_delta() const559 guint Timeline::get_delta() const
560 {
561 return clutter_timeline_get_delta(const_cast<ClutterTimeline*>(gobj()));
562 }
563
is_playing() const564 bool Timeline::is_playing() const
565 {
566 return clutter_timeline_is_playing(const_cast<ClutterTimeline*>(gobj()));
567 }
568
set_delay(guint msecs)569 void Timeline::set_delay(guint msecs)
570 {
571 clutter_timeline_set_delay(gobj(), msecs);
572 }
573
get_delay() const574 guint Timeline::get_delay() const
575 {
576 return clutter_timeline_get_delay(const_cast<ClutterTimeline*>(gobj()));
577 }
578
get_elapsed_time() const579 guint Timeline::get_elapsed_time() const
580 {
581 return clutter_timeline_get_elapsed_time(const_cast<ClutterTimeline*>(gobj()));
582 }
583
get_progress() const584 double Timeline::get_progress() const
585 {
586 return clutter_timeline_get_progress(const_cast<ClutterTimeline*>(gobj()));
587 }
588
set_direction(TimelineDirection direction)589 void Timeline::set_direction(TimelineDirection direction)
590 {
591 clutter_timeline_set_direction(gobj(), ((ClutterTimelineDirection)(direction)));
592 }
593
get_direction() const594 TimelineDirection Timeline::get_direction() const
595 {
596 return ((TimelineDirection)(clutter_timeline_get_direction(const_cast<ClutterTimeline*>(gobj()))));
597 }
598
add_marker_at_time(const Glib::ustring & marker_name,guint msecs)599 void Timeline::add_marker_at_time(const Glib::ustring& marker_name, guint msecs)
600 {
601 clutter_timeline_add_marker_at_time(gobj(), marker_name.c_str(), msecs);
602 }
603
has_marker(const Glib::ustring & marker_name)604 bool Timeline::has_marker(const Glib::ustring& marker_name)
605 {
606 return clutter_timeline_has_marker(gobj(), marker_name.c_str());
607 }
608
remove_marker(const Glib::ustring & marker_name)609 void Timeline::remove_marker(const Glib::ustring& marker_name)
610 {
611 clutter_timeline_remove_marker(gobj(), marker_name.c_str());
612 }
613
advance_to_marker(const Glib::ustring & marker_name)614 void Timeline::advance_to_marker(const Glib::ustring& marker_name)
615 {
616 clutter_timeline_advance_to_marker(gobj(), marker_name.c_str());
617 }
618
set_progress_mode(AnimationMode mode)619 void Timeline::set_progress_mode(AnimationMode mode)
620 {
621 clutter_timeline_set_progress_mode(gobj(), ((ClutterAnimationMode)(mode)));
622 }
623
get_progress_mode() const624 AnimationMode Timeline::get_progress_mode() const
625 {
626 return ((AnimationMode)(clutter_timeline_get_progress_mode(const_cast<ClutterTimeline*>(gobj()))));
627 }
628
629
signal_completed()630 Glib::SignalProxy0< void > Timeline::signal_completed()
631 {
632 return Glib::SignalProxy0< void >(this, &Timeline_signal_completed_info);
633 }
634
635
signal_new_frame()636 Glib::SignalProxy1< void,int > Timeline::signal_new_frame()
637 {
638 return Glib::SignalProxy1< void,int >(this, &Timeline_signal_new_frame_info);
639 }
640
641
signal_paused()642 Glib::SignalProxy0< void > Timeline::signal_paused()
643 {
644 return Glib::SignalProxy0< void >(this, &Timeline_signal_paused_info);
645 }
646
647
signal_started()648 Glib::SignalProxy0< void > Timeline::signal_started()
649 {
650 return Glib::SignalProxy0< void >(this, &Timeline_signal_started_info);
651 }
652
653
signal_marker_reached()654 Glib::SignalProxy2< void,const Glib::ustring&,int > Timeline::signal_marker_reached()
655 {
656 return Glib::SignalProxy2< void,const Glib::ustring&,int >(this, &Timeline_signal_marker_reached_info);
657 }
658
659
660 #ifdef GLIBMM_PROPERTIES_ENABLED
property_delay()661 Glib::PropertyProxy< guint > Timeline::property_delay()
662 {
663 return Glib::PropertyProxy< guint >(this, "delay");
664 }
665 #endif //GLIBMM_PROPERTIES_ENABLED
666
667 #ifdef GLIBMM_PROPERTIES_ENABLED
property_delay() const668 Glib::PropertyProxy_ReadOnly< guint > Timeline::property_delay() const
669 {
670 return Glib::PropertyProxy_ReadOnly< guint >(this, "delay");
671 }
672 #endif //GLIBMM_PROPERTIES_ENABLED
673
674 #ifdef GLIBMM_PROPERTIES_ENABLED
property_direction()675 Glib::PropertyProxy< TimelineDirection > Timeline::property_direction()
676 {
677 return Glib::PropertyProxy< TimelineDirection >(this, "direction");
678 }
679 #endif //GLIBMM_PROPERTIES_ENABLED
680
681 #ifdef GLIBMM_PROPERTIES_ENABLED
property_direction() const682 Glib::PropertyProxy_ReadOnly< TimelineDirection > Timeline::property_direction() const
683 {
684 return Glib::PropertyProxy_ReadOnly< TimelineDirection >(this, "direction");
685 }
686 #endif //GLIBMM_PROPERTIES_ENABLED
687
688 #ifdef GLIBMM_PROPERTIES_ENABLED
property_duration()689 Glib::PropertyProxy< guint > Timeline::property_duration()
690 {
691 return Glib::PropertyProxy< guint >(this, "duration");
692 }
693 #endif //GLIBMM_PROPERTIES_ENABLED
694
695 #ifdef GLIBMM_PROPERTIES_ENABLED
property_duration() const696 Glib::PropertyProxy_ReadOnly< guint > Timeline::property_duration() const
697 {
698 return Glib::PropertyProxy_ReadOnly< guint >(this, "duration");
699 }
700 #endif //GLIBMM_PROPERTIES_ENABLED
701
702 #ifndef CLUTTERMM_DISABLE_DEPRECATED
703
704 #ifdef GLIBMM_PROPERTIES_ENABLED
property_loop()705 Glib::PropertyProxy< bool > Timeline::property_loop()
706 {
707 return Glib::PropertyProxy< bool >(this, "loop");
708 }
709 #endif //GLIBMM_PROPERTIES_ENABLED
710 #endif // CLUTTERMM_DISABLE_DEPRECATED
711
712
713 #ifndef CLUTTERMM_DISABLE_DEPRECATED
714
715 #ifdef GLIBMM_PROPERTIES_ENABLED
property_loop() const716 Glib::PropertyProxy_ReadOnly< bool > Timeline::property_loop() const
717 {
718 return Glib::PropertyProxy_ReadOnly< bool >(this, "loop");
719 }
720 #endif //GLIBMM_PROPERTIES_ENABLED
721 #endif // CLUTTERMM_DISABLE_DEPRECATED
722
723
724 #ifdef GLIBMM_PROPERTIES_ENABLED
property_auto_reverse()725 Glib::PropertyProxy< bool > Timeline::property_auto_reverse()
726 {
727 return Glib::PropertyProxy< bool >(this, "auto-reverse");
728 }
729 #endif //GLIBMM_PROPERTIES_ENABLED
730
731 #ifdef GLIBMM_PROPERTIES_ENABLED
property_auto_reverse() const732 Glib::PropertyProxy_ReadOnly< bool > Timeline::property_auto_reverse() const
733 {
734 return Glib::PropertyProxy_ReadOnly< bool >(this, "auto-reverse");
735 }
736 #endif //GLIBMM_PROPERTIES_ENABLED
737
738 #ifdef GLIBMM_PROPERTIES_ENABLED
property_repeat_count()739 Glib::PropertyProxy< int > Timeline::property_repeat_count()
740 {
741 return Glib::PropertyProxy< int >(this, "repeat-count");
742 }
743 #endif //GLIBMM_PROPERTIES_ENABLED
744
745 #ifdef GLIBMM_PROPERTIES_ENABLED
property_repeat_count() const746 Glib::PropertyProxy_ReadOnly< int > Timeline::property_repeat_count() const
747 {
748 return Glib::PropertyProxy_ReadOnly< int >(this, "repeat-count");
749 }
750 #endif //GLIBMM_PROPERTIES_ENABLED
751
752 #ifdef GLIBMM_PROPERTIES_ENABLED
property_progress_mode()753 Glib::PropertyProxy< AnimationMode > Timeline::property_progress_mode()
754 {
755 return Glib::PropertyProxy< AnimationMode >(this, "progress-mode");
756 }
757 #endif //GLIBMM_PROPERTIES_ENABLED
758
759 #ifdef GLIBMM_PROPERTIES_ENABLED
property_progress_mode() const760 Glib::PropertyProxy_ReadOnly< AnimationMode > Timeline::property_progress_mode() const
761 {
762 return Glib::PropertyProxy_ReadOnly< AnimationMode >(this, "progress-mode");
763 }
764 #endif //GLIBMM_PROPERTIES_ENABLED
765
766
on_completed()767 void Clutter::Timeline::on_completed()
768 {
769 BaseClassType *const base = static_cast<BaseClassType*>(
770 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
771 );
772
773 if(base && base->completed)
774 (*base->completed)(gobj());
775 }
on_new_frame(int fram_num)776 void Clutter::Timeline::on_new_frame(int fram_num)
777 {
778 BaseClassType *const base = static_cast<BaseClassType*>(
779 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
780 );
781
782 if(base && base->new_frame)
783 (*base->new_frame)(gobj(),fram_num);
784 }
on_paused()785 void Clutter::Timeline::on_paused()
786 {
787 BaseClassType *const base = static_cast<BaseClassType*>(
788 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
789 );
790
791 if(base && base->paused)
792 (*base->paused)(gobj());
793 }
on_started()794 void Clutter::Timeline::on_started()
795 {
796 BaseClassType *const base = static_cast<BaseClassType*>(
797 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
798 );
799
800 if(base && base->started)
801 (*base->started)(gobj());
802 }
on_marker_reached(const Glib::ustring & marker_name,int frame_num)803 void Clutter::Timeline::on_marker_reached(const Glib::ustring& marker_name, int frame_num)
804 {
805 BaseClassType *const base = static_cast<BaseClassType*>(
806 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
807 );
808
809 if(base && base->marker_reached)
810 (*base->marker_reached)(gobj(),marker_name.c_str(),frame_num);
811 }
812
813
814 } // namespace Clutter
815
816
817