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/actor.h>
9 #include <cluttermm/private/actor_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 <cluttermm/layout-manager.h>
30 #include <cluttermm/constraint.h>
31 #include <cluttermm/content.h>
32 #include <clutter/clutter.h>
33 #include <iterator>
34
35 namespace Clutter
36 {
37
is_mapped() const38 bool Actor::is_mapped() const
39 {
40 return (CLUTTER_ACTOR_IS_MAPPED(gobj()) != 0);
41 }
42
is_realized() const43 bool Actor::is_realized() const
44 {
45 return (CLUTTER_ACTOR_IS_REALIZED(gobj()) != 0);
46 }
47
is_visible() const48 bool Actor::is_visible() const
49 {
50 return CLUTTER_ACTOR_IS_VISIBLE(gobj());
51 }
52
is_reactive() const53 bool Actor::is_reactive() const
54 {
55 return (CLUTTER_ACTOR_IS_REACTIVE(gobj()) != 0);
56 }
57
58 #ifndef CLUTTERMM_DISABLE_DEPRECATED
59
get_geometry() const60 Geometry Actor::get_geometry() const
61 {
62 Geometry geom;
63 clutter_actor_get_geometry(const_cast<ClutterActor*>(gobj()), geom.gobj());
64 return geom;
65 }
66 #endif // CLUTTERMM_DISABLE_DEPRECATED
67
68
69 #if 0
70 ActorBox Actor::get_paint_area() const
71 {
72 ActorBox box;
73 clutter_actor_get_paint_area(const_cast<ClutterActor*>(gobj()), box.gobj());
74 return box;
75 }
76 #endif
77
get_abs_allocation_vertices(Vertex vertices[4]) const78 void Actor::get_abs_allocation_vertices(Vertex vertices[4]) const
79 {
80 clutter_actor_get_abs_allocation_vertices(const_cast<ClutterActor*>(gobj()), reinterpret_cast<ClutterVertex*>(vertices));
81 }
82
get_allocation_vertices(Vertex vertices[4]) const83 void Actor::get_allocation_vertices(Vertex vertices[4]) const
84 {
85 clutter_actor_get_allocation_vertices(const_cast<ClutterActor*>(gobj()), NULL, reinterpret_cast<ClutterVertex*>(vertices));
86 }
87
get_allocation_vertices(const Glib::RefPtr<Actor> & ancestor,Vertex vertices[4]) const88 void Actor::get_allocation_vertices(const Glib::RefPtr<Actor>& ancestor, Vertex vertices[4]) const
89 {
90 clutter_actor_get_allocation_vertices(const_cast<ClutterActor*>(gobj()), Glib::unwrap(ancestor), reinterpret_cast<ClutterVertex*>(vertices));
91 }
92
get_allocation_box() const93 ActorBox Actor::get_allocation_box() const
94 {
95 ActorBox box;
96 clutter_actor_get_allocation_box(const_cast<ClutterActor*>(gobj()), box.gobj());
97 return box;
98 }
99
get_content_box() const100 ActorBox Actor::get_content_box() const
101 {
102 ActorBox box;
103 clutter_actor_get_content_box(const_cast<ClutterActor*>(gobj()), box.gobj());
104 return box;
105 }
106
apply_relative_transform_to_point(const Vertex & point,Vertex & vertex) const107 void Actor::apply_relative_transform_to_point(const Vertex& point, Vertex& vertex) const
108 {
109 clutter_actor_apply_relative_transform_to_point(const_cast<ClutterActor*>(gobj()), NULL, const_cast<ClutterVertex*>(point.gobj()), vertex.gobj());
110 }
111
112 #ifndef CLUTTERMM_DISABLE_DEPRECATED
113
get_allocation_geometry() const114 Geometry Actor::get_allocation_geometry() const
115 {
116 Geometry geom;
117 clutter_actor_get_allocation_geometry(const_cast<ClutterActor*>(gobj()), geom.gobj());
118 return geom;
119 }
120 #endif // CLUTTERMM_DISABLE_DEPRECATED
121
122
set_margins(float top,float left,float bottom,float right)123 void Actor::set_margins(float top, float left, float bottom, float right)
124 {
125 set_margin_top(top);
126 set_margin_left(left);
127 set_margin_bottom(bottom);
128 set_margin_right(right);
129 }
130
get_background_color() const131 Color Actor::get_background_color() const
132 {
133 Color result;
134 clutter_actor_get_background_color(const_cast<ClutterActor*>(gobj()), result.gobj());
135 return result;
136 }
137
unset_layout_manager()138 void Actor::unset_layout_manager()
139 {
140 clutter_actor_set_layout_manager(gobj(), 0);
141 }
142
143
get_transform() const144 Matrix Actor::get_transform() const
145 {
146 Matrix matrix;
147 clutter_actor_get_transform(const_cast<ClutterActor*>(this->gobj()), &matrix);
148 return matrix;
149 }
150
get_child_transform() const151 Matrix Actor::get_child_transform() const
152 {
153 Matrix matrix;
154 clutter_actor_get_child_transform(const_cast<ClutterActor*>(this->gobj()), &matrix);
155 return matrix;
156 }
157
158 // Glib::RefPtr<Animation>
159 // Actor::animate(gulong mode, guint duration, const std::map<std::string, Glib::ValueBase>& properties)
160 // {
161 // gchar* c_properties[properties.size()];
162 // GValue values[properties.size()];
163
164 // for(std::map<std::string, Glib::ValueBase>::const_iterator iter = properties.begin(); iter != properties.end(); ++iter)
165 // {
166 // c_properties[std::distance(properties.begin(), iter)] = g_strdup(iter->first.c_str());
167 // g_value_copy(iter->second.gobj(), &values[std::distance(properties.begin(), iter)]);
168 // }
169
170 // return Glib::wrap(clutter_actor_animatev(gobj(), mode, duration, properties.size(), c_properties, values));
171 // }
172
173 // Glib::RefPtr<Animation>
174 // Actor::animate(gulong mode, const Glib::RefPtr<Timeline>& timeline, const std::map<std::string, Glib::ValueBase>& properties)
175 // {
176 // gchar* c_properties[properties.size()];
177 // GValue values[properties.size()];
178
179 // for(std::map<std::string, Glib::ValueBase>::const_iterator iter = properties.begin(); iter != properties.end(); ++iter)
180 // {
181 // c_properties[std::distance(properties.begin(), iter)] = g_strdup(iter->first.c_str());
182 // g_value_copy(iter->second.gobj(), &values[std::distance(properties.begin(), iter)]);
183 // }
184
185 // return Glib::wrap(clutter_actor_animate_with_timelinev(gobj(), mode, timeline->gobj(), properties.size(), c_properties, values));
186 // }
187
188 // Glib::RefPtr<Animation>
189 // Actor::animate(const Glib::RefPtr<Alpha>& alpha, const std::map<std::string, Glib::ValueBase>& properties)
190 // {
191 // gchar* c_properties[properties.size()];
192 // GValue values[properties.size()];
193
194 // for(std::map<std::string, Glib::ValueBase>::const_iterator iter = properties.begin(); iter != properties.end(); ++iter)
195 // {
196 // c_properties[std::distance(properties.begin(), iter)] = g_strdup(iter->first.c_str());
197 // g_value_copy(iter->second.gobj(), &values[std::distance(properties.begin(), iter)]);
198 // }
199
200 // return Glib::wrap(clutter_actor_animate_with_alphav(gobj(), alpha->gobj(), properties.size(), c_properties, values));
201 // }
202
203 #if 0
204 // We need to hand-code this vfunc to write the result back into the
205 // box variable. The C++ wrapper cannot ref the existing variable, but only
206 // make a copy.
207 void Actor_Class::get_paint_area_vfunc_callback(ClutterActor* self, ClutterActorBox* box)
208 {
209 CppObjectType *const obj = dynamic_cast<CppObjectType*>(
210 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
211
212 // Non-gtkmmproc-generated custom classes implicitly call the default
213 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
214 // generated classes can use this optimisation, which avoids the unnecessary
215 // parameter conversions if there is no possibility of the virtual function
216 // being overridden:
217 if(obj && obj->is_derived_())
218 {
219 #ifdef GLIBMM_EXCEPTIONS_ENABLED
220 try // Trap C++ exceptions which would normally be lost because this is a C callback.
221 {
222 #endif //GLIBMM_EXCEPTIONS_ENABLED
223 // Call the virtual member method, which derived classes might override.
224 ActorBox cpp_box;
225 obj->get_paint_area_vfunc(cpp_box);
226 *box = *cpp_box.gobj();
227 #ifdef GLIBMM_EXCEPTIONS_ENABLED
228 }
229 catch(...)
230 {
231 Glib::exception_handlers_invoke();
232 }
233 #endif //GLIBMM_EXCEPTIONS_ENABLED
234 }
235 else
236 {
237 BaseClassType *const base = static_cast<BaseClassType*>(
238 g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
239 g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
240 ) );
241
242 // Call the original underlying C function:
243 if(base && base->get_paint_area)
244 (*base->get_paint_area)(self, box);
245 }
246 }
247
248 void Actor::get_paint_area_vfunc(ActorBox& box) const
249 {
250 //Call the default C implementation:
251
252 BaseClassType *const base = static_cast<BaseClassType*>(
253 g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
254 g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
255 )
256 );
257
258 if(base && base->get_paint_area)
259 (*base->get_paint_area)(const_cast<ClutterActor*>(gobj()), box.gobj());
260 }
261 #endif
262
263 } //namespace Clutter
264
265 namespace
266 {
267
268
Actor_signal_button_press_event_callback(ClutterActor * self,ClutterButtonEvent * p0,void * data)269 static gboolean Actor_signal_button_press_event_callback(ClutterActor* self, ClutterButtonEvent* p0,void* data)
270 {
271 using namespace Clutter;
272 typedef sigc::slot< bool,ButtonEvent* > SlotType;
273
274 // Do not try to call a signal on a disassociated wrapper.
275 if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
276 {
277 #ifdef GLIBMM_EXCEPTIONS_ENABLED
278 try
279 {
280 #endif //GLIBMM_EXCEPTIONS_ENABLED
281 if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
282 return static_cast<int>((*static_cast<SlotType*>(slot))(p0
283 ));
284 #ifdef GLIBMM_EXCEPTIONS_ENABLED
285 }
286 catch(...)
287 {
288 Glib::exception_handlers_invoke();
289 }
290 #endif //GLIBMM_EXCEPTIONS_ENABLED
291 }
292
293 typedef gboolean RType;
294 return RType();
295 }
296
Actor_signal_button_press_event_notify_callback(ClutterActor * self,ClutterButtonEvent * p0,void * data)297 static gboolean Actor_signal_button_press_event_notify_callback(ClutterActor* self, ClutterButtonEvent* p0, void* data)
298 {
299 using namespace Clutter;
300 typedef sigc::slot< void,ButtonEvent* > SlotType;
301
302 // Do not try to call a signal on a disassociated wrapper.
303 if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
304 {
305 #ifdef GLIBMM_EXCEPTIONS_ENABLED
306 try
307 {
308 #endif //GLIBMM_EXCEPTIONS_ENABLED
309 if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
310 (*static_cast<SlotType*>(slot))(p0
311 );
312 #ifdef GLIBMM_EXCEPTIONS_ENABLED
313 }
314 catch(...)
315 {
316 Glib::exception_handlers_invoke();
317 }
318 #endif //GLIBMM_EXCEPTIONS_ENABLED
319 }
320
321 typedef gboolean RType;
322 return RType();
323 }
324
325 static const Glib::SignalProxyInfo Actor_signal_button_press_event_info =
326 {
327 "button_press_event",
328 (GCallback) &Actor_signal_button_press_event_callback,
329 (GCallback) &Actor_signal_button_press_event_notify_callback
330 };
331
332
Actor_signal_button_release_event_callback(ClutterActor * self,ClutterButtonEvent * p0,void * data)333 static gboolean Actor_signal_button_release_event_callback(ClutterActor* self, ClutterButtonEvent* p0,void* data)
334 {
335 using namespace Clutter;
336 typedef sigc::slot< bool,ButtonEvent* > SlotType;
337
338 // Do not try to call a signal on a disassociated wrapper.
339 if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
340 {
341 #ifdef GLIBMM_EXCEPTIONS_ENABLED
342 try
343 {
344 #endif //GLIBMM_EXCEPTIONS_ENABLED
345 if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
346 return static_cast<int>((*static_cast<SlotType*>(slot))(p0
347 ));
348 #ifdef GLIBMM_EXCEPTIONS_ENABLED
349 }
350 catch(...)
351 {
352 Glib::exception_handlers_invoke();
353 }
354 #endif //GLIBMM_EXCEPTIONS_ENABLED
355 }
356
357 typedef gboolean RType;
358 return RType();
359 }
360
Actor_signal_button_release_event_notify_callback(ClutterActor * self,ClutterButtonEvent * p0,void * data)361 static gboolean Actor_signal_button_release_event_notify_callback(ClutterActor* self, ClutterButtonEvent* p0, void* data)
362 {
363 using namespace Clutter;
364 typedef sigc::slot< void,ButtonEvent* > SlotType;
365
366 // Do not try to call a signal on a disassociated wrapper.
367 if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
368 {
369 #ifdef GLIBMM_EXCEPTIONS_ENABLED
370 try
371 {
372 #endif //GLIBMM_EXCEPTIONS_ENABLED
373 if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
374 (*static_cast<SlotType*>(slot))(p0
375 );
376 #ifdef GLIBMM_EXCEPTIONS_ENABLED
377 }
378 catch(...)
379 {
380 Glib::exception_handlers_invoke();
381 }
382 #endif //GLIBMM_EXCEPTIONS_ENABLED
383 }
384
385 typedef gboolean RType;
386 return RType();
387 }
388
389 static const Glib::SignalProxyInfo Actor_signal_button_release_event_info =
390 {
391 "button_release_event",
392 (GCallback) &Actor_signal_button_release_event_callback,
393 (GCallback) &Actor_signal_button_release_event_notify_callback
394 };
395
396
Actor_signal_motion_event_callback(ClutterActor * self,ClutterMotionEvent * p0,void * data)397 static gboolean Actor_signal_motion_event_callback(ClutterActor* self, ClutterMotionEvent* p0,void* data)
398 {
399 using namespace Clutter;
400 typedef sigc::slot< bool,MotionEvent* > SlotType;
401
402 // Do not try to call a signal on a disassociated wrapper.
403 if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
404 {
405 #ifdef GLIBMM_EXCEPTIONS_ENABLED
406 try
407 {
408 #endif //GLIBMM_EXCEPTIONS_ENABLED
409 if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
410 return static_cast<int>((*static_cast<SlotType*>(slot))(p0
411 ));
412 #ifdef GLIBMM_EXCEPTIONS_ENABLED
413 }
414 catch(...)
415 {
416 Glib::exception_handlers_invoke();
417 }
418 #endif //GLIBMM_EXCEPTIONS_ENABLED
419 }
420
421 typedef gboolean RType;
422 return RType();
423 }
424
Actor_signal_motion_event_notify_callback(ClutterActor * self,ClutterMotionEvent * p0,void * data)425 static gboolean Actor_signal_motion_event_notify_callback(ClutterActor* self, ClutterMotionEvent* p0, void* data)
426 {
427 using namespace Clutter;
428 typedef sigc::slot< void,MotionEvent* > SlotType;
429
430 // Do not try to call a signal on a disassociated wrapper.
431 if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
432 {
433 #ifdef GLIBMM_EXCEPTIONS_ENABLED
434 try
435 {
436 #endif //GLIBMM_EXCEPTIONS_ENABLED
437 if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
438 (*static_cast<SlotType*>(slot))(p0
439 );
440 #ifdef GLIBMM_EXCEPTIONS_ENABLED
441 }
442 catch(...)
443 {
444 Glib::exception_handlers_invoke();
445 }
446 #endif //GLIBMM_EXCEPTIONS_ENABLED
447 }
448
449 typedef gboolean RType;
450 return RType();
451 }
452
453 static const Glib::SignalProxyInfo Actor_signal_motion_event_info =
454 {
455 "motion_event",
456 (GCallback) &Actor_signal_motion_event_callback,
457 (GCallback) &Actor_signal_motion_event_notify_callback
458 };
459
460
Actor_signal_leave_event_callback(ClutterActor * self,ClutterCrossingEvent * p0,void * data)461 static gboolean Actor_signal_leave_event_callback(ClutterActor* self, ClutterCrossingEvent* p0,void* data)
462 {
463 using namespace Clutter;
464 typedef sigc::slot< bool,CrossingEvent* > SlotType;
465
466 // Do not try to call a signal on a disassociated wrapper.
467 if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
468 {
469 #ifdef GLIBMM_EXCEPTIONS_ENABLED
470 try
471 {
472 #endif //GLIBMM_EXCEPTIONS_ENABLED
473 if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
474 return static_cast<int>((*static_cast<SlotType*>(slot))(p0
475 ));
476 #ifdef GLIBMM_EXCEPTIONS_ENABLED
477 }
478 catch(...)
479 {
480 Glib::exception_handlers_invoke();
481 }
482 #endif //GLIBMM_EXCEPTIONS_ENABLED
483 }
484
485 typedef gboolean RType;
486 return RType();
487 }
488
Actor_signal_leave_event_notify_callback(ClutterActor * self,ClutterCrossingEvent * p0,void * data)489 static gboolean Actor_signal_leave_event_notify_callback(ClutterActor* self, ClutterCrossingEvent* p0, void* data)
490 {
491 using namespace Clutter;
492 typedef sigc::slot< void,CrossingEvent* > SlotType;
493
494 // Do not try to call a signal on a disassociated wrapper.
495 if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
496 {
497 #ifdef GLIBMM_EXCEPTIONS_ENABLED
498 try
499 {
500 #endif //GLIBMM_EXCEPTIONS_ENABLED
501 if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
502 (*static_cast<SlotType*>(slot))(p0
503 );
504 #ifdef GLIBMM_EXCEPTIONS_ENABLED
505 }
506 catch(...)
507 {
508 Glib::exception_handlers_invoke();
509 }
510 #endif //GLIBMM_EXCEPTIONS_ENABLED
511 }
512
513 typedef gboolean RType;
514 return RType();
515 }
516
517 static const Glib::SignalProxyInfo Actor_signal_leave_event_info =
518 {
519 "leave_event",
520 (GCallback) &Actor_signal_leave_event_callback,
521 (GCallback) &Actor_signal_leave_event_notify_callback
522 };
523
524
525 static const Glib::SignalProxyInfo Actor_signal_show_info =
526 {
527 "show",
528 (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
529 (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
530 };
531
532
533 static const Glib::SignalProxyInfo Actor_signal_hide_info =
534 {
535 "hide",
536 (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
537 (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
538 };
539
540
Actor_signal_key_release_event_callback(ClutterActor * self,ClutterKeyEvent * p0,void * data)541 static gboolean Actor_signal_key_release_event_callback(ClutterActor* self, ClutterKeyEvent* p0,void* data)
542 {
543 using namespace Clutter;
544 typedef sigc::slot< bool,KeyEvent* > SlotType;
545
546 // Do not try to call a signal on a disassociated wrapper.
547 if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
548 {
549 #ifdef GLIBMM_EXCEPTIONS_ENABLED
550 try
551 {
552 #endif //GLIBMM_EXCEPTIONS_ENABLED
553 if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
554 return static_cast<int>((*static_cast<SlotType*>(slot))(p0
555 ));
556 #ifdef GLIBMM_EXCEPTIONS_ENABLED
557 }
558 catch(...)
559 {
560 Glib::exception_handlers_invoke();
561 }
562 #endif //GLIBMM_EXCEPTIONS_ENABLED
563 }
564
565 typedef gboolean RType;
566 return RType();
567 }
568
Actor_signal_key_release_event_notify_callback(ClutterActor * self,ClutterKeyEvent * p0,void * data)569 static gboolean Actor_signal_key_release_event_notify_callback(ClutterActor* self, ClutterKeyEvent* p0, void* data)
570 {
571 using namespace Clutter;
572 typedef sigc::slot< void,KeyEvent* > SlotType;
573
574 // Do not try to call a signal on a disassociated wrapper.
575 if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
576 {
577 #ifdef GLIBMM_EXCEPTIONS_ENABLED
578 try
579 {
580 #endif //GLIBMM_EXCEPTIONS_ENABLED
581 if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
582 (*static_cast<SlotType*>(slot))(p0
583 );
584 #ifdef GLIBMM_EXCEPTIONS_ENABLED
585 }
586 catch(...)
587 {
588 Glib::exception_handlers_invoke();
589 }
590 #endif //GLIBMM_EXCEPTIONS_ENABLED
591 }
592
593 typedef gboolean RType;
594 return RType();
595 }
596
597 static const Glib::SignalProxyInfo Actor_signal_key_release_event_info =
598 {
599 "key_release_event",
600 (GCallback) &Actor_signal_key_release_event_callback,
601 (GCallback) &Actor_signal_key_release_event_notify_callback
602 };
603
604
Actor_signal_enter_event_callback(ClutterActor * self,ClutterCrossingEvent * p0,void * data)605 static gboolean Actor_signal_enter_event_callback(ClutterActor* self, ClutterCrossingEvent* p0,void* data)
606 {
607 using namespace Clutter;
608 typedef sigc::slot< bool,CrossingEvent* > SlotType;
609
610 // Do not try to call a signal on a disassociated wrapper.
611 if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
612 {
613 #ifdef GLIBMM_EXCEPTIONS_ENABLED
614 try
615 {
616 #endif //GLIBMM_EXCEPTIONS_ENABLED
617 if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
618 return static_cast<int>((*static_cast<SlotType*>(slot))(p0
619 ));
620 #ifdef GLIBMM_EXCEPTIONS_ENABLED
621 }
622 catch(...)
623 {
624 Glib::exception_handlers_invoke();
625 }
626 #endif //GLIBMM_EXCEPTIONS_ENABLED
627 }
628
629 typedef gboolean RType;
630 return RType();
631 }
632
Actor_signal_enter_event_notify_callback(ClutterActor * self,ClutterCrossingEvent * p0,void * data)633 static gboolean Actor_signal_enter_event_notify_callback(ClutterActor* self, ClutterCrossingEvent* p0, void* data)
634 {
635 using namespace Clutter;
636 typedef sigc::slot< void,CrossingEvent* > SlotType;
637
638 // Do not try to call a signal on a disassociated wrapper.
639 if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
640 {
641 #ifdef GLIBMM_EXCEPTIONS_ENABLED
642 try
643 {
644 #endif //GLIBMM_EXCEPTIONS_ENABLED
645 if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
646 (*static_cast<SlotType*>(slot))(p0
647 );
648 #ifdef GLIBMM_EXCEPTIONS_ENABLED
649 }
650 catch(...)
651 {
652 Glib::exception_handlers_invoke();
653 }
654 #endif //GLIBMM_EXCEPTIONS_ENABLED
655 }
656
657 typedef gboolean RType;
658 return RType();
659 }
660
661 static const Glib::SignalProxyInfo Actor_signal_enter_event_info =
662 {
663 "enter_event",
664 (GCallback) &Actor_signal_enter_event_callback,
665 (GCallback) &Actor_signal_enter_event_notify_callback
666 };
667
668
Actor_signal_event_callback(ClutterActor * self,ClutterEvent * p0,void * data)669 static gboolean Actor_signal_event_callback(ClutterActor* self, ClutterEvent* p0,void* data)
670 {
671 using namespace Clutter;
672 typedef sigc::slot< bool,Event* > SlotType;
673
674 // Do not try to call a signal on a disassociated wrapper.
675 if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
676 {
677 #ifdef GLIBMM_EXCEPTIONS_ENABLED
678 try
679 {
680 #endif //GLIBMM_EXCEPTIONS_ENABLED
681 if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
682 return static_cast<int>((*static_cast<SlotType*>(slot))(p0
683 ));
684 #ifdef GLIBMM_EXCEPTIONS_ENABLED
685 }
686 catch(...)
687 {
688 Glib::exception_handlers_invoke();
689 }
690 #endif //GLIBMM_EXCEPTIONS_ENABLED
691 }
692
693 typedef gboolean RType;
694 return RType();
695 }
696
Actor_signal_event_notify_callback(ClutterActor * self,ClutterEvent * p0,void * data)697 static gboolean Actor_signal_event_notify_callback(ClutterActor* self, ClutterEvent* p0, void* data)
698 {
699 using namespace Clutter;
700 typedef sigc::slot< void,Event* > SlotType;
701
702 // Do not try to call a signal on a disassociated wrapper.
703 if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
704 {
705 #ifdef GLIBMM_EXCEPTIONS_ENABLED
706 try
707 {
708 #endif //GLIBMM_EXCEPTIONS_ENABLED
709 if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
710 (*static_cast<SlotType*>(slot))(p0
711 );
712 #ifdef GLIBMM_EXCEPTIONS_ENABLED
713 }
714 catch(...)
715 {
716 Glib::exception_handlers_invoke();
717 }
718 #endif //GLIBMM_EXCEPTIONS_ENABLED
719 }
720
721 typedef gboolean RType;
722 return RType();
723 }
724
725 static const Glib::SignalProxyInfo Actor_signal_event_info =
726 {
727 "event",
728 (GCallback) &Actor_signal_event_callback,
729 (GCallback) &Actor_signal_event_notify_callback
730 };
731
732
733 static const Glib::SignalProxyInfo Actor_signal_key_focus_out_info =
734 {
735 "key-focus_out",
736 (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
737 (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
738 };
739
740
741 static const Glib::SignalProxyInfo Actor_signal_key_focus_in_info =
742 {
743 "key-focus_in",
744 (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
745 (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
746 };
747
748
Actor_signal_parent_set_callback(ClutterActor * self,ClutterActor * p0,void * data)749 static void Actor_signal_parent_set_callback(ClutterActor* self, ClutterActor* p0,void* data)
750 {
751 using namespace Clutter;
752 typedef sigc::slot< void,const Glib::RefPtr<Actor>& > SlotType;
753
754 // Do not try to call a signal on a disassociated wrapper.
755 if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
756 {
757 #ifdef GLIBMM_EXCEPTIONS_ENABLED
758 try
759 {
760 #endif //GLIBMM_EXCEPTIONS_ENABLED
761 if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
762 (*static_cast<SlotType*>(slot))(Glib::wrap((p0),true)
763 );
764 #ifdef GLIBMM_EXCEPTIONS_ENABLED
765 }
766 catch(...)
767 {
768 Glib::exception_handlers_invoke();
769 }
770 #endif //GLIBMM_EXCEPTIONS_ENABLED
771 }
772 }
773
774 static const Glib::SignalProxyInfo Actor_signal_parent_set_info =
775 {
776 "parent_set",
777 (GCallback) &Actor_signal_parent_set_callback,
778 (GCallback) &Actor_signal_parent_set_callback
779 };
780
781
Actor_signal_scroll_event_callback(ClutterActor * self,ClutterScrollEvent * p0,void * data)782 static gboolean Actor_signal_scroll_event_callback(ClutterActor* self, ClutterScrollEvent* p0,void* data)
783 {
784 using namespace Clutter;
785 typedef sigc::slot< bool,ScrollEvent* > SlotType;
786
787 // Do not try to call a signal on a disassociated wrapper.
788 if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
789 {
790 #ifdef GLIBMM_EXCEPTIONS_ENABLED
791 try
792 {
793 #endif //GLIBMM_EXCEPTIONS_ENABLED
794 if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
795 return static_cast<int>((*static_cast<SlotType*>(slot))(p0
796 ));
797 #ifdef GLIBMM_EXCEPTIONS_ENABLED
798 }
799 catch(...)
800 {
801 Glib::exception_handlers_invoke();
802 }
803 #endif //GLIBMM_EXCEPTIONS_ENABLED
804 }
805
806 typedef gboolean RType;
807 return RType();
808 }
809
Actor_signal_scroll_event_notify_callback(ClutterActor * self,ClutterScrollEvent * p0,void * data)810 static gboolean Actor_signal_scroll_event_notify_callback(ClutterActor* self, ClutterScrollEvent* p0, void* data)
811 {
812 using namespace Clutter;
813 typedef sigc::slot< void,ScrollEvent* > SlotType;
814
815 // Do not try to call a signal on a disassociated wrapper.
816 if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
817 {
818 #ifdef GLIBMM_EXCEPTIONS_ENABLED
819 try
820 {
821 #endif //GLIBMM_EXCEPTIONS_ENABLED
822 if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
823 (*static_cast<SlotType*>(slot))(p0
824 );
825 #ifdef GLIBMM_EXCEPTIONS_ENABLED
826 }
827 catch(...)
828 {
829 Glib::exception_handlers_invoke();
830 }
831 #endif //GLIBMM_EXCEPTIONS_ENABLED
832 }
833
834 typedef gboolean RType;
835 return RType();
836 }
837
838 static const Glib::SignalProxyInfo Actor_signal_scroll_event_info =
839 {
840 "scroll_event",
841 (GCallback) &Actor_signal_scroll_event_callback,
842 (GCallback) &Actor_signal_scroll_event_notify_callback
843 };
844
845
Actor_signal_key_press_event_callback(ClutterActor * self,ClutterKeyEvent * p0,void * data)846 static gboolean Actor_signal_key_press_event_callback(ClutterActor* self, ClutterKeyEvent* p0,void* data)
847 {
848 using namespace Clutter;
849 typedef sigc::slot< bool,KeyEvent* > SlotType;
850
851 // Do not try to call a signal on a disassociated wrapper.
852 if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
853 {
854 #ifdef GLIBMM_EXCEPTIONS_ENABLED
855 try
856 {
857 #endif //GLIBMM_EXCEPTIONS_ENABLED
858 if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
859 return static_cast<int>((*static_cast<SlotType*>(slot))(p0
860 ));
861 #ifdef GLIBMM_EXCEPTIONS_ENABLED
862 }
863 catch(...)
864 {
865 Glib::exception_handlers_invoke();
866 }
867 #endif //GLIBMM_EXCEPTIONS_ENABLED
868 }
869
870 typedef gboolean RType;
871 return RType();
872 }
873
Actor_signal_key_press_event_notify_callback(ClutterActor * self,ClutterKeyEvent * p0,void * data)874 static gboolean Actor_signal_key_press_event_notify_callback(ClutterActor* self, ClutterKeyEvent* p0, void* data)
875 {
876 using namespace Clutter;
877 typedef sigc::slot< void,KeyEvent* > SlotType;
878
879 // Do not try to call a signal on a disassociated wrapper.
880 if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
881 {
882 #ifdef GLIBMM_EXCEPTIONS_ENABLED
883 try
884 {
885 #endif //GLIBMM_EXCEPTIONS_ENABLED
886 if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
887 (*static_cast<SlotType*>(slot))(p0
888 );
889 #ifdef GLIBMM_EXCEPTIONS_ENABLED
890 }
891 catch(...)
892 {
893 Glib::exception_handlers_invoke();
894 }
895 #endif //GLIBMM_EXCEPTIONS_ENABLED
896 }
897
898 typedef gboolean RType;
899 return RType();
900 }
901
902 static const Glib::SignalProxyInfo Actor_signal_key_press_event_info =
903 {
904 "key_press_event",
905 (GCallback) &Actor_signal_key_press_event_callback,
906 (GCallback) &Actor_signal_key_press_event_notify_callback
907 };
908
909
Actor_signal_captured_event_callback(ClutterActor * self,ClutterEvent * p0,void * data)910 static gboolean Actor_signal_captured_event_callback(ClutterActor* self, ClutterEvent* p0,void* data)
911 {
912 using namespace Clutter;
913 typedef sigc::slot< bool,Event* > SlotType;
914
915 // Do not try to call a signal on a disassociated wrapper.
916 if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
917 {
918 #ifdef GLIBMM_EXCEPTIONS_ENABLED
919 try
920 {
921 #endif //GLIBMM_EXCEPTIONS_ENABLED
922 if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
923 return static_cast<int>((*static_cast<SlotType*>(slot))(p0
924 ));
925 #ifdef GLIBMM_EXCEPTIONS_ENABLED
926 }
927 catch(...)
928 {
929 Glib::exception_handlers_invoke();
930 }
931 #endif //GLIBMM_EXCEPTIONS_ENABLED
932 }
933
934 typedef gboolean RType;
935 return RType();
936 }
937
Actor_signal_captured_event_notify_callback(ClutterActor * self,ClutterEvent * p0,void * data)938 static gboolean Actor_signal_captured_event_notify_callback(ClutterActor* self, ClutterEvent* p0, void* data)
939 {
940 using namespace Clutter;
941 typedef sigc::slot< void,Event* > SlotType;
942
943 // Do not try to call a signal on a disassociated wrapper.
944 if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
945 {
946 #ifdef GLIBMM_EXCEPTIONS_ENABLED
947 try
948 {
949 #endif //GLIBMM_EXCEPTIONS_ENABLED
950 if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
951 (*static_cast<SlotType*>(slot))(p0
952 );
953 #ifdef GLIBMM_EXCEPTIONS_ENABLED
954 }
955 catch(...)
956 {
957 Glib::exception_handlers_invoke();
958 }
959 #endif //GLIBMM_EXCEPTIONS_ENABLED
960 }
961
962 typedef gboolean RType;
963 return RType();
964 }
965
966 static const Glib::SignalProxyInfo Actor_signal_captured_event_info =
967 {
968 "captured_event",
969 (GCallback) &Actor_signal_captured_event_callback,
970 (GCallback) &Actor_signal_captured_event_notify_callback
971 };
972
973
Actor_signal_queue_redaw_callback(ClutterActor * self,ClutterActor * p0,void * data)974 static void Actor_signal_queue_redaw_callback(ClutterActor* self, ClutterActor* p0,void* data)
975 {
976 using namespace Clutter;
977 typedef sigc::slot< void,const Glib::RefPtr<Actor>& > SlotType;
978
979 // Do not try to call a signal on a disassociated wrapper.
980 if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
981 {
982 #ifdef GLIBMM_EXCEPTIONS_ENABLED
983 try
984 {
985 #endif //GLIBMM_EXCEPTIONS_ENABLED
986 if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
987 (*static_cast<SlotType*>(slot))(Glib::wrap((p0),true)
988 );
989 #ifdef GLIBMM_EXCEPTIONS_ENABLED
990 }
991 catch(...)
992 {
993 Glib::exception_handlers_invoke();
994 }
995 #endif //GLIBMM_EXCEPTIONS_ENABLED
996 }
997 }
998
999 static const Glib::SignalProxyInfo Actor_signal_queue_redaw_info =
1000 {
1001 "queue_redraw",
1002 (GCallback) &Actor_signal_queue_redaw_callback,
1003 (GCallback) &Actor_signal_queue_redaw_callback
1004 };
1005
1006
1007 static const Glib::SignalProxyInfo Actor_signal_queue_relayout_info =
1008 {
1009 "queue_relayout",
1010 (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
1011 (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
1012 };
1013
1014
1015 static const Glib::SignalProxyInfo Actor_signal_realize_info =
1016 {
1017 "realize",
1018 (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
1019 (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
1020 };
1021
1022
1023 static const Glib::SignalProxyInfo Actor_signal_unrealize_info =
1024 {
1025 "unrealize",
1026 (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
1027 (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
1028 };
1029
1030
Actor_signal_pick_callback(ClutterActor * self,const ClutterColor * color,void * data)1031 static void Actor_signal_pick_callback(ClutterActor* self, const ClutterColor* color,void* data)
1032 {
1033 using namespace Clutter;
1034 typedef sigc::slot< void,const Color& > SlotType;
1035
1036 // Do not try to call a signal on a disassociated wrapper.
1037 if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1038 {
1039 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1040 try
1041 {
1042 #endif //GLIBMM_EXCEPTIONS_ENABLED
1043 if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1044 (*static_cast<SlotType*>(slot))(Color(const_cast<ClutterColor*>(color), true)
1045 );
1046 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1047 }
1048 catch(...)
1049 {
1050 Glib::exception_handlers_invoke();
1051 }
1052 #endif //GLIBMM_EXCEPTIONS_ENABLED
1053 }
1054 }
1055
1056 static const Glib::SignalProxyInfo Actor_signal_pick_info =
1057 {
1058 "pick",
1059 (GCallback) &Actor_signal_pick_callback,
1060 (GCallback) &Actor_signal_pick_callback
1061 };
1062
1063
Actor_signal_allocation_changed_callback(ClutterActor * self,ClutterActorBox * p0,ClutterAllocationFlags p1,void * data)1064 static void Actor_signal_allocation_changed_callback(ClutterActor* self, ClutterActorBox* p0,ClutterAllocationFlags p1,void* data)
1065 {
1066 using namespace Clutter;
1067 typedef sigc::slot< void,const ActorBox&,AllocationFlags > SlotType;
1068
1069 // Do not try to call a signal on a disassociated wrapper.
1070 if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1071 {
1072 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1073 try
1074 {
1075 #endif //GLIBMM_EXCEPTIONS_ENABLED
1076 if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1077 (*static_cast<SlotType*>(slot))(ActorBox(const_cast<ClutterActorBox*>(p0))
1078 , ((AllocationFlags)(p1))
1079 );
1080 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1081 }
1082 catch(...)
1083 {
1084 Glib::exception_handlers_invoke();
1085 }
1086 #endif //GLIBMM_EXCEPTIONS_ENABLED
1087 }
1088 }
1089
1090 static const Glib::SignalProxyInfo Actor_signal_allocation_changed_info =
1091 {
1092 "allocation-changed",
1093 (GCallback) &Actor_signal_allocation_changed_callback,
1094 (GCallback) &Actor_signal_allocation_changed_callback
1095 };
1096
1097
Actor_signal_touch_event_callback(ClutterActor * self,ClutterTouchEvent * p0,void * data)1098 static gboolean Actor_signal_touch_event_callback(ClutterActor* self, ClutterTouchEvent* p0,void* data)
1099 {
1100 using namespace Clutter;
1101 typedef sigc::slot< bool,ClutterTouchEvent* > SlotType;
1102
1103 // Do not try to call a signal on a disassociated wrapper.
1104 if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1105 {
1106 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1107 try
1108 {
1109 #endif //GLIBMM_EXCEPTIONS_ENABLED
1110 if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1111 return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
1112 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1113 }
1114 catch(...)
1115 {
1116 Glib::exception_handlers_invoke();
1117 }
1118 #endif //GLIBMM_EXCEPTIONS_ENABLED
1119 }
1120
1121 typedef gboolean RType;
1122 return RType();
1123 }
1124
Actor_signal_touch_event_notify_callback(ClutterActor * self,ClutterTouchEvent * p0,void * data)1125 static gboolean Actor_signal_touch_event_notify_callback(ClutterActor* self, ClutterTouchEvent* p0, void* data)
1126 {
1127 using namespace Clutter;
1128 typedef sigc::slot< void,ClutterTouchEvent* > SlotType;
1129
1130 // Do not try to call a signal on a disassociated wrapper.
1131 if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1132 {
1133 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1134 try
1135 {
1136 #endif //GLIBMM_EXCEPTIONS_ENABLED
1137 if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1138 (*static_cast<SlotType*>(slot))(p0);
1139 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1140 }
1141 catch(...)
1142 {
1143 Glib::exception_handlers_invoke();
1144 }
1145 #endif //GLIBMM_EXCEPTIONS_ENABLED
1146 }
1147
1148 typedef gboolean RType;
1149 return RType();
1150 }
1151
1152 static const Glib::SignalProxyInfo Actor_signal_touch_event_info =
1153 {
1154 "touch-event",
1155 (GCallback) &Actor_signal_touch_event_callback,
1156 (GCallback) &Actor_signal_touch_event_notify_callback
1157 };
1158
1159
1160 static const Glib::SignalProxyInfo Actor_signal_transitions_completed_info =
1161 {
1162 "transitions-completed",
1163 (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
1164 (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
1165 };
1166
1167
Actor_signal_transition_stopped_callback(ClutterActor * self,const gchar * p0,gboolean p1,void * data)1168 static void Actor_signal_transition_stopped_callback(ClutterActor* self, const gchar* p0,gboolean p1,void* data)
1169 {
1170 using namespace Clutter;
1171 typedef sigc::slot< void,const Glib::ustring&,bool > SlotType;
1172
1173 // Do not try to call a signal on a disassociated wrapper.
1174 if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1175 {
1176 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1177 try
1178 {
1179 #endif //GLIBMM_EXCEPTIONS_ENABLED
1180 if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1181 (*static_cast<SlotType*>(slot))(Glib::convert_const_gchar_ptr_to_ustring(p0)
1182 , p1
1183 );
1184 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1185 }
1186 catch(...)
1187 {
1188 Glib::exception_handlers_invoke();
1189 }
1190 #endif //GLIBMM_EXCEPTIONS_ENABLED
1191 }
1192 }
1193
1194 static const Glib::SignalProxyInfo Actor_signal_transition_stopped_info =
1195 {
1196 "transition-stopped",
1197 (GCallback) &Actor_signal_transition_stopped_callback,
1198 (GCallback) &Actor_signal_transition_stopped_callback
1199 };
1200
1201
1202 } // anonymous namespace
1203
1204 // static
value_type()1205 GType Glib::Value<Clutter::ActorAlign>::value_type()
1206 {
1207 return clutter_actor_align_get_type();
1208 }
1209
1210 // static
value_type()1211 GType Glib::Value<Clutter::ActorFlags>::value_type()
1212 {
1213 return clutter_actor_flags_get_type();
1214 }
1215
1216 // static
value_type()1217 GType Glib::Value<Clutter::AllocationFlags>::value_type()
1218 {
1219 return clutter_allocation_flags_get_type();
1220 }
1221
1222 // static
value_type()1223 GType Glib::Value<Clutter::ContentRepeat>::value_type()
1224 {
1225 return clutter_content_repeat_get_type();
1226 }
1227
1228 // static
value_type()1229 GType Glib::Value<Clutter::ContentGravity>::value_type()
1230 {
1231 return clutter_content_gravity_get_type();
1232 }
1233
1234 // static
value_type()1235 GType Glib::Value<Clutter::OffscreenRedirect>::value_type()
1236 {
1237 return clutter_offscreen_redirect_get_type();
1238 }
1239
1240 // static
value_type()1241 GType Glib::Value<Clutter::Orientation>::value_type()
1242 {
1243 return clutter_orientation_get_type();
1244 }
1245
1246
1247 namespace Glib
1248 {
1249
wrap(ClutterActor * object,bool take_copy)1250 Glib::RefPtr<Clutter::Actor> wrap(ClutterActor* object, bool take_copy)
1251 {
1252 return Glib::RefPtr<Clutter::Actor>( dynamic_cast<Clutter::Actor*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
1253 //We use dynamic_cast<> in case of multiple inheritance.
1254 }
1255
1256 } /* namespace Glib */
1257
1258
1259 namespace Clutter
1260 {
1261
1262
1263 /* The *_Class implementation: */
1264
init()1265 const Glib::Class& Actor_Class::init()
1266 {
1267 if(!gtype_) // create the GType if necessary
1268 {
1269 // Glib::Class has to know the class init function to clone custom types.
1270 class_init_func_ = &Actor_Class::class_init_function;
1271
1272 // This is actually just optimized away, apparently with no harm.
1273 // Make sure that the parent type has been created.
1274 //CppClassParent::CppObjectType::get_type();
1275
1276 // Create the wrapper type, with the same class/instance size as the base type.
1277 register_derived_type(clutter_actor_get_type());
1278
1279 // Add derived versions of interfaces, if the C type implements any interfaces:
1280 Scriptable::add_interface(get_type());
1281 Animatable::add_interface(get_type());
1282
1283 }
1284
1285 return *this;
1286 }
1287
1288
class_init_function(void * g_class,void * class_data)1289 void Actor_Class::class_init_function(void* g_class, void* class_data)
1290 {
1291 BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
1292 CppClassParent::class_init_function(klass, class_data);
1293
1294 klass->show_all = &show_all_vfunc_callback;
1295 klass->hide_all = &hide_all_vfunc_callback;
1296 klass->map = &map_vfunc_callback;
1297 klass->unmap = &unmap_vfunc_callback;
1298 klass->paint = &paint_vfunc_callback;
1299 klass->get_preferred_width = &get_preferred_width_vfunc_callback;
1300 klass->get_preferred_height = &get_preferred_height_vfunc_callback;
1301 klass->allocate = &allocate_vfunc_callback;
1302 klass->pick = &pick_vfunc_callback;
1303 klass->get_paint_volume = &get_paint_volume_vfunc_callback;
1304 klass->has_overlaps = &has_overlaps_vfunc_callback;
1305 klass->paint_node = &paint_node_vfunc_callback;
1306
1307 klass->button_press_event = &button_press_event_callback;
1308 klass->button_release_event = &button_release_event_callback;
1309 klass->motion_event = &motion_event_callback;
1310 klass->leave_event = &leave_event_callback;
1311 klass->show = &show_callback;
1312 klass->hide = &hide_callback;
1313 klass->key_release_event = &key_release_event_callback;
1314 klass->enter_event = &enter_event_callback;
1315 klass->event = &event_callback;
1316 klass->key_focus_out = &key_focus_out_callback;
1317 klass->key_focus_in = &key_focus_in_callback;
1318 klass->parent_set = &parent_set_callback;
1319 klass->scroll_event = &scroll_event_callback;
1320 klass->key_press_event = &key_press_event_callback;
1321 klass->captured_event = &captured_event_callback;
1322 klass->queue_redraw = &queue_redraw_callback;
1323 klass->queue_relayout = &queue_relayout_callback;
1324 klass->realize = &realize_callback;
1325 klass->unrealize = &unrealize_callback;
1326 klass->pick = &pick_callback;
1327 klass->touch_event = &touch_event_callback;
1328 }
1329
show_all_vfunc_callback(ClutterActor * self)1330 void Actor_Class::show_all_vfunc_callback(ClutterActor* self)
1331 {
1332 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
1333 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
1334
1335 // Non-gtkmmproc-generated custom classes implicitly call the default
1336 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
1337 // generated classes can use this optimisation, which avoids the unnecessary
1338 // parameter conversions if there is no possibility of the virtual function
1339 // being overridden:
1340 if(obj_base && obj_base->is_derived_())
1341 {
1342 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
1343 if(obj) // This can be NULL during destruction.
1344 {
1345 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1346 try // Trap C++ exceptions which would normally be lost because this is a C callback.
1347 {
1348 #endif //GLIBMM_EXCEPTIONS_ENABLED
1349 // Call the virtual member method, which derived classes might override.
1350 obj->show_all_vfunc();
1351 return;
1352 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1353 }
1354 catch(...)
1355 {
1356 Glib::exception_handlers_invoke();
1357 }
1358 #endif //GLIBMM_EXCEPTIONS_ENABLED
1359 }
1360 }
1361
1362 BaseClassType *const base = static_cast<BaseClassType*>(
1363 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
1364 );
1365
1366 // Call the original underlying C function:
1367 if(base && base->show_all)
1368 {
1369 (*base->show_all)(self);
1370 }
1371
1372 }
hide_all_vfunc_callback(ClutterActor * self)1373 void Actor_Class::hide_all_vfunc_callback(ClutterActor* self)
1374 {
1375 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
1376 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
1377
1378 // Non-gtkmmproc-generated custom classes implicitly call the default
1379 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
1380 // generated classes can use this optimisation, which avoids the unnecessary
1381 // parameter conversions if there is no possibility of the virtual function
1382 // being overridden:
1383 if(obj_base && obj_base->is_derived_())
1384 {
1385 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
1386 if(obj) // This can be NULL during destruction.
1387 {
1388 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1389 try // Trap C++ exceptions which would normally be lost because this is a C callback.
1390 {
1391 #endif //GLIBMM_EXCEPTIONS_ENABLED
1392 // Call the virtual member method, which derived classes might override.
1393 obj->hide_all_vfunc();
1394 return;
1395 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1396 }
1397 catch(...)
1398 {
1399 Glib::exception_handlers_invoke();
1400 }
1401 #endif //GLIBMM_EXCEPTIONS_ENABLED
1402 }
1403 }
1404
1405 BaseClassType *const base = static_cast<BaseClassType*>(
1406 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
1407 );
1408
1409 // Call the original underlying C function:
1410 if(base && base->hide_all)
1411 {
1412 (*base->hide_all)(self);
1413 }
1414
1415 }
map_vfunc_callback(ClutterActor * self)1416 void Actor_Class::map_vfunc_callback(ClutterActor* self)
1417 {
1418 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
1419 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
1420
1421 // Non-gtkmmproc-generated custom classes implicitly call the default
1422 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
1423 // generated classes can use this optimisation, which avoids the unnecessary
1424 // parameter conversions if there is no possibility of the virtual function
1425 // being overridden:
1426 if(obj_base && obj_base->is_derived_())
1427 {
1428 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
1429 if(obj) // This can be NULL during destruction.
1430 {
1431 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1432 try // Trap C++ exceptions which would normally be lost because this is a C callback.
1433 {
1434 #endif //GLIBMM_EXCEPTIONS_ENABLED
1435 // Call the virtual member method, which derived classes might override.
1436 obj->map_vfunc();
1437 return;
1438 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1439 }
1440 catch(...)
1441 {
1442 Glib::exception_handlers_invoke();
1443 }
1444 #endif //GLIBMM_EXCEPTIONS_ENABLED
1445 }
1446 }
1447
1448 BaseClassType *const base = static_cast<BaseClassType*>(
1449 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
1450 );
1451
1452 // Call the original underlying C function:
1453 if(base && base->map)
1454 {
1455 (*base->map)(self);
1456 }
1457
1458 }
unmap_vfunc_callback(ClutterActor * self)1459 void Actor_Class::unmap_vfunc_callback(ClutterActor* self)
1460 {
1461 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
1462 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
1463
1464 // Non-gtkmmproc-generated custom classes implicitly call the default
1465 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
1466 // generated classes can use this optimisation, which avoids the unnecessary
1467 // parameter conversions if there is no possibility of the virtual function
1468 // being overridden:
1469 if(obj_base && obj_base->is_derived_())
1470 {
1471 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
1472 if(obj) // This can be NULL during destruction.
1473 {
1474 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1475 try // Trap C++ exceptions which would normally be lost because this is a C callback.
1476 {
1477 #endif //GLIBMM_EXCEPTIONS_ENABLED
1478 // Call the virtual member method, which derived classes might override.
1479 obj->unmap_vfunc();
1480 return;
1481 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1482 }
1483 catch(...)
1484 {
1485 Glib::exception_handlers_invoke();
1486 }
1487 #endif //GLIBMM_EXCEPTIONS_ENABLED
1488 }
1489 }
1490
1491 BaseClassType *const base = static_cast<BaseClassType*>(
1492 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
1493 );
1494
1495 // Call the original underlying C function:
1496 if(base && base->unmap)
1497 {
1498 (*base->unmap)(self);
1499 }
1500
1501 }
paint_vfunc_callback(ClutterActor * self)1502 void Actor_Class::paint_vfunc_callback(ClutterActor* self)
1503 {
1504 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
1505 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
1506
1507 // Non-gtkmmproc-generated custom classes implicitly call the default
1508 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
1509 // generated classes can use this optimisation, which avoids the unnecessary
1510 // parameter conversions if there is no possibility of the virtual function
1511 // being overridden:
1512 if(obj_base && obj_base->is_derived_())
1513 {
1514 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
1515 if(obj) // This can be NULL during destruction.
1516 {
1517 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1518 try // Trap C++ exceptions which would normally be lost because this is a C callback.
1519 {
1520 #endif //GLIBMM_EXCEPTIONS_ENABLED
1521 // Call the virtual member method, which derived classes might override.
1522 obj->paint_vfunc();
1523 return;
1524 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1525 }
1526 catch(...)
1527 {
1528 Glib::exception_handlers_invoke();
1529 }
1530 #endif //GLIBMM_EXCEPTIONS_ENABLED
1531 }
1532 }
1533
1534 BaseClassType *const base = static_cast<BaseClassType*>(
1535 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
1536 );
1537
1538 // Call the original underlying C function:
1539 if(base && base->paint)
1540 {
1541 (*base->paint)(self);
1542 }
1543
1544 }
get_preferred_width_vfunc_callback(ClutterActor * self,float for_height,float * min_width_p,float * natural_width_p)1545 void Actor_Class::get_preferred_width_vfunc_callback(ClutterActor* self, float for_height, float* min_width_p, float* natural_width_p)
1546 {
1547 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
1548 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
1549
1550 // Non-gtkmmproc-generated custom classes implicitly call the default
1551 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
1552 // generated classes can use this optimisation, which avoids the unnecessary
1553 // parameter conversions if there is no possibility of the virtual function
1554 // being overridden:
1555 if(obj_base && obj_base->is_derived_())
1556 {
1557 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
1558 if(obj) // This can be NULL during destruction.
1559 {
1560 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1561 try // Trap C++ exceptions which would normally be lost because this is a C callback.
1562 {
1563 #endif //GLIBMM_EXCEPTIONS_ENABLED
1564 // Call the virtual member method, which derived classes might override.
1565 obj->get_preferred_width_vfunc(for_height, *(min_width_p)
1566 , *(natural_width_p)
1567 );
1568 return;
1569 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1570 }
1571 catch(...)
1572 {
1573 Glib::exception_handlers_invoke();
1574 }
1575 #endif //GLIBMM_EXCEPTIONS_ENABLED
1576 }
1577 }
1578
1579 BaseClassType *const base = static_cast<BaseClassType*>(
1580 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
1581 );
1582
1583 // Call the original underlying C function:
1584 if(base && base->get_preferred_width)
1585 {
1586 (*base->get_preferred_width)(self, for_height, min_width_p, natural_width_p);
1587 }
1588
1589 }
get_preferred_height_vfunc_callback(ClutterActor * self,float for_width,float * min_height_p,float * natural_height_p)1590 void Actor_Class::get_preferred_height_vfunc_callback(ClutterActor* self, float for_width, float* min_height_p, float* natural_height_p)
1591 {
1592 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
1593 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
1594
1595 // Non-gtkmmproc-generated custom classes implicitly call the default
1596 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
1597 // generated classes can use this optimisation, which avoids the unnecessary
1598 // parameter conversions if there is no possibility of the virtual function
1599 // being overridden:
1600 if(obj_base && obj_base->is_derived_())
1601 {
1602 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
1603 if(obj) // This can be NULL during destruction.
1604 {
1605 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1606 try // Trap C++ exceptions which would normally be lost because this is a C callback.
1607 {
1608 #endif //GLIBMM_EXCEPTIONS_ENABLED
1609 // Call the virtual member method, which derived classes might override.
1610 obj->get_preferred_height_vfunc(for_width, *(min_height_p)
1611 , *(natural_height_p)
1612 );
1613 return;
1614 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1615 }
1616 catch(...)
1617 {
1618 Glib::exception_handlers_invoke();
1619 }
1620 #endif //GLIBMM_EXCEPTIONS_ENABLED
1621 }
1622 }
1623
1624 BaseClassType *const base = static_cast<BaseClassType*>(
1625 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
1626 );
1627
1628 // Call the original underlying C function:
1629 if(base && base->get_preferred_height)
1630 {
1631 (*base->get_preferred_height)(self, for_width, min_height_p, natural_height_p);
1632 }
1633
1634 }
allocate_vfunc_callback(ClutterActor * self,const ClutterActorBox * box,ClutterAllocationFlags absolute_origin_changed)1635 void Actor_Class::allocate_vfunc_callback(ClutterActor* self, const ClutterActorBox* box, ClutterAllocationFlags absolute_origin_changed)
1636 {
1637 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
1638 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
1639
1640 // Non-gtkmmproc-generated custom classes implicitly call the default
1641 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
1642 // generated classes can use this optimisation, which avoids the unnecessary
1643 // parameter conversions if there is no possibility of the virtual function
1644 // being overridden:
1645 if(obj_base && obj_base->is_derived_())
1646 {
1647 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
1648 if(obj) // This can be NULL during destruction.
1649 {
1650 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1651 try // Trap C++ exceptions which would normally be lost because this is a C callback.
1652 {
1653 #endif //GLIBMM_EXCEPTIONS_ENABLED
1654 // Call the virtual member method, which derived classes might override.
1655 obj->allocate_vfunc(Glib::wrap(box)
1656 , ((AllocationFlags)(absolute_origin_changed))
1657 );
1658 return;
1659 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1660 }
1661 catch(...)
1662 {
1663 Glib::exception_handlers_invoke();
1664 }
1665 #endif //GLIBMM_EXCEPTIONS_ENABLED
1666 }
1667 }
1668
1669 BaseClassType *const base = static_cast<BaseClassType*>(
1670 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
1671 );
1672
1673 // Call the original underlying C function:
1674 if(base && base->allocate)
1675 {
1676 (*base->allocate)(self, box, absolute_origin_changed);
1677 }
1678
1679 }
pick_vfunc_callback(ClutterActor * self,const ClutterColor * color)1680 void Actor_Class::pick_vfunc_callback(ClutterActor* self, const ClutterColor* color)
1681 {
1682 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
1683 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
1684
1685 // Non-gtkmmproc-generated custom classes implicitly call the default
1686 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
1687 // generated classes can use this optimisation, which avoids the unnecessary
1688 // parameter conversions if there is no possibility of the virtual function
1689 // being overridden:
1690 if(obj_base && obj_base->is_derived_())
1691 {
1692 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
1693 if(obj) // This can be NULL during destruction.
1694 {
1695 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1696 try // Trap C++ exceptions which would normally be lost because this is a C callback.
1697 {
1698 #endif //GLIBMM_EXCEPTIONS_ENABLED
1699 // Call the virtual member method, which derived classes might override.
1700 obj->pick_vfunc(Color(const_cast<ClutterColor*>(color), true)
1701 );
1702 return;
1703 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1704 }
1705 catch(...)
1706 {
1707 Glib::exception_handlers_invoke();
1708 }
1709 #endif //GLIBMM_EXCEPTIONS_ENABLED
1710 }
1711 }
1712
1713 BaseClassType *const base = static_cast<BaseClassType*>(
1714 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
1715 );
1716
1717 // Call the original underlying C function:
1718 if(base && base->pick)
1719 {
1720 (*base->pick)(self, color);
1721 }
1722
1723 }
get_paint_volume_vfunc_callback(ClutterActor * self,ClutterPaintVolume * volume)1724 gboolean Actor_Class::get_paint_volume_vfunc_callback(ClutterActor* self, ClutterPaintVolume* volume)
1725 {
1726 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
1727 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
1728
1729 // Non-gtkmmproc-generated custom classes implicitly call the default
1730 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
1731 // generated classes can use this optimisation, which avoids the unnecessary
1732 // parameter conversions if there is no possibility of the virtual function
1733 // being overridden:
1734 if(obj_base && obj_base->is_derived_())
1735 {
1736 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
1737 if(obj) // This can be NULL during destruction.
1738 {
1739 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1740 try // Trap C++ exceptions which would normally be lost because this is a C callback.
1741 {
1742 #endif //GLIBMM_EXCEPTIONS_ENABLED
1743 // Call the virtual member method, which derived classes might override.
1744 return static_cast<int>(obj->get_paint_volume_vfunc(volume));
1745 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1746 }
1747 catch(...)
1748 {
1749 Glib::exception_handlers_invoke();
1750 }
1751 #endif //GLIBMM_EXCEPTIONS_ENABLED
1752 }
1753 }
1754
1755 BaseClassType *const base = static_cast<BaseClassType*>(
1756 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
1757 );
1758
1759 // Call the original underlying C function:
1760 if(base && base->get_paint_volume)
1761 {
1762 gboolean retval = (*base->get_paint_volume)(self, volume);
1763 return retval;
1764 }
1765
1766 typedef gboolean RType;
1767 return RType();
1768 }
has_overlaps_vfunc_callback(ClutterActor * self)1769 gboolean Actor_Class::has_overlaps_vfunc_callback(ClutterActor* self)
1770 {
1771 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
1772 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
1773
1774 // Non-gtkmmproc-generated custom classes implicitly call the default
1775 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
1776 // generated classes can use this optimisation, which avoids the unnecessary
1777 // parameter conversions if there is no possibility of the virtual function
1778 // being overridden:
1779 if(obj_base && obj_base->is_derived_())
1780 {
1781 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
1782 if(obj) // This can be NULL during destruction.
1783 {
1784 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1785 try // Trap C++ exceptions which would normally be lost because this is a C callback.
1786 {
1787 #endif //GLIBMM_EXCEPTIONS_ENABLED
1788 // Call the virtual member method, which derived classes might override.
1789 return static_cast<int>(obj->has_overlaps_vfunc());
1790 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1791 }
1792 catch(...)
1793 {
1794 Glib::exception_handlers_invoke();
1795 }
1796 #endif //GLIBMM_EXCEPTIONS_ENABLED
1797 }
1798 }
1799
1800 BaseClassType *const base = static_cast<BaseClassType*>(
1801 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
1802 );
1803
1804 // Call the original underlying C function:
1805 if(base && base->has_overlaps)
1806 {
1807 gboolean retval = (*base->has_overlaps)(self);
1808 return retval;
1809 }
1810
1811 typedef gboolean RType;
1812 return RType();
1813 }
paint_node_vfunc_callback(ClutterActor * self,ClutterPaintNode * root)1814 void Actor_Class::paint_node_vfunc_callback(ClutterActor* self, ClutterPaintNode* root)
1815 {
1816 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
1817 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
1818
1819 // Non-gtkmmproc-generated custom classes implicitly call the default
1820 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
1821 // generated classes can use this optimisation, which avoids the unnecessary
1822 // parameter conversions if there is no possibility of the virtual function
1823 // being overridden:
1824 if(obj_base && obj_base->is_derived_())
1825 {
1826 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
1827 if(obj) // This can be NULL during destruction.
1828 {
1829 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1830 try // Trap C++ exceptions which would normally be lost because this is a C callback.
1831 {
1832 #endif //GLIBMM_EXCEPTIONS_ENABLED
1833 // Call the virtual member method, which derived classes might override.
1834 obj->paint_node_vfunc(root);
1835 return;
1836 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1837 }
1838 catch(...)
1839 {
1840 Glib::exception_handlers_invoke();
1841 }
1842 #endif //GLIBMM_EXCEPTIONS_ENABLED
1843 }
1844 }
1845
1846 BaseClassType *const base = static_cast<BaseClassType*>(
1847 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
1848 );
1849
1850 // Call the original underlying C function:
1851 if(base && base->paint_node)
1852 {
1853 (*base->paint_node)(self, root);
1854 }
1855
1856 }
1857
button_press_event_callback(ClutterActor * self,ClutterButtonEvent * p0)1858 gboolean Actor_Class::button_press_event_callback(ClutterActor* self, ClutterButtonEvent* p0)
1859 {
1860 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
1861 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
1862
1863 // Non-gtkmmproc-generated custom classes implicitly call the default
1864 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
1865 // generated classes can use this optimisation, which avoids the unnecessary
1866 // parameter conversions if there is no possibility of the virtual function
1867 // being overridden:
1868 if(obj_base && obj_base->is_derived_())
1869 {
1870 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
1871 if(obj) // This can be NULL during destruction.
1872 {
1873 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1874 try // Trap C++ exceptions which would normally be lost because this is a C callback.
1875 {
1876 #endif //GLIBMM_EXCEPTIONS_ENABLED
1877 // Call the virtual member method, which derived classes might override.
1878 return static_cast<int>(obj->on_button_press_event(p0
1879 ));
1880 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1881 }
1882 catch(...)
1883 {
1884 Glib::exception_handlers_invoke();
1885 }
1886 #endif //GLIBMM_EXCEPTIONS_ENABLED
1887 }
1888 }
1889
1890 BaseClassType *const base = static_cast<BaseClassType*>(
1891 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
1892 );
1893
1894 // Call the original underlying C function:
1895 if(base && base->button_press_event)
1896 return (*base->button_press_event)(self, p0);
1897
1898 typedef gboolean RType;
1899 return RType();
1900 }
button_release_event_callback(ClutterActor * self,ClutterButtonEvent * p0)1901 gboolean Actor_Class::button_release_event_callback(ClutterActor* self, ClutterButtonEvent* p0)
1902 {
1903 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
1904 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
1905
1906 // Non-gtkmmproc-generated custom classes implicitly call the default
1907 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
1908 // generated classes can use this optimisation, which avoids the unnecessary
1909 // parameter conversions if there is no possibility of the virtual function
1910 // being overridden:
1911 if(obj_base && obj_base->is_derived_())
1912 {
1913 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
1914 if(obj) // This can be NULL during destruction.
1915 {
1916 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1917 try // Trap C++ exceptions which would normally be lost because this is a C callback.
1918 {
1919 #endif //GLIBMM_EXCEPTIONS_ENABLED
1920 // Call the virtual member method, which derived classes might override.
1921 return static_cast<int>(obj->on_button_release_event(p0
1922 ));
1923 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1924 }
1925 catch(...)
1926 {
1927 Glib::exception_handlers_invoke();
1928 }
1929 #endif //GLIBMM_EXCEPTIONS_ENABLED
1930 }
1931 }
1932
1933 BaseClassType *const base = static_cast<BaseClassType*>(
1934 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
1935 );
1936
1937 // Call the original underlying C function:
1938 if(base && base->button_release_event)
1939 return (*base->button_release_event)(self, p0);
1940
1941 typedef gboolean RType;
1942 return RType();
1943 }
motion_event_callback(ClutterActor * self,ClutterMotionEvent * p0)1944 gboolean Actor_Class::motion_event_callback(ClutterActor* self, ClutterMotionEvent* p0)
1945 {
1946 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
1947 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
1948
1949 // Non-gtkmmproc-generated custom classes implicitly call the default
1950 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
1951 // generated classes can use this optimisation, which avoids the unnecessary
1952 // parameter conversions if there is no possibility of the virtual function
1953 // being overridden:
1954 if(obj_base && obj_base->is_derived_())
1955 {
1956 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
1957 if(obj) // This can be NULL during destruction.
1958 {
1959 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1960 try // Trap C++ exceptions which would normally be lost because this is a C callback.
1961 {
1962 #endif //GLIBMM_EXCEPTIONS_ENABLED
1963 // Call the virtual member method, which derived classes might override.
1964 return static_cast<int>(obj->on_motion_event(p0
1965 ));
1966 #ifdef GLIBMM_EXCEPTIONS_ENABLED
1967 }
1968 catch(...)
1969 {
1970 Glib::exception_handlers_invoke();
1971 }
1972 #endif //GLIBMM_EXCEPTIONS_ENABLED
1973 }
1974 }
1975
1976 BaseClassType *const base = static_cast<BaseClassType*>(
1977 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
1978 );
1979
1980 // Call the original underlying C function:
1981 if(base && base->motion_event)
1982 return (*base->motion_event)(self, p0);
1983
1984 typedef gboolean RType;
1985 return RType();
1986 }
leave_event_callback(ClutterActor * self,ClutterCrossingEvent * p0)1987 gboolean Actor_Class::leave_event_callback(ClutterActor* self, ClutterCrossingEvent* p0)
1988 {
1989 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
1990 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
1991
1992 // Non-gtkmmproc-generated custom classes implicitly call the default
1993 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
1994 // generated classes can use this optimisation, which avoids the unnecessary
1995 // parameter conversions if there is no possibility of the virtual function
1996 // being overridden:
1997 if(obj_base && obj_base->is_derived_())
1998 {
1999 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
2000 if(obj) // This can be NULL during destruction.
2001 {
2002 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2003 try // Trap C++ exceptions which would normally be lost because this is a C callback.
2004 {
2005 #endif //GLIBMM_EXCEPTIONS_ENABLED
2006 // Call the virtual member method, which derived classes might override.
2007 return static_cast<int>(obj->on_leave_event(p0
2008 ));
2009 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2010 }
2011 catch(...)
2012 {
2013 Glib::exception_handlers_invoke();
2014 }
2015 #endif //GLIBMM_EXCEPTIONS_ENABLED
2016 }
2017 }
2018
2019 BaseClassType *const base = static_cast<BaseClassType*>(
2020 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
2021 );
2022
2023 // Call the original underlying C function:
2024 if(base && base->leave_event)
2025 return (*base->leave_event)(self, p0);
2026
2027 typedef gboolean RType;
2028 return RType();
2029 }
show_callback(ClutterActor * self)2030 void Actor_Class::show_callback(ClutterActor* self)
2031 {
2032 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
2033 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
2034
2035 // Non-gtkmmproc-generated custom classes implicitly call the default
2036 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
2037 // generated classes can use this optimisation, which avoids the unnecessary
2038 // parameter conversions if there is no possibility of the virtual function
2039 // being overridden:
2040 if(obj_base && obj_base->is_derived_())
2041 {
2042 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
2043 if(obj) // This can be NULL during destruction.
2044 {
2045 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2046 try // Trap C++ exceptions which would normally be lost because this is a C callback.
2047 {
2048 #endif //GLIBMM_EXCEPTIONS_ENABLED
2049 // Call the virtual member method, which derived classes might override.
2050 obj->on_show();
2051 return;
2052 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2053 }
2054 catch(...)
2055 {
2056 Glib::exception_handlers_invoke();
2057 }
2058 #endif //GLIBMM_EXCEPTIONS_ENABLED
2059 }
2060 }
2061
2062 BaseClassType *const base = static_cast<BaseClassType*>(
2063 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
2064 );
2065
2066 // Call the original underlying C function:
2067 if(base && base->show)
2068 (*base->show)(self);
2069 }
hide_callback(ClutterActor * self)2070 void Actor_Class::hide_callback(ClutterActor* self)
2071 {
2072 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
2073 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
2074
2075 // Non-gtkmmproc-generated custom classes implicitly call the default
2076 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
2077 // generated classes can use this optimisation, which avoids the unnecessary
2078 // parameter conversions if there is no possibility of the virtual function
2079 // being overridden:
2080 if(obj_base && obj_base->is_derived_())
2081 {
2082 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
2083 if(obj) // This can be NULL during destruction.
2084 {
2085 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2086 try // Trap C++ exceptions which would normally be lost because this is a C callback.
2087 {
2088 #endif //GLIBMM_EXCEPTIONS_ENABLED
2089 // Call the virtual member method, which derived classes might override.
2090 obj->on_hide();
2091 return;
2092 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2093 }
2094 catch(...)
2095 {
2096 Glib::exception_handlers_invoke();
2097 }
2098 #endif //GLIBMM_EXCEPTIONS_ENABLED
2099 }
2100 }
2101
2102 BaseClassType *const base = static_cast<BaseClassType*>(
2103 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
2104 );
2105
2106 // Call the original underlying C function:
2107 if(base && base->hide)
2108 (*base->hide)(self);
2109 }
key_release_event_callback(ClutterActor * self,ClutterKeyEvent * p0)2110 gboolean Actor_Class::key_release_event_callback(ClutterActor* self, ClutterKeyEvent* p0)
2111 {
2112 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
2113 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
2114
2115 // Non-gtkmmproc-generated custom classes implicitly call the default
2116 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
2117 // generated classes can use this optimisation, which avoids the unnecessary
2118 // parameter conversions if there is no possibility of the virtual function
2119 // being overridden:
2120 if(obj_base && obj_base->is_derived_())
2121 {
2122 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
2123 if(obj) // This can be NULL during destruction.
2124 {
2125 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2126 try // Trap C++ exceptions which would normally be lost because this is a C callback.
2127 {
2128 #endif //GLIBMM_EXCEPTIONS_ENABLED
2129 // Call the virtual member method, which derived classes might override.
2130 return static_cast<int>(obj->on_key_release_event(p0
2131 ));
2132 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2133 }
2134 catch(...)
2135 {
2136 Glib::exception_handlers_invoke();
2137 }
2138 #endif //GLIBMM_EXCEPTIONS_ENABLED
2139 }
2140 }
2141
2142 BaseClassType *const base = static_cast<BaseClassType*>(
2143 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
2144 );
2145
2146 // Call the original underlying C function:
2147 if(base && base->key_release_event)
2148 return (*base->key_release_event)(self, p0);
2149
2150 typedef gboolean RType;
2151 return RType();
2152 }
enter_event_callback(ClutterActor * self,ClutterCrossingEvent * p0)2153 gboolean Actor_Class::enter_event_callback(ClutterActor* self, ClutterCrossingEvent* p0)
2154 {
2155 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
2156 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
2157
2158 // Non-gtkmmproc-generated custom classes implicitly call the default
2159 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
2160 // generated classes can use this optimisation, which avoids the unnecessary
2161 // parameter conversions if there is no possibility of the virtual function
2162 // being overridden:
2163 if(obj_base && obj_base->is_derived_())
2164 {
2165 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
2166 if(obj) // This can be NULL during destruction.
2167 {
2168 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2169 try // Trap C++ exceptions which would normally be lost because this is a C callback.
2170 {
2171 #endif //GLIBMM_EXCEPTIONS_ENABLED
2172 // Call the virtual member method, which derived classes might override.
2173 return static_cast<int>(obj->on_enter_event(p0
2174 ));
2175 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2176 }
2177 catch(...)
2178 {
2179 Glib::exception_handlers_invoke();
2180 }
2181 #endif //GLIBMM_EXCEPTIONS_ENABLED
2182 }
2183 }
2184
2185 BaseClassType *const base = static_cast<BaseClassType*>(
2186 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
2187 );
2188
2189 // Call the original underlying C function:
2190 if(base && base->enter_event)
2191 return (*base->enter_event)(self, p0);
2192
2193 typedef gboolean RType;
2194 return RType();
2195 }
event_callback(ClutterActor * self,ClutterEvent * p0)2196 gboolean Actor_Class::event_callback(ClutterActor* self, ClutterEvent* p0)
2197 {
2198 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
2199 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
2200
2201 // Non-gtkmmproc-generated custom classes implicitly call the default
2202 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
2203 // generated classes can use this optimisation, which avoids the unnecessary
2204 // parameter conversions if there is no possibility of the virtual function
2205 // being overridden:
2206 if(obj_base && obj_base->is_derived_())
2207 {
2208 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
2209 if(obj) // This can be NULL during destruction.
2210 {
2211 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2212 try // Trap C++ exceptions which would normally be lost because this is a C callback.
2213 {
2214 #endif //GLIBMM_EXCEPTIONS_ENABLED
2215 // Call the virtual member method, which derived classes might override.
2216 return static_cast<int>(obj->on_event(p0
2217 ));
2218 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2219 }
2220 catch(...)
2221 {
2222 Glib::exception_handlers_invoke();
2223 }
2224 #endif //GLIBMM_EXCEPTIONS_ENABLED
2225 }
2226 }
2227
2228 BaseClassType *const base = static_cast<BaseClassType*>(
2229 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
2230 );
2231
2232 // Call the original underlying C function:
2233 if(base && base->event)
2234 return (*base->event)(self, p0);
2235
2236 typedef gboolean RType;
2237 return RType();
2238 }
key_focus_out_callback(ClutterActor * self)2239 void Actor_Class::key_focus_out_callback(ClutterActor* self)
2240 {
2241 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
2242 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
2243
2244 // Non-gtkmmproc-generated custom classes implicitly call the default
2245 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
2246 // generated classes can use this optimisation, which avoids the unnecessary
2247 // parameter conversions if there is no possibility of the virtual function
2248 // being overridden:
2249 if(obj_base && obj_base->is_derived_())
2250 {
2251 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
2252 if(obj) // This can be NULL during destruction.
2253 {
2254 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2255 try // Trap C++ exceptions which would normally be lost because this is a C callback.
2256 {
2257 #endif //GLIBMM_EXCEPTIONS_ENABLED
2258 // Call the virtual member method, which derived classes might override.
2259 obj->on_key_focus_out();
2260 return;
2261 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2262 }
2263 catch(...)
2264 {
2265 Glib::exception_handlers_invoke();
2266 }
2267 #endif //GLIBMM_EXCEPTIONS_ENABLED
2268 }
2269 }
2270
2271 BaseClassType *const base = static_cast<BaseClassType*>(
2272 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
2273 );
2274
2275 // Call the original underlying C function:
2276 if(base && base->key_focus_out)
2277 (*base->key_focus_out)(self);
2278 }
key_focus_in_callback(ClutterActor * self)2279 void Actor_Class::key_focus_in_callback(ClutterActor* self)
2280 {
2281 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
2282 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
2283
2284 // Non-gtkmmproc-generated custom classes implicitly call the default
2285 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
2286 // generated classes can use this optimisation, which avoids the unnecessary
2287 // parameter conversions if there is no possibility of the virtual function
2288 // being overridden:
2289 if(obj_base && obj_base->is_derived_())
2290 {
2291 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
2292 if(obj) // This can be NULL during destruction.
2293 {
2294 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2295 try // Trap C++ exceptions which would normally be lost because this is a C callback.
2296 {
2297 #endif //GLIBMM_EXCEPTIONS_ENABLED
2298 // Call the virtual member method, which derived classes might override.
2299 obj->on_key_focus_in();
2300 return;
2301 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2302 }
2303 catch(...)
2304 {
2305 Glib::exception_handlers_invoke();
2306 }
2307 #endif //GLIBMM_EXCEPTIONS_ENABLED
2308 }
2309 }
2310
2311 BaseClassType *const base = static_cast<BaseClassType*>(
2312 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
2313 );
2314
2315 // Call the original underlying C function:
2316 if(base && base->key_focus_in)
2317 (*base->key_focus_in)(self);
2318 }
parent_set_callback(ClutterActor * self,ClutterActor * p0)2319 void Actor_Class::parent_set_callback(ClutterActor* self, ClutterActor* p0)
2320 {
2321 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
2322 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
2323
2324 // Non-gtkmmproc-generated custom classes implicitly call the default
2325 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
2326 // generated classes can use this optimisation, which avoids the unnecessary
2327 // parameter conversions if there is no possibility of the virtual function
2328 // being overridden:
2329 if(obj_base && obj_base->is_derived_())
2330 {
2331 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
2332 if(obj) // This can be NULL during destruction.
2333 {
2334 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2335 try // Trap C++ exceptions which would normally be lost because this is a C callback.
2336 {
2337 #endif //GLIBMM_EXCEPTIONS_ENABLED
2338 // Call the virtual member method, which derived classes might override.
2339 obj->on_parent_set(Glib::wrap((p0),true)
2340 );
2341 return;
2342 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2343 }
2344 catch(...)
2345 {
2346 Glib::exception_handlers_invoke();
2347 }
2348 #endif //GLIBMM_EXCEPTIONS_ENABLED
2349 }
2350 }
2351
2352 BaseClassType *const base = static_cast<BaseClassType*>(
2353 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
2354 );
2355
2356 // Call the original underlying C function:
2357 if(base && base->parent_set)
2358 (*base->parent_set)(self, p0);
2359 }
scroll_event_callback(ClutterActor * self,ClutterScrollEvent * p0)2360 gboolean Actor_Class::scroll_event_callback(ClutterActor* self, ClutterScrollEvent* p0)
2361 {
2362 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
2363 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
2364
2365 // Non-gtkmmproc-generated custom classes implicitly call the default
2366 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
2367 // generated classes can use this optimisation, which avoids the unnecessary
2368 // parameter conversions if there is no possibility of the virtual function
2369 // being overridden:
2370 if(obj_base && obj_base->is_derived_())
2371 {
2372 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
2373 if(obj) // This can be NULL during destruction.
2374 {
2375 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2376 try // Trap C++ exceptions which would normally be lost because this is a C callback.
2377 {
2378 #endif //GLIBMM_EXCEPTIONS_ENABLED
2379 // Call the virtual member method, which derived classes might override.
2380 return static_cast<int>(obj->on_scroll_event(p0
2381 ));
2382 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2383 }
2384 catch(...)
2385 {
2386 Glib::exception_handlers_invoke();
2387 }
2388 #endif //GLIBMM_EXCEPTIONS_ENABLED
2389 }
2390 }
2391
2392 BaseClassType *const base = static_cast<BaseClassType*>(
2393 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
2394 );
2395
2396 // Call the original underlying C function:
2397 if(base && base->scroll_event)
2398 return (*base->scroll_event)(self, p0);
2399
2400 typedef gboolean RType;
2401 return RType();
2402 }
key_press_event_callback(ClutterActor * self,ClutterKeyEvent * p0)2403 gboolean Actor_Class::key_press_event_callback(ClutterActor* self, ClutterKeyEvent* p0)
2404 {
2405 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
2406 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
2407
2408 // Non-gtkmmproc-generated custom classes implicitly call the default
2409 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
2410 // generated classes can use this optimisation, which avoids the unnecessary
2411 // parameter conversions if there is no possibility of the virtual function
2412 // being overridden:
2413 if(obj_base && obj_base->is_derived_())
2414 {
2415 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
2416 if(obj) // This can be NULL during destruction.
2417 {
2418 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2419 try // Trap C++ exceptions which would normally be lost because this is a C callback.
2420 {
2421 #endif //GLIBMM_EXCEPTIONS_ENABLED
2422 // Call the virtual member method, which derived classes might override.
2423 return static_cast<int>(obj->on_key_press_event(p0
2424 ));
2425 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2426 }
2427 catch(...)
2428 {
2429 Glib::exception_handlers_invoke();
2430 }
2431 #endif //GLIBMM_EXCEPTIONS_ENABLED
2432 }
2433 }
2434
2435 BaseClassType *const base = static_cast<BaseClassType*>(
2436 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
2437 );
2438
2439 // Call the original underlying C function:
2440 if(base && base->key_press_event)
2441 return (*base->key_press_event)(self, p0);
2442
2443 typedef gboolean RType;
2444 return RType();
2445 }
captured_event_callback(ClutterActor * self,ClutterEvent * p0)2446 gboolean Actor_Class::captured_event_callback(ClutterActor* self, ClutterEvent* p0)
2447 {
2448 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
2449 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
2450
2451 // Non-gtkmmproc-generated custom classes implicitly call the default
2452 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
2453 // generated classes can use this optimisation, which avoids the unnecessary
2454 // parameter conversions if there is no possibility of the virtual function
2455 // being overridden:
2456 if(obj_base && obj_base->is_derived_())
2457 {
2458 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
2459 if(obj) // This can be NULL during destruction.
2460 {
2461 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2462 try // Trap C++ exceptions which would normally be lost because this is a C callback.
2463 {
2464 #endif //GLIBMM_EXCEPTIONS_ENABLED
2465 // Call the virtual member method, which derived classes might override.
2466 return static_cast<int>(obj->on_captured_event(p0
2467 ));
2468 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2469 }
2470 catch(...)
2471 {
2472 Glib::exception_handlers_invoke();
2473 }
2474 #endif //GLIBMM_EXCEPTIONS_ENABLED
2475 }
2476 }
2477
2478 BaseClassType *const base = static_cast<BaseClassType*>(
2479 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
2480 );
2481
2482 // Call the original underlying C function:
2483 if(base && base->captured_event)
2484 return (*base->captured_event)(self, p0);
2485
2486 typedef gboolean RType;
2487 return RType();
2488 }
queue_redraw_callback(ClutterActor * self,ClutterActor * p0)2489 void Actor_Class::queue_redraw_callback(ClutterActor* self, ClutterActor* p0)
2490 {
2491 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
2492 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
2493
2494 // Non-gtkmmproc-generated custom classes implicitly call the default
2495 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
2496 // generated classes can use this optimisation, which avoids the unnecessary
2497 // parameter conversions if there is no possibility of the virtual function
2498 // being overridden:
2499 if(obj_base && obj_base->is_derived_())
2500 {
2501 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
2502 if(obj) // This can be NULL during destruction.
2503 {
2504 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2505 try // Trap C++ exceptions which would normally be lost because this is a C callback.
2506 {
2507 #endif //GLIBMM_EXCEPTIONS_ENABLED
2508 // Call the virtual member method, which derived classes might override.
2509 obj->on_queue_redaw(Glib::wrap((p0),true)
2510 );
2511 return;
2512 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2513 }
2514 catch(...)
2515 {
2516 Glib::exception_handlers_invoke();
2517 }
2518 #endif //GLIBMM_EXCEPTIONS_ENABLED
2519 }
2520 }
2521
2522 BaseClassType *const base = static_cast<BaseClassType*>(
2523 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
2524 );
2525
2526 // Call the original underlying C function:
2527 if(base && base->queue_redraw)
2528 (*base->queue_redraw)(self, p0);
2529 }
queue_relayout_callback(ClutterActor * self)2530 void Actor_Class::queue_relayout_callback(ClutterActor* self)
2531 {
2532 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
2533 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
2534
2535 // Non-gtkmmproc-generated custom classes implicitly call the default
2536 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
2537 // generated classes can use this optimisation, which avoids the unnecessary
2538 // parameter conversions if there is no possibility of the virtual function
2539 // being overridden:
2540 if(obj_base && obj_base->is_derived_())
2541 {
2542 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
2543 if(obj) // This can be NULL during destruction.
2544 {
2545 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2546 try // Trap C++ exceptions which would normally be lost because this is a C callback.
2547 {
2548 #endif //GLIBMM_EXCEPTIONS_ENABLED
2549 // Call the virtual member method, which derived classes might override.
2550 obj->on_queue_relayout();
2551 return;
2552 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2553 }
2554 catch(...)
2555 {
2556 Glib::exception_handlers_invoke();
2557 }
2558 #endif //GLIBMM_EXCEPTIONS_ENABLED
2559 }
2560 }
2561
2562 BaseClassType *const base = static_cast<BaseClassType*>(
2563 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
2564 );
2565
2566 // Call the original underlying C function:
2567 if(base && base->queue_relayout)
2568 (*base->queue_relayout)(self);
2569 }
realize_callback(ClutterActor * self)2570 void Actor_Class::realize_callback(ClutterActor* self)
2571 {
2572 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
2573 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
2574
2575 // Non-gtkmmproc-generated custom classes implicitly call the default
2576 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
2577 // generated classes can use this optimisation, which avoids the unnecessary
2578 // parameter conversions if there is no possibility of the virtual function
2579 // being overridden:
2580 if(obj_base && obj_base->is_derived_())
2581 {
2582 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
2583 if(obj) // This can be NULL during destruction.
2584 {
2585 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2586 try // Trap C++ exceptions which would normally be lost because this is a C callback.
2587 {
2588 #endif //GLIBMM_EXCEPTIONS_ENABLED
2589 // Call the virtual member method, which derived classes might override.
2590 obj->on_realize();
2591 return;
2592 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2593 }
2594 catch(...)
2595 {
2596 Glib::exception_handlers_invoke();
2597 }
2598 #endif //GLIBMM_EXCEPTIONS_ENABLED
2599 }
2600 }
2601
2602 BaseClassType *const base = static_cast<BaseClassType*>(
2603 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
2604 );
2605
2606 // Call the original underlying C function:
2607 if(base && base->realize)
2608 (*base->realize)(self);
2609 }
unrealize_callback(ClutterActor * self)2610 void Actor_Class::unrealize_callback(ClutterActor* self)
2611 {
2612 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
2613 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
2614
2615 // Non-gtkmmproc-generated custom classes implicitly call the default
2616 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
2617 // generated classes can use this optimisation, which avoids the unnecessary
2618 // parameter conversions if there is no possibility of the virtual function
2619 // being overridden:
2620 if(obj_base && obj_base->is_derived_())
2621 {
2622 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
2623 if(obj) // This can be NULL during destruction.
2624 {
2625 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2626 try // Trap C++ exceptions which would normally be lost because this is a C callback.
2627 {
2628 #endif //GLIBMM_EXCEPTIONS_ENABLED
2629 // Call the virtual member method, which derived classes might override.
2630 obj->on_unrealize();
2631 return;
2632 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2633 }
2634 catch(...)
2635 {
2636 Glib::exception_handlers_invoke();
2637 }
2638 #endif //GLIBMM_EXCEPTIONS_ENABLED
2639 }
2640 }
2641
2642 BaseClassType *const base = static_cast<BaseClassType*>(
2643 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
2644 );
2645
2646 // Call the original underlying C function:
2647 if(base && base->unrealize)
2648 (*base->unrealize)(self);
2649 }
pick_callback(ClutterActor * self,const ClutterColor * color)2650 void Actor_Class::pick_callback(ClutterActor* self, const ClutterColor* color)
2651 {
2652 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
2653 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
2654
2655 // Non-gtkmmproc-generated custom classes implicitly call the default
2656 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
2657 // generated classes can use this optimisation, which avoids the unnecessary
2658 // parameter conversions if there is no possibility of the virtual function
2659 // being overridden:
2660 if(obj_base && obj_base->is_derived_())
2661 {
2662 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
2663 if(obj) // This can be NULL during destruction.
2664 {
2665 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2666 try // Trap C++ exceptions which would normally be lost because this is a C callback.
2667 {
2668 #endif //GLIBMM_EXCEPTIONS_ENABLED
2669 // Call the virtual member method, which derived classes might override.
2670 obj->on_pick(Color(const_cast<ClutterColor*>(color), true)
2671 );
2672 return;
2673 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2674 }
2675 catch(...)
2676 {
2677 Glib::exception_handlers_invoke();
2678 }
2679 #endif //GLIBMM_EXCEPTIONS_ENABLED
2680 }
2681 }
2682
2683 BaseClassType *const base = static_cast<BaseClassType*>(
2684 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
2685 );
2686
2687 // Call the original underlying C function:
2688 if(base && base->pick)
2689 (*base->pick)(self, color);
2690 }
touch_event_callback(ClutterActor * self,ClutterTouchEvent * p0)2691 gboolean Actor_Class::touch_event_callback(ClutterActor* self, ClutterTouchEvent* p0)
2692 {
2693 Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
2694 Glib::ObjectBase::_get_current_wrapper((GObject*)self));
2695
2696 // Non-gtkmmproc-generated custom classes implicitly call the default
2697 // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
2698 // generated classes can use this optimisation, which avoids the unnecessary
2699 // parameter conversions if there is no possibility of the virtual function
2700 // being overridden:
2701 if(obj_base && obj_base->is_derived_())
2702 {
2703 CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
2704 if(obj) // This can be NULL during destruction.
2705 {
2706 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2707 try // Trap C++ exceptions which would normally be lost because this is a C callback.
2708 {
2709 #endif //GLIBMM_EXCEPTIONS_ENABLED
2710 // Call the virtual member method, which derived classes might override.
2711 return static_cast<int>(obj->on_touch_event(p0));
2712 #ifdef GLIBMM_EXCEPTIONS_ENABLED
2713 }
2714 catch(...)
2715 {
2716 Glib::exception_handlers_invoke();
2717 }
2718 #endif //GLIBMM_EXCEPTIONS_ENABLED
2719 }
2720 }
2721
2722 BaseClassType *const base = static_cast<BaseClassType*>(
2723 g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
2724 );
2725
2726 // Call the original underlying C function:
2727 if(base && base->touch_event)
2728 return (*base->touch_event)(self, p0);
2729
2730 typedef gboolean RType;
2731 return RType();
2732 }
2733
2734
wrap_new(GObject * object)2735 Glib::ObjectBase* Actor_Class::wrap_new(GObject* object)
2736 {
2737 return new Actor((ClutterActor*)object);
2738 }
2739
2740
2741 /* The implementation: */
2742
gobj_copy()2743 ClutterActor* Actor::gobj_copy()
2744 {
2745 reference();
2746 return gobj();
2747 }
2748
Actor(const Glib::ConstructParams & construct_params)2749 Actor::Actor(const Glib::ConstructParams& construct_params)
2750 :
2751 Glib::Object(construct_params)
2752 {
2753 if(gobject_ && g_object_is_floating (gobject_))
2754 g_object_ref_sink(gobject_); //Stops it from being floating.
2755
2756 }
2757
Actor(ClutterActor * castitem)2758 Actor::Actor(ClutterActor* castitem)
2759 :
2760 Glib::Object((GObject*)(castitem))
2761 {}
2762
2763
~Actor()2764 Actor::~Actor()
2765 {}
2766
2767
2768 Actor::CppClassType Actor::actor_class_; // initialize static member
2769
get_type()2770 GType Actor::get_type()
2771 {
2772 return actor_class_.init().get_type();
2773 }
2774
2775
get_base_type()2776 GType Actor::get_base_type()
2777 {
2778 return clutter_actor_get_type();
2779 }
2780
2781
Actor()2782 Actor::Actor()
2783 :
2784 // Mark this class as non-derived to allow C++ vfuncs to be skipped.
2785 Glib::ObjectBase(0),
2786 Glib::Object(Glib::ConstructParams(actor_class_.init()))
2787 {
2788
2789 if(gobject_ && g_object_is_floating (gobject_))
2790 g_object_ref_sink(gobject_); //Stops it from being floating.
2791
2792 }
2793
create()2794 Glib::RefPtr<Actor> Actor::create()
2795 {
2796 return Glib::RefPtr<Actor>( new Actor() );
2797 }
2798
set_flags(ActorFlags flags)2799 void Actor::set_flags(ActorFlags flags)
2800 {
2801 clutter_actor_set_flags(gobj(), ((ClutterActorFlags)(flags)));
2802 }
2803
unset_flags(ActorFlags flags)2804 void Actor::unset_flags(ActorFlags flags)
2805 {
2806 clutter_actor_unset_flags(gobj(), ((ClutterActorFlags)(flags)));
2807 }
2808
get_flags() const2809 ActorFlags Actor::get_flags() const
2810 {
2811 return ((ActorFlags)(clutter_actor_get_flags(const_cast<ClutterActor*>(gobj()))));
2812 }
2813
show()2814 void Actor::show()
2815 {
2816 clutter_actor_show(gobj());
2817 }
2818
2819 #ifndef CLUTTERMM_DISABLE_DEPRECATED
2820
show_all()2821 void Actor::show_all()
2822 {
2823 clutter_actor_show_all(gobj());
2824 }
2825
2826 #endif // CLUTTERMM_DISABLE_DEPRECATED
2827
hide()2828 void Actor::hide()
2829 {
2830 clutter_actor_hide(gobj());
2831 }
2832
2833 #ifndef CLUTTERMM_DISABLE_DEPRECATED
2834
hide_all()2835 void Actor::hide_all()
2836 {
2837 clutter_actor_hide_all(gobj());
2838 }
2839
2840 #endif // CLUTTERMM_DISABLE_DEPRECATED
2841
realize()2842 void Actor::realize()
2843 {
2844 clutter_actor_realize(gobj());
2845 }
2846
unrealize()2847 void Actor::unrealize()
2848 {
2849 clutter_actor_unrealize(gobj());
2850 }
2851
map()2852 void Actor::map()
2853 {
2854 clutter_actor_map(gobj());
2855 }
2856
unmap()2857 void Actor::unmap()
2858 {
2859 clutter_actor_unmap(gobj());
2860 }
2861
paint()2862 void Actor::paint()
2863 {
2864 clutter_actor_paint(gobj());
2865 }
2866
continue_paint()2867 void Actor::continue_paint()
2868 {
2869 clutter_actor_continue_paint(gobj());
2870 }
2871
queue_redraw()2872 void Actor::queue_redraw()
2873 {
2874 clutter_actor_queue_redraw(gobj());
2875 }
2876
queue_relayout()2877 void Actor::queue_relayout()
2878 {
2879 clutter_actor_queue_relayout(gobj());
2880 }
2881
has_overlaps()2882 bool Actor::has_overlaps()
2883 {
2884 return clutter_actor_has_overlaps(gobj());
2885 }
2886
set_content(const Glib::RefPtr<Content> & content)2887 void Actor::set_content(const Glib::RefPtr<Content>& content)
2888 {
2889 clutter_actor_set_content(gobj(), Glib::unwrap(content));
2890 }
2891
get_content()2892 Glib::RefPtr<Content> Actor::get_content()
2893 {
2894 Glib::RefPtr<Content> retvalue = Glib::wrap(clutter_actor_get_content(gobj()));
2895 if(retvalue)
2896 retvalue->reference(); //The function does not do a ref for us.
2897 return retvalue;
2898 }
2899
get_content() const2900 Glib::RefPtr<const Content> Actor::get_content() const
2901 {
2902 return const_cast<Actor*>(this)->get_content();
2903 }
2904
set_content_gravity(ContentGravity gravity)2905 void Actor::set_content_gravity(ContentGravity gravity)
2906 {
2907 clutter_actor_set_content_gravity(gobj(), ((ClutterContentGravity)(gravity)));
2908 }
2909
get_content_gravity() const2910 ContentGravity Actor::get_content_gravity() const
2911 {
2912 return ((ContentGravity)(clutter_actor_get_content_gravity(const_cast<ClutterActor*>(gobj()))));
2913 }
2914
set_content_scaling_filters(ScalingFilter min_filter,ScalingFilter mag_filter)2915 void Actor::set_content_scaling_filters(ScalingFilter min_filter, ScalingFilter mag_filter)
2916 {
2917 clutter_actor_set_content_scaling_filters(gobj(), ((ClutterScalingFilter)(min_filter)), ((ClutterScalingFilter)(mag_filter)));
2918 }
2919
get_content_scaling_filters(ScalingFilter & min_filter,ScalingFilter & mag_filter)2920 void Actor::get_content_scaling_filters(ScalingFilter& min_filter, ScalingFilter& mag_filter)
2921 {
2922 clutter_actor_get_content_scaling_filters(gobj(), ((ClutterScalingFilter*)&(min_filter)), ((ClutterScalingFilter*)&(mag_filter)));
2923 }
2924
set_content_repeat(ContentRepeat repeat)2925 void Actor::set_content_repeat(ContentRepeat repeat)
2926 {
2927 clutter_actor_set_content_repeat(gobj(), ((ClutterContentRepeat)(repeat)));
2928 }
2929
get_content_repeat() const2930 ContentRepeat Actor::get_content_repeat() const
2931 {
2932 return ((ContentRepeat)(clutter_actor_get_content_repeat(const_cast<ClutterActor*>(gobj()))));
2933 }
2934
get_pango_context()2935 Glib::RefPtr<Pango::Context> Actor::get_pango_context()
2936 {
2937 Glib::RefPtr<Pango::Context> retvalue = Glib::wrap(clutter_actor_get_pango_context(gobj()));
2938 if(retvalue)
2939 retvalue->reference(); //The function does not do a ref for us.
2940 return retvalue;
2941 }
2942
get_pango_context() const2943 Glib::RefPtr<const Pango::Context> Actor::get_pango_context() const
2944 {
2945 return const_cast<Actor*>(this)->get_pango_context();
2946 }
2947
create_pango_context()2948 Glib::RefPtr<Pango::Context> Actor::create_pango_context()
2949 {
2950 return Glib::wrap(clutter_actor_create_pango_context(gobj()));
2951 }
2952
create_pango_layout(const Glib::ustring & text)2953 Glib::RefPtr<Pango::Layout> Actor::create_pango_layout(const Glib::ustring& text)
2954 {
2955 return Glib::wrap(clutter_actor_create_pango_layout(gobj(), text.c_str()));
2956 }
2957
2958 #ifndef CLUTTERMM_DISABLE_DEPRECATED
2959
get_transformation_matrix(ClutterMatrix * matrix)2960 void Actor::get_transformation_matrix(ClutterMatrix* matrix)
2961 {
2962 clutter_actor_get_transformation_matrix(gobj(), matrix);
2963 }
2964
2965 #endif // CLUTTERMM_DISABLE_DEPRECATED
2966
set_transform(const Matrix & transform)2967 void Actor::set_transform(const Matrix& transform)
2968 {
2969 clutter_actor_set_transform(gobj(), &(transform));
2970 }
2971
set_child_transform(const Matrix & transform)2972 void Actor::set_child_transform(const Matrix& transform)
2973 {
2974 clutter_actor_set_child_transform(gobj(), &(transform));
2975 }
2976
is_in_clone_paint() const2977 bool Actor::is_in_clone_paint() const
2978 {
2979 return clutter_actor_is_in_clone_paint(const_cast<ClutterActor*>(gobj()));
2980 }
2981
get_paint_box(ActorBox & box)2982 bool Actor::get_paint_box(ActorBox& box)
2983 {
2984 ClutterActorBox g_box = ClutterActorBox();
2985 bool retvalue = clutter_actor_get_paint_box(gobj(), &g_box);
2986 box = Glib::wrap(&(g_box));
2987 return retvalue;
2988 }
2989
has_pointer() const2990 bool Actor::has_pointer() const
2991 {
2992 return clutter_actor_has_pointer(const_cast<ClutterActor*>(gobj()));
2993 }
2994
set_text_direction(TextDirection text_dir)2995 void Actor::set_text_direction(TextDirection text_dir)
2996 {
2997 clutter_actor_set_text_direction(gobj(), ((ClutterTextDirection)(text_dir)));
2998 }
2999
get_text_direction() const3000 TextDirection Actor::get_text_direction() const
3001 {
3002 return ((TextDirection)(clutter_actor_get_text_direction(const_cast<ClutterActor*>(gobj()))));
3003 }
3004
get_stage()3005 Glib::RefPtr<Actor> Actor::get_stage()
3006 {
3007 Glib::RefPtr<Actor> retvalue = Glib::wrap(clutter_actor_get_stage(gobj()));
3008 if(retvalue)
3009 retvalue->reference(); //The function does not do a ref for us.
3010 return retvalue;
3011 }
3012
get_stage() const3013 Glib::RefPtr<const Actor> Actor::get_stage() const
3014 {
3015 return const_cast<Actor*>(this)->get_stage();
3016 }
3017
set_child_below_sibling(const Glib::RefPtr<Actor> & child,const Glib::RefPtr<Actor> & sibling)3018 void Actor::set_child_below_sibling(const Glib::RefPtr<Actor>& child, const Glib::RefPtr<Actor>& sibling)
3019 {
3020 clutter_actor_set_child_below_sibling(gobj(), Glib::unwrap(child), Glib::unwrap(sibling));
3021 }
3022
set_child_above_sibling(const Glib::RefPtr<Actor> & child,const Glib::RefPtr<Actor> & sibling)3023 void Actor::set_child_above_sibling(const Glib::RefPtr<Actor>& child, const Glib::RefPtr<Actor>& sibling)
3024 {
3025 clutter_actor_set_child_above_sibling(gobj(), Glib::unwrap(child), Glib::unwrap(sibling));
3026 }
3027
set_child_at_index(const Glib::RefPtr<Actor> & child,int index)3028 void Actor::set_child_at_index(const Glib::RefPtr<Actor>& child, int index)
3029 {
3030 clutter_actor_set_child_at_index(gobj(), Glib::unwrap(child), index);
3031 }
3032
3033 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3034
set_geometry(const Geometry & geometry)3035 void Actor::set_geometry(const Geometry& geometry)
3036 {
3037 clutter_actor_set_geometry(gobj(), (geometry).gobj());
3038 }
3039
3040 #endif // CLUTTERMM_DISABLE_DEPRECATED
3041
set_size(float width,float height)3042 void Actor::set_size(float width, float height)
3043 {
3044 clutter_actor_set_size(gobj(), width, height);
3045 }
3046
get_position(float & x,float & y)3047 void Actor::get_position(float& x, float& y)
3048 {
3049 clutter_actor_get_position(gobj(), &(x), &(y));
3050 }
3051
set_position(float x,float y)3052 void Actor::set_position(float x, float y)
3053 {
3054 clutter_actor_set_position(gobj(), x, y);
3055 }
3056
get_width() const3057 float Actor::get_width() const
3058 {
3059 return clutter_actor_get_width(const_cast<ClutterActor*>(gobj()));
3060 }
3061
get_height() const3062 float Actor::get_height() const
3063 {
3064 return clutter_actor_get_height(const_cast<ClutterActor*>(gobj()));
3065 }
3066
set_width(float width)3067 void Actor::set_width(float width)
3068 {
3069 clutter_actor_set_width(gobj(), width);
3070 }
3071
set_height(float height)3072 void Actor::set_height(float height)
3073 {
3074 clutter_actor_set_height(gobj(), height);
3075 }
3076
set_x(float x)3077 void Actor::set_x(float x)
3078 {
3079 clutter_actor_set_x(gobj(), x);
3080 }
3081
get_x() const3082 float Actor::get_x() const
3083 {
3084 return clutter_actor_get_x(const_cast<ClutterActor*>(gobj()));
3085 }
3086
set_y(float y)3087 void Actor::set_y(float y)
3088 {
3089 clutter_actor_set_y(gobj(), y);
3090 }
3091
get_y() const3092 float Actor::get_y() const
3093 {
3094 return clutter_actor_get_y(const_cast<ClutterActor*>(gobj()));
3095 }
3096
set_z_position(float z_position)3097 void Actor::set_z_position(float z_position)
3098 {
3099 clutter_actor_set_z_position(gobj(), z_position);
3100 }
3101
get_z_position() const3102 float Actor::get_z_position() const
3103 {
3104 return clutter_actor_get_z_position(const_cast<ClutterActor*>(gobj()));
3105 }
3106
set_x_align(ActorAlign x_align)3107 void Actor::set_x_align(ActorAlign x_align)
3108 {
3109 clutter_actor_set_x_align(gobj(), ((ClutterActorAlign)(x_align)));
3110 }
3111
get_x_align() const3112 ActorAlign Actor::get_x_align() const
3113 {
3114 return ((ActorAlign)(clutter_actor_get_x_align(const_cast<ClutterActor*>(gobj()))));
3115 }
3116
set_y_align(ActorAlign y_align)3117 void Actor::set_y_align(ActorAlign y_align)
3118 {
3119 clutter_actor_set_y_align(gobj(), ((ClutterActorAlign)(y_align)));
3120 }
3121
get_y_align() const3122 ActorAlign Actor::get_y_align() const
3123 {
3124 return ((ActorAlign)(clutter_actor_get_y_align(const_cast<ClutterActor*>(gobj()))));
3125 }
3126
get_x_expand() const3127 bool Actor::get_x_expand() const
3128 {
3129 return clutter_actor_get_x_expand(const_cast<ClutterActor*>(gobj()));
3130 }
3131
set_x_expand(bool expand)3132 void Actor::set_x_expand(bool expand)
3133 {
3134 clutter_actor_set_x_expand(gobj(), static_cast<int>(expand));
3135 }
3136
get_y_expand() const3137 bool Actor::get_y_expand() const
3138 {
3139 return clutter_actor_get_y_expand(const_cast<ClutterActor*>(gobj()));
3140 }
3141
set_y_expand(bool expand)3142 void Actor::set_y_expand(bool expand)
3143 {
3144 clutter_actor_set_y_expand(gobj(), static_cast<int>(expand));
3145 }
3146
needs_expand(Orientation orientation) const3147 bool Actor::needs_expand(Orientation orientation) const
3148 {
3149 return clutter_actor_needs_expand(const_cast<ClutterActor*>(gobj()), ((ClutterOrientation)(orientation)));
3150 }
3151
set_layout_manager(const Glib::RefPtr<LayoutManager> & manager)3152 void Actor::set_layout_manager(const Glib::RefPtr<LayoutManager>& manager)
3153 {
3154 clutter_actor_set_layout_manager(gobj(), Glib::unwrap(manager));
3155 }
3156
get_layout_manager()3157 Glib::RefPtr<LayoutManager> Actor::get_layout_manager()
3158 {
3159 Glib::RefPtr<LayoutManager> retvalue = Glib::wrap(clutter_actor_get_layout_manager(gobj()));
3160 if(retvalue)
3161 retvalue->reference(); //The function does not do a ref for us.
3162 return retvalue;
3163 }
3164
get_layout_manager() const3165 Glib::RefPtr<const LayoutManager> Actor::get_layout_manager() const
3166 {
3167 return const_cast<Actor*>(this)->get_layout_manager();
3168 }
3169
set_reactive(bool reactive)3170 void Actor::set_reactive(bool reactive)
3171 {
3172 clutter_actor_set_reactive(gobj(), static_cast<int>(reactive));
3173 }
3174
get_reactive() const3175 bool Actor::get_reactive() const
3176 {
3177 return clutter_actor_get_reactive(const_cast<ClutterActor*>(gobj()));
3178 }
3179
has_key_focus() const3180 bool Actor::has_key_focus() const
3181 {
3182 return clutter_actor_has_key_focus(const_cast<ClutterActor*>(gobj()));
3183 }
3184
3185 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3186
set_rotation(RotateAxis axis,double angle,float x,float y,float z)3187 void Actor::set_rotation(RotateAxis axis, double angle, float x, float y, float z)
3188 {
3189 clutter_actor_set_rotation(gobj(), ((ClutterRotateAxis)(axis)), angle, x, y, z);
3190 }
3191
3192 #endif // CLUTTERMM_DISABLE_DEPRECATED
3193
3194 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3195
set_z_rotation_from_gravity(double angle,Gravity gravity)3196 void Actor::set_z_rotation_from_gravity(double angle, Gravity gravity)
3197 {
3198 clutter_actor_set_z_rotation_from_gravity(gobj(), angle, ((ClutterGravity)(gravity)));
3199 }
3200
3201 #endif // CLUTTERMM_DISABLE_DEPRECATED
3202
3203 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3204
get_rotation(RotateAxis axis,float & x,float & y,float & z) const3205 double Actor::get_rotation(RotateAxis axis, float& x, float& y, float& z) const
3206 {
3207 return clutter_actor_get_rotation(const_cast<ClutterActor*>(gobj()), ((ClutterRotateAxis)(axis)), &(x), &(y), &(z));
3208 }
3209
3210 #endif // CLUTTERMM_DISABLE_DEPRECATED
3211
3212 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3213
get_z_rotation_gravity() const3214 Gravity Actor::get_z_rotation_gravity() const
3215 {
3216 return ((Gravity)(clutter_actor_get_z_rotation_gravity(const_cast<ClutterActor*>(gobj()))));
3217 }
3218
3219 #endif // CLUTTERMM_DISABLE_DEPRECATED
3220
set_opacity(guint8 opacity)3221 void Actor::set_opacity(guint8 opacity)
3222 {
3223 clutter_actor_set_opacity(gobj(), opacity);
3224 }
3225
get_opacity() const3226 guint8 Actor::get_opacity() const
3227 {
3228 return clutter_actor_get_opacity(const_cast<ClutterActor*>(gobj()));
3229 }
3230
set_offscreen_redirect(OffscreenRedirect redirect) const3231 void Actor::set_offscreen_redirect(OffscreenRedirect redirect) const
3232 {
3233 clutter_actor_set_offscreen_redirect(const_cast<ClutterActor*>(gobj()), ((ClutterOffscreenRedirect)(redirect)));
3234 }
3235
get_offscreen_redirect()3236 OffscreenRedirect Actor::get_offscreen_redirect()
3237 {
3238 return ((OffscreenRedirect)(clutter_actor_get_offscreen_redirect(gobj())));
3239 }
3240
set_background_color(const Color & color)3241 void Actor::set_background_color(const Color& color)
3242 {
3243 clutter_actor_set_background_color(gobj(), (color).gobj());
3244 }
3245
get_paint_volume() const3246 const PaintVolume* Actor::get_paint_volume() const
3247 {
3248 return (clutter_actor_get_paint_volume(const_cast<ClutterActor*>(gobj())));
3249 }
3250
get_transformed_paint_volume(const Glib::RefPtr<Actor> & relative_to_ancestor) const3251 const PaintVolume* Actor::get_transformed_paint_volume(const Glib::RefPtr<Actor>& relative_to_ancestor) const
3252 {
3253 return (clutter_actor_get_transformed_paint_volume(const_cast<ClutterActor*>(gobj()), Glib::unwrap(relative_to_ancestor)));
3254 }
3255
get_transformed_paint_volume() const3256 const PaintVolume* Actor::get_transformed_paint_volume() const
3257 {
3258 return (clutter_actor_get_transformed_paint_volume(const_cast<ClutterActor*>(gobj()), 0));
3259 }
3260
get_default_paint_volume() const3261 const PaintVolume* Actor::get_default_paint_volume() const
3262 {
3263 return (clutter_actor_get_default_paint_volume(const_cast<ClutterActor*>(gobj())));
3264 }
3265
set_name(const gchar * name)3266 void Actor::set_name(const gchar * name)
3267 {
3268 clutter_actor_set_name(gobj(), name);
3269 }
3270
get_name() const3271 Glib::ustring Actor::get_name() const
3272 {
3273 return Glib::convert_const_gchar_ptr_to_ustring(clutter_actor_get_name(const_cast<ClutterActor*>(gobj())));
3274 }
3275
get_gid() const3276 guint32 Actor::get_gid() const
3277 {
3278 return clutter_actor_get_gid(const_cast<ClutterActor*>(gobj()));
3279 }
3280
set_clip(float xoff,float yoff,float width,float height)3281 void Actor::set_clip(float xoff, float yoff, float width, float height)
3282 {
3283 clutter_actor_set_clip(gobj(), xoff, yoff, width, height);
3284 }
3285
get_clip(float & xoff,float & yoff,float & width,float & height)3286 void Actor::get_clip(float& xoff, float& yoff, float& width, float& height)
3287 {
3288 clutter_actor_get_clip(gobj(), &(xoff), &(yoff), &(width), &(height));
3289 }
3290
set_clip_to_allocation(bool clip_set)3291 void Actor::set_clip_to_allocation(bool clip_set)
3292 {
3293 clutter_actor_set_clip_to_allocation(gobj(), static_cast<int>(clip_set));
3294 }
3295
get_clip_to_allocation() const3296 bool Actor::get_clip_to_allocation() const
3297 {
3298 return clutter_actor_get_clip_to_allocation(const_cast<ClutterActor*>(gobj()));
3299 }
3300
remove_clip()3301 void Actor::remove_clip()
3302 {
3303 clutter_actor_remove_clip(gobj());
3304 }
3305
has_clip() const3306 bool Actor::has_clip() const
3307 {
3308 return clutter_actor_has_clip(const_cast<ClutterActor*>(gobj()));
3309 }
3310
get_children()3311 std::vector< Glib::RefPtr<Actor> > Actor::get_children()
3312 {
3313 return Glib::ListHandler< Glib::RefPtr<Actor> >::list_to_vector(clutter_actor_get_children(gobj()), Glib::OWNERSHIP_SHALLOW);
3314 }
3315
get_children() const3316 std::vector< Glib::RefPtr<const Actor> > Actor::get_children() const
3317 {
3318 return Glib::ListHandler< Glib::RefPtr<const Actor> >::list_to_vector(clutter_actor_get_children(const_cast<ClutterActor*>(gobj())), Glib::OWNERSHIP_SHALLOW);
3319 }
3320
get_n_children() const3321 int Actor::get_n_children() const
3322 {
3323 return clutter_actor_get_n_children(const_cast<ClutterActor*>(gobj()));
3324 }
3325
get_child_at_index(int index)3326 Glib::RefPtr<Actor> Actor::get_child_at_index(int index)
3327 {
3328 Glib::RefPtr<Actor> retvalue = Glib::wrap(clutter_actor_get_child_at_index(gobj(), index));
3329 if(retvalue)
3330 retvalue->reference(); //The function does not do a ref for us.
3331 return retvalue;
3332 }
3333
get_child_at_index(int index) const3334 Glib::RefPtr<const Actor> Actor::get_child_at_index(int index) const
3335 {
3336 return const_cast<Actor*>(this)->get_child_at_index(index);
3337 }
3338
get_previous_sibling()3339 Glib::RefPtr<Actor> Actor::get_previous_sibling()
3340 {
3341 Glib::RefPtr<Actor> retvalue = Glib::wrap(clutter_actor_get_previous_sibling(gobj()));
3342 if(retvalue)
3343 retvalue->reference(); //The function does not do a ref for us.
3344 return retvalue;
3345 }
3346
get_previous_sibling() const3347 Glib::RefPtr<const Actor> Actor::get_previous_sibling() const
3348 {
3349 return const_cast<Actor*>(this)->get_previous_sibling();
3350 }
3351
get_next_sibling()3352 Glib::RefPtr<Actor> Actor::get_next_sibling()
3353 {
3354 Glib::RefPtr<Actor> retvalue = Glib::wrap(clutter_actor_get_next_sibling(gobj()));
3355 if(retvalue)
3356 retvalue->reference(); //The function does not do a ref for us.
3357 return retvalue;
3358 }
3359
get_next_sibling() const3360 Glib::RefPtr<const Actor> Actor::get_next_sibling() const
3361 {
3362 return const_cast<Actor*>(this)->get_next_sibling();
3363 }
3364
get_first_child()3365 Glib::RefPtr<Actor> Actor::get_first_child()
3366 {
3367 Glib::RefPtr<Actor> retvalue = Glib::wrap(clutter_actor_get_first_child(gobj()));
3368 if(retvalue)
3369 retvalue->reference(); //The function does not do a ref for us.
3370 return retvalue;
3371 }
3372
get_first_child() const3373 Glib::RefPtr<const Actor> Actor::get_first_child() const
3374 {
3375 return const_cast<Actor*>(this)->get_first_child();
3376 }
3377
get_last_child()3378 Glib::RefPtr<Actor> Actor::get_last_child()
3379 {
3380 Glib::RefPtr<Actor> retvalue = Glib::wrap(clutter_actor_get_last_child(gobj()));
3381 if(retvalue)
3382 retvalue->reference(); //The function does not do a ref for us.
3383 return retvalue;
3384 }
3385
get_last_child() const3386 Glib::RefPtr<const Actor> Actor::get_last_child() const
3387 {
3388 return const_cast<Actor*>(this)->get_last_child();
3389 }
3390
3391 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3392
set_parent(const Glib::RefPtr<Actor> & parent)3393 void Actor::set_parent(const Glib::RefPtr<Actor>& parent)
3394 {
3395 clutter_actor_set_parent(gobj(), Glib::unwrap(parent));
3396 }
3397
3398 #endif // CLUTTERMM_DISABLE_DEPRECATED
3399
get_parent()3400 Glib::RefPtr<Actor> Actor::get_parent()
3401 {
3402 Glib::RefPtr<Actor> retvalue = Glib::wrap(clutter_actor_get_parent(gobj()));
3403 if(retvalue)
3404 retvalue->reference(); //The function does not do a ref for us.
3405 return retvalue;
3406 }
3407
get_parent() const3408 Glib::RefPtr<const Actor> Actor::get_parent() const
3409 {
3410 return const_cast<Actor*>(this)->get_parent();
3411 }
3412
3413 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3414
reparent(const Glib::RefPtr<Actor> & new_parent)3415 void Actor::reparent(const Glib::RefPtr<Actor>& new_parent)
3416 {
3417 clutter_actor_reparent(gobj(), Glib::unwrap(new_parent));
3418 }
3419
3420 #endif // CLUTTERMM_DISABLE_DEPRECATED
3421
3422 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3423
unparent()3424 void Actor::unparent()
3425 {
3426 clutter_actor_unparent(gobj());
3427 }
3428
3429 #endif // CLUTTERMM_DISABLE_DEPRECATED
3430
contains(const Glib::RefPtr<const Actor> & descendant) const3431 bool Actor::contains(const Glib::RefPtr<const Actor>& descendant) const
3432 {
3433 return clutter_actor_contains(const_cast<ClutterActor*>(gobj()), const_cast<ClutterActor*>(Glib::unwrap(descendant)));
3434 }
3435
3436 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3437
raise(const Glib::RefPtr<Actor> & below)3438 void Actor::raise(const Glib::RefPtr<Actor>& below)
3439 {
3440 clutter_actor_raise(gobj(), Glib::unwrap(below));
3441 }
3442
3443 #endif // CLUTTERMM_DISABLE_DEPRECATED
3444
3445 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3446
lower(const Glib::RefPtr<Actor> & above)3447 void Actor::lower(const Glib::RefPtr<Actor>& above)
3448 {
3449 clutter_actor_lower(gobj(), Glib::unwrap(above));
3450 }
3451
3452 #endif // CLUTTERMM_DISABLE_DEPRECATED
3453
raise_top()3454 void Actor::raise_top()
3455 {
3456 clutter_actor_raise_top(gobj());
3457 }
3458
lower_bottom()3459 void Actor::lower_bottom()
3460 {
3461 clutter_actor_lower_bottom(gobj());
3462 }
3463
3464 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3465
get_shader()3466 Glib::RefPtr<Shader> Actor::get_shader()
3467 {
3468 Glib::RefPtr<Shader> retvalue = Glib::wrap(clutter_actor_get_shader(gobj()));
3469 if(retvalue)
3470 retvalue->reference(); //The function does not do a ref for us.
3471 return retvalue;
3472 }
3473
3474 #endif // CLUTTERMM_DISABLE_DEPRECATED
3475
3476 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3477
get_shader() const3478 Glib::RefPtr<const Shader> Actor::get_shader() const
3479 {
3480 return const_cast<Actor*>(this)->get_shader();
3481 }
3482
3483 #endif // CLUTTERMM_DISABLE_DEPRECATED
3484
3485 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3486
set_shader(const Glib::RefPtr<Shader> & shader)3487 void Actor::set_shader(const Glib::RefPtr<Shader>& shader)
3488 {
3489 clutter_actor_set_shader(gobj(), Glib::unwrap(shader));
3490 }
3491
3492 #endif // CLUTTERMM_DISABLE_DEPRECATED
3493
is_rotated() const3494 bool Actor::is_rotated() const
3495 {
3496 return clutter_actor_is_rotated(const_cast<ClutterActor*>(gobj()));
3497 }
3498
is_scaled() const3499 bool Actor::is_scaled() const
3500 {
3501 return clutter_actor_is_scaled(const_cast<ClutterActor*>(gobj()));
3502 }
3503
set_pivot_point(float x,float y)3504 void Actor::set_pivot_point(float x, float y)
3505 {
3506 clutter_actor_set_pivot_point(gobj(), x, y);
3507 }
3508
get_pivot_point(float & pivot_x,float & pivot_y) const3509 void Actor::get_pivot_point(float& pivot_x, float& pivot_y) const
3510 {
3511 clutter_actor_get_pivot_point(const_cast<ClutterActor*>(gobj()), &(pivot_x), &(pivot_y));
3512 }
3513
set_pivot_point_z(float pivot_z)3514 void Actor::set_pivot_point_z(float pivot_z)
3515 {
3516 clutter_actor_set_pivot_point_z(gobj(), pivot_z);
3517 }
3518
get_pivot_point_z() const3519 float Actor::get_pivot_point_z() const
3520 {
3521 return clutter_actor_get_pivot_point_z(const_cast<ClutterActor*>(gobj()));
3522 }
3523
set_rotation_angle(RotateAxis axis,double angle)3524 void Actor::set_rotation_angle(RotateAxis axis, double angle)
3525 {
3526 clutter_actor_set_rotation_angle(gobj(), ((ClutterRotateAxis)(axis)), angle);
3527 }
3528
get_rotation_angle(RotateAxis axis) const3529 double Actor::get_rotation_angle(RotateAxis axis) const
3530 {
3531 return clutter_actor_get_rotation_angle(const_cast<ClutterActor*>(gobj()), ((ClutterRotateAxis)(axis)));
3532 }
3533
set_translation(float translate_x,float translate_y,float translate_z)3534 void Actor::set_translation(float translate_x, float translate_y, float translate_z)
3535 {
3536 clutter_actor_set_translation(gobj(), translate_x, translate_y, translate_z);
3537 }
3538
get_translation(float & translate_x,float & translate_y,float & translate_z) const3539 void Actor::get_translation(float& translate_x, float& translate_y, float& translate_z) const
3540 {
3541 clutter_actor_get_translation(const_cast<ClutterActor*>(gobj()), &(translate_x), &(translate_y), &(translate_z));
3542 }
3543
should_pick_paint() const3544 bool Actor::should_pick_paint() const
3545 {
3546 return clutter_actor_should_pick_paint(const_cast<ClutterActor*>(gobj()));
3547 }
3548
allocate_align_fill(const ActorBox & box,gdouble x_align,double y_align,bool x_fill,bool y_fill,AllocationFlags flags)3549 void Actor::allocate_align_fill(const ActorBox& box, gdouble x_align, double y_align, bool x_fill, bool y_fill, AllocationFlags flags)
3550 {
3551 clutter_actor_allocate_align_fill(gobj(), (box).gobj(), x_align, y_align, static_cast<int>(x_fill), static_cast<int>(y_fill), ((ClutterAllocationFlags)(flags)));
3552 }
3553
set_allocation(const ActorBox & box,AllocationFlags flags)3554 void Actor::set_allocation(const ActorBox& box, AllocationFlags flags)
3555 {
3556 clutter_actor_set_allocation(gobj(), (box).gobj(), ((ClutterAllocationFlags)(flags)));
3557 }
3558
allocate(const ActorBox & box,AllocationFlags absolute_origin_changed)3559 void Actor::allocate(const ActorBox& box, AllocationFlags absolute_origin_changed)
3560 {
3561 clutter_actor_allocate(gobj(), (box).gobj(), ((ClutterAllocationFlags)(absolute_origin_changed)));
3562 }
3563
allocate_preferred_size(AllocationFlags absolute_origin_changed)3564 void Actor::allocate_preferred_size(AllocationFlags absolute_origin_changed)
3565 {
3566 clutter_actor_allocate_preferred_size(gobj(), ((ClutterAllocationFlags)(absolute_origin_changed)));
3567 }
3568
allocate_available_size(float x,float y,float available_width,float available_height,AllocationFlags flags)3569 void Actor::allocate_available_size(float x, float y, float available_width, float available_height, AllocationFlags flags)
3570 {
3571 clutter_actor_allocate_available_size(gobj(), x, y, available_width, available_height, ((ClutterAllocationFlags)(flags)));
3572 }
3573
apply_transform_to_point(const Vertex & point,Vertex & vertex) const3574 void Actor::apply_transform_to_point(const Vertex& point, Vertex& vertex) const
3575 {
3576 clutter_actor_apply_transform_to_point(const_cast<ClutterActor*>(gobj()), (point).gobj(), (vertex).gobj());
3577 }
3578
transform_stage_point(float x,float y,float & x_out,float & y_out) const3579 void Actor::transform_stage_point(float x, float y, float& x_out, float& y_out) const
3580 {
3581 clutter_actor_transform_stage_point(const_cast<ClutterActor*>(gobj()), x, y, &(x_out), &(y_out));
3582 }
3583
apply_relative_transform_to_point(const Glib::RefPtr<Actor> & ancestor,const Vertex & point,Vertex & vertex) const3584 void Actor::apply_relative_transform_to_point(const Glib::RefPtr<Actor>& ancestor, const Vertex& point, Vertex& vertex) const
3585 {
3586 clutter_actor_apply_relative_transform_to_point(const_cast<ClutterActor*>(gobj()), Glib::unwrap(ancestor), (point).gobj(), (vertex).gobj());
3587 }
3588
get_transformed_position(float & x,float & y) const3589 void Actor::get_transformed_position(float& x, float& y) const
3590 {
3591 clutter_actor_get_transformed_position(const_cast<ClutterActor*>(gobj()), &(x), &(y));
3592 }
3593
get_transformed_size(float & width,float & height) const3594 void Actor::get_transformed_size(float& width, float& height) const
3595 {
3596 clutter_actor_get_transformed_size(const_cast<ClutterActor*>(gobj()), &(width), &(height));
3597 }
3598
set_request_mode(RequestMode mode)3599 void Actor::set_request_mode(RequestMode mode)
3600 {
3601 clutter_actor_set_request_mode(gobj(), ((ClutterRequestMode)(mode)));
3602 }
3603
get_request_mode() const3604 RequestMode Actor::get_request_mode() const
3605 {
3606 return ((RequestMode)(clutter_actor_get_request_mode(const_cast<ClutterActor*>(gobj()))));
3607 }
3608
get_preferred_size(float & min_width_p,float & min_height_p,float & natural_width_p,float & natural_height_p) const3609 void Actor::get_preferred_size(float& min_width_p, float& min_height_p, float& natural_width_p, float& natural_height_p) const
3610 {
3611 clutter_actor_get_preferred_size(const_cast<ClutterActor*>(gobj()), &(min_width_p), &(min_height_p), &(natural_width_p), &(natural_height_p));
3612 }
3613
get_preferred_width(float for_height,float & min_width_p,float & natural_width_p) const3614 void Actor::get_preferred_width(float for_height, float& min_width_p, float& natural_width_p) const
3615 {
3616 clutter_actor_get_preferred_width(const_cast<ClutterActor*>(gobj()), for_height, &(min_width_p), &(natural_width_p));
3617 }
3618
get_preferred_height(float for_width,float & min_height_p,float & natural_height_p) const3619 void Actor::get_preferred_height(float for_width, float& min_height_p, float& natural_height_p) const
3620 {
3621 clutter_actor_get_preferred_height(const_cast<ClutterActor*>(gobj()), for_width, &(min_height_p), &(natural_height_p));
3622 }
3623
get_paint_opacity() const3624 guint8 Actor::get_paint_opacity() const
3625 {
3626 return clutter_actor_get_paint_opacity(const_cast<ClutterActor*>(gobj()));
3627 }
3628
get_paint_visibility() const3629 bool Actor::get_paint_visibility() const
3630 {
3631 return clutter_actor_get_paint_visibility(const_cast<ClutterActor*>(gobj()));
3632 }
3633
3634 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3635
move_anchor_point_from_gravity(Gravity gravity)3636 void Actor::move_anchor_point_from_gravity(Gravity gravity)
3637 {
3638 clutter_actor_move_anchor_point_from_gravity(gobj(), ((ClutterGravity)(gravity)));
3639 }
3640
3641 #endif // CLUTTERMM_DISABLE_DEPRECATED
3642
3643 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3644
move_anchor_point(float anchor_x,float anchor_y)3645 void Actor::move_anchor_point(float anchor_x, float anchor_y)
3646 {
3647 clutter_actor_move_anchor_point(gobj(), anchor_x, anchor_y);
3648 }
3649
3650 #endif // CLUTTERMM_DISABLE_DEPRECATED
3651
set_margin_top(float margin)3652 void Actor::set_margin_top(float margin)
3653 {
3654 clutter_actor_set_margin_top(gobj(), margin);
3655 }
3656
get_margin_top() const3657 float Actor::get_margin_top() const
3658 {
3659 return clutter_actor_get_margin_top(const_cast<ClutterActor*>(gobj()));
3660 }
3661
set_margin_bottom(float margin)3662 void Actor::set_margin_bottom(float margin)
3663 {
3664 clutter_actor_set_margin_bottom(gobj(), margin);
3665 }
3666
get_margin_bottom() const3667 float Actor::get_margin_bottom() const
3668 {
3669 return clutter_actor_get_margin_bottom(const_cast<ClutterActor*>(gobj()));
3670 }
3671
set_margin_left(float margin)3672 void Actor::set_margin_left(float margin)
3673 {
3674 clutter_actor_set_margin_left(gobj(), margin);
3675 }
3676
get_margin_left() const3677 float Actor::get_margin_left() const
3678 {
3679 return clutter_actor_get_margin_left(const_cast<ClutterActor*>(gobj()));
3680 }
3681
set_margin_right(float margin)3682 void Actor::set_margin_right(float margin)
3683 {
3684 clutter_actor_set_margin_right(gobj(), margin);
3685 }
3686
get_margin_right() const3687 float Actor::get_margin_right() const
3688 {
3689 return clutter_actor_get_margin_right(const_cast<ClutterActor*>(gobj()));
3690 }
3691
get_fixed_position_set() const3692 bool Actor::get_fixed_position_set() const
3693 {
3694 return clutter_actor_get_fixed_position_set(const_cast<ClutterActor*>(gobj()));
3695 }
3696
set_fixed_position_set(bool is_set)3697 void Actor::set_fixed_position_set(bool is_set)
3698 {
3699 clutter_actor_set_fixed_position_set(gobj(), static_cast<int>(is_set));
3700 }
3701
3702 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3703
set_depth(float depth)3704 void Actor::set_depth(float depth)
3705 {
3706 clutter_actor_set_depth(gobj(), depth);
3707 }
3708
3709 #endif // CLUTTERMM_DISABLE_DEPRECATED
3710
3711 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3712
get_depth() const3713 float Actor::get_depth() const
3714 {
3715 return clutter_actor_get_depth(const_cast<ClutterActor*>(gobj()));
3716 }
3717
3718 #endif // CLUTTERMM_DISABLE_DEPRECATED
3719
set_scale(double scale_x,double scale_y)3720 void Actor::set_scale(double scale_x, double scale_y)
3721 {
3722 clutter_actor_set_scale(gobj(), scale_x, scale_y);
3723 }
3724
set_scale_z(double scale_z)3725 void Actor::set_scale_z(double scale_z)
3726 {
3727 clutter_actor_set_scale_z(gobj(), scale_z);
3728 }
3729
3730 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3731
set_scale_full(double scale_x,double scale_y,float center_x,float center_y)3732 void Actor::set_scale_full(double scale_x, double scale_y, float center_x, float center_y)
3733 {
3734 clutter_actor_set_scale_full(gobj(), scale_x, scale_y, center_x, center_y);
3735 }
3736
3737 #endif // CLUTTERMM_DISABLE_DEPRECATED
3738
3739 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3740
set_scale_with_gravity(double scale_x,double scale_y,Gravity gravity)3741 void Actor::set_scale_with_gravity(double scale_x, double scale_y, Gravity gravity)
3742 {
3743 clutter_actor_set_scale_with_gravity(gobj(), scale_x, scale_y, ((ClutterGravity)(gravity)));
3744 }
3745
3746 #endif // CLUTTERMM_DISABLE_DEPRECATED
3747
get_scale(double & scale_x,double & scale_y) const3748 void Actor::get_scale(double& scale_x, double& scale_y) const
3749 {
3750 clutter_actor_get_scale(const_cast<ClutterActor*>(gobj()), &(scale_x), &(scale_y));
3751 }
3752
get_scale_z() const3753 double Actor::get_scale_z() const
3754 {
3755 return clutter_actor_get_scale_z(const_cast<ClutterActor*>(gobj()));
3756 }
3757
3758 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3759
get_scale_center(float & center_x,float & center_y) const3760 void Actor::get_scale_center(float& center_x, float& center_y) const
3761 {
3762 clutter_actor_get_scale_center(const_cast<ClutterActor*>(gobj()), &(center_x), &(center_y));
3763 }
3764
3765 #endif // CLUTTERMM_DISABLE_DEPRECATED
3766
3767 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3768
get_scale_gravity() const3769 Gravity Actor::get_scale_gravity() const
3770 {
3771 return ((Gravity)(clutter_actor_get_scale_gravity(const_cast<ClutterActor*>(gobj()))));
3772 }
3773
3774 #endif // CLUTTERMM_DISABLE_DEPRECATED
3775
get_size(float & width,float & height) const3776 void Actor::get_size(float& width, float& height) const
3777 {
3778 clutter_actor_get_size(const_cast<ClutterActor*>(gobj()), &(width), &(height));
3779 }
3780
move_by(float dx,float dy)3781 void Actor::move_by(float dx, float dy)
3782 {
3783 clutter_actor_move_by(gobj(), dx, dy);
3784 }
3785
event(const ClutterEvent * event,bool capture)3786 bool Actor::event(const ClutterEvent* event, bool capture)
3787 {
3788 return clutter_actor_event(gobj(), event, static_cast<int>(capture));
3789 }
3790
3791 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3792
get_actor_by_gid(guint32 id)3793 Glib::RefPtr<Actor> Actor::get_actor_by_gid(guint32 id)
3794 {
3795
3796 Glib::RefPtr<Actor> retvalue = Glib::wrap(clutter_get_actor_by_gid(id));
3797 if(retvalue)
3798 retvalue->reference(); //The function does not do a ref for us
3799 return retvalue;
3800 }
3801
3802 #endif // CLUTTERMM_DISABLE_DEPRECATED
3803
3804
3805 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3806
set_anchor_point(float anchor_x,float anchor_y)3807 void Actor::set_anchor_point(float anchor_x, float anchor_y)
3808 {
3809 clutter_actor_set_anchor_point(gobj(), anchor_x, anchor_y);
3810 }
3811
3812 #endif // CLUTTERMM_DISABLE_DEPRECATED
3813
3814 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3815
get_anchor_point(float & anchor_x,float & anchor_y) const3816 void Actor::get_anchor_point(float& anchor_x, float& anchor_y) const
3817 {
3818 clutter_actor_get_anchor_point(const_cast<ClutterActor*>(gobj()), &(anchor_x), &(anchor_y));
3819 }
3820
3821 #endif // CLUTTERMM_DISABLE_DEPRECATED
3822
3823 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3824
set_anchor_point_from_gravity(ClutterGravity gravity)3825 void Actor::set_anchor_point_from_gravity(ClutterGravity gravity)
3826 {
3827 clutter_actor_set_anchor_point_from_gravity(gobj(), gravity);
3828 }
3829
3830 #endif // CLUTTERMM_DISABLE_DEPRECATED
3831
3832 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3833
get_anchor_point_gravity()3834 Gravity Actor::get_anchor_point_gravity()
3835 {
3836 return ((Gravity)(clutter_actor_get_anchor_point_gravity(gobj())));
3837 }
3838
3839 #endif // CLUTTERMM_DISABLE_DEPRECATED
3840
grab_key_focus()3841 void Actor::grab_key_focus()
3842 {
3843 clutter_actor_grab_key_focus(gobj());
3844 }
3845
add_child(const Glib::RefPtr<Actor> & child)3846 void Actor::add_child(const Glib::RefPtr<Actor>& child)
3847 {
3848 clutter_actor_add_child(gobj(), Glib::unwrap(child));
3849 }
3850
insert_child_above(const Glib::RefPtr<Actor> & child,const Glib::RefPtr<Actor> & sibling)3851 void Actor::insert_child_above(const Glib::RefPtr<Actor>& child, const Glib::RefPtr<Actor>& sibling)
3852 {
3853 clutter_actor_insert_child_above(gobj(), Glib::unwrap(child), Glib::unwrap(sibling));
3854 }
3855
insert_child_at_index(const Glib::RefPtr<Actor> & child,int index)3856 void Actor::insert_child_at_index(const Glib::RefPtr<Actor>& child, int index)
3857 {
3858 clutter_actor_insert_child_at_index(gobj(), Glib::unwrap(child), index);
3859 }
3860
insert_child_at_index(const Glib::RefPtr<Actor> & child)3861 void Actor::insert_child_at_index(const Glib::RefPtr<Actor>& child)
3862 {
3863 clutter_actor_insert_child_at_index(gobj(), Glib::unwrap(child), 0);
3864 }
3865
insert_child_below(const Glib::RefPtr<Actor> & child,const Glib::RefPtr<Actor> & sibling)3866 void Actor::insert_child_below(const Glib::RefPtr<Actor>& child, const Glib::RefPtr<Actor>& sibling)
3867 {
3868 clutter_actor_insert_child_below(gobj(), Glib::unwrap(child), Glib::unwrap(sibling));
3869 }
3870
replace_child(const Glib::RefPtr<Actor> & old_child,const Glib::RefPtr<Actor> & new_child)3871 void Actor::replace_child(const Glib::RefPtr<Actor>& old_child, const Glib::RefPtr<Actor>& new_child)
3872 {
3873 clutter_actor_replace_child(gobj(), Glib::unwrap(old_child), Glib::unwrap(new_child));
3874 }
3875
remove_child(const Glib::RefPtr<Actor> & child)3876 void Actor::remove_child(const Glib::RefPtr<Actor>& child)
3877 {
3878 clutter_actor_remove_child(gobj(), Glib::unwrap(child));
3879 }
3880
remove_all_children()3881 void Actor::remove_all_children()
3882 {
3883 clutter_actor_remove_all_children(gobj());
3884 }
3885
3886 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3887
get_animation()3888 Glib::RefPtr<Animation> Actor::get_animation()
3889 {
3890 Glib::RefPtr<Animation> retvalue = Glib::wrap(clutter_actor_get_animation(gobj()));
3891 if(retvalue)
3892 retvalue->reference(); //The function does not do a ref for us.
3893 return retvalue;
3894 }
3895
3896 #endif // CLUTTERMM_DISABLE_DEPRECATED
3897
3898 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3899
get_animation() const3900 Glib::RefPtr<const Animation> Actor::get_animation() const
3901 {
3902 return const_cast<Actor*>(this)->get_animation();
3903 }
3904
3905 #endif // CLUTTERMM_DISABLE_DEPRECATED
3906
detach_animation()3907 void Actor::detach_animation()
3908 {
3909 clutter_actor_detach_animation(gobj());
3910 }
3911
3912 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3913
push_internal()3914 void Actor::push_internal()
3915 {
3916 clutter_actor_push_internal(gobj());
3917 }
3918
3919 #endif // CLUTTERMM_DISABLE_DEPRECATED
3920
3921 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3922
pop_internal()3923 void Actor::pop_internal()
3924 {
3925 clutter_actor_pop_internal(gobj());
3926 }
3927
3928 #endif // CLUTTERMM_DISABLE_DEPRECATED
3929
has_allocation() const3930 bool Actor::has_allocation() const
3931 {
3932 return clutter_actor_has_allocation(const_cast<ClutterActor*>(gobj()));
3933 }
3934
get_accessible()3935 Glib::RefPtr<Atk::Object> Actor::get_accessible()
3936 {
3937 Glib::RefPtr<Atk::Object> retvalue = Glib::wrap(clutter_actor_get_accessible(gobj()));
3938 if(retvalue)
3939 retvalue->reference(); //The function does not do a ref for us.
3940 return retvalue;
3941 }
3942
get_accessible() const3943 Glib::RefPtr<const Atk::Object> Actor::get_accessible() const
3944 {
3945 return const_cast<Actor*>(this)->get_accessible();
3946 }
3947
add_action(const Glib::RefPtr<Action> & action)3948 void Actor::add_action(const Glib::RefPtr<Action>& action)
3949 {
3950 clutter_actor_add_action(gobj(), Glib::unwrap(action));
3951 }
3952
add_action(const Glib::ustring & name,const Glib::RefPtr<Action> & action)3953 void Actor::add_action(const Glib::ustring& name, const Glib::RefPtr<Action>& action)
3954 {
3955 clutter_actor_add_action_with_name(gobj(), name.c_str(), Glib::unwrap(action));
3956 }
3957
remove_action(const Glib::RefPtr<Action> & action)3958 void Actor::remove_action(const Glib::RefPtr<Action>& action)
3959 {
3960 clutter_actor_remove_action(gobj(), Glib::unwrap(action));
3961 }
3962
remove_action(const Glib::ustring & name)3963 void Actor::remove_action(const Glib::ustring& name)
3964 {
3965 clutter_actor_remove_action_by_name(gobj(), name.c_str());
3966 }
3967
get_action(const Glib::ustring & name)3968 Glib::RefPtr<Action> Actor::get_action(const Glib::ustring& name)
3969 {
3970 Glib::RefPtr<Action> retvalue = Glib::wrap(clutter_actor_get_action(gobj(), name.c_str()));
3971 if(retvalue)
3972 retvalue->reference(); //The function does not do a ref for us.
3973 return retvalue;
3974 }
3975
get_action(const Glib::ustring & name) const3976 Glib::RefPtr<const Action> Actor::get_action(const Glib::ustring& name) const
3977 {
3978 return const_cast<Actor*>(this)->get_action(name);
3979 }
3980
clear_actions()3981 void Actor::clear_actions()
3982 {
3983 clutter_actor_clear_actions(gobj());
3984 }
3985
get_actions()3986 std::vector< Glib::RefPtr<Action> > Actor::get_actions()
3987 {
3988 return Glib::ListHandler< Glib::RefPtr<Action> >::list_to_vector(clutter_actor_get_actions(gobj()), Glib::OWNERSHIP_SHALLOW);
3989 }
3990
get_actions() const3991 std::vector< Glib::RefPtr<const Action> > Actor::get_actions() const
3992 {
3993 return Glib::ListHandler< Glib::RefPtr<const Action> >::list_to_vector(clutter_actor_get_actions(const_cast<ClutterActor*>(gobj())), Glib::OWNERSHIP_SHALLOW);
3994 }
3995
has_actions() const3996 bool Actor::has_actions() const
3997 {
3998 return clutter_actor_has_actions(const_cast<ClutterActor*>(gobj()));
3999 }
4000
add_effect(const Glib::RefPtr<Effect> & effect)4001 void Actor::add_effect(const Glib::RefPtr<Effect>& effect)
4002 {
4003 clutter_actor_add_effect(gobj(), Glib::unwrap(effect));
4004 }
4005
add_effect_with_name(const Glib::ustring & name,const Glib::RefPtr<Effect> & effect)4006 void Actor::add_effect_with_name(const Glib::ustring& name, const Glib::RefPtr<Effect>& effect)
4007 {
4008 clutter_actor_add_effect_with_name(gobj(), name.c_str(), Glib::unwrap(effect));
4009 }
4010
remove_effect(const Glib::RefPtr<Effect> & effect)4011 void Actor::remove_effect(const Glib::RefPtr<Effect>& effect)
4012 {
4013 clutter_actor_remove_effect(gobj(), Glib::unwrap(effect));
4014 }
4015
remove_effect(const Glib::ustring & name)4016 void Actor::remove_effect(const Glib::ustring& name)
4017 {
4018 clutter_actor_remove_effect_by_name(gobj(), name.c_str());
4019 }
4020
get_effects()4021 std::vector< Glib::RefPtr<Effect> > Actor::get_effects()
4022 {
4023 return Glib::ListHandler< Glib::RefPtr<Effect> >::list_to_vector(clutter_actor_get_effects(gobj()), Glib::OWNERSHIP_SHALLOW);
4024 }
4025
get_effects() const4026 std::vector< Glib::RefPtr<const Effect> > Actor::get_effects() const
4027 {
4028 return Glib::ListHandler< Glib::RefPtr<const Effect> >::list_to_vector(clutter_actor_get_effects(const_cast<ClutterActor*>(gobj())), Glib::OWNERSHIP_SHALLOW);
4029 }
4030
get_effect(const Glib::ustring & name)4031 Glib::RefPtr<Effect> Actor::get_effect(const Glib::ustring& name)
4032 {
4033 Glib::RefPtr<Effect> retvalue = Glib::wrap(clutter_actor_get_effect(gobj(), name.c_str()));
4034 if(retvalue)
4035 retvalue->reference(); //The function does not do a ref for us.
4036 return retvalue;
4037 }
4038
get_effect(const Glib::ustring & name) const4039 Glib::RefPtr<const Effect> Actor::get_effect(const Glib::ustring& name) const
4040 {
4041 return const_cast<Actor*>(this)->get_effect(name);
4042 }
4043
clear_effects()4044 void Actor::clear_effects()
4045 {
4046 clutter_actor_clear_effects(gobj());
4047 }
4048
has_effects() const4049 bool Actor::has_effects() const
4050 {
4051 return clutter_actor_has_effects(const_cast<ClutterActor*>(gobj()));
4052 }
4053
save_easing_state()4054 void Actor::save_easing_state()
4055 {
4056 clutter_actor_save_easing_state(gobj());
4057 }
4058
restore_easing_state()4059 void Actor::restore_easing_state()
4060 {
4061 clutter_actor_restore_easing_state(gobj());
4062 }
4063
set_easing_duration(guint msecs)4064 void Actor::set_easing_duration(guint msecs)
4065 {
4066 clutter_actor_set_easing_duration(gobj(), msecs);
4067 }
4068
get_easing_duration() const4069 guint Actor::get_easing_duration() const
4070 {
4071 return clutter_actor_get_easing_duration(const_cast<ClutterActor*>(gobj()));
4072 }
4073
get_easing_mode() const4074 AnimationMode Actor::get_easing_mode() const
4075 {
4076 return ((AnimationMode)(clutter_actor_get_easing_mode(const_cast<ClutterActor*>(gobj()))));
4077 }
4078
set_easing_mode(AnimationMode mode)4079 void Actor::set_easing_mode(AnimationMode mode)
4080 {
4081 clutter_actor_set_easing_mode(gobj(), ((ClutterAnimationMode)(mode)));
4082 }
4083
get_easing_delay() const4084 guint Actor::get_easing_delay() const
4085 {
4086 return clutter_actor_get_easing_delay(const_cast<ClutterActor*>(gobj()));
4087 }
4088
set_easing_delay(guint msecs)4089 void Actor::set_easing_delay(guint msecs)
4090 {
4091 clutter_actor_set_easing_delay(gobj(), msecs);
4092 }
4093
get_transition(const Glib::ustring & name)4094 Glib::RefPtr<Transition> Actor::get_transition(const Glib::ustring& name)
4095 {
4096 return Glib::wrap(clutter_actor_get_transition(gobj(), name.c_str()));
4097 }
4098
get_transition(const Glib::ustring & name) const4099 Glib::RefPtr<const Transition> Actor::get_transition(const Glib::ustring& name) const
4100 {
4101 return Glib::wrap(clutter_actor_get_transition(const_cast<ClutterActor*>(gobj()), name.c_str()));
4102 }
4103
add_transition(const Glib::ustring & name,const Glib::RefPtr<Transition> & transition)4104 void Actor::add_transition(const Glib::ustring& name, const Glib::RefPtr<Transition>& transition)
4105 {
4106 clutter_actor_add_transition(gobj(), name.c_str(), Glib::unwrap(transition));
4107 }
4108
remove_transition(const Glib::ustring & name)4109 void Actor::remove_transition(const Glib::ustring& name)
4110 {
4111 clutter_actor_remove_transition(gobj(), name.c_str());
4112 }
4113
remove_all_transitions()4114 void Actor::remove_all_transitions()
4115 {
4116 clutter_actor_remove_all_transitions(gobj());
4117 }
4118
add_constraint(const Glib::RefPtr<Constraint> & constraint)4119 void Actor::add_constraint(const Glib::RefPtr<Constraint>& constraint)
4120 {
4121 clutter_actor_add_constraint(gobj(), Glib::unwrap(constraint));
4122 }
4123
add_constraint(const Glib::ustring & name,const Glib::RefPtr<Constraint> & constraint)4124 void Actor::add_constraint(const Glib::ustring& name, const Glib::RefPtr<Constraint>& constraint)
4125 {
4126 clutter_actor_add_constraint_with_name(gobj(), name.c_str(), Glib::unwrap(constraint));
4127 }
4128
remove_constraint(const Glib::RefPtr<Constraint> & constraint)4129 void Actor::remove_constraint(const Glib::RefPtr<Constraint>& constraint)
4130 {
4131 clutter_actor_remove_constraint(gobj(), Glib::unwrap(constraint));
4132 }
4133
remove_constraint(const Glib::ustring & name)4134 void Actor::remove_constraint(const Glib::ustring& name)
4135 {
4136 clutter_actor_remove_constraint_by_name(gobj(), name.c_str());
4137 }
4138
has_constraints() const4139 bool Actor::has_constraints() const
4140 {
4141 return clutter_actor_has_constraints(const_cast<ClutterActor*>(gobj()));
4142 }
4143
get_constraints()4144 std::vector< Glib::RefPtr<Clutter::Constraint> > Actor::get_constraints()
4145 {
4146 return Glib::ListHandler< Glib::RefPtr<Clutter::Constraint> >::list_to_vector(clutter_actor_get_constraints(gobj()), Glib::OWNERSHIP_SHALLOW);
4147 }
4148
get_constraints() const4149 std::vector< Glib::RefPtr<const Clutter::Constraint> > Actor::get_constraints() const
4150 {
4151 return Glib::ListHandler< Glib::RefPtr<const Clutter::Constraint> >::list_to_vector(clutter_actor_get_constraints(const_cast<ClutterActor*>(gobj())), Glib::OWNERSHIP_SHALLOW);
4152 }
4153
get_constraint(const Glib::ustring & name) const4154 Glib::RefPtr<const Constraint> Actor::get_constraint(const Glib::ustring& name) const
4155 {
4156 return const_cast<Actor*>(this)->get_constraint(name);
4157 }
4158
get_constraint(const Glib::ustring & name)4159 Glib::RefPtr<Constraint> Actor::get_constraint(const Glib::ustring& name)
4160 {
4161 Glib::RefPtr<Constraint> retvalue = Glib::wrap(clutter_actor_get_constraint(gobj(), name.c_str()));
4162 if(retvalue)
4163 retvalue->reference(); //The function does not do a ref for us.
4164 return retvalue;
4165 }
4166
clear_constraints()4167 void Actor::clear_constraints()
4168 {
4169 clutter_actor_clear_constraints(gobj());
4170 }
4171
4172 #ifndef CLUTTERMM_DISABLE_DEPRECATED
4173
set_shader_param_value(const Glib::ustring & param,const Glib::ValueBase & value)4174 void Actor::set_shader_param_value(const Glib::ustring& param, const Glib::ValueBase& value)
4175 {
4176 clutter_actor_set_shader_param(gobj(), param.c_str(), (value).gobj());
4177 }
4178
4179 #endif // CLUTTERMM_DISABLE_DEPRECATED
4180
4181
signal_button_press_event()4182 Glib::SignalProxy1< bool,ButtonEvent* > Actor::signal_button_press_event()
4183 {
4184 return Glib::SignalProxy1< bool,ButtonEvent* >(this, &Actor_signal_button_press_event_info);
4185 }
4186
4187
signal_button_release_event()4188 Glib::SignalProxy1< bool,ButtonEvent* > Actor::signal_button_release_event()
4189 {
4190 return Glib::SignalProxy1< bool,ButtonEvent* >(this, &Actor_signal_button_release_event_info);
4191 }
4192
4193
signal_motion_event()4194 Glib::SignalProxy1< bool,MotionEvent* > Actor::signal_motion_event()
4195 {
4196 return Glib::SignalProxy1< bool,MotionEvent* >(this, &Actor_signal_motion_event_info);
4197 }
4198
4199
signal_leave_event()4200 Glib::SignalProxy1< bool,CrossingEvent* > Actor::signal_leave_event()
4201 {
4202 return Glib::SignalProxy1< bool,CrossingEvent* >(this, &Actor_signal_leave_event_info);
4203 }
4204
4205
signal_show()4206 Glib::SignalProxy0< void > Actor::signal_show()
4207 {
4208 return Glib::SignalProxy0< void >(this, &Actor_signal_show_info);
4209 }
4210
4211
signal_hide()4212 Glib::SignalProxy0< void > Actor::signal_hide()
4213 {
4214 return Glib::SignalProxy0< void >(this, &Actor_signal_hide_info);
4215 }
4216
4217
signal_key_release_event()4218 Glib::SignalProxy1< bool,KeyEvent* > Actor::signal_key_release_event()
4219 {
4220 return Glib::SignalProxy1< bool,KeyEvent* >(this, &Actor_signal_key_release_event_info);
4221 }
4222
4223
signal_enter_event()4224 Glib::SignalProxy1< bool,CrossingEvent* > Actor::signal_enter_event()
4225 {
4226 return Glib::SignalProxy1< bool,CrossingEvent* >(this, &Actor_signal_enter_event_info);
4227 }
4228
4229
signal_event()4230 Glib::SignalProxy1< bool,Event* > Actor::signal_event()
4231 {
4232 return Glib::SignalProxy1< bool,Event* >(this, &Actor_signal_event_info);
4233 }
4234
4235
signal_key_focus_out()4236 Glib::SignalProxy0< void > Actor::signal_key_focus_out()
4237 {
4238 return Glib::SignalProxy0< void >(this, &Actor_signal_key_focus_out_info);
4239 }
4240
4241
signal_key_focus_in()4242 Glib::SignalProxy0< void > Actor::signal_key_focus_in()
4243 {
4244 return Glib::SignalProxy0< void >(this, &Actor_signal_key_focus_in_info);
4245 }
4246
4247
signal_parent_set()4248 Glib::SignalProxy1< void,const Glib::RefPtr<Actor>& > Actor::signal_parent_set()
4249 {
4250 return Glib::SignalProxy1< void,const Glib::RefPtr<Actor>& >(this, &Actor_signal_parent_set_info);
4251 }
4252
4253
signal_scroll_event()4254 Glib::SignalProxy1< bool,ScrollEvent* > Actor::signal_scroll_event()
4255 {
4256 return Glib::SignalProxy1< bool,ScrollEvent* >(this, &Actor_signal_scroll_event_info);
4257 }
4258
4259
signal_key_press_event()4260 Glib::SignalProxy1< bool,KeyEvent* > Actor::signal_key_press_event()
4261 {
4262 return Glib::SignalProxy1< bool,KeyEvent* >(this, &Actor_signal_key_press_event_info);
4263 }
4264
4265
signal_captured_event()4266 Glib::SignalProxy1< bool,Event* > Actor::signal_captured_event()
4267 {
4268 return Glib::SignalProxy1< bool,Event* >(this, &Actor_signal_captured_event_info);
4269 }
4270
4271
signal_queue_redaw()4272 Glib::SignalProxy1< void,const Glib::RefPtr<Actor>& > Actor::signal_queue_redaw()
4273 {
4274 return Glib::SignalProxy1< void,const Glib::RefPtr<Actor>& >(this, &Actor_signal_queue_redaw_info);
4275 }
4276
4277
signal_queue_relayout()4278 Glib::SignalProxy0< void > Actor::signal_queue_relayout()
4279 {
4280 return Glib::SignalProxy0< void >(this, &Actor_signal_queue_relayout_info);
4281 }
4282
4283
signal_realize()4284 Glib::SignalProxy0< void > Actor::signal_realize()
4285 {
4286 return Glib::SignalProxy0< void >(this, &Actor_signal_realize_info);
4287 }
4288
4289
signal_unrealize()4290 Glib::SignalProxy0< void > Actor::signal_unrealize()
4291 {
4292 return Glib::SignalProxy0< void >(this, &Actor_signal_unrealize_info);
4293 }
4294
4295
signal_pick()4296 Glib::SignalProxy1< void,const Color& > Actor::signal_pick()
4297 {
4298 return Glib::SignalProxy1< void,const Color& >(this, &Actor_signal_pick_info);
4299 }
4300
4301
signal_allocation_changed()4302 Glib::SignalProxy2< void,const ActorBox&,AllocationFlags > Actor::signal_allocation_changed()
4303 {
4304 return Glib::SignalProxy2< void,const ActorBox&,AllocationFlags >(this, &Actor_signal_allocation_changed_info);
4305 }
4306
4307
signal_touch_event()4308 Glib::SignalProxy1< bool,ClutterTouchEvent* > Actor::signal_touch_event()
4309 {
4310 return Glib::SignalProxy1< bool,ClutterTouchEvent* >(this, &Actor_signal_touch_event_info);
4311 }
4312
4313
signal_transitions_completed()4314 Glib::SignalProxy0< void > Actor::signal_transitions_completed()
4315 {
4316 return Glib::SignalProxy0< void >(this, &Actor_signal_transitions_completed_info);
4317 }
4318
4319
signal_transition_stopped()4320 Glib::SignalProxy2< void,const Glib::ustring&,bool > Actor::signal_transition_stopped()
4321 {
4322 return Glib::SignalProxy2< void,const Glib::ustring&,bool >(this, &Actor_signal_transition_stopped_info);
4323 }
4324
4325
4326 #ifdef GLIBMM_PROPERTIES_ENABLED
property_allocation() const4327 Glib::PropertyProxy_ReadOnly< ActorBox > Actor::property_allocation() const
4328 {
4329 return Glib::PropertyProxy_ReadOnly< ActorBox >(this, "allocation");
4330 }
4331 #endif //GLIBMM_PROPERTIES_ENABLED
4332
4333 #ifdef GLIBMM_PROPERTIES_ENABLED
property_anchor_x()4334 Glib::PropertyProxy< float > Actor::property_anchor_x()
4335 {
4336 return Glib::PropertyProxy< float >(this, "anchor-x");
4337 }
4338 #endif //GLIBMM_PROPERTIES_ENABLED
4339
4340 #ifdef GLIBMM_PROPERTIES_ENABLED
property_anchor_x() const4341 Glib::PropertyProxy_ReadOnly< float > Actor::property_anchor_x() const
4342 {
4343 return Glib::PropertyProxy_ReadOnly< float >(this, "anchor-x");
4344 }
4345 #endif //GLIBMM_PROPERTIES_ENABLED
4346
4347 #ifdef GLIBMM_PROPERTIES_ENABLED
property_anchor_y()4348 Glib::PropertyProxy< float > Actor::property_anchor_y()
4349 {
4350 return Glib::PropertyProxy< float >(this, "anchor-y");
4351 }
4352 #endif //GLIBMM_PROPERTIES_ENABLED
4353
4354 #ifdef GLIBMM_PROPERTIES_ENABLED
property_anchor_y() const4355 Glib::PropertyProxy_ReadOnly< float > Actor::property_anchor_y() const
4356 {
4357 return Glib::PropertyProxy_ReadOnly< float >(this, "anchor-y");
4358 }
4359 #endif //GLIBMM_PROPERTIES_ENABLED
4360
4361 #ifdef GLIBMM_PROPERTIES_ENABLED
property_anchor_gravity()4362 Glib::PropertyProxy< Gravity > Actor::property_anchor_gravity()
4363 {
4364 return Glib::PropertyProxy< Gravity >(this, "anchor-gravity");
4365 }
4366 #endif //GLIBMM_PROPERTIES_ENABLED
4367
4368 #ifdef GLIBMM_PROPERTIES_ENABLED
property_anchor_gravity() const4369 Glib::PropertyProxy_ReadOnly< Gravity > Actor::property_anchor_gravity() const
4370 {
4371 return Glib::PropertyProxy_ReadOnly< Gravity >(this, "anchor-gravity");
4372 }
4373 #endif //GLIBMM_PROPERTIES_ENABLED
4374
4375 #ifdef GLIBMM_PROPERTIES_ENABLED
property_background_color()4376 Glib::PropertyProxy< Color > Actor::property_background_color()
4377 {
4378 return Glib::PropertyProxy< Color >(this, "background-color");
4379 }
4380 #endif //GLIBMM_PROPERTIES_ENABLED
4381
4382 #ifdef GLIBMM_PROPERTIES_ENABLED
property_background_color() const4383 Glib::PropertyProxy_ReadOnly< Color > Actor::property_background_color() const
4384 {
4385 return Glib::PropertyProxy_ReadOnly< Color >(this, "background-color");
4386 }
4387 #endif //GLIBMM_PROPERTIES_ENABLED
4388
4389 #ifdef GLIBMM_PROPERTIES_ENABLED
property_background_color_set() const4390 Glib::PropertyProxy_ReadOnly< bool > Actor::property_background_color_set() const
4391 {
4392 return Glib::PropertyProxy_ReadOnly< bool >(this, "background-color-set");
4393 }
4394 #endif //GLIBMM_PROPERTIES_ENABLED
4395
4396 #ifdef GLIBMM_PROPERTIES_ENABLED
property_child_transform()4397 Glib::PropertyProxy< Matrix > Actor::property_child_transform()
4398 {
4399 return Glib::PropertyProxy< Matrix >(this, "child-transform");
4400 }
4401 #endif //GLIBMM_PROPERTIES_ENABLED
4402
4403 #ifdef GLIBMM_PROPERTIES_ENABLED
property_child_transform() const4404 Glib::PropertyProxy_ReadOnly< Matrix > Actor::property_child_transform() const
4405 {
4406 return Glib::PropertyProxy_ReadOnly< Matrix >(this, "child-transform");
4407 }
4408 #endif //GLIBMM_PROPERTIES_ENABLED
4409
4410 #ifdef GLIBMM_PROPERTIES_ENABLED
property_child_transform_set() const4411 Glib::PropertyProxy_ReadOnly< bool > Actor::property_child_transform_set() const
4412 {
4413 return Glib::PropertyProxy_ReadOnly< bool >(this, "child-transform-set");
4414 }
4415 #endif //GLIBMM_PROPERTIES_ENABLED
4416
4417 #ifdef GLIBMM_PROPERTIES_ENABLED
property_clip()4418 Glib::PropertyProxy< Geometry > Actor::property_clip()
4419 {
4420 return Glib::PropertyProxy< Geometry >(this, "clip");
4421 }
4422 #endif //GLIBMM_PROPERTIES_ENABLED
4423
4424 #ifdef GLIBMM_PROPERTIES_ENABLED
property_clip() const4425 Glib::PropertyProxy_ReadOnly< Geometry > Actor::property_clip() const
4426 {
4427 return Glib::PropertyProxy_ReadOnly< Geometry >(this, "clip");
4428 }
4429 #endif //GLIBMM_PROPERTIES_ENABLED
4430
4431 #ifdef GLIBMM_PROPERTIES_ENABLED
property_clip_rect()4432 Glib::PropertyProxy< Rect > Actor::property_clip_rect()
4433 {
4434 return Glib::PropertyProxy< Rect >(this, "clip-rect");
4435 }
4436 #endif //GLIBMM_PROPERTIES_ENABLED
4437
4438 #ifdef GLIBMM_PROPERTIES_ENABLED
property_clip_rect() const4439 Glib::PropertyProxy_ReadOnly< Rect > Actor::property_clip_rect() const
4440 {
4441 return Glib::PropertyProxy_ReadOnly< Rect >(this, "clip-rect");
4442 }
4443 #endif //GLIBMM_PROPERTIES_ENABLED
4444
4445 #ifdef GLIBMM_PROPERTIES_ENABLED
property_clip_to_allocation()4446 Glib::PropertyProxy< bool > Actor::property_clip_to_allocation()
4447 {
4448 return Glib::PropertyProxy< bool >(this, "clip-to-allocation");
4449 }
4450 #endif //GLIBMM_PROPERTIES_ENABLED
4451
4452 #ifdef GLIBMM_PROPERTIES_ENABLED
property_clip_to_allocation() const4453 Glib::PropertyProxy_ReadOnly< bool > Actor::property_clip_to_allocation() const
4454 {
4455 return Glib::PropertyProxy_ReadOnly< bool >(this, "clip-to-allocation");
4456 }
4457 #endif //GLIBMM_PROPERTIES_ENABLED
4458
4459 #ifdef GLIBMM_PROPERTIES_ENABLED
property_content()4460 Glib::PropertyProxy< Content > Actor::property_content()
4461 {
4462 return Glib::PropertyProxy< Content >(this, "content");
4463 }
4464 #endif //GLIBMM_PROPERTIES_ENABLED
4465
4466 #ifdef GLIBMM_PROPERTIES_ENABLED
property_content() const4467 Glib::PropertyProxy_ReadOnly< Content > Actor::property_content() const
4468 {
4469 return Glib::PropertyProxy_ReadOnly< Content >(this, "content");
4470 }
4471 #endif //GLIBMM_PROPERTIES_ENABLED
4472
4473 #ifdef GLIBMM_PROPERTIES_ENABLED
property_content_box() const4474 Glib::PropertyProxy_ReadOnly< ActorBox > Actor::property_content_box() const
4475 {
4476 return Glib::PropertyProxy_ReadOnly< ActorBox >(this, "content-box");
4477 }
4478 #endif //GLIBMM_PROPERTIES_ENABLED
4479
4480 #ifdef GLIBMM_PROPERTIES_ENABLED
property_content_gravity()4481 Glib::PropertyProxy< ContentGravity > Actor::property_content_gravity()
4482 {
4483 return Glib::PropertyProxy< ContentGravity >(this, "content-gravity");
4484 }
4485 #endif //GLIBMM_PROPERTIES_ENABLED
4486
4487 #ifdef GLIBMM_PROPERTIES_ENABLED
property_content_gravity() const4488 Glib::PropertyProxy_ReadOnly< ContentGravity > Actor::property_content_gravity() const
4489 {
4490 return Glib::PropertyProxy_ReadOnly< ContentGravity >(this, "content-gravity");
4491 }
4492 #endif //GLIBMM_PROPERTIES_ENABLED
4493
4494 #ifdef GLIBMM_PROPERTIES_ENABLED
property_content_repeat()4495 Glib::PropertyProxy< ContentRepeat > Actor::property_content_repeat()
4496 {
4497 return Glib::PropertyProxy< ContentRepeat >(this, "content-repeat");
4498 }
4499 #endif //GLIBMM_PROPERTIES_ENABLED
4500
4501 #ifdef GLIBMM_PROPERTIES_ENABLED
property_content_repeat() const4502 Glib::PropertyProxy_ReadOnly< ContentRepeat > Actor::property_content_repeat() const
4503 {
4504 return Glib::PropertyProxy_ReadOnly< ContentRepeat >(this, "content-repeat");
4505 }
4506 #endif //GLIBMM_PROPERTIES_ENABLED
4507
4508 #ifdef GLIBMM_PROPERTIES_ENABLED
property_depth()4509 Glib::PropertyProxy< float > Actor::property_depth()
4510 {
4511 return Glib::PropertyProxy< float >(this, "depth");
4512 }
4513 #endif //GLIBMM_PROPERTIES_ENABLED
4514
4515 #ifdef GLIBMM_PROPERTIES_ENABLED
property_depth() const4516 Glib::PropertyProxy_ReadOnly< float > Actor::property_depth() const
4517 {
4518 return Glib::PropertyProxy_ReadOnly< float >(this, "depth");
4519 }
4520 #endif //GLIBMM_PROPERTIES_ENABLED
4521
4522 #ifdef GLIBMM_PROPERTIES_ENABLED
property_effect()4523 Glib::PropertyProxy_WriteOnly< Glib::RefPtr<Effect> > Actor::property_effect()
4524 {
4525 return Glib::PropertyProxy_WriteOnly< Glib::RefPtr<Effect> >(this, "effect");
4526 }
4527 #endif //GLIBMM_PROPERTIES_ENABLED
4528
4529 #ifdef GLIBMM_PROPERTIES_ENABLED
property_first_child() const4530 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Actor> > Actor::property_first_child() const
4531 {
4532 return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Actor> >(this, "first-child");
4533 }
4534 #endif //GLIBMM_PROPERTIES_ENABLED
4535
4536 #ifdef GLIBMM_PROPERTIES_ENABLED
property_fixed_position_set()4537 Glib::PropertyProxy< bool > Actor::property_fixed_position_set()
4538 {
4539 return Glib::PropertyProxy< bool >(this, "fixed-position-set");
4540 }
4541 #endif //GLIBMM_PROPERTIES_ENABLED
4542
4543 #ifdef GLIBMM_PROPERTIES_ENABLED
property_fixed_position_set() const4544 Glib::PropertyProxy_ReadOnly< bool > Actor::property_fixed_position_set() const
4545 {
4546 return Glib::PropertyProxy_ReadOnly< bool >(this, "fixed-position-set");
4547 }
4548 #endif //GLIBMM_PROPERTIES_ENABLED
4549
4550 #ifdef GLIBMM_PROPERTIES_ENABLED
property_fixed_x()4551 Glib::PropertyProxy< float > Actor::property_fixed_x()
4552 {
4553 return Glib::PropertyProxy< float >(this, "fixed-x");
4554 }
4555 #endif //GLIBMM_PROPERTIES_ENABLED
4556
4557 #ifdef GLIBMM_PROPERTIES_ENABLED
property_fixed_x() const4558 Glib::PropertyProxy_ReadOnly< float > Actor::property_fixed_x() const
4559 {
4560 return Glib::PropertyProxy_ReadOnly< float >(this, "fixed-x");
4561 }
4562 #endif //GLIBMM_PROPERTIES_ENABLED
4563
4564 #ifdef GLIBMM_PROPERTIES_ENABLED
property_fixed_y()4565 Glib::PropertyProxy< float > Actor::property_fixed_y()
4566 {
4567 return Glib::PropertyProxy< float >(this, "fixed-y");
4568 }
4569 #endif //GLIBMM_PROPERTIES_ENABLED
4570
4571 #ifdef GLIBMM_PROPERTIES_ENABLED
property_fixed_y() const4572 Glib::PropertyProxy_ReadOnly< float > Actor::property_fixed_y() const
4573 {
4574 return Glib::PropertyProxy_ReadOnly< float >(this, "fixed-y");
4575 }
4576 #endif //GLIBMM_PROPERTIES_ENABLED
4577
4578 #ifdef GLIBMM_PROPERTIES_ENABLED
property_has_clip() const4579 Glib::PropertyProxy_ReadOnly< bool > Actor::property_has_clip() const
4580 {
4581 return Glib::PropertyProxy_ReadOnly< bool >(this, "has-clip");
4582 }
4583 #endif //GLIBMM_PROPERTIES_ENABLED
4584
4585 #ifdef GLIBMM_PROPERTIES_ENABLED
property_has_pointer() const4586 Glib::PropertyProxy_ReadOnly< bool > Actor::property_has_pointer() const
4587 {
4588 return Glib::PropertyProxy_ReadOnly< bool >(this, "has-pointer");
4589 }
4590 #endif //GLIBMM_PROPERTIES_ENABLED
4591
4592 #ifdef GLIBMM_PROPERTIES_ENABLED
property_height()4593 Glib::PropertyProxy< float > Actor::property_height()
4594 {
4595 return Glib::PropertyProxy< float >(this, "height");
4596 }
4597 #endif //GLIBMM_PROPERTIES_ENABLED
4598
4599 #ifdef GLIBMM_PROPERTIES_ENABLED
property_height() const4600 Glib::PropertyProxy_ReadOnly< float > Actor::property_height() const
4601 {
4602 return Glib::PropertyProxy_ReadOnly< float >(this, "height");
4603 }
4604 #endif //GLIBMM_PROPERTIES_ENABLED
4605
4606 #ifdef GLIBMM_PROPERTIES_ENABLED
property_last_child() const4607 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Actor> > Actor::property_last_child() const
4608 {
4609 return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Actor> >(this, "last-child");
4610 }
4611 #endif //GLIBMM_PROPERTIES_ENABLED
4612
4613 #ifdef GLIBMM_PROPERTIES_ENABLED
property_layout_manager()4614 Glib::PropertyProxy< Glib::RefPtr<LayoutManager> > Actor::property_layout_manager()
4615 {
4616 return Glib::PropertyProxy< Glib::RefPtr<LayoutManager> >(this, "layout-manager");
4617 }
4618 #endif //GLIBMM_PROPERTIES_ENABLED
4619
4620 #ifdef GLIBMM_PROPERTIES_ENABLED
property_layout_manager() const4621 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<LayoutManager> > Actor::property_layout_manager() const
4622 {
4623 return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<LayoutManager> >(this, "layout-manager");
4624 }
4625 #endif //GLIBMM_PROPERTIES_ENABLED
4626
4627 #ifdef GLIBMM_PROPERTIES_ENABLED
property_magnification_filter()4628 Glib::PropertyProxy< ScalingFilter > Actor::property_magnification_filter()
4629 {
4630 return Glib::PropertyProxy< ScalingFilter >(this, "magnification-filter");
4631 }
4632 #endif //GLIBMM_PROPERTIES_ENABLED
4633
4634 #ifdef GLIBMM_PROPERTIES_ENABLED
property_magnification_filter() const4635 Glib::PropertyProxy_ReadOnly< ScalingFilter > Actor::property_magnification_filter() const
4636 {
4637 return Glib::PropertyProxy_ReadOnly< ScalingFilter >(this, "magnification-filter");
4638 }
4639 #endif //GLIBMM_PROPERTIES_ENABLED
4640
4641 #ifdef GLIBMM_PROPERTIES_ENABLED
property_mapped() const4642 Glib::PropertyProxy_ReadOnly< bool > Actor::property_mapped() const
4643 {
4644 return Glib::PropertyProxy_ReadOnly< bool >(this, "mapped");
4645 }
4646 #endif //GLIBMM_PROPERTIES_ENABLED
4647
4648 #ifdef GLIBMM_PROPERTIES_ENABLED
property_margin_bottom()4649 Glib::PropertyProxy< float > Actor::property_margin_bottom()
4650 {
4651 return Glib::PropertyProxy< float >(this, "margin-bottom");
4652 }
4653 #endif //GLIBMM_PROPERTIES_ENABLED
4654
4655 #ifdef GLIBMM_PROPERTIES_ENABLED
property_margin_bottom() const4656 Glib::PropertyProxy_ReadOnly< float > Actor::property_margin_bottom() const
4657 {
4658 return Glib::PropertyProxy_ReadOnly< float >(this, "margin-bottom");
4659 }
4660 #endif //GLIBMM_PROPERTIES_ENABLED
4661
4662 #ifdef GLIBMM_PROPERTIES_ENABLED
property_margin_left()4663 Glib::PropertyProxy< float > Actor::property_margin_left()
4664 {
4665 return Glib::PropertyProxy< float >(this, "margin-left");
4666 }
4667 #endif //GLIBMM_PROPERTIES_ENABLED
4668
4669 #ifdef GLIBMM_PROPERTIES_ENABLED
property_margin_left() const4670 Glib::PropertyProxy_ReadOnly< float > Actor::property_margin_left() const
4671 {
4672 return Glib::PropertyProxy_ReadOnly< float >(this, "margin-left");
4673 }
4674 #endif //GLIBMM_PROPERTIES_ENABLED
4675
4676 #ifdef GLIBMM_PROPERTIES_ENABLED
property_margin_right()4677 Glib::PropertyProxy< float > Actor::property_margin_right()
4678 {
4679 return Glib::PropertyProxy< float >(this, "margin-right");
4680 }
4681 #endif //GLIBMM_PROPERTIES_ENABLED
4682
4683 #ifdef GLIBMM_PROPERTIES_ENABLED
property_margin_right() const4684 Glib::PropertyProxy_ReadOnly< float > Actor::property_margin_right() const
4685 {
4686 return Glib::PropertyProxy_ReadOnly< float >(this, "margin-right");
4687 }
4688 #endif //GLIBMM_PROPERTIES_ENABLED
4689
4690 #ifdef GLIBMM_PROPERTIES_ENABLED
property_margin_top()4691 Glib::PropertyProxy< float > Actor::property_margin_top()
4692 {
4693 return Glib::PropertyProxy< float >(this, "margin-top");
4694 }
4695 #endif //GLIBMM_PROPERTIES_ENABLED
4696
4697 #ifdef GLIBMM_PROPERTIES_ENABLED
property_margin_top() const4698 Glib::PropertyProxy_ReadOnly< float > Actor::property_margin_top() const
4699 {
4700 return Glib::PropertyProxy_ReadOnly< float >(this, "margin-top");
4701 }
4702 #endif //GLIBMM_PROPERTIES_ENABLED
4703
4704 #ifdef GLIBMM_PROPERTIES_ENABLED
property_minification_filter()4705 Glib::PropertyProxy< ScalingFilter > Actor::property_minification_filter()
4706 {
4707 return Glib::PropertyProxy< ScalingFilter >(this, "minification-filter");
4708 }
4709 #endif //GLIBMM_PROPERTIES_ENABLED
4710
4711 #ifdef GLIBMM_PROPERTIES_ENABLED
property_minification_filter() const4712 Glib::PropertyProxy_ReadOnly< ScalingFilter > Actor::property_minification_filter() const
4713 {
4714 return Glib::PropertyProxy_ReadOnly< ScalingFilter >(this, "minification-filter");
4715 }
4716 #endif //GLIBMM_PROPERTIES_ENABLED
4717
4718 #ifdef GLIBMM_PROPERTIES_ENABLED
property_min_height()4719 Glib::PropertyProxy< float > Actor::property_min_height()
4720 {
4721 return Glib::PropertyProxy< float >(this, "min-height");
4722 }
4723 #endif //GLIBMM_PROPERTIES_ENABLED
4724
4725 #ifdef GLIBMM_PROPERTIES_ENABLED
property_min_height() const4726 Glib::PropertyProxy_ReadOnly< float > Actor::property_min_height() const
4727 {
4728 return Glib::PropertyProxy_ReadOnly< float >(this, "min-height");
4729 }
4730 #endif //GLIBMM_PROPERTIES_ENABLED
4731
4732 #ifdef GLIBMM_PROPERTIES_ENABLED
property_min_height_set()4733 Glib::PropertyProxy< bool > Actor::property_min_height_set()
4734 {
4735 return Glib::PropertyProxy< bool >(this, "min-height-set");
4736 }
4737 #endif //GLIBMM_PROPERTIES_ENABLED
4738
4739 #ifdef GLIBMM_PROPERTIES_ENABLED
property_min_height_set() const4740 Glib::PropertyProxy_ReadOnly< bool > Actor::property_min_height_set() const
4741 {
4742 return Glib::PropertyProxy_ReadOnly< bool >(this, "min-height-set");
4743 }
4744 #endif //GLIBMM_PROPERTIES_ENABLED
4745
4746 #ifdef GLIBMM_PROPERTIES_ENABLED
property_min_width()4747 Glib::PropertyProxy< float > Actor::property_min_width()
4748 {
4749 return Glib::PropertyProxy< float >(this, "min-width");
4750 }
4751 #endif //GLIBMM_PROPERTIES_ENABLED
4752
4753 #ifdef GLIBMM_PROPERTIES_ENABLED
property_min_width() const4754 Glib::PropertyProxy_ReadOnly< float > Actor::property_min_width() const
4755 {
4756 return Glib::PropertyProxy_ReadOnly< float >(this, "min-width");
4757 }
4758 #endif //GLIBMM_PROPERTIES_ENABLED
4759
4760 #ifdef GLIBMM_PROPERTIES_ENABLED
property_min_width_set()4761 Glib::PropertyProxy< bool > Actor::property_min_width_set()
4762 {
4763 return Glib::PropertyProxy< bool >(this, "min-width-set");
4764 }
4765 #endif //GLIBMM_PROPERTIES_ENABLED
4766
4767 #ifdef GLIBMM_PROPERTIES_ENABLED
property_min_width_set() const4768 Glib::PropertyProxy_ReadOnly< bool > Actor::property_min_width_set() const
4769 {
4770 return Glib::PropertyProxy_ReadOnly< bool >(this, "min-width-set");
4771 }
4772 #endif //GLIBMM_PROPERTIES_ENABLED
4773
4774 #ifdef GLIBMM_PROPERTIES_ENABLED
property_name()4775 Glib::PropertyProxy< Glib::ustring > Actor::property_name()
4776 {
4777 return Glib::PropertyProxy< Glib::ustring >(this, "name");
4778 }
4779 #endif //GLIBMM_PROPERTIES_ENABLED
4780
4781 #ifdef GLIBMM_PROPERTIES_ENABLED
property_name() const4782 Glib::PropertyProxy_ReadOnly< Glib::ustring > Actor::property_name() const
4783 {
4784 return Glib::PropertyProxy_ReadOnly< Glib::ustring >(this, "name");
4785 }
4786 #endif //GLIBMM_PROPERTIES_ENABLED
4787
4788 #ifdef GLIBMM_PROPERTIES_ENABLED
property_natural_height()4789 Glib::PropertyProxy< float > Actor::property_natural_height()
4790 {
4791 return Glib::PropertyProxy< float >(this, "natural-height");
4792 }
4793 #endif //GLIBMM_PROPERTIES_ENABLED
4794
4795 #ifdef GLIBMM_PROPERTIES_ENABLED
property_natural_height() const4796 Glib::PropertyProxy_ReadOnly< float > Actor::property_natural_height() const
4797 {
4798 return Glib::PropertyProxy_ReadOnly< float >(this, "natural-height");
4799 }
4800 #endif //GLIBMM_PROPERTIES_ENABLED
4801
4802 #ifdef GLIBMM_PROPERTIES_ENABLED
property_natural_height_set()4803 Glib::PropertyProxy< bool > Actor::property_natural_height_set()
4804 {
4805 return Glib::PropertyProxy< bool >(this, "natural-height-set");
4806 }
4807 #endif //GLIBMM_PROPERTIES_ENABLED
4808
4809 #ifdef GLIBMM_PROPERTIES_ENABLED
property_natural_height_set() const4810 Glib::PropertyProxy_ReadOnly< bool > Actor::property_natural_height_set() const
4811 {
4812 return Glib::PropertyProxy_ReadOnly< bool >(this, "natural-height-set");
4813 }
4814 #endif //GLIBMM_PROPERTIES_ENABLED
4815
4816 #ifdef GLIBMM_PROPERTIES_ENABLED
property_natural_width()4817 Glib::PropertyProxy< float > Actor::property_natural_width()
4818 {
4819 return Glib::PropertyProxy< float >(this, "natural-width");
4820 }
4821 #endif //GLIBMM_PROPERTIES_ENABLED
4822
4823 #ifdef GLIBMM_PROPERTIES_ENABLED
property_natural_width() const4824 Glib::PropertyProxy_ReadOnly< float > Actor::property_natural_width() const
4825 {
4826 return Glib::PropertyProxy_ReadOnly< float >(this, "natural-width");
4827 }
4828 #endif //GLIBMM_PROPERTIES_ENABLED
4829
4830 #ifdef GLIBMM_PROPERTIES_ENABLED
property_natural_width_set()4831 Glib::PropertyProxy< bool > Actor::property_natural_width_set()
4832 {
4833 return Glib::PropertyProxy< bool >(this, "natural-width-set");
4834 }
4835 #endif //GLIBMM_PROPERTIES_ENABLED
4836
4837 #ifdef GLIBMM_PROPERTIES_ENABLED
property_natural_width_set() const4838 Glib::PropertyProxy_ReadOnly< bool > Actor::property_natural_width_set() const
4839 {
4840 return Glib::PropertyProxy_ReadOnly< bool >(this, "natural-width-set");
4841 }
4842 #endif //GLIBMM_PROPERTIES_ENABLED
4843
4844 #ifdef GLIBMM_PROPERTIES_ENABLED
property_opacity()4845 Glib::PropertyProxy< guint8 > Actor::property_opacity()
4846 {
4847 return Glib::PropertyProxy< guint8 >(this, "opacity");
4848 }
4849 #endif //GLIBMM_PROPERTIES_ENABLED
4850
4851 #ifdef GLIBMM_PROPERTIES_ENABLED
property_opacity() const4852 Glib::PropertyProxy_ReadOnly< guint8 > Actor::property_opacity() const
4853 {
4854 return Glib::PropertyProxy_ReadOnly< guint8 >(this, "opacity");
4855 }
4856 #endif //GLIBMM_PROPERTIES_ENABLED
4857
4858 #ifdef GLIBMM_PROPERTIES_ENABLED
property_offscreen_redirect()4859 Glib::PropertyProxy< OffscreenRedirect > Actor::property_offscreen_redirect()
4860 {
4861 return Glib::PropertyProxy< OffscreenRedirect >(this, "offscreen-redirect");
4862 }
4863 #endif //GLIBMM_PROPERTIES_ENABLED
4864
4865 #ifdef GLIBMM_PROPERTIES_ENABLED
property_offscreen_redirect() const4866 Glib::PropertyProxy_ReadOnly< OffscreenRedirect > Actor::property_offscreen_redirect() const
4867 {
4868 return Glib::PropertyProxy_ReadOnly< OffscreenRedirect >(this, "offscreen-redirect");
4869 }
4870 #endif //GLIBMM_PROPERTIES_ENABLED
4871
4872 #ifdef GLIBMM_PROPERTIES_ENABLED
property_pivot_point()4873 Glib::PropertyProxy< Point > Actor::property_pivot_point()
4874 {
4875 return Glib::PropertyProxy< Point >(this, "pivot-point");
4876 }
4877 #endif //GLIBMM_PROPERTIES_ENABLED
4878
4879 #ifdef GLIBMM_PROPERTIES_ENABLED
property_pivot_point() const4880 Glib::PropertyProxy_ReadOnly< Point > Actor::property_pivot_point() const
4881 {
4882 return Glib::PropertyProxy_ReadOnly< Point >(this, "pivot-point");
4883 }
4884 #endif //GLIBMM_PROPERTIES_ENABLED
4885
4886 #ifdef GLIBMM_PROPERTIES_ENABLED
property_pivot_point_z()4887 Glib::PropertyProxy< float > Actor::property_pivot_point_z()
4888 {
4889 return Glib::PropertyProxy< float >(this, "pivot-point-z");
4890 }
4891 #endif //GLIBMM_PROPERTIES_ENABLED
4892
4893 #ifdef GLIBMM_PROPERTIES_ENABLED
property_pivot_point_z() const4894 Glib::PropertyProxy_ReadOnly< float > Actor::property_pivot_point_z() const
4895 {
4896 return Glib::PropertyProxy_ReadOnly< float >(this, "pivot-point-z");
4897 }
4898 #endif //GLIBMM_PROPERTIES_ENABLED
4899
4900 #ifdef GLIBMM_PROPERTIES_ENABLED
property_position()4901 Glib::PropertyProxy< Point > Actor::property_position()
4902 {
4903 return Glib::PropertyProxy< Point >(this, "position");
4904 }
4905 #endif //GLIBMM_PROPERTIES_ENABLED
4906
4907 #ifdef GLIBMM_PROPERTIES_ENABLED
property_position() const4908 Glib::PropertyProxy_ReadOnly< Point > Actor::property_position() const
4909 {
4910 return Glib::PropertyProxy_ReadOnly< Point >(this, "position");
4911 }
4912 #endif //GLIBMM_PROPERTIES_ENABLED
4913
4914 #ifdef GLIBMM_PROPERTIES_ENABLED
property_reactive()4915 Glib::PropertyProxy< bool > Actor::property_reactive()
4916 {
4917 return Glib::PropertyProxy< bool >(this, "reactive");
4918 }
4919 #endif //GLIBMM_PROPERTIES_ENABLED
4920
4921 #ifdef GLIBMM_PROPERTIES_ENABLED
property_reactive() const4922 Glib::PropertyProxy_ReadOnly< bool > Actor::property_reactive() const
4923 {
4924 return Glib::PropertyProxy_ReadOnly< bool >(this, "reactive");
4925 }
4926 #endif //GLIBMM_PROPERTIES_ENABLED
4927
4928 #ifdef GLIBMM_PROPERTIES_ENABLED
property_realized() const4929 Glib::PropertyProxy_ReadOnly< bool > Actor::property_realized() const
4930 {
4931 return Glib::PropertyProxy_ReadOnly< bool >(this, "realized");
4932 }
4933 #endif //GLIBMM_PROPERTIES_ENABLED
4934
4935 #ifdef GLIBMM_PROPERTIES_ENABLED
property_request_mode()4936 Glib::PropertyProxy< RequestMode > Actor::property_request_mode()
4937 {
4938 return Glib::PropertyProxy< RequestMode >(this, "request-mode");
4939 }
4940 #endif //GLIBMM_PROPERTIES_ENABLED
4941
4942 #ifdef GLIBMM_PROPERTIES_ENABLED
property_request_mode() const4943 Glib::PropertyProxy_ReadOnly< RequestMode > Actor::property_request_mode() const
4944 {
4945 return Glib::PropertyProxy_ReadOnly< RequestMode >(this, "request-mode");
4946 }
4947 #endif //GLIBMM_PROPERTIES_ENABLED
4948
4949 #ifdef GLIBMM_PROPERTIES_ENABLED
property_rotation_angle_x()4950 Glib::PropertyProxy< double > Actor::property_rotation_angle_x()
4951 {
4952 return Glib::PropertyProxy< double >(this, "rotation-angle-x");
4953 }
4954 #endif //GLIBMM_PROPERTIES_ENABLED
4955
4956 #ifdef GLIBMM_PROPERTIES_ENABLED
property_rotation_angle_x() const4957 Glib::PropertyProxy_ReadOnly< double > Actor::property_rotation_angle_x() const
4958 {
4959 return Glib::PropertyProxy_ReadOnly< double >(this, "rotation-angle-x");
4960 }
4961 #endif //GLIBMM_PROPERTIES_ENABLED
4962
4963 #ifdef GLIBMM_PROPERTIES_ENABLED
property_rotation_angle_y()4964 Glib::PropertyProxy< double > Actor::property_rotation_angle_y()
4965 {
4966 return Glib::PropertyProxy< double >(this, "rotation-angle-y");
4967 }
4968 #endif //GLIBMM_PROPERTIES_ENABLED
4969
4970 #ifdef GLIBMM_PROPERTIES_ENABLED
property_rotation_angle_y() const4971 Glib::PropertyProxy_ReadOnly< double > Actor::property_rotation_angle_y() const
4972 {
4973 return Glib::PropertyProxy_ReadOnly< double >(this, "rotation-angle-y");
4974 }
4975 #endif //GLIBMM_PROPERTIES_ENABLED
4976
4977 #ifdef GLIBMM_PROPERTIES_ENABLED
property_rotation_angle_z()4978 Glib::PropertyProxy< double > Actor::property_rotation_angle_z()
4979 {
4980 return Glib::PropertyProxy< double >(this, "rotation-angle-z");
4981 }
4982 #endif //GLIBMM_PROPERTIES_ENABLED
4983
4984 #ifdef GLIBMM_PROPERTIES_ENABLED
property_rotation_angle_z() const4985 Glib::PropertyProxy_ReadOnly< double > Actor::property_rotation_angle_z() const
4986 {
4987 return Glib::PropertyProxy_ReadOnly< double >(this, "rotation-angle-z");
4988 }
4989 #endif //GLIBMM_PROPERTIES_ENABLED
4990
4991 #ifdef GLIBMM_PROPERTIES_ENABLED
property_rotation_center_x()4992 Glib::PropertyProxy< Vertex > Actor::property_rotation_center_x()
4993 {
4994 return Glib::PropertyProxy< Vertex >(this, "rotation-center-x");
4995 }
4996 #endif //GLIBMM_PROPERTIES_ENABLED
4997
4998 #ifdef GLIBMM_PROPERTIES_ENABLED
property_rotation_center_x() const4999 Glib::PropertyProxy_ReadOnly< Vertex > Actor::property_rotation_center_x() const
5000 {
5001 return Glib::PropertyProxy_ReadOnly< Vertex >(this, "rotation-center-x");
5002 }
5003 #endif //GLIBMM_PROPERTIES_ENABLED
5004
5005 #ifdef GLIBMM_PROPERTIES_ENABLED
property_rotation_center_y()5006 Glib::PropertyProxy< Vertex > Actor::property_rotation_center_y()
5007 {
5008 return Glib::PropertyProxy< Vertex >(this, "rotation-center-y");
5009 }
5010 #endif //GLIBMM_PROPERTIES_ENABLED
5011
5012 #ifdef GLIBMM_PROPERTIES_ENABLED
property_rotation_center_y() const5013 Glib::PropertyProxy_ReadOnly< Vertex > Actor::property_rotation_center_y() const
5014 {
5015 return Glib::PropertyProxy_ReadOnly< Vertex >(this, "rotation-center-y");
5016 }
5017 #endif //GLIBMM_PROPERTIES_ENABLED
5018
5019 #ifdef GLIBMM_PROPERTIES_ENABLED
property_rotation_center_z()5020 Glib::PropertyProxy< Vertex > Actor::property_rotation_center_z()
5021 {
5022 return Glib::PropertyProxy< Vertex >(this, "rotation-center-z");
5023 }
5024 #endif //GLIBMM_PROPERTIES_ENABLED
5025
5026 #ifdef GLIBMM_PROPERTIES_ENABLED
property_rotation_center_z() const5027 Glib::PropertyProxy_ReadOnly< Vertex > Actor::property_rotation_center_z() const
5028 {
5029 return Glib::PropertyProxy_ReadOnly< Vertex >(this, "rotation-center-z");
5030 }
5031 #endif //GLIBMM_PROPERTIES_ENABLED
5032
5033 #ifdef GLIBMM_PROPERTIES_ENABLED
property_rotation_center_z_gravity()5034 Glib::PropertyProxy< Gravity > Actor::property_rotation_center_z_gravity()
5035 {
5036 return Glib::PropertyProxy< Gravity >(this, "rotation-center-z-gravity");
5037 }
5038 #endif //GLIBMM_PROPERTIES_ENABLED
5039
5040 #ifdef GLIBMM_PROPERTIES_ENABLED
property_rotation_center_z_gravity() const5041 Glib::PropertyProxy_ReadOnly< Gravity > Actor::property_rotation_center_z_gravity() const
5042 {
5043 return Glib::PropertyProxy_ReadOnly< Gravity >(this, "rotation-center-z-gravity");
5044 }
5045 #endif //GLIBMM_PROPERTIES_ENABLED
5046
5047 #ifdef GLIBMM_PROPERTIES_ENABLED
property_scale_x()5048 Glib::PropertyProxy< double > Actor::property_scale_x()
5049 {
5050 return Glib::PropertyProxy< double >(this, "scale-x");
5051 }
5052 #endif //GLIBMM_PROPERTIES_ENABLED
5053
5054 #ifdef GLIBMM_PROPERTIES_ENABLED
property_scale_x() const5055 Glib::PropertyProxy_ReadOnly< double > Actor::property_scale_x() const
5056 {
5057 return Glib::PropertyProxy_ReadOnly< double >(this, "scale-x");
5058 }
5059 #endif //GLIBMM_PROPERTIES_ENABLED
5060
5061 #ifdef GLIBMM_PROPERTIES_ENABLED
property_scale_y()5062 Glib::PropertyProxy< double > Actor::property_scale_y()
5063 {
5064 return Glib::PropertyProxy< double >(this, "scale-y");
5065 }
5066 #endif //GLIBMM_PROPERTIES_ENABLED
5067
5068 #ifdef GLIBMM_PROPERTIES_ENABLED
property_scale_y() const5069 Glib::PropertyProxy_ReadOnly< double > Actor::property_scale_y() const
5070 {
5071 return Glib::PropertyProxy_ReadOnly< double >(this, "scale-y");
5072 }
5073 #endif //GLIBMM_PROPERTIES_ENABLED
5074
5075 #ifdef GLIBMM_PROPERTIES_ENABLED
property_scale_z()5076 Glib::PropertyProxy< double > Actor::property_scale_z()
5077 {
5078 return Glib::PropertyProxy< double >(this, "scale-z");
5079 }
5080 #endif //GLIBMM_PROPERTIES_ENABLED
5081
5082 #ifdef GLIBMM_PROPERTIES_ENABLED
property_scale_z() const5083 Glib::PropertyProxy_ReadOnly< double > Actor::property_scale_z() const
5084 {
5085 return Glib::PropertyProxy_ReadOnly< double >(this, "scale-z");
5086 }
5087 #endif //GLIBMM_PROPERTIES_ENABLED
5088
5089 #ifdef GLIBMM_PROPERTIES_ENABLED
property_scale_center_x()5090 Glib::PropertyProxy< double > Actor::property_scale_center_x()
5091 {
5092 return Glib::PropertyProxy< double >(this, "scale-center-x");
5093 }
5094 #endif //GLIBMM_PROPERTIES_ENABLED
5095
5096 #ifdef GLIBMM_PROPERTIES_ENABLED
property_scale_center_x() const5097 Glib::PropertyProxy_ReadOnly< double > Actor::property_scale_center_x() const
5098 {
5099 return Glib::PropertyProxy_ReadOnly< double >(this, "scale-center-x");
5100 }
5101 #endif //GLIBMM_PROPERTIES_ENABLED
5102
5103 #ifdef GLIBMM_PROPERTIES_ENABLED
property_scale_center_y()5104 Glib::PropertyProxy< double > Actor::property_scale_center_y()
5105 {
5106 return Glib::PropertyProxy< double >(this, "scale-center-y");
5107 }
5108 #endif //GLIBMM_PROPERTIES_ENABLED
5109
5110 #ifdef GLIBMM_PROPERTIES_ENABLED
property_scale_center_y() const5111 Glib::PropertyProxy_ReadOnly< double > Actor::property_scale_center_y() const
5112 {
5113 return Glib::PropertyProxy_ReadOnly< double >(this, "scale-center-y");
5114 }
5115 #endif //GLIBMM_PROPERTIES_ENABLED
5116
5117 #ifdef GLIBMM_PROPERTIES_ENABLED
property_scale_gravity()5118 Glib::PropertyProxy< Gravity > Actor::property_scale_gravity()
5119 {
5120 return Glib::PropertyProxy< Gravity >(this, "scale-gravity");
5121 }
5122 #endif //GLIBMM_PROPERTIES_ENABLED
5123
5124 #ifdef GLIBMM_PROPERTIES_ENABLED
property_scale_gravity() const5125 Glib::PropertyProxy_ReadOnly< Gravity > Actor::property_scale_gravity() const
5126 {
5127 return Glib::PropertyProxy_ReadOnly< Gravity >(this, "scale-gravity");
5128 }
5129 #endif //GLIBMM_PROPERTIES_ENABLED
5130
5131 #ifdef GLIBMM_PROPERTIES_ENABLED
property_show_on_set_parent()5132 Glib::PropertyProxy< bool > Actor::property_show_on_set_parent()
5133 {
5134 return Glib::PropertyProxy< bool >(this, "show-on-set-parent");
5135 }
5136 #endif //GLIBMM_PROPERTIES_ENABLED
5137
5138 #ifdef GLIBMM_PROPERTIES_ENABLED
property_show_on_set_parent() const5139 Glib::PropertyProxy_ReadOnly< bool > Actor::property_show_on_set_parent() const
5140 {
5141 return Glib::PropertyProxy_ReadOnly< bool >(this, "show-on-set-parent");
5142 }
5143 #endif //GLIBMM_PROPERTIES_ENABLED
5144
5145 #ifdef GLIBMM_PROPERTIES_ENABLED
property_text_direction()5146 Glib::PropertyProxy< TextDirection > Actor::property_text_direction()
5147 {
5148 return Glib::PropertyProxy< TextDirection >(this, "text-direction");
5149 }
5150 #endif //GLIBMM_PROPERTIES_ENABLED
5151
5152 #ifdef GLIBMM_PROPERTIES_ENABLED
property_text_direction() const5153 Glib::PropertyProxy_ReadOnly< TextDirection > Actor::property_text_direction() const
5154 {
5155 return Glib::PropertyProxy_ReadOnly< TextDirection >(this, "text-direction");
5156 }
5157 #endif //GLIBMM_PROPERTIES_ENABLED
5158
5159 #ifdef GLIBMM_PROPERTIES_ENABLED
property_translation_x()5160 Glib::PropertyProxy< float > Actor::property_translation_x()
5161 {
5162 return Glib::PropertyProxy< float >(this, "translation-x");
5163 }
5164 #endif //GLIBMM_PROPERTIES_ENABLED
5165
5166 #ifdef GLIBMM_PROPERTIES_ENABLED
property_translation_x() const5167 Glib::PropertyProxy_ReadOnly< float > Actor::property_translation_x() const
5168 {
5169 return Glib::PropertyProxy_ReadOnly< float >(this, "translation-x");
5170 }
5171 #endif //GLIBMM_PROPERTIES_ENABLED
5172
5173 #ifdef GLIBMM_PROPERTIES_ENABLED
property_translation_y()5174 Glib::PropertyProxy< float > Actor::property_translation_y()
5175 {
5176 return Glib::PropertyProxy< float >(this, "translation-y");
5177 }
5178 #endif //GLIBMM_PROPERTIES_ENABLED
5179
5180 #ifdef GLIBMM_PROPERTIES_ENABLED
property_translation_y() const5181 Glib::PropertyProxy_ReadOnly< float > Actor::property_translation_y() const
5182 {
5183 return Glib::PropertyProxy_ReadOnly< float >(this, "translation-y");
5184 }
5185 #endif //GLIBMM_PROPERTIES_ENABLED
5186
5187 #ifdef GLIBMM_PROPERTIES_ENABLED
property_translation_z()5188 Glib::PropertyProxy< float > Actor::property_translation_z()
5189 {
5190 return Glib::PropertyProxy< float >(this, "translation-z");
5191 }
5192 #endif //GLIBMM_PROPERTIES_ENABLED
5193
5194 #ifdef GLIBMM_PROPERTIES_ENABLED
property_translation_z() const5195 Glib::PropertyProxy_ReadOnly< float > Actor::property_translation_z() const
5196 {
5197 return Glib::PropertyProxy_ReadOnly< float >(this, "translation-z");
5198 }
5199 #endif //GLIBMM_PROPERTIES_ENABLED
5200
5201 #ifdef GLIBMM_PROPERTIES_ENABLED
property_transform()5202 Glib::PropertyProxy< Matrix > Actor::property_transform()
5203 {
5204 return Glib::PropertyProxy< Matrix >(this, "transform");
5205 }
5206 #endif //GLIBMM_PROPERTIES_ENABLED
5207
5208 #ifdef GLIBMM_PROPERTIES_ENABLED
property_transform() const5209 Glib::PropertyProxy_ReadOnly< Matrix > Actor::property_transform() const
5210 {
5211 return Glib::PropertyProxy_ReadOnly< Matrix >(this, "transform");
5212 }
5213 #endif //GLIBMM_PROPERTIES_ENABLED
5214
5215 #ifdef GLIBMM_PROPERTIES_ENABLED
property_transform_set() const5216 Glib::PropertyProxy_ReadOnly< bool > Actor::property_transform_set() const
5217 {
5218 return Glib::PropertyProxy_ReadOnly< bool >(this, "transform-set");
5219 }
5220 #endif //GLIBMM_PROPERTIES_ENABLED
5221
5222 #ifdef GLIBMM_PROPERTIES_ENABLED
property_visible()5223 Glib::PropertyProxy< bool > Actor::property_visible()
5224 {
5225 return Glib::PropertyProxy< bool >(this, "visible");
5226 }
5227 #endif //GLIBMM_PROPERTIES_ENABLED
5228
5229 #ifdef GLIBMM_PROPERTIES_ENABLED
property_visible() const5230 Glib::PropertyProxy_ReadOnly< bool > Actor::property_visible() const
5231 {
5232 return Glib::PropertyProxy_ReadOnly< bool >(this, "visible");
5233 }
5234 #endif //GLIBMM_PROPERTIES_ENABLED
5235
5236 #ifdef GLIBMM_PROPERTIES_ENABLED
property_width()5237 Glib::PropertyProxy< float > Actor::property_width()
5238 {
5239 return Glib::PropertyProxy< float >(this, "width");
5240 }
5241 #endif //GLIBMM_PROPERTIES_ENABLED
5242
5243 #ifdef GLIBMM_PROPERTIES_ENABLED
property_width() const5244 Glib::PropertyProxy_ReadOnly< float > Actor::property_width() const
5245 {
5246 return Glib::PropertyProxy_ReadOnly< float >(this, "width");
5247 }
5248 #endif //GLIBMM_PROPERTIES_ENABLED
5249
5250 #ifdef GLIBMM_PROPERTIES_ENABLED
property_x()5251 Glib::PropertyProxy< float > Actor::property_x()
5252 {
5253 return Glib::PropertyProxy< float >(this, "x");
5254 }
5255 #endif //GLIBMM_PROPERTIES_ENABLED
5256
5257 #ifdef GLIBMM_PROPERTIES_ENABLED
property_x() const5258 Glib::PropertyProxy_ReadOnly< float > Actor::property_x() const
5259 {
5260 return Glib::PropertyProxy_ReadOnly< float >(this, "x");
5261 }
5262 #endif //GLIBMM_PROPERTIES_ENABLED
5263
5264 #ifdef GLIBMM_PROPERTIES_ENABLED
property_x_align()5265 Glib::PropertyProxy< ActorAlign > Actor::property_x_align()
5266 {
5267 return Glib::PropertyProxy< ActorAlign >(this, "x-align");
5268 }
5269 #endif //GLIBMM_PROPERTIES_ENABLED
5270
5271 #ifdef GLIBMM_PROPERTIES_ENABLED
property_x_align() const5272 Glib::PropertyProxy_ReadOnly< ActorAlign > Actor::property_x_align() const
5273 {
5274 return Glib::PropertyProxy_ReadOnly< ActorAlign >(this, "x-align");
5275 }
5276 #endif //GLIBMM_PROPERTIES_ENABLED
5277
5278 #ifdef GLIBMM_PROPERTIES_ENABLED
property_x_expand()5279 Glib::PropertyProxy< bool > Actor::property_x_expand()
5280 {
5281 return Glib::PropertyProxy< bool >(this, "x-expand");
5282 }
5283 #endif //GLIBMM_PROPERTIES_ENABLED
5284
5285 #ifdef GLIBMM_PROPERTIES_ENABLED
property_x_expand() const5286 Glib::PropertyProxy_ReadOnly< bool > Actor::property_x_expand() const
5287 {
5288 return Glib::PropertyProxy_ReadOnly< bool >(this, "x-expand");
5289 }
5290 #endif //GLIBMM_PROPERTIES_ENABLED
5291
5292 #ifdef GLIBMM_PROPERTIES_ENABLED
property_y()5293 Glib::PropertyProxy< float > Actor::property_y()
5294 {
5295 return Glib::PropertyProxy< float >(this, "y");
5296 }
5297 #endif //GLIBMM_PROPERTIES_ENABLED
5298
5299 #ifdef GLIBMM_PROPERTIES_ENABLED
property_y() const5300 Glib::PropertyProxy_ReadOnly< float > Actor::property_y() const
5301 {
5302 return Glib::PropertyProxy_ReadOnly< float >(this, "y");
5303 }
5304 #endif //GLIBMM_PROPERTIES_ENABLED
5305
5306 #ifdef GLIBMM_PROPERTIES_ENABLED
property_y_align()5307 Glib::PropertyProxy< ActorAlign > Actor::property_y_align()
5308 {
5309 return Glib::PropertyProxy< ActorAlign >(this, "y-align");
5310 }
5311 #endif //GLIBMM_PROPERTIES_ENABLED
5312
5313 #ifdef GLIBMM_PROPERTIES_ENABLED
property_y_align() const5314 Glib::PropertyProxy_ReadOnly< ActorAlign > Actor::property_y_align() const
5315 {
5316 return Glib::PropertyProxy_ReadOnly< ActorAlign >(this, "y-align");
5317 }
5318 #endif //GLIBMM_PROPERTIES_ENABLED
5319
5320 #ifdef GLIBMM_PROPERTIES_ENABLED
property_y_expand()5321 Glib::PropertyProxy< bool > Actor::property_y_expand()
5322 {
5323 return Glib::PropertyProxy< bool >(this, "y-expand");
5324 }
5325 #endif //GLIBMM_PROPERTIES_ENABLED
5326
5327 #ifdef GLIBMM_PROPERTIES_ENABLED
property_y_expand() const5328 Glib::PropertyProxy_ReadOnly< bool > Actor::property_y_expand() const
5329 {
5330 return Glib::PropertyProxy_ReadOnly< bool >(this, "y-expand");
5331 }
5332 #endif //GLIBMM_PROPERTIES_ENABLED
5333
5334 #ifdef GLIBMM_PROPERTIES_ENABLED
property_z_position()5335 Glib::PropertyProxy< float > Actor::property_z_position()
5336 {
5337 return Glib::PropertyProxy< float >(this, "z-position");
5338 }
5339 #endif //GLIBMM_PROPERTIES_ENABLED
5340
5341 #ifdef GLIBMM_PROPERTIES_ENABLED
property_z_position() const5342 Glib::PropertyProxy_ReadOnly< float > Actor::property_z_position() const
5343 {
5344 return Glib::PropertyProxy_ReadOnly< float >(this, "z-position");
5345 }
5346 #endif //GLIBMM_PROPERTIES_ENABLED
5347
5348
on_button_press_event(ButtonEvent * event)5349 bool Clutter::Actor::on_button_press_event(ButtonEvent* event)
5350 {
5351 BaseClassType *const base = static_cast<BaseClassType*>(
5352 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5353 );
5354
5355 if(base && base->button_press_event)
5356 return (*base->button_press_event)(gobj(),event);
5357
5358 typedef bool RType;
5359 return RType();
5360 }
on_button_release_event(ButtonEvent * event)5361 bool Clutter::Actor::on_button_release_event(ButtonEvent* event)
5362 {
5363 BaseClassType *const base = static_cast<BaseClassType*>(
5364 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5365 );
5366
5367 if(base && base->button_release_event)
5368 return (*base->button_release_event)(gobj(),event);
5369
5370 typedef bool RType;
5371 return RType();
5372 }
on_motion_event(MotionEvent * event)5373 bool Clutter::Actor::on_motion_event(MotionEvent* event)
5374 {
5375 BaseClassType *const base = static_cast<BaseClassType*>(
5376 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5377 );
5378
5379 if(base && base->motion_event)
5380 return (*base->motion_event)(gobj(),event);
5381
5382 typedef bool RType;
5383 return RType();
5384 }
on_leave_event(CrossingEvent * event)5385 bool Clutter::Actor::on_leave_event(CrossingEvent* event)
5386 {
5387 BaseClassType *const base = static_cast<BaseClassType*>(
5388 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5389 );
5390
5391 if(base && base->leave_event)
5392 return (*base->leave_event)(gobj(),event);
5393
5394 typedef bool RType;
5395 return RType();
5396 }
on_show()5397 void Clutter::Actor::on_show()
5398 {
5399 BaseClassType *const base = static_cast<BaseClassType*>(
5400 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5401 );
5402
5403 if(base && base->show)
5404 (*base->show)(gobj());
5405 }
on_hide()5406 void Clutter::Actor::on_hide()
5407 {
5408 BaseClassType *const base = static_cast<BaseClassType*>(
5409 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5410 );
5411
5412 if(base && base->hide)
5413 (*base->hide)(gobj());
5414 }
on_key_release_event(KeyEvent * event)5415 bool Clutter::Actor::on_key_release_event(KeyEvent* event)
5416 {
5417 BaseClassType *const base = static_cast<BaseClassType*>(
5418 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5419 );
5420
5421 if(base && base->key_release_event)
5422 return (*base->key_release_event)(gobj(),event);
5423
5424 typedef bool RType;
5425 return RType();
5426 }
on_enter_event(CrossingEvent * event)5427 bool Clutter::Actor::on_enter_event(CrossingEvent* event)
5428 {
5429 BaseClassType *const base = static_cast<BaseClassType*>(
5430 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5431 );
5432
5433 if(base && base->enter_event)
5434 return (*base->enter_event)(gobj(),event);
5435
5436 typedef bool RType;
5437 return RType();
5438 }
on_event(Event * event)5439 bool Clutter::Actor::on_event(Event* event)
5440 {
5441 BaseClassType *const base = static_cast<BaseClassType*>(
5442 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5443 );
5444
5445 if(base && base->event)
5446 return (*base->event)(gobj(),event);
5447
5448 typedef bool RType;
5449 return RType();
5450 }
on_key_focus_out()5451 void Clutter::Actor::on_key_focus_out()
5452 {
5453 BaseClassType *const base = static_cast<BaseClassType*>(
5454 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5455 );
5456
5457 if(base && base->key_focus_out)
5458 (*base->key_focus_out)(gobj());
5459 }
on_key_focus_in()5460 void Clutter::Actor::on_key_focus_in()
5461 {
5462 BaseClassType *const base = static_cast<BaseClassType*>(
5463 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5464 );
5465
5466 if(base && base->key_focus_in)
5467 (*base->key_focus_in)(gobj());
5468 }
on_parent_set(const Glib::RefPtr<Actor> & old_parent)5469 void Clutter::Actor::on_parent_set(const Glib::RefPtr<Actor>& old_parent)
5470 {
5471 BaseClassType *const base = static_cast<BaseClassType*>(
5472 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5473 );
5474
5475 if(base && base->parent_set)
5476 (*base->parent_set)(gobj(),Glib::unwrap(old_parent));
5477 }
on_scroll_event(ScrollEvent * event)5478 bool Clutter::Actor::on_scroll_event(ScrollEvent* event)
5479 {
5480 BaseClassType *const base = static_cast<BaseClassType*>(
5481 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5482 );
5483
5484 if(base && base->scroll_event)
5485 return (*base->scroll_event)(gobj(),event);
5486
5487 typedef bool RType;
5488 return RType();
5489 }
on_key_press_event(KeyEvent * event)5490 bool Clutter::Actor::on_key_press_event(KeyEvent* event)
5491 {
5492 BaseClassType *const base = static_cast<BaseClassType*>(
5493 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5494 );
5495
5496 if(base && base->key_press_event)
5497 return (*base->key_press_event)(gobj(),event);
5498
5499 typedef bool RType;
5500 return RType();
5501 }
on_captured_event(Event * event)5502 bool Clutter::Actor::on_captured_event(Event* event)
5503 {
5504 BaseClassType *const base = static_cast<BaseClassType*>(
5505 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5506 );
5507
5508 if(base && base->captured_event)
5509 return (*base->captured_event)(gobj(),event);
5510
5511 typedef bool RType;
5512 return RType();
5513 }
on_queue_redaw(const Glib::RefPtr<Actor> & origin)5514 void Clutter::Actor::on_queue_redaw(const Glib::RefPtr<Actor>& origin)
5515 {
5516 BaseClassType *const base = static_cast<BaseClassType*>(
5517 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5518 );
5519
5520 if(base && base->queue_redraw)
5521 (*base->queue_redraw)(gobj(),Glib::unwrap(origin));
5522 }
on_queue_relayout()5523 void Clutter::Actor::on_queue_relayout()
5524 {
5525 BaseClassType *const base = static_cast<BaseClassType*>(
5526 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5527 );
5528
5529 if(base && base->queue_relayout)
5530 (*base->queue_relayout)(gobj());
5531 }
on_realize()5532 void Clutter::Actor::on_realize()
5533 {
5534 BaseClassType *const base = static_cast<BaseClassType*>(
5535 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5536 );
5537
5538 if(base && base->realize)
5539 (*base->realize)(gobj());
5540 }
on_unrealize()5541 void Clutter::Actor::on_unrealize()
5542 {
5543 BaseClassType *const base = static_cast<BaseClassType*>(
5544 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5545 );
5546
5547 if(base && base->unrealize)
5548 (*base->unrealize)(gobj());
5549 }
on_pick(const Color & color)5550 void Clutter::Actor::on_pick(const Color& color)
5551 {
5552 BaseClassType *const base = static_cast<BaseClassType*>(
5553 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5554 );
5555
5556 if(base && base->pick)
5557 (*base->pick)(gobj(),(color).gobj());
5558 }
on_touch_event(ClutterTouchEvent * event)5559 bool Clutter::Actor::on_touch_event(ClutterTouchEvent* event)
5560 {
5561 BaseClassType *const base = static_cast<BaseClassType*>(
5562 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5563 );
5564
5565 if(base && base->touch_event)
5566 return (*base->touch_event)(gobj(),event);
5567
5568 typedef bool RType;
5569 return RType();
5570 }
5571
show_all_vfunc()5572 void Clutter::Actor::show_all_vfunc()
5573 {
5574 BaseClassType *const base = static_cast<BaseClassType*>(
5575 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5576 );
5577
5578 if(base && base->show_all)
5579 {
5580 (*base->show_all)(gobj());
5581 }
5582 }
hide_all_vfunc()5583 void Clutter::Actor::hide_all_vfunc()
5584 {
5585 BaseClassType *const base = static_cast<BaseClassType*>(
5586 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5587 );
5588
5589 if(base && base->hide_all)
5590 {
5591 (*base->hide_all)(gobj());
5592 }
5593 }
map_vfunc()5594 void Clutter::Actor::map_vfunc()
5595 {
5596 BaseClassType *const base = static_cast<BaseClassType*>(
5597 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5598 );
5599
5600 if(base && base->map)
5601 {
5602 (*base->map)(gobj());
5603 }
5604 }
unmap_vfunc()5605 void Clutter::Actor::unmap_vfunc()
5606 {
5607 BaseClassType *const base = static_cast<BaseClassType*>(
5608 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5609 );
5610
5611 if(base && base->unmap)
5612 {
5613 (*base->unmap)(gobj());
5614 }
5615 }
paint_vfunc()5616 void Clutter::Actor::paint_vfunc()
5617 {
5618 BaseClassType *const base = static_cast<BaseClassType*>(
5619 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5620 );
5621
5622 if(base && base->paint)
5623 {
5624 (*base->paint)(gobj());
5625 }
5626 }
get_preferred_width_vfunc(float for_height,float & min_width_p,float & natural_width_p) const5627 void Clutter::Actor::get_preferred_width_vfunc(float for_height, float& min_width_p, float& natural_width_p) const
5628 {
5629 BaseClassType *const base = static_cast<BaseClassType*>(
5630 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5631 );
5632
5633 if(base && base->get_preferred_width)
5634 {
5635 (*base->get_preferred_width)(const_cast<ClutterActor*>(gobj()),for_height,&(min_width_p),&(natural_width_p));
5636 }
5637 }
get_preferred_height_vfunc(float for_width,float & min_height_p,float & natural_height_p) const5638 void Clutter::Actor::get_preferred_height_vfunc(float for_width, float& min_height_p, float& natural_height_p) const
5639 {
5640 BaseClassType *const base = static_cast<BaseClassType*>(
5641 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5642 );
5643
5644 if(base && base->get_preferred_height)
5645 {
5646 (*base->get_preferred_height)(const_cast<ClutterActor*>(gobj()),for_width,&(min_height_p),&(natural_height_p));
5647 }
5648 }
allocate_vfunc(const ActorBox & box,AllocationFlags absolute_origin_changed)5649 void Clutter::Actor::allocate_vfunc(const ActorBox& box, AllocationFlags absolute_origin_changed)
5650 {
5651 BaseClassType *const base = static_cast<BaseClassType*>(
5652 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5653 );
5654
5655 if(base && base->allocate)
5656 {
5657 (*base->allocate)(gobj(),(box).gobj(),((ClutterAllocationFlags)(absolute_origin_changed)));
5658 }
5659 }
pick_vfunc(const Color & color)5660 void Clutter::Actor::pick_vfunc(const Color& color)
5661 {
5662 BaseClassType *const base = static_cast<BaseClassType*>(
5663 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5664 );
5665
5666 if(base && base->pick)
5667 {
5668 (*base->pick)(gobj(),(color).gobj());
5669 }
5670 }
get_paint_volume_vfunc(ClutterPaintVolume * volume)5671 bool Clutter::Actor::get_paint_volume_vfunc(ClutterPaintVolume* volume)
5672 {
5673 BaseClassType *const base = static_cast<BaseClassType*>(
5674 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5675 );
5676
5677 if(base && base->get_paint_volume)
5678 {
5679 bool retval((*base->get_paint_volume)(gobj(),volume));
5680 return retval;
5681 }
5682
5683 typedef bool RType;
5684 return RType();
5685 }
has_overlaps_vfunc() const5686 bool Clutter::Actor::has_overlaps_vfunc() const
5687 {
5688 BaseClassType *const base = static_cast<BaseClassType*>(
5689 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5690 );
5691
5692 if(base && base->has_overlaps)
5693 {
5694 bool retval((*base->has_overlaps)(const_cast<ClutterActor*>(gobj())));
5695 return retval;
5696 }
5697
5698 typedef bool RType;
5699 return RType();
5700 }
paint_node_vfunc(ClutterPaintNode * root)5701 void Clutter::Actor::paint_node_vfunc(ClutterPaintNode* root)
5702 {
5703 BaseClassType *const base = static_cast<BaseClassType*>(
5704 g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
5705 );
5706
5707 if(base && base->paint_node)
5708 {
5709 (*base->paint_node)(gobj(),root);
5710 }
5711 }
5712
5713
5714 } // namespace Clutter
5715
5716
5717