[gimp/wip/animation: 19/145] plug-ins: the legacy animation becomes "animatic" animation.



commit 2e3f9edfa48a5ca93085709066eacda90707eb17
Author: Jehan <jehan girinstud io>
Date:   Sat Apr 9 13:45:16 2016 +0200

    plug-ins: the legacy animation becomes "animatic" animation.
    
    We show all layers as panels of a storyboard view, where one can choose
    each panel's duration, and whether it combines with the previous one.
    Layer name tagging will still be processed, for backward compatibility,
    but everything will be doable through a much nicer UI now.
    Changes of logics:
    - There aren't 2 modes now. By default, all panels just replace the
    previous one. Note that the button to combine exists but does not work
    yet.
    - Panels can now be commented. Current version has the UI, but neither
    comments nor any other settings are saved at this point.
    - Time is not given in ms as for tagging. Each panel duration is in
    frames, with a global framerate. Keeping irregular frame duration is
    not how animation works.

 plug-ins/animation-play/Makefile.am                |    6 +-
 plug-ins/animation-play/core/animation.c           |  134 +++--
 plug-ins/animation-play/core/animation.h           |   30 +-
 plug-ins/animation-play/core/animationanimatic.c   |  709 ++++++++++++++++++++
 plug-ins/animation-play/core/animationanimatic.h   |   66 ++
 plug-ins/animation-play/core/animationlegacy.c     |  473 -------------
 plug-ins/animation-play/core/animationlegacy.h     |   48 --
 plug-ins/animation-play/widgets/animation-dialog.c |  241 +++----
 .../animation-play/widgets/animation-storyboard.c  |  334 +++++++++
 .../animation-play/widgets/animation-storyboard.h  |   52 ++
 10 files changed, 1365 insertions(+), 728 deletions(-)
---
diff --git a/plug-ins/animation-play/Makefile.am b/plug-ins/animation-play/Makefile.am
index 763be80..944432e 100644
--- a/plug-ins/animation-play/Makefile.am
+++ b/plug-ins/animation-play/Makefile.am
@@ -45,10 +45,12 @@ LDADD = \
 animation_play_SOURCES = \
        core/animation.h                                \
        core/animation.c                                \
-       core/animationlegacy.h                          \
-       core/animationlegacy.c                          \
+       core/animationanimatic.h                \
+       core/animationanimatic.c                \
        widgets/animation-dialog.h              \
        widgets/animation-dialog.c              \
+       widgets/animation-storyboard.h  \
+       widgets/animation-storyboard.c  \
        animation-utils.h                               \
        animation-utils.c                               \
        animation-play.c
diff --git a/plug-ins/animation-play/core/animation.c b/plug-ins/animation-play/core/animation.c
index 6fe1758..3faefcd 100644
--- a/plug-ins/animation-play/core/animation.c
+++ b/plug-ins/animation-play/core/animation.c
@@ -28,7 +28,7 @@
 #include "animation-utils.h"
 
 #include "animation.h"
-#include "animationlegacy.h"
+#include "animationanimatic.h"
 
 enum
 {
@@ -63,7 +63,6 @@ struct _AnimationPrivate
 
   /* State of the currently loaded animation. */
   gint         position;
-  gint32       length;
   /* We want to allow animator to set any number as first frame,
    * for frame export capability. */
   guint        start_pos;
@@ -74,8 +73,10 @@ struct _AnimationPrivate
   /* Proxy settings generates a reload. */
   gdouble      proxy_ratio;
 
-  /* Frames are associated to an unused image (used as backend for GEGL buffers). */
   gboolean     loaded;
+
+  gint64       playback_start_time;
+  gint64       frames_played;
 };
 
 
@@ -95,7 +96,7 @@ static void       animation_get_property           (GObject      *object,
 
 /* Base implementation of virtual methods. */
 static gint       animation_real_get_start_position (Animation *animation);
-static gboolean   animation_real_identical_frames   (Animation *animation,
+static gboolean   animation_real_same               (Animation *animation,
                                                      gint       prev_pos,
                                                      gint       next_pos);
 
@@ -253,6 +254,8 @@ animation_class_init (AnimationClass *klass)
    * @animation: the animation.
    * @playback_start: the playback start frame.
    * @playback_stop: the playback last frame.
+   * @first_frame: the first frame.
+   * @length: the full length.
    *
    * The ::playback-range signal is emitted when the playback range is
    * updated.
@@ -265,7 +268,9 @@ animation_class_init (AnimationClass *klass)
                   NULL, NULL,
                   NULL,
                   G_TYPE_NONE,
-                  2,
+                  4,
+                  G_TYPE_INT,
+                  G_TYPE_INT,
                   G_TYPE_INT,
                   G_TYPE_INT);
   /**
@@ -310,7 +315,7 @@ animation_class_init (AnimationClass *klass)
   object_class->get_property = animation_get_property;
 
   klass->get_start_position  = animation_real_get_start_position;
-  klass->identical_frames    = animation_real_identical_frames;
+  klass->same                = animation_real_same;
 
   /**
    * Animation:image:
@@ -339,15 +344,13 @@ animation_init (Animation *animation)
 /************ Public Functions ****************/
 
 Animation *
-animation_new (gint32      image_id,
-               DisposeType disposal)
+animation_new (gint32   image_id,
+               gboolean xsheet)
 {
   Animation *animation;
 
-  /* Right now, only legacy animation type exists. */
-  animation = g_object_new (ANIMATION_TYPE_ANIMATION_LEGACY,
+  animation = g_object_new (ANIMATION_TYPE_ANIMATIC,
                             "image", image_id,
-                            "disposal", disposal,
                             NULL);
   return animation;
 }
@@ -367,6 +370,7 @@ animation_load (Animation *animation,
   AnimationPrivate *priv = ANIMATION_GET_PRIVATE (animation);
   GeglBuffer       *buffer;
   gint              width, height;
+  gint              length;
 
   priv->loaded = FALSE;
   g_signal_emit (animation, animation_signals[LOADING_START], 0);
@@ -378,17 +382,17 @@ animation_load (Animation *animation,
 
   priv->start_pos = ANIMATION_GET_CLASS (animation)->get_start_position (animation);
   priv->position  = priv->start_pos;
-  priv->length    = ANIMATION_GET_CLASS (animation)->get_length (animation);
+  length    = ANIMATION_GET_CLASS (animation)->get_length (animation);
 
   /* Default playback is the full range of frames. */
   priv->playback_start = priv->position;
-  priv->playback_stop  = priv->position + priv->length - 1;
+  priv->playback_stop  = priv->position + length - 1;
 
   priv->loaded = TRUE;
 
   animation_get_size (animation, &width, &height);
   g_signal_emit (animation, animation_signals[LOADED], 0,
-                 1, priv->length,
+                 1, length,
                  priv->playback_start,
                  priv->playback_stop,
                  width,
@@ -403,13 +407,14 @@ animation_load (Animation *animation,
     g_object_unref (buffer);
 }
 
-DisposeType
-animation_get_disposal (Animation *animation)
+gchar *
+animation_serialize (Animation   *animation)
 {
-  return ANIMATION_GET_CLASS (animation)->get_disposal (animation);
+  return ANIMATION_GET_CLASS (animation)->serialize (animation);
 }
 
-gint animation_get_start_position (Animation *animation)
+gint
+animation_get_start_position (Animation *animation)
 {
   return ANIMATION_GET_CLASS (animation)->get_start_position (animation);
 }
@@ -465,7 +470,7 @@ animation_play (Animation *animation)
   AnimationPrivate *priv = ANIMATION_GET_PRIVATE (animation);
   gint              duration;
 
-  duration = ANIMATION_GET_CLASS (animation)->time_to_next (animation);
+  duration = (gint) (1000.0 / animation_get_framerate (animation));
 
   if (priv->playback_timer)
     {
@@ -476,11 +481,8 @@ animation_play (Animation *animation)
       g_source_remove (priv->playback_timer);
     }
 
-  if (duration <= 0)
-    {
-      gdouble fps = animation_get_framerate (animation);
-      duration = (gint) (1000.0 / fps);
-    }
+  priv->playback_start_time = g_get_monotonic_time ();
+  priv->frames_played = 1;
 
   priv->playback_timer = g_timeout_add ((guint) duration,
                                         (GSourceFunc) animation_advance_frame_callback,
@@ -508,19 +510,21 @@ animation_next (Animation *animation)
   AnimationPrivate *priv         = ANIMATION_GET_PRIVATE (animation);
   GeglBuffer       *buffer       = NULL;
   gint              previous_pos = priv->position;
+  gboolean          identical;
 
   priv->position = animation_get_playback_start (animation) +
                    ((priv->position - animation_get_playback_start (animation) + 1) %
                     (animation_get_playback_stop (animation) - animation_get_playback_start (animation) + 
1));
 
-  if (! ANIMATION_GET_CLASS (animation)->identical_frames (animation,
-                                                           previous_pos,
-                                                           priv->position))
+  identical = ANIMATION_GET_CLASS (animation)->same (animation,
+                                                     previous_pos,
+                                                     priv->position);
+  if (! identical)
     {
       buffer = animation_get_frame (animation, priv->position);
     }
   g_signal_emit (animation, animation_signals[RENDER], 0,
-                 priv->position, buffer, FALSE);
+                 priv->position, buffer, ! identical);
   if (buffer != NULL)
     {
       g_object_unref (buffer);
@@ -533,6 +537,7 @@ animation_prev (Animation *animation)
   AnimationPrivate *priv     = ANIMATION_GET_PRIVATE (animation);
   GeglBuffer       *buffer   = NULL;
   gint              prev_pos = priv->position;
+  gboolean          identical;
 
   if (priv->position == animation_get_playback_start (animation))
     {
@@ -543,14 +548,15 @@ animation_prev (Animation *animation)
       --priv->position;
     }
 
-  if (! ANIMATION_GET_CLASS (animation)->identical_frames (animation,
-                                                           prev_pos,
-                                                           priv->position))
+  identical = ANIMATION_GET_CLASS (animation)->same (animation,
+                                                     prev_pos,
+                                                     priv->position);
+  if (! identical)
     {
       buffer = animation_get_frame (animation, priv->position);
     }
   g_signal_emit (animation, animation_signals[RENDER], 0,
-                 priv->position, buffer, FALSE);
+                 priv->position, buffer, ! identical);
   if (buffer)
     g_object_unref (buffer);
 }
@@ -562,6 +568,7 @@ animation_jump (Animation *animation,
   AnimationPrivate *priv           = ANIMATION_GET_PRIVATE (animation);
   GeglBuffer       *buffer         = NULL;
   gint              prev_pos = priv->position;
+  gboolean          identical;
 
   if (index < priv->playback_start ||
       index > priv->playback_stop)
@@ -569,14 +576,15 @@ animation_jump (Animation *animation,
   else
     priv->position = index;
 
-  if (! ANIMATION_GET_CLASS (animation)->identical_frames (animation,
-                                                           prev_pos,
-                                                           priv->position))
+  identical = ANIMATION_GET_CLASS (animation)->same (animation,
+                                                     prev_pos,
+                                                     priv->position);
+  if (! identical)
     {
       buffer = animation_get_frame (animation, priv->position);
     }
   g_signal_emit (animation, animation_signals[RENDER], 0,
-                 priv->position, buffer, FALSE);
+                 priv->position, buffer, ! identical);
   if (buffer)
     g_object_unref (buffer);
 }
@@ -586,9 +594,12 @@ animation_set_playback_start (Animation *animation,
                               gint       frame_number)
 {
   AnimationPrivate *priv = ANIMATION_GET_PRIVATE (animation);
+  gint              length;
+
+  length = animation_get_length (animation);
 
   if (frame_number < priv->start_pos ||
-      frame_number >= priv->start_pos + priv->length)
+      frame_number >= priv->start_pos + length)
     {
       priv->playback_start = priv->start_pos;
     }
@@ -598,11 +609,12 @@ animation_set_playback_start (Animation *animation,
     }
   if (priv->playback_stop < priv->playback_start)
     {
-      priv->playback_stop = priv->start_pos + priv->length - 1;
+      priv->playback_stop = priv->start_pos + length - 1;
     }
 
   g_signal_emit (animation, animation_signals[PLAYBACK_RANGE], 0,
-                 priv->playback_start, priv->playback_stop);
+                 priv->playback_start, priv->playback_stop,
+                 priv->start_pos, length);
 
   if (priv->position < priv->playback_start ||
       priv->position > priv->playback_stop)
@@ -624,11 +636,14 @@ animation_set_playback_stop (Animation *animation,
                              gint       frame_number)
 {
   AnimationPrivate *priv = ANIMATION_GET_PRIVATE (animation);
+  gint              length;
+
+  length = animation_get_length (animation);
 
   if (frame_number < priv->start_pos ||
-      frame_number >= priv->start_pos + priv->length)
+      frame_number >= priv->start_pos + length)
     {
-      priv->playback_stop = priv->start_pos + priv->length - 1;
+      priv->playback_stop = priv->start_pos + length - 1;
     }
   else
     {
@@ -639,7 +654,8 @@ animation_set_playback_stop (Animation *animation,
       priv->playback_start = priv->start_pos;
     }
   g_signal_emit (animation, animation_signals[PLAYBACK_RANGE], 0,
-                 priv->playback_start, priv->playback_stop);
+                 priv->playback_start, priv->playback_stop,
+                 priv->start_pos, length);
 
   if (priv->position < priv->playback_start ||
       priv->position > priv->playback_stop)
@@ -738,9 +754,9 @@ gint animation_real_get_start_position (Animation *animation)
 }
 
 static gboolean
-animation_real_identical_frames (Animation *animation,
-                                 gint       previous_pos,
-                                 gint       next_pos)
+animation_real_same (Animation *animation,
+                     gint       previous_pos,
+                     gint       next_pos)
 {
   /* By default all frames are supposed different. */
   return (previous_pos == next_pos);
@@ -750,16 +766,34 @@ static gboolean
 animation_advance_frame_callback (Animation *animation)
 {
   AnimationPrivate *priv = ANIMATION_GET_PRIVATE (animation);
-  gint              duration;
+  gint64            duration;
+  gint64            duration_since_start;
+  static gboolean   prev_low_framerate = FALSE;
 
   animation_next (animation);
-  duration = ANIMATION_GET_CLASS (animation)->time_to_next (animation);
+  duration = (gint) (1000.0 / animation_get_framerate (animation));
+
+  duration_since_start = (g_get_monotonic_time () - priv->playback_start_time) / 1000;
+  duration = duration - (duration_since_start - priv->frames_played * duration);
 
-  if (duration <= 0)
+  if (duration < 1)
+    {
+      if (prev_low_framerate)
+        {
+          /* Let's only warn the user for several subsequent slow frames. */
+          gdouble real_framerate = (gdouble) priv->frames_played * 1000.0 / duration_since_start;
+          if (real_framerate < priv->framerate)
+            g_signal_emit (animation, animation_signals[LOW_FRAMERATE], 0,
+                           real_framerate);
+        }
+      duration = 1;
+      prev_low_framerate = TRUE;
+    }
+  else
     {
-      gdouble fps = animation_get_framerate (animation);
-      duration = (gint) (1000.0 / fps);
+      prev_low_framerate = FALSE;
     }
+  priv->frames_played++;
 
   priv->playback_timer = g_timeout_add ((guint) duration,
                                         (GSourceFunc) animation_advance_frame_callback,
diff --git a/plug-ins/animation-play/core/animation.h b/plug-ins/animation-play/core/animation.h
index 9b701f8..21d9418 100644
--- a/plug-ins/animation-play/core/animation.h
+++ b/plug-ins/animation-play/core/animation.h
@@ -31,18 +31,6 @@
 typedef struct _Animation      Animation;
 typedef struct _AnimationClass AnimationClass;
 
-typedef enum
-{
-  /* Each layer is combined over the previous frame. */
-  DISPOSE_COMBINE  = 0x00,
-  /* Each layer is a frame. */
-  DISPOSE_REPLACE  = 0x01,
-  /* Custom disposal through timeline. */
-  DISPOSE_XSHEET   = 0x02,
-  /* Keep the current disposal */
-  DISPOSE_KEEP     = 0x03,
-} DisposeType;
-
 struct _Animation
 {
   GObject      parent_instance;
@@ -56,38 +44,36 @@ struct _AnimationClass
   gint         (*get_start_position) (Animation *animation);
 
   /* Defaults to returning FALSE for any different position. */
-  gboolean     (*identical_frames) (Animation *animation,
-                                    gint       prev_pos,
-                                    gint       next_pos);
+  gboolean     (*same)               (Animation *animation,
+                                      gint       prev_pos,
+                                      gint       next_pos);
 
   /* These virtual methods must be implemented by any subclass. */
   void         (*load)          (Animation  *animation,
                                  gdouble     proxy_ratio);
-  DisposeType  (*get_disposal)  (Animation   *animation);
   gint         (*get_length)    (Animation   *animation);
-  gint         (*next)          (Animation   *animation);
-  gint         (*prev)          (Animation   *animation);
 
 
   void         (*get_size)      (Animation   *animation,
                                  gint        *width,
                                  gint        *height);
 
-  gint         (*time_to_next)  (Animation   *animation);
-
   GeglBuffer * (*get_frame)     (Animation   *animation,
                                  gint         pos);
+
+  gchar      * (*serialize)     (Animation   *animation);
 };
 
 GType         animation_get_type (void);
 
 Animation   * animation_new                (gint32       image_id,
-                                            DisposeType  disposal);
+                                            gboolean     xsheet);
 gint32        animation_get_image_id       (Animation   *animation);
 
 void          animation_load               (Animation   *animation,
                                             gdouble      proxy_ratio);
-DisposeType   animation_get_disposal       (Animation   *animation);
+
+gchar       * animation_serialize          (Animation   *animation);
 
 gint          animation_get_start_position (Animation   *animation);
 gint          animation_get_position       (Animation   *animation);
diff --git a/plug-ins/animation-play/core/animationanimatic.c 
b/plug-ins/animation-play/core/animationanimatic.c
new file mode 100644
index 0000000..060aecf
--- /dev/null
+++ b/plug-ins/animation-play/core/animationanimatic.c
@@ -0,0 +1,709 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * animation.c
+ * Copyright (C) 2016 Jehan <jehan gimp org>
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <libgimp/gimp.h>
+#include <libgimp/stdplugins-intl.h>
+
+#include "animationanimatic.h"
+
+enum
+{
+  IMAGE_DURATION,
+  LAST_SIGNAL
+};
+
+typedef struct _AnimationAnimaticPrivate AnimationAnimaticPrivate;
+
+struct _AnimationAnimaticPrivate
+{
+  gint         preview_width;
+  gint         preview_height;
+
+  /* Panel images are associated to an unused image (used as backend
+   * for GEGL buffers). */
+  gint32       panels;
+  /* The number of panels. */
+  gint         n_panels;
+  /* Layers associated to each panel. For serialization. */
+  gint        *tattoos;
+  /* The duration of each panel in frames. */
+  gint        *durations;
+  /* Whether a panel should get blended together with previous panel. */
+  gboolean    *combine;
+  /* Panel comments. */
+  gchar      **comments;
+};
+
+#define GET_PRIVATE(animation) \
+        G_TYPE_INSTANCE_GET_PRIVATE (animation, \
+                                     ANIMATION_TYPE_ANIMATIC, \
+                                     AnimationAnimaticPrivate)
+
+static void         animation_animatic_finalize   (GObject           *object);
+
+/* Virtual methods */
+
+static gint         animation_animatic_get_length (Animation         *animation);
+static void         animation_animatic_get_size   (Animation         *animation,
+                                                   gint              *width,
+                                                   gint              *height);
+
+static void         animation_animatic_load       (Animation         *animation,
+                                                   gdouble            proxy_ratio);
+static GeglBuffer * animation_animatic_get_frame  (Animation         *animation,
+                                                   gint               pos);
+static gchar      * animation_animatic_serialize  (Animation         *animation);
+static gboolean     animation_animatic_same       (Animation         *animation,
+                                                   gint               previous_pos,
+                                                   gint               next_pos);
+
+/* Utils */
+
+static gint         animation_animatic_get_layer  (AnimationAnimatic *animation,
+                                                   gint               pos);
+
+/* Tag handling (from layer names) */
+
+static gint         parse_ms_tag                  (Animation         *animation,
+                                                   const gchar       *str);
+static gboolean     parse_combine_tag             (const gchar       *str);
+
+static gboolean     is_ms_tag                     (const gchar       *str,
+                                                   gint              *duration,
+                                                   gint              *taglength);
+
+G_DEFINE_TYPE (AnimationAnimatic, animation_animatic, ANIMATION_TYPE_ANIMATION)
+
+#define parent_class animation_animatic_parent_class
+
+static guint signals[LAST_SIGNAL] = { 0 };
+
+static void
+animation_animatic_class_init (AnimationAnimaticClass *klass)
+{
+  GObjectClass   *object_class = G_OBJECT_CLASS (klass);
+  AnimationClass *anim_class   = ANIMATION_CLASS (klass);
+
+  /**
+   * AnimationAnimatic::image-duration:
+   * @animatic: the #AnimationAnimatic.
+   * @layer_id: the #GimpLayer id.
+   * @duration: the new duration for @layer_id (in number of panels).
+   *
+   * The ::image-duration will be emitted when the duration of a layer
+   * changes. It can be %0 meaning that this layer should not be shown
+   * in the reel.
+   */
+  signals[IMAGE_DURATION] =
+    g_signal_new ("image-duration",
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_FIRST,
+                  0,
+                  NULL, NULL,
+                  NULL,
+                  G_TYPE_NONE,
+                  2,
+                  G_TYPE_INT,
+                  G_TYPE_INT);
+
+  object_class->finalize = animation_animatic_finalize;
+
+  anim_class->get_length = animation_animatic_get_length;
+  anim_class->get_size   = animation_animatic_get_size;
+  anim_class->load       = animation_animatic_load;
+  anim_class->get_frame  = animation_animatic_get_frame;
+  anim_class->serialize  = animation_animatic_serialize;
+  anim_class->same       = animation_animatic_same;
+
+  g_type_class_add_private (klass, sizeof (AnimationAnimaticPrivate));
+}
+
+static void
+animation_animatic_init (AnimationAnimatic *animation)
+{
+}
+
+static void
+animation_animatic_finalize (GObject *object)
+{
+  AnimationAnimaticPrivate *priv = GET_PRIVATE (object);
+
+  gimp_image_delete (priv->panels);
+  if (priv->tattoos)
+    g_free (priv->tattoos);
+  if (priv->durations)
+    g_free (priv->durations);
+  if (priv->combine)
+    g_free (priv->combine);
+  if (priv->comments)
+    {
+      gint i;
+
+      for (i = 0; i < priv->n_panels; i++)
+        {
+          g_free (priv->comments[i]);
+        }
+      g_free (priv->comments);
+    }
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+/**** Public Functions ****/
+
+void
+animation_animatic_set_duration (AnimationAnimatic *animatic,
+                                 gint               panel_num,
+                                 gint               duration)
+{
+  AnimationAnimaticPrivate *priv           = GET_PRIVATE (animatic);
+  Animation                *animation      = ANIMATION (animatic);
+  gint                      prev_length    = animation_get_length (animation);
+  gint                      playback_start = animation_get_playback_start (animation);
+  gint                      playback_stop  = animation_get_playback_stop (animation);
+  gint                      position       = animation_get_position (animation);
+  gint                      layer_id;
+  gint                      length;
+
+  g_return_if_fail (duration >= 0  &&
+                    panel_num > 0 &&
+                    panel_num <= priv->n_panels);
+
+  layer_id = animation_animatic_get_layer (animatic, position);
+
+  priv->durations[panel_num - 1] = duration;
+  length = animation_get_length (animation);
+
+  if (playback_start > length)
+    {
+      playback_start = animation_get_start_position (animation);
+    }
+  if (playback_stop > length ||
+      playback_stop == prev_length)
+    {
+      playback_stop = length;
+    }
+  g_signal_emit (animatic, signals[IMAGE_DURATION], 0,
+                 panel_num, duration);
+  g_signal_emit_by_name (animatic, "playback-range",
+                         playback_start, playback_stop,
+                         animation_get_start_position (animation),
+                         animation_get_length (animation));
+  if (position > length)
+    {
+      animation_jump (animation, length);
+    }
+  else if (layer_id != animation_animatic_get_layer (animatic, position))
+    {
+      GeglBuffer *buffer;
+
+      buffer = animation_get_frame (animation, position);
+      g_signal_emit_by_name (animation, "render",
+                             position, buffer, TRUE);
+      if (buffer)
+        g_object_unref (buffer);
+    }
+}
+
+gint
+animation_animatic_get_duration (AnimationAnimatic *animatic,
+                                 gint               panel_num)
+{
+  AnimationAnimaticPrivate *priv = GET_PRIVATE (animatic);
+
+  g_return_val_if_fail (panel_num > 0 &&
+                        panel_num <= priv->n_panels,
+                        0);
+
+  return priv->durations[panel_num - 1];
+}
+
+void
+animation_animatic_set_comment (AnimationAnimatic *animatic,
+                                gint               panel_num,
+                                const gchar       *comment)
+{
+  AnimationAnimaticPrivate *priv = GET_PRIVATE (animatic);
+
+  g_return_if_fail (panel_num > 0 &&
+                    panel_num <= priv->n_panels);
+
+  if (priv->comments[panel_num - 1])
+    g_free (priv->comments[panel_num - 1]);
+
+  priv->comments[panel_num - 1] = g_strdup (comment);
+}
+
+const gchar *
+animation_animatic_get_comment (AnimationAnimatic *animatic,
+                                gint               panel_num)
+{
+  AnimationAnimaticPrivate *priv = GET_PRIVATE (animatic);
+
+  g_return_val_if_fail (panel_num > 0 &&
+                        panel_num <= priv->n_panels,
+                        0);
+  return priv->comments[panel_num - 1];
+}
+
+void
+animation_animatic_set_combine (AnimationAnimatic *animatic,
+                                gint               panel_num,
+                                gboolean           combine)
+{
+  AnimationAnimaticPrivate *priv = GET_PRIVATE (animatic);
+
+  g_return_if_fail (panel_num > 0 &&
+                    panel_num <= priv->n_panels);
+
+  priv->combine[panel_num] = combine;
+}
+
+const gboolean
+animation_animatic_get_combine (AnimationAnimatic *animatic,
+                                gint               panel_num)
+{
+  AnimationAnimaticPrivate *priv = GET_PRIVATE (animatic);
+
+  g_return_val_if_fail (panel_num > 0 &&
+                        panel_num <= priv->n_panels,
+                        0);
+  return priv->combine[panel_num - 1];
+}
+
+/**** Virtual methods ****/
+
+static gint
+animation_animatic_get_length (Animation *animation)
+{
+  AnimationAnimaticPrivate *priv = GET_PRIVATE (animation);
+  gint                      count = 0;
+  gint                      i ;
+
+  for (i = 0; i < priv->n_panels; i++)
+    {
+      count += priv->durations[i];
+    }
+
+  return count;
+}
+
+static void
+animation_animatic_get_size (Animation *animation,
+                             gint      *width,
+                             gint      *height)
+{
+  AnimationAnimaticPrivate *priv = GET_PRIVATE (animation);
+
+  *width  = priv->preview_width;
+  *height = priv->preview_height;
+}
+
+static void
+animation_animatic_load (Animation *animation,
+                         gdouble    proxy_ratio)
+{
+  AnimationAnimaticPrivate *priv = GET_PRIVATE (animation);
+  gint32                   *layers;
+  gint32                    image_id;
+  gint32                    new_frame;
+  gint32                    previous_frame = 0;
+  gint                      image_width;
+  gint                      image_height;
+  gint                      i;
+
+  g_return_if_fail (proxy_ratio > 0.0 && proxy_ratio <= 1.0);
+
+  /* Cleaning. */
+  if (gimp_image_is_valid (priv->panels))
+    {
+      gimp_image_delete (priv->panels);
+      g_free (priv->tattoos);
+      g_free (priv->durations);
+      g_free (priv->combine);
+
+      for (i = 0; i < priv->n_panels; i++)
+        {
+          g_free (priv->comments[i]);
+        }
+      g_free (priv->comments);
+    }
+
+  image_id = animation_get_image_id (animation);
+  layers   = gimp_image_get_layers (image_id, &priv->n_panels);
+
+  priv->tattoos   = g_try_malloc0_n (priv->n_panels, sizeof (gint));
+  priv->durations = g_try_malloc0_n (priv->n_panels, sizeof (gint));
+  priv->combine   = g_try_malloc0_n (priv->n_panels, sizeof (gboolean));
+  priv->comments  = g_try_malloc0_n (priv->n_panels, sizeof (gchar*));
+  if (! priv->tattoos || ! priv->durations ||
+      ! priv->combine || ! priv->comments)
+    {
+      gimp_message (_("Memory could not be allocated to the animatic."));
+      gimp_quit ();
+      return;
+    }
+
+  /* We default at full preview size. */
+  image_width  = gimp_image_width (image_id);
+  image_height = gimp_image_height (image_id);
+
+  priv->preview_width = image_width;
+  priv->preview_height = image_height;
+
+  /* Apply proxy ratio. */
+  priv->preview_width  *= proxy_ratio;
+  priv->preview_height *= proxy_ratio;
+
+  priv->panels = gimp_image_new (priv->preview_width,
+                                 priv->preview_width,
+                                 GIMP_RGB);
+
+  gimp_image_undo_disable (priv->panels);
+
+  for (i = 0; i < priv->n_panels; i++)
+    {
+      gchar       *layer_name;
+      gint         duration;
+      gboolean     combine;
+      gint         layer_offx;
+      gint         layer_offy;
+
+      g_signal_emit_by_name (animation, "loading",
+                             (gdouble) i / ((gdouble) priv->n_panels - 0.999));
+
+      layer_name = gimp_item_get_name (layers[priv->n_panels - (i + 1)]);
+
+      duration = parse_ms_tag (animation, layer_name);
+      combine  = parse_combine_tag (layer_name);
+
+      /* Frame duration. */
+      priv->tattoos[i]   = gimp_item_get_tattoo (layers[priv->n_panels - (i + 1)]);
+      priv->durations[i] = duration;
+      priv->combine[i]   = combine;
+      /* Layer names are used as default comments. */
+      priv->comments[i]  = layer_name;
+
+      /* Frame disposal. */
+      if (i > 0 && combine)
+        {
+          previous_frame = gimp_layer_copy (previous_frame);
+          gimp_image_insert_layer (priv->panels, previous_frame, 0, 0);
+          gimp_item_set_visible (previous_frame, TRUE);
+        }
+
+      new_frame = gimp_layer_new_from_drawable (layers[priv->n_panels - (i + 1)],
+                                                priv->panels);
+      gimp_image_insert_layer (priv->panels, new_frame, 0, 0);
+      gimp_layer_scale (new_frame,
+                        (gimp_drawable_width (layers[priv->n_panels - (i + 1)]) * (gint) 
priv->preview_width) / image_width,
+                        (gimp_drawable_height (layers[priv->n_panels - (i + 1)]) * (gint) 
priv->preview_height) / image_height,
+                        FALSE);
+      gimp_drawable_offsets (layers[priv->n_panels - (i + 1)], &layer_offx, &layer_offy);
+      gimp_layer_set_offsets (new_frame,
+                              (layer_offx * (gint) priv->preview_width) / image_width,
+                              (layer_offy * (gint) priv->preview_height) / image_height);
+      gimp_layer_resize_to_image_size (new_frame);
+      gimp_item_set_visible (new_frame, TRUE);
+      new_frame = gimp_image_merge_visible_layers (priv->panels, GIMP_CLIP_TO_IMAGE);
+      gimp_item_set_visible (new_frame, FALSE);
+
+      previous_frame = new_frame;
+    }
+  g_free (layers);
+}
+
+static GeglBuffer *
+animation_animatic_get_frame (Animation *animation,
+                              gint       pos)
+{
+  AnimationAnimaticPrivate *priv = GET_PRIVATE (animation);
+  GeglBuffer               *buffer = NULL;
+
+  if (priv->panels)
+    {
+      gint32 *layers;
+      gint32  num_layers;
+      gint    count = 0;
+
+      layers = gimp_image_get_layers (priv->panels, &num_layers);
+
+      if (num_layers > 0 &&
+          pos >= 1       &&
+          pos <= animation_animatic_get_length (animation))
+        {
+          gint i ;
+
+          for (i = 0; i < num_layers; i++)
+            {
+              count += priv->durations[i];
+              if (count >= pos)
+                break;
+            }
+
+          buffer = gimp_drawable_get_buffer (layers[num_layers - i - 1]);
+        }
+
+      g_free (layers);
+    }
+
+  return buffer;
+}
+
+static gchar *
+animation_animatic_serialize (Animation *animation)
+{
+  AnimationAnimaticPrivate *priv = GET_PRIVATE (animation);
+  gchar                    *text;
+  gchar                    *tmp;
+  gint                      i;
+
+  text = g_strdup_printf ("<animation framerate=\"%f\" type=\"animatic\"><sequence>",
+                          animation_get_framerate (animation));
+  for (i = 0; i < priv->n_panels; i++)
+    {
+      gchar  *panel;
+      gchar  *layer_name;
+      gint32 *panels;
+      gint    n_panels;
+
+      panels = gimp_image_get_layers (priv->panels, &n_panels);
+      layer_name = gimp_item_get_name (panels[n_panels - (i + 1)]);
+
+      panel = g_markup_printf_escaped ("<panel title=\"%s\" duration=\"%d\" layer=\"%d\">",
+                                       layer_name, priv->durations[i],
+                                       priv->tattoos[i]);
+      g_free (layer_name);
+
+      tmp = text;
+      text = g_strconcat (text, panel, NULL);
+      g_free (tmp);
+      g_free (panel);
+
+      if (priv->comments[i])
+        {
+          gchar *comment;
+
+          comment = g_markup_printf_escaped ("<notes title=\"Notes\">%s</notes>",
+                                             priv->comments[i]);
+          tmp = text;
+          text = g_strconcat (text, comment, NULL);
+          g_free (tmp);
+          g_free (comment);
+        }
+      tmp = text;
+      text = g_strconcat (text, "</panel>", NULL);
+      g_free (tmp);
+    }
+  tmp = text;
+  text = g_strconcat (text, "</sequence></animation>", NULL);
+  g_free (tmp);
+
+  return text;
+}
+
+static gboolean
+animation_animatic_same (Animation *animation,
+                         gint       previous_pos,
+                         gint       next_pos)
+{
+  AnimationAnimaticPrivate *priv = GET_PRIVATE (animation);
+  gint                      count = 0;
+  gboolean                  identical = FALSE;
+  gint                      i ;
+
+  for (i = 0; i < priv->n_panels; i++)
+    {
+      count += priv->durations[i];
+      if (count >= previous_pos && count >= next_pos)
+        {
+          identical = TRUE;
+          break;
+        }
+      else if (count >= previous_pos || count >= next_pos)
+        {
+          identical = FALSE;
+          break;
+        }
+    }
+
+  return identical;
+}
+
+/**** Utils ****/
+
+static gint
+animation_animatic_get_layer (AnimationAnimatic *animation,
+                              gint               pos)
+{
+  AnimationAnimaticPrivate *priv = GET_PRIVATE (animation);
+  gint                      i = -1;
+
+  if (priv->panels)
+    {
+      gint32 *layers;
+      gint32  num_layers;
+      gint    count = 0;
+
+      layers = gimp_image_get_layers (priv->panels, &num_layers);
+
+      if (num_layers > 0 &&
+          pos >= 1       &&
+          pos <= animation_animatic_get_length (ANIMATION (animation)))
+        {
+          for (i = num_layers - 1; i >= 0; i--)
+            {
+              count += priv->durations[i];
+              if (count >= pos)
+                break;
+            }
+        }
+
+      g_free (layers);
+    }
+
+  return i;
+}
+
+/**** TAG UTILS ****/
+
+static gint
+parse_ms_tag (Animation   *animation,
+              const gchar *str)
+{
+  if (str != NULL)
+    {
+      gint length = strlen (str);
+      gint i;
+
+      for (i = 0; i < length; i++)
+        {
+          gint duration;
+          gint dummy;
+
+          if (is_ms_tag (&str[i], &duration, &dummy))
+            {
+              gdouble fps = animation_get_framerate (animation);
+
+              /* Get frame duration in frame numbers, not millisecond. */
+              duration = (gint) ((fps * (gdouble) duration) / 1000.0);
+
+              return duration;
+            }
+        }
+    }
+
+  /* Default to 6 frames per panel.
+   * Storyboard-type animations are rarely detailed. */
+  return 6;
+}
+
+static gboolean
+parse_combine_tag (const gchar *str)
+{
+  gboolean combine = FALSE;
+
+  if (str != NULL)
+    {
+      gint length = strlen (str);
+      gint i;
+
+      for (i = 0; i < length; i++)
+        {
+          if (strlen (str) != 9)
+            continue;
+
+          if (strncmp (str, "(combine)", 9) == 0)
+            {
+              combine = TRUE;
+              break;
+            }
+          else if (strncmp (str, "(replace)", 9) == 0)
+            {
+              combine = FALSE;
+              break;
+            }
+        }
+    }
+
+  return combine;
+}
+
+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;
+}
diff --git a/plug-ins/animation-play/core/animationanimatic.h 
b/plug-ins/animation-play/core/animationanimatic.h
new file mode 100644
index 0000000..f2e084c
--- /dev/null
+++ b/plug-ins/animation-play/core/animationanimatic.h
@@ -0,0 +1,66 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * animation.h
+ * Copyright (C) 2016 Jehan <jehan gimp org>
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __ANIMATION_ANIMATIC_H__
+#define __ANIMATION_ANIMATIC_H__
+
+#include "animation.h"
+
+#define ANIMATION_TYPE_ANIMATIC            (animation_animatic_get_type ())
+#define ANIMATION_ANIMATIC(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), ANIMATION_TYPE_ANIMATIC, 
AnimationAnimatic))
+#define ANIMATION_ANIMATIC_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), ANIMATION_TYPE_ANIMATIC, 
AnimationAnimaticClass))
+#define ANIMATION_IS_ANIMATIC(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ANIMATION_TYPE_ANIMATIC))
+#define ANIMATION_IS_ANIMATIC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ANIMATION_TYPE_ANIMATIC))
+#define ANIMATION_ANIMATIC_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), ANIMATION_TYPE_ANIMATIC, 
AnimationAnimaticClass))
+
+typedef struct _AnimationAnimatic      AnimationAnimatic;
+typedef struct _AnimationAnimaticClass AnimationAnimaticClass;
+
+struct _AnimationAnimatic
+{
+  Animation       parent_instance;
+};
+
+struct _AnimationAnimaticClass
+{
+  AnimationClass  parent_class;
+};
+
+GType            animation_animatic_get_type (void);
+
+void             animation_animatic_set_duration (AnimationAnimatic *animatic,
+                                                  gint               panel_num,
+                                                  gint               duration);
+gint             animation_animatic_get_duration (AnimationAnimatic *animatic,
+                                                  gint               panel_num);
+
+void             animation_animatic_set_comment  (AnimationAnimatic *animatic,
+                                                  gint               panel_num,
+                                                  const gchar       *comment);
+const gchar    * animation_animatic_get_comment  (AnimationAnimatic *animatic,
+                                                  gint               panel_num);
+
+void             animation_animatic_set_combine  (AnimationAnimatic *animatic,
+                                                  gint               panel_num,
+                                                  gboolean           combine);
+const gboolean   animation_animatic_get_combine  (AnimationAnimatic *animatic,
+                                                  gint               panel_num);
+
+#endif  /*  __ANIMATION_ANIMATIC_H__  */
diff --git a/plug-ins/animation-play/widgets/animation-dialog.c 
b/plug-ins/animation-play/widgets/animation-dialog.c
index ea1ba62..416ee73 100755
--- a/plug-ins/animation-play/widgets/animation-dialog.c
+++ b/plug-ins/animation-play/widgets/animation-dialog.c
@@ -31,8 +31,12 @@
 #include <libgimp/gimpui.h>
 
 #include "animation-utils.h"
+
 #include "core/animation.h"
+#include "core/animationanimatic.h"
+
 #include "animation-dialog.h"
+#include "animation-storyboard.h"
 
 #include "libgimp/stdplugins-intl.h"
 
@@ -40,11 +44,10 @@
 #define DITHERTYPE     GDK_RGB_DITHER_NORMAL
 
 /* Settings we cache assuming they may be the user's
- * favorite, like a framerate, or a type of frame disposal.
+ * favorite, like a framerate.
  * These will be used only for image without stored animation. */
 typedef struct
 {
-  DisposeType disposal;
   gdouble     framerate;
 }
 CachedSettings;
@@ -75,7 +78,6 @@ struct _AnimationDialogPrivate
   GtkWidget      *progress_bar;
   GtkWidget      *settings_bar;
 
-  GtkWidget      *disposalcombo;
   GtkWidget      *fpscombo;
   GtkWidget      *zoomcombo;
   GtkWidget      *proxycheckbox;
@@ -99,6 +101,9 @@ struct _AnimationDialogPrivate
   guint           shape_drawing_area_width;
   guint           shape_drawing_area_height;
 
+  /* The hpaned (left is preview, right is layer list. */
+  GtkWidget      *hpaned;
+
   /* The vpaned (bottom is timeline, above is preview). */
   GtkWidget      *vpaned;
 
@@ -148,8 +153,6 @@ static void        close_callback            (GtkAction        *action,
 static void        help_callback             (GtkAction        *action,
                                               AnimationDialog  *dialog);
 
-static void        disposalcombo_changed     (GtkWidget        *combo,
-                                              AnimationDialog  *dialog);
 static void        fpscombo_activated        (GtkEntry         *combo,
                                               AnimationDialog  *dialog);
 static void        fpscombo_changed          (GtkWidget        *combo,
@@ -206,6 +209,12 @@ static gboolean    popup_menu                (GtkWidget        *widget,
 static void        show_loading_progress     (Animation        *animation,
                                               gdouble           load_rate,
                                               AnimationDialog  *dialog);
+static void        animation_update_progress (Animation        *animation,
+                                              gint              first_frame,
+                                              gint              num_frames,
+                                              gint              playback_start,
+                                              gint              playback_stop,
+                                              AnimationDialog  *dialog);
 static void        block_ui                  (Animation        *animation,
                                               AnimationDialog  *dialog);
 static void        unblock_ui                (Animation        *animation,
@@ -219,6 +228,8 @@ static void        unblock_ui                (Animation        *animation,
 static void        playback_range_changed    (Animation        *animation,
                                               gint              playback_start,
                                               gint              playback_stop,
+                                              gint              start_pos,
+                                              gint              length,
                                               AnimationDialog  *dialog);
 static void        proxy_changed             (Animation        *animation,
                                               gdouble           fps,
@@ -324,7 +335,7 @@ animation_dialog_init (AnimationDialog *dialog)
   priv->shape_drawing_area_height = -1;
 }
 
-/************ Public Functions ****************/
+/**** Public Functions ****/
 
 GtkWidget *
 animation_dialog_new (gint32 image_id)
@@ -335,21 +346,12 @@ animation_dialog_new (gint32 image_id)
   CachedSettings  settings;
 
   /* Acceptable default settings. */
-  settings.disposal  = DISPOSE_COMBINE;
   settings.framerate = 24.0;
 
   /* If we saved any settings globally, use the one from the last run. */
   gimp_get_data (PLUG_IN_PROC, &settings);
 
   /* If this animation has specific settings already, override the global ones. */
-  parasite = gimp_image_get_parasite (image_id, PLUG_IN_PROC "/frame-disposal");
-  if (parasite)
-    {
-      const DisposeType *mode = gimp_parasite_data (parasite);
-
-      settings.disposal = *mode;
-      gimp_parasite_free (parasite);
-    }
   parasite = gimp_image_get_parasite (image_id,
                                       PLUG_IN_PROC "/framerate");
   if (parasite)
@@ -360,7 +362,7 @@ animation_dialog_new (gint32 image_id)
       gimp_parasite_free (parasite);
     }
 
-  animation = animation_new (image_id, settings.disposal);
+  animation = animation_new (image_id, FALSE);
 
   dialog = g_object_new (ANIMATION_TYPE_DIALOG,
                          "type",  GTK_WINDOW_TOPLEVEL,
@@ -375,14 +377,13 @@ animation_dialog_new (gint32 image_id)
   return dialog;
 }
 
-/************ Private Functions ****************/
+/**** Private Functions ****/
 
 static void
 animation_dialog_constructed (GObject *object)
 {
   AnimationDialog        *dialog = ANIMATION_DIALOG (object);
   AnimationDialogPrivate *priv   = GET_PRIVATE (dialog);
-  GtkWidget              *hpaned;
   GtkAdjustment          *adjust;
   GtkWidget              *main_vbox;
   GtkWidget              *upper_bar;
@@ -422,13 +423,13 @@ animation_dialog_constructed (GObject *object)
   gtk_container_add (GTK_CONTAINER (dialog), priv->vpaned);
   gtk_widget_show (priv->vpaned);
 
-  hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
-  gtk_paned_pack1 (GTK_PANED (priv->vpaned), hpaned, TRUE, TRUE);
-  gtk_widget_show (hpaned);
+  priv->hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
+  gtk_paned_pack1 (GTK_PANED (priv->vpaned), priv->hpaned, TRUE, TRUE);
+  gtk_widget_show (priv->hpaned);
 
   /* Playback vertical box. */
   main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
-  gtk_paned_pack1 (GTK_PANED (hpaned), main_vbox, TRUE, TRUE);
+  gtk_paned_pack1 (GTK_PANED (priv->hpaned), main_vbox, TRUE, TRUE);
   gtk_widget_show (main_vbox);
 
   /* Upper Bar */
@@ -444,6 +445,7 @@ animation_dialog_constructed (GObject *object)
   /*****************/
   /* Settings box. */
   /*****************/
+
   priv->settings_bar = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
   gtk_paned_add1 (GTK_PANED (hbox), priv->settings_bar);
   gtk_widget_show (priv->settings_bar);
@@ -519,27 +521,6 @@ animation_dialog_constructed (GObject *object)
   gtk_box_pack_end (GTK_BOX (priv->settings_bar), priv->fpscombo, FALSE, FALSE, 0);
   gtk_widget_show (priv->fpscombo);
 
-  /* Settings: frame mode. */
-  priv->disposalcombo = gtk_combo_box_text_new ();
-
-  text = g_strdup (_("Cumulative layers (combine)"));
-  gtk_combo_box_text_insert_text (GTK_COMBO_BOX_TEXT (priv->disposalcombo),
-                                  DISPOSE_COMBINE, text);
-  g_free (text);
-
-  text = g_strdup (_("One frame per layer (replace)"));
-  gtk_combo_box_text_insert_text (GTK_COMBO_BOX_TEXT (priv->disposalcombo),
-                                  DISPOSE_REPLACE, text);
-  g_free (text);
-
-  g_signal_connect (priv->disposalcombo, "changed",
-                    G_CALLBACK (disposalcombo_changed),
-                    dialog);
-
-  gtk_box_pack_end (GTK_BOX (priv->settings_bar),
-                    priv->disposalcombo, FALSE, FALSE, 0);
-  gtk_widget_show (priv->disposalcombo);
-
   /*************/
   /* View box. */
   /*************/
@@ -762,7 +743,6 @@ animation_dialog_constructed (GObject *object)
 
   preview_width = gimp_image_width (priv->image_id);
   preview_height = gimp_image_height (priv->image_id);
-  /*animation_get_size (priv->animation, &preview_width, &preview_height);*/
   gtk_window_set_default_size (GTK_WINDOW (dialog),
                                MAX (preview_width + 20,
                                     screen_width - 20),
@@ -1145,10 +1125,6 @@ animation_dialog_set_animation (AnimationDialog *dialog,
                                    G_CALLBACK (fpscombo_activated),
                                    dialog);
 
-  g_signal_handlers_block_by_func (priv->disposalcombo,
-                                   G_CALLBACK (disposalcombo_changed),
-                                   dialog);
-
   g_signal_handlers_block_by_func (gtk_bin_get_child (GTK_BIN (priv->zoomcombo)),
                                    G_CALLBACK (zoomcombo_activated),
                                    dialog);
@@ -1211,14 +1187,6 @@ animation_dialog_set_animation (AnimationDialog *dialog,
                                      G_CALLBACK (fpscombo_activated),
                                      dialog);
 
-  /* Settings: frame mode. */
-  gtk_combo_box_set_active (GTK_COMBO_BOX (priv->disposalcombo),
-                            animation_get_disposal (priv->animation));
-
-  g_signal_handlers_unblock_by_func (priv->disposalcombo,
-                                     G_CALLBACK (disposalcombo_changed),
-                                     dialog);
-
   /* View: zoom. */
   g_signal_handlers_unblock_by_func (gtk_bin_get_child (GTK_BIN (priv->zoomcombo)),
                                      G_CALLBACK (zoomcombo_activated),
@@ -1242,6 +1210,33 @@ animation_dialog_set_animation (AnimationDialog *dialog,
                                      G_CALLBACK (progress_button),
                                      dialog);
 
+  /* The layer list. */
+  if (ANIMATION_IS_ANIMATIC (animation))
+    {
+      GtkWidget *scrolled_win;
+      GtkWidget *layer_list;
+      GtkWidget *frame;
+
+      layer_list = gtk_paned_get_child2 (GTK_PANED (priv->hpaned));
+      if (layer_list)
+        gtk_widget_destroy (layer_list);
+
+      frame = gtk_frame_new (_("Storyboard"));
+      gtk_paned_pack2 (GTK_PANED (priv->hpaned), frame,
+                       TRUE, TRUE);
+      gtk_widget_show (frame);
+
+      scrolled_win = gtk_scrolled_window_new (NULL, NULL);
+      gtk_container_add (GTK_CONTAINER (frame), scrolled_win);
+      gtk_widget_show (scrolled_win);
+
+      layer_list = animation_storyboard_new (ANIMATION_ANIMATIC (animation));
+      gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win),
+                                             layer_list);
+
+      gtk_widget_show (layer_list);
+    }
+
   /* Animation. */
   g_signal_connect (priv->animation, "proxy",
                     G_CALLBACK (proxy_changed),
@@ -1281,7 +1276,6 @@ animation_dialog_save_settings (AnimationDialog *dialog)
   CachedSettings          cached_settings;
 
   /* First saving in cache for any image. */
-  cached_settings.disposal  = animation_get_disposal (priv->animation);
   cached_settings.framerate = animation_get_framerate (priv->animation);
 
   gimp_set_data (PLUG_IN_PROC, &cached_settings, sizeof (&cached_settings));
@@ -1291,25 +1285,6 @@ animation_dialog_save_settings (AnimationDialog *dialog)
    * current state, do not resave them.
    * This prevents setting the image in a dirty state while it stayed
    * the same. */
-  old_parasite = gimp_image_get_parasite (priv->image_id,
-                                          PLUG_IN_PROC "/frame-disposal");
-  if (! old_parasite ||
-      *(DisposeType *) gimp_parasite_data (old_parasite) != cached_settings.disposal)
-    {
-      GimpParasite *parasite;
-
-      gimp_image_undo_group_start (priv->image_id);
-      undo_step_started = TRUE;
-
-      parasite = gimp_parasite_new (PLUG_IN_PROC "/frame-disposal",
-                                    GIMP_PARASITE_PERSISTENT | GIMP_PARASITE_UNDOABLE,
-                                    sizeof (cached_settings.disposal),
-                                    &cached_settings.disposal);
-      gimp_image_attach_parasite (priv->image_id, parasite);
-      gimp_parasite_free (parasite);
-    }
-  gimp_parasite_free (old_parasite);
-
   old_parasite = gimp_image_get_parasite (priv->image_id, PLUG_IN_PROC "/framerate");
   if (! old_parasite ||
       *(gdouble *) gimp_parasite_data (old_parasite) != cached_settings.framerate)
@@ -1419,38 +1394,6 @@ help_callback (GtkAction           *action,
 }
 
 /*
- * Callback emitted when the user changes the disposal in UI.
- */
-static void
-disposalcombo_changed (GtkWidget       *combo,
-                       AnimationDialog *dialog)
-{
-  AnimationDialogPrivate *priv = GET_PRIVATE (dialog);
-  Animation              *animation;
-  DisposeType             disposal;
-
-  disposal = gtk_combo_box_get_active (GTK_COMBO_BOX (combo));
-
-  if (! priv->animation ||
-      animation_get_disposal (priv->animation) != disposal)
-    {
-      gdouble proxy;
-
-      if (priv->animation &&
-          animation_is_playing (priv->animation))
-        animation_stop (priv->animation);
-
-      /* Keep same proxy ratio as previously. */
-      proxy = animation_get_proxy (priv->animation);
-
-      animation = animation_new (priv->image_id, disposal);
-      animation_dialog_set_animation (dialog,
-                                      animation);
-      animation_load (animation, proxy);
-    }
-}
-
-/*
  * Callback emitted when the user hits the Enter key of the fps combo.
  */
 static void
@@ -1971,6 +1914,36 @@ show_loading_progress (Animation       *animation,
 }
 
 static void
+animation_update_progress (Animation      *animation,
+                           gint            first_frame,
+                           gint            num_frames,
+                           gint            playback_start,
+                           gint            playback_stop,
+                           AnimationDialog *dialog)
+{
+  AnimationDialogPrivate *priv = GET_PRIVATE (dialog);
+  gint frame_spin_size;
+  gint last_frame = num_frames + first_frame - 1;
+
+  frame_spin_size = (gint) (log10 (last_frame - (last_frame % 10))) + 1;
+  gtk_entry_set_width_chars (GTK_ENTRY (priv->startframe_spin), frame_spin_size);
+  gtk_entry_set_width_chars (GTK_ENTRY (priv->endframe_spin), frame_spin_size);
+
+  gtk_adjustment_configure (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (priv->startframe_spin)),
+                            playback_start,
+                            first_frame,
+                            last_frame,
+                            1.0, 5.0, 0.0);
+  gtk_adjustment_configure (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (priv->endframe_spin)),
+                            playback_stop,
+                            playback_start,
+                            last_frame,
+                            1.0, 5.0, 0.0);
+
+  update_ui_sensitivity (dialog);
+}
+
+static void
 block_ui (Animation       *animation,
           AnimationDialog *dialog)
 {
@@ -1998,27 +1971,12 @@ unblock_ui (Animation      *animation,
             gint            preview_height,
             AnimationDialog *dialog)
 {
-  AnimationDialogPrivate *priv = GET_PRIVATE (dialog);
-  gint frame_spin_size;
-  gint last_frame = num_frames + first_frame - 1;
-
-  frame_spin_size = (gint) (log10 (last_frame - (last_frame % 10))) + 1;
-  gtk_entry_set_width_chars (GTK_ENTRY (priv->startframe_spin), frame_spin_size);
-  gtk_entry_set_width_chars (GTK_ENTRY (priv->endframe_spin), frame_spin_size);
-
-  gtk_adjustment_configure (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (priv->startframe_spin)),
-                            playback_start,
-                            first_frame,
-                            last_frame,
-                            1.0, 5.0, 0.0);
-  gtk_adjustment_configure (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (priv->endframe_spin)),
-                            playback_stop,
-                            playback_start,
-                            last_frame,
-                            1.0, 5.0, 0.0);
-
-  update_ui_sensitivity (dialog);
-
+  animation_update_progress (animation,
+                             first_frame,
+                             num_frames,
+                             playback_start,
+                             playback_stop,
+                             dialog);
   animation_dialog_refresh (dialog);
 }
 
@@ -2026,12 +1984,21 @@ static void
 playback_range_changed (Animation       *animation,
                         gint             playback_start,
                         gint             playback_stop,
+                        gint             start_pos,
+                        gint             length,
                         AnimationDialog *dialog)
 {
   AnimationDialogPrivate *priv = GET_PRIVATE (dialog);
   GtkAdjustment *startframe_adjust;
   GtkAdjustment *stopframe_adjust;
 
+  animation_update_progress (animation,
+                             start_pos,
+                             length,
+                             playback_start,
+                             playback_stop,
+                             dialog);
+
   startframe_adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (priv->startframe_spin));
   stopframe_adjust  = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (priv->endframe_spin));
 
@@ -2049,6 +2016,8 @@ playback_range_changed (Animation       *animation,
   g_signal_handlers_unblock_by_func (stopframe_adjust,
                                      G_CALLBACK (endframe_changed),
                                      dialog);
+
+  show_playing_progress (dialog);
 }
 
 static void
@@ -2261,7 +2230,7 @@ da_size_callback (GtkWidget       *drawing_area,
                            allocation->height);
       repaint_da (priv->drawing_area, NULL, dialog);
     }
-  else 
+  else
     {
       /* Update the zoom information. */
       AnimationDialogPrivate *priv = GET_PRIVATE (dialog);
@@ -2590,7 +2559,9 @@ progress_button (GtkWidget       *widget,
       gtk_widget_get_allocation (widget, &allocation);
 
       goto_frame = animation_get_start_position (priv->animation) +
-                  (gint) (event->x / (allocation.width / animation_get_length (priv->animation)));
+        (gint) (event->x /
+                ((gdouble) allocation.width /
+                 (gdouble) animation_get_length (priv->animation)));
 
       animation_jump (priv->animation, goto_frame);
     }
@@ -2610,7 +2581,9 @@ progress_entered (GtkWidget        *widget,
   gtk_widget_get_allocation (widget, &allocation);
 
   goto_frame = animation_get_start_position (priv->animation) +
-               (gint) (event->x / (allocation.width / animation_get_length (priv->animation)));
+               (gint) (event->x /
+                       ((gdouble) allocation.width /
+                        (gdouble) animation_get_length (priv->animation)));
 
   show_goto_progress (dialog, goto_frame);
 
@@ -2629,7 +2602,9 @@ progress_motion (GtkWidget       *widget,
   gtk_widget_get_allocation (widget, &allocation);
 
   goto_frame = animation_get_start_position (priv->animation) +
-               (gint) (event->x / (allocation.width / animation_get_length (priv->animation)));
+               (gint) (event->x /
+                       ((gdouble) allocation.width /
+                        (gdouble) animation_get_length (priv->animation)));
 
   show_goto_progress (dialog, goto_frame);
 
diff --git a/plug-ins/animation-play/widgets/animation-storyboard.c 
b/plug-ins/animation-play/widgets/animation-storyboard.c
new file mode 100644
index 0000000..ee5c528
--- /dev/null
+++ b/plug-ins/animation-play/widgets/animation-storyboard.c
@@ -0,0 +1,334 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * animation-layer_view.c
+ * Copyright (C) 2016 Jehan <jehan gimp org>
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <libgimp/gimp.h>
+#include <libgimp/gimpui.h>
+
+#include "libgimp/stdplugins-intl.h"
+
+#include "core/animationanimatic.h"
+
+#include "animation-storyboard.h"
+
+/* Properties. */
+enum
+{
+  PROP_0,
+  PROP_ANIMATION
+};
+
+struct _AnimationStoryboardPrivate
+{
+  AnimationAnimatic *animation;
+};
+
+/* GObject handlers */
+static void animation_storyboard_constructed           (GObject             *object);
+static void animation_storyboard_set_property          (GObject             *object,
+                                                        guint                property_id,
+                                                        const GValue        *value,
+                                                        GParamSpec          *pspec);
+static void animation_storyboard_get_property          (GObject             *object,
+                                                        guint                property_id,
+                                                        GValue              *value,
+                                                        GParamSpec          *pspec);
+static void animation_storyboard_finalize              (GObject             *object);
+
+/* Callbacks on animation */
+static void animation_storyboard_load                  (Animation           *animation,
+                                                        G_GNUC_UNUSED gint   first_frame,
+                                                        G_GNUC_UNUSED gint   num_frames,
+                                                        G_GNUC_UNUSED gint   playback_start,
+                                                        G_GNUC_UNUSED gint   playback_stop,
+                                                        G_GNUC_UNUSED gint   preview_width,
+                                                        G_GNUC_UNUSED gint   preview_height,
+                                                        AnimationStoryboard *view);
+
+static void animation_storyboard_duration_spin_changed (GtkSpinButton       *spinbutton,
+                                                        AnimationAnimatic   *animation);
+
+G_DEFINE_TYPE (AnimationStoryboard, animation_storyboard, GTK_TYPE_TABLE)
+
+#define parent_class animation_storyboard_parent_class
+
+static void
+animation_storyboard_class_init (AnimationStoryboardClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->constructed  = animation_storyboard_constructed;
+  object_class->finalize     = animation_storyboard_finalize;
+  object_class->get_property = animation_storyboard_get_property;
+  object_class->set_property = animation_storyboard_set_property;
+
+  /**
+   * AnimationStoryboard:animation:
+   *
+   * The associated #AnimationAnimatic.
+   */
+  g_object_class_install_property (object_class, PROP_ANIMATION,
+                                   g_param_spec_object ("animation",
+                                                        NULL, NULL,
+                                                        ANIMATION_TYPE_ANIMATIC,
+                                                        G_PARAM_READWRITE |
+                                                        G_PARAM_CONSTRUCT_ONLY));
+
+  g_type_class_add_private (klass, sizeof (AnimationStoryboardPrivate));
+}
+
+static void
+animation_storyboard_init (AnimationStoryboard *view)
+{
+  view->priv = G_TYPE_INSTANCE_GET_PRIVATE (view,
+                                            ANIMATION_TYPE_STORYBOARD,
+                                            AnimationStoryboardPrivate);
+
+  gtk_table_set_homogeneous (GTK_TABLE (view), TRUE);
+}
+
+/**** Public Functions ****/
+
+/**
+ * animation_storyboard_new:
+ * @animation: the #AnimationAnimatic for this storyboard.
+ *
+ * Creates a new layer view tied to @animation, ready to be displayed.
+ */
+GtkWidget *
+animation_storyboard_new (AnimationAnimatic *animation)
+{
+  GtkWidget *layer_view;
+
+  layer_view = g_object_new (ANIMATION_TYPE_STORYBOARD,
+                             "animation", animation,
+                             NULL);
+  return layer_view;
+}
+
+/**** Private Functions ****/
+
+static void
+animation_storyboard_constructed (GObject *object)
+{
+  AnimationStoryboard *view = ANIMATION_STORYBOARD (object);
+
+  g_signal_connect (view->priv->animation, "loaded",
+                    (GCallback) animation_storyboard_load,
+                    view);
+}
+
+static void
+animation_storyboard_set_property (GObject      *object,
+                                        guint         property_id,
+                                        const GValue *value,
+                                        GParamSpec   *pspec)
+{
+  AnimationStoryboard *view = ANIMATION_STORYBOARD (object);
+
+  switch (property_id)
+    {
+    case PROP_ANIMATION:
+      view->priv->animation = g_value_dup_object (value);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
+animation_storyboard_get_property (GObject    *object,
+                                        guint       property_id,
+                                        GValue     *value,
+                                        GParamSpec *pspec)
+{
+  AnimationStoryboard *view = ANIMATION_STORYBOARD (object);
+
+  switch (property_id)
+    {
+    case PROP_ANIMATION:
+      g_value_set_object (value, view->priv->animation);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
+animation_storyboard_finalize (GObject *object)
+{
+  AnimationStoryboard *view = ANIMATION_STORYBOARD (object);
+
+  g_object_unref (view->priv->animation);
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+/* animation_storyboard_load:
+ * @view: the #AnimationStoryboard.
+ *
+ * Recursively fills @store with the #GimpLayers data of the #GimpImage
+ * tied to @view.
+ */
+static void
+animation_storyboard_load (Animation           *animation,
+                           gint                 first_frame,
+                           gint                 num_frames,
+                           gint                 playback_start,
+                           gint                 playback_stop,
+                           gint                 preview_width,
+                           gint                 preview_height,
+                           AnimationStoryboard *view)
+{
+  gint   *layers;
+  gint32  image_id;
+  gint    n_images;
+  gint    i;
+
+  image_id = animation_get_image_id (animation);
+
+  /* Cleaning previous loads. */
+  gtk_container_foreach (GTK_CONTAINER (view),
+                         (GtkCallback) gtk_widget_destroy,
+                         NULL);
+
+  /* Setting new values. */
+  layers = gimp_image_get_layers (image_id,
+                                  &n_images);
+
+  gtk_table_resize (GTK_TABLE (view),
+                    5 * n_images,
+                    10);
+  for (i = 0; i < n_images; i++)
+    {
+      GdkPixbuf *thumbnail;
+      GtkWidget *image;
+      GtkWidget *comment;
+      GtkWidget *duration;
+      GtkWidget *disposal;
+      gchar     *image_name;
+      gint       panel_num = n_images - i;
+
+      thumbnail = gimp_drawable_get_thumbnail (layers[i], 250, 250,
+                                               GIMP_PIXBUF_SMALL_CHECKS);
+      image = gtk_image_new_from_pixbuf (thumbnail);
+      g_object_unref (thumbnail);
+
+      /* Let's align top-right, in case the storyboard gets resized
+       * and the image grows (the thumbnail right now stays as fixed size). */
+      gtk_misc_set_alignment (GTK_MISC (image), 1.0, 0.0);
+
+      gtk_table_attach (GTK_TABLE (view),
+                        image, 0, 4,
+                        5 * n_images - 5 * i - 5,
+                        5 * n_images - 5 * i,
+                        GTK_EXPAND | GTK_FILL,
+                        GTK_EXPAND | GTK_FILL,
+                        1, 1);
+      gtk_widget_show (image);
+
+      comment = gtk_text_view_new ();
+      gtk_table_attach (GTK_TABLE (view),
+                        comment, 5, 10,
+                        5 * n_images - 5 * i - 5,
+                        5 * n_images - 5 * i,
+                        GTK_EXPAND | GTK_FILL,
+                        GTK_EXPAND | GTK_FILL,
+                        0, 1);
+      gtk_widget_show (comment);
+
+      image_name = gimp_item_get_name (layers[i]);
+      if (image_name)
+        {
+          GtkTextBuffer *buffer;
+          const gchar   *comment_contents;
+
+          /* Layer name is shown as a tooltip. */
+          gtk_widget_set_tooltip_text (image, image_name);
+
+          buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (comment));
+
+          comment_contents = animation_animatic_get_comment (view->priv->animation,
+                                                             panel_num);
+          if (comment_contents != NULL)
+            gtk_text_buffer_insert_at_cursor (buffer, comment_contents, -1);
+
+          g_free (image_name);
+        }
+
+      duration = gtk_spin_button_new_with_range (0.0, G_MAXINT, 1.0);
+      gtk_spin_button_set_digits (GTK_SPIN_BUTTON (duration), 0);
+      gtk_spin_button_set_increments (GTK_SPIN_BUTTON (duration), 1.0, 10.0);
+      gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (duration), TRUE);
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON (duration),
+                                 animation_animatic_get_duration (ANIMATION_ANIMATIC (animation),
+                                                                  panel_num));
+      gtk_entry_set_width_chars (GTK_ENTRY (duration), 2);
+      /* Allowing non-numeric text to type "ms" or "s". */
+      gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (duration), FALSE);
+
+      gtk_table_attach (GTK_TABLE (view),
+                        duration, 4, 5,
+                        5 * n_images - 5 * i - 5,
+                        5 * n_images - 5 * i - 4,
+                        0, /* Do not expand nor fill, nor shrink. */
+                        0, /* Do not expand nor fill, nor shrink. */
+                        0, 1);
+      g_object_set_data (G_OBJECT (duration), "layer-position",
+                         GINT_TO_POINTER (panel_num));
+      g_signal_connect (duration, "value-changed",
+                        (GCallback) animation_storyboard_duration_spin_changed,
+                        animation);
+      gtk_widget_show (duration);
+
+      disposal = gtk_toggle_button_new ();
+      image = gtk_image_new_from_icon_name (GIMP_STOCK_TRANSPARENCY,
+                                            GTK_ICON_SIZE_MENU);
+      gtk_container_add (GTK_CONTAINER (disposal), image);
+      gtk_widget_show (image);
+      gtk_table_attach (GTK_TABLE (view),
+                        disposal, 4, 5,
+                        5 * n_images - 5 * i - 3,
+                        5 * n_images - 5 * i - 2,
+                        GTK_EXPAND, GTK_EXPAND,
+                        0, 1);
+      gtk_widget_show (disposal);
+    }
+}
+
+static void
+animation_storyboard_duration_spin_changed (GtkSpinButton     *spinbutton,
+                                            AnimationAnimatic *animation)
+{
+  gpointer layer_pos;
+  gint     duration;
+
+  layer_pos = g_object_get_data (G_OBJECT (spinbutton), "layer-position");
+  duration = gtk_spin_button_get_value_as_int (spinbutton);
+
+  animation_animatic_set_duration (animation,
+                                   GPOINTER_TO_INT (layer_pos),
+                                   duration);
+}
diff --git a/plug-ins/animation-play/widgets/animation-storyboard.h 
b/plug-ins/animation-play/widgets/animation-storyboard.h
new file mode 100644
index 0000000..f92a23e
--- /dev/null
+++ b/plug-ins/animation-play/widgets/animation-storyboard.h
@@ -0,0 +1,52 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * animation-layer_view.h
+ * Copyright (C) 2016 Jehan <jehan gimp org>
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __ANIMATION_STORYBOARD_H__
+#define __ANIMATION_STORYBOARD_H__
+
+#define ANIMATION_TYPE_STORYBOARD            (animation_storyboard_get_type ())
+#define ANIMATION_STORYBOARD(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), ANIMATION_TYPE_STORYBOARD, 
AnimationStoryboard))
+#define ANIMATION_STORYBOARD_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), ANIMATION_TYPE_STORYBOARD, 
AnimationStoryboardClass))
+#define ANIMATION_IS_STORYBOARD(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ANIMATION_TYPE_STORYBOARD))
+#define ANIMATION_IS_STORYBOARD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ANIMATION_TYPE_STORYBOARD))
+#define ANIMATION_STORYBOARD_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), ANIMATION_TYPE_STORYBOARD, 
AnimationStoryboardClass))
+
+typedef struct _AnimationStoryboard        AnimationStoryboard;
+typedef struct _AnimationStoryboardClass   AnimationStoryboardClass;
+typedef struct _AnimationStoryboardPrivate AnimationStoryboardPrivate;
+
+struct _AnimationStoryboard
+{
+  GtkTable          parent_instance;
+
+  AnimationStoryboardPrivate *priv;
+};
+
+struct _AnimationStoryboardClass
+{
+  GtkTableClass     parent_class;
+};
+
+GType       animation_storyboard_get_type (void) G_GNUC_CONST;
+
+GtkWidget * animation_storyboard_new      (AnimationAnimatic *animation);
+
+#endif  /*  __ANIMATION_STORYBOARD_H__  */
+


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]