2006-05-29 08:59:36 +00:00
|
|
|
/*
|
|
|
|
* Clutter.
|
|
|
|
*
|
|
|
|
* An OpenGL based 'interactive canvas' library.
|
|
|
|
*
|
|
|
|
* Authored By Matthew Allum <mallum@openedhand.com>
|
|
|
|
*
|
|
|
|
* Copyright (C) 2006 OpenedHand
|
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
2010-03-01 12:56:10 +00:00
|
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*
|
|
|
|
*
|
2006-05-29 08:59:36 +00:00
|
|
|
*/
|
|
|
|
|
2006-06-21 22:34:25 +00:00
|
|
|
/**
|
|
|
|
* SECTION:clutter-stage
|
|
|
|
* @short_description: Top level visual element to which actors are placed.
|
2007-10-12 08:17:00 +00:00
|
|
|
*
|
2006-06-21 22:34:25 +00:00
|
|
|
* #ClutterStage is a top level 'window' on which child actors are placed
|
|
|
|
* and manipulated.
|
2008-04-04 15:02:11 +00:00
|
|
|
*
|
|
|
|
* Clutter creates a default stage upon initialization, which can be retrieved
|
|
|
|
* using clutter_stage_get_default(). Clutter always provides the default
|
|
|
|
* stage, unless the backend is unable to create one. The stage returned
|
|
|
|
* by clutter_stage_get_default() is guaranteed to always be the same.
|
|
|
|
*
|
|
|
|
* Backends might provide support for multiple stages. The support for this
|
|
|
|
* feature can be checked at run-time using the clutter_feature_available()
|
|
|
|
* function and the %CLUTTER_FEATURE_STAGE_MULTIPLE flag. If the backend used
|
|
|
|
* supports multiple stages, new #ClutterStage instances can be created
|
|
|
|
* using clutter_stage_new(). These stages must be managed by the developer
|
|
|
|
* using clutter_actor_destroy(), which will take care of destroying all the
|
|
|
|
* actors contained inside them.
|
|
|
|
*
|
|
|
|
* #ClutterStage is a proxy actor, wrapping the backend-specific
|
|
|
|
* implementation of the windowing system. It is possible to subclass
|
|
|
|
* #ClutterStage, as long as every overridden virtual function chains up to
|
|
|
|
* the parent class corresponding function.
|
2006-06-21 22:34:25 +00:00
|
|
|
*/
|
|
|
|
|
2007-10-12 08:17:00 +00:00
|
|
|
#ifdef HAVE_CONFIG_H
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
#include "config.h"
|
2007-10-12 08:17:00 +00:00
|
|
|
#endif
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
|
2006-05-29 08:59:36 +00:00
|
|
|
#include "clutter-stage.h"
|
2010-04-16 14:34:36 +00:00
|
|
|
|
2010-10-21 11:16:05 +00:00
|
|
|
#include "clutter-actor-private.h"
|
2010-10-21 10:49:37 +00:00
|
|
|
#include "clutter-backend-private.h"
|
2006-05-29 08:59:36 +00:00
|
|
|
#include "clutter-color.h"
|
2010-10-21 10:59:50 +00:00
|
|
|
#include "clutter-container.h"
|
|
|
|
#include "clutter-debug.h"
|
|
|
|
#include "clutter-device-manager-private.h"
|
|
|
|
#include "clutter-enum-types.h"
|
|
|
|
#include "clutter-id-pool.h"
|
|
|
|
#include "clutter-main.h"
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
#include "clutter-marshal.h"
|
2009-03-21 20:39:32 +00:00
|
|
|
#include "clutter-master-clock.h"
|
2010-10-21 10:59:50 +00:00
|
|
|
#include "clutter-paint-volume-private.h"
|
2006-11-21 Emmanuele Bassi <ebassi@openedhand.com>
* configure.ac: Enable debug messages also when
--enable-debug is set to "minimum".
* clutter/Makefile.am:
* clutter/clutter-debug.h: Move all debugging macros inside
this private header; make all debug macros depend on the
CLUTTER_ENABLE_DEBUG compile time define, controlled by
the --enable-debug configure switch; add G_LOG_DOMAIN define.
* clutter/clutter-main.c: Clean up the debug stuff; add
command line argument parsing using GOption; the debug
messages now are triggered like this:
CLUTTER_DEBUG=section:section:... clutter-app
or like this:
clutter-app --clutter-debug=section:section:...
where "section" is one of the sections listed in clutter-main.c,
or "all", for all sections; each section is bound to a flag,
which can be used to define a domain when adding a debug note
using the CLUTTER_NOTE() macro; the old CLUTTER_DBG() macro is
just a wrapper around that, under the CLUTTER_DEBUG_MISC domain;
CLUTTER_NOTE() is used like this:
CLUTTER_NOTE (DOMAIN, log-function);
where log function is g_printerr(), g_message(), g_warning(),
g_critical() or directly g_log() - for instance:
CLUTTER_NOTE (PANGO, g_warning ("Cache miss: %d", glyph));
will print the warning only if the "pango" flag has been
set to the CLUTTER_DEBUG envvar or passed to the --clutter-debug
command line argument.
similar to CLUTTER_SHOW_FPS, there's also the --clutter-show-fps
command line switch; also, the --display and --screen command
line switches have been added: the first overrides the DISPLAY
envvar and the second controls the X screen used by Clutter to
get the root window on the display.
* clutter/clutter-main.h:
* clutter/clutter-main.c: Add extended support for GOption
in Clutter; use clutter_init_with_args() to let Clutter
parse your own command line arguments; use instead
clutter_get_option_group() to get the GOptionGroup used by
Clutter if you want to do the parsing yourself with
g_option_context_parse(). The init sequence has been verified,
updated and moved into common functions where possible.
* clutter/pango/pangoclutter-render.c:
* clutter/*.c: Include "clutter-debug.h" where needed; use
CLUTTER_NOTE() instead of CLUTTER_DBG().
* examples/super-oh.c: Use the new clutter_init_with_args()
function, and add a --num-hands command line switch to
the SuperOH example code controlling the number of hands at
runtime.
2006-11-21 21:27:53 +00:00
|
|
|
#include "clutter-private.h"
|
2009-03-30 15:41:02 +00:00
|
|
|
#include "clutter-profile.h"
|
2010-10-21 10:59:50 +00:00
|
|
|
#include "clutter-stage-manager-private.h"
|
2010-10-21 10:29:09 +00:00
|
|
|
#include "clutter-stage-private.h"
|
2010-10-21 10:59:50 +00:00
|
|
|
#include "clutter-util.h"
|
|
|
|
#include "clutter-version.h" /* For flavour */
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
#include "cogl/cogl.h"
|
2007-03-25 11:47:30 +00:00
|
|
|
|
2008-04-04 15:02:11 +00:00
|
|
|
G_DEFINE_TYPE (ClutterStage, clutter_stage, CLUTTER_TYPE_GROUP);
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
#define CLUTTER_STAGE_GET_PRIVATE(obj) \
|
|
|
|
(G_TYPE_INSTANCE_GET_PRIVATE ((obj), CLUTTER_TYPE_STAGE, ClutterStagePrivate))
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2010-04-16 14:34:36 +00:00
|
|
|
/* <private>
|
|
|
|
* ClutterStageHint:
|
|
|
|
* @CLUTTER_STAGE_NONE: No hint set
|
|
|
|
* @CLUTTER_STAGE_NO_CLEAR_ON_PAINT: When this hint is set, the stage
|
|
|
|
* should not clear the viewport; this flag is useful when painting
|
|
|
|
* fully opaque actors covering the whole visible area of the stage,
|
|
|
|
* i.e. when no blending with the stage color happens over the whole
|
|
|
|
* stage viewport
|
|
|
|
*
|
|
|
|
* A series of hints that enable or disable behaviours on the stage
|
|
|
|
*/
|
|
|
|
typedef enum { /*< prefix=CLUTTER_STAGE >*/
|
|
|
|
CLUTTER_STAGE_HINT_NONE = 0,
|
|
|
|
|
|
|
|
CLUTTER_STAGE_NO_CLEAR_ON_PAINT = 1 << 0
|
|
|
|
} ClutterStageHint;
|
|
|
|
|
|
|
|
#define STAGE_NO_CLEAR_ON_PAINT(s) ((((ClutterStage *) (s))->priv->stage_hints & CLUTTER_STAGE_NO_CLEAR_ON_PAINT) != 0)
|
|
|
|
|
2010-09-10 00:33:02 +00:00
|
|
|
struct _ClutterStageQueueRedrawEntry
|
|
|
|
{
|
|
|
|
ClutterActor *actor;
|
|
|
|
gboolean has_clip;
|
|
|
|
ClutterPaintVolume clip;
|
|
|
|
};
|
|
|
|
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
struct _ClutterStagePrivate
|
2006-05-29 08:59:36 +00:00
|
|
|
{
|
2008-04-04 15:02:11 +00:00
|
|
|
/* the stage implementation */
|
2009-08-13 11:34:07 +00:00
|
|
|
ClutterStageWindow *impl;
|
2008-04-04 15:02:11 +00:00
|
|
|
|
2007-05-25 10:56:09 +00:00
|
|
|
ClutterColor color;
|
|
|
|
ClutterPerspective perspective;
|
2010-09-07 12:10:55 +00:00
|
|
|
CoglMatrix projection;
|
|
|
|
int viewport[4];
|
2007-11-21 11:55:26 +00:00
|
|
|
ClutterFog fog;
|
2007-03-22 18:21:59 +00:00
|
|
|
|
2008-04-04 15:02:11 +00:00
|
|
|
gchar *title;
|
|
|
|
ClutterActor *key_focused_actor;
|
|
|
|
|
2009-06-06 23:10:41 +00:00
|
|
|
GQueue *event_queue;
|
2008-04-04 15:02:11 +00:00
|
|
|
|
2010-04-16 14:34:36 +00:00
|
|
|
ClutterStageHint stage_hints;
|
|
|
|
|
2010-09-10 23:29:05 +00:00
|
|
|
gint picks_per_frame;
|
|
|
|
|
2010-09-07 17:04:19 +00:00
|
|
|
GArray *paint_volume_stack;
|
|
|
|
|
2010-09-07 21:21:28 +00:00
|
|
|
const ClutterGeometry *current_paint_clip;
|
|
|
|
|
2010-09-10 00:33:02 +00:00
|
|
|
GList *pending_queue_redraws;
|
|
|
|
|
2010-10-27 17:02:47 +00:00
|
|
|
ClutterPickMode pick_buffer_mode;
|
|
|
|
|
2010-09-07 19:08:00 +00:00
|
|
|
guint relayout_pending : 1;
|
2009-07-14 12:47:35 +00:00
|
|
|
guint redraw_pending : 1;
|
|
|
|
guint is_fullscreen : 1;
|
|
|
|
guint is_cursor_visible : 1;
|
|
|
|
guint is_user_resizable : 1;
|
|
|
|
guint use_fog : 1;
|
|
|
|
guint throttle_motion_events : 1;
|
2009-12-01 16:16:18 +00:00
|
|
|
guint use_alpha : 1;
|
2010-02-26 18:36:38 +00:00
|
|
|
guint min_size_changed : 1;
|
2010-09-07 12:10:55 +00:00
|
|
|
guint dirty_viewport : 1;
|
|
|
|
guint dirty_projection : 1;
|
2010-09-10 23:29:05 +00:00
|
|
|
guint have_valid_pick_buffer : 1;
|
2010-12-28 17:37:18 +00:00
|
|
|
guint accept_focus : 1;
|
2006-05-29 08:59:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
enum
|
|
|
|
{
|
|
|
|
PROP_0,
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
PROP_COLOR,
|
2009-06-09 12:48:03 +00:00
|
|
|
PROP_FULLSCREEN_SET,
|
2006-06-02 20:24:55 +00:00
|
|
|
PROP_OFFSCREEN,
|
2007-05-25 10:56:09 +00:00
|
|
|
PROP_CURSOR_VISIBLE,
|
|
|
|
PROP_PERSPECTIVE,
|
2007-06-19 09:10:37 +00:00
|
|
|
PROP_TITLE,
|
2010-08-11 11:40:22 +00:00
|
|
|
PROP_USER_RESIZABLE,
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
PROP_USE_FOG,
|
2009-12-01 16:16:18 +00:00
|
|
|
PROP_FOG,
|
2010-02-01 11:04:59 +00:00
|
|
|
PROP_USE_ALPHA,
|
2010-04-16 14:34:36 +00:00
|
|
|
PROP_KEY_FOCUS,
|
2010-12-28 17:37:18 +00:00
|
|
|
PROP_NO_CLEAR_HINT,
|
|
|
|
PROP_ACCEPT_FOCUS
|
2006-05-29 08:59:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
enum
|
|
|
|
{
|
2007-08-24 15:12:52 +00:00
|
|
|
FULLSCREEN,
|
|
|
|
UNFULLSCREEN,
|
|
|
|
ACTIVATE,
|
|
|
|
DEACTIVATE,
|
2010-01-12 15:44:28 +00:00
|
|
|
DELETE_EVENT,
|
2009-01-12 14:19:48 +00:00
|
|
|
|
2006-05-29 08:59:36 +00:00
|
|
|
LAST_SIGNAL
|
|
|
|
};
|
|
|
|
|
2007-04-25 14:22:24 +00:00
|
|
|
static guint stage_signals[LAST_SIGNAL] = { 0, };
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
|
2008-11-17 14:21:49 +00:00
|
|
|
static const ClutterColor default_stage_color = { 255, 255, 255, 255 };
|
|
|
|
|
2010-09-10 00:33:02 +00:00
|
|
|
static void _clutter_stage_maybe_finish_queue_redraws (ClutterStage *stage);
|
|
|
|
|
|
|
|
static void
|
|
|
|
_clutter_stage_maybe_finish_queue_redraws (ClutterStage *stage);
|
|
|
|
|
2008-04-04 15:02:11 +00:00
|
|
|
static void
|
2008-06-10 Emmanuele Bassi <ebassi@openedhand.com>
Bug #815 - Split up request, allocation, and paint box
* clutter/clutter-actor.[ch]: Rework the size allocation,
request and paint area. Now ::request_coords() is called
::allocate(), and ::query_coords() has been split into
::get_preferred_width() and ::get_preferred_height(). See
the documentation and the layout test on how to implement
a container and layout manager with the new API. (#915,
based on a patch by Havoc Pennington, Lucas Rocha and Johan
Bilien)
* clutter/clutter-clone-texture.c: Port CloneTexture to
the new size negotiation API; it just means forwarding
the requests to the parent texture.
* clutter/clutter-deprecated.h: Add deprecated and replaced
API.
* clutter/clutter-entry.c: Port Entry to the new size
negotiation API.
* clutter/clutter-group.c: Port Group to the new size
negotiation API; the semantics of the Group actor do not
change.
* clutter/clutter-label.c: Port Label to the new size
negotiation API, and vastly simplify the code.
* clutter/clutter-main.[ch]: Add API for executing a
relayout when needed.
* clutter/clutter-private.h: Add new Stage private API.
* clutter/clutter-rectangle.c: Update the get_abs_opacity()
call to get_paint_opacity().
* clutter/clutter-stage.c:
(clutter_stage_get_preferred_width),
(clutter_stage_get_preferred_height),
(clutter_stage_allocate),
(clutter_stage_class_init): Port Stage to the new size
negotiation API.
* clutter/clutter-texture.c: Port Texture to the new size
negotiation API.
* clutter/clutter-types.h: Add ClutterRequestMode enumeration.
* clutter/x11/clutter-stage-x11.c: Port the X11 stage
implementation to the new size negotiation API.
* tests/Makefile.am: Add the layout manager test case.
* tests/test-opacity.c: Update.
* tests/test-project.c: Update.
* tests/test-layout.c: Test case for a layout manager implemented
using the new size negotiation API; the layout manager handles
both transformed and untransformed children.
2008-06-10 17:07:52 +00:00
|
|
|
clutter_stage_get_preferred_width (ClutterActor *self,
|
Remove Units from the public API
With the recent change to internal floating point values, ClutterUnit
has become a redundant type, defined to be a float. All integer entry
points are being internally converted to floating point values to be
passed to the GL pipeline with the least amount of conversion.
ClutterUnit is thus exposed as just a "pixel with fractionary bits",
and not -- as users might think -- as generic, resolution and device
independent units. not that it was the case, but a definitive amount
of people was convinced it did provide this "feature", and was flummoxed
about the mere existence of this type.
So, having ClutterUnit exposed in the public API doubles the entry
points and has the following disadvantages:
- we have to maintain twice the amount of entry points in ClutterActor
- we still do an integer-to-float implicit conversion
- we introduce a weird impedance between pixels and "pixels with
fractionary bits"
- language bindings will have to choose what to bind, and resort
to manually overriding the API
+ *except* for language bindings based on GObject-Introspection, as
they cannot do manual overrides, thus will replicate the entire
set of entry points
For these reason, we should coalesces every Actor entry point for
pixels and for ClutterUnit into a single entry point taking a float,
like:
void clutter_actor_set_x (ClutterActor *self,
gfloat x);
void clutter_actor_get_size (ClutterActor *self,
gfloat *width,
gfloat *height);
gfloat clutter_actor_get_height (ClutterActor *self);
etc.
The issues I have identified are:
- we'll have a two cases of compiler warnings:
- printf() format of the return values from %d to %f
- clutter_actor_get_size() taking floats instead of unsigned ints
- we'll have a problem with varargs when passing an integer instead
of a floating point value, except on 64bit platforms where the
size of a float is the same as the size of an int
To be clear: the *intent* of the API should not change -- we still use
pixels everywhere -- but:
- we remove ambiguity in the API with regard to pixels and units
- we remove entry points we get to maintain for the whole 1.0
version of the API
- we make things simpler to bind for both manual language bindings
and automatic (gobject-introspection based) ones
- we have the simplest API possible while still exposing the
capabilities of the underlying GL implementation
2009-05-06 15:44:47 +00:00
|
|
|
gfloat for_height,
|
|
|
|
gfloat *min_width_p,
|
|
|
|
gfloat *natural_width_p)
|
2008-04-04 15:02:11 +00:00
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv = CLUTTER_STAGE (self)->priv;
|
2009-08-13 11:34:07 +00:00
|
|
|
ClutterGeometry geom = { 0, };
|
2008-04-04 15:02:11 +00:00
|
|
|
|
2009-06-16 15:38:01 +00:00
|
|
|
if (priv->impl == NULL)
|
|
|
|
return;
|
2008-04-04 15:02:11 +00:00
|
|
|
|
2009-08-13 11:34:07 +00:00
|
|
|
_clutter_stage_window_get_geometry (priv->impl, &geom);
|
|
|
|
|
|
|
|
if (min_width_p)
|
|
|
|
*min_width_p = geom.width;
|
|
|
|
|
|
|
|
if (natural_width_p)
|
|
|
|
*natural_width_p = geom.width;
|
2008-04-04 15:02:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2008-06-10 Emmanuele Bassi <ebassi@openedhand.com>
Bug #815 - Split up request, allocation, and paint box
* clutter/clutter-actor.[ch]: Rework the size allocation,
request and paint area. Now ::request_coords() is called
::allocate(), and ::query_coords() has been split into
::get_preferred_width() and ::get_preferred_height(). See
the documentation and the layout test on how to implement
a container and layout manager with the new API. (#915,
based on a patch by Havoc Pennington, Lucas Rocha and Johan
Bilien)
* clutter/clutter-clone-texture.c: Port CloneTexture to
the new size negotiation API; it just means forwarding
the requests to the parent texture.
* clutter/clutter-deprecated.h: Add deprecated and replaced
API.
* clutter/clutter-entry.c: Port Entry to the new size
negotiation API.
* clutter/clutter-group.c: Port Group to the new size
negotiation API; the semantics of the Group actor do not
change.
* clutter/clutter-label.c: Port Label to the new size
negotiation API, and vastly simplify the code.
* clutter/clutter-main.[ch]: Add API for executing a
relayout when needed.
* clutter/clutter-private.h: Add new Stage private API.
* clutter/clutter-rectangle.c: Update the get_abs_opacity()
call to get_paint_opacity().
* clutter/clutter-stage.c:
(clutter_stage_get_preferred_width),
(clutter_stage_get_preferred_height),
(clutter_stage_allocate),
(clutter_stage_class_init): Port Stage to the new size
negotiation API.
* clutter/clutter-texture.c: Port Texture to the new size
negotiation API.
* clutter/clutter-types.h: Add ClutterRequestMode enumeration.
* clutter/x11/clutter-stage-x11.c: Port the X11 stage
implementation to the new size negotiation API.
* tests/Makefile.am: Add the layout manager test case.
* tests/test-opacity.c: Update.
* tests/test-project.c: Update.
* tests/test-layout.c: Test case for a layout manager implemented
using the new size negotiation API; the layout manager handles
both transformed and untransformed children.
2008-06-10 17:07:52 +00:00
|
|
|
clutter_stage_get_preferred_height (ClutterActor *self,
|
Remove Units from the public API
With the recent change to internal floating point values, ClutterUnit
has become a redundant type, defined to be a float. All integer entry
points are being internally converted to floating point values to be
passed to the GL pipeline with the least amount of conversion.
ClutterUnit is thus exposed as just a "pixel with fractionary bits",
and not -- as users might think -- as generic, resolution and device
independent units. not that it was the case, but a definitive amount
of people was convinced it did provide this "feature", and was flummoxed
about the mere existence of this type.
So, having ClutterUnit exposed in the public API doubles the entry
points and has the following disadvantages:
- we have to maintain twice the amount of entry points in ClutterActor
- we still do an integer-to-float implicit conversion
- we introduce a weird impedance between pixels and "pixels with
fractionary bits"
- language bindings will have to choose what to bind, and resort
to manually overriding the API
+ *except* for language bindings based on GObject-Introspection, as
they cannot do manual overrides, thus will replicate the entire
set of entry points
For these reason, we should coalesces every Actor entry point for
pixels and for ClutterUnit into a single entry point taking a float,
like:
void clutter_actor_set_x (ClutterActor *self,
gfloat x);
void clutter_actor_get_size (ClutterActor *self,
gfloat *width,
gfloat *height);
gfloat clutter_actor_get_height (ClutterActor *self);
etc.
The issues I have identified are:
- we'll have a two cases of compiler warnings:
- printf() format of the return values from %d to %f
- clutter_actor_get_size() taking floats instead of unsigned ints
- we'll have a problem with varargs when passing an integer instead
of a floating point value, except on 64bit platforms where the
size of a float is the same as the size of an int
To be clear: the *intent* of the API should not change -- we still use
pixels everywhere -- but:
- we remove ambiguity in the API with regard to pixels and units
- we remove entry points we get to maintain for the whole 1.0
version of the API
- we make things simpler to bind for both manual language bindings
and automatic (gobject-introspection based) ones
- we have the simplest API possible while still exposing the
capabilities of the underlying GL implementation
2009-05-06 15:44:47 +00:00
|
|
|
gfloat for_width,
|
|
|
|
gfloat *min_height_p,
|
|
|
|
gfloat *natural_height_p)
|
2008-04-04 15:02:11 +00:00
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv = CLUTTER_STAGE (self)->priv;
|
2009-08-13 11:34:07 +00:00
|
|
|
ClutterGeometry geom = { 0, };
|
2008-04-04 15:02:11 +00:00
|
|
|
|
2009-06-16 15:38:01 +00:00
|
|
|
if (priv->impl == NULL)
|
|
|
|
return;
|
2008-06-10 Emmanuele Bassi <ebassi@openedhand.com>
Bug #815 - Split up request, allocation, and paint box
* clutter/clutter-actor.[ch]: Rework the size allocation,
request and paint area. Now ::request_coords() is called
::allocate(), and ::query_coords() has been split into
::get_preferred_width() and ::get_preferred_height(). See
the documentation and the layout test on how to implement
a container and layout manager with the new API. (#915,
based on a patch by Havoc Pennington, Lucas Rocha and Johan
Bilien)
* clutter/clutter-clone-texture.c: Port CloneTexture to
the new size negotiation API; it just means forwarding
the requests to the parent texture.
* clutter/clutter-deprecated.h: Add deprecated and replaced
API.
* clutter/clutter-entry.c: Port Entry to the new size
negotiation API.
* clutter/clutter-group.c: Port Group to the new size
negotiation API; the semantics of the Group actor do not
change.
* clutter/clutter-label.c: Port Label to the new size
negotiation API, and vastly simplify the code.
* clutter/clutter-main.[ch]: Add API for executing a
relayout when needed.
* clutter/clutter-private.h: Add new Stage private API.
* clutter/clutter-rectangle.c: Update the get_abs_opacity()
call to get_paint_opacity().
* clutter/clutter-stage.c:
(clutter_stage_get_preferred_width),
(clutter_stage_get_preferred_height),
(clutter_stage_allocate),
(clutter_stage_class_init): Port Stage to the new size
negotiation API.
* clutter/clutter-texture.c: Port Texture to the new size
negotiation API.
* clutter/clutter-types.h: Add ClutterRequestMode enumeration.
* clutter/x11/clutter-stage-x11.c: Port the X11 stage
implementation to the new size negotiation API.
* tests/Makefile.am: Add the layout manager test case.
* tests/test-opacity.c: Update.
* tests/test-project.c: Update.
* tests/test-layout.c: Test case for a layout manager implemented
using the new size negotiation API; the layout manager handles
both transformed and untransformed children.
2008-06-10 17:07:52 +00:00
|
|
|
|
2009-08-13 11:34:07 +00:00
|
|
|
_clutter_stage_window_get_geometry (priv->impl, &geom);
|
|
|
|
|
|
|
|
if (min_height_p)
|
|
|
|
*min_height_p = geom.height;
|
|
|
|
|
|
|
|
if (natural_height_p)
|
|
|
|
*natural_height_p = geom.height;
|
2008-06-10 Emmanuele Bassi <ebassi@openedhand.com>
Bug #815 - Split up request, allocation, and paint box
* clutter/clutter-actor.[ch]: Rework the size allocation,
request and paint area. Now ::request_coords() is called
::allocate(), and ::query_coords() has been split into
::get_preferred_width() and ::get_preferred_height(). See
the documentation and the layout test on how to implement
a container and layout manager with the new API. (#915,
based on a patch by Havoc Pennington, Lucas Rocha and Johan
Bilien)
* clutter/clutter-clone-texture.c: Port CloneTexture to
the new size negotiation API; it just means forwarding
the requests to the parent texture.
* clutter/clutter-deprecated.h: Add deprecated and replaced
API.
* clutter/clutter-entry.c: Port Entry to the new size
negotiation API.
* clutter/clutter-group.c: Port Group to the new size
negotiation API; the semantics of the Group actor do not
change.
* clutter/clutter-label.c: Port Label to the new size
negotiation API, and vastly simplify the code.
* clutter/clutter-main.[ch]: Add API for executing a
relayout when needed.
* clutter/clutter-private.h: Add new Stage private API.
* clutter/clutter-rectangle.c: Update the get_abs_opacity()
call to get_paint_opacity().
* clutter/clutter-stage.c:
(clutter_stage_get_preferred_width),
(clutter_stage_get_preferred_height),
(clutter_stage_allocate),
(clutter_stage_class_init): Port Stage to the new size
negotiation API.
* clutter/clutter-texture.c: Port Texture to the new size
negotiation API.
* clutter/clutter-types.h: Add ClutterRequestMode enumeration.
* clutter/x11/clutter-stage-x11.c: Port the X11 stage
implementation to the new size negotiation API.
* tests/Makefile.am: Add the layout manager test case.
* tests/test-opacity.c: Update.
* tests/test-project.c: Update.
* tests/test-layout.c: Test case for a layout manager implemented
using the new size negotiation API; the layout manager handles
both transformed and untransformed children.
2008-06-10 17:07:52 +00:00
|
|
|
}
|
2010-09-07 22:25:18 +00:00
|
|
|
|
2010-09-30 09:27:10 +00:00
|
|
|
static inline void
|
2010-09-07 22:25:18 +00:00
|
|
|
queue_full_redraw (ClutterStage *stage)
|
|
|
|
{
|
|
|
|
ClutterStageWindow *stage_window;
|
|
|
|
|
2010-09-30 09:27:10 +00:00
|
|
|
if (CLUTTER_ACTOR_IN_DESTRUCTION (stage))
|
|
|
|
return;
|
|
|
|
|
2010-09-07 22:25:18 +00:00
|
|
|
clutter_actor_queue_redraw (CLUTTER_ACTOR (stage));
|
|
|
|
|
|
|
|
/* Just calling clutter_actor_queue_redraw will typically only
|
|
|
|
* redraw the bounding box of the children parented on the stage but
|
|
|
|
* in this case we really need to ensure that the full stage is
|
|
|
|
* redrawn so we add a NULL redraw clip to the stage window. */
|
|
|
|
stage_window = _clutter_stage_get_window (stage);
|
2010-09-30 09:27:10 +00:00
|
|
|
if (stage_window == NULL)
|
|
|
|
return;
|
|
|
|
|
2010-09-07 22:25:18 +00:00
|
|
|
_clutter_stage_window_add_redraw_clip (stage_window, NULL);
|
|
|
|
}
|
|
|
|
|
2008-06-10 Emmanuele Bassi <ebassi@openedhand.com>
Bug #815 - Split up request, allocation, and paint box
* clutter/clutter-actor.[ch]: Rework the size allocation,
request and paint area. Now ::request_coords() is called
::allocate(), and ::query_coords() has been split into
::get_preferred_width() and ::get_preferred_height(). See
the documentation and the layout test on how to implement
a container and layout manager with the new API. (#915,
based on a patch by Havoc Pennington, Lucas Rocha and Johan
Bilien)
* clutter/clutter-clone-texture.c: Port CloneTexture to
the new size negotiation API; it just means forwarding
the requests to the parent texture.
* clutter/clutter-deprecated.h: Add deprecated and replaced
API.
* clutter/clutter-entry.c: Port Entry to the new size
negotiation API.
* clutter/clutter-group.c: Port Group to the new size
negotiation API; the semantics of the Group actor do not
change.
* clutter/clutter-label.c: Port Label to the new size
negotiation API, and vastly simplify the code.
* clutter/clutter-main.[ch]: Add API for executing a
relayout when needed.
* clutter/clutter-private.h: Add new Stage private API.
* clutter/clutter-rectangle.c: Update the get_abs_opacity()
call to get_paint_opacity().
* clutter/clutter-stage.c:
(clutter_stage_get_preferred_width),
(clutter_stage_get_preferred_height),
(clutter_stage_allocate),
(clutter_stage_class_init): Port Stage to the new size
negotiation API.
* clutter/clutter-texture.c: Port Texture to the new size
negotiation API.
* clutter/clutter-types.h: Add ClutterRequestMode enumeration.
* clutter/x11/clutter-stage-x11.c: Port the X11 stage
implementation to the new size negotiation API.
* tests/Makefile.am: Add the layout manager test case.
* tests/test-opacity.c: Update.
* tests/test-project.c: Update.
* tests/test-layout.c: Test case for a layout manager implemented
using the new size negotiation API; the layout manager handles
both transformed and untransformed children.
2008-06-10 17:07:52 +00:00
|
|
|
static void
|
2009-06-03 13:02:06 +00:00
|
|
|
clutter_stage_allocate (ClutterActor *self,
|
|
|
|
const ClutterActorBox *box,
|
|
|
|
ClutterAllocationFlags flags)
|
2008-06-10 Emmanuele Bassi <ebassi@openedhand.com>
Bug #815 - Split up request, allocation, and paint box
* clutter/clutter-actor.[ch]: Rework the size allocation,
request and paint area. Now ::request_coords() is called
::allocate(), and ::query_coords() has been split into
::get_preferred_width() and ::get_preferred_height(). See
the documentation and the layout test on how to implement
a container and layout manager with the new API. (#915,
based on a patch by Havoc Pennington, Lucas Rocha and Johan
Bilien)
* clutter/clutter-clone-texture.c: Port CloneTexture to
the new size negotiation API; it just means forwarding
the requests to the parent texture.
* clutter/clutter-deprecated.h: Add deprecated and replaced
API.
* clutter/clutter-entry.c: Port Entry to the new size
negotiation API.
* clutter/clutter-group.c: Port Group to the new size
negotiation API; the semantics of the Group actor do not
change.
* clutter/clutter-label.c: Port Label to the new size
negotiation API, and vastly simplify the code.
* clutter/clutter-main.[ch]: Add API for executing a
relayout when needed.
* clutter/clutter-private.h: Add new Stage private API.
* clutter/clutter-rectangle.c: Update the get_abs_opacity()
call to get_paint_opacity().
* clutter/clutter-stage.c:
(clutter_stage_get_preferred_width),
(clutter_stage_get_preferred_height),
(clutter_stage_allocate),
(clutter_stage_class_init): Port Stage to the new size
negotiation API.
* clutter/clutter-texture.c: Port Texture to the new size
negotiation API.
* clutter/clutter-types.h: Add ClutterRequestMode enumeration.
* clutter/x11/clutter-stage-x11.c: Port the X11 stage
implementation to the new size negotiation API.
* tests/Makefile.am: Add the layout manager test case.
* tests/test-opacity.c: Update.
* tests/test-project.c: Update.
* tests/test-layout.c: Test case for a layout manager implemented
using the new size negotiation API; the layout manager handles
both transformed and untransformed children.
2008-06-10 17:07:52 +00:00
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv = CLUTTER_STAGE (self)->priv;
|
2010-09-08 10:32:29 +00:00
|
|
|
ClutterGeometry prev_geom;
|
2010-02-15 18:53:58 +00:00
|
|
|
ClutterGeometry geom = { 0, };
|
2009-06-03 13:02:06 +00:00
|
|
|
gboolean origin_changed;
|
2009-08-13 11:34:07 +00:00
|
|
|
gint width, height;
|
2009-06-03 13:02:06 +00:00
|
|
|
|
|
|
|
origin_changed = (flags & CLUTTER_ABSOLUTE_ORIGIN_CHANGED) ? TRUE : FALSE;
|
2008-06-10 Emmanuele Bassi <ebassi@openedhand.com>
Bug #815 - Split up request, allocation, and paint box
* clutter/clutter-actor.[ch]: Rework the size allocation,
request and paint area. Now ::request_coords() is called
::allocate(), and ::query_coords() has been split into
::get_preferred_width() and ::get_preferred_height(). See
the documentation and the layout test on how to implement
a container and layout manager with the new API. (#915,
based on a patch by Havoc Pennington, Lucas Rocha and Johan
Bilien)
* clutter/clutter-clone-texture.c: Port CloneTexture to
the new size negotiation API; it just means forwarding
the requests to the parent texture.
* clutter/clutter-deprecated.h: Add deprecated and replaced
API.
* clutter/clutter-entry.c: Port Entry to the new size
negotiation API.
* clutter/clutter-group.c: Port Group to the new size
negotiation API; the semantics of the Group actor do not
change.
* clutter/clutter-label.c: Port Label to the new size
negotiation API, and vastly simplify the code.
* clutter/clutter-main.[ch]: Add API for executing a
relayout when needed.
* clutter/clutter-private.h: Add new Stage private API.
* clutter/clutter-rectangle.c: Update the get_abs_opacity()
call to get_paint_opacity().
* clutter/clutter-stage.c:
(clutter_stage_get_preferred_width),
(clutter_stage_get_preferred_height),
(clutter_stage_allocate),
(clutter_stage_class_init): Port Stage to the new size
negotiation API.
* clutter/clutter-texture.c: Port Texture to the new size
negotiation API.
* clutter/clutter-types.h: Add ClutterRequestMode enumeration.
* clutter/x11/clutter-stage-x11.c: Port the X11 stage
implementation to the new size negotiation API.
* tests/Makefile.am: Add the layout manager test case.
* tests/test-opacity.c: Update.
* tests/test-project.c: Update.
* tests/test-layout.c: Test case for a layout manager implemented
using the new size negotiation API; the layout manager handles
both transformed and untransformed children.
2008-06-10 17:07:52 +00:00
|
|
|
|
2009-06-16 15:38:01 +00:00
|
|
|
if (priv->impl == NULL)
|
|
|
|
return;
|
2008-06-10 Emmanuele Bassi <ebassi@openedhand.com>
Bug #815 - Split up request, allocation, and paint box
* clutter/clutter-actor.[ch]: Rework the size allocation,
request and paint area. Now ::request_coords() is called
::allocate(), and ::query_coords() has been split into
::get_preferred_width() and ::get_preferred_height(). See
the documentation and the layout test on how to implement
a container and layout manager with the new API. (#915,
based on a patch by Havoc Pennington, Lucas Rocha and Johan
Bilien)
* clutter/clutter-clone-texture.c: Port CloneTexture to
the new size negotiation API; it just means forwarding
the requests to the parent texture.
* clutter/clutter-deprecated.h: Add deprecated and replaced
API.
* clutter/clutter-entry.c: Port Entry to the new size
negotiation API.
* clutter/clutter-group.c: Port Group to the new size
negotiation API; the semantics of the Group actor do not
change.
* clutter/clutter-label.c: Port Label to the new size
negotiation API, and vastly simplify the code.
* clutter/clutter-main.[ch]: Add API for executing a
relayout when needed.
* clutter/clutter-private.h: Add new Stage private API.
* clutter/clutter-rectangle.c: Update the get_abs_opacity()
call to get_paint_opacity().
* clutter/clutter-stage.c:
(clutter_stage_get_preferred_width),
(clutter_stage_get_preferred_height),
(clutter_stage_allocate),
(clutter_stage_class_init): Port Stage to the new size
negotiation API.
* clutter/clutter-texture.c: Port Texture to the new size
negotiation API.
* clutter/clutter-types.h: Add ClutterRequestMode enumeration.
* clutter/x11/clutter-stage-x11.c: Port the X11 stage
implementation to the new size negotiation API.
* tests/Makefile.am: Add the layout manager test case.
* tests/test-opacity.c: Update.
* tests/test-project.c: Update.
* tests/test-layout.c: Test case for a layout manager implemented
using the new size negotiation API; the layout manager handles
both transformed and untransformed children.
2008-06-10 17:07:52 +00:00
|
|
|
|
2010-09-08 10:32:29 +00:00
|
|
|
clutter_actor_get_allocation_geometry (self, &prev_geom);
|
|
|
|
|
2009-08-13 11:34:07 +00:00
|
|
|
width = clutter_actor_box_get_width (box);
|
|
|
|
height = clutter_actor_box_get_height (box);
|
2010-02-15 18:53:58 +00:00
|
|
|
_clutter_stage_window_get_geometry (priv->impl, &geom);
|
|
|
|
|
2008-06-25 11:49:43 +00:00
|
|
|
/* if the stage is fixed size (for instance, it's using a frame-buffer)
|
2008-06-25 13:05:59 +00:00
|
|
|
* then we simply ignore any allocation request and override the
|
|
|
|
* allocation chain.
|
2008-06-25 11:49:43 +00:00
|
|
|
*/
|
Remove Units from the public API
With the recent change to internal floating point values, ClutterUnit
has become a redundant type, defined to be a float. All integer entry
points are being internally converted to floating point values to be
passed to the GL pipeline with the least amount of conversion.
ClutterUnit is thus exposed as just a "pixel with fractionary bits",
and not -- as users might think -- as generic, resolution and device
independent units. not that it was the case, but a definitive amount
of people was convinced it did provide this "feature", and was flummoxed
about the mere existence of this type.
So, having ClutterUnit exposed in the public API doubles the entry
points and has the following disadvantages:
- we have to maintain twice the amount of entry points in ClutterActor
- we still do an integer-to-float implicit conversion
- we introduce a weird impedance between pixels and "pixels with
fractionary bits"
- language bindings will have to choose what to bind, and resort
to manually overriding the API
+ *except* for language bindings based on GObject-Introspection, as
they cannot do manual overrides, thus will replicate the entire
set of entry points
For these reason, we should coalesces every Actor entry point for
pixels and for ClutterUnit into a single entry point taking a float,
like:
void clutter_actor_set_x (ClutterActor *self,
gfloat x);
void clutter_actor_get_size (ClutterActor *self,
gfloat *width,
gfloat *height);
gfloat clutter_actor_get_height (ClutterActor *self);
etc.
The issues I have identified are:
- we'll have a two cases of compiler warnings:
- printf() format of the return values from %d to %f
- clutter_actor_get_size() taking floats instead of unsigned ints
- we'll have a problem with varargs when passing an integer instead
of a floating point value, except on 64bit platforms where the
size of a float is the same as the size of an int
To be clear: the *intent* of the API should not change -- we still use
pixels everywhere -- but:
- we remove ambiguity in the API with regard to pixels and units
- we remove entry points we get to maintain for the whole 1.0
version of the API
- we make things simpler to bind for both manual language bindings
and automatic (gobject-introspection based) ones
- we have the simplest API possible while still exposing the
capabilities of the underlying GL implementation
2009-05-06 15:44:47 +00:00
|
|
|
if ((!clutter_feature_available (CLUTTER_FEATURE_STAGE_STATIC)))
|
2008-06-25 11:49:43 +00:00
|
|
|
{
|
|
|
|
ClutterActorClass *klass;
|
|
|
|
|
Remove Units from the public API
With the recent change to internal floating point values, ClutterUnit
has become a redundant type, defined to be a float. All integer entry
points are being internally converted to floating point values to be
passed to the GL pipeline with the least amount of conversion.
ClutterUnit is thus exposed as just a "pixel with fractionary bits",
and not -- as users might think -- as generic, resolution and device
independent units. not that it was the case, but a definitive amount
of people was convinced it did provide this "feature", and was flummoxed
about the mere existence of this type.
So, having ClutterUnit exposed in the public API doubles the entry
points and has the following disadvantages:
- we have to maintain twice the amount of entry points in ClutterActor
- we still do an integer-to-float implicit conversion
- we introduce a weird impedance between pixels and "pixels with
fractionary bits"
- language bindings will have to choose what to bind, and resort
to manually overriding the API
+ *except* for language bindings based on GObject-Introspection, as
they cannot do manual overrides, thus will replicate the entire
set of entry points
For these reason, we should coalesces every Actor entry point for
pixels and for ClutterUnit into a single entry point taking a float,
like:
void clutter_actor_set_x (ClutterActor *self,
gfloat x);
void clutter_actor_get_size (ClutterActor *self,
gfloat *width,
gfloat *height);
gfloat clutter_actor_get_height (ClutterActor *self);
etc.
The issues I have identified are:
- we'll have a two cases of compiler warnings:
- printf() format of the return values from %d to %f
- clutter_actor_get_size() taking floats instead of unsigned ints
- we'll have a problem with varargs when passing an integer instead
of a floating point value, except on 64bit platforms where the
size of a float is the same as the size of an int
To be clear: the *intent* of the API should not change -- we still use
pixels everywhere -- but:
- we remove ambiguity in the API with regard to pixels and units
- we remove entry points we get to maintain for the whole 1.0
version of the API
- we make things simpler to bind for both manual language bindings
and automatic (gobject-introspection based) ones
- we have the simplest API possible while still exposing the
capabilities of the underlying GL implementation
2009-05-06 15:44:47 +00:00
|
|
|
CLUTTER_NOTE (LAYOUT,
|
|
|
|
"Following allocation to %dx%d (origin %s)",
|
2009-08-13 11:34:07 +00:00
|
|
|
width, height,
|
2008-06-25 13:32:03 +00:00
|
|
|
origin_changed ? "changed" : "not changed");
|
|
|
|
|
2008-06-25 11:49:43 +00:00
|
|
|
klass = CLUTTER_ACTOR_CLASS (clutter_stage_parent_class);
|
2009-06-03 13:02:06 +00:00
|
|
|
klass->allocate (self, box, flags);
|
2008-06-25 11:49:43 +00:00
|
|
|
|
2010-02-15 18:53:58 +00:00
|
|
|
/* Ensure the window is sized correctly */
|
2010-02-26 18:36:38 +00:00
|
|
|
if (!priv->is_fullscreen)
|
|
|
|
{
|
|
|
|
if (priv->min_size_changed)
|
|
|
|
{
|
|
|
|
gfloat min_width, min_height;
|
|
|
|
gboolean min_width_set, min_height_set;
|
|
|
|
|
|
|
|
g_object_get (G_OBJECT (self),
|
|
|
|
"min-width", &min_width,
|
|
|
|
"min-width-set", &min_width_set,
|
|
|
|
"min-height", &min_height,
|
|
|
|
"min-height-set", &min_height_set,
|
|
|
|
NULL);
|
|
|
|
|
|
|
|
if (!min_width_set)
|
|
|
|
min_width = 1;
|
|
|
|
if (!min_height_set)
|
|
|
|
min_height = 1;
|
|
|
|
|
|
|
|
if (width < min_width)
|
|
|
|
width = min_width;
|
|
|
|
if (height < min_height)
|
|
|
|
height = min_height;
|
|
|
|
|
|
|
|
priv->min_size_changed = FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((geom.width != width) || (geom.height != height))
|
|
|
|
_clutter_stage_window_resize (priv->impl, width, height);
|
|
|
|
}
|
2008-06-25 11:49:43 +00:00
|
|
|
}
|
2008-06-25 13:05:59 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
ClutterActorBox override = { 0, };
|
|
|
|
ClutterActorClass *klass;
|
2008-06-26 21:42:44 +00:00
|
|
|
|
2008-06-25 13:05:59 +00:00
|
|
|
override.x1 = 0;
|
|
|
|
override.y1 = 0;
|
2009-08-13 11:34:07 +00:00
|
|
|
override.x2 = geom.width;
|
|
|
|
override.y2 = geom.height;
|
2008-06-25 13:32:03 +00:00
|
|
|
|
Remove Units from the public API
With the recent change to internal floating point values, ClutterUnit
has become a redundant type, defined to be a float. All integer entry
points are being internally converted to floating point values to be
passed to the GL pipeline with the least amount of conversion.
ClutterUnit is thus exposed as just a "pixel with fractionary bits",
and not -- as users might think -- as generic, resolution and device
independent units. not that it was the case, but a definitive amount
of people was convinced it did provide this "feature", and was flummoxed
about the mere existence of this type.
So, having ClutterUnit exposed in the public API doubles the entry
points and has the following disadvantages:
- we have to maintain twice the amount of entry points in ClutterActor
- we still do an integer-to-float implicit conversion
- we introduce a weird impedance between pixels and "pixels with
fractionary bits"
- language bindings will have to choose what to bind, and resort
to manually overriding the API
+ *except* for language bindings based on GObject-Introspection, as
they cannot do manual overrides, thus will replicate the entire
set of entry points
For these reason, we should coalesces every Actor entry point for
pixels and for ClutterUnit into a single entry point taking a float,
like:
void clutter_actor_set_x (ClutterActor *self,
gfloat x);
void clutter_actor_get_size (ClutterActor *self,
gfloat *width,
gfloat *height);
gfloat clutter_actor_get_height (ClutterActor *self);
etc.
The issues I have identified are:
- we'll have a two cases of compiler warnings:
- printf() format of the return values from %d to %f
- clutter_actor_get_size() taking floats instead of unsigned ints
- we'll have a problem with varargs when passing an integer instead
of a floating point value, except on 64bit platforms where the
size of a float is the same as the size of an int
To be clear: the *intent* of the API should not change -- we still use
pixels everywhere -- but:
- we remove ambiguity in the API with regard to pixels and units
- we remove entry points we get to maintain for the whole 1.0
version of the API
- we make things simpler to bind for both manual language bindings
and automatic (gobject-introspection based) ones
- we have the simplest API possible while still exposing the
capabilities of the underlying GL implementation
2009-05-06 15:44:47 +00:00
|
|
|
CLUTTER_NOTE (LAYOUT,
|
|
|
|
"Overrigin original allocation of %dx%d "
|
|
|
|
"with %dx%d (origin %s)",
|
2009-08-13 11:34:07 +00:00
|
|
|
width, height,
|
Remove Units from the public API
With the recent change to internal floating point values, ClutterUnit
has become a redundant type, defined to be a float. All integer entry
points are being internally converted to floating point values to be
passed to the GL pipeline with the least amount of conversion.
ClutterUnit is thus exposed as just a "pixel with fractionary bits",
and not -- as users might think -- as generic, resolution and device
independent units. not that it was the case, but a definitive amount
of people was convinced it did provide this "feature", and was flummoxed
about the mere existence of this type.
So, having ClutterUnit exposed in the public API doubles the entry
points and has the following disadvantages:
- we have to maintain twice the amount of entry points in ClutterActor
- we still do an integer-to-float implicit conversion
- we introduce a weird impedance between pixels and "pixels with
fractionary bits"
- language bindings will have to choose what to bind, and resort
to manually overriding the API
+ *except* for language bindings based on GObject-Introspection, as
they cannot do manual overrides, thus will replicate the entire
set of entry points
For these reason, we should coalesces every Actor entry point for
pixels and for ClutterUnit into a single entry point taking a float,
like:
void clutter_actor_set_x (ClutterActor *self,
gfloat x);
void clutter_actor_get_size (ClutterActor *self,
gfloat *width,
gfloat *height);
gfloat clutter_actor_get_height (ClutterActor *self);
etc.
The issues I have identified are:
- we'll have a two cases of compiler warnings:
- printf() format of the return values from %d to %f
- clutter_actor_get_size() taking floats instead of unsigned ints
- we'll have a problem with varargs when passing an integer instead
of a floating point value, except on 64bit platforms where the
size of a float is the same as the size of an int
To be clear: the *intent* of the API should not change -- we still use
pixels everywhere -- but:
- we remove ambiguity in the API with regard to pixels and units
- we remove entry points we get to maintain for the whole 1.0
version of the API
- we make things simpler to bind for both manual language bindings
and automatic (gobject-introspection based) ones
- we have the simplest API possible while still exposing the
capabilities of the underlying GL implementation
2009-05-06 15:44:47 +00:00
|
|
|
(int) (override.x2),
|
|
|
|
(int) (override.y2),
|
|
|
|
origin_changed ? "changed" : "not changed");
|
|
|
|
|
2008-06-26 21:42:44 +00:00
|
|
|
/* and store the overridden allocation */
|
2008-06-25 13:05:59 +00:00
|
|
|
klass = CLUTTER_ACTOR_CLASS (clutter_stage_parent_class);
|
2009-06-03 13:02:06 +00:00
|
|
|
klass->allocate (self, &override, flags);
|
2008-06-25 13:05:59 +00:00
|
|
|
}
|
2010-09-07 12:10:55 +00:00
|
|
|
|
2010-10-21 15:27:17 +00:00
|
|
|
/* XXX: Until Cogl becomes fully responsible for backend windows
|
|
|
|
* Clutter need to manually keep it informed of the current window
|
|
|
|
* size. We do this after the allocation above so that the stage
|
|
|
|
* window has a chance to update the window size based on the
|
|
|
|
* allocation. */
|
|
|
|
_clutter_stage_window_get_geometry (priv->impl, &geom);
|
|
|
|
_cogl_onscreen_clutter_backend_set_size (geom.width, geom.height);
|
|
|
|
|
2010-09-07 12:10:55 +00:00
|
|
|
clutter_actor_get_allocation_geometry (self, &geom);
|
2010-09-08 10:32:29 +00:00
|
|
|
if (geom.width != prev_geom.width || geom.height != prev_geom.height)
|
|
|
|
{
|
|
|
|
_clutter_stage_set_viewport (CLUTTER_STAGE (self),
|
|
|
|
0, 0, geom.width, geom.height);
|
2010-09-07 12:10:55 +00:00
|
|
|
|
2010-09-08 10:32:29 +00:00
|
|
|
/* Note: we don't assume that set_viewport will queue a full redraw
|
|
|
|
* since it may bail-out early if something preemptively set the
|
|
|
|
* viewport before the stage was really allocated its new size. */
|
|
|
|
queue_full_redraw (CLUTTER_STAGE (self));
|
|
|
|
}
|
2008-04-04 15:02:11 +00:00
|
|
|
}
|
|
|
|
|
2010-09-07 17:04:19 +00:00
|
|
|
/* This provides a common point of entry for painting the scenegraph
|
|
|
|
* for picking or painting...
|
2010-09-07 21:21:28 +00:00
|
|
|
*
|
|
|
|
* XXX: Instead of having a toplevel 2D clip region, it might be
|
|
|
|
* better to have a clip volume within the view frustum. This could
|
|
|
|
* allow us to avoid projecting actors into window coordinates to
|
|
|
|
* be able to cull them.
|
2010-09-07 17:04:19 +00:00
|
|
|
*/
|
|
|
|
void
|
2010-09-07 21:21:28 +00:00
|
|
|
_clutter_stage_do_paint (ClutterStage *stage, const ClutterGeometry *clip)
|
2010-09-07 17:04:19 +00:00
|
|
|
{
|
2010-09-07 21:21:28 +00:00
|
|
|
ClutterStagePrivate *priv = stage->priv;
|
|
|
|
priv->current_paint_clip = clip;
|
2010-09-07 17:04:19 +00:00
|
|
|
_clutter_stage_paint_volume_stack_free_all (stage);
|
|
|
|
clutter_actor_paint (CLUTTER_ACTOR (stage));
|
2010-09-07 21:21:28 +00:00
|
|
|
priv->current_paint_clip = NULL;
|
2010-09-07 17:04:19 +00:00
|
|
|
}
|
|
|
|
|
2007-03-23 16:37:56 +00:00
|
|
|
static void
|
2007-05-28 18:49:34 +00:00
|
|
|
clutter_stage_paint (ClutterActor *self)
|
2007-03-23 16:37:56 +00:00
|
|
|
{
|
2007-07-04 09:36:44 +00:00
|
|
|
ClutterStagePrivate *priv = CLUTTER_STAGE (self)->priv;
|
2010-04-16 14:34:36 +00:00
|
|
|
CoglBufferBit clear_flags;
|
2008-10-30 16:50:07 +00:00
|
|
|
CoglColor stage_color;
|
2009-12-07 17:35:17 +00:00
|
|
|
guint8 real_alpha;
|
2009-03-30 15:41:02 +00:00
|
|
|
CLUTTER_STATIC_TIMER (stage_clear_timer,
|
|
|
|
"Painting actors", /* parent */
|
|
|
|
"Stage clear",
|
|
|
|
"The time spent clearing the stage",
|
|
|
|
0 /* no application private data */);
|
2007-07-04 09:36:44 +00:00
|
|
|
|
2008-04-04 15:02:11 +00:00
|
|
|
CLUTTER_NOTE (PAINT, "Initializing stage paint");
|
|
|
|
|
2009-12-07 17:35:17 +00:00
|
|
|
/* composite the opacity to the stage color */
|
|
|
|
real_alpha = clutter_actor_get_opacity (self)
|
|
|
|
* priv->color.alpha
|
|
|
|
/ 255;
|
|
|
|
|
|
|
|
/* we use the real alpha to clear the stage if :use-alpha is
|
|
|
|
* set; the effect depends entirely on how the Clutter backend
|
|
|
|
*/
|
2010-09-03 15:55:12 +00:00
|
|
|
cogl_color_init_from_4ub (&stage_color,
|
|
|
|
priv->color.red,
|
|
|
|
priv->color.green,
|
|
|
|
priv->color.blue,
|
|
|
|
priv->use_alpha ? real_alpha
|
2009-12-07 17:35:17 +00:00
|
|
|
: 255);
|
2009-12-09 01:46:09 +00:00
|
|
|
cogl_color_premultiply (&stage_color);
|
2009-03-30 15:41:02 +00:00
|
|
|
|
2010-04-16 14:34:36 +00:00
|
|
|
clear_flags = COGL_BUFFER_BIT_DEPTH;
|
|
|
|
if (!STAGE_NO_CLEAR_ON_PAINT (self))
|
|
|
|
clear_flags |= COGL_BUFFER_BIT_COLOR;
|
|
|
|
|
2009-03-30 15:41:02 +00:00
|
|
|
CLUTTER_TIMER_START (_clutter_uprof_context, stage_clear_timer);
|
2010-04-16 14:34:36 +00:00
|
|
|
|
|
|
|
cogl_clear (&stage_color, clear_flags);
|
|
|
|
|
2009-03-30 15:41:02 +00:00
|
|
|
CLUTTER_TIMER_STOP (_clutter_uprof_context, stage_clear_timer);
|
2007-07-04 09:36:44 +00:00
|
|
|
|
2007-11-21 11:55:26 +00:00
|
|
|
if (priv->use_fog)
|
|
|
|
{
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
/* we only expose the linear progression of the fog in
|
|
|
|
* the ClutterStage API, and that ignores the fog density.
|
|
|
|
* thus, we pass 1.0 as the density parameter
|
|
|
|
*/
|
2009-02-04 09:21:37 +00:00
|
|
|
cogl_set_fog (&stage_color,
|
2009-02-12 13:23:20 +00:00
|
|
|
COGL_FOG_MODE_LINEAR,
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
1.0,
|
2007-11-21 11:55:26 +00:00
|
|
|
priv->fog.z_near,
|
|
|
|
priv->fog.z_far);
|
|
|
|
}
|
2009-02-12 13:23:20 +00:00
|
|
|
else
|
|
|
|
cogl_disable_fog ();
|
2007-11-21 11:55:26 +00:00
|
|
|
|
2008-04-04 15:02:11 +00:00
|
|
|
/* this will take care of painting every child */
|
2007-05-28 18:49:34 +00:00
|
|
|
CLUTTER_ACTOR_CLASS (clutter_stage_parent_class)->paint (self);
|
2007-03-23 16:37:56 +00:00
|
|
|
}
|
|
|
|
|
2007-11-18 23:24:55 +00:00
|
|
|
static void
|
|
|
|
clutter_stage_pick (ClutterActor *self,
|
|
|
|
const ClutterColor *color)
|
|
|
|
{
|
2009-11-25 20:37:01 +00:00
|
|
|
/* Note: we don't chain up to our parent as we don't want any geometry
|
|
|
|
* emitted for the stage itself. The stage's pick id is effectively handled
|
|
|
|
* by the call to cogl_clear done in clutter-main.c:_clutter_do_pick_async()
|
2007-11-18 23:24:55 +00:00
|
|
|
*/
|
2009-11-25 20:37:01 +00:00
|
|
|
clutter_container_foreach (CLUTTER_CONTAINER (self),
|
2009-12-01 16:16:18 +00:00
|
|
|
CLUTTER_CALLBACK (clutter_actor_paint),
|
|
|
|
NULL);
|
2007-11-18 23:24:55 +00:00
|
|
|
}
|
|
|
|
|
2010-11-23 14:31:45 +00:00
|
|
|
static gboolean
|
|
|
|
clutter_stage_get_paint_volume (ClutterActor *self,
|
|
|
|
ClutterPaintVolume *volume)
|
|
|
|
{
|
|
|
|
/* Returning False effectively means Clutter has to assume it covers
|
|
|
|
* everything... */
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2008-04-04 15:02:11 +00:00
|
|
|
static void
|
|
|
|
clutter_stage_realize (ClutterActor *self)
|
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv = CLUTTER_STAGE (self)->priv;
|
2009-08-13 11:34:07 +00:00
|
|
|
gboolean is_realized;
|
2008-04-04 15:02:11 +00:00
|
|
|
|
2009-01-21 12:47:29 +00:00
|
|
|
/* Make sure the viewport and projection matrix are valid for the
|
2009-05-08 16:17:48 +00:00
|
|
|
* first paint (which will likely occur before the ConfigureNotify
|
|
|
|
* is received)
|
|
|
|
*/
|
2010-09-07 12:10:55 +00:00
|
|
|
priv->dirty_viewport = TRUE;
|
|
|
|
priv->dirty_projection = TRUE;
|
2009-01-21 12:47:29 +00:00
|
|
|
|
2008-04-04 17:26:26 +00:00
|
|
|
g_assert (priv->impl != NULL);
|
2009-08-13 11:34:07 +00:00
|
|
|
is_realized = _clutter_stage_window_realize (priv->impl);
|
2008-04-04 15:02:11 +00:00
|
|
|
|
2008-05-12 Emmanuele Bassi <ebassi@openedhand.com>
Rework the stage wrapper/implementation relation: remove
duplicated code and all the bookkeeping from the backends into
ClutterStage whenever possible, to reduce the amount of work a
backend must do (and possibly get wrong). Thanks to Tommi
Komulainen.
* clutter/clutter-main.c:
(clutter_init_with_args), (clutter_init): Realize the default
stage after creation. The default stage is special, because we
use it in the initialization sequence. This removes the burden
from the backends and reduces the things a backend can get
wrong.
* clutter/clutter-stage.c:
(clutter_stage_show): Make sure to realize the implementation if
it hasn't been realized yet.
(clutter_stage_realize): Set the REALIZED flag and call
clutter_stage_ensure_current() if the implementation was
successfully realized.
(clutter_stage_unrealized): Call clutter_stage_ensure_current()
on unrealize.
* clutter/glx/clutter-backend-glx.c:
(clutter_backend_glx_create_stage): Do not realize the stage anymore
when creating it, and let the normal realization sequence take
place.
(clutter_backend_glx_ensure_context): Trap for X11 errors.
* clutter/glx/clutter-stage-glx.c:
(clutter_stage_glx_realize): Chain up to the X11 implementation
so that we can set up the window state (title, cursor visibility)
when we actually have a X window. Also, do not call
clutter_stage_ensure_current(), and rely on the wrapper to do
it for us. This means we can drop setting the REALIZED flag on
the wrapper.
(clutter_stage_glx_unrealize): Do not call
clutter_stage_ensure_current() ourselves, and rely on the wrapper
to do it for us.
* clutter/x11/clutter-stage-x11.c:
(set_wm_title), (set_cursor_visible): Move the WM title and
cursor visibility code inside their own functions.
(clutter_stage_x11_realize): Set the window title and whether the
cursor is visible or not after realizing the stage.
(clutter_stage_x11_set_cursor_visible),
(clutter_stage_x11_set_title): Call set_wm_title() and
set_cursor_visible().
(clutter_stage_x11_finalize): Free the title string.
* clutter/x11/clutter-stage-x11.h: Save more of the stage state,
so that we can set it even when the stage hasn't been realized
yet.
* clutter/eglnative/clutter-backend-egl.c:
(clutter_backend_egl_create_stage):
* clutter/eglnative/clutter-stage-egl.c:
(clutter_stage_egl_unrealize),
(clutter_stage_egl_realize): Update the eglnative backend.
* clutter/eglx/clutter-backend-egl.c:
(clutter_backend_egl_ensure_context),
(clutter_backend_egl_create_stage):
* clutter/eglx/clutter-stage-egl.c:
(clutter_stage_egl_unrealize),
(clutter_stage_egl_realize): Update the eglx backend.
* clutter/sdl/clutter-backend-sdl.c:
(clutter_backend_sdl_create_stage):
* clutter/sdl/clutter-stage-sdl.c:
(clutter_stage_sdl_realize): Update the sdl backend.
* clutter/fruity/clutter-backend-fruity.c:
(clutter_backend_fruity_create_stage):
* clutter/sdl/clutter-stage-fruity.c:
(clutter_stage_fruity_realize): Update the fruity backend.
* tests/test-multistage.c (on_button_press): Bail out if
clutter_stage_new() returns NULL.
* HACKING.backends: Update backend writing documentation.
2008-05-12 15:26:37 +00:00
|
|
|
/* ensure that the stage is using the context if the
|
|
|
|
* realization sequence was successful
|
|
|
|
*/
|
2009-08-13 11:34:07 +00:00
|
|
|
if (is_realized)
|
|
|
|
{
|
2009-11-11 13:26:54 +00:00
|
|
|
ClutterBackend *backend = clutter_get_default_backend ();
|
2009-12-03 17:13:44 +00:00
|
|
|
GError *error = NULL;
|
2009-11-11 13:26:54 +00:00
|
|
|
|
|
|
|
/* We want to select the context without calling
|
|
|
|
clutter_backend_ensure_context so that it doesn't call any
|
|
|
|
Cogl functions. Otherwise it would create the Cogl context
|
|
|
|
before we get a chance to check whether the GL version is
|
|
|
|
valid */
|
|
|
|
_clutter_backend_ensure_context_internal (backend, CLUTTER_STAGE (self));
|
|
|
|
|
|
|
|
/* Make sure Cogl can support the driver */
|
|
|
|
if (!_cogl_check_driver_valid (&error))
|
|
|
|
{
|
2009-12-03 17:13:44 +00:00
|
|
|
g_critical ("The GL driver is not supported: %s",
|
|
|
|
error->message);
|
2009-11-11 13:26:54 +00:00
|
|
|
g_clear_error (&error);
|
|
|
|
CLUTTER_ACTOR_UNSET_FLAGS (self, CLUTTER_ACTOR_REALIZED);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
CLUTTER_ACTOR_SET_FLAGS (self, CLUTTER_ACTOR_REALIZED);
|
2009-08-13 11:34:07 +00:00
|
|
|
}
|
2008-04-04 17:26:26 +00:00
|
|
|
else
|
|
|
|
CLUTTER_ACTOR_UNSET_FLAGS (self, CLUTTER_ACTOR_REALIZED);
|
2008-04-04 15:02:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
clutter_stage_unrealize (ClutterActor *self)
|
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv = CLUTTER_STAGE (self)->priv;
|
|
|
|
|
|
|
|
/* and then unrealize the implementation */
|
2008-04-04 17:26:26 +00:00
|
|
|
g_assert (priv->impl != NULL);
|
2009-08-13 11:34:07 +00:00
|
|
|
_clutter_stage_window_unrealize (priv->impl);
|
|
|
|
|
|
|
|
CLUTTER_ACTOR_UNSET_FLAGS (self, CLUTTER_ACTOR_REALIZED);
|
2008-05-12 Emmanuele Bassi <ebassi@openedhand.com>
Rework the stage wrapper/implementation relation: remove
duplicated code and all the bookkeeping from the backends into
ClutterStage whenever possible, to reduce the amount of work a
backend must do (and possibly get wrong). Thanks to Tommi
Komulainen.
* clutter/clutter-main.c:
(clutter_init_with_args), (clutter_init): Realize the default
stage after creation. The default stage is special, because we
use it in the initialization sequence. This removes the burden
from the backends and reduces the things a backend can get
wrong.
* clutter/clutter-stage.c:
(clutter_stage_show): Make sure to realize the implementation if
it hasn't been realized yet.
(clutter_stage_realize): Set the REALIZED flag and call
clutter_stage_ensure_current() if the implementation was
successfully realized.
(clutter_stage_unrealized): Call clutter_stage_ensure_current()
on unrealize.
* clutter/glx/clutter-backend-glx.c:
(clutter_backend_glx_create_stage): Do not realize the stage anymore
when creating it, and let the normal realization sequence take
place.
(clutter_backend_glx_ensure_context): Trap for X11 errors.
* clutter/glx/clutter-stage-glx.c:
(clutter_stage_glx_realize): Chain up to the X11 implementation
so that we can set up the window state (title, cursor visibility)
when we actually have a X window. Also, do not call
clutter_stage_ensure_current(), and rely on the wrapper to do
it for us. This means we can drop setting the REALIZED flag on
the wrapper.
(clutter_stage_glx_unrealize): Do not call
clutter_stage_ensure_current() ourselves, and rely on the wrapper
to do it for us.
* clutter/x11/clutter-stage-x11.c:
(set_wm_title), (set_cursor_visible): Move the WM title and
cursor visibility code inside their own functions.
(clutter_stage_x11_realize): Set the window title and whether the
cursor is visible or not after realizing the stage.
(clutter_stage_x11_set_cursor_visible),
(clutter_stage_x11_set_title): Call set_wm_title() and
set_cursor_visible().
(clutter_stage_x11_finalize): Free the title string.
* clutter/x11/clutter-stage-x11.h: Save more of the stage state,
so that we can set it even when the stage hasn't been realized
yet.
* clutter/eglnative/clutter-backend-egl.c:
(clutter_backend_egl_create_stage):
* clutter/eglnative/clutter-stage-egl.c:
(clutter_stage_egl_unrealize),
(clutter_stage_egl_realize): Update the eglnative backend.
* clutter/eglx/clutter-backend-egl.c:
(clutter_backend_egl_ensure_context),
(clutter_backend_egl_create_stage):
* clutter/eglx/clutter-stage-egl.c:
(clutter_stage_egl_unrealize),
(clutter_stage_egl_realize): Update the eglx backend.
* clutter/sdl/clutter-backend-sdl.c:
(clutter_backend_sdl_create_stage):
* clutter/sdl/clutter-stage-sdl.c:
(clutter_stage_sdl_realize): Update the sdl backend.
* clutter/fruity/clutter-backend-fruity.c:
(clutter_backend_fruity_create_stage):
* clutter/sdl/clutter-stage-fruity.c:
(clutter_stage_fruity_realize): Update the fruity backend.
* tests/test-multistage.c (on_button_press): Bail out if
clutter_stage_new() returns NULL.
* HACKING.backends: Update backend writing documentation.
2008-05-12 15:26:37 +00:00
|
|
|
|
|
|
|
clutter_stage_ensure_current (CLUTTER_STAGE (self));
|
2008-04-04 15:02:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
clutter_stage_show (ClutterActor *self)
|
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv = CLUTTER_STAGE (self)->priv;
|
|
|
|
|
2009-05-11 11:43:37 +00:00
|
|
|
CLUTTER_ACTOR_CLASS (clutter_stage_parent_class)->show (self);
|
|
|
|
|
2009-07-17 11:43:52 +00:00
|
|
|
/* Possibly do an allocation run so that the stage will have the
|
|
|
|
right size before we map it */
|
|
|
|
_clutter_stage_maybe_relayout (self);
|
|
|
|
|
2008-04-04 15:02:11 +00:00
|
|
|
g_assert (priv->impl != NULL);
|
2009-08-13 11:34:07 +00:00
|
|
|
_clutter_stage_window_show (priv->impl, TRUE);
|
2008-04-04 15:02:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
clutter_stage_hide (ClutterActor *self)
|
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv = CLUTTER_STAGE (self)->priv;
|
2009-05-11 11:43:37 +00:00
|
|
|
|
2008-04-04 15:02:11 +00:00
|
|
|
g_assert (priv->impl != NULL);
|
2009-08-13 11:34:07 +00:00
|
|
|
_clutter_stage_window_hide (priv->impl);
|
2009-06-04 15:27:21 +00:00
|
|
|
|
|
|
|
CLUTTER_ACTOR_CLASS (clutter_stage_parent_class)->hide (self);
|
2008-04-04 15:02:11 +00:00
|
|
|
}
|
|
|
|
|
2009-05-07 10:20:19 +00:00
|
|
|
static void
|
|
|
|
clutter_stage_emit_key_focus_event (ClutterStage *stage,
|
|
|
|
gboolean focus_in)
|
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv = stage->priv;
|
|
|
|
|
|
|
|
if (priv->key_focused_actor == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (focus_in)
|
|
|
|
g_signal_emit_by_name (priv->key_focused_actor, "key-focus-in");
|
|
|
|
else
|
|
|
|
g_signal_emit_by_name (priv->key_focused_actor, "key-focus-out");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
clutter_stage_real_activate (ClutterStage *stage)
|
|
|
|
{
|
|
|
|
clutter_stage_emit_key_focus_event (stage, TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
clutter_stage_real_deactivate (ClutterStage *stage)
|
|
|
|
{
|
|
|
|
clutter_stage_emit_key_focus_event (stage, FALSE);
|
|
|
|
}
|
|
|
|
|
2008-06-10 Emmanuele Bassi <ebassi@openedhand.com>
Bug #815 - Split up request, allocation, and paint box
* clutter/clutter-actor.[ch]: Rework the size allocation,
request and paint area. Now ::request_coords() is called
::allocate(), and ::query_coords() has been split into
::get_preferred_width() and ::get_preferred_height(). See
the documentation and the layout test on how to implement
a container and layout manager with the new API. (#915,
based on a patch by Havoc Pennington, Lucas Rocha and Johan
Bilien)
* clutter/clutter-clone-texture.c: Port CloneTexture to
the new size negotiation API; it just means forwarding
the requests to the parent texture.
* clutter/clutter-deprecated.h: Add deprecated and replaced
API.
* clutter/clutter-entry.c: Port Entry to the new size
negotiation API.
* clutter/clutter-group.c: Port Group to the new size
negotiation API; the semantics of the Group actor do not
change.
* clutter/clutter-label.c: Port Label to the new size
negotiation API, and vastly simplify the code.
* clutter/clutter-main.[ch]: Add API for executing a
relayout when needed.
* clutter/clutter-private.h: Add new Stage private API.
* clutter/clutter-rectangle.c: Update the get_abs_opacity()
call to get_paint_opacity().
* clutter/clutter-stage.c:
(clutter_stage_get_preferred_width),
(clutter_stage_get_preferred_height),
(clutter_stage_allocate),
(clutter_stage_class_init): Port Stage to the new size
negotiation API.
* clutter/clutter-texture.c: Port Texture to the new size
negotiation API.
* clutter/clutter-types.h: Add ClutterRequestMode enumeration.
* clutter/x11/clutter-stage-x11.c: Port the X11 stage
implementation to the new size negotiation API.
* tests/Makefile.am: Add the layout manager test case.
* tests/test-opacity.c: Update.
* tests/test-project.c: Update.
* tests/test-layout.c: Test case for a layout manager implemented
using the new size negotiation API; the layout manager handles
both transformed and untransformed children.
2008-06-10 17:07:52 +00:00
|
|
|
static void
|
|
|
|
clutter_stage_real_fullscreen (ClutterStage *stage)
|
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv = stage->priv;
|
2009-08-13 11:34:07 +00:00
|
|
|
ClutterGeometry geom;
|
2008-06-10 Emmanuele Bassi <ebassi@openedhand.com>
Bug #815 - Split up request, allocation, and paint box
* clutter/clutter-actor.[ch]: Rework the size allocation,
request and paint area. Now ::request_coords() is called
::allocate(), and ::query_coords() has been split into
::get_preferred_width() and ::get_preferred_height(). See
the documentation and the layout test on how to implement
a container and layout manager with the new API. (#915,
based on a patch by Havoc Pennington, Lucas Rocha and Johan
Bilien)
* clutter/clutter-clone-texture.c: Port CloneTexture to
the new size negotiation API; it just means forwarding
the requests to the parent texture.
* clutter/clutter-deprecated.h: Add deprecated and replaced
API.
* clutter/clutter-entry.c: Port Entry to the new size
negotiation API.
* clutter/clutter-group.c: Port Group to the new size
negotiation API; the semantics of the Group actor do not
change.
* clutter/clutter-label.c: Port Label to the new size
negotiation API, and vastly simplify the code.
* clutter/clutter-main.[ch]: Add API for executing a
relayout when needed.
* clutter/clutter-private.h: Add new Stage private API.
* clutter/clutter-rectangle.c: Update the get_abs_opacity()
call to get_paint_opacity().
* clutter/clutter-stage.c:
(clutter_stage_get_preferred_width),
(clutter_stage_get_preferred_height),
(clutter_stage_allocate),
(clutter_stage_class_init): Port Stage to the new size
negotiation API.
* clutter/clutter-texture.c: Port Texture to the new size
negotiation API.
* clutter/clutter-types.h: Add ClutterRequestMode enumeration.
* clutter/x11/clutter-stage-x11.c: Port the X11 stage
implementation to the new size negotiation API.
* tests/Makefile.am: Add the layout manager test case.
* tests/test-opacity.c: Update.
* tests/test-project.c: Update.
* tests/test-layout.c: Test case for a layout manager implemented
using the new size negotiation API; the layout manager handles
both transformed and untransformed children.
2008-06-10 17:07:52 +00:00
|
|
|
ClutterActorBox box;
|
|
|
|
|
|
|
|
/* we need to force an allocation here because the size
|
|
|
|
* of the stage might have been changed by the backend
|
|
|
|
*
|
|
|
|
* this is a really bad solution to the issues caused by
|
|
|
|
* the fact that fullscreening the stage on the X11 backends
|
|
|
|
* is really an asynchronous operation
|
|
|
|
*/
|
2009-08-13 11:34:07 +00:00
|
|
|
_clutter_stage_window_get_geometry (priv->impl, &geom);
|
2008-06-10 Emmanuele Bassi <ebassi@openedhand.com>
Bug #815 - Split up request, allocation, and paint box
* clutter/clutter-actor.[ch]: Rework the size allocation,
request and paint area. Now ::request_coords() is called
::allocate(), and ::query_coords() has been split into
::get_preferred_width() and ::get_preferred_height(). See
the documentation and the layout test on how to implement
a container and layout manager with the new API. (#915,
based on a patch by Havoc Pennington, Lucas Rocha and Johan
Bilien)
* clutter/clutter-clone-texture.c: Port CloneTexture to
the new size negotiation API; it just means forwarding
the requests to the parent texture.
* clutter/clutter-deprecated.h: Add deprecated and replaced
API.
* clutter/clutter-entry.c: Port Entry to the new size
negotiation API.
* clutter/clutter-group.c: Port Group to the new size
negotiation API; the semantics of the Group actor do not
change.
* clutter/clutter-label.c: Port Label to the new size
negotiation API, and vastly simplify the code.
* clutter/clutter-main.[ch]: Add API for executing a
relayout when needed.
* clutter/clutter-private.h: Add new Stage private API.
* clutter/clutter-rectangle.c: Update the get_abs_opacity()
call to get_paint_opacity().
* clutter/clutter-stage.c:
(clutter_stage_get_preferred_width),
(clutter_stage_get_preferred_height),
(clutter_stage_allocate),
(clutter_stage_class_init): Port Stage to the new size
negotiation API.
* clutter/clutter-texture.c: Port Texture to the new size
negotiation API.
* clutter/clutter-types.h: Add ClutterRequestMode enumeration.
* clutter/x11/clutter-stage-x11.c: Port the X11 stage
implementation to the new size negotiation API.
* tests/Makefile.am: Add the layout manager test case.
* tests/test-opacity.c: Update.
* tests/test-project.c: Update.
* tests/test-layout.c: Test case for a layout manager implemented
using the new size negotiation API; the layout manager handles
both transformed and untransformed children.
2008-06-10 17:07:52 +00:00
|
|
|
|
|
|
|
box.x1 = 0;
|
|
|
|
box.y1 = 0;
|
2009-08-13 11:34:07 +00:00
|
|
|
box.x2 = geom.width;
|
|
|
|
box.y2 = geom.height;
|
2008-06-10 Emmanuele Bassi <ebassi@openedhand.com>
Bug #815 - Split up request, allocation, and paint box
* clutter/clutter-actor.[ch]: Rework the size allocation,
request and paint area. Now ::request_coords() is called
::allocate(), and ::query_coords() has been split into
::get_preferred_width() and ::get_preferred_height(). See
the documentation and the layout test on how to implement
a container and layout manager with the new API. (#915,
based on a patch by Havoc Pennington, Lucas Rocha and Johan
Bilien)
* clutter/clutter-clone-texture.c: Port CloneTexture to
the new size negotiation API; it just means forwarding
the requests to the parent texture.
* clutter/clutter-deprecated.h: Add deprecated and replaced
API.
* clutter/clutter-entry.c: Port Entry to the new size
negotiation API.
* clutter/clutter-group.c: Port Group to the new size
negotiation API; the semantics of the Group actor do not
change.
* clutter/clutter-label.c: Port Label to the new size
negotiation API, and vastly simplify the code.
* clutter/clutter-main.[ch]: Add API for executing a
relayout when needed.
* clutter/clutter-private.h: Add new Stage private API.
* clutter/clutter-rectangle.c: Update the get_abs_opacity()
call to get_paint_opacity().
* clutter/clutter-stage.c:
(clutter_stage_get_preferred_width),
(clutter_stage_get_preferred_height),
(clutter_stage_allocate),
(clutter_stage_class_init): Port Stage to the new size
negotiation API.
* clutter/clutter-texture.c: Port Texture to the new size
negotiation API.
* clutter/clutter-types.h: Add ClutterRequestMode enumeration.
* clutter/x11/clutter-stage-x11.c: Port the X11 stage
implementation to the new size negotiation API.
* tests/Makefile.am: Add the layout manager test case.
* tests/test-opacity.c: Update.
* tests/test-project.c: Update.
* tests/test-layout.c: Test case for a layout manager implemented
using the new size negotiation API; the layout manager handles
both transformed and untransformed children.
2008-06-10 17:07:52 +00:00
|
|
|
|
2009-06-03 13:02:06 +00:00
|
|
|
clutter_actor_allocate (CLUTTER_ACTOR (stage),
|
|
|
|
&box,
|
|
|
|
CLUTTER_ALLOCATION_NONE);
|
2008-06-10 Emmanuele Bassi <ebassi@openedhand.com>
Bug #815 - Split up request, allocation, and paint box
* clutter/clutter-actor.[ch]: Rework the size allocation,
request and paint area. Now ::request_coords() is called
::allocate(), and ::query_coords() has been split into
::get_preferred_width() and ::get_preferred_height(). See
the documentation and the layout test on how to implement
a container and layout manager with the new API. (#915,
based on a patch by Havoc Pennington, Lucas Rocha and Johan
Bilien)
* clutter/clutter-clone-texture.c: Port CloneTexture to
the new size negotiation API; it just means forwarding
the requests to the parent texture.
* clutter/clutter-deprecated.h: Add deprecated and replaced
API.
* clutter/clutter-entry.c: Port Entry to the new size
negotiation API.
* clutter/clutter-group.c: Port Group to the new size
negotiation API; the semantics of the Group actor do not
change.
* clutter/clutter-label.c: Port Label to the new size
negotiation API, and vastly simplify the code.
* clutter/clutter-main.[ch]: Add API for executing a
relayout when needed.
* clutter/clutter-private.h: Add new Stage private API.
* clutter/clutter-rectangle.c: Update the get_abs_opacity()
call to get_paint_opacity().
* clutter/clutter-stage.c:
(clutter_stage_get_preferred_width),
(clutter_stage_get_preferred_height),
(clutter_stage_allocate),
(clutter_stage_class_init): Port Stage to the new size
negotiation API.
* clutter/clutter-texture.c: Port Texture to the new size
negotiation API.
* clutter/clutter-types.h: Add ClutterRequestMode enumeration.
* clutter/x11/clutter-stage-x11.c: Port the X11 stage
implementation to the new size negotiation API.
* tests/Makefile.am: Add the layout manager test case.
* tests/test-opacity.c: Update.
* tests/test-project.c: Update.
* tests/test-layout.c: Test case for a layout manager implemented
using the new size negotiation API; the layout manager handles
both transformed and untransformed children.
2008-06-10 17:07:52 +00:00
|
|
|
}
|
|
|
|
|
2009-06-06 23:10:41 +00:00
|
|
|
void
|
|
|
|
_clutter_stage_queue_event (ClutterStage *stage,
|
|
|
|
ClutterEvent *event)
|
2009-01-12 14:19:48 +00:00
|
|
|
{
|
2009-06-06 23:10:41 +00:00
|
|
|
ClutterStagePrivate *priv;
|
2009-06-07 02:48:15 +00:00
|
|
|
gboolean first_event;
|
2010-01-08 17:51:00 +00:00
|
|
|
ClutterInputDevice *device;
|
2009-03-21 20:39:32 +00:00
|
|
|
|
2009-06-06 23:10:41 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
2009-03-21 20:39:32 +00:00
|
|
|
|
2009-06-06 23:10:41 +00:00
|
|
|
priv = stage->priv;
|
|
|
|
|
2009-06-07 02:48:15 +00:00
|
|
|
first_event = priv->event_queue->length == 0;
|
|
|
|
|
2010-01-08 17:51:00 +00:00
|
|
|
g_queue_push_tail (priv->event_queue, clutter_event_copy (event));
|
2009-06-07 02:48:15 +00:00
|
|
|
|
|
|
|
if (first_event)
|
|
|
|
{
|
|
|
|
ClutterMasterClock *master_clock = _clutter_master_clock_get_default ();
|
|
|
|
_clutter_master_clock_start_running (master_clock);
|
|
|
|
}
|
2010-01-08 17:51:00 +00:00
|
|
|
|
|
|
|
/* if needed, update the state of the input device of the event.
|
|
|
|
* we do it here to avoid calling the same code from every backend
|
|
|
|
* event processing function
|
|
|
|
*/
|
|
|
|
device = clutter_event_get_device (event);
|
|
|
|
if (device != NULL)
|
|
|
|
{
|
|
|
|
ClutterModifierType event_state = clutter_event_get_state (event);
|
|
|
|
guint32 event_time = clutter_event_get_time (event);
|
|
|
|
gfloat event_x, event_y;
|
|
|
|
|
|
|
|
clutter_event_get_coords (event, &event_x, &event_y);
|
|
|
|
|
|
|
|
_clutter_input_device_set_coords (device, event_x, event_y);
|
|
|
|
_clutter_input_device_set_state (device, event_state);
|
|
|
|
_clutter_input_device_set_time (device, event_time);
|
|
|
|
}
|
2009-06-06 23:10:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
gboolean
|
|
|
|
_clutter_stage_has_queued_events (ClutterStage *stage)
|
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv;
|
|
|
|
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_STAGE (stage), FALSE);
|
|
|
|
|
|
|
|
priv = stage->priv;
|
|
|
|
|
|
|
|
return priv->event_queue->length > 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
_clutter_stage_process_queued_events (ClutterStage *stage)
|
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv;
|
2010-01-08 17:51:00 +00:00
|
|
|
GList *events, *l;
|
2009-06-06 23:10:41 +00:00
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
|
|
|
|
|
|
|
priv = stage->priv;
|
|
|
|
|
|
|
|
if (priv->event_queue->length == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* In case the stage gets destroyed during event processing */
|
|
|
|
g_object_ref (stage);
|
|
|
|
|
|
|
|
/* Steal events before starting processing to avoid reentrancy
|
|
|
|
* issues */
|
|
|
|
events = priv->event_queue->head;
|
|
|
|
priv->event_queue->head = NULL;
|
|
|
|
priv->event_queue->tail = NULL;
|
|
|
|
priv->event_queue->length = 0;
|
|
|
|
|
2010-01-08 17:51:00 +00:00
|
|
|
for (l = events; l != NULL; l = l->next)
|
2009-06-06 23:10:41 +00:00
|
|
|
{
|
|
|
|
ClutterEvent *event;
|
|
|
|
ClutterEvent *next_event;
|
2010-02-22 11:34:04 +00:00
|
|
|
ClutterInputDevice *device;
|
|
|
|
ClutterInputDevice *next_device;
|
|
|
|
gboolean check_device = FALSE;
|
2009-06-06 23:10:41 +00:00
|
|
|
|
|
|
|
event = l->data;
|
|
|
|
next_event = l->next ? l->next->data : NULL;
|
|
|
|
|
2010-02-22 11:34:04 +00:00
|
|
|
device = clutter_event_get_device (event);
|
|
|
|
|
|
|
|
if (next_event != NULL)
|
|
|
|
next_device = clutter_event_get_device (next_event);
|
|
|
|
else
|
|
|
|
next_device = NULL;
|
|
|
|
|
|
|
|
if (device != NULL && next_device != NULL)
|
|
|
|
check_device = TRUE;
|
|
|
|
|
|
|
|
/* Skip consecutive motion events coming from the same device */
|
2009-07-14 12:47:35 +00:00
|
|
|
if (priv->throttle_motion_events &&
|
2010-02-22 11:34:04 +00:00
|
|
|
next_event != NULL &&
|
2009-06-06 23:10:41 +00:00
|
|
|
event->type == CLUTTER_MOTION &&
|
|
|
|
(next_event->type == CLUTTER_MOTION ||
|
2010-02-22 11:34:04 +00:00
|
|
|
next_event->type == CLUTTER_LEAVE) &&
|
|
|
|
(!check_device || (device == next_device)))
|
2009-06-06 23:10:41 +00:00
|
|
|
{
|
2010-02-22 11:34:04 +00:00
|
|
|
CLUTTER_NOTE (EVENT,
|
|
|
|
"Omitting motion event at %d, %d",
|
|
|
|
(int) event->motion.x,
|
|
|
|
(int) event->motion.y);
|
|
|
|
goto next_event;
|
2009-06-06 23:10:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
_clutter_process_event (event);
|
|
|
|
|
|
|
|
next_event:
|
|
|
|
clutter_event_free (event);
|
|
|
|
}
|
|
|
|
|
|
|
|
g_list_free (events);
|
|
|
|
|
|
|
|
g_object_unref (stage);
|
|
|
|
}
|
|
|
|
|
2009-06-06 22:22:51 +00:00
|
|
|
/**
|
|
|
|
* _clutter_stage_needs_update:
|
|
|
|
* @stage: A #ClutterStage
|
|
|
|
*
|
|
|
|
* Determines if _clutter_stage_do_update() needs to be called.
|
|
|
|
*
|
2009-06-10 14:50:27 +00:00
|
|
|
* Return value: %TRUE if the stage need layout or painting
|
2009-06-06 22:22:51 +00:00
|
|
|
*/
|
|
|
|
gboolean
|
|
|
|
_clutter_stage_needs_update (ClutterStage *stage)
|
2009-01-12 14:19:48 +00:00
|
|
|
{
|
2009-06-06 22:22:51 +00:00
|
|
|
ClutterStagePrivate *priv;
|
2009-03-21 20:39:32 +00:00
|
|
|
|
2009-06-06 22:22:51 +00:00
|
|
|
g_return_val_if_fail (CLUTTER_IS_STAGE (stage), FALSE);
|
|
|
|
|
|
|
|
priv = stage->priv;
|
|
|
|
|
2010-09-07 19:08:00 +00:00
|
|
|
return priv->relayout_pending || priv->redraw_pending;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
_clutter_stage_maybe_relayout (ClutterActor *actor)
|
|
|
|
{
|
|
|
|
ClutterStage *stage = CLUTTER_STAGE (actor);
|
|
|
|
ClutterStagePrivate *priv = stage->priv;
|
|
|
|
gfloat natural_width, natural_height;
|
|
|
|
ClutterActorBox box = { 0, };
|
|
|
|
CLUTTER_STATIC_TIMER (relayout_timer,
|
|
|
|
"Mainloop", /* no parent */
|
|
|
|
"Layouting",
|
|
|
|
"The time spent reallocating the stage",
|
|
|
|
0 /* no application private data */);
|
|
|
|
|
|
|
|
if (!priv->relayout_pending)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* avoid reentrancy */
|
|
|
|
if (!CLUTTER_ACTOR_IN_RELAYOUT (stage))
|
|
|
|
{
|
2010-12-29 21:57:02 +00:00
|
|
|
priv->relayout_pending = FALSE;
|
|
|
|
|
2010-09-07 19:08:00 +00:00
|
|
|
CLUTTER_TIMER_START (_clutter_uprof_context, relayout_timer);
|
|
|
|
CLUTTER_NOTE (ACTOR, "Recomputing layout");
|
|
|
|
|
|
|
|
CLUTTER_SET_PRIVATE_FLAGS (stage, CLUTTER_IN_RELAYOUT);
|
|
|
|
|
|
|
|
natural_width = natural_height = 0;
|
|
|
|
clutter_actor_get_preferred_size (CLUTTER_ACTOR (stage),
|
|
|
|
NULL, NULL,
|
|
|
|
&natural_width, &natural_height);
|
|
|
|
|
|
|
|
box.x1 = 0;
|
|
|
|
box.y1 = 0;
|
|
|
|
box.x2 = natural_width;
|
|
|
|
box.y2 = natural_height;
|
|
|
|
|
|
|
|
CLUTTER_NOTE (ACTOR, "Allocating (0, 0 - %d, %d) for the stage",
|
|
|
|
(int) natural_width,
|
|
|
|
(int) natural_height);
|
|
|
|
|
|
|
|
clutter_actor_allocate (CLUTTER_ACTOR (stage),
|
|
|
|
&box, CLUTTER_ALLOCATION_NONE);
|
|
|
|
|
|
|
|
CLUTTER_UNSET_PRIVATE_FLAGS (stage, CLUTTER_IN_RELAYOUT);
|
|
|
|
CLUTTER_TIMER_STOP (_clutter_uprof_context, relayout_timer);
|
|
|
|
}
|
2009-06-06 22:22:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* _clutter_stage_do_update:
|
|
|
|
* @stage: A #ClutterStage
|
|
|
|
*
|
|
|
|
* Handles per-frame layout and repaint for the stage.
|
2009-06-10 14:50:27 +00:00
|
|
|
*
|
|
|
|
* Return value: %TRUE if the stage was updated
|
2009-06-06 22:22:51 +00:00
|
|
|
*/
|
2009-06-10 14:50:27 +00:00
|
|
|
gboolean
|
2009-06-06 22:22:51 +00:00
|
|
|
_clutter_stage_do_update (ClutterStage *stage)
|
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv;
|
|
|
|
|
2009-06-10 14:50:27 +00:00
|
|
|
g_return_val_if_fail (CLUTTER_IS_STAGE (stage), FALSE);
|
2009-06-06 22:22:51 +00:00
|
|
|
|
|
|
|
priv = stage->priv;
|
|
|
|
|
2010-09-07 19:08:00 +00:00
|
|
|
/* NB: We need to ensure we have an up to date layout *before* we
|
|
|
|
* check or clear the pending redraws flag since a relayout may
|
|
|
|
* queue a redraw.
|
2009-03-12 19:33:36 +00:00
|
|
|
*/
|
|
|
|
_clutter_stage_maybe_relayout (CLUTTER_ACTOR (stage));
|
|
|
|
|
2010-09-07 19:08:00 +00:00
|
|
|
if (!priv->redraw_pending)
|
|
|
|
return FALSE;
|
|
|
|
|
2010-09-10 00:33:02 +00:00
|
|
|
_clutter_stage_maybe_finish_queue_redraws (stage);
|
|
|
|
|
2009-03-21 20:39:32 +00:00
|
|
|
CLUTTER_NOTE (PAINT, "redrawing via idle for stage[%p]", stage);
|
2009-06-05 16:55:24 +00:00
|
|
|
_clutter_do_redraw (stage);
|
2009-03-21 20:39:32 +00:00
|
|
|
|
2009-05-07 18:07:21 +00:00
|
|
|
/* reset the guard, so that new redraws are possible */
|
2009-06-06 22:22:51 +00:00
|
|
|
priv->redraw_pending = FALSE;
|
2009-05-07 18:07:21 +00:00
|
|
|
|
2009-03-21 20:39:32 +00:00
|
|
|
if (CLUTTER_CONTEXT ()->redraw_count > 0)
|
2009-01-12 14:19:48 +00:00
|
|
|
{
|
2009-05-07 18:07:21 +00:00
|
|
|
CLUTTER_NOTE (SCHEDULER, "Queued %lu redraws during the last cycle",
|
2009-03-21 20:39:32 +00:00
|
|
|
CLUTTER_CONTEXT ()->redraw_count);
|
|
|
|
|
|
|
|
CLUTTER_CONTEXT ()->redraw_count = 0;
|
2009-01-12 14:19:48 +00:00
|
|
|
}
|
|
|
|
|
2009-06-10 14:50:27 +00:00
|
|
|
return TRUE;
|
2009-01-12 14:19:48 +00:00
|
|
|
}
|
|
|
|
|
2010-09-07 19:08:00 +00:00
|
|
|
static void
|
|
|
|
clutter_stage_real_queue_relayout (ClutterActor *self)
|
|
|
|
{
|
|
|
|
ClutterStage *stage = CLUTTER_STAGE (self);
|
|
|
|
ClutterStagePrivate *priv = stage->priv;
|
|
|
|
ClutterActorClass *parent_class;
|
|
|
|
|
|
|
|
priv->relayout_pending = TRUE;
|
|
|
|
|
|
|
|
/* chain up */
|
|
|
|
parent_class = CLUTTER_ACTOR_CLASS (clutter_stage_parent_class);
|
|
|
|
parent_class->queue_relayout (self);
|
|
|
|
}
|
|
|
|
|
2009-01-12 14:19:48 +00:00
|
|
|
static void
|
2009-02-17 17:22:02 +00:00
|
|
|
clutter_stage_real_queue_redraw (ClutterActor *actor,
|
|
|
|
ClutterActor *leaf)
|
2009-01-12 14:19:48 +00:00
|
|
|
{
|
2009-02-17 17:22:02 +00:00
|
|
|
ClutterStage *stage = CLUTTER_STAGE (actor);
|
2009-01-12 14:19:48 +00:00
|
|
|
ClutterStagePrivate *priv = stage->priv;
|
2009-11-30 17:47:55 +00:00
|
|
|
ClutterStageWindow *stage_window;
|
|
|
|
ClutterGeometry stage_clip;
|
2010-09-07 18:31:27 +00:00
|
|
|
const ClutterPaintVolume *redraw_clip;
|
|
|
|
ClutterPaintVolume projected_clip;
|
|
|
|
CoglMatrix modelview;
|
|
|
|
ClutterActorBox bounding_box;
|
2009-01-12 14:19:48 +00:00
|
|
|
|
2010-09-30 09:27:10 +00:00
|
|
|
if (CLUTTER_ACTOR_IN_DESTRUCTION (actor))
|
|
|
|
return;
|
|
|
|
|
2009-11-30 17:47:55 +00:00
|
|
|
/* If the backend can't do anything with redraw clips (e.g. it already knows
|
|
|
|
* it needs to redraw everything anyway) then don't spend time transforming
|
2010-09-07 18:31:27 +00:00
|
|
|
* any clip volume into stage coordinates... */
|
2009-11-30 17:47:55 +00:00
|
|
|
stage_window = _clutter_stage_get_window (stage);
|
2010-09-30 09:27:10 +00:00
|
|
|
if (stage_window == NULL)
|
|
|
|
return;
|
|
|
|
|
2009-11-30 17:47:55 +00:00
|
|
|
if (_clutter_stage_window_ignoring_redraw_clips (stage_window))
|
2010-11-23 16:48:59 +00:00
|
|
|
{
|
|
|
|
_clutter_stage_window_add_redraw_clip (stage_window, NULL);
|
|
|
|
return;
|
|
|
|
}
|
2009-11-30 17:47:55 +00:00
|
|
|
|
2010-09-07 18:31:27 +00:00
|
|
|
/* Convert the clip volume (which is in leaf actor coordinates) into stage
|
2009-11-30 17:47:55 +00:00
|
|
|
* coordinates and then into an axis aligned stage coordinates bounding
|
|
|
|
* box...
|
|
|
|
*/
|
|
|
|
|
2010-09-07 18:31:27 +00:00
|
|
|
if (!_clutter_actor_get_queue_redraw_clip (leaf))
|
2009-11-30 17:47:55 +00:00
|
|
|
{
|
|
|
|
_clutter_stage_window_add_redraw_clip (stage_window, NULL);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-09-07 18:31:27 +00:00
|
|
|
redraw_clip = _clutter_actor_get_queue_redraw_clip (leaf);
|
2009-11-30 17:47:55 +00:00
|
|
|
|
2010-09-07 18:31:27 +00:00
|
|
|
_clutter_paint_volume_copy_static (redraw_clip, &projected_clip);
|
2009-11-30 17:47:55 +00:00
|
|
|
|
2010-09-07 18:31:27 +00:00
|
|
|
/* NB: _clutter_actor_apply_modelview_transform_recursive will never
|
|
|
|
* include the transformation between stage coordinates and OpenGL
|
|
|
|
* window coordinates, we have to explicitly use the
|
|
|
|
* stage->apply_transform to get that... */
|
|
|
|
cogl_matrix_init_identity (&modelview);
|
|
|
|
_clutter_actor_apply_modelview_transform (CLUTTER_ACTOR (stage), &modelview);
|
|
|
|
_clutter_actor_apply_modelview_transform_recursive (leaf, NULL, &modelview);
|
|
|
|
|
|
|
|
_clutter_paint_volume_project (&projected_clip,
|
|
|
|
&modelview,
|
|
|
|
&priv->projection,
|
|
|
|
priv->viewport);
|
|
|
|
|
|
|
|
_clutter_paint_volume_get_bounding_box (&projected_clip, &bounding_box);
|
|
|
|
clutter_paint_volume_free (&projected_clip);
|
|
|
|
|
|
|
|
clutter_actor_box_clamp_to_pixel (&bounding_box);
|
2009-11-30 17:47:55 +00:00
|
|
|
|
|
|
|
/* when converting to integer coordinates make sure we round the edges of the
|
|
|
|
* clip rectangle outwards... */
|
2010-09-07 18:31:27 +00:00
|
|
|
stage_clip.x = bounding_box.x1;
|
|
|
|
stage_clip.y = bounding_box.y1;
|
|
|
|
stage_clip.width = bounding_box.x2 - stage_clip.x;
|
|
|
|
stage_clip.height = bounding_box.y2 - stage_clip.y;
|
2009-11-30 17:47:55 +00:00
|
|
|
|
|
|
|
_clutter_stage_window_add_redraw_clip (stage_window, &stage_clip);
|
|
|
|
}
|
|
|
|
|
|
|
|
gboolean
|
|
|
|
_clutter_stage_has_full_redraw_queued (ClutterStage *stage)
|
|
|
|
{
|
|
|
|
ClutterStageWindow *stage_window = _clutter_stage_get_window (stage);
|
2010-07-20 13:39:43 +00:00
|
|
|
|
2010-07-21 15:10:46 +00:00
|
|
|
if (CLUTTER_ACTOR_IN_DESTRUCTION (stage) || stage_window == NULL)
|
2010-07-20 13:39:43 +00:00
|
|
|
return FALSE;
|
2009-11-30 17:47:55 +00:00
|
|
|
|
|
|
|
if (stage->priv->redraw_pending &&
|
|
|
|
!_clutter_stage_window_has_redraw_clips (stage_window))
|
|
|
|
return TRUE;
|
|
|
|
else
|
|
|
|
return FALSE;
|
2009-01-12 14:19:48 +00:00
|
|
|
}
|
|
|
|
|
2010-01-12 15:44:28 +00:00
|
|
|
static gboolean
|
|
|
|
clutter_stage_real_delete_event (ClutterStage *stage,
|
|
|
|
ClutterEvent *event)
|
|
|
|
{
|
|
|
|
if (clutter_stage_is_default (stage))
|
|
|
|
clutter_main_quit ();
|
|
|
|
else
|
|
|
|
clutter_actor_destroy (CLUTTER_ACTOR (stage));
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2010-09-07 12:10:55 +00:00
|
|
|
static void
|
|
|
|
clutter_stage_real_apply_transform (ClutterActor *stage,
|
|
|
|
CoglMatrix *matrix)
|
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv = CLUTTER_STAGE (stage)->priv;
|
|
|
|
CoglMatrix perspective;
|
|
|
|
gfloat z_camera;
|
|
|
|
gfloat width, height;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In theory, we can compute the camera distance from screen as:
|
|
|
|
*
|
|
|
|
* 0.5 * tan (FOV)
|
|
|
|
*
|
|
|
|
* However, it's better to compute the z_camera from our projection
|
|
|
|
* matrix so that we get a 1:1 mapping at the screen distance. Consider
|
|
|
|
* the upper-left corner of the screen. It has object coordinates
|
|
|
|
* (0,0,0), so by the transform below, ends up with eye coordinate
|
|
|
|
*
|
|
|
|
* x_eye = x_object / width - 0.5 = - 0.5
|
|
|
|
* y_eye = (height - y_object) / width - 0.5 = 0.5
|
|
|
|
* z_eye = z_object / width - z_camera = - z_camera
|
|
|
|
*
|
|
|
|
* From cogl_perspective(), we know that the projection matrix has
|
|
|
|
* the form:
|
|
|
|
*
|
|
|
|
* (x, 0, 0, 0)
|
|
|
|
* (0, y, 0, 0)
|
|
|
|
* (0, 0, c, d)
|
|
|
|
* (0, 0, -1, 0)
|
|
|
|
*
|
|
|
|
* Applied to the above, we get clip coordinates of
|
|
|
|
*
|
|
|
|
* x_clip = x * (- 0.5)
|
|
|
|
* y_clip = y * 0.5
|
|
|
|
* w_clip = - 1 * (- z_camera) = z_camera
|
|
|
|
*
|
|
|
|
* Dividing through by w to get normalized device coordinates, we
|
|
|
|
* have, x_nd = x * 0.5 / z_camera, y_nd = - y * 0.5 / z_camera.
|
|
|
|
* The upper left corner of the screen has normalized device coordinates,
|
|
|
|
* (-1, 1), so to have the correct 1:1 mapping, we have to have:
|
|
|
|
*
|
|
|
|
* z_camera = 0.5 * x = 0.5 * y
|
|
|
|
*
|
|
|
|
* If x != y, then we have a non-uniform aspect ration, and a 1:1 mapping
|
|
|
|
* doesn't make sense.
|
|
|
|
*/
|
|
|
|
|
|
|
|
cogl_matrix_init_identity (&perspective);
|
|
|
|
cogl_matrix_perspective (&perspective,
|
|
|
|
priv->perspective.fovy,
|
|
|
|
priv->perspective.aspect,
|
|
|
|
priv->perspective.z_near,
|
|
|
|
priv->perspective.z_far);
|
|
|
|
|
|
|
|
z_camera = 0.5f * perspective.xx;
|
|
|
|
|
|
|
|
clutter_actor_get_size (stage, &width, &height);
|
|
|
|
|
|
|
|
cogl_matrix_init_identity (matrix);
|
|
|
|
cogl_matrix_translate (matrix, -0.5f, -0.5f, -z_camera);
|
|
|
|
cogl_matrix_scale (matrix,
|
|
|
|
1.0f / width, -1.0f / height, 1.0f / width);
|
|
|
|
cogl_matrix_translate (matrix, 0.0f, -1.0f * height, 0.0f);
|
|
|
|
}
|
|
|
|
|
2006-05-29 08:59:36 +00:00
|
|
|
static void
|
2007-10-12 08:17:00 +00:00
|
|
|
clutter_stage_set_property (GObject *object,
|
2006-05-29 08:59:36 +00:00
|
|
|
guint prop_id,
|
2007-10-12 08:17:00 +00:00
|
|
|
const GValue *value,
|
2006-05-29 08:59:36 +00:00
|
|
|
GParamSpec *pspec)
|
|
|
|
{
|
2010-02-11 15:19:18 +00:00
|
|
|
ClutterStage *stage = CLUTTER_STAGE (object);
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2007-10-12 08:17:00 +00:00
|
|
|
switch (prop_id)
|
2006-05-29 08:59:36 +00:00
|
|
|
{
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
case PROP_COLOR:
|
2008-11-17 14:21:49 +00:00
|
|
|
clutter_stage_set_color (stage, clutter_value_get_color (value));
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
break;
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
|
2006-06-02 20:24:55 +00:00
|
|
|
case PROP_OFFSCREEN:
|
2009-07-31 17:34:51 +00:00
|
|
|
if (g_value_get_boolean (value))
|
|
|
|
g_warning ("Offscreen stages are currently not supported\n");
|
2006-06-02 20:24:55 +00:00
|
|
|
break;
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
|
2007-03-22 18:21:59 +00:00
|
|
|
case PROP_CURSOR_VISIBLE:
|
|
|
|
if (g_value_get_boolean (value))
|
|
|
|
clutter_stage_show_cursor (stage);
|
|
|
|
else
|
|
|
|
clutter_stage_hide_cursor (stage);
|
2006-05-29 08:59:36 +00:00
|
|
|
break;
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
|
2007-05-25 10:56:09 +00:00
|
|
|
case PROP_PERSPECTIVE:
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
clutter_stage_set_perspective (stage, g_value_get_boxed (value));
|
2007-05-25 10:56:09 +00:00
|
|
|
break;
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
|
2007-06-19 09:10:37 +00:00
|
|
|
case PROP_TITLE:
|
2007-10-12 08:17:00 +00:00
|
|
|
clutter_stage_set_title (stage, g_value_get_string (value));
|
2007-06-19 09:10:37 +00:00
|
|
|
break;
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
|
2010-08-11 11:40:22 +00:00
|
|
|
case PROP_USER_RESIZABLE:
|
2007-07-31 17:01:52 +00:00
|
|
|
clutter_stage_set_user_resizable (stage, g_value_get_boolean (value));
|
2007-07-26 20:08:09 +00:00
|
|
|
break;
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
|
2007-11-21 11:55:26 +00:00
|
|
|
case PROP_USE_FOG:
|
|
|
|
clutter_stage_set_use_fog (stage, g_value_get_boolean (value));
|
|
|
|
break;
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
|
|
|
|
case PROP_FOG:
|
|
|
|
clutter_stage_set_fog (stage, g_value_get_boxed (value));
|
|
|
|
break;
|
|
|
|
|
2009-12-01 16:16:18 +00:00
|
|
|
case PROP_USE_ALPHA:
|
2009-12-09 02:04:56 +00:00
|
|
|
clutter_stage_set_use_alpha (stage, g_value_get_boolean (value));
|
2009-12-01 16:16:18 +00:00
|
|
|
break;
|
|
|
|
|
2010-02-01 11:04:59 +00:00
|
|
|
case PROP_KEY_FOCUS:
|
|
|
|
clutter_stage_set_key_focus (stage, g_value_get_object (value));
|
|
|
|
break;
|
|
|
|
|
2010-04-16 14:34:36 +00:00
|
|
|
case PROP_NO_CLEAR_HINT:
|
|
|
|
clutter_stage_set_no_clear_hint (stage, g_value_get_boolean (value));
|
|
|
|
break;
|
|
|
|
|
2006-05-29 08:59:36 +00:00
|
|
|
default:
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
clutter_stage_get_property (GObject *gobject,
|
2007-05-16 09:08:30 +00:00
|
|
|
guint prop_id,
|
2007-10-12 08:17:00 +00:00
|
|
|
GValue *value,
|
2007-05-16 09:08:30 +00:00
|
|
|
GParamSpec *pspec)
|
2006-05-29 08:59:36 +00:00
|
|
|
{
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
ClutterStagePrivate *priv = CLUTTER_STAGE (gobject)->priv;
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2007-10-12 08:17:00 +00:00
|
|
|
switch (prop_id)
|
2006-05-29 08:59:36 +00:00
|
|
|
{
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
case PROP_COLOR:
|
2008-11-17 14:21:49 +00:00
|
|
|
clutter_value_set_color (value, &priv->color);
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
break;
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
|
2006-06-02 20:24:55 +00:00
|
|
|
case PROP_OFFSCREEN:
|
2009-07-31 17:34:51 +00:00
|
|
|
g_value_set_boolean (value, FALSE);
|
2006-06-02 20:24:55 +00:00
|
|
|
break;
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
|
2009-06-09 12:48:03 +00:00
|
|
|
case PROP_FULLSCREEN_SET:
|
2007-03-22 18:21:59 +00:00
|
|
|
g_value_set_boolean (value, priv->is_fullscreen);
|
2006-05-29 08:59:36 +00:00
|
|
|
break;
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
|
2007-03-22 18:21:59 +00:00
|
|
|
case PROP_CURSOR_VISIBLE:
|
|
|
|
g_value_set_boolean (value, priv->is_cursor_visible);
|
2006-05-29 08:59:36 +00:00
|
|
|
break;
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
|
2007-05-25 10:56:09 +00:00
|
|
|
case PROP_PERSPECTIVE:
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
g_value_set_boxed (value, &priv->perspective);
|
2007-05-25 10:56:09 +00:00
|
|
|
break;
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
|
2007-06-19 09:10:37 +00:00
|
|
|
case PROP_TITLE:
|
|
|
|
g_value_set_string (value, priv->title);
|
|
|
|
break;
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
|
2010-08-11 11:40:22 +00:00
|
|
|
case PROP_USER_RESIZABLE:
|
2007-07-31 17:01:52 +00:00
|
|
|
g_value_set_boolean (value, priv->is_user_resizable);
|
2007-07-26 20:08:09 +00:00
|
|
|
break;
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
|
2007-11-21 11:55:26 +00:00
|
|
|
case PROP_USE_FOG:
|
|
|
|
g_value_set_boolean (value, priv->use_fog);
|
|
|
|
break;
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
|
|
|
|
case PROP_FOG:
|
|
|
|
g_value_set_boxed (value, &priv->fog);
|
|
|
|
break;
|
|
|
|
|
2009-12-01 16:16:18 +00:00
|
|
|
case PROP_USE_ALPHA:
|
|
|
|
g_value_set_boolean (value, priv->use_alpha);
|
|
|
|
break;
|
|
|
|
|
2010-02-01 11:04:59 +00:00
|
|
|
case PROP_KEY_FOCUS:
|
|
|
|
g_value_set_object (value, priv->key_focused_actor);
|
|
|
|
break;
|
|
|
|
|
2010-04-16 14:34:36 +00:00
|
|
|
case PROP_NO_CLEAR_HINT:
|
|
|
|
{
|
|
|
|
gboolean hint =
|
|
|
|
(priv->stage_hints & CLUTTER_STAGE_NO_CLEAR_ON_PAINT) != 0;
|
|
|
|
|
|
|
|
g_value_set_boolean (value, hint);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2006-05-29 08:59:36 +00:00
|
|
|
default:
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
|
2006-05-29 08:59:36 +00:00
|
|
|
break;
|
2007-10-12 08:17:00 +00:00
|
|
|
}
|
2006-05-29 08:59:36 +00:00
|
|
|
}
|
|
|
|
|
2008-03-31 17:15:02 +00:00
|
|
|
static void
|
|
|
|
clutter_stage_dispose (GObject *object)
|
|
|
|
{
|
2008-04-04 15:02:11 +00:00
|
|
|
ClutterStage *stage = CLUTTER_STAGE (object);
|
|
|
|
ClutterStagePrivate *priv = stage->priv;
|
|
|
|
ClutterStageManager *stage_manager = clutter_stage_manager_get_default ();
|
2009-11-13 13:39:24 +00:00
|
|
|
ClutterMainContext *context;
|
|
|
|
GList *l, *next;
|
2008-04-04 15:02:11 +00:00
|
|
|
|
Enforce invariants on mapped, realized, visibility states
Bug 1138 - No trackable "mapped" state
* Add a VISIBLE flag tracking application programmer's
expected showing-state for the actor, allowing us to
always ensure we keep what the app wants while tracking
internal implementation state separately.
* Make MAPPED reflect whether the actor will be painted;
add notification on a ClutterActor::mapped property.
Keep MAPPED state updated as the actor is shown,
ancestors are shown, actor is reparented, etc.
* Require a stage and realized parents to realize; this means
at realization time the correct window system and GL resources
are known. But unparented actors can no longer be realized.
* Allow children to be unrealized even if parent is realized.
Otherwise in effect either all actors or no actors are realized,
i.e. it becomes a stage-global flag.
* Allow clutter_actor_realize() to "fail" if not inside a toplevel
* Rework clutter_actor_unrealize() so internally we have
a flavor that does not mess with visibility flag
* Add _clutter_actor_rerealize() to encapsulate a somewhat
tricky operation we were doing in a couple of places
* Do not realize/unrealize children in ClutterGroup,
ClutterActor already does it
* Do not realize impl by hand in clutter_stage_show(),
since showing impl already does that
* Do not unrealize in various dispose() methods, since
ClutterActor dispose implementation already does it
and chaining up is mandatory
* ClutterTexture uses COGL while unrealizable (before it's
added to a stage). Previously this breakage was affecting
ClutterActor because we had to allow realize outside
a stage. Move the breakage to ClutterTexture, by making
ClutterTexture just use COGL while not realized.
* Unrealize before we set parent to NULL in clutter_actor_unparent().
This means unrealize() implementations can get to the stage.
Because actors need the stage in order to detach from stage.
* Update clutter-actor-invariants.txt to reflect latest changes
* Remove explicit hide/unrealize from ClutterActor::dispose since
unparent already forces those
Instead just assert that unparent() occurred and did the right thing.
* Check whether parent implements unrealize before chaining up
Needed because ClutterGroup no longer has to implement unrealize.
* Perform unrealize in the default handler for the signal.
This allows non-containers that have children to work properly,
and allows containers to override how it's done.
* Add map/unmap virtual methods and set MAPPED flag on self and
children in there. This allows subclasses to hook map/unmap.
These are not signals, because notify::mapped is better for
anything it's legitimate for a non-subclass to do.
Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-04-02 13:16:43 +00:00
|
|
|
clutter_actor_hide (CLUTTER_ACTOR (object));
|
2008-07-31 08:54:43 +00:00
|
|
|
|
2008-04-04 15:02:11 +00:00
|
|
|
_clutter_stage_manager_remove_stage (stage_manager, stage);
|
|
|
|
|
2009-11-13 13:39:24 +00:00
|
|
|
context = _clutter_context_get_default ();
|
|
|
|
|
|
|
|
/* Remove any pending events for this stage from the event queue */
|
|
|
|
for (l = context->events_queue->head; l; l = next)
|
|
|
|
{
|
|
|
|
ClutterEvent *event = l->data;
|
|
|
|
|
|
|
|
next = l->next;
|
|
|
|
|
|
|
|
if (event->any.stage == stage)
|
|
|
|
{
|
|
|
|
g_queue_delete_link (context->events_queue, l);
|
|
|
|
clutter_event_free (event);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-13 11:34:07 +00:00
|
|
|
if (priv->impl != NULL)
|
2008-04-04 15:02:11 +00:00
|
|
|
{
|
2009-05-08 16:17:48 +00:00
|
|
|
CLUTTER_NOTE (BACKEND, "Disposing of the stage implementation");
|
2009-08-13 11:34:07 +00:00
|
|
|
|
|
|
|
g_object_unref (priv->impl);
|
2008-04-04 15:02:11 +00:00
|
|
|
priv->impl = NULL;
|
|
|
|
}
|
2008-03-31 17:15:02 +00:00
|
|
|
|
|
|
|
G_OBJECT_CLASS (clutter_stage_parent_class)->dispose (object);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
clutter_stage_finalize (GObject *object)
|
|
|
|
{
|
2008-07-30 15:01:37 +00:00
|
|
|
ClutterStage *stage = CLUTTER_STAGE (object);
|
2009-06-06 23:10:41 +00:00
|
|
|
ClutterStagePrivate *priv = stage->priv;
|
|
|
|
|
|
|
|
g_queue_foreach (priv->event_queue, (GFunc)clutter_event_free, NULL);
|
|
|
|
g_queue_free (priv->event_queue);
|
2008-07-30 15:01:37 +00:00
|
|
|
|
|
|
|
g_free (stage->priv->title);
|
2009-06-06 23:10:41 +00:00
|
|
|
|
2010-09-07 17:04:19 +00:00
|
|
|
g_array_free (priv->paint_volume_stack, TRUE);
|
|
|
|
|
2008-03-31 17:15:02 +00:00
|
|
|
G_OBJECT_CLASS (clutter_stage_parent_class)->finalize (object);
|
|
|
|
}
|
|
|
|
|
2006-05-29 08:59:36 +00:00
|
|
|
static void
|
|
|
|
clutter_stage_class_init (ClutterStageClass *klass)
|
|
|
|
{
|
2007-03-22 18:21:59 +00:00
|
|
|
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
|
2007-03-23 16:37:56 +00:00
|
|
|
ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
|
2008-11-17 14:21:49 +00:00
|
|
|
GParamSpec *pspec;
|
2006-05-29 08:59:36 +00:00
|
|
|
|
|
|
|
gobject_class->set_property = clutter_stage_set_property;
|
|
|
|
gobject_class->get_property = clutter_stage_get_property;
|
2008-03-31 17:15:02 +00:00
|
|
|
gobject_class->dispose = clutter_stage_dispose;
|
|
|
|
gobject_class->finalize = clutter_stage_finalize;
|
2007-03-22 18:21:59 +00:00
|
|
|
|
2008-06-10 Emmanuele Bassi <ebassi@openedhand.com>
Bug #815 - Split up request, allocation, and paint box
* clutter/clutter-actor.[ch]: Rework the size allocation,
request and paint area. Now ::request_coords() is called
::allocate(), and ::query_coords() has been split into
::get_preferred_width() and ::get_preferred_height(). See
the documentation and the layout test on how to implement
a container and layout manager with the new API. (#915,
based on a patch by Havoc Pennington, Lucas Rocha and Johan
Bilien)
* clutter/clutter-clone-texture.c: Port CloneTexture to
the new size negotiation API; it just means forwarding
the requests to the parent texture.
* clutter/clutter-deprecated.h: Add deprecated and replaced
API.
* clutter/clutter-entry.c: Port Entry to the new size
negotiation API.
* clutter/clutter-group.c: Port Group to the new size
negotiation API; the semantics of the Group actor do not
change.
* clutter/clutter-label.c: Port Label to the new size
negotiation API, and vastly simplify the code.
* clutter/clutter-main.[ch]: Add API for executing a
relayout when needed.
* clutter/clutter-private.h: Add new Stage private API.
* clutter/clutter-rectangle.c: Update the get_abs_opacity()
call to get_paint_opacity().
* clutter/clutter-stage.c:
(clutter_stage_get_preferred_width),
(clutter_stage_get_preferred_height),
(clutter_stage_allocate),
(clutter_stage_class_init): Port Stage to the new size
negotiation API.
* clutter/clutter-texture.c: Port Texture to the new size
negotiation API.
* clutter/clutter-types.h: Add ClutterRequestMode enumeration.
* clutter/x11/clutter-stage-x11.c: Port the X11 stage
implementation to the new size negotiation API.
* tests/Makefile.am: Add the layout manager test case.
* tests/test-opacity.c: Update.
* tests/test-project.c: Update.
* tests/test-layout.c: Test case for a layout manager implemented
using the new size negotiation API; the layout manager handles
both transformed and untransformed children.
2008-06-10 17:07:52 +00:00
|
|
|
actor_class->allocate = clutter_stage_allocate;
|
|
|
|
actor_class->get_preferred_width = clutter_stage_get_preferred_width;
|
|
|
|
actor_class->get_preferred_height = clutter_stage_get_preferred_height;
|
2007-03-23 16:37:56 +00:00
|
|
|
actor_class->paint = clutter_stage_paint;
|
2007-11-18 23:24:55 +00:00
|
|
|
actor_class->pick = clutter_stage_pick;
|
2010-11-23 14:31:45 +00:00
|
|
|
actor_class->get_paint_volume = clutter_stage_get_paint_volume;
|
2008-04-04 15:02:11 +00:00
|
|
|
actor_class->realize = clutter_stage_realize;
|
|
|
|
actor_class->unrealize = clutter_stage_unrealize;
|
|
|
|
actor_class->show = clutter_stage_show;
|
|
|
|
actor_class->hide = clutter_stage_hide;
|
2010-09-07 19:08:00 +00:00
|
|
|
actor_class->queue_relayout = clutter_stage_real_queue_relayout;
|
2009-02-17 17:22:02 +00:00
|
|
|
actor_class->queue_redraw = clutter_stage_real_queue_redraw;
|
2010-09-07 12:10:55 +00:00
|
|
|
actor_class->apply_transform = clutter_stage_real_apply_transform;
|
2007-03-23 16:37:56 +00:00
|
|
|
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
/**
|
2007-08-21 15:47:51 +00:00
|
|
|
* ClutterStage:fullscreen:
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
*
|
|
|
|
* Whether the stage should be fullscreen or not.
|
2009-06-09 12:48:03 +00:00
|
|
|
*
|
2009-06-09 13:05:03 +00:00
|
|
|
* This property is set by calling clutter_stage_set_fullscreen()
|
|
|
|
* but since the actual implementation is delegated to the backend
|
|
|
|
* you should connect to the notify::fullscreen-set signal in order
|
|
|
|
* to get notification if the fullscreen state has been successfully
|
|
|
|
* achieved.
|
2009-06-09 12:48:03 +00:00
|
|
|
*
|
|
|
|
* Since: 1.0
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
*/
|
2009-06-09 12:48:03 +00:00
|
|
|
pspec = g_param_spec_boolean ("fullscreen-set",
|
2010-06-03 11:57:50 +00:00
|
|
|
P_("Fullscreen Set"),
|
|
|
|
P_("Whether the main stage is fullscreen"),
|
2009-06-09 12:48:03 +00:00
|
|
|
FALSE,
|
|
|
|
CLUTTER_PARAM_READABLE);
|
|
|
|
g_object_class_install_property (gobject_class,
|
|
|
|
PROP_FULLSCREEN_SET,
|
|
|
|
pspec);
|
2007-08-21 15:47:51 +00:00
|
|
|
/**
|
|
|
|
* ClutterStage:offscreen:
|
|
|
|
*
|
|
|
|
* Whether the stage should be rendered in an offscreen buffer.
|
2009-07-27 14:42:31 +00:00
|
|
|
*
|
|
|
|
* <warning><para>Not every backend supports redirecting the
|
|
|
|
* stage to an offscreen buffer. This property might not work
|
|
|
|
* and it might be deprecated at any later date.</para></warning>
|
2007-08-21 15:47:51 +00:00
|
|
|
*/
|
2009-06-09 12:48:03 +00:00
|
|
|
pspec = g_param_spec_boolean ("offscreen",
|
2010-06-03 11:57:50 +00:00
|
|
|
P_("Offscreen"),
|
|
|
|
P_("Whether the main stage should be rendered offscreen"),
|
2009-06-09 12:48:03 +00:00
|
|
|
FALSE,
|
|
|
|
CLUTTER_PARAM_READWRITE);
|
|
|
|
g_object_class_install_property (gobject_class,
|
|
|
|
PROP_OFFSCREEN,
|
|
|
|
pspec);
|
2007-08-21 15:47:51 +00:00
|
|
|
/**
|
|
|
|
* ClutterStage:cursor-visible:
|
|
|
|
*
|
|
|
|
* Whether the mouse pointer should be visible
|
|
|
|
*/
|
2009-06-09 12:48:03 +00:00
|
|
|
pspec = g_param_spec_boolean ("cursor-visible",
|
2010-06-03 11:57:50 +00:00
|
|
|
P_("Cursor Visible"),
|
|
|
|
P_("Whether the mouse pointer is visible on the main stage"),
|
2009-06-09 12:48:03 +00:00
|
|
|
TRUE,
|
|
|
|
CLUTTER_PARAM_READWRITE);
|
|
|
|
g_object_class_install_property (gobject_class,
|
|
|
|
PROP_CURSOR_VISIBLE,
|
|
|
|
pspec);
|
2007-08-21 15:47:51 +00:00
|
|
|
/**
|
|
|
|
* ClutterStage:user-resizable:
|
|
|
|
*
|
2008-02-15 15:18:02 +00:00
|
|
|
* Whether the stage is resizable via user interaction.
|
2007-08-21 15:47:51 +00:00
|
|
|
*
|
|
|
|
* Since: 0.4
|
|
|
|
*/
|
2009-06-09 12:48:03 +00:00
|
|
|
pspec = g_param_spec_boolean ("user-resizable",
|
2010-06-03 11:57:50 +00:00
|
|
|
P_("User Resizable"),
|
|
|
|
P_("Whether the stage is able to be resized via user interaction"),
|
2009-06-09 12:48:03 +00:00
|
|
|
FALSE,
|
|
|
|
CLUTTER_PARAM_READWRITE);
|
|
|
|
g_object_class_install_property (gobject_class,
|
2010-08-11 11:40:22 +00:00
|
|
|
PROP_USER_RESIZABLE,
|
2009-06-09 12:48:03 +00:00
|
|
|
pspec);
|
2007-08-21 15:47:51 +00:00
|
|
|
/**
|
|
|
|
* ClutterStage:color:
|
|
|
|
*
|
|
|
|
* The color of the main stage.
|
|
|
|
*/
|
2008-11-17 14:21:49 +00:00
|
|
|
pspec = clutter_param_spec_color ("color",
|
2010-06-03 11:57:50 +00:00
|
|
|
P_("Color"),
|
|
|
|
P_("The color of the stage"),
|
2008-11-17 14:21:49 +00:00
|
|
|
&default_stage_color,
|
|
|
|
CLUTTER_PARAM_READWRITE);
|
|
|
|
g_object_class_install_property (gobject_class, PROP_COLOR, pspec);
|
2008-07-30 21:09:58 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* ClutterStage:perspective:
|
|
|
|
*
|
|
|
|
* The parameters used for the perspective projection from 3D
|
|
|
|
* coordinates to 2D
|
|
|
|
*
|
|
|
|
* Since: 0.8.2
|
|
|
|
*/
|
2009-06-09 12:48:03 +00:00
|
|
|
pspec = g_param_spec_boxed ("perspective",
|
2010-06-03 11:57:50 +00:00
|
|
|
P_("Perspective"),
|
|
|
|
P_("Perspective projection parameters"),
|
2009-06-09 12:48:03 +00:00
|
|
|
CLUTTER_TYPE_PERSPECTIVE,
|
|
|
|
CLUTTER_PARAM_READWRITE);
|
|
|
|
g_object_class_install_property (gobject_class,
|
|
|
|
PROP_PERSPECTIVE,
|
|
|
|
pspec);
|
2008-07-30 21:09:58 +00:00
|
|
|
|
2007-06-19 09:10:37 +00:00
|
|
|
/**
|
|
|
|
* ClutterStage:title:
|
|
|
|
*
|
2008-02-15 15:18:02 +00:00
|
|
|
* The stage's title - usually displayed in stage windows title decorations.
|
2007-06-19 09:10:37 +00:00
|
|
|
*
|
|
|
|
* Since: 0.4
|
|
|
|
*/
|
2009-06-09 12:48:03 +00:00
|
|
|
pspec = g_param_spec_string ("title",
|
2010-06-03 11:57:50 +00:00
|
|
|
P_("Title"),
|
|
|
|
P_("Stage Title"),
|
2009-06-09 12:48:03 +00:00
|
|
|
NULL,
|
|
|
|
CLUTTER_PARAM_READWRITE);
|
|
|
|
g_object_class_install_property (gobject_class, PROP_TITLE, pspec);
|
|
|
|
|
2007-11-21 11:55:26 +00:00
|
|
|
/**
|
|
|
|
* ClutterStage:use-fog:
|
|
|
|
*
|
2008-02-15 15:18:02 +00:00
|
|
|
* Whether the stage should use a linear GL "fog" in creating the
|
|
|
|
* depth-cueing effect, to enhance the perception of depth by fading
|
|
|
|
* actors farther from the viewpoint.
|
2007-11-21 11:55:26 +00:00
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
2009-06-09 12:48:03 +00:00
|
|
|
pspec = g_param_spec_boolean ("use-fog",
|
2010-06-03 11:57:50 +00:00
|
|
|
P_("Use Fog"),
|
|
|
|
P_("Whether to enable depth cueing"),
|
2009-06-09 12:48:03 +00:00
|
|
|
FALSE,
|
|
|
|
CLUTTER_PARAM_READWRITE);
|
|
|
|
g_object_class_install_property (gobject_class, PROP_USE_FOG, pspec);
|
|
|
|
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
/**
|
|
|
|
* ClutterStage:fog:
|
|
|
|
*
|
|
|
|
* The settings for the GL "fog", used only if #ClutterStage:use-fog
|
|
|
|
* is set to %TRUE
|
|
|
|
*
|
|
|
|
* Since: 1.0
|
|
|
|
*/
|
|
|
|
pspec = g_param_spec_boxed ("fog",
|
2010-06-03 11:57:50 +00:00
|
|
|
P_("Fog"),
|
|
|
|
P_("Settings for the depth cueing"),
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
CLUTTER_TYPE_FOG,
|
|
|
|
CLUTTER_PARAM_READWRITE);
|
|
|
|
g_object_class_install_property (gobject_class, PROP_FOG, pspec);
|
2007-08-24 15:12:52 +00:00
|
|
|
|
2009-12-01 16:16:18 +00:00
|
|
|
/**
|
|
|
|
* ClutterStage:use-alpha:
|
|
|
|
*
|
|
|
|
* Whether the #ClutterStage should honour the alpha component of the
|
|
|
|
* #ClutterStage:color property when painting. If Clutter is run under
|
|
|
|
* a compositing manager this will result in the stage being blended
|
|
|
|
* with the underlying window(s)
|
|
|
|
*
|
|
|
|
* Since: 1.2
|
|
|
|
*/
|
|
|
|
pspec = g_param_spec_boolean ("use-alpha",
|
2010-06-03 11:57:50 +00:00
|
|
|
P_("Use Alpha"),
|
|
|
|
P_("Whether to honour the alpha component of the stage color"),
|
2009-12-01 16:16:18 +00:00
|
|
|
FALSE,
|
|
|
|
CLUTTER_PARAM_READWRITE);
|
|
|
|
g_object_class_install_property (gobject_class, PROP_USE_ALPHA, pspec);
|
|
|
|
|
2010-02-01 11:04:59 +00:00
|
|
|
/**
|
|
|
|
* ClutterStage:key-focus:
|
|
|
|
*
|
|
|
|
* The #ClutterActor that will receive key events from the underlying
|
|
|
|
* windowing system.
|
|
|
|
*
|
|
|
|
* If %NULL, the #ClutterStage will receive the events.
|
|
|
|
*
|
|
|
|
* Since: 1.2
|
|
|
|
*/
|
|
|
|
pspec = g_param_spec_object ("key-focus",
|
2010-06-03 11:57:50 +00:00
|
|
|
P_("Key Focus"),
|
|
|
|
P_("The currently key focused actor"),
|
2010-02-01 11:04:59 +00:00
|
|
|
CLUTTER_TYPE_ACTOR,
|
|
|
|
CLUTTER_PARAM_READWRITE);
|
|
|
|
g_object_class_install_property (gobject_class, PROP_KEY_FOCUS, pspec);
|
|
|
|
|
2010-04-16 14:34:36 +00:00
|
|
|
/**
|
|
|
|
* ClutterStage:no-clear-hint:
|
|
|
|
*
|
|
|
|
* Whether or not the #ClutterStage should clear its contents
|
|
|
|
* before each paint cycle.
|
|
|
|
*
|
|
|
|
* See clutter_stage_set_no_clear_hint() for further information.
|
|
|
|
*
|
|
|
|
* Since: 1.4
|
|
|
|
*/
|
|
|
|
pspec = g_param_spec_boolean ("no-clear-hint",
|
2010-06-03 11:57:50 +00:00
|
|
|
P_("No Clear Hint"),
|
|
|
|
P_("Whether the stage should clear its contents"),
|
2010-04-16 14:34:36 +00:00
|
|
|
FALSE,
|
|
|
|
CLUTTER_PARAM_READWRITE);
|
|
|
|
g_object_class_install_property (gobject_class, PROP_NO_CLEAR_HINT, pspec);
|
|
|
|
|
2010-12-28 17:37:18 +00:00
|
|
|
/**
|
|
|
|
* ClutterStage:accept-focus:
|
|
|
|
*
|
|
|
|
* Whether the #ClutterStage should accept key focus when shown.
|
|
|
|
*
|
|
|
|
* Since: 1.6
|
|
|
|
*/
|
|
|
|
pspec = g_param_spec_boolean ("accept-focus",
|
|
|
|
P_("Accept Focus"),
|
|
|
|
P_("Whether the stage should accept focus on show"),
|
|
|
|
TRUE,
|
|
|
|
CLUTTER_PARAM_READWRITE);
|
|
|
|
g_object_class_install_property (gobject_class, PROP_ACCEPT_FOCUS, pspec);
|
|
|
|
|
2007-08-24 15:12:52 +00:00
|
|
|
/**
|
|
|
|
* ClutterStage::fullscreen
|
|
|
|
* @stage: the stage which was fullscreened
|
|
|
|
*
|
|
|
|
* The ::fullscreen signal is emitted when the stage is made fullscreen.
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
stage_signals[FULLSCREEN] =
|
2010-06-03 11:57:50 +00:00
|
|
|
g_signal_new (I_("fullscreen"),
|
2007-08-24 15:12:52 +00:00
|
|
|
G_TYPE_FROM_CLASS (gobject_class),
|
2008-06-10 Emmanuele Bassi <ebassi@openedhand.com>
Bug #815 - Split up request, allocation, and paint box
* clutter/clutter-actor.[ch]: Rework the size allocation,
request and paint area. Now ::request_coords() is called
::allocate(), and ::query_coords() has been split into
::get_preferred_width() and ::get_preferred_height(). See
the documentation and the layout test on how to implement
a container and layout manager with the new API. (#915,
based on a patch by Havoc Pennington, Lucas Rocha and Johan
Bilien)
* clutter/clutter-clone-texture.c: Port CloneTexture to
the new size negotiation API; it just means forwarding
the requests to the parent texture.
* clutter/clutter-deprecated.h: Add deprecated and replaced
API.
* clutter/clutter-entry.c: Port Entry to the new size
negotiation API.
* clutter/clutter-group.c: Port Group to the new size
negotiation API; the semantics of the Group actor do not
change.
* clutter/clutter-label.c: Port Label to the new size
negotiation API, and vastly simplify the code.
* clutter/clutter-main.[ch]: Add API for executing a
relayout when needed.
* clutter/clutter-private.h: Add new Stage private API.
* clutter/clutter-rectangle.c: Update the get_abs_opacity()
call to get_paint_opacity().
* clutter/clutter-stage.c:
(clutter_stage_get_preferred_width),
(clutter_stage_get_preferred_height),
(clutter_stage_allocate),
(clutter_stage_class_init): Port Stage to the new size
negotiation API.
* clutter/clutter-texture.c: Port Texture to the new size
negotiation API.
* clutter/clutter-types.h: Add ClutterRequestMode enumeration.
* clutter/x11/clutter-stage-x11.c: Port the X11 stage
implementation to the new size negotiation API.
* tests/Makefile.am: Add the layout manager test case.
* tests/test-opacity.c: Update.
* tests/test-project.c: Update.
* tests/test-layout.c: Test case for a layout manager implemented
using the new size negotiation API; the layout manager handles
both transformed and untransformed children.
2008-06-10 17:07:52 +00:00
|
|
|
G_SIGNAL_RUN_FIRST,
|
2007-08-24 15:12:52 +00:00
|
|
|
G_STRUCT_OFFSET (ClutterStageClass, fullscreen),
|
|
|
|
NULL, NULL,
|
2010-06-11 14:49:46 +00:00
|
|
|
_clutter_marshal_VOID__VOID,
|
2007-08-24 15:12:52 +00:00
|
|
|
G_TYPE_NONE, 0);
|
|
|
|
/**
|
|
|
|
* ClutterStage::unfullscreen
|
|
|
|
* @stage: the stage which has left a fullscreen state.
|
|
|
|
*
|
|
|
|
* The ::unfullscreen signal is emitted when the stage leaves a fullscreen
|
|
|
|
* state.
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
stage_signals[UNFULLSCREEN] =
|
2010-06-03 11:57:50 +00:00
|
|
|
g_signal_new (I_("unfullscreen"),
|
2007-08-24 15:12:52 +00:00
|
|
|
G_TYPE_FROM_CLASS (gobject_class),
|
|
|
|
G_SIGNAL_RUN_LAST,
|
|
|
|
G_STRUCT_OFFSET (ClutterStageClass, unfullscreen),
|
|
|
|
NULL, NULL,
|
2010-06-11 14:49:46 +00:00
|
|
|
_clutter_marshal_VOID__VOID,
|
2007-08-24 15:12:52 +00:00
|
|
|
G_TYPE_NONE, 0);
|
|
|
|
/**
|
|
|
|
* ClutterStage::activate
|
|
|
|
* @stage: the stage which was activated
|
|
|
|
*
|
2008-02-15 15:18:02 +00:00
|
|
|
* The ::activate signal is emitted when the stage receives key focus
|
2007-08-24 15:12:52 +00:00
|
|
|
* from the underlying window system.
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
stage_signals[ACTIVATE] =
|
2010-06-03 11:57:50 +00:00
|
|
|
g_signal_new (I_("activate"),
|
2007-08-24 15:12:52 +00:00
|
|
|
G_TYPE_FROM_CLASS (gobject_class),
|
|
|
|
G_SIGNAL_RUN_LAST,
|
|
|
|
G_STRUCT_OFFSET (ClutterStageClass, activate),
|
|
|
|
NULL, NULL,
|
2010-06-11 14:49:46 +00:00
|
|
|
_clutter_marshal_VOID__VOID,
|
2007-08-24 15:12:52 +00:00
|
|
|
G_TYPE_NONE, 0);
|
|
|
|
/**
|
|
|
|
* ClutterStage::deactivate
|
|
|
|
* @stage: the stage which was deactivated
|
|
|
|
*
|
|
|
|
* The ::activate signal is emitted when the stage loses key focus
|
|
|
|
* from the underlying window system.
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
stage_signals[DEACTIVATE] =
|
2010-06-03 11:57:50 +00:00
|
|
|
g_signal_new (I_("deactivate"),
|
2007-08-24 15:12:52 +00:00
|
|
|
G_TYPE_FROM_CLASS (gobject_class),
|
|
|
|
G_SIGNAL_RUN_LAST,
|
|
|
|
G_STRUCT_OFFSET (ClutterStageClass, deactivate),
|
|
|
|
NULL, NULL,
|
2010-06-11 14:49:46 +00:00
|
|
|
_clutter_marshal_VOID__VOID,
|
2007-08-24 15:12:52 +00:00
|
|
|
G_TYPE_NONE, 0);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2010-01-12 15:44:28 +00:00
|
|
|
/**
|
|
|
|
* ClutterStage::delete-event:
|
|
|
|
* @stage: the stage that received the event
|
|
|
|
* @event: a #ClutterEvent of type %CLUTTER_DELETE
|
|
|
|
*
|
|
|
|
* The ::delete-event signal is emitted when the user closes a
|
|
|
|
* #ClutterStage window using the window controls.
|
|
|
|
*
|
|
|
|
* Clutter by default will call clutter_main_quit() if @stage is
|
|
|
|
* the default stage, and clutter_actor_destroy() for any other
|
|
|
|
* stage.
|
|
|
|
*
|
|
|
|
* It is possible to override the default behaviour by connecting
|
|
|
|
* a new handler and returning %TRUE there.
|
|
|
|
*
|
|
|
|
* <note>This signal is emitted only on Clutter backends that
|
|
|
|
* embed #ClutterStage in native windows. It is not emitted for
|
|
|
|
* backends that use a static frame buffer.</note>
|
|
|
|
*
|
|
|
|
* Since: 1.2
|
|
|
|
*/
|
|
|
|
stage_signals[DELETE_EVENT] =
|
|
|
|
g_signal_new (I_("delete-event"),
|
|
|
|
G_TYPE_FROM_CLASS (gobject_class),
|
|
|
|
G_SIGNAL_RUN_LAST,
|
|
|
|
G_STRUCT_OFFSET (ClutterStageClass, delete_event),
|
|
|
|
_clutter_boolean_handled_accumulator, NULL,
|
2010-06-11 14:49:46 +00:00
|
|
|
_clutter_marshal_BOOLEAN__BOXED,
|
2010-01-12 15:44:28 +00:00
|
|
|
G_TYPE_BOOLEAN, 1,
|
|
|
|
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
|
|
|
|
|
2008-06-10 Emmanuele Bassi <ebassi@openedhand.com>
Bug #815 - Split up request, allocation, and paint box
* clutter/clutter-actor.[ch]: Rework the size allocation,
request and paint area. Now ::request_coords() is called
::allocate(), and ::query_coords() has been split into
::get_preferred_width() and ::get_preferred_height(). See
the documentation and the layout test on how to implement
a container and layout manager with the new API. (#915,
based on a patch by Havoc Pennington, Lucas Rocha and Johan
Bilien)
* clutter/clutter-clone-texture.c: Port CloneTexture to
the new size negotiation API; it just means forwarding
the requests to the parent texture.
* clutter/clutter-deprecated.h: Add deprecated and replaced
API.
* clutter/clutter-entry.c: Port Entry to the new size
negotiation API.
* clutter/clutter-group.c: Port Group to the new size
negotiation API; the semantics of the Group actor do not
change.
* clutter/clutter-label.c: Port Label to the new size
negotiation API, and vastly simplify the code.
* clutter/clutter-main.[ch]: Add API for executing a
relayout when needed.
* clutter/clutter-private.h: Add new Stage private API.
* clutter/clutter-rectangle.c: Update the get_abs_opacity()
call to get_paint_opacity().
* clutter/clutter-stage.c:
(clutter_stage_get_preferred_width),
(clutter_stage_get_preferred_height),
(clutter_stage_allocate),
(clutter_stage_class_init): Port Stage to the new size
negotiation API.
* clutter/clutter-texture.c: Port Texture to the new size
negotiation API.
* clutter/clutter-types.h: Add ClutterRequestMode enumeration.
* clutter/x11/clutter-stage-x11.c: Port the X11 stage
implementation to the new size negotiation API.
* tests/Makefile.am: Add the layout manager test case.
* tests/test-opacity.c: Update.
* tests/test-project.c: Update.
* tests/test-layout.c: Test case for a layout manager implemented
using the new size negotiation API; the layout manager handles
both transformed and untransformed children.
2008-06-10 17:07:52 +00:00
|
|
|
klass->fullscreen = clutter_stage_real_fullscreen;
|
2009-05-07 10:20:19 +00:00
|
|
|
klass->activate = clutter_stage_real_activate;
|
|
|
|
klass->deactivate = clutter_stage_real_deactivate;
|
2010-01-12 15:44:28 +00:00
|
|
|
klass->delete_event = clutter_stage_real_delete_event;
|
2008-06-10 Emmanuele Bassi <ebassi@openedhand.com>
Bug #815 - Split up request, allocation, and paint box
* clutter/clutter-actor.[ch]: Rework the size allocation,
request and paint area. Now ::request_coords() is called
::allocate(), and ::query_coords() has been split into
::get_preferred_width() and ::get_preferred_height(). See
the documentation and the layout test on how to implement
a container and layout manager with the new API. (#915,
based on a patch by Havoc Pennington, Lucas Rocha and Johan
Bilien)
* clutter/clutter-clone-texture.c: Port CloneTexture to
the new size negotiation API; it just means forwarding
the requests to the parent texture.
* clutter/clutter-deprecated.h: Add deprecated and replaced
API.
* clutter/clutter-entry.c: Port Entry to the new size
negotiation API.
* clutter/clutter-group.c: Port Group to the new size
negotiation API; the semantics of the Group actor do not
change.
* clutter/clutter-label.c: Port Label to the new size
negotiation API, and vastly simplify the code.
* clutter/clutter-main.[ch]: Add API for executing a
relayout when needed.
* clutter/clutter-private.h: Add new Stage private API.
* clutter/clutter-rectangle.c: Update the get_abs_opacity()
call to get_paint_opacity().
* clutter/clutter-stage.c:
(clutter_stage_get_preferred_width),
(clutter_stage_get_preferred_height),
(clutter_stage_allocate),
(clutter_stage_class_init): Port Stage to the new size
negotiation API.
* clutter/clutter-texture.c: Port Texture to the new size
negotiation API.
* clutter/clutter-types.h: Add ClutterRequestMode enumeration.
* clutter/x11/clutter-stage-x11.c: Port the X11 stage
implementation to the new size negotiation API.
* tests/Makefile.am: Add the layout manager test case.
* tests/test-opacity.c: Update.
* tests/test-project.c: Update.
* tests/test-layout.c: Test case for a layout manager implemented
using the new size negotiation API; the layout manager handles
both transformed and untransformed children.
2008-06-10 17:07:52 +00:00
|
|
|
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
g_type_class_add_private (gobject_class, sizeof (ClutterStagePrivate));
|
2006-05-29 08:59:36 +00:00
|
|
|
}
|
|
|
|
|
2010-02-26 18:36:38 +00:00
|
|
|
static void
|
|
|
|
clutter_stage_notify_min_size (ClutterStage *self)
|
|
|
|
{
|
|
|
|
self->priv->min_size_changed = TRUE;
|
|
|
|
}
|
|
|
|
|
2006-05-29 08:59:36 +00:00
|
|
|
static void
|
|
|
|
clutter_stage_init (ClutterStage *self)
|
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv;
|
2008-04-04 15:02:11 +00:00
|
|
|
ClutterBackend *backend;
|
2010-09-07 12:10:55 +00:00
|
|
|
ClutterGeometry geom;
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
|
|
|
|
/* a stage is a top-level object */
|
2010-07-21 15:10:46 +00:00
|
|
|
CLUTTER_SET_PRIVATE_FLAGS (self, CLUTTER_IS_TOPLEVEL);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
self->priv = priv = CLUTTER_STAGE_GET_PRIVATE (self);
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2008-04-04 15:02:11 +00:00
|
|
|
CLUTTER_NOTE (BACKEND, "Creating stage from the default backend");
|
|
|
|
backend = clutter_get_default_backend ();
|
|
|
|
priv->impl = _clutter_backend_create_stage (backend, self, NULL);
|
|
|
|
if (!priv->impl)
|
|
|
|
{
|
|
|
|
g_warning ("Unable to create a new stage, falling back to the "
|
|
|
|
"default stage.");
|
2009-08-13 11:34:07 +00:00
|
|
|
priv->impl = _clutter_stage_get_default_window ();
|
2008-04-04 15:02:11 +00:00
|
|
|
|
|
|
|
/* at this point we must have a default stage, or we're screwed */
|
|
|
|
g_assert (priv->impl != NULL);
|
|
|
|
}
|
2009-05-08 16:17:48 +00:00
|
|
|
|
2009-06-06 23:10:41 +00:00
|
|
|
priv->event_queue = g_queue_new ();
|
|
|
|
|
2009-07-14 12:47:35 +00:00
|
|
|
priv->is_fullscreen = FALSE;
|
|
|
|
priv->is_user_resizable = FALSE;
|
|
|
|
priv->is_cursor_visible = TRUE;
|
|
|
|
priv->use_fog = FALSE;
|
|
|
|
priv->throttle_motion_events = TRUE;
|
2010-02-26 18:36:38 +00:00
|
|
|
priv->min_size_changed = FALSE;
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2008-11-17 14:21:49 +00:00
|
|
|
priv->color = default_stage_color;
|
2007-05-31 17:11:09 +00:00
|
|
|
|
2009-01-20 16:20:54 +00:00
|
|
|
priv->perspective.fovy = 60.0; /* 60 Degrees */
|
|
|
|
priv->perspective.aspect = 1.0;
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
priv->perspective.z_near = 0.1;
|
|
|
|
priv->perspective.z_far = 100.0;
|
2007-06-01 11:30:52 +00:00
|
|
|
|
2010-09-07 12:10:55 +00:00
|
|
|
cogl_matrix_init_identity (&priv->projection);
|
|
|
|
cogl_matrix_perspective (&priv->projection,
|
|
|
|
priv->perspective.fovy,
|
|
|
|
priv->perspective.aspect,
|
|
|
|
priv->perspective.z_near,
|
|
|
|
priv->perspective.z_far);
|
|
|
|
|
2007-11-21 11:55:26 +00:00
|
|
|
/* depth cueing */
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
priv->fog.z_near = 1.0;
|
|
|
|
priv->fog.z_far = 2.0;
|
2007-11-21 11:55:26 +00:00
|
|
|
|
2010-09-07 19:08:00 +00:00
|
|
|
priv->relayout_pending = TRUE;
|
|
|
|
|
2007-11-15 17:35:47 +00:00
|
|
|
clutter_actor_set_reactive (CLUTTER_ACTOR (self), TRUE);
|
2009-12-03 20:47:48 +00:00
|
|
|
clutter_stage_set_title (self, g_get_prgname ());
|
2007-10-02 14:03:36 +00:00
|
|
|
clutter_stage_set_key_focus (self, NULL);
|
2010-02-26 18:36:38 +00:00
|
|
|
|
|
|
|
g_signal_connect (self, "notify::min-width",
|
|
|
|
G_CALLBACK (clutter_stage_notify_min_size), NULL);
|
|
|
|
g_signal_connect (self, "notify::min-height",
|
|
|
|
G_CALLBACK (clutter_stage_notify_min_size), NULL);
|
2010-09-07 12:10:55 +00:00
|
|
|
|
|
|
|
_clutter_stage_window_get_geometry (priv->impl, &geom);
|
|
|
|
_clutter_stage_set_viewport (self, 0, 0, geom.width, geom.height);
|
2010-09-10 23:29:05 +00:00
|
|
|
|
2010-10-27 17:02:47 +00:00
|
|
|
_clutter_stage_set_pick_buffer_valid (self, FALSE, CLUTTER_PICK_ALL);
|
2010-09-10 23:29:05 +00:00
|
|
|
_clutter_stage_reset_picks_per_frame_counter (self);
|
2010-09-07 17:04:19 +00:00
|
|
|
|
|
|
|
priv->paint_volume_stack =
|
|
|
|
g_array_new (FALSE, FALSE, sizeof (ClutterPaintVolume));
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_stage_get_default:
|
|
|
|
*
|
2008-04-04 15:02:11 +00:00
|
|
|
* Returns the main stage. The default #ClutterStage is a singleton,
|
|
|
|
* so the stage will be created the first time this function is
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
* called (typically, inside clutter_init()); all the subsequent
|
2008-04-04 15:02:11 +00:00
|
|
|
* calls to clutter_stage_get_default() will return the same instance.
|
|
|
|
*
|
|
|
|
* Clutter guarantess the existence of the default stage.
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
*
|
2009-02-17 00:25:20 +00:00
|
|
|
* Return value: (transfer none): the main #ClutterStage. You should never
|
2007-03-22 18:21:59 +00:00
|
|
|
* destroy or unref the returned actor.
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
*/
|
2006-06-13 13:17:45 +00:00
|
|
|
ClutterActor *
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
clutter_stage_get_default (void)
|
|
|
|
{
|
2008-03-28 22:50:55 +00:00
|
|
|
ClutterStageManager *stage_manager = clutter_stage_manager_get_default ();
|
2008-04-04 15:02:11 +00:00
|
|
|
ClutterStage *stage;
|
|
|
|
|
|
|
|
stage = clutter_stage_manager_get_default_stage (stage_manager);
|
|
|
|
if (G_UNLIKELY (stage == NULL))
|
2009-12-03 21:07:45 +00:00
|
|
|
{
|
|
|
|
/* This will take care of automatically adding the stage to the
|
|
|
|
* stage manager and setting it as the default. Its floating
|
|
|
|
* reference will be claimed by the stage manager.
|
|
|
|
*/
|
|
|
|
stage = g_object_new (CLUTTER_TYPE_STAGE, NULL);
|
2010-02-18 16:58:29 +00:00
|
|
|
_clutter_stage_manager_set_default_stage (stage_manager, stage);
|
2009-12-03 21:07:45 +00:00
|
|
|
|
|
|
|
/* the default stage is realized by default */
|
|
|
|
clutter_actor_realize (CLUTTER_ACTOR (stage));
|
|
|
|
}
|
2007-03-22 18:21:59 +00:00
|
|
|
|
2008-04-04 15:02:11 +00:00
|
|
|
return CLUTTER_ACTOR (stage);
|
2006-05-29 08:59:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
* clutter_stage_set_color:
|
2006-05-29 08:59:36 +00:00
|
|
|
* @stage: A #ClutterStage
|
|
|
|
* @color: A #ClutterColor
|
2007-10-12 08:17:00 +00:00
|
|
|
*
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
* Sets the stage color.
|
|
|
|
*/
|
2006-05-29 08:59:36 +00:00
|
|
|
void
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
clutter_stage_set_color (ClutterStage *stage,
|
|
|
|
const ClutterColor *color)
|
2006-05-29 08:59:36 +00:00
|
|
|
{
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
ClutterStagePrivate *priv;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
|
|
|
g_return_if_fail (color != NULL);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
priv = stage->priv;
|
2008-04-04 15:02:11 +00:00
|
|
|
|
|
|
|
priv->color = *color;
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2010-02-09 19:34:32 +00:00
|
|
|
clutter_actor_queue_redraw (CLUTTER_ACTOR (stage));
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
g_object_notify (G_OBJECT (stage), "color");
|
2006-05-29 08:59:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
* clutter_stage_get_color:
|
2006-05-29 08:59:36 +00:00
|
|
|
* @stage: A #ClutterStage
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
* @color: return location for a #ClutterColor
|
2007-10-12 08:17:00 +00:00
|
|
|
*
|
2006-06-21 23:19:59 +00:00
|
|
|
* Retrieves the stage color.
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_stage_get_color (ClutterStage *stage,
|
|
|
|
ClutterColor *color)
|
2006-05-29 08:59:36 +00:00
|
|
|
{
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
ClutterStagePrivate *priv;
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
|
|
|
g_return_if_fail (color != NULL);
|
|
|
|
|
|
|
|
priv = stage->priv;
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2008-04-04 15:02:11 +00:00
|
|
|
*color = priv->color;
|
2006-05-29 08:59:36 +00:00
|
|
|
}
|
|
|
|
|
2007-05-25 10:56:09 +00:00
|
|
|
/**
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
* clutter_stage_set_perspective:
|
2007-05-25 10:56:09 +00:00
|
|
|
* @stage: A #ClutterStage
|
|
|
|
* @perspective: A #ClutterPerspective
|
2007-10-12 08:17:00 +00:00
|
|
|
*
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
* Sets the stage perspective.
|
|
|
|
*/
|
2007-05-25 10:56:09 +00:00
|
|
|
void
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
clutter_stage_set_perspective (ClutterStage *stage,
|
|
|
|
ClutterPerspective *perspective)
|
2007-05-25 10:56:09 +00:00
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
2007-11-21 11:55:26 +00:00
|
|
|
g_return_if_fail (perspective != NULL);
|
2009-04-15 16:27:04 +00:00
|
|
|
g_return_if_fail (perspective->z_far - perspective->z_near != 0);
|
2007-05-25 10:56:09 +00:00
|
|
|
|
|
|
|
priv = stage->priv;
|
|
|
|
|
2010-09-07 12:10:55 +00:00
|
|
|
if (priv->perspective.fovy == perspective->fovy &&
|
|
|
|
priv->perspective.aspect == perspective->aspect &&
|
|
|
|
priv->perspective.z_near == perspective->z_near &&
|
|
|
|
priv->perspective.z_far == perspective->z_far)
|
|
|
|
return;
|
|
|
|
|
2007-11-21 11:55:26 +00:00
|
|
|
priv->perspective = *perspective;
|
|
|
|
|
2010-09-07 12:10:55 +00:00
|
|
|
cogl_matrix_init_identity (&priv->projection);
|
|
|
|
cogl_matrix_perspective (&priv->projection,
|
|
|
|
priv->perspective.fovy,
|
|
|
|
priv->perspective.aspect,
|
|
|
|
priv->perspective.z_near,
|
|
|
|
priv->perspective.z_far);
|
|
|
|
|
|
|
|
priv->dirty_projection = TRUE;
|
|
|
|
clutter_actor_queue_redraw (CLUTTER_ACTOR (stage));
|
2007-05-25 10:56:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
* clutter_stage_get_perspective:
|
2007-05-25 10:56:09 +00:00
|
|
|
* @stage: A #ClutterStage
|
2010-09-08 16:04:21 +00:00
|
|
|
* @perspective: (out caller-allocates) (allow-none): return location for a
|
|
|
|
* #ClutterPerspective
|
2007-10-12 08:17:00 +00:00
|
|
|
*
|
2007-05-25 10:56:09 +00:00
|
|
|
* Retrieves the stage perspective.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_stage_get_perspective (ClutterStage *stage,
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
ClutterPerspective *perspective)
|
2007-05-25 10:56:09 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
g_return_if_fail (perspective != NULL);
|
2007-05-25 10:56:09 +00:00
|
|
|
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
*perspective = stage->priv->perspective;
|
2007-05-25 10:56:09 +00:00
|
|
|
}
|
|
|
|
|
2010-09-07 12:10:55 +00:00
|
|
|
/*
|
|
|
|
* clutter_stage_get_projection_matrix:
|
|
|
|
* @stage: A #ClutterStage
|
|
|
|
* @projection: return location for a #CoglMatrix representing the
|
|
|
|
* perspective projection applied to actors on the given
|
|
|
|
* @stage.
|
|
|
|
*
|
|
|
|
* Retrieves the @stage's projection matrix. This is derived from the
|
|
|
|
* current perspective set using clutter_stage_set_perspective().
|
|
|
|
*
|
|
|
|
* Since: 1.6
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
_clutter_stage_get_projection_matrix (ClutterStage *stage,
|
|
|
|
CoglMatrix *projection)
|
|
|
|
{
|
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
|
|
|
g_return_if_fail (projection != NULL);
|
|
|
|
|
|
|
|
*projection = stage->priv->projection;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This simply provides a simple mechanism for us to ensure that
|
|
|
|
* the projection matrix gets re-asserted before painting.
|
|
|
|
*
|
|
|
|
* This is used when switching between multiple stages */
|
|
|
|
void
|
|
|
|
_clutter_stage_dirty_projection (ClutterStage *stage)
|
|
|
|
{
|
|
|
|
stage->priv->dirty_projection = TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* clutter_stage_set_viewport:
|
|
|
|
* @stage: A #ClutterStage
|
|
|
|
* @x: The X postition to render the stage at, in window coordinates
|
|
|
|
* @y: The Y position to render the stage at, in window coordinates
|
|
|
|
* @width: The width to render the stage at, in window coordinates
|
|
|
|
* @height: The height to render the stage at, in window coordinates
|
|
|
|
*
|
|
|
|
* Sets the stage viewport. The viewport defines a final scale and
|
|
|
|
* translation of your rendered stage and actors. This lets you render
|
|
|
|
* your stage into a subregion of the stage window or you could use it to
|
|
|
|
* pan a subregion of the stage if your stage window is smaller then
|
|
|
|
* the stage. (XXX: currently this isn't possible)
|
|
|
|
*
|
|
|
|
* Unlike a scale and translation done using the modelview matrix this
|
|
|
|
* is done after everything has had perspective projection applied, so
|
|
|
|
* for example if you were to pan across a subregion of the stage using
|
|
|
|
* the viewport then you would not see a change in perspective for the
|
|
|
|
* actors on the stage.
|
|
|
|
*
|
|
|
|
* Normally the stage viewport will automatically track the size of the
|
|
|
|
* stage window with no offset so the stage will fill your window. This
|
|
|
|
* behaviour can be changed with the "viewport-mimics-window" property
|
|
|
|
* which will automatically be set to FALSE if you use this API. If
|
|
|
|
* you want to revert to the original behaviour then you should set
|
|
|
|
* this property back to %TRUE using
|
|
|
|
* clutter_stage_set_viewport_mimics_window().
|
|
|
|
* (XXX: If we were to make this API public then we might want to do
|
|
|
|
* add that property.)
|
|
|
|
*
|
|
|
|
* Since: 1.6
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
_clutter_stage_set_viewport (ClutterStage *stage,
|
|
|
|
int x,
|
|
|
|
int y,
|
|
|
|
int width,
|
|
|
|
int height)
|
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
|
|
|
|
|
|
|
priv = stage->priv;
|
|
|
|
|
|
|
|
|
|
|
|
if (x == priv->viewport[0] &&
|
|
|
|
y == priv->viewport[1] &&
|
|
|
|
width == priv->viewport[2] &&
|
|
|
|
height == priv->viewport[3])
|
|
|
|
return;
|
|
|
|
|
|
|
|
priv->viewport[0] = x;
|
|
|
|
priv->viewport[1] = y;
|
|
|
|
priv->viewport[2] = width;
|
|
|
|
priv->viewport[3] = height;
|
|
|
|
|
|
|
|
priv->dirty_viewport = TRUE;
|
|
|
|
|
2010-09-07 22:25:18 +00:00
|
|
|
queue_full_redraw (stage);
|
2010-09-07 12:10:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* This simply provides a simple mechanism for us to ensure that
|
|
|
|
* the viewport gets re-asserted before next painting.
|
|
|
|
*
|
|
|
|
* This is used when switching between multiple stages */
|
|
|
|
void
|
|
|
|
_clutter_stage_dirty_viewport (ClutterStage *stage)
|
|
|
|
{
|
|
|
|
stage->priv->dirty_viewport = TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* clutter_stage_get_viewport:
|
|
|
|
* @stage: A #ClutterStage
|
|
|
|
* @x: A location for the X position where the stage is rendered,
|
|
|
|
* in window coordinates.
|
|
|
|
* @y: A location for the Y position where the stage is rendered,
|
|
|
|
* in window coordinates.
|
|
|
|
* @width: A location for the width the stage is rendered at,
|
|
|
|
* in window coordinates.
|
|
|
|
* @height: A location for the height the stage is rendered at,
|
|
|
|
* in window coordinates.
|
|
|
|
*
|
|
|
|
* Returns the viewport offset and size set using
|
|
|
|
* clutter_stage_set_viewport() or if the "viewport-mimics-window" property
|
|
|
|
* is TRUE then @x and @y will be set to 0 and @width and @height will equal
|
|
|
|
* the width if the stage window.
|
|
|
|
*
|
|
|
|
* Since: 1.6
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
_clutter_stage_get_viewport (ClutterStage *stage,
|
|
|
|
int *x,
|
|
|
|
int *y,
|
|
|
|
int *width,
|
|
|
|
int *height)
|
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
|
|
|
|
|
|
|
priv = stage->priv;
|
|
|
|
|
|
|
|
*x = priv->viewport[0];
|
|
|
|
*y = priv->viewport[1];
|
|
|
|
*width = priv->viewport[2];
|
|
|
|
*height = priv->viewport[3];
|
|
|
|
}
|
|
|
|
|
2007-03-22 18:21:59 +00:00
|
|
|
/**
|
2009-06-09 13:05:03 +00:00
|
|
|
* clutter_stage_set_fullscreen:
|
2007-03-22 18:21:59 +00:00
|
|
|
* @stage: a #ClutterStage
|
2009-06-09 13:47:36 +00:00
|
|
|
* @fullscreen: %TRUE to to set the stage fullscreen
|
2007-03-22 18:21:59 +00:00
|
|
|
*
|
2009-06-09 13:05:03 +00:00
|
|
|
* Asks to place the stage window in the fullscreen or unfullscreen
|
|
|
|
* states.
|
|
|
|
*
|
|
|
|
( Note that you shouldn't assume the window is definitely full screen
|
|
|
|
* afterward, because other entities (e.g. the user or window manager)
|
|
|
|
* could unfullscreen it again, and not all window managers honor
|
|
|
|
* requests to fullscreen windows.
|
|
|
|
*
|
|
|
|
* If you want to receive notification of the fullscreen state you
|
|
|
|
* should either use the #ClutterStage::fullscreen and
|
|
|
|
* #ClutterStage::unfullscreen signals, or use the notify signal
|
|
|
|
* for the #ClutterStage:fullscreen-set property
|
|
|
|
*
|
|
|
|
* Since: 1.0
|
2007-03-22 18:21:59 +00:00
|
|
|
*/
|
|
|
|
void
|
2009-06-09 13:05:03 +00:00
|
|
|
clutter_stage_set_fullscreen (ClutterStage *stage,
|
|
|
|
gboolean fullscreen)
|
2006-05-29 08:59:36 +00:00
|
|
|
{
|
2007-03-22 18:21:59 +00:00
|
|
|
ClutterStagePrivate *priv;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
|
|
|
|
|
|
|
priv = stage->priv;
|
2009-06-09 13:05:03 +00:00
|
|
|
|
|
|
|
if (priv->is_fullscreen != fullscreen)
|
2007-03-22 18:21:59 +00:00
|
|
|
{
|
2008-04-04 15:02:11 +00:00
|
|
|
ClutterStageWindow *impl = CLUTTER_STAGE_WINDOW (priv->impl);
|
|
|
|
ClutterStageWindowIface *iface;
|
|
|
|
|
|
|
|
iface = CLUTTER_STAGE_WINDOW_GET_IFACE (impl);
|
|
|
|
|
2007-10-12 08:17:00 +00:00
|
|
|
/* Only set if backend implements.
|
2009-06-09 13:05:03 +00:00
|
|
|
*
|
2007-10-08 16:18:33 +00:00
|
|
|
* Also see clutter_stage_event() for setting priv->is_fullscreen
|
2007-10-12 08:17:00 +00:00
|
|
|
* on state change event.
|
2009-06-09 13:05:03 +00:00
|
|
|
*/
|
2008-04-04 15:02:11 +00:00
|
|
|
if (iface->set_fullscreen)
|
2009-06-09 13:05:03 +00:00
|
|
|
iface->set_fullscreen (impl, fullscreen);
|
2007-03-22 18:21:59 +00:00
|
|
|
}
|
2010-09-07 12:10:55 +00:00
|
|
|
|
|
|
|
/* If the backend did fullscreen the stage window then we need to resize
|
|
|
|
* the stage and update its viewport so we queue a relayout. Note: if the
|
|
|
|
* fullscreen request is handled asynchronously we can't rely on this
|
|
|
|
* queue_relayout to update the viewport, but for example the X backend
|
|
|
|
* will recieve a ConfigureNotify after a successful resize which is how
|
|
|
|
* we ensure the viewport is updated on X.
|
|
|
|
*/
|
|
|
|
clutter_actor_queue_relayout (CLUTTER_ACTOR (stage));
|
2006-05-29 08:59:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-06-09 13:05:03 +00:00
|
|
|
* clutter_stage_get_fullscreen:
|
2007-03-22 18:21:59 +00:00
|
|
|
* @stage: a #ClutterStage
|
2006-05-29 08:59:36 +00:00
|
|
|
*
|
2009-06-09 13:05:03 +00:00
|
|
|
* Retrieves whether the stage is full screen or not
|
|
|
|
*
|
|
|
|
* Return value: %TRUE if the stage is full screen
|
|
|
|
*
|
|
|
|
* Since: 1.0
|
2007-03-22 18:21:59 +00:00
|
|
|
*/
|
2009-06-09 13:05:03 +00:00
|
|
|
gboolean
|
|
|
|
clutter_stage_get_fullscreen (ClutterStage *stage)
|
2006-05-29 08:59:36 +00:00
|
|
|
{
|
2009-06-09 13:05:03 +00:00
|
|
|
g_return_val_if_fail (CLUTTER_IS_STAGE (stage), FALSE);
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
|
2009-06-09 13:05:03 +00:00
|
|
|
return stage->priv->is_fullscreen;
|
2007-03-22 18:21:59 +00:00
|
|
|
}
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
|
2007-07-26 20:08:09 +00:00
|
|
|
/**
|
2007-07-31 17:01:52 +00:00
|
|
|
* clutter_stage_set_user_resizable:
|
2007-07-26 20:08:09 +00:00
|
|
|
* @stage: a #ClutterStage
|
2008-02-15 15:18:02 +00:00
|
|
|
* @resizable: whether the stage should be user resizable.
|
2007-07-26 20:08:09 +00:00
|
|
|
*
|
2008-02-15 15:18:02 +00:00
|
|
|
* Sets if the stage is resizable by user interaction (e.g. via
|
2007-07-26 20:08:09 +00:00
|
|
|
* window manager controls)
|
2007-07-31 17:01:52 +00:00
|
|
|
*
|
|
|
|
* Since: 0.4
|
2007-07-26 20:08:09 +00:00
|
|
|
*/
|
|
|
|
void
|
2007-07-31 17:01:52 +00:00
|
|
|
clutter_stage_set_user_resizable (ClutterStage *stage,
|
|
|
|
gboolean resizable)
|
2007-07-26 20:08:09 +00:00
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
|
|
|
|
|
|
|
priv = stage->priv;
|
|
|
|
|
|
|
|
if (clutter_feature_available (CLUTTER_FEATURE_STAGE_USER_RESIZE)
|
2008-04-04 15:02:11 +00:00
|
|
|
&& priv->is_user_resizable != resizable)
|
2007-07-26 20:08:09 +00:00
|
|
|
{
|
2008-04-04 15:02:11 +00:00
|
|
|
ClutterStageWindow *impl = CLUTTER_STAGE_WINDOW (priv->impl);
|
|
|
|
ClutterStageWindowIface *iface;
|
2007-07-26 20:08:09 +00:00
|
|
|
|
2008-04-04 15:02:11 +00:00
|
|
|
iface = CLUTTER_STAGE_WINDOW_GET_IFACE (impl);
|
|
|
|
if (iface->set_user_resizable)
|
|
|
|
{
|
|
|
|
priv->is_user_resizable = resizable;
|
|
|
|
|
|
|
|
iface->set_user_resizable (impl, resizable);
|
2007-07-26 20:08:09 +00:00
|
|
|
|
2008-04-04 15:02:11 +00:00
|
|
|
g_object_notify (G_OBJECT (stage), "user-resizable");
|
|
|
|
}
|
2007-07-26 20:08:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-07-31 17:01:52 +00:00
|
|
|
/**
|
|
|
|
* clutter_stage_get_user_resizable:
|
|
|
|
* @stage: a #ClutterStage
|
|
|
|
*
|
|
|
|
* Retrieves the value set with clutter_stage_set_user_resizable().
|
|
|
|
*
|
2008-02-15 15:18:02 +00:00
|
|
|
* Return value: %TRUE if the stage is resizable by the user.
|
2007-07-31 17:01:52 +00:00
|
|
|
*
|
|
|
|
* Since: 0.4
|
|
|
|
*/
|
|
|
|
gboolean
|
|
|
|
clutter_stage_get_user_resizable (ClutterStage *stage)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_STAGE (stage), FALSE);
|
|
|
|
|
|
|
|
return stage->priv->is_user_resizable;
|
|
|
|
}
|
|
|
|
|
2007-03-22 18:21:59 +00:00
|
|
|
/**
|
|
|
|
* clutter_stage_show_cursor:
|
|
|
|
* @stage: a #ClutterStage
|
|
|
|
*
|
|
|
|
* Shows the cursor on the stage window
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_stage_show_cursor (ClutterStage *stage)
|
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv;
|
2006-06-05 Emmanuele Bassi <ebassi@openedhand.com>
* clutter-color.h:
* clutter-color.c: Reimplement ClutterColor as a boxed type;
add convenience API for color handling, like: add, subtract,
shade, HSL color-space conversion, packing and unpacking.
* clutter-private.h: Update ClutterMainContext, and export the
main context pointer here.
* clutter-rectangle.h:
* clutter-rectangle.c: Update the color-related code; make
clutter_rectangle_new() and empty constructor and provide
clutter_rectangle_new_with_color(); provide color setter
and getter API.
* clutter-label.h:
* clutter-label.c: Rename the "font" property to "font-name";
update the color-related code to the new ClutterColor object;
rename clutter_label_new() to clutter_label_new_with_text(),
and add setters and getters for the properties.
* clutter-marshal.list: Add VOID:OBJECT and VOID:BOXED marshallers
generators.
* clutter-stage.h:
* clutter-stage.c: Rework the API: provide a default constructor
for a singleton object, named clutter_stage_get_default(), which
supercedes the clutter_stage() function in clutter-main; provide
new events: button-press-event, button-release-event,
key-press-event and key-release-event; update the color-related
code;
(clutter_stage_snapshot): Allow negative width and height when
taking a snapshot (meaning: use full width/height).
(clutter_stage_get_element_at_pos): Rename clutter_stage_pick().
* clutter-element.c (clutter_element_paint): Clean up the
stage and color related code.
* clutter-event.h:
* clutter-event.c: Add generic ClutterAnyEvent type; add
clutter_event_new(), clutter_event_copy() and clutter_event_free();
make ClutterEvent a boxed type.
* clutter-main.h:
* clutter-main.c: Remove clutter_stage(); add clutter_main_quit(),
for cleanly quitting from clutter_main(); add multiple mainloops
support; allocate the ClutterCntx instead of adding it to the
stack; re-work the ClutterEvent dispatching.
* clutter-group.c (clutter_group_add), (clutter_group_remove): Keep
a reference on the element when added to a ClutterGroup.
* examples/rects.py
* examples/test.c:
* examples/test-text.c:
* examples/video-cube.c:
* examples/super-oh.c:
* examples/test-video.c: Update.
2006-06-05 13:38:31 +00:00
|
|
|
|
2007-03-22 18:21:59 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2007-03-22 18:21:59 +00:00
|
|
|
priv = stage->priv;
|
|
|
|
if (!priv->is_cursor_visible)
|
2006-06-08 21:28:05 +00:00
|
|
|
{
|
2008-04-04 15:02:11 +00:00
|
|
|
ClutterStageWindow *impl = CLUTTER_STAGE_WINDOW (priv->impl);
|
|
|
|
ClutterStageWindowIface *iface;
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2008-04-04 15:02:11 +00:00
|
|
|
iface = CLUTTER_STAGE_WINDOW_GET_IFACE (impl);
|
|
|
|
if (iface->set_cursor_visible)
|
|
|
|
{
|
|
|
|
priv->is_cursor_visible = TRUE;
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2008-04-04 15:02:11 +00:00
|
|
|
iface->set_cursor_visible (impl, TRUE);
|
|
|
|
|
|
|
|
g_object_notify (G_OBJECT (stage), "cursor-visible");
|
|
|
|
}
|
2006-06-08 21:28:05 +00:00
|
|
|
}
|
2006-05-29 08:59:36 +00:00
|
|
|
}
|
|
|
|
|
2007-03-22 18:21:59 +00:00
|
|
|
/**
|
|
|
|
* clutter_stage_hide_cursor:
|
2007-07-24 17:34:06 +00:00
|
|
|
* @stage: a #ClutterStage
|
|
|
|
*
|
|
|
|
* Makes the cursor invisible on the stage window
|
2007-03-22 18:21:59 +00:00
|
|
|
*
|
2007-07-24 17:34:06 +00:00
|
|
|
* Since: 0.4
|
2007-03-22 18:21:59 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_stage_hide_cursor (ClutterStage *stage)
|
2007-01-23 20:29:11 +00:00
|
|
|
{
|
2007-03-22 18:21:59 +00:00
|
|
|
ClutterStagePrivate *priv;
|
2007-01-23 20:29:11 +00:00
|
|
|
|
2007-03-22 18:21:59 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
2007-01-23 20:29:11 +00:00
|
|
|
|
2007-03-22 18:21:59 +00:00
|
|
|
priv = stage->priv;
|
|
|
|
if (priv->is_cursor_visible)
|
|
|
|
{
|
2008-04-04 15:02:11 +00:00
|
|
|
ClutterStageWindow *impl = CLUTTER_STAGE_WINDOW (priv->impl);
|
|
|
|
ClutterStageWindowIface *iface;
|
|
|
|
|
|
|
|
iface = CLUTTER_STAGE_WINDOW_GET_IFACE (impl);
|
|
|
|
if (iface->set_cursor_visible)
|
|
|
|
{
|
2008-07-14 08:49:22 +00:00
|
|
|
priv->is_cursor_visible = FALSE;
|
2007-01-23 20:29:11 +00:00
|
|
|
|
2008-04-04 15:02:11 +00:00
|
|
|
iface->set_cursor_visible (impl, FALSE);
|
2007-01-23 20:29:11 +00:00
|
|
|
|
2008-04-04 15:02:11 +00:00
|
|
|
g_object_notify (G_OBJECT (stage), "cursor-visible");
|
|
|
|
}
|
2007-03-22 18:21:59 +00:00
|
|
|
}
|
|
|
|
}
|
2007-01-23 20:29:11 +00:00
|
|
|
|
2007-03-22 18:21:59 +00:00
|
|
|
/**
|
2008-04-25 13:37:36 +00:00
|
|
|
* clutter_stage_read_pixels:
|
2007-03-22 18:21:59 +00:00
|
|
|
* @stage: A #ClutterStage
|
|
|
|
* @x: x coordinate of the first pixel that is read from stage
|
|
|
|
* @y: y coordinate of the first pixel that is read from stage
|
|
|
|
* @width: Width dimention of pixels to be read, or -1 for the
|
|
|
|
* entire stage width
|
|
|
|
* @height: Height dimention of pixels to be read, or -1 for the
|
|
|
|
* entire stage height
|
|
|
|
*
|
2008-04-25 13:37:36 +00:00
|
|
|
* Makes a screenshot of the stage in RGBA 8bit data, returns a
|
2008-06-23 10:06:02 +00:00
|
|
|
* linear buffer with @width * 4 as rowstride.
|
2007-03-22 18:21:59 +00:00
|
|
|
*
|
2008-07-14 08:49:22 +00:00
|
|
|
* The alpha data contained in the returned buffer is driver-dependent,
|
2008-07-01 14:08:24 +00:00
|
|
|
* and not guaranteed to hold any sensible value.
|
|
|
|
*
|
2008-04-25 13:37:36 +00:00
|
|
|
* Return value: a pointer to newly allocated memory with the buffer
|
2008-06-23 10:06:02 +00:00
|
|
|
* or %NULL if the read failed. Use g_free() on the returned data
|
|
|
|
* to release the resources it has allocated.
|
2008-04-04 15:02:11 +00:00
|
|
|
*/
|
2008-04-25 13:37:36 +00:00
|
|
|
guchar *
|
|
|
|
clutter_stage_read_pixels (ClutterStage *stage,
|
|
|
|
gint x,
|
|
|
|
gint y,
|
|
|
|
gint width,
|
|
|
|
gint height)
|
2007-03-22 18:21:59 +00:00
|
|
|
{
|
2008-04-25 13:37:36 +00:00
|
|
|
guchar *pixels;
|
|
|
|
GLint viewport[4];
|
|
|
|
gint rowstride;
|
2009-06-17 13:30:44 +00:00
|
|
|
gint stage_width, stage_height;
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2007-03-22 18:21:59 +00:00
|
|
|
g_return_val_if_fail (CLUTTER_IS_STAGE (stage), NULL);
|
2008-04-25 13:37:36 +00:00
|
|
|
|
|
|
|
/* according to glReadPixels documentation pixels outside the viewport are
|
|
|
|
* undefined, but no error should be provoked, thus this is probably unnneed.
|
|
|
|
*/
|
2007-03-22 18:21:59 +00:00
|
|
|
g_return_val_if_fail (x >= 0 && y >= 0, NULL);
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
/* Force a redraw of the stage before reading back pixels */
|
|
|
|
clutter_stage_ensure_current (stage);
|
2009-06-10 13:52:53 +00:00
|
|
|
clutter_actor_paint (CLUTTER_ACTOR (stage));
|
2008-04-25 13:37:36 +00:00
|
|
|
|
|
|
|
glGetIntegerv (GL_VIEWPORT, viewport);
|
2008-06-23 10:06:02 +00:00
|
|
|
stage_width = viewport[2];
|
|
|
|
stage_height = viewport[3];
|
2008-04-25 13:37:36 +00:00
|
|
|
|
2008-06-23 10:06:02 +00:00
|
|
|
if (width < 0 || width > stage_width)
|
|
|
|
width = stage_width;
|
|
|
|
|
|
|
|
if (height < 0 || height > stage_height)
|
|
|
|
height = stage_height;
|
|
|
|
|
|
|
|
rowstride = width * 4;
|
|
|
|
|
|
|
|
pixels = g_malloc (height * rowstride);
|
2008-04-04 15:02:11 +00:00
|
|
|
|
2009-06-17 13:30:44 +00:00
|
|
|
cogl_read_pixels (x, y, width, height,
|
|
|
|
COGL_READ_PIXELS_COLOR_BUFFER,
|
|
|
|
COGL_PIXEL_FORMAT_RGBA_8888,
|
|
|
|
pixels);
|
2008-06-23 10:06:02 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
return pixels;
|
2007-03-22 18:21:59 +00:00
|
|
|
}
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2007-03-25 11:47:30 +00:00
|
|
|
/**
|
|
|
|
* clutter_stage_get_actor_at_pos:
|
2007-07-01 16:44:24 +00:00
|
|
|
* @stage: a #ClutterStage
|
2009-04-24 14:05:02 +00:00
|
|
|
* @pick_mode: how the scene graph should be painted
|
2007-07-01 16:44:24 +00:00
|
|
|
* @x: X coordinate to check
|
|
|
|
* @y: Y coordinate to check
|
2007-03-25 11:47:30 +00:00
|
|
|
*
|
2007-07-01 16:44:24 +00:00
|
|
|
* Checks the scene at the coordinates @x and @y and returns a pointer
|
|
|
|
* to the #ClutterActor at those coordinates.
|
2007-03-25 11:47:30 +00:00
|
|
|
*
|
2009-04-24 14:05:02 +00:00
|
|
|
* By using @pick_mode it is possible to control which actors will be
|
|
|
|
* painted and thus available.
|
|
|
|
*
|
|
|
|
* Return value: (transfer none): the actor at the specified coordinates,
|
|
|
|
* if any
|
2007-03-25 11:47:30 +00:00
|
|
|
*/
|
2007-03-22 18:21:59 +00:00
|
|
|
ClutterActor *
|
2009-04-24 14:05:02 +00:00
|
|
|
clutter_stage_get_actor_at_pos (ClutterStage *stage,
|
|
|
|
ClutterPickMode pick_mode,
|
|
|
|
gint x,
|
|
|
|
gint y)
|
2007-03-22 18:21:59 +00:00
|
|
|
{
|
2009-04-24 14:05:02 +00:00
|
|
|
return _clutter_do_pick (stage, x, y, pick_mode);
|
2006-05-29 08:59:36 +00:00
|
|
|
}
|
2007-03-26 23:18:39 +00:00
|
|
|
|
2007-04-25 14:22:24 +00:00
|
|
|
/**
|
|
|
|
* clutter_stage_event:
|
|
|
|
* @stage: a #ClutterStage
|
|
|
|
* @event: a #ClutterEvent
|
|
|
|
*
|
|
|
|
* This function is used to emit an event on the main stage.
|
2008-04-04 15:02:11 +00:00
|
|
|
*
|
2007-04-25 14:22:24 +00:00
|
|
|
* You should rarely need to use this function, except for
|
2008-04-04 15:02:11 +00:00
|
|
|
* synthetised events.
|
2007-04-25 14:22:24 +00:00
|
|
|
*
|
|
|
|
* Return value: the return value from the signal emission
|
|
|
|
*
|
|
|
|
* Since: 0.4
|
|
|
|
*/
|
|
|
|
gboolean
|
|
|
|
clutter_stage_event (ClutterStage *stage,
|
|
|
|
ClutterEvent *event)
|
|
|
|
{
|
2007-10-08 16:18:33 +00:00
|
|
|
ClutterStagePrivate *priv;
|
|
|
|
|
2007-04-25 14:22:24 +00:00
|
|
|
g_return_val_if_fail (CLUTTER_IS_STAGE (stage), FALSE);
|
|
|
|
g_return_val_if_fail (event != NULL, FALSE);
|
|
|
|
|
2007-10-08 16:18:33 +00:00
|
|
|
priv = stage->priv;
|
|
|
|
|
2007-08-24 15:12:52 +00:00
|
|
|
if (event->type == CLUTTER_DELETE)
|
2008-01-18 18:08:37 +00:00
|
|
|
{
|
|
|
|
gboolean retval = FALSE;
|
|
|
|
|
|
|
|
g_signal_emit_by_name (stage, "event", event, &retval);
|
|
|
|
|
2010-01-12 15:44:28 +00:00
|
|
|
if (!retval)
|
|
|
|
g_signal_emit_by_name (stage, "delete-event", event, &retval);
|
|
|
|
|
2008-01-18 18:08:37 +00:00
|
|
|
return retval;
|
|
|
|
}
|
2007-08-24 15:12:52 +00:00
|
|
|
|
|
|
|
if (event->type != CLUTTER_STAGE_STATE)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
/* emit raw event */
|
2007-10-10 13:04:34 +00:00
|
|
|
if (clutter_actor_event (CLUTTER_ACTOR (stage), event, FALSE))
|
2007-10-02 14:03:36 +00:00
|
|
|
return TRUE;
|
2007-08-24 15:12:52 +00:00
|
|
|
|
|
|
|
if (event->stage_state.changed_mask & CLUTTER_STAGE_STATE_FULLSCREEN)
|
|
|
|
{
|
|
|
|
if (event->stage_state.new_state & CLUTTER_STAGE_STATE_FULLSCREEN)
|
2007-10-08 16:18:33 +00:00
|
|
|
{
|
|
|
|
priv->is_fullscreen = TRUE;
|
|
|
|
g_signal_emit (stage, stage_signals[FULLSCREEN], 0);
|
2007-10-10 14:29:29 +00:00
|
|
|
|
2009-06-09 12:48:03 +00:00
|
|
|
g_object_notify (G_OBJECT (stage), "fullscreen-set");
|
2007-10-08 16:18:33 +00:00
|
|
|
}
|
2007-08-24 15:12:52 +00:00
|
|
|
else
|
2007-10-08 16:18:33 +00:00
|
|
|
{
|
|
|
|
priv->is_fullscreen = FALSE;
|
|
|
|
g_signal_emit (stage, stage_signals[UNFULLSCREEN], 0);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2009-06-09 12:48:03 +00:00
|
|
|
g_object_notify (G_OBJECT (stage), "fullscreen-set");
|
2007-10-08 16:18:33 +00:00
|
|
|
}
|
2007-08-24 15:12:52 +00:00
|
|
|
}
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-08-24 15:12:52 +00:00
|
|
|
if (event->stage_state.changed_mask & CLUTTER_STAGE_STATE_ACTIVATED)
|
|
|
|
{
|
|
|
|
if (event->stage_state.new_state & CLUTTER_STAGE_STATE_ACTIVATED)
|
|
|
|
g_signal_emit (stage, stage_signals[ACTIVATE], 0);
|
|
|
|
else
|
|
|
|
g_signal_emit (stage, stage_signals[DEACTIVATE], 0);
|
|
|
|
}
|
2007-04-25 14:22:24 +00:00
|
|
|
|
2007-08-13 20:48:01 +00:00
|
|
|
return TRUE;
|
2007-04-25 14:22:24 +00:00
|
|
|
}
|
|
|
|
|
2007-06-19 09:10:37 +00:00
|
|
|
/**
|
|
|
|
* clutter_stage_set_title
|
|
|
|
* @stage: A #ClutterStage
|
|
|
|
* @title: A utf8 string for the stage windows title.
|
2007-10-12 08:17:00 +00:00
|
|
|
*
|
2007-06-19 09:10:37 +00:00
|
|
|
* Sets the stage title.
|
|
|
|
*
|
2008-12-05 14:08:06 +00:00
|
|
|
* Since: 0.4
|
2007-06-19 09:10:37 +00:00
|
|
|
**/
|
2007-10-12 08:17:00 +00:00
|
|
|
void
|
2007-06-19 09:10:37 +00:00
|
|
|
clutter_stage_set_title (ClutterStage *stage,
|
|
|
|
const gchar *title)
|
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv;
|
2008-04-04 15:02:11 +00:00
|
|
|
ClutterStageWindow *impl;
|
2007-06-19 09:10:37 +00:00
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
|
|
|
|
|
|
|
priv = stage->priv;
|
|
|
|
|
|
|
|
g_free (priv->title);
|
|
|
|
priv->title = g_strdup (title);
|
|
|
|
|
2008-04-04 15:02:11 +00:00
|
|
|
impl = CLUTTER_STAGE_WINDOW (priv->impl);
|
2008-04-25 13:37:36 +00:00
|
|
|
if (CLUTTER_STAGE_WINDOW_GET_IFACE(impl)->set_title != NULL)
|
|
|
|
CLUTTER_STAGE_WINDOW_GET_IFACE (impl)->set_title (impl, priv->title);
|
2007-06-19 09:10:37 +00:00
|
|
|
|
|
|
|
g_object_notify (G_OBJECT (stage), "title");
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_stage_get_title
|
|
|
|
* @stage: A #ClutterStage
|
2007-10-12 08:17:00 +00:00
|
|
|
*
|
2007-06-19 09:10:37 +00:00
|
|
|
* Gets the stage title.
|
|
|
|
*
|
|
|
|
* Return value: pointer to the title string for the stage. The
|
|
|
|
* returned string is owned by the actor and should not
|
|
|
|
* be modified or freed.
|
|
|
|
*
|
|
|
|
* Since: 0.4
|
|
|
|
**/
|
|
|
|
G_CONST_RETURN gchar *
|
|
|
|
clutter_stage_get_title (ClutterStage *stage)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_STAGE (stage), NULL);
|
|
|
|
|
|
|
|
return stage->priv->title;
|
|
|
|
}
|
|
|
|
|
2007-08-13 20:48:01 +00:00
|
|
|
static void
|
|
|
|
on_key_focused_weak_notify (gpointer data,
|
|
|
|
GObject *where_the_object_was)
|
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv;
|
2007-10-02 14:03:36 +00:00
|
|
|
ClutterStage *stage = CLUTTER_STAGE (data);
|
2007-08-13 20:48:01 +00:00
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
|
|
|
|
|
|
|
priv = stage->priv;
|
|
|
|
priv->key_focused_actor = NULL;
|
|
|
|
|
2007-10-12 08:17:00 +00:00
|
|
|
/* focused actor has dissapeared - fall back to stage
|
2007-08-13 20:48:01 +00:00
|
|
|
* FIXME: need some kind of signal dance/block here.
|
|
|
|
*/
|
2007-10-02 14:03:36 +00:00
|
|
|
clutter_stage_set_key_focus (stage, NULL);
|
2007-08-13 20:48:01 +00:00
|
|
|
}
|
|
|
|
|
2007-11-23 13:11:10 +00:00
|
|
|
/**
|
|
|
|
* clutter_stage_set_key_focus:
|
|
|
|
* @stage: the #ClutterStage
|
2009-08-13 09:49:39 +00:00
|
|
|
* @actor: (allow-none): the actor to set key focus to, or %NULL
|
2007-11-23 13:11:10 +00:00
|
|
|
*
|
|
|
|
* Sets the key focus on @actor. An actor with key focus will receive
|
|
|
|
* all the key events. If @actor is %NULL, the stage will receive
|
|
|
|
* focus.
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
2007-08-13 20:48:01 +00:00
|
|
|
void
|
2007-10-02 14:03:36 +00:00
|
|
|
clutter_stage_set_key_focus (ClutterStage *stage,
|
|
|
|
ClutterActor *actor)
|
2007-08-13 20:48:01 +00:00
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
|
|
|
g_return_if_fail (actor == NULL || CLUTTER_IS_ACTOR (actor));
|
|
|
|
|
|
|
|
priv = stage->priv;
|
|
|
|
|
|
|
|
if (priv->key_focused_actor == actor)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (priv->key_focused_actor)
|
|
|
|
{
|
2009-04-24 15:43:39 +00:00
|
|
|
ClutterActor *old_focused_actor;
|
|
|
|
|
|
|
|
old_focused_actor = priv->key_focused_actor;
|
|
|
|
|
|
|
|
/* set key_focused_actor to NULL before emitting the signal or someone
|
|
|
|
* might hide the previously focused actor in the signal handler and we'd
|
|
|
|
* get re-entrant call and get glib critical from g_object_weak_unref
|
|
|
|
*/
|
|
|
|
|
2007-10-02 14:03:36 +00:00
|
|
|
g_object_weak_unref (G_OBJECT (priv->key_focused_actor),
|
2007-08-13 20:48:01 +00:00
|
|
|
on_key_focused_weak_notify,
|
|
|
|
stage);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-10-02 14:03:36 +00:00
|
|
|
priv->key_focused_actor = NULL;
|
2009-04-24 15:43:39 +00:00
|
|
|
|
|
|
|
g_signal_emit_by_name (old_focused_actor, "key-focus-out");
|
2007-08-13 20:48:01 +00:00
|
|
|
}
|
2007-10-02 14:03:36 +00:00
|
|
|
else
|
2009-05-06 16:56:40 +00:00
|
|
|
g_signal_emit_by_name (stage, "key-focus-out");
|
2007-08-13 20:48:01 +00:00
|
|
|
|
2009-04-24 15:43:39 +00:00
|
|
|
/* Note, if someone changes key focus in focus-out signal handler we'd be
|
|
|
|
* overriding the latter call below moving the focus where it was originally
|
|
|
|
* intended. The order of events would be:
|
|
|
|
* 1st focus-out, 2nd focus-out (on stage), 2nd focus-in, 1st focus-in
|
|
|
|
*/
|
|
|
|
|
2007-08-13 20:48:01 +00:00
|
|
|
if (actor)
|
|
|
|
{
|
2007-10-02 14:03:36 +00:00
|
|
|
priv->key_focused_actor = actor;
|
|
|
|
|
|
|
|
g_object_weak_ref (G_OBJECT (actor),
|
2007-08-13 20:48:01 +00:00
|
|
|
on_key_focused_weak_notify,
|
|
|
|
stage);
|
2009-05-06 16:56:40 +00:00
|
|
|
g_signal_emit_by_name (priv->key_focused_actor, "key-focus-in");
|
2007-08-13 20:48:01 +00:00
|
|
|
}
|
2007-10-02 14:03:36 +00:00
|
|
|
else
|
2009-05-06 16:56:40 +00:00
|
|
|
g_signal_emit_by_name (stage, "key-focus-in");
|
2010-02-01 11:04:59 +00:00
|
|
|
|
|
|
|
g_object_notify (G_OBJECT (stage), "key-focus");
|
2007-08-13 20:48:01 +00:00
|
|
|
}
|
|
|
|
|
2007-11-23 13:11:10 +00:00
|
|
|
/**
|
|
|
|
* clutter_stage_get_key_focus:
|
|
|
|
* @stage: the #ClutterStage
|
|
|
|
*
|
|
|
|
* Retrieves the actor that is currently under key focus.
|
|
|
|
*
|
2009-02-17 00:25:20 +00:00
|
|
|
* Return value: (transfer none): the actor with key focus, or the stage
|
2007-11-23 13:11:10 +00:00
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
2007-10-02 14:03:36 +00:00
|
|
|
ClutterActor *
|
|
|
|
clutter_stage_get_key_focus (ClutterStage *stage)
|
2007-08-13 20:48:01 +00:00
|
|
|
{
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_STAGE (stage), NULL);
|
|
|
|
|
2007-10-02 14:03:36 +00:00
|
|
|
if (stage->priv->key_focused_actor)
|
|
|
|
return stage->priv->key_focused_actor;
|
2007-08-13 20:48:01 +00:00
|
|
|
|
2007-10-02 14:03:36 +00:00
|
|
|
return CLUTTER_ACTOR (stage);
|
2007-08-13 20:48:01 +00:00
|
|
|
}
|
|
|
|
|
2007-11-21 11:55:26 +00:00
|
|
|
/**
|
|
|
|
* clutter_stage_get_use_fog:
|
|
|
|
* @stage: the #ClutterStage
|
|
|
|
*
|
|
|
|
* Gets whether the depth cueing effect is enabled on @stage.
|
|
|
|
*
|
2010-11-25 18:13:51 +00:00
|
|
|
* Return value: %TRUE if the depth cueing effect is enabled
|
2007-11-21 11:55:26 +00:00
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
gboolean
|
|
|
|
clutter_stage_get_use_fog (ClutterStage *stage)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_STAGE (stage), FALSE);
|
2007-08-13 20:48:01 +00:00
|
|
|
|
2007-11-21 11:55:26 +00:00
|
|
|
return stage->priv->use_fog;
|
|
|
|
}
|
2007-03-26 23:18:39 +00:00
|
|
|
|
|
|
|
/**
|
2007-11-21 11:55:26 +00:00
|
|
|
* clutter_stage_set_use_fog:
|
|
|
|
* @stage: the #ClutterStage
|
|
|
|
* @fog: %TRUE for enabling the depth cueing effect
|
2007-03-26 23:18:39 +00:00
|
|
|
*
|
2007-11-21 11:55:26 +00:00
|
|
|
* Sets whether the depth cueing effect on the stage should be enabled
|
|
|
|
* or not.
|
2007-03-26 23:18:39 +00:00
|
|
|
*
|
2007-11-21 11:55:26 +00:00
|
|
|
* Depth cueing is a 3D effect that makes actors farther away from the
|
|
|
|
* viewing point less opaque, by fading them with the stage color.
|
|
|
|
|
|
|
|
* The parameters of the GL fog used can be changed using the
|
|
|
|
* clutter_stage_set_fog() function.
|
2007-03-26 23:18:39 +00:00
|
|
|
*
|
2007-11-21 11:55:26 +00:00
|
|
|
* Since: 0.6
|
2007-03-26 23:18:39 +00:00
|
|
|
*/
|
2007-11-21 11:55:26 +00:00
|
|
|
void
|
|
|
|
clutter_stage_set_use_fog (ClutterStage *stage,
|
|
|
|
gboolean fog)
|
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
|
|
|
|
|
|
|
priv = stage->priv;
|
|
|
|
|
|
|
|
if (priv->use_fog != fog)
|
|
|
|
{
|
|
|
|
priv->use_fog = fog;
|
|
|
|
|
|
|
|
CLUTTER_NOTE (MISC, "%s depth-cueing inside stage",
|
|
|
|
priv->use_fog ? "enabling" : "disabling");
|
|
|
|
|
2010-02-09 19:34:32 +00:00
|
|
|
clutter_actor_queue_redraw (CLUTTER_ACTOR (stage));
|
2007-11-21 11:55:26 +00:00
|
|
|
|
|
|
|
g_object_notify (G_OBJECT (stage), "use-fog");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_stage_set_fog:
|
|
|
|
* @stage: the #ClutterStage
|
|
|
|
* @fog: a #ClutterFog structure
|
|
|
|
*
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
* Sets the fog (also known as "depth cueing") settings for the @stage.
|
|
|
|
*
|
|
|
|
* A #ClutterStage will only use a linear fog progression, which
|
|
|
|
* depends solely on the distance from the viewer. The cogl_set_fog()
|
|
|
|
* function in COGL exposes more of the underlying implementation,
|
|
|
|
* and allows changing the for progression function. It can be directly
|
|
|
|
* used by disabling the #ClutterStage:use-fog property and connecting
|
|
|
|
* a signal handler to the #ClutterActor::paint signal on the @stage,
|
|
|
|
* like:
|
|
|
|
*
|
|
|
|
* |[
|
|
|
|
* clutter_stage_set_use_fog (stage, FALSE);
|
|
|
|
* g_signal_connect (stage, "paint", G_CALLBACK (on_stage_paint), NULL);
|
|
|
|
* ]|
|
|
|
|
*
|
|
|
|
* The paint signal handler will call cogl_set_fog() with the
|
|
|
|
* desired settings:
|
|
|
|
*
|
|
|
|
* |[
|
|
|
|
* static void
|
|
|
|
* on_stage_paint (ClutterActor *actor)
|
|
|
|
* {
|
|
|
|
* ClutterColor stage_color = { 0, };
|
|
|
|
* CoglColor fog_color = { 0, };
|
|
|
|
*
|
|
|
|
* /* set the fog color to the stage background color */
|
|
|
|
* clutter_stage_get_color (CLUTTER_STAGE (actor), &stage_color);
|
2010-09-03 15:55:12 +00:00
|
|
|
* cogl_color_init_from_4ub (&fog_color,
|
|
|
|
* stage_color.red,
|
|
|
|
* stage_color.green,
|
|
|
|
* stage_color.blue,
|
|
|
|
* stage_color.alpha);
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
*
|
|
|
|
* /* enable fog */
|
|
|
|
* cogl_set_fog (&fog_color,
|
|
|
|
* COGL_FOG_MODE_EXPONENTIAL, /* mode */
|
|
|
|
* 0.5, /* density */
|
|
|
|
* 5.0, 30.0); /* z_near and z_far */
|
|
|
|
* }
|
|
|
|
* ]|
|
2007-11-21 11:55:26 +00:00
|
|
|
*
|
2010-09-03 15:55:12 +00:00
|
|
|
* <note>The fogging functions only work correctly when the visible actors use
|
|
|
|
* unmultiplied alpha colors. By default Cogl will premultiply textures and
|
|
|
|
* cogl_set_source_color() will premultiply colors, so unless you explicitly
|
|
|
|
* load your textures requesting an unmultiplied internal format and use
|
|
|
|
* cogl_material_set_color() you can only use fogging with fully opaque actors.
|
|
|
|
* Support for premultiplied colors will improve in the future when we can
|
|
|
|
* depend on fragment shaders.</note>
|
2009-06-07 10:54:05 +00:00
|
|
|
*
|
2007-11-21 11:55:26 +00:00
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
void
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
clutter_stage_set_fog (ClutterStage *stage,
|
|
|
|
ClutterFog *fog)
|
2007-11-21 11:55:26 +00:00
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
|
|
|
g_return_if_fail (fog != NULL);
|
|
|
|
|
|
|
|
priv = stage->priv;
|
|
|
|
|
|
|
|
priv->fog = *fog;
|
|
|
|
|
2010-02-09 19:34:32 +00:00
|
|
|
if (priv->use_fog)
|
2007-11-21 11:55:26 +00:00
|
|
|
clutter_actor_queue_redraw (CLUTTER_ACTOR (stage));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
* clutter_stage_get_fog:
|
2007-11-21 11:55:26 +00:00
|
|
|
* @stage: the #ClutterStage
|
|
|
|
* @fog: return location for a #ClutterFog structure
|
|
|
|
*
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
* Retrieves the current depth cueing settings from the stage.
|
2007-11-21 11:55:26 +00:00
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
void
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
clutter_stage_get_fog (ClutterStage *stage,
|
2007-11-21 11:55:26 +00:00
|
|
|
ClutterFog *fog)
|
|
|
|
{
|
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
|
|
|
g_return_if_fail (fog != NULL);
|
|
|
|
|
|
|
|
*fog = stage->priv->fog;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*** Perspective boxed type ******/
|
|
|
|
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
static gpointer
|
|
|
|
clutter_perspective_copy (gpointer data)
|
2007-03-26 23:18:39 +00:00
|
|
|
{
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
if (G_LIKELY (data))
|
|
|
|
return g_slice_dup (ClutterPerspective, data);
|
2007-03-26 23:18:39 +00:00
|
|
|
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
return NULL;
|
2007-03-26 23:18:39 +00:00
|
|
|
}
|
|
|
|
|
2007-11-21 11:55:26 +00:00
|
|
|
static void
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
clutter_perspective_free (gpointer data)
|
2007-03-26 23:18:39 +00:00
|
|
|
{
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
if (G_LIKELY (data))
|
|
|
|
g_slice_free (ClutterPerspective, data);
|
2007-03-26 23:18:39 +00:00
|
|
|
}
|
|
|
|
|
2010-10-08 14:21:57 +00:00
|
|
|
G_DEFINE_BOXED_TYPE (ClutterPerspective, clutter_perspective,
|
|
|
|
clutter_perspective_copy,
|
|
|
|
clutter_perspective_free);
|
2007-05-25 10:56:09 +00:00
|
|
|
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
static gpointer
|
|
|
|
clutter_fog_copy (gpointer data)
|
2007-11-21 11:55:26 +00:00
|
|
|
{
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
if (G_LIKELY (data))
|
|
|
|
return g_slice_dup (ClutterFog, data);
|
2007-11-21 11:55:26 +00:00
|
|
|
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
return NULL;
|
2007-11-21 11:55:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
clutter_fog_free (gpointer data)
|
2007-11-21 11:55:26 +00:00
|
|
|
{
|
[stage] Coalesce fog and perspective API
The fog and perspective API is currently split in two parts:
- the floating point version, using values
- the fixed point version, using structures
The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.
Thus:
clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
clutter_stage_get_fog (ClutterStage*, ClutterFog*)
clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)
Which supercedes the fixed point and floating point variants.
More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.
ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.
Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
|
|
|
if (G_LIKELY (data))
|
|
|
|
g_slice_free (ClutterFog, data);
|
2007-11-21 11:55:26 +00:00
|
|
|
}
|
|
|
|
|
2010-10-08 14:21:57 +00:00
|
|
|
G_DEFINE_BOXED_TYPE (ClutterFog, clutter_fog, clutter_fog_copy, clutter_fog_free);
|
2008-03-28 22:50:55 +00:00
|
|
|
|
|
|
|
/**
|
2008-04-04 15:02:11 +00:00
|
|
|
* clutter_stage_new:
|
2008-03-28 22:50:55 +00:00
|
|
|
*
|
|
|
|
* Creates a new, non-default stage. A non-default stage is a new
|
|
|
|
* top-level actor which can be used as another container. It works
|
|
|
|
* exactly like the default stage, but while clutter_stage_get_default()
|
|
|
|
* will always return the same instance, you will have to keep a pointer
|
2010-11-18 14:14:37 +00:00
|
|
|
* to any #ClutterStage returned by clutter_stage_new().
|
2008-03-28 22:50:55 +00:00
|
|
|
*
|
|
|
|
* The ability to support multiple stages depends on the current
|
|
|
|
* backend. Use clutter_feature_available() and
|
|
|
|
* %CLUTTER_FEATURE_STAGE_MULTIPLE to check at runtime whether a
|
|
|
|
* backend supports multiple stages.
|
|
|
|
*
|
|
|
|
* Return value: a new stage, or %NULL if the default backend does
|
|
|
|
* not support multiple stages. Use clutter_actor_destroy() to
|
2008-04-04 15:02:11 +00:00
|
|
|
* programmatically close the returned stage.
|
2008-03-28 22:50:55 +00:00
|
|
|
*
|
|
|
|
* Since: 0.8
|
|
|
|
*/
|
2008-04-04 15:02:11 +00:00
|
|
|
ClutterActor *
|
|
|
|
clutter_stage_new (void)
|
2008-03-28 22:50:55 +00:00
|
|
|
{
|
|
|
|
if (!clutter_feature_available (CLUTTER_FEATURE_STAGE_MULTIPLE))
|
|
|
|
{
|
|
|
|
g_warning ("Unable to create a new stage: the %s backend does not "
|
|
|
|
"support multiple stages.",
|
|
|
|
CLUTTER_FLAVOUR);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-06-03 20:15:11 +00:00
|
|
|
/* The stage manager will grab the floating reference when the stage
|
|
|
|
is added to it in the constructor */
|
|
|
|
return g_object_new (CLUTTER_TYPE_STAGE, NULL);
|
2008-03-28 22:50:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_stage_ensure_current:
|
|
|
|
* @stage: the #ClutterStage
|
|
|
|
*
|
|
|
|
* This function essentially makes sure the right GL context is
|
|
|
|
* current for the passed stage. It is not intended to
|
|
|
|
* be used by applications.
|
|
|
|
*
|
|
|
|
* Since: 0.8
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_stage_ensure_current (ClutterStage *stage)
|
|
|
|
{
|
2009-06-17 16:59:54 +00:00
|
|
|
ClutterBackend *backend;
|
2008-03-28 22:50:55 +00:00
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
|
|
|
|
2009-06-17 16:59:54 +00:00
|
|
|
backend = clutter_get_default_backend ();
|
|
|
|
_clutter_backend_ensure_context (backend, stage);
|
2008-03-28 22:50:55 +00:00
|
|
|
}
|
|
|
|
|
2009-01-12 11:18:11 +00:00
|
|
|
/**
|
|
|
|
* clutter_stage_ensure_viewport:
|
|
|
|
* @stage: a #ClutterStage
|
|
|
|
*
|
|
|
|
* Ensures that the GL viewport is updated with the current
|
|
|
|
* stage window size.
|
|
|
|
*
|
|
|
|
* This function will queue a redraw of @stage.
|
|
|
|
*
|
|
|
|
* This function should not be called by applications; it is used
|
|
|
|
* when embedding a #ClutterStage into a toolkit with another
|
|
|
|
* windowing system, like GTK+.
|
|
|
|
*
|
|
|
|
* Since: 1.0
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_stage_ensure_viewport (ClutterStage *stage)
|
|
|
|
{
|
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
|
|
|
|
2010-09-07 12:10:55 +00:00
|
|
|
_clutter_stage_dirty_viewport (stage);
|
2009-01-12 11:18:11 +00:00
|
|
|
|
2009-02-17 17:22:02 +00:00
|
|
|
clutter_actor_queue_redraw (CLUTTER_ACTOR (stage));
|
2009-01-12 11:18:11 +00:00
|
|
|
}
|
|
|
|
|
2010-09-07 12:10:55 +00:00
|
|
|
void
|
|
|
|
_clutter_stage_maybe_setup_viewport (ClutterStage *stage)
|
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv = stage->priv;
|
|
|
|
|
|
|
|
if (priv->dirty_viewport)
|
|
|
|
{
|
|
|
|
CLUTTER_NOTE (PAINT,
|
|
|
|
"Setting up the viewport { w:%d, h:%d }",
|
|
|
|
priv->viewport[2], priv->viewport[3]);
|
|
|
|
|
|
|
|
cogl_set_viewport (priv->viewport[0],
|
|
|
|
priv->viewport[1],
|
|
|
|
priv->viewport[2],
|
|
|
|
priv->viewport[3]);
|
|
|
|
|
2010-12-13 17:21:58 +00:00
|
|
|
|
|
|
|
priv->dirty_viewport = FALSE;
|
2010-09-07 12:10:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (priv->dirty_projection)
|
2010-12-13 17:21:58 +00:00
|
|
|
{
|
|
|
|
cogl_set_projection_matrix (&priv->projection);
|
|
|
|
|
|
|
|
priv->dirty_projection = FALSE;
|
|
|
|
}
|
2010-09-07 12:10:55 +00:00
|
|
|
}
|
|
|
|
|
2009-06-09 15:29:29 +00:00
|
|
|
/**
|
|
|
|
* clutter_stage_ensure_redraw:
|
|
|
|
* @stage: a #ClutterStage
|
|
|
|
*
|
|
|
|
* Ensures that @stage is redrawn
|
|
|
|
*
|
|
|
|
* This function should not be called by applications: it is
|
|
|
|
* used when embedding a #ClutterStage into a toolkit with
|
|
|
|
* another windowing system, like GTK+.
|
|
|
|
*
|
|
|
|
* Since: 1.0
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_stage_ensure_redraw (ClutterStage *stage)
|
|
|
|
{
|
|
|
|
ClutterMasterClock *master_clock;
|
|
|
|
ClutterStagePrivate *priv;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
|
|
|
|
|
|
|
priv = stage->priv;
|
2010-09-07 19:08:00 +00:00
|
|
|
priv->relayout_pending = TRUE;
|
2009-06-09 15:29:29 +00:00
|
|
|
priv->redraw_pending = TRUE;
|
|
|
|
|
|
|
|
master_clock = _clutter_master_clock_get_default ();
|
|
|
|
_clutter_master_clock_start_running (master_clock);
|
|
|
|
}
|
|
|
|
|
2008-03-28 22:50:55 +00:00
|
|
|
/**
|
|
|
|
* clutter_stage_queue_redraw:
|
|
|
|
* @stage: the #ClutterStage
|
|
|
|
*
|
2008-04-04 15:02:11 +00:00
|
|
|
* Queues a redraw for the passed stage.
|
|
|
|
*
|
|
|
|
* <note>Applications should call clutter_actor_queue_redraw() and not
|
|
|
|
* this function.</note>
|
2008-03-28 22:50:55 +00:00
|
|
|
*
|
2009-02-17 17:22:02 +00:00
|
|
|
* <note>This function is just a wrapper for clutter_actor_queue_redraw()
|
|
|
|
* and should probably go away.</note>
|
|
|
|
*
|
2008-03-28 22:50:55 +00:00
|
|
|
* Since: 0.8
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_stage_queue_redraw (ClutterStage *stage)
|
|
|
|
{
|
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
|
|
|
|
2009-02-17 17:22:02 +00:00
|
|
|
clutter_actor_queue_redraw (CLUTTER_ACTOR (stage));
|
2008-03-28 22:50:55 +00:00
|
|
|
}
|
2008-04-04 15:02:11 +00:00
|
|
|
|
2008-04-04 17:26:26 +00:00
|
|
|
/**
|
|
|
|
* clutter_stage_is_default:
|
|
|
|
* @stage: a #ClutterStage
|
|
|
|
*
|
|
|
|
* Checks if @stage is the default stage, or an instance created using
|
|
|
|
* clutter_stage_new() but internally using the same implementation.
|
|
|
|
*
|
|
|
|
* Return value: %TRUE if the passed stage is the default one
|
|
|
|
*
|
|
|
|
* Since: 0.8
|
|
|
|
*/
|
|
|
|
gboolean
|
|
|
|
clutter_stage_is_default (ClutterStage *stage)
|
|
|
|
{
|
|
|
|
ClutterStageWindow *impl;
|
|
|
|
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_STAGE (stage), FALSE);
|
|
|
|
|
|
|
|
if (CLUTTER_ACTOR (stage) == clutter_stage_get_default ())
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
impl = _clutter_stage_get_window (stage);
|
|
|
|
if (impl == _clutter_stage_get_default_window ())
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2008-04-04 15:02:11 +00:00
|
|
|
void
|
|
|
|
_clutter_stage_set_window (ClutterStage *stage,
|
|
|
|
ClutterStageWindow *stage_window)
|
|
|
|
{
|
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE_WINDOW (stage_window));
|
|
|
|
|
|
|
|
if (stage->priv->impl)
|
|
|
|
g_object_unref (stage->priv->impl);
|
|
|
|
|
2009-08-13 11:34:07 +00:00
|
|
|
stage->priv->impl = stage_window;
|
2008-04-04 15:02:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ClutterStageWindow *
|
|
|
|
_clutter_stage_get_window (ClutterStage *stage)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_STAGE (stage), NULL);
|
|
|
|
|
|
|
|
return CLUTTER_STAGE_WINDOW (stage->priv->impl);
|
|
|
|
}
|
|
|
|
|
|
|
|
ClutterStageWindow *
|
|
|
|
_clutter_stage_get_default_window (void)
|
|
|
|
{
|
|
|
|
ClutterActor *stage = clutter_stage_get_default ();
|
|
|
|
|
|
|
|
return _clutter_stage_get_window (CLUTTER_STAGE (stage));
|
|
|
|
}
|
2009-07-14 12:47:35 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_stage_set_throttle_motion_events:
|
|
|
|
* @stage: a #ClutterStage
|
|
|
|
* @throttle: %TRUE to throttle motion events
|
|
|
|
*
|
|
|
|
* Sets whether motion events received between redraws should
|
|
|
|
* be throttled or not. If motion events are throttled, those
|
|
|
|
* events received by the windowing system between redraws will
|
|
|
|
* be compressed so that only the last event will be propagated
|
|
|
|
* to the @stage and its actors.
|
|
|
|
*
|
|
|
|
* This function should only be used if you want to have all
|
|
|
|
* the motion events delivered to your application code.
|
|
|
|
*
|
|
|
|
* Since: 1.0
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_stage_set_throttle_motion_events (ClutterStage *stage,
|
|
|
|
gboolean throttle)
|
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
|
|
|
|
|
|
|
priv = stage->priv;
|
|
|
|
|
|
|
|
if (priv->throttle_motion_events != throttle)
|
|
|
|
priv->throttle_motion_events = throttle;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_stage_get_throttle_motion_events:
|
|
|
|
* @stage: a #ClutterStage
|
|
|
|
*
|
|
|
|
* Retrieves the value set with clutter_stage_set_throttle_motion_events()
|
|
|
|
*
|
|
|
|
* Return value: %TRUE if the motion events are being throttled,
|
|
|
|
* and %FALSE otherwise
|
|
|
|
*
|
|
|
|
* Since: 1.0
|
|
|
|
*/
|
|
|
|
gboolean
|
|
|
|
clutter_stage_get_throttle_motion_events (ClutterStage *stage)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_STAGE (stage), FALSE);
|
|
|
|
|
|
|
|
return stage->priv->throttle_motion_events;
|
|
|
|
}
|
2009-12-09 02:04:56 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_stage_set_use_alpha:
|
|
|
|
* @stage: a #ClutterStage
|
|
|
|
* @use_alpha: whether the stage should honour the opacity or the
|
|
|
|
* alpha channel of the stage color
|
|
|
|
*
|
|
|
|
* Sets whether the @stage should honour the #ClutterActor:opacity and
|
|
|
|
* the alpha channel of the #ClutterStage:color
|
|
|
|
*
|
|
|
|
* Since: 1.2
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_stage_set_use_alpha (ClutterStage *stage,
|
|
|
|
gboolean use_alpha)
|
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
|
|
|
|
|
|
|
priv = stage->priv;
|
|
|
|
|
|
|
|
if (priv->use_alpha != use_alpha)
|
|
|
|
{
|
|
|
|
priv->use_alpha = use_alpha;
|
|
|
|
|
|
|
|
clutter_actor_queue_redraw (CLUTTER_ACTOR (stage));
|
|
|
|
|
|
|
|
g_object_notify (G_OBJECT (stage), "use-alpha");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_stage_get_use_alpha:
|
|
|
|
* @stage: a #ClutterStage
|
|
|
|
*
|
|
|
|
* Retrieves the value set using clutter_stage_set_use_alpha()
|
|
|
|
*
|
|
|
|
* Return value: %TRUE if the stage should honour the opacity and the
|
|
|
|
* alpha channel of the stage color
|
|
|
|
*
|
|
|
|
* Since: 1.2
|
|
|
|
*/
|
|
|
|
gboolean
|
|
|
|
clutter_stage_get_use_alpha (ClutterStage *stage)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_STAGE (stage), FALSE);
|
|
|
|
|
|
|
|
return stage->priv->use_alpha;
|
|
|
|
}
|
2010-02-06 11:23:37 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_stage_set_minimum_size:
|
|
|
|
* @stage: a #ClutterStage
|
|
|
|
* @width: width, in pixels
|
|
|
|
* @height: height, in pixels
|
|
|
|
*
|
2010-02-27 18:56:34 +00:00
|
|
|
* Sets the minimum size for a stage window, if the default backend
|
|
|
|
* uses #ClutterStage inside a window
|
|
|
|
*
|
|
|
|
* This is a convenience function, and it is equivalent to setting the
|
|
|
|
* #ClutterActor:min-width and #ClutterActor:min-height on @stage
|
|
|
|
*
|
|
|
|
* If the current size of @stage is smaller than the minimum size, the
|
|
|
|
* @stage will be resized to the new @width and @height
|
|
|
|
*
|
|
|
|
* This function has no effect if @stage is fullscreen
|
2010-02-06 11:23:37 +00:00
|
|
|
*
|
|
|
|
* Since: 1.2
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_stage_set_minimum_size (ClutterStage *stage,
|
|
|
|
guint width,
|
|
|
|
guint height)
|
|
|
|
{
|
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
|
|
|
g_return_if_fail ((width > 0) && (height > 0));
|
|
|
|
|
2010-02-26 18:36:38 +00:00
|
|
|
g_object_set (G_OBJECT (stage),
|
2010-02-27 18:56:34 +00:00
|
|
|
"min-width", (gfloat) width,
|
|
|
|
"min-height", (gfloat )height,
|
2010-02-26 18:36:38 +00:00
|
|
|
NULL);
|
2010-02-06 11:23:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_stage_get_minimum_size:
|
|
|
|
* @stage: a #ClutterStage
|
2010-02-27 18:56:34 +00:00
|
|
|
* @width: (out): return location for the minimum width, in pixels,
|
|
|
|
* or %NULL
|
|
|
|
* @height: (out): return location for the minimum height, in pixels,
|
|
|
|
* or %NULL
|
2010-02-06 11:23:37 +00:00
|
|
|
*
|
2010-02-27 18:56:34 +00:00
|
|
|
* Retrieves the minimum size for a stage window as set using
|
|
|
|
* clutter_stage_set_minimum_size().
|
2010-02-06 11:23:37 +00:00
|
|
|
*
|
2010-02-27 18:56:34 +00:00
|
|
|
* The returned size may not correspond to the actual minimum size and
|
|
|
|
* it is specific to the #ClutterStage implementation inside the
|
|
|
|
* Clutter backend
|
2010-02-06 11:23:37 +00:00
|
|
|
*
|
|
|
|
* Since: 1.2
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_stage_get_minimum_size (ClutterStage *stage,
|
2010-02-26 18:36:38 +00:00
|
|
|
guint *width_p,
|
|
|
|
guint *height_p)
|
2010-02-06 11:23:37 +00:00
|
|
|
{
|
2010-02-26 18:36:38 +00:00
|
|
|
gfloat width, height;
|
|
|
|
gboolean width_set, height_set;
|
|
|
|
|
2010-02-06 11:23:37 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
|
|
|
|
2010-02-26 18:36:38 +00:00
|
|
|
g_object_get (G_OBJECT (stage),
|
|
|
|
"min-width", &width,
|
|
|
|
"min-width-set", &width_set,
|
|
|
|
"min-height", &height,
|
|
|
|
"min-height-set", &height_set,
|
|
|
|
NULL);
|
|
|
|
|
2010-02-27 18:56:34 +00:00
|
|
|
/* if not width or height have been set, then the Stage
|
|
|
|
* minimum size is defined to be 1x1
|
|
|
|
*/
|
2010-02-26 18:36:38 +00:00
|
|
|
if (!width_set)
|
|
|
|
width = 1;
|
2010-02-27 18:56:34 +00:00
|
|
|
|
2010-02-26 18:36:38 +00:00
|
|
|
if (!height_set)
|
|
|
|
height = 1;
|
|
|
|
|
|
|
|
if (width_p)
|
2010-02-27 18:56:34 +00:00
|
|
|
*width_p = (guint) width;
|
|
|
|
|
2010-02-26 18:36:38 +00:00
|
|
|
if (height_p)
|
2010-02-27 18:56:34 +00:00
|
|
|
*height_p = (guint) height;
|
2010-02-06 11:23:37 +00:00
|
|
|
}
|
|
|
|
|
2009-11-12 20:37:01 +00:00
|
|
|
/* Returns the number of swap buffers pending completion for the stage */
|
|
|
|
int
|
|
|
|
_clutter_stage_get_pending_swaps (ClutterStage *stage)
|
|
|
|
{
|
2010-02-15 12:04:50 +00:00
|
|
|
ClutterStageWindow *stage_window;
|
|
|
|
|
2010-07-21 15:10:46 +00:00
|
|
|
if (CLUTTER_ACTOR_IN_DESTRUCTION (stage))
|
2010-02-15 12:04:50 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
stage_window = _clutter_stage_get_window (stage);
|
|
|
|
if (stage_window == NULL)
|
|
|
|
return 0;
|
|
|
|
|
2009-11-12 20:37:01 +00:00
|
|
|
return _clutter_stage_window_get_pending_swaps (stage_window);
|
|
|
|
}
|
2010-04-16 14:34:36 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_stage_set_no_clear_hint:
|
|
|
|
* @stage: a #ClutterStage
|
|
|
|
* @no_clear: %TRUE if the @stage should not clear itself on every
|
|
|
|
* repaint cycle
|
|
|
|
*
|
|
|
|
* Sets whether the @stage should clear itself at the beginning
|
|
|
|
* of each paint cycle or not.
|
|
|
|
*
|
|
|
|
* Clearing the #ClutterStage can be a costly operation, especially
|
|
|
|
* if the stage is always covered - for instance, in a full-screen
|
|
|
|
* video player or in a game with a background texture.
|
|
|
|
*
|
|
|
|
* <note><para>This setting is a hint; Clutter might discard this
|
|
|
|
* hint depending on its internal state.</para></note>
|
|
|
|
*
|
|
|
|
* <warning><para>If parts of the stage are visible and you disable
|
|
|
|
* clearing you might end up with visual artifacts while painting the
|
|
|
|
* contents of the stage.</para></warning>
|
|
|
|
*
|
|
|
|
* Since: 1.4
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_stage_set_no_clear_hint (ClutterStage *stage,
|
|
|
|
gboolean no_clear)
|
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv;
|
|
|
|
ClutterStageHint new_hints;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
|
|
|
|
|
|
|
priv = stage->priv;
|
|
|
|
new_hints = priv->stage_hints;
|
|
|
|
|
|
|
|
if (no_clear)
|
|
|
|
new_hints |= CLUTTER_STAGE_NO_CLEAR_ON_PAINT;
|
|
|
|
else
|
|
|
|
new_hints &= ~CLUTTER_STAGE_NO_CLEAR_ON_PAINT;
|
|
|
|
|
|
|
|
if (priv->stage_hints == new_hints)
|
|
|
|
return;
|
|
|
|
|
|
|
|
priv->stage_hints = new_hints;
|
|
|
|
|
|
|
|
g_object_notify (G_OBJECT (stage), "no-clear-hint");
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_stage_get_no_clear_hint:
|
|
|
|
* @stage: a #ClutterStage
|
|
|
|
*
|
|
|
|
* Retrieves the hint set with clutter_stage_set_no_clear_hint()
|
|
|
|
*
|
|
|
|
* Return value: %TRUE if the stage should not clear itself on every paint
|
|
|
|
* cycle, and %FALSE otherwise
|
|
|
|
*
|
|
|
|
* Since: 1.4
|
|
|
|
*/
|
|
|
|
gboolean
|
|
|
|
clutter_stage_get_no_clear_hint (ClutterStage *stage)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_STAGE (stage), FALSE);
|
|
|
|
|
|
|
|
return (stage->priv->stage_hints & CLUTTER_STAGE_NO_CLEAR_ON_PAINT) != 0;
|
|
|
|
}
|
2010-09-10 23:29:05 +00:00
|
|
|
|
|
|
|
gboolean
|
2010-10-27 17:02:47 +00:00
|
|
|
_clutter_stage_get_pick_buffer_valid (ClutterStage *stage, ClutterPickMode mode)
|
2010-09-10 23:29:05 +00:00
|
|
|
{
|
2010-09-23 15:17:24 +00:00
|
|
|
g_return_val_if_fail (CLUTTER_IS_STAGE (stage), FALSE);
|
|
|
|
|
2010-10-27 17:02:47 +00:00
|
|
|
if (stage->priv->pick_buffer_mode != mode)
|
|
|
|
return FALSE;
|
|
|
|
|
2010-09-10 23:29:05 +00:00
|
|
|
return stage->priv->have_valid_pick_buffer;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2010-10-27 17:02:47 +00:00
|
|
|
_clutter_stage_set_pick_buffer_valid (ClutterStage *stage,
|
|
|
|
gboolean valid,
|
|
|
|
ClutterPickMode mode)
|
2010-09-10 23:29:05 +00:00
|
|
|
{
|
2010-09-23 15:17:24 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
|
|
|
|
|
|
|
stage->priv->have_valid_pick_buffer = !!valid;
|
2010-10-27 17:02:47 +00:00
|
|
|
stage->priv->pick_buffer_mode = mode;
|
2010-09-10 23:29:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
_clutter_stage_increment_picks_per_frame_counter (ClutterStage *stage)
|
|
|
|
{
|
2010-09-23 15:17:24 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
|
|
|
|
2010-09-10 23:29:05 +00:00
|
|
|
stage->priv->picks_per_frame++;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
_clutter_stage_reset_picks_per_frame_counter (ClutterStage *stage)
|
|
|
|
{
|
2010-09-23 15:17:24 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
|
|
|
|
2010-09-10 23:29:05 +00:00
|
|
|
stage->priv->picks_per_frame = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
guint
|
|
|
|
_clutter_stage_get_picks_per_frame_counter (ClutterStage *stage)
|
|
|
|
{
|
2010-09-23 15:17:24 +00:00
|
|
|
g_return_val_if_fail (CLUTTER_IS_STAGE (stage), 0);
|
|
|
|
|
2010-09-10 23:29:05 +00:00
|
|
|
return stage->priv->picks_per_frame;
|
|
|
|
}
|
2010-09-07 17:04:19 +00:00
|
|
|
|
|
|
|
ClutterPaintVolume *
|
|
|
|
_clutter_stage_paint_volume_stack_allocate (ClutterStage *stage)
|
|
|
|
{
|
|
|
|
GArray *paint_volume_stack = stage->priv->paint_volume_stack;
|
|
|
|
|
|
|
|
g_array_set_size (paint_volume_stack,
|
|
|
|
paint_volume_stack->len+1);
|
|
|
|
|
|
|
|
return &g_array_index (paint_volume_stack,
|
|
|
|
ClutterPaintVolume,
|
|
|
|
paint_volume_stack->len - 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
_clutter_stage_paint_volume_stack_free_all (ClutterStage *stage)
|
|
|
|
{
|
|
|
|
GArray *paint_volume_stack = stage->priv->paint_volume_stack;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < paint_volume_stack->len; i++)
|
|
|
|
{
|
|
|
|
ClutterPaintVolume *pv =
|
|
|
|
&g_array_index (paint_volume_stack, ClutterPaintVolume, i);
|
|
|
|
clutter_paint_volume_free (pv);
|
|
|
|
}
|
|
|
|
|
|
|
|
g_array_set_size (paint_volume_stack, 0);
|
|
|
|
}
|
|
|
|
|
2010-09-07 21:21:28 +00:00
|
|
|
/* The is an out-of-band paramater available while painting that
|
|
|
|
* can be used to cull actors. */
|
|
|
|
const ClutterGeometry *
|
|
|
|
_clutter_stage_get_clip (ClutterStage *stage)
|
|
|
|
{
|
|
|
|
return stage->priv->current_paint_clip;
|
|
|
|
}
|
|
|
|
|
2010-09-10 00:33:02 +00:00
|
|
|
/* When an actor queues a redraw we add it to a list on the stage that
|
|
|
|
* gets processed once all updates to the stage have been finished.
|
|
|
|
*
|
|
|
|
* This deferred approach to processing queue_redraw requests means
|
|
|
|
* that we can avoid redundant transformations of clip volumes if
|
|
|
|
* something later triggers a full stage redraw anyway. It also means
|
|
|
|
* we can be more sure that all the referenced actors will have valid
|
|
|
|
* allocations improving the chance that we can determine the actors
|
|
|
|
* paint volume so we can clip the redraw request even if the user
|
|
|
|
* didn't explicitly do so.
|
|
|
|
*/
|
|
|
|
ClutterStageQueueRedrawEntry *
|
|
|
|
_clutter_stage_queue_actor_redraw (ClutterStage *stage,
|
|
|
|
ClutterStageQueueRedrawEntry *entry,
|
|
|
|
ClutterActor *actor,
|
|
|
|
ClutterPaintVolume *clip)
|
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv = stage->priv;
|
|
|
|
|
|
|
|
CLUTTER_NOTE (PAINT, "Redraw request number %lu",
|
|
|
|
CLUTTER_CONTEXT ()->redraw_count + 1);
|
|
|
|
|
|
|
|
if (!priv->redraw_pending)
|
|
|
|
{
|
|
|
|
ClutterMasterClock *master_clock;
|
|
|
|
|
|
|
|
priv->redraw_pending = TRUE;
|
|
|
|
|
|
|
|
master_clock = _clutter_master_clock_get_default ();
|
|
|
|
_clutter_master_clock_start_running (master_clock);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
CLUTTER_CONTEXT ()->redraw_count += 1;
|
|
|
|
|
|
|
|
/* We have an optimization in _clutter_do_pick to detect when the
|
|
|
|
* scene is static so we can cache a full, un-clipped pick buffer to
|
|
|
|
* avoid continuous pick renders.
|
|
|
|
*
|
|
|
|
* Currently the assumption is that actors queue a redraw when some
|
|
|
|
* state changes that affects painting *or* picking so we can use
|
|
|
|
* this point to invalidate any currently cached pick buffer.
|
|
|
|
*/
|
2010-10-27 17:02:47 +00:00
|
|
|
_clutter_stage_set_pick_buffer_valid (stage, FALSE, -1);
|
2010-09-10 00:33:02 +00:00
|
|
|
|
|
|
|
if (entry)
|
|
|
|
{
|
|
|
|
/* Ignore all requests to queue a redraw for an actor if a full
|
|
|
|
* (non-clipped) redraw of the actor has already been queued. */
|
|
|
|
if (!entry->has_clip)
|
|
|
|
return entry;
|
|
|
|
|
|
|
|
/* If queuing a clipped redraw and a clipped redraw has
|
|
|
|
* previously been queued for this actor then combine the latest
|
|
|
|
* clip together with the existing clip */
|
|
|
|
if (clip)
|
|
|
|
clutter_paint_volume_union (&entry->clip, clip);
|
2010-09-30 17:42:40 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
clutter_paint_volume_free (&entry->clip);
|
|
|
|
entry->has_clip = FALSE;
|
|
|
|
}
|
2010-09-10 00:33:02 +00:00
|
|
|
return entry;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
entry = g_slice_new (ClutterStageQueueRedrawEntry);
|
|
|
|
entry->actor = g_object_ref (actor);
|
|
|
|
|
|
|
|
if (clip)
|
|
|
|
{
|
|
|
|
entry->has_clip = TRUE;
|
|
|
|
_clutter_paint_volume_init_static (actor, &entry->clip);
|
|
|
|
_clutter_paint_volume_set_from_volume (&entry->clip, clip);
|
|
|
|
}
|
2010-09-29 22:43:30 +00:00
|
|
|
else
|
|
|
|
entry->has_clip = FALSE;
|
2010-09-10 00:33:02 +00:00
|
|
|
|
|
|
|
stage->priv->pending_queue_redraws =
|
|
|
|
g_list_prepend (stage->priv->pending_queue_redraws, entry);
|
|
|
|
|
|
|
|
return entry;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
free_queue_redraw_entry (ClutterStageQueueRedrawEntry *entry)
|
|
|
|
{
|
2010-10-30 22:11:03 +00:00
|
|
|
if (entry->actor)
|
|
|
|
g_object_unref (entry->actor);
|
2010-09-10 00:33:02 +00:00
|
|
|
if (entry->has_clip)
|
|
|
|
clutter_paint_volume_free (&entry->clip);
|
|
|
|
g_slice_free (ClutterStageQueueRedrawEntry, entry);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2010-10-15 15:05:44 +00:00
|
|
|
_clutter_stage_queue_redraw_entry_invalidate (ClutterStageQueueRedrawEntry *entry)
|
2010-09-10 00:33:02 +00:00
|
|
|
{
|
2010-10-15 15:05:44 +00:00
|
|
|
if (entry == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (entry->actor != NULL)
|
|
|
|
{
|
|
|
|
g_object_unref (entry->actor);
|
|
|
|
entry->actor = NULL;
|
|
|
|
}
|
|
|
|
|
2010-09-10 00:33:02 +00:00
|
|
|
if (entry->has_clip)
|
2010-09-29 22:43:30 +00:00
|
|
|
{
|
|
|
|
clutter_paint_volume_free (&entry->clip);
|
|
|
|
entry->has_clip = FALSE;
|
|
|
|
}
|
2010-09-10 00:33:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_clutter_stage_maybe_finish_queue_redraws (ClutterStage *stage)
|
|
|
|
{
|
|
|
|
/* Note: we have to repeat until the pending_queue_redraws list is
|
|
|
|
* empty because actors are allowed to queue redraws in response to
|
|
|
|
* the queue-redraw signal. For example Clone actors or
|
|
|
|
* texture_new_from_actor actors will have to queue a redraw if
|
|
|
|
* their source queues a redraw.
|
|
|
|
*/
|
|
|
|
while (stage->priv->pending_queue_redraws)
|
|
|
|
{
|
|
|
|
GList *l;
|
|
|
|
/* XXX: we need to allow stage->priv->pending_queue_redraws to
|
|
|
|
* be updated while we process the current entries in the list
|
|
|
|
* so we steal the list pointer and then reset it to an empty
|
|
|
|
* list before processing... */
|
|
|
|
GList *stolen_list = stage->priv->pending_queue_redraws;
|
|
|
|
stage->priv->pending_queue_redraws = NULL;
|
|
|
|
|
|
|
|
for (l = stolen_list; l; l = l->next)
|
|
|
|
{
|
|
|
|
ClutterStageQueueRedrawEntry *entry = l->data;
|
2010-10-25 12:08:52 +00:00
|
|
|
ClutterPaintVolume *clip;
|
2010-09-10 00:33:02 +00:00
|
|
|
|
|
|
|
/* NB: Entries may be invalidated if the actor gets destroyed */
|
2010-10-30 22:11:03 +00:00
|
|
|
if (G_LIKELY (entry->actor != NULL))
|
|
|
|
{
|
|
|
|
clip = entry->has_clip ? &entry->clip : NULL;
|
2010-09-10 00:33:02 +00:00
|
|
|
|
2010-10-30 22:11:03 +00:00
|
|
|
_clutter_actor_finish_queue_redraw (entry->actor, clip);
|
|
|
|
}
|
2010-09-10 00:33:02 +00:00
|
|
|
|
|
|
|
free_queue_redraw_entry (entry);
|
|
|
|
}
|
|
|
|
g_list_free (stolen_list);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-12-28 17:37:18 +00:00
|
|
|
/**
|
|
|
|
* clutter_stage_get_accept_focus:
|
|
|
|
* @stage: a #ClutterStage
|
|
|
|
* @accept_focus: %TRUE to accept focus on show
|
|
|
|
*
|
|
|
|
* Sets whether the @stage should accept the key focus when shown.
|
|
|
|
*
|
|
|
|
* This function should be called before showing @stage using
|
|
|
|
* clutter_actor_show().
|
|
|
|
*
|
|
|
|
* Since: 1.6
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_stage_set_accept_focus (ClutterStage *stage,
|
|
|
|
gboolean accept_focus)
|
|
|
|
{
|
|
|
|
ClutterStagePrivate *priv;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE (stage));
|
|
|
|
|
|
|
|
accept_focus = !!accept_focus;
|
|
|
|
|
|
|
|
priv = stage->priv;
|
|
|
|
|
|
|
|
if (priv->accept_focus != accept_focus)
|
|
|
|
{
|
|
|
|
_clutter_stage_window_set_accept_focus (priv->impl, accept_focus);
|
|
|
|
g_object_notify (G_OBJECT (stage), "accept-focus");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_stage_get_accept_focus:
|
|
|
|
* @stage: a #ClutterStage
|
|
|
|
*
|
|
|
|
* Retrieves the value set with clutter_stage_set_accept_focus().
|
|
|
|
*
|
|
|
|
* Return value: %TRUE if the #ClutterStage should accept focus, and %FALSE
|
|
|
|
* otherwise
|
|
|
|
*
|
|
|
|
* Since: 1.6
|
|
|
|
*/
|
|
|
|
gboolean
|
|
|
|
clutter_stage_get_accept_focus (ClutterStage *stage)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_STAGE (stage), TRUE);
|
|
|
|
|
|
|
|
return stage->priv->accept_focus;
|
|
|
|
}
|