Update various qt function definitions and static methods for tqt3

23 files changed, 74 insertions, 74 deletions

diff --git a/chalk/core/kis_alpha_mask.cc b/chalk/core/kis_alpha_mask.cc
index 3f382c30..15296308 100644
--- a/chalk/core/kis_alpha_mask.cc
+++ b/chalk/core/kis_alpha_mask.cc
@@ -117,7 +117,7 @@ KisAlphaMaskSP KisAlphaMask::interpolate(KisAlphaMaskSP mask1, KisAlphaMaskSP ma
     int width = mask1->width();
     int height = mask1->height();
     KisAlphaMaskSP outputMask = new KisAlphaMask(width, height);
-    Q_CHECK_PTR(outputMask);
+    TQ_CHECK_PTR(outputMask);
 
     for (int x = 0; x < width; x++) {
         for (int y = 0; y < height; y++) {
diff --git a/chalk/core/kis_brush.cc b/chalk/core/kis_brush.cc
index 247bc7df..71676e3a 100644
--- a/chalk/core/kis_brush.cc
+++ b/chalk/core/kis_brush.cc
@@ -455,7 +455,7 @@ KisPaintDeviceSP KisBrush::image(KisColorSpace * /*colorSpace*/, const KisPaintI
 
     KisPaintDevice *layer = new KisPaintDevice(KisMetaRegistry::instance()->csRegistry()->getRGB8(), "brush");
 
-    Q_CHECK_PTR(layer);
+    TQ_CHECK_PTR(layer);
 
     for (int y = 0; y < outputHeight; y++) {
         KisHLineIterator iter = layer->createHLineIterator( 0, y, outputWidth, true);
@@ -563,7 +563,7 @@ void KisBrush::createScaledBrushes() const
         }
 
         KisAlphaMaskSP scaledMask = new KisAlphaMask(scaledImage, hasColor());
-        Q_CHECK_PTR(scaledMask);
+        TQ_CHECK_PTR(scaledMask);
 
         double xScale = static_cast<double>(width) / m_img.width();
         double yScale = static_cast<double>(height) / m_img.height();
@@ -627,7 +627,7 @@ KisAlphaMaskSP KisBrush::scaleMask(const ScaledBrush *srcBrush, double scale, do
     int dstHeight = static_cast<int>(ceil(scale * height())) + 1;
 
     KisAlphaMaskSP dstMask = new KisAlphaMask(dstWidth, dstHeight);
-    Q_CHECK_PTR(dstMask);
+    TQ_CHECK_PTR(dstMask);
 
     KisAlphaMaskSP srcMask = srcBrush->mask();
 
@@ -978,7 +978,7 @@ KisAlphaMaskSP KisBrush::scaleSinglePixelMask(double scale, TQ_UINT8 maskValue,
     int dstWidth = 2;
     int dstHeight = 2;
     KisAlphaMaskSP outputMask = new KisAlphaMask(dstWidth, dstHeight);
-    Q_CHECK_PTR(outputMask);
+    TQ_CHECK_PTR(outputMask);
 
     double a = subPixelX;
     double b = subPixelY;
diff --git a/chalk/core/kis_fill_painter.cc b/chalk/core/kis_fill_painter.cc
index 33b68a5b..5fa31953 100644
--- a/chalk/core/kis_fill_painter.cc
+++ b/chalk/core/kis_fill_painter.cc
@@ -147,7 +147,7 @@ void KisFillPainter::fillColor(int startX, int startY) {
 
     // Now create a layer and fill it
     KisPaintDeviceSP filled = new KisPaintDevice(m_device->colorSpace(), "filled");
-    Q_CHECK_PTR(filled);
+    TQ_CHECK_PTR(filled);
     KisFillPainter painter(filled.data());
     painter.fillRect(0, 0, m_width, m_height, m_paintColor);
     painter.end();
@@ -160,7 +160,7 @@ void KisFillPainter::fillPattern(int startX, int startY) {
 
     // Now create a layer and fill it
     KisPaintDeviceSP filled = new KisPaintDevice(m_device->colorSpace(), "filled");
-    Q_CHECK_PTR(filled);
+    TQ_CHECK_PTR(filled);
     KisFillPainter painter(filled.data());
     painter.fillRect(0, 0, m_width, m_height, m_pattern);
     painter.end();
diff --git a/chalk/core/kis_filter_strategy.cc b/chalk/core/kis_filter_strategy.cc
index f82e6cb5..573d3840 100644
--- a/chalk/core/kis_filter_strategy.cc
+++ b/chalk/core/kis_filter_strategy.cc
@@ -177,7 +177,7 @@ KisFilterStrategyRegistry* KisFilterStrategyRegistry::instance()
     if(KisFilterStrategyRegistry::m_singleton == 0)
     {
         KisFilterStrategyRegistry::m_singleton = new KisFilterStrategyRegistry();
-        Q_CHECK_PTR(KisFilterStrategyRegistry::m_singleton);
+        TQ_CHECK_PTR(KisFilterStrategyRegistry::m_singleton);
         m_singleton->add(new KisHermiteFilterStrategy);
         m_singleton->add(new KisBoxFilterStrategy);
         m_singleton->add(new KisTriangleFilterStrategy);
diff --git a/chalk/core/kis_gradient.cc b/chalk/core/kis_gradient.cc
index efc370bb..43c182d7 100644
--- a/chalk/core/kis_gradient.cc
+++ b/chalk/core/kis_gradient.cc
@@ -103,7 +103,7 @@ bool KisGradient::init()
                 Color rightColor(rightRgb.color(), colstopNext->opacity);
 
                 KisGradientSegment *segment = new KisGradientSegment(colstop->interpolation, colstop->colorType, colstop->offset, midp, colstopNext->offset, leftColor, rightColor);
-                Q_CHECK_PTR(segment);
+                TQ_CHECK_PTR(segment);
 
                 if ( !segment->isValid() ) {
                     delete segment;
@@ -418,7 +418,7 @@ KisGradientSegment::RGBColorInterpolationStrategy *KisGradientSegment::RGBColorI
 {
     if (m_instance == 0) {
         m_instance = new RGBColorInterpolationStrategy();
-        Q_CHECK_PTR(m_instance);
+        TQ_CHECK_PTR(m_instance);
     }
 
     return m_instance;
@@ -442,7 +442,7 @@ KisGradientSegment::HSVCWColorInterpolationStrategy *KisGradientSegment::HSVCWCo
 {
     if (m_instance == 0) {
         m_instance = new HSVCWColorInterpolationStrategy();
-        Q_CHECK_PTR(m_instance);
+        TQ_CHECK_PTR(m_instance);
     }
 
     return m_instance;
@@ -477,7 +477,7 @@ KisGradientSegment::HSVCCWColorInterpolationStrategy *KisGradientSegment::HSVCCW
 {
     if (m_instance == 0) {
         m_instance = new HSVCCWColorInterpolationStrategy();
-        Q_CHECK_PTR(m_instance);
+        TQ_CHECK_PTR(m_instance);
     }
 
     return m_instance;
@@ -512,7 +512,7 @@ KisGradientSegment::LinearInterpolationStrategy *KisGradientSegment::LinearInter
 {
     if (m_instance == 0) {
         m_instance = new LinearInterpolationStrategy();
-        Q_CHECK_PTR(m_instance);
+        TQ_CHECK_PTR(m_instance);
     }
 
     return m_instance;
@@ -559,7 +559,7 @@ KisGradientSegment::CurvedInterpolationStrategy *KisGradientSegment::CurvedInter
 {
     if (m_instance == 0) {
         m_instance = new CurvedInterpolationStrategy();
-        Q_CHECK_PTR(m_instance);
+        TQ_CHECK_PTR(m_instance);
     }
 
     return m_instance;
@@ -585,7 +585,7 @@ KisGradientSegment::SineInterpolationStrategy *KisGradientSegment::SineInterpola
 {
     if (m_instance == 0) {
         m_instance = new SineInterpolationStrategy();
-        Q_CHECK_PTR(m_instance);
+        TQ_CHECK_PTR(m_instance);
     }
 
     return m_instance;
@@ -603,7 +603,7 @@ KisGradientSegment::SphereIncreasingInterpolationStrategy *KisGradientSegment::S
 {
     if (m_instance == 0) {
         m_instance = new SphereIncreasingInterpolationStrategy();
-        Q_CHECK_PTR(m_instance);
+        TQ_CHECK_PTR(m_instance);
     }
 
     return m_instance;
@@ -621,7 +621,7 @@ KisGradientSegment::SphereDecreasingInterpolationStrategy *KisGradientSegment::S
 {
     if (m_instance == 0) {
         m_instance = new SphereDecreasingInterpolationStrategy();
-        Q_CHECK_PTR(m_instance);
+        TQ_CHECK_PTR(m_instance);
     }
 
     return m_instance;
diff --git a/chalk/core/kis_gradient_painter.cc b/chalk/core/kis_gradient_painter.cc
index 672747a5..968bb67e 100644
--- a/chalk/core/kis_gradient_painter.cc
+++ b/chalk/core/kis_gradient_painter.cc
@@ -366,7 +366,7 @@ namespace {
     {
         if (m_instance == 0) {
             m_instance = new GradientRepeatNoneStrategy();
-            Q_CHECK_PTR(m_instance);
+            TQ_CHECK_PTR(m_instance);
         }
 
         return m_instance;
@@ -407,7 +407,7 @@ namespace {
     {
         if (m_instance == 0) {
             m_instance = new GradientRepeatForwardsStrategy();
-            Q_CHECK_PTR(m_instance);
+            TQ_CHECK_PTR(m_instance);
         }
 
         return m_instance;
@@ -446,7 +446,7 @@ namespace {
     {
         if (m_instance == 0) {
             m_instance = new GradientRepeatAlternateStrategy();
-            Q_CHECK_PTR(m_instance);
+            TQ_CHECK_PTR(m_instance);
         }
 
         return m_instance;
@@ -518,7 +518,7 @@ bool KisGradientPainter::paintGradient(const KisPoint& gradientVectorStart,
         shapeStrategy = new ConicalSymetricGradientStrategy(gradientVectorStart, gradientVectorEnd);
         break;
     }
-    Q_CHECK_PTR(shapeStrategy);
+    TQ_CHECK_PTR(shapeStrategy);
 
     GradientRepeatStrategy *repeatStrategy = 0;
 
diff --git a/chalk/core/kis_image.cc b/chalk/core/kis_image.cc
index 1efeb715..a872b3ee 100644
--- a/chalk/core/kis_image.cc
+++ b/chalk/core/kis_image.cc
@@ -542,7 +542,7 @@ KisImage::KisImage(const KisImage& rhs) : TQObject(), KShared(rhs)
         m_adapter = rhs.m_adapter;
 
         m_bkg = new KisBackground();
-        Q_CHECK_PTR(m_bkg);
+        TQ_CHECK_PTR(m_bkg);
 
         m_rootLayer = static_cast<KisGroupLayer*>(rhs.m_rootLayer->clone().data());
         connect(m_rootLayer, TQT_SIGNAL(sigDirty(TQRect)), this, TQT_SIGNAL(sigImageUpdated(TQRect)));
@@ -550,7 +550,7 @@ KisImage::KisImage(const KisImage& rhs) : TQObject(), KShared(rhs)
         m_annotations = rhs.m_annotations; // XXX the annotations would probably need to be deep-copied
 
         m_nserver = new KisNameServer(i18n("Layer %1"), rhs.m_nserver->currentSeed() + 1);
-        Q_CHECK_PTR(m_nserver);
+        TQ_CHECK_PTR(m_nserver);
 
         //m_guides = rhs.m_guides;
 
@@ -575,7 +575,7 @@ DCOPObject * KisImage::dcopObject()
 {
     if (!m_dcop) {
         m_dcop = new KisImageIface(this);
-        Q_CHECK_PTR(m_dcop);
+        TQ_CHECK_PTR(m_dcop);
     }
     return m_dcop;
 }
@@ -1041,7 +1041,7 @@ KisLayerSP KisImage::newLayer(const TQString& name, TQ_UINT8 opacity, const KisC
         layer = new KisPaintLayer(this, name, opacity, colorstrategy);
     else
         layer = new KisPaintLayer(this, name, opacity);
-    Q_CHECK_PTR(layer);
+    TQ_CHECK_PTR(layer);
 
     if (compositeOp.isValid())
         layer->setCompositeOp(compositeOp);
@@ -1310,7 +1310,7 @@ void KisImage::flatten()
     disconnect(oldRootLayer, TQT_SIGNAL(sigDirty(TQRect)), this, TQT_SIGNAL(sigImageUpdated(TQRect)));
 
     KisPaintLayer *dst = new KisPaintLayer(this, nextLayerName(), OPACITY_OPAQUE, colorSpace());
-    Q_CHECK_PTR(dst);
+    TQ_CHECK_PTR(dst);
 
     TQRect rc = mergedImage()->extent();
 
@@ -1345,7 +1345,7 @@ void KisImage::flatten()
 void KisImage::mergeLayer(KisLayerSP layer)
 {
     KisPaintLayer *player = new KisPaintLayer(this, layer->name(), OPACITY_OPAQUE, colorSpace());
-    Q_CHECK_PTR(player);
+    TQ_CHECK_PTR(player);
 
     TQRect rc = layer->extent() | layer->nextSibling()->extent();
 
diff --git a/chalk/core/kis_imagepipe_brush.cc b/chalk/core/kis_imagepipe_brush.cc
index 726d0295..e7c61e65 100644
--- a/chalk/core/kis_imagepipe_brush.cc
+++ b/chalk/core/kis_imagepipe_brush.cc
@@ -237,7 +237,7 @@ bool KisImagePipeBrush::init()
         KisBrush * brush = new KisBrush(name() + "_" + numOfBrushes,
                         m_data,
                         i);
-        Q_CHECK_PTR(brush);
+        TQ_CHECK_PTR(brush);
 
         m_brushes.append(brush);
 
diff --git a/chalk/core/kis_iterators_pixel.cc b/chalk/core/kis_iterators_pixel.cc
index 3c5f1e44..741a20b0 100644
--- a/chalk/core/kis_iterators_pixel.cc
+++ b/chalk/core/kis_iterators_pixel.cc
@@ -29,7 +29,7 @@ KisHLineIteratorPixel::KisHLineIteratorPixel( KisPaintDevice *ndevice, KisDataMa
 {
     if(sel_dm) {
         KisHLineIterator * i = new KisHLineIterator(sel_dm, x - offsetx, y - offsety, w, false);
-        Q_CHECK_PTR(i);
+        TQ_CHECK_PTR(i);
         KisIteratorPixelTrait <KisHLineIterator>::setSelectionIterator(i);
     }
 }
@@ -41,7 +41,7 @@ KisVLineIteratorPixel::KisVLineIteratorPixel( KisPaintDevice *ndevice, KisDataMa
 {
     if(sel_dm) {
         KisVLineIterator * i = new KisVLineIterator(sel_dm, x - offsetx, y - offsety, h, false);
-        Q_CHECK_PTR(i);
+        TQ_CHECK_PTR(i);
         KisIteratorPixelTrait <KisVLineIterator>::setSelectionIterator(i);
     }
 }
@@ -53,7 +53,7 @@ KisRectIteratorPixel::KisRectIteratorPixel( KisPaintDevice *ndevice, KisDataMana
 {
     if(sel_dm) {
         KisRectIterator * i = new KisRectIterator(sel_dm, x - offsetx, y - offsety, w, h, false);
-        Q_CHECK_PTR(i);
+        TQ_CHECK_PTR(i);
         KisIteratorPixelTrait <KisRectIterator>::setSelectionIterator(i);
     }
 }
diff --git a/chalk/core/kis_paint_device.cc b/chalk/core/kis_paint_device.cc
index 195364c6..c9734819 100644
--- a/chalk/core/kis_paint_device.cc
+++ b/chalk/core/kis_paint_device.cc
@@ -223,7 +223,7 @@ KisPaintDevice::KisPaintDevice(KisColorSpace * colorSpace, const char * name) :
     m_datamanager = new KisDataManager(m_pixelSize, defPixel);
     delete [] defPixel;
 
-    Q_CHECK_PTR(m_datamanager);
+    TQ_CHECK_PTR(m_datamanager);
     m_extentIsValid = true;
 
     m_parentLayer = 0;
@@ -269,7 +269,7 @@ KisPaintDevice::KisPaintDevice(KisLayer *parent, KisColorSpace * colorSpace, con
 
     m_datamanager = new KisDataManager(m_pixelSize, defPixel);
     delete [] defPixel;
-    Q_CHECK_PTR(m_datamanager);
+    TQ_CHECK_PTR(m_datamanager);
     m_extentIsValid = true;
 
     if ( TQString ( name ) == TQString( "Layer 1" ) ) {
@@ -292,7 +292,7 @@ KisPaintDevice::KisPaintDevice(const KisPaintDevice& rhs) : TQObject(), KShared(
         m_dcop = rhs.m_dcop;
         if (rhs.m_datamanager) {
             m_datamanager = new KisDataManager(*rhs.m_datamanager);
-            Q_CHECK_PTR(m_datamanager);
+            TQ_CHECK_PTR(m_datamanager);
         }
         else {
             kdWarning() << "rhs " << rhs.name() << " has no datamanager\n";
@@ -338,7 +338,7 @@ DCOPObject *KisPaintDevice::dcopObject()
 {
     if (!m_dcop) {
         m_dcop = new KisPaintDeviceIface(this);
-        Q_CHECK_PTR(m_dcop);
+        TQ_CHECK_PTR(m_dcop);
     }
     return m_dcop;
 }
@@ -401,7 +401,7 @@ void KisPaintDevice::move(const TQPoint& pt)
 KNamedCommand * KisPaintDevice::moveCommand(TQ_INT32 x, TQ_INT32 y)
 {
     KNamedCommand * cmd = new MoveCommand(this, TQPoint(m_x, m_y), TQPoint(x, y));
-    Q_CHECK_PTR(cmd);
+    TQ_CHECK_PTR(cmd);
     cmd->execute();
     return cmd;
 }
@@ -859,7 +859,7 @@ TQImage KisPaintDevice::convertToTQImage(KisProfile *  dstProfile, TQ_INT32 x1,
         return TQImage();
 
     TQ_UINT8 * data = new TQ_UINT8 [w * h * m_pixelSize];
-    Q_CHECK_PTR(data);
+    TQ_CHECK_PTR(data);
 
     // XXX: Is this really faster than converting line by line and building the TQImage directly?
     //      This copies potentially a lot of data.
@@ -1024,7 +1024,7 @@ KisSelectionSP KisPaintDevice::selection()
     }
     else if (!m_selection) {
         m_selection = new KisSelection(this);
-        Q_CHECK_PTR(m_selection);
+        TQ_CHECK_PTR(m_selection);
         m_selection->setX(m_x);
         m_selection->setY(m_y);
     }
diff --git a/chalk/core/kis_painter.cc b/chalk/core/kis_painter.cc
index c64935fc..fc3e1d88 100644
--- a/chalk/core/kis_painter.cc
+++ b/chalk/core/kis_painter.cc
@@ -126,7 +126,7 @@ void KisPainter::beginTransaction(const TQString& customName)
     if (m_transaction)
         delete m_transaction;
     m_transaction = new KisTransaction(customName, m_device);
-    Q_CHECK_PTR(m_transaction);
+    TQ_CHECK_PTR(m_transaction);
 }
 
 void KisPainter::beginTransaction( KisTransaction* command)
@@ -782,9 +782,9 @@ void KisPainter::fillPolygon(const vKisPoint& points, FillStyle fillStyle)
     }
 
     ind = new int[n];
-    Q_CHECK_PTR(ind);
+    TQ_CHECK_PTR(ind);
     active = new Edge[n];
-    Q_CHECK_PTR(active);
+    TQ_CHECK_PTR(active);
 
     /* create y-sorted array of indices ind[k] into vertex list */
     for (k=0; k<n; k++)
@@ -815,7 +815,7 @@ void KisPainter::fillPolygon(const vKisPoint& points, FillStyle fillStyle)
     // create a mask for the actual polygon coverage.
 
     KisPaintDeviceSP polygon = new KisPaintDevice(m_device->colorSpace(), "polygon");
-    Q_CHECK_PTR(polygon);
+    TQ_CHECK_PTR(polygon);
 
     KisFillPainter fillPainter(polygon);
     TQRect boundingRectangle(x0, y0, x1 - x0 + 1, y1 - y0 + 1);
diff --git a/chalk/core/kis_paintop.cc b/chalk/core/kis_paintop.cc
index edb9faf6..59cfef6b 100644
--- a/chalk/core/kis_paintop.cc
+++ b/chalk/core/kis_paintop.cc
@@ -57,7 +57,7 @@ KisPaintDeviceSP KisPaintOp::computeDab(KisAlphaMaskSP mask, KisColorSpace *cs)
 
     if(!m_dab || m_dab->colorSpace() != cs)
         m_dab = new KisPaintDevice(cs, "dab");
-    Q_CHECK_PTR(m_dab);
+    TQ_CHECK_PTR(m_dab);
 
     KisColor kc = m_painter->paintColor();
 
diff --git a/chalk/core/kis_paintop_registry.cc b/chalk/core/kis_paintop_registry.cc
index 7d5de556..0ae94f71 100644
--- a/chalk/core/kis_paintop_registry.cc
+++ b/chalk/core/kis_paintop_registry.cc
@@ -78,7 +78,7 @@ KisPaintOpRegistry* KisPaintOpRegistry::instance()
     if(KisPaintOpRegistry::m_singleton == 0)
     {
         KisPaintOpRegistry::m_singleton = new KisPaintOpRegistry();
-        Q_CHECK_PTR(KisPaintOpRegistry::m_singleton);
+        TQ_CHECK_PTR(KisPaintOpRegistry::m_singleton);
     }
     return KisPaintOpRegistry::m_singleton;
 }
diff --git a/chalk/core/kis_pattern.cc b/chalk/core/kis_pattern.cc
index 72130db6..f757b060 100644
--- a/chalk/core/kis_pattern.cc
+++ b/chalk/core/kis_pattern.cc
@@ -284,7 +284,7 @@ KisPaintDeviceSP KisPattern::image(KisColorSpace * colorSpace) {
     // If not, create one
     KisPaintDeviceSP layer = new KisPaintDevice(colorSpace, "pattern");
 
-    Q_CHECK_PTR(layer);
+    TQ_CHECK_PTR(layer);
 
     layer->convertFromTQImage(m_img,"");
 
diff --git a/chalk/core/kis_scale_visitor.cc b/chalk/core/kis_scale_visitor.cc
index 25ad47c4..fb4c9f42 100644
--- a/chalk/core/kis_scale_visitor.cc
+++ b/chalk/core/kis_scale_visitor.cc
@@ -42,15 +42,15 @@ void KisScaleWorker::run()
     TQ_INT32 targetH = TQABS( tqRound( m_sy * height ) );
 
     TQ_UINT8* newData = new TQ_UINT8[targetW * targetH * m_pixelSize ];
-    Q_CHECK_PTR(newData);
+    TQ_CHECK_PTR(newData);
 
     double* weight = new double[ m_pixelSize ];    /* filter calculation variables */
 
     TQ_UINT8* pel = new TQ_UINT8[ m_pixelSize ];
-    Q_CHECK_PTR(pel);
+    TQ_CHECK_PTR(pel);
 
     TQ_UINT8 *pel2 = new TQ_UINT8[ m_pixelSize ];
-    Q_CHECK_PTR(pel2);
+    TQ_CHECK_PTR(pel2);
 
     bool* bPelDelta = new bool[ m_pixelSize ];
     ContribList    *contribX;
@@ -61,7 +61,7 @@ void KisScaleWorker::run()
 
     // create intermediate row to hold vertical dst row zoom
     TQ_UINT8 * tmp = new TQ_UINT8[ width * m_pixelSize ];
-    Q_CHECK_PTR(tmp);
+    TQ_CHECK_PTR(tmp);
 
     //create array of pointers to intermediate rows
     TQ_UINT8 **tmpRows = new TQ_UINT8*[ height ];
@@ -74,7 +74,7 @@ void KisScaleWorker::run()
         for(int i = 0; i < (int)(fwidth / m_sy * 2 + 1); i++)
         {
              tmpRowsMem[i] = new TQ_UINT8[ width * m_pixelSize ];
-             Q_CHECK_PTR(tmpRowsMem[i]);
+             TQ_CHECK_PTR(tmpRowsMem[i]);
         }
     }
     else
@@ -83,7 +83,7 @@ void KisScaleWorker::run()
         for(int i = 0; i < (int)(fwidth * 2 + 1); i++)
         {
             tmpRowsMem[i] = new TQ_UINT8[ width * m_pixelSize ];
-            Q_CHECK_PTR(tmpRowsMem[i]);
+            TQ_CHECK_PTR(tmpRowsMem[i]);
         }
     }
 
diff --git a/chalk/core/kis_strategy_move.cc b/chalk/core/kis_strategy_move.cc
index 7391777c..59679056 100644
--- a/chalk/core/kis_strategy_move.cc
+++ b/chalk/core/kis_strategy_move.cc
@@ -120,7 +120,7 @@ void KisStrategyMove::endDrag(const TQPoint& pos, bool undo)
 
             if (undo && img->undo()) {
                 KCommand *cmd = dev->moveCommand(m_layerStart, m_layerPosition);
-                Q_CHECK_PTR(cmd);
+                TQ_CHECK_PTR(cmd);
                 
                 KisUndoAdapter *adapter = img->undoAdapter();
                 if (adapter) {
diff --git a/chalk/core/kis_transform_visitor.h b/chalk/core/kis_transform_visitor.h
index 9e6f51c0..5df21316 100644
--- a/chalk/core/kis_transform_visitor.h
+++ b/chalk/core/kis_transform_visitor.h
@@ -69,7 +69,7 @@ public:
         KisTransaction * t = 0;
         if (m_img->undo()) {
             t = new KisTransaction(i18n("Rotate Layer"), dev);
-            Q_CHECK_PTR(t);
+            TQ_CHECK_PTR(t);
 	}
 
         KisTransformWorker tw(dev, m_sx, m_sy, 0.0, 0.0, m_angle, m_tx, m_ty, m_progress, m_filter, true);
@@ -108,7 +108,7 @@ public:
 
         if (m_img->undo()) {
             t = new KisTransaction(i18n("Rotate Layer"), dev);
-            Q_CHECK_PTR(t);
+            TQ_CHECK_PTR(t);
         }
 
         KisTransformWorker tw(dev, m_sx, m_sy, 0.0, 0.0, m_angle, m_tx, m_ty, m_progress, m_filter, true);
diff --git a/chalk/core/kis_transform_worker.cc b/chalk/core/kis_transform_worker.cc
index ae4f4e24..77ea25f5 100644
--- a/chalk/core/kis_transform_worker.cc
+++ b/chalk/core/kis_transform_worker.cc
@@ -354,10 +354,10 @@ template <class T> void KisTransformWorker::transformPass(KisPaintDevice *src, K
     TQ_INT32 extraLen = (support+256)>>8 + 1;
 
     TQ_UINT8 *tmpLine = new TQ_UINT8[(srcLen +2*extraLen)* pixelSize];
-    Q_CHECK_PTR(tmpLine);
+    TQ_CHECK_PTR(tmpLine);
 
     TQ_UINT8 *tmpSel = new TQ_UINT8[srcLen+2*extraLen];
-    Q_CHECK_PTR(tmpSel);
+    TQ_CHECK_PTR(tmpSel);
 
     //allocate space for colors
     const TQ_UINT8 **colors = new const TQ_UINT8 *[2*support+1];
diff --git a/chalk/core/tiles/kis_memento.cc b/chalk/core/tiles/kis_memento.cc
index aaec3724..c67a0476 100644
--- a/chalk/core/tiles/kis_memento.cc
+++ b/chalk/core/tiles/kis_memento.cc
@@ -23,10 +23,10 @@
 KisMemento::KisMemento(TQ_UINT32 pixelSize) : KShared()
 {
     m_hashTable = new KisTile * [1024];
-    Q_CHECK_PTR(m_hashTable);
+    TQ_CHECK_PTR(m_hashTable);
 
     m_redoHashTable = new KisTile * [1024];
-    Q_CHECK_PTR(m_redoHashTable);
+    TQ_CHECK_PTR(m_redoHashTable);
 
     for(int i = 0; i < 1024; i++)
     {
diff --git a/chalk/core/tiles/kis_memento.h b/chalk/core/tiles/kis_memento.h
index 5942dc44..3213a490 100644
--- a/chalk/core/tiles/kis_memento.h
+++ b/chalk/core/tiles/kis_memento.h
@@ -84,7 +84,7 @@ private:
         void addTile(TQ_INT32 col, TQ_INT32 row)
         {
             DeletedTile *d = new DeletedTile(col, row, m_firstDeletedTile);
-            Q_CHECK_PTR(d);
+            TQ_CHECK_PTR(d);
 
             m_firstDeletedTile = d;
         }
diff --git a/chalk/core/tiles/kis_tile.cc b/chalk/core/tiles/kis_tile.cc
index 86d55128..743ca82b 100644
--- a/chalk/core/tiles/kis_tile.cc
+++ b/chalk/core/tiles/kis_tile.cc
@@ -102,7 +102,7 @@ void KisTile::allocate()
     if (m_data == 0) {
         assert (!readers());
         m_data = KisTileManager::instance()->requestTileData(m_pixelSize);
-        Q_CHECK_PTR(m_data);
+        TQ_CHECK_PTR(m_data);
     }
 }
 
diff --git a/chalk/core/tiles/kis_tileddatamanager.cc b/chalk/core/tiles/kis_tileddatamanager.cc
index d4b957d9..6d99dc93 100644
--- a/chalk/core/tiles/kis_tileddatamanager.cc
+++ b/chalk/core/tiles/kis_tileddatamanager.cc
@@ -41,14 +41,14 @@ KisTiledDataManager::KisTiledDataManager(TQ_UINT32 pixelSize, const TQ_UINT8 *de
     m_pixelSize = pixelSize;
 
     m_defPixel = new TQ_UINT8[m_pixelSize];
-    Q_CHECK_PTR(m_defPixel);
+    TQ_CHECK_PTR(m_defPixel);
     memcpy(m_defPixel, defPixel, m_pixelSize);
 
     m_defaultTile = new KisTile(pixelSize,0,0, m_defPixel);
-    Q_CHECK_PTR(m_defaultTile);
+    TQ_CHECK_PTR(m_defaultTile);
 
     m_hashTable = new KisTile * [1024];
-    Q_CHECK_PTR(m_hashTable);
+    TQ_CHECK_PTR(m_hashTable);
 
     for(int i = 0; i < 1024; i++)
         m_hashTable [i] = 0;
@@ -66,14 +66,14 @@ KisTiledDataManager::KisTiledDataManager(const KisTiledDataManager & dm)
     m_pixelSize = dm.m_pixelSize;
 
     m_defPixel = new TQ_UINT8[m_pixelSize];
-    Q_CHECK_PTR(m_defPixel);
+    TQ_CHECK_PTR(m_defPixel);
     memcpy(m_defPixel, dm.m_defPixel, m_pixelSize);
 
     m_defaultTile = new KisTile(*dm.m_defaultTile, dm.m_defaultTile->getCol(), dm.m_defaultTile->getRow());
-    Q_CHECK_PTR(m_defaultTile);
+    TQ_CHECK_PTR(m_defaultTile);
 
     m_hashTable = new KisTile * [1024];
-    Q_CHECK_PTR(m_hashTable);
+    TQ_CHECK_PTR(m_hashTable);
 
     m_numTiles = 0;
     m_currentMemento = 0;
@@ -92,7 +92,7 @@ KisTiledDataManager::KisTiledDataManager(const KisTiledDataManager & dm)
         while(tile)
         {
             KisTile *newtile = new KisTile(*tile, tile->getCol(), tile->getRow());
-            Q_CHECK_PTR(newtile);
+            TQ_CHECK_PTR(newtile);
 
             newtile->setNext(m_hashTable[i]);
             m_hashTable[i] = newtile;
@@ -193,7 +193,7 @@ bool KisTiledDataManager::read(KoStore *store)
         TQ_UINT32 tileHash = calcTileHash(col, row);
 
         KisTile *tile = new KisTile(m_pixelSize, col, row, m_defPixel);
-        Q_CHECK_PTR(tile);
+        TQ_CHECK_PTR(tile);
 
         updateExtent(col,row);
 
@@ -528,7 +528,7 @@ TQ_UINT32 KisTiledDataManager::calcTileHash(TQ_INT32 col, TQ_INT32 row)
 KisMementoSP KisTiledDataManager::getMemento()
 {
     m_currentMemento = new KisMemento(m_pixelSize);
-    Q_CHECK_PTR(m_currentMemento);
+    TQ_CHECK_PTR(m_currentMemento);
 
     memcpy(m_currentMemento->m_defPixel, m_defPixel, m_pixelSize);
 
@@ -606,7 +606,7 @@ void KisTiledDataManager::rollback(KisMementoSP memento)
 
             // Put a copy of the memento tile into our hashtable
             curTile = new KisTile(*tile);
-            Q_CHECK_PTR(curTile);
+            TQ_CHECK_PTR(curTile);
             m_numTiles++;
 
             curTile->setNext(m_hashTable[i]);
@@ -671,7 +671,7 @@ void KisTiledDataManager::rollforward(KisMementoSP memento)
 
             // Put a copy of the memento tile into our hashtable
             curTile = new KisTile(*tile);
-            Q_CHECK_PTR(curTile);
+            TQ_CHECK_PTR(curTile);
 
             curTile->setNext(m_hashTable[i]);
             m_hashTable[i] = curTile;
@@ -744,7 +744,7 @@ void KisTiledDataManager::ensureTileMementoed(TQ_INT32 col, TQ_INT32 row, TQ_UIN
         return; // it has allready been stored
 
     tile = new KisTile(*refTile);
-    Q_CHECK_PTR(tile);
+    TQ_CHECK_PTR(tile);
 
     tile->setNext(m_currentMemento->m_hashTable[tileHash]);
     m_currentMemento->m_hashTable[tileHash] = tile;
@@ -784,7 +784,7 @@ KisTile *KisTiledDataManager::getTile(TQ_INT32 col, TQ_INT32 row, bool writeAcce
         {
             // Create a new tile
             tile = new KisTile(*m_defaultTile, col, row);
-            Q_CHECK_PTR(tile);
+            TQ_CHECK_PTR(tile);
 
             tile->setNext(m_hashTable[tileHash]);
             m_hashTable[tileHash] = tile;
diff --git a/chalk/core/tiles/kis_tilemanager.cc b/chalk/core/tiles/kis_tilemanager.cc
index 2c3fed8e..2fca4ec9 100644
--- a/chalk/core/tiles/kis_tilemanager.cc
+++ b/chalk/core/tiles/kis_tilemanager.cc
@@ -116,7 +116,7 @@ KisTileManager* KisTileManager::instance()
 {
     if(KisTileManager::m_singleton == 0) {
         staticDeleter.setObject(KisTileManager::m_singleton, new KisTileManager());
-        Q_CHECK_PTR(KisTileManager::m_singleton);
+        TQ_CHECK_PTR(KisTileManager::m_singleton);
     }
     return KisTileManager::m_singleton;
 }