/**
* clutter_input_device_update_from_event:
* @device: a #ClutterInputDevice
* @event: a #ClutterEvent
* @update_stage: whether to update the #ClutterStage of the @device
* using the stage of the event
*
* Forcibly updates the state of the @device using a #ClutterEvent
*
* This function should never be used by applications: it is meant
* for integration with embedding toolkits, like clutter-gtk
*
* Embedding toolkits that disable the event collection inside Clutter
* need to use this function to update the state of input devices depending
* on a #ClutterEvent that they are going to submit to the event handling code
* in Clutter though clutter_do_event(). Since the input devices hold the state
* that is going to be used to fill in fields like the #ClutterButtonEvent
* click count, or to emit synthesized events like %CLUTTER_ENTER and
* %CLUTTER_LEAVE, it is necessary for embedding toolkits to also be
* responsible of updating the input device state.
*
* For instance, this might be the code to translate an embedding toolkit
* native motion notification into a Clutter #ClutterMotionEvent and ask
* Clutter to process it:
*
* |[
* ClutterEvent c_event;
*
* translate_native_event_to_clutter (native_event, &c_event);
*
* clutter_do_event (&c_event);
* ]|
*
* Before letting clutter_do_event() process the event, it is necessary to call
* clutter_input_device_update_from_event():
*
* |[
* ClutterEvent c_event;
* ClutterDeviceManager *manager;
* ClutterInputDevice *device;
*
* translate_native_event_to_clutter (native_event, &c_event);
*
* /* get the device manager */
* manager = clutter_device_manager_get_default ();
*
* /* use the default Core Pointer that Clutter
* * backends register by default
* */
* device = clutter_device_manager_get_core_device (manager, %CLUTTER_POINTER_DEVICE);
*
* /* update the state of the input device */
* clutter_input_device_update_from_event (device, &c_event, FALSE);
*
* clutter_do_event (&c_event);
* ]|
*
* The @update_stage boolean argument should be used when the input device
* enters and leaves a #ClutterStage; it will use the #ClutterStage field
* of the passed @event to update the stage associated to the input device.
*
* Since: 1.2
*/
void
clutter_input_device_update_from_event (ClutterInputDevice *device,
ClutterEvent *event,
gboolean update_stage)
{
ClutterModifierType event_state;
ClutterStage *event_stage;
gfloat event_x, event_y;
guint32 event_time;
g_return_if_fail (CLUTTER_IS_INPUT_DEVICE (device));
g_return_if_fail (event != NULL);
event_state = clutter_event_get_state (event);
event_time = clutter_event_get_time (event);
event_stage = clutter_event_get_stage (event);
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);
if (update_stage)
_clutter_input_device_set_stage (device, event_stage);
}
/* Dragged actor moved */
static void _xfdashboard_drag_action_drag_motion(ClutterDragAction *inAction,
ClutterActor *inActor,
gfloat inDeltaX,
gfloat inDeltaY)
{
XfdashboardDragAction *self;
XfdashboardDragActionPrivate *priv;
ClutterDragActionClass *dragActionClass;
gfloat stageX, stageY;
XfdashboardDropAction *dropTarget;
gfloat dropX, dropY;
const ClutterEvent *event;
g_return_if_fail(XFDASHBOARD_IS_DRAG_ACTION(inAction));
self=XFDASHBOARD_DRAG_ACTION(inAction);
priv=self->priv;
dragActionClass=CLUTTER_DRAG_ACTION_CLASS(xfdashboard_drag_action_parent_class);
/* Call parent's class method */
if(dragActionClass->drag_motion) dragActionClass->drag_motion(inAction, inActor, inDeltaX, inDeltaY);
/* Remember motion delta coordinates */
priv->lastDeltaX=inDeltaX;
priv->lastDeltaY=inDeltaY;
/* Get event coordinates relative to stage */
clutter_drag_action_get_motion_coords(inAction, &stageX, &stageY);
/* Find drop target at stage coordinate */
dropTarget=_xfdashboard_drag_action_find_drop_traget_at_coord(self, stageX, stageY);
/* If found drop target is not the same as the last one emit "drag-leave"
* signal at last drop target and "drag-enter" in new drop target
*/
if(priv->lastDropTarget!=dropTarget)
{
/* Emit "drag-leave" signal on last drop target */
if(priv->lastDropTarget)
{
g_signal_emit_by_name(priv->lastDropTarget, "drag-leave", self, NULL);
priv->lastDropTarget=NULL;
}
/* Check if new drop target is active and emit "drag-enter" signal */
if(dropTarget)
{
ClutterActorMeta *actorMeta=CLUTTER_ACTOR_META(dropTarget);
ClutterActor *dropActor=clutter_actor_meta_get_actor(actorMeta);
if(clutter_actor_meta_get_enabled(actorMeta) &&
clutter_actor_is_visible(dropActor) &&
clutter_actor_get_reactive(dropActor))
{
g_signal_emit_by_name(dropTarget, "drag-enter", self, NULL);
priv->lastDropTarget=dropTarget;
}
}
}
/* Transform event coordinates relative to last drop target which
* should be the drop target under pointer device if it is active
* and emit "drag-motion" signal
*/
if(priv->lastDropTarget)
{
dropX=dropY=0.0f;
_xfdashboard_drag_action_transform_stage_point(priv->lastDropTarget,
stageX, stageY,
&dropX, &dropY);
g_signal_emit_by_name(priv->lastDropTarget, "drag-motion", self, dropX, dropY, NULL);
}
/* We are derived from ClutterDragAction and this one disables stage motion
* so no "enter-event", "motion-event" and "leave-event" will be emitted while
* dragging. We need to do it on our own.
*/
event=clutter_get_current_event();
if(event && clutter_event_type(event)==CLUTTER_MOTION)
{
GSList *list, *next;
ClutterStage *stage;
ClutterActor *motionActor;
gboolean newMotionActor;
ClutterActor *actor;
gfloat x, y, w, h;
gboolean result;
ClutterEvent *actorEvent;
/* Get stage where event happened */
stage=clutter_event_get_stage(event);
if(stage)
{
/* Get actor under pointer */
newMotionActor=TRUE;
motionActor=clutter_stage_get_actor_at_pos(stage,
CLUTTER_PICK_REACTIVE,
stageX, stageY);
/* Iterate through list of crossed actors so far and check if pointer
* is still inside. If pointer is outside of an actor emit "leave-event".
* For each actor the pointer is still inside emit this "motion-event".
* Also check if actor under pointer is already is list to prevent
* "enter-event" to be emitted more than once.
*/
list=priv->lastMotionActors;
while(list)
{
/* Get next entry now as this entry might get deleted */
next=g_slist_next(list);
/* Get actor from entry */
actor=CLUTTER_ACTOR(list->data);
/* Actor must be one same stage where event happened */
if(clutter_actor_get_stage(actor)!=CLUTTER_ACTOR(stage)) continue;
/* Get position and size of actor in stage coordinates */
clutter_actor_get_transformed_position(actor, &x, &y);
clutter_actor_get_transformed_size(actor, &w, &h);
/* Check if pointer is still inside actor */
if(stageX>=x && stageX<(x+w) &&
stageY>=y && stageY<(y+h))
{
/* Check if actor is the "new" motion actor. If so set flag. */
if(actor==motionActor) newMotionActor=FALSE;
/* Emit "motion-event" */
actorEvent=clutter_event_copy(event);
actorEvent->motion.source=actor;
g_signal_emit_by_name(actor, "motion-event", actorEvent, &result);
clutter_event_free(actorEvent);
}
/* Pointer is not inside actor anymore so remove actor from list
* of last known "motion actors" and send "leave-event"
*/
else
{
/* Disconnect signal */
g_signal_handlers_disconnect_by_func(actor, G_CALLBACK(_xfdashboard_drag_action_on_motion_actor_destroyed), self);
/* Remove from list */
priv->lastMotionActors=g_slist_remove_link(priv->lastMotionActors, list);
g_slist_free_1(list);
/* Create and emit "leave-event" */
actorEvent=clutter_event_new(CLUTTER_LEAVE);
actorEvent->crossing.time=event->motion.time;
actorEvent->crossing.flags=event->motion.flags;
actorEvent->crossing.stage=event->motion.stage;
actorEvent->crossing.source=actor;
actorEvent->crossing.x=event->motion.x;
actorEvent->crossing.y=event->motion.y;
actorEvent->crossing.device=event->motion.device;
actorEvent->crossing.related=event->motion.source;
g_signal_emit_by_name(actor, "leave-event", actorEvent, &result);
clutter_event_free(actorEvent);
}
/* Proceed with next actor */
list=next;
}
/* We have an actor under pointer and was not seen while iterating
* through list of all last known "motion actors" then add this actor
* to list and emit "enter-event" and also all parent actors because
* if pointer is inside their child then it is also inside them.
*/
if(motionActor && newMotionActor)
{
while(motionActor)
{
/* Avoid duplicates */
if(!g_slist_find(priv->lastMotionActors, motionActor))
{
/* Add to list */
priv->lastMotionActors=g_slist_append(priv->lastMotionActors, motionActor);
/* Create and emit "enter-event" */
actorEvent=clutter_event_new(CLUTTER_ENTER);
actorEvent->crossing.time=event->motion.time;
actorEvent->crossing.flags=event->motion.flags;
actorEvent->crossing.stage=event->motion.stage;
actorEvent->crossing.source=event->motion.source;
actorEvent->crossing.x=event->motion.x;
actorEvent->crossing.y=event->motion.y;
actorEvent->crossing.device=event->motion.device;
actorEvent->crossing.related=motionActor;
g_signal_emit_by_name(motionActor, "enter-event", actorEvent, &result);
clutter_event_free(actorEvent);
/* To prevent emiting these motion events on actors being
* destroyed while drag is in progress we connect to 'destroy'
* signal of each "motion actor" added to list. The signal
* handler will be removed either on actor's destruction by
* signal handler's callback, when pointer leaves actor or on
* end of drag.
*/
g_signal_connect(motionActor, "destroy", G_CALLBACK(_xfdashboard_drag_action_on_motion_actor_destroyed), self);
}
/* Get parent */
motionActor=clutter_actor_get_parent(motionActor);
}
}
}
}
}
