/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- */

/* GdkPixbuf library - Simple transformations of animations

 *

 * Copyright (C) Red Hat, Inc

 *

 * Authors: Matthias Clasen <mclasen@redhat.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/>.

 *

 */

#include <glib.h>

#include "gdk-pixbuf.h"

#include "gdk-pixbuf-io.h"

#include "gdk-pixbuf-scaled-anim.h"

struct _GdkPixbufScaledAnimClass

{

        GdkPixbufAnimationClass parent_class;

};

struct _GdkPixbufScaledAnim

{

 	GdkPixbufAnimation parent_instance;

	GdkPixbufAnimation *anim;

	gdouble xscale;

	gdouble yscale;

	gdouble tscale;

	GdkPixbuf *current;

};

struct _GdkPixbufScaledAnimIterClass

{

        GdkPixbufAnimationClass parent_class;

};

struct _GdkPixbufScaledAnimIter

{

 	GdkPixbufAnimationIter parent_instance;

	GdkPixbufScaledAnim *scaled;

        GdkPixbufAnimationIter *iter;

};

typedef struct _GdkPixbufScaledAnimIter GdkPixbufScaledAnimIter;

typedef struct _GdkPixbufScaledAnimIterClass GdkPixbufScaledAnimIterClass;

GdkPixbufScaledAnim *

_gdk_pixbuf_scaled_anim_new (GdkPixbufAnimation *anim,

                             gdouble             xscale,

                             gdouble             yscale,

                             gdouble             tscale)

{

	GdkPixbufScaledAnim *scaled;

	scaled = g_object_new (GDK_TYPE_PIXBUF_SCALED_ANIM, NULL);

	scaled->anim = g_object_ref (anim);

	scaled->xscale = xscale;

	scaled->yscale = yscale;

	scaled->tscale = tscale;

	return scaled;

}

G_DEFINE_TYPE (GdkPixbufScaledAnim, gdk_pixbuf_scaled_anim, GDK_TYPE_PIXBUF_ANIMATION);

static void

gdk_pixbuf_scaled_anim_init (GdkPixbufScaledAnim *scaled)

{

	scaled->xscale = 1.0;

	scaled->yscale = 1.0;

	scaled->tscale = 1.0;

}

static void

gdk_pixbuf_scaled_anim_finalize (GObject *object)

{

	GdkPixbufScaledAnim *scaled = (GdkPixbufScaledAnim *)object;

	if (scaled->anim) {

		g_object_unref (scaled->anim);

		scaled->anim = NULL;

	}

	if (scaled->current) {

		g_object_unref (scaled->current);

		scaled->current = NULL;

	}

	G_OBJECT_CLASS (gdk_pixbuf_scaled_anim_parent_class)->finalize (object);

}

static gboolean

is_static_image (GdkPixbufAnimation *anim)

{

	GdkPixbufScaledAnim *scaled = (GdkPixbufScaledAnim *)anim;

	return gdk_pixbuf_animation_is_static_image (scaled->anim);

}	

static GdkPixbuf *

get_scaled_pixbuf (GdkPixbufScaledAnim *scaled, 

                   GdkPixbuf           *pixbuf)

{

	GQuark  quark;

	gchar **options;

	if (scaled->current) 

		g_object_unref (scaled->current);

	/* Preserve the options associated with the original pixbuf 

	   (if present), mostly so that client programs can use the

	   "orientation" option (if present) to rotate the image 

	   appropriately. gdk_pixbuf_scale_simple (and most other

           gdk transform operations) does not preserve the attached

           options when returning a new pixbuf. */

	quark = g_quark_from_static_string ("gdk_pixbuf_options");

	options = g_object_get_qdata (G_OBJECT (pixbuf), quark);

	/* Get a new scaled pixbuf */

	scaled->current  = gdk_pixbuf_scale_simple (pixbuf, 

                        MAX((int) ((gdouble) gdk_pixbuf_get_width (pixbuf) * scaled->xscale + .5), 1),

                        MAX((int) ((gdouble) gdk_pixbuf_get_height (pixbuf) * scaled->yscale + .5), 1),

			GDK_INTERP_BILINEAR);

	/* Copy the original pixbuf options to the scaled pixbuf */

        if (options && scaled->current)

	          g_object_set_qdata_full (G_OBJECT (scaled->current), quark, 

                                           g_strdupv (options), (GDestroyNotify) g_strfreev);

	return scaled->current;

}

static GdkPixbuf *

get_static_image (GdkPixbufAnimation *anim)

{

	GdkPixbufScaledAnim *scaled = (GdkPixbufScaledAnim *)anim;

	GdkPixbuf *pixbuf;

	pixbuf = gdk_pixbuf_animation_get_static_image (scaled->anim);

	return get_scaled_pixbuf (scaled, pixbuf);

}

static void

get_size (GdkPixbufAnimation *anim,

	  int                *width,

	  int 		     *height)

{

	GdkPixbufScaledAnim *scaled = (GdkPixbufScaledAnim *)anim;

        GDK_PIXBUF_ANIMATION_GET_CLASS (scaled->anim)->get_size (scaled->anim, width, height);

	if (width) 

		*width = (int)(*width * scaled->xscale + .5);

	if (height)

		*height = (int)(*height * scaled->yscale + .5);

}

static GdkPixbufAnimationIter *

get_iter (GdkPixbufAnimation *anim,

          const GTimeVal     *start_time)

{

	GdkPixbufScaledAnim *scaled = (GdkPixbufScaledAnim *)anim;

	GdkPixbufScaledAnimIter *iter;

	iter = g_object_new (GDK_TYPE_PIXBUF_SCALED_ANIM_ITER, NULL);

	iter->scaled = g_object_ref (scaled);

	iter->iter = gdk_pixbuf_animation_get_iter (scaled->anim, start_time);

	return (GdkPixbufAnimationIter*)iter;

}

static void

gdk_pixbuf_scaled_anim_class_init (GdkPixbufScaledAnimClass *klass)

{

        GObjectClass *object_class;

        GdkPixbufAnimationClass *anim_class;

        object_class = G_OBJECT_CLASS (klass);

        anim_class = GDK_PIXBUF_ANIMATION_CLASS (klass);

        object_class->finalize = gdk_pixbuf_scaled_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;

}

G_DEFINE_TYPE (GdkPixbufScaledAnimIter, gdk_pixbuf_scaled_anim_iter, GDK_TYPE_PIXBUF_ANIMATION_ITER);

static void

gdk_pixbuf_scaled_anim_iter_init (GdkPixbufScaledAnimIter *iter)

{

}

static int

get_delay_time (GdkPixbufAnimationIter *iter)

{

	GdkPixbufScaledAnimIter *scaled = (GdkPixbufScaledAnimIter *)iter;

	int delay;

	delay = gdk_pixbuf_animation_iter_get_delay_time (scaled->iter);

	delay = (int)(delay * scaled->scaled->tscale);

	return delay;

}

static GdkPixbuf *

get_pixbuf (GdkPixbufAnimationIter *iter)

{

	GdkPixbufScaledAnimIter *scaled = (GdkPixbufScaledAnimIter *)iter;

	GdkPixbuf *pixbuf;

	pixbuf = gdk_pixbuf_animation_iter_get_pixbuf (scaled->iter);

	return get_scaled_pixbuf (scaled->scaled, pixbuf);

}

static gboolean 

on_currently_loading_frame (GdkPixbufAnimationIter *iter)

{

	GdkPixbufScaledAnimIter *scaled = (GdkPixbufScaledAnimIter *)iter;

	return gdk_pixbuf_animation_iter_on_currently_loading_frame (scaled->iter);

}

static gboolean

advance (GdkPixbufAnimationIter *iter,

	 const GTimeVal         *current_time)

{

	GdkPixbufScaledAnimIter *scaled = (GdkPixbufScaledAnimIter *)iter;

	return gdk_pixbuf_animation_iter_advance (scaled->iter, current_time);

}

static void

gdk_pixbuf_scaled_anim_iter_finalize (GObject *object)

{

        GdkPixbufScaledAnimIter *iter = (GdkPixbufScaledAnimIter *)object;

	g_object_unref (iter->iter);

   	g_object_unref (iter->scaled);

	G_OBJECT_CLASS (gdk_pixbuf_scaled_anim_iter_parent_class)->finalize (object);

}

static void

gdk_pixbuf_scaled_anim_iter_class_init (GdkPixbufScaledAnimIterClass *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_scaled_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;

}