/* Copyright (C) 1998-2002 The gtkmm Development Team
 *
 * 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.1 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 <https://www.gnu.org/licenses/>.
 */

_DEFS(gdkmm,gdk)
_CONFIGINCLUDE(gdkmmconfig.h)
_IS_DEPRECATED // The entire file is deprecated.

#include <glibmm/object.h>
#include <gdkmm/pixbuf.h>
#include <gdk-pixbuf/gdk-pixbuf.h>

_PINCLUDE(glibmm/private/object_p.h)

namespace Gdk
{

/** An iterator which points to a certain position in a PixbufAnimation.
 *
 * @deprecated 4.20: Pixbuf animation is deprecated. There is no replacement.
 */
class GDKMM_API PixbufAnimationIter : public Glib::Object
{
  _CLASS_GOBJECT(PixbufAnimationIter, GdkPixbufAnimationIter, GDK_PIXBUF_ANIMATION_ITER, Glib::Object, GObject, , , GDKMM_API)
protected:

  //A constructor (if any) would go here, protected.

public:
  /** Gets the number of milliseconds the current pixbuf should be displayed,
   * or -1 if the current pixbuf should be displayed forever.
   *
   * Glib::SignalTimeout::connect() conveniently takes a timeout in milliseconds,
   * so you can use a timeout to schedule the next update.
   *
   * Note that some formats, like GIF, might clamp the timeout values in the
   * image file to avoid updates that are just too quick. The minimum timeout
   * for GIF images is currently 20 milliseconds.
   * 
   * @return Delay time in milliseconds (thousandths of a second).
   */
  _WRAP_METHOD(int get_delay_time() const, gdk_pixbuf_animation_iter_get_delay_time)

  _WRAP_METHOD(Glib::RefPtr<Gdk::Pixbuf> get_pixbuf(), gdk_pixbuf_animation_iter_get_pixbuf, refreturn)
  _WRAP_METHOD(Glib::RefPtr<const Gdk::Pixbuf> get_pixbuf() const, gdk_pixbuf_animation_iter_get_pixbuf, refreturn, constversion)

  _WRAP_METHOD(bool on_currently_loading_frame() const, gdk_pixbuf_animation_iter_on_currently_loading_frame)

  /** Possibly advances an animation to a new frame. Chooses the frame based
   * on the start time passed to Gdk::PixbufAnimation::get_iter().
   *
   * @a current_time would normally come from g_get_real_time(), and
   * must be greater than or equal to the time passed to
   * Gdk::PixbufAnimation::get_iter(), and must increase or remain
   * unchanged each time get_pixbuf() is called.
   * That is, you can't go backward in time; animations only play forward.
   *
   * As a shortcut, the default value of @a current_time is g_get_real_time().
   * So you only need to explicitly pass @a current_time if you're doing
   * something odd like playing the animation at double speed.
   *
   * If this function returns <tt>false</tt>, there's no need to update the animation
   * display, assuming the display had been rendered prior to advancing;
   * if <tt>true</tt>, you need to call get_pixbuf() and update the
   * display with the new pixbuf.
   *
   * @param current_time Current time.
   * @return <tt>true</tt> if the image may need updating.
   */
  bool advance(gint64 current_time = g_get_real_time());
  _IGNORE(gdk_pixbuf_animation_iter_advance)
};

} // namespace Gdk
