brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

2007-08-13 Matthew Allum <mallum@openedhand.com>

Browse Source 
* clutter/clutter-actor.c:
        * clutter/clutter-actor.h:
        * clutter/clutter-event.c:
        * clutter/clutter-event.h:
        * clutter/clutter-main.c:
        * clutter/clutter-main.h:
        * clutter/clutter-private.h:
        * clutter/clutter-stage.c:
        * clutter/clutter-stage.h:
        * clutter/clutter-types.h:
        Initial implementation of actors emmitting event signals (423);
        - Actors set_reactive() to receive mouse events.
          (call clutter_enable_motion_events() for per action motion events)
        - clutter_stage_set_key_focus () to direct key events.
        - Events bubble up to parents (ending at stage)
          (original source identified by clutter_event_get_source())
        TODO:
        - enter/leave notifys for actors.
        - stage specific events - fullscreen
        - grabs

        * tests/test-events.c:
        Extend a little to use new API

        * clutter/cogl/gl/cogl.c:
        * clutter/glx/clutter-backend-glx.c:
        Move get_proc_address into cogl and out of backend.
        (shaders will need it)

        * clutter/clutter-group.c: (clutter_group_real_lower):
        Fix a minor compile warning.

        * TODO:
        Sync up.
This commit is contained in:
Matthew Allum 2007-08-13 20:48:01 +00:00
parent e726ef9a2b
commit 8ad4dde16b
16 changed files with 913 additions and 398 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
ChangeLog
View File

@ -1,3 +1,40 @@
2007-08-13 Matthew Allum <mallum@openedhand.com>
* clutter/clutter-actor.c:
* clutter/clutter-actor.h:
* clutter/clutter-event.c:
* clutter/clutter-event.h:
* clutter/clutter-main.c:
* clutter/clutter-main.h:
* clutter/clutter-private.h:
* clutter/clutter-stage.c:
* clutter/clutter-stage.h:
* clutter/clutter-types.h:
Initial implementation of actors emmitting event signals (423);
- Actors set_reactive() to receive mouse events.
(call clutter_enable_motion_events() for per action motion events)
- clutter_stage_set_key_focus () to direct key events.
- Events bubble up to parents (ending at stage)
(original source identified by clutter_event_get_source())
TODO:
- enter/leave notifys for actors.
- stage specific events - fullscreen
- grabs
* tests/test-events.c:
Extend a little to use new API
* clutter/cogl/gl/cogl.c:
* clutter/glx/clutter-backend-glx.c:
Move get_proc_address into cogl and out of backend.
(shaders will need it)
* clutter/clutter-group.c: (clutter_group_real_lower):
Fix a minor compile warning.
* TODO:
Sync up.
2007-08-13 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-container.[ch]: Add find_child_by_id(),
@ -27,10 +64,16 @@
the per-timeout dispatch; this guarantees that the ref+unref of
the single timeouts are done under the main lock.
2007-08-12 Matthew Allum <mallum@openedhand.com>
* clutter/clutter-texture.c: (texture_upload_data):
Align texture data correctly for edge tiles.
(#422 - Neil Roberts)
2007-08-11 Matthew Allum <mallum@openedhand.com>
* clutter/clutter-texture.c:
Fix typo in clutter_texture_get_pixbuf (#458, #442?, Neil Roberts).
Fix typo in clutter_texture_get_pixbuf (#458, Neil Roberts).
Use take_object when getting pixbuf prop to avoid ref leak. (Neil
Roberts)

41
TODO
View File

@ -1,31 +1,7 @@
TODO
====
Last updated 22/06/2007
0.4 (July 07)
==
Definetly:
- YUV texture data [DONE] premulled alpha texture data. (ma)
- Basic layout code. [DONE] (eb)
- Basic text entry [DONE] (np)
- Perspective setup [DONE] (ma)
- API doc fixups (all)
- main loop scheduling - paints vs timelimes vs events [DONE] ((ma, eb)
- ClutterProxyTexture (ma)
- event queue fixups [DONE} (eb)
- clutter_actor_get_vertices [Partly DONE?] (tf)
- fix up event queue [DONE] (eb)
Maybe:
- SDL event fixups [DONE - roughly]
- Application developers manual
- Lookat type functionality.
- Mipmaps for pango renderer to improving text scaling quality
Last updated 08/08/2007
0.6
===
@ -41,10 +17,13 @@ Definetly:
- Very simple focus model - actors have a focus flag and if set emit
key events.
- Motion events need to be explicitly enabled.
- Mipmaps for pango renderer to improving text scaling quality
- ClutterScore
- Class for chaining timelines togeather
Nice/Maybe:
===========
- Lookat type functionality.
- Improve cogl massively to be be processing like.
- Gradient support ?
- Rectangle like props to all actors
@ -53,4 +32,12 @@ Nice/Maybe:
- Apple/Win native backends.
- ClutterBehaviourDepth (trivial)
- ClutterTextureAnimation (trivial)
- Glitz backend over GLX (would cover above)
- Glitz backend over GLX (would cover above)
(Also see bugzilla.o-hand.com bug with 0.6 milestones for more
detail/status on the above)
0.8
===
- ?

356
clutter/clutter-actor.c
View File

@ -91,7 +91,16 @@ enum
HIDE,
DESTROY,
PARENT_SET,
EVENT,
EVENT_AFTER,
BUTTON_PRESS_EVENT,
BUTTON_RELEASE_EVENT,
SCROLL_EVENT,
KEY_PRESS_EVENT,
KEY_RELEASE_EVENT,
MOTION_EVENT,
FOCUS_IN,
FOCUS_OUT,
LAST_SIGNAL
};
@ -193,11 +202,14 @@ clutter_actor_hide (ClutterActor *self)
{
g_object_ref (self);
if (CLUTTER_ACTOR_IS_REACTIVE(self))
; /* FIXME: decrease global reactive count */
g_signal_emit (self, actor_signals[HIDE], 0);
g_object_notify (G_OBJECT (self), "visible");
g_object_unref (self);
}
}
}
/**
@ -678,26 +690,32 @@ clutter_actor_paint (ClutterActor *self)
_clutter_actor_apply_modelview_transform (self);
if (G_UNLIKELY(context->pick_mode == TRUE))
if (G_UNLIKELY(context->pick_mode != CLUTTER_PICK_NONE))
{
gint r, g, b;
ClutterColor col;
guint32 id;
id = clutter_actor_get_id (self);
if (context->pick_mode == CLUTTER_PICK_ALL
|| (context->pick_mode == CLUTTER_PICK_REACTIVE
&& CLUTTER_ACTOR_IS_REACTIVE(self)))
{
id = clutter_actor_get_id (self);
cogl_get_bitmasks (&r, &g, &b, NULL);
cogl_get_bitmasks (&r, &g, &b, NULL);
/* Encode the actor id into a color, taking into account bpp */
col.red = ((id >> (g+b)) & (0xff>>(8-r)))<<(8-r);
col.green = ((id >> b) & (0xff>>(8-g))) << (8-g);
col.blue = (id & (0xff>>(8-b)))<<(8-b);
col.alpha = 0xff;
/* Encode the actor id into a color, taking into account bpp */
col.red = ((id >> (g+b)) & (0xff>>(8-r)))<<(8-r);
col.green = ((id >> b) & (0xff>>(8-g))) << (8-g);
col.blue = (id & (0xff>>(8-b)))<<(8-b);
col.alpha = 0xff;
/* Actor will then paint silhouette of itself in supplied color.
* See clutter_stage_get_actor_at_pos() for where picking is enabled.
*/
clutter_actor_pick (self, &col);
/* Actor will then paint silhouette of itself in supplied
* color. See clutter_stage_get_actor_at_pos() for where
* picking is enabled.
*/
clutter_actor_pick (self, &col);
}
}
else
{
@ -1151,6 +1169,195 @@ clutter_actor_class_init (ClutterActorClass *klass)
G_TYPE_NONE, 1,
CLUTTER_TYPE_ACTOR);
/**
* ClutterActor::event:
* @actor: the actor which received the event
* @event: a #ClutterEvent
*
* The ::event signal is emitted each time and event is received
* by the @actor.
*
* Since: 0.6
*/
actor_signals[EVENT] =
g_signal_new ("event",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterActorClass, event),
NULL, NULL,
clutter_marshal_VOID__BOXED,
G_TYPE_NONE, 1,
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
/**
* ClutterActor::event-after:
* @actor: the actor which received the event
* @event: a #ClutterEvent
*
* The ::event-after signal is emitted after each event, except for
* the "delete-event" is received by @actor.
*
* Since: 0.6
*/
actor_signals[EVENT_AFTER] =
g_signal_new ("event-after",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterActorClass, event_after),
NULL, NULL,
clutter_marshal_VOID__BOXED,
G_TYPE_NONE, 1,
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
/**
* ClutterActor::button-press-event:
* @actor: the actor which received the event
* @event: a #ClutterButtonEvent
*
* The ::button-press-event signal is emitted each time a mouse button
* is pressed on @actor.
*
* Since: 0.6
*/
actor_signals[BUTTON_PRESS_EVENT] =
g_signal_new ("button-press-event",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterActorClass, button_press_event),
NULL, NULL,
clutter_marshal_VOID__BOXED,
G_TYPE_NONE, 1,
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
/**
* ClutterActor::button-release-event:
* @actor: the actor which received the event
* @event: a #ClutterButtonEvent
*
* The ::button-release-event signal is emitted each time a mouse button
* is released on @actor.
*
* Since: 0.6
*/
actor_signals[BUTTON_RELEASE_EVENT] =
g_signal_new ("button-release-event",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterActorClass, button_release_event),
NULL, NULL,
clutter_marshal_VOID__BOXED,
G_TYPE_NONE, 1,
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
/**
* ClutterActor::scroll-event:
* @actor: the actor which received the event
* @event: a #ClutterScrollEvent
*
* The ::scroll-event signal is emitted each time a the mouse is
* scrolled on @actor
*
*
* Since: 0.6
*/
actor_signals[SCROLL_EVENT] =
g_signal_new ("scroll-event",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterActorClass, scroll_event),
NULL, NULL,
clutter_marshal_VOID__BOXED,
G_TYPE_NONE, 1,
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
/**
* ClutterActor::key-press-event:
* @actor: the actor which received the event
* @event: a #ClutterKeyEvent
*
* The ::key-press-event signal is emitted each time a keyboard button
* is pressed on @actor.
*
* Since: 0.6
*/
actor_signals[KEY_PRESS_EVENT] =
g_signal_new ("key-press-event",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterActorClass, key_press_event),
NULL, NULL,
clutter_marshal_VOID__BOXED,
G_TYPE_NONE, 1,
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
/**
* ClutterActor::key-release-event:
* @actor: the actor which received the event
* @event: a #ClutterKeyEvent
*
* The ::key-release-event signal is emitted each time a keyboard button
* is released on @actor.
*
* Since: 0.6
*/
actor_signals[KEY_RELEASE_EVENT] =
g_signal_new ("key-release-event",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterActorClass, key_release_event),
NULL, NULL,
clutter_marshal_VOID__BOXED,
G_TYPE_NONE, 1,
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
/**
* ClutterActor::motion-event:
* @actor: the actor which received the event
* @event: a #ClutterMotionEvent
*
* The ::motion-event signal is emitted each time the mouse pointer is
* moved on @actor.
*
* Since: 0.6
*/
actor_signals[MOTION_EVENT] =
g_signal_new ("motion-event",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterActorClass, motion_event),
NULL, NULL,
clutter_marshal_VOID__BOXED,
G_TYPE_NONE, 1,
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
/**
* ClutterActor::focus-in:
* @actor: the actor which now has key focus
*
* The ::focus-in signal is emitted when @actor recieves key focus.
*
* Since: 0.6
*/
actor_signals[FOCUS_IN] =
g_signal_new ("focus-in",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterActorClass, focus_in),
NULL, NULL,
clutter_marshal_VOID__VOID,
G_TYPE_NONE, 0);
/**
* ClutterActor::focus-out:
* @actor: the actor which now has key focus
*
* The ::focus-out signal is emitted when @actor loses key focus.
*
* Source: 0.6
*/
actor_signals[FOCUS_OUT] =
g_signal_new ("focus-out",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterActorClass, focus_out),
NULL, NULL,
clutter_marshal_VOID__VOID,
G_TYPE_NONE, 0);
klass->show = clutter_actor_real_show;
klass->show_all = clutter_actor_show;
klass->hide = clutter_actor_real_hide;
@ -2598,6 +2805,104 @@ clutter_actor_lower_bottom (ClutterActor *self)
clutter_actor_lower (self, NULL);
}
/*
* Event handling
*/
/**
* clutter_actor_event:
* @actor: a #ClutterActor
* @event: a #ClutterEvent
*
* This function is used to emit an event on the main stage.
* You should rarely need to use this function, except for
* synthetising events.
*
* Return value: the return value from the signal emission
*
* Since: 0.4
*/
gboolean
clutter_actor_event (ClutterActor *actor,
ClutterEvent *event)
{
gboolean res = TRUE;
gint signal_num = -1;
g_return_val_if_fail (CLUTTER_IS_ACTOR (actor), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
g_object_ref (actor);
g_signal_emit (actor, actor_signals[EVENT], 0, event);
switch (event->type)
{
case CLUTTER_NOTHING:
break;
case CLUTTER_BUTTON_PRESS:
case CLUTTER_2BUTTON_PRESS:
case CLUTTER_3BUTTON_PRESS:
signal_num = BUTTON_PRESS_EVENT;
break;
case CLUTTER_BUTTON_RELEASE:
signal_num = BUTTON_RELEASE_EVENT;
break;
case CLUTTER_SCROLL:
signal_num = SCROLL_EVENT;
break;
case CLUTTER_KEY_PRESS:
signal_num = KEY_PRESS_EVENT;
break;
case CLUTTER_KEY_RELEASE:
signal_num = KEY_RELEASE_EVENT;
break;
case CLUTTER_MOTION:
signal_num = MOTION_EVENT;
break;
case CLUTTER_DELETE:
signal_num = -1;
break;
case CLUTTER_DESTROY_NOTIFY:
signal_num = -1;
break;
case CLUTTER_CLIENT_MESSAGE:
signal_num = -1;
break;
default:
break;
}
if (signal_num != -1)
{
g_signal_emit (actor, actor_signals[signal_num], 0, event);
g_signal_emit (actor, actor_signals[EVENT_AFTER], 0, event);
res = TRUE;
}
g_object_unref (actor);
return res;
}
void
clutter_actor_set_reactive (ClutterActor *actor)
{
CLUTTER_ACTOR_SET_FLAGS (actor, CLUTTER_ACTOR_REACTIVE);
}
void
clutter_actor_unset_reactive (ClutterActor *actor)
{
CLUTTER_ACTOR_UNSET_FLAGS (actor, CLUTTER_ACTOR_REACTIVE);
}
gboolean
clutter_actor_is_reactive (ClutterActor *actor)
{
return CLUTTER_ACTOR_IS_REACTIVE(actor);
}
/*
* ClutterGemoetry
*/
@ -2618,9 +2923,10 @@ clutter_geometry_get_type (void)
static GType our_type = 0;
if (our_type == 0)
our_type = g_boxed_type_register_static (g_intern_static_string ("ClutterGeometry"),
(GBoxedCopyFunc) clutter_geometry_copy,
(GBoxedFreeFunc) g_free);
our_type = g_boxed_type_register_static
(g_intern_static_string ("ClutterGeometry"),
(GBoxedCopyFunc) clutter_geometry_copy,
(GBoxedFreeFunc) g_free);
return our_type;
}
@ -2645,9 +2951,10 @@ clutter_vertex_get_type (void)
static GType our_type = 0;
if (our_type == 0)
our_type = g_boxed_type_register_static (g_intern_static_string ("ClutterVertex"),
(GBoxedCopyFunc) clutter_vertex_copy,
(GBoxedFreeFunc) g_free);
our_type = g_boxed_type_register_static
(g_intern_static_string ("ClutterVertex"),
(GBoxedCopyFunc) clutter_vertex_copy,
(GBoxedFreeFunc) g_free);
return our_type;
}
@ -2671,9 +2978,10 @@ clutter_actor_box_get_type (void)
static GType our_type = 0;
if (our_type == 0)
our_type = g_boxed_type_register_static (g_intern_static_string ("ClutterActorBox"),
(GBoxedCopyFunc) clutter_actor_box_copy,
(GBoxedFreeFunc) g_free);
our_type = g_boxed_type_register_static
(g_intern_static_string ("ClutterActorBox"),
(GBoxedCopyFunc) clutter_actor_box_copy,
(GBoxedFreeFunc) g_free);
return our_type;
}

44
clutter/clutter-actor.h
View File

@ -33,6 +33,7 @@
#include <clutter/clutter-fixed.h>
#include <clutter/clutter-types.h>
#include <clutter/clutter-units.h>
#include <clutter/clutter-event.h>
G_BEGIN_DECLS
@ -57,8 +58,10 @@ G_BEGIN_DECLS
#define CLUTTER_ACTOR_IS_REALIZED(e) ((e)->flags & CLUTTER_ACTOR_REALIZED)
#define CLUTTER_ACTOR_IS_VISIBLE(e) (CLUTTER_ACTOR_IS_MAPPED (e) && \
CLUTTER_ACTOR_IS_REALIZED (e))
#define CLUTTER_ACTOR_IS_REACTIVE(e) (((e)->flags & CLUTTER_ACTOR_REACTIVE))
/* && CLUTTER_ACTOR_IS_VISIBLE(e)) */
typedef struct _ClutterActor ClutterActor;
typedef struct _ClutterActorClass ClutterActorClass;
typedef struct _ClutterActorBox ClutterActorBox;
typedef struct _ClutterActorPrivate ClutterActorPrivate;
@ -78,13 +81,16 @@ typedef void (*ClutterCallback) (ClutterActor *actor, gpointer data);
* @CLUTTER_ACTOR_MAPPED: the actor has been painted
* @CLUTTER_ACTOR_REALIZED: the resources associated to the actor have been
* allocated
* @CLUTTER_ACTOR_REACTIVE: the actor 'reacts' to mouse events emmitting event
* signals
*
* Flags used to signal the state of an actor.
*/
typedef enum
{
CLUTTER_ACTOR_MAPPED = 1 << 1,
CLUTTER_ACTOR_REALIZED = 1 << 2
CLUTTER_ACTOR_REALIZED = 1 << 2,
CLUTTER_ACTOR_REACTIVE = 1 << 3
} ClutterActorFlags;
/**
@ -186,6 +192,26 @@ struct _ClutterActorClass
void (* pick) (ClutterActor *actor,
const ClutterColor *color);
/* event signals */
void (* event) (ClutterActor *actor,
ClutterEvent *event);
void (* event_after) (ClutterActor *actor,
ClutterEvent *event);
void (* button_press_event) (ClutterActor *actor,
ClutterButtonEvent *event);
void (* button_release_event) (ClutterActor *actor,
ClutterButtonEvent *event);
void (* scroll_event) (ClutterActor *actor,
ClutterScrollEvent *event);
void (* key_press_event) (ClutterActor *actor,
ClutterKeyEvent *event);
void (* key_release_event) (ClutterActor *actor,
ClutterKeyEvent *event);
void (* motion_event) (ClutterActor *actor,
ClutterMotionEvent *event);
void (* focus_in) (ClutterActor *actor);
void (* focus_out) (ClutterActor *actor);
/*< private >*/
/* padding for future expansion */
gpointer _padding_dummy[32];
@ -335,6 +361,20 @@ void clutter_actor_get_vertices (ClutterActor
void clutter_actor_apply_transform_to_point (ClutterActor *self,
ClutterVertex *point,
ClutterVertex *vertex);
/* Per actor event handling - may change */
gboolean
clutter_actor_event (ClutterActor *actor,
ClutterEvent *event);
void
clutter_actor_set_reactive (ClutterActor *actor);
void
clutter_actor_unset_reactive (ClutterActor *actor);
gboolean
clutter_actor_is_reactive (ClutterActor *actor);
G_END_DECLS

43
clutter/clutter-event.c
View File

@ -183,6 +183,49 @@ clutter_event_get_coords (ClutterEvent *event,
*y = event_y;
}
/**
* clutter_event_get_source:
* @event: a #ClutterEvent
*
* Retrieves the source #ClutterActor the event originated from, or
* NULL if the event has no source.
*
* Since: 0.6
*/
ClutterActor*
clutter_event_get_source (ClutterEvent *event)
{
ClutterActor *res = NULL;
gint event_x, event_y;
g_return_val_if_fail (event != NULL, NULL);
event_x = event_y = 0;
switch (event->type)
{
case CLUTTER_KEY_PRESS:
case CLUTTER_KEY_RELEASE:
res = event->key.source;
break;
case CLUTTER_BUTTON_PRESS:
case CLUTTER_2BUTTON_PRESS:
case CLUTTER_BUTTON_RELEASE:
res = event->button.source;
break;
case CLUTTER_MOTION:
res = event->motion.source;
break;
case CLUTTER_SCROLL:
res = event->scroll.source;
break;
default:
break;
}
return res;
}
/**
* clutter_button_event_button:
* @buttev: a #ClutterButtonEvent

17
clutter/clutter-event.h
View File

@ -27,6 +27,7 @@
#define _HAVE_CLUTTER_EVENT_H
#include <glib-object.h>
#include <clutter/clutter-types.h>
#define CLUTTER_TYPE_EVENT (clutter_event_get_type ())
#define CLUTTER_PRIORITY_EVENTS (G_PRIORITY_DEFAULT)
@ -78,10 +79,12 @@ typedef enum
typedef enum
{
CLUTTER_STAGE_STATE_FULLSCREEN,
CLUTTER_STAGE_STATE_MAXIMIZED,
CLUTTER_STAGE_STATE_MINIMIZED,
CLUTTER_STAGE_STATE_OFFSCREEN
CLUTTER_STAGE_STATE_FULLSCREEN = (1<<1),
CLUTTER_STAGE_STATE_OFFSCREEN = (1<<2),
CLUTTER_STAGE_STATE_POINTER_ENTER = (1<<3),
CLUTTER_STAGE_STATE_POINTER_LEAVE = (1<<4),
CLUTTER_STAGE_STATE_FOCUS_ACTIVATE = (1<<5),
CLUTTER_STAGE_STATE_FOCUS_DEACTIVATE = (1<<6),
} ClutterStageState;
typedef union _ClutterEvent ClutterEvent;
@ -107,6 +110,7 @@ struct _ClutterKeyEvent
ClutterModifierType modifier_state;
guint keyval;
guint16 hardware_keycode;
ClutterActor *source;
};
struct _ClutterButtonEvent
@ -119,6 +123,7 @@ struct _ClutterButtonEvent
guint32 button;
gdouble *axes; /* Future use */
ClutterInputDevice *device; /* Future use */
ClutterActor *source;
};
struct _ClutterMotionEvent
@ -130,6 +135,7 @@ struct _ClutterMotionEvent
ClutterModifierType modifier_state;
gdouble *axes; /* Future use */
ClutterInputDevice *device; /* Future use */
ClutterActor *source;
};
struct _ClutterScrollEvent
@ -142,6 +148,7 @@ struct _ClutterScrollEvent
ClutterModifierType modifier_state;
gdouble *axes; /* future use */
ClutterInputDevice *device; /* future use */
ClutterActor *source;
};
struct _ClutterStageStateEvent
@ -187,6 +194,8 @@ guint32 clutter_button_event_button (ClutterButtonEvent *buttev);
guint32 clutter_keysym_to_unicode (guint keyval);
ClutterActor* clutter_event_get_source (ClutterEvent *event);
G_END_DECLS
#endif

1
clutter/clutter-group.c
View File

@ -368,7 +368,6 @@ clutter_group_real_lower (ClutterContainer *container,
{
ClutterGroup *self = CLUTTER_GROUP (container);
ClutterGroupPrivate *priv = self->priv;
gint pos;
priv->children = g_list_remove (priv->children, actor);

152
clutter/clutter-main.c
View File

@ -172,6 +172,23 @@ clutter_redraw (void)
CLUTTER_TIMESTAMP (SCHEDULER, "Redraw finish");
}
void
clutter_enable_motion_events (gboolean enable)
{
ClutterMainContext *context = clutter_context_get_default ();
context->motion_events_per_actor = enable;
}
gboolean
clutter_get_motion_events_enabled (void)
{
ClutterMainContext *context = clutter_context_get_default ();
return context->motion_events_per_actor;
}
/**
* clutter_do_event
* @event: a #ClutterEvent.
@ -183,9 +200,10 @@ clutter_redraw (void)
void
clutter_do_event (ClutterEvent *event)
{
ClutterMainContext *context;
ClutterBackend *backend;
ClutterActor *stage;
ClutterMainContext *context;
ClutterBackend *backend;
ClutterActor *stage;
static ClutterActor *motion_last_actor = NULL;
context = clutter_context_get_default ();
backend = context->backend;
@ -195,6 +213,10 @@ clutter_do_event (ClutterEvent *event)
CLUTTER_TIMESTAMP (SCHEDULER, "Event recieved");
/* TODO:
*
*/
switch (event->type)
{
case CLUTTER_NOTHING:
@ -202,27 +224,145 @@ clutter_do_event (ClutterEvent *event)
case CLUTTER_DESTROY_NOTIFY:
case CLUTTER_DELETE:
/* FIXME: handle delete working in stage */
if (clutter_stage_event (CLUTTER_STAGE (stage), event))
clutter_main_quit ();
break;
case CLUTTER_KEY_PRESS:
case CLUTTER_KEY_RELEASE:
{
ClutterActor *actor = NULL;
actor = clutter_stage_get_key_focus (CLUTTER_STAGE(stage));
g_return_if_fail (actor != NULL);
/* FIXME: should we ref ? */
event->key.source = actor;
/* bubble up */
do
{
clutter_actor_event (actor, event);
actor = clutter_actor_get_parent(actor);
}
while (actor != NULL);
}
break;
case CLUTTER_MOTION:
if (context->motion_events_per_actor == FALSE)
{
/* Only stage gets motion events */
event->motion.source = stage;
clutter_actor_event (stage, event);
break;
}
case CLUTTER_BUTTON_PRESS:
case CLUTTER_2BUTTON_PRESS:
case CLUTTER_3BUTTON_PRESS:
case CLUTTER_BUTTON_RELEASE:
case CLUTTER_SCROLL:
clutter_stage_event (CLUTTER_STAGE (stage), event);
break;
{
ClutterActor *actor;
gint x,y;
clutter_event_get_coords (event, &x, &y);
/* Map the event to a reactive actor */
actor = _clutter_do_pick (CLUTTER_STAGE (stage),
x, y,
CLUTTER_PICK_REACTIVE);
CLUTTER_NOTE (EVENT, "Reactive event recieved at %ix%i - actor: %p",
x, y, actor);
if (event->type == CLUTTER_SCROLL)
event->scroll.source = actor;
else
event->button.source = actor;
/* Motion enter leave events */
if (event->type == CLUTTER_MOTION)
{
if (motion_last_actor != actor)
{
if (motion_last_actor)
; /* FIXME: leave_notify to motion_last_actor */
if (actor)
; /* FIXME: Enter notify to actor */
}
motion_last_actor = actor;
}
/* Send the event to the actor and all parents always the
* stage.
*
* FIXME: for an optimisation should check if there are
* actually any reactive actors and avoid the pick all togeather
* (signalling just the stage). Should be big help for gles.
*/
while (actor)
{
if (clutter_actor_is_reactive (actor)
|| clutter_actor_get_parent(actor) == NULL /* STAGE */ )
{
CLUTTER_NOTE (EVENT, "forwarding event to reactive actor");
clutter_actor_event (actor, event);
}
actor = clutter_actor_get_parent(actor);
}
}
break;
case CLUTTER_STAGE_STATE:
/* FIXME: fullscreen / focus / mouse - forward to stage */
break;
case CLUTTER_CLIENT_MESSAGE:
break;
}
}
ClutterActor*
_clutter_do_pick (ClutterStage *stage,
gint x,
gint y,
ClutterPickMode mode)
{
ClutterMainContext *context;
guchar pixel[4];
GLint viewport[4];
ClutterColor white = { 0xff, 0xff, 0xff, 0xff };
guint32 id;
gint r,g,b;
context = clutter_context_get_default ();
cogl_paint_init (&white);
cogl_enable (0);
/* Render the entire scence in pick mode - just single colored silhouette's
* are drawn offscreen (as we never swap buffers)
*/
context->pick_mode = mode;
clutter_actor_paint (CLUTTER_ACTOR (stage));
context->pick_mode = CLUTTER_PICK_NONE;
/* Calls should work under both GL and GLES, note GLES needs RGBA */
glGetIntegerv(GL_VIEWPORT, viewport);
glReadPixels(x, viewport[3] - y, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, pixel);
if (pixel[0] == 0xff && pixel[1] == 0xff && pixel[2] == 0xff)
return CLUTTER_ACTOR(stage);
cogl_get_bitmasks (&r, &g, &b, NULL);
/* Decode color back into an ID, taking into account fb depth */
id = pixel[2]>>(8-b) | pixel[1]<<b>>(8-g) | pixel[0]<<(g+b)>>(8-r);
return clutter_container_find_child_by_id (CLUTTER_CONTAINER (stage), id);
}
/**
* clutter_main_quit:
*

5
clutter/clutter-main.h
View File

@ -100,6 +100,11 @@ guint clutter_threads_add_timeout_full (gint priority,
gpointer data,
GDestroyNotify notify);
void clutter_enable_motion_events (gboolean enable);
gboolean clutter_get_motion_events_enabled (void);
G_END_DECLS
#endif /* _HAVE_CLUTTER_MAIN_H */

43
clutter/clutter-private.h
View File

@ -43,6 +43,24 @@
G_BEGIN_DECLS
typedef enum {
CLUTTER_ACTOR_UNUSED_FLAG = 0,
CLUTTER_ACTOR_IN_DESTRUCTION = 1 << 0,
CLUTTER_ACTOR_IS_TOPLEVEL = 1 << 1,
CLUTTER_ACTOR_IN_REPARENT = 1 << 2,
CLUTTER_ACTOR_SYNC_MATRICES = 1 << 3 /* Used by stage to indicate GL
* viewport / perspective etc
* needs (re)setting.
*/
} ClutterPrivateFlags;
typedef enum {
CLUTTER_PICK_NONE = 0,
CLUTTER_PICK_REACTIVE,
CLUTTER_PICK_ALL
} ClutterPickMode;
typedef struct _ClutterMainContext ClutterMainContext;
struct _ClutterMainContext
@ -58,28 +76,16 @@ struct _ClutterMainContext
guint update_idle;
guint is_initialized : 1;
guint pick_mode : 1; /* Indicates pick render mode */
GTimer *timer; /* Used for debugging scheduler */
ClutterPickMode pick_mode; /* Indicates pick render mode */
guint motion_events_per_actor : 1;
gint num_reactives; /* Num of reactive actors */
};
#define CLUTTER_CONTEXT() (clutter_context_get_default ())
ClutterMainContext *clutter_context_get_default (void);
const gchar *clutter_vblank_method (void);
typedef enum {
CLUTTER_ACTOR_UNUSED_FLAG = 0,
CLUTTER_ACTOR_IN_DESTRUCTION = 1 << 0,
CLUTTER_ACTOR_IS_TOPLEVEL = 1 << 1,
CLUTTER_ACTOR_IN_REPARENT = 1 << 2,
CLUTTER_ACTOR_SYNC_MATRICES = 1 << 3 /* Used by stage to indicate GL
* viewport / perspective etc
* needs (re)setting.
*/
} ClutterPrivateFlags;
#define CLUTTER_PRIVATE_FLAGS(a) (CLUTTER_ACTOR ((a))->private_flags)
#define CLUTTER_SET_PRIVATE_FLAGS(a,f) G_STMT_START{ (CLUTTER_PRIVATE_FLAGS (a) |= (f)); }G_STMT_END
#define CLUTTER_UNSET_PRIVATE_FLAGS(a,f) G_STMT_START{ (CLUTTER_PRIVATE_FLAGS (a) &= ~(f)); }G_STMT_END
@ -123,6 +129,11 @@ void _clutter_event_button_generate (ClutterBackend *backend,
void _clutter_feature_init (void);
ClutterActor* _clutter_do_pick (ClutterStage *stage,
gint x,
gint y,
ClutterPickMode mode);
/* Does this need to be private ? */
void clutter_do_event (ClutterEvent *event);

309
clutter/clutter-stage.c
View File

@ -64,6 +64,7 @@ struct _ClutterStagePrivate
guint is_user_resizable : 1;
gchar *title;
ClutterActor *key_focused_actor;
};
enum
@ -81,16 +82,9 @@ enum
enum
{
EVENT,
EVENT_AFTER,
BUTTON_PRESS_EVENT,
BUTTON_RELEASE_EVENT,
SCROLL_EVENT,
KEY_PRESS_EVENT,
KEY_RELEASE_EVENT,
MOTION_EVENT,
STAGE_STATE_EVENT,
ACTIVATE_STAGE,
DEACTIVATE_STAGE,
LAST_SIGNAL
};
@ -285,145 +279,6 @@ clutter_stage_class_init (ClutterStageClass *klass)
"Stage Title",
NULL,
CLUTTER_PARAM_READWRITE));
/**
* ClutterStage::event:
* @stage: the actor which received the event
* @event: a #ClutterEvent
*
* The ::event signal is emitted each time and event is received
* by the @stage.
*/
stage_signals[EVENT] =
g_signal_new ("event",
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterStageClass, event),
NULL, NULL,
clutter_marshal_VOID__BOXED,
G_TYPE_NONE, 1,
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
/**
* ClutterStage::event-after:
* @stage: the actor which received the event
* @event: a #ClutterEvent
*
* The ::event-after signal is emitted after each event, except for
* the "delete-event" is received by @stage.
*/
stage_signals[EVENT_AFTER] =
g_signal_new ("event-after",
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterStageClass, event_after),
NULL, NULL,
clutter_marshal_VOID__BOXED,
G_TYPE_NONE, 1,
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
/**
* ClutterStage::button-press-event:
* @stage: the actor which received the event
* @event: a #ClutterButtonEvent
*
* The ::button-press-event signal is emitted each time a mouse button
* is pressed on @stage.
*/
stage_signals[BUTTON_PRESS_EVENT] =
g_signal_new ("button-press-event",
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterStageClass, button_press_event),
NULL, NULL,
clutter_marshal_VOID__BOXED,
G_TYPE_NONE, 1,
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
/**
* ClutterStage::button-release-event:
* @stage: the actor which received the event
* @event: a #ClutterButtonEvent
*
* The ::button-release-event signal is emitted each time a mouse button
* is released on @stage.
*/
stage_signals[BUTTON_RELEASE_EVENT] =
g_signal_new ("button-release-event",
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterStageClass, button_release_event),
NULL, NULL,
clutter_marshal_VOID__BOXED,
G_TYPE_NONE, 1,
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
/**
* ClutterStage::scroll-event:
* @stage: the actor which received the event
* @event: a #ClutterScrollEvent
*
* The ::scroll-event signal is emitted each time a the mouse is
* scrolled on @stage
*
* Since: 0.4
*/
stage_signals[SCROLL_EVENT] =
g_signal_new ("scroll-event",
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterStageClass, scroll_event),
NULL, NULL,
clutter_marshal_VOID__BOXED,
G_TYPE_NONE, 1,
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
/**
* ClutterStage::key-press-event:
* @stage: the actor which received the event
* @event: a #ClutterKeyEvent
*
* The ::key-press-event signal is emitted each time a keyboard button
* is pressed on @stage.
*/
stage_signals[KEY_PRESS_EVENT] =
g_signal_new ("key-press-event",
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterStageClass, key_press_event),
NULL, NULL,
clutter_marshal_VOID__BOXED,
G_TYPE_NONE, 1,
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
/**
* ClutterStage::key-release-event:
* @stage: the actor which received the event
* @event: a #ClutterKeyEvent
*
* The ::key-release-event signal is emitted each time a keyboard button
* is released on @stage.
*/
stage_signals[KEY_RELEASE_EVENT] =
g_signal_new ("key-release-event",
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterStageClass, key_release_event),
NULL, NULL,
clutter_marshal_VOID__BOXED,
G_TYPE_NONE, 1,
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
/**
* ClutterStage::motion-event:
* @stage: the actor which received the event
* @event: a #ClutterMotionEvent
*
* The ::motion-event signal is emitted each time the mouse pointer is
* moved on @stage.
*/
stage_signals[MOTION_EVENT] =
g_signal_new ("motion-event",
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterStageClass, motion_event),
NULL, NULL,
clutter_marshal_VOID__BOXED,
G_TYPE_NONE, 1,
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
g_type_class_add_private (gobject_class, sizeof (ClutterStagePrivate));
}
@ -454,6 +309,9 @@ clutter_stage_init (ClutterStage *self)
priv->perspective.z_far = CLUTTER_FLOAT_TO_FIXED (100.0);
clutter_actor_set_size (CLUTTER_ACTOR (self), 640, 480);
clutter_actor_set_reactive (CLUTTER_ACTOR (self));
clutter_stage_set_key_focus (self, CLUTTER_ACTOR (self));
}
/**
@ -853,40 +711,7 @@ clutter_stage_get_actor_at_pos (ClutterStage *stage,
gint x,
gint y)
{
ClutterMainContext *context;
guchar pixel[4];
GLint viewport[4];
ClutterColor white = { 0xff, 0xff, 0xff, 0xff };
guint32 id;
gint r,g,b;
context = clutter_context_get_default ();
cogl_paint_init (&white);
cogl_enable (0);
/* Render the entire scence in pick mode - just single colored silhouette's
* are drawn offscreen (as we never swap buffers)
*/
context->pick_mode = TRUE;
clutter_actor_paint (CLUTTER_ACTOR (stage));
context->pick_mode = FALSE;
/* Calls should work under both GL and GLES, note GLES needs RGBA */
glGetIntegerv (GL_VIEWPORT, viewport);
glReadPixels (x, viewport[3] - y, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, pixel);
if (pixel[0] == 0xff && pixel[1] == 0xff && pixel[2] == 0xff)
return CLUTTER_ACTOR(stage);
cogl_get_bitmasks (&r, &g, &b, NULL);
/* Decode color back into an ID, taking into account fb depth */
id = pixel[2] >> (8 - b)
| pixel[1] << b >> (8 - g)
| pixel[0] << (g + b) >> (8 - r);
return clutter_container_find_child_by_id (CLUTTER_CONTAINER (stage), id);
return _clutter_do_pick (stage, x, y, CLUTTER_PICK_ALL);
}
/**
@ -906,64 +731,12 @@ gboolean
clutter_stage_event (ClutterStage *stage,
ClutterEvent *event)
{
gboolean res = TRUE;
gint signal_num = -1;
g_return_val_if_fail (CLUTTER_IS_STAGE (stage), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
g_object_ref (stage);
/* FIXME: Handle StageState Changes and Delete events */
g_signal_emit (stage, stage_signals[EVENT], 0, event);
switch (event->type)
{
case CLUTTER_NOTHING:
break;
case CLUTTER_BUTTON_PRESS:
case CLUTTER_2BUTTON_PRESS:
case CLUTTER_3BUTTON_PRESS:
signal_num = BUTTON_PRESS_EVENT;
break;
case CLUTTER_BUTTON_RELEASE:
signal_num = BUTTON_RELEASE_EVENT;
break;
case CLUTTER_SCROLL:
signal_num = SCROLL_EVENT;
break;
case CLUTTER_KEY_PRESS:
signal_num = KEY_PRESS_EVENT;
break;
case CLUTTER_KEY_RELEASE:
signal_num = KEY_RELEASE_EVENT;
break;
case CLUTTER_MOTION:
signal_num = MOTION_EVENT;
break;
case CLUTTER_DELETE:
signal_num = -1;
break;
case CLUTTER_STAGE_STATE:
signal_num = -1;
break;
case CLUTTER_DESTROY_NOTIFY:
signal_num = -1;
break;
case CLUTTER_CLIENT_MESSAGE:
signal_num = -1;
break;
}
if (signal_num != -1)
{
g_signal_emit (stage, stage_signals[signal_num], 0, event);
g_signal_emit (stage, stage_signals[EVENT_AFTER], 0, event);
res = TRUE;
}
g_object_unref (stage);
return res;
return TRUE;
}
/**
@ -1014,6 +787,70 @@ clutter_stage_get_title (ClutterStage *stage)
return stage->priv->title;
}
static void
on_key_focused_weak_notify (gpointer data,
GObject *where_the_object_was)
{
ClutterStagePrivate *priv;
ClutterStage *stage = CLUTTER_STAGE(data);
g_return_if_fail (CLUTTER_IS_STAGE (stage));
priv = stage->priv;
priv->key_focused_actor = NULL;
/* focused actor has dissapeared - fall back to stage
* FIXME: need some kind of signal dance/block here.
*/
clutter_stage_set_key_focus (stage, CLUTTER_ACTOR(stage));
}
void
clutter_stage_set_key_focus (ClutterStage *stage,
ClutterActor *actor)
{
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)
{
g_object_weak_unref (G_OBJECT(priv->key_focused_actor),
on_key_focused_weak_notify,
stage);
g_signal_emit_by_name (G_OBJECT(priv->key_focused_actor), "focus-out");
}
priv->key_focused_actor = actor;
if (actor)
{
g_object_weak_ref (G_OBJECT(actor),
on_key_focused_weak_notify,
stage);
g_signal_emit_by_name (G_OBJECT(actor), "focus-in");
}
}
ClutterActor*
clutter_stage_get_key_focus (ClutterStage *stage)
{
ClutterStagePrivate *priv;
g_return_val_if_fail (CLUTTER_IS_STAGE (stage), NULL);
priv = stage->priv;
return priv->key_focused_actor;
}
/*** Perspective boxed type ******/
/**

26
clutter/clutter-stage.h
View File

@ -98,23 +98,7 @@ struct _ClutterStageClass
void (* set_user_resize) (ClutterStage *stage,
gboolean value);
/* signals */
void (* event) (ClutterStage *stage,
ClutterEvent *event);
void (* event_after) (ClutterStage *stage,
ClutterEvent *event);
void (* button_press_event) (ClutterStage *stage,
ClutterButtonEvent *event);
void (* button_release_event) (ClutterStage *stage,
ClutterButtonEvent *event);
void (* scroll_event) (ClutterStage *stage,
ClutterScrollEvent *event);
void (* key_press_event) (ClutterStage *stage,
ClutterKeyEvent *event);
void (* key_release_event) (ClutterStage *stage,
ClutterKeyEvent *event);
void (* motion_event) (ClutterStage *stage,
ClutterMotionEvent *event);
/* events */
void (* stage_state_event) (ClutterStage *stage,
ClutterStageStateEvent *event);
@ -192,6 +176,14 @@ void clutter_stage_set_user_resizable (ClutterStage *stage,
gboolean resizable);
gboolean clutter_stage_get_user_resizable (ClutterStage *stage);
/* New experiental calls */
void
clutter_stage_set_key_focus (ClutterStage *stage,
ClutterActor *actor);
ClutterActor*
clutter_stage_get_key_focus (ClutterStage *stage);
G_END_DECLS
#endif /* __CLUTTER_STAGE_H__ */

3
clutter/clutter-types.h
View File

@ -39,6 +39,9 @@ G_BEGIN_DECLS
#define CLUTTER_TYPE_PADDING (clutter_padding_get_type ())
#define CLUTTER_TYPE_VERTEX (clutter_vertex_get_type ())
/* Forward delarations to avoid header catch 22's */
typedef struct _ClutterActor ClutterActor;
/**
* ClutterGravity:
* @CLUTTER_GRAVITY_NONE: Do not apply any gravity

45
clutter/cogl/gl/cogl.c
View File

@ -29,6 +29,13 @@
#include <GL/gl.h>
#include <string.h>
#ifdef HAVE_CLUTTER_GLX
#include <dlfcn.h>
#include <GL/glx.h>
typedef CoglFuncPtr (*GLXGetProcAddressProc) (const guint8 *procName);
#endif
static gulong __enable_flags = 0;
#if COGL_DEBUG
@ -81,7 +88,43 @@ error_string(GLenum errorCode)
CoglFuncPtr
cogl_get_proc_address (const gchar* name)
{
/* FIXME: This very likely needs to be handled in the backend */
/* Sucks to ifdef here but not other option..? would be nice to
* split the code up for more reuse (once more backends use this
*/
#ifdef HAVE_CLUTTER_GLX
static GLXGetProcAddressProc get_proc_func = NULL;
static void *dlhand = NULL;
if (get_proc_func == NULL && dlhand == NULL)
{
dlhand = dlopen (NULL, RTLD_LAZY);
if (dlhand)
{
dlerror ();
get_proc_func =
(GLXGetProcAddressProc) dlsym (dlhand, "glXGetProcAddress");
if (dlerror () != NULL)
{
get_proc_func =
(GLXGetProcAddressProc) dlsym (dlhand, "glXGetProcAddressARB");
}
if (dlerror () != NULL)
{
get_proc_func = NULL;
g_warning ("failed to bind GLXGetProcAddress "
"or GLXGetProcAddressARB");
}
}
}
if (get_proc_func)
return get_proc_func ((unsigned char*) name);
#endif
return NULL;
}

47
clutter/glx/clutter-backend-glx.c
View File

@ -37,7 +37,7 @@
#include <GL/glx.h>
#include <GL/gl.h>
#include <dlfcn.h>
#include "clutter-backend-glx.h"
#include "clutter-stage-glx.h"
@ -52,8 +52,6 @@
G_DEFINE_TYPE (ClutterBackendGLX, clutter_backend_glx, CLUTTER_TYPE_BACKEND);
typedef CoglFuncPtr (*GLXGetProcAddressProc) (const guint8 *procName);
/* singleton object */
static ClutterBackendGLX *backend_singleton = NULL;
@ -387,43 +385,6 @@ check_vblank_env (const char *name)
return FALSE;
}
static CoglFuncPtr
get_proc_address (const gchar* name)
{
static GLXGetProcAddressProc get_proc_func = NULL;
static void *dlhand = NULL;
if (get_proc_func == NULL && dlhand == NULL)
{
dlhand = dlopen (NULL, RTLD_LAZY);
if (dlhand)
{
dlerror ();
get_proc_func =
(GLXGetProcAddressProc) dlsym (dlhand, "glXGetProcAddress");
if (dlerror () != NULL)
{
get_proc_func =
(GLXGetProcAddressProc) dlsym (dlhand, "glXGetProcAddressARB");
}
if (dlerror () != NULL)
{
get_proc_func = NULL;
g_warning ("failed to bind GLXGetProcAddress "
"or GLXGetProcAddressARB");
}
}
}
if (get_proc_func)
return get_proc_func ((unsigned char*) name);
return NULL;
}
static ClutterFeatureFlags
clutter_backend_glx_get_features (ClutterBackend *backend)
@ -475,7 +436,7 @@ clutter_backend_glx_get_features (ClutterBackend *backend)
cogl_check_extension ("GLX_SGI_swap_control", glx_extensions))
{
backend_glx->swap_interval =
(SwapIntervalProc) get_proc_address ("glXSwapIntervalSGI");
(SwapIntervalProc) cogl_get_proc_address ("glXSwapIntervalSGI");
CLUTTER_NOTE (BACKEND, "attempting glXSwapIntervalSGI vblank setup");
@ -500,10 +461,10 @@ clutter_backend_glx_get_features (ClutterBackend *backend)
CLUTTER_NOTE (BACKEND, "attempting glXGetVideoSyncSGI vblank setup");
backend_glx->get_video_sync =
(GetVideoSyncProc) get_proc_address ("glXGetVideoSyncSGI");
(GetVideoSyncProc) cogl_get_proc_address ("glXGetVideoSyncSGI");
backend_glx->wait_video_sync =
(WaitVideoSyncProc) get_proc_address ("glXWaitVideoSyncSGI");
(WaitVideoSyncProc) cogl_get_proc_address ("glXWaitVideoSyncSGI");
if ((backend_glx->get_video_sync != NULL) &&
(backend_glx->wait_video_sync != NULL))

134
tests/test-events.c
View File

@ -1,11 +1,37 @@
#include <clutter/clutter.h>
static void
input_cb (ClutterStage *stage,
ClutterEvent *event,
gpointer data)
void
key_focus_in_cb (ClutterActor *actor,
gpointer data)
{
gchar keybuf[9];
ClutterActor *focus_box = CLUTTER_ACTOR(data);
if (actor == clutter_stage_get_default ())
{
clutter_actor_hide (focus_box);
}
else
{
clutter_actor_show (focus_box);
clutter_actor_set_position (focus_box,
clutter_actor_get_x (actor) - 5,
clutter_actor_get_y (actor) - 5);
clutter_actor_set_size (focus_box,
clutter_actor_get_width (actor) + 10,
clutter_actor_get_height (actor) + 10);
}
}
static void
input_cb (ClutterActor *actor,
ClutterEvent *event,
gpointer data)
{
gchar keybuf[9], *source = (gchar*)data;
int len = 0;
switch (event->type)
@ -14,58 +40,126 @@ input_cb (ClutterStage *stage,
len = g_unichar_to_utf8 (clutter_keysym_to_unicode (event->key.keyval),
keybuf);
keybuf[len] = '\0';
printf ("- KEY PRESS '%s'\n", keybuf);
printf ("[%s] KEY PRESS '%s'", source, keybuf);
break;
case CLUTTER_KEY_RELEASE:
len = g_unichar_to_utf8 (clutter_keysym_to_unicode (event->key.keyval),
keybuf);
keybuf[len] = '\0';
printf ("- KEY RELEASE '%s'\n", keybuf);
printf ("[%s] KEY RELEASE '%s'", source, keybuf);
break;
case CLUTTER_MOTION:
printf("- MOTION\n");
printf("[%s] MOTION", source);
break;
case CLUTTER_BUTTON_PRESS:
printf("- BUTTON PRESS\n");
printf("[%s] BUTTON PRESS", source);
break;
case CLUTTER_2BUTTON_PRESS:
printf("- BUTTON 2 PRESS\n");
printf("[%s] BUTTON 2 PRESS", source);
break;
case CLUTTER_3BUTTON_PRESS:
printf("- BUTTON 3 PRESS\n");
printf("[%s] BUTTON 3 PRESS", source);
break;
case CLUTTER_BUTTON_RELEASE:
printf("- BUTTON RELEASE\n");
printf("[%s] BUTTON RELEASE", source);
if (clutter_event_get_source (event) == actor)
clutter_stage_set_key_focus
(CLUTTER_STAGE(clutter_stage_get_default ()), actor);
break;
case CLUTTER_SCROLL:
printf("- BUTTON SCROLL\n");
printf("[%s] BUTTON SCROLL", source);
break;
case CLUTTER_STAGE_STATE:
printf("- STAGE STATE\n");
printf("[%s] STAGE STATE", source);
break;
case CLUTTER_DESTROY_NOTIFY:
printf("- DESTROY NOTIFY\n");
printf("[%s] DESTROY NOTIFY", source);
break;
case CLUTTER_CLIENT_MESSAGE:
printf("- CLIENT MESSAGE\n");
printf("[%s] CLIENT MESSAGE\n", source);
break;
case CLUTTER_DELETE:
printf("- DELETE\n");
printf("[%s] DELETE", source);
break;
case CLUTTER_NOTHING:
break;
return;
}
if (clutter_event_get_source (event) == actor)
printf(" *source*");
printf("\n");
}
int
main (int argc, char *argv[])
{
ClutterActor *stage;
ClutterActor *stage, *actor, *focus_box;
ClutterColor rcol = { 0xff, 0, 0, 0xff},
bcol = { 0, 0, 0xff, 0xff },
gcol = { 0, 0xff, 0, 0xff },
ncol = { 0, 0, 0, 0xff };
clutter_init (&argc, &argv);
stage = clutter_stage_get_default ();
g_signal_connect (stage, "event", G_CALLBACK (input_cb), NULL);
g_signal_connect (stage, "event", G_CALLBACK (input_cb), "stage");
focus_box = clutter_rectangle_new_with_color (&ncol);
clutter_container_add (CLUTTER_CONTAINER(stage), focus_box, NULL);
actor = clutter_rectangle_new_with_color (&rcol);
clutter_actor_set_size (actor, 100, 100);
clutter_actor_set_position (actor, 100, 100);
clutter_actor_set_reactive (actor);
clutter_container_add (CLUTTER_CONTAINER(stage), actor, NULL);
g_signal_connect (actor, "event", G_CALLBACK (input_cb), "red box");
g_signal_connect (actor, "focus-in", G_CALLBACK (key_focus_in_cb),
focus_box);
clutter_stage_set_key_focus (stage, actor);
actor = clutter_rectangle_new_with_color (&gcol);
clutter_actor_set_size (actor, 100, 100);
clutter_actor_set_position (actor, 250, 100);
clutter_actor_set_reactive (actor);
clutter_container_add (CLUTTER_CONTAINER(stage), actor, NULL);
g_signal_connect (actor, "event", G_CALLBACK (input_cb), "green box");
g_signal_connect (actor, "focus-in", G_CALLBACK (key_focus_in_cb),
focus_box);
actor = clutter_rectangle_new_with_color (&bcol);
clutter_actor_set_size (actor, 100, 100);
clutter_actor_set_position (actor, 400, 100);
clutter_actor_set_reactive (actor);
clutter_container_add (CLUTTER_CONTAINER(stage), actor, NULL);
g_signal_connect (actor, "event", G_CALLBACK (input_cb), "blue box");
g_signal_connect (actor, "focus-in", G_CALLBACK (key_focus_in_cb),
focus_box);
actor = clutter_rectangle_new_with_color (&ncol);
clutter_actor_set_size (actor, 400, 50);
clutter_actor_set_position (actor, 100, 250);
clutter_container_add (CLUTTER_CONTAINER(stage), actor, NULL);
g_signal_connect (actor, "event", G_CALLBACK (input_cb), "blue box");
g_signal_connect (actor, "focus-in", G_CALLBACK (key_focus_in_cb),
focus_box);
g_signal_connect (stage, "focus-in", G_CALLBACK (key_focus_in_cb),
focus_box);
clutter_actor_show_all (CLUTTER_ACTOR (stage));
clutter_main();