TQt4 port kipi-plugins

This enables compilation under both Qt3 and Qt4


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/libraries/kipi-plugins@1232561 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

18 files changed, 322 insertions, 317 deletions

diff --git a/kipi-plugins/jpeglossless/actions.h b/kipi-plugins/jpeglossless/actions.h
index bc4fc77..90d7a66 100644
--- a/kipi-plugins/jpeglossless/actions.h
+++ b/kipi-plugins/jpeglossless/actions.h
@@ -63,8 +63,8 @@ public:
     bool    starting;
     bool    success;
 
-    QString fileName;
-    QString errString;
+    TQString fileName;
+    TQString errString;
 
     Action  action;
 };
diff --git a/kipi-plugins/jpeglossless/actionthread.cpp b/kipi-plugins/jpeglossless/actionthread.cpp
index 7e85426..660990f 100644
--- a/kipi-plugins/jpeglossless/actionthread.cpp
+++ b/kipi-plugins/jpeglossless/actionthread.cpp
@@ -27,11 +27,11 @@
  * 
  * ============================================================ */
 
-// Qt includes.
+// TQt includes.
 
-#include <qapplication.h>
-#include <qdir.h>
-#include <qdeepcopy.h>
+#include <tqapplication.h>
+#include <tqdir.h>
+#include <tqdeepcopy.h>
 
 // KDE includes.
 
@@ -48,8 +48,8 @@
 namespace KIPIJPEGLossLessPlugin
 {
 
-ActionThread::ActionThread( KIPI::Interface* interface, QObject *parent)
-            : QThread(), m_parent(parent), m_interface( interface )
+ActionThread::ActionThread( KIPI::Interface* interface, TQObject *tqparent)
+            : TQThread(), m_parent(tqparent), m_interface( interface )
 {
 }
 
@@ -106,7 +106,7 @@ void ActionThread::rotate(const KURL::List& urlList, RotateAction val)
         */
 
         Task *t      = new Task;
-        t->filePath  = QDeepCopy<QString>((*it).path()); //deep copy
+        t->filePath  = TQDeepCopy<TQString>((*it).path()); //deep copy
         t->action    = Rotate;
         t->rotAction = val;
         m_taskQueue.enqueue(t);
@@ -130,7 +130,7 @@ void ActionThread::flip(const KURL::List& urlList, FlipAction val)
         }
 
         Task *t       = new Task;
-        t->filePath   = QDeepCopy<QString>((*it).path()); //deep copy
+        t->filePath   = TQDeepCopy<TQString>((*it).path()); //deep copy
         t->action     = Flip;
         t->flipAction = val;
         m_taskQueue.enqueue(t);
@@ -143,7 +143,7 @@ void ActionThread::convert2grayscale(const KURL::List& urlList)
          it != urlList.end(); ++it ) 
     {
         Task *t     = new Task;
-        t->filePath = QDeepCopy<QString>((*it).path()); //deep copy
+        t->filePath = TQDeepCopy<TQString>((*it).path()); //deep copy
         t->action   = GrayScale;
         m_taskQueue.enqueue(t);
     }
@@ -161,7 +161,7 @@ void ActionThread::run()
         Task *t = m_taskQueue.dequeue();
         if (!t) continue;
 
-        QString errString;
+        TQString errString;
 
         EventData *d = new EventData;
 
@@ -172,7 +172,7 @@ void ActionThread::run()
                 d->action   = Rotate;
                 d->fileName = t->filePath;
                 d->starting = true;
-                QApplication::postEvent(m_parent, new QCustomEvent(QEvent::User, d));
+                TQApplication::postEvent(m_parent, new TQCustomEvent(TQEvent::User, d));
 
                 bool result = true;
                 ImageRotate imageRotate;
@@ -183,7 +183,7 @@ void ActionThread::run()
                 r->fileName  = t->filePath;
                 r->success   = result;
                 r->errString = errString;
-                QApplication::postEvent(m_parent, new QCustomEvent(QEvent::User, r));
+                TQApplication::postEvent(m_parent, new TQCustomEvent(TQEvent::User, r));
                 break;
             }
             case Flip: 
@@ -191,7 +191,7 @@ void ActionThread::run()
                 d->action   = Flip;
                 d->fileName = t->filePath;
                 d->starting = true;
-                QApplication::postEvent(m_parent, new QCustomEvent(QEvent::User, d));
+                TQApplication::postEvent(m_parent, new TQCustomEvent(TQEvent::User, d));
                 
                 ImageFlip imageFlip;
                 bool result = imageFlip.flip(t->filePath, t->flipAction, errString);
@@ -201,7 +201,7 @@ void ActionThread::run()
                 r->fileName  = t->filePath;
                 r->success   = result;
                 r->errString = errString;
-                QApplication::postEvent(m_parent, new QCustomEvent(QEvent::User, r));
+                TQApplication::postEvent(m_parent, new TQCustomEvent(TQEvent::User, r));
                 break;
             }
             case GrayScale: 
@@ -209,7 +209,7 @@ void ActionThread::run()
                 d->action   = GrayScale;
                 d->fileName = t->filePath;
                 d->starting = true;
-                QApplication::postEvent(m_parent, new QCustomEvent(QEvent::User, d));
+                TQApplication::postEvent(m_parent, new TQCustomEvent(TQEvent::User, d));
     
                 ImageGrayScale imageGrayScale;
                 bool result = imageGrayScale.image2GrayScale(t->filePath, errString);
@@ -219,7 +219,7 @@ void ActionThread::run()
                 r->fileName  = t->filePath;
                 r->success   = result;
                 r->errString = errString;
-                QApplication::postEvent(m_parent, new QCustomEvent(QEvent::User, r));
+                TQApplication::postEvent(m_parent, new TQCustomEvent(TQEvent::User, r));
                 break;
             }
             default: 
diff --git a/kipi-plugins/jpeglossless/actionthread.h b/kipi-plugins/jpeglossless/actionthread.h
index 5f41751..fb81edf 100644
--- a/kipi-plugins/jpeglossless/actionthread.h
+++ b/kipi-plugins/jpeglossless/actionthread.h
@@ -30,11 +30,11 @@
 #ifndef ACTIONTHREAD_H
 #define ACTIONTHREAD_H
 
-// Qt includes.
+// TQt includes.
 
-#include <qstring.h>
-#include <qthread.h>
-#include <qstringlist.h>
+#include <tqstring.h>
+#include <tqthread.h>
+#include <tqstringlist.h>
 
 // KDE includes.
 
@@ -49,16 +49,16 @@
 #include "actions.h"
 #include "mtqueue.h"
 
-class QObject;
+class TQObject;
 
 namespace KIPIJPEGLossLessPlugin
 {
 
-class ActionThread : public QThread
+class ActionThread : public TQThread
 {
 public:
 
-    ActionThread( KIPI::Interface* interface, QObject *parent);
+    ActionThread( KIPI::Interface* interface, TQObject *tqparent);
     ~ActionThread();
 
     void rotate(const KURL::List& urlList, RotateAction val);
@@ -74,7 +74,7 @@ private:
 
     struct Task_ 
     {
-        QString      filePath;
+        TQString      filePath;
         Action       action;
         RotateAction rotAction;
         FlipAction   flipAction;
@@ -82,7 +82,7 @@ private:
 
     typedef struct Task_ Task;
 
-    QObject         *m_parent;
+    TQObject         *m_parent;
 
     MTQueue<Task>    m_taskQueue;
 
diff --git a/kipi-plugins/jpeglossless/convert2grayscale.cpp b/kipi-plugins/jpeglossless/convert2grayscale.cpp
index 66cbbfa..4c865c1 100644
--- a/kipi-plugins/jpeglossless/convert2grayscale.cpp
+++ b/kipi-plugins/jpeglossless/convert2grayscale.cpp
@@ -40,13 +40,13 @@ extern "C"
 #include <jpeglib.h>
 }
 
-// Qt includes.
+// TQt includes.
 
-#include <qimage.h>
-#include <qstring.h>
-#include <qwmatrix.h>
-#include <qfile.h>
-#include <qfileinfo.h>
+#include <tqimage.h>
+#include <tqstring.h>
+#include <tqwmatrix.h>
+#include <tqfile.h>
+#include <tqfileinfo.h>
 
 // KDE includes.
 
@@ -66,9 +66,9 @@ namespace KIPIJPEGLossLessPlugin
 {
 
 ImageGrayScale::ImageGrayScale()
-              : QObject()
+              : TQObject()
 {
-    m_tmpFile = new KTempFile(QString(), QString("kipiplugin-grayscale"));
+    m_tmpFile = new KTempFile(TQString(), TQString("kipiplugin-grayscale"));
     m_tmpFile->setAutoDelete(true);
 }
 
@@ -77,9 +77,9 @@ ImageGrayScale::~ImageGrayScale()
     delete m_tmpFile;
 }
 
-bool ImageGrayScale::image2GrayScale(const QString& src, QString& err)
+bool ImageGrayScale::image2GrayScale(const TQString& src, TQString& err)
 {
-    QFileInfo fi(src);
+    TQFileInfo fi(src);
 
     if (!fi.exists() || !fi.isReadable() || !fi.isWritable()) 
     {
@@ -93,7 +93,7 @@ bool ImageGrayScale::image2GrayScale(const QString& src, QString& err)
         return false;
     }
 
-    QString tmp = m_tmpFile->name();
+    TQString tmp = m_tmpFile->name();
 
     if (Utils::isRAW(src))
     {
@@ -128,7 +128,7 @@ bool ImageGrayScale::image2GrayScale(const QString& src, QString& err)
     return true;
 }
 
-bool ImageGrayScale::image2GrayScaleJPEG(const QString& src, const QString& dest, QString& err)
+bool ImageGrayScale::image2GrayScaleJPEG(const TQString& src, const TQString& dest, TQString& err)
 {
     JCOPY_OPTION copyoption = JCOPYOPT_ALL;
     jpeg_transform_info transformoption;
@@ -155,7 +155,7 @@ bool ImageGrayScale::image2GrayScaleJPEG(const QString& src, const QString& dest
     FILE *input_file;
     FILE *output_file;
 
-    input_file = fopen(QFile::encodeName(src), "rb");
+    input_file = fopen(TQFile::encodeName(src), "rb");
     if (!input_file)
     {
         qDebug("Image2GrayScale: Error in opening input file");
@@ -163,7 +163,7 @@ bool ImageGrayScale::image2GrayScaleJPEG(const QString& src, const QString& dest
         return false;
     }
 
-    output_file = fopen(QFile::encodeName(dest), "wb");
+    output_file = fopen(TQFile::encodeName(dest), "wb");
     if (!output_file)
     {
         fclose(input_file);
@@ -202,7 +202,7 @@ bool ImageGrayScale::image2GrayScaleJPEG(const QString& src, const QString& dest
     // Start compressor (note no image data is actually written here)
     jpeg_write_coefficients(&dstinfo, dst_coef_arrays);
 
-    // Copy to the output file any extra markers that we want to preserve (merging from src file with Qt tmp file)
+    // Copy to the output file any extra markers that we want to preserve (merging from src file with TQt tmp file)
     jcopy_markers_execute(&srcinfo, &dstinfo, copyoption);
 
     // Execute the actual jpeg transformations
@@ -220,22 +220,22 @@ bool ImageGrayScale::image2GrayScaleJPEG(const QString& src, const QString& dest
     return true;
 }
 
-bool ImageGrayScale::image2GrayScaleImageMagick(const QString& src, const QString& dest, QString& err)
+bool ImageGrayScale::image2GrayScaleImageMagick(const TQString& src, const TQString& dest, TQString& err)
 {
     KProcess process;
     process.clearArguments();
     process << "convert";
     process << "-verbose";
     process << "-type" << "Grayscale";
-    process << src + QString("[0]") << dest;
+    process << src + TQString("[0]") << dest;
 
     qDebug("ImageMagick Command line args:");
-    QValueList<QCString> args = process.args();
-    for (QValueList<QCString>::iterator it = args.begin(); it != args.end(); ++it)
+    TQValueList<TQCString> args = process.args();
+    for (TQValueList<TQCString>::iterator it = args.begin(); it != args.end(); ++it)
         qDebug("%s", (const char*)(*it));
 
-    connect(&process, SIGNAL(receivedStderr(KProcess *, char*, int)),
-            this, SLOT(slotReadStderr(KProcess*, char*, int)));
+    connect(&process, TQT_SIGNAL(receivedStderr(KProcess *, char*, int)),
+            this, TQT_SLOT(slotReadStderr(KProcess*, char*, int)));
 
     if (!process.start(KProcess::Block, KProcess::Stderr))
         return false;
@@ -258,13 +258,13 @@ bool ImageGrayScale::image2GrayScaleImageMagick(const QString& src, const QStrin
     }
 
     // Processing error !
-    err = i18n("Cannot convert to gray scale: %1").arg(m_stdErr.replace('\n', ' '));
+    err = i18n("Cannot convert to gray scale: %1").tqarg(m_stdErr.tqreplace('\n', ' '));
     return false;
 }
 
 void ImageGrayScale::slotReadStderr(KProcess*, char* buffer, int buflen)
 {
-    m_stdErr.append(QString::fromLocal8Bit(buffer, buflen));
+    m_stdErr.append(TQString::fromLocal8Bit(buffer, buflen));
 }
 
 }  // NameSpace KIPIJPEGLossLessPlugin
diff --git a/kipi-plugins/jpeglossless/convert2grayscale.h b/kipi-plugins/jpeglossless/convert2grayscale.h
index 6d264f8..8be16f5 100644
--- a/kipi-plugins/jpeglossless/convert2grayscale.h
+++ b/kipi-plugins/jpeglossless/convert2grayscale.h
@@ -24,10 +24,10 @@
 #ifndef convert2grayscale_H
 #define convert2grayscale_H
 
-// Qt includes.
+// TQt includes.
 
-#include <qobject.h>
-#include <qstring.h>
+#include <tqobject.h>
+#include <tqstring.h>
 
 class KTempFile;
 class KProcess;
@@ -35,16 +35,17 @@ class KProcess;
 namespace KIPIJPEGLossLessPlugin
 {
 
-class ImageGrayScale : public QObject
+class ImageGrayScale : public TQObject
 {
     Q_OBJECT
+  TQ_OBJECT
 
 public:
 
     ImageGrayScale();
     ~ImageGrayScale();
 
-    bool image2GrayScale(const QString& src, QString& err);
+    bool image2GrayScale(const TQString& src, TQString& err);
 
 private slots:
 
@@ -52,12 +53,12 @@ private slots:
 
 private:
 
-    bool image2GrayScaleJPEG(const QString& src, const QString& dest, QString& err);
-    bool image2GrayScaleImageMagick(const QString& src, const QString& dest, QString& err);
+    bool image2GrayScaleJPEG(const TQString& src, const TQString& dest, TQString& err);
+    bool image2GrayScaleImageMagick(const TQString& src, const TQString& dest, TQString& err);
 
 private:
 
-    QString    m_stdErr;
+    TQString    m_stdErr;
 
     KTempFile *m_tmpFile;
 };
diff --git a/kipi-plugins/jpeglossless/imageflip.cpp b/kipi-plugins/jpeglossless/imageflip.cpp
index 4d08a67..b3a2e9b 100644
--- a/kipi-plugins/jpeglossless/imageflip.cpp
+++ b/kipi-plugins/jpeglossless/imageflip.cpp
@@ -40,12 +40,12 @@ extern "C"
 #include <jpeglib.h>
 }
 
-// Qt includes.
+// TQt includes.
 
-#include <qimage.h>
-#include <qstring.h>
-#include <qfile.h>
-#include <qfileinfo.h>
+#include <tqimage.h>
+#include <tqstring.h>
+#include <tqfile.h>
+#include <tqfileinfo.h>
 
 // KDE includes.
 
@@ -66,9 +66,9 @@ namespace KIPIJPEGLossLessPlugin
 {
 
 ImageFlip::ImageFlip()
-         : QObject()
+         : TQObject()
 {
-    m_tmpFile = new KTempFile(QString(), QString("kipiplugin-flip"));
+    m_tmpFile = new KTempFile(TQString(), TQString("kipiplugin-flip"));
     m_tmpFile->setAutoDelete(true);
 }
 
@@ -77,9 +77,9 @@ ImageFlip::~ImageFlip()
     delete m_tmpFile;
 }
 
-bool ImageFlip::flip(const QString& src, FlipAction action, QString& err)
+bool ImageFlip::flip(const TQString& src, FlipAction action, TQString& err)
 {
-    QFileInfo fi(src);
+    TQFileInfo fi(src);
 
     if (!fi.exists() || !fi.isReadable() || !fi.isWritable()) 
     {
@@ -93,7 +93,7 @@ bool ImageFlip::flip(const QString& src, FlipAction action, QString& err)
         return false;
     }
 
-    QString tmp = m_tmpFile->name();
+    TQString tmp = m_tmpFile->name();
 
     if (Utils::isRAW(src))
     {
@@ -128,7 +128,7 @@ bool ImageFlip::flip(const QString& src, FlipAction action, QString& err)
     return true;
 }
 
-bool ImageFlip::flipJPEG(const QString& src, const QString& dest, FlipAction action, QString& err)
+bool ImageFlip::flipJPEG(const TQString& src, const TQString& dest, FlipAction action, TQString& err)
 {
     Matrix transform=Matrix::none;
 
@@ -155,7 +155,7 @@ bool ImageFlip::flipJPEG(const QString& src, const QString& dest, FlipAction act
     return transformJPEG(src, dest, transform, err);
 }
 
-bool ImageFlip::flipImageMagick(const QString& src, const QString& dest, FlipAction action, QString& err)
+bool ImageFlip::flipImageMagick(const TQString& src, const TQString& dest, FlipAction action, TQString& err)
 {
     KProcess process;
     process.clearArguments();
@@ -182,15 +182,15 @@ bool ImageFlip::flipImageMagick(const QString& src, const QString& dest, FlipAct
         }
     }
 
-    process << src + QString("[0]") << dest;
+    process << src + TQString("[0]") << dest;
 
     qDebug("ImageMagick Command line args:");
-    QValueList<QCString> args = process.args();
-    for (QValueList<QCString>::iterator it = args.begin(); it != args.end(); ++it)
+    TQValueList<TQCString> args = process.args();
+    for (TQValueList<TQCString>::iterator it = args.begin(); it != args.end(); ++it)
         qDebug("%s", (const char*)(*it));
 
-    connect(&process, SIGNAL(receivedStderr(KProcess *, char*, int)),
-            this, SLOT(slotReadStderr(KProcess*, char*, int)));
+    connect(&process, TQT_SIGNAL(receivedStderr(KProcess *, char*, int)),
+            this, TQT_SLOT(slotReadStderr(KProcess*, char*, int)));
 
     if (!process.start(KProcess::Block, KProcess::Stderr))
         return false;
@@ -213,13 +213,13 @@ bool ImageFlip::flipImageMagick(const QString& src, const QString& dest, FlipAct
     }
 
     // Processing error !
-    err = i18n("Cannot flip: %1").arg(m_stdErr.replace('\n', ' '));
+    err = i18n("Cannot flip: %1").tqarg(m_stdErr.tqreplace('\n', ' '));
     return false;
 }
 
 void ImageFlip::slotReadStderr(KProcess*, char* buffer, int buflen)
 {
-    m_stdErr.append(QString::fromLocal8Bit(buffer, buflen));
+    m_stdErr.append(TQString::fromLocal8Bit(buffer, buflen));
 }
 
 }  // NameSpace KIPIJPEGLossLessPlugin
diff --git a/kipi-plugins/jpeglossless/imageflip.h b/kipi-plugins/jpeglossless/imageflip.h
index ff787fd..a91d70f 100644
--- a/kipi-plugins/jpeglossless/imageflip.h
+++ b/kipi-plugins/jpeglossless/imageflip.h
@@ -28,10 +28,10 @@
 
 #include "actions.h"
 
-// Qt includes.
+// TQt includes.
 
-#include <qobject.h>
-#include <qstring.h>
+#include <tqobject.h>
+#include <tqstring.h>
 
 class KTempFile;
 class KProcess;
@@ -39,16 +39,17 @@ class KProcess;
 namespace KIPIJPEGLossLessPlugin
 {
 
-class ImageFlip : public QObject
+class ImageFlip : public TQObject
 {
     Q_OBJECT
+  TQ_OBJECT
 
 public:
 
     ImageFlip();
     ~ImageFlip();
 
-    bool flip(const QString& src, FlipAction action, QString& err);
+    bool flip(const TQString& src, FlipAction action, TQString& err);
 
 private slots:
 
@@ -56,12 +57,12 @@ private slots:
 
 private:
 
-    bool flipJPEG(const QString& src, const QString& dest, FlipAction action, QString& err);
-    bool flipImageMagick(const QString& src, const QString& dest, FlipAction action, QString& err);
+    bool flipJPEG(const TQString& src, const TQString& dest, FlipAction action, TQString& err);
+    bool flipImageMagick(const TQString& src, const TQString& dest, FlipAction action, TQString& err);
 
 private:
 
-    QString    m_stdErr;
+    TQString    m_stdErr;
 
     KTempFile *m_tmpFile;
 };
diff --git a/kipi-plugins/jpeglossless/imagerotate.cpp b/kipi-plugins/jpeglossless/imagerotate.cpp
index cff301e..3115c16 100644
--- a/kipi-plugins/jpeglossless/imagerotate.cpp
+++ b/kipi-plugins/jpeglossless/imagerotate.cpp
@@ -41,12 +41,12 @@ extern "C"
 #include <jpeglib.h>
 }
 
-// Qt includes.
+// TQt includes.
 
-#include <qimage.h>
-#include <qwmatrix.h>
-#include <qfile.h>
-#include <qfileinfo.h>
+#include <tqimage.h>
+#include <tqwmatrix.h>
+#include <tqfile.h>
+#include <tqfileinfo.h>
 
 // KDE includes.
 
@@ -67,9 +67,9 @@ namespace KIPIJPEGLossLessPlugin
 {
 
 ImageRotate::ImageRotate()
-           : QObject()
+           : TQObject()
 {
-    m_tmpFile = new KTempFile(QString(), QString("kipiplugin-rotate"));
+    m_tmpFile = new KTempFile(TQString(), TQString("kipiplugin-rotate"));
     m_tmpFile->setAutoDelete(true);
 }
 
@@ -78,9 +78,9 @@ ImageRotate::~ImageRotate()
     delete m_tmpFile;
 }
 
-bool ImageRotate::rotate(const QString& src, RotateAction angle, QString& err)
+bool ImageRotate::rotate(const TQString& src, RotateAction angle, TQString& err)
 {
-    QFileInfo fi(src);
+    TQFileInfo fi(src);
 
     if (!fi.exists() || !fi.isReadable() || !fi.isWritable()) 
     {
@@ -94,7 +94,7 @@ bool ImageRotate::rotate(const QString& src, RotateAction angle, QString& err)
         return false;
     }
 
-    QString tmp = m_tmpFile->name();
+    TQString tmp = m_tmpFile->name();
 
     if (Utils::isRAW(src))
     {
@@ -104,7 +104,7 @@ bool ImageRotate::rotate(const QString& src, RotateAction angle, QString& err)
     else if (Utils::isJPEG(src))
     {
         if (!rotateJPEG(src, tmp, angle, err)) {
-            if (err == "nothing to do") { err=QString::null; return true; }
+            if (err == "nothing to do") { err=TQString(); return true; }
             return false;
         }
     }
@@ -131,7 +131,7 @@ bool ImageRotate::rotate(const QString& src, RotateAction angle, QString& err)
     return true;
 }
 
-bool ImageRotate::rotateJPEG(const QString& src, const QString& dest, RotateAction angle, QString& err)
+bool ImageRotate::rotateJPEG(const TQString& src, const TQString& dest, RotateAction angle, TQString& err)
 {
     Matrix transform=Matrix::none;
 
@@ -168,8 +168,8 @@ bool ImageRotate::rotateJPEG(const QString& src, const QString& dest, RotateActi
     return transformJPEG(src, dest, transform, err);
 }
 
-bool ImageRotate::rotateImageMagick(const QString& src, const QString& dest, 
-                                    RotateAction angle, QString& err)
+bool ImageRotate::rotateImageMagick(const TQString& src, const TQString& dest, 
+                                    RotateAction angle, TQString& err)
 {
     KProcess process;
     process.clearArguments();
@@ -206,15 +206,15 @@ bool ImageRotate::rotateImageMagick(const QString& src, const QString& dest,
         }
     }
 
-    process << src + QString("[0]") << dest;
+    process << src + TQString("[0]") << dest;
 
     qDebug("ImageMagick Command line args:");
-    QValueList<QCString> args = process.args();
-    for (QValueList<QCString>::iterator it = args.begin(); it != args.end(); ++it)
+    TQValueList<TQCString> args = process.args();
+    for (TQValueList<TQCString>::iterator it = args.begin(); it != args.end(); ++it)
         qDebug("%s", (const char*)(*it));
 
-    connect(&process, SIGNAL(receivedStderr(KProcess *, char*, int)),
-            this, SLOT(slotReadStderr(KProcess*, char*, int)));
+    connect(&process, TQT_SIGNAL(receivedStderr(KProcess *, char*, int)),
+            this, TQT_SLOT(slotReadStderr(KProcess*, char*, int)));
 
     if (!process.start(KProcess::Block, KProcess::Stderr))
         return false;
@@ -237,13 +237,13 @@ bool ImageRotate::rotateImageMagick(const QString& src, const QString& dest,
     }
 
     // Processing error !
-    err = i18n("Cannot rotate: %1").arg(m_stdErr.replace('\n', ' '));
+    err = i18n("Cannot rotate: %1").tqarg(m_stdErr.tqreplace('\n', ' '));
     return false;
 }
 
 void ImageRotate::slotReadStderr(KProcess*, char* buffer, int buflen)
 {
-    m_stdErr.append(QString::fromLocal8Bit(buffer, buflen));
+    m_stdErr.append(TQString::fromLocal8Bit(buffer, buflen));
 }
 
 }  // NameSpace KIPIJPEGLossLessPlugin
diff --git a/kipi-plugins/jpeglossless/imagerotate.h b/kipi-plugins/jpeglossless/imagerotate.h
index aaa27c0..8e4ff22 100644
--- a/kipi-plugins/jpeglossless/imagerotate.h
+++ b/kipi-plugins/jpeglossless/imagerotate.h
@@ -29,10 +29,10 @@
 
 #include "actions.h"
 
-// Qt includes.
+// TQt includes.
 
-#include <qobject.h>
-#include <qstring.h>
+#include <tqobject.h>
+#include <tqstring.h>
 
 class KTempFile;
 class KProcess;
@@ -40,16 +40,17 @@ class KProcess;
 namespace KIPIJPEGLossLessPlugin
 {
 
-class ImageRotate : public QObject
+class ImageRotate : public TQObject
 {
     Q_OBJECT
+  TQ_OBJECT
 
 public:
 
     ImageRotate();
     ~ImageRotate();
 
-    bool rotate(const QString& src, RotateAction angle, QString& err);
+    bool rotate(const TQString& src, RotateAction angle, TQString& err);
 
 private slots:
 
@@ -57,12 +58,12 @@ private slots:
 
 private:
 
-    bool rotateJPEG(const QString& src, const QString& dest, RotateAction angle, QString& err);
-    bool rotateImageMagick(const QString& src, const QString& dest, RotateAction angle, QString& err);
+    bool rotateJPEG(const TQString& src, const TQString& dest, RotateAction angle, TQString& err);
+    bool rotateImageMagick(const TQString& src, const TQString& dest, RotateAction angle, TQString& err);
 
 private:
 
-    QString    m_stdErr;
+    TQString    m_stdErr;
 
     KTempFile *m_tmpFile;
 };
diff --git a/kipi-plugins/jpeglossless/jpegint.h b/kipi-plugins/jpeglossless/jpegint.h
index 95b00d4..9d00c59 100644
--- a/kipi-plugins/jpeglossless/jpegint.h
+++ b/kipi-plugins/jpeglossless/jpegint.h
@@ -43,9 +43,9 @@ typedef enum {			/* Operating modes for buffer controllers */
 
 /* Master control module */
 struct jpeg_comp_master {
-  JMETHOD(void, prepare_for_pass, (j_compress_ptr cinfo));
-  JMETHOD(void, pass_startup, (j_compress_ptr cinfo));
-  JMETHOD(void, finish_pass, (j_compress_ptr cinfo));
+  JTQT_METHOD(void, prepare_for_pass, (j_compress_ptr cinfo));
+  JTQT_METHOD(void, pass_startup, (j_compress_ptr cinfo));
+  JTQT_METHOD(void, finish_pass, (j_compress_ptr cinfo));
 
   /* State variables made visible to other modules */
   boolean call_pass_startup;	/* True if pass_startup must be called */
@@ -54,16 +54,16 @@ struct jpeg_comp_master {
 
 /* Main buffer control (downsampled-data buffer) */
 struct jpeg_c_main_controller {
-  JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
-  JMETHOD(void, process_data, (j_compress_ptr cinfo,
+  JTQT_METHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
+  JTQT_METHOD(void, process_data, (j_compress_ptr cinfo,
 			       JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
 			       JDIMENSION in_rows_avail));
 };
 
 /* Compression preprocessing (downsampling input buffer control) */
 struct jpeg_c_prep_controller {
-  JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
-  JMETHOD(void, pre_process_data, (j_compress_ptr cinfo,
+  JTQT_METHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
+  JTQT_METHOD(void, pre_process_data, (j_compress_ptr cinfo,
 				   JSAMPARRAY input_buf,
 				   JDIMENSION *in_row_ctr,
 				   JDIMENSION in_rows_avail,
@@ -74,23 +74,23 @@ struct jpeg_c_prep_controller {
 
 /* Coefficient buffer control */
 struct jpeg_c_coef_controller {
-  JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
-  JMETHOD(boolean, compress_data, (j_compress_ptr cinfo,
+  JTQT_METHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
+  JTQT_METHOD(boolean, compress_data, (j_compress_ptr cinfo,
 				   JSAMPIMAGE input_buf));
 };
 
 /* Colorspace conversion */
 struct jpeg_color_converter {
-  JMETHOD(void, start_pass, (j_compress_ptr cinfo));
-  JMETHOD(void, color_convert, (j_compress_ptr cinfo,
+  JTQT_METHOD(void, start_pass, (j_compress_ptr cinfo));
+  JTQT_METHOD(void, color_convert, (j_compress_ptr cinfo,
 				JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
 				JDIMENSION output_row, int num_rows));
 };
 
 /* Downsampling */
 struct jpeg_downsampler {
-  JMETHOD(void, start_pass, (j_compress_ptr cinfo));
-  JMETHOD(void, downsample, (j_compress_ptr cinfo,
+  JTQT_METHOD(void, start_pass, (j_compress_ptr cinfo));
+  JTQT_METHOD(void, downsample, (j_compress_ptr cinfo,
 			     JSAMPIMAGE input_buf, JDIMENSION in_row_index,
 			     JSAMPIMAGE output_buf,
 			     JDIMENSION out_row_group_index));
@@ -100,9 +100,9 @@ struct jpeg_downsampler {
 
 /* Forward DCT (also controls coefficient quantization) */
 struct jpeg_forward_dct {
-  JMETHOD(void, start_pass, (j_compress_ptr cinfo));
+  JTQT_METHOD(void, start_pass, (j_compress_ptr cinfo));
   /* perhaps this should be an array??? */
-  JMETHOD(void, forward_DCT, (j_compress_ptr cinfo,
+  JTQT_METHOD(void, forward_DCT, (j_compress_ptr cinfo,
 			      jpeg_component_info * compptr,
 			      JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
 			      JDIMENSION start_row, JDIMENSION start_col,
@@ -111,23 +111,23 @@ struct jpeg_forward_dct {
 
 /* Entropy encoding */
 struct jpeg_entropy_encoder {
-  JMETHOD(void, start_pass, (j_compress_ptr cinfo, boolean gather_statistics));
-  JMETHOD(boolean, encode_mcu, (j_compress_ptr cinfo, JBLOCKROW *MCU_data));
-  JMETHOD(void, finish_pass, (j_compress_ptr cinfo));
+  JTQT_METHOD(void, start_pass, (j_compress_ptr cinfo, boolean gather_statistics));
+  JTQT_METHOD(boolean, encode_mcu, (j_compress_ptr cinfo, JBLOCKROW *MCU_data));
+  JTQT_METHOD(void, finish_pass, (j_compress_ptr cinfo));
 };
 
 /* Marker writing */
 struct jpeg_marker_writer {
-  JMETHOD(void, write_file_header, (j_compress_ptr cinfo));
-  JMETHOD(void, write_frame_header, (j_compress_ptr cinfo));
-  JMETHOD(void, write_scan_header, (j_compress_ptr cinfo));
-  JMETHOD(void, write_file_trailer, (j_compress_ptr cinfo));
-  JMETHOD(void, write_tables_only, (j_compress_ptr cinfo));
+  JTQT_METHOD(void, write_file_header, (j_compress_ptr cinfo));
+  JTQT_METHOD(void, write_frame_header, (j_compress_ptr cinfo));
+  JTQT_METHOD(void, write_scan_header, (j_compress_ptr cinfo));
+  JTQT_METHOD(void, write_file_trailer, (j_compress_ptr cinfo));
+  JTQT_METHOD(void, write_tables_only, (j_compress_ptr cinfo));
   /* These routines are exported to allow insertion of extra markers */
   /* Probably only COM and APPn markers should be written this way */
-  JMETHOD(void, write_marker_header, (j_compress_ptr cinfo, int marker,
+  JTQT_METHOD(void, write_marker_header, (j_compress_ptr cinfo, int marker,
 				      unsigned int datalen));
-  JMETHOD(void, write_marker_byte, (j_compress_ptr cinfo, int val));
+  JTQT_METHOD(void, write_marker_byte, (j_compress_ptr cinfo, int val));
 };
 
 
@@ -135,8 +135,8 @@ struct jpeg_marker_writer {
 
 /* Master control module */
 struct jpeg_decomp_master {
-  JMETHOD(void, prepare_for_output_pass, (j_decompress_ptr cinfo));
-  JMETHOD(void, finish_output_pass, (j_decompress_ptr cinfo));
+  JTQT_METHOD(void, prepare_for_output_pass, (j_decompress_ptr cinfo));
+  JTQT_METHOD(void, finish_output_pass, (j_decompress_ptr cinfo));
 
   /* State variables made visible to other modules */
   boolean is_dummy_pass;	/* True during 1st pass for 2-pass quant */
@@ -144,10 +144,10 @@ struct jpeg_decomp_master {
 
 /* Input control module */
 struct jpeg_input_controller {
-  JMETHOD(int, consume_input, (j_decompress_ptr cinfo));
-  JMETHOD(void, reset_input_controller, (j_decompress_ptr cinfo));
-  JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo));
-  JMETHOD(void, finish_input_pass, (j_decompress_ptr cinfo));
+  JTQT_METHOD(int, consume_input, (j_decompress_ptr cinfo));
+  JTQT_METHOD(void, reset_input_controller, (j_decompress_ptr cinfo));
+  JTQT_METHOD(void, start_input_pass, (j_decompress_ptr cinfo));
+  JTQT_METHOD(void, finish_input_pass, (j_decompress_ptr cinfo));
 
   /* State variables made visible to other modules */
   boolean has_multiple_scans;	/* True if file has multiple scans */
@@ -156,18 +156,18 @@ struct jpeg_input_controller {
 
 /* Main buffer control (downsampled-data buffer) */
 struct jpeg_d_main_controller {
-  JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
-  JMETHOD(void, process_data, (j_decompress_ptr cinfo,
+  JTQT_METHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
+  JTQT_METHOD(void, process_data, (j_decompress_ptr cinfo,
 			       JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
 			       JDIMENSION out_rows_avail));
 };
 
 /* Coefficient buffer control */
 struct jpeg_d_coef_controller {
-  JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo));
-  JMETHOD(int, consume_data, (j_decompress_ptr cinfo));
-  JMETHOD(void, start_output_pass, (j_decompress_ptr cinfo));
-  JMETHOD(int, decompress_data, (j_decompress_ptr cinfo,
+  JTQT_METHOD(void, start_input_pass, (j_decompress_ptr cinfo));
+  JTQT_METHOD(int, consume_data, (j_decompress_ptr cinfo));
+  JTQT_METHOD(void, start_output_pass, (j_decompress_ptr cinfo));
+  JTQT_METHOD(int, decompress_data, (j_decompress_ptr cinfo,
 				 JSAMPIMAGE output_buf));
   /* Pointer to array of coefficient virtual arrays, or NULL if none */
   jvirt_barray_ptr *coef_arrays;
@@ -175,8 +175,8 @@ struct jpeg_d_coef_controller {
 
 /* Decompression postprocessing (color quantization buffer control) */
 struct jpeg_d_post_controller {
-  JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
-  JMETHOD(void, post_process_data, (j_decompress_ptr cinfo,
+  JTQT_METHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
+  JTQT_METHOD(void, post_process_data, (j_decompress_ptr cinfo,
 				    JSAMPIMAGE input_buf,
 				    JDIMENSION *in_row_group_ctr,
 				    JDIMENSION in_row_groups_avail,
@@ -187,12 +187,12 @@ struct jpeg_d_post_controller {
 
 /* Marker reading & parsing */
 struct jpeg_marker_reader {
-  JMETHOD(void, reset_marker_reader, (j_decompress_ptr cinfo));
+  JTQT_METHOD(void, reset_marker_reader, (j_decompress_ptr cinfo));
   /* Read markers until SOS or EOI.
    * Returns same codes as are defined for jpeg_consume_input:
    * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
    */
-  JMETHOD(int, read_markers, (j_decompress_ptr cinfo));
+  JTQT_METHOD(int, read_markers, (j_decompress_ptr cinfo));
   /* Read a restart marker --- exported for use by entropy decoder only */
   jpeg_marker_parser_method read_restart_marker;
 
@@ -207,8 +207,8 @@ struct jpeg_marker_reader {
 
 /* Entropy decoding */
 struct jpeg_entropy_decoder {
-  JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
-  JMETHOD(boolean, decode_mcu, (j_decompress_ptr cinfo,
+  JTQT_METHOD(void, start_pass, (j_decompress_ptr cinfo));
+  JTQT_METHOD(boolean, decode_mcu, (j_decompress_ptr cinfo,
 				JBLOCKROW *MCU_data));
 
   /* This is here to share code between baseline and progressive decoders; */
@@ -217,21 +217,21 @@ struct jpeg_entropy_decoder {
 };
 
 /* Inverse DCT (also performs dequantization) */
-typedef JMETHOD(void, inverse_DCT_method_ptr,
+typedef JTQT_METHOD(void, inverse_DCT_method_ptr,
 		(j_decompress_ptr cinfo, jpeg_component_info * compptr,
 		 JCOEFPTR coef_block,
 		 JSAMPARRAY output_buf, JDIMENSION output_col));
 
 struct jpeg_inverse_dct {
-  JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
+  JTQT_METHOD(void, start_pass, (j_decompress_ptr cinfo));
   /* It is useful to allow each component to have a separate IDCT method. */
   inverse_DCT_method_ptr inverse_DCT[MAX_COMPONENTS];
 };
 
 /* Upsampling (note that upsampler must also call color converter) */
 struct jpeg_upsampler {
-  JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
-  JMETHOD(void, upsample, (j_decompress_ptr cinfo,
+  JTQT_METHOD(void, start_pass, (j_decompress_ptr cinfo));
+  JTQT_METHOD(void, upsample, (j_decompress_ptr cinfo,
 			   JSAMPIMAGE input_buf,
 			   JDIMENSION *in_row_group_ctr,
 			   JDIMENSION in_row_groups_avail,
@@ -244,20 +244,20 @@ struct jpeg_upsampler {
 
 /* Colorspace conversion */
 struct jpeg_color_deconverter {
-  JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
-  JMETHOD(void, color_convert, (j_decompress_ptr cinfo,
+  JTQT_METHOD(void, start_pass, (j_decompress_ptr cinfo));
+  JTQT_METHOD(void, color_convert, (j_decompress_ptr cinfo,
 				JSAMPIMAGE input_buf, JDIMENSION input_row,
 				JSAMPARRAY output_buf, int num_rows));
 };
 
 /* Color quantization or color precision reduction */
 struct jpeg_color_quantizer {
-  JMETHOD(void, start_pass, (j_decompress_ptr cinfo, boolean is_pre_scan));
-  JMETHOD(void, color_quantize, (j_decompress_ptr cinfo,
+  JTQT_METHOD(void, start_pass, (j_decompress_ptr cinfo, boolean is_pre_scan));
+  JTQT_METHOD(void, color_quantize, (j_decompress_ptr cinfo,
 				 JSAMPARRAY input_buf, JSAMPARRAY output_buf,
 				 int num_rows));
-  JMETHOD(void, finish_pass, (j_decompress_ptr cinfo));
-  JMETHOD(void, new_color_map, (j_decompress_ptr cinfo));
+  JTQT_METHOD(void, finish_pass, (j_decompress_ptr cinfo));
+  JTQT_METHOD(void, new_color_map, (j_decompress_ptr cinfo));
 };
 
 
diff --git a/kipi-plugins/jpeglossless/jpegtransform.cpp b/kipi-plugins/jpeglossless/jpegtransform.cpp
index 7009e47..4f883d4 100644
--- a/kipi-plugins/jpeglossless/jpegtransform.cpp
+++ b/kipi-plugins/jpeglossless/jpegtransform.cpp
@@ -41,11 +41,11 @@ extern "C"
 #include <jpeglib.h>
 }
 
-// Qt includes.
+// TQt includes.
 
-#include <qstring.h>
-#include <qwmatrix.h>
-#include <qfile.h>
+#include <tqstring.h>
+#include <tqwmatrix.h>
+#include <tqfile.h>
 
 // KDE includes.
 
@@ -119,11 +119,11 @@ static void jpegtransform_jpeg_output_message(j_common_ptr cinfo)
 #endif
 }
 
-bool transformJPEG(const QString& src, const QString& destGiven,
-                   Matrix &userAction, QString& err)
+bool transformJPEG(const TQString& src, const TQString& destGiven,
+                   Matrix &userAction, TQString& err)
 {
     //may be modified
-    QString dest(destGiven);   
+    TQString dest(destGiven);   
     
     JCOPY_OPTION copyoption = JCOPYOPT_ALL;
     jpeg_transform_info transformoption;
@@ -155,7 +155,7 @@ bool transformJPEG(const QString& src, const QString& destGiven,
     FILE *input_file;
     FILE *output_file;
 
-    input_file = fopen(QFile::encodeName(src), "rb");
+    input_file = fopen(TQFile::encodeName(src), "rb");
     if (!input_file)
     {
         qDebug("ImageRotate/ImageFlip: Error in opening input file");
@@ -163,7 +163,7 @@ bool transformJPEG(const QString& src, const QString& destGiven,
         return false;
     }
 
-    output_file = fopen(QFile::encodeName(dest), "wb");
+    output_file = fopen(TQFile::encodeName(dest), "wb");
     if (!output_file)
     {
         fclose(input_file);
@@ -219,7 +219,7 @@ bool transformJPEG(const QString& src, const QString& destGiven,
         dest=tempFile.name();
     }
 
-    output_file = fopen(QFile::encodeName(dest), "wb");
+    output_file = fopen(TQFile::encodeName(dest), "wb");
     if (!output_file)
     {
         fclose(input_file);
@@ -277,7 +277,7 @@ bool transformJPEG(const QString& src, const QString& destGiven,
         dstinfo.err = jpeg_std_error(&jdsterr);
         jpeg_create_compress(&dstinfo);
 
-        input_file = fopen(QFile::encodeName(dest), "rb");
+        input_file = fopen(TQFile::encodeName(dest), "rb");
         if (!input_file)
         {
             qDebug("ImageRotate/ImageFlip: Error in opening input file");
@@ -285,7 +285,7 @@ bool transformJPEG(const QString& src, const QString& destGiven,
             return false;
         }
 
-        output_file = fopen(QFile::encodeName(destGiven), "wb");
+        output_file = fopen(TQFile::encodeName(destGiven), "wb");
         if (!output_file)
         {
             fclose(input_file);
@@ -338,16 +338,16 @@ bool transformJPEG(const QString& src, const QString& destGiven,
         fclose(output_file);
 
         // Unlink temp file
-        unlink(QFile::encodeName(dest));
+        unlink(TQFile::encodeName(dest));
     }
 
     // And set finaly update the metadata to target file.
 
-    QImage img(destGiven);
-    QImage exifThumbnail = img.scale(160, 120, QImage::ScaleMin);
+    TQImage img(destGiven);
+    TQImage exifThumbnail = img.scale(160, 120, TQ_ScaleMin);
     exiv2Iface.load(destGiven);
     exiv2Iface.setImageOrientation(KExiv2Iface::KExiv2::ORIENTATION_NORMAL);
-    exiv2Iface.setImageProgramId(QString("Kipi-plugins"), QString(kipiplugins_version));
+    exiv2Iface.setImageProgramId(TQString("Kipi-plugins"), TQString(kipiplugins_version));
     exiv2Iface.setImageDimensions(img.size());
     exiv2Iface.setExifThumbnail(exifThumbnail);
     exiv2Iface.save(destGiven);
diff --git a/kipi-plugins/jpeglossless/jpegtransform.h b/kipi-plugins/jpeglossless/jpegtransform.h
index 1cf76f2..e04c2a2 100644
--- a/kipi-plugins/jpeglossless/jpegtransform.h
+++ b/kipi-plugins/jpeglossless/jpegtransform.h
@@ -25,9 +25,9 @@
 #ifndef JPEGTRANSFORM_H
 #define JPEGTRANSFORM_H
 
-// Qt includes.
+// TQt includes.
 
-#include <qstring.h>
+#include <tqstring.h>
 
 // LibKExiv2 includes. 
 
@@ -49,7 +49,7 @@ namespace KIPIJPEGLossLessPlugin
    cares for both composing (180+90=270) and eliminating (180+180=no action),
    as well as the non-commutative nature of the operations (vflip+90 is not 90+vflip)
    
-   All 2D transformations can be described by a 2x3 matrix, see QWMatrix.
+   All 2D transformations can be described by a 2x3 matrix, see TQWMatrix.
    All transformations needed here - rotate 90, 180, 270, flipV, flipH - 
    can be described in a 2x2 matrix with the values 0,1,-1
    (because flipping is expressed by changing the sign only,
@@ -121,7 +121,7 @@ protected:
 };
 
 
-bool transformJPEG(const QString& src, const QString& dest, Matrix &action, QString& err);
+bool transformJPEG(const TQString& src, const TQString& dest, Matrix &action, TQString& err);
 
 void convertTransform(Matrix &action, JXFORM_CODE &flip, JXFORM_CODE &rotate);
 
diff --git a/kipi-plugins/jpeglossless/mtqueue.h b/kipi-plugins/jpeglossless/mtqueue.h
index 209ade5..80af490 100644
--- a/kipi-plugins/jpeglossless/mtqueue.h
+++ b/kipi-plugins/jpeglossless/mtqueue.h
@@ -25,10 +25,10 @@
 #ifndef MTQUEUE_H
 #define MTQUEUE_H
 
-// Qt includes.
+// TQt includes.
 
-#include <qptrqueue.h>
-#include <qmutex.h>
+#include <tqptrqueue.h>
+#include <tqmutex.h>
 
 namespace KIPIJPEGLossLessPlugin
 {
@@ -80,8 +80,8 @@ public:
 
 private:
 
-  QPtrQueue<Type> m_queue;
-  QMutex          m_mutex;
+  TQPtrQueue<Type> m_queue;
+  TQMutex          m_mutex;
 };
 
 }  // NameSpace KIPIJPEGLossLessPlugin
diff --git a/kipi-plugins/jpeglossless/plugin_jpeglossless.cpp b/kipi-plugins/jpeglossless/plugin_jpeglossless.cpp
index 71fd86e..959fe05 100644
--- a/kipi-plugins/jpeglossless/plugin_jpeglossless.cpp
+++ b/kipi-plugins/jpeglossless/plugin_jpeglossless.cpp
@@ -26,9 +26,9 @@
 
 #include <iostream>
 
-// Qt includes.
+// TQt includes.
 
-#include <qdir.h>
+#include <tqdir.h>
 
 // KDE includes.
 
@@ -59,8 +59,8 @@ typedef KGenericFactory<Plugin_JPEGLossless> Factory;
 K_EXPORT_COMPONENT_FACTORY( kipiplugin_jpeglossless,
                             Factory("kipiplugin_jpeglossless"))
 
-Plugin_JPEGLossless::Plugin_JPEGLossless(QObject *parent, const char*, const QStringList &)
-                   : KIPI::Plugin( Factory::instance(), parent, "JPEGLossless")
+Plugin_JPEGLossless::Plugin_JPEGLossless(TQObject *tqparent, const char*, const TQStringList &)
+                   : KIPI::Plugin( Factory::instance(), tqparent, "JPEGLossless")
 {
     m_total                    = 0;
     m_current                  = 0;
@@ -75,14 +75,14 @@ Plugin_JPEGLossless::Plugin_JPEGLossless(QObject *parent, const char*, const QSt
     kdDebug( 51001 ) << "Plugin_JPEGLossless plugin loaded" << endl;
 }
 
-void Plugin_JPEGLossless::setup( QWidget* widget )
+void Plugin_JPEGLossless::setup( TQWidget* widget )
 {
     KIPI::Plugin::setup( widget );
 
     m_action_AutoExif = new KAction(i18n("Auto Rotate/Flip Using Exif Information"),
                                   0, 0,
                                   this,
-                                  SLOT(slotRotate()),
+                                  TQT_SLOT(slotRotate()),
                                   actionCollection(),
                                   "rotate_exif");    
 
@@ -95,14 +95,14 @@ void Plugin_JPEGLossless::setup( QWidget* widget )
                                   "rotate_ccw",
                                   SHIFT+CTRL+Key_Left,
                                   this,
-                                  SLOT(slotRotate()),
+                                  TQT_SLOT(slotRotate()),
                                   actionCollection(),
                                   "rotate_ccw") );
     m_action_RotateImage->insert( new KAction(i18n("Right"),
                                   "rotate_cw",
                                   SHIFT+CTRL+Key_Right,
                                   this,
-                                  SLOT(slotRotate()),
+                                  TQT_SLOT(slotRotate()),
                                   actionCollection(),
                                   "rotate_cw") );
 
@@ -115,7 +115,7 @@ void Plugin_JPEGLossless::setup( QWidget* widget )
                                   0,
                                   CTRL+Key_Asterisk,
                                   this,
-                                  SLOT(slotFlip()),
+                                  TQT_SLOT(slotFlip()),
                                   actionCollection(),
                                   "flip_horizontal") );
 
@@ -123,7 +123,7 @@ void Plugin_JPEGLossless::setup( QWidget* widget )
                                   0,
                                   CTRL+Key_Slash,
                                   this,
-                                  SLOT(slotFlip()),
+                                  TQT_SLOT(slotFlip()),
                                   actionCollection(),
                                   "flip_vertical") );
 
@@ -131,7 +131,7 @@ void Plugin_JPEGLossless::setup( QWidget* widget )
                                   "grayscaleconvert",
                                   0,
                                   this,
-                                  SLOT(slotConvert2GrayScale()),
+                                  TQT_SLOT(slotConvert2GrayScale()),
                                   actionCollection(),
                                   "jpeglossless_convert2grayscale");
 
@@ -140,7 +140,7 @@ void Plugin_JPEGLossless::setup( QWidget* widget )
     addAction( m_action_FlipImage );
     addAction( m_action_Convert2GrayScale );
 
-    KIPI::Interface* interface = dynamic_cast<KIPI::Interface*>( parent() );
+    KIPI::Interface* interface = dynamic_cast<KIPI::Interface*>( tqparent() );
 
     if ( !interface ) 
     {
@@ -155,17 +155,17 @@ void Plugin_JPEGLossless::setup( QWidget* widget )
 
     m_thread = new KIPIJPEGLossLessPlugin::ActionThread(interface, this);
 
-    connect( interface, SIGNAL( selectionChanged( bool ) ),
-             m_action_AutoExif, SLOT( setEnabled( bool ) ) );
+    connect( interface, TQT_SIGNAL( selectionChanged( bool ) ),
+             m_action_AutoExif, TQT_SLOT( setEnabled( bool ) ) );
 
-    connect( interface, SIGNAL( selectionChanged( bool ) ),
-             m_action_RotateImage, SLOT( setEnabled( bool ) ) );
+    connect( interface, TQT_SIGNAL( selectionChanged( bool ) ),
+             m_action_RotateImage, TQT_SLOT( setEnabled( bool ) ) );
 
-    connect( interface, SIGNAL( selectionChanged( bool ) ),
-             m_action_FlipImage, SLOT( setEnabled( bool ) ) );
+    connect( interface, TQT_SIGNAL( selectionChanged( bool ) ),
+             m_action_FlipImage, TQT_SLOT( setEnabled( bool ) ) );
 
-    connect( interface, SIGNAL( selectionChanged( bool ) ),
-             m_action_Convert2GrayScale, SLOT( setEnabled( bool ) ) );
+    connect( interface, TQT_SIGNAL( selectionChanged( bool ) ),
+             m_action_Convert2GrayScale, TQT_SLOT( setEnabled( bool ) ) );
 }
 
 Plugin_JPEGLossless::~Plugin_JPEGLossless()
@@ -179,8 +179,8 @@ void Plugin_JPEGLossless::slotFlip()
     KURL::List items = images();
     if (items.count() <= 0) return;
 
-    QString from(sender()->name());
-    QString title;
+    TQString from(TQT_TQOBJECT(const_cast<TQT_BASE_OBJECT_NAME*>(sender()))->name());
+    TQString title;
     bool proceed = false;
 
     if (from == "flip_horizontal") 
@@ -212,11 +212,11 @@ void Plugin_JPEGLossless::slotFlip()
         m_progressDlg = 0;
     }
 
-    m_progressDlg = new KIPI::BatchProgressDialog(kapp->activeWindow(), 
-                        i18n("Flip images %1").arg(title));
+    m_progressDlg = new KIPI::BatchProgressDialog(TQT_TQWIDGET(kapp->activeWindow()), 
+                        i18n("Flip images %1").tqarg(title));
 
-    connect(m_progressDlg, SIGNAL(cancelClicked()),
-            this, SLOT(slotCancel()));
+    connect(m_progressDlg, TQT_SIGNAL(cancelClicked()),
+            this, TQT_SLOT(slotCancel()));
 
     m_progressDlg->show();
 
@@ -229,8 +229,8 @@ void Plugin_JPEGLossless::slotRotate()
     KURL::List items = images();
     if (items.count() <= 0) return;
 
-    QString from(sender()->name());
-    QString title;
+    TQString from(TQT_TQOBJECT(const_cast<TQT_BASE_OBJECT_NAME*>(sender()))->name());
+    TQString title;
     bool proceed = false;
 
     if (from == "rotate_cw") 
@@ -268,11 +268,11 @@ void Plugin_JPEGLossless::slotRotate()
         m_progressDlg = 0;
     }
 
-    m_progressDlg = new KIPI::BatchProgressDialog(kapp->activeWindow(), 
-                        i18n("Rotate images %1").arg(title));
+    m_progressDlg = new KIPI::BatchProgressDialog(TQT_TQWIDGET(kapp->activeWindow()), 
+                        i18n("Rotate images %1").tqarg(title));
 
-    connect(m_progressDlg, SIGNAL(cancelClicked()),
-            this, SLOT(slotCancel()));
+    connect(m_progressDlg, TQT_SIGNAL(cancelClicked()),
+            this, TQT_SLOT(slotCancel()));
 
     m_progressDlg->show();
 
@@ -284,12 +284,12 @@ void Plugin_JPEGLossless::slotConvert2GrayScale()
 {
     KURL::List items = images();
     if (items.count() <= 0 ||
-        KMessageBox::No==KMessageBox::warningYesNo(kapp->activeWindow(),
+        KMessageBox::No==KMessageBox::warningYesNo(TQT_TQWIDGET(kapp->activeWindow()),
                      i18n("<p>Are you sure you wish to convert the selected image(s) to "
                          "black and white? This operation <b>cannot</b> be undone.</p>")))
         return;
 
-    QString from(sender()->name());
+    TQString from(TQT_TQOBJECT(const_cast<TQT_BASE_OBJECT_NAME*>(sender()))->name());
 
     m_total   = items.count();
     m_current = 0;
@@ -301,11 +301,11 @@ void Plugin_JPEGLossless::slotConvert2GrayScale()
         m_progressDlg = 0;
     }
 
-    m_progressDlg = new KIPI::BatchProgressDialog(kapp->activeWindow(), 
+    m_progressDlg = new KIPI::BatchProgressDialog(TQT_TQWIDGET(kapp->activeWindow()), 
                         i18n("Convert images to black & white"));
 
-    connect(m_progressDlg, SIGNAL(cancelClicked()),
-            this, SLOT(slotCancel()));
+    connect(m_progressDlg, TQT_SIGNAL(cancelClicked()),
+            this, TQT_SLOT(slotCancel()));
 
     m_progressDlg->show();
 
@@ -318,7 +318,7 @@ void Plugin_JPEGLossless::slotCancel()
 {
     m_thread->cancel();
 
-    KIPI::Interface* interface = dynamic_cast<KIPI::Interface*>( parent() );
+    KIPI::Interface* interface = dynamic_cast<KIPI::Interface*>( tqparent() );
 
     if ( !interface ) 
     {
@@ -329,14 +329,14 @@ void Plugin_JPEGLossless::slotCancel()
     interface->refreshImages( m_images );
 }
 
-void Plugin_JPEGLossless::customEvent(QCustomEvent *event)
+void Plugin_JPEGLossless::customEvent(TQCustomEvent *event)
 {
     if (!event) return;
 
     KIPIJPEGLossLessPlugin::EventData *d = (KIPIJPEGLossLessPlugin::EventData*) event->data();
     if (!d) return;
 
-    QString text;
+    TQString text;
 
     if (d->starting) 
     {
@@ -344,17 +344,17 @@ void Plugin_JPEGLossless::customEvent(QCustomEvent *event)
         {
             case(KIPIJPEGLossLessPlugin::Rotate): 
             {
-                text = i18n("Rotating Image \"%1\"").arg(d->fileName.section('/', -1));
+                text = i18n("Rotating Image \"%1\"").tqarg(d->fileName.section('/', -1));
                 break;
             }
             case(KIPIJPEGLossLessPlugin::Flip): 
             {
-                text = i18n("Flipping Image \"%1\"").arg(d->fileName.section('/', -1));
+                text = i18n("Flipping Image \"%1\"").tqarg(d->fileName.section('/', -1));
                 break;
             }
             case(KIPIJPEGLossLessPlugin::GrayScale): 
             {
-                text = i18n("Converting to Black & White \"%1\"").arg(d->fileName.section('/', -1));
+                text = i18n("Converting to Black & White \"%1\"").tqarg(d->fileName.section('/', -1));
                 break;
             }
             default:
@@ -445,8 +445,8 @@ void Plugin_JPEGLossless::customEvent(QCustomEvent *event)
             m_progressDlg->setButtonCancelText( i18n("&Close") );
 #endif
 
-            disconnect(m_progressDlg, SIGNAL(cancelClicked()),
-                    this, SLOT(slotCancel()));
+            disconnect(m_progressDlg, TQT_SIGNAL(cancelClicked()),
+                    this, TQT_SLOT(slotCancel()));
         }
         else 
         {
@@ -455,7 +455,7 @@ void Plugin_JPEGLossless::customEvent(QCustomEvent *event)
             m_progressDlg = 0;
         }
 
-        KIPI::Interface* interface = dynamic_cast<KIPI::Interface*>( parent() );
+        KIPI::Interface* interface = dynamic_cast<KIPI::Interface*>( tqparent() );
 
         if ( !interface ) 
         {
@@ -484,7 +484,7 @@ KIPI::Category Plugin_JPEGLossless::category( KAction* action ) const
 
 KURL::List Plugin_JPEGLossless::images()
 {
-    KIPI::Interface* interface = dynamic_cast<KIPI::Interface*>( parent() );
+    KIPI::Interface* interface = dynamic_cast<KIPI::Interface*>( tqparent() );
 
     if ( !interface ) 
     {
diff --git a/kipi-plugins/jpeglossless/plugin_jpeglossless.h b/kipi-plugins/jpeglossless/plugin_jpeglossless.h
index 71dd22c..c718698 100644
--- a/kipi-plugins/jpeglossless/plugin_jpeglossless.h
+++ b/kipi-plugins/jpeglossless/plugin_jpeglossless.h
@@ -30,7 +30,7 @@
 #include <libkipi/plugin.h>
 #include <libkipi/imagecollection.h>
 
-class QCustomEvent;
+class TQCustomEvent;
 class KActionMenu;
 class KAction;
 
@@ -43,18 +43,19 @@ class ProgressDlg;
 class Plugin_JPEGLossless : public KIPI::Plugin
 {
     Q_OBJECT
+  TQ_OBJECT
 
 public:
 
-    Plugin_JPEGLossless(QObject *parent, const char* name, const QStringList &args);
+    Plugin_JPEGLossless(TQObject *tqparent, const char* name, const TQStringList &args);
     ~Plugin_JPEGLossless();
 
     virtual KIPI::Category category( KAction* action ) const;
-    virtual void setup( QWidget* widget );
+    virtual void setup( TQWidget* widget );
 
 protected:
 
-    void customEvent(QCustomEvent *event);
+    void customEvent(TQCustomEvent *event);
     KURL::List images();
 
 private slots:
diff --git a/kipi-plugins/jpeglossless/transupp.cpp b/kipi-plugins/jpeglossless/transupp.cpp
index 6552364..156ac08 100644
--- a/kipi-plugins/jpeglossless/transupp.cpp
+++ b/kipi-plugins/jpeglossless/transupp.cpp
@@ -40,7 +40,7 @@ namespace KIPIJPEGLossLessPlugin
  * or recompression of the image.
  * Thanks to Guido Vollbeding for the initial design and code of this feature.
  *
- * Horizontal flipping is done in-place, using a single top-to-bottom
+ *Qt::Horizontal flipping is done in-place, using a single top-to-bottom
  * pass through the virtual source array.  It will thus be much the
  * fastest option for images larger than main memory.
  *
@@ -75,7 +75,7 @@ namespace KIPIJPEGLossLessPlugin
 LOCAL(void)
 do_flip_h (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
 	   jvirt_barray_ptr *src_coef_arrays)
-/* Horizontal flip; done in-place, so no separate dest array is required */
+/*Qt::Horizontal flip; done in-place, so no separate dest array is required */
 {
   JDIMENSION MCU_cols, comp_width, blk_x, blk_y;
   int ci, k, offset_y;
@@ -84,7 +84,7 @@ do_flip_h (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
   JCOEF temp1, temp2;
   jpeg_component_info *compptr;
 
-  /* Horizontal mirroring of DCT blocks is accomplished by swapping
+  /*Qt::Horizontal mirroring of DCT blocks is accomplished by swapping
    * pairs of blocks in-place.  Within a DCT block, we perform horizontal
    * mirroring by changing the signs of odd-numbered columns.
    * Partial iMCUs at the right edge are left untouched.
@@ -125,7 +125,7 @@ LOCAL(void)
 do_flip_v (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
 	   jvirt_barray_ptr *src_coef_arrays,
 	   jvirt_barray_ptr *dst_coef_arrays)
-/* Vertical flip */
+/*Qt::Vertical flip */
 {
   JDIMENSION MCU_rows, comp_height, dst_blk_x, dst_blk_y;
   int ci, i, j, offset_y;
@@ -242,7 +242,7 @@ do_rot_90 (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
 	   jvirt_barray_ptr *dst_coef_arrays)
 /* 90 degree rotation is equivalent to
  *   1. Transposing the image;
- *   2. Horizontal mirroring.
+ *   2.Qt::Horizontal mirroring.
  * These two steps are merged into a single processing routine.
  */
 {
@@ -305,7 +305,7 @@ do_rot_270 (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
 	    jvirt_barray_ptr *src_coef_arrays,
 	    jvirt_barray_ptr *dst_coef_arrays)
 /* 270 degree rotation is equivalent to
- *   1. Horizontal mirroring;
+ *   1.Qt::Horizontal mirroring;
  *   2. Transposing the image.
  * These two steps are merged into a single processing routine.
  */
@@ -369,8 +369,8 @@ do_rot_180 (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
 	    jvirt_barray_ptr *src_coef_arrays,
 	    jvirt_barray_ptr *dst_coef_arrays)
 /* 180 degree rotation is equivalent to
- *   1. Vertical mirroring;
- *   2. Horizontal mirroring.
+ *   1.Qt::Vertical mirroring;
+ *   2.Qt::Horizontal mirroring.
  * These two steps are merged into a single processing routine.
  */
 {
@@ -473,9 +473,9 @@ do_transverse (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
  *   1. 180 degree rotation;
  *   2. Transposition;
  * or
- *   1. Horizontal mirroring;
+ *   1.Qt::Horizontal mirroring;
  *   2. Transposition;
- *   3. Horizontal mirroring.
+ *   3.Qt::Horizontal mirroring.
  * These steps are merged into a single processing routine.
  */
 {
diff --git a/kipi-plugins/jpeglossless/utils.cpp b/kipi-plugins/jpeglossless/utils.cpp
index b050bde..d7b5b1a 100644
--- a/kipi-plugins/jpeglossless/utils.cpp
+++ b/kipi-plugins/jpeglossless/utils.cpp
@@ -36,13 +36,13 @@ extern "C"
 #include <unistd.h>
 }
 
-// Qt includes.
+// TQt includes.
 
-#include <qfileinfo.h>
-#include <qimage.h>
-#include <qstring.h>
-#include <qfile.h>
-#include <qdir.h>
+#include <tqfileinfo.h>
+#include <tqimage.h>
+#include <tqstring.h>
+#include <tqfile.h>
+#include <tqdir.h>
 
 // KDE includes.
 
@@ -73,8 +73,8 @@ extern "C"
 namespace KIPIJPEGLossLessPlugin
 {
 
-Utils::Utils(QObject *parent)
-     : QObject(parent)
+Utils::Utils(TQObject *tqparent)
+     : TQObject(tqparent)
 {
 }
 
@@ -82,54 +82,54 @@ Utils::~Utils()
 {
 }
 
-bool Utils::updateMetadataImageMagick(const QString& src, QString& err)
+bool Utils::updateMetadataImageMagick(const TQString& src, TQString& err)
 {
-    QFileInfo finfo(src);
+    TQFileInfo finfo(src);
     if (src.isEmpty() || !finfo.isReadable())
     {
         err = i18n("unable to open source file");
         return false;
     }
 
-    QImage img(src);
-    QImage iptcPreview   = img.scale(1280, 1024, QImage::ScaleMin);
-    QImage exifThumbnail = iptcPreview.scale(160, 120, QImage::ScaleMin);
+    TQImage img(src);
+    TQImage iptcPreview   = img.scale(1280, 1024, TQ_ScaleMin);
+    TQImage exifThumbnail = iptcPreview.scale(160, 120, TQ_ScaleMin);
 
     KExiv2Iface::KExiv2 meta;
     meta.load(src);
     meta.setImageOrientation(KExiv2Iface::KExiv2::ORIENTATION_NORMAL);
-    meta.setImageProgramId(QString("Kipi-plugins"), QString(kipiplugins_version));
+    meta.setImageProgramId(TQString("Kipi-plugins"), TQString(kipiplugins_version));
     meta.setImageDimensions(img.size());
     meta.setExifThumbnail(exifThumbnail);
     meta.setImagePreview(iptcPreview);
-    QByteArray ba = meta.getExif();
+    TQByteArray ba = meta.getExif();
     const uchar exifHeader[] = {0x45, 0x78, 0x69, 0x66, 0x00, 0x00};
-    QByteArray exifData = QByteArray(ba.size() + sizeof(exifHeader));
+    TQByteArray exifData = TQByteArray(ba.size() + sizeof(exifHeader));
     memcpy(exifData.data(), exifHeader, sizeof(exifHeader));
     memcpy(exifData.data()+sizeof(exifHeader), ba.data(), ba.size());
-    QByteArray iptcData = meta.getIptc(true);
+    TQByteArray iptcData = meta.getIptc(true);
 
-    KTempFile exifTemp(QString(), "kipipluginsiptc.app1");
+    KTempFile exifTemp(TQString(), "kipipluginsiptc.app1");
     exifTemp.setAutoDelete(true);
-    QFile *exifFile = exifTemp.file();
+    TQFile *exifFile = exifTemp.file();
     if ( !exifFile )
     {
         err = i18n("unable to open temp file");
         return false;
     }
-    QDataStream streamExif( exifFile );
+    TQDataStream streamExif( exifFile );
     streamExif.writeRawBytes(exifData.data(), exifData.size());
     exifFile->close();
 
-    KTempFile iptcTemp(QString(), "kipipluginsiptc.8bim");
+    KTempFile iptcTemp(TQString(), "kipipluginsiptc.8bim");
     iptcTemp.setAutoDelete(true);
-    QFile *iptcFile = iptcTemp.file();
+    TQFile *iptcFile = iptcTemp.file();
     if ( !iptcFile )
     {
         err = i18n("Cannot rotate: unable to open temp file");
         return false;
     }
-    QDataStream streamIptc( iptcFile );
+    TQDataStream streamIptc( iptcFile );
     streamIptc.writeRawBytes(iptcData.data(), iptcData.size());
     iptcFile->close();
 
@@ -144,15 +144,15 @@ bool Utils::updateMetadataImageMagick(const QString& src, QString& err)
     process << "-profile";
     process << iptcTemp.name();
 
-    process << src + QString("[0]");
+    process << src + TQString("[0]");
 
     qDebug("ImageMagick Command line args:");
-    QValueList<QCString> args = process.args();
-    for (QValueList<QCString>::iterator it = args.begin(); it != args.end(); ++it)
+    TQValueList<TQCString> args = process.args();
+    for (TQValueList<TQCString>::iterator it = args.begin(); it != args.end(); ++it)
         qDebug("%s", (const char*)(*it));
 
-    connect(&process, SIGNAL(receivedStderr(KProcess *, char*, int)),
-            this, SLOT(slotReadStderr(KProcess*, char*, int)));
+    connect(&process, TQT_SIGNAL(receivedStderr(KProcess *, char*, int)),
+            this, TQT_SLOT(slotReadStderr(KProcess*, char*, int)));
 
     if (!process.start(KProcess::Block, KProcess::Stderr))
         return false;
@@ -175,40 +175,40 @@ bool Utils::updateMetadataImageMagick(const QString& src, QString& err)
     }
 
     // Processing error !
-    err = i18n("Cannot update metadata: %1").arg(m_stdErr.replace('\n', ' '));
+    err = i18n("Cannot update metadata: %1").tqarg(m_stdErr.tqreplace('\n', ' '));
     return false;
 }
 
 void Utils::slotReadStderr(KProcess*, char* buffer, int buflen)
 {
-    m_stdErr.append(QString::fromLocal8Bit(buffer, buflen));
+    m_stdErr.append(TQString::fromLocal8Bit(buffer, buflen));
 }
 
-bool Utils::isJPEG(const QString& file)
+bool Utils::isJPEG(const TQString& file)
 {
-    QString format = QString(QImageIO::imageFormat(file)).upper();
+    TQString format = TQString(TQImageIO::imageFormat(file)).upper();
     return format=="JPEG";
 }
 
-bool Utils::isRAW(const QString& file)
+bool Utils::isRAW(const TQString& file)
 {
 #if KDCRAW_VERSION < 0x000106
-    QString rawFilesExt(KDcrawIface::DcrawBinary::instance()->rawFiles());
+    TQString rawFilesExt(KDcrawIface::DcrawBinary::instance()->rawFiles());
 #else
-    QString rawFilesExt(KDcrawIface::KDcraw::rawFiles());
+    TQString rawFilesExt(KDcrawIface::KDcraw::rawFiles());
 #endif
 
-    QFileInfo fileInfo(file);
-    if (rawFilesExt.upper().contains( fileInfo.extension(false).upper() ))
+    TQFileInfo fileInfo(file);
+    if (rawFilesExt.upper().tqcontains( fileInfo.extension(false).upper() ))
         return true;
 
     return false;
 }
 
-bool Utils::CopyFile(const QString& src, const QString& dst)
+bool Utils::CopyFile(const TQString& src, const TQString& dst)
 {
-    QFile sFile(src);
-    QFile dFile(dst);
+    TQFile sFile(src);
+    TQFile dFile(dst);
 
     if ( !sFile.open(IO_ReadOnly) )
         return false;
@@ -222,10 +222,10 @@ bool Utils::CopyFile(const QString& src, const QString& dst)
     const int MAX_IPC_SIZE = (1024*32);
     char buffer[MAX_IPC_SIZE];
 
-    Q_LONG len;
+    TQ_LONG len;
     while ((len = sFile.readBlock(buffer, MAX_IPC_SIZE)) != 0)
     {
-        if (len == -1 || dFile.writeBlock(buffer, (Q_ULONG)len) == -1)
+        if (len == -1 || dFile.writeBlock(buffer, (TQ_ULONG)len) == -1)
         {
             sFile.close();
             dFile.close();
@@ -239,10 +239,10 @@ bool Utils::CopyFile(const QString& src, const QString& dst)
     return true;
 }
 
-bool Utils::MoveFile(const QString& src, const QString& dst)
+bool Utils::MoveFile(const TQString& src, const TQString& dst)
 {
     struct stat stbuf;
-    if (::stat(QFile::encodeName(dst), &stbuf) != 0)
+    if (::stat(TQFile::encodeName(dst), &stbuf) != 0)
     {
         qDebug("KIPIJPEGLossLessPlugin:MoveFile: failed to stat src");
         return false;
@@ -254,32 +254,32 @@ bool Utils::MoveFile(const QString& src, const QString& dst)
     struct utimbuf timbuf;
     timbuf.actime = stbuf.st_atime;
     timbuf.modtime = stbuf.st_mtime;
-    if (::utime(QFile::encodeName(dst), &timbuf) != 0)
+    if (::utime(TQFile::encodeName(dst), &timbuf) != 0)
     {
         qDebug("KIPIJPEGLossLessPlugin:MoveFile: failed to update dst time");
     }
     
-    if (::unlink(QFile::encodeName(src).data()) != 0)
+    if (::unlink(TQFile::encodeName(src).data()) != 0)
     {
         qDebug("KIPIJPEGLossLessPlugin:MoveFile: failed to unlink src");
     }
     return true;
 }
 
-bool Utils::deleteDir(const QString& dirPath)
+bool Utils::deleteDir(const TQString& dirPath)
 {
-    QDir dir(dirPath);
+    TQDir dir(dirPath);
     if (!dir.exists()) 
         return false;
 
-    dir.setFilter(QDir::Dirs | QDir::Files | QDir::NoSymLinks);
+    dir.setFilter(TQDir::Dirs | TQDir::Files | TQDir::NoSymLinks);
 
-    const QFileInfoList* infoList = dir.entryInfoList();
+    const TQFileInfoList* infoList = dir.entryInfoList();
     if (!infoList) 
         return false;
 
-    QFileInfoListIterator it(*infoList);
-    QFileInfo* fi;
+    TQFileInfoListIterator it(*infoList);
+    TQFileInfo* fi;
 
     while( (fi = it.current()) ) 
     {
diff --git a/kipi-plugins/jpeglossless/utils.h b/kipi-plugins/jpeglossless/utils.h
index b9040d6..43c10ac 100644
--- a/kipi-plugins/jpeglossless/utils.h
+++ b/kipi-plugins/jpeglossless/utils.h
@@ -25,48 +25,49 @@
 #ifndef UTILS_H
 #define UTILS_H
 
-// Qt includes.
+// TQt includes.
 
-#include <qobject.h>
-#include <qstring.h>
+#include <tqobject.h>
+#include <tqstring.h>
 
 class KProcess;
 
 namespace KIPIJPEGLossLessPlugin
 {
 
-class Utils : public QObject
+class Utils : public TQObject
 {
     Q_OBJECT
+  TQ_OBJECT
 
 public:
 
-    Utils(QObject *parent);
+    Utils(TQObject *tqparent);
     ~Utils();
 
-    bool updateMetadataImageMagick(const QString& src, QString& err);
+    bool updateMetadataImageMagick(const TQString& src, TQString& err);
 
 public: // Static methods.
 
     /** Test if a file is a JPEG file.
     */
-    static bool isJPEG(const QString& file);
+    static bool isJPEG(const TQString& file);
     
     /** Test if a file is a RAW file supported by dcraw.
     */
-    static bool isRAW(const QString& file);
+    static bool isRAW(const TQString& file);
     
     /** POSIX Compliant File Copy and Move -
         Can't use KIO based operations as we need to use these in a thread
     */
     
-    static bool CopyFile(const QString& src, const QString& dst);
-    static bool MoveFile(const QString& src, const QString& dst);
+    static bool CopyFile(const TQString& src, const TQString& dst);
+    static bool MoveFile(const TQString& src, const TQString& dst);
     
     /** Thread-safe recursive dir deletion.
     */
     
-    static bool deleteDir(const QString& dirPath);
+    static bool deleteDir(const TQString& dirPath);
 
 private slots:
 
@@ -74,7 +75,7 @@ private slots:
 
 private:
 
-    QString m_stdErr;
+    TQString m_stdErr;
 };
 
 }  // NameSpace KIPIJPEGLossLessPlugin