/* *****************************************************************************

** $Id$

** Initial file written and documented by:

** Kevin Shepherd <kshepherd@php.net> December 2007

** of Scarlet Line http://www.scarletline.com/

** with contributions from Torben Nielsen.

*******************************************************************************/

/** \file gdpp.h

	\brief Object Oriented C++ wrappers around libgd functionality.

	Example usage, convert png to gif:

	#include <fstream>

	#include <gdpp.h>

	std::ifstream in("image.png", std::ios_base::in | std::ios_base::binary );

	GD::Image im(in, GD::Png_tag());

	if (im.good())

		{

		std::ofstream out("image.gif", std::ios_base::out | std::ios_base::binary );

		im.Gif(out);

		}

*/

#ifdef __cplusplus

#ifndef _gdpp_h

#define _gdpp_h

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "gd_io_stream.h"

#include <string>

/// namespace GD:: contains the C++ wrapper classes for libgd

/** This namespace is primarily to avoid name clashes, and to

	contain all of the gd classes within one namespace.

	It is not recommended to use the "using namespace" directive with this namespace.

	Example usage:

	GD::Image	im(64, 32, true); // Create a truecolor image 64 pixels wide by 32 pixels high

	GD::Point	pt(10, 8); // The point at x=10, y=8.

	GD::Size	sz(16, 8); // The size width=16, height=8.

	GD::TrueColor	col(0xFF, 0, 0); // The colour red; R=255, G=0, B=0.

	im.Rectangle(pt, sz, col.Int()); // Draw a red rectangle with top left corner at pt, of size sz.

*/

namespace GD

{

/**	This class GD::Point stores a point in two dimensions, somewhere

	on the plane of an image.

*/

class BGD_EXPORT_DATA_PROT Point

{

public:

	// Constructors

	Point(int x, int y)

		:_x(x), _y(y) {}

	Point(const Point & p)

		:_x(p._x), _y(p._y) {}

	Point()

		:_x(0), _y(0) {}

	Point & operator=(const Point & p) {

		_x = p._x;

		_y = p._y;

		return (* this);

	}

	// Accessors

	int X() const {

		return _x;

	}

	int Y() const {

		return _y;

	}

	// Updaters

	void X(int x) {

		_x = x;

	}

	void Y(int y) {

		_y = y;

	}

	void set(int x, int y) {

		_x = x;

		_y = y;

	}

	int & lhsX() {

		return _x;

	}

	int & lhsY() {

		return _y;

	}

	gdPointPtr as_gdPointPtr() {

		return (gdPointPtr) this;

	}

protected:

	int	_x, _y;

};

typedef Point * PointPtr;

/**	This class GD::Size stores length in two dimensions.

	Giving the size of an area as width and height.

*/

class BGD_EXPORT_DATA_PROT Size

{

public:

	// Constructors

	Size(int w, int h)

		:_w(w), _h(h) {}

	Size(const Size & p)

		:_w(p._w), _h(p._h) {}

	Size()

		:_w(0), _h(0) {}

	Size & operator=(const Size & p) {

		_w = p._w;

		_h = p._h;

		return (* this);

	}

	// Accessors

	int W() const {

		return _w;

	}

	int H() const {

		return _h;

	}

	// Updaters

	void W(int w) {

		_w = w;

	}

	void H(int h) {

		_h = h;

	}

	void set(int w, int h) {

		_w = w;

		_h = h;

	}

	int & lhsW() {

		return _w;

	}

	int & lhsH() {

		return _h;

	}

protected:

	int	_w, _h;

};

typedef Size * SizePtr;

/**	This class GD::TrueColor stores a colour as an RGBA quadruplet.

	It can also be read as an integer, and in other colour formats.

*/

class BGD_EXPORT_DATA_PROT TrueColor

{

public:

	union as_types {

		int as_int;

		struct uchars {

			unsigned char blue, green, red, alpha;

		} as_uchar;

	};

	TrueColor() {

		internal.as_int = 0;

	}

	TrueColor(int c) {

		internal.as_int = c;

	}

	TrueColor(unsigned char r, unsigned char g, unsigned char b, unsigned char a = 0) {

		internal.as_uchar.alpha = a;

		internal.as_uchar.red = r;

		internal.as_uchar.green = g;

		internal.as_uchar.blue = b;

	}

	// Accessors

	int Int() const {

		return internal.as_int;

	}

	unsigned char Red() const {

		return internal.as_uchar.red;

	}

	unsigned char Green() const {

		return internal.as_uchar.green;

	}

	unsigned char Blue() const {

		return internal.as_uchar.blue;

	}

	unsigned char Alpha() const {

		return internal.as_uchar.alpha;

	}

	// Updaters

	void set(int c) {

		internal.as_int = c;

	}

	void set(unsigned char r, unsigned char g, unsigned char b, unsigned char a = 0) {

		internal.as_uchar.alpha = a;

		internal.as_uchar.red = r;

		internal.as_uchar.green = g;

		internal.as_uchar.blue = b;

	}

	void Red(unsigned char c) {

		internal.as_uchar.red = c;

	}

	void Green(unsigned char c) {

		internal.as_uchar.green = c;

	}

	void Blue(unsigned char c) {

		internal.as_uchar.blue = c;

	}

	void Alpha(unsigned char c) {

		internal.as_uchar.alpha = c;

	}

protected:

	as_types internal;

};

/*	The following tags are simply empty structures which are used

	to tell the compiler which constructor we want when we know

	the image file format.

*/

struct BGD_EXPORT_DATA_PROT Png_tag {};

struct BGD_EXPORT_DATA_PROT Gif_tag {};

struct BGD_EXPORT_DATA_PROT WBMP_tag {};

struct BGD_EXPORT_DATA_PROT Jpeg_tag {};

struct BGD_EXPORT_DATA_PROT Gd_tag {};

struct BGD_EXPORT_DATA_PROT Gd2_tag {};

struct BGD_EXPORT_DATA_PROT Xbm_tag {};

/**	This class GD::Image wraps all of the 'C' libgd functionality

	for the convenience of C++ users.  An instance of this class

	corresponds to a single image.

*/

class BGD_EXPORT_DATA_PROT Image

{

public:

	/**	Construct a null image

	*/

	Image()

		:im(0)

	{}

	/** Construct a blank image, of the given size and colour format type.

		\param[in] sx Width of the image

		\param[in] sy Height of the image

		\param[in] istruecolor Create a true colour image, defaults to false, i.e. create an indexed palette image.

	*/

	Image(int sx, int sy, bool istruecolor = false)

		:im(0) {

		if (istruecolor)

			CreateTrueColor(sx, sy);

		else

			Create(sx, sy);

	}

	/** Construct a blank image, of the given size and colour format type.

		\param[in] s Width and height of the image

		\param[in] istruecolor Create a true colour image, defaults to false, i.e. create an indexed palette image.

	*/

	Image(const Size & s, bool istruecolor = false)

		:im(0) {

		if (istruecolor)

			CreateTrueColor(s);

		else

			Create(s);

	}

	/** Construct an instance of the GD::Image class, given the internal gdImage poimter.

		Note that gdImageDestroy will be called on the image pointer in the destructor.

		\param[in] i Pointer to the internal gdImage

	*/

	Image(gdImagePtr i)

		:im(i) {}

	/** Copy constructor. Construct an instance of the GD::Image class,

		by making a copy of the GD::Image provided.

		\param[in] i Reference to the image to be copied

	*/

	Image(const GD::Image & i)

		:im(0) {

		Copy(i);

	}

	/** Construct an image by reading from \p in.  This constructor

		will first attempt to determine the file format.

		\param[in] in The stream containing the image data

	*/

	Image(std::istream & in)

		:im(0) {

		CreateFrom(in);

	}

	/** Construct an image by reading from \p in.  This constructor

		will first attempt to determine the file format.

		\param[in] in An opened FILE * handle to a file containing the image data

	*/

	Image(FILE * in)

		:im(0) {

		CreateFrom(in);

	}

	/** Construct an image by reading from memory block \p data.  This constructor

		will first attempt to determine the image formatting.

		\param[in] size The byte count of the memory block

		\param[in] data Pointer to the memory block

	*/

	Image(int size, void * data)

		:im(0) {

		CreateFrom(size, data);

	}

#ifdef HAVE_LIBPNG

	/** Construct an image by reading from \p in.

		The tag is an empty struct which simply tells the compiler which image read function to use.

		e.g. GD::Image img(input, GD::Png_tag()); // read a png file from input

		\param[in] in The stream containing the image data

	*/

	Image(std::istream & in, Png_tag)

		:im(0) {

		CreateFromPng(in);

	}

	/** Construct an image by reading from \p in.

		The tag is an empty struct which simply tells the compiler which image read function to use.

		e.g. GD::Image img(input, GD::Png_tag()); // read a png file from input

		\param[in] in An opened FILE * handle to a file containing the image data

	*/

	Image(FILE * in, Png_tag)

		:im(0) {

		CreateFromPng(in);

	}

	/** Construct an image by reading from \p in.

		The tag is an empty struct which simply tells the compiler which image read function to use.

		e.g. GD::Image img(input, GD::Png_tag()); // read a png file from input

		\param[in] in The io context from which to read the image data

	*/

	Image(gdIOCtx * in, Png_tag)

		:im(0) {

		CreateFromPng(in);

	}

	/** Construct an image by reading from memory block \p data.

		The tag is an empty struct which simply tells the compiler which image read function to use.

		e.g. GD::Image img(sz, dat, GD::Png_tag()); // read a png file from dat

		\param[in] size The byte count of the memory block

		\param[in] data Pointer to the memory block

	*/

	Image(int size, void * data, Png_tag)

		:im(0) {

		CreateFromPng(size, data);

	}

#endif

	/** Construct an image by reading from \p in.

		The tag is an empty struct which simply tells the compiler which image read function to use.

		e.g. GD::Image img(input, GD::Gif_tag()); // read a gif file from input

		\param[in] in The stream containing the image data

	*/

	Image(std::istream & in, Gif_tag)

		:im(0) {

		CreateFromGif(in);

	}

	/** Construct an image by reading from \p in.

		The tag is an empty struct which simply tells the compiler which image read function to use.

		e.g. GD::Image img(input, GD::Gif_tag()); // read a gif file from input

		\param[in] in An opened FILE * handle to a file containing the image data

	*/

	Image(FILE * in, Gif_tag)

		:im(0) {

		CreateFromGif(in);

	}

	/** Construct an image by reading from \p in.

		The tag is an empty struct which simply tells the compiler which image read function to use.

		e.g. GD::Image img(input, GD::Gif_tag()); // read a gif file from input

		\param[in] in The io context from which to read the image data

	*/

	Image(gdIOCtx * in, Gif_tag)

		:im(0) {

		CreateFromGif(in);

	}

	/** Construct an image by reading from memory block \p data.

		The tag is an empty struct which simply tells the compiler which image read function to use.

		e.g. GD::Image img(sz, dat, GD::Gif_tag()); // read a gif file from dat

		\param[in] size The byte count of the memory block

		\param[in] data Pointer to the memory block

	*/

	Image(int size, void * data, Gif_tag)

		:im(0) {

		CreateFromGif(size, data);

	}

	/** Construct an image by reading from \p in.

		The tag is an empty struct which simply tells the compiler which image read function to use.

		e.g. GD::Image img(input, GD::WBMP_tag()); // read a monchrome WBMP file from input

		\param[in] in The stream containing the image data

	*/

	Image(std::istream & in, WBMP_tag)

		:im(0) {

		CreateFromWBMP(in);

	}

	/** Construct an image by reading from \p in.

		The tag is an empty struct which simply tells the compiler which image read function to use.

		e.g. GD::Image img(input, GD::WBMP_tag()); // read a monchrome WBMP file from input

		\param[in] in An opened FILE * handle to a file containing the image data

	*/

	Image(FILE * in, WBMP_tag)

		:im(0) {

		CreateFromWBMP(in);

	}

	/** Construct an image by reading from \p in.

		The tag is an empty struct which simply tells the compiler which image read function to use.

		e.g. GD::Image img(input, GD::WBMP_tag()); // read a monchrome WBMP file from input

		\param[in] in The io context from which to read the image data

	*/

	Image(gdIOCtx * in, WBMP_tag)

		:im(0) {

		CreateFromWBMP(in);

	}

	/** Construct an image by reading from memory block \p data.

		The tag is an empty struct which simply tells the compiler which image read function to use.

		e.g. GD::Image img(sz, dat, GD::WBMP_tag()); // read a monchrome WBMP file from dat

		\param[in] size The byte count of the memory block

		\param[in] data Pointer to the memory block

	*/

	Image(int size, void * data, WBMP_tag)

		:im(0) {

		CreateFromWBMP(size, data);

	}

#ifdef HAVE_LIBJPEG

	/** Construct an image by reading from \p in.

		The tag is an empty struct which simply tells the compiler which image read function to use.

		e.g. GD::Image img(input, GD::Jpeg_tag()); // read a jpeg file from input

		\param[in] in The stream containing the image data

	*/

	Image(std::istream & in, Jpeg_tag)

		:im(0) {

		CreateFromJpeg(in);

	}

	/** Construct an image by reading from \p in.

		The tag is an empty struct which simply tells the compiler which image read function to use.

		e.g. GD::Image img(input, GD::Jpeg_tag()); // read a jpeg file from input

		\param[in] in An opened FILE * handle to a file containing the image data

	*/

	Image(FILE * in, Jpeg_tag)

		:im(0) {

		CreateFromJpeg(in);

	}

	/** Construct an image by reading from \p in.

		The tag is an empty struct which simply tells the compiler which image read function to use.

		e.g. GD::Image img(input, GD::Jpeg_tag()); // read a jpeg file from input

		\param[in] in The io context from which to read the image data

	*/

	Image(gdIOCtx * in, Jpeg_tag)

		:im(0) {

		CreateFromJpeg(in);

	}

	/** Construct an image by reading from memory block \p data.

		The tag is an empty struct which simply tells the compiler which image read function to use.

		e.g. GD::Image img(sz, dat, GD::Jpeg_tag()); // read a jpeg file from dat

		\param[in] size The byte count of the memory block

		\param[in] data Pointer to the memory block

	*/

	Image(int size, void * data, Jpeg_tag)

		:im(0) {

		CreateFromJpeg(size, data);

	}

#endif

	/** Construct an image by reading from \p in.

		The tag is an empty struct which simply tells the compiler which image read function to use.

		e.g. GD::Image img(input, GD::Gd_tag()); // read a gd file from input

		\param[in] in The stream containing the image data

	*/

	Image(std::istream & in, Gd_tag)

		:im(0) {

		CreateFromGd(in);

	}

	/** Construct an image by reading from \p in.

		The tag is an empty struct which simply tells the compiler which image read function to use.

		e.g. GD::Image img(input, GD::Gd_tag()); // read a gd file from input

		\param[in] in An opened FILE * handle to a file containing the image data

	*/

	Image(FILE * in, Gd_tag)

		:im(0) {

		CreateFromGd(in);

	}

	/** Construct an image by reading from \p in.

		The tag is an empty struct which simply tells the compiler which image read function to use.

		e.g. GD::Image img(input, GD::Gd_tag()); // read a gd file from input

		\param[in] in The io context from which to read the image data

	*/

	Image(gdIOCtx * in, Gd_tag)

		:im(0) {

		CreateFromGd(in);

	}

	/** Construct an image by reading from memory block \p data.

		The tag is an empty struct which simply tells the compiler which image read function to use.

		e.g. GD::Image img(sz, dat, GD::Gd_tag()); // read a gd file from dat

		\param[in] size The byte count of the memory block

		\param[in] data Pointer to the memory block

	*/

	Image(int size, void * data, Gd_tag)

		:im(0) {

		CreateFromGd(size, data);

	}

	/** Construct an image by reading from \p in.

		The tag is an empty struct which simply tells the compiler which image read function to use.

		e.g. GD::Image img(input, GD::Gd2_tag()); // read a gd2 file from input

		\param[in] in The stream containing the image data

	*/

	Image(std::istream & in, Gd2_tag)

		:im(0) {

		CreateFromGd2(in);

	}

	/** Construct an image by reading from \p in.

		The tag is an empty struct which simply tells the compiler which image read function to use.

		e.g. GD::Image img(input, GD::Png_tag()); // read a png file from input

		\param[in] in An opened FILE * handle to a file containing the image data

	*/

	Image(FILE * in, Gd2_tag)

		:im(0) {

		CreateFromGd2(in);

	}

	/** Construct an image by reading from \p in.

		The tag is an empty struct which simply tells the compiler which image read function to use.

		e.g. GD::Image img(input, GD::Gd2_tag()); // read a gd2 file from input

		\param[in] in The io context from which to read the image data

	*/

	Image(gdIOCtx * in, Gd2_tag)

		:im(0) {

		CreateFromGd2(in);

	}

	/** Construct an image by reading from memory block \p data.

		The tag is an empty struct which simply tells the compiler which image read function to use.

		e.g. GD::Image img(sz, dat, GD::Gd2_tag()); // read a gd2 file from dat

		\param[in] size The byte count of the memory block

		\param[in] data Pointer to the memory block

	*/

	Image(int size, void * data, Gd2_tag)

		:im(0) {

		CreateFromGd2(size, data);

	}

	/** Construct an image by reading from \p in.

		The tag is an empty struct which simply tells the compiler which image read function to use.

		e.g. GD::Image img(input, GD::Xbm_tag()); // read an xbm file from input

		\param[in] in An opened FILE * handle to a file containing the image data

	*/

	Image(FILE * in, Xbm_tag)

		:im(0) {

		CreateFromXbm(in);

	}

	~Image() {

		clear();

	}

	/** Assignment Operator. Make this a copy of the GD::Image provided.

		\param[in] src Reference to the image to be copied

	*/

	GD::Image & operator=(const GD::Image & src) {

		Copy(src);

		return (* this);

	}

	/** Make this an exact copy of the GD::Image provided.  Any existing iamge data is discarded.

		\param[in] src Reference to the image to be copied

	*/

	void Copy(const GD::Image & src) {

		int w = src.Width(), h = src.Height();

		if (src.IsTrueColor())

			CreateTrueColor(w, h);

		else {

			Create(w, h);

			PaletteCopy(src);

		}

		Copy(src, 0, 0, 0, 0, w, h);

	}

	/** Check to see if this appears to be a valid image

	*/

	bool good() const {

		return (im != 0);

	}

	// Creation:

	/**

		Create a palette-based image, with no more than 256 colors.

		\param sx Width of the desired image

		\param sy Height of the desired image

		\return true if it worked, else false

	*/

	bool Create(int sx, int sy) {

		clear();

		return ((im = gdImageCreate(sx, sy)) != 0);

	}

	/**

		Create a truecolor image.

		\param sx Width of the desired image

		\param sy Height of the desired image

		\return true if it worked, else false

	*/

	bool CreateTrueColor(int sx, int sy) {

		clear();

		return ((im = gdImageCreateTrueColor(sx, sy)) != 0);

	}

	/**

		Create a palette-based image, with no more than 256 colors.

		\param s Width and height of the desired image

		\return true if it worked, else false

	*/

	bool Create(const Size & s) {

		return Create(s.W(), s.H());

	}

	/**

		Create a truecolor image.

		\param s Width and height of the desired image

		\return true if it worked, else false

	*/

	bool CreateTrueColor(const Size & s) {

		return CreateTrueColor(s.W(), s.H());

	}

	// Create, determining the image format from the data

	/// Read an image from an open FILE * handle, after determining the image format

	bool CreateFrom(FILE * in);

	/// Read an image from an open standard library input stream, after determining the image format

	bool CreateFrom(std::istream & in);

	/// Read an image from a memory block, after determining the image format

	bool CreateFrom(int size, void * data);

#ifdef HAVE_LIBPNG

	// Png

	bool CreateFromPng(FILE * in) {

		clear();

		return ((im = gdImageCreateFromPng(in)) != 0);

	}

	bool CreateFromPng(gdIOCtx * in) {

		clear();

		return ((im = gdImageCreateFromPngCtx(in)) != 0);

	}

	bool CreateFromPng(int size, void * data) {

		clear();

		return ((im = gdImageCreateFromPngPtr(size, data)) != 0);

	}

	bool CreateFromPng(std::istream & in) {

		clear();

		istreamIOCtx _in_ctx(in);

		return ((im = gdImageCreateFromPngCtx( & _in_ctx)) != 0);

	}

#endif

	// Gif

	bool CreateFromGif(FILE * in) {

		clear();

		return ((im = gdImageCreateFromGif(in)) != 0);

	}

	bool CreateFromGif(gdIOCtx * in) {

		clear();

		return ((im = gdImageCreateFromGifCtx(in)) != 0);

	}

	bool CreateFromGif(int size, void * data) {

		clear();

		return ((im = gdImageCreateFromGifPtr(size, data)) != 0);

	}

	bool CreateFromGif(std::istream & in) {

		clear();

		istreamIOCtx _in_ctx(in);

		return ((im = gdImageCreateFromGifCtx( & _in_ctx)) != 0);

	}

	// WBMP

	bool CreateFromWBMP(FILE * in) {

		clear();

		return ((im = gdImageCreateFromWBMP(in)) != 0);

	}

	bool CreateFromWBMP(gdIOCtx * in) {

		clear();

		return ((im = gdImageCreateFromWBMPCtx(in)) != 0);

	}

	bool CreateFromWBMP(int size, void * data) {

		clear();

		return ((im = gdImageCreateFromWBMPPtr(size, data)) != 0);

	}

	bool CreateFromWBMP(std::istream & in) {

		clear();

		istreamIOCtx _in_ctx(in);

		return ((im = gdImageCreateFromWBMPCtx( & _in_ctx)) != 0);

	}

#ifdef HAVE_LIBJPEG

	// Jpeg

	/**

		Load a truecolor image from a JPEG format file.

		Invoke CreateFromJpeg with an already opened

		pointer to a file containing the desired image.

		CreateFromJpeg does not close the file.

		\return true for success, or false if unable to load the image (most often because

		the file is corrupt or does not contain a JPEG image).

		You can call Width() and Height() member functions of the image to determine its

		size. The returned image is always a truecolor image.

	*/

	bool CreateFromJpeg(FILE * in) {

		clear();

		return ((im = gdImageCreateFromJpeg(in)) != 0);

	}

	/**

		Load a truecolor image from a JPEG format file.

		Invoke CreateFromJpeg with an already opened

		pointer to a file containing the desired image.

		CreateFromJpeg does not close the file.

		\return true for success, or false if unable to load the image (most often because the file is corrupt or does not contain a JPEG image).

		You can call Width() and Height() member functions of the image to determine its

		size. The returned image is always a truecolor image.

	*/

	bool CreateFromJpeg(gdIOCtx * in) {

		clear();

		return ((im = gdImageCreateFromJpegCtx(in)) != 0);

	}

	/**

		Load a truecolor image from a JPEG format file.

		Invoke CreateFromJpeg with an already opened

		pointer to a file containing the desired image.

		CreateFromJpeg does not close the file.

		\return true for success, or false if unable to load the image (most often because the file is corrupt or does not contain a JPEG image).

		You can call Width() and Height() member functions of the image to determine its

		size. The returned image is always a truecolor image.

	*/

	bool CreateFromJpeg(int size, void * data) {

		clear();

		return ((im = gdImageCreateFromJpegPtr(size, data)) != 0);

	}

	/**

		Load a truecolor image from a JPEG format file.

		Invoke CreateFromJpeg with an image file in memory.

		\return true for success, or false if unable to load the image (most often because the format is corrupt or does not contain a JPEG image).

		You can call Width() and Height() member functions of the image to determine its

		size. The returned image is always a truecolor image.

	*/

	bool CreateFromJpeg(std::istream & in) {

		clear();

		istreamIOCtx _in_ctx(in);

		return ((im = gdImageCreateFromJpegCtx( & _in_ctx)) != 0);

	}

#endif

	// Gd

	bool CreateFromGd(FILE * in) {

		clear();

		return ((im = gdImageCreateFromGd(in)) != 0);

	}

	bool CreateFromGd(gdIOCtx * in) {

		clear();

		return ((im = gdImageCreateFromGdCtx(in)) != 0);

	}

	bool CreateFromGd(int size, void * data) {

		clear();

		return ((im = gdImageCreateFromGdPtr(size, data)) != 0);

	}

	bool CreateFromGd(std::istream & in) {

		clear();

		istreamIOCtx _in_ctx(in);

		return ((im = gdImageCreateFromGdCtx( & _in_ctx)) != 0);

	}

	// Gd2

	bool CreateFromGd2(FILE * in) {

		clear();

		return ((im = gdImageCreateFromGd2(in)) != 0);

	}

	bool CreateFromGd2(gdIOCtx * in) {

		clear();

		return ((im = gdImageCreateFromGd2Ctx(in)) != 0);

	}

	bool CreateFromGd2(int size, void * data) {

		clear();

		return ((im = gdImageCreateFromGd2Ptr(size, data)) != 0);

	}

	bool CreateFromGd2(std::istream & in) {

		clear();

		istreamIOCtx _in_ctx(in);

		return ((im = gdImageCreateFromGd2Ctx( & _in_ctx)) != 0);

	}

	// Gd2 Part

	bool CreateFromGd2Part(FILE * in, int srcx, int srcy, int w, int h) {

		clear();

		return ((im = gdImageCreateFromGd2Part(in, srcx, srcy, w, h)) != 0);

	}

	bool CreateFromGd2Part(gdIOCtx * in, int srcx, int srcy, int w, int h) {

		clear();

		return ((im = gdImageCreateFromGd2PartCtx(in, srcx, srcy, w, h)) != 0);

	}

	bool CreateFromGd2Part(int size, void * data, int srcx, int srcy, int w, int h) {

		clear();

		return ((im = gdImageCreateFromGd2PartPtr(size, data, srcx, srcy, w, h)) != 0);

	}

	bool CreateFromGd2Part(std::istream & in, int srcx, int srcy, int w, int h) {

		clear();

		istreamIOCtx _in_ctx(in);

		return ((im = gdImageCreateFromGd2PartCtx( & _in_ctx, srcx, srcy, w, h)) != 0);

	}

	bool CreateFromGd2Part(FILE * in, const Point & src, const Size & s) {

		return CreateFromGd2Part(in, src.X(), src.Y(), s.W(), s.H());

	}

	bool CreateFromGd2Part(gdIOCtx * in, const Point & src, const Size & s) {

		return CreateFromGd2Part(in, src.X(), src.Y(), s.W(), s.H());

	}

	bool CreateFromGd2Part(int size, void * data, const Point & src, const Size & s) {

		return CreateFromGd2Part(size, data, src.X(), src.Y(), s.W(), s.H());

	}

	bool CreateFromGd2Part(std::istream & in, const Point & src, const Size & s) {

		return CreateFromGd2Part(in, src.X(), src.Y(), s.W(), s.H());

	}

	// Xbm

	bool CreateFromXbm(FILE * in) {

		clear();

		return ((im = gdImageCreateFromXbm(in)) != 0);

	}

	// Xpm

	bool CreateFromXpm(char * filename) {

		clear();

		return ((im = gdImageCreateFromXpm(filename)) != 0);

	}

	bool CreateFromXpm(std::string & filename) {

		return CreateFromXpm((char *)(filename.c_str()));

	}

	// Accessors, Updaters & Methods:

	void SetPixel(int x, int y, int color) {

		gdImageSetPixel(im, x, y, color);

	}

	void SetPixel(const Point & p, int color) {

		SetPixel(p.X(), p.Y(), color);

	}

	int GetPixel(int x, int y) const {

		return gdImageGetPixel(im, x, y);

	}

	int GetPixel(const Point & p) const {

		return GetPixel(p.X(), p.Y());

	}

	int GetTrueColorPixel(int x, int y) const {

		return gdImageGetTrueColorPixel(im, x, y);

	}

	int GetTrueColorPixel(const Point & p) const {

		return GetTrueColorPixel(p.X(), p.Y());

	}

	void SetPixel(int x, int y, TrueColor c) {

		SetPixel(x, y, c.Int());

	}

	void SetPixel(const Point & p, TrueColor c) {

		SetPixel(p.X(), p.Y(), c.Int());

	}

	void GetTrueColorPixel(TrueColor & c, int x, int y) const {

		c.set(GetTrueColorPixel(x, y));

	}

	void GetTrueColorPixel(TrueColor & c, const Point & p) const {

		c.set(GetTrueColorPixel(p.X(), p.Y()));

	}

	void AABlend() {

		gdImageAABlend(im);

	}

	void Line(int x1, int y1, int x2, int y2, int color) {

		gdImageLine(im, x1, y1, x2, y2, color);

	}

	void Line(const Point & p1, const Point & p2, int color) {

		Line(p1.X(), p1.Y(), p2.X(), p2.Y(), color);

	}

	void Rectangle(int x1, int y1, int x2, int y2, int color) {

		gdImageRectangle(im, x1, y1, x2, y2, color);

	}

	void Rectangle(const Point & p1, const Point & p2, int color) {

		Rectangle(p1.X(), p1.Y(), p2.X(), p2.Y(), color);

	}

	void Rectangle(const Point & p, const Size & s, int color) {

		Rectangle(p.X(), p.Y(), p.X() + s.W(), p.Y() + s.H(), color);

	}

	void FilledRectangle(int x1, int y1, int x2, int y2, int color) {

		gdImageFilledRectangle(im, x1, y1, x2, y2, color);

	}

	void FilledRectangle(const Point & p1, const Point & p2, int color) {

		FilledRectangle(p1.X(), p1.Y(), p2.X(), p2.Y(), color);

	}

	void FilledRectangle(const Point & p, const Size & s, int color) {

		FilledRectangle(p.X(), p.Y(), p.X() + s.W(), p.Y() + s.H(), color);

	}

	void SetClip(int x1, int y1, int x2, int y2) {

		gdImageSetClip(im, x1, y1, x2, y2);

	}

	void SetClip(const Point & p1, const Point & p2) {

		SetClip(p1.X(), p1.Y(), p2.X(), p2.Y());

	}

	void SetClip(const Point & p, const Size & s) {

		SetClip(p.X(), p.Y(), p.X() + s.W(), p.Y() + s.H());

	}

	void GetClip(int & x1, int & y1, int & x2, int & y2) const {

		gdImageGetClip(im, & x1, & y1, & x2, & y2);

	}

	void GetClip(Point & p1, Point & p2) const {

		GetClip(p1.lhsX(), p1.lhsY(), p2.lhsX(), p2.lhsY());