1 // -*- c++ -*-
2 // Generated by gmmproc 2.40.0 -- DO NOT MODIFY!
3 #ifndef _CLUTTERMM_ACTOR_H
4 #define _CLUTTERMM_ACTOR_H
5
6
7 #include <glibmm/ustring.h>
8 #include <sigc++/sigc++.h>
9
10 /* Copyright (C) 2007 The cluttermm Development Team
11 *
12 * This library is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU Lesser General Public
14 * License as published by the Free Software Foundation; either
15 * version 2.1 of the License, or (at your option) any later version.
16 *
17 * This library is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * Lesser General Public License for more details.
21 *
22 * You should have received a copy of the GNU Lesser General Public
23 * License along with this library; if not, write to the Free
24 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 */
26
27 #include <glibmm/object.h>
28 #include <pangomm/context.h>
29 #include <pangomm/layout.h>
30 #include <atkmm/object.h>
31 #include <cluttermm/action.h>
32 #include <cluttermm/actor-box.h>
33 #include <cluttermm/animation.h>
34 #include <cluttermm/animatable.h>
35 #include <cluttermm/color.h>
36 //#include <cluttermm/content.h>
37 #include <cluttermm/effect.h>
38 //#include <cluttermm/layout-manager.h>
39 #include <cluttermm/scriptable.h>
40 #include <cluttermm/shader.h>
41 #include <cluttermm/transition.h>
42 #include <cluttermm/types.h> // For Event*
43
44
45 #ifndef DOXYGEN_SHOULD_SKIP_THIS
46 typedef struct _ClutterActor ClutterActor;
47 typedef struct _ClutterActorClass ClutterActorClass;
48 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
49
50
51 namespace Clutter
52 { class Actor_Class; } // namespace Clutter
53 namespace Clutter
54 {
55
56 typedef ClutterMatrix Matrix;
57 typedef ClutterPaintVolume PaintVolume;
58
59 class Animation;
60 class Constraint;
61 class Content;
62 class LayoutManager;
63
64 /** @addtogroup cluttermmEnums cluttermm Enums and Flags */
65
66 /**
67 * @var ActorAlign ACTOR_ALIGN_FILL
68 * Stretch to cover the whole allocated space.
69 *
70 * @var ActorAlign ACTOR_ALIGN_START
71 * Snap to left or top side, leaving space to the right or bottom. For horizontal layouts, in right-to-left locales this should be reversed.
72 *
73 * @var ActorAlign ACTOR_ALIGN_CENTER
74 * Center the actor inside the allocation.
75 *
76 * @var ActorAlign ACTOR_ALIGN_END
77 * Snap to right or bottom side, leaving space to the left or top. For horizontal layouts, in right-to-left locales this should be reversed.
78 *
79 * @enum ActorAlign
80 *
81 * Controls how a Clutter::Actor should align itself inside the extra space
82 * assigned to it during the allocation.
83 *
84 * Alignment only matters if the allocated space given to an actor is
85 * bigger than its natural size; for example, when the Clutter::Actor::property_x_expand()
86 * or the Clutter::Actor::property_y_expand() properties of Clutter::Actor are set to <tt>true</tt>.
87 *
88 * @newin{1,10}
89 * @ingroup cluttermmEnums
90 */
91 enum ActorAlign
92 {
93 ACTOR_ALIGN_FILL,
94 ACTOR_ALIGN_START,
95 ACTOR_ALIGN_CENTER,
96 ACTOR_ALIGN_END
97 };
98
99 } // namespace Clutter
100
101
102 #ifndef DOXYGEN_SHOULD_SKIP_THIS
103 namespace Glib
104 {
105
106 template <>
107 class Value<Clutter::ActorAlign> : public Glib::Value_Enum<Clutter::ActorAlign>
108 {
109 public:
110 static GType value_type() G_GNUC_CONST;
111 };
112
113 } // namespace Glib
114 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
115
116
117 namespace Clutter
118 {
119
120 /**
121 * @var ActorFlags ACTOR_MAPPED
122 * The actor will be painted (is visible, and inside a toplevel, and all parents visible).
123 *
124 * @var ActorFlags ACTOR_REALIZED
125 * The resources associated to the actor have been allocated.
126 *
127 * @var ActorFlags ACTOR_REACTIVE
128 * The actor 'reacts' to mouse events emmitting event signals.
129 *
130 * @var ActorFlags ACTOR_VISIBLE
131 * The actor has been shown by the application program.
132 *
133 * @var ActorFlags ACTOR_NO_LAYOUT
134 * The actor provides an explicit layout management policy for its children; this flag will prevent Clutter from automatic queueing of relayout and will defer all layouting to the actor itself.
135 *
136 * @enum ActorFlags
137 *
138 * Flags used to signal the state of an actor.
139 * @ingroup cluttermmEnums
140 * @par Bitwise operators:
141 * <tt>%ActorFlags operator|(ActorFlags, ActorFlags)</tt><br>
142 * <tt>%ActorFlags operator&(ActorFlags, ActorFlags)</tt><br>
143 * <tt>%ActorFlags operator^(ActorFlags, ActorFlags)</tt><br>
144 * <tt>%ActorFlags operator~(ActorFlags)</tt><br>
145 * <tt>%ActorFlags& operator|=(ActorFlags&, ActorFlags)</tt><br>
146 * <tt>%ActorFlags& operator&=(ActorFlags&, ActorFlags)</tt><br>
147 * <tt>%ActorFlags& operator^=(ActorFlags&, ActorFlags)</tt><br>
148 */
149 enum ActorFlags
150 {
151 ACTOR_MAPPED = 1 << 1,
152 ACTOR_REALIZED = 1 << 2,
153 ACTOR_REACTIVE = 1 << 3,
154 ACTOR_VISIBLE = 1 << 4,
155 ACTOR_NO_LAYOUT = 1 << 5
156 };
157
158 /** @ingroup cluttermmEnums */
159 inline ActorFlags operator|(ActorFlags lhs, ActorFlags rhs)
160 { return static_cast<ActorFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
161
162 /** @ingroup cluttermmEnums */
163 inline ActorFlags operator&(ActorFlags lhs, ActorFlags rhs)
164 { return static_cast<ActorFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
165
166 /** @ingroup cluttermmEnums */
167 inline ActorFlags operator^(ActorFlags lhs, ActorFlags rhs)
168 { return static_cast<ActorFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
169
170 /** @ingroup cluttermmEnums */
171 inline ActorFlags operator~(ActorFlags flags)
172 { return static_cast<ActorFlags>(~static_cast<unsigned>(flags)); }
173
174 /** @ingroup cluttermmEnums */
175 inline ActorFlags& operator|=(ActorFlags& lhs, ActorFlags rhs)
176 { return (lhs = static_cast<ActorFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
177
178 /** @ingroup cluttermmEnums */
179 inline ActorFlags& operator&=(ActorFlags& lhs, ActorFlags rhs)
180 { return (lhs = static_cast<ActorFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
181
182 /** @ingroup cluttermmEnums */
183 inline ActorFlags& operator^=(ActorFlags& lhs, ActorFlags rhs)
184 { return (lhs = static_cast<ActorFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
185
186 } // namespace Clutter
187
188
189 #ifndef DOXYGEN_SHOULD_SKIP_THIS
190 namespace Glib
191 {
192
193 template <>
194 class Value<Clutter::ActorFlags> : public Glib::Value_Flags<Clutter::ActorFlags>
195 {
196 public:
197 static GType value_type() G_GNUC_CONST;
198 };
199
200 } // namespace Glib
201 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
202
203
204 namespace Clutter
205 {
206
207 /**
208 * @var AllocationFlags ALLOCATION_NONE
209 * No flag set.
210 *
211 * @var AllocationFlags ABSOLUTE_ORIGIN_CHANGED
212 * Whether the absolute origin of the actor has changed; this implies that any ancestor of the actor has been moved.
213 *
214 * @var AllocationFlags DELEGATE_LAYOUT
215 * Whether the allocation should be delegated to the Clutter::LayoutManager instance stored inside the Clutter::Actor::property_layout_manager() property of Clutter::Actor. This flag should only be used if you are subclassing Clutter::Actor and overriding the Clutter::ActorClass.allocate() virtual function, but you wish to use the default implementation of the virtual function inside Clutter::Actor. Added in Clutter 1.10.
216 *
217 * @enum AllocationFlags
218 *
219 * Flags passed to the Clutter::ActorClass.allocate() virtual function
220 * and to the Clutter::Actor::allocate() function.
221 *
222 * @newin{1,0}
223 * @ingroup cluttermmEnums
224 * @par Bitwise operators:
225 * <tt>%AllocationFlags operator|(AllocationFlags, AllocationFlags)</tt><br>
226 * <tt>%AllocationFlags operator&(AllocationFlags, AllocationFlags)</tt><br>
227 * <tt>%AllocationFlags operator^(AllocationFlags, AllocationFlags)</tt><br>
228 * <tt>%AllocationFlags operator~(AllocationFlags)</tt><br>
229 * <tt>%AllocationFlags& operator|=(AllocationFlags&, AllocationFlags)</tt><br>
230 * <tt>%AllocationFlags& operator&=(AllocationFlags&, AllocationFlags)</tt><br>
231 * <tt>%AllocationFlags& operator^=(AllocationFlags&, AllocationFlags)</tt><br>
232 */
233 enum AllocationFlags
234 {
235 ALLOCATION_NONE = 0x0,
236 ABSOLUTE_ORIGIN_CHANGED = 1 << 1,
237 DELEGATE_LAYOUT = 1 << 2
238 };
239
240 /** @ingroup cluttermmEnums */
241 inline AllocationFlags operator|(AllocationFlags lhs, AllocationFlags rhs)
242 { return static_cast<AllocationFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
243
244 /** @ingroup cluttermmEnums */
245 inline AllocationFlags operator&(AllocationFlags lhs, AllocationFlags rhs)
246 { return static_cast<AllocationFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
247
248 /** @ingroup cluttermmEnums */
249 inline AllocationFlags operator^(AllocationFlags lhs, AllocationFlags rhs)
250 { return static_cast<AllocationFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
251
252 /** @ingroup cluttermmEnums */
253 inline AllocationFlags operator~(AllocationFlags flags)
254 { return static_cast<AllocationFlags>(~static_cast<unsigned>(flags)); }
255
256 /** @ingroup cluttermmEnums */
257 inline AllocationFlags& operator|=(AllocationFlags& lhs, AllocationFlags rhs)
258 { return (lhs = static_cast<AllocationFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
259
260 /** @ingroup cluttermmEnums */
261 inline AllocationFlags& operator&=(AllocationFlags& lhs, AllocationFlags rhs)
262 { return (lhs = static_cast<AllocationFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
263
264 /** @ingroup cluttermmEnums */
265 inline AllocationFlags& operator^=(AllocationFlags& lhs, AllocationFlags rhs)
266 { return (lhs = static_cast<AllocationFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
267
268 } // namespace Clutter
269
270
271 #ifndef DOXYGEN_SHOULD_SKIP_THIS
272 namespace Glib
273 {
274
275 template <>
276 class Value<Clutter::AllocationFlags> : public Glib::Value_Flags<Clutter::AllocationFlags>
277 {
278 public:
279 static GType value_type() G_GNUC_CONST;
280 };
281
282 } // namespace Glib
283 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
284
285
286 namespace Clutter
287 {
288
289 /**
290 * @var ContentRepeat REPEAT_NONE
291 * No repeat.
292 *
293 * @var ContentRepeat REPEAT_X_AXIS
294 * Repeat the content on the X axis.
295 *
296 * @var ContentRepeat REPEAT_Y_AXIS
297 * Repeat the content on the Y axis.
298 *
299 * @var ContentRepeat REPEAT_BOTH
300 * Repeat the content on both axis.
301 *
302 * @enum ContentRepeat
303 *
304 * Content repeat modes.
305 *
306 * @newin{1,12}
307 * @ingroup cluttermmEnums
308 * @par Bitwise operators:
309 * <tt>%ContentRepeat operator|(ContentRepeat, ContentRepeat)</tt><br>
310 * <tt>%ContentRepeat operator&(ContentRepeat, ContentRepeat)</tt><br>
311 * <tt>%ContentRepeat operator^(ContentRepeat, ContentRepeat)</tt><br>
312 * <tt>%ContentRepeat operator~(ContentRepeat)</tt><br>
313 * <tt>%ContentRepeat& operator|=(ContentRepeat&, ContentRepeat)</tt><br>
314 * <tt>%ContentRepeat& operator&=(ContentRepeat&, ContentRepeat)</tt><br>
315 * <tt>%ContentRepeat& operator^=(ContentRepeat&, ContentRepeat)</tt><br>
316 */
317 enum ContentRepeat
318 {
319 REPEAT_NONE = 0x0,
320 REPEAT_X_AXIS = 1 << 0,
321 REPEAT_Y_AXIS = 1 << 1,
322 REPEAT_BOTH = 0x3
323 };
324
325 /** @ingroup cluttermmEnums */
326 inline ContentRepeat operator|(ContentRepeat lhs, ContentRepeat rhs)
327 { return static_cast<ContentRepeat>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
328
329 /** @ingroup cluttermmEnums */
330 inline ContentRepeat operator&(ContentRepeat lhs, ContentRepeat rhs)
331 { return static_cast<ContentRepeat>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
332
333 /** @ingroup cluttermmEnums */
334 inline ContentRepeat operator^(ContentRepeat lhs, ContentRepeat rhs)
335 { return static_cast<ContentRepeat>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
336
337 /** @ingroup cluttermmEnums */
338 inline ContentRepeat operator~(ContentRepeat flags)
339 { return static_cast<ContentRepeat>(~static_cast<unsigned>(flags)); }
340
341 /** @ingroup cluttermmEnums */
342 inline ContentRepeat& operator|=(ContentRepeat& lhs, ContentRepeat rhs)
343 { return (lhs = static_cast<ContentRepeat>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
344
345 /** @ingroup cluttermmEnums */
346 inline ContentRepeat& operator&=(ContentRepeat& lhs, ContentRepeat rhs)
347 { return (lhs = static_cast<ContentRepeat>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
348
349 /** @ingroup cluttermmEnums */
350 inline ContentRepeat& operator^=(ContentRepeat& lhs, ContentRepeat rhs)
351 { return (lhs = static_cast<ContentRepeat>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
352
353 } // namespace Clutter
354
355
356 #ifndef DOXYGEN_SHOULD_SKIP_THIS
357 namespace Glib
358 {
359
360 template <>
361 class Value<Clutter::ContentRepeat> : public Glib::Value_Flags<Clutter::ContentRepeat>
362 {
363 public:
364 static GType value_type() G_GNUC_CONST;
365 };
366
367 } // namespace Glib
368 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
369
370
371 namespace Clutter
372 {
373
374 /**
375 * @var ContentGravity CONTENT_GRAVITY_TOP_LEFT
376 * Align the content to the top left corner.
377 *
378 * @var ContentGravity CONTENT_GRAVITY_TOP
379 * Align the content to the top edge.
380 *
381 * @var ContentGravity CONTENT_GRAVITY_TOP_RIGHT
382 * Align the content to the top right corner.
383 *
384 * @var ContentGravity CONTENT_GRAVITY_LEFT
385 * Align the content to the left edge.
386 *
387 * @var ContentGravity CONTENT_GRAVITY_CENTER
388 * Align the content to the center.
389 *
390 * @var ContentGravity CONTENT_GRAVITY_RIGHT
391 * Align the content to the right edge.
392 *
393 * @var ContentGravity CONTENT_GRAVITY_BOTTOM_LEFT
394 * Align the content to the bottom left corner.
395 *
396 * @var ContentGravity CONTENT_GRAVITY_BOTTOM
397 * Align the content to the bottom edge.
398 *
399 * @var ContentGravity CONTENT_GRAVITY_BOTTOM_RIGHT
400 * Align the content to the bottom right corner.
401 *
402 * @var ContentGravity CONTENT_GRAVITY_RESIZE_FILL
403 * Resize the content to fill the allocation.
404 *
405 * @var ContentGravity CONTENT_GRAVITY_RESIZE_ASPECT
406 * Resize the content to remain within the allocation, while maintaining the aspect ratio.
407 *
408 * @enum ContentGravity
409 *
410 * Controls the alignment of the Clutter::Content inside a Clutter::Actor.
411 *
412 * @newin{1,10}
413 * @ingroup cluttermmEnums
414 */
415 enum ContentGravity
416 {
417 CONTENT_GRAVITY_TOP_LEFT,
418 CONTENT_GRAVITY_TOP,
419 CONTENT_GRAVITY_TOP_RIGHT,
420 CONTENT_GRAVITY_LEFT,
421 CONTENT_GRAVITY_CENTER,
422 CONTENT_GRAVITY_RIGHT,
423 CONTENT_GRAVITY_BOTTOM_LEFT,
424 CONTENT_GRAVITY_BOTTOM,
425 CONTENT_GRAVITY_BOTTOM_RIGHT,
426 CONTENT_GRAVITY_RESIZE_FILL,
427 CONTENT_GRAVITY_RESIZE_ASPECT
428 };
429
430 } // namespace Clutter
431
432
433 #ifndef DOXYGEN_SHOULD_SKIP_THIS
434 namespace Glib
435 {
436
437 template <>
438 class Value<Clutter::ContentGravity> : public Glib::Value_Enum<Clutter::ContentGravity>
439 {
440 public:
441 static GType value_type() G_GNUC_CONST;
442 };
443
444 } // namespace Glib
445 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
446
447
448 namespace Clutter
449 {
450
451 /**
452 * @var OffscreenRedirect OFFSCREEN_REDIRECT_AUTOMATIC_FOR_OPACITY
453 * Only redirect the actor if it is semi-transparent and its has_overlaps() virtual returns <tt>true</tt>. This is the default.
454 *
455 * @var OffscreenRedirect OFFSCREEN_REDIRECT_ALWAYS
456 * Always redirect the actor to an offscreen buffer even if it is fully opaque.
457 *
458 * @enum OffscreenRedirect
459 *
460 * Possible flags to pass to Clutter::Actor::set_offscreen_redirect().
461 *
462 * @newin{1,8}
463 * @ingroup cluttermmEnums
464 * @par Bitwise operators:
465 * <tt>%OffscreenRedirect operator|(OffscreenRedirect, OffscreenRedirect)</tt><br>
466 * <tt>%OffscreenRedirect operator&(OffscreenRedirect, OffscreenRedirect)</tt><br>
467 * <tt>%OffscreenRedirect operator^(OffscreenRedirect, OffscreenRedirect)</tt><br>
468 * <tt>%OffscreenRedirect operator~(OffscreenRedirect)</tt><br>
469 * <tt>%OffscreenRedirect& operator|=(OffscreenRedirect&, OffscreenRedirect)</tt><br>
470 * <tt>%OffscreenRedirect& operator&=(OffscreenRedirect&, OffscreenRedirect)</tt><br>
471 * <tt>%OffscreenRedirect& operator^=(OffscreenRedirect&, OffscreenRedirect)</tt><br>
472 */
473 enum OffscreenRedirect
474 {
475 OFFSCREEN_REDIRECT_AUTOMATIC_FOR_OPACITY = 1<<0,
476 OFFSCREEN_REDIRECT_ALWAYS = 1<<1
477 };
478
479 /** @ingroup cluttermmEnums */
480 inline OffscreenRedirect operator|(OffscreenRedirect lhs, OffscreenRedirect rhs)
481 { return static_cast<OffscreenRedirect>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
482
483 /** @ingroup cluttermmEnums */
484 inline OffscreenRedirect operator&(OffscreenRedirect lhs, OffscreenRedirect rhs)
485 { return static_cast<OffscreenRedirect>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
486
487 /** @ingroup cluttermmEnums */
488 inline OffscreenRedirect operator^(OffscreenRedirect lhs, OffscreenRedirect rhs)
489 { return static_cast<OffscreenRedirect>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
490
491 /** @ingroup cluttermmEnums */
492 inline OffscreenRedirect operator~(OffscreenRedirect flags)
493 { return static_cast<OffscreenRedirect>(~static_cast<unsigned>(flags)); }
494
495 /** @ingroup cluttermmEnums */
496 inline OffscreenRedirect& operator|=(OffscreenRedirect& lhs, OffscreenRedirect rhs)
497 { return (lhs = static_cast<OffscreenRedirect>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
498
499 /** @ingroup cluttermmEnums */
500 inline OffscreenRedirect& operator&=(OffscreenRedirect& lhs, OffscreenRedirect rhs)
501 { return (lhs = static_cast<OffscreenRedirect>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
502
503 /** @ingroup cluttermmEnums */
504 inline OffscreenRedirect& operator^=(OffscreenRedirect& lhs, OffscreenRedirect rhs)
505 { return (lhs = static_cast<OffscreenRedirect>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
506
507 } // namespace Clutter
508
509
510 #ifndef DOXYGEN_SHOULD_SKIP_THIS
511 namespace Glib
512 {
513
514 template <>
515 class Value<Clutter::OffscreenRedirect> : public Glib::Value_Flags<Clutter::OffscreenRedirect>
516 {
517 public:
518 static GType value_type() G_GNUC_CONST;
519 };
520
521 } // namespace Glib
522 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
523
524
525 namespace Clutter
526 {
527
528 /**
529 * @var Orientation ORIENTATION_HORIZONTAL
530 * An horizontal orientation.
531 *
532 * @var Orientation ORIENTATION_VERTICAL
533 * A vertical orientation.
534 *
535 * @enum Orientation
536 *
537 * Represents the orientation of actors or layout managers.
538 *
539 * @newin{1,12}
540 * @ingroup cluttermmEnums
541 */
542 enum Orientation
543 {
544 ORIENTATION_HORIZONTAL,
545 ORIENTATION_VERTICAL
546 };
547
548 } // namespace Clutter
549
550
551 #ifndef DOXYGEN_SHOULD_SKIP_THIS
552 namespace Glib
553 {
554
555 template <>
556 class Value<Clutter::Orientation> : public Glib::Value_Enum<Clutter::Orientation>
557 {
558 public:
559 static GType value_type() G_GNUC_CONST;
560 };
561
562 } // namespace Glib
563 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
564
565
566 namespace Clutter
567 {
568
569
570 //TODO: Write a version of the large description from here: http://clutter-project.org/docs/clutter/stable/ClutterActor.html#ClutterActor.description
571
572 class Actor : public Glib::Object, public Scriptable, public Animatable
573 {
574
575 #ifndef DOXYGEN_SHOULD_SKIP_THIS
576
577 public:
578 typedef Actor CppObjectType;
579 typedef Actor_Class CppClassType;
580 typedef ClutterActor BaseObjectType;
581 typedef ClutterActorClass BaseClassType;
582
583 private: friend class Actor_Class;
584 static CppClassType actor_class_;
585
586 private:
587 // noncopyable
588 Actor(const Actor&);
589 Actor& operator=(const Actor&);
590
591 protected:
592 explicit Actor(const Glib::ConstructParams& construct_params);
593 explicit Actor(ClutterActor* castitem);
594
595 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
596
597 public:
598 virtual ~Actor();
599
600 /** Get the GType for this class, for use with the underlying GObject type system.
601 */
602 static GType get_type() G_GNUC_CONST;
603
604 #ifndef DOXYGEN_SHOULD_SKIP_THIS
605
606
607 static GType get_base_type() G_GNUC_CONST;
608 #endif
609
610 ///Provides access to the underlying C GObject.
gobj()611 ClutterActor* gobj() { return reinterpret_cast<ClutterActor*>(gobject_); }
612
613 ///Provides access to the underlying C GObject.
gobj()614 const ClutterActor* gobj() const { return reinterpret_cast<ClutterActor*>(gobject_); }
615
616 ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
617 ClutterActor* gobj_copy();
618
619 private:
620
621
622 protected:
623 Actor();
624
625 public:
626
627
628 static Glib::RefPtr<Actor> create();
629
630
631 /** Sets @a flags on @a self
632 *
633 * This function will emit notifications for the changed properties
634 *
635 * @newin{1,0}
636 * @param flags The flags to set.
637 */
638 void set_flags(ActorFlags flags);
639
640 /** Unsets @a flags on @a self
641 *
642 * This function will emit notifications for the changed properties
643 *
644 * @newin{1,0}
645 * @param flags The flags to unset.
646 */
647 void unset_flags(ActorFlags flags);
648
649 /** Retrieves the flags set on @a self
650 *
651 * @newin{1,0}
652 * @return A bitwise or of Clutter::ActorFlags or 0.
653 */
654 ActorFlags get_flags() const;
655
656 //TODO: Remove these now that there are properties instead?
657 // Not at present; there are no accessors available.
658 bool is_mapped() const;
659 bool is_realized() const;
660 bool is_visible() const;
661 bool is_reactive() const;
662
663
664 /** Flags an actor to be displayed. An actor that isn't shown will not
665 * be rendered on the stage.
666 *
667 * Actors are visible by default.
668 *
669 * If this function is called on an actor without a parent, the
670 * Clutter::Actor::property_show_on_set_parent() will be set to <tt>true</tt> as a side
671 * effect.
672 */
673 void show();
674
675 #ifndef CLUTTERMM_DISABLE_DEPRECATED
676
677 /** Calls show() on all children of an actor (if any).
678 *
679 * @newin{0,2}
680 *
681 * Deprecated: 1.10: Actors are visible by default
682 * @deprecated Actors are visible by default.
683 */
684 void show_all();
685 #endif // CLUTTERMM_DISABLE_DEPRECATED
686
687
688 /** Flags an actor to be hidden. A hidden actor will not be
689 * rendered on the stage.
690 *
691 * Actors are visible by default.
692 *
693 * If this function is called on an actor without a parent, the
694 * Clutter::Actor::property_show_on_set_parent() property will be set to <tt>false</tt>
695 * as a side-effect.
696 */
697 void hide();
698
699 #ifndef CLUTTERMM_DISABLE_DEPRECATED
700
701 /** Calls hide() on all child actors (if any).
702 *
703 * @newin{0,2}
704 *
705 * Deprecated: 1.10: Using hide() on the actor will
706 * prevent its children from being painted as well.
707 * @deprecated Using hide() on the actor will now prevent its children from being painted as well.
708 */
709 void hide_all();
710 #endif // CLUTTERMM_DISABLE_DEPRECATED
711
712
713 /** Realization informs the actor that it is attached to a stage. It
714 * can use this to allocate resources if it wanted to delay allocation
715 * until it would be rendered. However it is perfectly acceptable for
716 * an actor to create resources before being realized because Clutter
717 * only ever has a single rendering context so that actor is free to
718 * be moved from one stage to another.
719 *
720 * This function does nothing if the actor is already realized.
721 *
722 * Because a realized actor must have realized parent actors, calling
723 * realize() will also realize all parents of the actor.
724 *
725 * This function does not realize child actors, except in the special
726 * case that realizing the stage, when the stage is visible, will
727 * suddenly map (and thus realize) the children of the stage.
728 *
729 * Deprecated: 1.16: Actors are automatically realized, and nothing
730 * requires explicit realization.
731 */
732 void realize();
733
734 /** Unrealization informs the actor that it may be being destroyed or
735 * moved to another stage. The actor may want to destroy any
736 * underlying graphics resources at this point. However it is
737 * perfectly acceptable for it to retain the resources until the actor
738 * is destroyed because Clutter only ever uses a single rendering
739 * context and all of the graphics resources are valid on any stage.
740 *
741 * Because mapped actors must be realized, actors may not be
742 * unrealized if they are mapped. This function hides the actor to be
743 * sure it isn't mapped, an application-visible side effect that you
744 * may not be expecting.
745 *
746 * This function should not be called by application code.
747 *
748 * This function should not really be in the public API, because
749 * there isn't a good reason to call it. ClutterActor will already
750 * unrealize things for you when it's important to do so.
751 *
752 * If you were using unrealize() in a dispose
753 * implementation, then don't, just chain up to ClutterActor's
754 * dispose.
755 *
756 * If you were using unrealize() to implement
757 * unrealizing children of your container, then don't, ClutterActor
758 * will already take care of that.
759 *
760 * Deprecated: 1.16: Actors are automatically unrealized, and nothing
761 * requires explicit realization.
762 */
763 void unrealize();
764
765 /** Sets the Clutter::ACTOR_MAPPED flag on the actor and possibly maps
766 * and realizes its children if they are visible. Does nothing if the
767 * actor is not visible.
768 *
769 * Calling this function is strongly disencouraged: the default
770 * implementation of Clutter::ActorClass.map() will map all the children
771 * of an actor when mapping its parent.
772 *
773 * When overriding map, it is mandatory to chain up to the parent
774 * implementation.
775 *
776 * @newin{1,0}
777 */
778 void map();
779
780 /** Unsets the Clutter::ACTOR_MAPPED flag on the actor and possibly
781 * unmaps its children if they were mapped.
782 *
783 * Calling this function is not encouraged: the default Clutter::Actor
784 * implementation of Clutter::ActorClass.unmap() will also unmap any
785 * eventual children by default when their parent is unmapped.
786 *
787 * When overriding Clutter::ActorClass.unmap(), it is mandatory to
788 * chain up to the parent implementation.
789 *
790 * <note>It is important to note that the implementation of the
791 * Clutter::ActorClass.unmap() virtual function may be called after
792 * the Clutter::ActorClass.destroy() or the ObjectClass.dispose()
793 * implementation, but it is guaranteed to be called before the
794 * ObjectClass.finalize() implementation.</note>
795 *
796 * @newin{1,0}
797 */
798 void unmap();
799
800 /** Renders the actor to display.
801 *
802 * This function should not be called directly by applications.
803 * Call queue_redraw() to queue paints, instead.
804 *
805 * This function is context-aware, and will either cause a
806 * regular paint or a pick paint.
807 *
808 * This function will emit the Clutter::Actor::signal_paint() signal or
809 * the Clutter::Actor::signal_pick() signal, depending on the context.
810 *
811 * This function does not paint the actor if the actor is set to 0,
812 * unless it is performing a pick paint.
813 */
814 void paint();
815
816 /** Run the next stage of the paint sequence. This function should only
817 * be called within the implementation of the ‘run’ virtual of a
818 * Clutter::Effect. It will cause the run method of the next effect to
819 * be applied, or it will paint the actual actor if the current effect
820 * is the last effect in the chain.
821 *
822 * @newin{1,8}
823 */
824 void continue_paint();
825
826 /** Queues up a redraw of an actor and any children. The redraw occurs
827 * once the main loop becomes idle (after the current batch of events
828 * has been processed, roughly).
829 *
830 * Applications rarely need to call this, as redraws are handled
831 * automatically by modification functions.
832 *
833 * This function will not do anything if @a self is not visible, or
834 * if the actor is inside an invisible part of the scenegraph.
835 *
836 * Also be aware that painting is a NOP for actors with an opacity of
837 * 0
838 *
839 * When you are implementing a custom actor you must queue a redraw
840 * whenever some private state changes that will affect painting or
841 * picking of your actor.
842 */
843 void queue_redraw();
844
845 /** Indicates that the actor's size request or other layout-affecting
846 * properties may have changed. This function is used inside Clutter::Actor
847 * subclass implementations, not by applications directly.
848 *
849 * Queueing a new layout automatically queues a redraw as well.
850 *
851 * @newin{0,8}
852 */
853 void queue_relayout();
854 //internal.
855 //not for application code.
856 //not for application code.
857
858
859 /** Asks the actor's implementation whether it may contain overlapping
860 * primitives.
861 *
862 * For example; Clutter may use this to determine whether the painting
863 * should be redirected to an offscreen buffer to correctly implement
864 * the opacity property.
865 *
866 * Custom actors can override the default response by implementing the
867 * Clutter::Actor <tt>has_overlaps</tt> virtual function. See
868 * set_offscreen_redirect() for more information.
869 *
870 * @newin{1,8}
871 * @return <tt>true</tt> if the actor may have overlapping primitives, and
872 * <tt>false</tt> otherwise.
873 */
874 bool has_overlaps();
875
876
877 /** Sets the contents of a Clutter::Actor.
878 *
879 * @newin{1,10}
880 * @param content A Clutter::Content, or <tt>0</tt>.
881 */
882 void set_content(const Glib::RefPtr<Content>& content);
883
884
885 /** Retrieves the contents of @a self.
886 *
887 * @newin{1,10}
888 * @return A pointer to the Clutter::Content instance,
889 * or <tt>0</tt> if none was set.
890 */
891 Glib::RefPtr<Content> get_content();
892
893 /** Retrieves the contents of @a self.
894 *
895 * @newin{1,10}
896 * @return A pointer to the Clutter::Content instance,
897 * or <tt>0</tt> if none was set.
898 */
899 Glib::RefPtr<const Content> get_content() const;
900
901
902 /** Sets the gravity of the Clutter::Content used by @a self.
903 *
904 * See the description of the Clutter::Actor::property_content_gravity() property for
905 * more information.
906 *
907 * The Clutter::Actor::property_content_gravity() property is animatable.
908 *
909 * @newin{1,10}
910 * @param gravity The Clutter::ContentGravity.
911 */
912 void set_content_gravity(ContentGravity gravity);
913
914
915 /** Retrieves the content gravity as set using
916 * set_content_gravity().
917 *
918 * @newin{1,10}
919 * @return The content gravity.
920 */
921 ContentGravity get_content_gravity() const;
922
923
924 /** Sets the minification and magnification filter to be applied when
925 * scaling the Clutter::Actor::property_content() of a Clutter::Actor.
926 *
927 * The Clutter::Actor::property_minification_filter() will be used when reducing
928 * the size of the content; the Clutter::Actor::property_magnification_filter()
929 * will be used when increasing the size of the content.
930 *
931 * @newin{1,10}
932 * @param min_filter The minification filter for the content.
933 * @param mag_filter The magnification filter for the content.
934 */
935 void set_content_scaling_filters(ScalingFilter min_filter, ScalingFilter mag_filter);
936
937
938 /** Retrieves the values set using set_content_scaling_filters().
939 *
940 * @newin{1,10}
941 * @param min_filter Return location for the minification
942 * filter, or <tt>0</tt>.
943 * @param mag_filter Return location for the magnification
944 * filter, or <tt>0</tt>.
945 */
946 void get_content_scaling_filters(ScalingFilter& min_filter, ScalingFilter& mag_filter);
947
948
949 /** Sets the policy for repeating the Clutter::Actor::property_content() of a
950 * Clutter::Actor. The behaviour is deferred to the Clutter::Content
951 * implementation.
952 *
953 * @newin{1,12}
954 * @param repeat The repeat policy.
955 */
956 void set_content_repeat(ContentRepeat repeat);
957
958 /** Retrieves the repeat policy for a Clutter::Actor set by
959 * set_content_repeat().
960 *
961 * @newin{1,12}
962 * @return The content repeat policy.
963 */
964 ContentRepeat get_content_repeat() const;
965
966 ActorBox get_content_box() const;
967
968
969 //We ignore clutter_actor_destroy because it would break any existing RefPtr.
970
971
972 /** Retrieves the Pango::Context for @a self. The actor's Pango::Context
973 * is already configured using the appropriate font map, resolution
974 * and font options.
975 *
976 * Unlike create_pango_context(), this context is owend
977 * by the Clutter::Actor and it will be updated each time the options
978 * stored by the Clutter::Backend change.
979 *
980 * You can use the returned Pango::Context to create a Pango::Layout
981 * and render text using cogl_pango_render_layout() to reuse the
982 * glyphs cache also used by Clutter.
983 *
984 * @newin{1,0}
985 * @return The Pango::Context for a Clutter::Actor.
986 * The returned Pango::Context is owned by the actor and should not be
987 * unreferenced by the application code.
988 */
989 Glib::RefPtr<Pango::Context> get_pango_context();
990
991 /** Retrieves the Pango::Context for @a self. The actor's Pango::Context
992 * is already configured using the appropriate font map, resolution
993 * and font options.
994 *
995 * Unlike create_pango_context(), this context is owend
996 * by the Clutter::Actor and it will be updated each time the options
997 * stored by the Clutter::Backend change.
998 *
999 * You can use the returned Pango::Context to create a Pango::Layout
1000 * and render text using cogl_pango_render_layout() to reuse the
1001 * glyphs cache also used by Clutter.
1002 *
1003 * @newin{1,0}
1004 * @return The Pango::Context for a Clutter::Actor.
1005 * The returned Pango::Context is owned by the actor and should not be
1006 * unreferenced by the application code.
1007 */
1008 Glib::RefPtr<const Pango::Context> get_pango_context() const;
1009
1010 /** Creates a Pango::Context for the given actor. The Pango::Context
1011 * is already configured using the appropriate font map, resolution
1012 * and font options.
1013 *
1014 * See also get_pango_context().
1015 *
1016 * @newin{1,0}
1017 * @return The newly created Pango::Context.
1018 * Use Glib::object_unref() on the returned value to deallocate its
1019 * resources.
1020 */
1021 Glib::RefPtr<Pango::Context> create_pango_context();
1022
1023
1024 /** Creates a new Pango::Layout from the same Pango::Context used
1025 * by the Clutter::Actor. The Pango::Layout is already configured
1026 * with the font map, resolution and font options, and the
1027 * given @a text.
1028 *
1029 * If you want to keep around a Pango::Layout created by this
1030 * function you will have to connect to the Clutter::Backend::signal_font_changed()
1031 * and Clutter::Backend::signal_resolution_changed() signals, and call
1032 * pango_layout_context_changed() in response to them.
1033 *
1034 * @newin{1,0}
1035 * @param text The text to set on the Pango::Layout, or <tt>0</tt>.
1036 * @return The newly created Pango::Layout.
1037 * Use Glib::object_unref() when done.
1038 */
1039 Glib::RefPtr<Pango::Layout> create_pango_layout(const Glib::ustring& text);
1040
1041 //handcoded to allow returning the Matrix.
1042
1043 /**
1044 * Returns the transformation matrix being used by the actor.
1045 * */
1046 Matrix get_transform() const;
1047
1048
1049 #ifndef CLUTTERMM_DISABLE_DEPRECATED
1050
1051 /** Retrieves the transformations applied to @a self relative to its
1052 * parent.
1053 *
1054 * @newin{1,0}
1055 *
1056 * Deprecated: 1.12: Use get_transform() instead
1057 * @deprecated Use get_transform() instead
1058 * @param matrix The return location for a Clutter::Matrix.
1059 */
1060 void get_transformation_matrix(ClutterMatrix* matrix);
1061 #endif // CLUTTERMM_DISABLE_DEPRECATED
1062
1063
1064 /** Overrides the transformations of a Clutter::Actor with a custom
1065 * matrix, which will be applied relative to the origin of the
1066 * actor's allocation and to the actor's pivot point.
1067 *
1068 * The Clutter::Actor::property_transform() property is animatable.
1069 *
1070 * @newin{1,12}
1071 * @param transform A Clutter::Matrix, or <tt>0</tt> to
1072 * unset a custom transformation.
1073 */
1074 void set_transform(const Matrix& transform);
1075
1076 /** Sets the transformation matrix to be applied to all the children
1077 * of @a self prior to their own transformations. The default child
1078 * transformation is the identity matrix.
1079 *
1080 * If @a transform is <tt>0</tt>, the child transform will be unset.
1081 *
1082 * The Clutter::Actor::property_child_transform() property is animatable.
1083 *
1084 * @newin{1,12}
1085 * @param transform A Clutter::Matrix, or <tt>0</tt>.
1086 */
1087 void set_child_transform(const Matrix& transform);
1088
1089
1090 /** Checks whether @a self is being currently painted by a Clutter::Clone
1091 *
1092 * This function is useful only inside the signal_paint() virtual function
1093 * implementations or within handlers for the Clutter::Actor::signal_paint()
1094 * signal
1095 *
1096 * This function should not be used by applications
1097 *
1098 * @newin{1,0}
1099 * @return <tt>true</tt> if the Clutter::Actor is currently being painted
1100 * by a Clutter::Clone, and <tt>false</tt> otherwise.
1101 */
1102 bool is_in_clone_paint() const;
1103
1104
1105 /** Retrieves the paint volume of the passed Clutter::Actor, and
1106 * transforms it into a 2D bounding box in stage coordinates.
1107 *
1108 * This function is useful to determine the on screen area occupied by
1109 * the actor. The box is only an approximation and may often be
1110 * considerably larger due to the optimizations used to calculate the
1111 * box. The box is never smaller though, so it can reliably be used
1112 * for culling.
1113 *
1114 * There are times when a 2D paint box can't be determined, e.g.
1115 * because the actor isn't yet parented under a stage or because
1116 * the actor is unable to determine a paint volume.
1117 *
1118 * @newin{1,6}
1119 * @param box Return location for a Clutter::ActorBox.
1120 * @return <tt>true</tt> if a 2D paint box could be determined, else
1121 * <tt>false</tt>.
1122 */
1123 bool get_paint_box(ActorBox& box);
1124
1125
1126 /** Checks whether an actor contains the pointer of a
1127 * Clutter::InputDevice
1128 *
1129 * @newin{1,2}
1130 * @return <tt>true</tt> if the actor contains the pointer, and
1131 * <tt>false</tt> otherwise.
1132 */
1133 bool has_pointer() const;
1134
1135 /** Sets the Clutter::TextDirection for an actor
1136 *
1137 * The passed text direction must not be Clutter::TEXT_DIRECTION_DEFAULT
1138 *
1139 * If @a self implements Clutter::Container then this function will recurse
1140 * inside all the children of @a self (including the internal ones).
1141 *
1142 * Composite actors not implementing Clutter::Container, or actors requiring
1143 * special handling when the text direction changes, should connect to
1144 * the Object::signal_notify() signal for the Clutter::Actor::property_text_direction() property
1145 *
1146 * @newin{1,2}
1147 * @param text_dir The text direction for @a self.
1148 */
1149 void set_text_direction(TextDirection text_dir);
1150
1151 /** Retrieves the value set using set_text_direction()
1152 *
1153 * If no text direction has been previously set, the default text
1154 * direction, as returned by clutter_get_default_text_direction(), will
1155 * be returned instead
1156 *
1157 * @newin{1,2}
1158 * @return The Clutter::TextDirection for the actor.
1159 */
1160 TextDirection get_text_direction() const;
1161
1162
1163 /** Retrieves the Clutter::Stage where @a actor is contained.
1164 *
1165 * @newin{0,8}
1166 * @return The stage
1167 * containing the actor, or <tt>0</tt>.
1168 */
1169 Glib::RefPtr<Actor> get_stage();
1170
1171 /** Retrieves the Clutter::Stage where @a actor is contained.
1172 *
1173 * @newin{0,8}
1174 * @return The stage
1175 * containing the actor, or <tt>0</tt>.
1176 */
1177 Glib::RefPtr<const Actor> get_stage() const;
1178
1179
1180 /** Sets @a child to be below @a sibling in the list of children of @a self.
1181 *
1182 * If @a sibling is <tt>0</tt>, @a child will be the new first child of @a self.
1183 *
1184 * This function is logically equivalent to removing @a self and using
1185 * insert_child_below(), but it will not emit signals
1186 * or change state on @a child.
1187 *
1188 * @newin{1,10}
1189 * @param child A Clutter::Actor child of @a self.
1190 * @param sibling A Clutter::Actor child of @a self, or <tt>0</tt>.
1191 */
1192 void set_child_below_sibling(const Glib::RefPtr<Actor>& child, const Glib::RefPtr<Actor>& sibling);
1193
1194 /** Sets @a child to be above @a sibling in the list of children of @a self.
1195 *
1196 * If @a sibling is <tt>0</tt>, @a child will be the new last child of @a self.
1197 *
1198 * This function is logically equivalent to removing @a child and using
1199 * insert_child_above(), but it will not emit signals
1200 * or change state on @a child.
1201 *
1202 * @newin{1,10}
1203 * @param child A Clutter::Actor child of @a self.
1204 * @param sibling A Clutter::Actor child of @a self, or <tt>0</tt>.
1205 */
1206 void set_child_above_sibling(const Glib::RefPtr<Actor>& child, const Glib::RefPtr<Actor>& sibling);
1207
1208 /** Changes the index of @a child in the list of children of @a self.
1209 *
1210 * This function is logically equivalent to removing @a child and
1211 * calling insert_child_at_index(), but it will not
1212 * emit signals or change state on @a child.
1213 *
1214 * @newin{1,10}
1215 * @param child A Clutter::Actor child of @a self.
1216 * @param index The new index for @a child.
1217 */
1218 void set_child_at_index(const Glib::RefPtr<Actor>& child, int index);
1219
1220
1221 #ifndef CLUTTERMM_DISABLE_DEPRECATED
1222
1223 /** Sets the actor's fixed position and forces its minimum and natural
1224 * size, in pixels. This means the untransformed actor will have the
1225 * given geometry. This is the same as calling set_position()
1226 * and set_size().
1227 *
1228 * Deprecated: 1.10: Use set_position() and
1229 * set_size() instead.
1230 * @deprecated Use set_position() and set_size() instead.
1231 * @param geometry A Clutter::Geometry.
1232 */
1233 void set_geometry(const Geometry& geometry);
1234 #endif // CLUTTERMM_DISABLE_DEPRECATED
1235
1236
1237 #ifndef CLUTTERMM_DISABLE_DEPRECATED
1238
1239
1240 /** Gets the size and position of an actor relative to its parent
1241 * actor. This is the same as calling get_position() and
1242 * get_size(). It tries to "do what you mean" and get the
1243 * requested size and position if the actor's allocation is invalid.
1244 *
1245 * Deprecated: 1.10: Use get_position() and
1246 * get_size(), or get_allocation_geometry()
1247 * instead.
1248 * @param geometry A location to store actors Clutter::Geometry.
1249 */
1250
1251 /**
1252 * @deprecated Use get_position() and get_size(), or get_allocation_geometry() instead.
1253 */
1254 Geometry get_geometry() const;
1255 #endif // CLUTTERMM_DISABLE_DEPRECATED
1256
1257
1258 //_WRAP_METHOD(void get_coords(float *x_1, float *y_1, float *x_2, float *y_2) const, clutter_actor_get_coords)
1259
1260 /** Sets the actor's size request in pixels. This overrides any
1261 * "normal" size request the actor would have. For example
1262 * a text actor might normally request the size of the text;
1263 * this function would force a specific size instead.
1264 *
1265 * If @a width and/or @a height are -1 the actor will use its
1266 * "normal" size request instead of overriding it, i.e.
1267 * you can "unset" the size with -1.
1268 *
1269 * This function sets or unsets both the minimum and natural size.
1270 * @param width New width of actor in pixels, or -1.
1271 * @param height New height of actor in pixels, or -1.
1272 */
1273 void set_size(float width, float height);
1274
1275 /** This function tries to "do what you mean" and tell you where the
1276 * actor is, prior to any transformations. Retrieves the fixed
1277 * position of an actor in pixels, if one has been set; otherwise, if
1278 * the allocation is valid, returns the actor's allocated position;
1279 * otherwise, returns 0,0.
1280 *
1281 * The returned position is in pixels.
1282 *
1283 * @newin{0,6}
1284 * @param x Return location for the X coordinate, or <tt>0</tt>.
1285 * @param y Return location for the Y coordinate, or <tt>0</tt>.
1286 */
1287 void get_position(float& x, float& y);
1288
1289 /** Sets the actor's fixed position in pixels relative to any parent
1290 * actor.
1291 *
1292 * If a layout manager is in use, this position will override the
1293 * layout manager and force a fixed position.
1294 * @param x New left position of actor in pixels.
1295 * @param y New top position of actor in pixels.
1296 */
1297 void set_position(float x, float y);
1298 //_WRAP_METHOD(void get_abs_position(float& x, float& y) const, clutter_actor_get_abs_position)
1299
1300 /** Retrieves the width of a Clutter::Actor.
1301 *
1302 * If the actor has a valid allocation, this function will return the
1303 * width of the allocated area given to the actor.
1304 *
1305 * If the actor does not have a valid allocation, this function will
1306 * return the actor's natural width, that is the preferred width of
1307 * the actor.
1308 *
1309 * If you care whether you get the preferred width or the width that
1310 * has been assigned to the actor, you should probably call a different
1311 * function like get_allocation_box() to retrieve the
1312 * allocated size or get_preferred_width() to retrieve the
1313 * preferred width.
1314 *
1315 * If an actor has a fixed width, for instance a width that has been
1316 * assigned using set_width(), the width returned will
1317 * be the same value.
1318 * @return The width of the actor, in pixels.
1319 */
1320 float get_width() const;
1321
1322 /** Retrieves the height of a Clutter::Actor.
1323 *
1324 * If the actor has a valid allocation, this function will return the
1325 * height of the allocated area given to the actor.
1326 *
1327 * If the actor does not have a valid allocation, this function will
1328 * return the actor's natural height, that is the preferred height of
1329 * the actor.
1330 *
1331 * If you care whether you get the preferred height or the height that
1332 * has been assigned to the actor, you should probably call a different
1333 * function like get_allocation_box() to retrieve the
1334 * allocated size or get_preferred_height() to retrieve the
1335 * preferred height.
1336 *
1337 * If an actor has a fixed height, for instance a height that has been
1338 * assigned using set_height(), the height returned will
1339 * be the same value.
1340 * @return The height of the actor, in pixels.
1341 */
1342 float get_height() const;
1343
1344 /** Forces a width on an actor, causing the actor's preferred width
1345 * and height (if any) to be ignored.
1346 *
1347 * If @a width is -1 the actor will use its preferred width request
1348 * instead of overriding it, i.e. you can "unset" the width with -1.
1349 *
1350 * This function sets both the minimum and natural size of the actor.
1351 *
1352 * since: 0.2
1353 * @param width Requested new width for the actor, in pixels, or -1.
1354 */
1355 void set_width(float width);
1356
1357 /** Forces a height on an actor, causing the actor's preferred width
1358 * and height (if any) to be ignored.
1359 *
1360 * If @a height is -1 the actor will use its preferred height instead of
1361 * overriding it, i.e. you can "unset" the height with -1.
1362 *
1363 * This function sets both the minimum and natural size of the actor.
1364 *
1365 * since: 0.2
1366 * @param height Requested new height for the actor, in pixels, or -1.
1367 */
1368 void set_height(float height);
1369
1370
1371 /** Sets the actor's X coordinate, relative to its parent, in pixels.
1372 *
1373 * Overrides any layout manager and forces a fixed position for
1374 * the actor.
1375 *
1376 * The Clutter::Actor::property_x() property is animatable.
1377 *
1378 * @newin{0,6}
1379 * @param x The actor's position on the X axis.
1380 */
1381 void set_x(float x);
1382
1383 /** Retrieves the X coordinate of a Clutter::Actor.
1384 *
1385 * This function tries to "do what you mean", by returning the
1386 * correct value depending on the actor's state.
1387 *
1388 * If the actor has a valid allocation, this function will return
1389 * the X coordinate of the origin of the allocation box.
1390 *
1391 * If the actor has any fixed coordinate set using set_x(),
1392 * set_position() or set_geometry(), this
1393 * function will return that coordinate.
1394 *
1395 * If both the allocation and a fixed position are missing, this function
1396 * will return 0.
1397 * @return The X coordinate, in pixels, ignoring any
1398 * transformation (i.e. scaling, rotation).
1399 */
1400 float get_x() const;
1401
1402 /** Sets the actor's Y coordinate, relative to its parent, in pixels.#
1403 *
1404 * Overrides any layout manager and forces a fixed position for
1405 * the actor.
1406 *
1407 * The Clutter::Actor::property_y() property is animatable.
1408 *
1409 * @newin{0,6}
1410 * @param y The actor's position on the Y axis.
1411 */
1412 void set_y(float y);
1413
1414 /** Retrieves the Y coordinate of a Clutter::Actor.
1415 *
1416 * This function tries to "do what you mean", by returning the
1417 * correct value depending on the actor's state.
1418 *
1419 * If the actor has a valid allocation, this function will return
1420 * the Y coordinate of the origin of the allocation box.
1421 *
1422 * If the actor has any fixed coordinate set using set_y(),
1423 * set_position() or set_geometry(), this
1424 * function will return that coordinate.
1425 *
1426 * If both the allocation and a fixed position are missing, this function
1427 * will return 0.
1428 * @return The Y coordinate, in pixels, ignoring any
1429 * transformation (i.e. scaling, rotation).
1430 */
1431 float get_y() const;
1432
1433 /** Sets the actor's position on the Z axis.
1434 *
1435 * See Clutter::Actor::property_z_position().
1436 *
1437 * @newin{1,12}
1438 * @param z_position The position on the Z axis.
1439 */
1440 void set_z_position(float z_position);
1441
1442 /** Retrieves the actor's position on the Z axis.
1443 *
1444 * @newin{1,12}
1445 * @return The position on the Z axis.
1446 */
1447 float get_z_position() const;
1448
1449
1450 /** Sets the horizontal alignment policy of a Clutter::Actor, in case the
1451 * actor received extra horizontal space.
1452 *
1453 * See also the Clutter::Actor::property_x_align() property.
1454 *
1455 * @newin{1,10}
1456 * @param x_align The horizontal alignment policy.
1457 */
1458 void set_x_align(ActorAlign x_align);
1459
1460 /** Retrieves the horizontal alignment policy set using
1461 * set_x_align().
1462 *
1463 * @newin{1,10}
1464 * @return The horizontal alignment policy.
1465 */
1466 ActorAlign get_x_align() const;
1467
1468 /** Sets the vertical alignment policy of a Clutter::Actor, in case the
1469 * actor received extra vertical space.
1470 *
1471 * See also the Clutter::Actor::property_y_align() property.
1472 *
1473 * @newin{1,10}
1474 * @param y_align The vertical alignment policy.
1475 */
1476 void set_y_align(ActorAlign y_align);
1477
1478 /** Retrieves the vertical alignment policy set using
1479 * set_y_align().
1480 *
1481 * @newin{1,10}
1482 * @return The vertical alignment policy.
1483 */
1484 ActorAlign get_y_align() const;
1485
1486
1487 /** Retrieves the value set with set_x_expand().
1488 *
1489 * See also: needs_expand()
1490 *
1491 * @newin{1,12}
1492 * @return <tt>true</tt> if the actor has been set to expand.
1493 */
1494 bool get_x_expand() const;
1495
1496 /** Sets whether a Clutter::Actor should expand horizontally; this means
1497 * that layout manager should allocate extra space for the actor, if
1498 * possible.
1499 *
1500 * Setting an actor to expand will also make all its parent expand, so
1501 * that it's possible to build an actor tree and only set this flag on
1502 * its leaves and not on every single actor.
1503 *
1504 * @newin{1,12}
1505 * @param expand Whether the actor should expand horizontally.
1506 */
1507 void set_x_expand(bool expand = true);
1508
1509 /** Retrieves the value set with set_y_expand().
1510 *
1511 * See also: needs_expand()
1512 *
1513 * @newin{1,12}
1514 * @return <tt>true</tt> if the actor has been set to expand.
1515 */
1516 bool get_y_expand() const;
1517
1518 /** Sets whether a Clutter::Actor should expand horizontally; this means
1519 * that layout manager should allocate extra space for the actor, if
1520 * possible.
1521 *
1522 * Setting an actor to expand will also make all its parent expand, so
1523 * that it's possible to build an actor tree and only set this flag on
1524 * its leaves and not on every single actor.
1525 *
1526 * @newin{1,12}
1527 * @param expand Whether the actor should expand vertically.
1528 */
1529 void set_y_expand(bool expand = true);
1530
1531 /** Checks whether an actor, or any of its children, is set to expand
1532 * horizontally or vertically.
1533 *
1534 * This function should only be called by layout managers that can
1535 * assign extra space to their children.
1536 *
1537 * If you want to know whether the actor was explicitly set to expand,
1538 * use get_x_expand() or get_y_expand().
1539 *
1540 * @newin{1,12}
1541 * @param orientation The direction of expansion.
1542 * @return <tt>true</tt> if the actor should expand.
1543 */
1544 bool needs_expand(Orientation orientation) const;
1545
1546
1547 /** Sets the Clutter::LayoutManager delegate object that will be used to
1548 * lay out the children of @a self.
1549 *
1550 * The Clutter::Actor will take a reference on the passed @a manager which
1551 * will be released either when the layout manager is removed, or when
1552 * the actor is destroyed.
1553 *
1554 * @newin{1,10}
1555 * @param manager A Clutter::LayoutManager, or <tt>0</tt> to unset it.
1556 */
1557 void set_layout_manager(const Glib::RefPtr<LayoutManager>& manager);
1558
1559 /** Unset the layout manager.
1560 */
1561 void unset_layout_manager();
1562
1563
1564 /** Retrieves the Clutter::LayoutManager used by @a self.
1565 *
1566 * @newin{1,10}
1567 * @return A pointer to the Clutter::LayoutManager,
1568 * or <tt>0</tt>.
1569 */
1570 Glib::RefPtr<LayoutManager> get_layout_manager();
1571
1572 /** Retrieves the Clutter::LayoutManager used by @a self.
1573 *
1574 * @newin{1,10}
1575 * @return A pointer to the Clutter::LayoutManager,
1576 * or <tt>0</tt>.
1577 */
1578 Glib::RefPtr<const LayoutManager> get_layout_manager() const;
1579
1580
1581 /** Sets @a actor as reactive. Reactive actors will receive events.
1582 *
1583 * @newin{0,6}
1584 * @param reactive Whether the actor should be reactive to events.
1585 */
1586 void set_reactive(bool reactive = true);
1587
1588 /** Checks whether @a actor is marked as reactive.
1589 *
1590 * @newin{0,6}
1591 * @return <tt>true</tt> if the actor is reactive.
1592 */
1593 bool get_reactive() const;
1594
1595 /** Checks whether @a self is the Clutter::Actor that has key focus
1596 *
1597 * @newin{1,4}
1598 * @return <tt>true</tt> if the actor has key focus, and <tt>false</tt> otherwise.
1599 */
1600 bool has_key_focus() const;
1601
1602
1603 #ifndef CLUTTERMM_DISABLE_DEPRECATED
1604
1605 /** Sets the rotation angle of @a self around the given axis.
1606 *
1607 * The rotation center coordinates used depend on the value of @a axis:
1608 * - Clutter::X_AXIS requires @a y and @a z
1609 * - Clutter::Y_AXIS requires @a x and @a z
1610 * - Clutter::Z_AXIS requires @a x and @a y
1611 *
1612 * The rotation coordinates are relative to the anchor point of the
1613 * actor, set using set_anchor_point(). If no anchor
1614 * point is set, the upper left corner is assumed as the origin.
1615 *
1616 * @newin{0,8}
1617 *
1618 * Deprecated: 1.12: Use set_rotation_angle() and
1619 * set_pivot_point() instead.
1620 * @deprecated Use set_rotation_angle() and set_pivot_point() instead.
1621 * @param axis The axis of rotation.
1622 * @param angle The angle of rotation.
1623 * @param x X coordinate of the rotation center.
1624 * @param y Y coordinate of the rotation center.
1625 * @param z Z coordinate of the rotation center.
1626 */
1627 void set_rotation(RotateAxis axis, double angle, float x, float y, float z);
1628 #endif // CLUTTERMM_DISABLE_DEPRECATED
1629
1630
1631 #ifndef CLUTTERMM_DISABLE_DEPRECATED
1632
1633 /** Sets the rotation angle of @a self around the Z axis using the center
1634 * point specified as a compass point. For example to rotate such that
1635 * the center of the actor remains static you can use
1636 * Clutter::GRAVITY_CENTER. If the actor changes size the center point
1637 * will move accordingly.
1638 *
1639 * @newin{1,0}
1640 *
1641 * Deprecated: 1.12: Use set_rotation_angle() and
1642 * set_pivot_point() instead.
1643 * @deprecated Use set_rotation_angle() and set_pivot_point() instead.
1644 * @param angle The angle of rotation.
1645 * @param gravity The center point of the rotation.
1646 */
1647 void set_z_rotation_from_gravity(double angle, Gravity gravity);
1648 #endif // CLUTTERMM_DISABLE_DEPRECATED
1649
1650
1651 #ifndef CLUTTERMM_DISABLE_DEPRECATED
1652
1653 /** Retrieves the angle and center of rotation on the given axis,
1654 * set using set_rotation().
1655 *
1656 * @newin{0,8}
1657 *
1658 * Deprecated: 1.12: Use get_rotation_angle() and
1659 * get_pivot_point() instead.
1660 * @deprecated Use get_rotation_angle() and get_pivot_point() instead.
1661 * @param axis The axis of rotation.
1662 * @param x Return value for the X coordinate of the center of rotation.
1663 * @param y Return value for the Y coordinate of the center of rotation.
1664 * @param z Return value for the Z coordinate of the center of rotation.
1665 * @return The angle of rotation.
1666 */
1667 double get_rotation(RotateAxis axis, float& x, float& y, float& z) const;
1668 #endif // CLUTTERMM_DISABLE_DEPRECATED
1669
1670
1671 #ifndef CLUTTERMM_DISABLE_DEPRECATED
1672
1673 /** Retrieves the center for the rotation around the Z axis as a
1674 * compass direction. If the center was specified in pixels or units
1675 * this will return Clutter::GRAVITY_NONE.
1676 *
1677 * @newin{1,0}
1678 *
1679 * Deprecated: 1.12: Use the Clutter::Actor::property_pivot_point() instead of
1680 * a Clutter::Gravity
1681 * @deprecated Use the “pivot-point” instead of a Gravity.
1682 * @return The Z rotation center.
1683 */
1684 Gravity get_z_rotation_gravity() const;
1685 #endif // CLUTTERMM_DISABLE_DEPRECATED
1686
1687
1688 /** Sets the actor's opacity, with zero being completely transparent and
1689 * 255 (0xff) being fully opaque.
1690 *
1691 * The Clutter::Actor::property_opacity() property is animatable.
1692 * @param opacity New opacity value for the actor.
1693 */
1694 void set_opacity(guint8 opacity);
1695
1696 /** Retrieves the opacity value of an actor, as set by
1697 * set_opacity().
1698 *
1699 * For retrieving the absolute opacity of the actor inside a paint
1700 * virtual function, see get_paint_opacity().
1701 * @return The opacity of the actor.
1702 */
1703 guint8 get_opacity() const;
1704
1705
1706 /** Defines the circumstances where the actor should be redirected into
1707 * an offscreen image. The offscreen image is used to flatten the
1708 * actor into a single image while painting for two main reasons.
1709 * Firstly, when the actor is painted a second time without any of its
1710 * contents changing it can simply repaint the cached image without
1711 * descending further down the actor hierarchy. Secondly, it will make
1712 * the opacity look correct even if there are overlapping primitives
1713 * in the actor.
1714 *
1715 * Caching the actor could in some cases be a performance win and in
1716 * some cases be a performance lose so it is important to determine
1717 * which value is right for an actor before modifying this value. For
1718 * example, there is never any reason to flatten an actor that is just
1719 * a single texture (such as a Clutter::Texture) because it is
1720 * effectively already cached in an image so the offscreen would be
1721 * redundant. Also if the actor contains primitives that are far apart
1722 * with a large transparent area in the middle (such as a large
1723 * CluterGroup with a small actor in the top left and a small actor in
1724 * the bottom right) then the cached image will contain the entire
1725 * image of the large area and the paint will waste time blending all
1726 * of the transparent pixels in the middle.
1727 *
1728 * The default method of implementing opacity on a container simply
1729 * forwards on the opacity to all of the children. If the children are
1730 * overlapping then it will appear as if they are two separate glassy
1731 * objects and there will be a break in the color where they
1732 * overlap. By redirecting to an offscreen buffer it will be as if the
1733 * two opaque objects are combined into one and then made transparent
1734 * which is usually what is expected.
1735 *
1736 * The image below demonstrates the difference between redirecting and
1737 * not. The image shows two Clutter groups, each containing a red and
1738 * a green rectangle which overlap. The opacity on the group is set to
1739 * 128 (which is 50%). When the offscreen redirect is not used, the
1740 * red rectangle can be seen through the blue rectangle as if the two
1741 * rectangles were separately transparent. When the redirect is used
1742 * the group as a whole is transparent instead so the red rectangle is
1743 * not visible where they overlap.
1744 *
1745 * <figure id="offscreen-redirect">
1746 * <title>Sample of using an offscreen redirect for transparency</title>
1747 * <graphic fileref="offscreen-redirect.png" format="PNG"/>
1748 * </figure>
1749 *
1750 * The default value for this property is 0, so we effectively will
1751 * never redirect an actor offscreen by default. This means that there
1752 * are times that transparent actors may look glassy as described
1753 * above. The reason this is the default is because there is a
1754 * performance trade off between quality and performance here. In many
1755 * cases the default form of glassy opacity looks good enough, but if
1756 * it's not you will need to set the
1757 * Clutter::OFFSCREEN_REDIRECT_AUTOMATIC_FOR_OPACITY flag to enable
1758 * redirection for opacity.
1759 *
1760 * Custom actors that don't contain any overlapping primitives are
1761 * recommended to override the has_overlaps() virtual to return <tt>false</tt>
1762 * for maximum efficiency.
1763 *
1764 * @newin{1,8}
1765 * @param redirect New offscreen redirect flags for the actor.
1766 */
1767 void set_offscreen_redirect(OffscreenRedirect redirect) const;
1768
1769 /** Retrieves whether to redirect the actor to an offscreen buffer, as
1770 * set by set_offscreen_redirect().
1771 *
1772 * @newin{1,8}
1773 * @return The value of the offscreen-redirect property of the actor.
1774 */
1775 OffscreenRedirect get_offscreen_redirect();
1776
1777
1778 /** Sets the background color of a Clutter::Actor.
1779 *
1780 * The background color will be used to cover the whole allocation of the
1781 * actor. The default background color of an actor is transparent.
1782 *
1783 * To check whether an actor has a background color, you can use the
1784 * Clutter::Actor::property_background_color_set() actor property.
1785 *
1786 * The Clutter::Actor::property_background_color() property is animatable.
1787 *
1788 * @newin{1,10}
1789 * @param color A Clutter::Color, or <tt>0</tt> to unset a previously
1790 * set color.
1791 */
1792 void set_background_color(const Color& color);
1793
1794 /** Retrieves the color set using set_background_color().
1795 */
1796 Color get_background_color() const;
1797
1798
1799 /** Retrieves the paint volume of the passed Clutter::Actor, or <tt>0</tt>
1800 * when a paint volume can't be determined.
1801 *
1802 * The paint volume is defined as the 3D space occupied by an actor
1803 * when being painted.
1804 *
1805 * This function will call the <tt>get_paint_volume()</tt>
1806 * virtual function of the Clutter::Actor class. Sub-classes of Clutter::Actor
1807 * should not usually care about overriding the default implementation,
1808 * unless they are, for instance: painting outside their allocation, or
1809 * actors with a depth factor (not in terms of Clutter::Actor::property_depth() but real
1810 * 3D depth).
1811 *
1812 * <note>2D actors overriding <tt>get_paint_volume()</tt>
1813 * ensure their volume has a depth of 0. (This will be true so long as
1814 * you don't call clutter_paint_volume_set_depth().)</note>
1815 *
1816 * @newin{1,6}
1817 * @return A pointer to a Clutter::PaintVolume,
1818 * or <tt>0</tt> if no volume could be determined. The returned pointer
1819 * is not guaranteed to be valid across multiple frames; if you want
1820 * to keep it, you will need to copy it using clutter_paint_volume_copy().
1821 */
1822 const PaintVolume* get_paint_volume() const;
1823
1824 /** Retrieves the 3D paint volume of an actor like
1825 * get_paint_volume() does (Please refer to the
1826 * documentation of get_paint_volume() for more
1827 * details.) and it additionally transforms the paint volume into the
1828 * coordinate space of @a relative_to_ancestor. (Or the stage if <tt>0</tt>
1829 * is passed for @a relative_to_ancestor)
1830 *
1831 * This can be used by containers that base their paint volume on
1832 * the volume of their children. Such containers can query the
1833 * transformed paint volume of all of its children and union them
1834 * together using clutter_paint_volume_union().
1835 *
1836 * @newin{1,6}
1837 * @param relative_to_ancestor A Clutter::Actor that is an ancestor of @a self
1838 * (or <tt>0</tt> for the stage).
1839 * @return A pointer to a Clutter::PaintVolume,
1840 * or <tt>0</tt> if no volume could be determined. The returned pointer is
1841 * not guaranteed to be valid across multiple frames; if you wish to
1842 * keep it, you will have to copy it using clutter_paint_volume_copy().
1843 */
1844 const PaintVolume* get_transformed_paint_volume(const Glib::RefPtr<Actor>& relative_to_ancestor) const;
1845
1846 /// A get_transformed_paint_volume() convenience overload.
1847 const PaintVolume* get_transformed_paint_volume() const;
1848
1849 /** Retrieves the default paint volume for @a self.
1850 *
1851 * This function provides the same Clutter::PaintVolume that would be
1852 * computed by the default implementation inside Clutter::Actor of the
1853 * Clutter::ActorClass.get_paint_volume() virtual function.
1854 *
1855 * This function should only be used by Clutter::Actor subclasses that
1856 * cannot chain up to the parent implementation when computing their
1857 * paint volume.
1858 *
1859 * @newin{1,10}
1860 * @return A pointer to the default
1861 * Clutter::PaintVolume, relative to the Clutter::Actor, or <tt>0</tt> if
1862 * the actor could not compute a valid paint volume. The returned value
1863 * is not guaranteed to be stable across multiple frames, so if you
1864 * want to retain it, you will need to copy it using
1865 * clutter_paint_volume_copy().
1866 */
1867 const PaintVolume* get_default_paint_volume() const;
1868
1869
1870 /** Sets the given name to @a self. The name can be used to identify
1871 * a Clutter::Actor.
1872 * @param name Textual tag to apply to actor.
1873 */
1874 void set_name(const gchar * name);
1875
1876 /** Retrieves the name of @a self.
1877 * @return The name of the actor, or <tt>0</tt>. The returned string is
1878 * owned by the actor and should not be modified or freed.
1879 */
1880 Glib::ustring get_name() const;
1881
1882 /** Retrieves the unique id for @a self.
1883 *
1884 * @newin{0,6}
1885 *
1886 * Deprecated: 1.8: The id is not used any longer.
1887 * @return Globally unique value for this object instance.
1888 */
1889 guint32 get_gid() const;
1890
1891 /** Sets clip area for @a self. The clip area is always computed from the
1892 * upper left corner of the actor, even if the anchor point is set
1893 * otherwise.
1894 *
1895 * @newin{0,6}
1896 * @param xoff X offset of the clip rectangle.
1897 * @param yoff Y offset of the clip rectangle.
1898 * @param width Width of the clip rectangle.
1899 * @param height Height of the clip rectangle.
1900 */
1901 void set_clip(float xoff, float yoff, float width, float height);
1902
1903 /** Gets the clip area for @a self, if any is set.
1904 *
1905 * @newin{0,6}
1906 * @param xoff Return location for the X offset of
1907 * the clip rectangle, or <tt>0</tt>.
1908 * @param yoff Return location for the Y offset of
1909 * the clip rectangle, or <tt>0</tt>.
1910 * @param width Return location for the width of
1911 * the clip rectangle, or <tt>0</tt>.
1912 * @param height Return location for the height of
1913 * the clip rectangle, or <tt>0</tt>.
1914 */
1915 void get_clip(float& xoff, float& yoff, float& width, float& height);
1916
1917 /** Sets whether @a self should be clipped to the same size as its
1918 * allocation
1919 *
1920 * @newin{1,4}
1921 * @param clip_set <tt>true</tt> to apply a clip tracking the allocation.
1922 */
1923 void set_clip_to_allocation(bool clip_set = true);
1924
1925 /** Retrieves the value set using set_clip_to_allocation()
1926 *
1927 * @newin{1,4}
1928 * @return <tt>true</tt> if the Clutter::Actor is clipped to its allocation.
1929 */
1930 bool get_clip_to_allocation() const;
1931
1932 /** Removes clip area from @a self.
1933 */
1934 void remove_clip();
1935
1936 /** Determines whether the actor has a clip area set or not.
1937 *
1938 * @newin{0,1,1}
1939 * @return <tt>true</tt> if the actor has a clip area set.
1940 */
1941 bool has_clip() const;
1942
1943
1944 /** Retrieves the list of children of @a self.
1945 *
1946 * @newin{1,10}
1947 * @return A newly
1948 * allocated List of Clutter::Actor<!-- -->s. Use Glib::list_free() when
1949 * done.
1950 */
1951 std::vector< Glib::RefPtr<Actor> > get_children();
1952
1953
1954 /** Retrieves the list of children of @a self.
1955 *
1956 * @newin{1,10}
1957 * @return A newly
1958 * allocated List of Clutter::Actor<!-- -->s. Use Glib::list_free() when
1959 * done.
1960 */
1961 std::vector< Glib::RefPtr<const Actor> > get_children() const;
1962
1963
1964 /** Retrieves the number of children of @a self.
1965 *
1966 * @newin{1,10}
1967 * @return The number of children of an actor.
1968 */
1969 int get_n_children() const;
1970
1971
1972 /** Retrieves the actor at the given @a index inside the list of
1973 * children of @a self.
1974 *
1975 * @newin{1,10}
1976 * @param index The position in the list of children.
1977 * @return A pointer to a Clutter::Actor, or <tt>0</tt>.
1978 */
1979 Glib::RefPtr<Actor> get_child_at_index(int index);
1980
1981 /** Retrieves the actor at the given @a index inside the list of
1982 * children of @a self.
1983 *
1984 * @newin{1,10}
1985 * @param index The position in the list of children.
1986 * @return A pointer to a Clutter::Actor, or <tt>0</tt>.
1987 */
1988 Glib::RefPtr<const Actor> get_child_at_index(int index) const;
1989
1990
1991 /** Retrieves the sibling of @a self that comes before it in the list
1992 * of children of @a self's parent.
1993 *
1994 * The returned pointer is only valid until the scene graph changes; it
1995 * is not safe to modify the list of children of @a self while iterating
1996 * it.
1997 *
1998 * @newin{1,10}
1999 * @return A pointer to a Clutter::Actor, or <tt>0</tt>.
2000 */
2001 Glib::RefPtr<Actor> get_previous_sibling();
2002
2003 /** Retrieves the sibling of @a self that comes before it in the list
2004 * of children of @a self's parent.
2005 *
2006 * The returned pointer is only valid until the scene graph changes; it
2007 * is not safe to modify the list of children of @a self while iterating
2008 * it.
2009 *
2010 * @newin{1,10}
2011 * @return A pointer to a Clutter::Actor, or <tt>0</tt>.
2012 */
2013 Glib::RefPtr<const Actor> get_previous_sibling() const;
2014
2015
2016 /** Retrieves the sibling of @a self that comes after it in the list
2017 * of children of @a self's parent.
2018 *
2019 * The returned pointer is only valid until the scene graph changes; it
2020 * is not safe to modify the list of children of @a self while iterating
2021 * it.
2022 *
2023 * @newin{1,10}
2024 * @return A pointer to a Clutter::Actor, or <tt>0</tt>.
2025 */
2026 Glib::RefPtr<Actor> get_next_sibling();
2027
2028 /** Retrieves the sibling of @a self that comes after it in the list
2029 * of children of @a self's parent.
2030 *
2031 * The returned pointer is only valid until the scene graph changes; it
2032 * is not safe to modify the list of children of @a self while iterating
2033 * it.
2034 *
2035 * @newin{1,10}
2036 * @return A pointer to a Clutter::Actor, or <tt>0</tt>.
2037 */
2038 Glib::RefPtr<const Actor> get_next_sibling() const;
2039
2040
2041 /** Retrieves the first child of @a self.
2042 *
2043 * The returned pointer is only valid until the scene graph changes; it
2044 * is not safe to modify the list of children of @a self while iterating
2045 * it.
2046 *
2047 * @newin{1,10}
2048 * @return A pointer to a Clutter::Actor, or <tt>0</tt>.
2049 */
2050 Glib::RefPtr<Actor> get_first_child();
2051
2052 /** Retrieves the first child of @a self.
2053 *
2054 * The returned pointer is only valid until the scene graph changes; it
2055 * is not safe to modify the list of children of @a self while iterating
2056 * it.
2057 *
2058 * @newin{1,10}
2059 * @return A pointer to a Clutter::Actor, or <tt>0</tt>.
2060 */
2061 Glib::RefPtr<const Actor> get_first_child() const;
2062
2063
2064 /** Retrieves the last child of @a self.
2065 *
2066 * The returned pointer is only valid until the scene graph changes; it
2067 * is not safe to modify the list of children of @a self while iterating
2068 * it.
2069 *
2070 * @newin{1,10}
2071 * @return A pointer to a Clutter::Actor, or <tt>0</tt>.
2072 */
2073 Glib::RefPtr<Actor> get_last_child();
2074
2075 /** Retrieves the last child of @a self.
2076 *
2077 * The returned pointer is only valid until the scene graph changes; it
2078 * is not safe to modify the list of children of @a self while iterating
2079 * it.
2080 *
2081 * @newin{1,10}
2082 * @return A pointer to a Clutter::Actor, or <tt>0</tt>.
2083 */
2084 Glib::RefPtr<const Actor> get_last_child() const;
2085
2086
2087 #ifndef CLUTTERMM_DISABLE_DEPRECATED
2088
2089 /** Sets the parent of @a self to @a parent.
2090 *
2091 * This function will result in @a parent acquiring a reference on @a self,
2092 * eventually by sinking its floating reference first. The reference
2093 * will be released by unparent().
2094 *
2095 * This function should only be called by legacy Clutter::Actor<!-- -->s
2096 * implementing the Clutter::Container interface.
2097 *
2098 * Deprecated: 1.10: Use add_child() instead.
2099 * @deprecated Use add_child() instead.
2100 * @param parent A new Clutter::Actor parent.
2101 */
2102 void set_parent(const Glib::RefPtr<Actor>& parent);
2103 #endif // CLUTTERMM_DISABLE_DEPRECATED
2104
2105
2106 /** Retrieves the parent of @a self.
2107 * @return The Clutter::Actor parent, or <tt>0</tt>
2108 * if no parent is set.
2109 */
2110 Glib::RefPtr<Actor> get_parent();
2111
2112 /** Retrieves the parent of @a self.
2113 * @return The Clutter::Actor parent, or <tt>0</tt>
2114 * if no parent is set.
2115 */
2116 Glib::RefPtr<const Actor> get_parent() const;
2117
2118 #ifndef CLUTTERMM_DISABLE_DEPRECATED
2119
2120 /** Resets the parent actor of @a self.
2121 *
2122 * This function is logically equivalent to calling unparent()
2123 * and set_parent(), but more efficiently implemented, as it
2124 * ensures the child is not finalized when unparented, and emits the
2125 * Clutter::Actor::signal_parent_set() signal only once.
2126 *
2127 * In reality, calling this function is less useful than it sounds, as some
2128 * application code may rely on changes in the intermediate state between
2129 * removal and addition of the actor from its old parent to the @a new_parent.
2130 * Thus, it is strongly encouraged to avoid using this function in application
2131 * code.
2132 *
2133 * @newin{0,2}
2134 *
2135 * Deprecated: 1.10: Use remove_child() and
2136 * add_child() instead; remember to take a reference on
2137 * the actor being removed before calling remove_child()
2138 * to avoid the reference count dropping to zero and the actor being
2139 * destroyed.
2140 * @deprecated Use remove_child() and add_child() instead.
2141 * @param new_parent The new Clutter::Actor parent.
2142 */
2143 void reparent(const Glib::RefPtr<Actor>& new_parent);
2144 #endif // CLUTTERMM_DISABLE_DEPRECATED
2145
2146
2147 #ifndef CLUTTERMM_DISABLE_DEPRECATED
2148
2149 /** Removes the parent of @a self.
2150 *
2151 * This will cause the parent of @a self to release the reference
2152 * acquired when calling set_parent(), so if you
2153 * want to keep @a self you will have to acquire a reference of
2154 * your own, through Glib::object_ref().
2155 *
2156 * This function should only be called by legacy Clutter::Actor<!-- -->s
2157 * implementing the Clutter::Container interface.
2158 *
2159 * @newin{0,1,1}
2160 *
2161 * Deprecated: 1.10: Use remove_child() instead.
2162 * @deprecated Use remove_child() instead.
2163 */
2164 void unparent();
2165 #endif // CLUTTERMM_DISABLE_DEPRECATED
2166
2167
2168 /** Determines if @a descendant is contained inside @a self (either as an
2169 * immediate child, or as a deeper descendant). If @a self and
2170 * @a descendant point to the same actor then it will also return <tt>true</tt>.
2171 *
2172 * @newin{1,4}
2173 * @param descendant A Clutter::Actor, possibly contained in @a self.
2174 * @return Whether @a descendent is contained within @a self.
2175 */
2176 bool contains(const Glib::RefPtr<const Actor>& descendant) const;
2177
2178 #ifndef CLUTTERMM_DISABLE_DEPRECATED
2179
2180 /** Puts @a self above @a below.
2181 *
2182 * Both actors must have the same parent, and the parent must implement
2183 * the Clutter::Container interface
2184 *
2185 * This function calls Clutter::Container::raise_child() internally.
2186 *
2187 * Deprecated: 1.10: Use set_child_above_sibling() instead.
2188 * @deprecated Use set_child_above_sibling() instead.
2189 * @param below A Clutter::Actor to raise above.
2190 */
2191 void raise(const Glib::RefPtr<Actor>& below);
2192 #endif // CLUTTERMM_DISABLE_DEPRECATED
2193
2194
2195 #ifndef CLUTTERMM_DISABLE_DEPRECATED
2196
2197 /** Puts @a self below @a above.
2198 *
2199 * Both actors must have the same parent, and the parent must implement
2200 * the Clutter::Container interface.
2201 *
2202 * This function calls Clutter::Container::lower_child() internally.
2203 *
2204 * Deprecated: 1.10: Use set_child_below_sibling() instead.
2205 * @deprecated Use set_child_below_sibling() instead
2206 * @param above A Clutter::Actor to lower below.
2207 */
2208 void lower(const Glib::RefPtr<Actor>& above);
2209 #endif // CLUTTERMM_DISABLE_DEPRECATED
2210
2211
2212 /** Raises @a self to the top.
2213 *
2214 * This function calls raise() internally.
2215 *
2216 * Deprecated: 1.10: Use set_child_above_sibling() with
2217 * a <tt>0</tt> sibling, instead.
2218 */
2219 void raise_top();
2220
2221 /** Lowers @a self to the bottom.
2222 *
2223 * This function calls lower() internally.
2224 *
2225 * Deprecated: 1.10: Use set_child_below_sibling() with
2226 * a <tt>0</tt> sibling, instead.
2227 */
2228 void lower_bottom();
2229
2230
2231 #ifndef CLUTTERMM_DISABLE_DEPRECATED
2232
2233 /** Queries the currently set Clutter::Shader on @a self.
2234 *
2235 * @newin{0,6}
2236 *
2237 * Deprecated: 1.8: Use get_effect() instead.
2238 * @deprecated Use get_effect() instead.
2239 * @return The currently set Clutter::Shader
2240 * or <tt>0</tt> if no shader is set.
2241 */
2242 Glib::RefPtr<Shader> get_shader();
2243 #endif // CLUTTERMM_DISABLE_DEPRECATED
2244
2245
2246 #ifndef CLUTTERMM_DISABLE_DEPRECATED
2247
2248 /** Queries the currently set Clutter::Shader on @a self.
2249 *
2250 * @newin{0,6}
2251 *
2252 * Deprecated: 1.8: Use get_effect() instead.
2253 * @deprecated Use get_effect() instead.
2254 * @return The currently set Clutter::Shader
2255 * or <tt>0</tt> if no shader is set.
2256 */
2257 Glib::RefPtr<const Shader> get_shader() const;
2258 #endif // CLUTTERMM_DISABLE_DEPRECATED
2259
2260
2261 #ifndef CLUTTERMM_DISABLE_DEPRECATED
2262
2263 /** Sets the Clutter::Shader to be used when rendering @a self.
2264 *
2265 * If @a shader is <tt>0</tt> this function will unset any currently set shader
2266 * for the actor.
2267 *
2268 * <note>Any Clutter::Effect applied to @a self will take the precedence
2269 * over the Clutter::Shader set using this function.</note>
2270 *
2271 * @newin{0,6}
2272 *
2273 * Deprecated: 1.8: Use Clutter::ShaderEffect and
2274 * add_effect() instead.
2275 * @deprecated Use add_effect() instead.
2276 * @param shader A Clutter::Shader or <tt>0</tt> to unset the shader.
2277 * @return <tt>true</tt> if the shader was successfully applied
2278 * or removed.
2279 */
2280 void set_shader(const Glib::RefPtr<Shader>& shader);
2281 #endif // CLUTTERMM_DISABLE_DEPRECATED
2282
2283
2284 #ifndef CLUTTERMM_DISABLE_DEPRECATED
2285
2286
2287 /** Sets the value for a named parameter of the shader applied
2288 * to @a actor.
2289 *
2290 * @newin{1,0}
2291 *
2292 * Deprecated: 1.8: Use Clutter::ShaderEffect::set_uniform_value() instead
2293 * @param param The name of the parameter.
2294 * @param value The value of the parameter.
2295 */
2296
2297 /**
2298 * @deprecated Use ShaderEffect::set_uniform_value() instead."
2299 */
2300 template <class ParamType> void set_shader_param(const Glib::ustring& param, const ParamType& value);
2301 #endif // CLUTTERMM_DISABLE_DEPRECATED
2302
2303
2304 //_WRAP_METHOD_DOCS_ONLY(clutter_actor_get_paint_area)
2305 //ActorBox get_paint_area() const;
2306
2307 /** Checks whether any rotation is applied to the actor.
2308 *
2309 * @newin{0,6}
2310 * @return <tt>true</tt> if the actor is rotated.
2311 */
2312 bool is_rotated() const;
2313
2314 /** Checks whether the actor is scaled in either dimension.
2315 *
2316 * @newin{0,6}
2317 * @return <tt>true</tt> if the actor is scaled.
2318 */
2319 bool is_scaled() const;
2320
2321
2322 /** Sets the position of the Clutter::Actor::property_pivot_point() around which the
2323 * scaling and rotation transformations occur.
2324 *
2325 * The pivot point's coordinates are in normalized space, with the (0, 0)
2326 * point being the top left corner of the actor, and the (1, 1) point being
2327 * the bottom right corner.
2328 *
2329 * @newin{1,12}
2330 * @param pivot_x The normalized X coordinate of the pivot point.
2331 * @param pivot_y The normalized Y coordinate of the pivot point.
2332 */
2333 void set_pivot_point(float x, float y);
2334
2335 /** Retrieves the coordinates of the Clutter::Actor::property_pivot_point().
2336 *
2337 * @newin{1,12}
2338 * @param pivot_x Return location for the normalized X
2339 * coordinate of the pivot point, or <tt>0</tt>.
2340 * @param pivot_y Return location for the normalized Y
2341 * coordinate of the pivot point, or <tt>0</tt>.
2342 */
2343 void get_pivot_point(float& pivot_x, float& pivot_y) const;
2344
2345 /** Sets the component on the Z axis of the Clutter::Actor::property_pivot_point() around
2346 * which the scaling and rotation transformations occur.
2347 *
2348 * The @a pivot_z value is expressed as a distance along the Z axis.
2349 *
2350 * @newin{1,12}
2351 * @param pivot_z The Z coordinate of the actor's pivot point.
2352 */
2353 void set_pivot_point_z(float pivot_z);
2354
2355 /** Retrieves the Z component of the Clutter::Actor::property_pivot_point().
2356 *
2357 * @newin{1,12}
2358 */
2359 float get_pivot_point_z() const;
2360
2361 /** Sets the @a angle of rotation of a Clutter::Actor on the given @a axis.
2362 *
2363 * This function is a convenience for setting the rotation properties
2364 * Clutter::Actor::property_rotation_angle_x(), Clutter::Actor::property_rotation_angle_y(),
2365 * and Clutter::Actor::property_rotation_angle_z().
2366 *
2367 * The center of rotation is established by the Clutter::Actor::property_pivot_point()
2368 * property.
2369 *
2370 * @newin{1,12}
2371 * @param axis The axis to set the angle one.
2372 * @param angle The angle of rotation, in degrees.
2373 */
2374 void set_rotation_angle(RotateAxis axis, double angle);
2375
2376 /** Retrieves the angle of rotation set by set_rotation_angle().
2377 *
2378 * @newin{1,12}
2379 * @param axis The axis of the rotation.
2380 * @return The angle of rotation, in degrees.
2381 */
2382 double get_rotation_angle(RotateAxis axis) const;
2383
2384
2385 /** Sets an additional translation transformation on a Clutter::Actor,
2386 * relative to the Clutter::Actor::property_pivot_point().
2387 *
2388 * @newin{1,12}
2389 * @param translate_x The translation along the X axis.
2390 * @param translate_y The translation along the Y axis.
2391 * @param translate_z The translation along the Z axis.
2392 */
2393 void set_translation(float translate_x, float translate_y, float translate_z);
2394
2395 /** Retrieves the translation set using set_translation().
2396 *
2397 * @newin{1,12}
2398 * @param translate_x Return location for the X component
2399 * of the translation, or <tt>0</tt>.
2400 * @param translate_y Return location for the Y component
2401 * of the translation, or <tt>0</tt>.
2402 * @param translate_z Return location for the Z component
2403 * of the translation, or <tt>0</tt>.
2404 */
2405 void get_translation(float& translate_x, float& translate_y, float& translate_z) const;
2406
2407
2408 /** Should be called inside the implementation of the
2409 * Clutter::Actor::signal_pick() virtual function in order to check whether
2410 * the actor should paint itself in pick mode or not.
2411 *
2412 * This function should never be called directly by applications.
2413 * @return <tt>true</tt> if the actor should paint its silhouette,
2414 * <tt>false</tt> otherwise.
2415 */
2416 bool should_pick_paint() const;
2417
2418
2419 /** Calculates the transformed coordinates of the four corners of the
2420 * actor in the plane of @a ancestor. The returned vertices relate to
2421 * the Clutter::ActorBox coordinates as follows:
2422 * - @a verts[0] contains (x1, y1)
2423 * - @a verts[1] contains (x2, y1)
2424 * - @a verts[2] contains (x1, y2)
2425 * - @a verts[3] contains (x2, y2)
2426 *
2427 * If @a ancestor is <tt>0</tt> the ancestor will be the Clutter::Stage. In
2428 * this case, the coordinates returned will be the coordinates on
2429 * the stage before the projection is applied. This is different from
2430 * the behaviour of get_abs_allocation_vertices().
2431 *
2432 * @newin{0,6}
2433 * @param ancestor A Clutter::Actor to calculate the vertices
2434 * against, or <tt>0</tt> to use the Clutter::Stage.
2435 * @param verts Return
2436 * location for an array of 4 Clutter::Vertex in which to store the result.
2437 */
2438
2439 void get_allocation_vertices(Vertex vertices[4]) const;
2440
2441
2442 /** Calculates the transformed coordinates of the four corners of the
2443 * actor in the plane of @a ancestor. The returned vertices relate to
2444 * the Clutter::ActorBox coordinates as follows:
2445 * - @a verts[0] contains (x1, y1)
2446 * - @a verts[1] contains (x2, y1)
2447 * - @a verts[2] contains (x1, y2)
2448 * - @a verts[3] contains (x2, y2)
2449 *
2450 * If @a ancestor is <tt>0</tt> the ancestor will be the Clutter::Stage. In
2451 * this case, the coordinates returned will be the coordinates on
2452 * the stage before the projection is applied. This is different from
2453 * the behaviour of get_abs_allocation_vertices().
2454 *
2455 * @newin{0,6}
2456 * @param ancestor A Clutter::Actor to calculate the vertices
2457 * against, or <tt>0</tt> to use the Clutter::Stage.
2458 * @param verts Return
2459 * location for an array of 4 Clutter::Vertex in which to store the result.
2460 */
2461
2462 void get_allocation_vertices(const Glib::RefPtr<Actor>& ancestor, Vertex vertices[4]) const;
2463
2464
2465 /** Calculates the transformed screen coordinates of the four corners of
2466 * the actor; the returned vertices relate to the Clutter::ActorBox
2467 * coordinates as follows:
2468 * - v[0] contains (x1, y1)
2469 * - v[1] contains (x2, y1)
2470 * - v[2] contains (x1, y2)
2471 * - v[3] contains (x2, y2)
2472 *
2473 * @newin{0,4}
2474 * @param verts Pointer to a location of an array
2475 * of 4 Clutter::Vertex where to store the result.
2476 */
2477
2478 void get_abs_allocation_vertices(Vertex vertices[4]) const;
2479
2480
2481 /** Allocates @a self by taking into consideration the available allocation
2482 * area; an alignment factor on either axis; and whether the actor should
2483 * fill the allocation on either axis.
2484 *
2485 * The @a box should contain the available allocation width and height;
2486 * if the x1 and y1 members of Clutter::ActorBox are not set to 0, the
2487 * allocation will be offset by their value.
2488 *
2489 * This function takes into consideration the geometry request specified by
2490 * the Clutter::Actor::property_request_mode() property, and the text direction.
2491 *
2492 * This function is useful for fluid layout managers using legacy alignment
2493 * flags. Newly written layout managers should use the Clutter::Actor::property_x_align()
2494 * and Clutter::Actor::property_y_align() properties, instead, and just call
2495 * allocate() inside their Clutter::ActorClass.allocate()
2496 * implementation.
2497 *
2498 * @newin{1,4}
2499 * @param box A Clutter::ActorBox, containing the available width and height.
2500 * @param x_align The horizontal alignment, between 0 and 1.
2501 * @param y_align The vertical alignment, between 0 and 1.
2502 * @param x_fill Whether the actor should fill horizontally.
2503 * @param y_fill Whether the actor should fill vertically.
2504 * @param flags Allocation flags to be passed to allocate().
2505 */
2506 void allocate_align_fill(const ActorBox& box, gdouble x_align, double y_align, bool x_fill, bool y_fill, AllocationFlags flags);
2507
2508
2509 /** Stores the allocation of @a self as defined by @a box.
2510 *
2511 * This function can only be called from within the implementation of
2512 * the Clutter::ActorClass.allocate() virtual function.
2513 *
2514 * The allocation should have been adjusted to take into account constraints,
2515 * alignment, and margin properties. If you are implementing a Clutter::Actor
2516 * subclass that provides its own layout management policy for its children
2517 * instead of using a Clutter::LayoutManager delegate, you should not call
2518 * this function on the children of @a self; instead, you should call
2519 * allocate(), which will adjust the allocation box for
2520 * you.
2521 *
2522 * This function should only be used by subclasses of Clutter::Actor
2523 * that wish to store their allocation but cannot chain up to the
2524 * parent's implementation; the default implementation of the
2525 * Clutter::ActorClass.allocate() virtual function will call this
2526 * function.
2527 *
2528 * It is important to note that, while chaining up was the recommended
2529 * behaviour for Clutter::Actor subclasses prior to the introduction of
2530 * this function, it is recommended to call set_allocation()
2531 * instead.
2532 *
2533 * If the Clutter::Actor is using a Clutter::LayoutManager delegate object
2534 * to handle the allocation of its children, this function will call
2535 * the Clutter::LayoutManager::allocate() function only if the
2536 * Clutter::DELEGATE_LAYOUT flag is set on @a flags, otherwise it is
2537 * expected that the subclass will call Clutter::LayoutManager::allocate()
2538 * by itself. For instance, the following code:
2539 *
2540 *
2541 * [C example ellipted]
2542 *
2543 * is equivalent to this:
2544 *
2545 *
2546 * [C example ellipted]
2547 *
2548 * @newin{1,10}
2549 * @param box A Clutter::ActorBox.
2550 * @param flags Allocation flags.
2551 */
2552 void set_allocation(const ActorBox& box, AllocationFlags flags);
2553
2554
2555 /** Gets the layout box an actor has been assigned. The allocation can
2556 * only be assumed valid inside a paint() method; anywhere else, it
2557 * may be out-of-date.
2558 *
2559 * An allocation does not incorporate the actor's scale or anchor point;
2560 * those transformations do not affect layout, only rendering.
2561 *
2562 * <note>Do not call any of the clutter_actor_get_allocation_*() family
2563 * of functions inside the implementation of the get_preferred_width()
2564 * or get_preferred_height() virtual functions.</note>
2565 *
2566 * @newin{0,8}
2567 * @param box The function fills this in with the actor's allocation.
2568 */
2569
2570 ActorBox get_allocation_box() const;
2571
2572
2573 /** Assigns the size of a Clutter::Actor from the given @a box.
2574 *
2575 * This function should only be called on the children of an actor when
2576 * overriding the Clutter::ActorClass.allocate() virtual function.
2577 *
2578 * This function will adjust the stored allocation to take into account
2579 * the alignment flags set in the Clutter::Actor::property_x_align() and
2580 * Clutter::Actor::property_y_align() properties, as well as the margin values set in
2581 * the Clutter::Actor::property_margin_top(), Clutter::Actor::property_margin_right(),
2582 * Clutter::Actor::property_margin_bottom(), and Clutter::Actor::property_margin_left() properties.
2583 *
2584 * This function will respect the easing state of the Clutter::Actor and
2585 * interpolate between the current allocation and the new one if the
2586 * easing state duration is a positive value.
2587 *
2588 * Actors can know from their allocation box whether they have moved
2589 * with respect to their parent actor. The @a flags parameter describes
2590 * additional information about the allocation, for instance whether
2591 * the parent has moved with respect to the stage, for example because
2592 * a grandparent's origin has moved.
2593 *
2594 * @newin{0,8}
2595 * @param box New allocation of the actor, in parent-relative coordinates.
2596 * @param flags Flags that control the allocation.
2597 */
2598 void allocate(const ActorBox& box, AllocationFlags absolute_origin_changed = ALLOCATION_NONE);
2599
2600 //TODO: Make this protected?
2601
2602 /** Allocates the natural size of @a self.
2603 *
2604 * This function is a utility call for Clutter::Actor implementations
2605 * that allocates the actor's preferred natural size. It can be used
2606 * by fixed layout managers (like Clutter::Group or so called
2607 * 'composite actors') inside the ClutterActor::allocate
2608 * implementation to give each child exactly how much space it
2609 * requires, regardless of the size of the parent.
2610 *
2611 * This function is not meant to be used by applications. It is also
2612 * not meant to be used outside the implementation of the
2613 * Clutter::ActorClass.allocate virtual function.
2614 *
2615 * @newin{0,8}
2616 * @param flags Flags controlling the allocation.
2617 */
2618 void allocate_preferred_size(AllocationFlags absolute_origin_changed = ALLOCATION_NONE);
2619
2620
2621 /** Allocates @a self taking into account the Clutter::Actor<!-- -->'s
2622 * preferred size, but limiting it to the maximum available width
2623 * and height provided.
2624 *
2625 * This function will do the right thing when dealing with the
2626 * actor's request mode.
2627 *
2628 * The implementation of this function is equivalent to:
2629 *
2630 *
2631 * [C example ellipted]
2632 *
2633 * This function can be used by fluid layout managers to allocate
2634 * an actor's preferred size without making it bigger than the area
2635 * available for the container.
2636 *
2637 * @newin{1,0}
2638 * @param x The actor's X coordinate.
2639 * @param y The actor's Y coordinate.
2640 * @param available_width The maximum available width, or -1 to use the
2641 * actor's natural width.
2642 * @param available_height The maximum available height, or -1 to use the
2643 * actor's natural height.
2644 * @param flags Flags controlling the allocation.
2645 */
2646 void allocate_available_size(float x, float y, float available_width, float available_height, AllocationFlags flags = ALLOCATION_NONE);
2647
2648
2649 /** Transforms @a point in coordinates relative to the actor
2650 * into screen-relative coordinates with the current actor
2651 * transformation (i.e.\ scale, rotation, etc)
2652 *
2653 * @newin{0,4}
2654 * @param point A point as Clutter::Vertex.
2655 * @param vertex The translated Clutter::Vertex.
2656 */
2657 void apply_transform_to_point(const Vertex& point, Vertex& vertex) const;
2658
2659 /** This function translates screen coordinates ( @a x, @a y) to
2660 * coordinates relative to the actor. For example, it can be used to translate
2661 * screen events from global screen coordinates into actor-local coordinates.
2662 *
2663 * The conversion can fail, notably if the transform stack results in the
2664 * actor being projected on the screen as a mere line.
2665 *
2666 * The conversion should not be expected to be pixel-perfect due to the
2667 * nature of the operation. In general the error grows when the skewing
2668 * of the actor rectangle on screen increases.
2669 *
2670 * <note>This function can be computationally intensive.</note>
2671 *
2672 * <note>This function only works when the allocation is up-to-date,
2673 * i.e. inside of paint().</note>
2674 *
2675 * @newin{0,6}
2676 * @param x X screen coordinate of the point to unproject.
2677 * @param y Y screen coordinate of the point to unproject.
2678 * @param x_out Return location for the unprojected x coordinance.
2679 * @param y_out Return location for the unprojected y coordinance.
2680 * @return <tt>true</tt> if conversion was successful.
2681 */
2682 void transform_stage_point(float x, float y, float& x_out, float& y_out) const;
2683
2684
2685 /** Transforms @a point in coordinates relative to the actor into
2686 * ancestor-relative coordinates using the relevant transform
2687 * stack (i.e.\ scale, rotation, etc).
2688 *
2689 * If @a ancestor is <tt>0</tt> the ancestor will be the Clutter::Stage. In
2690 * this case, the coordinates returned will be the coordinates on
2691 * the stage before the projection is applied. This is different from
2692 * the behaviour of apply_transform_to_point().
2693 *
2694 * @newin{0,6}
2695 * @param ancestor A Clutter::Actor ancestor, or <tt>0</tt> to use the
2696 * default Clutter::Stage.
2697 * @param point A point as Clutter::Vertex.
2698 * @param vertex The translated Clutter::Vertex.
2699 */
2700 void apply_relative_transform_to_point(const Glib::RefPtr<Actor>& ancestor, const Vertex& point, Vertex& vertex) const;
2701
2702 /** Calculates the transformed coordinates of the four corners of the
2703 * actor in the plane of @a ancestor. The returned vertices relate to
2704 * the Clutter::ActorBox coordinates as follows:
2705 * - @a verts[0] contains (x1, y1)
2706 * - @a verts[1] contains (x2, y1)
2707 * - @a verts[2] contains (x1, y2)
2708 * - @a verts[3] contains (x2, y2)
2709 *
2710 * If @a ancestor is <tt>0</tt> the ancestor will be the Clutter::Stage. In
2711 * this case, the coordinates returned will be the coordinates on
2712 * the stage before the projection is applied. This is different from
2713 * the behaviour of get_abs_allocation_vertices().
2714 *
2715 * @newin{0,6}
2716 * @param ancestor A Clutter::Actor to calculate the vertices
2717 * against, or <tt>0</tt> to use the Clutter::Stage.
2718 * @param verts Return
2719 * location for an array of 4 Clutter::Vertex in which to store the result.
2720 */
2721
2722 void apply_relative_transform_to_point(const Vertex& point, Vertex& vertex) const;
2723
2724 /** Gets the absolute position of an actor, in pixels relative to the stage.
2725 *
2726 * @newin{0,8}
2727 * @param x Return location for the X coordinate, or <tt>0</tt>.
2728 * @param y Return location for the Y coordinate, or <tt>0</tt>.
2729 */
2730 void get_transformed_position(float& x, float& y) const;
2731
2732 Matrix get_child_transform() const;
2733
2734
2735 /** Gets the absolute size of an actor in pixels, taking into account the
2736 * scaling factors.
2737 *
2738 * If the actor has a valid allocation, the allocated size will be used.
2739 * If the actor has not a valid allocation then the preferred size will
2740 * be transformed and returned.
2741 *
2742 * If you want the transformed allocation, see
2743 * get_abs_allocation_vertices() instead.
2744 *
2745 * <note>When the actor (or one of its ancestors) is rotated around the
2746 * X or Y axis, it no longer appears as on the stage as a rectangle, but
2747 * as a generic quadrangle; in that case this function returns the size
2748 * of the smallest rectangle that encapsulates the entire quad. Please
2749 * note that in this case no assumptions can be made about the relative
2750 * position of this envelope to the absolute position of the actor, as
2751 * returned by get_transformed_position(); if you need this
2752 * information, you need to use get_abs_allocation_vertices()
2753 * to get the coords of the actual quadrangle.</note>
2754 *
2755 * @newin{0,8}
2756 * @param width Return location for the width, or <tt>0</tt>.
2757 * @param height Return location for the height, or <tt>0</tt>.
2758 */
2759 void get_transformed_size(float& width, float& height) const;
2760
2761
2762 /** Sets the geometry request mode of @a self.
2763 *
2764 * The @a mode determines the order for invoking
2765 * get_preferred_width() and
2766 * get_preferred_height()
2767 *
2768 * @newin{1,2}
2769 * @param mode The request mode.
2770 */
2771 void set_request_mode(RequestMode mode);
2772
2773 /** Retrieves the geometry request mode of @a self
2774 *
2775 * @newin{1,2}
2776 * @return The request mode for the actor.
2777 */
2778 RequestMode get_request_mode() const;
2779
2780
2781 /** Computes the preferred minimum and natural size of an actor, taking into
2782 * account the actor's geometry management (either height-for-width
2783 * or width-for-height).
2784 *
2785 * The width and height used to compute the preferred height and preferred
2786 * width are the actor's natural ones.
2787 *
2788 * If you need to control the height for the preferred width, or the width for
2789 * the preferred height, you should use get_preferred_width()
2790 * and get_preferred_height(), and check the actor's preferred
2791 * geometry management using the Clutter::Actor::property_request_mode() property.
2792 *
2793 * @newin{0,8}
2794 * @param min_width_p Return location for the minimum
2795 * width, or <tt>0</tt>.
2796 * @param min_height_p Return location for the minimum
2797 * height, or <tt>0</tt>.
2798 * @param natural_width_p Return location for the natural
2799 * width, or <tt>0</tt>.
2800 * @param natural_height_p Return location for the natural
2801 * height, or <tt>0</tt>.
2802 */
2803 void get_preferred_size(float& min_width_p, float& min_height_p, float& natural_width_p, float& natural_height_p) const;
2804
2805 /** Computes the requested minimum and natural widths for an actor,
2806 * optionally depending on the specified height, or if they are
2807 * already computed, returns the cached values.
2808 *
2809 * An actor may not get its request - depending on the layout
2810 * manager that's in effect.
2811 *
2812 * A request should not incorporate the actor's scale or anchor point;
2813 * those transformations do not affect layout, only rendering.
2814 *
2815 * @newin{0,8}
2816 * @param for_height Available height when computing the preferred width,
2817 * or a negative value to indicate that no height is defined.
2818 * @param min_width_p Return location for minimum width,
2819 * or <tt>0</tt>.
2820 * @param natural_width_p Return location for the natural
2821 * width, or <tt>0</tt>.
2822 */
2823 void get_preferred_width(float for_height, float& min_width_p, float& natural_width_p) const;
2824
2825 /** Computes the requested minimum and natural heights for an actor,
2826 * or if they are already computed, returns the cached values.
2827 *
2828 * An actor may not get its request - depending on the layout
2829 * manager that's in effect.
2830 *
2831 * A request should not incorporate the actor's scale or anchor point;
2832 * those transformations do not affect layout, only rendering.
2833 *
2834 * @newin{0,8}
2835 * @param for_width Available width to assume in computing desired height,
2836 * or a negative value to indicate that no width is defined.
2837 * @param min_height_p Return location for minimum height,
2838 * or <tt>0</tt>.
2839 * @param natural_height_p Return location for natural
2840 * height, or <tt>0</tt>.
2841 */
2842 void get_preferred_height(float for_width, float& min_height_p, float& natural_height_p) const;
2843
2844 /** Retrieves the absolute opacity of the actor, as it appears on the stage.
2845 *
2846 * This function traverses the hierarchy chain and composites the opacity of
2847 * the actor with that of its parents.
2848 *
2849 * This function is intended for subclasses to use in the paint virtual
2850 * function, to paint themselves with the correct opacity.
2851 *
2852 * @newin{0,8}
2853 * @return The actor opacity value.
2854 */
2855 guint8 get_paint_opacity() const;
2856
2857 /** Retrieves the 'paint' visibility of an actor recursively checking for non
2858 * visible parents.
2859 *
2860 * This is by definition the same as Clutter::ACTOR_IS_MAPPED.
2861 *
2862 * @newin{0,8,4}
2863 * @return <tt>true</tt> if the actor is visibile and will be painted.
2864 */
2865 bool get_paint_visibility() const;
2866
2867 #ifndef CLUTTERMM_DISABLE_DEPRECATED
2868
2869 /** Sets an anchor point on the actor based on the given gravity, adjusting the
2870 * actor postion so that its relative position within its parent remains
2871 * unchanged.
2872 *
2873 * Since version 1.0 the anchor point will be stored as a gravity so
2874 * that if the actor changes size then the anchor point will move. For
2875 * example, if you set the anchor point to Clutter::GRAVITY_SOUTH_EAST
2876 * and later double the size of the actor, the anchor point will move
2877 * to the bottom right.
2878 *
2879 * @newin{0,6}
2880 *
2881 * Deprecated: 1.12: Use Clutter::Actor::property_pivot_point() instead.
2882 * @deprecated Use “pivot-point” instead.
2883 * @param gravity Clutter::Gravity.
2884 */
2885 void move_anchor_point_from_gravity(Gravity gravity);
2886 #endif // CLUTTERMM_DISABLE_DEPRECATED
2887
2888
2889 #ifndef CLUTTERMM_DISABLE_DEPRECATED
2890
2891 /** Sets an anchor point for the actor, and adjusts the actor postion so that
2892 * the relative position of the actor toward its parent remains the same.
2893 *
2894 * @newin{0,6}
2895 *
2896 * Deprecated: 1.12: Use Clutter::Actor::property_pivot_point() instead.
2897 * @deprecated Use “pivot-point” instead.
2898 * @param anchor_x X coordinate of the anchor point.
2899 * @param anchor_y Y coordinate of the anchor point.
2900 */
2901 void move_anchor_point(float anchor_x, float anchor_y);
2902 #endif // CLUTTERMM_DISABLE_DEPRECATED
2903
2904
2905 // IM: ClutterMargin.
2906
2907
2908 /** Sets the margin from the top of a Clutter::Actor.
2909 *
2910 * The Clutter::Actor::property_margin_top() property is animatable.
2911 *
2912 * @newin{1,10}
2913 * @param margin The top margin.
2914 */
2915 void set_margin_top(float margin);
2916
2917 /** Retrieves the top margin of a Clutter::Actor.
2918 *
2919 * @newin{1,10}
2920 * @return The top margin.
2921 */
2922 float get_margin_top() const;
2923
2924 /** Sets the margin from the bottom of a Clutter::Actor.
2925 *
2926 * The Clutter::Actor::property_margin_bottom() property is animatable.
2927 *
2928 * @newin{1,10}
2929 * @param margin The bottom margin.
2930 */
2931 void set_margin_bottom(float margin);
2932
2933 /** Retrieves the bottom margin of a Clutter::Actor.
2934 *
2935 * @newin{1,10}
2936 * @return The bottom margin.
2937 */
2938 float get_margin_bottom() const;
2939
2940 /** Sets the margin from the left of a Clutter::Actor.
2941 *
2942 * The Clutter::Actor::property_margin_left() property is animatable.
2943 *
2944 * @newin{1,10}
2945 * @param margin The left margin.
2946 */
2947 void set_margin_left(float margin);
2948
2949 /** Retrieves the left margin of a Clutter::Actor.
2950 *
2951 * @newin{1,10}
2952 * @return The left margin.
2953 */
2954 float get_margin_left() const;
2955
2956 /** Sets the margin from the right of a Clutter::Actor.
2957 *
2958 * The Clutter::Actor::property_margin_right() property is animatable.
2959 *
2960 * @newin{1,10}
2961 * @param margin The right margin.
2962 */
2963 void set_margin_right(float margin);
2964
2965 /** Retrieves the right margin of a Clutter::Actor.
2966 *
2967 * @newin{1,10}
2968 * @return The right margin.
2969 */
2970 float get_margin_right() const;
2971 /**
2972 * Convenience method for setting all margins at once.
2973 *
2974 * @param top The top margin
2975 * @param left the left margin
2976 * @param bottom The bottom margin
2977 * @param right The right margin.
2978 * */
2979 void set_margins(float top, float left, float bottom, float right);
2980
2981
2982 /** Checks whether an actor has a fixed position set (and will thus be
2983 * unaffected by any layout manager).
2984 *
2985 * @newin{0,8}
2986 * @return <tt>true</tt> if the fixed position is set on the actor.
2987 */
2988 bool get_fixed_position_set() const;
2989
2990 /** Sets whether an actor has a fixed position set (and will thus be
2991 * unaffected by any layout manager).
2992 *
2993 * @newin{0,8}
2994 * @param is_set Whether to use fixed position.
2995 */
2996 void set_fixed_position_set(bool is_set);
2997
2998 #ifndef CLUTTERMM_DISABLE_DEPRECATED
2999
3000
3001 /** Gets the layout box an actor has been assigned. The allocation can
3002 * only be assumed valid inside a paint() method; anywhere else, it
3003 * may be out-of-date.
3004 *
3005 * An allocation does not incorporate the actor's scale or anchor point;
3006 * those transformations do not affect layout, only rendering.
3007 *
3008 * The returned rectangle is in pixels.
3009 *
3010 * @newin{0,8}
3011 *
3012 * Deprecated: 1.12: Use get_allocation_box() instead.
3013 * @param geom Allocation geometry in pixels.
3014 */
3015
3016 /**
3017 * @deprecated Use get_allocation_box() instead.
3018 */
3019 Geometry get_allocation_geometry() const;
3020 #endif // CLUTTERMM_DISABLE_DEPRECATED
3021
3022
3023 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3024
3025 /** Sets the Z coordinate of @a self to @a depth.
3026 *
3027 * The unit used by @a depth is dependant on the perspective setup. See
3028 * also Clutter::Stage::set_perspective().
3029 *
3030 * Deprecated: 1.12: Use set_z_position() instead.
3031 * @deprecated Use set_z_position() instead.
3032 * @param depth Z co-ord.
3033 */
3034 void set_depth(float depth);
3035 #endif // CLUTTERMM_DISABLE_DEPRECATED
3036
3037
3038 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3039
3040 /** Retrieves the depth of @a self.
3041 *
3042 * Deprecated: 1.12: Use get_z_position() instead.
3043 * @deprecated Use get_z_position() instead.
3044 * @return The depth of the actor.
3045 */
3046 float get_depth() const;
3047 #endif // CLUTTERMM_DISABLE_DEPRECATED
3048
3049
3050 /** Scales an actor with the given factors.
3051 *
3052 * The scale transformation is relative the the Clutter::Actor::property_pivot_point().
3053 *
3054 * The Clutter::Actor::property_scale_x() and Clutter::Actor::property_scale_y() properties are
3055 * animatable.
3056 *
3057 * @newin{0,2}
3058 * @param scale_x Double factor to scale actor by horizontally.
3059 * @param scale_y Double factor to scale actor by vertically.
3060 */
3061 void set_scale(double scale_x, double scale_y);
3062
3063 /** Scales an actor on the Z axis by the given @a scale_z factor.
3064 *
3065 * The scale transformation is relative the the Clutter::Actor::property_pivot_point().
3066 *
3067 * The Clutter::Actor::property_scale_z() property is animatable.
3068 *
3069 * @newin{1,12}
3070 * @param scale_z The scaling factor along the Z axis.
3071 */
3072 void set_scale_z(double scale_z);
3073
3074 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3075
3076 /** Scales an actor with the given factors around the given center
3077 * point. The center point is specified in pixels relative to the
3078 * anchor point (usually the top left corner of the actor).
3079 *
3080 * The Clutter::Actor::property_scale_x() and Clutter::Actor::property_scale_y() properties
3081 * are animatable.
3082 *
3083 * @newin{1,0}
3084 *
3085 * Deprecated: 1.12: Use set_pivot_point() to control
3086 * the scale center
3087 * @deprecated Use set_pivot_point() to control the scale center.
3088 * @param scale_x Double factor to scale actor by horizontally.
3089 * @param scale_y Double factor to scale actor by vertically.
3090 * @param center_x X coordinate of the center of the scaling.
3091 * @param center_y Y coordinate of the center of the scaling.
3092 */
3093 void set_scale_full(double scale_x, double scale_y, float center_x, float center_y);
3094 #endif // CLUTTERMM_DISABLE_DEPRECATED
3095
3096
3097 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3098
3099 /** Scales an actor with the given factors around the given
3100 * center point. The center point is specified as one of the compass
3101 * directions in Clutter::Gravity. For example, setting it to north
3102 * will cause the top of the actor to remain unchanged and the rest of
3103 * the actor to expand left, right and downwards.
3104 *
3105 * The Clutter::Actor::property_scale_x() and Clutter::Actor::property_scale_y() properties are
3106 * animatable.
3107 *
3108 * @newin{1,0}
3109 *
3110 * Deprecated: 1.12: Use set_pivot_point() to set the
3111 * scale center using normalized coordinates instead.
3112 * @deprecated Use set_pivot_point() to set the scale center using normalized coordinates instead.
3113 * @param scale_x Double factor to scale actor by horizontally.
3114 * @param scale_y Double factor to scale actor by vertically.
3115 * @param gravity The location of the scale center expressed as a compass
3116 * direction.
3117 */
3118 void set_scale_with_gravity(double scale_x, double scale_y, Gravity gravity);
3119 #endif // CLUTTERMM_DISABLE_DEPRECATED
3120
3121
3122 /** Retrieves an actors scale factors.
3123 *
3124 * @newin{0,2}
3125 * @param scale_x Location to store horizonal
3126 * scale factor, or <tt>0</tt>.
3127 * @param scale_y Location to store vertical
3128 * scale factor, or <tt>0</tt>.
3129 */
3130 void get_scale(double& scale_x, double& scale_y) const;
3131
3132 /** Retrieves the scaling factor along the Z axis, as set using
3133 * set_scale_z().
3134 *
3135 * @newin{1,12}
3136 * @return The scaling factor along the Z axis.
3137 */
3138 double get_scale_z() const;
3139
3140 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3141
3142 /** Retrieves the scale center coordinate in pixels relative to the top
3143 * left corner of the actor. If the scale center was specified using a
3144 * Clutter::Gravity this will calculate the pixel offset using the
3145 * current size of the actor.
3146 *
3147 * @newin{1,0}
3148 *
3149 * Deprecated: 1.12: Use get_pivot_point() instead.
3150 * @deprecated Use get_pivot_point() instead.
3151 * @param center_x Location to store the X position
3152 * of the scale center, or <tt>0</tt>.
3153 * @param center_y Location to store the Y position
3154 * of the scale center, or <tt>0</tt>.
3155 */
3156 void get_scale_center(float& center_x, float& center_y) const;
3157 #endif // CLUTTERMM_DISABLE_DEPRECATED
3158
3159
3160 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3161
3162 /** Retrieves the scale center as a compass direction. If the scale
3163 * center was specified in pixels or units this will return
3164 * Clutter::GRAVITY_NONE.
3165 *
3166 * @newin{1,0}
3167 *
3168 * Deprecated: 1.12: Use get_pivot_point() instead.
3169 * @deprecated Use get_pivot_point() instead.
3170 * @return The scale gravity.
3171 */
3172 Gravity get_scale_gravity() const;
3173 #endif // CLUTTERMM_DISABLE_DEPRECATED
3174
3175
3176 //_WRAP_METHOD(void get_abs_size(float& width, float& height) const, clutter_actor_get_abs_size)
3177
3178 /** This function tries to "do what you mean" and return
3179 * the size an actor will have. If the actor has a valid
3180 * allocation, the allocation will be returned; otherwise,
3181 * the actors natural size request will be returned.
3182 *
3183 * If you care whether you get the request vs. the allocation, you
3184 * should probably call a different function like
3185 * get_allocation_box() or
3186 * get_preferred_width().
3187 *
3188 * @newin{0,2}
3189 * @param width Return location for the width, or <tt>0</tt>.
3190 * @param height Return location for the height, or <tt>0</tt>.
3191 */
3192 void get_size(float& width, float& height) const;
3193
3194 /** Moves an actor by the specified distance relative to its current
3195 * position in pixels.
3196 *
3197 * This function modifies the fixed position of an actor and thus removes
3198 * it from any layout management. Another way to move an actor is with an
3199 * anchor point, see set_anchor_point(), or with an additional
3200 * translation, using set_translation().
3201 *
3202 * @newin{0,2}
3203 * @param dx Distance to move Actor on X axis.
3204 * @param dy Distance to move Actor on Y axis.
3205 */
3206 void move_by(float dx, float dy);
3207
3208
3209 /** This function is used to emit an event on the main stage.
3210 * You should rarely need to use this function, except for
3211 * synthetising events.
3212 *
3213 * @newin{0,6}
3214 * @param event A Clutter::Event.
3215 * @param capture <tt>true</tt> if event in in capture phase, <tt>false</tt> otherwise.
3216 * @return The return value from the signal emission: <tt>true</tt>
3217 * if the actor handled the event, or <tt>false</tt> if the event was
3218 * not handled.
3219 */
3220 bool event(const ClutterEvent* event, bool capture);
3221
3222 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3223
3224 /** Retrieves the Clutter::Actor with @a id.
3225 *
3226 * @newin{0,6}
3227 *
3228 * Deprecated: 1.8: The id is not used any longer.
3229 * @deprecated The ID is no longer used.
3230 * @param id A Clutter::Actor unique id.
3231 * @return The actor with the passed id or <tt>0</tt>.
3232 * The returned actor does not have its reference count increased.
3233 */
3234 static Glib::RefPtr<Actor> get_actor_by_gid(guint32 id);
3235 #endif // CLUTTERMM_DISABLE_DEPRECATED
3236
3237
3238 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3239
3240 /** Sets an anchor point for @a self. The anchor point is a point in the
3241 * coordinate space of an actor to which the actor position within its
3242 * parent is relative; the default is (0, 0), i.e. the top-left corner
3243 * of the actor.
3244 *
3245 * @newin{0,6}
3246 *
3247 * Deprecated: 1.12: Use Clutter::Actor::property_pivot_point() instead.
3248 * @deprecated Use “pivot-point” instead.
3249 * @param anchor_x X coordinate of the anchor point.
3250 * @param anchor_y Y coordinate of the anchor point.
3251 */
3252 void set_anchor_point(float anchor_x, float anchor_y);
3253 #endif // CLUTTERMM_DISABLE_DEPRECATED
3254
3255
3256 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3257
3258 /** Gets the current anchor point of the @a actor in pixels.
3259 *
3260 * @newin{0,6}
3261 *
3262 * Deprecated: 1.12: Use Clutter::Actor::property_pivot_point() instead
3263 * @deprecated Use “pivot-point” instead.
3264 * @param anchor_x Return location for the X coordinate of the anchor point.
3265 * @param anchor_y Return location for the Y coordinate of the anchor point.
3266 */
3267 void get_anchor_point(float& anchor_x, float& anchor_y) const;
3268 #endif // CLUTTERMM_DISABLE_DEPRECATED
3269
3270
3271 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3272
3273 /** Sets an anchor point on the actor, based on the given gravity (this is a
3274 * convenience function wrapping set_anchor_point()).
3275 *
3276 * Since version 1.0 the anchor point will be stored as a gravity so
3277 * that if the actor changes size then the anchor point will move. For
3278 * example, if you set the anchor point to Clutter::GRAVITY_SOUTH_EAST
3279 * and later double the size of the actor, the anchor point will move
3280 * to the bottom right.
3281 *
3282 * @newin{0,6}
3283 *
3284 * Deprecated: 1.12: Use Clutter::Actor::property_pivot_point() instead.
3285 * @deprecated Use “pivot-point” instead.
3286 * @param gravity Clutter::Gravity.
3287 */
3288 void set_anchor_point_from_gravity(ClutterGravity gravity);
3289 #endif // CLUTTERMM_DISABLE_DEPRECATED
3290
3291
3292 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3293
3294 /** Retrieves the anchor position expressed as a Clutter::Gravity. If
3295 * the anchor point was specified using pixels or units this will
3296 * return Clutter::GRAVITY_NONE.
3297 *
3298 * @newin{1,0}
3299 *
3300 * Deprecated: 1.12: Use Clutter::Actor::property_pivot_point() instead.
3301 * @deprecated Use “pivot-point” instead.
3302 * @return The Clutter::Gravity used by the anchor point.
3303 */
3304 Gravity get_anchor_point_gravity();
3305 #endif // CLUTTERMM_DISABLE_DEPRECATED
3306
3307
3308 /** Sets the key focus of the Clutter::Stage including @a self
3309 * to this Clutter::Actor.
3310 *
3311 * @newin{1,0}
3312 */
3313 void grab_key_focus();
3314
3315
3316 /** Adds @a child to the children of @a self.
3317 *
3318 * This function will acquire a reference on @a child that will only
3319 * be released when calling remove_child().
3320 *
3321 * This function will take into consideration the Clutter::Actor::property_depth()
3322 * of @a child, and will keep the list of children sorted.
3323 *
3324 * This function will emit the Clutter::Container::signal_actor_added() signal
3325 * on @a self.
3326 *
3327 * @newin{1,10}
3328 * @param child A Clutter::Actor.
3329 */
3330 void add_child(const Glib::RefPtr<Actor>& child);
3331
3332 /** Inserts @a child into the list of children of @a self, above another
3333 * child of @a self or, if @a sibling is <tt>0</tt>, above all the children
3334 * of @a self.
3335 *
3336 * This function will acquire a reference on @a child that will only
3337 * be released when calling remove_child().
3338 *
3339 * This function will not take into consideration the Clutter::Actor::property_depth()
3340 * of @a child.
3341 *
3342 * This function will emit the Clutter::Container::signal_actor_added() signal
3343 * on @a self.
3344 *
3345 * @newin{1,10}
3346 * @param child A Clutter::Actor.
3347 * @param sibling A child of @a self, or <tt>0</tt>.
3348 */
3349 void insert_child_above(const Glib::RefPtr<Actor>& child, const Glib::RefPtr<Actor>& sibling);
3350
3351 /** Inserts @a child into the list of children of @a self, using the
3352 * given @a index. If @a index is greater than the number of children
3353 * in @a self, or is less than 0, then the new child is added at the end.
3354 *
3355 * This function will acquire a reference on @a child that will only
3356 * be released when calling remove_child().
3357 *
3358 * This function will not take into consideration the Clutter::Actor::property_depth()
3359 * of @a child.
3360 *
3361 * This function will emit the Clutter::Container::signal_actor_added() signal
3362 * on @a self.
3363 *
3364 * @newin{1,10}
3365 * @param child A Clutter::Actor.
3366 * @param index The index.
3367 */
3368 void insert_child_at_index(const Glib::RefPtr<Actor>& child, int index);
3369
3370 /// A insert_child_at_index() convenience overload.
3371 void insert_child_at_index(const Glib::RefPtr<Actor>& child);
3372
3373 /** Inserts @a child into the list of children of @a self, below another
3374 * child of @a self or, if @a sibling is <tt>0</tt>, below all the children
3375 * of @a self.
3376 *
3377 * This function will acquire a reference on @a child that will only
3378 * be released when calling remove_child().
3379 *
3380 * This function will not take into consideration the Clutter::Actor::property_depth()
3381 * of @a child.
3382 *
3383 * This function will emit the Clutter::Container::signal_actor_added() signal
3384 * on @a self.
3385 *
3386 * @newin{1,10}
3387 * @param child A Clutter::Actor.
3388 * @param sibling A child of @a self, or <tt>0</tt>.
3389 */
3390 void insert_child_below(const Glib::RefPtr<Actor>& child, const Glib::RefPtr<Actor>& sibling);
3391
3392 /** Replaces @a old_child with @a new_child in the list of children of @a self.
3393 *
3394 * @newin{1,10}
3395 * @param old_child The child of @a self to replace.
3396 * @param new_child The Clutter::Actor to replace @a old_child.
3397 */
3398 void replace_child(const Glib::RefPtr<Actor>& old_child, const Glib::RefPtr<Actor>& new_child);
3399
3400
3401 /** Removes @a child from the children of @a self.
3402 *
3403 * This function will release the reference added by
3404 * add_child(), so if you want to keep using @a child
3405 * you will have to acquire a referenced on it before calling this
3406 * function.
3407 *
3408 * This function will emit the Clutter::Container::signal_actor_removed()
3409 * signal on @a self.
3410 *
3411 * @newin{1,10}
3412 * @param child A Clutter::Actor.
3413 */
3414 void remove_child(const Glib::RefPtr<Actor>& child);
3415
3416 /** Removes all children of @a self.
3417 *
3418 * This function releases the reference added by inserting a child actor
3419 * in the list of children of @a self.
3420 *
3421 * If the reference count of a child drops to zero, the child will be
3422 * destroyed. If you want to ensure the destruction of all the children
3423 * of @a self, use destroy_all_children().
3424 *
3425 * @newin{1,10}
3426 */
3427 void remove_all_children();
3428
3429 //deprecated
3430
3431
3432 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3433
3434 /** Retrieves the Clutter::Animation used by @a actor, if animate()
3435 * has been called on @a actor.
3436 *
3437 * @newin{1,0}
3438 * Deprecated: 1.12: Use the implicit transition for animatable properties
3439 * in Clutter::Actor instead, and get_transition() to retrieve
3440 * the transition.
3441 * @deprecated Use the implicit transition for animatable properties in ClutterActor instead
3442 * @return A Clutter::Animation, or <tt>0</tt>.
3443 */
3444 Glib::RefPtr<Animation> get_animation();
3445 #endif // CLUTTERMM_DISABLE_DEPRECATED
3446
3447
3448 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3449
3450 /** Retrieves the Clutter::Animation used by @a actor, if animate()
3451 * has been called on @a actor.
3452 *
3453 * @newin{1,0}
3454 * Deprecated: 1.12: Use the implicit transition for animatable properties
3455 * in Clutter::Actor instead, and get_transition() to retrieve
3456 * the transition.
3457 * @deprecated Use the implicit transition for animatable properties in ClutterActor instead
3458 * @return A Clutter::Animation, or <tt>0</tt>.
3459 */
3460 Glib::RefPtr<const Animation> get_animation() const;
3461 #endif // CLUTTERMM_DISABLE_DEPRECATED
3462
3463
3464 /** Detaches the Clutter::Animation used by @a actor, if animate()
3465 * has been called on @a actor.
3466 *
3467 * Once the animation has been detached, it loses a reference. If it was
3468 * the only reference then the Clutter::Animation becomes invalid.
3469 *
3470 * The Clutter::Animation::signal_completed() signal will not be emitted.
3471 *
3472 * @newin{1,4}
3473 * Deprecated: 1.12: Use the implicit transition for animatable properties
3474 * in Clutter::Actor instead, and remove_transition() to
3475 * remove the transition.
3476 */
3477 void detach_animation();
3478
3479
3480 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3481
3482 /** Should be used by actors implementing the Clutter::Container and with
3483 * internal children added through set_parent(), for instance:
3484 *
3485 *
3486 * [C example ellipted]
3487 *
3488 * This function will be used by Clutter to toggle an "internal child"
3489 * flag whenever set_parent() is called; internal children
3490 * are handled differently by Clutter, specifically when destroying their
3491 * parent.
3492 *
3493 * Call pop_internal() when you finished adding internal
3494 * children.
3495 *
3496 * Nested calls to push_internal() are allowed, but each
3497 * one must by followed by a pop_internal() call.
3498 *
3499 * @newin{1,2}
3500 *
3501 * Deprecated: 1.10: All children of an actor are accessible through
3502 * the Clutter::Actor API, and Clutter::Actor implements the
3503 * Clutter::Container interface, so this function is only useful
3504 * for legacy containers overriding the default implementation.
3505 * @deprecated All children of an actor are accessible through the ClutterActor API
3506 */
3507 void push_internal();
3508 #endif // CLUTTERMM_DISABLE_DEPRECATED
3509
3510
3511 #ifndef CLUTTERMM_DISABLE_DEPRECATED
3512
3513 /** Disables the effects of push_internal().
3514 *
3515 * @newin{1,2}
3516 *
3517 * Deprecated: 1.10: All children of an actor are accessible through
3518 * the Clutter::Actor API. This function is only useful for legacy
3519 * containers overriding the default implementation of the
3520 * Clutter::Container interface.
3521 * @deprecated All children of an actor are accessible through the ClutterActor API. This function is only useful for legacy containers overriding the default implementation of the ClutterContainer interface.
3522 */
3523 void pop_internal();
3524 #endif // CLUTTERMM_DISABLE_DEPRECATED
3525
3526
3527 /** Checks if the actor has an up-to-date allocation assigned to
3528 * it. This means that the actor should have an allocation: it's
3529 * visible and has a parent. It also means that there is no
3530 * outstanding relayout request in progress for the actor or its
3531 * children (There might be other outstanding layout requests in
3532 * progress that will cause the actor to get a new allocation
3533 * when the stage is laid out, however).
3534 *
3535 * If this function returns <tt>false</tt>, then the actor will normally
3536 * be allocated before it is next drawn on the screen.
3537 *
3538 * @newin{1,4}
3539 * @return <tt>true</tt> if the actor has an up-to-date allocation.
3540 */
3541 bool has_allocation() const;
3542
3543
3544 /** Returns the accessible object that describes the actor to an
3545 * assistive technology.
3546 *
3547 * If no class-specific Atk::Object implementation is available for the
3548 * actor instance in question, it will inherit an Atk::Object
3549 * implementation from the first ancestor class for which such an
3550 * implementation is defined.
3551 *
3552 * The documentation of the ATK
3553 * library contains more information about accessible objects and
3554 * their uses.
3555 * @return The Atk::Object associated with @a actor.
3556 */
3557 Glib::RefPtr<Atk::Object> get_accessible();
3558
3559 /** Returns the accessible object that describes the actor to an
3560 * assistive technology.
3561 *
3562 * If no class-specific Atk::Object implementation is available for the
3563 * actor instance in question, it will inherit an Atk::Object
3564 * implementation from the first ancestor class for which such an
3565 * implementation is defined.
3566 *
3567 * The documentation of the ATK
3568 * library contains more information about accessible objects and
3569 * their uses.
3570 * @return The Atk::Object associated with @a actor.
3571 */
3572 Glib::RefPtr<const Atk::Object> get_accessible() const;
3573
3574
3575 /** Adds @a action to the list of actions applied to @a self
3576 *
3577 * A Clutter::Action can only belong to one actor at a time
3578 *
3579 * The Clutter::Actor will hold a reference on @a action until either
3580 * remove_action() or clear_actions()
3581 * is called
3582 *
3583 * @newin{1,4}
3584 * @param action A Clutter::Action.
3585 */
3586 void add_action(const Glib::RefPtr<Action>& action);
3587
3588 /** A convenience function for setting the name of a Clutter::Action
3589 * while adding it to the list of actions applied to @a self
3590 *
3591 * This function is the logical equivalent of:
3592 *
3593 *
3594 * [C example ellipted]
3595 *
3596 * @newin{1,4}
3597 * @param name The name to set on the action.
3598 * @param action A Clutter::Action.
3599 */
3600 void add_action(const Glib::ustring& name, const Glib::RefPtr<Action>& action);
3601
3602 /** Removes @a action from the list of actions applied to @a self
3603 *
3604 * The reference held by @a self on the Clutter::Action will be released
3605 *
3606 * @newin{1,4}
3607 * @param action A Clutter::Action.
3608 */
3609 void remove_action(const Glib::RefPtr<Action>& action);
3610
3611 /** Removes the Clutter::Action with the given name from the list
3612 * of actions applied to @a self
3613 *
3614 * @newin{1,4}
3615 * @param name The name of the action to remove.
3616 */
3617 void remove_action(const Glib::ustring& name);
3618
3619
3620 /** Retrieves the Clutter::Action with the given name in the list
3621 * of actions applied to @a self
3622 *
3623 * @newin{1,4}
3624 * @param name The name of the action to retrieve.
3625 * @return A Clutter::Action for the given
3626 * name, or <tt>0</tt>. The returned Clutter::Action is owned by the
3627 * actor and it should not be unreferenced directly.
3628 */
3629 Glib::RefPtr<Action> get_action(const Glib::ustring& name);
3630
3631 /** Retrieves the Clutter::Action with the given name in the list
3632 * of actions applied to @a self
3633 *
3634 * @newin{1,4}
3635 * @param name The name of the action to retrieve.
3636 * @return A Clutter::Action for the given
3637 * name, or <tt>0</tt>. The returned Clutter::Action is owned by the
3638 * actor and it should not be unreferenced directly.
3639 */
3640 Glib::RefPtr<const Action> get_action(const Glib::ustring& name) const;
3641
3642
3643 /** Clears the list of actions applied to @a self
3644 *
3645 * @newin{1,4}
3646 */
3647 void clear_actions();
3648
3649
3650 /** Retrieves the list of actions applied to @a self
3651 *
3652 * @newin{1,4}
3653 * @return A copy
3654 * of the list of Clutter::Action<!-- -->s. The contents of the list are
3655 * owned by the Clutter::Actor. Use Glib::list_free() to free the resources
3656 * allocated by the returned List.
3657 */
3658 std::vector< Glib::RefPtr<Action> > get_actions();
3659
3660
3661 /** Retrieves the list of actions applied to @a self
3662 *
3663 * @newin{1,4}
3664 * @return A copy
3665 * of the list of Clutter::Action<!-- -->s. The contents of the list are
3666 * owned by the Clutter::Actor. Use Glib::list_free() to free the resources
3667 * allocated by the returned List.
3668 */
3669 std::vector< Glib::RefPtr<const Action> > get_actions() const;
3670
3671
3672 /** Returns whether the actor has any actions applied.
3673 *
3674 * @newin{1,10}
3675 * @return <tt>true</tt> if the actor has any actions,
3676 * <tt>false</tt> otherwise.
3677 */
3678 bool has_actions() const;
3679
3680
3681 /** Adds @a effect to the list of Clutter::Effect<!-- -->s applied to @a self
3682 *
3683 * The Clutter::Actor will hold a reference on the @a effect until either
3684 * remove_effect() or clear_effects() is
3685 * called.
3686 *
3687 * @newin{1,4}
3688 * @param effect A Clutter::Effect.
3689 */
3690 void add_effect(const Glib::RefPtr<Effect>& effect);
3691
3692 /** A convenience function for setting the name of a Clutter::Effect
3693 * while adding it to the list of effectss applied to @a self
3694 *
3695 * This function is the logical equivalent of:
3696 *
3697 *
3698 * [C example ellipted]
3699 *
3700 * @newin{1,4}
3701 * @param name The name to set on the effect.
3702 * @param effect A Clutter::Effect.
3703 */
3704 void add_effect_with_name(const Glib::ustring& name, const Glib::RefPtr<Effect>& effect);
3705
3706 /** Removes @a effect from the list of effects applied to @a self
3707 *
3708 * The reference held by @a self on the Clutter::Effect will be released
3709 *
3710 * @newin{1,4}
3711 * @param effect A Clutter::Effect.
3712 */
3713 void remove_effect(const Glib::RefPtr<Effect>& effect);
3714
3715 /** Removes the Clutter::Effect with the given name from the list
3716 * of effects applied to @a self
3717 *
3718 * @newin{1,4}
3719 * @param name The name of the effect to remove.
3720 */
3721 void remove_effect(const Glib::ustring& name);
3722
3723
3724 /** Retrieves the Clutter::Effect<!-- -->s applied on @a self, if any
3725 *
3726 * @newin{1,4}
3727 * @return A list
3728 * of Clutter::Effect<!-- -->s, or <tt>0</tt>. The elements of the returned
3729 * list are owned by Clutter and they should not be freed. You should
3730 * free the returned list using Glib::list_free() when done.
3731 */
3732 std::vector< Glib::RefPtr<Effect> > get_effects();
3733
3734
3735 /** Retrieves the Clutter::Effect<!-- -->s applied on @a self, if any
3736 *
3737 * @newin{1,4}
3738 * @return A list
3739 * of Clutter::Effect<!-- -->s, or <tt>0</tt>. The elements of the returned
3740 * list are owned by Clutter and they should not be freed. You should
3741 * free the returned list using Glib::list_free() when done.
3742 */
3743 std::vector< Glib::RefPtr<const Effect> > get_effects() const;
3744
3745
3746 /** Retrieves the Clutter::Effect with the given name in the list
3747 * of effects applied to @a self
3748 *
3749 * @newin{1,4}
3750 * @param name The name of the effect to retrieve.
3751 * @return A Clutter::Effect for the given
3752 * name, or <tt>0</tt>. The returned Clutter::Effect is owned by the
3753 * actor and it should not be unreferenced directly.
3754 */
3755 Glib::RefPtr<Effect> get_effect(const Glib::ustring& name);
3756
3757 /** Retrieves the Clutter::Effect with the given name in the list
3758 * of effects applied to @a self
3759 *
3760 * @newin{1,4}
3761 * @param name The name of the effect to retrieve.
3762 * @return A Clutter::Effect for the given
3763 * name, or <tt>0</tt>. The returned Clutter::Effect is owned by the
3764 * actor and it should not be unreferenced directly.
3765 */
3766 Glib::RefPtr<const Effect> get_effect(const Glib::ustring& name) const;
3767
3768 /** Clears the list of effects applied to @a self
3769 *
3770 * @newin{1,4}
3771 */
3772 void clear_effects();
3773
3774 /** Returns whether the actor has any effects applied.
3775 *
3776 * @newin{1,10}
3777 * @return <tt>true</tt> if the actor has any effects,
3778 * <tt>false</tt> otherwise.
3779 */
3780 bool has_effects() const;
3781
3782
3783 //Animation Framework. The Easing state is used for basic animations.
3784
3785
3786 /** Saves the current easing state for animatable properties, and creates
3787 * a new state with the default values for easing mode and duration.
3788 *
3789 * New transitions created after calling this function will inherit the
3790 * duration, easing mode, and delay of the new easing state; this also
3791 * applies to transitions modified in flight.
3792 *
3793 * @newin{1,10}
3794 */
3795 void save_easing_state();
3796
3797 /** Restores the easing state as it was prior to a call to
3798 * save_easing_state().
3799 *
3800 * @newin{1,10}
3801 */
3802 void restore_easing_state();
3803
3804 /** Sets the duration of the tweening for animatable properties
3805 * of @a self for the current easing state.
3806 *
3807 * @newin{1,10}
3808 * @param msecs The duration of the easing, or <tt>0</tt>.
3809 */
3810 void set_easing_duration(guint msecs);
3811
3812 /** Retrieves the duration of the tweening for animatable
3813 * properties of @a self for the current easing state.
3814 *
3815 * @newin{1,10}
3816 * @return The duration of the tweening, in milliseconds.
3817 */
3818 guint get_easing_duration() const;
3819
3820 /** Retrieves the easing mode for the tweening of animatable properties
3821 * of @a self for the current easing state.
3822 *
3823 * @newin{1,10}
3824 * @return An easing mode.
3825 */
3826 AnimationMode get_easing_mode() const;
3827
3828 /** Sets the easing mode for the tweening of animatable properties
3829 * of @a self.
3830 *
3831 * @newin{1,10}
3832 * @param mode An easing mode, excluding Clutter::CUSTOM_MODE.
3833 */
3834 void set_easing_mode(AnimationMode mode);
3835
3836 /** Retrieves the delay that should be applied when tweening animatable
3837 * properties.
3838 *
3839 * @newin{1,10}
3840 * @return A delay, in milliseconds.
3841 */
3842 guint get_easing_delay() const;
3843
3844 /** Sets the delay that should be applied before tweening animatable
3845 * properties.
3846 *
3847 * @newin{1,10}
3848 * @param msecs The delay before the start of the tweening, in milliseconds.
3849 */
3850 void set_easing_delay(guint msecs);
3851
3852 // Transitions. Used for more complex animation handling.
3853
3854 /** Retrieves the Clutter::Transition of a Clutter::Actor by using the
3855 * transition @a name.
3856 *
3857 * Transitions created for animatable properties use the name of the
3858 * property itself, for instance the code below:
3859 *
3860 *
3861 * [C example ellipted]
3862 *
3863 * will call the <tt>on_transition_stopped</tt> callback when
3864 * the transition is finished.
3865 *
3866 * If you just want to get notifications of the completion of a transition,
3867 * you should use the Clutter::Actor::signal_transition_stopped() signal, using the
3868 * transition name as the signal detail.
3869 *
3870 * @newin{1,10}
3871 * @param name The name of the transition.
3872 * @return A Clutter::Transition, or <tt>0</tt> is none
3873 * was found to match the passed name; the returned instance is owned
3874 * by Clutter and it should not be freed.
3875 */
3876 Glib::RefPtr<Transition> get_transition(const Glib::ustring& name);
3877
3878 /** Retrieves the Clutter::Transition of a Clutter::Actor by using the
3879 * transition @a name.
3880 *
3881 * Transitions created for animatable properties use the name of the
3882 * property itself, for instance the code below:
3883 *
3884 *
3885 * [C example ellipted]
3886 *
3887 * will call the <tt>on_transition_stopped</tt> callback when
3888 * the transition is finished.
3889 *
3890 * If you just want to get notifications of the completion of a transition,
3891 * you should use the Clutter::Actor::signal_transition_stopped() signal, using the
3892 * transition name as the signal detail.
3893 *
3894 * @newin{1,10}
3895 * @param name The name of the transition.
3896 * @return A Clutter::Transition, or <tt>0</tt> is none
3897 * was found to match the passed name; the returned instance is owned
3898 * by Clutter and it should not be freed.
3899 */
3900 Glib::RefPtr<const Transition> get_transition(const Glib::ustring& name) const;
3901
3902
3903 /** Adds a @a transition to the Clutter::Actor's list of animations.
3904 *
3905 * The @a name string is a per-actor unique identifier of the @a transition: only
3906 * one Clutter::Transition can be associated to the specified @a name.
3907 *
3908 * The @a transition will be started once added.
3909 *
3910 * This function will take a reference on the @a transition.
3911 *
3912 * This function is usually called implicitly when modifying an animatable
3913 * property.
3914 *
3915 * @newin{1,10}
3916 * @param name The name of the transition to add.
3917 * @param transition The Clutter::Transition to add.
3918 */
3919 void add_transition(const Glib::ustring& name, const Glib::RefPtr<Transition>& transition);
3920
3921 /** Removes the transition stored inside a Clutter::Actor using @a name
3922 * identifier.
3923 *
3924 * If the transition is currently in progress, it will be stopped.
3925 *
3926 * This function releases the reference acquired when the transition
3927 * was added to the Clutter::Actor.
3928 *
3929 * @newin{1,10}
3930 * @param name The name of the transition to remove.
3931 */
3932 void remove_transition(const Glib::ustring& name);
3933
3934 /** Removes all transitions associated to @a self.
3935 *
3936 * @newin{1,10}
3937 */
3938 void remove_all_transitions();
3939
3940 //Constraints.
3941
3942 /** Adds @a constraint to the list of Clutter::Constraint<!-- -->s applied
3943 * to @a self
3944 *
3945 * The Clutter::Actor will hold a reference on the @a constraint until
3946 * either remove_constraint() or
3947 * clear_constraints() is called.
3948 *
3949 * @newin{1,4}
3950 * @param constraint A Clutter::Constraint.
3951 */
3952 void add_constraint(const Glib::RefPtr<Constraint>& constraint);
3953
3954 /** A convenience function for setting the name of a Clutter::Constraint
3955 * while adding it to the list of constraints applied to @a self
3956 *
3957 * This function is the logical equivalent of:
3958 *
3959 *
3960 * [C example ellipted]
3961 *
3962 * @newin{1,4}
3963 * @param name The name to set on the constraint.
3964 * @param constraint A Clutter::Constraint.
3965 */
3966 void add_constraint(const Glib::ustring& name, const Glib::RefPtr<Constraint>& constraint);
3967
3968 /** Removes @a constraint from the list of constraints applied to @a self
3969 *
3970 * The reference held by @a self on the Clutter::Constraint will be released
3971 *
3972 * @newin{1,4}
3973 * @param constraint A Clutter::Constraint.
3974 */
3975 void remove_constraint(const Glib::RefPtr<Constraint>& constraint);
3976
3977 /** Removes the Clutter::Constraint with the given name from the list
3978 * of constraints applied to @a self
3979 *
3980 * @newin{1,4}
3981 * @param name The name of the constraint to remove.
3982 */
3983 void remove_constraint(const Glib::ustring& name);
3984
3985 /** Returns whether the actor has any constraints applied.
3986 *
3987 * @newin{1,10}
3988 * @return <tt>true</tt> if the actor has any constraints,
3989 * <tt>false</tt> otherwise.
3990 */
3991 bool has_constraints() const;
3992
3993 // Clutter docs: Use g_list_free() when done.
3994
3995
3996 /** Retrieves the list of constraints applied to @a self
3997 *
3998 * @newin{1,4}
3999 * @return A copy
4000 * of the list of Clutter::Constraint<!-- -->s. The contents of the list are
4001 * owned by the Clutter::Actor. Use Glib::list_free() to free the resources
4002 * allocated by the returned List.
4003 */
4004 std::vector< Glib::RefPtr<Clutter::Constraint> > get_constraints();
4005
4006
4007 /** Retrieves the list of constraints applied to @a self
4008 *
4009 * @newin{1,4}
4010 * @return A copy
4011 * of the list of Clutter::Constraint<!-- -->s. The contents of the list are
4012 * owned by the Clutter::Actor. Use Glib::list_free() to free the resources
4013 * allocated by the returned List.
4014 */
4015 std::vector< Glib::RefPtr<const Clutter::Constraint> > get_constraints() const;
4016
4017
4018 /** Retrieves the Clutter::Constraint with the given name in the list
4019 * of constraints applied to @a self
4020 *
4021 * @newin{1,4}
4022 * @param name The name of the constraint to retrieve.
4023 * @return A Clutter::Constraint for the given
4024 * name, or <tt>0</tt>. The returned Clutter::Constraint is owned by the
4025 * actor and it should not be unreferenced directly.
4026 */
4027 Glib::RefPtr<const Constraint> get_constraint(const Glib::ustring& name) const;
4028
4029 /** Retrieves the Clutter::Constraint with the given name in the list
4030 * of constraints applied to @a self
4031 *
4032 * @newin{1,4}
4033 * @param name The name of the constraint to retrieve.
4034 * @return A Clutter::Constraint for the given
4035 * name, or <tt>0</tt>. The returned Clutter::Constraint is owned by the
4036 * actor and it should not be unreferenced directly.
4037 */
4038 Glib::RefPtr<Constraint> get_constraint(const Glib::ustring& name);
4039
4040 /** Clears the list of constraints applied to @a self
4041 *
4042 * @newin{1,4}
4043 */
4044 void clear_constraints();
4045
4046
4047 // signals
4048
4049 /**
4050 * @par Slot Prototype:
4051 * <tt>bool on_my_%button_press_event(ButtonEvent* event)</tt>
4052 *
4053 * The signal_button_press_event() signal is emitted each time a mouse button
4054 * is pressed on @a actor.
4055 *
4056 * @newin{0,6}
4057 * @param event A Clutter::ButtonEvent.
4058 * @return <tt>true</tt> if the event has been handled by the actor,
4059 * or <tt>false</tt> to continue the emission.
4060 */
4061
4062 Glib::SignalProxy1< bool,ButtonEvent* > signal_button_press_event();
4063
4064
4065 /**
4066 * @par Slot Prototype:
4067 * <tt>bool on_my_%button_release_event(ButtonEvent* event)</tt>
4068 *
4069 * The signal_button_release_event() signal is emitted each time a mouse button
4070 * is released on @a actor.
4071 *
4072 * @newin{0,6}
4073 * @param event A Clutter::ButtonEvent.
4074 * @return <tt>true</tt> if the event has been handled by the actor,
4075 * or <tt>false</tt> to continue the emission.
4076 */
4077
4078 Glib::SignalProxy1< bool,ButtonEvent* > signal_button_release_event();
4079
4080
4081 /**
4082 * @par Slot Prototype:
4083 * <tt>bool on_my_%motion_event(MotionEvent* event)</tt>
4084 *
4085 * The signal_motion_event() signal is emitted each time the mouse pointer is
4086 * moved over @a actor.
4087 *
4088 * @newin{0,6}
4089 * @param event A Clutter::MotionEvent.
4090 * @return <tt>true</tt> if the event has been handled by the actor,
4091 * or <tt>false</tt> to continue the emission.
4092 */
4093
4094 Glib::SignalProxy1< bool,MotionEvent* > signal_motion_event();
4095
4096
4097 /**
4098 * @par Slot Prototype:
4099 * <tt>bool on_my_%leave_event(CrossingEvent* event)</tt>
4100 *
4101 * The signal_leave_event() signal is emitted when the pointer leaves the @a actor.
4102 *
4103 * @newin{0,6}
4104 * @param event A Clutter::CrossingEvent.
4105 * @return <tt>true</tt> if the event has been handled by the actor,
4106 * or <tt>false</tt> to continue the emission.
4107 */
4108
4109 Glib::SignalProxy1< bool,CrossingEvent* > signal_leave_event();
4110
4111
4112 /**
4113 * @par Slot Prototype:
4114 * <tt>void on_my_%show()</tt>
4115 *
4116 * The signal_show() signal is emitted when an actor is visible and
4117 * rendered on the stage.
4118 *
4119 * @newin{0,2}
4120 */
4121
4122 Glib::SignalProxy0< void > signal_show();
4123
4124
4125 /**
4126 * @par Slot Prototype:
4127 * <tt>void on_my_%hide()</tt>
4128 *
4129 * The signal_hide() signal is emitted when an actor is no longer rendered
4130 * on the stage.
4131 *
4132 * @newin{0,2}
4133 */
4134
4135 Glib::SignalProxy0< void > signal_hide();
4136
4137
4138 //We ignore the destroy signal because it would just encourage strange memory management.
4139
4140
4141 /**
4142 * @par Slot Prototype:
4143 * <tt>bool on_my_%key_release_event(KeyEvent* event)</tt>
4144 *
4145 * The signal_key_release_event() signal is emitted each time a keyboard button
4146 * is released while @a actor has key focus (see
4147 * Clutter::Stage::set_key_focus()).
4148 *
4149 * @newin{0,6}
4150 * @param event A Clutter::KeyEvent.
4151 * @return <tt>true</tt> if the event has been handled by the actor,
4152 * or <tt>false</tt> to continue the emission.
4153 */
4154
4155 Glib::SignalProxy1< bool,KeyEvent* > signal_key_release_event();
4156
4157
4158 /**
4159 * @par Slot Prototype:
4160 * <tt>bool on_my_%enter_event(CrossingEvent* event)</tt>
4161 *
4162 * The signal_enter_event() signal is emitted when the pointer enters the @a actor
4163 *
4164 * @newin{0,6}
4165 * @param event A Clutter::CrossingEvent.
4166 * @return <tt>true</tt> if the event has been handled by the actor,
4167 * or <tt>false</tt> to continue the emission.
4168 */
4169
4170 Glib::SignalProxy1< bool,CrossingEvent* > signal_enter_event();
4171
4172
4173 /**
4174 * @par Slot Prototype:
4175 * <tt>bool on_my_%event(Event* event)</tt>
4176 *
4177 * The signal_event() signal is emitted each time an event is received
4178 * by the @a actor. This signal will be emitted on every actor,
4179 * following the hierarchy chain, until it reaches the top-level
4180 * container (the Clutter::Stage).
4181 *
4182 * @newin{0,6}
4183 * @param event A Clutter::Event.
4184 * @return <tt>true</tt> if the event has been handled by the actor,
4185 * or <tt>false</tt> to continue the emission.
4186 */
4187
4188 Glib::SignalProxy1< bool,Event* > signal_event();
4189
4190
4191 /**
4192 * @par Slot Prototype:
4193 * <tt>void on_my_%key_focus_out()</tt>
4194 *
4195 * The signal_key_focus_out() signal is emitted when @a actor loses key focus.
4196 *
4197 * @newin{0,6}
4198 */
4199
4200 Glib::SignalProxy0< void > signal_key_focus_out();
4201
4202
4203 /**
4204 * @par Slot Prototype:
4205 * <tt>void on_my_%key_focus_in()</tt>
4206 *
4207 * The signal_key_focus_in() signal is emitted when @a actor receives key focus.
4208 *
4209 * @newin{0,6}
4210 */
4211
4212 Glib::SignalProxy0< void > signal_key_focus_in();
4213
4214
4215 /**
4216 * @par Slot Prototype:
4217 * <tt>void on_my_%parent_set(const Glib::RefPtr<Actor>& old_parent)</tt>
4218 *
4219 * This signal is emitted when the parent of the actor changes.
4220 *
4221 * @newin{0,2}
4222 * @param old_parent The previous parent of the actor, or <tt>0</tt>.
4223 */
4224
4225 Glib::SignalProxy1< void,const Glib::RefPtr<Actor>& > signal_parent_set();
4226
4227
4228 /**
4229 * @par Slot Prototype:
4230 * <tt>bool on_my_%scroll_event(ScrollEvent* event)</tt>
4231 *
4232 * The signal_scroll_event() signal is emitted each time the mouse is
4233 * scrolled on @a actor
4234 *
4235 * @newin{0,6}
4236 * @param event A Clutter::ScrollEvent.
4237 * @return <tt>true</tt> if the event has been handled by the actor,
4238 * or <tt>false</tt> to continue the emission.
4239 */
4240
4241 Glib::SignalProxy1< bool,ScrollEvent* > signal_scroll_event();
4242
4243
4244 /**
4245 * @par Slot Prototype:
4246 * <tt>bool on_my_%key_press_event(KeyEvent* event)</tt>
4247 *
4248 * The signal_key_press_event() signal is emitted each time a keyboard button
4249 * is pressed while @a actor has key focus (see Clutter::Stage::set_key_focus()).
4250 *
4251 * @newin{0,6}
4252 * @param event A Clutter::KeyEvent.
4253 * @return <tt>true</tt> if the event has been handled by the actor,
4254 * or <tt>false</tt> to continue the emission.
4255 */
4256
4257 Glib::SignalProxy1< bool,KeyEvent* > signal_key_press_event();
4258
4259
4260 /**
4261 * @par Slot Prototype:
4262 * <tt>bool on_my_%captured_event(Event* event)</tt>
4263 *
4264 * The signal_captured_event() signal is emitted when an event is captured
4265 * by Clutter. This signal will be emitted starting from the top-level
4266 * container (the Clutter::Stage) to the actor which received the event
4267 * going down the hierarchy. This signal can be used to intercept every
4268 * event before the specialized events (like
4269 * ClutterActor::button-press-event or signal_key_released_event()) are
4270 * emitted.
4271 *
4272 * @newin{0,6}
4273 * @param event A Clutter::Event.
4274 * @return <tt>true</tt> if the event has been handled by the actor,
4275 * or <tt>false</tt> to continue the emission.
4276 */
4277
4278 Glib::SignalProxy1< bool,Event* > signal_captured_event();
4279
4280
4281 //We have to actually ignore this signal so we can replace its default signal handler with the vfunc.
4282
4283 //_WRAP_SIGNAL(void paint(), "paint", deprecated "Override the paint_func(), use a Clutter::Content implementation, or a Clutter::Effect instead of connecting to this signal.")
4284
4285
4286 /**
4287 * @par Slot Prototype:
4288 * <tt>void on_my_%queue_redaw(const Glib::RefPtr<Actor>& origin)</tt>
4289 *
4290 * The ::queue_redraw signal is emitted when Clutter::Actor::queue_redraw()
4291 * is called on @a origin.
4292 *
4293 * The default implementation for Clutter::Actor chains up to the
4294 * parent actor and queues a redraw on the parent, thus "bubbling"
4295 * the redraw queue up through the actor graph. The default
4296 * implementation for Clutter::Stage queues a Clutter::Stage::ensure_redraw()
4297 * in a main loop idle handler.
4298 *
4299 * Note that the @a origin actor may be the stage, or a container; it
4300 * does not have to be a leaf node in the actor graph.
4301 *
4302 * Toolkits embedding a Clutter::Stage which require a redraw and
4303 * relayout cycle can stop the emission of this signal using the
4304 * GSignal API, redraw the UI and then call Clutter::Stage::ensure_redraw()
4305 * themselves, like:
4306 *
4307 *
4308 * [C example ellipted]
4309 *
4310 * <note>This signal is emitted before the Clutter paint
4311 * pipeline is executed. If you want to know when the pipeline has
4312 * been completed you should connect to the signal_paint() signal on the
4313 * Stage with Glib::signal_connect_after().</note>
4314 *
4315 * @newin{1,0}
4316 * @param origin The actor which initiated the redraw request.
4317 */
4318
4319 Glib::SignalProxy1< void,const Glib::RefPtr<Actor>& > signal_queue_redaw();
4320
4321
4322 /**
4323 * @par Slot Prototype:
4324 * <tt>void on_my_%queue_relayout()</tt>
4325 *
4326 * The ::queue_layout signal is emitted when Clutter::Actor::queue_relayout()
4327 * is called on an actor.
4328 *
4329 * The default implementation for Clutter::Actor chains up to the
4330 * parent actor and queues a relayout on the parent, thus "bubbling"
4331 * the relayout queue up through the actor graph.
4332 *
4333 * The main purpose of this signal is to allow relayout to be propagated
4334 * properly in the procense of Clutter::Clone actors. Applications will
4335 * not normally need to connect to this signal.
4336 *
4337 * @newin{1,2}
4338 */
4339
4340 Glib::SignalProxy0< void > signal_queue_relayout();
4341
4342
4343 /**
4344 * @par Slot Prototype:
4345 * <tt>void on_my_%realize()</tt>
4346 *
4347 * The signal_realize() signal is emitted each time an actor is being
4348 * realized.
4349 *
4350 * @newin{0,8}
4351 *
4352 * Deprecated: 1.16: The signal should not be used in newly
4353 * written code
4354 */
4355
4356 Glib::SignalProxy0< void > signal_realize();
4357
4358
4359 /**
4360 * @par Slot Prototype:
4361 * <tt>void on_my_%unrealize()</tt>
4362 *
4363 * The signal_unrealize() signal is emitted each time an actor is being
4364 * unrealized.
4365 *
4366 * @newin{0,8}
4367 *
4368 * Deprecated: 1.16: The signal should not be used in newly
4369 * written code
4370 */
4371
4372 Glib::SignalProxy0< void > signal_unrealize();
4373
4374
4375 /**
4376 * @par Slot Prototype:
4377 * <tt>void on_my_%pick(const Color& color)</tt>
4378 *
4379 * The signal_pick() signal is emitted each time an actor is being painted
4380 * in "pick mode". The pick mode is used to identify the actor during
4381 * the event handling phase, or by Clutter::Stage::get_actor_at_pos().
4382 * The actor should paint its shape using the passed @a pick_color.
4383 *
4384 * Subclasses of Clutter::Actor should override the class signal handler
4385 * and paint themselves in that function.
4386 *
4387 * It is possible to connect a handler to the signal_pick() signal in order
4388 * to set up some custom aspect of a paint in pick mode.
4389 *
4390 * @newin{1,0}
4391 * Deprecated: 1.12: Override the Clutter::ActorClass.pick virtual function
4392 * instead.
4393 * @param color The Clutter::Color to be used when picking.
4394 */
4395
4396 Glib::SignalProxy1< void,const Color& > signal_pick();
4397
4398
4399 /**
4400 * @par Slot Prototype:
4401 * <tt>void on_my_%allocation_changed(const ActorBox& box, AllocationFlags flags)</tt>
4402 *
4403 * The signal_allocation_changed() signal is emitted when the
4404 * Clutter::Actor::property_allocation() property changes. Usually, application
4405 * code should just use the notifications for the :allocation property
4406 * but if you want to track the allocation flags as well, for instance
4407 * to know whether the absolute origin of @a actor changed, then you might
4408 * want use this signal instead.
4409 *
4410 * @newin{1,0}
4411 * @param box A Clutter::ActorBox with the new allocation.
4412 * @param flags Clutter::AllocationFlags for the allocation.
4413 */
4414
4415 Glib::SignalProxy2< void,const ActorBox&,AllocationFlags > signal_allocation_changed();
4416
4417
4418 //TODO: Wrap ClutterTouchEvent?
4419
4420 /**
4421 * @par Slot Prototype:
4422 * <tt>bool on_my_%touch_event(ClutterTouchEvent* event)</tt>
4423 *
4424 * The signal_touch_event() signal is emitted each time a touch
4425 * begin/end/update/cancel event.
4426 *
4427 * @newin{1,12}
4428 * @param event A Clutter::Event.
4429 * @return Clutter::EVENT_STOP if the event has been handled by
4430 * the actor, or Clutter::EVENT_PROPAGATE to continue the emission.
4431 */
4432
4433 Glib::SignalProxy1< bool,ClutterTouchEvent* > signal_touch_event();
4434
4435
4436 //TODO: There might be a default handler when clutter breaks ABI:
4437
4438 /**
4439 * @par Slot Prototype:
4440 * <tt>void on_my_%transitions_completed()</tt>
4441 *
4442 * The signal_transitions_completed() signal is emitted once all transitions
4443 * involving @a actor are complete.
4444 *
4445 * @newin{1,10}
4446 */
4447
4448 Glib::SignalProxy0< void > signal_transitions_completed();
4449
4450
4451 /**
4452 * @par Slot Prototype:
4453 * <tt>void on_my_%transition_stopped(const Glib::ustring& name, bool is_finished)</tt>
4454 *
4455 * The signal_transition_stopped() signal is emitted once a transition
4456 * is stopped; a transition is stopped once it reached its total
4457 * duration (including eventual repeats), it has been stopped
4458 * using Clutter::Timeline::stop(), or it has been removed from the
4459 * transitions applied on @a actor, using Clutter::Actor::remove_transition().
4460 *
4461 * @newin{1,12}
4462 * @param name The name of the transition.
4463 * @param is_finished Whether the transition was finished, or stopped.
4464 */
4465
4466 Glib::SignalProxy2< void,const Glib::ustring&,bool > signal_transition_stopped();
4467
4468
4469 #ifdef GLIBMM_PROPERTIES_ENABLED
4470 /** The actor's allocation.
4471 *
4472 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4473 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4474 * or receive notification when the value of the property changes.
4475 */
4476 Glib::PropertyProxy_ReadOnly< ActorBox > property_allocation() const;
4477 #endif //#GLIBMM_PROPERTIES_ENABLED
4478
4479
4480 #ifdef GLIBMM_PROPERTIES_ENABLED
4481 /** X coordinate of the anchor point.
4482 *
4483 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4484 * @return A PropertyProxy that allows you to get or set the value of the property,
4485 * or receive notification when the value of the property changes.
4486 */
4487 Glib::PropertyProxy< float > property_anchor_x() ;
4488 #endif //#GLIBMM_PROPERTIES_ENABLED
4489
4490 #ifdef GLIBMM_PROPERTIES_ENABLED
4491 /** X coordinate of the anchor point.
4492 *
4493 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4494 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4495 * or receive notification when the value of the property changes.
4496 */
4497 Glib::PropertyProxy_ReadOnly< float > property_anchor_x() const;
4498 #endif //#GLIBMM_PROPERTIES_ENABLED
4499
4500 #ifdef GLIBMM_PROPERTIES_ENABLED
4501 /** Y coordinate of the anchor point.
4502 *
4503 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4504 * @return A PropertyProxy that allows you to get or set the value of the property,
4505 * or receive notification when the value of the property changes.
4506 */
4507 Glib::PropertyProxy< float > property_anchor_y() ;
4508 #endif //#GLIBMM_PROPERTIES_ENABLED
4509
4510 #ifdef GLIBMM_PROPERTIES_ENABLED
4511 /** Y coordinate of the anchor point.
4512 *
4513 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4514 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4515 * or receive notification when the value of the property changes.
4516 */
4517 Glib::PropertyProxy_ReadOnly< float > property_anchor_y() const;
4518 #endif //#GLIBMM_PROPERTIES_ENABLED
4519
4520 #ifdef GLIBMM_PROPERTIES_ENABLED
4521 /** The anchor point as a ClutterGravity.
4522 *
4523 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4524 * @return A PropertyProxy that allows you to get or set the value of the property,
4525 * or receive notification when the value of the property changes.
4526 */
4527 Glib::PropertyProxy< Gravity > property_anchor_gravity() ;
4528 #endif //#GLIBMM_PROPERTIES_ENABLED
4529
4530 #ifdef GLIBMM_PROPERTIES_ENABLED
4531 /** The anchor point as a ClutterGravity.
4532 *
4533 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4534 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4535 * or receive notification when the value of the property changes.
4536 */
4537 Glib::PropertyProxy_ReadOnly< Gravity > property_anchor_gravity() const;
4538 #endif //#GLIBMM_PROPERTIES_ENABLED
4539
4540 #ifdef GLIBMM_PROPERTIES_ENABLED
4541 /** The actor's background color.
4542 *
4543 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4544 * @return A PropertyProxy that allows you to get or set the value of the property,
4545 * or receive notification when the value of the property changes.
4546 */
4547 Glib::PropertyProxy< Color > property_background_color() ;
4548 #endif //#GLIBMM_PROPERTIES_ENABLED
4549
4550 #ifdef GLIBMM_PROPERTIES_ENABLED
4551 /** The actor's background color.
4552 *
4553 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4554 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4555 * or receive notification when the value of the property changes.
4556 */
4557 Glib::PropertyProxy_ReadOnly< Color > property_background_color() const;
4558 #endif //#GLIBMM_PROPERTIES_ENABLED
4559
4560 #ifdef GLIBMM_PROPERTIES_ENABLED
4561 /** Whether the background color is set.
4562 *
4563 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4564 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4565 * or receive notification when the value of the property changes.
4566 */
4567 Glib::PropertyProxy_ReadOnly< bool > property_background_color_set() const;
4568 #endif //#GLIBMM_PROPERTIES_ENABLED
4569
4570
4571 #ifdef GLIBMM_PROPERTIES_ENABLED
4572 /** Children transformation matrix.
4573 *
4574 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4575 * @return A PropertyProxy that allows you to get or set the value of the property,
4576 * or receive notification when the value of the property changes.
4577 */
4578 Glib::PropertyProxy< Matrix > property_child_transform() ;
4579 #endif //#GLIBMM_PROPERTIES_ENABLED
4580
4581 #ifdef GLIBMM_PROPERTIES_ENABLED
4582 /** Children transformation matrix.
4583 *
4584 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4585 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4586 * or receive notification when the value of the property changes.
4587 */
4588 Glib::PropertyProxy_ReadOnly< Matrix > property_child_transform() const;
4589 #endif //#GLIBMM_PROPERTIES_ENABLED
4590
4591 #ifdef GLIBMM_PROPERTIES_ENABLED
4592 /** Whether the child-transform property is set.
4593 *
4594 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4595 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4596 * or receive notification when the value of the property changes.
4597 */
4598 Glib::PropertyProxy_ReadOnly< bool > property_child_transform_set() const;
4599 #endif //#GLIBMM_PROPERTIES_ENABLED
4600
4601
4602 #ifdef GLIBMM_PROPERTIES_ENABLED
4603 /** The clip region for the actor.
4604 *
4605 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4606 * @return A PropertyProxy that allows you to get or set the value of the property,
4607 * or receive notification when the value of the property changes.
4608 */
4609 Glib::PropertyProxy< Geometry > property_clip() ;
4610 #endif //#GLIBMM_PROPERTIES_ENABLED
4611
4612 #ifdef GLIBMM_PROPERTIES_ENABLED
4613 /** The clip region for the actor.
4614 *
4615 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4616 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4617 * or receive notification when the value of the property changes.
4618 */
4619 Glib::PropertyProxy_ReadOnly< Geometry > property_clip() const;
4620 #endif //#GLIBMM_PROPERTIES_ENABLED
4621 //TODO: This is marked for removal in clutter.
4622 #ifdef GLIBMM_PROPERTIES_ENABLED
4623 /** The visible region of the actor.
4624 *
4625 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4626 * @return A PropertyProxy that allows you to get or set the value of the property,
4627 * or receive notification when the value of the property changes.
4628 */
4629 Glib::PropertyProxy< Rect > property_clip_rect() ;
4630 #endif //#GLIBMM_PROPERTIES_ENABLED
4631
4632 #ifdef GLIBMM_PROPERTIES_ENABLED
4633 /** The visible region of the actor.
4634 *
4635 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4636 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4637 * or receive notification when the value of the property changes.
4638 */
4639 Glib::PropertyProxy_ReadOnly< Rect > property_clip_rect() const;
4640 #endif //#GLIBMM_PROPERTIES_ENABLED
4641
4642 #ifdef GLIBMM_PROPERTIES_ENABLED
4643 /** Sets the clip region to track the actor's allocation.
4644 *
4645 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4646 * @return A PropertyProxy that allows you to get or set the value of the property,
4647 * or receive notification when the value of the property changes.
4648 */
4649 Glib::PropertyProxy< bool > property_clip_to_allocation() ;
4650 #endif //#GLIBMM_PROPERTIES_ENABLED
4651
4652 #ifdef GLIBMM_PROPERTIES_ENABLED
4653 /** Sets the clip region to track the actor's allocation.
4654 *
4655 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4656 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4657 * or receive notification when the value of the property changes.
4658 */
4659 Glib::PropertyProxy_ReadOnly< bool > property_clip_to_allocation() const;
4660 #endif //#GLIBMM_PROPERTIES_ENABLED
4661
4662 #ifdef GLIBMM_PROPERTIES_ENABLED
4663 /** Delegate object for painting the actor's content.
4664 *
4665 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4666 * @return A PropertyProxy that allows you to get or set the value of the property,
4667 * or receive notification when the value of the property changes.
4668 */
4669 Glib::PropertyProxy< Content > property_content() ;
4670 #endif //#GLIBMM_PROPERTIES_ENABLED
4671
4672 #ifdef GLIBMM_PROPERTIES_ENABLED
4673 /** Delegate object for painting the actor's content.
4674 *
4675 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4676 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4677 * or receive notification when the value of the property changes.
4678 */
4679 Glib::PropertyProxy_ReadOnly< Content > property_content() const;
4680 #endif //#GLIBMM_PROPERTIES_ENABLED
4681
4682 #ifdef GLIBMM_PROPERTIES_ENABLED
4683 /** The bounding box of the actor's content.
4684 *
4685 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4686 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4687 * or receive notification when the value of the property changes.
4688 */
4689 Glib::PropertyProxy_ReadOnly< ActorBox > property_content_box() const;
4690 #endif //#GLIBMM_PROPERTIES_ENABLED
4691
4692
4693 #ifdef GLIBMM_PROPERTIES_ENABLED
4694 /** Alignment of the actor's content.
4695 *
4696 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4697 * @return A PropertyProxy that allows you to get or set the value of the property,
4698 * or receive notification when the value of the property changes.
4699 */
4700 Glib::PropertyProxy< ContentGravity > property_content_gravity() ;
4701 #endif //#GLIBMM_PROPERTIES_ENABLED
4702
4703 #ifdef GLIBMM_PROPERTIES_ENABLED
4704 /** Alignment of the actor's content.
4705 *
4706 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4707 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4708 * or receive notification when the value of the property changes.
4709 */
4710 Glib::PropertyProxy_ReadOnly< ContentGravity > property_content_gravity() const;
4711 #endif //#GLIBMM_PROPERTIES_ENABLED
4712
4713 #ifdef GLIBMM_PROPERTIES_ENABLED
4714 /** The repeat policy for the actor's content.
4715 *
4716 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4717 * @return A PropertyProxy that allows you to get or set the value of the property,
4718 * or receive notification when the value of the property changes.
4719 */
4720 Glib::PropertyProxy< ContentRepeat > property_content_repeat() ;
4721 #endif //#GLIBMM_PROPERTIES_ENABLED
4722
4723 #ifdef GLIBMM_PROPERTIES_ENABLED
4724 /** The repeat policy for the actor's content.
4725 *
4726 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4727 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4728 * or receive notification when the value of the property changes.
4729 */
4730 Glib::PropertyProxy_ReadOnly< ContentRepeat > property_content_repeat() const;
4731 #endif //#GLIBMM_PROPERTIES_ENABLED
4732
4733
4734 // This property is not wrapped because it is documented in Clutter as adding, instead of just setting, a Constraint.
4735 //_WRAP_PROPERTY("constraints", Glib::RefPtr<Constraint>)
4736
4737 #ifdef GLIBMM_PROPERTIES_ENABLED
4738 /** Position on the Z axis.
4739 *
4740 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4741 * @return A PropertyProxy that allows you to get or set the value of the property,
4742 * or receive notification when the value of the property changes.
4743 */
4744 Glib::PropertyProxy< float > property_depth() ;
4745 #endif //#GLIBMM_PROPERTIES_ENABLED
4746
4747 #ifdef GLIBMM_PROPERTIES_ENABLED
4748 /** Position on the Z axis.
4749 *
4750 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4751 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4752 * or receive notification when the value of the property changes.
4753 */
4754 Glib::PropertyProxy_ReadOnly< float > property_depth() const;
4755 #endif //#GLIBMM_PROPERTIES_ENABLED
4756
4757 #ifdef GLIBMM_PROPERTIES_ENABLED
4758 /** Add an effect to be applied on the actor.
4759 *
4760 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4761 * @return A PropertyProxy_WriteOnly that allows you to set the value of the property,
4762 * or receive notification when the value of the property changes.
4763 */
4764 Glib::PropertyProxy_WriteOnly< Glib::RefPtr<Effect> > property_effect() ;
4765 #endif //#GLIBMM_PROPERTIES_ENABLED
4766
4767
4768 #ifdef GLIBMM_PROPERTIES_ENABLED
4769 /** The actor's first child.
4770 *
4771 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4772 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4773 * or receive notification when the value of the property changes.
4774 */
4775 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Actor> > property_first_child() const;
4776 #endif //#GLIBMM_PROPERTIES_ENABLED
4777
4778
4779 #ifdef GLIBMM_PROPERTIES_ENABLED
4780 /** Whether to use fixed positioning for the actor.
4781 *
4782 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4783 * @return A PropertyProxy that allows you to get or set the value of the property,
4784 * or receive notification when the value of the property changes.
4785 */
4786 Glib::PropertyProxy< bool > property_fixed_position_set() ;
4787 #endif //#GLIBMM_PROPERTIES_ENABLED
4788
4789 #ifdef GLIBMM_PROPERTIES_ENABLED
4790 /** Whether to use fixed positioning for the actor.
4791 *
4792 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4793 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4794 * or receive notification when the value of the property changes.
4795 */
4796 Glib::PropertyProxy_ReadOnly< bool > property_fixed_position_set() const;
4797 #endif //#GLIBMM_PROPERTIES_ENABLED
4798
4799 #ifdef GLIBMM_PROPERTIES_ENABLED
4800 /** Forced X position of the actor.
4801 *
4802 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4803 * @return A PropertyProxy that allows you to get or set the value of the property,
4804 * or receive notification when the value of the property changes.
4805 */
4806 Glib::PropertyProxy< float > property_fixed_x() ;
4807 #endif //#GLIBMM_PROPERTIES_ENABLED
4808
4809 #ifdef GLIBMM_PROPERTIES_ENABLED
4810 /** Forced X position of the actor.
4811 *
4812 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4813 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4814 * or receive notification when the value of the property changes.
4815 */
4816 Glib::PropertyProxy_ReadOnly< float > property_fixed_x() const;
4817 #endif //#GLIBMM_PROPERTIES_ENABLED
4818
4819 #ifdef GLIBMM_PROPERTIES_ENABLED
4820 /** Forced Y position of the actor.
4821 *
4822 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4823 * @return A PropertyProxy that allows you to get or set the value of the property,
4824 * or receive notification when the value of the property changes.
4825 */
4826 Glib::PropertyProxy< float > property_fixed_y() ;
4827 #endif //#GLIBMM_PROPERTIES_ENABLED
4828
4829 #ifdef GLIBMM_PROPERTIES_ENABLED
4830 /** Forced Y position of the actor.
4831 *
4832 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4833 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4834 * or receive notification when the value of the property changes.
4835 */
4836 Glib::PropertyProxy_ReadOnly< float > property_fixed_y() const;
4837 #endif //#GLIBMM_PROPERTIES_ENABLED
4838
4839 #ifdef GLIBMM_PROPERTIES_ENABLED
4840 /** Whether the actor has a clip set.
4841 *
4842 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4843 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4844 * or receive notification when the value of the property changes.
4845 */
4846 Glib::PropertyProxy_ReadOnly< bool > property_has_clip() const;
4847 #endif //#GLIBMM_PROPERTIES_ENABLED
4848
4849
4850 #ifdef GLIBMM_PROPERTIES_ENABLED
4851 /** Whether the actor contains the pointer of an input device.
4852 *
4853 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4854 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4855 * or receive notification when the value of the property changes.
4856 */
4857 Glib::PropertyProxy_ReadOnly< bool > property_has_pointer() const;
4858 #endif //#GLIBMM_PROPERTIES_ENABLED
4859
4860
4861 #ifdef GLIBMM_PROPERTIES_ENABLED
4862 /** Height of the actor.
4863 *
4864 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4865 * @return A PropertyProxy that allows you to get or set the value of the property,
4866 * or receive notification when the value of the property changes.
4867 */
4868 Glib::PropertyProxy< float > property_height() ;
4869 #endif //#GLIBMM_PROPERTIES_ENABLED
4870
4871 #ifdef GLIBMM_PROPERTIES_ENABLED
4872 /** Height of the actor.
4873 *
4874 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4875 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4876 * or receive notification when the value of the property changes.
4877 */
4878 Glib::PropertyProxy_ReadOnly< float > property_height() const;
4879 #endif //#GLIBMM_PROPERTIES_ENABLED
4880
4881 #ifdef GLIBMM_PROPERTIES_ENABLED
4882 /** The actor's last child.
4883 *
4884 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4885 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4886 * or receive notification when the value of the property changes.
4887 */
4888 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Actor> > property_last_child() const;
4889 #endif //#GLIBMM_PROPERTIES_ENABLED
4890
4891
4892 #ifdef GLIBMM_PROPERTIES_ENABLED
4893 /** The object controlling the layout of an actor's children.
4894 *
4895 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4896 * @return A PropertyProxy that allows you to get or set the value of the property,
4897 * or receive notification when the value of the property changes.
4898 */
4899 Glib::PropertyProxy< Glib::RefPtr<LayoutManager> > property_layout_manager() ;
4900 #endif //#GLIBMM_PROPERTIES_ENABLED
4901
4902 #ifdef GLIBMM_PROPERTIES_ENABLED
4903 /** The object controlling the layout of an actor's children.
4904 *
4905 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4906 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4907 * or receive notification when the value of the property changes.
4908 */
4909 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<LayoutManager> > property_layout_manager() const;
4910 #endif //#GLIBMM_PROPERTIES_ENABLED
4911
4912 #ifdef GLIBMM_PROPERTIES_ENABLED
4913 /** The filter used when increasing the size of the content.
4914 *
4915 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4916 * @return A PropertyProxy that allows you to get or set the value of the property,
4917 * or receive notification when the value of the property changes.
4918 */
4919 Glib::PropertyProxy< ScalingFilter > property_magnification_filter() ;
4920 #endif //#GLIBMM_PROPERTIES_ENABLED
4921
4922 #ifdef GLIBMM_PROPERTIES_ENABLED
4923 /** The filter used when increasing the size of the content.
4924 *
4925 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4926 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4927 * or receive notification when the value of the property changes.
4928 */
4929 Glib::PropertyProxy_ReadOnly< ScalingFilter > property_magnification_filter() const;
4930 #endif //#GLIBMM_PROPERTIES_ENABLED
4931
4932 #ifdef GLIBMM_PROPERTIES_ENABLED
4933 /** Whether the actor will be painted.
4934 *
4935 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4936 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4937 * or receive notification when the value of the property changes.
4938 */
4939 Glib::PropertyProxy_ReadOnly< bool > property_mapped() const;
4940 #endif //#GLIBMM_PROPERTIES_ENABLED
4941
4942
4943 #ifdef GLIBMM_PROPERTIES_ENABLED
4944 /** Extra space at the bottom.
4945 *
4946 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4947 * @return A PropertyProxy that allows you to get or set the value of the property,
4948 * or receive notification when the value of the property changes.
4949 */
4950 Glib::PropertyProxy< float > property_margin_bottom() ;
4951 #endif //#GLIBMM_PROPERTIES_ENABLED
4952
4953 #ifdef GLIBMM_PROPERTIES_ENABLED
4954 /** Extra space at the bottom.
4955 *
4956 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4957 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4958 * or receive notification when the value of the property changes.
4959 */
4960 Glib::PropertyProxy_ReadOnly< float > property_margin_bottom() const;
4961 #endif //#GLIBMM_PROPERTIES_ENABLED
4962
4963 #ifdef GLIBMM_PROPERTIES_ENABLED
4964 /** Extra space at the left.
4965 *
4966 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4967 * @return A PropertyProxy that allows you to get or set the value of the property,
4968 * or receive notification when the value of the property changes.
4969 */
4970 Glib::PropertyProxy< float > property_margin_left() ;
4971 #endif //#GLIBMM_PROPERTIES_ENABLED
4972
4973 #ifdef GLIBMM_PROPERTIES_ENABLED
4974 /** Extra space at the left.
4975 *
4976 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4977 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4978 * or receive notification when the value of the property changes.
4979 */
4980 Glib::PropertyProxy_ReadOnly< float > property_margin_left() const;
4981 #endif //#GLIBMM_PROPERTIES_ENABLED
4982
4983 #ifdef GLIBMM_PROPERTIES_ENABLED
4984 /** Extra space at the right.
4985 *
4986 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4987 * @return A PropertyProxy that allows you to get or set the value of the property,
4988 * or receive notification when the value of the property changes.
4989 */
4990 Glib::PropertyProxy< float > property_margin_right() ;
4991 #endif //#GLIBMM_PROPERTIES_ENABLED
4992
4993 #ifdef GLIBMM_PROPERTIES_ENABLED
4994 /** Extra space at the right.
4995 *
4996 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
4997 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
4998 * or receive notification when the value of the property changes.
4999 */
5000 Glib::PropertyProxy_ReadOnly< float > property_margin_right() const;
5001 #endif //#GLIBMM_PROPERTIES_ENABLED
5002
5003 #ifdef GLIBMM_PROPERTIES_ENABLED
5004 /** Extra space at the top.
5005 *
5006 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5007 * @return A PropertyProxy that allows you to get or set the value of the property,
5008 * or receive notification when the value of the property changes.
5009 */
5010 Glib::PropertyProxy< float > property_margin_top() ;
5011 #endif //#GLIBMM_PROPERTIES_ENABLED
5012
5013 #ifdef GLIBMM_PROPERTIES_ENABLED
5014 /** Extra space at the top.
5015 *
5016 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5017 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5018 * or receive notification when the value of the property changes.
5019 */
5020 Glib::PropertyProxy_ReadOnly< float > property_margin_top() const;
5021 #endif //#GLIBMM_PROPERTIES_ENABLED
5022
5023 #ifdef GLIBMM_PROPERTIES_ENABLED
5024 /** The filter used when reducing the size of the content.
5025 *
5026 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5027 * @return A PropertyProxy that allows you to get or set the value of the property,
5028 * or receive notification when the value of the property changes.
5029 */
5030 Glib::PropertyProxy< ScalingFilter > property_minification_filter() ;
5031 #endif //#GLIBMM_PROPERTIES_ENABLED
5032
5033 #ifdef GLIBMM_PROPERTIES_ENABLED
5034 /** The filter used when reducing the size of the content.
5035 *
5036 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5037 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5038 * or receive notification when the value of the property changes.
5039 */
5040 Glib::PropertyProxy_ReadOnly< ScalingFilter > property_minification_filter() const;
5041 #endif //#GLIBMM_PROPERTIES_ENABLED
5042
5043 #ifdef GLIBMM_PROPERTIES_ENABLED
5044 /** Forced minimum height request for the actor.
5045 *
5046 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5047 * @return A PropertyProxy that allows you to get or set the value of the property,
5048 * or receive notification when the value of the property changes.
5049 */
5050 Glib::PropertyProxy< float > property_min_height() ;
5051 #endif //#GLIBMM_PROPERTIES_ENABLED
5052
5053 #ifdef GLIBMM_PROPERTIES_ENABLED
5054 /** Forced minimum height request for the actor.
5055 *
5056 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5057 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5058 * or receive notification when the value of the property changes.
5059 */
5060 Glib::PropertyProxy_ReadOnly< float > property_min_height() const;
5061 #endif //#GLIBMM_PROPERTIES_ENABLED
5062
5063 #ifdef GLIBMM_PROPERTIES_ENABLED
5064 /** Whether to use the min-height property.
5065 *
5066 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5067 * @return A PropertyProxy that allows you to get or set the value of the property,
5068 * or receive notification when the value of the property changes.
5069 */
5070 Glib::PropertyProxy< bool > property_min_height_set() ;
5071 #endif //#GLIBMM_PROPERTIES_ENABLED
5072
5073 #ifdef GLIBMM_PROPERTIES_ENABLED
5074 /** Whether to use the min-height property.
5075 *
5076 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5077 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5078 * or receive notification when the value of the property changes.
5079 */
5080 Glib::PropertyProxy_ReadOnly< bool > property_min_height_set() const;
5081 #endif //#GLIBMM_PROPERTIES_ENABLED
5082
5083 #ifdef GLIBMM_PROPERTIES_ENABLED
5084 /** Forced minimum width request for the actor.
5085 *
5086 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5087 * @return A PropertyProxy that allows you to get or set the value of the property,
5088 * or receive notification when the value of the property changes.
5089 */
5090 Glib::PropertyProxy< float > property_min_width() ;
5091 #endif //#GLIBMM_PROPERTIES_ENABLED
5092
5093 #ifdef GLIBMM_PROPERTIES_ENABLED
5094 /** Forced minimum width request for the actor.
5095 *
5096 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5097 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5098 * or receive notification when the value of the property changes.
5099 */
5100 Glib::PropertyProxy_ReadOnly< float > property_min_width() const;
5101 #endif //#GLIBMM_PROPERTIES_ENABLED
5102
5103 #ifdef GLIBMM_PROPERTIES_ENABLED
5104 /** Whether to use the min-width property.
5105 *
5106 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5107 * @return A PropertyProxy that allows you to get or set the value of the property,
5108 * or receive notification when the value of the property changes.
5109 */
5110 Glib::PropertyProxy< bool > property_min_width_set() ;
5111 #endif //#GLIBMM_PROPERTIES_ENABLED
5112
5113 #ifdef GLIBMM_PROPERTIES_ENABLED
5114 /** Whether to use the min-width property.
5115 *
5116 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5117 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5118 * or receive notification when the value of the property changes.
5119 */
5120 Glib::PropertyProxy_ReadOnly< bool > property_min_width_set() const;
5121 #endif //#GLIBMM_PROPERTIES_ENABLED
5122
5123 #ifdef GLIBMM_PROPERTIES_ENABLED
5124 /** Name of the actor.
5125 *
5126 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5127 * @return A PropertyProxy that allows you to get or set the value of the property,
5128 * or receive notification when the value of the property changes.
5129 */
5130 Glib::PropertyProxy< Glib::ustring > property_name() ;
5131 #endif //#GLIBMM_PROPERTIES_ENABLED
5132
5133 #ifdef GLIBMM_PROPERTIES_ENABLED
5134 /** Name of the actor.
5135 *
5136 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5137 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5138 * or receive notification when the value of the property changes.
5139 */
5140 Glib::PropertyProxy_ReadOnly< Glib::ustring > property_name() const;
5141 #endif //#GLIBMM_PROPERTIES_ENABLED
5142
5143 #ifdef GLIBMM_PROPERTIES_ENABLED
5144 /** Forced natural height request for the actor.
5145 *
5146 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5147 * @return A PropertyProxy that allows you to get or set the value of the property,
5148 * or receive notification when the value of the property changes.
5149 */
5150 Glib::PropertyProxy< float > property_natural_height() ;
5151 #endif //#GLIBMM_PROPERTIES_ENABLED
5152
5153 #ifdef GLIBMM_PROPERTIES_ENABLED
5154 /** Forced natural height request for the actor.
5155 *
5156 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5157 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5158 * or receive notification when the value of the property changes.
5159 */
5160 Glib::PropertyProxy_ReadOnly< float > property_natural_height() const;
5161 #endif //#GLIBMM_PROPERTIES_ENABLED
5162
5163 #ifdef GLIBMM_PROPERTIES_ENABLED
5164 /** Whether to use the natural-height property.
5165 *
5166 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5167 * @return A PropertyProxy that allows you to get or set the value of the property,
5168 * or receive notification when the value of the property changes.
5169 */
5170 Glib::PropertyProxy< bool > property_natural_height_set() ;
5171 #endif //#GLIBMM_PROPERTIES_ENABLED
5172
5173 #ifdef GLIBMM_PROPERTIES_ENABLED
5174 /** Whether to use the natural-height property.
5175 *
5176 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5177 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5178 * or receive notification when the value of the property changes.
5179 */
5180 Glib::PropertyProxy_ReadOnly< bool > property_natural_height_set() const;
5181 #endif //#GLIBMM_PROPERTIES_ENABLED
5182
5183 #ifdef GLIBMM_PROPERTIES_ENABLED
5184 /** Forced natural width request for the actor.
5185 *
5186 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5187 * @return A PropertyProxy that allows you to get or set the value of the property,
5188 * or receive notification when the value of the property changes.
5189 */
5190 Glib::PropertyProxy< float > property_natural_width() ;
5191 #endif //#GLIBMM_PROPERTIES_ENABLED
5192
5193 #ifdef GLIBMM_PROPERTIES_ENABLED
5194 /** Forced natural width request for the actor.
5195 *
5196 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5197 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5198 * or receive notification when the value of the property changes.
5199 */
5200 Glib::PropertyProxy_ReadOnly< float > property_natural_width() const;
5201 #endif //#GLIBMM_PROPERTIES_ENABLED
5202
5203 #ifdef GLIBMM_PROPERTIES_ENABLED
5204 /** Whether to use the natural-width property.
5205 *
5206 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5207 * @return A PropertyProxy that allows you to get or set the value of the property,
5208 * or receive notification when the value of the property changes.
5209 */
5210 Glib::PropertyProxy< bool > property_natural_width_set() ;
5211 #endif //#GLIBMM_PROPERTIES_ENABLED
5212
5213 #ifdef GLIBMM_PROPERTIES_ENABLED
5214 /** Whether to use the natural-width property.
5215 *
5216 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5217 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5218 * or receive notification when the value of the property changes.
5219 */
5220 Glib::PropertyProxy_ReadOnly< bool > property_natural_width_set() const;
5221 #endif //#GLIBMM_PROPERTIES_ENABLED
5222
5223 #ifdef GLIBMM_PROPERTIES_ENABLED
5224 /** Opacity of an actor.
5225 *
5226 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5227 * @return A PropertyProxy that allows you to get or set the value of the property,
5228 * or receive notification when the value of the property changes.
5229 */
5230 Glib::PropertyProxy< guint8 > property_opacity() ;
5231 #endif //#GLIBMM_PROPERTIES_ENABLED
5232
5233 #ifdef GLIBMM_PROPERTIES_ENABLED
5234 /** Opacity of an actor.
5235 *
5236 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5237 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5238 * or receive notification when the value of the property changes.
5239 */
5240 Glib::PropertyProxy_ReadOnly< guint8 > property_opacity() const;
5241 #endif //#GLIBMM_PROPERTIES_ENABLED
5242
5243 #ifdef GLIBMM_PROPERTIES_ENABLED
5244 /** Flags controlling when to flatten the actor into a single image.
5245 *
5246 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5247 * @return A PropertyProxy that allows you to get or set the value of the property,
5248 * or receive notification when the value of the property changes.
5249 */
5250 Glib::PropertyProxy< OffscreenRedirect > property_offscreen_redirect() ;
5251 #endif //#GLIBMM_PROPERTIES_ENABLED
5252
5253 #ifdef GLIBMM_PROPERTIES_ENABLED
5254 /** Flags controlling when to flatten the actor into a single image.
5255 *
5256 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5257 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5258 * or receive notification when the value of the property changes.
5259 */
5260 Glib::PropertyProxy_ReadOnly< OffscreenRedirect > property_offscreen_redirect() const;
5261 #endif //#GLIBMM_PROPERTIES_ENABLED
5262
5263 #ifdef GLIBMM_PROPERTIES_ENABLED
5264 /** The point around which the scaling and rotation occur.
5265 *
5266 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5267 * @return A PropertyProxy that allows you to get or set the value of the property,
5268 * or receive notification when the value of the property changes.
5269 */
5270 Glib::PropertyProxy< Point > property_pivot_point() ;
5271 #endif //#GLIBMM_PROPERTIES_ENABLED
5272
5273 #ifdef GLIBMM_PROPERTIES_ENABLED
5274 /** The point around which the scaling and rotation occur.
5275 *
5276 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5277 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5278 * or receive notification when the value of the property changes.
5279 */
5280 Glib::PropertyProxy_ReadOnly< Point > property_pivot_point() const;
5281 #endif //#GLIBMM_PROPERTIES_ENABLED
5282
5283 #ifdef GLIBMM_PROPERTIES_ENABLED
5284 /** Z component of the pivot point.
5285 *
5286 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5287 * @return A PropertyProxy that allows you to get or set the value of the property,
5288 * or receive notification when the value of the property changes.
5289 */
5290 Glib::PropertyProxy< float > property_pivot_point_z() ;
5291 #endif //#GLIBMM_PROPERTIES_ENABLED
5292
5293 #ifdef GLIBMM_PROPERTIES_ENABLED
5294 /** Z component of the pivot point.
5295 *
5296 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5297 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5298 * or receive notification when the value of the property changes.
5299 */
5300 Glib::PropertyProxy_ReadOnly< float > property_pivot_point_z() const;
5301 #endif //#GLIBMM_PROPERTIES_ENABLED
5302
5303 #ifdef GLIBMM_PROPERTIES_ENABLED
5304 /** The position of the origin of the actor.
5305 *
5306 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5307 * @return A PropertyProxy that allows you to get or set the value of the property,
5308 * or receive notification when the value of the property changes.
5309 */
5310 Glib::PropertyProxy< Point > property_position() ;
5311 #endif //#GLIBMM_PROPERTIES_ENABLED
5312
5313 #ifdef GLIBMM_PROPERTIES_ENABLED
5314 /** The position of the origin of the actor.
5315 *
5316 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5317 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5318 * or receive notification when the value of the property changes.
5319 */
5320 Glib::PropertyProxy_ReadOnly< Point > property_position() const;
5321 #endif //#GLIBMM_PROPERTIES_ENABLED
5322
5323 #ifdef GLIBMM_PROPERTIES_ENABLED
5324 /** Whether the actor is reactive to events.
5325 *
5326 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5327 * @return A PropertyProxy that allows you to get or set the value of the property,
5328 * or receive notification when the value of the property changes.
5329 */
5330 Glib::PropertyProxy< bool > property_reactive() ;
5331 #endif //#GLIBMM_PROPERTIES_ENABLED
5332
5333 #ifdef GLIBMM_PROPERTIES_ENABLED
5334 /** Whether the actor is reactive to events.
5335 *
5336 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5337 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5338 * or receive notification when the value of the property changes.
5339 */
5340 Glib::PropertyProxy_ReadOnly< bool > property_reactive() const;
5341 #endif //#GLIBMM_PROPERTIES_ENABLED
5342
5343 #ifdef GLIBMM_PROPERTIES_ENABLED
5344 /** Whether the actor has been realized.
5345 *
5346 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5347 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5348 * or receive notification when the value of the property changes.
5349 */
5350 Glib::PropertyProxy_ReadOnly< bool > property_realized() const;
5351 #endif //#GLIBMM_PROPERTIES_ENABLED
5352
5353
5354 #ifdef GLIBMM_PROPERTIES_ENABLED
5355 /** The actor's request mode.
5356 *
5357 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5358 * @return A PropertyProxy that allows you to get or set the value of the property,
5359 * or receive notification when the value of the property changes.
5360 */
5361 Glib::PropertyProxy< RequestMode > property_request_mode() ;
5362 #endif //#GLIBMM_PROPERTIES_ENABLED
5363
5364 #ifdef GLIBMM_PROPERTIES_ENABLED
5365 /** The actor's request mode.
5366 *
5367 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5368 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5369 * or receive notification when the value of the property changes.
5370 */
5371 Glib::PropertyProxy_ReadOnly< RequestMode > property_request_mode() const;
5372 #endif //#GLIBMM_PROPERTIES_ENABLED
5373
5374 #ifdef GLIBMM_PROPERTIES_ENABLED
5375 /** The rotation angle on the X axis.
5376 *
5377 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5378 * @return A PropertyProxy that allows you to get or set the value of the property,
5379 * or receive notification when the value of the property changes.
5380 */
5381 Glib::PropertyProxy< double > property_rotation_angle_x() ;
5382 #endif //#GLIBMM_PROPERTIES_ENABLED
5383
5384 #ifdef GLIBMM_PROPERTIES_ENABLED
5385 /** The rotation angle on the X axis.
5386 *
5387 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5388 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5389 * or receive notification when the value of the property changes.
5390 */
5391 Glib::PropertyProxy_ReadOnly< double > property_rotation_angle_x() const;
5392 #endif //#GLIBMM_PROPERTIES_ENABLED
5393
5394 #ifdef GLIBMM_PROPERTIES_ENABLED
5395 /** The rotation angle on the Y axis.
5396 *
5397 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5398 * @return A PropertyProxy that allows you to get or set the value of the property,
5399 * or receive notification when the value of the property changes.
5400 */
5401 Glib::PropertyProxy< double > property_rotation_angle_y() ;
5402 #endif //#GLIBMM_PROPERTIES_ENABLED
5403
5404 #ifdef GLIBMM_PROPERTIES_ENABLED
5405 /** The rotation angle on the Y axis.
5406 *
5407 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5408 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5409 * or receive notification when the value of the property changes.
5410 */
5411 Glib::PropertyProxy_ReadOnly< double > property_rotation_angle_y() const;
5412 #endif //#GLIBMM_PROPERTIES_ENABLED
5413
5414 #ifdef GLIBMM_PROPERTIES_ENABLED
5415 /** The rotation angle on the Z axis.
5416 *
5417 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5418 * @return A PropertyProxy that allows you to get or set the value of the property,
5419 * or receive notification when the value of the property changes.
5420 */
5421 Glib::PropertyProxy< double > property_rotation_angle_z() ;
5422 #endif //#GLIBMM_PROPERTIES_ENABLED
5423
5424 #ifdef GLIBMM_PROPERTIES_ENABLED
5425 /** The rotation angle on the Z axis.
5426 *
5427 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5428 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5429 * or receive notification when the value of the property changes.
5430 */
5431 Glib::PropertyProxy_ReadOnly< double > property_rotation_angle_z() const;
5432 #endif //#GLIBMM_PROPERTIES_ENABLED
5433
5434 #ifdef GLIBMM_PROPERTIES_ENABLED
5435 /** The rotation center on the X axis.
5436 *
5437 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5438 * @return A PropertyProxy that allows you to get or set the value of the property,
5439 * or receive notification when the value of the property changes.
5440 */
5441 Glib::PropertyProxy< Vertex > property_rotation_center_x() ;
5442 #endif //#GLIBMM_PROPERTIES_ENABLED
5443
5444 #ifdef GLIBMM_PROPERTIES_ENABLED
5445 /** The rotation center on the X axis.
5446 *
5447 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5448 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5449 * or receive notification when the value of the property changes.
5450 */
5451 Glib::PropertyProxy_ReadOnly< Vertex > property_rotation_center_x() const;
5452 #endif //#GLIBMM_PROPERTIES_ENABLED
5453
5454 #ifdef GLIBMM_PROPERTIES_ENABLED
5455 /** The rotation center on the Y axis.
5456 *
5457 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5458 * @return A PropertyProxy that allows you to get or set the value of the property,
5459 * or receive notification when the value of the property changes.
5460 */
5461 Glib::PropertyProxy< Vertex > property_rotation_center_y() ;
5462 #endif //#GLIBMM_PROPERTIES_ENABLED
5463
5464 #ifdef GLIBMM_PROPERTIES_ENABLED
5465 /** The rotation center on the Y axis.
5466 *
5467 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5468 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5469 * or receive notification when the value of the property changes.
5470 */
5471 Glib::PropertyProxy_ReadOnly< Vertex > property_rotation_center_y() const;
5472 #endif //#GLIBMM_PROPERTIES_ENABLED
5473
5474 #ifdef GLIBMM_PROPERTIES_ENABLED
5475 /** The rotation center on the Z axis.
5476 *
5477 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5478 * @return A PropertyProxy that allows you to get or set the value of the property,
5479 * or receive notification when the value of the property changes.
5480 */
5481 Glib::PropertyProxy< Vertex > property_rotation_center_z() ;
5482 #endif //#GLIBMM_PROPERTIES_ENABLED
5483
5484 #ifdef GLIBMM_PROPERTIES_ENABLED
5485 /** The rotation center on the Z axis.
5486 *
5487 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5488 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5489 * or receive notification when the value of the property changes.
5490 */
5491 Glib::PropertyProxy_ReadOnly< Vertex > property_rotation_center_z() const;
5492 #endif //#GLIBMM_PROPERTIES_ENABLED
5493
5494 #ifdef GLIBMM_PROPERTIES_ENABLED
5495 /** Center point for rotation around the Z axis.
5496 *
5497 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5498 * @return A PropertyProxy that allows you to get or set the value of the property,
5499 * or receive notification when the value of the property changes.
5500 */
5501 Glib::PropertyProxy< Gravity > property_rotation_center_z_gravity() ;
5502 #endif //#GLIBMM_PROPERTIES_ENABLED
5503
5504 #ifdef GLIBMM_PROPERTIES_ENABLED
5505 /** Center point for rotation around the Z axis.
5506 *
5507 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5508 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5509 * or receive notification when the value of the property changes.
5510 */
5511 Glib::PropertyProxy_ReadOnly< Gravity > property_rotation_center_z_gravity() const;
5512 #endif //#GLIBMM_PROPERTIES_ENABLED
5513
5514 #ifdef GLIBMM_PROPERTIES_ENABLED
5515 /** Scale factor on the X axis.
5516 *
5517 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5518 * @return A PropertyProxy that allows you to get or set the value of the property,
5519 * or receive notification when the value of the property changes.
5520 */
5521 Glib::PropertyProxy< double > property_scale_x() ;
5522 #endif //#GLIBMM_PROPERTIES_ENABLED
5523
5524 #ifdef GLIBMM_PROPERTIES_ENABLED
5525 /** Scale factor on the X axis.
5526 *
5527 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5528 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5529 * or receive notification when the value of the property changes.
5530 */
5531 Glib::PropertyProxy_ReadOnly< double > property_scale_x() const;
5532 #endif //#GLIBMM_PROPERTIES_ENABLED
5533
5534 #ifdef GLIBMM_PROPERTIES_ENABLED
5535 /** Scale factor on the Y axis.
5536 *
5537 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5538 * @return A PropertyProxy that allows you to get or set the value of the property,
5539 * or receive notification when the value of the property changes.
5540 */
5541 Glib::PropertyProxy< double > property_scale_y() ;
5542 #endif //#GLIBMM_PROPERTIES_ENABLED
5543
5544 #ifdef GLIBMM_PROPERTIES_ENABLED
5545 /** Scale factor on the Y axis.
5546 *
5547 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5548 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5549 * or receive notification when the value of the property changes.
5550 */
5551 Glib::PropertyProxy_ReadOnly< double > property_scale_y() const;
5552 #endif //#GLIBMM_PROPERTIES_ENABLED
5553
5554 #ifdef GLIBMM_PROPERTIES_ENABLED
5555 /** Scale factor on the Z axis.
5556 *
5557 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5558 * @return A PropertyProxy that allows you to get or set the value of the property,
5559 * or receive notification when the value of the property changes.
5560 */
5561 Glib::PropertyProxy< double > property_scale_z() ;
5562 #endif //#GLIBMM_PROPERTIES_ENABLED
5563
5564 #ifdef GLIBMM_PROPERTIES_ENABLED
5565 /** Scale factor on the Z axis.
5566 *
5567 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5568 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5569 * or receive notification when the value of the property changes.
5570 */
5571 Glib::PropertyProxy_ReadOnly< double > property_scale_z() const;
5572 #endif //#GLIBMM_PROPERTIES_ENABLED
5573
5574 #ifdef GLIBMM_PROPERTIES_ENABLED
5575 /** Horizontal scale center.
5576 *
5577 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5578 * @return A PropertyProxy that allows you to get or set the value of the property,
5579 * or receive notification when the value of the property changes.
5580 */
5581 Glib::PropertyProxy< double > property_scale_center_x() ;
5582 #endif //#GLIBMM_PROPERTIES_ENABLED
5583
5584 #ifdef GLIBMM_PROPERTIES_ENABLED
5585 /** Horizontal scale center.
5586 *
5587 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5588 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5589 * or receive notification when the value of the property changes.
5590 */
5591 Glib::PropertyProxy_ReadOnly< double > property_scale_center_x() const;
5592 #endif //#GLIBMM_PROPERTIES_ENABLED
5593
5594 #ifdef GLIBMM_PROPERTIES_ENABLED
5595 /** Vertical scale center.
5596 *
5597 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5598 * @return A PropertyProxy that allows you to get or set the value of the property,
5599 * or receive notification when the value of the property changes.
5600 */
5601 Glib::PropertyProxy< double > property_scale_center_y() ;
5602 #endif //#GLIBMM_PROPERTIES_ENABLED
5603
5604 #ifdef GLIBMM_PROPERTIES_ENABLED
5605 /** Vertical scale center.
5606 *
5607 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5608 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5609 * or receive notification when the value of the property changes.
5610 */
5611 Glib::PropertyProxy_ReadOnly< double > property_scale_center_y() const;
5612 #endif //#GLIBMM_PROPERTIES_ENABLED
5613
5614 #ifdef GLIBMM_PROPERTIES_ENABLED
5615 /** The center of scaling.
5616 *
5617 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5618 * @return A PropertyProxy that allows you to get or set the value of the property,
5619 * or receive notification when the value of the property changes.
5620 */
5621 Glib::PropertyProxy< Gravity > property_scale_gravity() ;
5622 #endif //#GLIBMM_PROPERTIES_ENABLED
5623
5624 #ifdef GLIBMM_PROPERTIES_ENABLED
5625 /** The center of scaling.
5626 *
5627 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5628 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5629 * or receive notification when the value of the property changes.
5630 */
5631 Glib::PropertyProxy_ReadOnly< Gravity > property_scale_gravity() const;
5632 #endif //#GLIBMM_PROPERTIES_ENABLED
5633
5634 #ifdef GLIBMM_PROPERTIES_ENABLED
5635 /** Whether the actor is shown when parented.
5636 *
5637 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5638 * @return A PropertyProxy that allows you to get or set the value of the property,
5639 * or receive notification when the value of the property changes.
5640 */
5641 Glib::PropertyProxy< bool > property_show_on_set_parent() ;
5642 #endif //#GLIBMM_PROPERTIES_ENABLED
5643
5644 #ifdef GLIBMM_PROPERTIES_ENABLED
5645 /** Whether the actor is shown when parented.
5646 *
5647 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5648 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5649 * or receive notification when the value of the property changes.
5650 */
5651 Glib::PropertyProxy_ReadOnly< bool > property_show_on_set_parent() const;
5652 #endif //#GLIBMM_PROPERTIES_ENABLED
5653
5654 //TODO: _WRAP_PROPERTY("size", Size)
5655 #ifdef GLIBMM_PROPERTIES_ENABLED
5656 /** Direction of the text.
5657 *
5658 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5659 * @return A PropertyProxy that allows you to get or set the value of the property,
5660 * or receive notification when the value of the property changes.
5661 */
5662 Glib::PropertyProxy< TextDirection > property_text_direction() ;
5663 #endif //#GLIBMM_PROPERTIES_ENABLED
5664
5665 #ifdef GLIBMM_PROPERTIES_ENABLED
5666 /** Direction of the text.
5667 *
5668 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5669 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5670 * or receive notification when the value of the property changes.
5671 */
5672 Glib::PropertyProxy_ReadOnly< TextDirection > property_text_direction() const;
5673 #endif //#GLIBMM_PROPERTIES_ENABLED
5674
5675 #ifdef GLIBMM_PROPERTIES_ENABLED
5676 /** Translation along the X axis.
5677 *
5678 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5679 * @return A PropertyProxy that allows you to get or set the value of the property,
5680 * or receive notification when the value of the property changes.
5681 */
5682 Glib::PropertyProxy< float > property_translation_x() ;
5683 #endif //#GLIBMM_PROPERTIES_ENABLED
5684
5685 #ifdef GLIBMM_PROPERTIES_ENABLED
5686 /** Translation along the X axis.
5687 *
5688 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5689 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5690 * or receive notification when the value of the property changes.
5691 */
5692 Glib::PropertyProxy_ReadOnly< float > property_translation_x() const;
5693 #endif //#GLIBMM_PROPERTIES_ENABLED
5694
5695 #ifdef GLIBMM_PROPERTIES_ENABLED
5696 /** Translation along the Y axis.
5697 *
5698 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5699 * @return A PropertyProxy that allows you to get or set the value of the property,
5700 * or receive notification when the value of the property changes.
5701 */
5702 Glib::PropertyProxy< float > property_translation_y() ;
5703 #endif //#GLIBMM_PROPERTIES_ENABLED
5704
5705 #ifdef GLIBMM_PROPERTIES_ENABLED
5706 /** Translation along the Y axis.
5707 *
5708 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5709 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5710 * or receive notification when the value of the property changes.
5711 */
5712 Glib::PropertyProxy_ReadOnly< float > property_translation_y() const;
5713 #endif //#GLIBMM_PROPERTIES_ENABLED
5714
5715 #ifdef GLIBMM_PROPERTIES_ENABLED
5716 /** Translation along the Z axis.
5717 *
5718 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5719 * @return A PropertyProxy that allows you to get or set the value of the property,
5720 * or receive notification when the value of the property changes.
5721 */
5722 Glib::PropertyProxy< float > property_translation_z() ;
5723 #endif //#GLIBMM_PROPERTIES_ENABLED
5724
5725 #ifdef GLIBMM_PROPERTIES_ENABLED
5726 /** Translation along the Z axis.
5727 *
5728 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5729 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5730 * or receive notification when the value of the property changes.
5731 */
5732 Glib::PropertyProxy_ReadOnly< float > property_translation_z() const;
5733 #endif //#GLIBMM_PROPERTIES_ENABLED
5734
5735 #ifdef GLIBMM_PROPERTIES_ENABLED
5736 /** Transformation matrix.
5737 *
5738 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5739 * @return A PropertyProxy that allows you to get or set the value of the property,
5740 * or receive notification when the value of the property changes.
5741 */
5742 Glib::PropertyProxy< Matrix > property_transform() ;
5743 #endif //#GLIBMM_PROPERTIES_ENABLED
5744
5745 #ifdef GLIBMM_PROPERTIES_ENABLED
5746 /** Transformation matrix.
5747 *
5748 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5749 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5750 * or receive notification when the value of the property changes.
5751 */
5752 Glib::PropertyProxy_ReadOnly< Matrix > property_transform() const;
5753 #endif //#GLIBMM_PROPERTIES_ENABLED
5754
5755 #ifdef GLIBMM_PROPERTIES_ENABLED
5756 /** Whether the transform property is set.
5757 *
5758 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5759 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5760 * or receive notification when the value of the property changes.
5761 */
5762 Glib::PropertyProxy_ReadOnly< bool > property_transform_set() const;
5763 #endif //#GLIBMM_PROPERTIES_ENABLED
5764
5765
5766 #ifdef GLIBMM_PROPERTIES_ENABLED
5767 /** Whether the actor is visible or not.
5768 *
5769 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5770 * @return A PropertyProxy that allows you to get or set the value of the property,
5771 * or receive notification when the value of the property changes.
5772 */
5773 Glib::PropertyProxy< bool > property_visible() ;
5774 #endif //#GLIBMM_PROPERTIES_ENABLED
5775
5776 #ifdef GLIBMM_PROPERTIES_ENABLED
5777 /** Whether the actor is visible or not.
5778 *
5779 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5780 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5781 * or receive notification when the value of the property changes.
5782 */
5783 Glib::PropertyProxy_ReadOnly< bool > property_visible() const;
5784 #endif //#GLIBMM_PROPERTIES_ENABLED
5785
5786 #ifdef GLIBMM_PROPERTIES_ENABLED
5787 /** Width of the actor.
5788 *
5789 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5790 * @return A PropertyProxy that allows you to get or set the value of the property,
5791 * or receive notification when the value of the property changes.
5792 */
5793 Glib::PropertyProxy< float > property_width() ;
5794 #endif //#GLIBMM_PROPERTIES_ENABLED
5795
5796 #ifdef GLIBMM_PROPERTIES_ENABLED
5797 /** Width of the actor.
5798 *
5799 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5800 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5801 * or receive notification when the value of the property changes.
5802 */
5803 Glib::PropertyProxy_ReadOnly< float > property_width() const;
5804 #endif //#GLIBMM_PROPERTIES_ENABLED
5805
5806 #ifdef GLIBMM_PROPERTIES_ENABLED
5807 /** X coordinate of the actor.
5808 *
5809 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5810 * @return A PropertyProxy that allows you to get or set the value of the property,
5811 * or receive notification when the value of the property changes.
5812 */
5813 Glib::PropertyProxy< float > property_x() ;
5814 #endif //#GLIBMM_PROPERTIES_ENABLED
5815
5816 #ifdef GLIBMM_PROPERTIES_ENABLED
5817 /** X coordinate of the actor.
5818 *
5819 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5820 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5821 * or receive notification when the value of the property changes.
5822 */
5823 Glib::PropertyProxy_ReadOnly< float > property_x() const;
5824 #endif //#GLIBMM_PROPERTIES_ENABLED
5825
5826 #ifdef GLIBMM_PROPERTIES_ENABLED
5827 /** The alignment of the actor on the X axis within its allocation.
5828 *
5829 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5830 * @return A PropertyProxy that allows you to get or set the value of the property,
5831 * or receive notification when the value of the property changes.
5832 */
5833 Glib::PropertyProxy< ActorAlign > property_x_align() ;
5834 #endif //#GLIBMM_PROPERTIES_ENABLED
5835
5836 #ifdef GLIBMM_PROPERTIES_ENABLED
5837 /** The alignment of the actor on the X axis within its allocation.
5838 *
5839 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5840 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5841 * or receive notification when the value of the property changes.
5842 */
5843 Glib::PropertyProxy_ReadOnly< ActorAlign > property_x_align() const;
5844 #endif //#GLIBMM_PROPERTIES_ENABLED
5845
5846 #ifdef GLIBMM_PROPERTIES_ENABLED
5847 /** Whether extra horizontal space should be assigned to the actor.
5848 *
5849 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5850 * @return A PropertyProxy that allows you to get or set the value of the property,
5851 * or receive notification when the value of the property changes.
5852 */
5853 Glib::PropertyProxy< bool > property_x_expand() ;
5854 #endif //#GLIBMM_PROPERTIES_ENABLED
5855
5856 #ifdef GLIBMM_PROPERTIES_ENABLED
5857 /** Whether extra horizontal space should be assigned to the actor.
5858 *
5859 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5860 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5861 * or receive notification when the value of the property changes.
5862 */
5863 Glib::PropertyProxy_ReadOnly< bool > property_x_expand() const;
5864 #endif //#GLIBMM_PROPERTIES_ENABLED
5865
5866 #ifdef GLIBMM_PROPERTIES_ENABLED
5867 /** Y coordinate of the actor.
5868 *
5869 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5870 * @return A PropertyProxy that allows you to get or set the value of the property,
5871 * or receive notification when the value of the property changes.
5872 */
5873 Glib::PropertyProxy< float > property_y() ;
5874 #endif //#GLIBMM_PROPERTIES_ENABLED
5875
5876 #ifdef GLIBMM_PROPERTIES_ENABLED
5877 /** Y coordinate of the actor.
5878 *
5879 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5880 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5881 * or receive notification when the value of the property changes.
5882 */
5883 Glib::PropertyProxy_ReadOnly< float > property_y() const;
5884 #endif //#GLIBMM_PROPERTIES_ENABLED
5885
5886 #ifdef GLIBMM_PROPERTIES_ENABLED
5887 /** The alignment of the actor on the Y axis within its allocation.
5888 *
5889 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5890 * @return A PropertyProxy that allows you to get or set the value of the property,
5891 * or receive notification when the value of the property changes.
5892 */
5893 Glib::PropertyProxy< ActorAlign > property_y_align() ;
5894 #endif //#GLIBMM_PROPERTIES_ENABLED
5895
5896 #ifdef GLIBMM_PROPERTIES_ENABLED
5897 /** The alignment of the actor on the Y axis within its allocation.
5898 *
5899 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5900 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5901 * or receive notification when the value of the property changes.
5902 */
5903 Glib::PropertyProxy_ReadOnly< ActorAlign > property_y_align() const;
5904 #endif //#GLIBMM_PROPERTIES_ENABLED
5905
5906 #ifdef GLIBMM_PROPERTIES_ENABLED
5907 /** Whether extra vertical space should be assigned to the actor.
5908 *
5909 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5910 * @return A PropertyProxy that allows you to get or set the value of the property,
5911 * or receive notification when the value of the property changes.
5912 */
5913 Glib::PropertyProxy< bool > property_y_expand() ;
5914 #endif //#GLIBMM_PROPERTIES_ENABLED
5915
5916 #ifdef GLIBMM_PROPERTIES_ENABLED
5917 /** Whether extra vertical space should be assigned to the actor.
5918 *
5919 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5920 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5921 * or receive notification when the value of the property changes.
5922 */
5923 Glib::PropertyProxy_ReadOnly< bool > property_y_expand() const;
5924 #endif //#GLIBMM_PROPERTIES_ENABLED
5925
5926 #ifdef GLIBMM_PROPERTIES_ENABLED
5927 /** The actor's position on the Z axis.
5928 *
5929 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5930 * @return A PropertyProxy that allows you to get or set the value of the property,
5931 * or receive notification when the value of the property changes.
5932 */
5933 Glib::PropertyProxy< float > property_z_position() ;
5934 #endif //#GLIBMM_PROPERTIES_ENABLED
5935
5936 #ifdef GLIBMM_PROPERTIES_ENABLED
5937 /** The actor's position on the Z axis.
5938 *
5939 * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
5940 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
5941 * or receive notification when the value of the property changes.
5942 */
5943 Glib::PropertyProxy_ReadOnly< float > property_z_position() const;
5944 #endif //#GLIBMM_PROPERTIES_ENABLED
5945
5946
5947 protected:
5948 //TODO: Wrap ClutterShaderEffect.
5949
5950 #ifndef CLUTTERMM_DISABLE_DEPRECATED
5951
5952 /** Sets the value for a named parameter of the shader applied
5953 * to @a actor.
5954 *
5955 * @newin{1,0}
5956 *
5957 * Deprecated: 1.8: Use Clutter::ShaderEffect::set_uniform_value() instead
5958 * @deprecated Use ShaderEffect::set_uniform_value() instead.
5959 * @param param The name of the parameter.
5960 * @param value The value of the parameter.
5961 */
5962 void set_shader_param_value(const Glib::ustring& param, const Glib::ValueBase& value);
5963 #endif // CLUTTERMM_DISABLE_DEPRECATED
5964
5965
5966 //TODO: These are deprecated. Remove them when we can break ABI:
5967 virtual void show_all_vfunc();
5968
5969 virtual void hide_all_vfunc();
5970
5971
5972 //The realize and unrealize vfuncs are deprecated.
5973
5974 virtual void map_vfunc();
5975
5976 virtual void unmap_vfunc();
5977
5978 virtual void paint_vfunc();
5979
5980
5981 // TODO: I think we need to hand-code the vfuncs if we need to handle
5982 // the float* being NULL.
5983
5984
5985 virtual void get_preferred_width_vfunc(float for_height, float& min_width_p, float& natural_width_p) const;
5986
5987 virtual void get_preferred_height_vfunc(float for_width, float& min_height_p, float& natural_height_p) const;
5988
5989 virtual void allocate_vfunc(const ActorBox& box, AllocationFlags absolute_origin_changed);
5990
5991
5992 virtual void pick_vfunc(const Color& color);
5993
5994
5995 //TODO: _WRAP_VFUNC(Glib::RefPtr<Gtk::Object> get_accessible(), get_accessible)
5996 //TODO: Wrap ClutterPaintVolume?
5997 virtual bool get_paint_volume_vfunc(ClutterPaintVolume* volume);
5998
5999
6000 virtual bool has_overlaps_vfunc() const;
6001
6002
6003 //TODO: Wrap ClutterPaintNode*?
6004 virtual void paint_node_vfunc(ClutterPaintNode* root);
6005
6006
6007 public:
6008
6009 public:
6010 //C++ methods used to invoke GTK+ virtual functions:
6011
6012 protected:
6013 //GTK+ Virtual Functions (override these to change behaviour):
6014
6015 //Default Signal Handlers::
6016 /// This is a default handler for the signal signal_button_press_event().
6017 virtual bool on_button_press_event(ButtonEvent* event);
6018 /// This is a default handler for the signal signal_button_release_event().
6019 virtual bool on_button_release_event(ButtonEvent* event);
6020 /// This is a default handler for the signal signal_motion_event().
6021 virtual bool on_motion_event(MotionEvent* event);
6022 /// This is a default handler for the signal signal_leave_event().
6023 virtual bool on_leave_event(CrossingEvent* event);
6024 /// This is a default handler for the signal signal_show().
6025 virtual void on_show();
6026 /// This is a default handler for the signal signal_hide().
6027 virtual void on_hide();
6028 /// This is a default handler for the signal signal_key_release_event().
6029 virtual bool on_key_release_event(KeyEvent* event);
6030 /// This is a default handler for the signal signal_enter_event().
6031 virtual bool on_enter_event(CrossingEvent* event);
6032 /// This is a default handler for the signal signal_event().
6033 virtual bool on_event(Event* event);
6034 /// This is a default handler for the signal signal_key_focus_out().
6035 virtual void on_key_focus_out();
6036 /// This is a default handler for the signal signal_key_focus_in().
6037 virtual void on_key_focus_in();
6038 /// This is a default handler for the signal signal_parent_set().
6039 virtual void on_parent_set(const Glib::RefPtr<Actor>& old_parent);
6040 /// This is a default handler for the signal signal_scroll_event().
6041 virtual bool on_scroll_event(ScrollEvent* event);
6042 /// This is a default handler for the signal signal_key_press_event().
6043 virtual bool on_key_press_event(KeyEvent* event);
6044 /// This is a default handler for the signal signal_captured_event().
6045 virtual bool on_captured_event(Event* event);
6046 /// This is a default handler for the signal signal_queue_redaw().
6047 virtual void on_queue_redaw(const Glib::RefPtr<Actor>& origin);
6048 /// This is a default handler for the signal signal_queue_relayout().
6049 virtual void on_queue_relayout();
6050 /// This is a default handler for the signal signal_realize().
6051 virtual void on_realize();
6052 /// This is a default handler for the signal signal_unrealize().
6053 virtual void on_unrealize();
6054 /// This is a default handler for the signal signal_pick().
6055 virtual void on_pick(const Color& color);
6056 /// This is a default handler for the signal signal_touch_event().
6057 virtual bool on_touch_event(ClutterTouchEvent* event);
6058
6059
6060 };
6061
6062 #ifndef CLUTTERMM_DISABLE_DEPRECATED
6063
6064 #ifndef DOXYGEN_SHOULD_SKIP_THIS
6065 template <class ParamType>
set_shader_param(const Glib::ustring & param,const ParamType & value)6066 void Actor::set_shader_param(const Glib::ustring& param, const ParamType& value)
6067 {
6068 Glib::Value<ParamType> param_value;
6069 param_value.init(Glib::Value<ParamType>::value_type());
6070
6071 param_value.set(value);
6072 this->set_shader_param_value(param, param_value);
6073 }
6074 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
6075 #endif // CLUTTERMM_DISABLE_DEPRECATED
6076
6077
6078 } // namespace Clutter
6079
6080
6081 namespace Glib
6082 {
6083 /** A Glib::wrap() method for this object.
6084 *
6085 * @param object The C instance.
6086 * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
6087 * @result A C++ instance that wraps this C instance.
6088 *
6089 * @relates Clutter::Actor
6090 */
6091 Glib::RefPtr<Clutter::Actor> wrap(ClutterActor* object, bool take_copy = false);
6092 }
6093
6094
6095 #endif /* _CLUTTERMM_ACTOR_H */
6096
6097