/****************************************************************************
**
** Definition of TQImage and TQImageIO classes
**
** Created : 950207
**
** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
**
** This file is part of the kernel module of the TQt GUI Toolkit.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
** Software Foundation and appearing in the files LICENSE.GPL2
** and LICENSE.GPL3 included in the packaging of this file.
** Alternatively you may (at your option) use any later version
** of the GNU General Public License if such license has been
** publicly approved by Trolltech ASA (or its successors, if any)
** and the KDE Free TQt Foundation.
**
** Please review the following information to ensure GNU General
** Public Licensing requirements will be met:
** http://trolltech.com/products/qt/licenses/licensing/opensource/.
** If you are unsure which license is appropriate for your use, please
** review the following information:
** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
** or contact the sales department at sales@trolltech.com.
**
** This file may be used under the terms of the Q Public License as
** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
** included in the packaging of this file.  Licensees holding valid TQt
** Commercial licenses may use this file in accordance with the TQt
** Commercial License Agreement provided with the Software.
**
** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
** herein.
**
**********************************************************************/

#ifndef TQIMAGE_H
#define TQIMAGE_H

#include "tqtglobaldefines.h"

#ifndef TQT_H
#include "tqpixmap.h"
#include "tqstrlist.h"
#include "tqstringlist.h"
#endif // TQT_H

#ifdef USE_QT4

#include <Qt/qbitmap.h>
#include <Qt/qstringlist.h>
#include <Qt/qimagereader.h>
#include <Qt/qimagewriter.h>

#endif // USE_QT4

#ifdef USE_QT4

#ifndef TQT_NO_IMAGE_TEXT
class TQ_EXPORT TQImageTextKeyLang : public QImageTextKeyLang, virtual public TQt {
public:
	TQImageTextKeyLang(const char* k, const char* l) : QImageTextKeyLang(k, l) { }
	TQImageTextKeyLang() : QImageTextKeyLang() { }

	bool operator< (const TQImageTextKeyLang& other) const { return key < other.key || (key==other.key && lang < other.lang); }
	bool operator== (const TQImageTextKeyLang& other) const { return key==other.key && lang==other.lang; }

	// Interoperability
	static const TQImageTextKeyLang& convertFromQImageTextKeyLang( QImageTextKeyLang& qbr );
};

// Interoperability
inline static const TQImageTextKeyLang& convertFromQImageTextKeyLang( const QImageTextKeyLang& qbr ) {
	return (*static_cast<const TQImageTextKeyLang*>(&qbr));
}
#endif //TQT_NO_IMAGE_TEXT

class TQ_EXPORT TQImage : public QImage, virtual public TQt
{
public:
	enum Endian { IgnoreEndian, BigEndian, LittleEndian };

	QImage::Format formatFor(int depth, Endian bitOrder);

	TQImage() : QImage() { jumptable=NULL; }
	TQImage( int width, int height, int depth, int numColors=0, Endian bitOrder=IgnoreEndian ) : QImage( width, height, formatFor(depth, bitOrder) ) { jumptable=NULL; setColorCount(numColors); }
	TQImage( const QSize&ts, int depth, int numColors=0, Endian bitOrder=IgnoreEndian ) : QImage( ts, formatFor(depth, bitOrder) ) { jumptable=NULL; setColorCount(numColors); }
#ifndef TQT_NO_IMAGEIO
	TQImage( const QString &fileName, const char* format=0 ) : QImage( fileName, format ) { jumptable=NULL; }
	TQImage( const char * const xpm[] ) : QImage( xpm ) { jumptable=NULL; }
// 	TQImage( const QByteArray &data ) : QImage( data ) {}
#endif
	TQImage( uchar* data, int w, int h, int depth, QRgb* colortable, int numColors, Endian bitOrder ) : QImage( data, w, h, formatFor(depth, bitOrder) ) {
		jumptable=NULL;
		setColorCount(numColors);
		if (colortable) {
			setColorCount(numColors);
			for (int i = 0; i < numColors; ++i) {
				setColor(i, colortable[i]);
			}
		}
	}
// 	~TQImage();

#ifndef TQT_NO_IMAGE_HEURISTIC_MASK
	TQImage createHeuristicMask( bool clipTight=TRUE ) const;
#endif

	Endian bitOrder() const {
		Format f = format();
		return f == Format_Mono ? BigEndian : (f == Format_MonoLSB ? LittleEndian : IgnoreEndian);
	}
#ifdef TQ_WS_TQWS
	TQImage( uchar* data, int w, int h, int depth, int pbl, QRgb* colortable, int numColors, Endian bitOrder ) : QImage( data, w, h, depth, pbl, colortable, numColors, bitOrder ) { jumptable=NULL; }
#endif
	TQImage( const QImage &im ) : QImage( im ) { jumptable=NULL; }

// 	static TQStrList inputFormats() { return TQT_TQSTRLIST_OBJECT(QImageReader::supportedImageFormats()); }
// 	static TQStrList outputFormats() { return TQT_TQSTRLIST_OBJECT(QImageWriter::supportedImageFormats()); }

	inline TQImage smoothScale(int w, int h, AspectRatioMode mode = IgnoreAspectRatio) const { return scaled(QSize(w, h), (Qt::AspectRatioMode)mode, Qt::SmoothTransformation); }
	inline TQImage smoothScale(const QSize &s, AspectRatioMode mode = IgnoreAspectRatio) const { return scaled(s, (Qt::AspectRatioMode)mode, Qt::SmoothTransformation); }
	inline TQImage swapRGB() const { return rgbSwapped(); }
	inline TQImage mirror(bool horizontally = false, bool vertically = true) const { return mirrored(horizontally, vertically); }

#ifndef TQT_NO_IMAGE_TRANSFORMATION
	inline TQImage scale( int w, int h, ScaleMode mode=ScaleFree ) const { return scaled(QSize(w, h), (Qt::AspectRatioMode)mode, Qt::FastTransformation); }
	inline TQImage scale( const TQSize& s, ScaleMode mode=ScaleFree ) const { return scaled(s, (Qt::AspectRatioMode)mode, Qt::FastTransformation); }
	inline TQImage scaleWidth( int w ) const { return scaledToWidth(w, Qt::FastTransformation); }
	inline TQImage scaleHeight( int h ) const { return scaledToHeight(h, Qt::FastTransformation); }
	inline TQImage xForm(const QMatrix &matrix) const { return transformed(QTransform(matrix)); }
#endif

	TQImage convertDepth(int, Qt::ImageConversionFlags flags = Qt::AutoColor) const;
 	TQImage convertDepthWithPalette(int, QRgb* p, int pc, Qt::ImageConversionFlags flags = Qt::AutoColor) const;
	TQImage convertBitOrder(Endian) const;

	inline void tqinvertPixels( bool invertAlpha = TRUE ) { if (invertAlpha) invertPixels(InvertRgba); else invertPixels(InvertRgb); }

	bool hasAlphaBuffer() const;
	void setAlphaBuffer(bool);

	static inline Endian systemByteOrder() { return QSysInfo::ByteOrder == QSysInfo::BigEndian ? BigEndian : LittleEndian; }
	static Endian systemBitOrder();

	uchar **jumpTable();
	const uchar * const *jumpTable() const;

	bool create( int width, int height, int depth, int numColors=0, Endian bitOrder=IgnoreEndian );
	bool create( const TQSize&, int depth, int numColors=0, Endian bitOrder=IgnoreEndian );
	inline void reset() { *this = QImage(); }

	inline TQValueList<TQImageTextKeyLang> tqtextList() const {
		QList<QImageTextKeyLang> qs = textList();
		TQValueList<TQImageTextKeyLang> qn;
		for (int i = 0; i < qs.size(); ++i) qn.append(convertFromQImageTextKeyLang(qs.at(i)));
		return qn;
	}

	inline TQRgb *tqcolorTable() const {
		return colorTable().data();
	}

#ifndef TQT_NO_IMAGEIO
	static const char* imageFormat( const TQString &fileName );
	static TQStrList inputFormats();
	static TQStrList outputFormats();
#ifndef TQT_NO_STRINGLIST
	static TQStringList inputFormatList();
	static TQStringList outputFormatList();
#endif
	bool	load( const TQString &fileName, const char* format=0 );
	bool	loadFromData( const uchar *buf, uint len, const char *format=0 );
	bool	loadFromData( TQByteArray data, const char* format=0 );
	bool	save( const TQString &fileName, const char* format, int quality=-1 ) const;
	bool	save( QIODevice * tqdevice, const char* format, int quality=-1 ) const;
#endif //TQT_NO_IMAGEIO

private:
	mutable uchar **jumptable;
	void reinit();
	void freeBits();
#ifndef TQT_NO_IMAGEIO
	bool doImageIO( TQImageIO* io, int quality ) const;
#endif

public:
	// Interoperability
	static const TQImage& convertFromQImage( QImage& qi );

	using QImage::operator=;
};

// Interoperability
inline static const TQImage& convertFromQImage( const QImage& qi ) {
	return (*static_cast<const TQImage*>(&qi));
}

#if 0
typedef void (*image_io_handler)( TQImageIO * ); // image IO handler

class TQ_EXPORT TQImageIO : public QImageReader, public QImageWriter, virtual public TQt
{
public:
	TQImageIO() : QImageReader(), QImageWriter() {}
	TQImageIO( QIODevice *ioDevice, const char *format ) : QImageReader( ioDevice, format ), QImageWriter( ioDevice, format ) {}
	TQImageIO( const QString &fileName, const char* format ) : QImageReader( fileName, format ), QImageWriter( fileName, format ) {}

	static TQStrList inputFormats() { return TQT_TQSTRLIST_OBJECT(QImageReader::supportedImageFormats()); }
	static TQStrList outputFormats() { return TQT_TQSTRLIST_OBJECT(QImageWriter::supportedImageFormats()); }

	inline void setImage( const QImage &qi ) { internalImage = qi; }
	inline bool write() { return QImageWriter::write( internalImage ); }
	inline bool read() { if (QImageReader::read().isNull() == true) return false; else return true; }
	inline int quality() const { return QImageWriter::quality(); }
	inline const TQImage &image() { return TQT_TQIMAGE_OBJECT(QImageReader::read()); }

	inline static void defineIOHandler( const char *format, const char *header, const char *flags, image_io_handler read_image, image_io_handler write_image ) {
		// [FIXME] Is this now automatic in Qt4??
		TQ_UNUSED(format);
		TQ_UNUSED(header);
		TQ_UNUSED(flags);
		TQ_UNUSED(read_image);
		TQ_UNUSED(write_image);
		printf("[WARNING] static void defineIOHandler( const char *format, const char *header, const char *flags, image_io_handler read_image, image_io_handler write_image ) unimplemented\n\r");
	}

	void setqStatus( int );
	inline TQIODevice *ioDevice() const { if (QImageReader::device() != 0) return static_cast<TQIODevice*>(QImageReader::device()); else return static_cast<TQIODevice*>(QImageWriter::device()); }
	inline const char *format() const { if (QImageReader::format() != "") return QImageReader::format(); else return QImageWriter::format(); }
	inline TQString fileName() const { if (QImageReader::fileName() != "") return QImageReader::fileName(); else return QImageWriter::fileName(); }
	inline const char *parameters() const { printf("[WARNING] const char *parameters() const unimplemented\n\r"); return 0; }
	inline void setFileName( const QString &qs ) { QImageReader::setFileName(qs); QImageWriter::setFileName(qs); }
	inline void setQuality( int ql ) { QImageReader::setQuality(ql); QImageWriter::setQuality(ql); }
	inline void setIODevice( TQIODevice *tqiod ) { QImageReader::setDevice(tqiod); QImageWriter::setDevice(tqiod); }
	inline void setParameters( const char * ) { printf("[WARNING] void setParameters(const char *) unimplemented\n\r"); }
	inline void setFormat( const char * format ) { QImageReader::setFormat(format); QImageWriter::setFormat(format); }

private:
	QImage internalImage;
};
#else
class TQIODevice;
typedef void (*image_io_handler)( TQImageIO * ); // image IO handler


struct TQImageIOData;


class TQ_EXPORT TQImageIO
{
public:
    TQImageIO();
    TQImageIO( QIODevice *ioDevice, const char *format );
    TQImageIO( const TQString &fileName, const char* format );
   ~TQImageIO();


    const TQImage &image()	const	{ return im; }
    int		status()	const	{ return iostat; }
    const char *format()	const	{ return frmt; }
    TQIODevice  *ioDevice()	const	{ return iodev; }
    TQString	fileName()	const	{ return fname; }
    int		quality()	const;
    TQString	description()	const	{ return descr; }
    const char *parameters()	const;
    float gamma() const;

    void	setImage( const QImage & );
    void	setqStatus( int );
    void	setFormat( const char * );
    void	setIODevice( TQIODevice * );
    void	setFileName( const TQString & );
    void	setQuality( int );
    void	setDescription( const TQString & );
    void	setParameters( const char * );
    void	setGamma( float );

    bool	read();
    bool	write();

    static const char* imageFormat( const TQString &fileName );
    static const char *imageFormat( TQIODevice * );
    static TQStrList inputFormats();
    static TQStrList outputFormats();

    static void defineIOHandler( const char *format,
				 const char *header,
				 const char *flags,
				 image_io_handler read_image,
				 image_io_handler write_image );

private:
    void	init();

    TQImage	im;				// image
    int		iostat;				// IO status
    TQCString	frmt;				// image format
    TQIODevice  *iodev;				// IO tqdevice
    TQString	fname;				// file name
    char       *params;				// image parameters //### change to TQImageIOData *d in 3.0
    TQString     descr;				// image description
    TQImageIOData *d;

private:	// Disabled copy constructor and operator=
#if defined(TQ_DISABLE_COPY)
    TQImageIO( const TQImageIO & );
    TQImageIO &operator=( const TQImageIO & );
#endif
};
#endif

#else // USE_QT4

class TQImageDataMisc; // internal
#ifndef TQT_NO_IMAGE_TEXT
class TQ_EXPORT TQImageTextKeyLang {
public:
    TQImageTextKeyLang(const char* k, const char* l) : key(k), lang(l) { }
    TQImageTextKeyLang() { }

    TQCString key;
    TQCString lang;

    bool operator< (const TQImageTextKeyLang& other) const
	{ return key < other.key || (key==other.key && lang < other.lang); }
    bool operator== (const TQImageTextKeyLang& other) const
	{ return key==other.key && lang==other.lang; }
};
#endif //TQT_NO_IMAGE_TEXT


class TQ_EXPORT TQImage
{
public:
    enum Endian { IgnoreEndian, BigEndian, LittleEndian };

    TQImage();
    TQImage( int width, int height, int depth, int numColors=0,
	    Endian bitOrder=IgnoreEndian );
    TQImage( const TQSize&, int depth, int numColors=0,
	    Endian bitOrder=IgnoreEndian );
#ifndef TQT_NO_IMAGEIO
    TQImage( const TQString &fileName, const char* format=0 );
    TQImage( const char * const xpm[] );
    TQImage( const TQByteArray &data );
#endif
    TQImage( uchar* data, int w, int h, int depth,
		TQRgb* colortable, int numColors,
		Endian bitOrder );
#ifdef TQ_WS_TQWS
    TQImage( uchar* data, int w, int h, int depth, int pbl,
		TQRgb* colortable, int numColors,
		Endian bitOrder );
#endif
    TQImage( const TQImage & );
   ~TQImage();

    TQImage     &operator=( const TQImage & );
    TQImage     &operator=( const TQPixmap & );
    bool	operator==( const TQImage & ) const;
    bool	operator!=( const TQImage & ) const;
    void	detach();
    TQImage	copy()		const;
    TQImage	copy(int x, int y, int w, int h, int conversion_flags=0) const;
    TQImage	copy(const TQRect&)	const;
#ifndef TQT_NO_MIME
    static TQImage fromMimeSource( const TQString& abs_name );
#endif
    bool	isNull()	const	{ return data->bits == 0; }

    int		width()		const	{ return data->w; }
    int		height()	const	{ return data->h; }
    TQSize	size()		const	{ return TQSize(data->w,data->h); }
    TQRect	rect()		const	{ return TQRect(0,0,data->w,data->h); }
    int		depth()		const	{ return data->d; }
    int		numColors()	const	{ return data->ncols; }
    Endian	bitOrder()	const	{ return (Endian) data->bitordr; }

    TQRgb	color( int i )	const;
    void	setColor( int i, TQRgb c );
    void	setNumColors( int );

    bool	hasAlphaBuffer() const;
    void	setAlphaBuffer( bool );

    bool	allGray() const;
    bool        isGrayscale() const;

    uchar      *bits()		const;
    uchar      *scanLine( int ) const;
    uchar     **jumpTable()	const;
    TQRgb       *colorTable()	const;
    int		numBytes()	const;
    int		bytesPerLine()	const;

#ifdef TQ_WS_TQWS
    TQGfx * graphicsContext();
#endif

    bool	create( int width, int height, int depth, int numColors=0,
			Endian bitOrder=IgnoreEndian );
    bool	create( const TQSize&, int depth, int numColors=0,
			Endian bitOrder=IgnoreEndian );
    void	reset();

    void	fill( uint pixel );
    void	invertPixels( bool invertAlpha = TRUE );

    TQImage	convertDepth( int ) const;
#ifndef TQT_NO_IMAGE_TRUECOLOR
    TQImage	convertDepthWithPalette( int, TQRgb* p, int pc, int cf=0 ) const;
#endif
    TQImage	convertDepth( int, int conversion_flags ) const;
    TQImage	convertBitOrder( Endian ) const;

    enum ScaleMode {
	ScaleFree,
	ScaleMin,
	ScaleMax
    };
#ifndef TQT_NO_IMAGE_SMOOTHSCALE
    TQImage smoothScale( int w, int h, ScaleMode mode=ScaleFree ) const;
    TQImage smoothScale( const TQSize& s, ScaleMode mode=ScaleFree ) const;
#endif
#ifndef TQT_NO_IMAGE_TRANSFORMATION
    TQImage scale( int w, int h, ScaleMode mode=ScaleFree ) const;
    TQImage scale( const TQSize& s, ScaleMode mode=ScaleFree ) const;
    TQImage scaleWidth( int w ) const;
    TQImage scaleHeight( int h ) const;
    TQImage xForm( const TQWMatrix &matrix ) const;
#endif

#ifndef TQT_NO_IMAGE_DITHER_TO_1
    TQImage	createAlphaMask( int conversion_flags=0 ) const;
#endif
#ifndef TQT_NO_IMAGE_HEURISTIC_MASK
    TQImage	createHeuristicMask( bool clipTight=TRUE ) const;
#endif
#ifndef TQT_NO_IMAGE_MIRROR
    TQImage	mirror() const;
    TQImage	mirror(bool horizontally, bool vertically) const;
#endif
    TQImage	swapRGB() const;

    static Endian systemBitOrder();
    static Endian systemByteOrder();

#ifndef TQT_NO_IMAGEIO
    static const char* imageFormat( const TQString &fileName );
    static TQStrList inputFormats();
    static TQStrList outputFormats();
#ifndef TQT_NO_STRINGLIST
    static TQStringList inputFormatList();
    static TQStringList outputFormatList();
#endif
    bool	load( const TQString &fileName, const char* format=0 );
    bool	loadFromData( const uchar *buf, uint len,
			      const char *format=0 );
    bool	loadFromData( TQByteArray data, const char* format=0 );
    bool	save( const TQString &fileName, const char* format,
		      int quality=-1 ) const;
    bool	save( TQIODevice * tqdevice, const char* format,
		      int quality=-1 ) const;
#endif //TQT_NO_IMAGEIO

    bool	valid( int x, int y ) const;
    int		pixelIndex( int x, int y ) const;
    TQRgb	pixel( int x, int y ) const;
    void	setPixel( int x, int y, uint index_or_rgb );

    // Auxiliary data
    int dotsPerMeterX() const;
    int dotsPerMeterY() const;
    void setDotsPerMeterX(int);
    void setDotsPerMeterY(int);
    TQPoint offset() const;
    void setOffset(const TQPoint&);
#ifndef TQT_NO_IMAGE_TEXT
    TQValueList<TQImageTextKeyLang> textList() const;
    TQStringList textLanguages() const;
    TQStringList textKeys() const;
    TQString text(const char* key, const char* lang=0) const;
    TQString text(const TQImageTextKeyLang&) const;
    void setText(const char* key, const char* lang, const TQString&);
#endif
private:
    void	init();
    void	reinit();
    void	freeBits();
    static void	warningIndexRange( const char *, int );

    struct TQImageData : public TQShared {	// internal image data
	int	w;				// image width
	int	h;				// image height
	int	d;				// image depth
	int	ncols;				// number of colors
	int	nbytes;				// number of bytes data
	int	bitordr;			// bit order (1 bit depth)
	TQRgb   *ctbl;				// color table
	uchar **bits;				// image data
	bool	alpha;				// alpha buffer
	int	dpmx;				// dots per meter X (or 0)
	int	dpmy;				// dots per meter Y (or 0)
	TQPoint	offset;				// offset in pixels
#ifndef TQT_NO_IMAGE_TEXT
	TQImageDataMisc* misc;			// less common stuff
#endif
	bool    ctbl_mine;			// this allocated ctbl
    } *data;
#ifndef TQT_NO_IMAGE_TEXT
    TQImageDataMisc& misc() const;
#endif
#ifndef TQT_NO_IMAGEIO
    bool doImageIO( TQImageIO* io, int quality ) const;
#endif
    friend TQ_EXPORT void bitBlt( TQImage* dst, int dx, int dy,
				 const TQImage* src, int sx, int sy,
				 int sw, int sh, int conversion_flags );
};


// TQImage stream functions

#if !defined(TQT_NO_DATASTREAM) && !defined(TQT_NO_IMAGEIO)
TQ_EXPORT TQDataStream &operator<<( TQDataStream &, const TQImage & );
TQ_EXPORT TQDataStream &operator>>( TQDataStream &, TQImage & );
#endif

#ifndef TQT_NO_IMAGEIO
class TQIODevice;
typedef void (*image_io_handler)( TQImageIO * ); // image IO handler


struct TQImageIOData;


class TQ_EXPORT TQImageIO
{
public:
    TQImageIO();
    TQImageIO( TQIODevice	 *ioDevice, const char *format );
    TQImageIO( const TQString &fileName, const char* format );
   ~TQImageIO();


    const TQImage &image()	const	{ return im; }
    int		status()	const	{ return iostat; }
    const char *format()	const	{ return frmt; }
    TQIODevice  *ioDevice()	const	{ return iodev; }
    TQString	fileName()	const	{ return fname; }
    int		quality()	const;
    TQString	description()	const	{ return descr; }
    const char *parameters()	const;
    float gamma() const;

    void	setImage( const TQImage & );
    void	setqStatus( int );
    void	setFormat( const char * );
    void	setIODevice( TQIODevice * );
    void	setFileName( const TQString & );
    void	setQuality( int );
    void	setDescription( const TQString & );
    void	setParameters( const char * );
    void	setGamma( float );

    bool	read();
    bool	write();

    static const char* imageFormat( const TQString &fileName );
    static const char *imageFormat( TQIODevice * );
    static TQStrList inputFormats();
    static TQStrList outputFormats();

    static void defineIOHandler( const char *format,
				 const char *header,
				 const char *flags,
				 image_io_handler read_image,
				 image_io_handler write_image );

private:
    void	init();

    TQImage	im;				// image
    int		iostat;				// IO status
    TQCString	frmt;				// image format
    TQIODevice  *iodev;				// IO tqdevice
    TQString	fname;				// file name
    char       *params;				// image parameters //### change to TQImageIOData *d in 3.0
    TQString     descr;				// image description
    TQImageIOData *d;

private:	// Disabled copy constructor and operator=
#if defined(TQ_DISABLE_COPY)
    TQImageIO( const TQImageIO & );
    TQImageIO &operator=( const TQImageIO & );
#endif
};

#endif //TQT_NO_IMAGEIO

TQ_EXPORT void bitBlt( TQImage* dst, int dx, int dy, const TQImage* src,
		      int sx=0, int sy=0, int sw=-1, int sh=-1,
		      int conversion_flags=0 );


/*****************************************************************************
  TQImage member functions
 *****************************************************************************/

inline bool TQImage::hasAlphaBuffer() const
{
    return data->alpha;
}

inline uchar *TQImage::bits() const
{
    return data->bits ? data->bits[0] : 0;
}

inline uchar **TQImage::jumpTable() const
{
    return data->bits;
}

inline TQRgb *TQImage::colorTable() const
{
    return data->ctbl;
}

inline int TQImage::numBytes() const
{
    return data->nbytes;
}

inline int TQImage::bytesPerLine() const
{
    return data->h ? data->nbytes/data->h : 0;
}

inline TQImage TQImage::copy(const TQRect& r) const
{
    return copy(r.x(), r.y(), r.width(), r.height());
}

inline TQRgb TQImage::color( int i ) const
{
#if defined(TQT_CHECK_RANGE)
    if ( i >= data->ncols )
	warningIndexRange( "color", i );
#endif
    return data->ctbl ? data->ctbl[i] : (TQRgb)-1;
}

inline void TQImage::setColor( int i, TQRgb c )
{
#if defined(TQT_CHECK_RANGE)
    if ( i >= data->ncols )
	warningIndexRange( "setColor", i );
#endif
    if ( data->ctbl )
	data->ctbl[i] = c;
}

inline uchar *TQImage::scanLine( int i ) const
{
#if defined(TQT_CHECK_RANGE)
    if ( i >= data->h )
	warningIndexRange( "scanLine", i );
#endif
    return data->bits ? data->bits[i] : 0;
}

inline int TQImage::dotsPerMeterX() const
{
    return data->dpmx;
}

inline int TQImage::dotsPerMeterY() const
{
    return data->dpmy;
}

inline TQPoint TQImage::offset() const
{
    return data->offset;
}

#endif // USE_QT4

#endif // TQIMAGE_H