git.maemo.org Git - clutter-gtk/blob - clutter-gtk/gtk-clutter-embed.c

   1 /* gtk-clutter-embed.c: Embeddable ClutterStage
   2  *
   3  * Copyright (C) 2007 OpenedHand
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library. If not see <http://www.fsf.org/licensing>.
  17  *
  18  * Authors:
  19  *   Iain Holmes  <iain@openedhand.com>
  20  *   Emmanuele Bassi  <ebassi@openedhand.com>
  21  */
  22
  23 /**
  24  * SECTION:gtk-clutter-embed
  25  * @short_description: Widget for embedding a Clutter scene
  26  *
  27  * #GtkClutterEmbed is a GTK+ widget embedding a #ClutterStage. Using
  28  * a #GtkClutterEmbed widget is possible to build, show and interact with
  29  * a scene built using Clutter inside a GTK+ application.
  30  *
  31  * There can be as many #GtkClutterEmbed widgets per application, but
  32  * they will embed and show the same #ClutterStage as a general limitation
  33  * of Clutter.
  34  *
  35  * <note>To avoid flickering on show, you should call gtk_widget_show()
  36  * or gtk_widget_realize() before calling clutter_actor_show() on the
  37  * embedded #ClutterStage actor. This is needed for Clutter to be able
  38  * to paint on the #GtkClutterEmbed widget.</note>
  39  *
  40  * Since: 0.6
  41  */
  42
  43 #ifdef HAVE_CONFIG_H
  44 #include "config.h"
  45 #endif
  46
  47 #include <glib-object.h>
  48
  49 #include <clutter/clutter-main.h>
  50 #include <clutter/clutter-stage.h>
  51
  52 #include <gdk/gdk.h>
  53 #include <gdk/gdkx.h>
  54 #include <clutter/clutter-x11.h>
  55
  56 #include "gtk-clutter-embed.h"
  57
  58 G_DEFINE_TYPE (GtkClutterEmbed, gtk_clutter_embed, GTK_TYPE_WIDGET);
  59
  60 #define GTK_CLUTTER_EMBED_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GTK_TYPE_CLUTTER_EMBED, GtkClutterEmbedPrivate))
  61
  62 struct _GtkClutterEmbedPrivate
  63 {
  64   ClutterActor *stage;
  65 };
  66
  67 static void
  68 gtk_clutter_embed_send_configure (GtkClutterEmbed *embed)
  69 {
  70   GtkWidget *widget;
  71   GdkEvent *event = gdk_event_new (GDK_CONFIGURE);
  72
  73   widget = GTK_WIDGET (embed);
  74
  75   event->configure.window = g_object_ref (widget->window);
  76   event->configure.send_event = TRUE;
  77   event->configure.x = widget->allocation.x;
  78   event->configure.y = widget->allocation.y;
  79   event->configure.width = widget->allocation.width;
  80   event->configure.height = widget->allocation.height;
  81
  82   gtk_widget_event (widget, event);
  83   gdk_event_free (event);
  84 }
  85
  86 static void
  87 gtk_clutter_embed_dispose (GObject *gobject)
  88 {
  89   G_OBJECT_CLASS (gtk_clutter_embed_parent_class)->dispose (gobject);
  90 }
  91
  92 static void
  93 gtk_clutter_embed_show (GtkWidget *widget)
  94 {
  95   GtkClutterEmbedPrivate *priv = GTK_CLUTTER_EMBED (widget)->priv;
  96
  97   /* Make sure the widget is realised before we show */
  98   gtk_widget_realize (widget);
  99
 100   GTK_WIDGET_CLASS (gtk_clutter_embed_parent_class)->show (widget);
 101
 102   clutter_actor_show (priv->stage);
 103 }
 104
 105 static void
 106 gtk_clutter_embed_hide (GtkWidget *widget)
 107 {
 108   GtkClutterEmbedPrivate *priv = GTK_CLUTTER_EMBED (widget)->priv;
 109
 110   GTK_WIDGET_CLASS (gtk_clutter_embed_parent_class)->hide (widget);
 111
 112   clutter_actor_hide (priv->stage);
 113 }
 114
 115 static void
 116 gtk_clutter_embed_realize (GtkWidget *widget)
 117 {
 118   GtkClutterEmbedPrivate *priv = GTK_CLUTTER_EMBED (widget)->priv;
 119   GdkWindowAttr attributes;
 120   int attributes_mask;
 121
 122   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
 123
 124   attributes.window_type = GDK_WINDOW_CHILD;
 125   attributes.x = widget->allocation.x;
 126   attributes.y = widget->allocation.y;
 127   attributes.width = widget->allocation.width;
 128   attributes.height = widget->allocation.height;
 129   attributes.wclass = GDK_INPUT_OUTPUT;
 130   attributes.visual = gtk_widget_get_visual (widget);
 131   attributes.colormap = gtk_widget_get_colormap (widget);
 132   attributes.event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK;
 133
 134   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 135
 136   widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
 137                                    &attributes,
 138                                    attributes_mask);
 139   gdk_window_set_user_data (widget->window, widget);
 140
 141   widget->style = gtk_style_attach (widget->style, widget->window);
 142   gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
 143
 144   gdk_window_set_back_pixmap (widget->window, NULL, FALSE);
 145
 146   clutter_x11_set_stage_foreign (CLUTTER_STAGE (priv->stage),
 147                                  GDK_WINDOW_XID (widget->window));
 148   clutter_redraw ();
 149
 150   gtk_clutter_embed_send_configure (GTK_CLUTTER_EMBED (widget));
 151 }
 152
 153 static void
 154 gtk_clutter_embed_size_allocate (GtkWidget     *widget,
 155                                  GtkAllocation *allocation)
 156 {
 157   GtkClutterEmbedPrivate *priv = GTK_CLUTTER_EMBED (widget)->priv;
 158
 159   widget->allocation = *allocation;
 160
 161   if (GTK_WIDGET_REALIZED (widget))
 162     {
 163       gdk_window_move_resize (widget->window,
 164                               allocation->x, allocation->y,
 165                               allocation->width, allocation->height);
 166
 167       gtk_clutter_embed_send_configure (GTK_CLUTTER_EMBED (widget));
 168     }
 169
 170   clutter_actor_set_size (priv->stage,
 171                           allocation->width,
 172                           allocation->height);
 173
 174   if (CLUTTER_ACTOR_IS_VISIBLE (priv->stage))
 175     clutter_actor_queue_redraw (priv->stage);
 176 }
 177
 178 static gboolean
 179 gtk_clutter_embed_button_event (GtkWidget      *widget,
 180                                 GdkEventButton *event)
 181 {
 182   ClutterEvent cevent = { 0, };
 183
 184   if (event->type == GDK_BUTTON_PRESS ||
 185       event->type == GDK_2BUTTON_PRESS ||
 186       event->type == GDK_3BUTTON_PRESS)
 187     cevent.type = cevent.button.type = CLUTTER_BUTTON_PRESS;
 188   else if (event->type == GDK_BUTTON_RELEASE)
 189     cevent.type = cevent.button.type = CLUTTER_BUTTON_RELEASE;
 190   else
 191     return FALSE;
 192
 193   cevent.button.x = event->x;
 194   cevent.button.y = event->y;
 195   cevent.button.time = event->time;
 196   cevent.button.click_count =
 197     (event->type == GDK_BUTTON_PRESS ? 1
 198                                      : (event->type == GDK_2BUTTON_PRESS ? 2
 199                                                                          : 3));
 200   cevent.button.modifier_state = event->state;
 201   cevent.button.button = event->button;
 202
 203   clutter_do_event (&cevent);
 204
 205   return TRUE;
 206 }
 207
 208 static gboolean
 209 gtk_clutter_embed_key_event (GtkWidget   *widget,
 210                              GdkEventKey *event)
 211 {
 212   ClutterEvent cevent = { 0, };
 213
 214   if (event->type == GDK_KEY_PRESS)
 215     cevent.type = cevent.key.type = CLUTTER_KEY_PRESS;
 216   else if (event->type == GDK_KEY_RELEASE)
 217     cevent.type = cevent.key.type = CLUTTER_KEY_RELEASE;
 218   else
 219     return FALSE;
 220
 221   cevent.key.time = event->time;
 222   cevent.key.modifier_state = event->state;
 223   cevent.key.keyval = event->keyval;
 224   cevent.key.hardware_keycode = event->hardware_keycode;
 225
 226   clutter_do_event (&cevent);
 227
 228   return TRUE;
 229 }
 230
 231 static gboolean
 232 gtk_clutter_embed_expose_event (GtkWidget *widget, GdkEventExpose *event)
 233 {
 234   GtkClutterEmbedPrivate *priv = GTK_CLUTTER_EMBED (widget)->priv;
 235
 236   if (CLUTTER_ACTOR_IS_VISIBLE (priv->stage))
 237     clutter_actor_queue_redraw (priv->stage);
 238
 239   return TRUE;
 240 }
 241
 242 static gboolean
 243 gtk_clutter_embed_map_event (GtkWidget       *widget,
 244                              GdkEventAny     *event)
 245 {
 246   GtkClutterEmbedPrivate *priv = GTK_CLUTTER_EMBED (widget)->priv;
 247
 248   /* The backend wont get the XEvent as we go strait to do_event().
 249    * So we have to make sure we set the event here.
 250   */
 251   CLUTTER_ACTOR_SET_FLAGS (priv->stage, CLUTTER_ACTOR_MAPPED);
 252
 253   return TRUE;
 254 }
 255
 256 static void
 257 gtk_clutter_embed_class_init (GtkClutterEmbedClass *klass)
 258 {
 259   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 260   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
 261
 262   g_type_class_add_private (klass, sizeof (GtkClutterEmbedPrivate));
 263
 264   gobject_class->dispose = gtk_clutter_embed_dispose;
 265
 266   widget_class->size_allocate = gtk_clutter_embed_size_allocate;
 267   widget_class->realize = gtk_clutter_embed_realize;
 268   widget_class->show = gtk_clutter_embed_show;
 269   widget_class->hide = gtk_clutter_embed_hide;
 270   widget_class->button_press_event = gtk_clutter_embed_button_event;
 271   widget_class->button_release_event = gtk_clutter_embed_button_event;
 272   widget_class->key_press_event = gtk_clutter_embed_key_event;
 273   widget_class->key_release_event = gtk_clutter_embed_key_event;
 274   widget_class->expose_event = gtk_clutter_embed_expose_event;
 275   widget_class->map_event = gtk_clutter_embed_map_event;
 276 }
 277
 278 static void
 279 gtk_clutter_embed_init (GtkClutterEmbed *embed)
 280 {
 281   GtkClutterEmbedPrivate *priv;
 282   const XVisualInfo *xvinfo;
 283   GdkVisual *visual;
 284   GdkColormap *colormap;
 285
 286   embed->priv = priv = GTK_CLUTTER_EMBED_GET_PRIVATE (embed);
 287
 288   gtk_widget_set_double_buffered (GTK_WIDGET (embed), FALSE);
 289
 290   /* note we never ref or unref this */
 291   priv->stage = clutter_stage_get_default ();
 292
 293   /* We need to use the colormap from the Clutter visual */
 294   xvinfo = clutter_x11_get_stage_visual (CLUTTER_STAGE (priv->stage));
 295   visual = gdk_x11_screen_lookup_visual (gdk_screen_get_default (),
 296                                          xvinfo->visualid);
 297   colormap = gdk_colormap_new (visual, FALSE);
 298   gtk_widget_set_colormap (GTK_WIDGET (embed), colormap);
 299 }
 300
 301 /**
 302  * gtk_clutter_init:
 303  *
 304  * This function should be called instead of #clutter_init() and after
 305  * #gtk_init()
 306  *
 307  * Return value: %CLUTTER_INIT_SUCCESS on success, a negative integer
 308  *   on failure.
 309  *
 310  * Since: 0.8
 311  */
 312 ClutterInitError
 313 gtk_clutter_init (int *argc, char ***argv)
 314 {
 315   clutter_x11_set_display (GDK_DISPLAY());
 316   clutter_x11_disable_event_retrieval ();
 317
 318   /* FIXME: call gtk_init() here? */
 319
 320   return clutter_init (argc, argv);
 321 }
 322
 323 /**
 324  * gtk_clutter_embed_new:
 325  *
 326  * Creates a new #GtkClutterEmbed widget. This widget can be
 327  * used to build a scene using Clutter API into a GTK+ application.
 328  *
 329  * Return value: the newly created #GtkClutterEmbed
 330  *
 331  * Since: 0.6
 332  */
 333 GtkWidget *
 334 gtk_clutter_embed_new (void)
 335 {
 336   return g_object_new (GTK_TYPE_CLUTTER_EMBED, NULL);
 337 }
 338
 339 /**
 340  * gtk_clutter_embed_get_stage:
 341  * @embed: a #GtkClutterEmbed
 342  *
 343  * Retrieves the #ClutterStage from @embed. The returned stage can be
 344  * used to add actors to the Clutter scene.
 345  *
 346  * Return value: the Clutter stage. You should never destroy or unref
 347  *   the returned actor.
 348  *
 349  * Since: 0.6
 350  */
 351 ClutterActor *
 352 gtk_clutter_embed_get_stage (GtkClutterEmbed *embed)
 353 {
 354   g_return_val_if_fail (GTK_IS_CLUTTER_EMBED (embed), NULL);
 355
 356   return embed->priv->stage;
 357 }