diff options
Diffstat (limited to 'tqtinterface/qt4/src/kernel/tqimage.h')
| -rw-r--r-- | tqtinterface/qt4/src/kernel/tqimage.h | 695 |
1 files changed, 695 insertions, 0 deletions
diff --git a/tqtinterface/qt4/src/kernel/tqimage.h b/tqtinterface/qt4/src/kernel/tqimage.h new file mode 100644 index 0000000..19dc1a0 --- /dev/null +++ b/tqtinterface/qt4/src/kernel/tqimage.h @@ -0,0 +1,695 @@ +/**************************************************************************** +** +** 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 |