1 // -*- c++ -*- 2 // Generated by gmmproc 2.40.0 -- DO NOT MODIFY! 3 #ifndef _CLUTTERMM_STAGE_H 4 #define _CLUTTERMM_STAGE_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 <cluttermm/group.h> 28 #include <cluttermm/color.h> 29 30 31 #ifndef DOXYGEN_SHOULD_SKIP_THIS 32 typedef struct _ClutterStage ClutterStage; 33 typedef struct _ClutterStageClass ClutterStageClass; 34 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 35 36 37 namespace Clutter 38 { class Stage_Class; } // namespace Clutter 39 namespace Clutter 40 { 41 42 /** @addtogroup cluttermmEnums cluttermm Enums and Flags */ 43 44 /** 45 * @var PickMode PICK_NONE 46 * Do not paint any actor. 47 * 48 * @var PickMode PICK_REACTIVE 49 * Paint only the reactive actors. 50 * 51 * @var PickMode PICK_ALL 52 * Paint all actors. 53 * 54 * @enum PickMode 55 * 56 * Controls the paint cycle of the scene graph when in pick mode 57 * 58 * @newin{1,0} 59 * @ingroup cluttermmEnums 60 */ 61 enum PickMode 62 { 63 PICK_NONE, 64 PICK_REACTIVE, 65 PICK_ALL 66 }; 67 68 } // namespace Clutter 69 70 71 #ifndef DOXYGEN_SHOULD_SKIP_THIS 72 namespace Glib 73 { 74 75 template <> 76 class Value<Clutter::PickMode> : public Glib::Value_Enum<Clutter::PickMode> 77 { 78 public: 79 static GType value_type() G_GNUC_CONST; 80 }; 81 82 } // namespace Glib 83 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 84 85 86 namespace Clutter 87 { 88 89 90 /** 91 * @deprecated Fog settings are ignored. 92 */ 93 typedef ClutterFog Fog; 94 95 class Perspective 96 { 97 public: 98 #ifndef DOXYGEN_SHOULD_SKIP_THIS 99 typedef Perspective CppObjectType; 100 typedef ClutterPerspective BaseObjectType; 101 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 102 103 /** Get the GType for this class, for use with the underlying GObject type system. 104 */ 105 static GType get_type() G_GNUC_CONST; 106 107 Perspective(); 108 109 explicit Perspective(const ClutterPerspective* gobject); // always takes a copy 110 111 ///Provides access to the underlying C instance. gobj()112 ClutterPerspective* gobj() { return &gobject_; } 113 114 ///Provides access to the underlying C instance. gobj()115 const ClutterPerspective* gobj() const { return &gobject_; } 116 117 protected: 118 ClutterPerspective gobject_; 119 120 private: 121 122 public: 123 Perspective(float fovy, float aspect, float z_near, float z_far); 124 125 float get_fovy() const; 126 void set_fovy(const float& value); 127 float get_aspect() const; 128 void set_aspect(const float& value); 129 float get_z_near() const; 130 void set_z_near(const float& value); 131 float get_z_far() const; 132 void set_z_far(const float& value); 133 134 135 }; 136 137 //TODO: Wrap clutter_feature_available(), as mentioned in the class comment. 138 class Actor; 139 140 /** This is a top level 'window' on which child actors are placed and manipulated. 141 * 142 * Clutter creates a default stage upon initialization, which can be retrieved using Stage::get_default(). Clutter always 143 * provides the default stage, unless the backend is unable to create one. The stage returned by Stage::get_default() is 144 * guaranteed to always be the same. 145 * 146 * Backends might provide support for multiple stages. The support for this feature can be checked at run-time using the 147 * clutter_feature_available() function and the CLUTTER_FEATURE_STAGE_MULTIPLE flag. If the backend used supports multiple 148 * stages, new Clutter::Stage instances can be created. 149 * 150 * Clutter::Stage is a proxy actor, wrapping the backend-specific implementation of the windowing system. It is possible 151 * to subclass ClutterStage, as long as every overridden virtual function calls the implementation in the base class. 152 */ 153 154 class Stage : 155 public Group 156 { 157 158 #ifndef DOXYGEN_SHOULD_SKIP_THIS 159 160 public: 161 typedef Stage CppObjectType; 162 typedef Stage_Class CppClassType; 163 typedef ClutterStage BaseObjectType; 164 typedef ClutterStageClass BaseClassType; 165 166 private: friend class Stage_Class; 167 static CppClassType stage_class_; 168 169 private: 170 // noncopyable 171 Stage(const Stage&); 172 Stage& operator=(const Stage&); 173 174 protected: 175 explicit Stage(const Glib::ConstructParams& construct_params); 176 explicit Stage(ClutterStage* castitem); 177 178 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 179 180 public: 181 virtual ~Stage(); 182 183 /** Get the GType for this class, for use with the underlying GObject type system. 184 */ 185 static GType get_type() G_GNUC_CONST; 186 187 #ifndef DOXYGEN_SHOULD_SKIP_THIS 188 189 190 static GType get_base_type() G_GNUC_CONST; 191 #endif 192 193 ///Provides access to the underlying C GObject. gobj()194 ClutterStage* gobj() { return reinterpret_cast<ClutterStage*>(gobject_); } 195 196 ///Provides access to the underlying C GObject. gobj()197 const ClutterStage* gobj() const { return reinterpret_cast<ClutterStage*>(gobject_); } 198 199 ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs. 200 ClutterStage* gobj_copy(); 201 202 private: 203 204 // Implements Container and Scriptable via Group. 205 206 protected: 207 208 /** 209 * Creates a new stage. Every Clutter::Actor must be placed on a stage, and the 210 * stage first created automatically occupies the window generated when 211 * Clutter::main() is run. 212 * 213 * Clutter can support more than one stage at once; however the ability to 214 * support multiple stages depends on the current backend. Use 215 * feature_available() and CLUTTER::FEATURE_STAGE_MULTIPLE to check at runtime 216 * whether a backend supports multiple stages. 217 * 218 * @return a new stage. 219 * 220 * @newin{0.8} 221 */ 222 Stage(); 223 224 public: 225 226 static Glib::RefPtr<Stage> create(); 227 228 229 #ifndef CLUTTERMM_DISABLE_DEPRECATED 230 231 /** Retrieves a Clutter::Stage singleton. 232 * 233 * This function is not as useful as it sounds, and will most likely 234 * by deprecated in the future. Application code should only create 235 * a Clutter::Stage instance using new(), and manage the 236 * lifetime of the stage manually. 237 * 238 * The default stage singleton has a platform-specific behaviour: on 239 * platforms without the Clutter::FEATURE_STAGE_MULTIPLE feature flag 240 * set, the first Clutter::Stage instance will also be set to be the 241 * default stage instance, and this function will always return a 242 * pointer to it. 243 * 244 * On platforms with the Clutter::FEATURE_STAGE_MULTIPLE feature flag 245 * set, the default stage will be created by the first call to this 246 * function, and every following call will return the same pointer to 247 * it. 248 * 249 * Deprecated: 1.10: Use new() instead. 250 * @deprecated Use Stage::create() instead 251 * @return The main 252 * Clutter::Stage. You should never destroy or unref the returned 253 * actor. 254 */ 255 static Glib::RefPtr<Stage> get_default(); 256 #endif // CLUTTERMM_DISABLE_DEPRECATED 257 258 259 #ifndef CLUTTERMM_DISABLE_DEPRECATED 260 261 /** Sets the stage color. 262 * 263 * Deprecated: 1.10: Use Clutter::Actor::set_background_color() instead. 264 * @deprecated Use Actor::set_background_color() instead. 265 * @param color A Clutter::Color. 266 */ 267 void set_color(const Color& color); 268 #endif // CLUTTERMM_DISABLE_DEPRECATED 269 270 271 /** Retrieves the stage color. 272 * 273 * Deprecated: 1.10: Use Clutter::Actor::get_background_color() instead. 274 * @param color Return location for a Clutter::Color. 275 */ 276 277 Color get_color() const; 278 279 280 /** Sets the stage perspective. Using this function is not recommended 281 * because it will disable Clutter's attempts to generate an 282 * appropriate perspective based on the size of the stage. 283 * @param perspective A Clutter::Perspective. 284 */ 285 void set_perspective(const Perspective& prespective); 286 287 /** Retrieves the stage perspective. 288 * @param perspective Return location for a 289 * Clutter::Perspective. 290 */ 291 void get_perspective(Perspective& prespective); 292 293 /** Asks to place the stage window in the fullscreen or unfullscreen 294 * states. 295 * 296 * ( Note that you shouldn't assume the window is definitely full screen 297 * afterward, because other entities (e.g. the user or window manager) 298 * could unfullscreen it again, and not all window managers honor 299 * requests to fullscreen windows. 300 * 301 * If you want to receive notification of the fullscreen state you 302 * should either use the Clutter::Stage::signal_fullscreen() and 303 * Clutter::Stage::signal_unfullscreen() signals, or use the notify signal 304 * for the Clutter::Stage::property_fullscreen_set() property 305 * 306 * @newin{1,0} 307 * @param fullscreen <tt>true</tt> to to set the stage fullscreen. 308 */ 309 void set_fullscreen(bool fullscreen = true); 310 311 /** Retrieves whether the stage is full screen or not 312 * 313 * @newin{1,0} 314 * @return <tt>true</tt> if the stage is full screen. 315 */ 316 bool get_fullscreen() const; 317 318 /** Shows the cursor on the stage window 319 */ 320 void show_cursor(); 321 322 /** Makes the cursor invisible on the stage window 323 * 324 * @newin{0,4} 325 */ 326 void hide_cursor(); 327 328 /** Gets the stage title. 329 * 330 * @newin{0,4} 331 * @return Pointer to the title string for the stage. The 332 * returned string is owned by the actor and should not 333 * be modified or freed. 334 */ 335 Glib::ustring get_title() const; 336 337 /** Sets the stage title. 338 * 339 * @newin{0,4} 340 * @param title A utf8 string for the stage windows title. 341 */ 342 void set_title(const Glib::ustring& title); 343 344 /** Sets if the stage is resizable by user interaction (e.g.\ via 345 * window manager controls) 346 * 347 * @newin{0,4} 348 * @param resizable Whether the stage should be user resizable. 349 */ 350 void set_user_resizable(bool value = true); 351 352 /** Retrieves the value set with set_user_resizable(). 353 * 354 * @newin{0,4} 355 * @return <tt>true</tt> if the stage is resizable by the user. 356 */ 357 bool get_user_resizable() const; 358 359 /** Sets whether the @a stage should accept the key focus when shown. 360 * 361 * This function should be called before showing @a stage using 362 * Clutter::Actor::show(). 363 * 364 * @newin{1,6} 365 * @param accept_focus <tt>true</tt> to accept focus on show. 366 */ 367 void set_accept_focus(bool value = true); 368 369 /** Retrieves the value set with set_accept_focus(). 370 * 371 * @newin{1,6} 372 * @return <tt>true</tt> if the Clutter::Stage should accept focus, and <tt>false</tt> 373 * otherwise. 374 */ 375 bool get_accept_focus() const; 376 377 378 /** Checks the scene at the coordinates @a x and @a y and returns a pointer 379 * to the Clutter::Actor at those coordinates. 380 * 381 * By using @a pick_mode it is possible to control which actors will be 382 * painted and thus available. 383 * @param pick_mode How the scene graph should be painted. 384 * @param x X coordinate to check. 385 * @param y Y coordinate to check. 386 * @return The actor at the specified coordinates, 387 * if any. 388 */ 389 Glib::RefPtr<Actor> get_actor_at_pos(PickMode pick_mode, int x, int y); 390 391 /** Checks the scene at the coordinates @a x and @a y and returns a pointer 392 * to the Clutter::Actor at those coordinates. 393 * 394 * By using @a pick_mode it is possible to control which actors will be 395 * painted and thus available. 396 * @param pick_mode How the scene graph should be painted. 397 * @param x X coordinate to check. 398 * @param y Y coordinate to check. 399 * @return The actor at the specified coordinates, 400 * if any. 401 */ 402 Glib::RefPtr<const Actor> get_actor_at_pos(PickMode pick_mode, int x, int y) const; 403 404 405 /** Retrieves the actor that is currently under key focus. 406 * 407 * @newin{0,6} 408 * @return The actor with key focus, or the stage. 409 */ 410 Glib::RefPtr<Actor> get_key_focus(); 411 412 /** Retrieves the actor that is currently under key focus. 413 * 414 * @newin{0,6} 415 * @return The actor with key focus, or the stage. 416 */ 417 Glib::RefPtr<const Actor> get_key_focus() const; 418 419 420 /** Sets the key focus on @a actor. An actor with key focus will receive 421 * all the key events. If @a actor is <tt>0</tt>, the stage will receive 422 * focus. 423 * 424 * @newin{0,6} 425 * @param actor The actor to set key focus to, or <tt>0</tt>. 426 */ 427 void set_key_focus(const Glib::RefPtr<Actor>& actor); 428 void set_key_focus(); 429 430 // TODO: Should we rather wrap this as std::string, or 431 // as std::vector<unsigned char>, or Glib::ArrayHandle<guchar>? 432 433 /** Makes a screenshot of the stage in RGBA 8bit data, returns a 434 * linear buffer with @a width * 4 as rowstride. 435 * 436 * The alpha data contained in the returned buffer is driver-dependent, 437 * and not guaranteed to hold any sensible value. 438 * @param x X coordinate of the first pixel that is read from stage. 439 * @param y Y coordinate of the first pixel that is read from stage. 440 * @param width Width dimention of pixels to be read, or -1 for the 441 * entire stage width. 442 * @param height Height dimention of pixels to be read, or -1 for the 443 * entire stage height. 444 * @return A pointer to newly allocated memory with the buffer 445 * or <tt>0</tt> if the read failed. Use Glib::free() on the returned data 446 * to release the resources it has allocated. 447 */ 448 guchar* read_pixels(int x, int y, int width, int height) const; 449 450 #ifndef CLUTTERMM_DISABLE_DEPRECATED 451 452 /** Gets whether the depth cueing effect is enabled on @a stage. 453 * 454 * @newin{0,6} 455 * 456 * Deprecated: 1.10: This function will always return <tt>false</tt> 457 * @deprecated This method will always return false. 458 * @return <tt>true</tt> if the depth cueing effect is enabled. 459 */ 460 bool get_use_fog() const; 461 #endif // CLUTTERMM_DISABLE_DEPRECATED 462 463 464 #ifndef CLUTTERMM_DISABLE_DEPRECATED 465 466 /** Sets whether the depth cueing effect on the stage should be enabled 467 * or not. 468 * 469 * Depth cueing is a 3D effect that makes actors farther away from the 470 * viewing point less opaque, by fading them with the stage color. 471 * 472 * The parameters of the GL fog used can be changed using the 473 * set_fog() function. 474 * 475 * @newin{0,6} 476 * 477 * Deprecated: 1.10: Calling this function produces no visible effect 478 * @deprecated This method has no visible effect. 479 * @param fog <tt>true</tt> for enabling the depth cueing effect. 480 */ 481 void set_use_fog(bool fog = true); 482 #endif // CLUTTERMM_DISABLE_DEPRECATED 483 484 485 #ifndef CLUTTERMM_DISABLE_DEPRECATED 486 487 /** Sets the fog (also known as "depth cueing") settings for the @a stage. 488 * 489 * A Clutter::Stage will only use a linear fog progression, which 490 * depends solely on the distance from the viewer. The cogl_set_fog() 491 * function in COGL exposes more of the underlying implementation, 492 * and allows changing the for progression function. It can be directly 493 * used by disabling the Clutter::Stage::property_use_fog() property and connecting 494 * a signal handler to the Clutter::Actor::signal_paint() signal on the @a stage, 495 * like: 496 * 497 * 498 * [C example ellipted] 499 * 500 * The paint signal handler will call cogl_set_fog() with the 501 * desired settings: 502 * 503 * 504 * [C example ellipted] 505 * 506 * <note>The fogging functions only work correctly when the visible actors use 507 * unmultiplied alpha colors. By default Cogl will premultiply textures and 508 * cogl_set_source_color() will premultiply colors, so unless you explicitly 509 * load your textures requesting an unmultiplied internal format and use 510 * cogl_material_set_color() you can only use fogging with fully opaque actors. 511 * Support for premultiplied colors will improve in the future when we can 512 * depend on fragment shaders.</note> 513 * 514 * @newin{0,6} 515 * 516 * Deprecated: 1.10: Fog settings are ignored. 517 * @deprecated Fog settings are ignored. 518 * @param fog A Clutter::Fog structure. 519 */ 520 void set_fog(const Fog& fog); 521 #endif // CLUTTERMM_DISABLE_DEPRECATED 522 523 524 #ifndef CLUTTERMM_DISABLE_DEPRECATED 525 526 /** Retrieves the current depth cueing settings from the stage. 527 * 528 * @newin{0,6} 529 * 530 * Deprecated: 1.10: This function will always return the default 531 * values of Clutter::Fog 532 * @deprecated This function will always return default values. 533 * @param fog Return location for a Clutter::Fog structure. 534 */ 535 void get_fog(Fog& fog) const; 536 #endif // CLUTTERMM_DISABLE_DEPRECATED 537 538 539 /** This function is used to emit an event on the main stage. 540 * 541 * You should rarely need to use this function, except for 542 * synthetised events. 543 * 544 * @newin{0,4} 545 * @param event A Clutter::Event. 546 * @return The return value from the signal emission. 547 */ 548 void stage_event(Event* event); 549 550 #ifndef CLUTTERMM_DISABLE_DEPRECATED 551 552 /** Checks if @a stage is the default stage, or an instance created using 553 * new() but internally using the same implementation. 554 * 555 * @newin{0,8} 556 * 557 * Deprecated: 1.10: Track the stage pointer inside your application 558 * code, or use Clutter::Actor::get_stage() to retrieve the stage for 559 * a given actor. 560 * @deprecated Track the stage pointer inside your application code 561 * @return <tt>true</tt> if the passed stage is the default one. 562 */ 563 bool is_default() const; 564 #endif // CLUTTERMM_DISABLE_DEPRECATED 565 566 567 /** This function essentially makes sure the right GL context is 568 * current for the passed stage. It is not intended to 569 * be used by applications. 570 * 571 * @newin{0,8} 572 */ 573 void ensure_current(); 574 575 /** Ensures that the GL viewport is updated with the current 576 * stage window size. 577 * 578 * This function will queue a redraw of @a stage. 579 * 580 * This function should not be called by applications; it is used 581 * when embedding a Clutter::Stage into a toolkit with another 582 * windowing system, like GTK+. 583 * 584 * @newin{1,0} 585 */ 586 void ensure_viewport(); 587 588 589 /** Ensures that @a stage is redrawn 590 * 591 * This function should not be called by applications: it is 592 * used when embedding a Clutter::Stage into a toolkit with 593 * another windowing system, like GTK+. 594 * 595 * @newin{1,0} 596 */ 597 void ensure_redraw(); 598 599 600 /** Sets whether motion events received between redraws should 601 * be throttled or not. If motion events are throttled, those 602 * events received by the windowing system between redraws will 603 * be compressed so that only the last event will be propagated 604 * to the @a stage and its actors. 605 * 606 * This function should only be used if you want to have all 607 * the motion events delivered to your application code. 608 * 609 * @newin{1,0} 610 * @param throttle <tt>true</tt> to throttle motion events. 611 */ 612 void set_throttle_motion_events(bool throttle = true); 613 614 /** Retrieves the value set with set_throttle_motion_events() 615 * 616 * @newin{1,0} 617 * @return <tt>true</tt> if the motion events are being throttled, 618 * and <tt>false</tt> otherwise. 619 */ 620 bool get_throttle_motion_events() const; 621 622 623 /** Sets whether the @a stage should honour the Clutter::Actor::property_opacity() and 624 * the alpha channel of the Clutter::Stage::property_color() 625 * 626 * @newin{1,2} 627 * @param use_alpha Whether the stage should honour the opacity or the 628 * alpha channel of the stage color. 629 */ 630 void set_use_alpha(bool use_alpha = true); 631 632 /** Retrieves the value set using set_use_alpha() 633 * 634 * @newin{1,2} 635 * @return <tt>true</tt> if the stage should honour the opacity and the 636 * alpha channel of the stage color. 637 */ 638 bool get_use_alpha() const; 639 640 641 /** Sets the minimum size for a stage window, if the default backend 642 * uses Clutter::Stage inside a window 643 * 644 * This is a convenience function, and it is equivalent to setting the 645 * Clutter::Actor::property_min_width() and Clutter::Actor::property_min_height() on @a stage 646 * 647 * If the current size of @a stage is smaller than the minimum size, the 648 * @a stage will be resized to the new @a width and @a height 649 * 650 * This function has no effect if @a stage is fullscreen 651 * 652 * @newin{1,2} 653 * @param width Width, in pixels. 654 * @param height Height, in pixels. 655 */ 656 void set_minimum_size(guint width, guint height); 657 658 /** Retrieves the minimum size for a stage window as set using 659 * set_minimum_size(). 660 * 661 * The returned size may not correspond to the actual minimum size and 662 * it is specific to the Clutter::Stage implementation inside the 663 * Clutter backend 664 * 665 * @newin{1,2} 666 * @param width Return location for the minimum width, in pixels, 667 * or <tt>0</tt>. 668 * @param height Return location for the minimum height, in pixels, 669 * or <tt>0</tt>. 670 */ 671 void get_minimum_size(guint& width, guint& height); 672 673 /** 674 * Returns the minimum size for the stage. The Point contains the x_minimum and y minimum. 675 * 676 * @return a point with the minimum sizes set as its parameters. 677 */ 678 Point get_minimum_size() const; 679 680 681 /** Sets whether the @a stage should clear itself at the beginning 682 * of each paint cycle or not. 683 * 684 * Clearing the Clutter::Stage can be a costly operation, especially 685 * if the stage is always covered - for instance, in a full-screen 686 * video player or in a game with a background texture. 687 * 688 * <note>This setting is a hint; Clutter might discard this 689 * hint depending on its internal state.</note> 690 * 691 * <warning>If parts of the stage are visible and you disable 692 * clearing you might end up with visual artifacts while painting the 693 * contents of the stage.</warning> 694 * 695 * @newin{1,4} 696 * @param no_clear <tt>true</tt> if the @a stage should not clear itself on every 697 * repaint cycle. 698 */ 699 void set_no_clear_hint(bool no_clear = true); 700 701 /** Retrieves the hint set with set_no_clear_hint() 702 * 703 * @newin{1,4} 704 * @return <tt>true</tt> if the stage should not clear itself on every paint 705 * cycle, and <tt>false</tt> otherwise. 706 */ 707 bool get_no_clear_hint() const; 708 //TODO: wrap 709 710 711 /** Sets whether per-actor motion events (and relative crossing 712 * events) should be disabled or not. 713 * 714 * The default is <tt>true</tt>. 715 * 716 * If @a enable is <tt>false</tt> the following events will not be delivered 717 * to the actors children of @a stage. 718 * 719 * - Clutter::Actor::signal_motion_event() 720 * - Clutter::Actor::signal_enter_event() 721 * - Clutter::Actor::signal_leave_event() 722 * 723 * The events will still be delivered to the Clutter::Stage. 724 * 725 * The main side effect of this function is that disabling the motion 726 * events will disable picking to detect the Clutter::Actor underneath 727 * the pointer for each motion event. This is useful, for instance, 728 * when dragging a Clutter::Actor across the @a stage: the actor underneath 729 * the pointer is not going to change, so it's meaningless to perform 730 * a pick. 731 * 732 * @newin{1,8} 733 * @param enabled <tt>true</tt> to enable the motion events delivery, and <tt>false</tt> 734 * otherwise. 735 */ 736 void set_motion_events_enabled(bool enabled = true); 737 738 /** Retrieves the value set using set_motion_events_enabled(). 739 * 740 * @newin{1,8} 741 * @return <tt>true</tt> if the per-actor motion event delivery is enabled 742 * and <tt>false</tt> otherwise. 743 */ 744 bool get_motion_events_enabled() const; 745 746 747 //signals: 748 749 750 /** 751 * @par Slot Prototype: 752 * <tt>void on_my_%fullscreen()</tt> 753 * 754 * The signal_fullscreen() signal is emitted when the stage is made fullscreen. 755 * 756 * @newin{0,6} 757 */ 758 759 Glib::SignalProxy0< void > signal_fullscreen(); 760 761 762 /** 763 * @par Slot Prototype: 764 * <tt>void on_my_%unfullscreen()</tt> 765 * 766 * The signal_unfullscreen() signal is emitted when the stage leaves a fullscreen 767 * state. 768 * 769 * @newin{0,6} 770 */ 771 772 Glib::SignalProxy0< void > signal_unfullscreen(); 773 774 775 /** 776 * @par Slot Prototype: 777 * <tt>void on_my_%activate()</tt> 778 * 779 * The signal_activate() signal is emitted when the stage receives key focus 780 * from the underlying window system. 781 * 782 * @newin{0,6} 783 */ 784 785 Glib::SignalProxy0< void > signal_activate(); 786 787 788 /** 789 * @par Slot Prototype: 790 * <tt>void on_my_%deactivate()</tt> 791 * 792 * The signal_activate() signal is emitted when the stage loses key focus 793 * from the underlying window system. 794 * 795 * @newin{0,6} 796 */ 797 798 Glib::SignalProxy0< void > signal_deactivate(); 799 800 801 /** 802 * @par Slot Prototype: 803 * <tt>bool on_my_%delete_event(ClutterEvent * event)</tt> 804 * 805 * The signal_delete_event() signal is emitted when the user closes a 806 * Clutter::Stage window using the window controls. 807 * 808 * Clutter by default will call clutter_main_quit() if @a stage is 809 * the default stage, and Clutter::Actor::destroy() for any other 810 * stage. 811 * 812 * It is possible to override the default behaviour by connecting 813 * a new handler and returning <tt>true</tt> there. 814 * 815 * <note>This signal is emitted only on Clutter backends that 816 * embed Clutter::Stage in native windows. It is not emitted for 817 * backends that use a static frame buffer.</note> 818 * 819 * @newin{1,2} 820 * @param event A Clutter::Event of type Clutter::DELETE. 821 */ 822 823 Glib::SignalProxy1< bool,ClutterEvent * > signal_delete_event(); 824 825 826 //There are no vfuncs. 827 828 //properties: 829 #ifdef GLIBMM_PROPERTIES_ENABLED 830 /** Whether the stage should accept focus on show. 831 * 832 * You rarely need to use properties because there are get_ and set_ methods for almost all of them. 833 * @return A PropertyProxy that allows you to get or set the value of the property, 834 * or receive notification when the value of the property changes. 835 */ 836 Glib::PropertyProxy< bool > property_accept_focus() ; 837 #endif //#GLIBMM_PROPERTIES_ENABLED 838 839 #ifdef GLIBMM_PROPERTIES_ENABLED 840 /** Whether the stage should accept focus on show. 841 * 842 * You rarely need to use properties because there are get_ and set_ methods for almost all of them. 843 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 844 * or receive notification when the value of the property changes. 845 */ 846 Glib::PropertyProxy_ReadOnly< bool > property_accept_focus() const; 847 #endif //#GLIBMM_PROPERTIES_ENABLED 848 849 #ifdef GLIBMM_PROPERTIES_ENABLED 850 /** The color of the stage. 851 * 852 * You rarely need to use properties because there are get_ and set_ methods for almost all of them. 853 * @return A PropertyProxy that allows you to get or set the value of the property, 854 * or receive notification when the value of the property changes. 855 */ 856 Glib::PropertyProxy< Color > property_color() ; 857 #endif //#GLIBMM_PROPERTIES_ENABLED 858 859 #ifdef GLIBMM_PROPERTIES_ENABLED 860 /** The color of the stage. 861 * 862 * You rarely need to use properties because there are get_ and set_ methods for almost all of them. 863 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 864 * or receive notification when the value of the property changes. 865 */ 866 Glib::PropertyProxy_ReadOnly< Color > property_color() const; 867 #endif //#GLIBMM_PROPERTIES_ENABLED 868 // deprecated; use background-color. 869 #ifdef GLIBMM_PROPERTIES_ENABLED 870 /** Whether the mouse pointer is visible on the main stage. 871 * 872 * You rarely need to use properties because there are get_ and set_ methods for almost all of them. 873 * @return A PropertyProxy that allows you to get or set the value of the property, 874 * or receive notification when the value of the property changes. 875 */ 876 Glib::PropertyProxy< bool > property_cursor_visible() ; 877 #endif //#GLIBMM_PROPERTIES_ENABLED 878 879 #ifdef GLIBMM_PROPERTIES_ENABLED 880 /** Whether the mouse pointer is visible on the main stage. 881 * 882 * You rarely need to use properties because there are get_ and set_ methods for almost all of them. 883 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 884 * or receive notification when the value of the property changes. 885 */ 886 Glib::PropertyProxy_ReadOnly< bool > property_cursor_visible() const; 887 #endif //#GLIBMM_PROPERTIES_ENABLED 888 889 #ifdef GLIBMM_PROPERTIES_ENABLED 890 /** Whether the main stage is fullscreen. 891 * 892 * You rarely need to use properties because there are get_ and set_ methods for almost all of them. 893 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 894 * or receive notification when the value of the property changes. 895 */ 896 Glib::PropertyProxy_ReadOnly< bool > property_fullscreen_set() const; 897 #endif //#GLIBMM_PROPERTIES_ENABLED 898 899 900 #ifdef GLIBMM_PROPERTIES_ENABLED 901 /** Whether the stage should clear its contents. 902 * 903 * You rarely need to use properties because there are get_ and set_ methods for almost all of them. 904 * @return A PropertyProxy that allows you to get or set the value of the property, 905 * or receive notification when the value of the property changes. 906 */ 907 Glib::PropertyProxy< bool > property_no_clear_hint() ; 908 #endif //#GLIBMM_PROPERTIES_ENABLED 909 910 #ifdef GLIBMM_PROPERTIES_ENABLED 911 /** Whether the stage should clear its contents. 912 * 913 * You rarely need to use properties because there are get_ and set_ methods for almost all of them. 914 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 915 * or receive notification when the value of the property changes. 916 */ 917 Glib::PropertyProxy_ReadOnly< bool > property_no_clear_hint() const; 918 #endif //#GLIBMM_PROPERTIES_ENABLED 919 920 #ifdef GLIBMM_PROPERTIES_ENABLED 921 /** Whether the main stage should be rendered offscreen. 922 * 923 * You rarely need to use properties because there are get_ and set_ methods for almost all of them. 924 * @return A PropertyProxy that allows you to get or set the value of the property, 925 * or receive notification when the value of the property changes. 926 */ 927 Glib::PropertyProxy< bool > property_offscreen() ; 928 #endif //#GLIBMM_PROPERTIES_ENABLED 929 930 #ifdef GLIBMM_PROPERTIES_ENABLED 931 /** Whether the main stage should be rendered offscreen. 932 * 933 * You rarely need to use properties because there are get_ and set_ methods for almost all of them. 934 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 935 * or receive notification when the value of the property changes. 936 */ 937 Glib::PropertyProxy_ReadOnly< bool > property_offscreen() const; 938 #endif //#GLIBMM_PROPERTIES_ENABLED 939 //deprecated, does not do anything. 940 #ifdef GLIBMM_PROPERTIES_ENABLED 941 /** Perspective projection parameters. 942 * 943 * You rarely need to use properties because there are get_ and set_ methods for almost all of them. 944 * @return A PropertyProxy that allows you to get or set the value of the property, 945 * or receive notification when the value of the property changes. 946 */ 947 Glib::PropertyProxy< Perspective > property_perspective() ; 948 #endif //#GLIBMM_PROPERTIES_ENABLED 949 950 #ifdef GLIBMM_PROPERTIES_ENABLED 951 /** Perspective projection parameters. 952 * 953 * You rarely need to use properties because there are get_ and set_ methods for almost all of them. 954 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 955 * or receive notification when the value of the property changes. 956 */ 957 Glib::PropertyProxy_ReadOnly< Perspective > property_perspective() const; 958 #endif //#GLIBMM_PROPERTIES_ENABLED 959 960 #ifdef GLIBMM_PROPERTIES_ENABLED 961 /** Stage Title. 962 * 963 * You rarely need to use properties because there are get_ and set_ methods for almost all of them. 964 * @return A PropertyProxy that allows you to get or set the value of the property, 965 * or receive notification when the value of the property changes. 966 */ 967 Glib::PropertyProxy< Glib::ustring > property_title() ; 968 #endif //#GLIBMM_PROPERTIES_ENABLED 969 970 #ifdef GLIBMM_PROPERTIES_ENABLED 971 /** Stage Title. 972 * 973 * You rarely need to use properties because there are get_ and set_ methods for almost all of them. 974 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 975 * or receive notification when the value of the property changes. 976 */ 977 Glib::PropertyProxy_ReadOnly< Glib::ustring > property_title() const; 978 #endif //#GLIBMM_PROPERTIES_ENABLED 979 980 #ifdef GLIBMM_PROPERTIES_ENABLED 981 /** Whether to enable depth cueing. 982 * 983 * You rarely need to use properties because there are get_ and set_ methods for almost all of them. 984 * @return A PropertyProxy that allows you to get or set the value of the property, 985 * or receive notification when the value of the property changes. 986 */ 987 Glib::PropertyProxy< bool > property_use_fog() ; 988 #endif //#GLIBMM_PROPERTIES_ENABLED 989 990 #ifdef GLIBMM_PROPERTIES_ENABLED 991 /** Whether to enable depth cueing. 992 * 993 * You rarely need to use properties because there are get_ and set_ methods for almost all of them. 994 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 995 * or receive notification when the value of the property changes. 996 */ 997 Glib::PropertyProxy_ReadOnly< bool > property_use_fog() const; 998 #endif //#GLIBMM_PROPERTIES_ENABLED 999 //deprecated, does not do anything. 1000 #ifdef GLIBMM_PROPERTIES_ENABLED 1001 /** Whether the stage is able to be resized via user interaction. 1002 * 1003 * You rarely need to use properties because there are get_ and set_ methods for almost all of them. 1004 * @return A PropertyProxy that allows you to get or set the value of the property, 1005 * or receive notification when the value of the property changes. 1006 */ 1007 Glib::PropertyProxy< bool > property_user_resizable() ; 1008 #endif //#GLIBMM_PROPERTIES_ENABLED 1009 1010 #ifdef GLIBMM_PROPERTIES_ENABLED 1011 /** Whether the stage is able to be resized via user interaction. 1012 * 1013 * You rarely need to use properties because there are get_ and set_ methods for almost all of them. 1014 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 1015 * or receive notification when the value of the property changes. 1016 */ 1017 Glib::PropertyProxy_ReadOnly< bool > property_user_resizable() const; 1018 #endif //#GLIBMM_PROPERTIES_ENABLED 1019 1020 #ifdef GLIBMM_PROPERTIES_ENABLED 1021 /** Settings for the depth cueing. 1022 * 1023 * You rarely need to use properties because there are get_ and set_ methods for almost all of them. 1024 * @return A PropertyProxy that allows you to get or set the value of the property, 1025 * or receive notification when the value of the property changes. 1026 */ 1027 Glib::PropertyProxy< Fog > property_fog() ; 1028 #endif //#GLIBMM_PROPERTIES_ENABLED 1029 1030 #ifdef GLIBMM_PROPERTIES_ENABLED 1031 /** Settings for the depth cueing. 1032 * 1033 * You rarely need to use properties because there are get_ and set_ methods for almost all of them. 1034 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 1035 * or receive notification when the value of the property changes. 1036 */ 1037 Glib::PropertyProxy_ReadOnly< Fog > property_fog() const; 1038 #endif //#GLIBMM_PROPERTIES_ENABLED 1039 //deprecated, does not do anything. 1040 #ifdef GLIBMM_PROPERTIES_ENABLED 1041 /** Whether to honour the alpha component of the stage color. 1042 * 1043 * You rarely need to use properties because there are get_ and set_ methods for almost all of them. 1044 * @return A PropertyProxy that allows you to get or set the value of the property, 1045 * or receive notification when the value of the property changes. 1046 */ 1047 Glib::PropertyProxy< bool > property_use_alpha() ; 1048 #endif //#GLIBMM_PROPERTIES_ENABLED 1049 1050 #ifdef GLIBMM_PROPERTIES_ENABLED 1051 /** Whether to honour the alpha component of the stage color. 1052 * 1053 * You rarely need to use properties because there are get_ and set_ methods for almost all of them. 1054 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 1055 * or receive notification when the value of the property changes. 1056 */ 1057 Glib::PropertyProxy_ReadOnly< bool > property_use_alpha() const; 1058 #endif //#GLIBMM_PROPERTIES_ENABLED 1059 1060 #ifdef GLIBMM_PROPERTIES_ENABLED 1061 /** The currently key focused actor. 1062 * 1063 * You rarely need to use properties because there are get_ and set_ methods for almost all of them. 1064 * @return A PropertyProxy that allows you to get or set the value of the property, 1065 * or receive notification when the value of the property changes. 1066 */ 1067 Glib::PropertyProxy< Glib::RefPtr<Actor> > property_key_focus() ; 1068 #endif //#GLIBMM_PROPERTIES_ENABLED 1069 1070 #ifdef GLIBMM_PROPERTIES_ENABLED 1071 /** The currently key focused actor. 1072 * 1073 * You rarely need to use properties because there are get_ and set_ methods for almost all of them. 1074 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 1075 * or receive notification when the value of the property changes. 1076 */ 1077 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Actor> > property_key_focus() const; 1078 #endif //#GLIBMM_PROPERTIES_ENABLED 1079 1080 1081 protected: 1082 // From the Clutter Docs: 1083 // Applications should call clutter_actor_queue_redraw and not this function. 1084 //_WRAP_METHOD(void queue_redraw(), clutter_stage_queue_redraw) 1085 1086 1087 public: 1088 1089 public: 1090 //C++ methods used to invoke GTK+ virtual functions: 1091 1092 protected: 1093 //GTK+ Virtual Functions (override these to change behaviour): 1094 1095 //Default Signal Handlers:: 1096 /// This is a default handler for the signal signal_fullscreen(). 1097 virtual void on_fullscreen(); 1098 /// This is a default handler for the signal signal_unfullscreen(). 1099 virtual void on_unfullscreen(); 1100 /// This is a default handler for the signal signal_activate(). 1101 virtual void on_activate(); 1102 /// This is a default handler for the signal signal_deactivate(). 1103 virtual void on_deactivate(); 1104 /// This is a default handler for the signal signal_delete_event(). 1105 virtual bool on_delete_event(ClutterEvent * event); 1106 1107 1108 }; 1109 1110 } // namespace Clutter 1111 1112 //vim: ts=2,sw=2 1113 1114 1115 namespace Glib 1116 { 1117 1118 /** @relates Clutter::Perspective 1119 * @param object The C instance 1120 * @result A C++ instance that wraps this C instance. 1121 */ 1122 Clutter::Perspective& wrap(ClutterPerspective* object); 1123 1124 /** @relates Clutter::Perspective 1125 * @param object The C instance 1126 * @result A C++ instance that wraps this C instance. 1127 */ 1128 const Clutter::Perspective& wrap(const ClutterPerspective* object); 1129 1130 #ifndef DOXYGEN_SHOULD_SKIP_THIS 1131 template <> 1132 class Value<Clutter::Perspective> : public Glib::Value_Boxed<Clutter::Perspective> 1133 {}; 1134 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 1135 1136 } // namespace Glib 1137 1138 1139 namespace Glib 1140 { 1141 /** A Glib::wrap() method for this object. 1142 * 1143 * @param object The C instance. 1144 * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref. 1145 * @result A C++ instance that wraps this C instance. 1146 * 1147 * @relates Clutter::Stage 1148 */ 1149 Glib::RefPtr<Clutter::Stage> wrap(ClutterStage* object, bool take_copy = false); 1150 } 1151 1152 1153 #endif /* _CLUTTERMM_STAGE_H */ 1154 1155