/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- */
/* GdkPixbuf library - Simple frame-based animations
 *
 * Copyright (C) Dom Lachowicz
 *
 * Authors: Dom Lachowicz <cinamod@hotmail.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
 *
 * Based on code originally by:
 *          Jonathan Blandford <jrb@redhat.com>
 *          Havoc Pennington <hp@redhat.com>
 */

#include "config.h"
#define GLIB_DISABLE_DEPRECATION_WARNINGS
#include <glib.h>

#define GDK_PIXBUF_C_COMPILATION
#include "gdk-pixbuf.h"
#include "gdk-pixbuf-private.h"
#include "gdk-pixbuf-simple-anim.h"

struct _GdkPixbufSimpleAnimClass
{
        GdkPixbufAnimationClass parent_class;
};

/* Private part of the GdkPixbufSimpleAnim structure */
struct _GdkPixbufSimpleAnim
{
        GdkPixbufAnimation parent_instance;
        
        gint n_frames;
        
        gfloat rate;
        gint total_time;
        
        GList *frames;
        
        gint width;
        gint height;
        
        gboolean loop;
};


typedef struct _GdkPixbufSimpleAnimIter GdkPixbufSimpleAnimIter;
typedef struct _GdkPixbufSimpleAnimIterClass GdkPixbufSimpleAnimIterClass;

#define GDK_TYPE_PIXBUF_SIMPLE_ANIM_ITER              (gdk_pixbuf_simple_anim_iter_get_type ())
#define GDK_PIXBUF_SIMPLE_ANIM_ITER(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_PIXBUF_SIMPLE_ANIM_ITER, GdkPixbufSimpleAnimIter))
#define GDK_IS_PIXBUF_SIMPLE_ANIM_ITER(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_PIXBUF_SIMPLE_ANIM_ITER))

#define GDK_PIXBUF_SIMPLE_ANIM_ITER_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_PIXBUF_SIMPLE_ANIM_ITER, GdkPixbufSimpleAnimIterClass))
#define GDK_IS_PIXBUF_SIMPLE_ANIM_ITER_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_PIXBUF_SIMPLE_ANIM_ITER))
#define GDK_PIXBUF_SIMPLE_ANIM_ITER_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_PIXBUF_SIMPLE_ANIM_ITER, GdkPixbufSimpleAnimIterClass))

GType gdk_pixbuf_simple_anim_iter_get_type (void) G_GNUC_CONST;


struct _GdkPixbufSimpleAnimIterClass
{
        GdkPixbufAnimationIterClass parent_class;
};

struct _GdkPixbufSimpleAnimIter
{
        GdkPixbufAnimationIter parent_instance;
        
        GdkPixbufSimpleAnim *simple_anim;
        
        GTimeVal start_time;
        GTimeVal current_time;
        
        gint position;
        
        GList *current_frame;
};

typedef struct _GdkPixbufFrame GdkPixbufFrame;
struct _GdkPixbufFrame
{
        GdkPixbuf *pixbuf;
        gint delay_time;
        gint elapsed;
};

static void gdk_pixbuf_simple_anim_finalize (GObject *object);

static gboolean   is_static_image  (GdkPixbufAnimation *animation);
static GdkPixbuf *get_static_image (GdkPixbufAnimation *animation);

static void       get_size         (GdkPixbufAnimation *anim,
                                    gint               *width, 
                                    gint               *height);
static GdkPixbufAnimationIter *get_iter (GdkPixbufAnimation *anim,
                                         const GTimeVal     *start_time);


static void gdk_pixbuf_simple_anim_set_property (GObject        *object,
                                                 guint           prop_id,
                                                 const GValue   *value,
                                                 GParamSpec     *pspec);
static void gdk_pixbuf_simple_anim_get_property (GObject        *object,
                                                 guint           prop_id,
                                                 GValue         *value,
                                                 GParamSpec     *pspec);

enum
{
        PROP_0,
        PROP_LOOP
};

G_DEFINE_TYPE (GdkPixbufSimpleAnim, gdk_pixbuf_simple_anim, GDK_TYPE_PIXBUF_ANIMATION)

static void
gdk_pixbuf_simple_anim_init (GdkPixbufSimpleAnim *anim)
{
}

static void
gdk_pixbuf_simple_anim_class_init (GdkPixbufSimpleAnimClass *klass)
{
        GObjectClass *object_class;
        GdkPixbufAnimationClass *anim_class;

        object_class = G_OBJECT_CLASS (klass);
        anim_class = GDK_PIXBUF_ANIMATION_CLASS (klass);

        object_class->set_property = gdk_pixbuf_simple_anim_set_property;
        object_class->get_property = gdk_pixbuf_simple_anim_get_property;
        object_class->finalize = gdk_pixbuf_simple_anim_finalize;
        
        anim_class->is_static_image = is_static_image;
        anim_class->get_static_image = get_static_image;
        anim_class->get_size = get_size;
        anim_class->get_iter = get_iter;

        /**
         * GdkPixbufSimpleAnim:loop:
         *
         * Whether the animation should loop when it reaches the end.
         *
         * Since: 2.18
         */
        g_object_class_install_property (object_class,
                                         PROP_LOOP,
                                         g_param_spec_boolean ("loop",
                                                               _("Loop"),
                                                               _("Whether the animation should loop when it reaches the end"),
                                                               FALSE,
                                                               G_PARAM_READWRITE));
}

static void
gdk_pixbuf_simple_anim_finalize (GObject *object)
{
        GdkPixbufSimpleAnim *anim;
        GList *l;
        GdkPixbufFrame *frame;
        
        anim = GDK_PIXBUF_SIMPLE_ANIM (object);        
        
        for (l = anim->frames; l; l = l->next) {
                frame = l->data;
                g_object_unref (frame->pixbuf);
                g_free (frame);
        }
        
        g_list_free (anim->frames);
        
        G_OBJECT_CLASS (gdk_pixbuf_simple_anim_parent_class)->finalize (object);
}

static gboolean
is_static_image (GdkPixbufAnimation *animation)
{
        GdkPixbufSimpleAnim *anim;
        
        anim = GDK_PIXBUF_SIMPLE_ANIM (animation);

        return (anim->frames != NULL && anim->frames->next == NULL);
}

static GdkPixbuf *
get_static_image (GdkPixbufAnimation *animation)
{
        GdkPixbufSimpleAnim *anim;
        
        anim = GDK_PIXBUF_SIMPLE_ANIM (animation);
        
        if (anim->frames == NULL)
                return NULL;
        else
                return ((GdkPixbufFrame *)anim->frames->data)->pixbuf;
}

static void
get_size (GdkPixbufAnimation *animation,
          gint               *width, 
          gint               *height)
{
        GdkPixbufSimpleAnim *anim;

        anim = GDK_PIXBUF_SIMPLE_ANIM (animation);
        
        if (width)
                *width = anim->width;
        
        if (height)
                *height = anim->height;
}

static void
iter_clear (GdkPixbufSimpleAnimIter *iter)
{
        iter->current_frame = NULL;
}

static void
iter_restart (GdkPixbufSimpleAnimIter *iter)
{
        iter_clear (iter);
        
        iter->current_frame = iter->simple_anim->frames;
}

static GdkPixbufAnimationIter *
get_iter (GdkPixbufAnimation *anim,
          const GTimeVal    *start_time)
{
        GdkPixbufSimpleAnimIter *iter;
        
        iter = g_object_new (GDK_TYPE_PIXBUF_SIMPLE_ANIM_ITER, NULL);

        iter->simple_anim = GDK_PIXBUF_SIMPLE_ANIM (anim);

        g_object_ref (iter->simple_anim);
        
        iter_restart (iter);
        
        iter->start_time = *start_time;
        iter->current_time = *start_time;
        
        return GDK_PIXBUF_ANIMATION_ITER (iter);
}

static void gdk_pixbuf_simple_anim_iter_finalize (GObject *object);

static gint       get_delay_time             (GdkPixbufAnimationIter *iter);
static GdkPixbuf *get_pixbuf                 (GdkPixbufAnimationIter *iter);
static gboolean   on_currently_loading_frame (GdkPixbufAnimationIter *iter);
static gboolean   advance                    (GdkPixbufAnimationIter *iter,
                                              const GTimeVal         *current_time);

G_DEFINE_TYPE (GdkPixbufSimpleAnimIter, gdk_pixbuf_simple_anim_iter, GDK_TYPE_PIXBUF_ANIMATION_ITER)

static void
gdk_pixbuf_simple_anim_iter_init (GdkPixbufSimpleAnimIter *iter)
{
}

static void
gdk_pixbuf_simple_anim_iter_class_init (GdkPixbufSimpleAnimIterClass *klass)
{
        GObjectClass *object_class;
        GdkPixbufAnimationIterClass *anim_iter_class;

        object_class = G_OBJECT_CLASS (klass);
        anim_iter_class = GDK_PIXBUF_ANIMATION_ITER_CLASS (klass);
        
        object_class->finalize = gdk_pixbuf_simple_anim_iter_finalize;
        
        anim_iter_class->get_delay_time = get_delay_time;
        anim_iter_class->get_pixbuf = get_pixbuf;
        anim_iter_class->on_currently_loading_frame = on_currently_loading_frame;
        anim_iter_class->advance = advance;
}

static void
gdk_pixbuf_simple_anim_iter_finalize (GObject *object)
{
        GdkPixbufSimpleAnimIter *iter;
        
        iter = GDK_PIXBUF_SIMPLE_ANIM_ITER (object);
        iter_clear (iter);
        
        g_object_unref (iter->simple_anim);
        
        G_OBJECT_CLASS (gdk_pixbuf_simple_anim_iter_parent_class)->finalize (object);
}

static gboolean
advance (GdkPixbufAnimationIter *anim_iter,
         const GTimeVal         *current_time)
{
        GdkPixbufSimpleAnimIter *iter;
        gint elapsed;
        gint loop_count;
        GList *tmp;
        GList *old;
        
        iter = GDK_PIXBUF_SIMPLE_ANIM_ITER (anim_iter);
        
        iter->current_time = *current_time;
        
        /* We use milliseconds for all times */
        elapsed = (((iter->current_time.tv_sec - iter->start_time.tv_sec) * G_USEC_PER_SEC +
                    iter->current_time.tv_usec - iter->start_time.tv_usec)) / 1000;
        
        if (elapsed < 0) {
                /* Try to compensate; probably the system clock
                 * was set backwards
                 */
                iter->start_time = iter->current_time;
                elapsed = 0;
        }
        
        g_assert (iter->simple_anim->total_time > 0);
        
        /* See how many times we've already played the full animation,
         * and subtract time for that.
         */
        loop_count = elapsed / iter->simple_anim->total_time;
        elapsed = elapsed % iter->simple_anim->total_time;
        
        iter->position = elapsed;
        
        /* Now move to the proper frame */
        if (loop_count < 1 || iter->simple_anim->loop)
                tmp = iter->simple_anim->frames;
        else
                tmp = NULL;
        
        while (tmp != NULL) {
                GdkPixbufFrame *frame = tmp->data;
                
                if (iter->position >= frame->elapsed &&
                    iter->position < (frame->elapsed + frame->delay_time))
                        break;
                
                tmp = tmp->next;
        }
        
        old = iter->current_frame;
        
        iter->current_frame = tmp;
        
        return iter->current_frame != old;
}

static gint
get_delay_time (GdkPixbufAnimationIter *anim_iter)
{
        GdkPixbufFrame *frame;
        GdkPixbufSimpleAnimIter *iter;

        iter = GDK_PIXBUF_SIMPLE_ANIM_ITER (anim_iter);
        
        if (iter->current_frame) {
                frame = iter->current_frame->data;
                return frame->delay_time - (iter->position - frame->elapsed);
        }
        else {
                return -1;		/* show last frame forever */
        }
}

static GdkPixbuf *
get_pixbuf (GdkPixbufAnimationIter *anim_iter)
{
        GdkPixbufSimpleAnimIter *iter;
        GdkPixbufFrame *frame;
        
        iter = GDK_PIXBUF_SIMPLE_ANIM_ITER (anim_iter);
        
        if (iter->current_frame)
                frame = iter->current_frame->data;
        else if (g_list_length (iter->simple_anim->frames) > 0)
                frame = g_list_last (iter->simple_anim->frames)->data;
        else
                frame = NULL;

        if (frame == NULL)
                return NULL;
        
        return frame->pixbuf;
}

static gboolean
on_currently_loading_frame (GdkPixbufAnimationIter *anim_iter)
{
  GdkPixbufSimpleAnimIter *iter;

  iter = GDK_PIXBUF_SIMPLE_ANIM_ITER (anim_iter);

  return iter->current_frame == NULL || iter->current_frame->next == NULL;
}

/**
 * gdk_pixbuf_simple_anim_new:
 * @width: the width of the animation
 * @height: the height of the animation
 * @rate: the speed of the animation, in frames per second
 *
 * Creates a new, empty animation.
 *
 * Returns: a newly allocated #GdkPixbufSimpleAnim 
 *
 * Since: 2.8
 */
GdkPixbufSimpleAnim *
gdk_pixbuf_simple_anim_new (gint   width, 
                            gint   height, 
                            gfloat rate)
{
  GdkPixbufSimpleAnim *anim;

  anim = g_object_new (GDK_TYPE_PIXBUF_SIMPLE_ANIM, NULL);
  anim->width = width;
  anim->height = height;
  anim->rate = rate;

  return anim;
}

/**
 * gdk_pixbuf_simple_anim_add_frame:
 * @animation: a #GdkPixbufSimpleAnim
 * @pixbuf: the pixbuf to add 
 *
 * Adds a new frame to @animation. The @pixbuf must
 * have the dimensions specified when the animation 
 * was constructed.
 *
 * Since: 2.8
 */
void
gdk_pixbuf_simple_anim_add_frame (GdkPixbufSimpleAnim *animation,
                                  GdkPixbuf           *pixbuf)
{
  GdkPixbufFrame *frame;
  int nframe = 0;
  
  g_return_if_fail (GDK_IS_PIXBUF_SIMPLE_ANIM (animation));
  g_return_if_fail (GDK_IS_PIXBUF (pixbuf));
  
  nframe = g_list_length (animation->frames);
  
  frame = g_new0 (GdkPixbufFrame, 1);
  frame->delay_time = (gint) (1000 / animation->rate);
  frame->elapsed = (gint) (frame->delay_time * nframe);
  animation->total_time += frame->delay_time;
  frame->pixbuf = g_object_ref (pixbuf);

  animation->frames = g_list_append (animation->frames, frame);
}

static void
gdk_pixbuf_simple_anim_get_property (GObject         *object,
                                     guint            prop_id,
                                     GValue          *value,
                                     GParamSpec      *pspec)
{
        GdkPixbufSimpleAnim *animation = GDK_PIXBUF_SIMPLE_ANIM (object);

        switch (prop_id) {
        case PROP_LOOP:
                g_value_set_boolean (value,
                                     gdk_pixbuf_simple_anim_get_loop (animation));
                break;
        default:
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
                break;
        }
}

static void
gdk_pixbuf_simple_anim_set_property (GObject         *object,
                                     guint            prop_id,
                                     const GValue    *value,
                                     GParamSpec      *pspec)
{
        GdkPixbufSimpleAnim *animation = GDK_PIXBUF_SIMPLE_ANIM (object);

        switch (prop_id) {
        case PROP_LOOP:
                gdk_pixbuf_simple_anim_set_loop (animation,
                                                 g_value_get_boolean (value));
                break;
        default:
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
                break;
        }
}

/**
 * gdk_pixbuf_simple_anim_set_loop:
 * @animation: a #GdkPixbufSimpleAnim
 * @loop: whether to loop the animation
 *
 * Sets whether @animation should loop indefinitely when it reaches the end.
 *
 * Since: 2.18
 **/
void
gdk_pixbuf_simple_anim_set_loop (GdkPixbufSimpleAnim *animation,
                                 gboolean             loop)
{
        g_return_if_fail (GDK_IS_PIXBUF_SIMPLE_ANIM (animation));

        if (loop != animation->loop) {
                animation->loop = loop;
                g_object_notify (G_OBJECT (animation), "loop");
        }
}

/**
 * gdk_pixbuf_simple_anim_get_loop:
 * @animation: a #GdkPixbufSimpleAnim
 *
 * Gets whether @animation should loop indefinitely when it reaches the end.
 *
 * Returns: %TRUE if the animation loops forever, %FALSE otherwise
 *
 * Since: 2.18
 **/
gboolean
gdk_pixbuf_simple_anim_get_loop (GdkPixbufSimpleAnim *animation)
{
        g_return_val_if_fail (GDK_IS_PIXBUF_SIMPLE_ANIM (animation), FALSE);

        return animation->loop;
}
