swfdec_gtk_widget.c

Swfdec is a decoder/renderer for Macromedia Flash animations. The decoding and rendering engine is

/* Swfdec
 * Copyright (C) 2006-2007 Benjamin Otte <[e-mail]>
 *
 * 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.1 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
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, 
 * Boston, MA  02110-1301  USA
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <math.h>
#include <gdk/gdkkeysyms.h>
#include "swfdec_gtk_widget.h"
#include "swfdec_gtk_keys.h"

struct _SwfdecGtkWidgetPrivate
{
  SwfdecPlayer *	player;		/* the video we play */

  gboolean		renderer_set;	/* TRUE if a special renderer has been set */
  cairo_surface_type_t	renderer;	/* the renderer that was set */
  gboolean		interactive;	/* TRUE if this widget propagates keyboard and mouse events */

  int			button;		/* status of mouse button in displayed movie */
};

enum {
  PROP_0,
  PROP_PLAYER,
  PROP_INTERACTIVE,
  PROP_RENDERER_SET,
  PROP_RENDERER
};

/*** gtk-doc ***/

/**
 * SECTION:SwfdecGtkWidget
 * @title: SwfdecGtkWidget
 * @short_description: a #GtkWidget for embedding SWF files
 *
 * This is a widget for playing Flash movies rendered with Swfdec in a Gtk 
 * application. It supports a lot of advanced features, if you want to use
 * them. If you don't want to use them and just want to embed a movie in 
 * your application, swfdec_gtk_widget_new() will probably be the only 
 * function you need.
 *
 * @see_also: SwfdecGtkPlayer
 */

/**
 * SwfdecGtkWidget:
 *
 * The structure for the Swfdec Gtk widget contains no public fields.
 */

/*** SWFDEC_GTK_WIDGET ***/

G_DEFINE_TYPE (SwfdecGtkWidget, swfdec_gtk_widget, GTK_TYPE_WIDGET)

static gboolean
swfdec_gtk_widget_motion_notify (GtkWidget *gtkwidget, GdkEventMotion *event)
{
  SwfdecGtkWidget *widget = SWFDEC_GTK_WIDGET (gtkwidget);
  SwfdecGtkWidgetPrivate *priv = widget->priv;
  int x, y;

  gdk_window_get_pointer (gtkwidget->window, &x, &y, NULL);

  if (priv->interactive && priv->player)
    swfdec_player_handle_mouse (priv->player, x, y, priv->button);
  
  return FALSE;
}

static gboolean
swfdec_gtk_widget_leave_notify (GtkWidget *gtkwidget, GdkEventCrossing *event)
{
  SwfdecGtkWidget *widget = SWFDEC_GTK_WIDGET (gtkwidget);
  SwfdecGtkWidgetPrivate *priv = widget->priv;

  if (priv->interactive && priv->player) {
    priv->button = 0;
    swfdec_player_handle_mouse (priv->player, event->x, event->y, 0);
  }
  return FALSE;
}

static gboolean
swfdec_gtk_widget_button_press (GtkWidget *gtkwidget, GdkEventButton *event)
{
  SwfdecGtkWidget *widget = SWFDEC_GTK_WIDGET (gtkwidget);
  SwfdecGtkWidgetPrivate *priv = widget->priv;

  if (event->button == 1) {
    priv->button = 1;
    if (priv->interactive && priv->player)
      swfdec_player_handle_mouse (priv->player, event->x, event->y, 1);
  }
  return FALSE;
}

static gboolean
swfdec_gtk_widget_button_release (GtkWidget *gtkwidget, GdkEventButton *event)
{
  SwfdecGtkWidget *widget = SWFDEC_GTK_WIDGET (gtkwidget);
  SwfdecGtkWidgetPrivate *priv = widget->priv;

  if (event->button == 1) {
    priv->button = 0;
    if (priv->interactive && priv->player)
      swfdec_player_handle_mouse (priv->player, event->x, event->y, 0);
  }
  return FALSE;
}

static guint
swfdec_gtk_event_to_keycode (GdkEventKey *event)
{
  guint ret;

  /* we try to match as well as possible to Flash _Windows_ key codes.
   * Since a lot of Flash files won't special case weird Linux key codes and we
   * want the best compatibility possible, we have to do that.
   */
  /* FIXME: I have no clue about non-western keyboards, so if you happen to use
   * such a keyboard, please help out here if it doesn't match.
   */

  /* try to match latin keys directly */
  if (event->keyval >= GDK_A && event->keyval <= GDK_Z)
    return event->keyval - GDK_A + SWFDEC_KEY_A;
  if (event->keyval >= GDK_a && event->keyval <= GDK_z)
    return event->keyval - GDK_a + SWFDEC_KEY_A;

  /* last resort: try to translate the hardware keycode directly */
  ret = swfdec_gtk_keycode_from_hardware_keycode (event->hardware_keycode);
  if (ret == 0)
    g_printerr ("could not translate key to Flash keycode. HW keycode %u, keyval %u\n",
	event->hardware_keycode, event->keyval);
  return ret;
}

static gboolean
swfdec_gtk_widget_key_press (GtkWidget *gtkwidget, GdkEventKey *event)
{
  SwfdecGtkWidget *widget = SWFDEC_GTK_WIDGET (gtkwidget);
  SwfdecGtkWidgetPrivate *priv = widget->priv;

  if (priv->interactive) {
    guint keycode = swfdec_gtk_event_to_keycode (event);
    if (keycode != 0) {
      swfdec_player_key_press (priv->player, keycode, 
	  gdk_keyval_to_unicode (event->keyval));
    }
    return TRUE;
  }

  return FALSE;
}

static gboolean
swfdec_gtk_widget_key_release (GtkWidget *gtkwidget, GdkEventKey *event)
{
  SwfdecGtkWidget *widget = SWFDEC_GTK_WIDGET (gtkwidget);
  SwfdecGtkWidgetPrivate *priv = widget->priv;

  if (priv->interactive) {
    guint keycode = swfdec_gtk_event_to_keycode (event);
    if (keycode != 0) {
      swfdec_player_key_release (priv->player, keycode, 
	  gdk_keyval_to_unicode (event->keyval));
    }
    return TRUE;
  }

  return FALSE;
}

static cairo_surface_t *
swfdec_gtk_widget_create_renderer (cairo_surface_type_t type, int width, int height)
{
  switch (type) {
    case CAIRO_SURFACE_TYPE_IMAGE:
      return cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
    default:
      break;
  }

  return NULL;
}

static gboolean
swfdec_gtk_widget_expose (GtkWidget *gtkwidget, GdkEventExpose *event)
{
  SwfdecGtkWidget *widget = SWFDEC_GTK_WIDGET (gtkwidget);
  SwfdecGtkWidgetPrivate *priv = widget->priv;
  cairo_t *cr;
  cairo_surface_t *surface = NULL;

  if (event->window != gtkwidget->window)
    return FALSE;
  if (priv->player == NULL)
    return FALSE;

  if (!priv->renderer_set ||
      (surface = swfdec_gtk_widget_create_renderer (priv->renderer, 
	      event->area.width, event->area.height)) == NULL) {
    cr = gdk_cairo_create (gtkwidget->window);
  } else {
    cr = cairo_create (surface);
    cairo_translate (cr, -event->area.x, -event->area.y);
  }
  swfdec_player_render (priv->player, cr,
      event->area.x, event->area.y, event->area.width, event->area.height);
  cairo_show_page (cr);
  cairo_destroy (cr);

  if (surface) {
    cairo_t *crw = gdk_cairo_create (gtkwidget->window);
    cairo_set_source_surface (crw, surface, event->area.x, event->area.y);
    cairo_paint (crw);
    cairo_destroy (crw);
    cairo_surface_destroy (surface);
  }

  return FALSE;
}

static void
swfdec_gtk_widget_get_property (GObject *object, guint param_id, GValue *value, 
    GParamSpec * pspec)
{
  SwfdecGtkWidget *widget = SWFDEC_GTK_WIDGET (object);
  SwfdecGtkWidgetPrivate *priv = widget->priv;
  
  switch (param_id) {
    case PROP_PLAYER:
      g_value_set_object (value, priv->player);
      break;
    case PROP_INTERACTIVE:
      g_value_set_boolean (value, priv->interactive);
      break;
    case PROP_RENDERER_SET:
      g_value_set_boolean (value, priv->renderer_set);
      break;
    case PROP_RENDERER:
      g_value_set_uint (value, priv->renderer);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
      break;
  }
}

static void
swfdec_gtk_widget_set_property (GObject *object, guint param_id, const GValue *value,
    GParamSpec *pspec)
{
  SwfdecGtkWidget *widget = SWFDEC_GTK_WIDGET (object);
  SwfdecGtkWidgetPrivate *priv = widget->priv;
  
  switch (param_id) {
    case PROP_PLAYER:
      swfdec_gtk_widget_set_player (widget, g_value_get_object (value));
      break;
    case PROP_INTERACTIVE:
      swfdec_gtk_widget_set_interactive (widget, g_value_get_boolean (value));
      break;
    case PROP_RENDERER_SET:
      priv->renderer_set = g_value_get_boolean (value);
      gtk_widget_queue_draw (GTK_WIDGET (widget));
      break;
    case PROP_RENDERER:
      priv->renderer = g_value_get_uint (value);
      if (priv->renderer_set)
	gtk_widget_queue_draw (GTK_WIDGET (widget));
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
      break;
  }
}

static void
swfdec_gtk_widget_dispose (GObject *object)
{
  SwfdecGtkWidget *widget = SWFDEC_GTK_WIDGET (object);

  swfdec_gtk_widget_set_player (widget, NULL);

  G_OBJECT_CLASS (swfdec_gtk_widget_parent_class)->dispose (object);
}

static void
swfdec_gtk_widget_size_allocate (GtkWidget *gtkwidget, GtkAllocation *allocation)
{
  SwfdecGtkWidget *widget = SWFDEC_GTK_WIDGET (gtkwidget);
  SwfdecGtkWidgetPrivate *priv = widget->priv;

  gtkwidget->allocation = *allocation;

  if (priv->player)
    swfdec_player_set_size (priv->player, allocation->width, allocation->height);
  if (GTK_WIDGET_REALIZED (gtkwidget)) {
    gdk_window_move_resize (gtkwidget->window, 
	allocation->x, allocation->y, allocation->width, allocation->height);
  }
}

static void
swfdec_gtk_widget_size_request (GtkWidget *gtkwidget, GtkRequisition *req)
{
  SwfdecGtkWidget * widget = SWFDEC_GTK_WIDGET (gtkwidget);
  SwfdecGtkWidgetPrivate *priv = widget->priv;

  if (priv->player == NULL) {
    req->width = req->height = 0;
  } else {
    swfdec_player_get_image_size (priv->player, 
	  &req->width, &req->height);
  } 
}

static void
swfdec_gtk_widget_update_cursor (SwfdecGtkWidget *widget)
{
  GdkWindow *window = GTK_WIDGET (widget)->window;
  GdkDisplay *display = gtk_widget_get_display (GTK_WIDGET (widget));
  SwfdecGtkWidgetPrivate *priv = widget->priv;
  SwfdecMouseCursor swfcursor;