TQt4 port koffice

This should enable compilation under both Qt3 and Qt4; fixes for any missed components will be forthcoming


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/koffice@1238284 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

5 files changed, 338 insertions, 337 deletions

diff --git a/krita/colorspaces/gray_u8/gray_plugin.cc b/krita/colorspaces/gray_u8/gray_plugin.cc
index 50fe51cc..d8df4393 100644
--- a/krita/colorspaces/gray_u8/gray_plugin.cc
+++ b/krita/colorspaces/gray_u8/gray_plugin.cc
@@ -37,16 +37,16 @@ typedef KGenericFactory<GrayPlugin> GrayPluginFactory;
 K_EXPORT_COMPONENT_FACTORY( kritagrayplugin, GrayPluginFactory( "kritacore" ) )
 
 
-GrayPlugin::GrayPlugin(QObject *parent, const char *name, const QStringList &)
-    : KParts::Plugin(parent, name)
+GrayPlugin::GrayPlugin(TQObject *tqparent, const char *name, const TQStringList &)
+    : KParts::Plugin(tqparent, name)
 {
            setInstance(GrayPluginFactory::instance());
 
     // This is not a gui plugin; only load it when the doc is created.
-    if ( parent->inherits("KisColorSpaceFactoryRegistry") )
+    if ( tqparent->inherits("KisColorSpaceFactoryRegistry") )
     {
 
-        KisColorSpaceFactoryRegistry * f = dynamic_cast<KisColorSpaceFactoryRegistry*>( parent );
+        KisColorSpaceFactoryRegistry * f = dynamic_cast<KisColorSpaceFactoryRegistry*>( tqparent );
 
         // .22 gamma grayscale or something like that. Taken from the lcms tutorial...
         LPGAMMATABLE Gamma = cmsBuildGamma(256, 2.2);
diff --git a/krita/colorspaces/gray_u8/gray_plugin.h b/krita/colorspaces/gray_u8/gray_plugin.h
index 9359fa72..f18bf77c 100644
--- a/krita/colorspaces/gray_u8/gray_plugin.h
+++ b/krita/colorspaces/gray_u8/gray_plugin.h
@@ -27,8 +27,9 @@
 class GrayPlugin : public KParts::Plugin
 {
     Q_OBJECT
+  TQ_OBJECT
 public:
-    GrayPlugin(QObject *parent, const char *name, const QStringList &);
+    GrayPlugin(TQObject *tqparent, const char *name, const TQStringList &);
     virtual ~GrayPlugin();
 
 };
diff --git a/krita/colorspaces/gray_u8/kis_gray_colorspace.cc b/krita/colorspaces/gray_u8/kis_gray_colorspace.cc
index f5e46416..dbd475df 100644
--- a/krita/colorspaces/gray_u8/kis_gray_colorspace.cc
+++ b/krita/colorspaces/gray_u8/kis_gray_colorspace.cc
@@ -24,7 +24,7 @@
 #include <config.h>
 #include LCMS_HEADER
 
-#include <qimage.h>
+#include <tqimage.h>
 
 #include <klocale.h>
 #include <kdebug.h>
@@ -36,15 +36,15 @@
 #include "kis_integer_maths.h"
 
 #define downscale(quantum)  (quantum) //((unsigned char) ((quantum)/257UL))
-#define upscale(value)  (value) // ((Q_UINT8) (257UL*(value)))
+#define upscale(value)  (value) // ((TQ_UINT8) (257UL*(value)))
 
 namespace {
-    const Q_INT32 MAX_CHANNEL_GRAYSCALE = 1;
-    const Q_INT32 MAX_CHANNEL_GRAYSCALEA = 2;
+    const TQ_INT32 MAX_CHANNEL_GRAYSCALE = 1;
+    const TQ_INT32 MAX_CHANNEL_GRAYSCALEA = 2;
 }
 
-KisGrayColorSpace::KisGrayColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p) :
-    KisU8BaseColorSpace(KisID("GRAYA", i18n("Grayscale")), TYPE_GRAYA_8, icSigGrayData, parent, p)
+KisGrayColorSpace::KisGrayColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p) :
+    KisU8BaseColorSpace(KisID("GRAYA", i18n("Grayscale")), TYPE_GRAYA_8, icSigGrayData, tqparent, p)
 {
     m_channels.push_back(new KisChannelInfo(i18n("Gray"), i18n("G"), 0, KisChannelInfo::COLOR, KisChannelInfo::UINT8));
     m_channels.push_back(new KisChannelInfo(i18n("Alpha"), i18n("A"), 1, KisChannelInfo::ALPHA, KisChannelInfo::UINT8));
@@ -59,24 +59,24 @@ KisGrayColorSpace::~KisGrayColorSpace()
 {
 }
 
-void KisGrayColorSpace::setPixel(Q_UINT8 *pixel, Q_UINT8 gray, Q_UINT8 alpha) const
+void KisGrayColorSpace::setPixel(TQ_UINT8 *pixel, TQ_UINT8 gray, TQ_UINT8 alpha) const
 {
     pixel[PIXEL_GRAY] = gray;
     pixel[PIXEL_GRAY_ALPHA] = alpha;
 }
 
-void KisGrayColorSpace::getPixel(const Q_UINT8 *pixel, Q_UINT8 *gray, Q_UINT8 *alpha) const
+void KisGrayColorSpace::getPixel(const TQ_UINT8 *pixel, TQ_UINT8 *gray, TQ_UINT8 *alpha) const
 {
     *gray = pixel[PIXEL_GRAY];
     *alpha = pixel[PIXEL_GRAY_ALPHA];
 }
 
-void KisGrayColorSpace::getAlpha(const Q_UINT8 *pixel, Q_UINT8 *alpha) const
+void KisGrayColorSpace::getAlpha(const TQ_UINT8 *pixel, TQ_UINT8 *alpha) const
 {
     *alpha = pixel[PIXEL_GRAY_ALPHA];
 }
 
-void KisGrayColorSpace::setAlpha(Q_UINT8 *pixels, Q_UINT8 alpha, Q_INT32 nPixels) const
+void KisGrayColorSpace::setAlpha(TQ_UINT8 *pixels, TQ_UINT8 alpha, TQ_INT32 nPixels) const
 {
     while (nPixels > 0) {
         pixels[PIXEL_GRAY_ALPHA] = alpha;
@@ -85,14 +85,14 @@ void KisGrayColorSpace::setAlpha(Q_UINT8 *pixels, Q_UINT8 alpha, Q_INT32 nPixels
     }
 }
 
-void KisGrayColorSpace::mixColors(const Q_UINT8 **colors, const Q_UINT8 *weights, Q_UINT32 nColors, Q_UINT8 *dst) const
+void KisGrayColorSpace::mixColors(const TQ_UINT8 **colors, const TQ_UINT8 *weights, TQ_UINT32 nColors, TQ_UINT8 *dst) const
 {
-    Q_UINT32 totalGray = 0, newAlpha = 0;
+    TQ_UINT32 totalGray = 0, newAlpha = 0;
 
     while (nColors--)
     {
-        Q_UINT32 alpha = (*colors)[PIXEL_GRAY_ALPHA];
-        Q_UINT32 alphaTimesWeight = UINT8_MULT(alpha, *weights);
+        TQ_UINT32 alpha = (*colors)[PIXEL_GRAY_ALPHA];
+        TQ_UINT32 alphaTimesWeight = UINT8_MULT(alpha, *weights);
 
         totalGray += (*colors)[PIXEL_GRAY] * alphaTimesWeight;
         newAlpha += alphaTimesWeight;
@@ -111,18 +111,18 @@ void KisGrayColorSpace::mixColors(const Q_UINT8 **colors, const Q_UINT8 *weights
 
     // Divide by 255.
     totalGray += 0x80;
-    Q_UINT32 dstGray = ((totalGray >> 8) + totalGray) >> 8;
+    TQ_UINT32 dstGray = ((totalGray >> 8) + totalGray) >> 8;
     Q_ASSERT(dstGray <= 255);
     dst[PIXEL_GRAY] = dstGray;
 }
 
-void KisGrayColorSpace::convolveColors(Q_UINT8** colors, Q_INT32* kernelValues, KisChannelInfo::enumChannelFlags channelFlags, Q_UINT8 *dst, Q_INT32 factor, Q_INT32 offset, Q_INT32 nColors) const
+void KisGrayColorSpace::convolveColors(TQ_UINT8** colors, TQ_INT32* kernelValues, KisChannelInfo::enumChannelFlags channelFlags, TQ_UINT8 *dst, TQ_INT32 factor, TQ_INT32 offset, TQ_INT32 nColors) const
 {
-    Q_INT32 totalGray = 0, totalAlpha = 0;
+    TQ_INT32 totalGray = 0, totalAlpha = 0;
 
     while (nColors--)
     {
-        Q_INT32 weight = *kernelValues;
+        TQ_INT32 weight = *kernelValues;
 
         if (weight != 0) {
             totalGray += (*colors)[PIXEL_GRAY] * weight;
@@ -134,117 +134,117 @@ void KisGrayColorSpace::convolveColors(Q_UINT8** colors, Q_INT32* kernelValues,
 
 
     if (channelFlags & KisChannelInfo::FLAG_COLOR) {
-        dst[PIXEL_GRAY] = CLAMP((totalGray / factor) + offset, 0, Q_UINT8_MAX);
+        dst[PIXEL_GRAY] = CLAMP((totalGray / factor) + offset, 0, TQ_UINT8_MAX);
     }
     if (channelFlags & KisChannelInfo::FLAG_ALPHA) {
-        dst[PIXEL_GRAY_ALPHA] = CLAMP((totalAlpha/ factor) + offset, 0, Q_UINT8_MAX);
+        dst[PIXEL_GRAY_ALPHA] = CLAMP((totalAlpha/ factor) + offset, 0, TQ_UINT8_MAX);
     }
 
 }
 
 
-void KisGrayColorSpace::invertColor(Q_UINT8 * src, Q_INT32 nPixels)
+void KisGrayColorSpace::invertColor(TQ_UINT8 * src, TQ_INT32 nPixels)
 {
-    Q_UINT32 psize = pixelSize();
+    TQ_UINT32 psize = pixelSize();
 
     while (nPixels--)
     {
-        src[PIXEL_GRAY] = Q_UINT8_MAX - src[PIXEL_GRAY];
+        src[PIXEL_GRAY] = TQ_UINT8_MAX - src[PIXEL_GRAY];
         src += psize;
     }
 }
 
-void KisGrayColorSpace::darken(const Q_UINT8 * src, Q_UINT8 * dst, Q_INT32 shade, bool compensate, double compensation, Q_INT32 nPixels) const
+void KisGrayColorSpace::darken(const TQ_UINT8 * src, TQ_UINT8 * dst, TQ_INT32 shade, bool compensate, double compensation, TQ_INT32 nPixels) const
 {
-    Q_UINT32 pSize = pixelSize();
+    TQ_UINT32 pSize = pixelSize();
 
     while (nPixels--) {
         if (compensate) {
-            dst[PIXEL_GRAY]  = (Q_INT8) QMIN(255,((src[PIXEL_GRAY] * shade) / (compensation * 255)));
+            dst[PIXEL_GRAY]  = (TQ_INT8) TQMIN(255,((src[PIXEL_GRAY] * shade) / (compensation * 255)));
         }
         else {
-            dst[PIXEL_GRAY]  = (Q_INT8) QMIN(255, (src[PIXEL_GRAY] * shade / 255));
+            dst[PIXEL_GRAY]  = (TQ_INT8) TQMIN(255, (src[PIXEL_GRAY] * shade / 255));
         }
         dst += pSize;
         src += pSize;
     }
 }
 
-Q_UINT8 KisGrayColorSpace::intensity8(const Q_UINT8 * src) const
+TQ_UINT8 KisGrayColorSpace::intensity8(const TQ_UINT8 * src) const
 {
     return src[PIXEL_GRAY];
 }
 
-QValueVector<KisChannelInfo *> KisGrayColorSpace::channels() const
+TQValueVector<KisChannelInfo *> KisGrayColorSpace::channels() const
 {
     return m_channels;
 }
 
-Q_UINT32 KisGrayColorSpace::nChannels() const
+TQ_UINT32 KisGrayColorSpace::nChannels() const
 {
     return MAX_CHANNEL_GRAYSCALEA;
 }
 
-Q_UINT32 KisGrayColorSpace::nColorChannels() const
+TQ_UINT32 KisGrayColorSpace::nColorChannels() const
 {
     return MAX_CHANNEL_GRAYSCALE;
 }
 
-Q_UINT32 KisGrayColorSpace::pixelSize() const
+TQ_UINT32 KisGrayColorSpace::pixelSize() const
 {
     return MAX_CHANNEL_GRAYSCALEA;
 }
 
-void KisGrayColorSpace::bitBlt(Q_UINT8 *dst,
-                      Q_INT32 dstRowStride,
-                      const Q_UINT8 *src,
-                      Q_INT32 srcRowStride,
-                      const Q_UINT8 *mask,
-                      Q_INT32 maskRowStride,
-                      Q_UINT8 opacity,
-                      Q_INT32 rows,
-                      Q_INT32 cols,
+void KisGrayColorSpace::bitBlt(TQ_UINT8 *dst,
+                      TQ_INT32 dstRowStride,
+                      const TQ_UINT8 *src,
+                      TQ_INT32 srcRowStride,
+                      const TQ_UINT8 *tqmask,
+                      TQ_INT32 tqmaskRowStride,
+                      TQ_UINT8 opacity,
+                      TQ_INT32 rows,
+                      TQ_INT32 cols,
                       const KisCompositeOp& op)
 {
     switch (op.op()) {
     case COMPOSITE_OVER:
-        compositeOver(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
+        compositeOver(dst, dstRowStride, src, srcRowStride, tqmask, tqmaskRowStride, rows, cols, opacity);
         break;
     case COMPOSITE_MULT:
-        compositeMultiply(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
+        compositeMultiply(dst, dstRowStride, src, srcRowStride, tqmask, tqmaskRowStride, rows, cols, opacity);
         break;
     case COMPOSITE_DIVIDE:
-        compositeDivide(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
+        compositeDivide(dst, dstRowStride, src, srcRowStride, tqmask, tqmaskRowStride, rows, cols, opacity);
         break;
     case COMPOSITE_DARKEN:
-        compositeDarken(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
+        compositeDarken(dst, dstRowStride, src, srcRowStride, tqmask, tqmaskRowStride, rows, cols, opacity);
         break;
     case COMPOSITE_LIGHTEN:
-        compositeLighten(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
+        compositeLighten(dst, dstRowStride, src, srcRowStride, tqmask, tqmaskRowStride, rows, cols, opacity);
         break;
     case COMPOSITE_SCREEN:
-        compositeScreen(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
+        compositeScreen(dst, dstRowStride, src, srcRowStride, tqmask, tqmaskRowStride, rows, cols, opacity);
         break;
     case COMPOSITE_OVERLAY:
-        compositeOverlay(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
+        compositeOverlay(dst, dstRowStride, src, srcRowStride, tqmask, tqmaskRowStride, rows, cols, opacity);
         break;
     case COMPOSITE_DODGE:
-        compositeDodge(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
+        compositeDodge(dst, dstRowStride, src, srcRowStride, tqmask, tqmaskRowStride, rows, cols, opacity);
         break;
     case COMPOSITE_BURN:
-        compositeBurn(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
+        compositeBurn(dst, dstRowStride, src, srcRowStride, tqmask, tqmaskRowStride, rows, cols, opacity);
         break;
     case COMPOSITE_ERASE:
-        compositeErase(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
+        compositeErase(dst, dstRowStride, src, srcRowStride, tqmask, tqmaskRowStride, rows, cols, opacity);
         break;
     case COMPOSITE_COPY:
-        compositeCopy(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
+        compositeCopy(dst, dstRowStride, src, srcRowStride, tqmask, tqmaskRowStride, rows, cols, opacity);
         break;
     case COMPOSITE_CLEAR: {
-        Q_UINT8 *d;
-        Q_INT32 linesize;
+        TQ_UINT8 *d;
+        TQ_INT32 linesize;
 
-        linesize = MAX_CHANNEL_GRAYSCALEA*sizeof(Q_UINT8) * cols;
+        linesize = MAX_CHANNEL_GRAYSCALEA*sizeof(TQ_UINT8) * cols;
         d = dst;
         while (rows-- > 0) {
             memset(d, 0, linesize);
@@ -253,7 +253,7 @@ void KisGrayColorSpace::bitBlt(Q_UINT8 *dst,
     }
         break;
     case COMPOSITE_ALPHA_DARKEN:
-        compositeAlphaDarken(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
+        compositeAlphaDarken(dst, dstRowStride, src, srcRowStride, tqmask, tqmaskRowStride, rows, cols, opacity);
         break;
 
     default:
@@ -278,25 +278,25 @@ KisCompositeOpList KisGrayColorSpace::userVisiblecompositeOps() const
     return list;
 }
 
-void KisGrayColorSpace::compositeOver(Q_UINT8 *dstRowStart, Q_INT32 dstRowStride, const Q_UINT8 *srcRowStart, Q_INT32 srcRowStride, const Q_UINT8 *maskRowStart, Q_INT32 maskRowStride, Q_INT32 rows, Q_INT32 numColumns, Q_UINT8 opacity)
+void KisGrayColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmaskRowStart, TQ_INT32 tqmaskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
 {
     while (rows > 0) {
 
-        const Q_UINT8 *src = srcRowStart;
-        Q_UINT8 *dst = dstRowStart;
-        Q_INT32 columns = numColumns;
-        const Q_UINT8 *mask = maskRowStart;
+        const TQ_UINT8 *src = srcRowStart;
+        TQ_UINT8 *dst = dstRowStart;
+        TQ_INT32 columns = numColumns;
+        const TQ_UINT8 *tqmask = tqmaskRowStart;
 
         while (columns > 0) {
 
-            Q_UINT8 srcAlpha = src[PIXEL_GRAY_ALPHA];
+            TQ_UINT8 srcAlpha = src[PIXEL_GRAY_ALPHA];
 
-            // apply the alphamask
-            if(mask != 0)
+            // apply the alphatqmask
+            if(tqmask != 0)
             {
-                if(*mask != OPACITY_OPAQUE)
-                    srcAlpha = UINT8_MULT(srcAlpha, *mask);
-                mask++;
+                if(*tqmask != OPACITY_OPAQUE)
+                    srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
+                tqmask++;
             }
 
             if (srcAlpha != OPACITY_TRANSPARENT) {
@@ -306,16 +306,16 @@ void KisGrayColorSpace::compositeOver(Q_UINT8 *dstRowStart, Q_INT32 dstRowStride
                 }
 
                 if (srcAlpha == OPACITY_OPAQUE) {
-                    memcpy(dst, src, MAX_CHANNEL_GRAYSCALEA * sizeof(Q_UINT8));
+                    memcpy(dst, src, MAX_CHANNEL_GRAYSCALEA * sizeof(TQ_UINT8));
                 } else {
-                    Q_UINT8 dstAlpha = dst[PIXEL_GRAY_ALPHA];
+                    TQ_UINT8 dstAlpha = dst[PIXEL_GRAY_ALPHA];
 
-                    Q_UINT8 srcBlend;
+                    TQ_UINT8 srcBlend;
 
                     if (dstAlpha == OPACITY_OPAQUE) {
                         srcBlend = srcAlpha;
                     } else {
-                        Q_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
+                        TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
                         dst[PIXEL_GRAY_ALPHA] = newAlpha;
 
                         if (newAlpha != 0) {
@@ -326,7 +326,7 @@ void KisGrayColorSpace::compositeOver(Q_UINT8 *dstRowStart, Q_INT32 dstRowStride
                     }
 
                     if (srcBlend == OPACITY_OPAQUE) {
-                        memcpy(dst, src, MAX_CHANNEL_GRAYSCALE * sizeof(Q_UINT8));
+                        memcpy(dst, src, MAX_CHANNEL_GRAYSCALE * sizeof(TQ_UINT8));
                     } else {
                         dst[PIXEL_GRAY] = UINT8_BLEND(src[PIXEL_GRAY], dst[PIXEL_GRAY], srcBlend);
                     }
@@ -341,33 +341,33 @@ void KisGrayColorSpace::compositeOver(Q_UINT8 *dstRowStart, Q_INT32 dstRowStride
         rows--;
         srcRowStart += srcRowStride;
         dstRowStart += dstRowStride;
-        if(maskRowStart)
-            maskRowStart += maskRowStride;
+        if(tqmaskRowStart)
+            tqmaskRowStart += tqmaskRowStride;
     }
 }
 
-void KisGrayColorSpace::compositeMultiply(Q_UINT8 *dstRowStart, Q_INT32 dstRowStride, const Q_UINT8 *srcRowStart, Q_INT32 srcRowStride, const Q_UINT8 *maskRowStart, Q_INT32 maskRowStride, Q_INT32 rows, Q_INT32 numColumns, Q_UINT8 opacity)
+void KisGrayColorSpace::compositeMultiply(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmaskRowStart, TQ_INT32 tqmaskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
 {
     while (rows > 0) {
 
-        const Q_UINT8 *src = srcRowStart;
-        Q_UINT8 *dst = dstRowStart;
-        Q_INT32 columns = numColumns;
-        const Q_UINT8 *mask = maskRowStart;
+        const TQ_UINT8 *src = srcRowStart;
+        TQ_UINT8 *dst = dstRowStart;
+        TQ_INT32 columns = numColumns;
+        const TQ_UINT8 *tqmask = tqmaskRowStart;
 
         while (columns > 0) {
 
-            Q_UINT8 srcAlpha = src[PIXEL_GRAY_ALPHA];
-            Q_UINT8 dstAlpha = dst[PIXEL_GRAY_ALPHA];
+            TQ_UINT8 srcAlpha = src[PIXEL_GRAY_ALPHA];
+            TQ_UINT8 dstAlpha = dst[PIXEL_GRAY_ALPHA];
 
-            srcAlpha = QMIN(srcAlpha, dstAlpha);
+            srcAlpha = TQMIN(srcAlpha, dstAlpha);
 
-            // apply the alphamask
-            if(mask != 0)
+            // apply the alphatqmask
+            if(tqmask != 0)
             {
-                if(*mask != OPACITY_OPAQUE)
-                    srcAlpha = UINT8_MULT(srcAlpha, *mask);
-                mask++;
+                if(*tqmask != OPACITY_OPAQUE)
+                    srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
+                tqmask++;
             }
 
             if (srcAlpha != OPACITY_TRANSPARENT) {
@@ -376,12 +376,12 @@ void KisGrayColorSpace::compositeMultiply(Q_UINT8 *dstRowStart, Q_INT32 dstRowSt
                     srcAlpha = UINT8_MULT(src[PIXEL_GRAY_ALPHA], opacity);
                 }
 
-                Q_UINT8 srcBlend;
+                TQ_UINT8 srcBlend;
 
                 if (dstAlpha == OPACITY_OPAQUE) {
                     srcBlend = srcAlpha;
                 } else {
-                    Q_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
+                    TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
                     dst[PIXEL_GRAY_ALPHA] = newAlpha;
 
                     if (newAlpha != 0) {
@@ -391,8 +391,8 @@ void KisGrayColorSpace::compositeMultiply(Q_UINT8 *dstRowStart, Q_INT32 dstRowSt
                     }
                 }
 
-                Q_UINT8 srcColor = src[PIXEL_GRAY];
-                Q_UINT8 dstColor = dst[PIXEL_GRAY];
+                TQ_UINT8 srcColor = src[PIXEL_GRAY];
+                TQ_UINT8 dstColor = dst[PIXEL_GRAY];
 
                 srcColor = UINT8_MULT(srcColor, dstColor);
 
@@ -407,33 +407,33 @@ void KisGrayColorSpace::compositeMultiply(Q_UINT8 *dstRowStart, Q_INT32 dstRowSt
         rows--;
         srcRowStart += srcRowStride;
         dstRowStart += dstRowStride;
-        if(maskRowStart)
-            maskRowStart += maskRowStride;
+        if(tqmaskRowStart)
+            tqmaskRowStart += tqmaskRowStride;
     }
 }
 
-void KisGrayColorSpace::compositeDivide(Q_UINT8 *dstRowStart, Q_INT32 dstRowStride, const Q_UINT8 *srcRowStart, Q_INT32 srcRowStride, const Q_UINT8 *maskRowStart, Q_INT32 maskRowStride, Q_INT32 rows, Q_INT32 numColumns, Q_UINT8 opacity)
+void KisGrayColorSpace::compositeDivide(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmaskRowStart, TQ_INT32 tqmaskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
 {
     while (rows > 0) {
 
-        const Q_UINT8 *src = srcRowStart;
-        Q_UINT8 *dst = dstRowStart;
-        Q_INT32 columns = numColumns;
-        const Q_UINT8 *mask = maskRowStart;
+        const TQ_UINT8 *src = srcRowStart;
+        TQ_UINT8 *dst = dstRowStart;
+        TQ_INT32 columns = numColumns;
+        const TQ_UINT8 *tqmask = tqmaskRowStart;
 
         while (columns > 0) {
 
-            Q_UINT8 srcAlpha = src[PIXEL_GRAY_ALPHA];
-            Q_UINT8 dstAlpha = dst[PIXEL_GRAY_ALPHA];
+            TQ_UINT8 srcAlpha = src[PIXEL_GRAY_ALPHA];
+            TQ_UINT8 dstAlpha = dst[PIXEL_GRAY_ALPHA];
 
-            srcAlpha = QMIN(srcAlpha, dstAlpha);
+            srcAlpha = TQMIN(srcAlpha, dstAlpha);
 
-            // apply the alphamask
-            if(mask != 0)
+            // apply the alphatqmask
+            if(tqmask != 0)
             {
-                if(*mask != OPACITY_OPAQUE)
-                    srcAlpha = UINT8_MULT(srcAlpha, *mask);
-                mask++;
+                if(*tqmask != OPACITY_OPAQUE)
+                    srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
+                tqmask++;
             }
 
             if (srcAlpha != OPACITY_TRANSPARENT) {
@@ -442,12 +442,12 @@ void KisGrayColorSpace::compositeDivide(Q_UINT8 *dstRowStart, Q_INT32 dstRowStri
                     srcAlpha = UINT8_MULT(src[PIXEL_GRAY_ALPHA], opacity);
                 }
 
-                Q_UINT8 srcBlend;
+                TQ_UINT8 srcBlend;
 
                 if (dstAlpha == OPACITY_OPAQUE) {
                     srcBlend = srcAlpha;
                 } else {
-                    Q_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
+                    TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
                     dst[PIXEL_GRAY_ALPHA] = newAlpha;
 
                     if (newAlpha != 0) {
@@ -459,12 +459,12 @@ void KisGrayColorSpace::compositeDivide(Q_UINT8 *dstRowStart, Q_INT32 dstRowStri
 
                 for (int channel = 0; channel < MAX_CHANNEL_GRAYSCALE; channel++) {
 
-                    Q_UINT8 srcColor = src[channel];
-                    Q_UINT8 dstColor = dst[channel];
+                    TQ_UINT8 srcColor = src[channel];
+                    TQ_UINT8 dstColor = dst[channel];
 
-                    srcColor = QMIN((dstColor * (UINT8_MAX + 1)) / (1 + srcColor), UINT8_MAX);
+                    srcColor = TQMIN((dstColor * (UINT8_MAX + 1)) / (1 + srcColor), UINT8_MAX);
 
-                    Q_UINT8 newColor = UINT8_BLEND(srcColor, dstColor, srcBlend);
+                    TQ_UINT8 newColor = UINT8_BLEND(srcColor, dstColor, srcBlend);
 
                     dst[channel] = newColor;
                 }
@@ -478,33 +478,33 @@ void KisGrayColorSpace::compositeDivide(Q_UINT8 *dstRowStart, Q_INT32 dstRowStri
         rows--;
         srcRowStart += srcRowStride;
         dstRowStart += dstRowStride;
-        if(maskRowStart)
-            maskRowStart += maskRowStride;
+        if(tqmaskRowStart)
+            tqmaskRowStart += tqmaskRowStride;
     }
 }
 
-void KisGrayColorSpace::compositeScreen(Q_UINT8 *dstRowStart, Q_INT32 dstRowStride, const Q_UINT8 *srcRowStart, Q_INT32 srcRowStride, const Q_UINT8 *maskRowStart, Q_INT32 maskRowStride, Q_INT32 rows, Q_INT32 numColumns, Q_UINT8 opacity)
+void KisGrayColorSpace::compositeScreen(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmaskRowStart, TQ_INT32 tqmaskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
 {
     while (rows > 0) {
 
-        const Q_UINT8 *src = srcRowStart;
-        Q_UINT8 *dst = dstRowStart;
-        Q_INT32 columns = numColumns;
-        const Q_UINT8 *mask = maskRowStart;
+        const TQ_UINT8 *src = srcRowStart;
+        TQ_UINT8 *dst = dstRowStart;
+        TQ_INT32 columns = numColumns;
+        const TQ_UINT8 *tqmask = tqmaskRowStart;
 
         while (columns > 0) {
 
-            Q_UINT8 srcAlpha = src[PIXEL_GRAY_ALPHA];
-            Q_UINT8 dstAlpha = dst[PIXEL_GRAY_ALPHA];
+            TQ_UINT8 srcAlpha = src[PIXEL_GRAY_ALPHA];
+            TQ_UINT8 dstAlpha = dst[PIXEL_GRAY_ALPHA];
 
-            srcAlpha = QMIN(srcAlpha, dstAlpha);
+            srcAlpha = TQMIN(srcAlpha, dstAlpha);
 
-            // apply the alphamask
-            if(mask != 0)
+            // apply the alphatqmask
+            if(tqmask != 0)
             {
-                if(*mask != OPACITY_OPAQUE)
-                    srcAlpha = UINT8_MULT(srcAlpha, *mask);
-                mask++;
+                if(*tqmask != OPACITY_OPAQUE)
+                    srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
+                tqmask++;
             }
 
             if (srcAlpha != OPACITY_TRANSPARENT) {
@@ -513,12 +513,12 @@ void KisGrayColorSpace::compositeScreen(Q_UINT8 *dstRowStart, Q_INT32 dstRowStri
                     srcAlpha = UINT8_MULT(src[PIXEL_GRAY_ALPHA], opacity);
                 }
 
-                Q_UINT8 srcBlend;
+                TQ_UINT8 srcBlend;
 
                 if (dstAlpha == OPACITY_OPAQUE) {
                     srcBlend = srcAlpha;
                 } else {
-                    Q_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
+                    TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
                     dst[PIXEL_GRAY_ALPHA] = newAlpha;
 
                     if (newAlpha != 0) {
@@ -530,12 +530,12 @@ void KisGrayColorSpace::compositeScreen(Q_UINT8 *dstRowStart, Q_INT32 dstRowStri
 
                 for (int channel = 0; channel < MAX_CHANNEL_GRAYSCALE; channel++) {
 
-                    Q_UINT8 srcColor = src[channel];
-                    Q_UINT8 dstColor = dst[channel];
+                    TQ_UINT8 srcColor = src[channel];
+                    TQ_UINT8 dstColor = dst[channel];
 
                     srcColor = UINT8_MAX - UINT8_MULT(UINT8_MAX - dstColor, UINT8_MAX - srcColor);
 
-                    Q_UINT8 newColor = UINT8_BLEND(srcColor, dstColor, srcBlend);
+                    TQ_UINT8 newColor = UINT8_BLEND(srcColor, dstColor, srcBlend);
 
                     dst[channel] = newColor;
                 }
@@ -549,33 +549,33 @@ void KisGrayColorSpace::compositeScreen(Q_UINT8 *dstRowStart, Q_INT32 dstRowStri
         rows--;
         srcRowStart += srcRowStride;
         dstRowStart += dstRowStride;
-        if(maskRowStart)
-            maskRowStart += maskRowStride;
+        if(tqmaskRowStart)
+            tqmaskRowStart += tqmaskRowStride;
     }
 }
 
-void KisGrayColorSpace::compositeOverlay(Q_UINT8 *dstRowStart, Q_INT32 dstRowStride, const Q_UINT8 *srcRowStart, Q_INT32 srcRowStride, const Q_UINT8 *maskRowStart, Q_INT32 maskRowStride, Q_INT32 rows, Q_INT32 numColumns, Q_UINT8 opacity)
+void KisGrayColorSpace::compositeOverlay(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmaskRowStart, TQ_INT32 tqmaskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
 {
     while (rows > 0) {
 
-        const Q_UINT8 *src = srcRowStart;
-        Q_UINT8 *dst = dstRowStart;
-        Q_INT32 columns = numColumns;
-        const Q_UINT8 *mask = maskRowStart;
+        const TQ_UINT8 *src = srcRowStart;
+        TQ_UINT8 *dst = dstRowStart;
+        TQ_INT32 columns = numColumns;
+        const TQ_UINT8 *tqmask = tqmaskRowStart;
 
         while (columns > 0) {
 
-            Q_UINT8 srcAlpha = src[PIXEL_GRAY_ALPHA];
-            Q_UINT8 dstAlpha = dst[PIXEL_GRAY_ALPHA];
+            TQ_UINT8 srcAlpha = src[PIXEL_GRAY_ALPHA];
+            TQ_UINT8 dstAlpha = dst[PIXEL_GRAY_ALPHA];
 
-            srcAlpha = QMIN(srcAlpha, dstAlpha);
+            srcAlpha = TQMIN(srcAlpha, dstAlpha);
 
-            // apply the alphamask
-            if(mask != 0)
+            // apply the alphatqmask
+            if(tqmask != 0)
             {
-                if(*mask != OPACITY_OPAQUE)
-                    srcAlpha = UINT8_MULT(srcAlpha, *mask);
-                mask++;
+                if(*tqmask != OPACITY_OPAQUE)
+                    srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
+                tqmask++;
             }
 
             if (srcAlpha != OPACITY_TRANSPARENT) {
@@ -584,12 +584,12 @@ void KisGrayColorSpace::compositeOverlay(Q_UINT8 *dstRowStart, Q_INT32 dstRowStr
                     srcAlpha = UINT8_MULT(src[PIXEL_GRAY_ALPHA], opacity);
                 }
 
-                Q_UINT8 srcBlend;
+                TQ_UINT8 srcBlend;
 
                 if (dstAlpha == OPACITY_OPAQUE) {
                     srcBlend = srcAlpha;
                 } else {
-                    Q_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
+                    TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
                     dst[PIXEL_GRAY_ALPHA] = newAlpha;
 
                     if (newAlpha != 0) {
@@ -601,12 +601,12 @@ void KisGrayColorSpace::compositeOverlay(Q_UINT8 *dstRowStart, Q_INT32 dstRowStr
 
                 for (int channel = 0; channel < MAX_CHANNEL_GRAYSCALE; channel++) {
 
-                    Q_UINT8 srcColor = src[channel];
-                    Q_UINT8 dstColor = dst[channel];
+                    TQ_UINT8 srcColor = src[channel];
+                    TQ_UINT8 dstColor = dst[channel];
 
                     srcColor = UINT8_MULT(dstColor, dstColor + UINT8_MULT(2 * srcColor, UINT8_MAX - dstColor));
 
-                    Q_UINT8 newColor = UINT8_BLEND(srcColor, dstColor, srcBlend);
+                    TQ_UINT8 newColor = UINT8_BLEND(srcColor, dstColor, srcBlend);
 
                     dst[channel] = newColor;
                 }
@@ -620,33 +620,33 @@ void KisGrayColorSpace::compositeOverlay(Q_UINT8 *dstRowStart, Q_INT32 dstRowStr
         rows--;
         srcRowStart += srcRowStride;
         dstRowStart += dstRowStride;
-        if(maskRowStart)
-            maskRowStart += maskRowStride;
+        if(tqmaskRowStart)
+            tqmaskRowStart += tqmaskRowStride;
     }
 }
 
-void KisGrayColorSpace::compositeDodge(Q_UINT8 *dstRowStart, Q_INT32 dstRowStride, const Q_UINT8 *srcRowStart, Q_INT32 srcRowStride, const Q_UINT8 *maskRowStart, Q_INT32 maskRowStride, Q_INT32 rows, Q_INT32 numColumns, Q_UINT8 opacity)
+void KisGrayColorSpace::compositeDodge(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmaskRowStart, TQ_INT32 tqmaskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
 {
     while (rows > 0) {
 
-        const Q_UINT8 *src = srcRowStart;
-        Q_UINT8 *dst = dstRowStart;
-        Q_INT32 columns = numColumns;
-        const Q_UINT8 *mask = maskRowStart;
+        const TQ_UINT8 *src = srcRowStart;
+        TQ_UINT8 *dst = dstRowStart;
+        TQ_INT32 columns = numColumns;
+        const TQ_UINT8 *tqmask = tqmaskRowStart;
 
         while (columns > 0) {
 
-            Q_UINT8 srcAlpha = src[PIXEL_GRAY_ALPHA];
-            Q_UINT8 dstAlpha = dst[PIXEL_GRAY_ALPHA];
+            TQ_UINT8 srcAlpha = src[PIXEL_GRAY_ALPHA];
+            TQ_UINT8 dstAlpha = dst[PIXEL_GRAY_ALPHA];
 
-            srcAlpha = QMIN(srcAlpha, dstAlpha);
+            srcAlpha = TQMIN(srcAlpha, dstAlpha);
 
-            // apply the alphamask
-            if(mask != 0)
+            // apply the alphatqmask
+            if(tqmask != 0)
             {
-                if(*mask != OPACITY_OPAQUE)
-                    srcAlpha = UINT8_MULT(srcAlpha, *mask);
-                mask++;
+                if(*tqmask != OPACITY_OPAQUE)
+                    srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
+                tqmask++;
             }
 
             if (srcAlpha != OPACITY_TRANSPARENT) {
@@ -655,12 +655,12 @@ void KisGrayColorSpace::compositeDodge(Q_UINT8 *dstRowStart, Q_INT32 dstRowStrid
                     srcAlpha = UINT8_MULT(src[PIXEL_GRAY_ALPHA], opacity);
                 }
 
-                Q_UINT8 srcBlend;
+                TQ_UINT8 srcBlend;
 
                 if (dstAlpha == OPACITY_OPAQUE) {
                     srcBlend = srcAlpha;
                 } else {
-                    Q_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
+                    TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
                     dst[PIXEL_GRAY_ALPHA] = newAlpha;
 
                     if (newAlpha != 0) {
@@ -672,12 +672,12 @@ void KisGrayColorSpace::compositeDodge(Q_UINT8 *dstRowStart, Q_INT32 dstRowStrid
 
                 for (int channel = 0; channel < MAX_CHANNEL_GRAYSCALE; channel++) {
 
-                    Q_UINT8 srcColor = src[channel];
-                    Q_UINT8 dstColor = dst[channel];
+                    TQ_UINT8 srcColor = src[channel];
+                    TQ_UINT8 dstColor = dst[channel];
 
-                    srcColor = QMIN((dstColor * (UINT8_MAX + 1)) / (UINT8_MAX + 1 - srcColor), UINT8_MAX);
+                    srcColor = TQMIN((dstColor * (UINT8_MAX + 1)) / (UINT8_MAX + 1 - srcColor), UINT8_MAX);
 
-                    Q_UINT8 newColor = UINT8_BLEND(srcColor, dstColor, srcBlend);
+                    TQ_UINT8 newColor = UINT8_BLEND(srcColor, dstColor, srcBlend);
 
                     dst[channel] = newColor;
                 }
@@ -691,33 +691,33 @@ void KisGrayColorSpace::compositeDodge(Q_UINT8 *dstRowStart, Q_INT32 dstRowStrid
         rows--;
         srcRowStart += srcRowStride;
         dstRowStart += dstRowStride;
-        if(maskRowStart)
-            maskRowStart += maskRowStride;
+        if(tqmaskRowStart)
+            tqmaskRowStart += tqmaskRowStride;
     }
 }
 
-void KisGrayColorSpace::compositeBurn(Q_UINT8 *dstRowStart, Q_INT32 dstRowStride, const Q_UINT8 *srcRowStart, Q_INT32 srcRowStride, const Q_UINT8 *maskRowStart, Q_INT32 maskRowStride, Q_INT32 rows, Q_INT32 numColumns, Q_UINT8 opacity)
+void KisGrayColorSpace::compositeBurn(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmaskRowStart, TQ_INT32 tqmaskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
 {
     while (rows > 0) {
 
-        const Q_UINT8 *src = srcRowStart;
-        Q_UINT8 *dst = dstRowStart;
-        Q_INT32 columns = numColumns;
-        const Q_UINT8 *mask = maskRowStart;
+        const TQ_UINT8 *src = srcRowStart;
+        TQ_UINT8 *dst = dstRowStart;
+        TQ_INT32 columns = numColumns;
+        const TQ_UINT8 *tqmask = tqmaskRowStart;
 
         while (columns > 0) {
 
-            Q_UINT8 srcAlpha = src[PIXEL_GRAY_ALPHA];
-            Q_UINT8 dstAlpha = dst[PIXEL_GRAY_ALPHA];
+            TQ_UINT8 srcAlpha = src[PIXEL_GRAY_ALPHA];
+            TQ_UINT8 dstAlpha = dst[PIXEL_GRAY_ALPHA];
 
-            srcAlpha = QMIN(srcAlpha, dstAlpha);
+            srcAlpha = TQMIN(srcAlpha, dstAlpha);
 
-            // apply the alphamask
-            if(mask != 0)
+            // apply the alphatqmask
+            if(tqmask != 0)
             {
-                if(*mask != OPACITY_OPAQUE)
-                    srcAlpha = UINT8_MULT(srcAlpha, *mask);
-                mask++;
+                if(*tqmask != OPACITY_OPAQUE)
+                    srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
+                tqmask++;
             }
 
             if (srcAlpha != OPACITY_TRANSPARENT) {
@@ -726,12 +726,12 @@ void KisGrayColorSpace::compositeBurn(Q_UINT8 *dstRowStart, Q_INT32 dstRowStride
                     srcAlpha = UINT8_MULT(src[PIXEL_GRAY_ALPHA], opacity);
                 }
 
-                Q_UINT8 srcBlend;
+                TQ_UINT8 srcBlend;
 
                 if (dstAlpha == OPACITY_OPAQUE) {
                     srcBlend = srcAlpha;
                 } else {
-                    Q_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
+                    TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
                     dst[PIXEL_GRAY_ALPHA] = newAlpha;
 
                     if (newAlpha != 0) {
@@ -743,13 +743,13 @@ void KisGrayColorSpace::compositeBurn(Q_UINT8 *dstRowStart, Q_INT32 dstRowStride
 
                 for (int channel = 0; channel < MAX_CHANNEL_GRAYSCALE; channel++) {
 
-                    Q_UINT8 srcColor = src[channel];
-                    Q_UINT8 dstColor = dst[channel];
+                    TQ_UINT8 srcColor = src[channel];
+                    TQ_UINT8 dstColor = dst[channel];
 
                     srcColor = kMin(((UINT8_MAX - dstColor) * (UINT8_MAX + 1)) / (srcColor + 1), UINT8_MAX);
                     srcColor = kClamp(UINT8_MAX - srcColor, 0u, UINT8_MAX);
 
-                    Q_UINT8 newColor = UINT8_BLEND(srcColor, dstColor, srcBlend);
+                    TQ_UINT8 newColor = UINT8_BLEND(srcColor, dstColor, srcBlend);
 
                     dst[channel] = newColor;
                 }
@@ -763,33 +763,33 @@ void KisGrayColorSpace::compositeBurn(Q_UINT8 *dstRowStart, Q_INT32 dstRowStride
         rows--;
         srcRowStart += srcRowStride;
         dstRowStart += dstRowStride;
-        if(maskRowStart)
-            maskRowStart += maskRowStride;
+        if(tqmaskRowStart)
+            tqmaskRowStart += tqmaskRowStride;
     }
 }
 
-void KisGrayColorSpace::compositeDarken(Q_UINT8 *dstRowStart, Q_INT32 dstRowStride, const Q_UINT8 *srcRowStart, Q_INT32 srcRowStride, const Q_UINT8 *maskRowStart, Q_INT32 maskRowStride, Q_INT32 rows, Q_INT32 numColumns, Q_UINT8 opacity)
+void KisGrayColorSpace::compositeDarken(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmaskRowStart, TQ_INT32 tqmaskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
 {
     while (rows > 0) {
 
-        const Q_UINT8 *src = srcRowStart;
-        Q_UINT8 *dst = dstRowStart;
-        Q_INT32 columns = numColumns;
-        const Q_UINT8 *mask = maskRowStart;
+        const TQ_UINT8 *src = srcRowStart;
+        TQ_UINT8 *dst = dstRowStart;
+        TQ_INT32 columns = numColumns;
+        const TQ_UINT8 *tqmask = tqmaskRowStart;
 
         while (columns > 0) {
 
-            Q_UINT8 srcAlpha = src[PIXEL_GRAY_ALPHA];
-            Q_UINT8 dstAlpha = dst[PIXEL_GRAY_ALPHA];
+            TQ_UINT8 srcAlpha = src[PIXEL_GRAY_ALPHA];
+            TQ_UINT8 dstAlpha = dst[PIXEL_GRAY_ALPHA];
 
-            srcAlpha = QMIN(srcAlpha, dstAlpha);
+            srcAlpha = TQMIN(srcAlpha, dstAlpha);
 
-            // apply the alphamask
-            if(mask != 0)
+            // apply the alphatqmask
+            if(tqmask != 0)
             {
-                if(*mask != OPACITY_OPAQUE)
-                    srcAlpha = UINT8_MULT(srcAlpha, *mask);
-                mask++;
+                if(*tqmask != OPACITY_OPAQUE)
+                    srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
+                tqmask++;
             }
 
             if (srcAlpha != OPACITY_TRANSPARENT) {
@@ -798,12 +798,12 @@ void KisGrayColorSpace::compositeDarken(Q_UINT8 *dstRowStart, Q_INT32 dstRowStri
                     srcAlpha = UINT8_MULT(src[PIXEL_GRAY_ALPHA], opacity);
                 }
 
-                Q_UINT8 srcBlend;
+                TQ_UINT8 srcBlend;
 
                 if (dstAlpha == OPACITY_OPAQUE) {
                     srcBlend = srcAlpha;
                 } else {
-                    Q_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
+                    TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
                     dst[PIXEL_GRAY_ALPHA] = newAlpha;
 
                     if (newAlpha != 0) {
@@ -815,12 +815,12 @@ void KisGrayColorSpace::compositeDarken(Q_UINT8 *dstRowStart, Q_INT32 dstRowStri
 
                 for (int channel = 0; channel < MAX_CHANNEL_GRAYSCALE; channel++) {
 
-                    Q_UINT8 srcColor = src[channel];
-                    Q_UINT8 dstColor = dst[channel];
+                    TQ_UINT8 srcColor = src[channel];
+                    TQ_UINT8 dstColor = dst[channel];
 
-                    srcColor = QMIN(srcColor, dstColor);
+                    srcColor = TQMIN(srcColor, dstColor);
 
-                    Q_UINT8 newColor = UINT8_BLEND(srcColor, dstColor, srcBlend);
+                    TQ_UINT8 newColor = UINT8_BLEND(srcColor, dstColor, srcBlend);
 
                     dst[channel] = newColor;
                 }
@@ -834,33 +834,33 @@ void KisGrayColorSpace::compositeDarken(Q_UINT8 *dstRowStart, Q_INT32 dstRowStri
         rows--;
         srcRowStart += srcRowStride;
         dstRowStart += dstRowStride;
-        if(maskRowStart)
-            maskRowStart += maskRowStride;
+        if(tqmaskRowStart)
+            tqmaskRowStart += tqmaskRowStride;
     }
 }
 
-void KisGrayColorSpace::compositeLighten(Q_UINT8 *dstRowStart, Q_INT32 dstRowStride, const Q_UINT8 *srcRowStart, Q_INT32 srcRowStride, const Q_UINT8 *maskRowStart, Q_INT32 maskRowStride, Q_INT32 rows, Q_INT32 numColumns, Q_UINT8 opacity)
+void KisGrayColorSpace::compositeLighten(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmaskRowStart, TQ_INT32 tqmaskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
 {
     while (rows > 0) {
 
-        const Q_UINT8 *src = srcRowStart;
-        Q_UINT8 *dst = dstRowStart;
-        Q_INT32 columns = numColumns;
-        const Q_UINT8 *mask = maskRowStart;
+        const TQ_UINT8 *src = srcRowStart;
+        TQ_UINT8 *dst = dstRowStart;
+        TQ_INT32 columns = numColumns;
+        const TQ_UINT8 *tqmask = tqmaskRowStart;
 
         while (columns > 0) {
 
-            Q_UINT8 srcAlpha = src[PIXEL_GRAY_ALPHA];
-            Q_UINT8 dstAlpha = dst[PIXEL_GRAY_ALPHA];
+            TQ_UINT8 srcAlpha = src[PIXEL_GRAY_ALPHA];
+            TQ_UINT8 dstAlpha = dst[PIXEL_GRAY_ALPHA];
 
-            srcAlpha = QMIN(srcAlpha, dstAlpha);
+            srcAlpha = TQMIN(srcAlpha, dstAlpha);
 
-            // apply the alphamask
-            if(mask != 0)
+            // apply the alphatqmask
+            if(tqmask != 0)
             {
-                if(*mask != OPACITY_OPAQUE)
-                    srcAlpha = UINT8_MULT(srcAlpha, *mask);
-                mask++;
+                if(*tqmask != OPACITY_OPAQUE)
+                    srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
+                tqmask++;
             }
 
             if (srcAlpha != OPACITY_TRANSPARENT) {
@@ -869,12 +869,12 @@ void KisGrayColorSpace::compositeLighten(Q_UINT8 *dstRowStart, Q_INT32 dstRowStr
                     srcAlpha = UINT8_MULT(src[PIXEL_GRAY_ALPHA], opacity);
                 }
 
-                Q_UINT8 srcBlend;
+                TQ_UINT8 srcBlend;
 
                 if (dstAlpha == OPACITY_OPAQUE) {
                     srcBlend = srcAlpha;
                 } else {
-                    Q_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
+                    TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
                     dst[PIXEL_GRAY_ALPHA] = newAlpha;
 
                     if (newAlpha != 0) {
@@ -886,12 +886,12 @@ void KisGrayColorSpace::compositeLighten(Q_UINT8 *dstRowStart, Q_INT32 dstRowStr
 
                 for (int channel = 0; channel < MAX_CHANNEL_GRAYSCALE; channel++) {
 
-                    Q_UINT8 srcColor = src[channel];
-                    Q_UINT8 dstColor = dst[channel];
+                    TQ_UINT8 srcColor = src[channel];
+                    TQ_UINT8 dstColor = dst[channel];
 
-                    srcColor = QMAX(srcColor, dstColor);
+                    srcColor = TQMAX(srcColor, dstColor);
 
-                    Q_UINT8 newColor = UINT8_BLEND(srcColor, dstColor, srcBlend);
+                    TQ_UINT8 newColor = UINT8_BLEND(srcColor, dstColor, srcBlend);
 
                     dst[channel] = newColor;
                 }
@@ -905,73 +905,73 @@ void KisGrayColorSpace::compositeLighten(Q_UINT8 *dstRowStart, Q_INT32 dstRowStr
         rows--;
         srcRowStart += srcRowStride;
         dstRowStart += dstRowStride;
-        if(maskRowStart)
-            maskRowStart += maskRowStride;
+        if(tqmaskRowStart)
+            tqmaskRowStart += tqmaskRowStride;
     }
 }
 
-void KisGrayColorSpace::compositeErase(Q_UINT8 *dst,
-            Q_INT32 dstRowSize,
-            const Q_UINT8 *src,
-            Q_INT32 srcRowSize,
-            const Q_UINT8 *srcAlphaMask,
-            Q_INT32 maskRowStride,
-            Q_INT32 rows,
-            Q_INT32 cols,
-            Q_UINT8 /*opacity*/)
+void KisGrayColorSpace::compositeErase(TQ_UINT8 *dst,
+            TQ_INT32 dstRowSize,
+            const TQ_UINT8 *src,
+            TQ_INT32 srcRowSize,
+            const TQ_UINT8 *srcAlphaMask,
+            TQ_INT32 tqmaskRowStride,
+            TQ_INT32 rows,
+            TQ_INT32 cols,
+            TQ_UINT8 /*opacity*/)
 {
-    Q_INT32 i;
-    Q_UINT8 srcAlpha;
+    TQ_INT32 i;
+    TQ_UINT8 srcAlpha;
 
     while (rows-- > 0)
     {
-        const Q_UINT8 *s = src;
-        Q_UINT8 *d = dst;
-        const Q_UINT8 *mask = srcAlphaMask;
+        const TQ_UINT8 *s = src;
+        TQ_UINT8 *d = dst;
+        const TQ_UINT8 *tqmask = srcAlphaMask;
 
         for (i = cols; i > 0; i--, s+=MAX_CHANNEL_GRAYSCALEA, d+=MAX_CHANNEL_GRAYSCALEA)
         {
             srcAlpha = s[PIXEL_GRAY_ALPHA];
-            // apply the alphamask
-            if(mask != 0)
+            // apply the alphatqmask
+            if(tqmask != 0)
             {
-                if(*mask != OPACITY_OPAQUE)
-                    srcAlpha = UINT8_BLEND(srcAlpha, OPACITY_OPAQUE, *mask);
-                mask++;
+                if(*tqmask != OPACITY_OPAQUE)
+                    srcAlpha = UINT8_BLEND(srcAlpha, OPACITY_OPAQUE, *tqmask);
+                tqmask++;
             }
             d[PIXEL_GRAY_ALPHA] = UINT8_MULT(srcAlpha, d[PIXEL_GRAY_ALPHA]);
         }
 
         dst += dstRowSize;
         if(srcAlphaMask)
-            srcAlphaMask += maskRowStride;
+            srcAlphaMask += tqmaskRowStride;
         src += srcRowSize;
     }
 }
 
-void KisGrayColorSpace::compositeAlphaDarken(Q_UINT8 *dstRowStart, Q_INT32 dstRowStride,
-                                     const Q_UINT8 *srcRowStart, Q_INT32 srcRowStride,
-                                     const Q_UINT8 *maskRowStart, Q_INT32 maskRowStride,
-                                     Q_INT32 rows, Q_INT32 numColumns, Q_UINT8 opacity)
+void KisGrayColorSpace::compositeAlphaDarken(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride,
+                                     const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride,
+                                     const TQ_UINT8 *tqmaskRowStart, TQ_INT32 tqmaskRowStride,
+                                     TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
 {
     while (rows > 0) {
 
-        const Q_UINT8 *src = srcRowStart;
-        Q_UINT8 *dst = dstRowStart;
-        const Q_UINT8 *mask = maskRowStart;
-        Q_INT32 columns = numColumns;
+        const TQ_UINT8 *src = srcRowStart;
+        TQ_UINT8 *dst = dstRowStart;
+        const TQ_UINT8 *tqmask = tqmaskRowStart;
+        TQ_INT32 columns = numColumns;
 
         while (columns > 0) {
 
-            Q_UINT8 srcAlpha = src[PIXEL_GRAY_ALPHA];
-            Q_UINT8 dstAlpha = dst[PIXEL_GRAY_ALPHA];
+            TQ_UINT8 srcAlpha = src[PIXEL_GRAY_ALPHA];
+            TQ_UINT8 dstAlpha = dst[PIXEL_GRAY_ALPHA];
 
-            // apply the alphamask
-            if(mask != 0)
+            // apply the alphatqmask
+            if(tqmask != 0)
             {
-                if(*mask != OPACITY_OPAQUE)
-                    srcAlpha = UINT8_MULT(srcAlpha, *mask);
-                mask++;
+                if(*tqmask != OPACITY_OPAQUE)
+                    srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
+                tqmask++;
             }
 
             if (opacity != OPACITY_OPAQUE) {
@@ -980,7 +980,7 @@ void KisGrayColorSpace::compositeAlphaDarken(Q_UINT8 *dstRowStart, Q_INT32 dstRo
 
             if (srcAlpha != OPACITY_TRANSPARENT && srcAlpha >= dstAlpha) {
                 dst[PIXEL_GRAY_ALPHA] = srcAlpha;
-                memcpy(dst, src, MAX_CHANNEL_GRAYSCALE * sizeof(Q_UINT8));
+                memcpy(dst, src, MAX_CHANNEL_GRAYSCALE * sizeof(TQ_UINT8));
             }
 
             columns--;
@@ -991,7 +991,7 @@ void KisGrayColorSpace::compositeAlphaDarken(Q_UINT8 *dstRowStart, Q_INT32 dstRo
         rows--;
         srcRowStart += srcRowStride;
         dstRowStart += dstRowStride;
-        if(maskRowStart)
-            maskRowStart += maskRowStride;
+        if(tqmaskRowStart)
+            tqmaskRowStart += tqmaskRowStride;
     }
 }
diff --git a/krita/colorspaces/gray_u8/kis_gray_colorspace.h b/krita/colorspaces/gray_u8/kis_gray_colorspace.h
index d6784017..66da3c30 100644
--- a/krita/colorspaces/gray_u8/kis_gray_colorspace.h
+++ b/krita/colorspaces/gray_u8/kis_gray_colorspace.h
@@ -17,7 +17,7 @@
  */
 #ifndef KIS_STRATEGY_COLORSPACE_GRAYSCALE_H_
 #define KIS_STRATEGY_COLORSPACE_GRAYSCALE_H_
-#include <qcolor.h>
+#include <tqcolor.h>
 
 #include <klocale.h>
 
@@ -29,7 +29,7 @@
 
 class KRITACORE_EXPORT KisGrayColorSpace : public KisU8BaseColorSpace {
 public:
-    KisGrayColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p);
+    KisGrayColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p);
     virtual ~KisGrayColorSpace();
 
     virtual bool willDegrade(ColorSpaceIndependence /*independence*/)
@@ -39,55 +39,55 @@ public:
 
 public:
 
-    void setPixel(Q_UINT8 *pixel, Q_UINT8 gray, Q_UINT8 alpha) const;
-    void getPixel(const Q_UINT8 *pixel, Q_UINT8 *gray, Q_UINT8 *alpha) const;
-
-    virtual void getAlpha(const Q_UINT8 *pixel, Q_UINT8 *alpha) const;
-    virtual void setAlpha(Q_UINT8 * pixels, Q_UINT8 alpha, Q_INT32 nPixels) const;
-
-    virtual void mixColors(const Q_UINT8 **colors, const Q_UINT8 *weights, Q_UINT32 nColors, Q_UINT8 *dst) const;
-    virtual void convolveColors(Q_UINT8** colors, Q_INT32* kernelValues, KisChannelInfo::enumChannelFlags channelFlags, Q_UINT8 *dst, Q_INT32 factor, Q_INT32 offset, Q_INT32 nColors) const;
-    virtual void invertColor(Q_UINT8 * src, Q_INT32 nPixels);
-    virtual void darken(const Q_UINT8 * src, Q_UINT8 * dst, Q_INT32 shade, bool compensate, double compensation, Q_INT32 nPixels) const;
-    virtual Q_UINT8 intensity8(const Q_UINT8 * src) const;
-
-    virtual QValueVector<KisChannelInfo *> channels() const;
-    virtual Q_UINT32 nChannels() const;
-    virtual Q_UINT32 nColorChannels() const;
-    virtual Q_UINT32 pixelSize() const;
-
-    virtual void bitBlt(Q_UINT8 *dst,
-                Q_INT32 dststride,
-                const Q_UINT8 *src,
-                Q_INT32 srcRowStride,
-                const Q_UINT8 *srcAlphaMask,
-                Q_INT32 maskRowStride,
-                Q_UINT8 opacity,
-                Q_INT32 rows,
-                Q_INT32 cols,
+    void setPixel(TQ_UINT8 *pixel, TQ_UINT8 gray, TQ_UINT8 alpha) const;
+    void getPixel(const TQ_UINT8 *pixel, TQ_UINT8 *gray, TQ_UINT8 *alpha) const;
+
+    virtual void getAlpha(const TQ_UINT8 *pixel, TQ_UINT8 *alpha) const;
+    virtual void setAlpha(TQ_UINT8 * pixels, TQ_UINT8 alpha, TQ_INT32 nPixels) const;
+
+    virtual void mixColors(const TQ_UINT8 **colors, const TQ_UINT8 *weights, TQ_UINT32 nColors, TQ_UINT8 *dst) const;
+    virtual void convolveColors(TQ_UINT8** colors, TQ_INT32* kernelValues, KisChannelInfo::enumChannelFlags channelFlags, TQ_UINT8 *dst, TQ_INT32 factor, TQ_INT32 offset, TQ_INT32 nColors) const;
+    virtual void invertColor(TQ_UINT8 * src, TQ_INT32 nPixels);
+    virtual void darken(const TQ_UINT8 * src, TQ_UINT8 * dst, TQ_INT32 shade, bool compensate, double compensation, TQ_INT32 nPixels) const;
+    virtual TQ_UINT8 intensity8(const TQ_UINT8 * src) const;
+
+    virtual TQValueVector<KisChannelInfo *> channels() const;
+    virtual TQ_UINT32 nChannels() const;
+    virtual TQ_UINT32 nColorChannels() const;
+    virtual TQ_UINT32 pixelSize() const;
+
+    virtual void bitBlt(TQ_UINT8 *dst,
+                TQ_INT32 dststride,
+                const TQ_UINT8 *src,
+                TQ_INT32 srcRowStride,
+                const TQ_UINT8 *srcAlphaMask,
+                TQ_INT32 tqmaskRowStride,
+                TQ_UINT8 opacity,
+                TQ_INT32 rows,
+                TQ_INT32 cols,
                 const KisCompositeOp& op);
 
     KisCompositeOpList userVisiblecompositeOps() const;
 
 protected:
-    void compositeOver(Q_UINT8 *dst, Q_INT32 dstRowStride, const Q_UINT8 *src, Q_INT32 srcRowStride, const Q_UINT8 *mask, Q_INT32 maskRowStride, Q_INT32 rows, Q_INT32 columns, Q_UINT8 opacity);
-    void compositeMultiply(Q_UINT8 *dst, Q_INT32 dstRowStride, const Q_UINT8 *src, Q_INT32 srcRowStride, const Q_UINT8 *mask, Q_INT32 maskRowStride, Q_INT32 rows, Q_INT32 columns, Q_UINT8 opacity);
-    void compositeDivide(Q_UINT8 *dst, Q_INT32 dstRowStride, const Q_UINT8 *src, Q_INT32 srcRowStride, const Q_UINT8 *mask, Q_INT32 maskRowStride, Q_INT32 rows, Q_INT32 columns, Q_UINT8 opacity);
-    void compositeScreen(Q_UINT8 *dst, Q_INT32 dstRowStride, const Q_UINT8 *src, Q_INT32 srcRowStride, const Q_UINT8 *mask, Q_INT32 maskRowStride, Q_INT32 rows, Q_INT32 columns, Q_UINT8 opacity);
-    void compositeOverlay(Q_UINT8 *dst, Q_INT32 dstRowStride, const Q_UINT8 *src, Q_INT32 srcRowStride, const Q_UINT8 *mask, Q_INT32 maskRowStride, Q_INT32 rows, Q_INT32 columns, Q_UINT8 opacity);
-    void compositeDodge(Q_UINT8 *dst, Q_INT32 dstRowStride, const Q_UINT8 *src, Q_INT32 srcRowStride, const Q_UINT8 *mask, Q_INT32 maskRowStride, Q_INT32 rows, Q_INT32 columns, Q_UINT8 opacity);
-    void compositeBurn(Q_UINT8 *dst, Q_INT32 dstRowStride, const Q_UINT8 *src, Q_INT32 srcRowStride, const Q_UINT8 *mask, Q_INT32 maskRowStride, Q_INT32 rows, Q_INT32 columns, Q_UINT8 opacity);
-    void compositeDarken(Q_UINT8 *dst, Q_INT32 dstRowStride, const Q_UINT8 *src, Q_INT32 srcRowStride, const Q_UINT8 *mask, Q_INT32 maskRowStride, Q_INT32 rows, Q_INT32 columns, Q_UINT8 opacity);
-    void compositeLighten(Q_UINT8 *dst, Q_INT32 dstRowStride, const Q_UINT8 *src, Q_INT32 srcRowStride, const Q_UINT8 *mask, Q_INT32 maskRowStride, Q_INT32 rows, Q_INT32 columns, Q_UINT8 opacity);
-    void compositeErase(Q_UINT8 *dst, Q_INT32 dstRowStride, const Q_UINT8 *src, Q_INT32 srcRowStride, const Q_UINT8 *mask, Q_INT32 maskRowStride, Q_INT32 rows, Q_INT32 columns, Q_UINT8 opacity);
-    void compositeAlphaDarken(Q_UINT8 *dst, Q_INT32 dstRowStride, const Q_UINT8 *src, Q_INT32 srcRowStride, const Q_UINT8 *mask, Q_INT32 maskRowStride, Q_INT32 rows, Q_INT32 columns, Q_UINT8 opacity);
+    void compositeOver(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 tqmaskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
+    void compositeMultiply(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 tqmaskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
+    void compositeDivide(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 tqmaskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
+    void compositeScreen(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 tqmaskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
+    void compositeOverlay(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 tqmaskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
+    void compositeDodge(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 tqmaskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
+    void compositeBurn(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 tqmaskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
+    void compositeDarken(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 tqmaskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
+    void compositeLighten(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 tqmaskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
+    void compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 tqmaskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
+    void compositeAlphaDarken(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 tqmaskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
 
 
 private:
     friend class KisGrayColorSpaceTester;
 
-    static const Q_UINT8 PIXEL_GRAY = 0;
-    static const Q_UINT8 PIXEL_GRAY_ALPHA = 1;
+    static const TQ_UINT8 PIXEL_GRAY = 0;
+    static const TQ_UINT8 PIXEL_GRAY_ALPHA = 1;
 };
 
 class KisGrayColorSpaceFactory : public KisColorSpaceFactory
@@ -102,13 +102,13 @@ public:
     /**
      * lcms colorspace type definition.
      */
-    virtual Q_UINT32 colorSpaceType() { return TYPE_GRAYA_8; };
+    virtual TQ_UINT32 colorSpaceType() { return TYPE_GRAYA_8; };
 
     virtual icColorSpaceSignature colorSpaceSignature() { return icSigGrayData; };
 
-    virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p) { return new KisGrayColorSpace(parent, p); };
+    virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p) { return new KisGrayColorSpace(tqparent, p); };
 
-    virtual QString defaultProfile() { return "gray built-in - (lcms internal)"; };
+    virtual TQString defaultProfile() { return "gray built-in - (lcms internal)"; };
 };
 
 #endif // KIS_STRATEGY_COLORSPACE_GRAYSCALE_H_
diff --git a/krita/colorspaces/gray_u8/tests/kis_strategy_colorspace_grayscale_tester.cpp b/krita/colorspaces/gray_u8/tests/kis_strategy_colorspace_grayscale_tester.cpp
index 3c91d6d1..0374c072 100644
--- a/krita/colorspaces/gray_u8/tests/kis_strategy_colorspace_grayscale_tester.cpp
+++ b/krita/colorspaces/gray_u8/tests/kis_strategy_colorspace_grayscale_tester.cpp
@@ -50,29 +50,29 @@ void KisGrayColorSpaceTester::testBasics()
     KisGrayColorSpace *cs = new KisGrayColorSpace(profile);
 
 
-    Q_UINT8 pixel[MAX_CHANNEL_GRAYSCALEA];
+    TQ_UINT8 pixel[MAX_CHANNEL_GRAYSCALEA];
 
     pixel[KisGrayColorSpace::PIXEL_GRAY] = 255;
     pixel[KisGrayColorSpace::PIXEL_GRAY_ALPHA] = 128;
 
-    QString valueText = cs->channelValueText(pixel, GRAY_CHANNEL);
-    CHECK(valueText, QString("255"));
+    TQString valueText = cs->channelValueText(pixel, GRAY_CHANNEL);
+    CHECK(valueText, TQString("255"));
 
     valueText = cs->channelValueText(pixel, ALPHA_CHANNEL);
-    CHECK(valueText, QString("128"));
+    CHECK(valueText, TQString("128"));
 
     valueText = cs->normalisedChannelValueText(pixel, GRAY_CHANNEL);
-    CHECK(valueText, QString().setNum(1.0));
+    CHECK(valueText, TQString().setNum(1.0));
 
     valueText = cs->normalisedChannelValueText(pixel, ALPHA_CHANNEL);
-    CHECK(valueText, QString().setNum(128.0 / 255.0));
+    CHECK(valueText, TQString().setNum(128.0 / 255.0));
 
     cs->setPixel(pixel, 128, 192l);
     CHECK((uint)pixel[KisGrayColorSpace::PIXEL_GRAY], 128u);
     CHECK((uint)pixel[KisGrayColorSpace::PIXEL_GRAY_ALPHA], 192u);
 
-    Q_UINT8 gray;
-    Q_UINT8 alpha;
+    TQ_UINT8 gray;
+    TQ_UINT8 alpha;
 
     cs->getPixel(pixel, &gray, &alpha);
     CHECK((uint)gray, 128u);
@@ -86,9 +86,9 @@ void KisGrayColorSpaceTester::testMixColors()
     KisProfile *profile = new KisProfile(cmsCreate_sRGBProfile());
     KisAbstractColorSpace * cs = new KisGrayColorSpace(profile);
 
-    Q_UINT8 pixel1[MAX_CHANNEL_GRAYSCALEA];
-    Q_UINT8 pixel2[MAX_CHANNEL_GRAYSCALEA];
-    Q_UINT8 outputPixel[MAX_CHANNEL_GRAYSCALEA];
+    TQ_UINT8 pixel1[MAX_CHANNEL_GRAYSCALEA];
+    TQ_UINT8 pixel2[MAX_CHANNEL_GRAYSCALEA];
+    TQ_UINT8 outputPixel[MAX_CHANNEL_GRAYSCALEA];
 
     pixel1[KisGrayColorSpace::PIXEL_GRAY] = 255;
     pixel1[KisGrayColorSpace::PIXEL_GRAY_ALPHA] = 255;
@@ -96,8 +96,8 @@ void KisGrayColorSpaceTester::testMixColors()
     pixel2[KisGrayColorSpace::PIXEL_GRAY] = 0;
     pixel2[KisGrayColorSpace::PIXEL_GRAY_ALPHA] = 0;
 
-    const Q_UINT8 *pixelPtrs[2];
-    Q_UINT8 weights[2];
+    const TQ_UINT8 *pixelPtrs[2];
+    TQ_UINT8 weights[2];
 
     pixelPtrs[0] = pixel1;
     pixelPtrs[1] = pixel2;