static void
gst_glimage_sink_mouse_event_cb (GstGLWindow * window, char *event_name,
int button, double posx, double posy, GstGLImageSink * gl_sink)
{
GST_DEBUG_OBJECT (gl_sink, "glimagesink event %s at %g, %g", event_name, posx,
posy);
gst_navigation_send_mouse_event (GST_NAVIGATION (gl_sink),
event_name, button, posx, posy);
}
P_INVOKE void
bp_dvd_mouse_button_released_notify (BansheePlayer *player, int button, double x, double y)
{
if (!player->navigation) {
_bp_dvd_find_navigation (player);
}
if (player->navigation) {
gst_navigation_send_mouse_event (player->navigation, "mouse-button-release", button, x, y);
}
}
P_INVOKE void
bp_dvd_mouse_move_notify (BansheePlayer *player, double x, double y)
{
if (!player->navigation) {
_bp_dvd_find_navigation (player);
}
if (player->navigation) {
gst_navigation_send_mouse_event (player->navigation, "mouse-move", 0, x, y);
}
}
static gboolean
gtk_gst_base_widget_motion_event (GtkWidget * widget, GdkEventMotion * event)
{
GtkGstBaseWidget *base_widget = GTK_GST_BASE_WIDGET (widget);
GstElement *element;
if ((element = g_weak_ref_get (&base_widget->element))) {
if (GST_IS_NAVIGATION (element)) {
gdouble x, y;
_display_size_to_stream_size (base_widget, event->x, event->y, &x, &y);
gst_navigation_send_mouse_event (GST_NAVIGATION (element), "mouse-move",
0, x, y);
}
g_object_unref (element);
}
return TRUE;
}
static gboolean
gtk_gst_base_widget_button_event (GtkWidget * widget, GdkEventButton * event)
{
GtkGstBaseWidget *base_widget = GTK_GST_BASE_WIDGET (widget);
GstElement *element;
if ((element = g_weak_ref_get (&base_widget->element))) {
if (GST_IS_NAVIGATION (element)) {
const gchar *key_type =
event->type ==
GDK_BUTTON_PRESS ? "mouse-button-press" : "mouse-button-release";
gdouble x, y;
_display_size_to_stream_size (base_widget, event->x, event->y, &x, &y);
gst_navigation_send_mouse_event (GST_NAVIGATION (element), key_type,
event->button, x, y);
}
g_object_unref (element);
}
return TRUE;
}
/* Process pending events. Call with ->lock held */
static void
gst_sdlv_process_events (GstSDLVideoSink * sdlvideosink)
{
SDL_Event event;
int numevents;
char *keysym = NULL;
do {
SDL_PumpEvents ();
numevents = SDL_PeepEvents (&event, 1, SDL_GETEVENT,
SDL_KEYDOWNMASK | SDL_KEYUPMASK |
SDL_MOUSEMOTIONMASK | SDL_MOUSEBUTTONDOWNMASK |
SDL_MOUSEBUTTONUPMASK | SDL_QUITMASK | SDL_VIDEORESIZEMASK);
if (numevents > 0 && (event.type == SDL_KEYUP || event.type == SDL_KEYDOWN)) {
keysym = SDL_GetKeyName (event.key.keysym.sym);
}
if (numevents > 0) {
g_mutex_unlock (sdlvideosink->lock);
switch (event.type) {
case SDL_MOUSEMOTION:
gst_navigation_send_mouse_event (GST_NAVIGATION (sdlvideosink),
"mouse-move", 0, event.motion.x, event.motion.y);
break;
case SDL_MOUSEBUTTONDOWN:
gst_navigation_send_mouse_event (GST_NAVIGATION (sdlvideosink),
"mouse-button-press",
event.button.button, event.button.x, event.button.y);
break;
case SDL_MOUSEBUTTONUP:
gst_navigation_send_mouse_event (GST_NAVIGATION (sdlvideosink),
"mouse-button-release",
event.button.button, event.button.x, event.button.y);
break;
case SDL_KEYUP:
GST_DEBUG ("key press event %s !",
SDL_GetKeyName (event.key.keysym.sym));
gst_navigation_send_key_event (GST_NAVIGATION (sdlvideosink),
"key-release", keysym);
break;
case SDL_KEYDOWN:
if (SDLK_ESCAPE != event.key.keysym.sym) {
GST_DEBUG ("key press event %s !",
SDL_GetKeyName (event.key.keysym.sym));
gst_navigation_send_key_event (GST_NAVIGATION (sdlvideosink),
"key-press", keysym);
break;
} else {
/* fall through */
}
case SDL_QUIT:
sdlvideosink->running = FALSE;
GST_ELEMENT_ERROR (sdlvideosink, RESOURCE, OPEN_WRITE,
("Video output device is gone."),
("We were running fullscreen and user "
"pressed the ESC key, stopping playback."));
break;
case SDL_VIDEORESIZE:
/* create a SDL window of the size requested by the user */
g_mutex_lock (sdlvideosink->lock);
GST_VIDEO_SINK_WIDTH (sdlvideosink) = event.resize.w;
GST_VIDEO_SINK_HEIGHT (sdlvideosink) = event.resize.h;
gst_sdlvideosink_create (sdlvideosink);
g_mutex_unlock (sdlvideosink->lock);
break;
}
g_mutex_lock (sdlvideosink->lock);
}
} while (numevents > 0);
}
/* This function handles XEvents that might be in the queue. It generates
GstEvent that will be sent upstream in the pipeline to handle interactivity
and navigation.*/
static void
gst_vdp_sink_handle_xevents (VdpSink * vdp_sink)
{
XEvent e;
guint pointer_x = 0, pointer_y = 0;
gboolean pointer_moved = FALSE;
gboolean exposed = FALSE, configured = FALSE;
g_return_if_fail (GST_IS_VDP_SINK (vdp_sink));
/* Then we get all pointer motion events, only the last position is
interesting. */
g_mutex_lock (vdp_sink->flow_lock);
g_mutex_lock (vdp_sink->x_lock);
while (XCheckWindowEvent (vdp_sink->device->display,
vdp_sink->window->win, PointerMotionMask, &e)) {
g_mutex_unlock (vdp_sink->x_lock);
g_mutex_unlock (vdp_sink->flow_lock);
switch (e.type) {
case MotionNotify:
pointer_x = e.xmotion.x;
pointer_y = e.xmotion.y;
pointer_moved = TRUE;
break;
default:
break;
}
g_mutex_lock (vdp_sink->flow_lock);
g_mutex_lock (vdp_sink->x_lock);
}
if (pointer_moved) {
g_mutex_unlock (vdp_sink->x_lock);
g_mutex_unlock (vdp_sink->flow_lock);
GST_DEBUG ("vdp_sink pointer moved over window at %d,%d",
pointer_x, pointer_y);
gst_navigation_send_mouse_event (GST_NAVIGATION (vdp_sink),
"mouse-move", 0, pointer_x, pointer_y);
g_mutex_lock (vdp_sink->flow_lock);
g_mutex_lock (vdp_sink->x_lock);
}
/* We get all remaining events on our window to throw them upstream */
while (XCheckWindowEvent (vdp_sink->device->display,
vdp_sink->window->win,
KeyPressMask | KeyReleaseMask |
ButtonPressMask | ButtonReleaseMask, &e)) {
KeySym keysym;
/* We lock only for the X function call */
g_mutex_unlock (vdp_sink->x_lock);
g_mutex_unlock (vdp_sink->flow_lock);
switch (e.type) {
case ButtonPress:
/* Mouse button pressed/released over our window. We send upstream
events for interactivity/navigation */
GST_DEBUG ("vdp_sink button %d pressed over window at %d,%d",
e.xbutton.button, e.xbutton.x, e.xbutton.x);
gst_navigation_send_mouse_event (GST_NAVIGATION (vdp_sink),
"mouse-button-press", e.xbutton.button, e.xbutton.x, e.xbutton.y);
break;
case ButtonRelease:
GST_DEBUG ("vdp_sink button %d release over window at %d,%d",
e.xbutton.button, e.xbutton.x, e.xbutton.x);
gst_navigation_send_mouse_event (GST_NAVIGATION (vdp_sink),
"mouse-button-release", e.xbutton.button, e.xbutton.x, e.xbutton.y);
break;
case KeyPress:
case KeyRelease:
/* Key pressed/released over our window. We send upstream
events for interactivity/navigation */
GST_DEBUG ("vdp_sink key %d pressed over window at %d,%d",
e.xkey.keycode, e.xkey.x, e.xkey.x);
g_mutex_lock (vdp_sink->x_lock);
keysym =
XKeycodeToKeysym (vdp_sink->device->display, e.xkey.keycode, 0);
g_mutex_unlock (vdp_sink->x_lock);
if (keysym != NoSymbol) {
char *key_str = NULL;
g_mutex_lock (vdp_sink->x_lock);
key_str = XKeysymToString (keysym);
g_mutex_unlock (vdp_sink->x_lock);
gst_navigation_send_key_event (GST_NAVIGATION (vdp_sink),
e.type == KeyPress ? "key-press" : "key-release", key_str);
} else {
gst_navigation_send_key_event (GST_NAVIGATION (vdp_sink),
e.type == KeyPress ? "key-press" : "key-release", "unknown");
}
break;
default:
GST_DEBUG_OBJECT (vdp_sink, "vdp_sink unhandled X event (%d)", e.type);
}
g_mutex_lock (vdp_sink->flow_lock);
g_mutex_lock (vdp_sink->x_lock);
}
while (XCheckWindowEvent (vdp_sink->device->display,
vdp_sink->window->win, ExposureMask | StructureNotifyMask, &e)) {
switch (e.type) {
case Expose:
exposed = TRUE;
break;
case ConfigureNotify:
configured = TRUE;
break;
default:
break;
}
}
if (vdp_sink->handle_expose && (exposed || configured)) {
g_mutex_unlock (vdp_sink->x_lock);
g_mutex_unlock (vdp_sink->flow_lock);
gst_vdp_sink_expose (GST_X_OVERLAY (vdp_sink));
g_mutex_lock (vdp_sink->flow_lock);
g_mutex_lock (vdp_sink->x_lock);
}
/* Handle Display events */
while (XPending (vdp_sink->device->display)) {
XNextEvent (vdp_sink->device->display, &e);
switch (e.type) {
case ClientMessage:{
Atom wm_delete;
wm_delete = XInternAtom (vdp_sink->device->display,
"WM_DELETE_WINDOW", False);
if (wm_delete == (Atom) e.xclient.data.l[0]) {
/* Handle window deletion by posting an error on the bus */
GST_ELEMENT_ERROR (vdp_sink, RESOURCE, NOT_FOUND,
("Output window was closed"), (NULL));
g_mutex_unlock (vdp_sink->x_lock);
gst_vdp_sink_window_destroy (vdp_sink, vdp_sink->window);
vdp_sink->window = NULL;
g_mutex_lock (vdp_sink->x_lock);
}
break;
}
default:
break;
}
}
g_mutex_unlock (vdp_sink->x_lock);
g_mutex_unlock (vdp_sink->flow_lock);
}
static gboolean
event_refresh (gpointer data)
{
GstV4l2Object *v4l2object = GST_V4L2_OBJECT (data);
GstV4l2Xv *v4l2xv = v4l2object->xv;
GST_LOG_OBJECT (v4l2object->element, "event refresh");
if (v4l2xv) {
XEvent e;
g_mutex_lock (v4l2xv->mutex);
/* If the element supports navigation, collect the relavent input
* events and push them upstream as navigation events
*/
if (GST_IS_NAVIGATION (v4l2object->element)) {
guint pointer_x = 0, pointer_y = 0;
gboolean pointer_moved = FALSE;
/* We get all pointer motion events, only the last position is
* interesting.
*/
while (XCheckWindowEvent (v4l2xv->dpy, v4l2object->xwindow_id,
PointerMotionMask, &e)) {
switch (e.type) {
case MotionNotify:
pointer_x = e.xmotion.x;
pointer_y = e.xmotion.y;
pointer_moved = TRUE;
break;
default:
break;
}
}
if (pointer_moved) {
GST_DEBUG_OBJECT (v4l2object->element,
"pointer moved over window at %d,%d", pointer_x, pointer_y);
g_mutex_unlock (v4l2xv->mutex);
gst_navigation_send_mouse_event (GST_NAVIGATION (v4l2object->element),
"mouse-move", 0, e.xbutton.x, e.xbutton.y);
g_mutex_lock (v4l2xv->mutex);
}
/* We get all events on our window to throw them upstream
*/
while (XCheckWindowEvent (v4l2xv->dpy, v4l2object->xwindow_id,
KeyPressMask | KeyReleaseMask |
ButtonPressMask | ButtonReleaseMask, &e)) {
KeySym keysym;
const char *key_str = NULL;
g_mutex_unlock (v4l2xv->mutex);
switch (e.type) {
case ButtonPress:
GST_DEBUG_OBJECT (v4l2object->element,
"button %d pressed over window at %d,%d",
e.xbutton.button, e.xbutton.x, e.xbutton.y);
gst_navigation_send_mouse_event (GST_NAVIGATION
(v4l2object->element), "mouse-button-press", e.xbutton.button,
e.xbutton.x, e.xbutton.y);
break;
case ButtonRelease:
GST_DEBUG_OBJECT (v4l2object->element,
"button %d released over window at %d,%d",
e.xbutton.button, e.xbutton.x, e.xbutton.y);
gst_navigation_send_mouse_event (GST_NAVIGATION
(v4l2object->element), "mouse-button-release", e.xbutton.button,
e.xbutton.x, e.xbutton.y);
break;
case KeyPress:
case KeyRelease:
g_mutex_lock (v4l2xv->mutex);
keysym = XkbKeycodeToKeysym (v4l2xv->dpy, e.xkey.keycode, 0, 0);
if (keysym != NoSymbol) {
key_str = XKeysymToString (keysym);
} else {
key_str = "unknown";
}
g_mutex_unlock (v4l2xv->mutex);
GST_DEBUG_OBJECT (v4l2object->element,
"key %d pressed over window at %d,%d (%s)",
e.xkey.keycode, e.xkey.x, e.xkey.y, key_str);
gst_navigation_send_key_event (GST_NAVIGATION (v4l2object->element),
e.type == KeyPress ? "key-press" : "key-release", key_str);
break;
default:
GST_DEBUG_OBJECT (v4l2object->element,
"unhandled X event (%d)", e.type);
}
g_mutex_lock (v4l2xv->mutex);
}
}
/* Handle ConfigureNotify */
while (XCheckWindowEvent (v4l2xv->dpy, v4l2object->xwindow_id,
StructureNotifyMask, &e)) {
switch (e.type) {
case ConfigureNotify:
update_geometry (v4l2object);
break;
default:
break;
}
}
g_mutex_unlock (v4l2xv->mutex);
}
/* repeat */
return TRUE;
}
