From bf7f88413be3831a9372d323d02fc0335b9f9188 Mon Sep 17 00:00:00 2001 From: tpearson Date: Thu, 26 May 2011 21:04:57 +0000 Subject: TQt4 port Gwenview This enables compilation under both Qt3 and Qt4 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/gwenview@1233720 283d02a7-25f6-0310-bc7c-ecb5cbfe19da --- src/gvcore/qxcfi.h | 176 ++++++++++++++++++++++++++--------------------------- 1 file changed, 88 insertions(+), 88 deletions(-) (limited to 'src/gvcore/qxcfi.h') diff --git a/src/gvcore/qxcfi.h b/src/gvcore/qxcfi.h index ac82173..e98f226 100644 --- a/src/gvcore/qxcfi.h +++ b/src/gvcore/qxcfi.h @@ -1,10 +1,10 @@ -#ifndef QXCFI_H -#define QXCFI_H +#ifndef TQXCFI_H +#define TQXCFI_H -#include -#include -#include -#include +#include +#include +#include +#include #include "gimp.h" namespace Gwenview { @@ -12,11 +12,11 @@ namespace Gwenview { // Safe readBlock helper functions class SafeDataStream { public: - SafeDataStream(QIODevice* device) + SafeDataStream(TQIODevice* device) : mDevice(device), mFailed(false) {} bool failed() const { return mFailed; } - QIODevice* device() const { return mDevice; } + TQIODevice* device() const { return mDevice; } SafeDataStream& readRawBytes(char* data, uint length) { if (mFailed) return *this; @@ -26,11 +26,11 @@ public: return *this; } - SafeDataStream& operator>>(Q_INT8& value) { + SafeDataStream& operator>>(TQ_INT8& value) { return readRawBytes((char*)&value, 1); } - SafeDataStream& operator>>(Q_UINT32& value) { + SafeDataStream& operator>>(TQ_UINT32& value) { if (mFailed) return *this; uchar *p = (uchar *)(&value); char b[4]; @@ -45,18 +45,18 @@ public: return *this; } - SafeDataStream& operator>>(Q_INT32& value) { - return *this >>((Q_UINT32&)value); + SafeDataStream& operator>>(TQ_INT32& value) { + return *this >>((TQ_UINT32&)value); } SafeDataStream& operator>>(float& value) { - return *this >>((Q_UINT32&)value); + return *this >>((TQ_UINT32&)value); } SafeDataStream& operator>>(char*& value) { if (mFailed) return *this; - Q_UINT32 len; + TQ_UINT32 len; *this >> len; if (mFailed) return *this; if ( len == 0 ) { @@ -95,17 +95,17 @@ public: int at() const; private: - QIODevice* mDevice; + TQIODevice* mDevice; bool mFailed; }; //! Plug-in for loading a GIMP XCF image file directly. /*! - * This class uses the Qt 3.0 Image format plug-in loader to provide + * This class uses the TQt 3.0 Image format plug-in loader to provide * the ability to read The GIMP XCF image files. This plug-in will * be dynamically loaded as needed. */ -class XCFImageFormat : public QImageFormatPlugin { +class XCFImageFormat : public TQImageFormatPlugin { /*! * Each layer in an XCF file is stored as a matrix of @@ -114,7 +114,7 @@ class XCFImageFormat : public QImageFormatPlugin { * parallel processing on a tile-by-tile basis. Here, though, * we just read them in en-masse and store them in a matrix. */ - typedef QValueVector< QValueVector< QImage > > Tiles; + typedef TQValueVector< TQValueVector< TQImage > > Tiles; /*! * Each GIMP image is composed of one or more layers. A layer can @@ -122,15 +122,15 @@ class XCFImageFormat : public QImageFormatPlugin { * optional alpha channel, there are six possible types altogether. * * Note: there is only ever one instance of this structure. The - * layer info is discarded after it is merged into the final QImage. + * layer info is discarded after it is merged into the final TQImage. */ struct Layer { - Q_UINT32 width; //!< Width of the layer - Q_UINT32 height; //!< Height of the layer - Q_INT32 type; //!< Type of the layer (GimpImageType) + TQ_UINT32 width; //!< Width of the layer + TQ_UINT32 height; //!< Height of the layer + TQ_INT32 type; //!< Type of the layer (GimpImageType) char* name; //!< Name of the layer - Q_UINT32 hierarchy_offset; //!< File position of Tile hierarchy - Q_UINT32 mask_offset; //!< File position of mask image + TQ_UINT32 hierarchy_offset; //!< File position of Tile hierarchy + TQ_UINT32 tqmask_offset; //!< File position of tqmask image uint nrows; //!< Number of rows of tiles (y direction) uint ncols; //!< Number of columns of tiles (x direction) @@ -139,36 +139,36 @@ class XCFImageFormat : public QImageFormatPlugin { //! For Grayscale and Indexed images, the alpha channel is stored //! separately (in this data structure, anyway). Tiles alpha_tiles; - Tiles mask_tiles; //!< The layer mask (optional) + Tiles tqmask_tiles; //!< The layer tqmask (optional) - //! Additional information about a layer mask. + //! Additional information about a layer tqmask. struct { - Q_UINT32 opacity; - Q_UINT32 visible; - Q_UINT32 show_masked; + TQ_UINT32 opacity; + TQ_UINT32 visible; + TQ_UINT32 show_tqmasked; uchar red, green, blue; - Q_UINT32 tattoo; - } mask_channel; + TQ_UINT32 tattoo; + } tqmask_channel; bool active; //!< Is this layer the active layer? - Q_UINT32 opacity; //!< The opacity of the layer - Q_UINT32 visible; //!< Is the layer visible? - Q_UINT32 linked; //!< Is this layer linked (geometrically) - Q_UINT32 preserve_transparency; //!< Preserve alpha when drawing on layer? - Q_UINT32 apply_mask; //!< Apply the layer mask? - Q_UINT32 edit_mask; //!< Is the layer mask the being edited? - Q_UINT32 show_mask; //!< Show the layer mask rather than the image? - Q_INT32 x_offset; //!< x offset of the layer relative to the image - Q_INT32 y_offset; //!< y offset of the layer relative to the image - Q_UINT32 mode; //!< Combining mode of layer (LayerModeEffects) - Q_UINT32 tattoo; //!< (unique identifier?) + TQ_UINT32 opacity; //!< The opacity of the layer + TQ_UINT32 visible; //!< Is the layer visible? + TQ_UINT32 linked; //!< Is this layer linked (geometrically) + TQ_UINT32 preserve_transparency; //!< Preserve alpha when drawing on layer? + TQ_UINT32 apply_tqmask; //!< Apply the layer tqmask? + TQ_UINT32 edit_tqmask; //!< Is the layer tqmask the being edited? + TQ_UINT32 show_tqmask; //!< Show the layer tqmask rather than the image? + TQ_INT32 x_offset; //!< x offset of the layer relative to the image + TQ_INT32 y_offset; //!< y offset of the layer relative to the image + TQ_UINT32 mode; //!< Combining mode of layer (LayerModeEffects) + TQ_UINT32 tattoo; //!< (unique identifier?) //! As each tile is read from the file, it is buffered here. - uchar tile[TILE_WIDTH * TILE_HEIGHT * sizeof(QRgb)]; + uchar tile[TILE_WIDTH * TILE_HEIGHT * sizeof(TQRgb)]; //! The data from tile buffer is copied to the Tile by this //! method. Depending on the type of the tile (RGB, Grayscale, - //! Indexed) and use (image or mask), the bytes in the buffer are + //! Indexed) and use (image or tqmask), the bytes in the buffer are //! copied in different ways. void (*assignBytes)( Layer& layer, uint i, uint j ); @@ -183,36 +183,36 @@ class XCFImageFormat : public QImageFormatPlugin { * metadata items, but is mostly a container for the layer information. */ struct XCFImage { - Q_UINT32 width; //!< width of the XCF image - Q_UINT32 height; //!< height of the XCF image - Q_INT32 type; //!< type of the XCF image (GimpImageBaseType) + TQ_UINT32 width; //!< width of the XCF image + TQ_UINT32 height; //!< height of the XCF image + TQ_INT32 type; //!< type of the XCF image (GimpImageBaseType) - Q_UINT8 compression; //!< tile compression method (CompressionType) + TQ_UINT8 compression; //!< tile compression method (CompressionType) float x_resolution; //!< x resolution in dots per inch float y_resolution; //!< y resolution in dots per inch - Q_INT32 tattoo; //!< (unique identifier?) - Q_UINT32 unit; //!< Units of The GIMP (inch, mm, pica, etc...) - Q_INT32 num_colors; //!< number of colors in an indexed image - QValueVector< QRgb > palette; //!< indexed image color palette + TQ_INT32 tattoo; //!< (unique identifier?) + TQ_UINT32 unit; //!< Units of The GIMP (inch, mm, pica, etc...) + TQ_INT32 num_colors; //!< number of colors in an indexed image + TQValueVector< TQRgb > palette; //!< indexed image color palette int num_layers; //!< number of layers Layer layer; //!< most recently read layer - bool initialized; //!< Is the QImage initialized? - QImage image; //!< final QImage + bool initialized; //!< Is the TQImage initialized? + TQImage image; //!< final TQImage //! Simple constructor. XCFImage ( void ) : initialized( false ) {} }; - //! The bottom-most layer is copied into the final QImage by this + //! The bottom-most layer is copied into the final TQImage by this //! routine. typedef void (*PixelCopyOperation) ( Layer& layer, uint i, uint j, int k, int l, - QImage& image, int m, int n ); + TQImage& image, int m, int n ); - //! Higher layers are merged into the the final QImage by this routine. + //! Higher layers are merged into the the final TQImage by this routine. typedef void (*PixelMergeOperation) ( Layer& layer, uint i, uint j, int k, int l, - QImage& image, int m, int n ); + TQImage& image, int m, int n ); //! In layer DISSOLVE mode, a random number is chosen to compare to a //! pixel's alpha. If the alpha is greater than the random number, the @@ -245,31 +245,31 @@ public: /*! * The image loader makes no (direct) use of dynamic memory - * and the Qt infrastructure takes care of constructing and destructing + * and the TQt infrastructure takes care of constructing and destructing * the loader so there is not much to do here. */ ~XCFImageFormat () {} /*! - * You can query Qt about the types of image file formats it knows about - * via QImage::inputFormats or QImage::inputFormatList(). + * You can query TQt about the types of image file formats it knows about + * via TQImage::inputFormats or TQImage::inputFormatList(). * This method returns "xcf". */ - QStringList keys () const { - return QStringList() << "XCF"; + TQStringList keys () const { + return TQStringList() << "XCF"; } /*! * This method installs the XCF reader on demand. */ - bool installIOHandler ( const QString& ); + bool installIOHandler ( const TQString& ); static void registerFormat(); private: - static void readXCF ( QImageIO* image_io ); + static void readXCF ( TQImageIO* image_io ); #ifdef TMP_WRITE - static void writeXCF ( QImageIO* ) {} + static void writeXCF ( TQImageIO* ) {} #endif static void initializeImage ( XCFImage& xcf_image ); static void composeTiles ( XCFImage& xcf_image ); @@ -279,52 +279,52 @@ private: static bool loadChannelProperties ( SafeDataStream& xcf_io, Layer& layer ); static bool loadHierarchy ( SafeDataStream& xcf_io, Layer& layer ); static bool loadMask ( SafeDataStream& xcf_io, Layer& layer ); - static bool loadLevel ( SafeDataStream& xcf_io, Layer& layer, Q_INT32 bpp ); + static bool loadLevel ( SafeDataStream& xcf_io, Layer& layer, TQ_INT32 bpp ); static bool loadTileRLE ( SafeDataStream& xcf_io, uchar* tile, int size, - int data_length, Q_INT32 bpp ); + int data_length, TQ_INT32 bpp ); static bool loadProperty ( SafeDataStream& xcf_io, PropType& type, - QByteArray& bytes ); - static void setGrayPalette ( QImage& image ); - static void setPalette ( XCFImage& xcf_image, QImage& image ); + TQByteArray& bytes ); + static void setGrayPalette ( TQImage& image ); + static void setPalette ( XCFImage& xcf_image, TQImage& image ); static void assignImageBytes ( Layer& layer, uint i, uint j ); static void assignMaskBytes ( Layer& layer, uint i, uint j ); static void copyLayerToImage ( XCFImage& xcf_image ); static void copyRGBToRGB ( Layer& layer, uint i, uint j, int k, int l, - QImage& image, int m, int n ); + TQImage& image, int m, int n ); static void copyGrayToGray ( Layer& layer, uint i, uint j, int k, int l, - QImage& image, int m, int n ); + TQImage& image, int m, int n ); static void copyGrayToRGB ( Layer& layer, uint i, uint j, int k, int l, - QImage& image, int m, int n ); + TQImage& image, int m, int n ); static void copyGrayAToRGB ( Layer& layer, uint i, uint j, int k, int l, - QImage& image, int m, int n ); + TQImage& image, int m, int n ); static void copyIndexedToIndexed ( Layer& layer, uint i, uint j, int k, int l, - QImage& image, int m, int n ); + TQImage& image, int m, int n ); static void copyIndexedAToIndexed ( Layer& layer, uint i, uint j, int k, int l, - QImage& image, int m, int n ); + TQImage& image, int m, int n ); static void copyIndexedAToRGB ( Layer& layer, uint i, uint j, int k, int l, - QImage& image, int m, int n ); + TQImage& image, int m, int n ); static void mergeLayerIntoImage ( XCFImage& xcf_image ); static void mergeRGBToRGB ( Layer& layer, uint i, uint j, int k, int l, - QImage& image, int m, int n ); + TQImage& image, int m, int n ); static void mergeGrayToGray ( Layer& layer, uint i, uint j, int k, int l, - QImage& image, int m, int n ); + TQImage& image, int m, int n ); static void mergeGrayAToGray ( Layer& layer, uint i, uint j, int k, int l, - QImage& image, int m, int n ); + TQImage& image, int m, int n ); static void mergeGrayToRGB ( Layer& layer, uint i, uint j, int k, int l, - QImage& image, int m, int n ); + TQImage& image, int m, int n ); static void mergeGrayAToRGB ( Layer& layer, uint i, uint j, int k, int l, - QImage& image, int m, int n ); + TQImage& image, int m, int n ); static void mergeIndexedToIndexed ( Layer& layer, uint i, uint j, int k, int l, - QImage& image, int m, int n ); + TQImage& image, int m, int n ); static void mergeIndexedAToIndexed ( Layer& layer, uint i, uint j, int k, int l, - QImage& image, int m, int n ); + TQImage& image, int m, int n ); static void mergeIndexedAToRGB ( Layer& layer, uint i, uint j, int k, int l, - QImage& image, int m, int n ); + TQImage& image, int m, int n ); - static void dissolveRGBPixels ( QImage& image, int x, int y ); - static void dissolveAlphaPixels ( QImage& image, int x, int y ); + static void dissolveRGBPixels ( TQImage& image, int x, int y ); + static void dissolveAlphaPixels ( TQImage& image, int x, int y ); }; } // namespace -- cgit v1.2.1