// -*- c++ -*-
// Generated by gmmproc 2.43.1 -- DO NOT MODIFY!
#ifndef _GDKMM_PIXBUF_H
#define _GDKMM_PIXBUF_H

#include <gdkmmconfig.h>


#include <glibmm/ustring.h>
#include <sigc++/sigc++.h>

/* 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, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

// This is for including the config header before any code (such as
// the #ifndef GDKMM_DISABLE_DEPRECATED in deprecated classes) is generated:


#include <vector>

//#include <gdkmm/window.h>
#include <gdkmm/pixbufformat.h>
#include <gdkmm/types.h>
#include <giomm/inputstream.h>
#include <giomm/icon.h>
#include <cairomm/surface.h>
#include <glibmm/error.h>


#ifndef DOXYGEN_SHOULD_SKIP_THIS
typedef struct _GdkPixbuf GdkPixbuf;
typedef struct _GdkPixbufClass GdkPixbufClass;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */


namespace Gdk
{ class Pixbuf_Class; } // namespace Gdk
namespace Gdk
{

class Window;


/** @addtogroup gdkmmEnums gdkmm Enums and Flags */

/** 
 *  @var Colorspace COLORSPACE_RGB
 *  Indicates a red/green/blue additive color space.
 * 
 *  @enum Colorspace
 * 
 * This enumeration defines the color spaces that are supported by
 * the gdk-pixbuf library.  Currently only RGB is supported.
 * @ingroup gdkmmEnums
 */
enum Colorspace
{
  COLORSPACE_RGB
};

} // namespace Gdk


#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{

template <>
class Value<Gdk::Colorspace> : public Glib::Value_Enum<Gdk::Colorspace>
{
public:
  static GType value_type() G_GNUC_CONST;
};

} // namespace Glib
#endif /* DOXYGEN_SHOULD_SKIP_THIS */


namespace Gdk
{

/** 
 *  @var InterpType INTERP_NEAREST
 *  Nearest neighbor sampling; this is the fastest and lowest quality mode. Quality is normally unacceptable when scaling  down, but may be OK when scaling up.
 * 
 *  @var InterpType INTERP_TILES
 *  This is an accurate simulation of the PostScript image operator without any interpolation enabled.  Each pixel is rendered as a tiny parallelogram of solid color, the edges of which are implemented with antialiasing.  It resembles nearest neighbor for enlargement, and bilinear for reduction.
 * 
 *  @var InterpType INTERP_BILINEAR
 *  Best quality/speed balance; use this mode by default. Bilinear interpolation.  For enlargement, it is equivalent to point-sampling the ideal bilinear-interpolated image. For reduction, it is equivalent to laying down small tiles and integrating over the coverage area.
 * 
 *  @var InterpType INTERP_HYPER
 *  This is the slowest and highest quality reconstruction function. It is derived from the hyperbolic filters in Wolberg's "Digital Image Warping", and is formally defined as the hyperbolic-filter sampling the ideal hyperbolic-filter interpolated image (the filter is designed to be idempotent for 1:1 pixel mapping).
 * 
 *  @enum InterpType
 * 
 * This enumeration describes the different interpolation modes that
 * can be used with the scaling functions. @a GDK_INTERP_NEAREST is 
 * the fastest scaling method, but has horrible quality when 
 * scaling down. @a GDK_INTERP_BILINEAR is the best choice if you 
 * aren't sure what to choose, it has a good speed/quality balance.
 * 
 * <note>
 * Cubic filtering is missing from the list; hyperbolic
 * interpolation is just as fast and results in higher quality.
 * </note>
 * @ingroup gdkmmEnums
 */
enum InterpType
{
  INTERP_NEAREST,
  INTERP_TILES,
  INTERP_BILINEAR,
  INTERP_HYPER
};

} // namespace Gdk


#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{

template <>
class Value<Gdk::InterpType> : public Glib::Value_Enum<Gdk::InterpType>
{
public:
  static GType value_type() G_GNUC_CONST;
};

} // namespace Glib
#endif /* DOXYGEN_SHOULD_SKIP_THIS */


namespace Gdk
{

/** 
 *  @var PixbufAlphaMode PIXBUF_ALPHA_BILEVEL
 *  A bilevel clipping mask (black and white) will be created and used to draw the image.  Pixels below 0.5 opacity will be considered fully transparent, and all others will be considered fully opaque.
 * 
 *  @var PixbufAlphaMode PIXBUF_ALPHA_FULL
 *  For now falls back to Gdk::PIXBUF_ALPHA_BILEVEL. In the future it will do full alpha compositing.
 * 
 *  @enum PixbufAlphaMode
 * 
 * These values can be passed to
 * gdk_pixbuf_render_to_drawable_alpha() to control how the alpha
 * channel of an image should be handled.  This function can create a
 * bilevel clipping mask (black and white) and use it while painting
 * the image.  In the future, when the X&nbsp;%Window System gets an alpha
 * channel extension, it will be possible to do full alpha
 * compositing onto arbitrary drawables.  For now both cases fall
 * back to a bilevel clipping mask.
 * @ingroup gdkmmEnums
 */
enum PixbufAlphaMode
{
  PIXBUF_ALPHA_BILEVEL,
  PIXBUF_ALPHA_FULL
};

} // namespace Gdk


#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{

template <>
class Value<Gdk::PixbufAlphaMode> : public Glib::Value_Enum<Gdk::PixbufAlphaMode>
{
public:
  static GType value_type() G_GNUC_CONST;
};

} // namespace Glib
#endif /* DOXYGEN_SHOULD_SKIP_THIS */


namespace Gdk
{

/** 
 *  @var PixbufRotation PIXBUF_ROTATE_NONE
 *  No rotation.
 * 
 *  @var PixbufRotation PIXBUF_ROTATE_COUNTERCLOCKWISE
 *  Rotate by 90 degrees.
 * 
 *  @var PixbufRotation PIXBUF_ROTATE_UPSIDEDOWN
 *  Rotate by 180 degrees.
 * 
 *  @var PixbufRotation PIXBUF_ROTATE_CLOCKWISE
 *  Rotate by 270 degrees.
 * 
 *  @enum PixbufRotation
 * 
 * The possible rotations which can be passed to Gdk::Pixbuf::rotate_simple().
 * To make them easier to use, their numerical values are the actual degrees.
 * @ingroup gdkmmEnums
 */
enum PixbufRotation
{
  PIXBUF_ROTATE_NONE = 0,
  PIXBUF_ROTATE_COUNTERCLOCKWISE = 90,
  PIXBUF_ROTATE_UPSIDEDOWN = 180,
  PIXBUF_ROTATE_CLOCKWISE = 270
};

} // namespace Gdk


#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{

template <>
class Value<Gdk::PixbufRotation> : public Glib::Value_Enum<Gdk::PixbufRotation>
{
public:
  static GType value_type() G_GNUC_CONST;
};

} // namespace Glib
#endif /* DOXYGEN_SHOULD_SKIP_THIS */


namespace Gdk
{


/** Exception class for Gdk::Pixbuf errors.
 */
class PixbufError : public Glib::Error
{
public:
  /**  @var Code CORRUPT_IMAGE
   *  An image file was broken somehow.
   * 
   *  @var Code INSUFFICIENT_MEMORY
   *  Not enough memory.
   * 
   *  @var Code BAD_OPTION
   *  A bad option was passed to a pixbuf save module.
   * 
   *  @var Code UNKNOWN_TYPE
   *  Unknown image type.
   * 
   *  @var Code UNSUPPORTED_OPERATION
   *  Don't know how to perform the given operation on the type of image at hand.
   * 
   *  @var Code FAILED
   *  Generic failure code, something went wrong.
   * 
   *  @enum Code
   * 
   * An error code in the Gdk::PIXBUF_ERROR domain. Many gdk-pixbuf
   * operations can cause errors in this domain, or in the FILE_ERROR
   * domain.
   */
  enum Code
  {
    CORRUPT_IMAGE,
    INSUFFICIENT_MEMORY,
    BAD_OPTION,
    UNKNOWN_TYPE,
    UNSUPPORTED_OPERATION,
    FAILED
  };

  PixbufError(Code error_code, const Glib::ustring& error_message);
  explicit PixbufError(GError* gobject);
  Code code() const;

#ifndef DOXYGEN_SHOULD_SKIP_THIS
private:

  static void throw_func(GError* gobject);

  friend void wrap_init(); // uses throw_func()

  #endif //DOXYGEN_SHOULD_SKIP_THIS
};

} // namespace Gdk

#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{

template <>
class Value<Gdk::PixbufError::Code> : public Glib::Value_Enum<Gdk::PixbufError::Code>
{
public:
  static GType value_type() G_GNUC_CONST;
};

} // namespace Glib
#endif /* DOXYGEN_SHOULD_SKIP_THIS */


namespace Gdk
{


class Pixbuf
  : public Glib::Object,
    public Gio::Icon
{
  
#ifndef DOXYGEN_SHOULD_SKIP_THIS

public:
  typedef Pixbuf CppObjectType;
  typedef Pixbuf_Class CppClassType;
  typedef GdkPixbuf BaseObjectType;
  typedef GdkPixbufClass BaseClassType;

private:  friend class Pixbuf_Class;
  static CppClassType pixbuf_class_;

private:
  // noncopyable
  Pixbuf(const Pixbuf&);
  Pixbuf& operator=(const Pixbuf&);

protected:
  explicit Pixbuf(const Glib::ConstructParams& construct_params);
  explicit Pixbuf(GdkPixbuf* castitem);

#endif /* DOXYGEN_SHOULD_SKIP_THIS */

public:
  virtual ~Pixbuf();

  /** Get the GType for this class, for use with the underlying GObject type system.
   */
  static GType get_type()      G_GNUC_CONST;

#ifndef DOXYGEN_SHOULD_SKIP_THIS


  static GType get_base_type() G_GNUC_CONST;
#endif

  ///Provides access to the underlying C GObject.
  GdkPixbuf*       gobj()       { return reinterpret_cast<GdkPixbuf*>(gobject_); }

  ///Provides access to the underlying C GObject.
  const GdkPixbuf* gobj() const { return reinterpret_cast<GdkPixbuf*>(gobject_); }

  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
  GdkPixbuf* gobj_copy();

private:

  
protected:

  //TODO: Throw an exception when the C function returns NULL?
  /** Transfers image data from a #GdkWindow and converts it to an RGB(A)
   * representation inside a Gdk::Pixbuf. In other words, copies
   * image data from a server-side drawable to a client-side RGB(A) buffer.
   * This allows you to efficiently read individual pixels on the client side.
   *
   * This function will create an RGB pixbuf with 8 bits per channel with
   * the same size specified by the @a width and @a height arguments. The pixbuf
   * will contain an alpha channel if the @a window contains one.
   *
   * If the window is off the screen, then there is no image data in the
   * obscured/offscreen regions to be placed in the pixbuf. The contents of
   * portions of the pixbuf corresponding to the offscreen region are undefined.
   *
   * If the window you're obtaining data from is partially obscured by
   * other windows, then the contents of the pixbuf areas corresponding
   * to the obscured regions are undefined.
   *
   * If the window is not mapped (typically because it's iconified/minimized
   * or not on the current workspace), then an invalid object will be returned.
   *
   * If memory can't be allocated for the return value, an invalid object will be returned
   * instead.
   *
   * @param src Source window.
   * @param src_x Source X coordinate within the window.
   * @param src_y Source Y coordinate within the window.
   * @param width Width in pixels of region to get.
   * @param height Height in pixels of region to get.
   *
   * @newin{2,12}
   */
  Pixbuf(const Glib::RefPtr<Window>& src,
         int src_x, int src_y, int width, int height);
  

  /** Transfers image data from a Cairo::Surface and converts it to an RGB(A)
   * representation inside a Gdk::Pixbuf. This allows you to efficiently read
   * individual pixels from cairo surfaces. For Gdk::Windows, use the
   * constructor that takes a Gdk::Window instead.
   *
   * This will create an RGB pixbuf with 8 bits per channel. The pixbuf will contain an alpha channel if the surface contains one. 
   *
   * @param surface Surface to copy from.
   * @param src_x Source X coordinate within the surface.
   * @param src_y Source Y coordinate within the surface.
   * @param width Width in pixels of region to get.
   * @param height Height in pixels of region to get.
   *
   * @newin{2,30}
   */
  Pixbuf(const Cairo::RefPtr<Cairo::Surface>& src,
         int src_x, int src_y, int width, int height);
   

public:
  typedef sigc::slot<void, const guint8*> SlotDestroyData;

  /** Transfers image data from a #GdkWindow and converts it to an RGB(A)
   * representation inside a Gdk::Pixbuf. In other words, copies
   * image data from a server-side drawable to a client-side RGB(A) buffer.
   * This allows you to efficiently read individual pixels on the client side.
   *
   * This function will create an RGB pixbuf with 8 bits per channel with
   * the same size specified by the @a width and @a height arguments. The pixbuf
   * will contain an alpha channel if the @a window contains one.
   *
   * If the window is off the screen, then there is no image data in the
   * obscured/offscreen regions to be placed in the pixbuf. The contents of
   * portions of the pixbuf corresponding to the offscreen region are undefined.
   *
   * If the window you're obtaining data from is partially obscured by
   * other windows, then the contents of the pixbuf areas corresponding
   * to the obscured regions are undefined.
   *
   * If the window is not mapped (typically because it's iconified/minimized
   * or not on the current workspace), then an invalid object will be returned.
   *
   * If memory can't be allocated for the return value, an invalid object will be returned
   * instead.
   *
   * @param src Source window.
   * @param src_x Source X coordinate within the window.
   * @param src_y Source Y coordinate within the window.
   * @param width Width in pixels of region to get.
   * @param height Height in pixels of region to get.
   *
   * @newin{2,12}
   */
  
  static Glib::RefPtr<Pixbuf> create(const Glib::RefPtr<Window>& src, int src_x, int src_y, int width, int height);


  /** Transfers image data from a Cairo::Surface and converts it to an RGB(A)
   * representation inside a Gdk::Pixbuf. This allows you to efficiently read
   * individual pixels from cairo surfaces. For Gdk::Windows, use the
   * create() method that takes a Gdk::Window instead.
   *
   * This will create an RGB pixbuf with 8 bits per channel. The pixbuf will contain an alpha channel if the surface contains one. 
   *
   * @param surface Surface to copy from.
   * @param src_x Source X coordinate within the surface.
   * @param src_y Source Y coordinate within the surface.
   * @param width Width in pixels of region to get.
   * @param height Height in pixels of region to get.
   *
   * @newin{2,30}
   */
  
  static Glib::RefPtr<Pixbuf> create(const Cairo::RefPtr<Cairo::Surface>& src, int src_x, int src_y, int width, int height);


  /** Creates a new Gdk::Pixbuf with a copy of the information in the specified
   *  @a pixbuf.
   * 
   * @return A newly-created pixbuf with a reference count of 1, or <tt>0</tt> if
   * not enough memory could be allocated.
   */
  Glib::RefPtr<Pixbuf> copy() const;

  
  /** Creates a new Gdk::Pixbuf structure and allocates a buffer for it.  The 
   * buffer has an optimal rowstride.  Note that the buffer is not cleared;
   * you will have to fill it completely yourself.
   * 
   * @param colorspace Color space for image.
   * @param has_alpha Whether the image should have transparency information.
   * @param bits_per_sample Number of bits per color sample.
   * @param width Width of image in pixels, must be > 0.
   * @param height Height of image in pixels, must be > 0.
   * @return A newly-created Gdk::Pixbuf with a reference count of 1, or 
   * <tt>0</tt> if not enough memory could be allocated for the image buffer.
   */
  static Glib::RefPtr<Pixbuf> create(Colorspace colorspace, bool has_alpha, int bits_per_sample, int width, int height);

  
  /** Creates a new pixbuf which represents a sub-region of @a src_pixbuf.
   * The new pixbuf shares its pixels with the original pixbuf, so
   * writing to one affects both.  The new pixbuf holds a reference to
   *  @a src_pixbuf, so @a src_pixbuf will not be finalized until the new
   * pixbuf is finalized.
   * 
   * Note that if @a src_pixbuf is read-only, this function will force it
   * to be mutable.
   * 
   * @param src_pixbuf A Gdk::Pixbuf.
   * @param src_x X coord in @a src_pixbuf.
   * @param src_y Y coord in @a src_pixbuf.
   * @param width Width of region in @a src_pixbuf.
   * @param height Height of region in @a src_pixbuf.
   * @return A new pixbuf.
   */
  static Glib::RefPtr<Pixbuf> create_subpixbuf(const Glib::RefPtr<Pixbuf>& src_pixbuf, int src_x, int src_y, int width, int height);

  
  /** Creates a new pixbuf by loading an image from a file. The file format is detected automatically.
   * @param filename The path to the pixbuf file.
   *
   * @throw Glib::FileError
   * @throw Gdk::PixbufError
   */
  static Glib::RefPtr<Pixbuf> create_from_file(const std::string& filename);

  
  /** Creates a new pixbuf by loading an image from a file. The file format is detected automatically.
   * The image will be scaled to fit in the requested size.
   * @param filename The path to the pixbuf file.
   * @param width The desired width
   * @param height The desired height
   * @param preserve_aspect_ratio Whether the image's aspect ratio will be preserved when scaling.
   *
   * @throw Glib::FileError
   * @throw Gdk::PixbufError
   */
  static Glib::RefPtr<Pixbuf> create_from_file(const std::string& filename, int width, int height, bool preserve_aspect_ratio =  true);
   //gdk_pixbuf_new_from_file_at_size() just calls gdk_pixbuf_new_from_file_at_scale().


  /** Creates a new pixbuf by loading an image from a resource. The file format is detected automatically.
   * @resource_path The path of the resource file.
   *
   * @throw Glib::ResourceError
   * @throw Gdk::PixbufError
   *
   * @newin{3,12}
   */
  static Glib::RefPtr<Pixbuf> create_from_resource(const std::string& resource_path);

  
  /** Creates a new pixbuf by loading an image from a resource. The file format is detected automatically.
   * The image will be scaled to fit in the requested size, optionally
   * preserving the image's aspect ratio. When preserving the aspect ratio,
   * a @a width of -1 will cause the image to be scaled to the exact given
   * height, and a @a height of -1 will cause the image to be scaled to the
   * exact given width. When not preserving aspect ratio, a @a width or
   * @a height of -1 means to not scale the image at all in that dimension.
   * @resource_path The path of the resource file.
   * @param width The desired width
   * @param height The desired height
   * @param preserve_aspect_ratio Whether the image's aspect ratio will be preserved when scaling.
   *
   * @throw Glib::ResourceError
   * @throw Gdk::PixbufError
   *
   * @newin{3,12}
   */
  static Glib::RefPtr<Pixbuf> create_from_resource(const std::string& resource_path, int width, int height, bool preserve_aspect_ratio =  true);


  /** Creates a new Gdk::Pixbuf out of in-memory image data.
   * Currently only RGB images with 8 bits per sample are supported.
   *
   * @param data %Image data in 8-bit/sample packed format.
   * @param colorspace Colorspace for the image data.
   * @param has_alpha Whether the data has an opacity channel.
   * @param bits_per_sample Number of bits per sample.
   * @param width Width of the image in pixels.
   * @param height Height of the image in pixels.
   * @param rowstride Distance in bytes between rows.
   * @return A newly-created Gdk::Pixbuf object.
   */
  static Glib::RefPtr<Pixbuf> create_from_data(const guint8* data, Colorspace colorspace,
                                               bool has_alpha, int bits_per_sample,
                                               int width, int height, int rowstride);

  /** Creates a new Gdk::Pixbuf out of in-memory image data.
   * Currently only RGB images with 8 bits per sample are supported.
   *
   * @param data %Image data in 8-bit/sample packed format.
   * @param colorspace Colorspace for the image data.
   * @param has_alpha Whether the data has an opacity channel.
   * @param bits_per_sample Number of bits per sample.
   * @param width Width of the image in pixels.
   * @param height Height of the image in pixels.
   * @param rowstride Distance in bytes between rows.
   * @param destroy_slot Slot used to free the data when the pixbuf's
   * reference count drops to zero.
   * @return A newly-created Gdk::Pixbuf object.
   */
  static Glib::RefPtr<Pixbuf> create_from_data(const guint8* data, Colorspace colorspace,
                                               bool has_alpha, int bits_per_sample,
                                               int width, int height, int rowstride,
                                               const SlotDestroyData& destroy_slot);

  
  /** Creates a new pixbuf by parsing XPM data in memory.  This data is commonly
   * the result of including an XPM file into a program's C source.
   * 
   * @param data Pointer to inline XPM data.
   * @return A newly-created pixbuf with a reference count of 1.
   */
  static Glib::RefPtr<Pixbuf> create_from_xpm_data(const char *const * data);

  
#ifndef GDKMM_DISABLE_DEPRECATED

  /** Create a Gdk::Pixbuf from a flat representation that is suitable for
   * storing as inline data in a program.  This is useful if you want to ship a
   * program with images, but don't want to depend on any external files.
   *
   * GTK+ ships with a program called <tt>gdk-pixbuf-csource</tt> which allows
   * for conversion of GdkPixbufs into such a inline representation. In almost
   * all cases, you should pass the <tt>--raw</tt> flag to
   * <tt>gdk-pixbuf-csource</tt>. A sample invocation would be:
   *
   * <tt>gdk-pixbuf-csource --raw --name=myimage_inline myimage.png</tt>
   *
   * For the typical case where the inline pixbuf is read-only static data, you
   * don't need to copy the pixel data unless you intend to write to it, so you
   * can pass <tt>false</tt> for @a copy_pixels. (If you pass <tt>--rle</tt> to
   * <tt>gdk-pixbuf-csource</tt>, a copy will be made even if @a copy_pixels is
   * <tt>false</tt>, so using this option is generally a bad idea.)
   *
   * If you create a pixbuf from const inline data compiled into your program,
   * it's probably safe to ignore errors, since things will always succeed. For
   * non-const inline data, you could get out of memory. For untrusted inline
   * data located at runtime, you could have corrupt inline data in addition.
   *
   * @param data_length Length in bytes of the @a data argument.
   * @param data Byte data containing a serialized GdkPixdata structure.
   * @param copy_pixels Whether to copy the pixel data, or use direct pointers
   *        to @a data for the resulting pixbuf.
   * @throw Gdk::PixbufError
   *
   * @deprecated Use Gio::Resource instead.
   */
  static Glib::RefPtr<Pixbuf> create_from_inline(int data_length, const guint8* data, bool copy_pixels =  false);
#endif // GDKMM_DISABLE_DEPRECATED


  /** Creates a new pixbuf by loading an image from an input stream.  
   * 
   * The file format is detected automatically. If <tt>0</tt> is returned, then 
   *  @a error will be set. The @a cancellable can be used to abort the operation
   * from another thread. If the operation was cancelled, the error 
   * IO_ERROR_CANCELLED will be returned. Other possible errors are in 
   * the Gdk::PIXBUF_ERROR and IO_ERROR domains. 
   * 
   * The stream is not closed.
   * 
   * @newin{2,14}
   * 
   * @param stream A InputStream to load the pixbuf from.
   * @param cancellable Optional Cancellable object, <tt>0</tt> to ignore.
   * @return A newly-created pixbuf, or <tt>0</tt> if any of several error 
   * conditions occurred: the file could not be opened, the image format is 
   * not supported, there was not enough memory to allocate the image buffer, 
   * the stream contained invalid data, or the operation was cancelled.
   */
  static Glib::RefPtr<Pixbuf> create_from_stream(const Glib::RefPtr<Gio::InputStream>& stream, const Glib::RefPtr<Gio::Cancellable>& cancellable);
  static Glib::RefPtr<Pixbuf> create_from_stream(const Glib::RefPtr<Gio::InputStream>& stream);

  
  /** Creates a new pixbuf by loading an image from an input stream.  
   * 
   * The file format is detected automatically. If <tt>0</tt> is returned, then 
   *  @a error will be set. The @a cancellable can be used to abort the operation
   * from another thread. If the operation was cancelled, the error 
   * IO_ERROR_CANCELLED will be returned. Other possible errors are in 
   * the Gdk::PIXBUF_ERROR and IO_ERROR domains. 
   * 
   * The image will be scaled to fit in the requested size, optionally 
   * preserving the image's aspect ratio.
   * 
   * When preserving the aspect ratio, a @a width of -1 will cause the image to be
   * scaled to the exact given height, and a @a height of -1 will cause the image
   * to be scaled to the exact given width. If both @a width and @a height are
   * given, this function will behave as if the smaller of the two values
   * is passed as -1.
   * 
   * When not preserving aspect ratio, a @a width or @a height of -1 means to not
   * scale the image at all in that dimension.
   * 
   * The stream is not closed.
   * 
   * @newin{2,14}
   * 
   * @param stream A InputStream to load the pixbuf from.
   * @param width The width the image should have or -1 to not constrain the width.
   * @param height The height the image should have or -1 to not constrain the height.
   * @param preserve_aspect_ratio <tt>true</tt> to preserve the image's aspect ratio.
   * @param cancellable Optional Cancellable object, <tt>0</tt> to ignore.
   * @return A newly-created pixbuf, or <tt>0</tt> if any of several error 
   * conditions occurred: the file could not be opened, the image format is 
   * not supported, there was not enough memory to allocate the image buffer, 
   * the stream contained invalid data, or the operation was cancelled.
   */
  static Glib::RefPtr<Pixbuf> create_from_stream_at_scale(const Glib::RefPtr<Gio::InputStream>& stream, int width, int height, bool preserve_aspect_ratio, const Glib::RefPtr<Gio::Cancellable>& cancellable);
  static Glib::RefPtr<Pixbuf> create_from_stream_at_scale(const Glib::RefPtr<Gio::InputStream>& stream, int width, int height, bool preserve_aspect_ratio);


  /** Queries the color space of a pixbuf.
   * 
   * @return Color space.
   */
  Colorspace get_colorspace() const;

  
  /** Queries the number of channels of a pixbuf.
   * 
   * @return Number of channels.
   */
  int get_n_channels() const;
  
  /** Queries whether a pixbuf has an alpha channel (opacity information).
   * 
   * @return <tt>true</tt> if it has an alpha channel, <tt>false</tt> otherwise.
   */
  bool get_has_alpha() const;
  
  /** Queries the number of bits per color sample in a pixbuf.
   * 
   * @return Number of bits per color sample.
   */
  int get_bits_per_sample() const;
  
  /** Queries a pointer to the pixel data of a pixbuf.
   * 
   * @return A pointer to the pixbuf's pixel data.
   * Please see the section on [image data](image-data) for information
   * about how the pixel data is stored in memory.
   * 
   * This function will cause an implicit copy of the pixbuf data if the
   * pixbuf was created from read-only data.
   */
  guint8* get_pixels() const;
  
  /** Queries the width of a pixbuf.
   * 
   * @return Width in pixels.
   */
  int get_width() const;
  
  /** Queries the height of a pixbuf.
   * 
   * @return Height in pixels.
   */
  int get_height() const;
  
  /** Queries the rowstride of a pixbuf, which is the number of bytes between
   * the start of a row and the start of the next row.
   * 
   * @return Distance between row starts.
   */
  int get_rowstride() const;
  
  /** Returns the length of the pixel data, in bytes.
   * 
   * @newin{2,26}
   * 
   * @return The length of the pixel data.
   */
  gsize get_byte_length() const;


  /** Clears a pixbuf to the given RGBA value, converting the RGBA value into
   * the pixbuf's pixel format. The alpha will be ignored if the pixbuf
   * doesn't have an alpha channel.
   * 
   * @param pixel RGBA pixel to clear to
   * (0xffffffff is opaque white, 0x00000000 transparent black).
   */
  void fill(guint32 pixel);

  /** Saves pixbuf to a file in format @a type.
   * By default, "jpeg", "png", "ico" and "bmp" are possible file formats to
   * save in, but more formats may be installed. The list of all writable
   * formats can be determined by using get_formats() with is_writable().
   *
   * @newin{3,6}
   *
   * @param filename The path of the file to be created.
   * @param type The file type.
   *
   * @throw Glib::FileError
   * @throw Gdk::PixbufError
   */
  void save(const std::string& filename, const Glib::ustring& type) const;

#ifndef GDKMM_DISABLE_DEPRECATED
  /**
   * Same as the const version.
   * @deprecated 3.6: Use the const version instead.
   */
  void save(const std::string& filename, const Glib::ustring& type);
#endif // GDKMM_DISABLE_DEPRECATED

  
  /** Saves pixbuf to a file in format @a type.
   * By default, "jpeg", "png", "ico" and "bmp" are possible file formats to save in, but more formats may be installed.
   * TThe list of all writable formats can be determined by using get_formats() with
   * Gdk::PixbufFormat::is_writable().
   *
   * The @a option_keys and @a option_values, if not empty, should contain pairs of strings that modify the save parameters.
   * For example,  "quality", "100".
   *
   * Currently only a few parameters exist. JPEG images can be saved with a "quality" parameter;
   * its value should be in the range [0,100]. Text chunks can be attached to PNG images by specifying parameters of the
   * form "tEXt::key", where key is an ASCII string of length 1-79. The values are UTF-8 encoded strings. ICO images can be
   * saved in depth 16, 24, or 32, by using the "depth" parameter. When the ICO saver is given "x_hot" and "y_hot"
   * parameters, it produces a CUR instead of an ICO.
   *
   * @newin{3,6}
   *
   * @param filename The path of the file to be created.
   * @param type The file type.
   * @param option_keys
   * @param option_values
   *
   * @throw Glib::FileError
   * @throw Gdk::PixbufError
   */
  void save(const std::string& filename, const Glib::ustring& type,
            const std::vector<Glib::ustring>& option_keys,
            const std::vector<Glib::ustring>& option_values) const;

#ifndef GDKMM_DISABLE_DEPRECATED
  /**
   * Same as the const version.
   * @deprecated 3.6: Use the const version instead.
   */
  void save(const std::string& filename, const Glib::ustring& type,
            const std::vector<Glib::ustring>& option_keys,
            const std::vector<Glib::ustring>& option_values);
#endif // GDKMM_DISABLE_DEPRECATED

  
#if 0 //TODO:
  typedef sigc::slot<const char* buf, gsize> SlotSave;

  /** @throws TODO
   */
  void save(const SlotSave& slot, const std::string& type);


  /** A map of option keys to option values.
   */
  typepdef std::map<Glib::ustring, Glib::ustring> SaveValuesMap;

  void save(const SlotSave& slot, const std::string& type, const SaveValuesMap& options);
#endif

/* TODO:
typedef gboolean (*GdkPixbufSaveFunc)   (const gchar *buf,
					 gsize count,
					 GError **error,
					 gpointer data);

gboolean gdk_pixbuf_save_to_callback    (GdkPixbuf  *pixbuf,
					 GdkPixbufSaveFunc save_func,
					 gpointer user_data,
					 const char *type,
					 GError    **error,
					 ...);

gboolean gdk_pixbuf_save_to_callbackv   (GdkPixbuf  *pixbuf,
					 GdkPixbufSaveFunc save_func,
					 gpointer user_data,
					 const char *type,
					 char      **option_keys,
					 char      **option_values,
					 GError    **error);

*/

  /** Saves the pixbuf to a new buffer in format @a type.
   * Note that the buffer is not nul-terminated and may contain embedded nulls.
   * @see save().
   *
   * @newin{3,6}
   *
   * @param buffer This will be set to the address of a new buffer.
   * @param buffer_size This will be set to the size of the @a buffer.
   * @param type Currently "jpeg", "png", "ico" or "bmp".
   *
   * @throw Glib::FileError
   * @throw Gdk::PixbufError
   */
  void save_to_buffer(gchar*& buffer, gsize& buffer_size,
                      const Glib::ustring& type = "png") const;

#ifndef GDKMM_DISABLE_DEPRECATED
  /**
   * Same as the const version.
   * @deprecated 3.6: Use the const version instead.
   */
  void save_to_buffer(gchar*& buffer, gsize& buffer_size,
                      const Glib::ustring& type = "png");
#endif // GDKMM_DISABLE_DEPRECATED

  /** Saves the pixbuf to a new buffer in format @a type.
   * Note that the buffer is not nul-terminated and may contain embedded nulls.
   * @see save().
   *
   * @newin{3,6}
   *
   * @param buffer This will be set to the address of a new buffer.
   * @param buffer_size This will be set to the size of the @a buffer.
   * @param type Currently "jpeg", "png", "ico" or "bmp".
   * @param option_keys Names of options to set.
   * @param option_values Values for named options.
   *
   * @throw Glib::FileError
   * @throw Gdk::PixbufError
   */
  void save_to_buffer(gchar*& buffer, gsize& buffer_size,
                      const Glib::ustring& type,
                      const std::vector<Glib::ustring>& option_keys,
                      const std::vector<Glib::ustring>& option_values) const;

#ifndef GDKMM_DISABLE_DEPRECATED
  /**
   * Same as the const version.
   * @deprecated 3.6: Use the const version instead.
   */
  void save_to_buffer(gchar*& buffer, gsize& buffer_size,
                      const Glib::ustring& type,
                      const std::vector<Glib::ustring>& option_keys,
                      const std::vector<Glib::ustring>& option_values);
#endif // GDKMM_DISABLE_DEPRECATED

  
  /** Takes an existing pixbuf and adds an alpha channel to it.
   * If the existing pixbuf already had an alpha channel, the channel
   * values are copied from the original; otherwise, the alpha channel
   * is initialized to 255 (full opacity).
   * 
   * If @a substitute_color is <tt>true</tt>, then the color specified by ( @a r, @a g, @a b) will be
   * assigned zero opacity. That is, if you pass (255, 255, 255) for the
   * substitute color, all white pixels will become fully transparent.
   * 
   * @param substitute_color Whether to set a color to zero opacity.  If this
   * is <tt>false</tt>, then the ( @a r, @a g, @a b) arguments will be ignored.
   * @param r Red value to substitute.
   * @param g Green value to substitute.
   * @param b Blue value to substitute.
   * @return A newly-created pixbuf with a reference count of 1.
   */
  Glib::RefPtr<Gdk::Pixbuf> add_alpha(bool substitute_color, guint8 r, guint8 g, guint8 b) const;

  
  /** Copies a rectangular area from @a src_pixbuf to @a dest_pixbuf.  Conversion of
   * pixbuf formats is done automatically.
   * 
   * If the source rectangle overlaps the destination rectangle on the
   * same pixbuf, it will be overwritten during the copy operation.
   * Therefore, you can not use this function to scroll a pixbuf.
   * 
   * @param src_x Source X coordinate within @a src_pixbuf.
   * @param src_y Source Y coordinate within @a src_pixbuf.
   * @param width Width of the area to copy.
   * @param height Height of the area to copy.
   * @param dest_pixbuf Destination pixbuf.
   * @param dest_x X coordinate within @a dest_pixbuf.
   * @param dest_y Y coordinate within @a dest_pixbuf.
   */
  void copy_area(int src_x, int src_y, int width, int height, const Glib::RefPtr<Gdk::Pixbuf>& dest_pixbuf, int dest_x, int dest_y) const;

  
  /** Modifies saturation and optionally pixelates @a src, placing the result in
   *  @a dest. @a src and @a dest may be the same pixbuf with no ill effects.  If
   *  @a saturation is 1.0 then saturation is not changed. If it's less than 1.0,
   * saturation is reduced (the image turns toward grayscale); if greater than
   * 1.0, saturation is increased (the image gets more vivid colors). If @a pixelate
   * is <tt>true</tt>, then pixels are faded in a checkerboard pattern to create a
   * pixelated image. @a src and @a dest must have the same image format, size, and
   * rowstride.
   * 
   * @param dest Place to write modified version of @a src.
   * @param saturation Saturation factor.
   * @param pixelate Whether to pixelate.
   */
  void saturate_and_pixelate(const Glib::RefPtr<Gdk::Pixbuf>& dest, float saturation, bool pixelate) const;


  /** Creates a transformation of the source image @a src by scaling by
   *  @a scale_x and @a scale_y then translating by @a offset_x and @a offset_y,
   * then renders the rectangle ( @a dest_x, @a dest_y, @a dest_width,
   *  @a dest_height) of the resulting image onto the destination image
   * replacing the previous contents.
   * 
   * Try to use scale_simple() first, this function is
   * the industrial-strength power tool you can fall back to if
   * scale_simple() isn't powerful enough.
   * 
   * If the source rectangle overlaps the destination rectangle on the
   * same pixbuf, it will be overwritten during the scaling which
   * results in rendering artifacts.
   * 
   * @param dest The Gdk::Pixbuf into which to render the results.
   * @param dest_x The left coordinate for region to render.
   * @param dest_y The top coordinate for region to render.
   * @param dest_width The width of the region to render.
   * @param dest_height The height of the region to render.
   * @param offset_x The offset in the X direction (currently rounded to an integer).
   * @param offset_y The offset in the Y direction (currently rounded to an integer).
   * @param scale_x The scale factor in the X direction.
   * @param scale_y The scale factor in the Y direction.
   * @param interp_type The interpolation type for the transformation.
   */
  void scale(const Glib::RefPtr<Gdk::Pixbuf>& dest, int dest_x, int dest_y, int dest_width, int dest_height, double offset_x, double offset_y, double scale_x, double scale_y, InterpType interp_type) const;

  
  /** Creates a transformation of the source image @a src by scaling by
   *  @a scale_x and @a scale_y then translating by @a offset_x and @a offset_y.
   * This gives an image in the coordinates of the destination pixbuf.
   * The rectangle ( @a dest_x, @a dest_y, @a dest_width, @a dest_height)
   * is then composited onto the corresponding rectangle of the
   * original destination image.
   * 
   * When the destination rectangle contains parts not in the source 
   * image, the data at the edges of the source image is replicated
   * to infinity. 
   * 
   * ![](composite.png)
   * 
   * @param dest The Gdk::Pixbuf into which to render the results.
   * @param dest_x The left coordinate for region to render.
   * @param dest_y The top coordinate for region to render.
   * @param dest_width The width of the region to render.
   * @param dest_height The height of the region to render.
   * @param offset_x The offset in the X direction (currently rounded to an integer).
   * @param offset_y The offset in the Y direction (currently rounded to an integer).
   * @param scale_x The scale factor in the X direction.
   * @param scale_y The scale factor in the Y direction.
   * @param interp_type The interpolation type for the transformation.
   * @param overall_alpha Overall alpha for source image (0..255).
   */
  void composite(const Glib::RefPtr<Gdk::Pixbuf>& dest, int dest_x, int dest_y, int dest_width, int dest_height, double offset_x, double offset_y, double scale_x, double scale_y, InterpType interp_type, int overall_alpha) const;

  
  /** Creates a transformation of the source image @a src by scaling by
   *  @a scale_x and @a scale_y then translating by @a offset_x and @a offset_y,
   * then composites the rectangle ( @a dest_x , @a dest_y, @a dest_width,
   *  @a dest_height) of the resulting image with a checkboard of the
   * colors @a color1 and @a color2 and renders it onto the destination
   * image.
   * 
   * See composite_color_simple() for a simpler variant of this
   * function suitable for many tasks.
   * 
   * @param dest The Gdk::Pixbuf into which to render the results.
   * @param dest_x The left coordinate for region to render.
   * @param dest_y The top coordinate for region to render.
   * @param dest_width The width of the region to render.
   * @param dest_height The height of the region to render.
   * @param offset_x The offset in the X direction (currently rounded to an integer).
   * @param offset_y The offset in the Y direction (currently rounded to an integer).
   * @param scale_x The scale factor in the X direction.
   * @param scale_y The scale factor in the Y direction.
   * @param interp_type The interpolation type for the transformation.
   * @param overall_alpha Overall alpha for source image (0..255).
   * @param check_x The X offset for the checkboard (origin of checkboard is at - @a check_x, - @a check_y).
   * @param check_y The Y offset for the checkboard.
   * @param check_size The size of checks in the checkboard (must be a power of two).
   * @param color1 The color of check at upper left.
   * @param color2 The color of the other check.
   */
  void composite_color(const Glib::RefPtr<Gdk::Pixbuf>& dest, int dest_x, int dest_y, int dest_width, int dest_height, double offset_x, double offset_y, double scale_x, double scale_y, InterpType interp_type, int overall_alpha, int check_x, int check_y, int check_size, guint32 color1, guint32 color2) const;

  
  /** Create a new Gdk::Pixbuf containing a copy of @a src scaled to
   *  @a dest_width x @a dest_height. Leaves @a src unaffected.  @a interp_type
   * should be Gdk::INTERP_NEAREST if you want maximum speed (but when
   * scaling down Gdk::INTERP_NEAREST is usually unusably ugly).  The
   * default @a interp_type should be Gdk::INTERP_BILINEAR which offers
   * reasonable quality and speed.
   * 
   * You can scale a sub-portion of @a src by creating a sub-pixbuf
   * pointing into @a src; see new_subpixbuf().
   * 
   * For more complicated scaling/compositing see scale()
   * and composite().
   * 
   * @param dest_width The width of destination image.
   * @param dest_height The height of destination image.
   * @param interp_type The interpolation type for the transformation.
   * @return The new Gdk::Pixbuf, or <tt>0</tt> if not enough memory could be
   * allocated for it.
   */
  Glib::RefPtr<Gdk::Pixbuf> scale_simple(int dest_width, int dest_height, InterpType interp_type) const;

  
  /** Creates a new Gdk::Pixbuf by scaling @a src to @a dest_width x
   *  @a dest_height and compositing the result with a checkboard of colors
   *  @a color1 and @a color2.
   * 
   * @param dest_width The width of destination image.
   * @param dest_height The height of destination image.
   * @param interp_type The interpolation type for the transformation.
   * @param overall_alpha Overall alpha for source image (0..255).
   * @param check_size The size of checks in the checkboard (must be a power of two).
   * @param color1 The color of check at upper left.
   * @param color2 The color of the other check.
   * @return The new Gdk::Pixbuf, or <tt>0</tt> if not enough memory could be
   * allocated for it.
   */
  Glib::RefPtr<Gdk::Pixbuf> composite_color_simple(int dest_width, int dest_height, InterpType interp_type, int overall_alpha, int check_size, guint32 color1, guint32 color2) const;

  
  /** Rotates a pixbuf by a multiple of 90 degrees, and returns the
   * result in a new pixbuf.
   * 
   * @newin{2,6}
   * 
   * @param angle The angle to rotate by.
   * @return The new Gdk::Pixbuf, or <tt>0</tt>
   * if not enough memory could be allocated for it.
   */
  Glib::RefPtr<Gdk::Pixbuf> rotate_simple(PixbufRotation angle) const;
  
  /** Flips a pixbuf horizontally or vertically and returns the
   * result in a new pixbuf.
   * 
   * @newin{2,6}
   * 
   * @param horizontal <tt>true</tt> to flip horizontally, <tt>false</tt> to flip vertically.
   * @return The new Gdk::Pixbuf, or <tt>0</tt>
   * if not enough memory could be allocated for it.
   */
  Glib::RefPtr<Gdk::Pixbuf> flip(bool horizontal =  true) const;

  //Use Gdk::Drawable::draw_pixbuf() instead of gdk_pixbuf_render_to_drawable(), gdk_pixbuf_render_to_drawable_alpha().
  //gtkmmproc error: gdk_pixbuf_render_to_drawable : ignored method defs lookup failed//gtkmmproc error: gdk_pixbuf_render_to_drawable_alpha : ignored method defs lookup failed

  
  /** Looks up @a key in the list of options that may have been attached to the
   *  @a pixbuf when it was loaded, or that may have been attached by another
   * function using set_option().
   * 
   * For instance, the ANI loader provides "Title" and "Artist" options. 
   * The ICO, XBM, and XPM loaders provide "x_hot" and "y_hot" hot-spot 
   * options for cursor definitions. The PNG loader provides the tEXt ancillary
   * chunk key/value pairs as options. Since 2.12, the TIFF and JPEG loaders
   * return an "orientation" option string that corresponds to the embedded 
   * TIFF/Exif orientation tag (if present). Since 2.32, the TIFF loader sets
   * the "multipage" option string to "yes" when a multi-page TIFF is loaded.
   * Since 2.32 the JPEG and PNG loaders set "x-dpi" and "y-dpi" if the file
   * contains image density information in dots per inch.
   * 
   * @param key A nul-terminated string.
   * @return The value associated with @a key. This is a nul-terminated 
   * string that should not be freed or <tt>0</tt> if @a key was not found.
   */
  Glib::ustring get_option(const Glib::ustring& key) const;

   //gdk_pixbuf_set_option() is only available when GDK_PIXBUF_ENABLE_BACKEND is defined.

  //This creates a new GdkPixbuf or returns the original with a reference.
  
  /** Takes an existing pixbuf and checks for the presence of an
   * associated "orientation" option, which may be provided by the 
   * jpeg loader (which reads the exif orientation tag) or the 
   * tiff loader (which reads the tiff orientation tag, and
   * compensates it for the partial transforms performed by 
   * libtiff). If an orientation option/tag is present, the
   * appropriate transform will be performed so that the pixbuf
   * is oriented correctly.
   * 
   * @newin{2,12}
   * 
   * @return A newly-created pixbuf, or a reference to the
   * input pixbuf (with an increased reference count).
   */
  Glib::RefPtr<Pixbuf> apply_embedded_orientation();

  /** Obtains the available information about the image formats supported by GdkPixbuf.
   * @result A list of PixbufFormats describing the supported image formats.
   */
  static std::vector<PixbufFormat> get_formats();
  

  #ifdef GLIBMM_PROPERTIES_ENABLED
/** The colorspace in which the samples are interpreted.
   *
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
   * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
   * or receive notification when the value of the property changes.
   */
  Glib::PropertyProxy_ReadOnly< Colorspace > property_colorspace() const;
#endif //#GLIBMM_PROPERTIES_ENABLED


  #ifdef GLIBMM_PROPERTIES_ENABLED
/** The number of samples per pixel.
   *
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
   * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
   * or receive notification when the value of the property changes.
   */
  Glib::PropertyProxy_ReadOnly< int > property_n_channels() const;
#endif //#GLIBMM_PROPERTIES_ENABLED


  #ifdef GLIBMM_PROPERTIES_ENABLED
/** Whether the pixbuf has an alpha channel.
   *
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
   * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
   * or receive notification when the value of the property changes.
   */
  Glib::PropertyProxy_ReadOnly< bool > property_has_alpha() const;
#endif //#GLIBMM_PROPERTIES_ENABLED


  #ifdef GLIBMM_PROPERTIES_ENABLED
/** The number of bits per sample.
   *
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
   * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
   * or receive notification when the value of the property changes.
   */
  Glib::PropertyProxy_ReadOnly< int > property_bits_per_sample() const;
#endif //#GLIBMM_PROPERTIES_ENABLED


  #ifdef GLIBMM_PROPERTIES_ENABLED
/** The number of columns of the pixbuf.
   *
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
   * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
   * or receive notification when the value of the property changes.
   */
  Glib::PropertyProxy_ReadOnly< int > property_width() const;
#endif //#GLIBMM_PROPERTIES_ENABLED


  #ifdef GLIBMM_PROPERTIES_ENABLED
/** The number of rows of the pixbuf.
   *
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
   * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
   * or receive notification when the value of the property changes.
   */
  Glib::PropertyProxy_ReadOnly< int > property_height() const;
#endif //#GLIBMM_PROPERTIES_ENABLED


  #ifdef GLIBMM_PROPERTIES_ENABLED
/** The number of bytes between the start of a row and the start of the next row.
   *
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
   * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
   * or receive notification when the value of the property changes.
   */
  Glib::PropertyProxy_ReadOnly< int > property_rowstride() const;
#endif //#GLIBMM_PROPERTIES_ENABLED


  #ifdef GLIBMM_PROPERTIES_ENABLED
/** A pointer to the pixel data of the pixbuf.
   *
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
   * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
   * or receive notification when the value of the property changes.
   */
  Glib::PropertyProxy_ReadOnly< void* > property_pixels() const;
#endif //#GLIBMM_PROPERTIES_ENABLED


public:

public:
  //C++ methods used to invoke GTK+ virtual functions:

protected:
  //GTK+ Virtual Functions (override these to change behaviour):

  //Default Signal Handlers::


};

} // namespace Gdk


namespace Glib
{
  /** A Glib::wrap() method for this object.
   * 
   * @param object The C instance.
   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
   * @result A C++ instance that wraps this C instance.
   *
   * @relates Gdk::Pixbuf
   */
  Glib::RefPtr<Gdk::Pixbuf> wrap(GdkPixbuf* object, bool take_copy = false);
}


#endif /* _GDKMM_PIXBUF_H */

