Adding upstream version 2.10.34.upstream/2.10.34upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1763 insertions, 0 deletions

diff --git a/plug-ins/common/animation-play.c b/plug-ins/common/animation-play.c
new file mode 100644
index 0000000..7e0ab26
--- /dev/null
+++ b/plug-ins/common/animation-play.c
@@ -0,0 +1,1763 @@
+/*
+ * Animation Playback plug-in version 0.99.1
+ *
+ * (c) Adam D. Moss : 1997-2000 : adam@gimp.org : adam@foxbox.org
+ * (c) Mircea Purdea : 2009 : someone_else@exhalus.net
+ * (c) Jehan : 2012 : jehan at girinstud.io
+ *
+ * GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/*
+ * TODO:
+ *  pdb interface - should we bother?
+ *
+ *  speedups (caching?  most bottlenecks seem to be in pixelrgns)
+ *    -> do pixelrgns properly!
+ */
+
+#include "config.h"
+
+#include <string.h>
+
+#include <libgimp/gimp.h>
+#undef GDK_DISABLE_DEPRECATED
+#include <libgimp/gimpui.h>
+
+#include "libgimp/stdplugins-intl.h"
+
+
+#define PLUG_IN_PROC   "plug-in-animationplay"
+#define PLUG_IN_BINARY "animation-play"
+#define PLUG_IN_ROLE   "gimp-animation-play"
+#define DITHERTYPE     GDK_RGB_DITHER_NORMAL
+
+
+typedef enum
+{
+  DISPOSE_COMBINE   = 0x00,
+  DISPOSE_REPLACE   = 0x01
+} DisposeType;
+
+typedef struct
+{
+  gint        duration_index;
+  DisposeType default_frame_disposal;
+  guint32     default_frame_duration;
+}
+AnimationSettings;
+
+/* for shaping */
+typedef struct
+{
+  gint x, y;
+} CursorOffset;
+
+/* Declare local functions. */
+static void        query                     (void);
+static void        run                       (const gchar      *name,
+                                              gint              nparams,
+                                              const GimpParam  *param,
+                                              gint             *nreturn_vals,
+                                              GimpParam       **return_vals);
+
+static void        initialize                (void);
+static void        build_dialog              (gchar           *imagename);
+static void        refresh_dialog            (gchar           *imagename);
+
+static void        da_size_callback          (GtkWidget *widget,
+                                              GtkAllocation *allocation, void *data);
+static void        sda_size_callback         (GtkWidget *widget,
+                                              GtkAllocation *allocation, void *data);
+
+static void        window_destroy            (GtkWidget       *widget);
+static void        play_callback             (GtkToggleAction *action);
+static void        step_back_callback        (GtkAction       *action);
+static void        step_callback             (GtkAction       *action);
+static void        refresh_callback          (GtkAction       *action);
+static void        rewind_callback           (GtkAction       *action);
+static void        speed_up_callback         (GtkAction       *action);
+static void        speed_down_callback       (GtkAction       *action);
+static void        speed_reset_callback      (GtkAction       *action);
+static void        framecombo_changed        (GtkWidget       *combo,
+                                              gpointer         data);
+static void        speedcombo_changed        (GtkWidget       *combo,
+                                              gpointer         data);
+static void        fpscombo_changed          (GtkWidget       *combo,
+                                              gpointer         data);
+static void        zoomcombo_activated       (GtkEntry        *combo,
+                                              gpointer         data);
+static void        zoomcombo_changed         (GtkWidget       *combo,
+                                              gpointer         data);
+static gboolean    repaint_sda               (GtkWidget       *darea,
+                                              GdkEventExpose  *event,
+                                              gpointer         data);
+static gboolean    repaint_da                (GtkWidget       *darea,
+                                              GdkEventExpose  *event,
+                                              gpointer         data);
+
+static void        init_frames               (void);
+static void        render_frame              (gint32           whichframe);
+static void        show_frame                (void);
+static void        total_alpha_preview       (void);
+static void        update_alpha_preview      (void);
+static void        update_combobox           (void);
+static gdouble     get_duration_factor       (gint             index);
+static gint        get_fps                   (gint             index);
+static gdouble     get_scale                 (gint             index);
+static void        update_scale              (gdouble          scale);
+
+
+/* tag util functions*/
+static gint        parse_ms_tag              (const gchar     *str);
+static DisposeType parse_disposal_tag        (const gchar     *str);
+static gboolean    is_disposal_tag           (const gchar     *str,
+                                              DisposeType     *disposal,
+                                              gint            *taglength);
+static gboolean    is_ms_tag                 (const gchar     *str,
+                                              gint            *duration,
+                                              gint            *taglength);
+
+
+const GimpPlugInInfo PLUG_IN_INFO =
+{
+  NULL,  /* init_proc  */
+  NULL,  /* quit_proc  */
+  query, /* query_proc */
+  run,   /* run_proc   */
+};
+
+
+/* Global widgets'n'stuff */
+static GtkWidget         *window                    = NULL;
+static GdkWindow         *root_win                  = NULL;
+static GtkUIManager      *ui_manager                = NULL;
+static GtkWidget         *progress;
+static GtkWidget         *speedcombo                = NULL;
+static GtkWidget         *fpscombo                  = NULL;
+static GtkWidget         *zoomcombo                 = NULL;
+static GtkWidget         *frame_disposal_combo      = NULL;
+
+static gint32             image_id;
+static guint              width                     = -1,
+                          height                    = -1;
+static gint32            *layers                    = NULL;
+static gint32             total_layers              = 0;
+
+static GtkWidget         *drawing_area              = NULL;
+static guchar            *drawing_area_data         = NULL;
+static guint              drawing_area_width        = -1,
+                          drawing_area_height       = -1;
+static guchar            *preview_alpha1_data       = NULL;
+static guchar            *preview_alpha2_data       = NULL;
+
+static GtkWidget         *shape_window              = NULL;
+static GtkWidget         *shape_drawing_area        = NULL;
+static guchar            *shape_drawing_area_data   = NULL;
+static guint              shape_drawing_area_width  = -1,
+                          shape_drawing_area_height = -1;
+static gchar             *shape_preview_mask        = NULL;
+
+
+static gint32             total_frames              = 0;
+static gint32            *frames                    = NULL;
+static guchar            *rawframe                  = NULL;
+static guint32           *frame_durations           = NULL;
+static guint              frame_number              = 0;
+
+static gboolean           playing                   = FALSE;
+static guint              timer                     = 0;
+static gboolean           detached                  = FALSE;
+static gdouble            scale, shape_scale;
+
+/* Default settings. */
+static AnimationSettings settings =
+{
+  3,
+  DISPOSE_COMBINE,
+  100 /* ms */
+};
+
+static gint32 frames_image_id = 0;
+
+MAIN ()
+
+static void
+query (void)
+{
+  static const GimpParamDef args[] =
+  {
+    { GIMP_PDB_INT32,    "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
+    { GIMP_PDB_IMAGE,    "image",    "Input image"                  },
+    { GIMP_PDB_DRAWABLE, "drawable", "Input drawable (unused)"      }
+  };
+
+  gimp_install_procedure (PLUG_IN_PROC,
+                          N_("Preview a GIMP layer-based animation"),
+                          "",
+                          "Adam D. Moss <adam@gimp.org>",
+                          "Adam D. Moss <adam@gimp.org>",
+                          "1997, 1998...",
+                          N_("_Playback..."),
+                          "RGB*, INDEXED*, GRAY*",
+                          GIMP_PLUGIN,
+                          G_N_ELEMENTS (args), 0,
+                          args, NULL);
+
+  gimp_plugin_menu_register (PLUG_IN_PROC, "<Image>/Filters/Animation");
+  gimp_plugin_icon_register (PLUG_IN_PROC, GIMP_ICON_TYPE_ICON_NAME,
+                             (const guint8 *) "media-playback-start");
+}
+
+static void
+run (const gchar      *name,
+     gint              n_params,
+     const GimpParam  *param,
+     gint             *nreturn_vals,
+     GimpParam       **return_vals)
+{
+  static GimpParam  values[1];
+  GimpRunMode       run_mode;
+  GimpPDBStatusType status = GIMP_PDB_SUCCESS;
+
+  INIT_I18N ();
+  gegl_init (NULL, NULL);
+
+  *nreturn_vals = 1;
+  *return_vals  = values;
+
+  run_mode = param[0].data.d_int32;
+
+ if (run_mode == GIMP_RUN_NONINTERACTIVE && n_params != 3)
+   {
+     status = GIMP_PDB_CALLING_ERROR;
+   }
+
+  if (status == GIMP_PDB_SUCCESS)
+    {
+      gimp_get_data (PLUG_IN_PROC, &settings);
+      image_id = param[1].data.d_image;
+
+      initialize ();
+      gtk_main ();
+      gimp_set_data (PLUG_IN_PROC, &settings, sizeof (settings));
+
+      if (run_mode != GIMP_RUN_NONINTERACTIVE)
+        gimp_displays_flush ();
+    }
+
+  values[0].type = GIMP_PDB_STATUS;
+  values[0].data.d_status = status;
+
+  gimp_image_delete (frames_image_id);
+  gegl_exit ();
+}
+
+static void
+reshape_from_bitmap (const gchar *bitmap)
+{
+  static gchar *prev_bitmap = NULL;
+  static guint  prev_width = -1;
+  static guint  prev_height = -1;
+
+  if ((!prev_bitmap) ||
+      prev_width != shape_drawing_area_width || prev_height != shape_drawing_area_height ||
+      (memcmp (prev_bitmap, bitmap, (shape_drawing_area_width * shape_drawing_area_height) / 8 + shape_drawing_area_height)))
+    {
+      GdkBitmap *shape_mask;
+
+      shape_mask = gdk_bitmap_create_from_data (gtk_widget_get_window (shape_window),
+                                                bitmap,
+                                                shape_drawing_area_width, shape_drawing_area_height);
+      gtk_widget_shape_combine_mask (shape_window, shape_mask, 0, 0);
+      g_object_unref (shape_mask);
+
+      if (!prev_bitmap || prev_width != shape_drawing_area_width || prev_height != shape_drawing_area_height)
+        {
+          g_free(prev_bitmap);
+          prev_bitmap = g_malloc ((shape_drawing_area_width * shape_drawing_area_height) / 8 + shape_drawing_area_height);
+          prev_width = shape_drawing_area_width;
+          prev_height = shape_drawing_area_height;
+        }
+
+      memcpy (prev_bitmap, bitmap, (shape_drawing_area_width * shape_drawing_area_height) / 8 + shape_drawing_area_height);
+    }
+}
+
+static gboolean
+popup_menu (GtkWidget      *widget,
+            GdkEventButton *event)
+{
+  GtkWidget *menu = gtk_ui_manager_get_widget (ui_manager, "/anim-play-popup");
+
+  gtk_menu_set_screen (GTK_MENU (menu), gtk_widget_get_screen (widget));
+  gtk_menu_popup (GTK_MENU (menu),
+                  NULL, NULL, NULL, NULL,
+                  event ? event->button : 0,
+                  event ? event->time   : gtk_get_current_event_time ());
+
+  return TRUE;
+}
+
+static gboolean
+button_press (GtkWidget      *widget,
+              GdkEventButton *event)
+{
+  if (gdk_event_triggers_context_menu ((GdkEvent *) event))
+    return popup_menu (widget, event);
+
+  return FALSE;
+}
+
+/*
+ * Update the actual drawing area metrics, which may be different as requested,
+ * because there is no full control of the WM.
+ * data is always NULL. */
+static void
+da_size_callback (GtkWidget *widget,
+                  GtkAllocation *allocation, void *data)
+{
+  if (allocation->width == drawing_area_width && allocation->height == drawing_area_height)
+    return;
+
+  drawing_area_width = allocation->width;
+  drawing_area_height = allocation->height;
+  scale = MIN ((gdouble) drawing_area_width / (gdouble) width, (gdouble) drawing_area_height / (gdouble) height);
+
+  g_free (drawing_area_data);
+  drawing_area_data = g_malloc (drawing_area_width * drawing_area_height * 3);
+
+  update_alpha_preview ();
+
+  if (! detached)
+    {
+      /* Update the zoom information. */
+      GtkEntry *zoomcombo_text_child;
+
+      zoomcombo_text_child = GTK_ENTRY (gtk_bin_get_child (GTK_BIN (zoomcombo)));
+      if (zoomcombo_text_child)
+        {
+          char* new_entry_text = g_strdup_printf  (_("%.1f %%"), scale * 100.0);
+
+          gtk_entry_set_text (zoomcombo_text_child, new_entry_text);
+          g_free (new_entry_text);
+        }
+
+      /* Update the rawframe. */
+      g_free (rawframe);
+      rawframe = g_malloc ((unsigned long) drawing_area_width * drawing_area_height * 4);
+
+      /* As we re-allocated the drawn data, let's render it again. */
+      if (frame_number < total_frames)
+        render_frame (frame_number);
+    }
+  else
+    {
+      /* Set "alpha grid" background. */
+      total_alpha_preview ();
+      repaint_da(drawing_area, NULL, NULL);
+    }
+}
+
+/*
+ * Update the actual shape drawing area metrics, which may be different as requested,
+ * They *should* be the same as the drawing area, but the safe way is to make sure
+ * and process it separately.
+ * data is always NULL. */
+static void
+sda_size_callback (GtkWidget *widget,
+                   GtkAllocation *allocation, void *data)
+{
+  if (allocation->width == shape_drawing_area_width && allocation->height == shape_drawing_area_height)
+    return;
+
+  shape_drawing_area_width = allocation->width;
+  shape_drawing_area_height = allocation->height;
+  shape_scale = MIN ((gdouble) shape_drawing_area_width / (gdouble) width, (gdouble) shape_drawing_area_height / (gdouble) height);
+
+  g_free (shape_drawing_area_data);
+  g_free (shape_preview_mask);
+
+  shape_drawing_area_data = g_malloc (shape_drawing_area_width * shape_drawing_area_height * 3);
+  shape_preview_mask = g_malloc ((shape_drawing_area_width * shape_drawing_area_height) / 8 + 1 + shape_drawing_area_height);
+
+  if (detached)
+    {
+      /* Update the zoom information. */
+      GtkEntry *zoomcombo_text_child;
+
+      zoomcombo_text_child = GTK_ENTRY (gtk_bin_get_child (GTK_BIN (zoomcombo)));
+      if (zoomcombo_text_child)
+        {
+          char* new_entry_text = g_strdup_printf  (_("%.1f %%"), shape_scale * 100.0);
+
+          gtk_entry_set_text (zoomcombo_text_child, new_entry_text);
+          g_free (new_entry_text);
+        }
+
+      /* Update the rawframe. */
+      g_free (rawframe);
+      rawframe = g_malloc ((unsigned long) shape_drawing_area_width * shape_drawing_area_height * 4);
+
+      if (frame_number < total_frames)
+        render_frame (frame_number);
+    }
+}
+
+static gboolean
+shape_pressed (GtkWidget      *widget,
+               GdkEventButton *event)
+{
+  if (button_press (widget, event))
+    return TRUE;
+
+  /* ignore double and triple click */
+  if (event->type == GDK_BUTTON_PRESS)
+    {
+      CursorOffset *p = g_object_get_data (G_OBJECT(widget), "cursor-offset");
+
+      if (!p)
+        return FALSE;
+
+      p->x = (gint) event->x;
+      p->y = (gint) event->y;
+
+      gtk_grab_add (widget);
+      gdk_pointer_grab (gtk_widget_get_window (widget), TRUE,
+                        GDK_BUTTON_RELEASE_MASK |
+                        GDK_BUTTON_MOTION_MASK  |
+                        GDK_POINTER_MOTION_HINT_MASK,
+                        NULL, NULL, 0);
+      gdk_window_raise (gtk_widget_get_window (widget));
+    }
+
+  return FALSE;
+}
+
+static gboolean
+shape_released (GtkWidget *widget)
+{
+  gtk_grab_remove (widget);
+  gdk_display_pointer_ungrab (gtk_widget_get_display (widget), 0);
+  gdk_flush ();
+
+  return FALSE;
+}
+
+static gboolean
+shape_motion (GtkWidget      *widget,
+              GdkEventMotion *event)
+{
+  GdkModifierType  mask;
+  gint             xp, yp;
+
+  gdk_window_get_pointer (root_win, &xp, &yp, &mask);
+
+  /* if a button is still held by the time we process this event... */
+  if (mask & GDK_BUTTON1_MASK)
+    {
+      CursorOffset *p = g_object_get_data (G_OBJECT (widget), "cursor-offset");
+
+      if (!p)
+        return FALSE;
+
+      gtk_window_move (GTK_WINDOW (widget), xp  - p->x, yp  - p->y);
+    }
+  else /* the user has released all buttons */
+    {
+      shape_released (widget);
+    }
+
+  return FALSE;
+}
+
+static gboolean
+repaint_da (GtkWidget      *darea,
+            GdkEventExpose *event,
+            gpointer        data)
+{
+  GtkStyle *style = gtk_widget_get_style (darea);
+
+  gdk_draw_rgb_image (gtk_widget_get_window (darea),
+                      style->white_gc,
+                      (gint) ((drawing_area_width - scale * width) / 2),
+                      (gint) ((drawing_area_height - scale * height) / 2),
+                      drawing_area_width, drawing_area_height,
+                      (total_frames == 1) ? GDK_RGB_DITHER_MAX : DITHERTYPE,
+                      drawing_area_data, drawing_area_width * 3);
+
+  return TRUE;
+}
+
+static gboolean
+repaint_sda (GtkWidget      *darea,
+             GdkEventExpose *event,
+             gpointer        data)
+{
+  GtkStyle *style = gtk_widget_get_style (darea);
+
+  gdk_draw_rgb_image (gtk_widget_get_window (darea),
+                      style->white_gc,
+                      (gint) ((shape_drawing_area_width - shape_scale * width) / 2),
+                      (gint) ((shape_drawing_area_height - shape_scale * height) / 2),
+                      shape_drawing_area_width, shape_drawing_area_height,
+                      (total_frames == 1) ? GDK_RGB_DITHER_MAX : DITHERTYPE,
+                      shape_drawing_area_data, shape_drawing_area_width * 3);
+
+  return TRUE;
+}
+
+static void
+close_callback (GtkAction *action,
+                gpointer   data)
+{
+  gtk_widget_destroy (GTK_WIDGET (data));
+}
+
+static void
+help_callback (GtkAction *action,
+               gpointer   data)
+{
+  gimp_standard_help_func (PLUG_IN_PROC, data);
+}
+
+
+static void
+detach_callback (GtkToggleAction *action)
+{
+  gboolean active = gtk_toggle_action_get_active (action);
+
+  if (active == detached)
+    {
+      g_warning ("detached state and toggle action got out of sync");
+      return;
+    }
+
+  detached = active;
+
+  if (detached)
+    {
+      gint x, y;
+
+      /* Create a total-alpha buffer merely for the not-shaped
+         drawing area to now display. */
+
+      gtk_window_set_screen (GTK_WINDOW (shape_window),
+                             gtk_widget_get_screen (drawing_area));
+
+      gtk_widget_show (shape_window);
+
+      if (!gtk_widget_get_realized (drawing_area))
+        gtk_widget_realize (drawing_area);
+      if (!gtk_widget_get_realized (shape_drawing_area))
+        gtk_widget_realize (shape_drawing_area);
+
+      gdk_window_get_origin (gtk_widget_get_window (drawing_area), &x, &y);
+
+      gtk_window_move (GTK_WINDOW (shape_window), x + 6, y + 6);
+
+      gdk_window_set_back_pixmap (gtk_widget_get_window (shape_drawing_area), NULL, TRUE);
+
+
+      /* Set "alpha grid" background. */
+      total_alpha_preview ();
+      repaint_da(drawing_area, NULL, NULL);
+    }
+  else
+    gtk_widget_hide (shape_window);
+
+  render_frame (frame_number);
+}
+
+static GtkUIManager *
+ui_manager_new (GtkWidget *window)
+{
+  static GtkActionEntry actions[] =
+  {
+    { "step-back", "media-skip-backward",
+      N_("Step _back"), "d", N_("Step back to previous frame"),
+      G_CALLBACK (step_back_callback) },
+
+    { "step", "media-skip-forward",
+      N_("_Step"), "f", N_("Step to next frame"),
+      G_CALLBACK (step_callback) },
+
+    { "rewind", "media-seek-backward",
+      NULL, NULL, N_("Rewind the animation"),
+      G_CALLBACK (rewind_callback) },
+
+    { "refresh", GIMP_ICON_VIEW_REFRESH,
+      NULL, "<control>R", N_("Reload the image"),
+      G_CALLBACK (refresh_callback) },
+
+    { "help", "help-browser",
+      NULL, NULL, NULL,
+      G_CALLBACK (help_callback) },
+
+    { "close", "window-close",
+      NULL, "<control>W", NULL,
+      G_CALLBACK (close_callback)
+    },
+    {
+      "quit", "application-quit",
+      NULL, "<control>Q", NULL,
+      G_CALLBACK (close_callback)
+    },
+    {
+      "speed-up", NULL,
+      N_("Faster"), "<control>L", N_("Increase the speed of the animation"),
+      G_CALLBACK (speed_up_callback)
+    },
+    {
+      "speed-down", NULL,
+      N_("Slower"), "<control>J", N_("Decrease the speed of the animation"),
+      G_CALLBACK (speed_down_callback)
+    },
+    {
+      "speed-reset", NULL,
+      N_("Reset speed"), "<control>K", N_("Reset the speed of the animation"),
+      G_CALLBACK (speed_reset_callback)
+    }
+  };
+
+  static GtkToggleActionEntry toggle_actions[] =
+  {
+    { "play", "media-playback-start",
+      NULL, "space", N_("Start playback"),
+      G_CALLBACK (play_callback), FALSE },
+
+    { "detach", GIMP_ICON_DETACH,
+      N_("Detach"), NULL,
+      N_("Detach the animation from the dialog window"),
+      G_CALLBACK (detach_callback), FALSE }
+  };
+
+  GtkUIManager   *ui_manager = gtk_ui_manager_new ();
+  GtkActionGroup *group      = gtk_action_group_new ("Actions");
+  GError         *error      = NULL;
+
+  gtk_action_group_set_translation_domain (group, NULL);
+
+  gtk_action_group_add_actions (group,
+                                actions,
+                                G_N_ELEMENTS (actions),
+                                window);
+  gtk_action_group_add_toggle_actions (group,
+                                       toggle_actions,
+                                       G_N_ELEMENTS (toggle_actions),
+                                       NULL);
+
+  gtk_window_add_accel_group (GTK_WINDOW (window),
+                              gtk_ui_manager_get_accel_group (ui_manager));
+  gtk_accel_group_lock (gtk_ui_manager_get_accel_group (ui_manager));
+
+  gtk_ui_manager_insert_action_group (ui_manager, group, -1);
+  g_object_unref (group);
+
+  gtk_ui_manager_add_ui_from_string (ui_manager,
+                                     "<ui>"
+                                     "  <toolbar name=\"anim-play-toolbar\">"
+                                     "    <toolitem action=\"play\" />"
+                                     "    <toolitem action=\"step-back\" />"
+                                     "    <toolitem action=\"step\" />"
+                                     "    <toolitem action=\"rewind\" />"
+                                     "    <separator />"
+                                     "    <toolitem action=\"detach\" />"
+                                     "    <toolitem action=\"refresh\" />"
+                                     "    <separator name=\"space\" />"
+                                     "    <toolitem action=\"help\" />"
+                                     "  </toolbar>"
+                                     "  <accelerator action=\"close\" />"
+                                     "  <accelerator action=\"quit\" />"
+                                     "</ui>",
+                                     -1, &error);
+
+  if (error)
+    {
+      g_warning ("error parsing ui: %s", error->message);
+      g_clear_error (&error);
+    }
+
+  gtk_ui_manager_add_ui_from_string (ui_manager,
+                                     "<ui>"
+                                     "  <popup name=\"anim-play-popup\">"
+                                     "    <menuitem action=\"play\" />"
+                                     "    <menuitem action=\"step-back\" />"
+                                     "    <menuitem action=\"step\" />"
+                                     "    <menuitem action=\"rewind\" />"
+                                     "    <separator />"
+                                     "    <menuitem action=\"speed-down\" />"
+                                     "    <menuitem action=\"speed-up\" />"
+                                     "    <menuitem action=\"speed-reset\" />"
+                                     "    <separator />"
+                                     "    <menuitem action=\"detach\" />"
+                                     "    <menuitem action=\"refresh\" />"
+                                     "    <menuitem action=\"close\" />"
+                                     "  </popup>"
+                                     "</ui>",
+                                     -1, &error);
+
+  if (error)
+    {
+      g_warning ("error parsing ui: %s", error->message);
+      g_clear_error (&error);
+    }
+
+  return ui_manager;
+}
+
+static void
+refresh_dialog (gchar *imagename)
+{
+  gchar     *name;
+  GdkScreen *screen;
+  guint      screen_width, screen_height;
+  gint       window_width, window_height;
+
+  /* Image Name */
+  name = g_strconcat (_("Animation Playback:"), " ", imagename, NULL);
+  gtk_window_set_title (GTK_WINDOW (window), name);
+  g_free (name);
+
+  /* Update GUI size. */
+  screen = gtk_widget_get_screen (window);
+  screen_height = gdk_screen_get_height (screen);
+  screen_width = gdk_screen_get_width (screen);
+  gtk_window_get_size (GTK_WINDOW (window), &window_width, &window_height);
+
+  /* if the *window* size is bigger than the screen size,
+   * diminish the drawing area by as much, then compute the corresponding scale. */
+  if (window_width + 50 > screen_width || window_height + 50 > screen_height)
+  {
+      guint expected_drawing_area_width = MAX (1, width - window_width + screen_width);
+      guint expected_drawing_area_height = MAX (1, height - window_height + screen_height);
+      gdouble expected_scale = MIN ((gdouble) expected_drawing_area_width / (gdouble) width,
+                                    (gdouble) expected_drawing_area_height / (gdouble) height);
+      update_scale (expected_scale);
+
+      /* There is unfortunately no good way to know the size of the decorations, taskbars, etc.
+       * So we take a wild guess by making the window slightly smaller to fit into any case. */
+      gtk_window_set_default_size (GTK_WINDOW (window),
+                                   MIN (expected_drawing_area_width + 20, screen_width - 60),
+                                   MIN (expected_drawing_area_height + 90, screen_height - 60));
+
+      gtk_window_reshow_with_initial_size (GTK_WINDOW (window));
+  }
+}
+
+static void
+build_dialog (gchar             *imagename)
+{
+  GtkWidget   *toolbar;
+  GtkWidget   *frame;
+  GtkWidget   *viewport;
+  GtkWidget   *main_vbox;
+  GtkWidget   *vbox;
+  GtkWidget   *hbox;
+  GtkWidget   *abox;
+  GtkToolItem *item;
+  GtkAction   *action;
+  GdkCursor   *cursor;
+  gint         index;
+  gchar       *text;
+
+  gimp_ui_init (PLUG_IN_BINARY, TRUE);
+
+
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_role (GTK_WINDOW (window), "animation-playback");
+
+  g_signal_connect (window, "destroy",
+                    G_CALLBACK (window_destroy),
+                    NULL);
+  g_signal_connect (window, "popup-menu",
+                    G_CALLBACK (popup_menu),
+                    NULL);
+
+  gimp_help_connect (window, gimp_standard_help_func, PLUG_IN_PROC, NULL);
+
+  ui_manager = ui_manager_new (window);
+
+  main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+  gtk_container_add (GTK_CONTAINER (window), main_vbox);
+  gtk_widget_show (main_vbox);
+
+  toolbar = gtk_ui_manager_get_widget (ui_manager, "/anim-play-toolbar");
+  gtk_box_pack_start (GTK_BOX (main_vbox), toolbar, FALSE, FALSE, 0);
+  gtk_widget_show (toolbar);
+
+  item =
+    GTK_TOOL_ITEM (gtk_ui_manager_get_widget (ui_manager,
+                                              "/anim-play-toolbar/space"));
+  gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (item), FALSE);
+  gtk_tool_item_set_expand (item, TRUE);
+
+  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
+  gtk_box_pack_start (GTK_BOX (main_vbox), vbox, TRUE, TRUE, 0);
+  gtk_widget_show (vbox);
+
+  /* Alignment for the scrolling window, which can be resized by the user. */
+  abox = gtk_alignment_new (0.5, 0.5, 1.0, 1.0);
+  gtk_box_pack_start (GTK_BOX (vbox), abox, TRUE, TRUE, 0);
+  gtk_widget_show (abox);
+
+  frame = gtk_scrolled_window_new (NULL, NULL);
+  gtk_container_add (GTK_CONTAINER (abox), frame);
+  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (frame),
+                                  GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+  gtk_widget_show (frame);
+
+  viewport = gtk_viewport_new (NULL, NULL);
+  gtk_container_add (GTK_CONTAINER (frame), viewport);
+  gtk_widget_show (viewport);
+
+  /* I add the drawing area inside an alignment box to prevent it from being resized. */
+  abox = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
+  gtk_container_add (GTK_CONTAINER (viewport), abox);
+  gtk_widget_show (abox);
+
+  /* Build a drawing area, with a default size same as the image */
+  drawing_area = gtk_drawing_area_new ();
+  gtk_widget_add_events (drawing_area, GDK_BUTTON_PRESS_MASK);
+  gtk_container_add (GTK_CONTAINER (abox), drawing_area);
+  gtk_widget_show (drawing_area);
+
+  g_signal_connect (drawing_area, "size-allocate",
+                    G_CALLBACK(da_size_callback),
+                    NULL);
+  g_signal_connect (drawing_area, "button-press-event",
+                    G_CALLBACK (button_press),
+                    NULL);
+
+  /* Lower option bar. */
+
+  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
+  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
+  gtk_widget_show (hbox);
+
+  /* Progress bar. */
+
+  progress = gtk_progress_bar_new ();
+  gtk_box_pack_end (GTK_BOX (hbox), progress, TRUE, TRUE, 0);
+  gtk_widget_show (progress);
+
+  /* Zoom */
+  zoomcombo = gtk_combo_box_text_new_with_entry ();
+  gtk_box_pack_end (GTK_BOX (hbox), zoomcombo, FALSE, FALSE, 0);
+  gtk_widget_show (zoomcombo);
+  for (index = 0; index < 5; index++)
+    {
+      /* list is given in "fps" - frames per second */
+      text = g_strdup_printf  (_("%.1f %%"), get_scale (index) * 100.0);
+      gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (zoomcombo), text);
+      g_free (text);
+    }
+
+  gtk_combo_box_set_active (GTK_COMBO_BOX (zoomcombo), 2); /* 1.0 by default. */
+
+  g_signal_connect (GTK_ENTRY (gtk_bin_get_child (GTK_BIN (zoomcombo))),
+                    "activate",
+                    G_CALLBACK (zoomcombo_activated),
+                    NULL);
+  g_signal_connect (zoomcombo, "changed",
+                    G_CALLBACK (zoomcombo_changed),
+                    NULL);
+
+  gimp_help_set_help_data (zoomcombo, _("Zoom"), NULL);
+
+  /* fps combo */
+  fpscombo = gtk_combo_box_text_new ();
+  gtk_box_pack_end (GTK_BOX (hbox), fpscombo, FALSE, FALSE, 0);
+  gtk_widget_show (fpscombo);
+
+  for (index = 0; index < 9; index++)
+    {
+      /* list is given in "fps" - frames per second */
+      text = g_strdup_printf  (_("%d fps"), get_fps (index));
+      gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (fpscombo), text);
+      g_free (text);
+      if (settings.default_frame_duration == 1000 / get_fps(index))
+        gtk_combo_box_set_active (GTK_COMBO_BOX (fpscombo), index);
+    }
+
+  g_signal_connect (fpscombo, "changed",
+                    G_CALLBACK (fpscombo_changed),
+                    NULL);
+
+  gimp_help_set_help_data (fpscombo, _("Default framerate"), NULL);
+
+  /* Speed Combo */
+  speedcombo = gtk_combo_box_text_new ();
+  gtk_box_pack_end (GTK_BOX (hbox), speedcombo, FALSE, FALSE, 0);
+  gtk_widget_show (speedcombo);
+
+  for (index = 0; index < 7; index++)
+    {
+      text = g_strdup_printf  ("%g\303\227", (100 / get_duration_factor (index)) / 100);
+      gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (speedcombo), text);
+      g_free (text);
+    }
+
+  gtk_combo_box_set_active (GTK_COMBO_BOX (speedcombo), settings.duration_index);
+
+  g_signal_connect (speedcombo, "changed",
+                    G_CALLBACK (speedcombo_changed),
+                    NULL);
+
+  gimp_help_set_help_data (speedcombo, _("Playback speed"), NULL);
+
+  action = gtk_ui_manager_get_action (ui_manager,
+                                      "/anim-play-popup/speed-reset");
+  gtk_action_set_sensitive (action, FALSE);
+
+  /* Set up the frame disposal combo. */
+  frame_disposal_combo = gtk_combo_box_text_new ();
+
+  /* 2 styles of default frame disposals: cumulative layers and one frame per layer. */
+  text = g_strdup (_("Cumulative layers (combine)"));
+  gtk_combo_box_text_insert_text (GTK_COMBO_BOX_TEXT (frame_disposal_combo), DISPOSE_COMBINE, text);
+  g_free (text);
+
+  text = g_strdup (_("One frame per layer (replace)"));
+  gtk_combo_box_text_insert_text (GTK_COMBO_BOX_TEXT (frame_disposal_combo), DISPOSE_REPLACE, text);
+  g_free (text);
+
+  gtk_combo_box_set_active (GTK_COMBO_BOX (frame_disposal_combo), settings.default_frame_disposal);
+
+  g_signal_connect (frame_disposal_combo, "changed",
+                    G_CALLBACK (framecombo_changed),
+                    NULL);
+
+  gtk_box_pack_end (GTK_BOX (hbox), frame_disposal_combo, FALSE, FALSE, 0);
+  gtk_widget_show (frame_disposal_combo);
+
+  gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
+  gtk_window_set_default_size (GTK_WINDOW (window), width + 20, height + 90);
+  gtk_widget_show (window);
+
+  /* shape_drawing_area for detached feature. */
+  shape_window = gtk_window_new (GTK_WINDOW_POPUP);
+  gtk_window_set_resizable (GTK_WINDOW (shape_window), FALSE);
+
+  shape_drawing_area = gtk_drawing_area_new ();
+  gtk_container_add (GTK_CONTAINER (shape_window), shape_drawing_area);
+  gtk_widget_show (shape_drawing_area);
+  gtk_widget_add_events (shape_drawing_area, GDK_BUTTON_PRESS_MASK);
+  gtk_widget_realize (shape_drawing_area);
+
+  gdk_window_set_back_pixmap (gtk_widget_get_window (shape_window), NULL, FALSE);
+
+  cursor = gdk_cursor_new_for_display (gtk_widget_get_display (shape_window),
+                                       GDK_HAND2);
+  gdk_window_set_cursor (gtk_widget_get_window (shape_window), cursor);
+  gdk_cursor_unref (cursor);
+
+  g_signal_connect(shape_drawing_area, "size-allocate",
+                   G_CALLBACK(sda_size_callback),
+                   NULL);
+  g_signal_connect (shape_window, "button-press-event",
+                    G_CALLBACK (shape_pressed),
+                    NULL);
+  g_signal_connect (shape_window, "button-release-event",
+                    G_CALLBACK (shape_released),
+                    NULL);
+  g_signal_connect (shape_window, "motion-notify-event",
+                    G_CALLBACK (shape_motion),
+                    NULL);
+
+  g_object_set_data (G_OBJECT (shape_window),
+                     "cursor-offset", g_new0 (CursorOffset, 1));
+
+  g_signal_connect (drawing_area, "expose-event",
+                    G_CALLBACK (repaint_da),
+                    NULL);
+
+  g_signal_connect (shape_drawing_area, "expose-event",
+                    G_CALLBACK (repaint_sda),
+                    NULL);
+
+  /* We request a minimum size *after* having connecting the
+   * size-allocate signal for correct initialization. */
+  gtk_widget_set_size_request (drawing_area, width, height);
+  gtk_widget_set_size_request (shape_drawing_area, width, height);
+
+  root_win = gdk_get_default_root_window ();
+}
+
+static void
+init_frames (void)
+{
+  /* Frames are associated to an unused image. */
+  gint          i;
+  gint32        new_frame, previous_frame, new_layer;
+  gboolean      animated;
+  GtkAction    *action;
+  gint          duration = 0;
+  DisposeType   disposal = settings.default_frame_disposal;
+  gchar        *layer_name;
+
+  total_frames = total_layers;
+
+  /* Cleanup before re-generation. */
+  if (frames)
+    {
+      gimp_image_delete (frames_image_id);
+      g_free (frames);
+      g_free (frame_durations);
+    }
+  frames = g_try_malloc0_n (total_frames, sizeof (gint32));
+  frame_durations = g_try_malloc0_n (total_frames, sizeof (guint32));
+  if (! frames || ! frame_durations)
+    {
+      gimp_message (_("Memory could not be allocated to the frame container."));
+      gtk_main_quit ();
+      gimp_quit ();
+      return;
+    }
+  /* We only use RGB images for display because indexed images would somehow
+     render terrible colors. Layers from other types will be automatically
+     converted. */
+  frames_image_id = gimp_image_new (width, height, GIMP_RGB);
+  /* Save processing time and memory by not saving history and merged frames. */
+  gimp_image_undo_disable (frames_image_id);
+
+  for (i = 0; i < total_frames; i++)
+    {
+      layer_name = gimp_item_get_name (layers[total_layers - (i + 1)]);
+      if (layer_name)
+        {
+          duration = parse_ms_tag (layer_name);
+          disposal = parse_disposal_tag (layer_name);
+          g_free (layer_name);
+        }
+
+      if (i > 0 && disposal != DISPOSE_REPLACE)
+        {
+          previous_frame = gimp_layer_copy (frames[i - 1]);
+          gimp_image_insert_layer (frames_image_id, previous_frame, 0, -1);
+          gimp_item_set_visible (previous_frame, TRUE);
+        }
+      new_layer = gimp_layer_new_from_drawable (layers[total_layers - (i + 1)], frames_image_id);
+      gimp_image_insert_layer (frames_image_id, new_layer, 0, -1);
+      gimp_item_set_visible (new_layer, TRUE);
+      new_frame = gimp_image_merge_visible_layers (frames_image_id, GIMP_CLIP_TO_IMAGE);
+      frames[i] = new_frame;
+      gimp_item_set_visible (new_frame, FALSE);
+
+      if (duration <= 0)
+        duration = settings.default_frame_duration;
+      frame_durations[i] = (guint32) duration;
+    }
+
+  /* Update the UI. */
+  animated = total_frames >= 2;
+  action = gtk_ui_manager_get_action (ui_manager,
+                                      "/ui/anim-play-toolbar/play");
+  gtk_action_set_sensitive (action, animated);
+
+  action = gtk_ui_manager_get_action (ui_manager,
+                                      "/ui/anim-play-toolbar/step-back");
+  gtk_action_set_sensitive (action, animated);
+
+  action = gtk_ui_manager_get_action (ui_manager,
+                                      "/ui/anim-play-toolbar/step");
+  gtk_action_set_sensitive (action, animated);
+
+  action = gtk_ui_manager_get_action (ui_manager,
+                                      "/ui/anim-play-toolbar/rewind");
+  gtk_action_set_sensitive (action, animated);
+
+  /* Keep the same frame number, unless it is now invalid. */
+  if (frame_number >= total_frames)
+    frame_number = 0;
+}
+
+static void
+initialize (void)
+{
+  /* Freeing existing data after a refresh. */
+  g_free (layers);
+
+  /* Catch the case when the user has closed the image in the meantime. */
+  if (! gimp_image_is_valid (image_id))
+    {
+      gimp_message (_("Invalid image. Did you close it?"));
+      gtk_main_quit ();
+      return;
+    }
+
+  width     = gimp_image_width (image_id);
+  height    = gimp_image_height (image_id);
+  layers    = gimp_image_get_layers (image_id, &total_layers);
+
+  if (!window)
+    build_dialog (gimp_image_get_name (image_id));
+  refresh_dialog (gimp_image_get_name (image_id));
+
+  init_frames ();
+  render_frame (frame_number);
+  show_frame ();
+}
+
+/* Rendering Functions */
+
+static void
+render_frame (gint32 whichframe)
+{
+  GeglBuffer    *buffer;
+  gint           i, j, k;
+  guchar        *srcptr;
+  guchar        *destptr;
+  GtkWidget     *da;
+  guint          drawing_width, drawing_height;
+  gdouble        drawing_scale;
+  guchar        *preview_data;
+
+  g_assert (whichframe < total_frames);
+
+  if (detached)
+    {
+      da = shape_drawing_area;
+      preview_data = shape_drawing_area_data;
+      drawing_width = shape_drawing_area_width;
+      drawing_height = shape_drawing_area_height;
+      drawing_scale = shape_scale;
+    }
+  else
+    {
+      da = drawing_area;
+      preview_data = drawing_area_data;
+      drawing_width = drawing_area_width;
+      drawing_height = drawing_area_height;
+      drawing_scale = scale;
+
+      /* Set "alpha grid" background. */
+      total_alpha_preview ();
+    }
+
+  buffer = gimp_drawable_get_buffer (frames[whichframe]);
+
+  /* Fetch and scale the whole raw new frame */
+  gegl_buffer_get (buffer, GEGL_RECTANGLE (0, 0, drawing_width, drawing_height),
+                   drawing_scale, babl_format ("R'G'B'A u8"),
+                   rawframe, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_CLAMP);
+
+  /* Number of pixels. */
+  i = drawing_width * drawing_height;
+  destptr = preview_data;
+  srcptr  = rawframe;
+  while (i--)
+    {
+      if (! (srcptr[3] & 128))
+        {
+          srcptr  += 4;
+          destptr += 3;
+          continue;
+        }
+
+      *(destptr++) = *(srcptr++);
+      *(destptr++) = *(srcptr++);
+      *(destptr++) = *(srcptr++);
+
+      srcptr++;
+    }
+
+  /* calculate the shape mask */
+  if (detached)
+    {
+      memset (shape_preview_mask, 0, (drawing_width * drawing_height) / 8 + drawing_height);
+      srcptr = rawframe + 3;
+
+      for (j = 0; j < drawing_height; j++)
+        {
+          k = j * ((7 + drawing_width) / 8);
+
+          for (i = 0; i < drawing_width; i++)
+            {
+              if ((*srcptr) & 128)
+                shape_preview_mask[k + i/8] |= (1 << (i&7));
+
+              srcptr += 4;
+            }
+        }
+      reshape_from_bitmap (shape_preview_mask);
+    }
+
+  /* Display the preview buffer. */
+  if (gtk_widget_get_realized (da))
+#ifndef PLATFORM_OSX
+    gdk_draw_rgb_image (gtk_widget_get_window (da),
+                        (gtk_widget_get_style (da))->white_gc,
+                        (gint) ((drawing_width - drawing_scale * width) / 2),
+                        (gint) ((drawing_height - drawing_scale * height) / 2),
+                        drawing_width, drawing_height,
+                        (total_frames == 1 ?
+                         GDK_RGB_DITHER_MAX : DITHERTYPE),
+                        preview_data, drawing_width * 3);
+#else
+    gtk_widget_queue_draw (da);
+#endif /* PLATFORM_OSX */
+
+  /* clean up */
+  g_object_unref (buffer);
+}
+
+static void
+show_frame (void)
+{
+  gchar *text;
+
+  /* update the dialog's progress bar */
+  gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress),
+                                 ((gfloat) frame_number /
+                                  (gfloat) (total_frames - 0.999)));
+
+  text = g_strdup_printf (_("Frame %d of %d"), frame_number + 1, total_frames);
+  gtk_progress_bar_set_text (GTK_PROGRESS_BAR (progress), text);
+  g_free (text);
+}
+
+static void
+update_alpha_preview (void)
+{
+  gint i;
+
+  g_free (preview_alpha1_data);
+  g_free (preview_alpha2_data);
+
+  preview_alpha1_data = g_malloc (drawing_area_width * 3);
+  preview_alpha2_data = g_malloc (drawing_area_width * 3);
+
+  for (i = 0; i < drawing_area_width; i++)
+    {
+      if (i & 8)
+        {
+          preview_alpha1_data[i*3 + 0] =
+          preview_alpha1_data[i*3 + 1] =
+          preview_alpha1_data[i*3 + 2] = 102;
+          preview_alpha2_data[i*3 + 0] =
+          preview_alpha2_data[i*3 + 1] =
+          preview_alpha2_data[i*3 + 2] = 154;
+        }
+      else
+        {
+          preview_alpha1_data[i*3 + 0] =
+          preview_alpha1_data[i*3 + 1] =
+          preview_alpha1_data[i*3 + 2] = 154;
+          preview_alpha2_data[i*3 + 0] =
+          preview_alpha2_data[i*3 + 1] =
+          preview_alpha2_data[i*3 + 2] = 102;
+        }
+    }
+}
+
+static void
+total_alpha_preview (void)
+{
+  gint i;
+
+  for (i = 0; i < drawing_area_height; i++)
+    {
+      if (i & 8)
+        memcpy (&drawing_area_data[i * 3 * drawing_area_width], preview_alpha1_data, 3 * drawing_area_width);
+      else
+        memcpy (&drawing_area_data[i * 3 * drawing_area_width], preview_alpha2_data, 3 * drawing_area_width);
+    }
+}
+
+/* Util. */
+
+static void
+remove_timer (void)
+{
+  if (timer)
+    {
+      g_source_remove (timer);
+      timer = 0;
+    }
+}
+
+static void
+do_back_step (void)
+{
+  if (frame_number == 0)
+    frame_number = total_frames - 1;
+  else
+    frame_number = (frame_number - 1) % total_frames;
+  render_frame (frame_number);
+}
+
+static void
+do_step (void)
+{
+  frame_number = (frame_number + 1) % total_frames;
+  render_frame (frame_number);
+}
+
+
+/*  Callbacks  */
+
+static void
+window_destroy (GtkWidget *widget)
+{
+  if (playing)
+    remove_timer ();
+
+  if (shape_window)
+    gtk_widget_destroy (GTK_WIDGET (shape_window));
+
+  gtk_main_quit ();
+}
+
+
+static gint
+advance_frame_callback (gpointer data)
+{
+  gdouble duration;
+
+  remove_timer();
+
+  duration = frame_durations[(frame_number + 1) % total_frames];
+
+  timer = g_timeout_add (duration * get_duration_factor (settings.duration_index),
+                         advance_frame_callback, NULL);
+
+  do_step ();
+  show_frame ();
+
+  return FALSE;
+}
+
+
+static void
+play_callback (GtkToggleAction *action)
+{
+  if (playing)
+    remove_timer ();
+
+  playing = gtk_toggle_action_get_active (action);
+
+  if (playing)
+    {
+      timer = g_timeout_add ((gdouble) frame_durations[frame_number] *
+                             get_duration_factor (settings.duration_index),
+                             advance_frame_callback, NULL);
+
+      gtk_action_set_icon_name (GTK_ACTION (action), "media-playback-pause");
+    }
+  else
+    {
+      gtk_action_set_icon_name (GTK_ACTION (action), "media-playback-start");
+    }
+
+  g_object_set (action,
+                "tooltip", playing ? _("Stop playback") : _("Start playback"),
+                NULL);
+}
+
+static gdouble
+get_duration_factor (gint index)
+{
+  switch (index)
+    {
+    case 0:
+      return 0.125;
+    case 1:
+      return 0.25;
+    case 2:
+      return 0.5;
+    case 3:
+      return 1.0;
+    case 4:
+      return 2.0;
+    case 5:
+      return 4.0;
+    case 6:
+      return 8.0;
+    default:
+      return 1.0;
+    }
+}
+
+static gint
+get_fps (gint index)
+{
+  switch (index)
+    {
+    case 0:
+      return 10;
+    case 1:
+      return 12;
+    case 2:
+      return 15;
+    case 3:
+      return 24;
+    case 4:
+      return 25;
+    case 5:
+      return 30;
+    case 6:
+      return 50;
+    case 7:
+      return 60;
+    case 8:
+      return 72;
+    default:
+      return 10;
+    }
+}
+
+static gdouble
+get_scale (gint index)
+{
+  switch (index)
+    {
+    case 0:
+      return 0.51;
+    case 1:
+      return 1.0;
+    case 2:
+      return 1.25;
+    case 3:
+      return 1.5;
+    case 4:
+      return 2.0;
+    default:
+      {
+        /* likely -1 returned if there is no active item from the list.
+         * Try a text conversion, locale-aware in such a case, assuming people write in percent. */
+        gchar* active_text = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (zoomcombo));
+        gdouble zoom = g_strtod (active_text, NULL);
+
+        /* Negative scales are inconsistent. And we want to avoid huge scaling. */
+        if (zoom > 400.0)
+          zoom = 400.0;
+        else if (zoom <= 50.0)
+          /* FIXME: scales under 0.5 are broken. See bug 690265. */
+          zoom = 50.1;
+        g_free (active_text);
+        return zoom / 100.0;
+      }
+    }
+}
+
+static void
+step_back_callback (GtkAction *action)
+{
+  if (playing)
+    gtk_action_activate (gtk_ui_manager_get_action (ui_manager,
+                                                    "/anim-play-toolbar/play"));
+  do_back_step();
+  show_frame();
+}
+
+static void
+step_callback (GtkAction *action)
+{
+  if (playing)
+    gtk_action_activate (gtk_ui_manager_get_action (ui_manager,
+                                                    "/anim-play-toolbar/play"));
+  do_step();
+  show_frame();
+}
+
+static void
+refresh_callback (GtkAction *action)
+{
+  initialize ();
+}
+
+static void
+rewind_callback (GtkAction *action)
+{
+  if (playing)
+    gtk_action_activate (gtk_ui_manager_get_action (ui_manager,
+                                                    "/anim-play-toolbar/play"));
+  frame_number = 0;
+  render_frame (frame_number);
+  show_frame ();
+}
+
+static void
+speed_up_callback (GtkAction *action)
+{
+  if (settings.duration_index > 0)
+    --settings.duration_index;
+
+  gtk_action_set_sensitive (action, settings.duration_index > 0);
+
+  action = gtk_ui_manager_get_action (ui_manager,
+                                      "/anim-play-popup/speed-reset");
+  gtk_action_set_sensitive (action, settings.duration_index != 3);
+
+  action = gtk_ui_manager_get_action (ui_manager,
+                                      "/anim-play-popup/speed-down");
+  gtk_action_set_sensitive (action, TRUE);
+
+  update_combobox ();
+}
+
+static void
+speed_down_callback (GtkAction *action)
+{
+  if (settings.duration_index < 6)
+    ++settings.duration_index;
+
+  gtk_action_set_sensitive (action, settings.duration_index < 6);
+
+  action = gtk_ui_manager_get_action (ui_manager,
+                                      "/anim-play-popup/speed-reset");
+  gtk_action_set_sensitive (action, settings.duration_index != 3);
+
+  action = gtk_ui_manager_get_action (ui_manager,
+                                      "/anim-play-popup/speed-up");
+  gtk_action_set_sensitive (action, TRUE);
+
+  update_combobox ();
+}
+
+static void
+speed_reset_callback (GtkAction *action)
+{
+  settings.duration_index = 3;
+
+  gtk_action_set_sensitive (action, FALSE);
+
+  action = gtk_ui_manager_get_action (ui_manager,
+                                      "/anim-play-popup/speed-down");
+  gtk_action_set_sensitive (action, TRUE);
+
+  action = gtk_ui_manager_get_action (ui_manager,
+                                      "/anim-play-popup/speed-up");
+  gtk_action_set_sensitive (action, TRUE);
+
+  update_combobox ();
+}
+
+static void
+framecombo_changed (GtkWidget *combo, gpointer data)
+{
+  settings.default_frame_disposal = gtk_combo_box_get_active (GTK_COMBO_BOX (combo));
+  init_frames ();
+  render_frame (frame_number);
+}
+
+static void
+speedcombo_changed (GtkWidget *combo, gpointer data)
+{
+  GtkAction * action;
+
+  settings.duration_index = gtk_combo_box_get_active (GTK_COMBO_BOX (combo));
+
+  action = gtk_ui_manager_get_action (ui_manager,
+                                      "/anim-play-popup/speed-reset");
+  gtk_action_set_sensitive (action, settings.duration_index != 3);
+
+  action = gtk_ui_manager_get_action (ui_manager,
+                                      "/anim-play-popup/speed-down");
+  gtk_action_set_sensitive (action, settings.duration_index < 6);
+
+  action = gtk_ui_manager_get_action (ui_manager,
+                                      "/anim-play-popup/speed-up");
+  gtk_action_set_sensitive (action, settings.duration_index > 0);
+}
+
+static void
+update_scale (gdouble scale)
+{
+  guint expected_drawing_area_width;
+  guint expected_drawing_area_height;
+
+  /* FIXME: scales under 0.5 are broken. See bug 690265. */
+  if (scale <= 0.5)
+    scale = 0.501;
+
+  expected_drawing_area_width = width * scale;
+  expected_drawing_area_height = height * scale;
+
+  gtk_widget_set_size_request (drawing_area, expected_drawing_area_width, expected_drawing_area_height);
+  gtk_widget_set_size_request (shape_drawing_area, expected_drawing_area_width, expected_drawing_area_height);
+  /* I force the shape window to a smaller size if we scale down. */
+  if (detached)
+    {
+      gint x, y;
+
+      gdk_window_get_origin (gtk_widget_get_window (shape_window), &x, &y);
+      gtk_window_reshow_with_initial_size (GTK_WINDOW (shape_window));
+      gtk_window_move (GTK_WINDOW (shape_window), x, y);
+    }
+}
+
+/*
+ * Callback emitted when the user hits the Enter key of the zoom combo.
+ */
+static void
+zoomcombo_activated (GtkEntry *combo, gpointer data)
+{
+  update_scale (get_scale (-1));
+}
+
+/*
+ * Callback emitted when the user selects a zoom in the dropdown,
+ * or edits the text entry.
+ * We don't want to process manual edits because it greedily emits
+ * signals after each character deleted or added.
+ */
+static void
+zoomcombo_changed (GtkWidget *combo, gpointer data)
+{
+  gint index = gtk_combo_box_get_active (GTK_COMBO_BOX (combo));
+
+  /* If no index, user is probably editing by hand. We wait for him to click "Enter". */
+  if (index != -1)
+    update_scale (get_scale (index));
+}
+
+static void
+fpscombo_changed (GtkWidget *combo, gpointer data)
+{
+  settings.default_frame_duration = 1000 / get_fps (gtk_combo_box_get_active (GTK_COMBO_BOX (combo)));
+}
+
+static void
+update_combobox (void)
+{
+  gtk_combo_box_set_active (GTK_COMBO_BOX (speedcombo), settings.duration_index);
+}
+
+/* tag util. */
+
+static gboolean
+is_ms_tag (const gchar *str,
+           gint        *duration,
+           gint        *taglength)
+{
+  gint sum = 0;
+  gint offset;
+  gint length;
+
+  length = strlen(str);
+
+  if (str[0] != '(')
+    return FALSE;
+
+  offset = 1;
+
+  /* eat any spaces between open-parenthesis and number */
+  while ((offset < length) && (str[offset] == ' '))
+    offset++;
+
+  if ((offset>=length) || (!g_ascii_isdigit (str[offset])))
+    return FALSE;
+
+  do
+    {
+      sum *= 10;
+      sum += str[offset] - '0';
+      offset++;
+    }
+  while ((offset<length) && (g_ascii_isdigit (str[offset])));
+
+  if (length - offset <= 2)
+    return FALSE;
+
+  /* eat any spaces between number and 'ms' */
+  while ((offset < length) && (str[offset] == ' '))
+    offset++;
+
+  if (length - offset <= 2                     ||
+      g_ascii_toupper (str[offset])     != 'M' ||
+      g_ascii_toupper (str[offset + 1]) != 'S')
+    return FALSE;
+
+  offset += 2;
+
+  /* eat any spaces between 'ms' and close-parenthesis */
+  while ((offset < length) && (str[offset] == ' '))
+    offset++;
+
+  if ((length - offset < 1) || (str[offset] != ')'))
+    return FALSE;
+
+  offset++;
+
+  *duration = sum;
+  *taglength = offset;
+
+  return TRUE;
+}
+
+static gint
+parse_ms_tag (const gchar *str)
+{
+  gint i;
+  gint length = strlen (str);
+
+  for (i = 0; i < length; i++)
+    {
+      gint rtn;
+      gint dummy;
+
+      if (is_ms_tag (&str[i], &rtn, &dummy))
+        return rtn;
+    }
+
+  return -1;
+}
+
+static gboolean
+is_disposal_tag (const gchar *str,
+                 DisposeType *disposal,
+                 gint        *taglength)
+{
+  if (strlen (str) != 9)
+    return FALSE;
+
+  if (strncmp (str, "(combine)", 9) == 0)
+    {
+      *taglength = 9;
+      *disposal = DISPOSE_COMBINE;
+      return TRUE;
+    }
+  else if (strncmp (str, "(replace)", 9) == 0)
+    {
+      *taglength = 9;
+      *disposal = DISPOSE_REPLACE;
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static DisposeType
+parse_disposal_tag (const gchar *str)
+{
+  gint i;
+  gint length = strlen (str);
+
+  for (i = 0; i < length; i++)
+    {
+      DisposeType rtn;
+      gint        dummy;
+
+      if (is_disposal_tag (&str[i], &rtn, &dummy))
+        return rtn;
+    }
+
+  return settings.default_frame_disposal;
+}
+