We want to set the default size without triggering the layout machinary,
so change the window creation process slightly so we start with a
640x480 window.
When requesting the GLXFBConfig for creating the GLX context, we should
always request one that links to an ARGB visual instead of a plain RGB
one.
By using an ARGB visual we allow the ClutterStage:use-alpha property to
work as intended when running Clutter under a compositing manager.
The default behaviour of requesting an ARGB visual can be disabled by
using the:
CLUTTER_DISABLE_ARGB_VISUAL
Environment variable.
The only backend that tried to implement offscreen stages was the GLX backend
and even this has apparently be broken for some time without anyone noticing.
The property still remains and since the property already clearly states that
it may not work I don't expect anyone to notice.
This simplifies quite a bit of the GLX code which is very desireable from the
POV that we want to start migrating window system code down to Cogl and the
simpler the code is the more straight forward this work will be.
In the future when Cogl has a nicely designed API for framebuffer objects then
re-implementing offscreen stages cleanly for *all* backends should be quite
straightforward.
Instead of using ClutterActor for the base class of the Stage
implementation we should extend the StageWindow interface with
the required bits (geometry, realization) and use a simple object
class.
This require a wee bit of changes across Backend, Stage and
StageWindow, even though it's mostly re-shuffling.
First of all, StageWindow should get new virtual functions:
* geometry:
- resize()
- get_geometry()
* realization
- realize()
- unrealize()
This covers all the bits that we use from ClutterActor currently
inside the stage implementations.
The ClutterBackend::create_stage() virtual function should create
a StageWindow, and not an Actor (it should always have been; the
fact that it returned an Actor was a leak of the black magic going
on underneath). Since we never guaranteed ABI compatibility for
the Backend class, this is not a problem.
Internally to ClutterStage we can finally drop the shenanigans of
setting/unsetting actor flags on the implementation: if the realization
succeeds, for instance, we set the REALIZED flag on the Stage and
we're done.
As an initial proof of concept, the X11 and GLX stage implementations
have been ported to the New World Order(tm) and show no regressions.
An implementaton of realize() never needs to set the
CLUTTER_ACTOR_REALIZED flag, though it can unset the flag if
things fail unexpectedly. (Previously, stage backend implementations
had to do this since clutter_actor_realize() wasn't used; this
is no longer the case.)
http://bugzilla.openedhand.com/show_bug.cgi?id=1634
Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
The mapping and unmapping of the X11 stage implementation is
a bit bong. It's asynchronous, for starters, when it really
can avoid it by tracking the state internally.
The ordering of the map/unmap sequence is also broken with
respect to the resizing.
By tracking the state internally into StageX11 we can safely
remove the MapNotify and UnmapNotify X event handling.
In theory, we should use _NET_WM_STATE a lot more, and reuse
the X11 state flags for fullscreening as well.
This is the another step into abstracting the backend operations
that are currently spread all across the board back into the
backend implementations where they belong.
The GL context creation, for instance, is demanded to the stage
realization which makes it a critical path for every operation
that is GL-context bound. This usually does not make any difference
since we realize the default stage, but at some point we might
start looking into avoiding the default stage realization in order
to make the Clutter startup faster.
It also makes the code maintainable because every part is self
contained and can be reworked with the minimum amount of pain.
The XVisualInfo for GL is created when a stage is being realized.
When embedding Clutter inside another toolkit we might not want to
realize a stage to extract the XVisualInfo, then set the stage
window using a foreign X Window -- which will cause a re-realization.
Instead, we should abstract as much as possible into the X11 backend.
Unfortunately, the XVisualInfo for GL is requested using GLX API; for
this reason we have to create a ClutterBackendX11 method that we
override inside the ClutterBackendGLX implementation.
This also allows us to move a little bit of complexity from out of
the stage realization, which is currently a very delicate and hard
to debug section.
Since we are destroying any previously set VisualInfo we keep we know
for sure that stage->xvisinfo is going to be None; hence, no reason to
check this condition.
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>
This is useful because sometimes we need to get the current matrix, which
is too expensive when indirect rendering.
In addition, this virtualization makes it easier to clean up the API in
the future.
Bug 1178 - No enter / leave events on actors when pointer leaves the
stage window
The patch is mostly thanks to Johan Bilien with small modifications
based on suggestions by Owen Taylor.
The X11 backend now listens for enter and leave notifications. Leave
notifications get translated directly to a CLUTTER_LEAVE
event. Clutter can detect these special events because the source
actor is NULL in which case it sets the source actor to the last known
actor and then sets the last known actor to NULL.
Enter notifications just get translated to CLUTTER_MOTION events which
will cause Clutter to generate an enter event through the usual code
path.
* clutter/glx/clutter-stage-glx.c (clutter_stage_glx_realize):
Don't set a backing pixel on the X window. Otherwise when the
window resizes it will flicker when X paints the background
immediatly before Clutter repaints the whole stage.
* clutter/glx/clutter-stage-glx.c:
* clutter/x11/clutter-backend-x11.c:
* clutter/x11/clutter-backend-x11.h:
* clutter/x11/clutter-event-x11.c:
* clutter/x11/clutter-x11.h:
* tests/test-devices.c:
Disable use of XInput and add an explicit clutter_x11_enable_xinput
to enable it.
Also fix up the x11 pre-init calls to not need g_type_init.
release events when pointer is outside window as well as re-enabling
keyrepeat.
* clutter/glx/clutter-stage-glx.c: (clutter_stage_glx_realize): select
for KeyPressMask and KeyReleaseMask even with XInput enabled.
* clutter/x11/clutter-backend-x11.c: (_clutter_x11_register_xinput):
Disabled the XInput keyboard code paths (comments and #if 0's)
* clutter/x11/clutter-event-x11.c: (event_translate): always handle
keyboard events without regard to XInput.
* clutter/cogl/gl/cogl.c:
Temp workaround for 10.4 ATI card OSX folks, see #929
(Tommi Komulainen)
Bug 998 - clutter always captures X input events
* clutter/eglx/clutter-stage-egl.c:
* clutter/glx/clutter-stage-glx.c:
When we disable X event retrival, dont still select for window
events.
* clutter/glx/clutter-stage-glx.c:
(clutter_stage_glx_unrealize): Move the shaders release from here...
* clutter/glx/clutter-backend-glx.c:
(clutter_backend_glx_dispose): ... to here. Shaders should be
released when the GL context is being destroyed, and that only
happens when the backend is being disposed, now that we support
multiple stages.
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.
* README: Add a note about the Shader API changes.
* clutter/clutter-deprecated.h: Add deprecation symbols.
* clutter/clutter-shader.[ch]: Rename the :bound read-only
property to :compiled. Also rename clutter_shader_bind()
and clutter_shader_is_bound() to clutter_shader_compil() and
clutter_shader_is_compiled(), respectively.
* clutter/glx/clutter-stage-glx.c:
(clutter_stage_glx_unrealize): Update after
clutter_shader_release_all() rename.
* tests/test-shader.c (button_release_cb), (main): Update.
* clutter/clutter-backend.c: Add more debug messages
* clutter/clutter-stage.h:
* clutter/clutter-stage.c:
(clutter_stage_is_default): Add a function to check if the
stage is the default one.
* clutter/glx/clutter-backend-glx.c:
* clutter/glx/clutter-stage-glx.c:
* clutter/x11/clutter-stage-x11.c: Keep the stage wrapper
and implementation flags in sync, to ensure that the GL
context is always set.
Bug #864 - Allow instantiating and subclassing of ClutterStage
* clutter/Makefile.am: Add clutter-stage-window.[ch]
* clutter/clutter-stage-manager.c:
(_clutter_stage_manager_remove_stage): Do not warn if removing
a stage we don't manage, as we might be invoked multiple times
during a ClutterState dispose sequence.
* clutter/clutter-actor.c:
* clutter/clutter-backend.[ch]:
* clutter/clutter-main.c:
* clutter/clutter-private.h:
* clutter/clutter-stage.[ch]: Make ClutterStage a proxy actor,
with a private actor implementing the ClutterStageWindow
interface for handling the per-backend realization, painting
and unrealization, plus all the windowing system abstraction.
* clutter/x11/clutter-event-x11.c:
* clutter/x11/clutter-stage-x11.[ch]: Port the X11 backend
to the new backend and stage API and semantics.
* clutter/glx/clutter-backend-glx.c:
* clutter/glx/clutter-stage-glx.c: Port the GLX backend to
the new backend and stage API and semantics.
* clutter/eglx/clutter-backend-egl.[ch]:
* clutter/eglx/clutter-stage-egl.[ch]: Port the EGLX backend
to the new backend and stage API and semantics (untested).
* tests/test-multistage.c (on_button_press): Rename
clutter_stage_create_new() to clutter_stage_new().
* clutter/clutter-backend.c:
* clutter/glx/clutter-backend-glx.c:
* clutter/glx/clutter-stage-glx.c:
Allow NULL to be passed to _clutter_backend_ensure_context
which essentially clears GL context. This is hooked into stage
unrealisation. Isn't yet quite bulletproof.
Fixes issues with gtk-embed crasher (thanks to Neil).
* README:
Add notes on new multistage feature.
* clutter/clutter-stage-manager.c:
Dont ref contained stages.
* clutter/clutter-stage.c:
Automatically remove stage from stage manager on finalisation.
Cleans up warnings when a stage is destroyed.
* clutter/clutter-backend.h:
* clutter/glx/clutter-backend-glx.c:
Minor formatting cleanups.
* clutter/glx/clutter-stage-glx.c:
* configure.ac:
* clutter/clutter-version.h.in:
Add a general CLUTTER_STAGE_TYPE define, should be useful for
evntual stage subclassing and creating with g_object_new()
* clutter/clutter-group.c:
Make sure unrealizing a group also unrealizes children.
* clutter/glx/clutter-stage-glx.c:
Chain up to group unrealize to make sure textures get unrealized
when changing context (see #718)
* clutter/clutter-texture.c:
Formatting cleanups
* clutter/Makefile.am:
* clutter/eglx/Makefile.am:
* clutter/eglx/clutter-backend-egl.c:
* clutter/eglx/clutter-backend-egl.h:
* clutter/eglx/clutter-eglx.h:
* clutter/eglx/clutter-event-egl.c:
* clutter/eglx/clutter-stage-egl.c:
* clutter/eglx/clutter-stage-egl.h:
* clutter/glx/Makefile.am:
* clutter/glx/clutter-backend-glx.c:
* clutter/glx/clutter-backend-glx.h:
* clutter/glx/clutter-event-glx.c:
* clutter/glx/clutter-glx.h:
* clutter/glx/clutter-stage-glx.c:
* clutter/glx/clutter-stage-glx.h:
* clutter/x11/Makefile.am:
* clutter/x11/clutter-backend-x11-private.h:
* clutter/x11/clutter-backend-x11.c:
* clutter/x11/clutter-backend-x11.h:
* clutter/x11/clutter-event-x11.c:
* clutter/x11/clutter-stage-x11.c:
* clutter/x11/clutter-stage-x11.h:
* clutter/x11/clutter-x11.h:
Create a new X11 backend class of which EGL and GLX 'real' backends
then subclass. Effectively shares all X11 code between both backends
avoids code duplication and brings many missing features to EGL X
backend. Requires some cleanup and testing. (#518)
* clutter/cogl/gles/cogl.c: (cogl_color):
Add define to use color4ub only if configure finds it.
If not fall back to old code.
* configure.ac:
Drop support for vincent checks.
Drop sdles backend.
Specifically check for color4ub call.
* clutter/clutter-actor.c:
* clutter/clutter-event.h:
* clutter/clutter-main.c:
* clutter/clutter-stage.c:
* clutter/clutter-stage.h:
* clutter/glx/clutter-backend-glx.c:
* clutter/glx/clutter-backend-glx.h:
* clutter/glx/clutter-event-glx.c:
* clutter/glx/clutter-stage-glx.c:
* clutter/glx/clutter-stage-glx.h:
Add initial support for stage state events.
Fix fullscreening for an already mapped stage.
* tests/test-events.c:
Print out info from the above. Blue button now toggles
fullscreen.
* clutter/clutter-effect.c:
* clutter/clutter-effect.h:
Add a setting for templates to ref or clone underlying
timelines. (As to improve sync issues like those in foofone)
* tests/test-timeline.c:
Also add completed signals.
* clutter/cogl/gles/cogl.c: (cogl_texture_image_2d):
* configure.ac:
Forward port from stable branch. RGB Image fixes gles
and check for lower case libgles_cm.
* clutter/clutter-stage.[ch]: Fix clutter_stage_set_user_resizable()
name, and add a getter for the property.
* clutter/glx/clutter-stage-glx.c: Use the accessor, not
g_object_get() to retrieve the value of the resizable property.
* clutter/clutter-feature.h:
Add new stage feature flags and document.
* clutter/eglnative/clutter-backend-egl.c:
* clutter/eglx/clutter-backend-egl.c:
* clutter/sdl/clutter-backend-sdl.c:
Set new feature flags.
* clutter/glx/clutter-backend-glx.c:
* clutter/glx/clutter-stage-glx.c:
* clutter/clutter-stage.c:
* clutter/clutter-stage.h:
Add a 'user_resizeable' setting to the backend and implement
for glx backend.
Two small fixes for correctly debugging the deinitialisation
phase of the backend:
* clutter/glx/clutter-backend-glx.c: Remove the event source
after we unref the main stage.
* clutter/glx/clutter-stage-glx.c: Add a mark at the end of the
unrealize call (the perl bindings seem to crash before we reach
this point).
* clutter/clutter-event.c:
Correct clutter_event_get_state () return type. Fixes#398
* clutter/glx/clutter-stage-glx.c:
Disable use XFixes cursor visibility funcs. Appears to have issues
on feisty X Server at least. Fallback should work generally better.
Fix non offscreen clutter_stage_snapshot to also rotate read pixel
data to correct orientation.
* TODO:
Updates.
* clutter/clutter-stage.c:
* clutter/glx/clutter-stage-glx.c:
Fix cursor visibility property.
Force a repaint before mapping to attempt to avoid flicker.
* clutter/clutter-box.c: (clutter_box_pick):
Call clutter_box_paint rather than actor paint method avoiding
infinte loop (Fixes test-boxes crasher).
* clutter/glx/clutter-stage-glx.c: (clutter_stage_glx_unrealize):
Trap the X calls to avoid potential X errors.
